Frameworks in JAVA

It is no surprise that Java is one in all the foremost fashionable programming

languages. In close to future, there's a bit likelihood for the other language to
exchange Java, not a minimum of in 2019.The same goes for the Java
Frameworks. Spring, Spring Boot and JSF square measure the highest 3
frameworks that square measure principally employed by Java Developers.
But this doesn't mean that different frameworks don't seem to be fashionable.

Spring Framework

Spring is one of the most popular frameworks for J2EE (Java enterprise edition).
Developers use Spring for developing reliable and high-quality applications.
Spring framework was designed by Rod Johnson. Since then Spring has become
another technology in java world for EJB model. You can create different types
of applications using spring framework.

It is difficult to understand what is Spring Framework without understanding

what is Dependency Injection and Inversion of Control. Dependency Injection
also called as DI, is one of the types of Inversion of Control (IoC).
Inversion of Control – this is the principle of object-oriented programming, in
which objects of the program do not depend on concrete implementations of
other objects( loose coupling ), but may have knowledge about their
abstractions ( interfaces ) for later interaction.

Dependency Injection – Is an arrangement of structural design patterns, in

which for each function of the application there is one, a conditionally
independent object ( service ) that can have the need to use other objects (
dependencies ) known to it by interfaces. Dependencies are transferred (
implemented ) to the service at the time of its creation. This is a situation where
we introduce an element of one class into another. In practice, DI is implemented
by passing parameters to the constructor or using setters. Libraries that
implement this approach are also called as IoC containers.
Aspect-oriented programming – A programming paradigm that allows you to
differentiate cross-through (functional) functionality in the application. These
functions, which span multiple application nodes, are called cross-cutting
concerns and these cross-cutting notes are separated from the immediate
business logic of the application.
In OOP, the key unit is the class, whereas in AOP, the key element is the aspect. DI
helps to separate application classes into separate modules, and AOP helps to
separate cross-cutting concerns from the objects they affect.

Spring Framework Architecture

Spring Framework is split into a number of separate modules, which allows you
to decide which ones to use in your application. Following image illustrates the
most important modules of Spring Framework architecture.
 Fig: Spring Framework Core Components

The Core container from Spring composed of four modules: SpEL, Context, Core,
Beans. Description for these elements are as follows:

➢ The SpEL module provides a powerful expression language for

manipulating objects during execution.
 ➢ Context is built on the basis of Beans and Core and allows you to access
any object that is defined in the settings. The key element of the Context
module is the
➢ ApplicationContext interface.
➢ The Core module provides key parts of the framework including IoC and
DI properties.
➢ Creating and managing Spring BeansThe Bean module's responsibility.

Spring Framework Web

Spring framework Web layer consists of Web, Web-MVC, Web-Socket, Web-
Portlet etc.

➢ The Web module supplies functions such as downloading files, creating a

web application, rest web service etc.
➢ Web-MVC carry a Spring MVC implementation for web applications.
➢ Web-Socket provides support for communication between the client and
the server, using Web-Sockets in web applications.
➢ Web-Portlet provides MVC implementation with portlet environment

Spring Framework Data Access

The Data Access/Integration container composed of JDBC, ORM, OXM, JMS and
the Transactions module.

➢ JDBC supplies an abstract layer of JDBC and eliminates the need for the
developer to manually register the monotonous code associated with
connecting to the database.
➢ Spring ORM provides integration with such popular ORMs as Hibernate,
JDO, JPA, etc.
➢ The OXM module is responsible for linking the Object / XML – XMLBeans,
JAXB, etc.
➢ The JMS (Java Messaging Service) module is responsible for creating,
sending and receiving messages.
➢ Transactions support, transaction management for classes that
implement certain methods and POJOs.
Spring Framework Miscellaneous Modules
Spring also includes a number of other important modules, such as AOP, Aspects,
Instrumentation, Messaging, and Test.

➢ AOP implements aspect-oriented programming and allows using the

entire arsenal of AOP capabilities.
➢ The Aspects module provides integration with AspectJ, which is also a
powerful AOP framework.
➢ Instrumentation is responsible for reinforcing class instrumentation and
class loader, which are used in server applications.
➢ The Messaging module provides STOMP support.
➢ Finally, the Test module provides testing using TestNG or the JUnit
Framework.

