17. Exposição de uma base de dados na Web
17.1. Arquitetura do serviço Web/JSON
Iremos implementar a seguinte arquitetura:
 |
- em [1], as camadas [DAO, [JPA], JDBC] são implementadas utilizando uma das 24 configurações apresentadas nos capítulos anteriores, nomeadamente no parágrafo 15;
- a camada [DAO] [3] do cliente remoto implementa a mesma interface que a camada [DAO] [1], o que nos permite utilizar a mesma camada de teste que nos capítulos anteriores. É como se as camadas [2-3] fossem transparentes para a camada [4];
Iremos basear-nos nos seguintes projetos:
- o projeto [sgbd-config-jdbc], que configura a camada JDBC de um dos seis SGBDs;
- o projeto [sgbd-config-jpa-*], que configura a camada JPA do SGBD selecionado para uma das três implementações JPA estudadas (Hibernate, EclipseLink, OpenJpa);
- o projeto genérico [spring-jdbc-04], que implementa a camada [DAO] [1];
- o projeto genérico [spring-jpa-generic] que implementa a camada [DAO] [2];
- o projeto genérico [spring-webjson-server-jdbc-generic], que implementa um serviço web baseado no projeto [spring-jdbc-04];
- o projeto genérico [spring-webjson-server-jpa-generic], que implementa um serviço web baseado no projeto [spring-jpa-generic];
- o cliente genérico [spring-webjson-client-generic], que será o único cliente para todas as 24 configurações de serviço web;
17.2. Configurar o ambiente de desenvolvimento
Iremos trabalhar com os seguintes componentes:
- Base de dados MySQL 5.6.25;
- Implementação do Hibernate JPA;
Importe os seguintes projetos para o STS:
 |
- Os projetos [spring-webjson-*] podem ser encontrados na pasta [<examples>\spring-database-generic\spring-webjson];
- Prima [Alt-F5] e, em seguida, regenere todos os projetos acima;
Para verificar se o ambiente de desenvolvimento está instalado corretamente, proceda da seguinte forma:
- Inicie o serviço web utilizando a configuração de tempo de execução [spring-webjson-server-jpa-generic-hibernate], que depende de uma implementação JPA/Hibernate;
 |  |
depois:
- inicie o cliente para este serviço web utilizando a configuração de tempo de execução [spring-webjson-client-generic], que é um teste JUnit:
 |  |
O teste deve ser aprovado:
 |
- Em [1], pare o serviço web e, em seguida, inicie-o com a configuração de tempo de execução [spring-webjson-server-jdbc-generic], que depende de uma implementação JDBC:
 |  |
depois inicie o cliente para este serviço web com a configuração de tempo de execução [spring-webjson-client-generic]:
| |
O teste deve ser aprovado:
 |
17.3. Implementação de Serviço Web / JSON / JDBC
Vamos começar por nos concentrar na seguinte arquitetura:
 |
onde a camada [DAO] [1] comunica diretamente com a camada JDBC do SGBD.
17.3.1. O projeto Eclipse para o serviço web
O projeto Eclipse para o serviço web / JSON / JDBC é o seguinte:
 |
Trata-se de um projeto Maven cujo ficheiro [pom.xml] é o seguinte:
<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>dvp.spring.database</groupId>
<artifactId>spring-webjson-server-jdbc-generic</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-webjson-server-jdbc-generic</name>
<description>démo spring mvc</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.2.3.RELEASE</version>
</parent>
<dependencies>
<!-- web layer -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- layer [DAO] -->
<dependency>
<groupId>dvp.spring.database</groupId>
<artifactId>spring-jdbc-generic-04</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
</dependencies>
<!-- plugins -->
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.18.1</version>
</plugin>
</plugins>
</build>
</project>
- linhas 11–15: o projeto Maven pai;
- linhas 24–28: a dependência da camada [DAO / JDBC] implementada pelo projeto [spring-jdbc-generic-04];
- linhas 19–22: a dependência do artefacto [spring-boot-starter-web]. Este artefacto inclui todas as dependências necessárias para criar um serviço web / JSON. Também inclui bibliotecas desnecessárias. Seria, portanto, necessária uma configuração mais precisa, mas esta configuração é útil para começar.
As dependências introduzidas por esta configuração são as seguintes:
 |  | 1  |
- Em [1], podemos ver que o Eclipse detetou a dependência do arquivo do projeto [spring-jdbc-generic-04];
As dependências acima são tanto da camada [DAO] como da camada [web].
17.3.2. Configuração da camada [web]
A camada [web] é configurada por dois ficheiros de configuração do Spring:
 |
