Вы находитесь на странице: 1из 9

Aplicao RESTful em Java com Jersey e MySQL

Aplicaes com arquitetura REST (Representational State Transfer) para a criao de servios web
interoperveis esto cada vez mais comuns. Uma das grandes vantagens da arquitetura REST a facilidade
de desenvolver os servios e os clientes. Um dos principais frameworks para desenvolver aplicaes REST
em Java o Jersey, que um framework que implementa todas as caractersticas da arquitetura REST.
Uma aplicao chamada de RESTful se ela segue todos os padres da arquitetura REST. Para mostrar o
desenvolvimento de uma aplicao RESTful, neste exemplo ser desenvolvido uma aplicao servidor com
trs operaes (GET, PUT e DELETE), e uma aplicao cliente para testar os servios criados. Tambm
ser utilizado um banco de dados MySQL para persistir os dados trocados entre os servios e clientes. Uma
aplicao REST tem que ser executada em um servidor, a aplicao desenvolvida neste exemplo foi testada
no Apache Tomcat 8.0.12.
Configurando o Projeto
Para exemplificar o uso do Jersey, ser construda duas aplicaes, um servidor que ser executado no
Tomcat, e uma aplicao cliente que ser executada em console. O servidor implementara as funes GET,
PUT e DELETE, que atualizara uma tabela em um banco de dados MySQL. A Listagem 1 mostra como
configurar a aplicao servidor no Maven com todas as dependncias necessrias para o projeto. As
principais dependncias do projeto servidor so o jar jersey-server que contm as classes para a
implementao do servidor REST e o jar do conector JDBC do MySQL.
Listagem 1 Configurando o projeto servidor com o Maven.
<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>com.devmedia.rest</groupId>
<artifactId>server</artifactId>
<packaging>war</packaging>
<version>0.0.1</version>
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
<dependency>
<groupId>org.glassfish.jersey.core</groupId>
<artifactId>jersey-server</artifactId>
<version>2.6</version>
</dependency>
<dependency>
<groupId>org.glassfish.jersey.containers</groupId>
<artifactId>jersey-container-servlet</artifactId>
<version>2.6</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.jaxrs</groupId>
<artifactId>jackson-jaxrs-json-provider</artifactId>
<version>2.4.1</version>
</dependency>

</dependencies>
<build>
<finalName>server</finalName>
</build>
</project>

O projeto cliente ter uma classe para testar cada um dos servios disponibilizados pelas interfaces do
REST. A Listagem 2 mostra como configurar a aplicao cliente para criar um cliente REST com o Jersey.
A principal dependncia desse projeto o jar jersey-client, que contm as classes para a implementao de
um cliente REST.
Listagem 2 Configurando o projeto cliente com o Maven.
<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.devmedia</groupId>
<artifactId>sclient</artifactId>
<version>0.0.1</version>
<dependencies>
<dependency>
<groupId>org.glassfish.jersey.core</groupId>
<artifactId>jersey-client</artifactId>
<version>2.6</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.jaxrs</groupId>
<artifactId>jackson-jaxrs-json-provider</artifactId>
<version>2.4.1</version>
</dependency>
</dependencies>
</project>

A aplicao servidor uma aplicao web que ser executada no Tomcat, para isso preciso criar o arquivo
web.xml. Nesse arquivo registrado o Servlet do Jersey, que deve interceptar todas as chamadas para os
servios, por isso foi definido que a chamada aos servios ser feita com o prefixo /rest. Tambm
necessrio registar onde as classes Java com os servios sero colocadas, no caso desse exemplo, no pacote
com.devmedia.server. A Listagem 3 mostra o arquivo web.xml do projeto servidor.
Listagem 3 Configurao do arquivo web.xml do projeto Server
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
id="WebApp_ID" version="3.0">
<display-name>com.devmedia.server</display-name>
<servlet>
<servlet-name>Jersey REST Service</servlet-name>
<servlet-class>org.glassfish.jersey.servlet.ServletContainer</servletclass>
<init-param>
<param-name>jersey.config.server.provider.packages</param-name>

<param-value>com.devmedia.server</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Jersey REST Service</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>
</web-app>

