Controllers com Spring MVC

Antes de começar, saiba que para conseguir implementar os códigos mostrados aqui neste post, o seu pom.xml deverá ter as seguintes dependências:

   <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.2.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.2.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.2.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.2.1.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.8.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.0.0.Final</version>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.185</version>
        </dependency>

        <!-- DataSource (HikariCP) -->
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>2.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.2.1.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

Estamos desenvolvendo um aplicativo Web de cadastro de usuários e neste post será mostrado como fazer um Controller.
O Controller, ou Controlador, é um dos pilares do MVC (Model, View e Controller), o modelos já foram discutidos no post sobre entidades e view é a camada visual do nosso aplicativo.
Esta camada é quem realiza as iterações entre os modelos e a UI (Interface com o Usuário - View), e estas iterações ocorrem tanto enviando dados da UI para os modelos, e possivelmente alterando os valores armazenados no banco. Como também envia mensagens dos modelos para a ui, alterando os valores mostrados para o usuário.
Estamos usando o SpringMVC para nos ajudar a configurar um Controller do Java.

Servlets

Com o Java podemos criar páginas Html com conteúdo dinâmico, ou seja, podemos escrever e alterar os dados que são mostrados em uma página para o usuário.

Os servlets são como pequenos servidores, que processam chamadas Html, processam a requisição e devolvem uma resposta.

Em um aplicativos Web, temos que processar as requisições Html geradas para o nossos Servlets, cada iteração do cliente, gera uma chamada Http ao nosso Servlet.

No java os Servlets extendem a classe javax.servlet.http.HttpServlet. 

Todos os controllers utilizados por nós, serão servlets, e o papel do Spring MVC aqui é nos ajudar a escrever menos código para conseguirmos processar as resquisições Html.

Configurando o web.xml

No web.xml serão configurados os servlets e os seus caminhos, assim como página inicial.

Quando desenvolvemos Servlets na mão, cada servlet precisa de uma entrada no arquivo web.xml, lá podemos definir qual classe será responsável por processar as requisições a cada caminho.

Com a utilização do Spring MVC esta configuração será realizada com annotations dentro dos Controllers.
O Spring MVC possui uma classe que escuta todas as requisições ao nosso aplicativo, e ela será responsável por direcionar estas requisições para cada um dos controllers.

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
         http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">
    <!-- Processa as requisições -->
    <servlet>
        <servlet-name>appServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        //so annotations
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>                org.springframework.web.context.support.AnnotationConfigWebApplicationContext
            </param-value>
        </init-param>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>br.unip.dsd.config.JPAConfig</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
    </servlet>

    <servlet-mapping>
        <servlet-name>appServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- Configura o arquivo padrão -->
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

</web-app>

A target <servlet> é onde definimos esta classe, ela irá processar todas as requisições e de acordo com as configurações inseridas nos controllers, elas serão direcionadas.
A classe definida como contextClass é usada quando queremos que todas as configurações dos controllers sejam feitas com anotações. Já contextConfigLocation indica a classe onde colocamos todas as configurações dos nossos beans.
Na tag servlet-mapping está configurado que o servlet irá escutar todas as requisições desde a raiz, aqui definida pela "/΅.
O arquivo de boas vindas (welcome-file) define qual será o arquivo a ser exibido assim que um usuário fizer alguma requisição ao endereço raiz do aplicativo.

Definições de Endereços dos Métodos

Para desenvolver um software, devemos definir os métodos, cada método fica responsável por realizar um tipo de operação, ou pelo menos é o que define a teoria.

Nos aplicativos Web, também temos a definição de métodos, sendo o seu nome o endereço da chamada. Porém na web somente o endereço não define um método, pois uma chamada, a um mesmo endereço pode ser realizada utilizando diferentes métodos Http. Os métodos http mais utilizados são:

• GET
• PUT
• POST
• DELETE

