In this article, we will extend previous article and integrate with Spring & Hibernate for database interaction. In the previous article, constructed a dummy objects for web service. But here we will use Hibernate’s rich API to interact with MySql database or in general any ORM compliant database
JBoss RestEasy is a JAX-RS implementation for developing Restful web service in java. Once developed, it isn’t restricted to deploy only in JBoss Application Server but you can deploy in any other server like Apache Tomcat, Glassfish, Oracle Weblogic, etc
As we are using both XML & JSON for web service request/response, we will design XSD for our service. Then invoke the services of Maven’s JAXB plugin to generate java-sources, as this is considered standard
Note: It’s a good practice to design XSD, if one intended to use XML for web service request/response
RestEasy official documentation for Spring+RestEasy integration see here
Annotation Used
- @Path (ws.rs.Path)
- @GET (ws.rs.GET)
- @POST (ws.rs.POST)
- @PUT (ws.rs.PUT)
- @DELETE (ws.rs.DELETE)
- @PathParam (ws.rs.PathParam)
- @Consumes (ws.rs.Consumes)
- @Produces (ws.rs.Produces)
- @Service (org.springframework.stereotype.Service)
- @Repository (org.springframework.stereotype.Repository)
- MediaType (ws.rs.core.MediaType)
Technology Used
- Java 1.7
- Eclipse Luna IDE
- RestEasy-3.0.8.Final
- Spring-Framework-3.2.11.RELEASE
- Hibernate-4.2.15.Final
- Apache Maven 3.2.1
- Apache Tomcat 7.0.54
- JBoss Application Server 7.1.1.Final
- MySql-Connector-Java-5.1.32
Mavenize or download required jars
Add RestEasy-3.0.8.Final, Spring-3.2.11-Release, Hibernate-4.2.15.Final & MySql-connector-java-5.1.32 dependencies to pom.xml
<properties> <resteasy.version>3.0.8.Final</resteasy.version> <resteasy.scope>compile</resteasy.scope> <!-- compile(Tomcat) / provided(JBoss) --> <spring.version>3.2.11.RELEASE</spring.version> <!-- 4.x doesn't work with RestEasy directly --> <hibernate.version>4.2.15.Final</hibernate.version> <!-- 4.3.x doesn't work --> <mysql.version>5.1.32</mysql.version> <compileSource>1.7</compileSource> <maven.compiler.target>1.7</maven.compiler.target> <maven.compiler.source>1.7</maven.compiler.source> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <dependencies> <!-- RESTEasy JAX RS Implementation --> <dependency> <groupId>org.jboss.resteasy</groupId> <artifactId>resteasy-jaxrs</artifactId> <version>${resteasy.version}</version> <scope>${resteasy.scope}</scope> </dependency> <!-- Resteasy Servlet Container Initializer --> <dependency> <groupId>org.jboss.resteasy</groupId> <artifactId>resteasy-servlet-initializer</artifactId> <version>${resteasy.version}</version> <scope>${resteasy.scope}</scope> </dependency> <!-- Resteasy JAXB Provider --> <dependency> <groupId>org.jboss.resteasy</groupId> <artifactId>resteasy-jaxb-provider</artifactId> <version>${resteasy.version}</version> <scope>${resteasy.scope}</scope> </dependency> <!-- Resteasy Jackson Provider --> <dependency> <groupId>org.jboss.resteasy</groupId> <artifactId>resteasy-jackson-provider</artifactId> <version>${resteasy.version}</version> <scope>${resteasy.scope}</scope> </dependency> <!-- RESTEasy JAX RS Client --> <dependency> <groupId>org.jboss.resteasy</groupId> <artifactId>resteasy-client</artifactId> <version>${resteasy.version}</version> <scope>${resteasy.scope}</scope> </dependency> <!-- Resteasy Spring Integration --> <dependency> <groupId>org.jboss.resteasy</groupId> <artifactId>resteasy-spring</artifactId> <version>${resteasy.version}</version> <exclusions> <exclusion> <artifactId>commons-logging</artifactId> <groupId>commons-logging</groupId> </exclusion> <exclusion> <artifactId>jaxb-impl</artifactId> <groupId>com.sun.xml.bind</groupId> </exclusion> <exclusion> <artifactId>sjsxp</artifactId> <groupId>com.sun.xml.stream</groupId> </exclusion> <exclusion> <artifactId>jsr250-api</artifactId> <groupId>javax.annotation</groupId> </exclusion> <exclusion> <artifactId>activation</artifactId> <groupId>javax.activation</groupId> </exclusion> </exclusions> </dependency> <!-- Spring Framework 3.2.x --> <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-web</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-orm</artifactId> <version>${spring.version}</version> </dependency> <!-- Hibernate Core 4.2.x --> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>${hibernate.version}</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-ehcache</artifactId> <version>${hibernate.version}</version> </dependency> <!-- MySql-Connector --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>${mysql.version}</version> </dependency> </dependencies>
Folks who aren’t familiar with Maven concepts or don’t require maven for their project, can download the below jars individually from the central repository or maven repository and download directly from Spring site include them in the classpath
- resteasy-jaxrs
- resteasy-servlet-initializer
- resteasy-jaxb-provider
- resteasy-jackson-provider
- resteasy-client
- jaxrs-api-3.0.8.Final
- jaxb-api-2.7.7
- jaxb-core-2.7.7
- jaxb-impl-2.7.7
- jackson-core-asl-1.9.12
- jackson-mapper-asl-1.9.12
- jackson-jaxrs-1.9.12
- jackson-xc-1.9.12
- jboss-annotations-api_1.1_spec-1.0.1.Final
- jcp-annotations-1.0
- activation-1.1
- async-http-servlet-3.0-3.0.8.Final
- common-codec-1.6
- commons-io-2.1
- commons-logging-1.1.1
- httpcore-4.2.1
- httpclient-4.2.1
- jsr173_api-1.0
- FastInfoset-1.2.12
- istack-commons-runtime-2.16
- spring-core-3.2.11
- spring-context-3.2.11
- spring-aop-3.2.11
- spring-beans-3.2.11
- spring-expression-3.2.11
- spring-web-3.2.11
- spring-webmvc-3.2.11
- hibernate-core-4.2.15.Final
- hibernate-ehcache-4.2.15.Final
- mysql-connector-java-5.1.32
JAXB – Generating java source files from XSD
Steps to generate java-sources from XML Schema Definition (XSD)
- configure JAXB Maven plugin in pom.xml
- write well-defined XSD for your service
- use maven command “mvn generate-sources” to generate java source files
Configure JAXB Maven plugin
<!-- JAXB plugin to generate-sources from XSD --> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>jaxb2-maven-plugin</artifactId> <version>1.6</version> <executions> <execution> <goals> <goal>xjc</goal><!-- xjc/generate --> </goals> <configuration> <outputDirectory>${basedir}/generated/java/source</outputDirectory> <schemaDirectory>${basedir}/src/main/resources/com/resteasy/series/spring/hibernate/service/entities </schemaDirectory> <schemaFiles>*.xsd</schemaFiles> <schemaLanguage>XMLSCHEMA</schemaLanguage> <extension>true</extension> <args> <arg>-XtoString</arg> </args> <plugins> <plugin> <groupId>org.jvnet.jaxb2_commons</groupId> <artifactId>jaxb2-basics</artifactId> <version>0.6.4</version> </plugin> </plugins> </configuration> </execution> </executions> </plugin>
Customer.xsd
Below XSD contains two elements with name “CustomerType” and “CustomerListType”
- CustomerType contains three attributes namely customerId, name, age
- CustomerListType which returns list of CustomerType
<?xml version="1.0" encoding="UTF-8"?> <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" targetNamespace="http://benchresources.in/cdm/Customer" xmlns:tns="http://benchresources.in/cdm/Customer" elementFormDefault="qualified"> <!-- player object with three attributes --> <xsd:element name="CustomerType"> <xsd:complexType> <xsd:sequence> <xsd:element name="customerId" type="xsd:int" /> <xsd:element name="name" type="xsd:string" /> <xsd:element name="age" type="xsd:int" /> </xsd:sequence> </xsd:complexType> </xsd:element> <!-- an object to contain lists of players referencing above player object --> <xsd:element name="CustomerListType"> <xsd:complexType> <xsd:sequence> <xsd:element ref="tns:CustomerType" minOccurs="0" maxOccurs="unbounded" /> </xsd:sequence> </xsd:complexType> </xsd:element> </xsd:schema>
Run mvn generate-sources
Look at the generated java source files in the generated folder
CustomerType.java
package in.benchresources.cdm.customer; import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlRootElement; import javax.xml.bind.annotation.XmlType; @XmlAccessorType(XmlAccessType.FIELD) @XmlType(name = "", propOrder = { "customerId", "name", "age" }) @XmlRootElement(name = "CustomerType") public class CustomerType { protected int customerId; @XmlElement(required = true) protected String name; protected int age; public int getCustomerId() { return customerId; } public void setCustomerId(int value) { this.customerId = value; } public String getName() { return name; } public void setName(String value) { this.name = value; } public int getAge() { return age; } public void setAge(int value) { this.age = value; } }
CustomerListType.java
package in.benchresources.cdm.customer; import java.util.ArrayList; import java.util.List; import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlRootElement; import javax.xml.bind.annotation.XmlType; @XmlAccessorType(XmlAccessType.FIELD) @XmlType(name = "", propOrder = { "customerType" }) @XmlRootElement(name = "CustomerListType") public class CustomerListType { @XmlElement(name = "CustomerType") protected List<CustomerType> customerType; public List<CustomerType> getCustomerType() { if (customerType == null) { customerType = new ArrayList<CustomerType>(); } return this.customerType; } }
Directory Structure
Before moving on, let us understand the directory/package structure once you create project in Eclipse IDE
Maven has to follow certain directory structure
- src/test/java –> test related files, mostly JUnit test cases
- src/main/java –> create java source files under this folder
- src/main/resources –> all configuration files placed here
- src/test/resources –> all test related configuration files placed here
- Maven Dependencies or Referenced Libraries –> includes jars in the classpath
- WEB-INF under webapp –> stores web.xml & other configuration files related to web application
Project Structure (Package Explorer view in Eclipse)
Jars Libraries Used in the Project (Maven Dependencies)
Database: Creating table and inserting few records for this example
Create Table command
CREATE TABLE `CUSTOMER` ( `CUSTOMER_ID` INT(6) NOT NULL AUTO_INCREMENT, `NAME` VARCHAR(50) NOT NULL, `AGE` INT(3) NOT NULL, PRIMARY KEY (`CUSTOMER_ID`) );
Insert command (examples)
INSERT INTO `CUSTOMER`(`NAME`, `AGE`) VALUES ("Tom", 26); INSERT INTO `CUSTOMER`(`NAME`, `AGE`) VALUES ("Dick", 27); INSERT INTO `CUSTOMER`(`NAME`, `AGE`) VALUES ("Harry", 28); INSERT INTO `CUSTOMER`(`NAME`, `AGE`) VALUES ("Henny", 21); INSERT INTO `CUSTOMER`(`NAME`, `AGE`) VALUES ("Esbita", 19);
Web application
For any web application, entry point is web.xml which describes how the incoming http requests are served / processed. Further, it describes about the global-context and local-context param (i.e.; <context-param> & <init-param>) for loading files particular to project requirements & contains respective listener
With this introduction, we will understand how we configured web.xml for RestEasy JAX-RS Restful web service
web.xml (the entry point –> under WEB-INF)
This web.xml file describes,
- register RestEasy Bootstrap listener jboss.resteasy.plugins.server.servlet.ResteasyBootstrap and this should be at the top among all listeners
- register another listener jboss.resteasy.plugins.spring.SpringContextLoaderListener
- Like any JEE web framework register org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher with servlet container
- http requests with URL pattern “/resteasy/*” will be sent to the registered servlet called “javax.ws.rs.core.Application” i.e.; HttpServletDispatcher (org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher)
- set resteasy.servlet.mapping.prefix as <context-param>, if your servlet-mapping has a url-pattern anything other than “/*”. In this example, set “/resteasy”
- if not set, then you will end up with 404 not found error
- set resteasy.resources as <param-name> with comma delimited list of fully qualified JAX-RS resource class names you want to register as <param-value> using global <context-param>
- <welcome-file-list> files under this tag is the start-up page
web.xml
<?xml version="1.0" encoding="UTF-8"?> <web-app version="3.0" 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_3_0.xsd"> <display-name>RestEasy-Spring-Hibernate</display-name> <!-- RestEasy Bootstrap --> <listener> <listener-class>org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap</listener-class> </listener> <!-- Spring Bootstrap --> <listener> <listener-class>org.jboss.resteasy.plugins.spring.SpringContextLoaderListener</listener-class> </listener> <!-- RestEasy Servlet --> <servlet> <servlet-name>javax.ws.rs.core.Application</servlet-name> <servlet-class>org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher</servlet-class> </servlet> <servlet-mapping> <servlet-name>javax.ws.rs.core.Application</servlet-name> <url-pattern>/resteasy/*</url-pattern> </servlet-mapping> <!-- loading Spring Context for registering beans with ApplicationContext --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>WEB-INF/spring-hibernate-resteasy.xml</param-value> </context-param> <!-- this is mandatory, if url-pattern is other than /* --> <context-param> <param-name>resteasy.servlet.mapping.prefix</param-name> <param-value>/resteasy</param-value> </context-param> <!-- welcome file --> <welcome-file-list> <welcome-file>index.html</welcome-file> </welcome-file-list> </web-app>
Spring Application Context file
This Spring Application Context file describes,
- <context:annotation-config /> to activate annotation on the registered beans with application context
- <context:component-scan base-package=”” /> tag scans all classes & sub-classes under the value of base-package attribute and register them with the Spring container
- bean with id=”transactionManager” to inform spring to take care of the database transaction. All methods annotated with @Transactional
- <tx:annotation-driven /> to turn ON transaction annotation on all DAO methods
- bean with id=”sessionFactory” defines hibernate properties to let it take care of database operations using hibernate’s rich API
- bean with id=”dataSource” defines values for driverClassName, url, username and password for MySql database
- Note: injection series between transactionManager, sessionFactory and dataSource
spring-hibernate-resteasy.xml
<?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" 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-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd"> <!-- to activate annotations in beans already registered in the ApplicationContext --> <context:annotation-config /> <!-- scans packages to find and register beans within the application context --> <context:component-scan base-package="com.resteasy.series.spring.hibernate" /> <!-- turn on spring transaction annotation --> <tx:annotation-driven transaction-manager="transactionManager" /> <!-- Transaction Manager --> <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory" /> </bean> <!-- Session Factory --> <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> <property name="dataSource" ref="dataSource" /> <property name="annotatedClasses"> <list> <value>com.resteasy.series.spring.hibernate.model.Customer</value> </list> </property> <property name="hibernateProperties"> <props> <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop> <prop key="hibernate.hbm2ddl.auto">update</prop> <prop key="hibernate.show_sql">true</prop> </props> </property> </bean> <!-- dataSource configuration --> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver" /> <property name="url" value="jdbc:mysql://localhost:3306/benchresources" /> <property name="username" value="root" /> <property name="password" value="" /> </bean> </beans>
Let’s see coding in action
URL Pattern
Http url for any common web application is http://<server>:<port>/<root-context>/<from_here_application_specific_path>
In our example, we are going to deploy the war into Tomcat 7.0 server so our server and port are localhost and 8080 respectively. Context root is the project name i.e.; RestEasy-Spring-Hibernate. Initial path for this application is http://localhost:8080/RestEasy-Spring-Hibernate
We have configured “/resteasy/*” as url-pattern for the “javax.ws.rs.core.Application” servlet in web.xml and at interface-level (or say class-level) path configured is “/customerservice” using @Path annotation. Next respective path for each method annotated with @Path (method-level)
Model Class
Model class Customer with three primitive attributes with their getter/setter && no-arg constructor and 3-arg constructor
Also Hibernate POJO class is annotated describing the mapping between java property and database columns
@Entity: represents an object that can be persisted in the database and for this class should have no-arg constructor
@Table: describes which table in the database to map with this class properties
@Id: defines this is unique which means it represents primary key in the database table
@GeneratedValue: this will be taken care by hibernate to define generator sequence
@Column: tells to map this particular property to table column in the database
For example, “age” property used to map “AGE” column in the “CUSTOMER” table in the database
@Column(name= “AGE”)
private int age;
Note: we can add attributes to the @Column annotation like name, length, nullable and unique
Customer.java
package com.resteasy.series.spring.mvc.hibernate.model; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.Table; @Entity @Table(name = "CUSTOMER") public class Customer { // member variables @Id @GeneratedValue @Column(name = "CUSTOMER_ID") private int customerId; @Column(name= "NAME") private String name; @Column(name= "AGE") private int age; // default constructor public Customer() { super(); } // 3-arg parameterized-constructor public Customer(int customerId, String name, int age) { super(); this.customerId = customerId; this.name = name; this.age = age; } // getters & setters public int getCustomerId() { return customerId; } public void setCustomerId(int customerId) { this.customerId = customerId; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
Customer Service interface
Defines simple CURD operations
- @POST – create/inserts a new resource (new customer)
- @GET – read/selects internal resource representation based on the customerId
- @PUT – update/modifies an internal resource representation (modify customer)
- @DELETE – delete/removes a resource (delete customer)
- @GET – retrieves all players (get all customers)
Let’s discuss @Produces, @Consumes and MediaType
@Consumes
Defines which MIME type is consumed by this method. For this example, exposed methods supports both XML & JSON formats i.e.; methods are annotated with @Consumes({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
Note: When Content-Type is not specified in the header, then by default it expects request body in “application/x-www-form-urlencoded”. So, Content-Type needs to be set/sent in the header
@Produces
Defines which MIME type it will produce. For this example, exposed methods produce response in both XML & JSON formats i.e.; methods are annotated with @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
Note: By default, when invoked it returns the response in XML as it is the first string in the array. So, to get the response in the JSON format then set accept=”application/json” in the header
Most widely used Media Types are
- MediaType.APPLICATION_XML,
- MediaType.APPLICATION_JSON,
- MediaType.TEXT_PLAIN,
- MediaType.TEXT_XML,
- MediaType.APPLICATION_FORM_URLENCODED,
- etc
NOTE: It’s always a good programming practice to do code-to-interface and have its implementation separately
ICustomerService.java
package com.resteasy.series.spring.mvc.hibernate.service; import in.benchresources.cdm.customer.CustomerListType; import in.benchresources.cdm.customer.CustomerType; import javax.ws.rs.Consumes; import javax.ws.rs.GET; import javax.ws.rs.POST; import javax.ws.rs.Path; import javax.ws.rs.PathParam; import javax.ws.rs.Produces; import javax.ws.rs.core.MediaType; import org.springframework.web.servlet.ModelAndView; @Path("/resteasy/customerservice") public interface ICustomerService { // Basic CRUD operations for Customer Service // http://localhost:8080/RestEasy-Spring-MVC-Hibernate/resteasy/customerservice/addcustomer - Tomcat 7.0.x // http://localhost:9090/RestEasy-Spring-MVC-Hibernate/resteasy/customerservice/addcustomer - JBoss AS7 @POST @Path("addcustomer") @Consumes({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML}) @Produces({MediaType.APPLICATION_FORM_URLENCODED}) public String createOrSaveNewCustomerInfo(CustomerType customerType); // http://localhost:8080/RestEasy-Spring-MVC-Hibernate/resteasy/customerservice/getcustomer/10001 - Tomcat 7.0.x // http://localhost:9090/RestEasy-Spring-MVC-Hibernate/resteasy/customerservice/getcustomer/10001 - JBoss AS7 @GET @Path("getcustomer/{id}") @Consumes({MediaType.APPLICATION_FORM_URLENCODED}) @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML}) public CustomerType getCustomerInfo(@PathParam("id") int customerId); // http://localhost:8080/RestEasy-Spring-MVC-Hibernate/resteasy/customerservice/getallcustomer - Tomcat 7.0.x // http://localhost:9090/RestEasy-Spring-MVC-Hibernate/resteasy/customerservice/getallcustomer - JBoss AS7 @GET @Path("getallcustomer") @Consumes({MediaType.APPLICATION_FORM_URLENCODED}) @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML}) public CustomerListType getAllCustomerInfo(); // REST allows a client to select which format it prefers to receive the data in through a process called Content Negotiation. // Content Negotiation can happen through HTTP headers, URI or query parameters. // http://localhost:8080/RestEasy-Spring-MVC-Hibernate/resteasy/customerservice/viewallcustomer - Tomcat 7.0.x // http://localhost:9090/RestEasy-Spring-MVC-Hibernate/resteasy/customerservice/viewallcustomer - JBoss AS7 @GET @Path("viewallcustomer") @Produces(MediaType.TEXT_HTML) public ModelAndView viewAllCustomer(); }
Customer Service implementation
Implements above interface. JAX-RS classes should be annotated with Spring annotation like @Component or @Service
CustomerServiceImpl.java
package com.resteasy.series.spring.mvc.hibernate.service; import in.benchresources.cdm.customer.CustomerListType; import in.benchresources.cdm.customer.CustomerType; import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.web.servlet.ModelAndView; import com.resteasy.series.spring.mvc.hibernate.dao.CustomerDAO; import com.resteasy.series.spring.mvc.hibernate.model.Customer; @Component public class CustomerServiceImpl implements ICustomerService { @Autowired private CustomerDAO customerDAO; @Override public String createOrSaveNewCustomerInfo(CustomerType customerType) { Customer newCustomer = new Customer(); newCustomer.setCustomerId(customerType.getCustomerId()); newCustomer.setName(customerType.getName()); newCustomer.setAge(customerType.getAge()); return customerDAO.insertNewCustomer(newCustomer); } @Override public CustomerType getCustomerInfo(int customerId) { Customer getCustomer = customerDAO.getCustomer(customerId); CustomerType customerType = new CustomerType(); customerType.setCustomerId(getCustomer.getCustomerId()); customerType.setName(getCustomer.getName()); customerType.setAge(getCustomer.getAge()); return customerType; } @Override public CustomerListType getAllCustomerInfo() { List<Customer> lstCustomer = customerDAO.getAllCustomer(); CustomerListType customerListType = new CustomerListType(); for(Customer customer : lstCustomer){ CustomerType customerType = new CustomerType(); customerType.setCustomerId(customer.getCustomerId()); customerType.setName(customer.getName()); customerType.setAge(customer.getAge()); customerListType.getCustomerType().add(customerType); } return customerListType; } @Override public ModelAndView viewAllCustomer() { CustomerListType customerListType = getAllCustomerInfo(); return new ModelAndView("viewAllCustomer", "customerListType", customerListType); } }
DAO layer
This DAO layer takes care of the database interaction i.e.; uses Hibernate’s rich API to interact with MySql database using MySqlDialect
CustomerDAO.java
package com.resteasy.series.spring.hibernate.dao; import java.util.List; import com.resteasy.series.spring.hibernate.model.Customer; public interface CustomerDAO { public String insertNewCustomer(Customer customer); public Customer getCustomer(int customerId); public String updateCustomer(Customer customer); public String deleteCustomer(Customer customer); public List<Customer> getAllCustomer(); }
CustomerDAOImpl.java
package com.resteasy.series.spring.hibernate.dao; import java.util.List; import org.hibernate.SessionFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.Transactional; import com.resteasy.series.spring.hibernate.model.Customer; @Repository("customerDAO") public class CustomerDAOImpl implements CustomerDAO { @Autowired private SessionFactory sessionFactory; public SessionFactory getSessionFactory() { return sessionFactory; } public void setSessionFactory(SessionFactory sessionFactory) { this.sessionFactory = sessionFactory; } @Override @Transactional public String insertNewCustomer(Customer customer) { // inserts into database & return customerId (primary_key) int customerId = (Integer) sessionFactory.getCurrentSession().save(customer); return "Customer information saved successfully with Customer_ID " + customerId; } @Override @Transactional public Customer getCustomer(int customerId) { // retrieve customer based on the id supplied in the formal argument Customer customer = (Customer) sessionFactory.getCurrentSession().get(Customer.class, customerId); return customer; } @Override @Transactional public String updateCustomer(Customer customer) { // update database with customer information and return success msg sessionFactory.getCurrentSession().update(customer); return "Customer information updated successfully"; } @Override @Transactional public String deleteCustomer(Customer customer) { // delete customer information and return success msg sessionFactory.getCurrentSession().delete(customer); return "Customer information deleted successfully"; } @SuppressWarnings("unchecked") @Override @Transactional public List<Customer> getAllCustomer() { // get all customer info from database List<Customer> lstCustomer = sessionFactory.getCurrentSession().createCriteria(Customer.class).list(); return lstCustomer; } }
Deployment
- Run maven command to build the war: mvn clean install (use command prompt or integrated maven in eclipse IDE
- Copy the war file from the target folder
- Paste it into apache tomcat (webapps folder)
- Start the tomcat server
Test the service !!
Testing
There are many ways to do testing
- Copy the URL of GET service into web browser
- Advanced REST client from Google Chrome
- Rest client in Mozilla Firefox Add On
- Write your own client for example, Java client using improved CloseableHttpClient from Apache
- JDK’s in-built classes like HttpURLConnection
- Using Client, WebTarget from core JAX-RS classes javax.ws.rs.client
- Using ResteasyClient, ResteasyWebTarget and Response classes from JBoss package org.jboss.resteasy.client
- Using ClientRequest and ClientResponse classes from JBoss package org.jboss.resteasy.client
1. Using RestClient from Mozilla Firefox Add-On
Every service tested setting up header parameters “accept” & “Content-Type” in the request. First for JSON format and then XML format
First service: @POST (createOrSaveNewCustomerInfo())
URL: http://localhost:8080/RestEasy-Spring-Hibernate/resteasy/customerservice/addcustomer
Request:
{ "customerId": 11, "name": "Karthick", "age": 24 }
Content-Type: application/json
Accept: application/x-www-form-urlencoded
Response: Customer information saved successfully with Customer_ID 11
Request:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <CustomerType xmlns="http://benchresources.in/cdm/Customer"> <customerId>12</customerId> <name>Shoaib</name> <age>32</age> </CustomerType>
Content-Type: application/xml
Accept: application/x-www-form-urlencoded
Response: Customer information saved successfully with Customer_ID 12
Second service: @GET (getCustomerInfo())
URL: http://localhost:8080/RestEasy-Spring-Hibernate/resteasy/customerservice/getcustomer/10
Request: None
Content-Type: application/x-www-form-urlencoded
Accept: application/json
Response:
{ "customerId": 10, "name": "Jerry", "age": 25 }
Request: None
Content-Type: application/x-www-form-urlencoded
Accept: application/xml
Response:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <CustomerType xmlns="http://benchresources.in/cdm/Customer"> <customerId>10</customerId> <name>Jerry</name> <age>25</age> </CustomerType>
2. Java client (RestEasy)
There are two test clients which comes from JBoss RestEasy package org.jboss.resteasy.client and org.jboss.resteasy.client.jaxrs
- ClientRequest and ClientResponse for invoking getCustomerInfo service
- ResteasyClient, ResteasyClientBuilder and ResteasyWebTarget for invoking addCustomerInfo service
Self-explanatory !!
Note: above clients can be interchanged. No restriction, only needs to set correct http request parameters or header values
TestCustomerService.java
package test.resteasy.series.spring.hibernate.service; import javax.ws.rs.HttpMethod; import javax.ws.rs.client.Entity; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import org.jboss.resteasy.client.ClientRequest; import org.jboss.resteasy.client.ClientResponse; import org.jboss.resteasy.client.jaxrs.ResteasyClient; import org.jboss.resteasy.client.jaxrs.ResteasyClientBuilder; import org.jboss.resteasy.client.jaxrs.ResteasyWebTarget; public class TestCustomerService { public static void main(String[] args) throws Exception { // setting & invoking first service getCustomer/12 System.out.println("Invoking and executing getCustomer service for customer id 12"); String httpGetURL = "http://localhost:8080/RestEasy-Spring-Hibernate/resteasy/customerservice/getcustomer/12"; String responseStringGet = testCustomerServiceForGetRequest(httpGetURL); System.out.println("GET >> Response String : " + responseStringGet); // setting & invoking second service addCustomer with XML request System.out.println("\n\nInvoking and executing addCustomer service with request"); String httpPostURL = "http://localhost:8080/RestEasy-Spring-Hibernate/resteasy/customerservice/addcustomer"; String requestStringInXml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" + "<CustomerType xmlns=\"http://benchresources.in/cdm/Customer\">" + "<customerId>13</customerId>" + "<name>Benton</name>" + "<age>19</age>" + "</CustomerType>"; String responseStringPost = testCustomerServiceForPostRequest(httpPostURL, requestStringInXml); System.out.println("POST >> Response String : " + responseStringPost); } /** * using ClientRequest and ClientResponse classes from org.jboss.resteasy.client * @param httpURL * @return responseString * @throws Exception */ @SuppressWarnings("deprecation") public static String testCustomerServiceForGetRequest(String httpURL) throws Exception { // local variables ClientRequest clientRequest = null; ClientResponse<String> clientResponse = null; int responseCode; String responseString = null; try{ clientRequest = new ClientRequest(httpURL); clientRequest.setHttpMethod(HttpMethod.GET); clientRequest.header("Content-Type", MediaType.APPLICATION_FORM_URLENCODED); clientRequest.accept(MediaType.APPLICATION_XML); clientResponse = clientRequest.get(String.class); responseCode = clientResponse.getResponseStatus().getStatusCode(); System.out.println("Response code: " + responseCode); if(clientResponse.getResponseStatus().getStatusCode() != 200) { throw new RuntimeException("Failed with HTTP error code : " + responseCode); } System.out.println("ResponseMessageFromServer: " + clientResponse.getResponseStatus().getReasonPhrase()); responseString = clientResponse.getEntity(); } catch(Exception ex) { ex.printStackTrace(); } finally{ // release resources, if any clientResponse.close(); clientRequest.clear(); } return responseString; } /** * using ResteasyClient, ResteasyWebTarget and Response classes from org.jboss.resteasy.client * @param httpURL * @param requestString * @return */ public static String testCustomerServiceForPostRequest(String httpURL, String requestString) throws Exception { // local variables ResteasyClient resteasyClient = null; ResteasyWebTarget resteasyWebTarget = null; Response response = null; int responseCode; String responseString = null; try{ resteasyClient = new ResteasyClientBuilder().build(); resteasyWebTarget = resteasyClient.target(httpURL); // resteasyWebTarget.property("Content-Type", MediaType.APPLICATION_FORM_URLENCODED); // resteasyWebTarget.property("accept", MediaType.APPLICATION_XML); response = resteasyWebTarget.request(MediaType.APPLICATION_FORM_URLENCODED).post(Entity.entity(requestString, MediaType.APPLICATION_XML)); responseCode = response.getStatus(); System.out.println("Response code: " + responseCode); if (response.getStatus() != 200) { throw new RuntimeException("Failed with HTTP error code : " + responseCode); } System.out.println("ResponseMessageFromServer: " + response.getStatusInfo().getReasonPhrase()); responseString = response.readEntity(String.class); } catch(Exception ex){ ex.printStackTrace(); } finally{ // release resources, if any response.close(); } return responseString; } }
Output in console
Response code: 200 ResponseMessageFromServer: OK GET >> Response String : <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <CustomerType xmlns="http://benchresources.in/cdm/Customer"> <customerId>12</customerId> <name>Shoaib</name> <age>32</age> </CustomerType> Invoking and executing addCustomer service with request Response code: 200 ResponseMessageFromServer: OK POST >> Response String : Customer information saved successfully with Customer_ID 13
Download project (Tomcat Server 7.0.x)
RestEasy-Spring-Hibernate(Tomcat server) (16kB)
JBoss Deployment
- Update pom.xml with resteasy scope “provided” for dependencies as JBoss AS7 modules already contains these dependent jars
<resteasy.scope>provided</resteasy.scope> <!-- compile(Tomcat) / provided(JBoss) -->
- Update web.xml
web.xml<?xml version="1.0" encoding="UTF-8"?> <web-app version="3.0" 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_3_0.xsd"> <display-name>RestEasy-Spring-Hibernate</display-name> <!-- RestEasy Bootstrap --> <listener> <listener-class>org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap</listener-class> </listener> <!-- Spring Bootstrap --> <listener> <listener-class>org.jboss.resteasy.plugins.spring.SpringContextLoaderListener</listener-class> </listener> <!-- RestEasy Servlet --> <servlet-mapping> <servlet-name>javax.ws.rs.core.Application</servlet-name> <url-pattern>/resteasy/*</url-pattern> </servlet-mapping> <!-- loading Spring Context for registering beans with ApplicationContext --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>WEB-INF/spring-hibernate-resteasy.xml</param-value> </context-param> <!-- welcome file --> <welcome-file-list> <welcome-file>index.html</welcome-file> </welcome-file-list> </web-app>
- Rest remain the same
- Read through this article which explains development & deployment of RestEasy web service with JBoss Application Server in detail
Note: JBoss Application Server 7.1.1.Final comes with default RestEasy distribution with version 2.3.2.Final. So update JBoss AS7 with latest RestEasy version. Look at this article, which explains how to update default version with latest version available in the JBoss community
Download project (JBoss Application Server 7.1.1.Final)
RestEasy-Spring-Hibernate (JBoss server) (16kB)
Conclusion: Example went through in this article is almost an enterprise application with services exposed using RestEasy JAX-RS web service and later integrating service/DAO layer with Hibernate (ORM) for database interaction
Happy Coding !!
Happy Learning !!