15. [TD]: Criação de um cliente para o serviço web

Palavras-chave: arquitetura multicamadas, Spring, injeção de dependências, serviço web / JSON, cliente / servidor

15.1. Suporte

Os projetos para este capítulo podem ser encontrados na pasta [support / chap-15].

15.2. A arquitetura cliente/servidor

Queremos criar a seguinte arquitetura cliente/servidor:

A camada [ui] será a que já foi desenvolvida nas secções 9 e 10. Isto será possível porque a camada [business] acima implementará a mesma interface [IElectionsMetier] que a camada [business] da secção 8:

package elections.client.metier;
 
import elections.client.entities.ListeElectorale;

public interface IElectionsMetier {
 
    // get the lists in competition
    public ListeElectorale[] getListesElectorales();
 
    // the number of seats to be filled
    public int getNbSiegesAPourvoir();
 
    // the electoral threshold
    public double getSeuilElectoral();
 
    // recording results
    public void recordResultats(ListeElectorale[] listesElectorales);
 
    // calculating seats
    public ListeElectorale[] calculerSieges(ListeElectorale[] listesElectorales);
 
}

Na Secção 7, a camada [DAO] trocava dados com um SGBD. Aqui, a camada [DAO] troca dados com um servidor web / JSON.

Inicialmente, iremos concentrar-nos na seguinte arquitetura:

15.3. O Projeto Eclipse

O projeto Eclipse é o seguinte:

Esta estrutura é idêntica à do projeto de exemplo da Secção 13.6.1. Seguiremos a mesma abordagem.

15.4. Configuração do Maven

Esta é a descrita na Secção 13.6.2.

15.5. Implementação da camada [DAO]

• O pacote [elections.client.config] contém a configuração Spring para a camada [DAO];
• O pacote [elections.client.dao] contém a implementação da camada [DAO];
• o pacote [elections.client.entities] contém os objetos trocados com o serviço web / JSON;
• O pacote [elections.client.business] contém a camada [business]
• O pacote [elections.client.ui] contém a camada [UI]

15.5.1. Configuração da camada [business]

A classe [MetierConfig] gere a configuração Spring da camada [business]. O seu código é o seguinte:

package elections.client.config;
 
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Scope;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
 
import com.fasterxml.jackson.databind.ObjectMapper;
 
@ComponentScan({ "elections.client.dao","elections.client.metier" })
public class MetierConfig {
 
    // constants
    static private final int TIMEOUT = 1000;
    static private final String URL_WEBJSON = "http://localhost:8080";
 
    @Bean
    public RestTemplate restTemplate(int timeout) {
        // creation of the RestTemplate component
        HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
        RestTemplate restTemplate = new RestTemplate(factory);
        // exchange timeout
        factory.setConnectTimeout(timeout);
        factory.setReadTimeout(timeout);
        // result
        return restTemplate;
    }
 
    @Bean
    public int timeout() {
        return TIMEOUT;
    }
 
    @Bean
    public String urlWebJson() {
        return URL_WEBJSON;
    }
 
    // mapper jSON
    @Bean
    @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public ObjectMapper jsonMapper() {
        return new ObjectMapper();
    }
}

Este código foi explicado na Secção 13.6.3.1. É mais simples porque não há filtros JSON para gerir aqui.

15.5.2. As entidades

As entidades tratadas pelas camadas [DAO] e [business] são aquelas que são trocadas com o serviço web / JSON. Trata-se de objetos do tipo [ElectionsConfig] e [VoterList]. No lado do servidor, estas entidades tinham anotações de persistência JPA. Aqui, essas anotações foram removidas. Estamos a incluir novamente o código da entidade para referência:

[Entidade abstrata]

package spring.webjson.client.entities;
 
 
public abstract class AbstractEntity {
    // properties
    protected Long id;
    protected Long version;
 
    // manufacturers
    public AbstractEntity() {
 
    }
 
    public AbstractEntity(Long id, Long version) {
        this.id = id;
        this.version = version;
    }
 
    // redefine [equals] and [hashcode]
    @Override
    public int hashCode() {
        return (id != null ? id.hashCode() : 0);
    }
 
    @Override
    public boolean equals(Object entity) {
        if (!(entity instanceof AbstractEntity)) {
            return false;
        }
        String class1 = this.getClass().getName();
        String class2 = entity.getClass().getName();
        if (!class2.equals(class1)) {
            return false;
        }
        AbstractEntity other = (AbstractEntity) entity;
        return id != null && this.id == other.id.longValue();
    }
 
    // getters and setters
    ...
}

