RESTEasy H2 tutorial
last modified January 10, 2023
RESTEasy H2 tutorial shows how to use H2 database in a RESTful web application created 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. It contains a rich set of providers, such as XML, JSON, YAML, Fastinfoset, Multipart, XOP, and Atom.
H2
H2 is a relational database management system written in Java. It can be embedded in Java applications or run in the client-server mode. It can be used also in a memory mode.
RESTEasy H2 example
The following example is a simple RESTful application, which returns the version of the H2 database. To connect to a database and execute a query, we use Spring's JdbcTemplate, which is a Java library on top of plain JDBC.
$ tree
.
├── nb-configuration.xml
├── pom.xml
└── src
├── main
│ ├── java
│ │ └── com
│ │ └── zetcode
│ │ ├── conf
│ │ │ └── AppResConfig.java
│ │ ├── resource
│ │ │ └── MyResource.java
│ │ └── service
│ │ └── VersionService.java
│ ├── resources
│ └── webapp
│ └── META-INF
│ └── context.xml
└── test
└── java
This is the project structure.
<?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>RestEasyH2</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<name>RestEasyH2</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>
<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.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.0.3.RELEASE</version>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.4.196</version>
</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, H2, and Spring JdbcTemplate.
<?xml version="1.0" encoding="UTF-8"?> <Context path="/RestEasyH2"/>
In the Tomcat's context.xml configuration file, we define
the application context path.
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.
package com.zetcode.service;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.SimpleDriverDataSource;
public class VersionService {
public static String getVersion() {
SimpleDriverDataSource ds = new SimpleDriverDataSource();
ds.setDriver(new org.h2.Driver());
ds.setUrl("jdbc:h2:mem:");
String sql = "SELECT H2VERSION()";
JdbcTemplate jtm = new JdbcTemplate(ds);
String version = jtm.queryForObject(sql, String.class);
return version;
}
}
VersionService connects to the H2 database created in memory and
returns its version.
SimpleDriverDataSource ds = new SimpleDriverDataSource();
ds.setDriver(new org.h2.Driver());
ds.setUrl("jdbc:h2:mem:");
We create a simple data source. With jdbc:h2:mem: URL string, we create
an in-memory private database for one connection only. The database is closed when
the connection to the database is closed.
String sql = "SELECT H2VERSION()";
This SQL statement returns the version of H2.
JdbcTemplate jtm = new JdbcTemplate(ds); String version = jtm.queryForObject(sql, String.class);
We use Spring JdbcTemplate to execute the sql query.
package com.zetcode.resource;
import com.zetcode.service.VersionService;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
@Path("version")
public class MyResource {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String message() {
String h2Version = VersionService.getVersion();
String message = String.format("H2 version: %s", h2Version);
return message;
}
}
This is the MyResource class.
@Path("version")
public class MyResource {
With the @Path annotation, we specify the URL to which
the resource responds.
@GET
@Produces(MediaType.TEXT_PLAIN)
public String message() {
String h2Version = VersionService.getVersion();
String message = String.format("H2 version on Tomcat 9: %s", h2Version);
return message;
}
The @GET annotation indicates that the annotated method responds to
HTTP GET requests. With the @Produces annotation, we define that
the method produces plain text. We call a service method and return a message
string.
$ curl localhost:8080/RestEasyH2/rest/version H2 version: 1.4.196
After the application is deployed on Tomcat, we send a GET request to the
application with curl. We get the version of H2 database.
In this tutorial, we have created a simple RESTFul application with RESTEasy and H2 database. We used Spring's JdbcTemplate to connect to H2. The application was deployed on Tomcat.
