Spring Boot follows the concept of conventions over configurations and is intended to simplify the rapid start in application development. The starter package already includes an AppServer and the most important configurations, so that development can be started without complex setup. Java Configuration Services are used throughout, which enable Spring Boot to manage dependencies on other tools and frameworks.
In principle, Spring Boot can use all the features of the other Spring projects and include them. The approach is currently addressing projects that rely on microservice architectures, as Spring Boot can bundle everything from the first class for database access to the web container.
- Very easy setup: The initial project can be created and downloaded on the website using wizards.
- Simple deployment: Spring Boot takes over the dependencies, a simple call and the container including the application are provided.
- Easy debugging: Since it is a simple Java application, it can also be used as such for debugging.
- The Focus: Like most frameworks, Spring Boot only covers a specific area of application development. The project will not succeed without further frameworks.
- Coding: Even if the annotations relieve a lot of work, at the end of the day there is still a large amount of lines of code that have to be written.
- Enterprise applications: The focus is on stand-alone applications in a microservice ecosystem. If an enterprise application is required, this approach is not helpful.
Java ServerFaces describes a web framework for creating applications based on Java as well as servlets and JSP (Java ServerPages) technologies and belongs to the Java EE technology stack. The approach of the model-view-controller concept is strictly followed, modularization and reuse allow an efficient design of the user interfaces. JSF is implemented by a number of web frameworks. These include ICEFaces from IceSoft, RichFaces from JBoss and - certainly the most prominent representative - PrimeFaces from PrimeTek.
Only last year PrimeFaces was honored in the Dukes Choice Award of the Java Community in the field of Enterprise Java.
PrimeFaces is a lightweight library that tries to make the complexity of the UI design appear as simple as possible. Especially with Spring applications in the backend, attractive enterprise applications can be created.
- Easy to use: The concept of using a JAR without any further dependencies makes it easier to integrate it into your own development infrastructure.
- Community support: Literature, blogs and support in various forums are widespread and offer extensive and valuable content.
- Standard: It follows the JSF and JEE standard and thus allows integration into and from other frameworks that follow this pattern. PrimeFaces can be accepted as a quasi-standard for the JSF area.
- Scope: PrimeFaces focuses exclusively on the design of the UI. Other frameworks are therefore absolutely necessary for the data connection and the controller.
- Data binding: The integration of data binding is time-consuming and quickly becomes extensive.
- Technically demanding: There are many options available for the UI, which can quickly lead to a complex implementation and requires a high level of technical know-how.
Vaadin is a web framework that allows the developer to write the complete application exclusively in Java on the server side. The framework uses Google's Java-to-Java Script Compiler "Goolge Web Toolkit" (GWT) to display the UI in the browser. In this combination, Vaadin achieves the feeling of a real rich client interface for the user with standard functions for e.g. B. Column sorting and the waiver of complete page refreshing.
Support for the development environment can be found especially in the Eclipse area, with Netbeans and IntelliJ also being supported. In addition, Vaadin also offers a visual designer, which allows a WYSIWYG development of the web front end.
- Helpful plugins from the manufacturer: These include a spreadsheet component, native smartphone and tablet support, UI testing tools, etc. v. m.
- Easy integration of Spring: Full integration via API, ideal access to Spring data provision.
- Use: Efficient implementation that focuses on server-side Java programming.
- Costs: If Vaadin is to be used in full, with all plug-ins and maintenance, the service starts at € 800 per month.
- Generated code: Relatively large, as the Java Script components generated on the client side quickly become quite extensive.
- No client-side processing possible: Each request goes to the server first and that can be time-consuming.
Hibernate ORM is a stable object-relative mapping framework. It allows for better communication between the Java programming language and the Relational Database Management (RDBMS) systems.
If you are working with an object-oriented language such as Java, you will encounter a problem called Object-Relational Impedance Mismatch, also called Paradigm Mismatch. This is because the data are handled differently by OO languages and RDBMSs which can lead to severe mismatch issues. So this Hibernate gives you a framework that overcomes Java's mismatch problems.
- You can develop persistent classes according to the object-oriented idiom
- It lets you communicate with any database using very small code changes, bridging the gap between objects and relational words
- It is an advanced ORM framework allowing you to operate the database on Java entities
- Portability, productivity, retention
- The framework is free and open source
- It removes many repeatable code from the JDBC API
- Single Purpose: only for Object Relation Mapping.
- Performance Cost: Hibernate generates lot of SQL statements in runtime based on our mapping
- Learning curve: as many other tool, Hibernate also takes considerable amount of time and effort to learn.
Play is a reactive web and mobile platform for highly scalable Java applications. It enables the development of Java and Scala applications for desktop and mobile interfaces which are lightweight and web-friendly. It is also compared to strong frameworks of other languages, such as Ruby on Rails, or Django for Python.
Play is a special Java system, since it is not based on the Java EE specifications. Instead, it plans to decrease all of the inconveniences of conventional Java web development such as long development times, a lot of configuration and much more. Based on the Akka Toolkit, the Play System truncates the development of Java Virtual Machine simultaneous and distributed applications.
- Offers features such as hot code reloading, configuration conventions and browser error messages
- It supports unblocked I / O which is important for high-performance applications
- More versatile and reactive to failures
- Immature. As with any significant piece of code that hasn't had years of battle-hardening, not all bugs were filtered out, the API is evolving, and best practices aren't well defined.
- Async + Java. Play is designed around I / O async, which means write code that will "load later." Unlike Scala, Java lacks main language features to keep the async code clean, such as closures. There are patterns and resources which make it tolerable, but you end up with lots of anonymous classes inside. You can't even use Java at all for streaming applications (figures, enumeratees). Also worth noting is that lots of existing Java libraries are synchronous / blocking, so be careful about which ones you use in an environment like Netty that is async / non-blocking. If required, however, you can always customize Play's thread pool to use lots of threads and act like any other blocking server would.
- no servlet. Breaking away from the servlet spec has benefits, but a lot of existing code in the Java world is based around HápServletRequest, HttServletResponse, and so on. Play does not use all of these, so you need to find additional libraries or build wrappers.
If you've already worked with JSP, it'll be a cakewalk to learn the wicket. A basic Java web frameworks, Wicket has a component-oriented layout and only Java and HTML are all you need to know. No XMLs or any configuration files at all!
Wicket's key feature is its POJO model, in which components are simple (Plain Old) Java Objects with OOP features. As reusable packages, these components are packaged together with images, buttons, forms, links, pages, containers, behaviors and more so that developers can customize them.
Wicket is lightweight, and you can very easily create applications. Uniting test code written in Wicket is fast, too.
- Real Isolation of Layout and Code .
- Component-based, which means high reusability of site elements; for example, you can build prettified form with automatic labeling and CSS styles and everything and it is totally reusable in another project simply by modifying it's DAO object in the component's constructor.
- Excellent support for items like Ajax, Portlets and different frameworks generally directly out of the box AND more importantly it doesn't rely on anything other than slf4j / log4j to function, it's all optional!
- Development has some uncertainty overall, and Wicket generics are a bit of a mess right now, even though they were cleaned up a lot in 1.4
- Some components (such as
Form.onSubmit()) easily require comprehensive subclassification or anonymous overriding method for injecting behaviour. This is due in part to the efficient event-based nature of Wicket but sadly it also means that making a code mess with Wicket is easy too.
Grails is a dynamic, programming language introduced by the Groovy JVM. It is an object-oriented language for the Java platform which aims to improve the productivity of developers. The syntax is compatible with Java, and is compiled to bytecode for JVM (Java Virtual Machine). Grails deals with Java technologies, including Java EE, Spring, SiteMesh, Quartz and Hibernate containers.
- It is very developer-friendly as it comes with comprehensive documentation that is easy to read
- You can also create your own plugins and provide the support for the Grails IDE for various platforms.
- Most e-commerce sites use Grails
- It provides a rapid development cycle.
- If you are dealing with a small or medium-size project, Grails is ideal for you.
- The framework offers a range of plug-ins to make your ob simple.
- The documentation is really impressive.
- The setup process is very simple. Therefore, you should be able to start building an app in an hour.
- Simple GORM. It may take some time to learn but once you are familiar with it, it’s absolutely wonderful.
- You can see the changes by hitting the refresh button.
- Less CSS framework plug-ins. Hence, it’s easier to manage the CSS.
- Dynamic configuration feature. Therefore, you can change the configuration without server restart.
- You have to deal with runtime language. Its negative quality is that it is error prone and you have to bear with other cons of runtime language.
- If you are working on a multi threaded app, GORM can be problematic for you.
- You have to buy IntelliJ Idea because other IDE’s either don’t have or provide limited support.
- Developers generally declare variables with “def” which is equivalent to “object”. It’s very hard to maintain.
- Interpreted languages increase weight and that directly affects the run time.
- You must learn Groovy coding.
- It works with GORM but not with any other ORMs.
- Integration process is complicated.
- Exercise 1:
- Install Spring Tools 4
- Create a Spring Boot Application Using Wizard