[ElectionsConfig]

package elections.webjson.client.entities;
 
 
public class ElectionsConfig extends AbstractEntity {
 
    // fields
    private int nbSiegesAPourvoir;
    private double seuilElectoral;
 
    // manufacturers
    public ElectionsConfig() {
 
    }
 
    public ElectionsConfig(int nbSiegesAPourvoir, double seuilElectoral) {
        this.nbSiegesAPourvoir = nbSiegesAPourvoir;
        this.seuilElectoral = seuilElectoral;
    }
 
    // getters and setters
    ...
}

[ListaDeVotantes]

package elections.webjson.client.entities;
 
 
public class ListeElectorale extends AbstractEntity {
 
    // fields
    private String nom;
    private int voix;
    private int sieges;
    private boolean elimine;
 
    // manufacturers
    public ListeElectorale() {
    }
 
    public ListeElectorale(String nom, int voix, int sieges, boolean elimine) {
        setNom(nom);
        setVoix(voix);
        setSieges(sieges);
        setElimine(elimine);
    }
 
    // getters and setters
    ...
}

15.5.3. A interface da camada [DAO]

A camada [DAO] possui a seguinte interface [IClientDao]:

package elections.client.dao;
 
public interface IClientDao {
 
    // generic request
    String getResponse(String url, String jsonPost);
 
}

A interface tem apenas um método [getResponse]:

• o primeiro parâmetro é a URL do servidor a consultar;
• o segundo parâmetro é o valor JSON a ser enviado, nulo se não houver nada para enviar;
• o resultado é a cadeia JSON de um objeto [Response<T>], em que a classe [Response] foi descrita na Secção 14.7;

15.5.4. Implementação da comunicação com o serviço web / JSON

A classe [ClientDao] implementa a interface [IClientDao] da seguinte forma:

package elections.client.dao;
 
import java.net.URI;
import java.net.URISyntaxException;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.MediaType;
import org.springframework.http.RequestEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
 
import elections.client.entities.ElectionsException;
 
@Component
public class ClientDao implements IClientDao {
 
    // data
    @Autowired
    protected RestTemplate restTemplate;
    @Autowired
    protected String urlServiceWebJson;
 
    // generic request
    @Override
    public String getResponse(String url, String jsonPost) {
 
        try {
            // url : URL to contact
            // jsonPost: the jSON value to be posted
 
            // request execution
            RequestEntity<?> request;
            if (jsonPost != null) {
                // query POST
                request = RequestEntity.post(new URI(String.format("%s%s", urlServiceWebJson, url)))
                        .header("Content-Type", "application/json").accept(MediaType.APPLICATION_JSON).body(jsonPost);
            } else {
                // query GET
                request = RequestEntity.get(new URI(String.format("%s%s", urlServiceWebJson, url)))
                        .accept(MediaType.APPLICATION_JSON).build();
            }
            // execute the query
            return restTemplate.exchange(request, new ParameterizedTypeReference<String>() {
            }).getBody();
        } catch (URISyntaxException e1) {
            throw new ElectionsException(200, e1);
        } catch (RuntimeException e2) {
            throw new ElectionsException(201, e2);
        }
    }
}

Este código é descrito na secção 13.6.3.6.

15.6. Implementação da camada [de negócios]

Como mencionado, a camada [de negócios] tem a mesma interface [IElectionsMetier] que na secção 8.4:

package elections.client.metier;
 
import elections.client.entities.ListeElectorale;
 
public interface IElectionsMetier {
 
    // get the lists in competition
    public ListeElectorale[] getListesElectorales();
 
    // the number of seats to be filled
    public int getNbSiegesAPourvoir();
 
    // the electoral threshold
    public double getSeuilElectoral();
 
    // recording results
    public void recordResultats(ListeElectorale[] listesElectorales);
 
    // calculating seats
    public ListeElectorale[] calculerSieges(ListeElectorale[] listesElectorales);
 
}

Esta interface é implementada pela seguinte classe [ElectionsMetier]:

package elections.client.metier;
 
import java.util.ArrayList;
import java.util.List;
 
import javax.annotation.PostConstruct;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
 
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
 
import elections.client.dao.IClientDao;
import elections.client.entities.ElectionsConfig;
import elections.client.entities.ElectionsException;
import elections.client.entities.ListeElectorale;
 
@Component
public class ElectionsMetier implements IElectionsMetier {
 
    @Autowired
    private IClientDao dao;
    @Autowired
    private ApplicationContext context;
 
    // election configuration
    private ElectionsConfig electionsConfig;
 