Spring 5 Features
Spring 5 brought a massive update to Spring 4. Few of the important features of
Spring 5 are:

➢ Support for Java 8, Java 9, Java EE 7, Java EE 8, Servlet 4.0, Bean

Validation 2.0, and JPA 2.2. I am happy to see that Spring is trying to catch
up with the latest versions of major technologies being used.
➢ Improved Logging with the new module – spring-JCL.
➢ File operations are using NIO 2 streams, hence improved performance.
➢ Support for Mono as well as RxJava 1.3 and 2.1 as return values from
Spring MVC controller methods.
➢ Support for Project, Kotlin, Lombok, JSON Binding API as an alternative to
Jackson and GSON.
➢ Spring WebFlux – Spring getting Reactive.
➢ Support for JUnit 5
➢ Functional programming support through Kotlin.
 Spring Boot

Spring Boot is a Framework provided by “The Spring Team” to ease the

bootstrapping and development of new Spring Applications. It provides defaults
for code and annotation configuration to quick start new Spring projects within
no time.

What is NOT Spring Boot?

Spring Boot Framework is not implemented from scratch by The Spring Team, It
is implemented on top of existing Spring Framework (Spring IO Platform).
Spring Boot Framework is not used for solving any new problems. It is used to
solve the same problems as the Spring Framework.

Why Spring Boot?

➢ To Make the Java-based applications Development easy, and make it easy
for Test Process(Unit Testing, Integration Testing)
➢ To reduce Development, Unit Test and Integration Test time by supplying
some defaults.
➢ To increase productivity.
➢ It is very uncomplicated to develop Spring Based applications with Java or
Groovy.
➢ It decreases lots of development time and increases productivity.
➢ It avoids developing lots of boilerplate Code, Annotations and XML
Configuration.
➢ It is very easy to combine Spring Boot Application with its Spring
Ecosystem like Spring JDBC, Spring ORM, Spring Data, Spring Security etc.

It supplies Embedded HTTP servers like Tomcat, Jetty etc. to design and test our
web applications very easily.
It supplies the Command Line Interface tool to develop and test Spring
Boot(Java or Groovy) Applications from command prompt very easily and
quickly.
It supplies lots of plugins to develop and test Spring Boot Applications very
conveniently using Build Tools like Maven and Gradle
It supplies lots of plugins to work with embedded and in-memory Databases very
easily.
In Simple Terminology, What Spring Boot means
That means Spring Boot is existing Spring Framework + Some Embedded HTTP
Servers.

Main Goal of Spring Boot:

➢ To completely avoid XML configuration.
➢ To completely avoid Annotation Configuration(It combined some existing
Spring Framework Annotations to a simple and single Annotation)
➢ To avoid writing lots of import statements.
➢ To provide some defaults to rapidly start new projects within no time.
➢ To provide the approach of Opinionated Development.
➢ By providing or avoiding these things, Spring Boot Framework lessens
Development time, Developer Effort and increases productivity.

Limitation/Drawback of Spring Boot:

➢ Spring Boot Framework has one limitation.
➢ It is somewhat bit time-consuming process to convert existing or legacy
Spring Framework projects into Spring Boot Applications but we can
convert all kinds of projects into Spring Boot Applications. We can easily
create brand new Projects using Spring Boot.

To begin with, Opinionated Approach to create Spring Boot Applications, The

Spring Team (The Pivotal Team) has provided the following three approaches.

➢ Use Spring Boot CLI Tool

➢ Use Spring STS IDE
➢ Use Spring Initializr Website
➢ We will discuss one by one in detail with some good examples in coming
posts. We can find Spring Initializr Website at: http://start.spring.io/
 ➢ By using Spring-Boot we can Develop two flavours of Spring Based
Applications
➢ Applications Based on Java
➢ Applications Based on Groovy

To develop Spring Boot Groovy Applications. we can use Spring Boot CLI or
Spring STS IDE, However, To develop Spring Boot Java Applications. we can use
Spring Boot CLI or Spring Initializr

