**JPA(Java Persistance API)** — JPA is a specification of Java which is used to map Java objects to a relational database, acting as a bridge between the two. It doesn’t perform operations on its own but requires implementation with ORM tools like Hibernate.


> Object relational mapping (ORM) is the mapping of Java objects to Database tables.


JPA is used to work directly with objects rather than using SQL statements to perform operations. Persistance metadata (defined by annotations of XML file) defines the mapping between Java objects and the database tables.


JPA defines a SQL-like Query language for the implementation of static and dynamic queries. **JPA JPQL** is an object oriented query language used to perform database operations. It uses the entity object to perform operations on the database records. The JPQL queries are then transformed to SQL using a JPA implementation. This can be used with any type of database such as MySQL, H2, Oracle, etc.
 
 
## Implementation
### Technology Stack

- Spring Boot Framework 
- Maven 3.6.3 
- MySQL 8.0.19
 
 

### Setting up the Project

1. Go to https://start.spring.io/ 
2. Choose the Project type depending on what build tool you want to use. We have chosen maven as the build tool. 
3. Choose the Spring Boot version. 
4. Fill in the Project Metadata info. 
5. Add the dependencies . In the case of this project we need Spring Web, Spring Data JPA, MySQL Driver. 
6. Generate the project and import it in your preferred editor