Implementao da Aplicao Servidor


A primeira coisa para comear a implementar a aplicao criar o banco de dados. A Listagem 4 mostra o
script para a criao do banco de dados DEVMEDIA, e da tabela USER. Na tabela USER sero
armazenados os dados referentes a um usurio, as colunas dessa tabela so id, que representa um
identificador para um usurio, user_name que armazenara o nome de usurio, password, que armazena uma
senha para o usurio, address, que representa o endereo do usurio e email, que armazena o e-mail do
usurio. Nessa aplicao ser utilizado o banco de dados MySQL, mas em aplicaes RESTful com o
Jersey, pode ser utilizado qualquer banco de dados que tenha um driver JDBC.
Listagem 4 SQL de criao do banco de dados.
CREATE DATABASE devmedia;
CREATE TABLE user (
id INT PRIMARY KEY,
user_name VARCHAR(30),
password VARCHAR(10),
address VARCHAR(50),
email VARCHAR(30)
);

Depois de criado o banco de dados, iniciado a implementao das classes Java, a primeira a ser criada, a
classe User, que segue o modelo do banco de dados, e que tambm representa um usurio, e tem como
atributos os mesmos dados das colunas da tabela User do banco de dados. A Listagem 5 mostra o cdigo
dessa classe.
Listagem 5 Classe POJO que ser utilizada para salvar os dados no banco.
package com.santana.easy.monitor.model;
import java.io.Serializable;
public class User implements Serializable {
private static final long serialVersionUID = -3842844978617110554L;
private
private
private
private
private

int id;
String userName;
String password;
String address;
String email;

public int getId() {


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

public String getUserName() {


return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}

O prximo passo, a criao da classe que faz a conexo com o banco de dados, para isso foi criada a classe
Connect, que implementa uma conexo bsica com JDBC, nesse exemplo, o foco mais na implementao
dos servios REST, por isso, no foi feito nada muito complexo na camada de dados, mas seria possvel
utilizar Hibernate ou qualquer outro framework de persistncia de dados.
A Listagem 6 mostra o cdigo da classe Connect, essa classe tem um atributo chamado com, que armazena
a conexo com o banco de dados. No construtor feita a conexo, utilizando a string de conexo
jdbc:mysql://localhos:3306/devmedia, que o banco de dados que foi criado anteriormente. O mtodo
closeConnection, apenas fecha a conexo criada. Alm disso, existem trs mtodos, que so os mtodos que
fazem a manipulao dos dados dos usurios, que so insertUser, getUser e deleteUser.
Listagem 6 Implementao da classe que faz a conexo com o banco de dados MySQL
package com.devmedia.database;
import
import
import
import
import
import
import

java.sql.Connection;
java.sql.DriverManager;
java.sql.PreparedStatement;
java.sql.ResultSet;
java.sql.SQLException;
java.util.logging.Level;
java.util.logging.Logger;

import com.devmedia.model.User;
public class Connect {
Connection con = null;

public
Connect()
throws
SQLException,
InstantiationException,
IllegalAccessException, ClassNotFoundException {
String url = "jdbc:mysql://localhost:3306/user";
String user = "root";
String password = "eduardo73";
Class.forName("com.mysql.jdbc.Driver").newInstance();
con = DriverManager.getConnection(url, user, password);
}
public void closeConnection() throws SQLException {
con.close();
}
public void insertUser(User user) {
try {
PreparedStatement preparedStatement = con
.prepareStatement("insert
user
(id,
password, address, email) values(?,?,?,?,?)");
preparedStatement.setInt(1, user.getId());
preparedStatement.setString(2, user.getUserName());
preparedStatement.setString(3, user.getPassword());
preparedStatement.setString(4, user.getAddress());
preparedStatement.setString(5, user.getEmail());
preparedStatement.execute();

user_name,

} catch (SQLException ex) {


Logger lgr = Logger.getLogger(Connect.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
}
}
public User getUser(int id) {
User user = null;
try {
PreparedStatement preparedStatement = con
.prepareStatement("select * from user where id =
?");
preparedStatement.setInt(1, id);
ResultSet rs = preparedStatement.executeQuery();
if (rs.next()) {
user = new User();
user.setId(rs.getInt(1));
user.setUserName(rs.getString(2));
user.setPassword(rs.getString(3));
user.setAddress(rs.getString(4));
user.setEmail(rs.getString(5));
}
} catch (SQLException ex) {
Logger lgr = Logger.getLogger(Connect.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
}
return user;
}

public void deleteUser(int id) {


try {
PreparedStatement preparedStatement = con
.prepareStatement("delete from user where id = ?");
preparedStatement.setInt(1, id);
preparedStatement.execute();
} catch (SQLException ex) {
Logger lgr = Logger.getLogger(Connect.class.getName());
lgr.log(Level.SEVERE, ex.getMessage(), ex);
}
}
}

A Listagem 7 mostra a implementao da classe que expe os mtodos como servios REST. A anotao
@Path definida na classe, indica o endereo que o servio ser acessada. O mtodo getUserHTML recebe
como parmetro um id de um usurio, e enviar como resposta um HTML com o nome do usurio. Se o
servio for acessado via um browse, esse mtodo ser executado, porque esse mtodo responde um HTML.
Alm desse mtodo existe outro mtodo que responde com um objeto do tipo User, o mtodo getUser. Para
acessar esse mtodo, necessrio indicar que se deseja acessar o mtodo com tipo de resposta
APPLICATION_JSON.
Alm dos dois mtodos GET, existe o mtodo PUT, createUser, que recebe como parmetro um objeto do
tipo User, e salva esse usurio na base de dados e o mtodo DELETE, deleteUser, que recebe como
parmetro um id, e exclui da base de dados o usurio com esse id.
Listagem 7 Servidor Rest com as operaes GET, PUT e DELETE.
package com.devmedia.server;
import java.sql.SQLException;
import
import
import
import
import
import
import
import
import

javax.ws.rs.DELETE;
javax.ws.rs.GET;
javax.ws.rs.PUT;
javax.ws.rs.Path;
javax.ws.rs.Produces;
javax.ws.rs.QueryParam;
javax.ws.rs.core.MediaType;
javax.ws.rs.core.Response;
javax.ws.rs.core.Response.Status;

import com.devmedia.database.Connect;
import com.devmedia.model.User;
@Path("/user")
public class RestUser {
@GET
@Produces(MediaType.TEXT_HTML)
public String getUserHTML(@QueryParam("id") int id) throws SQLException,
InstantiationException, IllegalAccessException, ClassNotFoundException {
Connect connect = new Connect();
User user = connect.getUser(id);
connect.closeConnection();
return "<HTML><BODY>" + user.getUserName() + "</BODY></HTML>";
}

@GET
@Produces(MediaType.APPLICATION_JSON)
public
User
getUser(@QueryParam("id")
int
id)
throws
InstantiationException, IllegalAccessException, ClassNotFoundException {
Connect connect = new Connect();
User user = connect.getUser(id);
connect.closeConnection();
return user;
}
@PUT
public
Response
createUser(User
user)
throws
InstantiationException, IllegalAccessException, ClassNotFoundException {
Connect connect = new Connect();
connect.insertUser(user);
connect.closeConnection();
return Response.status(Status.OK).build();
}
@DELETE
public Response deleteUser(@QueryParam("id") int id) throws
InstantiationException, IllegalAccessException, ClassNotFoundException {
Connect connect = new Connect();
connect.deleteUser(id);
connect.closeConnection();
return Response.status(Status.OK).build();
}
}

SQLException,

SQLException,

SQLException,

A Listagem 8 mostra a criao do cliente que acessa o servio GET do servidor desenvolvido
anteriormente. Para executar o cliente, o servidor de aplicao com o servidor deve estar sendo executado. O
primeiro passo no desenvolvimento do cliente, criar um objeto do tipo Client, depois definido o path da
requisio, no caso desse cliente, o endereo http://localhost:8080/server/rest/user. Por ultimo definido os
parmetros da requisio, no caso desse chamado, o parmetro id, e por fim feito a chamada get.
Listagem 8 Cdigo do cliente que executa as operaes GET
package com.santana.easy.manager.client;
import
import
import
import
import
import

javax.ws.rs.client.Client;
javax.ws.rs.client.ClientBuilder;
javax.ws.rs.client.Invocation;
javax.ws.rs.client.WebTarget;
javax.ws.rs.core.MediaType;
javax.ws.rs.core.Response;

import org.glassfish.jersey.client.ClientConfig;
import com.devmedia.model.User;
public class MainClientGet {
public static void main(String args[]) {
Client client = ClientBuilder.newClient();
WebTarget webTarget = client.target("http://localhost:8080/server");
WebTarget resourceWebTarget = webTarget.path("rest");
WebTarget pathdWebTarget = resourceWebTarget.path("user");
WebTarget pathdWebTargetQuery = pathdWebTarget.queryParam("id", 1);

Invocation.Builder
invocationBuilder
pathdWebTargetQuery.request(MediaType.APPLICATION_JSON_TYPE);

Response response = invocationBuilder.get();


System.out.println(response.getStatus());
User user = response.readEntity(User.class);
System.out.println(user.getId());
System.out.println(user.getUserName());
System.out.println(user.getPassword());
System.out.println(user.getAddress());
System.out.println(user.getEmail());
}
}

A Listagem 9 mostra a criao do cliente que acessa o servio PUT do servidor desenvolvido anteriormente.
O cdigo bastante parecido com o cliente anterior, a diferena que o parmetro um objeto do tipo User.
Listagem 9 Cliente que executa as operaes PUT
package com.santana.easy.manager.client;
import
import
import
import
import
import
import

javax.ws.rs.client.Client;
javax.ws.rs.client.ClientBuilder;
javax.ws.rs.client.Entity;
javax.ws.rs.client.Invocation;
javax.ws.rs.client.WebTarget;
javax.ws.rs.core.MediaType;
javax.ws.rs.core.Response;

import com.devmedia.model.User;
public class MainClientPut {
public static void main(String args[]) {
User user = new User();
user.setId(1);
user.setUserName("eduardo");
user.setPassword("1234");
user.setAddress("Rua abc");
user.setEmail("abc@abc.com");
Client client = ClientBuilder.newClient();
WebTarget webTarget = client.target("http://localhost:8080/server");
WebTarget resourceWebTarget = webTarget.path("rest");
WebTarget deleteWeb = resourceWebTarget.path("user");
Invocation.Builder deleteInvocationBuilder = deleteWeb.request();
Response putResponse = deleteInvocationBuilder.put(Entity.entity(user,
MediaType.APPLICATION_JSON_TYPE));
System.out.println(putResponse.getStatus());
System.out.println(putResponse.readEntity(String.class));
}
}

A Listagem 10 mostra a criao do cliente que acessa o servio DELETE do servidor desenvolvido
anteriormente. O cdigo bastante parecido com os dois clientes anteriores.
Listagem 10 Cliente que executa as operaes DELETE.
package com.santana.easy.manager.client;
import
import
import
import
import

javax.ws.rs.client.Client;
javax.ws.rs.client.ClientBuilder;
javax.ws.rs.client.Invocation;
javax.ws.rs.client.WebTarget;
javax.ws.rs.core.Response;

import org.glassfish.jersey.client.ClientConfig;
public class MainClientDelete {
public static void main(String args[]) {
ClientConfig clientConfig = new ClientConfig();
Client client = ClientBuilder.newClient(clientConfig);
WebTarget webTarget = client.target("http://localhost:8080/server");
WebTarget resourceWebTarget = webTarget.path("rest");
WebTarget deleteWebTarget = resourceWebTarget.path("user");
WebTarget deleteWebTargetQuery = deleteWebTarget.queryParam("id", 1);
Invocation.Builder invocationBuilder = deleteWebTargetQuery.request();
Response response = invocationBuilder.delete();
System.out.println(response.getStatus());
}
}

Este artigo mostrou como desenvolver uma aplicao RESTful com o framework Jersey em Java. Para isso
foi criado um servidor com dois mtodos GET, um mtodo PUT e um DELETE. Para testar os servios foi
criado um cliente que acessa os servios criados.
Espero que esse artigo seja til! At a prxima!