Anyhow, Groovy is also a JVM language like Java Language. We can merge both
Groovy and Java into one Project. Because like Java files, Groovy files are finally
compiled into *.class files only. Both *.groovy and *.java files are converted to
*.class file (Same byte code format).

Spring Boot Framework Programming model is stimulated by Groovy

Programming model. Internally Spring Boot uses some Groovy-based techniques
and tools to provide default imports and configuration.

Spring Boot Framework also merged existing Spring Framework annotations

into some simple or single annotations. We will explore those annotations one by
one incoming posts with some real-time examples.

Spring Boot Framework extremely changes Spring-Java Based Applications

Programming model into the new Programming model. As of now, Spring Boot
is at the initial stage only but the future is all about Spring Boot only.

JavaServer Faces (JSF)

JavaServer Faces (JSF) is the Java standard technology for building component-
based, event-oriented web interfaces. Just like JavaServer Pages (JSP), JSF allows
you to access server-side data and logic. Unlike JSP, which is essentially an HTML
page inspired with server-side capabilities, JSF is an XML document that
represents formal components in a logical tree. JSF components are supported
by Java objects, which are independent of the HTML and have the full range of
Java abilities, including accessing remote APIs and databases.

The main idea behind framework like JSF is to encapsulate (or wrap) client-side
technologies like HTML, CSS, and JavaScript, allowing developers to build web
interfaces without much interaction with these technologies.

This article presents a basic idea of JSF's approach to component-based UI

development for Java web applications. Some examples introduce JSF's MVC
architecture, event model, and component library. Examples comprise of new
features in JSF 2.3, and we'll use PrimeFaces for our component library.

Evolving JSF
JSF has recently faced competition from Java-compatible web frameworks,
encompassing client-side JavaScript frameworks. Still, JavaServer Faces persists
the Java standard, especially for large-scale, Java enterprise development. The
JSF specification has also spawned a wealth of frameworks and libraries, which
have kept pace with recent client-side improvements. One of these is PrimeFaces,
which we will traverse in this tutorial.

While the schedule for future development is uncertain, JSF 2.3 gives developers
plenty to work with while we wait. Released on March 2017, JSF 2.3 was
intentionally designed to modernize J

Managed beans are simple Java objects (POJO’s) which are declared in "faces-
config.xml" and can be used in a JSF application. For example, you can define aN
Object in Java "Student". Once you define the object in faces-config.xml you can
use the properties of Student in your JSF UI components, e.g. by binding the value
"firstName" of this object to a JSF input field.
JSF uses the Unified Expression Language (EL) to encapsulate UI components to
object attributes or methods.

Value and Method Binding

In JSF you can acquire the values of a managed bean via value binding. For
binding the Value, the universal Expression Language (EL) is used (to access
bean and/or methods). In JSF you do not need to mention the get() or set()
method but just the variable name. We can use Method binding to bind a JSF
component, e.g. a button to a method of a Java class.

Expression Language statements can be started with "${" or with "#{" and end
with "}".The JSP EL expressions are using the ${… } syntax. These EL expressions
are immediately analysed. JSF Expression Language expressions are of the type
#{… }. These are only analysed when needed (and otherwise stored as strings).

Prerequisites to use JSF

To use JSF you need:
➢ The JSP Standard tags library
➢ A Java runtime environment
➢ A web-container to use JSF

JSF Main features

➢ JSP has the following main features:
➢ JSP is based on the Model-View-Controller concept
➢ JSP has a stateful UI component model, e.g. each component is aware of its
data

JSF decomposes the functionality of a component from the display of the

component. The renderer is responsible for displaying the component for a
certain client. This renderer can get exchanged. The standard provider for JSF
components is the HTML renderer.
JSP support listeners on UI components

JSP support data validation, as well as data binding and data conversion
between the UI and the model

JSP and JSF

In this tutorial, the JSF application will be build based on JavaServer Pages
(JSP’s). JSTL tags are used to include JSF UI components into the JSP. This is
standard in JSF 1.2. The JSF 2.0 version is using Facelets.