17.3.2.1. A classe [WebConfig]
A principal função da classe [WebConfig] é configurar:
- o servidor Tomcat no qual o serviço web será implementado;
- os filtros JSON para serializar e deserializar objetos [Product] e [Category]:
package spring.webjson.server.config;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory;
import org.springframework.boot.context.embedded.ServletRegistrationBean;
import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
@Configuration
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {
// -------------------------------- layer configuration [web]
@Autowired
private ApplicationContext context;
@Bean
public DispatcherServlet dispatcherServlet() {
DispatcherServlet servlet=new DispatcherServlet((WebApplicationContext) context);
return servlet;
}
@Bean
public ServletRegistrationBean servletRegistrationBean(DispatcherServlet dispatcherServlet) {
return new ServletRegistrationBean(dispatcherServlet, "/*");
}
@Bean
public EmbeddedServletContainerFactory embeddedServletContainerFactory() {
return new TomcatEmbeddedServletContainerFactory("", 8081);
}
// -------------------------------- configuration filters [json]
...
}
- linha 25: a classe é uma classe de configuração Spring;
- linha 26: a anotação [@EnableWebMvc] indica que a camada web é implementada utilizando o Spring MVC. Isto irá acionar configurações implícitas que não teremos de definir;
- linhas 30-31: injeção do contexto Spring da aplicação;
- linhas 33–37: definição do bean [dispatcherServlet], que, em aplicações Spring MVC, atua como o [FrontController], cuja função é encaminhar os pedidos do cliente para o controlador capaz de os processar;
- linhas 39–42: o servlet do serviço web é registado juntamente com os URLs que trata. Aqui escrevemos [/*], o que significa todos os URLs;
- Linhas 44–47: Definição do bean [embeddedServletContainerFactory], que especifica o servidor web a utilizar. Neste caso, será o servidor web Tomcat [http://tomcat.apache.org/]. Também pode utilizar o servidor Jetty [http://www.eclipse.org/jetty/]. Ambos são servidores incorporados incluídos nas dependências do Maven. Quando o [Spring Boot] inicia o lançamento do projeto, inicia automaticamente o servidor web especificado na configuração e implementa o serviço ou a aplicação web nesse servidor;
Os filtros JSON estão configurados da seguinte forma:
package spring.webjson.server.config;
import java.util.List;
...
@Configuration
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {
// -------------------------------- layer configuration [web]
...
// -------------------------------- configuration filters [json]
// mapping jSON
@Bean
public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
final MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
final ObjectMapper objectMapper = new ObjectMapper();
converter.setObjectMapper(objectMapper);
return converter;
}
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
converters.add(mappingJackson2HttpMessageConverter());
super.configureMessageConverters(converters);
}
// filters jSON
@Bean
public ObjectMapper jsonMapper(MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter) {
return mappingJackson2HttpMessageConverter.getObjectMapper();
}
@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
ObjectMapper jsonMapperShortCategorie(MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter) {
ObjectMapper jsonMapper = jsonMapper(mappingJackson2HttpMessageConverter);
jsonMapper.setFilters(new SimpleFilterProvider().addFilter("jsonFilterCategorie",
SimpleBeanPropertyFilter.serializeAllExcept("produits")));
return jsonMapper;
}
@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
ObjectMapper jsonMapperLongCategorie(MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter) {
ObjectMapper jsonMapper = jsonMapper(mappingJackson2HttpMessageConverter);
jsonMapper.setFilters(new SimpleFilterProvider().addFilter("jsonFilterCategorie",
SimpleBeanPropertyFilter.serializeAllExcept()).addFilter("jsonFilterProduit",
SimpleBeanPropertyFilter.serializeAllExcept("categorie")));
return jsonMapper;
}
@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
ObjectMapper jsonMapperShortProduit(MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter) {
ObjectMapper jsonMapper = jsonMapper(mappingJackson2HttpMessageConverter);
jsonMapper.setFilters(new SimpleFilterProvider().addFilter("jsonFilterProduit",
SimpleBeanPropertyFilter.serializeAllExcept("categorie")));
return jsonMapper;
}
@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
ObjectMapper jsonMapperLongProduit(MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter) {
ObjectMapper jsonMapper = jsonMapper(mappingJackson2HttpMessageConverter);
jsonMapper.setFilters(new SimpleFilterProvider().addFilter("jsonFilterProduit",
SimpleBeanPropertyFilter.serializeAllExcept()).addFilter("jsonFilterCategorie",
SimpleBeanPropertyFilter.serializeAllExcept("produits")));
return jsonMapper;
}
}
- Linha 8: A classe [WebConfig] estende a classe [WebMvcConfigurerAdapter]. Esta última classe configura a aplicação web com valores predefinidos. Quando se pretende personalizar esta configuração, é necessário substituir determinados métodos desta classe. Aqui, pretendemos substituir o método [configureMessageConverters] nas linhas [22–26] (repare na anotação @Override), que define uma lista de «conversores». O serviço web/JSON e o seu cliente trocam linhas de texto. Um conversor é uma ferramenta capaz de criar um objeto a partir de uma linha de texto recebida (deserialização) e de criar uma linha de texto a partir de um objeto ( ização). Aqui, as linhas de texto serão cadeias de caracteres JSON. Referir-nos-emos, portanto, à serialização/deserialização JSON;
- linha 23: o método [configureMessageConverters] recebe uma lista de conversores como parâmetro;
- Linhas 24–25: O conversor JSON [MappingJackson2HttpMessageConverter] das linhas [14–20] é adicionado a esta lista. Isto permitirá trocas de JSON entre o cliente e o servidor;
- linhas [14-20]: definem um conversor JSON implementado pela classe [MappingJackson2HttpMessageConverter]. Esta classe (linha 10) pode ser encontrada nas dependências Maven do projeto;
- linhas [17-18]: é criado um mapeador JSON e atribuído ao [MappingJackson2HttpMessageConverter];
- linhas [29-32]: definem o mapeador JSON criado na linha 17 como um bean Spring. Isto coloca-o no contexto Spring e torna-o disponível para ser injetado noutros beans ou utilizado no código da aplicação web;
- linhas 34-41: definem um filtro JSON para o mapeador JSON anterior;
- linha 35: a anotação [@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)] garante que o bean definido aqui não seja um singleton. Cada vez que for solicitado a partir do contexto, o método [jsonMapperCategoryWithoutProducts] será reexecutado. Isto é necessário aqui porque estamos a definir quatro filtros JSON. No entanto, apenas um deve estar ativo em qualquer momento. Ao atribuir ao bean o escopo [ConfigurableBeanFactory.SCOPE_PROTOTYPE], garantimos que o método será reexecutado e que o filtro anterior será substituído pelo novo;
- Para compreender estes filtros, lembre-se de que na camada [DAO]:
- a entidade [Product] foi anotada com a anotação [jsonFilterProduct];
- a entidade [Category] foi anotada com [jsonFilterCategory];
Devemos, portanto, definir filtros com estes nomes.
- linhas [34-41]: definem um filtro chamado [jsonMapperShortCategorie] que fornece a representação JSON de uma categoria sem os seus produtos;
- linhas [43-51]: definem um filtro chamado [jsonMapperLongCategory] que fornece a representação JSON de uma categoria juntamente com os seus produtos;
- linhas [53-60]: definem um filtro chamado [jsonMapperShortProduct] que fornece a representação JSON de um produto sem a sua categoria;
- linhas [62-70]: definem um filtro chamado [jsonMapperLongProduct] que fornece a representação JSON de um produto com a sua categoria;
17.3.2.2. A classe [AppConfig]
A classe [AppConfig] configura toda a aplicação, ou seja, as camadas [web] e [DAO]:
package spring.webjson.server.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
@ComponentScan(basePackages = { "spring.webjson.server.service" })
@Import({ spring.jdbc.config.AppConfig.class, WebConfig.class })
public class AppConfig {
}
- Linha 7: A classe é uma classe de configuração Spring;
- linha 9: importamos os beans da camada [DAO / JDBC], bem como aqueles definidos pela classe [WebConfig]. Todos os beans da camada [DAO] estarão, portanto, disponíveis na aplicação web/JSON;
- linha 8: especifica os pacotes onde outros beans Spring podem ser encontrados;
17.3.3. A [ServerException]
 |
Tal como nos capítulos anteriores, em que a camada [DAO] lançou uma [DaoException] não capturada, a camada [web] lançará uma [ServerException] não capturada:
package spring.webjson.server.infrastructure;
import generic.jdbc.infrastructure.UncheckedException;
public class ServerException extends UncheckedException {
private static final long serialVersionUID = 1L;
// manufacturers
public ServerException() {
super();
}
public ServerException(int code, Throwable e, String simpleClassName) {
super(code, e, simpleClassName);
}
}
- linha 5: a classe [ServerException] estende a classe [UncheckedException] definida no projeto que configura a camada JDBC (linha 3);
17.3.4. Os controladores
 |
 |
Aqui teremos dois controladores:
- [CategoryController] irá tratar dos pedidos relacionados com categorias;
- [CategorieController] irá tratar das solicitações relacionadas com produtos;
Os URLs expostos pelos controladores correspondem, numa relação de um para um, aos métodos das interfaces [DaoCategorie] e [DaoProduit] na camada [DAO]:
 |  |
Assim, como mostrado acima:
- o método web [deleteAllCategories] chamará o método [deleteAllEntities] da classe [DaoCategorie];
- O método web [getShortCategoriesById] irá chamar o método [getShortEntitiesById] da classe [DaoCategorie];
O mesmo se aplica aos produtos:
 |  |
17.3.4.1. Os URLs expostos pelo [CategoryController]
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
17.3.4.2. Os URLs expostos pelo [ProductController]
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
17.3.5. Implementação genérica do serviço web
 |
A lista de URLs expostas pelo serviço web mostra que oferecemos os mesmos tipos de URLs para a gestão de categorias e produtos. Em vez de escrever dois controladores muito semelhantes, faremos com que derivem de uma classe que irá tratar de todo o trabalho comum a ambos os controladores. Esta será a classe [AbstractController] acima. Esta classe irá implementar a seguinte interface [Iws]:
package spring.webjson.server.service;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import spring.jdbc.entities.AbstractCoreEntity;
public interface Iws<T extends AbstractCoreEntity> {
// list of all T entities
public Response<List<T>> getAllShortEntities();
public Response<List<T>> getAllLongEntities();
// special entities - short version
public Response<List<T>> getShortEntitiesById(HttpServletRequest request);
public Response<List<T>> getShortEntitiesByName(HttpServletRequest request);
// special entities - long version
public Response<List<T>> getLongEntitiesById(HttpServletRequest request);
public Response<List<T>> getLongEntitiesByName(HttpServletRequest request);
// update of several entities
public Response<List<T>> saveEntities(HttpServletRequest request);
// delete all entities
public Response<Void> deleteAllEntities();
// deletion of multiple entities
public Response<Void> deleteEntitiesById(HttpServletRequest request);
public Response<Void> deleteEntitiesByName(HttpServletRequest request);
}
Esta interface implementa os métodos da interface da camada [DAO] que serão utilizados:
package spring.jdbc.dao;
import java.util.List;
import spring.jdbc.entities.AbstractCoreEntity;
public interface IDao<T extends AbstractCoreEntity> {
// list of all T entities
public List<T> getAllShortEntities();
public List<T> getAllLongEntities();
// special entities - short version
public List<T> getShortEntitiesById(Iterable<Long> ids);
public List<T> getShortEntitiesById(Long... ids);
public List<T> getShortEntitiesByName(Iterable<String> names);
public List<T> getShortEntitiesByName(String... names);
// special entities - long version
public List<T> getLongEntitiesById(Iterable<Long> ids);
public List<T> getLongEntitiesById(Long... ids);
public List<T> getLongEntitiesByName(Iterable<String> names);
public List<T> getLongEntitiesByName(String... names);
// update of several entities
public List<T> saveEntities(Iterable<T> entities);
public List<T> saveEntities(@SuppressWarnings("unchecked") T... entities);
// delete all entities
public void deleteAllEntities();
// deletion of multiple entities
public void deleteEntitiesById(Iterable<Long> ids);
public void deleteEntitiesById(Long... ids);
public void deleteEntitiesByName(Iterable<String> names);
public void deleteEntitiesByName(String... names);
public void deleteEntitiesByEntity(Iterable<T> entities);
public void deleteEntitiesByEntity(@SuppressWarnings("unchecked") T... entities);
}
A transição da interface [IDao<T>] na camada [DAO] para a interface [Iws<T>] no serviço web seguiu estas regras:
- os métodos da interface [Iws<T>] não lançarão exceções. Se ocorrer uma exceção, esta será encapsulada no objeto [Response];
- as variações de parâmetros, tais como as linhas 45 e 47 [Iterable<String> names, String... names], são removidas. Os métodos obtêm os seus parâmetros a partir do pedido HTTP do cliente do tipo [HttpServletRequest request];
Todas as respostas do serviço web serão encapsuladas no seguinte objeto [Response]:
 |
package spring.webjson.server.service;
public class Response<T> {
// ----------------- properties
// operation status
private int status;
// an error message
private String exception;
// the body of the reply
private T body;
// manufacturers
public Response() {
}
public Response(int status, String exception, T body) {
this.status = status;
this.exception = exception;
this.body = body;
}
// getters and setters
...
}
- linha 4: a resposta encapsula um tipo T;
- linha 12: a resposta do tipo T;
- linhas 7–10: um método pode encontrar uma exceção. Neste caso, irá devolver uma resposta com:
- linha 8: status!=0;
- linha 10: uma mensagem de erro;
A classe [AbstractController] é a seguinte:
package spring.webjson.server.service;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import spring.jdbc.dao.IDao;
import spring.jdbc.entities.AbstractCoreEntity;
import spring.jdbc.infrastructure.DaoException;
import spring.webjson.server.infrastructure.ServerException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.io.CharStreams;
public abstract class AbstractController<T extends AbstractCoreEntity> implements Iws<T> {
@Autowired
protected ApplicationContext context;
// layer DAO
private IDao<T> dao;
abstract protected IDao<T> getDao();
// local
private String simpleClassName = getClass().getSimpleName();
@PostConstruct
public void init(){
dao=getDao();
}
@Override
public Response<List<T>> getAllShortEntities() {
try {
// answer
return new Response<List<T>>(0, null, dao.getAllShortEntities());
} catch (DaoException e) {
return new Response<List<T>>(1, e.toString(), null);
} catch (Exception e) {
return new Response<List<T>>(2, new ServerException(1007, e, simpleClassName).toString(), null);
}
}
@Override
public Response<List<T>> getAllLongEntities() {
try {
// answer
return new Response<List<T>>(0, null, dao.getAllLongEntities());
} catch (DaoException e) {
return new Response<List<T>>(1, e.toString(), null);
} catch (Exception e) {
return new Response<List<T>>(2, new ServerException(1008, e, simpleClassName).toString(), null);
}
}
@Override
public Response<List<T>> getShortEntitiesById(HttpServletRequest request) {
...
}
@Override
public Response<List<T>> getShortEntitiesByName(HttpServletRequest request) {
...
}
@Override
public Response<List<T>> getLongEntitiesById(HttpServletRequest request) {
...
}
@Override
public Response<List<T>> getLongEntitiesByName(HttpServletRequest request) {
...
}
@Override
public Response<List<T>> saveEntities(HttpServletRequest request) {
return new Response<List<T>>(2, new ServerException(1013, new RuntimeException("[saveEntities] not implemented"), simpleClassName).toString(), null);
}
@Override
public Response<Void> deleteAllEntities() {
try {
// we delete
dao.deleteAllEntities();
// answer
return new Response<Void>(0, null, null);
} catch (DaoException e) {
return new Response<Void>(1, e.toString(), null);
} catch (Exception e) {
return new Response<Void>(2, new ServerException(1014, e, simpleClassName).toString(), null);
}
}
@Override
public Response<Void> deleteEntitiesById(HttpServletRequest request) {
...
}
@Override
public Response<Void> deleteEntitiesByName(HttpServletRequest request) {
...
}
}
Todos os métodos são implementados da mesma forma:
- se precisam de informações, obtêm-nas a partir do objeto [HttpServletRequest request];
- chamam o método na camada [DAO] que tem o mesmo nome que eles;
- tratam quaisquer exceções que possam ocorrer, seja na operação 1 (recuperação de parâmetros) ou na operação 2 (chamada à camada [DAO]);
Vamos primeiro examinar como a camada [DAO] é injetada na classe [AbstractController]:
public abstract class AbstractController<T extends AbstractCoreEntity> implements Iws<T> {
@Autowired
protected ApplicationContext context;
// layer DAO
private IDao<T> dao;
abstract protected IDao<T> getDao();
@PostConstruct
public void init(){
dao=getDao();
}
- linha 1: a classe é abstrata e implementa a interface genérica [Iws<T>];
- linhas 3-4: injeção do contexto Spring;
- linha 7: a referência ainda desconhecida à camada [DAO] a ser utilizada;
- linha 9: o método abstrato [getDao] que irá devolver a referência à camada [DAO] a ser utilizada. Este método será substituído pela classe filha, pelo que é a classe filha que irá especificar qual a camada [DAO] a utilizar (DaoProduct ou DaoCategory);
- linha 11: a anotação [@PostConstruct] marca um método a ser executado assim que a instanciação do objeto estiver concluída. Uma vez concluída a instanciação, as injeções do Spring já foram realizadas. A classe filha terá então obtido a referência à sua camada [DAO] e poderá, portanto, passá-la à sua classe pai;
O método [getShortEntitiesById] é o seguinte:
@Override
public Response<List<T>> getShortEntitiesById(HttpServletRequest request) {
try {
// retrieve the posted value
String body = CharStreams.toString(request.getReader());
// we deserialize it
ObjectMapper mapper = context.getBean("jsonMapper", ObjectMapper.class);
List<Long> ids = mapper.readValue(body, new TypeReference<List<Long>>() {
});
// answer
return new Response<List<T>>(0, null, dao.getShortEntitiesById(ids));
} catch (DaoException e) {
return new Response<List<T>>(1, e.toString(), null);
} catch (Exception e) {
return new Response<List<T>>(2, new ServerException(1009, e, simpleClassName).toString(), null);
}
}
- linha 5: o valor enviado pelo cliente será uma cadeia JSON. É aqui que é recuperado;
- linhas 7–9: A cadeia JSON contém a lista de chaves primárias das entidades cuja versão resumida é pretendida;
- linha 11: chamamos o método [DAO] com o mesmo nome. A resposta do tipo [List<T>] é encapsulada num objeto [Response];
- linha 13: caso em que a camada [DAO] lançou uma exceção;
- linha 15: caso para outras exceções, em particular a possível exceção durante a deserialização do parâmetro JSON, linha 8;
O método [getShortEntitiesByName] é semelhante:
@Override
public Response<List<T>> getShortEntitiesByName(HttpServletRequest request) {
try {
// retrieve the posted value
String body = CharStreams.toString(request.getReader());
// we deserialize it
ObjectMapper mapper = context.getBean("jsonMapper", ObjectMapper.class);
List<String> noms = mapper.readValue(body, new TypeReference<List<String>>() {
});
// answer
return new Response<List<T>>(0, null, dao.getShortEntitiesByName(noms));
} catch (DaoException e) {
return new Response<List<T>>(1, e.toString(), null);
} catch (Exception e) {
return new Response<List<T>>(2, new ServerException(1010, e, simpleClassName).toString(), null);
}
}
- linhas 4–9: aqui, o parâmetro jSON é a lista de nomes de categorias para as quais queremos a versão curta;
O método [saveEntities] não foi implementado porque depende fortemente do tipo de entidade a ser persistida, [Category] ou [Product]. Há pouco código para refatorar. Esta tarefa é, portanto, deixada para as classes filhas.
@Override
public Response<List<T>> saveEntities(HttpServletRequest request) {
return new Response<List<T>>(2, new ServerException(1013, new RuntimeException("[saveEntities] not implemented"), simpleClassName).toString(), null);
}
17.3.6. O [CategoryController]
 |
O controlador [CategorieController] lida com URLs relacionadas com categorias:
package spring.webjson.server.service;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import spring.jdbc.dao.IDao;
import spring.jdbc.entities.Categorie;
import spring.jdbc.entities.Produit;
import spring.jdbc.infrastructure.DaoException;
import spring.webjson.server.entities.CoreCategorie;
import spring.webjson.server.entities.CoreProduit;
import spring.webjson.server.infrastructure.ServerException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.io.CharStreams;
@RestController
public class CategorieController extends AbstractController<Categorie> {
@Autowired
private IDao<Categorie> daoCategorie;
@Override
protected IDao<Categorie> getDao() {
return daoCategorie;
}
// local
private String simpleClassName = getClass().getSimpleName();
@RequestMapping(value = "/getAllShortCategories", method = RequestMethod.GET)
public Response<List<Categorie>> getAllShortCategories() {
// parent
Response<List<Categorie>> response = super.getAllShortEntities();
// serialization filters jSON
context.getBean("jsonMapperShortCategorie", ObjectMapper.class);
// answer
return response;
}
@RequestMapping(value = "/getAllLongCategories", method = RequestMethod.GET)
public Response<List<Categorie>> getAllLongCategories() {
// parent
Response<List<Categorie>> response = super.getAllLongEntities();
// serialization filters jSON
context.getBean("jsonMapperLongCategorie", ObjectMapper.class);
// answer
return response;
}
@RequestMapping(value = "/getShortCategoriesById", method = RequestMethod.POST)
public Response<List<Categorie>> getShortCategoriesById(HttpServletRequest request) {
// parent
Response<List<Categorie>> response = super.getShortEntitiesById(request);
// serialization filters jSON
context.getBean("jsonMapperShortCategorie", ObjectMapper.class);
// answer
return response;
}
@RequestMapping(value = "/getShortCategoriesByName", method = RequestMethod.POST)
public Response<List<Categorie>> getShortCategoriesByName(HttpServletRequest request) {
// parent
Response<List<Categorie>> response = super.getShortEntitiesByName(request);
// serialization filters jSON
context.getBean("jsonMapperShortCategorie", ObjectMapper.class);
// answer
return response;
}
@RequestMapping(value = "/getLongCategoriesById", method = RequestMethod.POST)
public Response<List<Categorie>> getLongCategoriesById(HttpServletRequest request) {
// parent
Response<List<Categorie>> response = super.getLongEntitiesById(request);
// serialization filters jSON
context.getBean("jsonMapperLongCategorie", ObjectMapper.class);
// answer
return response;
}
@RequestMapping(value = "/getLongCategoriesByName", method = RequestMethod.POST)
public Response<List<Categorie>> getLongCategoriesByName(HttpServletRequest request) {
// parent
Response<List<Categorie>> response = super.getLongEntitiesByName(request);
// serialization filters jSON
context.getBean("jsonMapperLongCategorie", ObjectMapper.class);
// answer
return response;
}
@RequestMapping(value = "/saveCategories", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<List<CoreCategorie>> saveCategories(HttpServletRequest request) {
...
}
@RequestMapping(value = "/deleteAllCategories", method = RequestMethod.GET)
public Response<Void> deleteAllCategories() {
return super.deleteAllEntities();
}
@RequestMapping(value = "/deleteCategoriesById", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<Void> deleteCategoriesById(HttpServletRequest request) {
return super.deleteEntitiesById(request);
}
@RequestMapping(value = "/deleteCategoriesByName", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<Void> deleteCategoriesByName(HttpServletRequest request) {
return super.deleteEntitiesByName(request);
}
}
- linha 26: a classe [CategorieController] estende a classe [AbstractController];
- linha 25: a anotação [@RestController] torna a classe um componente Spring. Esta anotação também indica que a classe é um serviço web cujos métodos enviam as suas respostas diretamente ao cliente no formato JSON;
- linhas 28–29: a referência à camada [DAO] é injetada aqui;
- linhas 31–34: redefinição do método [getDao], declarado abstrato na classe pai, cujo objetivo é devolver uma referência à camada [DAO] a ser utilizada;
Os métodos são todos construídos com base no mesmo modelo:
- delegação do processamento à classe pai;
- inicialização do mapeador JSON que irá serializar a resposta;
- envio da resposta;
Vamos dar uma olhada nas assinaturas de algumas URLs:
| - a URL [/getAllShortCategories] é chamada com um GET |
| - A URL [/getShortCategoriesById] é chamada com uma solicitação POST. O valor enviado é a string JSON contendo as chaves primárias das categorias pretendidas; |
| - A URL [/getLongCategoriesByName] é chamada com uma POST. O valor enviado é a cadeia JSON que contém os nomes das categorias desejadas; |
Agora, vamos analisar mais detalhadamente o método [saveCategories], que não segue o formato dos outros métodos:
@RequestMapping(value = "/saveCategories", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<List<CoreCategorie>> saveCategories(HttpServletRequest request) {
// we persist categories
try {
// retrieve the posted value
String body = CharStreams.toString(request.getReader());
// we deserialize it
ObjectMapper mapper = context.getBean("jsonMapperLongCategorie", ObjectMapper.class);
List<Categorie> categories = mapper.readValue(body, new TypeReference<List<Categorie>>() {
});
// we persist categories
categories = daoCategorie.saveEntities(categories);
// we return the result
List<CoreCategorie> coreCategories = new ArrayList<CoreCategorie>();
for (Categorie categorie : categories) {
CoreCategorie coreCategorie = new CoreCategorie(categorie.getId());
coreCategories.add(coreCategorie);
List<Produit> produits = categorie.getProduits();
if (produits != null) {
List<CoreProduit> coreProduits = new ArrayList<CoreProduit>();
for (Produit produit : categorie.getProduits()) {
coreProduits.add(new CoreProduit(produit.getId()));
}
coreCategorie.setCoreProduits(coreProduits);
}
}
// result
return new Response<List<CoreCategorie>>(0, null, coreCategories);
} catch (DaoException e) {
return new Response<List<CoreCategorie>>(1, e.toString(), null);
} catch (Exception e) {
return new Response<List<CoreCategorie>>(2, new ServerException(1020, e, simpleClassName).toString(), null);
}
}
- linha 1: o URL [/saveCategories] é acompanhado por um valor enviado via POST. Trata-se da string JSON que contém as versões completas das categorias a serem persistidas;
- linhas 5–10: as categorias a serem persistidas são recriadas a partir da string JSON. A ligação [product.category] que liga um [Product] à sua [Category] é nula porque, na versão longa de uma [Category], cada [Product] está na sua versão curta, sem o campo [category]. Isto não constitui um problema, uma vez que a camada [DAO] implementada com JDBC não requer esta informação;
- linha 12: as categorias são persistidas. A lista de categorias recebida foi enriquecida com as chaves primárias dos elementos persistidos, categorias e produtos. Nada mais mudou. Em vez de devolver toda a lista recebida, o que é dispendioso, devolveremos apenas as chaves primárias dos elementos desta lista. Para o fazer, utilizamos as seguintes classes [CoreCategory] e [CoreProduct]:
 |
package spring.webjson.server.entities;
import java.util.List;
public class CoreCategorie {
// primary key
private Long id;
// manufacturers
public CoreCategorie() {
}
public CoreCategorie(Long id) {
this.id=id;
}
// list of products
private List<CoreProduit> coreProduits;
// getters and setters
...
}
- linha 8: a chave primária de um produto;
- linha 20: as chaves primárias dos seus produtos;
package spring.webjson.server.entities;
public class CoreProduit {
// primary key
private Long id;
// manufacturers
public CoreProduit() {
}
public CoreProduit(Long id) {
this.id = id;
}
// getters and setters
...
}
- linha 6: a chave primária de um produto;
Voltemos ao código do método [saveCategories]:
...
// on persiste les catégories
categories = daoCategorie.saveEntities(categories);
// on rend le résultat
List<CoreCategorie> coreCategories = new ArrayList<CoreCategorie>();
for (Categorie categorie : categories) {
CoreCategorie coreCategorie = new CoreCategorie(categorie.getId());
coreCategories.add(coreCategorie);
List<Produit> produits = categorie.getProduits();
if (produits != null) {
List<CoreProduit> coreProduits = new ArrayList<CoreProduit>();
for (Produit produit : categorie.getProduits()) {
coreProduits.add(new CoreProduit(produit.getId()));
}
coreCategorie.setCoreProduits(coreProduits);
}
}
// résultat
return new Response<List<CoreCategorie>>(0, null, coreCategories);
...
- linhas 5–17: criamos a lista de objetos [CoreCategory] que iremos devolver ao cliente remoto;
- linha 19: a resposta é devolvida e serializada para JSON;
17.3.7. Tratamento de filtros JSON
Para cada método de um controlador, existem dois pontos para a serialização/desserialização JSON:
- deserialização do valor enviado: isto é tratado explicitamente aqui;
- serialização do resultado: isto é tratado implicitamente aqui;
Vamos começar pela deserialização do valor enviado em [CategorieController.saveCategories]:
@RequestMapping(value = "/saveCategories", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<List<CoreCategorie>> saveCategories(HttpServletRequest request) {
// we persist categories
try {
// retrieve the posted value
String body = CharStreams.toString(request.getReader());
// we deserialize it
ObjectMapper mapper = context.getBean("jsonMapperLongCategorie", ObjectMapper.class);
List<Categorie> categories = mapper.readValue(body, new TypeReference<List<Categorie>>() {
});
- Linha 8: Recuperamos um mapper configurado para lidar com o filtro JSON [jsonMapperLongCategorie] do contexto Spring. Voltemos à definição deste mapper na classe de configuração [WebConfig]:
// -------------------------------- configuration filters [json]
// mapping jSON
@Bean
public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
final MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
final ObjectMapper objectMapper = new ObjectMapper();
converter.setObjectMapper(objectMapper);
return converter;
}
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
converters.add(mappingJackson2HttpMessageConverter());
super.configureMessageConverters(converters);
}
// filters jSON
@Bean
public ObjectMapper jsonMapper(MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter) {
return mappingJackson2HttpMessageConverter.getObjectMapper();
}
@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
ObjectMapper jsonMapperShortCategorie(MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter) {
ObjectMapper jsonMapper = jsonMapper(mappingJackson2HttpMessageConverter);
jsonMapper.setFilters(new SimpleFilterProvider().addFilter("jsonFilterCategorie",
SimpleBeanPropertyFilter.serializeAllExcept("produits")));
return jsonMapper;
}
@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
ObjectMapper jsonMapperLongCategorie(MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter) {
ObjectMapper jsonMapper = jsonMapper(mappingJackson2HttpMessageConverter);
jsonMapper.setFilters(new SimpleFilterProvider().addFilter("jsonFilterCategorie",
SimpleBeanPropertyFilter.serializeAllExcept()).addFilter("jsonFilterProduit",
SimpleBeanPropertyFilter.serializeAllExcept("categorie")));
return jsonMapper;
}
- linhas 32–40: o mapeador JSON [jsonMapperLongCategorie] recuperado pela classe [CategorieController];
- linha 35: este mapeador é devolvido pelo método [jsonMapper] nas linhas 18–21;
- linhas 18–21: o método [jsonMapper] devolve o mapeador JSON do [MappingJackson2HttpMessageConverter] nas linhas 3–9;
Por outras palavras, o mapeador JSON recuperado pela linha 4 abaixo em [CategorieController.saveCategories]:
// on récupère la valeur postée
String body = CharStreams.toString(request.getReader());
// on la désérialise
ObjectMapper mapper = context.getBean("jsonMapperLongCategorie", ObjectMapper.class);
List<Categorie> categories = mapper.readValue(body, new TypeReference<List<Categorie>>() {
});
é o conversor padrão utilizado pelo Spring MVC para deserializar o valor enviado pelo cliente e serializar o resultado que lhe é devolvido. Nas linhas acima, não houve deserialização implícita do valor enviado. Para o fazer, teria de escrever:
@RequestMapping(value = "/saveCategories", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<List<CoreCategorie>> saveCategories(@RequestBody List<Categorie> categories) {
Neste caso, teria ocorrido uma deserialização automática do valor enviado no parâmetro [categories]. Mas havia a questão do filtro [jsonFilterCategorie] que as entidades [Categorie] possuem. Este precisa de ser configurado. É por isso que optámos pela deserialização explícita (linhas 4–5). O segundo ponto a destacar é que o mapeador na linha 4 (que é o utilizado por predefinição pelo Spring MVC) também é adequado para serializar o resultado [Response<List<CoreCategory>]. Na verdade, a entidade [CoreCategorie] não possui um filtro JSON. Portanto, não há necessidade de configurar o mapeador JSON resultante com um filtro adicional. Neste caso, a resposta enviada ao cliente será serializada implicitamente.
17.3.8. O [ProductController]
 |
O controlador [ProduitController] gere as URLs relacionadas com produtos. O seu código é semelhante ao do controlador [CategorieController]:
package spring.webjson.server.service;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import spring.jdbc.dao.IDao;
import spring.jdbc.entities.Produit;
import spring.jdbc.infrastructure.DaoException;
import spring.webjson.server.entities.CoreProduit;
import spring.webjson.server.infrastructure.ServerException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.io.CharStreams;
@RestController
public class ProduitController extends AbstractController<Produit> {
@Autowired
private IDao<Produit> daoProduit;
@Override
protected IDao<Produit> getDao() {
return daoProduit;
}
// local
private String simpleClassName = getClass().getSimpleName();
@RequestMapping(value = "/getAllShortProduits", method = RequestMethod.GET)
public Response<List<Produit>> getAllShortProduits() {
// parent
Response<List<Produit>> response = super.getAllShortEntities();
// serialization filters jSON
context.getBean("jsonMapperShortProduit", ObjectMapper.class);
// answer
return response;
}
@RequestMapping(value = "/getAllLongProduits", method = RequestMethod.GET)
public Response<List<Produit>> getAllLongProduits() {
// parent
Response<List<Produit>> response = super.getAllLongEntities();
// serialization filters jSON
context.getBean("jsonMapperLongProduit", ObjectMapper.class);
// answer
return response;
}
@RequestMapping(value = "/getShortProduitsById", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<List<Produit>> getShortProduitsById(HttpServletRequest request) {
// parent
Response<List<Produit>> response = super.getShortEntitiesById(request);
// serialization filters jSON
context.getBean("jsonMapperShortProduit", ObjectMapper.class);
// answer
return response;
}
@RequestMapping(value = "/getShortProduitsByName", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<List<Produit>> getShortProduitsByName(HttpServletRequest request) {
// parent
Response<List<Produit>> response = super.getShortEntitiesByName(request);
// serialization filters jSON
context.getBean("jsonMapperShortProduit", ObjectMapper.class);
// answer
return response;
}
@RequestMapping(value = "/getLongProduitsById", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<List<Produit>> getLongProduitsById(HttpServletRequest request) {
// parent
Response<List<Produit>> response = super.getLongEntitiesById(request);
// serialization filters jSON
context.getBean("jsonMapperLongProduit", ObjectMapper.class);
// answer
return response;
}
@RequestMapping(value = "/getLongProduitsByName", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<List<Produit>> getLongProduitsByName(HttpServletRequest request) {
// parent
Response<List<Produit>> response = super.getLongEntitiesByName(request);
// serialization filters jSON
context.getBean("jsonMapperLongProduit", ObjectMapper.class);
// answer
return response;
}
@RequestMapping(value = "/saveProduits", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<List<CoreProduit>> saveProduits(HttpServletRequest request) {
...
}
@RequestMapping(value = "/deleteAllProduits", method = RequestMethod.GET)
public Response<Void> deleteAllProduits() {
return super.deleteAllEntities();
}
@RequestMapping(value = "/deleteProduitsById", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<Void> deleteProduitsById(HttpServletRequest request) {
return super.deleteEntitiesById(request);
}
@RequestMapping(value = "/deleteProduitsByName", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<Void> deleteProduitsByName(HttpServletRequest request) {
return super.deleteEntitiesByName(request);
}
}
Apenas o método [saveProducts] tem uma estrutura diferente dos outros métodos:
@RequestMapping(value = "/saveProduits", method = RequestMethod.POST, consumes = "application/json; charset=UTF-8")
public Response<List<CoreProduit>> saveProduits(HttpServletRequest request) {
try {
// retrieve the posted value
String body = CharStreams.toString(request.getReader());
// we deserialize it
ObjectMapper mapper = context.getBean("jsonMapperShortProduit", ObjectMapper.class);
List<Produit> produits = mapper.readValue(body, new TypeReference<List<Produit>>() {
});
// we persist products
produits = daoProduit.saveEntities(produits);
List<CoreProduit> coreProduits = new ArrayList<CoreProduit>();
for (Produit produit : produits) {
coreProduits.add(new CoreProduit(produit.getId()));
}
// we return the answer
return new Response<List<CoreProduit>>(0, null, coreProduits);
} catch (DaoException e) {
return new Response<List<CoreProduit>>(1, e.toString(), null);
} catch (Exception e) {
return new Response<List<CoreProduit>>(2, new ServerException(1021, e, simpleClassName).toString(), null);
}
}
- linhas 4–9: A partir da cadeia JSON recebida, reconstruímos a lista de objetos [Product] a serem persistidos. Uma vez que a cadeia JSON recebida contém as versões curtas dos produtos, o seu campo [category] é nulo. Mais uma vez, a camada DAO/JDBC não necessita desta informação;
- linha 11: os produtos são persistidos;
- linhas 12–15: a lista de objetos [CoreProduct] a serem devolvidos é construída;
- linha 18: a resposta é devolvida, sendo serializada (serialização implícita realizada pelo Spring MVC) pelo mapeador da linha 7 antes de ser enviada ao cliente remoto (ver discussão na secção 17.3.7);
17.3.9. O serviço web / classe de execução JSON
 |
A classe [Boot] é a classe executável do projeto:
package spring.webjson.server.boot;
import org.springframework.boot.SpringApplication;
import spring.webjson.server.config.AppConfig;
public class Boot {
public static void main(String[] args) {
SpringApplication.run(AppConfig.class, args);
}
}
- Linha 10: O método estático [SpringApplication.run] é executado. A classe [SpringApplication] é uma classe do projeto [Spring Boot] (linha 3). São-lhe passados dois parâmetros:
- [AppConfig.class]: a classe que configura toda a aplicação;
- [args]: quaisquer argumentos passados para o método [main] na linha 9. Este parâmetro não é utilizado aqui;
Quando esta classe é executada, são gerados os seguintes registos:
- linhas 11-15: são detetados beans que definem filtros JSON. Estes substituem os beans com os mesmos nomes detetados no projeto de configuração da camada JDBC;
- linhas 17-18: o servidor Tomcat é iniciado para executar o serviço web/JSON;
- Linhas 19–21: O contexto Spring MVC é inicializado;
- linhas 24–43: as URLs expostas são detetadas;
17.3.10. Testar o serviço web /jSON
Para realizar os testes, utilizamos o [Advanced Rest Client] (ver secção 23.11) para consultar as URLs expostas pelo serviço web /jSON (o serviço web /jSON deve estar em execução, assim como o SGBD, claro). Para preencher a base de dados, executamos a configuração de execução denominada [spring-jdbc-generic-04-fillDataBase], que preenche a base de dados com 5 categorias e 10 produtos:
 |
 |
- Em [1-3], solicitamos o URL [/getAllLongCategories] através de uma solicitação HTTP GET;
Recebemos a seguinte resposta:
 |
- em [1], o pedido HTTP do cliente;
- em [2], a resposta HTTP do servidor;
- em [3], o estado [200 OK] indica que o servidor processou a solicitação com sucesso;
- em [4], a resposta JSON do servidor;
A resposta JSON completa é a seguinte:
{"status":0,"exception":null,"body":[{"id":1880,"version":1,"nom":"categorie[0]","produits":[{"id":9072,"version":1,"nom":"produit[0,0]","idCategorie":1880,"prix":100.0,"description":"desc[0,0]"},{"id":9073,"version":1,"nom":"produit[0,1]","idCategorie":1880,"prix":101.0,"description":"desc[0,1]"},{"id":9074,"version":1,"nom":"produit[0,2]","idCategorie":1880,"prix":102.0,"description":"desc[0,2]"},{"id":9075,"version":1,"nom":"produit[0,3]","idCategorie":1880,"prix":103.0,"description":"desc[0,3]"},{"id":9076,"version":1,"nom":"produit[0,4]","idCategorie":1880,"prix":104.0,"description":"desc[0,4]"}]},{"id":1881,"version":1,"nom":"categorie[1]","produits":[{"id":9077,"version":1,"nom":"produit[1,0]","idCategorie":1881,"prix":110.00000000000001,"description":"desc[1,0]"},{"id":9078,"version":1,"nom":"produit[1,1]","idCategorie":1881,"prix":111.00000000000001,"description":"desc[1,1]"},{"id":9079,"version":1,"nom":"produit[1,2]","idCategorie":1881,"prix":112.00000000000001,"description":"desc[1,2]"},{"id":9080,"version":1,"nom":"produit[1,3]","idCategorie":1881,"prix":112.99999999999999,"description":"desc[1,3]"},{"id":9081,"version":1,"nom":"produit[1,4]","idCategorie":1881,"prix":114.00000000000001,"description":"desc[1,4]"}]}]}
- status:0 significa que não houve erros do lado do servidor;
- exception: null significa que não há mensagem de erro;
- body: é o corpo da resposta, neste caso a lista de categorias com os seus produtos. Existem duas categorias, cada uma com 5 produtos;
Vamos adicionar o produto [product15] à categoria [category1]. Para isso, utilizaremos a URL [/saveProducts], que espera uma string JSON dos produtos a serem guardados (inserção/atualização). Esta string será a seguinte:
[{"id":null,"version":null,"nom":"produit15","idCategorie":1881,"prix":111.0,"description":"desc15"}]}]
O pedido ao serviço web / JSON é feito da seguinte forma:
 |
- em [1], o URL solicitado;
- em [2], é solicitada através de uma operação POST;
- em [3], a cadeia JSON enviada;
- em [4], o servidor é notificado de que serão enviados dados JSON;
A resposta do servidor é a seguinte:
 |
- em [1], recebemos uma lista de objetos [CoreProduct] com as suas chaves primárias. Aqui, recebemos uma lista contendo um único item com a chave primária do produto que acabámos de inserir na base de dados;
Agora, vamos solicitar a versão completa da categoria denominada [category[1]:
 |
- Em [1], a URL solicitada;
- em [2], fazemos um pedido POST;
- em [3,4], o valor enviado é uma cadeia JSON. Isto representa a lista de nomes de categorias para as quais queremos a versão longa;
Obtemos o seguinte resultado:
 |
- em [5], a categoria [category[1]] tem agora um sexto produto;
Agora vamos eliminar este produto:
 |
- Em [1], o URL solicitado;
- Em [2], fazemos uma solicitação POST;
- em [3-4], enviamos uma string JSON que representa a lista de chaves primárias dos produtos que queremos eliminar;
O resultado é o seguinte:
 |
- [status:0] indica que a eliminação foi bem-sucedida;
Agora, vamos solicitar o produto [product[1,5]] para verificar se foi realmente eliminado:
 |
Obtemos o seguinte resultado:
 |
- [status:0] indica que a operação foi concluída sem exceções;
- [body:[0]] indica que [body] é uma lista vazia. A entidade [product[1,5]] foi, portanto, eliminada com sucesso;
Todas as operações [GET] podem ser realizadas num navegador web padrão:
 |
Convidamos os leitores a testarem os outros URLs do serviço web / JSON.