RESTEasy CRUD tutorial

last modified January 10, 2023

RESTEasy CRUD tutorial shows how to create a JAX-RS CRUD example with RESTEasy.

RESTEasy

RESTEasy is a Java framework for developing RESTful Web Services. It is a fully certified and portable implementation of the JAX-RS 2.0 specification. JAX-RS 2.0 specification is a JCP (Java Community Process) specification that provides a Java API for RESTful Web Services over the HTTP protocol.

RESTEasy can run in any Servlet container.

JAX-RS HTTP annotations

JAX-RS has annotations for responding to HTTP requests.

@GET - indicates that the annotated method responds to HTTP GET request
@POST - indicates that the annotated method responds to HTTP POST request
@DELETE - indicates that the annotated method responds to HTTP DELETE request
@PUT - indicates that the annotated method responds to HTTP PUT request

RESTEasy CRUD example

The following example is a simple RESTful CRUD application. Create, Read, Update, and Delete (CRUD) are the four basic functions of persistent storage.

The data is loaded at the start of the application in a web listener. There are two scripts: the schema.sql creates the table and the data.sql inserts data into the table.

$ tree
.
├── nb-configuration.xml
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── com
    │   │       └── zetcode
    │   │           ├── conf
    │   │           │   ├── AppConfig.java
    │   │           │   └── MyAppInitializer.java
    │   │           ├── dao
    │   │           │   ├── CityDao.java
    │   │           │   └── ICityDao.java
    │   │           ├── model
    │   │           │   └── City.java
    │   │           ├── resource
    │   │           │   └── MyResource.java
    │   │           └── service
    │   │               ├── CityService.java
    │   │               └── ICityService.java
    │   ├── resources
    │   │   └── sql
    │   │       ├── data.sql
    │   │       └── schema.sql
    │   └── webapp
    │       ├── META-INF
    │       │   └── context.xml
    │       └── WEB-INF
    │           └── beans.xml
    └── test
        └── java

This is the project structure.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zetcode</groupId>
    <artifactId>RestEasyLoadScripts</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>RestEasyLoadScripts</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>

        <!-- Set up RESTEasy-->
        <dependency>
            <groupId>org.jboss.resteasy</groupId>
            <artifactId>resteasy-jaxrs</artifactId>
            <version>3.1.4.Final</version>
        </dependency>

        <dependency>
            <groupId>org.jboss.resteasy</groupId>
            <artifactId>resteasy-servlet-initializer</artifactId>
            <version>3.1.4.Final</version>
        </dependency>

        <dependency>
            <groupId>org.jboss.resteasy</groupId>
            <artifactId>resteasy-jackson-provider</artifactId>
            <version>3.1.4.Final</version>
        </dependency>

        <!-- CDI for RESTEasy-->
        <dependency>
            <groupId>org.jboss.resteasy</groupId>
            <artifactId>resteasy-cdi</artifactId>
            <version>3.1.4.Final</version>
        </dependency>

        <dependency>
            <groupId>org.jboss.weld.servlet</groupId>
            <artifactId>weld-servlet-shaded</artifactId>
            <version>3.0.2.Final</version>
        </dependency>

        <!-- Spring JdbcTemplate -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.0.3.RELEASE</version>
        </dependency>

        <!-- H2 driver -->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.196</version>
        </dependency>

        <!-- Needed for @WebListener -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.0</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>

        </plugins>
    </build>

</project>

This is the Maven POM file. It contains dependencies for RESTEasy, CDI for RESTEasy, Jackson provider, H2 driver, Spring JdbcTemplate, and Java Servlets (for web listeners).

context.xml

<?xml version="1.0" encoding="UTF-8"?>
<Context path="/RestEasyCrud"/>

In the Tomcat's context.xml configuration file, we define the application context path.

beans.xml

<?xml version="1.0"?>
<beans xmlns="http://xmlns.jcp.org/xml/ns/javaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/beans_1_1.xsd"
       version="1.1" bean-discovery-mode="all">

</beans>

Applications that use CDI must have a beans.xml file defined. It can be empty, like in our case. For web applications, the beans.xml file must be in the WEB-INF directory. For EJB modules or JAR files, the beans.xml file must be in the META-INF directory.