Não necessariamente uma chamada que utiliza o método Http DELETE irá realizar uma operação de remoção de dados, nada impede que um método de criação seja implementado com o método Http DELETE, porém isso foge aos padrões esperados. Por padrão, as chamadas GET são utilizadas para requisitar alguma informação, na forma de uma entidade, do servidor web, já uma chamada PUT envolve a submissão de dados de uma entidade, quando esta entidade já existir, deve-se assumir que uma alteração foi submetida, quando a entidade ainda não existir, deve-se assumir que uma operação de inserção está sendo realizada. 

O método POST é utilizado para a criação de recursos, ou a inserção de dados, porém ele não deve ser utilizado quando a URL em questão não existe, por exemplo que acontece em posts de blogs, ou criação de dados que geram URLs.

DELETE requer que os dados daquela URL sejam apagados.

Argumentos dos métodos

Existem algumas formas de enviar argumentos a um método Http, e a mais simples delas, geralmente utilizada em métodos GET, é passar os argumentos pelo caminho do método, como mostrado abaixo:

www.seuservico.com.br/usuario?usuario_id=1;usuario_nome=teste

No caso acima, utilizamos o nosso serviço de usuários "/usuario" e dois argumentos, usuario_id e usuario_nome.
Note que em um serviço Web, uma URI pode apontar para um dado específico, por exemplo quando o ID daquele dado faz parte de uma URL.

www.seuservico.com.br/pessoas/1

Neste caso, esta chamada contém o ID da pessoa ao final da URI e todos os métodos com esta URI referenciam a pessoa com ID=1.
Esta prática de passar argumentos pela URL é bem comum e bem simples de se construir, porém note, qualquer pessoa ou serviço, como o seu provedor de acesso a internet, podem mapear as requisições aos seus serviços e dependendo das informações que você coloca na url, dados importantes dos seus usuários podem ficar expostos, como a senha, números de documentos, etc. A recomendação aqui é utilizar este tipo de método com cautela, ou nunca usá-la.
Veja nas páginas que você acessa hoje, se o endereço da web que está no seu navegador não contém argumentos, se tiver, você pode tentar descobrir quais atributos estão sendo utilizados por ele.
Uma outra forma de se passar argumentos, é através do Body Http da sua mensagem, neste caso o seu provedor de acesso também pode mapear os atributos da sua requisição, a não ser que você esteja fazendo uma chamada Https, que será criptografada e evita esta instrospecção.

Definição do Controller

Para definir um controller utilizando o Spring MVC, basta adicionar a anotação @Controller no topo de sua classe:

@Controller
@RequestMapping("/primeiro")
public class PrimeiroController {

 @RequestMapping(method = RequestMethod.GET)
 public String imprimeOla(ModelMap model) {
   model.addAttribute("mensagem", "Olá seu primeiro MVC!");
   return "primeiro";
 }
}

Com o conttroller definido, devemos mapear quais serão os seus métodos, o que é feito pela anotação @RequestMapping. Repare que esta classe só irá processar requisições feitas ao endereço /primeiro.
O ModelMap, é uma classe que podemos passar para a nossa página jsp, e nela consultar os valores inseridos neste modelo, o que é feito com:

<@ page contentType="text/html; charset=UTF-8" >
<html>
<head>
<title> Olá MVC</title>
</head>
<body>
   <h2>${mensagem}</h2>
</body>
</html>

A nossa mensagem será mostrada na página, através do ${mensagem}. Esta é uma das formas de enviarmos dados para a nossa página jsp, repare que podemos chamar vários addAttributes no nosso model, e acessar todos eles na nossa página.
Em RequestMapping estamos definindo a qual método http aquele método irá responder, o GET.
O RequestMapping também pode ser utilizado em cada método, onde também é possível definir um caminho específico para aquele método, por exemplo:

@RequestMapping("/indice")
public String indice() {
   return "indice";
}

Ao definir este método, você estará configurando ele para ser acessado pelo caminho da classe, o que no nosso caso é /primeiro, mais indice, portanto para acessá-lo devemos:

www.seuservico.com.br/primeiro/indice