![Dependencies](https://i.imgur.com/QqkHn1y.png "Dependencies")

![Setting up the Project](https://i.imgur.com/o5xUaIo.png "Setting up the project")
 
 

### Setting up the Database

- Create database **employees** in MySQL
- Create table **employee**

![Create Database & Table](https://i.imgur.com/rQDU1pI.png "")

![Table Description](https://i.imgur.com/YVvedeK.png "")

The Employee Model will contain the following attributes — **id, name, gender, experience in years, experience in months, experience in days.**
 
 

### Add database configuration with application.properties

The configuration for datasource is added in application.properties.


_**spring.datasource.url** indicates the url of the database_


_**spring.datasource.username** and **spring.datasource.password** indicates the username and password of the database being used._


_**spring.jpa.hibernate.ddl-auto** is a Spring Data JPA property which manipulates how the database schema will be transformed on application startup. The values can be **create** (creates a new schema every time the application is started), **create-drop** (the schema is dropped once the application is stopped and only created once the application is started again), **update** (updates the schema in case of any change) and **validate** (only validates the schema, not making any changes)._


_**spring.jpa.properties.hibernate.dialect** property makes hibernate generate better SQL for the database._


_**spring.jpa.show-sql** property when set to true logs the SQL Queries in the console._

![Property file](https://i.imgur.com/S86rMks.png "")
 
 

### Define the Entity

The basic unit of persistence in JPA is the **entity**. It is a Java class which uses metadata described be in the form of annotations or defined in an XML file(in this example annotations are used) to map the class to the database table.

![Entity](https://i.imgur.com/M2AqfUi.png "")

**@Entity** annotation is used on all the classes which need to be persisted in the database. An instance of the class is persisted as a row in the database table.


The database table name can be defined specifically using **@Table(name=”______”)** annotation. Otherwise the table takes the name of the corresponding class.


**@Id** is used to define the primary key


The primary key can be auto generated in the database using the **@GeneratedValue** annotation.


The fields in the Entity are saved as columns in the database table. The column name can be defined specifically using **@Column(name=”______”)** annotation. Otherwise the column takes the name of the corresponding field.


If the field does not need to be persisted in the database as a column it can be annotated with **@Transient** .
 
 

### Different ways to execute a query using JPQL

Before starting to implement the queries , it is important to acquire an EntityManager instance.


> EntityManager can be container-managed or application-managed.


Application-managed EntityManager is managed by the application, It needs to be created manually and the lifecycle has to be managed by us well.

In this example we use a container managed EntityManager instance where the container is responsible for creating the instance from EntityManagerFactory for us, beginning the transaction, committing it or rolling it back.



![Entity Manager Usage](https://i.imgur.com/AaerU4E.png "")


JPQL queries can be executed in different ways.


1. **createQuery**

The createQuery method is used to query the database using JPQL. This method is used to execute **dynamic queries** which are defined within the business logic of the application.


Query retrieves the matching record from the database table and also maps it to the Entity object.


![Get All Employees method](https://i.imgur.com/8jcLH8Z.png "")

**getAllEmployees** method retrieves the list of employees using **createQuery(String jpql)** method. The JPQL query is defined in **GET_EMPLOYEE_QUERY**. Instead of mentioning the table name (employee) in the query, the Entity name (Employee) is mentioned. Since JPA cannot determine the result type, we need to cast the result type before returning it. The **getResultList()** method is used to retrieve a list of the results after executing the JPQL query.

`TypedQuery`

JPA also provides a special Query sub-type known as a **TypedQuery** as a solution to JPA not being able to determine what the result type will be. This is a good solution whenever the result type is known beforehand and also helps in avoiding casting exceptions.

![TypedQuery example](https://i.imgur.com/7q16GjB.png "")

**getEmployeesByYearsOfExperience** method retrieves the list of employees having specified years of experience using **createQuery(String jpql)** method. The JPQL query is defined in **GET_EMPLOYEES_BY_YEARS_OF_EXPERIENCE**.


Positional Parameter has been used to specify the year of experience.


Parameters are used when we don’t want to hardcode values in our query but want the client to specify it. In this example we have used positional parameter.


> Positional parameters are declared with a question mark (?) followed by the numeric position of the parameter in the query. We start with 1 and increment the position with every parameter. The Query.setParameter(integer position, Object value) method is used to set the parameter values. We can also use the same parameter more than once within the same query.


We can execute the queries using the following Query interface methods :-
- executeUpdate() — This method executes the update and delete operation.

- getFirstResult() — This method returns the first positioned result the query object was set to retrieve.

- getMaxResults() — This method returns the maximum number of results the query object was set to retrieve.

- getResultList() — This method returns the list of results as an untyped list.

- getSingleResult() — This method returns a single untyped result.

 


2. **createNamedQuery**

The createNamedQuery method is used to execute **static queries**. The queries can be defined in the metadata by using the NamedQuery annotation on the Entity class itself. The name element of @NamedQuery specifies the name of the query that will be used with the createNamedQuery method. All NamedQueries must have a unique name.

![Get Employees by Months of Experience](https://i.imgur.com/P76Pnti.png "")

**getEmployeesByMonthsOfExperience** method retrieves the list of employees having specified months of experience using **createNamedQuery(String name)** method. The name of the **NamedQuery** is specified in the metadata.

![Find Employees by Months of Experience](https://i.imgur.com/Kc9vzNx.png "")

 


3. **createNativeQuery**

The **createNativeQuery** method is used to execute native/pure SQL queries.


A NativeQuery is simply an SQL query. This allows us to utilise features not available in JPQL syntax. However we lose database portability of the application.

![Get Employees by Days of Experience](https://i.imgur.com/TrY9wI1.png "")

**getEmployeesByDaysOfExperience** method retrieves the list of employees having specified days of experience using **createNativeQuery(String sql)** method. The SQL query is defined in **GET_EMPLOYEES_BY_DAYS_OF_EXPERIENCE**. Positional parameters can be used with Native SQL Queries as well.


Some extra methods -:


* **CREATE**

The persist method of EntityManager is used to save the Employee instance in the database.

![Create Method](https://i.imgur.com/ABygA7p.png "")


* **UPDATE AND DELETE**

Updating and deleting the Employee instance using createQuery method of EntityManager and executeUpdate method of the Query interface.

![Update and Delete Method](https://i.imgur.com/QzmTQ6I.png "")


* **GET BY ID**

This method retrieves an employee record based on the passed ID.

![Get By ID Method](https://i.imgur.com/qWKFpdi.png "")


* **BETWEEN … AND…**

The JPQL Query for getting employee list based on a **range of specified values** is executed in the following method.

![Between and And method](https://i.imgur.com/ZZSkcff.png "")


* **COUNT, MAX AND MIN**

The JPQL Queries to execute Aggregation methods like getting employee count, **maximum ** years of experience and **minimum** years of experience are executed in the following method.

![Count, Max and Min Method](https://i.imgur.com/U8UlyC6.png "")

* **SORTING**

The JPQL Query to retrieve records in sorted order. The following method retrieves records **sorted in descending order** based on years of experience.

![Sorting Method](https://i.imgur.com/9y5pryT.png "")


Find the link to complete code [**here**](https://github.com/AnviPuri/JPA-JPQL-Demo).

Implementation of Data Access Layer with JPA JPQL in Spring Boot

In the previous part i.e. [**Creating Spring Boot CRUD Rest APIs with Data JPA and JDBC — Part 1**](https://www.anvipuri.com/blog/creating-spring-boot-crud-rest-apis-with-data-jpa-and-jdbc-part-1) , we implemented **REST APIs** for **CRUD** operations using Data JPA. In this part, we will be implementing the same functionalities using **JDBC**.
 
 
### Technology Stack
- Spring Boot Framework 
- Maven 3.6.3 
- MySQL 8.0.19
 
 
### Setting up the Project and Database
Set up the project and database as done in [**Part 1**](https://www.anvipuri.com/blog/creating-spring-boot-crud-rest-apis-with-data-jpa-and-jdbc-part-1).

In the case of this project add the following dependencies: **Spring Web, Spring Data JDBC, MySQL Driver.**

![Dependencies](https://i.imgur.com/9sSmyhR.png "Dependencies")

The **REST endpoints** also remain the same.
 
 
### Project Layout

![Project Layout](https://i.imgur.com/XPwYhJP.png "Project Layout")

 
 

### Implementation of REST CRUD APIs

1. **Presentation Layer — UserController**

![Presentation Layer](https://i.imgur.com/1GfMIym.png "")

**UserController** is a **Rest Controller** which exposes REST APIs to the client.

**UserServiceImpl** class **(Service Layer)** is **autowired** in the controller. The methods in the controller call the exposed methods of the service layer to create, update, delete and retrieve users.

The APIs send back a response to the client with a **HTTP status** (**CREATED** or **OK**) along with user/s object in case of **GET** methods.

To understand the working of the Rest Controller and the annotations used refer [**Part 1**](https://www.anvipuri.com/blog/creating-spring-boot-crud-rest-apis-with-data-jpa-and-jdbc-part-1).



2. **Service Layer — UserService & UserServiceImpl**

![Service Layer](https://i.imgur.com/p2DDecS.png "")

**UserService** is an interface which defines the methods implemented in **UserServiceImpl** class. They are a part of the service layer and used to implement the business logic of the code.

**UserDaoImpl** class **(DAO Layer)** is **autowired** which exposes the methods of the DAO Layer.



3. **User Bean**

![User Bean](https://i.imgur.com/tbztYvg.png "")

The User bean is used by the Data Access Layer to perform CRUD operations.



4. **Data Access Layer — UserDao & UserDaoImpl**

![Data Access Layer](https://i.imgur.com/HI5QUFr.png "")

**UserDao** is an interface which defines the methods implemented in **UserDaoImpl** class. They are a part of the DAO layer and contain the methods which are used to perform operation on the database.

**JDBC** produces a lot of boilerplate code like managing the connection to the database, handling SQL exceptions. The Spring JDBC API is an adaptation of the standard JDBC API. **JdbcTemplate** is one of the ways provided by Spring JDBC to remove boilerplate code, mapping data to classes.

JdbcTemplate manages the connection to the database, executes SQL queries, iterates over the result set retrieving the values. It also handles the exceptions and translates the exceptions into exceptions which are defined under **org.springframework.dao** package.

The properties for the datasource are configured in **application.properties** and utilised by JdbcTemplate which is autowired in UserDaoImpl class.

![App Properties](https://i.imgur.com/WSx5jmF.png "")

Spring Boot gets the datasource properties and injects it to JdbcTemplate object while auto wiring.

Refer to [**Part 1**](https://anvipuri14.medium.com/creating-spring-boot-crud-rest-apis-with-data-jpa-and-jdbc-part-1-9eb0d6cd1358) to understand the properties defined above.

A RowMapper is implemented to process the ResultSet, mapping each row to an object.

![Row Mapper](https://i.imgur.com/3EyMJjJ.png "")

The **UserRowMapper** class implements **RowMapper** and overrides its **mapRow** method which maps a row of the result to the **User** class.

 
 

---

_**Creating a User**_

The query to create a user is defined in **INSERT_USER_QUERY.**

The **save** method of the UserDaoImpl class then uses the **update** method of JdbcTemplate.

```
update(String sql, Object... args)
```

> _The parameters are defined in new Object[] {……} in the order they are written in the query.
> 
> 
> The update method binds the given arguments with the sql query and performs an update operation to insert, update or delete with the help of a prepared statement.
> 
> 
> It returns an integer count of the number of rows that were changed after the execution of the query._


_**Updating a User**_

The query to update a user is defined in **UPDATE_USER_QUERY.**

The **update** method of the UserDaoImpl class then uses the **update** method of JdbcTemplate.


_**Deleting a User**_

The query to delete a user is defined in **DELETE_USER_QUERY.**

The **delete** method of the UserDaoImpl class then uses the **update** method of JdbcTemplate.


_**Retrieving all Users**_

The query to retrieve all users is defined in **GET_USERS_QUERY.**

The **findAll** method of the UserDaoImpl class then uses the **query** method of JdbcTemplate.

```
query(String sql, RowMapper<T> rowMapper)
```

> _The query method executes the SQL query and maps each row to the result object using the RowMapper specified in the argument.
> 
> 
> It returns a list of the result object which was mapped by the mapper._

The custom RowMapper used in this example is the **UserRowMapper** defined above.


_**Retrieving a User by ID**_

The query to retrieve a user by ID is defined in **GET_USER_BY_ID_QUERY.**

The **findById** method of the UserDaoImpl class then uses the **queryForObject** method of JdbcTemplate.

```
queryForObject(String sql, RowMapper<T> rowMapper, Object... args)
```

> _The SQL query and the list of arguments are bound by the prepared statement to execute the query, the result of which is mapped to the result object using the RowMapper.
> 
> 
> It returns the result object which was mapped by the mapper._

**Test the APIs** as shown in [**Part 1**](https://www.anvipuri.com/blog/creating-spring-boot-crud-rest-apis-with-data-jpa-and-jdbc-part-1).

Find the link to complete code [**here**](https://github.com/AnviPuri/CRUD-JDBC).

Creating Spring Boot CRUD Rest APIs with Data JPA and JDBC - Part 2

Spring Boot is a highly used and popular framework in Java which is easy to start with and understand as well. In order to get a head start into the framework we will be creating a Spring Boot Application which exposes REST APIs to create, edit, retrieve and delete a user.
 
 
### Technology Stack
- Spring Boot Framework 
- Maven 3.6.3 
- MySQL 8.0.19
 
 
### Setting up the Project
1. Go to https://start.spring.io/ 
2. Choose the Project type depending on what build tool you want to use. We have chosen maven as the build tool. 
3. Choose the Spring Boot version 
4. Fill in the Project Metadata info. 
5. Add the dependencies . In the case of this project we need **Spring Web, Spring Data JPA, MySQL Driver.** 
6. Generate the project and import it in your preferred editor


![Dependencies](https://i.imgur.com/TIPuR0w.png "Dependencies")

![Setting up a Spring Boot Project](https://i.imgur.com/sSNpeZW.png "Setting up a Spring Boot Project")
 
 
### Setting up the Database
- Create database **userdb** in MySQL
![Database Creation](https://i.imgur.com/La1rfZR.png "")
- Create table **user**
The User Model will contain the following attributes — _**id, first name, last name, gender and age.**_
![Database Table Creation](https://i.imgur.com/97pDWFR.png "")
 
 

### REST API Endpoints
1. **Create User** 
Method: **POST** 
Endpoint: **/users/save-user**

2. **Update User** 
Method: **PUT** 
Endpoint: **/users/update-user/{id}** 

3. **Delete User** 
Method: **DELETE** 
Endpoint: **/users/delete-user/{id}** 

4. **Get all Users** 
Method: **GET** 
Endpoint: **/users** 

5. **Get User by Id** 
Method: **GET** 
Endpoint: **/users/{id}**
 
 

### Project Layout 

![Project Layout](https://i.imgur.com/034eKqh.jpg "Project Layout")

1. **Application Property File** — This contains configuration of the spring boot project like database properties, port number, etc .

![application.properties](https://i.imgur.com/Cwdg4sb.png "application.properties")
 

- **server.port** indicates the port number the application will run on. 
- **spring.datasource.username** and **spring.datasource.password** indicates the username and password of the database being used. 
- **spring.datasource.url** indicates the url of the database. 
- **spring.jpa.hibernate.ddl-auto** is a Spring Data JPA property which manipulates how the database schema will be transformed on application startup. The values can be **create** (creates a new schema every time the application is started), **create-drop** (the schema is dropped once the application is stopped and only created once the application is started again), **update** (updates the schema in case of any change) and **validate** (only validates the schema, not making any changes). 
- **spring.jpa.properties.hibernate.dialect** property makes hibernate generate better SQL for the database

2. **ENTITY** — The Entity class is mapped to the respective table in the database. It is a bean which represents the table structure.

![User Entity](https://i.imgur.com/ifQBIGq.png "User Entity")

In the above figure the User entity is mapped to the user table in the database using **@Table** annotation where the name property specifies the name of the table.

The annotation **@Entity** annotation specifies the class an an entity bean and defines that a class can be mapped to a table.

The fields of the User class are mapped to the columns of the user table using **@Column** annotation. In case the name of the field and the column is different, name property can be used to map the field to the differently named column.

**@Id** annotation specifies the field which will be the primary key of the entity and **@GeneratedValue** specifies that the field will be automatically generated according to the specified strategy like in the above case the Identity strategy.

3. **PERSISTENCE LAYER** — This layer helps in transforming the business objects to database rows and vice versa, containing the logic to persist data to or retrieve data from the datastore.

![User Repo for Data Access](https://i.imgur.com/evCOzjY.png "User Repo for Data Access")

We are using Spring Data which simplifies the data access procedure for databases. JPA (Java Persistence API) is a API specification for object relational mapping which maps the objects of a class to rows of a table (in this example — maps User class to user table).

The Repository interface represents the DAO layer which takes care of database operations.

In the above example JpaRepository can carry out basic CRUD operations and also contains API for pagination and sorting without us having to specify the methods separately. With the help of this the boilerplate code written to access data is reduced.

The Entity (**User**) and the datatype of the primary key (**Integer**) of the entity ( i.e the field marked with **@Id** ) are specified as well.

4. **PRESENTATION LAYER AND SERVICE LAYER**

_Presentation Layer_ — This layer contains REST Controllers which expose the REST endpoints to the client , receives the Rest API request, transforms the JSON received by the client to the mapped model object present in the Rest API as parameters. The model object is then transferred to the service layer.

![Presentation Layer Structure](https://i.imgur.com/RegpjDZ.png "Presentation Layer Structure")

In the above figure UserController annotated with **@RestController** annotation making it a controller which receives HTTP requests from the client. It returns an object which is directly written into the HTTP response as JSON or XML. The annotation is a combination of **@Controller** (marks a class as a Spring MVC controller) and **@ResponseBody** (tells a controller that the returned object returned is to be serialised into JSON and written into HTTP response) annotations.

**@RequestMapping** maps HTTP requests to the handler classes/methods of REST controllers.

**@PostMapping, @GetMapping, @PutMapping, @DeleteMapping** annotated methods handle the respective HTTP POST, GET, PUT, DELETE requests matched with given URI expression.

_Service Layer_ — Implements any business logic on the request model and uses the methods exposed by the Data Access Layer.

**UserServiceImpl** class is the service class which is **autowired** in **UserController**. It exposes the methods of the service layer in the controller.

![Service Layer Structure](https://i.imgur.com/wgpQMTj.png "Service Layer Structure")

**@Service** annotation is a specialisation of **@Component** annotation. It is used to define service-layer classes.
 
 

### Implementation of REST CRUD APIs

1. **Creating a User**

![Creating a User](https://i.imgur.com/TduKGtn.png "")

**@RequestBody** converts the HTTP Request body to java objects using HTTP message converters.

The user object received in **createUser** method of **UserController** is then passed to the service layer.

![Creating a User](https://i.imgur.com/jZf5urn.png "")

**createUser** method in **UserServiceImpl** receives the user object from the controller and saves it in the database using the JpaRepository **UserRepo** and returns the saved user back to the controller.



2. **Updating a User**

![Updating a User](https://i.imgur.com/FpGf1Tv.png "")

**@PathVariable** annotation binds the request parameter of the handler method to the URI making it dynamic. Hence it is used for data passed in URI. In the above example id is the path variable which can have dynamic values.

The user object along with the id received in **updateUser** method of **UserController** is then passed to the service layer.

![Updating a User](https://i.imgur.com/jWPLkq6.png "")

**updateUser** method in **UserServiceImpl** receives the user object and id from the controller, checks if data is present in the database corresponding to that id using **findById** method of the JpaRepository. If data is present, the user object is copied to the updatedUser object using **BeanUtils.copyProperties()** and saved in the database corresponding to the id. The updated user is then returned to the controller.



3. **Deleting a User**

![Deleting a User](https://i.imgur.com/Gf84bCO.png "")

The id received as the path variable in **deleteUser** method of **UserController** is passed to the service layer.

![Deleting a User](https://i.imgur.com/exX0Q3l.png "")

**deleteUser** method in **UserServiceImpl** receives the id from the controller, checks if data is present in the database corresponding to that id using **findById** . If data is present, it is deleted using the **delete** method of JpaRepository.



4. **Retrieving all Users**

![Retrieving all Users](https://i.imgur.com/YTwOhaC.png "")

**getUsers** method of **UserController** calls the service layer method.

![Retrieving all Users](https://i.imgur.com/PrvU0Z1.png "")

**getUsers** method in **UserServiceImpl** uses the **findAll** method of JpaRepository to retrieve all users from the database. The data is then passed back to the controller.



5. **Retrieving a User by User ID**

![Retrieving a User by User ID](https://i.imgur.com/wNijrws.png "")

The id received as the path variable in **getUserById** method of **UserController** is passed to the service layer.

![Retrieving a User by User ID](https://i.imgur.com/PrvU0Z1.png "")

**getUserById** method in **UserServiceImpl** receives the id from the controller, checks if data is present in the database corresponding to that id using **findById** and retrieves the user. If user is present, the retrieved user is returned to the controller.
 
 

### Testing the APIs with Postman

1. **Creating a User**

![Testing Creating a User](https://i.imgur.com/ipgnwQR.png "")

2. **Updating a User**

![Testing Updating a User](https://i.imgur.com/ShGg9th.png "")

![Testing Updating a User](https://i.imgur.com/MTjnNYI.png "")

3. **Deleting a User**

![Testing Deleting a User](https://i.imgur.com/WJj9CdQ.png "")

4. **Retrieving all Users**

![Testing Retrieving all Users](https://i.imgur.com/TV9yIW3.png "")

5. **Retrieving a User by User ID**

![Testing Retrieving a User by User ID](https://i.imgur.com/UdmzHvx.png "")


Find the link to complete code [here](https://github.com/AnviPuri/CRUD-Data-JPA)

Find **Creating Spring Boot CRUD Rest APIs with Data JPA and JDBC — Part 2** [here](https://www.anvipuri.com/blog/creating-spring-boot-crud-rest-apis-with-data-jpa-and-jdbc-part-2)

Creating Spring Boot CRUD Rest APIs with Data JPA and JDBC - Part 1

**Spring framework** is a lightweight yet powerful Java framework which is used for application development. It provides support for developing Java applications and handles the infrastructure configuration, letting the developer focus on business logic (What more could a developer want, right?).
The fact that Spring promises modularity, makes it a famous framework among developers.
 
 

> _Modularity is the ability to use only the modules that are needed without worrying about using the other modules._
> 
> 
> The best part about Spring being modular is that the modules can be used according to the use case/ need of the product/ developers (can’t miss out any, can we?). Spring has modules like Spring AOP, Spring messaging, Spring Transaction, Spring Data Access, etc which provide a diverse range of services. The Spring Core module provides the base implementation on top of which these modules can be utilised.

 
 

### A Brief History Lesson…

Before understanding the different features the framework is built upon , let us have a quick history lesson on our much (or soon to become) favourite topic.
An Open source Framework, Spring was written by Rod Johnson and was first released in June 2002. It was built with the purpose of overcoming a number of major complexities with Java EE and Enterprise Java Beans by using a simpler solution (now affectionately known as Spring Framework) which is based on the use of **POJOs**( explained further in the article), **Dependency Injection** and **Inversion of Control**.
 
 

> **What is Java Enterprise Edition and EJB?**
> Java EE is used to develop enterprise apps. EJB is a specification of Java EE for server side architecture. One of the first technologies to make the development of server side enterprise applications easier, it handles myriad of concerns like implementation of concurrency, transaction management, etc.

 
 

### Drawbacks of applications built without Spring:

- A lot of configurations were needed — it was proving to be a performance bottleneck, slowing down applications.
- code could become complicated with increasing XML files
- applications could become heavy, affecting the performance of the system
- hard coding dependencies for each component made the development experience frustrating

Over the years , Spring has become a favourite among many developers as it has not only solved the above problems, but provided a higher learning curve, providing ease of development with its organised packages and classes, and a variety of other features.

 
 

### And Beyond...
Some concepts that Spring Framework is based upon
1. **Dependency Injection**
It is an implementation of Inversion of Control where instead of hardcoding the objects and their dependencies, the dependencies are simply specified via external configuration files, annotations or java code. The objects which have been registered during the startup of the container are injected at compile time only whenever they are required.
Different ways to implement Dependency Injection are:
1. Using Setters
2. Using Constructors
3. Field Based

![Dependency Injection Example](https://i.imgur.com/3hsLlBY.png "Dependency Injection Example")

The above example shows three different ways to implement Dependency Injection. Annotation based configuration has been used where we first define a Configuration class that will be used to define and inject the bean. **@Bean** annotation is used to let Spring framework know that the method defined with this annotation should be used to get the bean implementation to inject in Component classes. **@Autowired** allows constructor-based, field-based or setter dependency injection.

> _**Annotations** are tags which are used to represent the metadata associated with interfaces, classes, methods or fields to provide some additional information about them. Some commonly used annotations in Spring include — **@Component** ( a Java class annotated with @Component is found during classpath scanning and registered in the container as a Spring bean).**@Controller**, **@Service** ,**@Repository** are special cases of the component annotation which are used to define different types of components._

2. **Inversion of Control**
> _Inversion of Control introduces the concept of letting the Spring Framework container handle the creation of objects instead of the developer instantiating the object every time they are needed. This makes the objects loosely coupled._

This is a design framework which inverts the flow of control i.e it enables a container to manage the lifecycle of an object. This can be further explained by looking into a piece of software where the logical components which interact with each other are instances of classes (objects) and depend on one another. Invocation of one object may lead to the invocation of other objects , leading to these objects being tightly coupled.

The IoC container instantiates the application class, configures the objects and assembles the dependencies between the objects according to the information received by it through annotations, configuration files or java code.

Spring Framework allows the container to manage lifecycle of various processes. All the developers need to do to make this work is write some code to register the classes/objects using annotations, external configuration files, etc and the rest is by Spring ( from creation to destruction of the object).

![Example of tightly coupled objects](https://i.imgur.com/FrL4JRF.png "Example of tightly coupled objects")

In the following example the FoodMaker class is tightly coupled with the Ingredient class to perform **makeFood()**. In this case the parent object knows more about the child object and the child object cannot be changed by anyone except the parent class introducing a dependency, making it tightly coupled.

![Example of loosely coupled objects](https://i.imgur.com/J3zvaDC.png "Example of loosely coupled objects")

In the above example **FoodMaker** gets the **Ingredient** object from external sources, in this case the Spring container (using dependency injection). This makes the objects independent of each other.

3. **Using POJOs**
> _POJOs are Java Objects containing properties, their getters and setters and certain methods(like to String which can be overridden) ._

There are no restrictions on the scope of the properties (they can be public, private, protected with public getters and setters.) . They do not extend any pre-specified classes, interfaces or annotations and are exclusive of all frameworks. Further, Java Beans are special kinds of POJOs which must implement Serialisable interface. The fields should be private with getters, setters or both. These fields can be accessed only through getters or setters.The use of Plain Old Java Objects make the Java Program more readable and reusable.

![Example of a POJO](https://i.imgur.com/J3zvaDC.png "Example of a POJO")

 
 

### SPRING ARCHITECTURE

![Spring Architecture](https://i.imgur.com/b5okeWO.png "Source:https://docs.spring.io/spring/docs/3.0.x/spring-framework-reference/html/images/spring-overview.png")

The architecture of Spring framework comprises of several modules which are built on top of the core container and can be utilised according to need of the developer. This feature of modularity allows Spring to integrate with other frameworks as well.

1. **Core Container**

>_This module is responsible for creating and managing beans along with their dependencies_

The **Spring Core** and **Spring Bean** modules provide the means to implement Dependency Injection. It allows the object to define its dependencies. Whenever a bean is created, the container injects those dependencies. BeanFactory (which is an implementation of factory pattern) allows to decouple the configuration and specification of object dependencies from the actual business logic of the program.

The **Spring Context** module is built upon the Spring Core and Bean module. It provides a mean to access the objects that have been defined and configured in the Spring container. The module is responsible for providing various enterprise level services like internationalisation, support for scheduling, caching etc. The Application Context (container defined by ApplicationContext interface) is an integral part of the Context module. It can load bean definitions, wire beans together and provide functionalities like reading messages from a properties file or publishing application events.

The **Spring Expression** Module is an expression language which enables runtime manipulation and querying of objects. It can be used with annotation or XML based configurations.
 
2. **Spring Data Access/Integration**

>_This module is responsible for providing integration with various data access mechanisms / frameworks and communication with data sources._

**Spring JDBC** (Java Database Connectivity) is an API which helps the client to access a database and perform operations on it using Statements, Queries, ResultSets. The complexity related to this is removed using JDBCTemplate which allows easy access, iteration and mapping of data.

**Spring ORM** (Object Relational Mapping) frameworks map a java object to a database table using an ORM API. Some ORM frameworks are Hibernate, JPA ,etc. Spring ORM provides integration with these frameworks.

**Spring JMS** (Java Messaging Service) defines specification for producing and consuming messages (pub-sub communication). Spring JMS provides an abstraction over JMS implementations like ActiveMQ, RabbitMQ.

**Spring OXM** (Object XML Marshalling) defines specifications to transfer and access data in form of XML. Spring OXM provides abstraction over Java using OXM implementations like JAXB .

**Spring Transactions** provides a support for transaction management of classes.
 
3. **Web**

>_Responsible for providing a base for building web applications and integration with other MVC frameworks like Struts, JSF ,etc_

**Spring-Web** modules provides web oriented integration features.

**Spring Web MVC** module is used to create web applications. It enforces a design pattern which allows a single point of entry — the DispatcherServlet, which acts as the Front Controller and forwards the request to other objects for processing. Different concerns are separated into different layers- Model, View and Controller, which helps in building a loosely coupled application. Model is the application data, View is used to render the response to end user using the model and Controller is responsible for processing the request, generating a model and selecting the view based on the model.

**Spring Web-Socket** module provides support for building Web Sockets with spring, enabling bidirectional communication socket between client and servers so that server can also push messages directly to the clients.

**Spring Web-Portlet** helps in the easier development of Portlets and use the same concept as Spring MVC with a Dispatcher Portlet(Dispatcher servlet in the case of Spring MVC), front controller, handler mappings, controllers, views and model.
 
4. **AOP**

>_Aspect Oriented Programming provides modularity like Object Oriented Programming does. The key difference between both is that a class is the unit of modularity in OOPs whereas an aspect is the unit of modularity in AOP ._

AOP breaks the program logic into distinct parts using cross cutting concerns which are features that affect the whole application and are not specific to business logic. AOP can be used for logging, exception handling, implementing security, etc. AOP can be implemented with Spring using XML based configurations or annotations with AspectJ, which is a very popular way to implement AOP nowadays.
 
5. **Instrumentation**

Spring Instrumentation enables the developers to monitor the performance, track and trace code, its errors and the related information . Spring supports instrumentation through AOP and Logging in various environments.
 
6. **Test**

Spring test module helps in easy unit testing with JUnit, TestNG as well as integration testing. Mock objects can also be used to unit test the code in isolation.
 
7. **Messaging**

It serves as a foundation to implement messaging based applications.

 
 

### Conclusion
The Spring framework has evolved into an efficient and developer friendly framework with its modular architecture and a very active community of developers. Spring can be used to develop applications in an easy , flexible and secure manner. So when in doubt…**GO TEAM SPRING!**

Anvi Puri

Results for "spring framework"

Implementation of Data Access Layer with JPA JPQL in Spring Boot

Creating Spring Boot CRUD Rest APIs with Data JPA and JDBC - Part 2

Creating Spring Boot CRUD Rest APIs with Data JPA and JDBC - Part 1

Introduction to Spring Architecture