schema.sql

CREATE TABLE cities(id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100), population INT);

The schema.sql creates a database schema.

data.sql

INSERT INTO cities(name, population) VALUES('Bratislava', 432000);
INSERT INTO cities(name, population) VALUES('Budapest', 1759000);
INSERT INTO cities(name, population) VALUES('Prague', 1280000);
INSERT INTO cities(name, population) VALUES('Warsaw', 1748000);
INSERT INTO cities(name, population) VALUES('Los Angeles', 3971000);
INSERT INTO cities(name, population) VALUES('New York', 8550000);
INSERT INTO cities(name, population) VALUES('Edinburgh', 464000);
INSERT INTO cities(name, population) VALUES('Berlin', 3671000);

The data.sql inserts data into the database table.

AppConfig.java

package com.zetcode.conf;

import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;

@ApplicationPath("rest")
public class AppConfig extends Application {

}

This is the application configuration class. The Application defines the components of a JAX-RS application and supplies additional meta-data.

@ApplicationPath("rest")

With the @ApplicationPath annotation, we set the path to RESTful web services.

MyAppInitializer.java

package com.zetcode.conf;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import org.springframework.jdbc.datasource.SimpleDriverDataSource;

@WebListener
public class MyAppInitializer implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {

        Logger lgr = Logger.getLogger(MyAppInitializer.class.getName());
        lgr.log(Level.INFO, "executing contextInitialized()");

        String url = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;"
                + "INIT=RUNSCRIPT FROM 'classpath:/sql/schema.sql'"
                + "\\;RUNSCRIPT FROM 'classpath:/sql/data.sql'";

        SimpleDriverDataSource ds = new SimpleDriverDataSource();
        ds.setDriver(new org.h2.Driver());
        ds.setUrl(url);

        try (Connection con = ds.getConnection()) {

        } catch (SQLException ex) {
            lgr.log(Level.SEVERE, ex.getMessage(), ex);
        }
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
    }
}

The database scripts are initialized in a web listener.

