Configure Spring Data JPA in Jersey 2 JAX-RS App

In this blog post, I am going to share with you how to configure Spring Data JPA in a Jersey 2 Container Deployable Web App. Spring Data JPA makes it much easier and more convenient to persist and read data from the database and when I needed to tie together Spring Data JPA and Jersey 2 Web App I could not find a step by step instructions on how to do it. So in this blog post, I will try to document the steps I needed to do to integrate Spring Data JPA into Jersey 2 JAX-RS container deployable Web app and hopefully if you need to do this integration these steps will help you out and save you a lot of time.

So let’s begin.

Create Jersey 2 JAX-RS Web App with Maven

To create a new Jersey 2 container deployable web app I used the archetype and maven definition suggested on Jersey project website.

mvn archetype:generate -DarchetypeGroupId=org.glassfish.jersey.archetypes \
    -DarchetypeArtifactId=jersey-quickstart-webapp -DarchetypeVersion=2.26

POM.XML Dependencies

Open with your favorite IDE the created with the above maven definition Jersey 2 Web app and update it’s pom.xml file. Below is my pom.xml file which contains dependencies for:

  • Jersey 2
  • Spring Framework
  • Spring Data JPA
  • Hibernate
  • MySQL database
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>ru.altair</groupId>
    <artifactId>jersey_jpa</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>jersey_jpa</name>

    <build>
        <finalName>jersey_jpa</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.5.1</version>
                <inherited>true</inherited>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.glassfish.jersey</groupId>
                <artifactId>jersey-bom</artifactId>
                <version>${jersey.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.glassfish.jersey.containers</groupId>
            <artifactId>jersey-container-servlet-core</artifactId>
            <!-- use the following artifactId if you don't need servlet 2.x compatibility -->
            <!-- artifactId>jersey-container-servlet</artifactId -->
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.inject</groupId>
            <artifactId>jersey-hk2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.media</groupId>
            <artifactId>jersey-media-json-binding</artifactId>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.ext</groupId>
            <artifactId>jersey-spring4</artifactId>
            <version>2.26</version>
        </dependency>

        <!--Spring Framework Dependencies-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>${spring-data.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- Hibernate Dependencies -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>

        <!-- Database Dependencies -->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.187</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>


    </dependencies>
    <properties>
        <jersey.version>2.26</jersey.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>4.3.4.RELEASE</spring.version>
        <spring-data.version>1.10.5.RELEASE</spring-data.version>
        <hibernate.version>5.2.5.Final</hibernate.version>
    </properties>
</project>

WEB-XML File

It is very important up update the WEB-XML file to contain the below details:

  • contextConfigLocation with the location of you beans xml file,
  • Set up the ContextLoaderListener and the RequestContextListener,
  • Configure the jersey.config.server.provider.packagesspecify to specify which packages to scan,
  • And configure the URL pattern to specify the root URL path of your Web Service.
<?xml version="1.0" encoding="UTF-8"?>
<!-- This web.xml file is not required when using Servlet 3.0 container,
     see implementation details http://jersey.java.net/nonav/documentation/latest/jax-rs.html -->
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring/root-context.xml</param-value>
    </context-param>

    <!-- Creates the Spring Container shared by all Servlets and Filters -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <listener>
        <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
    </listener>

    <servlet>
        <servlet-name>Jersey Web Application</servlet-name>
        <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
        <init-param>
            <param-name>jersey.config.server.provider.packages</param-name>
            <param-value>com.appsdeveloperblog.app.ws</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>Jersey Web Application</servlet-name>
        <url-pattern>/webapi/*</url-pattern>
    </servlet-mapping>
</web-app>

Spring Root Context XML file

The location of this file is specified in the above WEB-XML file.  I have placed it in /WEB-XML/spring folder.

I also configure here the location of application.properties file which contains the database connection details and also other the Hibernate related properties.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:task="http://www.springframework.org/schema/task"
       xmlns:sec="http://www.springframework.org/schema/security"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
                           http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd">

    <context:component-scan base-package="com.appsdeveloperblog.app.ws" />

    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="ignoreUnresolvablePlaceholders" value="true"/>
        <property name="ignoreResourceNotFound" value="true"/>
        <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE"/>
        <property name="locations">
            <list>
                <value>classpath:application.properties</value>
                <value>file:${catalina.base}/conf/Catalina/localhost/application.properties</value>
            </list>
        </property>
    </bean>

    <import resource="classpath:db-context.xml"/>
</beans>

application.properties file

The application.properties file is also mentioned in the above beans XML file. In my project, this file is located in /src/main/resources folder. This application.properties file contains the details needed to connect to MySQL database and also the Hibernate properties to make our Jersey 2 Web app be able to use Spring Data JPA and to use hibernate and persist data into MySQL database.

#Database properties:
db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/photo_app
db.username=sergey
db.password=sergey

#Hibernate Configuration:
db.hibernate.dialect=org.hibernate.dialect.MySQLDialect
db.hibernate.show_sql=true
db.entitymanager.packages.to.scan=com.appsdeveloperblog.app.ws
db.hibernate.hbm2ddl.auto=update

db-context.xml file

The location of this db-context.xml file is in /src/main/resources folder and is right next to the application.properties file.

In this file we define the:

  • dataSource bean
  • entityManagerFactory bean
  • transactionManager bean
  • we specify that our application is annotation driven
  • and we specify the base package for Spring Data JPA Repositories
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="
    http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/data/jpa
    http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${db.driver}" />
        <property name="url" value="${db.url}" />
        <property name="username" value="${db.username}" />
        <property name="password" value="${db.password}" />
    </bean>

    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="packagesToScan" value="${db.entitymanager.packages.to.scan}"/>
        <property name="persistenceProviderClass" value="org.hibernate.jpa.HibernatePersistenceProvider"/>
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.dialect">${db.hibernate.dialect}</prop>
                <prop key="hibernate.jdbc.time_zone">UTC</prop>
                <prop key="db.hibernate.show_sql">${db.hibernate.show_sql}</prop>
                <prop key="db.hibernate.hbm2ddl.auto">${db.hibernate.hbm2ddl.auto}</prop>
            </props>
        </property>
    </bean>

    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <tx:annotation-driven />

    <jpa:repositories base-package="com.appsdeveloperblog.app.ws" />
    <context:annotation-config />
</beans>

And this is all we need to do for configuration. Is it not very straightforward if you are just starting with Web Services Development and this is your first time working with Spring Framework and Jersey at the same time.

Below I will provide source code to my Root Resouce class, Service class, Entity object that needs to be persisted into MySQL database and the CrudRepository interface. I will also attach the source code to this project so that you can download it. Update the database connection details and run it to see how it works.

Root Resouce Class example

I have created only two methods here. One for creating a new user and one for returning a list of all users. It is just a sample code, so do not be too picky that I am not returning a correct Response object here and I do not handle runtime exceptions.

Since my application is annotation driven please note the annotations I used here.

package com.appsdeveloperblog.app.ws.ui.entrypoints;

import com.appsdeveloperblog.app.ws.service.impl.UserServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.appsdeveloperblog.app.ws.shared.dto.UserDto;
import com.appsdeveloperblog.app.ws.ui.model.request.SaveUserRequest;
import com.appsdeveloperblog.app.ws.ui.model.response.UserRest;
import java.util.ArrayList;
import java.util.List;

import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import org.springframework.beans.BeanUtils;
 
@Component
@Path("users")
public class UsersEntryPoint {

    @Autowired
    UserServiceImpl springService;
 
    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public List<UserRest> getAllUsers() {
       
        List<UserRest> returnValue = new ArrayList();
        List<UserDto> foundUsers = springService.getAllUsers();
        
        for(UserDto userDto:foundUsers)
        {
            UserRest userRest = new UserRest();
            BeanUtils.copyProperties(userDto, userRest);
            returnValue.add(userRest);
        }
        return returnValue;
    }

    @POST
    @Produces(MediaType.TEXT_PLAIN)
    public String save(SaveUserRequest saveUserRequest) {
       UserDto userDto = new UserDto(); 
       BeanUtils.copyProperties(saveUserRequest, userDto);
 
       springService.save(userDto);
 
       return "Ok";
    }
 
}

Service class

This class Authowires the Spring Data JPA CrudRespository interface.

package com.appsdeveloperblog.app.ws.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.appsdeveloperblog.app.ws.io.entities.UserEntity;
import com.appsdeveloperblog.app.ws.io.repositories.UserRepository;
import com.appsdeveloperblog.app.ws.service.UserService;
import com.appsdeveloperblog.app.ws.shared.dto.UserDto;
import com.appsdeveloperblog.app.ws.shared.exceptions.UserServiceException;
import java.util.ArrayList;
import java.util.List;

import javax.annotation.PostConstruct;
import org.glassfish.jersey.internal.guava.Lists;
import org.springframework.beans.BeanUtils;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    UserRepository userRepository;

    @PostConstruct
    private void init() {
    }

    @Override
    public List<UserDto> getAllUsers() {
        List<UserDto> returnValue = new ArrayList();
        
       List<UserEntity> foundRecords = Lists.newArrayList(userRepository.findAll());
       
       for(UserEntity userEntity:foundRecords)
       {
            UserDto userDto = new UserDto();
            BeanUtils.copyProperties(userEntity, userDto);
            returnValue.add(userDto);
       }
        
        return returnValue;
    }
 

    @Override
    public void save(UserDto userDto) throws UserServiceException {
   
        UserEntity userEntity = new UserEntity();
        BeanUtils.copyProperties(userDto, userEntity);
        
        // Perform needed validation and other required business logic here
        // Set other required fields like enctypted password for example
        String encryptedPassword = "encrypted password here";
        
        userEntity.setEncryptedPassword(encryptedPassword);
        
        try {
            userRepository.save(userEntity);
        } catch (Exception ex) {
            throw new UserServiceException(ex.getMessage());
        }
    }

}

Entity class

package com.appsdeveloperblog.app.ws.io.entities;

import javax.persistence.*;
 
@Entity(name = "Users")
public class UserEntity {

    @Id
    @GeneratedValue
    private Long id;

    private String firstName;
    private String lastName;
    private String email;
    private String encryptedPassword;
 

    public Long getId() {
        return id;
    }

    public UserEntity setId(Long id) {
        this.id = id;
        return this;
    }

    public String getFirstName() {
        return firstName;
    }

    public UserEntity setFirstName(String firstName) {
        this.firstName = firstName;
        return this;
    }

    public String getLastName() {
        return lastName;
    }

    public UserEntity setLastName(String lastName) {
        this.lastName = lastName;
        return this;
    }

    /**
     * @return the email
     */
    public String getEmail() {
        return email;
    }

    /**
     * @param email the email to set
     */
    public void setEmail(String email) {
        this.email = email;
    }

    /**
     * @return the encryptedPassword
     */
    public String getEncryptedPassword() {
        return encryptedPassword;
    }

    /**
     * @param encryptedPassword the encryptedPassword to set
     */
    public void setEncryptedPassword(String encryptedPassword) {
        this.encryptedPassword = encryptedPassword;
    }
}

The source code of this project

Click here to download entire project. You will need to update the database related properties to be able to successfully run this project.

Learning how to build RESTful Web Services can be a challenging process if you do not have the right educational materials. But imagine how would your confidence and life change if you knew very well how to build powerful RESTful Web Services? Below I am listing a few link that might help you on your learning journey.

Happy learning!

Learning RESTful Web Services Development