    @PostConstruct
    public void init() {
        // mappers jSON
        ObjectMapper mapperResponse = context.getBean(ObjectMapper.class);
        try {
            // request
            Response<ElectionsConfig> response = mapperResponse.readValue(dao.getResponse("/getElectionsConfig", null),
                    new TypeReference<Response<ElectionsConfig>>() {
                    });
            // mistake?
            if (response.getStatus() != 0) {
                // 1 exception is thrown
                throw new ElectionsException(response.getStatus(), response.getMessages());
            } else {
                electionsConfig = response.getBody();
            }
        } catch (ElectionsException e1) {
            throw e1;
        } catch (Exception e2) {
            throw new ElectionsException(100, getMessagesForException(e2));
        }
    }
 
    @Override
    public ListeElectorale[] getListesElectorales() {
        ...
    }
 
    @Override
    public int getNbSiegesAPourvoir() {
        return electionsConfig.getNbSiegesAPourvoir();
    }
 
    @Override
    public double getSeuilElectoral() {
        return electionsConfig.getSeuilElectoral();
    }
 
    @Override
    public void recordResultats(ListeElectorale[] listesElectorales) {
    ...
    }
 
    @Override
    public ListeElectorale[] calculerSieges(ListeElectorale[] listesElectorales) {
...
    }
 
    // list of exception error messages
    private List<String> getMessagesForException(Exception exception) {
        // retrieve the list of exception error messages
        Throwable cause = exception;
        List<String> erreurs = new ArrayList<String>();
        while (cause != null) {
            // the message is retrieved only if it is !=null and not blank
            String message = cause.getMessage();
            if (message != null) {
                message = message.trim();
                if (message.length() != 0) {
                    erreurs.add(message);
                }
            }
            // next cause
            cause = cause.getCause();
        }
        return erreurs;
    }
}
 

O tipo [Resposta] utilizado na linha 37 é a resposta do servidor web/JSON descrita na secção 14.7;

---

Tarefa: Seguindo a secção 13.6.3.7, complete a classe [ElectionsMetier];

---

15.7. O teste JUnit

Voltemos à arquitetura cliente/servidor atualmente em construção:

A camada [JUnit] [1] comunica com a camada [Business] do servidor [5] através das camadas [2–4]. Ao garantir que as camadas [Business] [2] e [5] têm a mesma interface, tornamos as camadas [2–4] transparentes. A camada [1] parece comunicar diretamente com a camada [5]. O ponto interessante é que em [1] poderemos utilizar o teste JUnit que foi utilizado para testar a camada [Business] [5].

---

Tarefa: Execute o teste JUnit do projeto para verificar a sua implementação tanto do servidor como do cliente.

---

15.8. Implementação da camada [UI]

Voltemos à arquitetura que queremos construir:

Agora que a camada [Negócio] [2] foi construída e testada, podemos construir a camada [IU] [1].

Uma vez que a interface [IElectionsMetier] da camada [Business] é idêntica à do projeto descrito no parágrafo 8, podemos [3] copiar o projeto da camada [UI] do parágrafo 10. Este projeto era um projeto NetBeans. Basta copiar e colar as classes Java relevantes do NetBeans para o Eclipse. Depois de feito isto, há alguns ajustes de pacotes e importações a efetuar.

Faremos o mesmo para as classes executáveis no pacote [elections.client.boot] [4].

A classe [AbstractBootElections] é a seguinte:

package elections.client.boot;
 
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
import elections.client.config.UiConfig;
import elections.client.entities.ElectionsException;
import elections.client.ui.IElectionsUI;
 
public abstract class AbstractBootElections {
 
    // spring context retrieval
    protected AnnotationConfigApplicationContext ctx;
 
    public void run() {
        // instantiation layer [ui]
        IElectionsUI electionsUI = null;
        try {
            // spring context retrieval
            ctx = new AnnotationConfigApplicationContext(UiConfig.class);
            // ui] layer recovery
            electionsUI = getUI();
 
...

• Linha 19: O contexto Spring definido pela classe de configuração [UiConfig] é instanciado. Esta classe é a seguinte:

A classe [UiConfig] é a seguinte:

package elections.client.config;
 
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;
 
@Import(MetierConfig.class)
@ComponentScan(basePackages = { "elections.client.ui" })
public class UiConfig {
}

• Linha 6: Importa os beans da camada [business];
• Linha 7: Indicamos que existem beans Spring no pacote [elections.client.ui];

---

Tarefa: Verifique se as versões de consola e Swing da camada [ui] estão a funcionar.

---