@WebListener
public class MyAppInitializer implements ServletContextListener {

The @WebListener annotation is used to declare a web listener.

@Override
public void contextInitialized(ServletContextEvent sce) {

The ServletContextListener's contextInitialized method is called when the web application initialization starts.

String url = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;"
        + "INIT=RUNSCRIPT FROM 'classpath:/sql/schema.sql'"
        + "\\;RUNSCRIPT FROM 'classpath:/sql/data.sql'";

In this connection string URL, we create an in-memory database called testdb. The DB_CLOSE_DELAY keeps the content of an in-memory database as long as the virtual machine is alive. Otherwise, the database is deleted when the connection is closed. The RUNSCRIPT command executes the database scripts.

SimpleDriverDataSource ds = new SimpleDriverDataSource();
ds.setDriver(new org.h2.Driver());
ds.setUrl(url);

We set up a SimpleDriverDataSource. It is a simple data source that does not support connection pooling. It creates a new connection for each call.

try (Connection con = ds.getConnection()) {

} catch (SQLException ex) {
    lgr.log(Level.SEVERE, ex.getMessage(), ex);
}

The database scripts are executed when the connection is created.

City.java

package com.zetcode.model;

import java.util.Objects;

public class City {

    private Long id;
    private String name;
    private int population;

    public City() {
    }

    public City(String name, int population) {
        this.name = name;
        this.population = population;
    }

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPopulation() {
        return population;
    }

    public void setPopulation(int population) {
        this.population = population;
    }

    @Override
    public int hashCode() {
        int hash = 3;
        hash = 71 * hash + Objects.hashCode(this.id);
        hash = 71 * hash + Objects.hashCode(this.name);
        hash = 71 * hash + this.population;
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final City other = (City) obj;
        if (this.population != other.population) {
            return false;
        }
        if (!Objects.equals(this.name, other.name)) {
            return false;
        }
        return Objects.equals(this.id, other.id);
    }

    @Override
    public String toString() {

        StringBuilder builder = new StringBuilder();
        builder.append("City{id=").append(id).append(", name=")
                .append(name).append(", population=")
                .append(population).append("}");

        return builder.toString();
    }
}

This is a City model class. It contains three attributes: id, name, and population.

ICityService.java

package com.zetcode.service;

import com.zetcode.model.City;
import java.util.List;

public interface ICityService {

    public List<City> findAll();

    public boolean save(City city);

    public City find(Long id);

    public boolean update(City city, Long id);

    public boolean delete(Long id);
}

ICityService contains the CRUD contract methods. We have methods for finding cities, saving a city, updating a city, and deleting a city.

CityService.java

package com.zetcode.service;

import com.zetcode.dao.ICityDao;
import com.zetcode.model.City;
import java.util.List;
import javax.inject.Inject;

public class CityService implements ICityService {

    @Inject
    private ICityDao cityDao;

    @Override
    public List<City> findAll() {

        return cityDao.findAll();
    }

    @Override
    public boolean save(City city) {

        return cityDao.save(city);
    }

    @Override
    public City find(Long id) {

        return cityDao.find(id);
    }

    @Override
    public boolean update(City city, Long id) {

        return cityDao.update(city, id);
    }

    @Override
    public boolean delete(Long id) {

        return cityDao.delete(id);
    }
}

CityService contains the implementation for the service methods. It delegates the actual job to the CityDao.

ICityDao.java

package com.zetcode.dao;

import com.zetcode.model.City;
import java.util.List;

public interface ICityDao {

    public List<City> findAll();

    public boolean save(City city);

    public City find(Long id);

    public boolean update(City city, Long id);

    public boolean delete(Long id);
}

The ICityDao contains the contract methods.

CityDao.java

package com.zetcode.dao;

import com.zetcode.conf.AppConfig;
import com.zetcode.model.City;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.SimpleDriverDataSource;

public class CityDao implements ICityDao {

    @Override
    public List<City> findAll() {

        SimpleDriverDataSource ds = new SimpleDriverDataSource();
        ds.setDriver(new org.h2.Driver());
        ds.setUrl("jdbc:h2:mem:testdb");

        List<City> cities = new ArrayList<>();

        String query = "SELECT * FROM cities;";

        try {
            JdbcTemplate jtm = new JdbcTemplate(ds);
            cities = jtm.query(query,
                    new BeanPropertyRowMapper(City.class));
        } catch (DataAccessException dae) {
            Logger lgr = Logger.getLogger(CityDao.class.getName());
            lgr.log(Level.SEVERE, dae.getMessage(), dae);
        }

        return cities;
    }

    @Override
    public boolean save(City city) {

        SimpleDriverDataSource ds = new SimpleDriverDataSource();
        ds.setDriver(new org.h2.Driver());
        ds.setUrl("jdbc:h2:mem:testdb");

        String sql = "INSERT INTO cities(name, population) VALUES (?, ?)";

        boolean ret = true;

        try {
            JdbcTemplate jtm = new JdbcTemplate(ds);
            jtm.update(sql, new Object[]{city.getName(),
                city.getPopulation()});

        } catch (DataAccessException dae) {
            Logger lgr = Logger.getLogger(CityDao.class.getName());
            lgr.log(Level.SEVERE, dae.getMessage(), dae);

            ret = false;
        }

        return ret;
    }

    @Override
    public City find(Long id) {

        SimpleDriverDataSource ds = new SimpleDriverDataSource();
        ds.setDriver(new org.h2.Driver());
        ds.setUrl("jdbc:h2:mem:testdb");

        String sql = "SELECT * FROM cities WHERE Id=?";

        City city = new City();

        try {
            JdbcTemplate jtm = new JdbcTemplate(ds);
            city = (City) jtm.queryForObject(sql, new Object[]{id},
                    new BeanPropertyRowMapper(City.class));
        } catch (DataAccessException dae) {
            Logger lgr = Logger.getLogger(CityDao.class.getName());
            lgr.log(Level.SEVERE, dae.getMessage(), dae);
        }

        return city;
    }

    @Override
    public boolean update(City city, Long id) {

        SimpleDriverDataSource ds = new SimpleDriverDataSource();
        ds.setDriver(new org.h2.Driver());
        ds.setUrl("jdbc:h2:mem:testdb");

        boolean ret = true;

        String sql = "UPDATE cities SET name=?, population=? WHERE Id=?";

        try {
            JdbcTemplate jtm = new JdbcTemplate(ds);
            int nOfRows = jtm.update(sql, new Object[]{city.getName(),
                city.getPopulation(), id});
            if (nOfRows != 1) {
                ret = false;
            }
        } catch (DataAccessException dae) {
            Logger lgr = Logger.getLogger(CityDao.class.getName());
            lgr.log(Level.SEVERE, dae.getMessage(), dae);
            ret = false;
        }

        return ret;
    }

    @Override
    public boolean delete(Long id) {

        SimpleDriverDataSource ds = new SimpleDriverDataSource();
        ds.setDriver(new org.h2.Driver());
        ds.setUrl("jdbc:h2:mem:testdb");

        boolean ret = true;

        String sql = "DELETE FROM cities WHERE Id=?";
        try {
            JdbcTemplate jtm = new JdbcTemplate(ds);
            int nOfRows = jtm.update(sql, new Object[]{id});
            if (nOfRows != 1) {
                ret = false;
            }
        } catch (DataAccessException dae) {
            Logger lgr = Logger.getLogger(CityDao.class.getName());
            lgr.log(Level.SEVERE, dae.getMessage(), dae);
            ret = false;
        }

        return ret;
    }
}

CityDao cointains the implementation of the ICityDao methods.

SimpleDriverDataSource ds = new SimpleDriverDataSource();
ds.setDriver(new org.h2.Driver());
ds.setUrl("jdbc:h2:mem:testdb");

SimpleDriverDataSource is used to build a data source for the in-memory H2 database.

JdbcTemplate jtm = new JdbcTemplate(ds);
cities = jtm.query(query,
        new BeanPropertyRowMapper(City.class));

Spring's JdbcTemplate is used to execute queries and other JDBC statements.

} catch (DataAccessException dae) {
    Logger lgr = Logger.getLogger(CityDao.class.getName());
    lgr.log(Level.SEVERE, dae.getMessage(), dae);
}

Spring's DataAccessException is thrown for all kinds of JDBC exceptions

@Override
public boolean save(City city) {

The save method, as well as the update and delete methods, return a boolean value indicating whether the task completed OK. This is used for determining the status code of the response.

MyResource.java

package com.zetcode.resource;

import com.zetcode.model.City;
import com.zetcode.service.ICityService;
import java.util.List;
import javax.inject.Inject;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.FormParam;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

@Path("cities")
public class MyResource {

    @Inject
    private ICityService cityService;

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public Response getCities() {

        List<City> cities = cityService.findAll();

        if (!cities.isEmpty()) {

            return Response.ok(cities).build();
        } else {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
    }

    @Path("/{id}")
    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public Response findCity(@PathParam("id") Long id) {

        City city = cityService.find(id);

        if (city.getId() != null) {
            return Response.ok(city).build();
        } else {
            return Response.status(Response.Status.NOT_FOUND).build();
        }
    }

    @POST
    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
    public Response saveCity(@FormParam("name") String name,
            @FormParam("population") int population) {

        City city = new City();
        city.setName(name);
        city.setPopulation(population);

        boolean r = cityService.save(city);

        if (r) {
            return Response.ok().status(Response.Status.CREATED).build();
        } else {
            return Response.notModified().build();
        }
    }

    @Path("/{id}")
    @PUT
    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
    public Response updateCity(@FormParam("name") String name,
            @FormParam("population") int population,
            @PathParam("id") Long id) {

        City city = new City();
        city.setName(name);
        city.setPopulation(population);

        boolean r = cityService.update(city, id);

        if (r) {
            return Response.ok().status(Response.Status.NO_CONTENT).build();
        } else {
            return Response.notModified().build();
        }
    }

    @Path("/{id}")
    @DELETE
    @Produces(MediaType.APPLICATION_JSON)
    public Response deleteCity(@PathParam("id") Long id) {

        boolean r = cityService.delete(id);

        if (r) {
            return Response.ok().status(Response.Status.NO_CONTENT).build();
        } else {
            return Response.notModified().build();
        }
    }
}

This is the MyResource class.

@Path("cities")
public class MyResource {

The @Path specifies the URL to which the resource responds.

@Inject
private ICityService cityService;

With the @Inject annotation, we inject the city service object into the cityService field.

@GET
@Produces(MediaType.APPLICATION_JSON)
public Response getCities() {

The @GET annotation indicates that the annotated method responds to HTTP GET requests. With the @Produces annotation, we define that the method produces JSON.

List<City> cities = cityService.findAll();

if (!cities.isEmpty()) {

    return Response.ok(cities).build();
} else {
    return Response.status(Response.Status.NOT_FOUND).build();
}

We call the findAll service method and return a list of all cities. On success, we return data with Response.ok(cities).build If the service method does not find any data, we return Response.Status.NOT_FOUND.

@Path("/{id}")
@GET
@Produces(MediaType.APPLICATION_JSON)
public Response findCity(@PathParam("id") Long id) {

For finding a particular city by its Id, we have a path parameter with @Path("/{id}"). The id is retrieved with @PathParam("id") annotation.

@POST
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
public Response saveCity(@FormParam("name") String name,
        @FormParam("population") int population) {

When creating a new resource, we use the @POST annotation. With the @Consumes(MediaType.APPLICATION_FORM_URLENCODED) we set that the saveCity receives enconded data from the body of the request. The data from the body request is retrieved with the @FormParam annotation.

return Response.ok().status(Response.Status.CREATED).build();

For a newly created resource, we send back Response.Status.CREATED.

@Path("/{id}")
@PUT
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
public Response updateCity(@FormParam("name") String name,
        @FormParam("population") int population,
        @PathParam("id") Long id) {

To modify a resource, we use the @PUT annotation. The Id of the resource is retrieved from the path, the modified data from the body of the request.

@Path("/{id}")
@DELETE
@Produces(MediaType.APPLICATION_JSON)
public Response deleteCity(@PathParam("id") Long id) {

To delete a resource, we use the @DELETE annotation.

return Response.ok().status(Response.Status.NO_CONTENT).build();

The Response.Status.NO_CONTENT can be used for resource updating and deletion.

$ curl localhost:8084/RestEasyCrud/rest/cities/ -i
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Content-Type: application/json
Content-Length: 383
Date: Mon, 19 Feb 2018 12:19:24 GMT

[{"id":1,"name":"Bratislava","population":432000},
{"id":2,"name":"Budapest","population":1759000},
{"id":3,"name":"Prague","population":1280000},
{"id":4,"name":"Warsaw","population":1748000},
{"id":5,"name":"Los Angeles","population":3971000},
{"id":6,"name":"New York","population":8550000},
{"id":7,"name":"Edinburgh","population":464000},
{"id":8,"name":"Berlin","population":3671000}]

We get all the cities with a GET request.

$ curl -X POST -d name=Kiev -d population=2877000 localhost:8084/RestEasyCrud/rest/cities/ -i
HTTP/1.1 201 Created
Server: Apache-Coyote/1.1
Content-Length: 0
Date: Mon, 19 Feb 2018 12:21:25 GMT

We create a new city resource with a POST request.

$ curl -X DELETE localhost:8084/RestEasyCrud/rest/cities/1 -i
HTTP/1.1 204 No Content
Server: Apache-Coyote/1.1
Date: Mon, 19 Feb 2018 12:23:20 GMT

We delete a resource with a DELETE request.

$ curl localhost:8084/RestEasyCrud/rest/cities/ -i
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Content-Type: application/json
Content-Length: 428
Date: Mon, 19 Feb 2018 12:24:42 GMT

We modify a resource with a PUT request.

In this tutorial, we have created a CRUD RESTFul application with RESTEasy and H2 database. We used Spring's JdbcTemplate to connect to H2. The application was deployed on Tomcat.

Ebooks

RESTEasy CRUD tutorial

RESTEasy

JAX-RS HTTP annotations

RESTEasy CRUD example