DEV Community: Awdesh sharma

Database Access with Spring Data JPA

Awdesh sharma — Tue, 02 Mar 2021 05:09:51 +0000

JPA is a standard for ORM. It is an API layer that maps Java objects to the database tables. All you need is to annotate your Domain object with @Entity.

In Spring Boot, Spring Data JPA brings the goodness of Spring Data and JPA together.

In the JDBC world we have to embed sql queries inside the codebase to access the database, JPA hides all that complexity by providing many CRUD related methods via JpaRepository.

Let's take a look

Above code is mapping User Object to User table in the database. User table consists two columns "first_name" and "last_name". @Column annotation is defining the column inside the User table.

JPA supports many annotations e.g. @Table annotation can define the indexes on the table. Take a look at the sample code below.

Above we are creating an index name “name_index” on the first_name column.

Data access layer without JPA:

JDBC is the prominent method to access the database. JDBC requires one to write sql queries to communicate with the database, it makes use of Statement, ResultSet etc. to prepare a sql statement and gets the result out of database respectively.

Let's take a look below-:

Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT first_name FROM Customers WHERE last_name = 'Doe'");

Here we create a statement object and call executeQuery on it with supplying the SQL query. ResultSet object will contain all the returned result from the query. We can now use an iterator to iterate over items inside result set.

Similarly an insert statement could look like this.

Statement stmt = connection.createStatement();
stmt.execute("INSERT INTO user (FIRST_NAME,LAST_NAME) VALUES (1,'John','Dow')");

Data access layer with JPA

Let's see how JPA does above two database operations.

Spring Data Jpa expose JpaRepository which is comprises on all the CRUD methods. Once we define a repository for the domain object we are ready to call these methods.

Let's create a repository interface for User.

@Repository annotation tells Spring Boot to scan interface and make it available at startup. You'll notice that we haven't create any method inside our interface because we don't need to, atleast for the simple CRUD use cases.
All those operations are supported by JpaRepository out of the box and we are extending it.

Now let's compare same select and insert operation of Jdbc here in Jpa.

Like Select if we have to retrieve all the objects we can do

User user = userRepository.findAll();

Like Insert if we have to insert a user we can do

userRepository.save(user);

Much simpler than the JDBC implementation.

Let's take a look at another example.

Finding all the users with the given first name.

Use “findBy” to search on a particular column.

// find rows by the first name.
userRepository.findByFirstName(String firstName);

Similarly,

// find rows by the last name.
userRepository.findByLastName(String lastName);

I'll stop here for this post. In the next post I'll write how to handle more complex sql queries using JPA.

If you like to walk through video tutorial rather I have a Spring Boot playlist on YouTube 👉 Spring Boot Tutorial Series

I post daily about programming on different platforms with the intention of writing good tech content and keep them less spammy.

You can also find me 👇

Youtube | Twitter | Instagram

Let’s learn together 💪💪

Happy Coding 💻

Quick walkthrough of creating an API with Spring Boot.

Awdesh sharma — Thu, 25 Feb 2021 07:03:40 +0000

In this post, I am discussing how we can create a simple API with Spring Boot. This post discusses about Repository, Controller/Resource and Model layer.

Let's get to it. 🚀

Prerequisite: Make sure you have Java 11 and maven installed.

Head over to start.spring.io from your favourite browser and create a starter project. Add these three dependency from the Add Dependency tab on right pane.

JPA : JAVA Persistence API. Provides lot of methods to interact with database.
H2 : In memory relational database.
Spring Web : Uses Apache Tomcat as default embedded container.

Click on Generate at the bottom to download the zipped folder. Extract it and open it in IntelliJ or any other favourite editor of your choice.

Your pom.xml with dependencies should look like below.

Just three dependencies that we added from the website. Simple and clean.

At this point we can run the service and it'll start the tomcat but it won't be very useful to us since we haven't defined any endpoints.

So let’s jump into the action and start creating classes. I'll start from bottom-up i.e. creating classes that are closer to the database and then move up to utilize those classes.

1. Model layer

The first thing I like to think about is the object that I want to store in the database. In this post I am using Video object. A video can contain a title and a description.

Let's create a class named Video.java.

Here is the quick summary of the annotations used in the class.

@id : Annotation tells that the field is a primary key.
@GeneratedValue : JPA will take care of auto generating this value for us. We don't need to manually send it with the object.
@Entity : Represents that the POJO can be persisted in the database.

2. Repository layer

Remember JPA that we added while generating the project. It exposes many methods that can be utilized to interact with the database. Methods like save(), findAll(), delete for regular CRUD operations.

No more hassle of constructing JDBC queries.👍

@Repository : Helps Spring Boot to scan the repository layer.

3. Controller/ Resource layer

Layer that expose object from data to the outside world and brings days from outside world.

In other words, it is where we define GET, POST and other REST mappings to create API endpoints.

@RestController : Signifies that the class is a controller class and contains REST endpoints.

That's it. 🎉🎉

Now you are ready to run the service. Look for the class ending with Application in your project. It should contain main method.

You can simply run the main method that will scan all the components based on the annotations that we have supplied and bootup the service.

If everything went well, you should be able to see tomcat running at port 8080. Fireup postman and go to http://localhost:8080 and GET, POST a Video object.

http://localhost:8080/h2-console will open the window to connect to in memory database. You don't need to change anything other than Jdbc_url which can be find from the logs inside the terminal window.

This is a very basic and simple implementation of creating an API with Spring Boot. There are many features of SB that comes out of the box which I will write about in the next few posts.

If you like to walk through video tutorial rather I have a Spring Boot playlist on YouTube 👉 Spring Boot Tutorial Series

I post daily about programming. You can find me 👇

Youtube | Twitter | Instagram

Let’s learn together 💪💪

Happy Coding 💻