Perguntas da entrevista do Spring MVC

Spring MVC implements a clear separation of concerns that allows us to develop and unit test our applications easily.

Os conceitos como:

são completamente independentes um do outro e são responsáveis ​​por apenas uma coisa.

Portanto,MVC gives us quite big flexibility. É baseado em interfaces (com classes de implementação fornecidas) e podemos configurar cada parte da estrutura usando interfaces personalizadas.

Another important thing is that we aren’t tied to a specific view technology (for example, JSP), but we have the option to choose from the ones we like the most.

Além disso,we don’t use Spring MVC only in web applications development but in the creation of RESTful web services as well.

The @Autowired annotation can be used with fields or methods for injecting a bean by type. Essa anotação permite que o Spring resolva e injete beans colaborativos no seu bean.

Para obter mais detalhes, consulte o tutorial sobre@Autowired in Spring.

A anotação@ModelAttribute é uma das anotações mais importantes no Spring MVC. It binds a method parameter or a method return value to a named model attribute and then exposes it to a web view.

Se o usarmos no nível do método, isso indica que o objetivo desse método é adicionar um ou mais atributos de modelo.

Por outro lado, quando usado como argumento de método, indica que o argumento deve ser recuperado do modelo. Quando não estiver presente, devemos instanciar e depois adicioná-lo ao modelo. Uma vez presente no modelo, devemos preencher os campos de argumentos de todos os parâmetros de solicitação que possuem nomes correspondentes.

Mais sobre esta anotação pode ser encontrado em nossoarticle related to the @ModelAttribute annotation.

A principal diferença entre as anotações@Controller e@RestController é quethe @ResponseBody annotation is automatically included in the @RestController. Isso significa que não precisamos anotar nossos métodos de tratamento com@ResponseBody. Precisamos fazer isso em uma classe@Controller se quisermos escrever o tipo de resposta diretamente no corpo da resposta HTTP.

We can use the @PathVariable annotation as a handler method parameter in order to extract the value of a URI template variable.

Por exemplo, se quisermos buscar um usuário por id dewww.mysite.com/user/123, devemos mapear nosso método no controlador como/user/{id}:

The @PathVariable has only one element named value. It’s optional and we use it to define the URI template variable name. Se omitirmos o elemento value, o nome da variável do modelo de URI deve corresponder ao nome do parâmetro do método.

Também é permitido ter várias anotações@PathVariable, declarando-as uma após a outra:

ou colocá-los todos emMap<String, String> ouMultiValueMap<String, String>:

Spring MVC supports JSR-303 specifications by default. We need to add JSR-303 and its implementation dependencies to our Spring MVC application. O Hibernate Validator, por exemplo, é uma das implementações do JSR-303 à nossa disposição.

JSR-303 é uma especificação da API Java para validação de bean, parte de JavaEE e JavaSE, que garante que as propriedades de um bean atendam a critérios específicos, usando anotações como@NotNull,@Min e@Max. Mais sobre validação está disponível no artigoJava Bean Validation Basics.

Spring offers the @Validator annotation and the BindingResult class. A implementação deValidator gerará erros no método do manipulador de solicitação do controlador quando houver dados inválidos. Então, podemos usar a classeBindingResult para obter esses erros.

Além de usar as implementações existentes, podemos criar nossas próprias. Para fazer isso, criamos uma anotação em conformidade com as especificações JSR-303 primeiro. Em seguida, implementamos a classeValidator. Outra maneira seria implementar a interfaceValidator do Spring e defini-la como o validador por meio da anotação@InitBinder na classeController.

Para verificar como implementar e usar suas próprias validações, consulte o tutorial sobreCustom Validation in Spring MVC.

The @RequestBody annotation, used as a handler method parameter, binds the HTTP Request body to a transfer or a domain object. O Spring desserializa automaticamente a Solicitação HTTP de entrada para o objeto Java usando Conversores de Mensagens Http.

When we use the @ResponseBody annotation on a handler method in the Spring MVC controller, it indicates that we’ll write the return type of the method directly to the HTTP response body. Não o colocaremos emModel, e o Spring não interpretará como um nome de visualização.

Consulte o artigo em@RequestBody and @ResponseBody para ver mais detalhes sobre essas anotações.

The Model interface defines a holder for model attributes. The ModelMap has a similar purpose, with the ability to pass a collection of values. Em seguida, trata esses valores como se estivessem dentro deMap. Devemos observar que emModel (ModelMap) podemos apenas armazenar dados. Colocamos dados e retornamos um nome de exibição.

Por outro lado,with the ModelAndView, we return the object itself. Definimos todas as informações necessárias, como os dados e o nome da visualização, no objeto que estamos retornando.

Você pode encontrar mais detalhes no artigo emModel, ModelMap, and ModelView.

The @SessionAttributes annotation is used for storing the model attribute in the user’s session. Nós o usamos no nível da classe do controlador, conforme mostrado em nosso artigo sobreSession Attributes in Spring MVC:

No exemplo anterior, o atributo de modelo ‘todos’ será adicionado à sessão se@ModelAttributee@SessionAttributes tiverem o mesmo atributo de nome.

If we want to retrieve the existing attribute from a session that is managed globally, we’ll use @SessionAttribute annotation as a method parameter:

The @EnableWebMvc annotation’s purpose is to enable Spring MVC via Java configuration. É equivalente a<mvc: annotation-driven> em uma configuração XML. Esta anotação importa a configuração Spring MVC deWebMvcConfigurationSupport. Ele permite o suporte para classes anotadas em@Controller que usam@RequestMapping para mapear solicitações de entrada para um método de manipulador.

Você pode aprender mais sobre esta e outras anotações semelhantes em nossoGuide to the Spring @Enable Annotations.

The ViewResolver enables an application to render models in the browser - sem vincular a implementação a uma tecnologia de exibição específica -by mapping view names to actual views.

Para obter mais detalhes sobreViewResolver, dê uma olhada em nossoGuide to the ViewResolver in Spring MVC.

BindingResult is an interface from org.springframework.validation package that represents binding results. We can use it to detect and report errors in the submitted form. É fácil de invocar - só precisamos garantir que o colocamos como um parâmetro logo após o objeto de formulário que estamos validando. O parâmetro opcionalModel deve vir depois deBindingResult, como pode ser visto emcustom validator tutorial:

When Spring sees the @Valid annotation, it’ll first try to find the validator for the object being validated. Em seguida, ele pegará as anotações de validação e chamará o validador. Finalmente, ele colocará os erros encontrados emBindingResulte adicionará o último ao modelo de visualização.

The form backing object or a Command Object is just a POJO that collects data from the form we’re submitting.

Devemos ter em mente que ele não contém nenhuma lógica, apenas dados.

Para aprender a usar o objeto de apoio do formulário com os formulários no Spring MVC, dê uma olhada em nosso artigo sobreForms in Spring MVC.

It is used simultaneously with the @Autowired annotation to avoid confusion when multiple instances of a bean type are present.

Vamos ver um exemplo. Declaramos dois beans semelhantes na configuração XML:

Quando tentamos conectar o bean, obteremos umorg.springframework.beans.factory.NoSuchBeanDefinitionException.. Para consertar, precisamos usar@Qualifier para informar ao Spring sobre qual bean deve ser conectado:

A anotação@Required é usada em métodos setter e indica que a propriedade do bean que possui essa anotação deve ser preenchida no momento da configuração. Caso contrário, o contêiner Spring lançará uma exceçãoBeanInitializationException.

Além disso,@Required difere de@Autowired - pois é limitado a um setter, enquanto@Autowired não é. @Autowired pode ser usado para conectar um construtor e um campo também, enquanto@Required verifica apenas se a propriedade está definida.

Vamos ver um exemplo:

Agora, oname do beanPerson precisa ser definido na configuração XML desta forma:

Observe que@Required doesn’t work with Java based @Configuration classes by default. Se você precisa ter certeza de que todas as suas propriedades estão definidas, você pode fazer isso ao criar o bean nos métodos anotados@Bean.

In the Front Controller pattern, all requests will first go to the front controller instead of the servlet. It’ll make sure that the responses are ready and will send them back to the browser. This way we have one place where we control everything that comes from the outside world.

O controlador frontal identificará o servlet que deve lidar com a solicitação primeiro. Então, quando ele obtém os dados de volta do servlet, ele decidirá qual visualização renderizar e, finalmente, enviará a visualização renderizada de volta como uma resposta:

Para ver os detalhes de implementação, verifique nossoGuide to the Front Controller Pattern in Java.

O Modelo 1 e o Modelo 2 representam dois modelos de design usados ​​com frequência quando se trata de projetar Java Web Applications.

In Model 1, a request comes to a servlet or JSP where it gets handled. O servlet ou o JSP processa a solicitação, manipula a lógica de negócios, recupera e valida dados e gera a resposta:

Como essa arquitetura é fácil de implementar, geralmente a usamos em aplicativos pequenos e simples.

Por outro lado, não é conveniente para aplicativos da web em grande escala. As funcionalidades são frequentemente duplicadas em JSPs, onde as lógicas de negócios e de apresentação são acopladas.

O Model 2 é baseado no padrão de design Model View Controller e separa a visualização da lógica que manipula o conteúdo.

Furthermore, we can distinguish three modules in the MVC pattern: the model, the view, and the controller. O modelo está representando a estrutura de dados dinâmica de um aplicativo. É responsável pela manipulação de dados e lógica de negócios. A visualização é responsável por exibir os dados, enquanto o controlador serve como uma interface entre os dois anteriores.

No Modelo 2, uma solicitação é passada para o controlador, que lida com a lógica necessária para obter o conteúdo correto que deve ser exibido. O controlador, em seguida, coloca o conteúdo de volta na solicitação, geralmente como JavaBean ou POJO. Ele também decide qual visualização deve renderizar o conteúdo e, finalmente, passa a solicitação para ele. Em seguida, a exibição renderiza os dados:

De acordo com a documentação oficial do Spring,@Component é um estereótipo genérico para qualquer componente gerenciado pelo Spring. @Repository,@Service e@Controller são especializações de@Component para casos de uso mais específicos, por exemplo, nas camadas de persistência, serviço e apresentação, respectivamente.

Vamos dar uma olhada em casos de uso específicos dos três últimos:

Simplificando, no padrão de design do Front Controller, um único controlador é responsável por direcionarHttpRequests de entrada para todos os outros controladores e manipuladores de um aplicativo.

DispatcherServlet de Spring implementa este padrão e é, portanto, responsável por coordenar corretamente oHttpRequests para os manipuladores certos.

Por outro lado,ContextLoaderListener inicia e fecha a raiz do SpringWebApplicationContext. Ele vincula o ciclo de vida deApplicationContext ao ciclo de vida deServletContext.. Podemos usá-lo para definir beans compartilhados trabalhando em diferentes contextos Spring.

Para obter mais detalhes sobreDispatcherServlet, consulteto this tutorial.

The MultipartResolver interface is used for uploading files. A estrutura Spring fornece uma implementaçãoMultipartResolver para uso com Commons FileUpload e outra para uso com análise de solicitação de várias partes Servlet 3.0.

Usando isso, podemos suportar uploads de arquivos em nossos aplicativos da web.

Os Spring MVC Interceptors nos permitem interceptar uma solicitação do cliente e processá-la em três locais - antes do manuseio, após o manuseio ou após a conclusão (quando a exibição é renderizada) de uma solicitação.

O interceptador pode ser usado para preocupações transversais e para evitar códigos repetitivos de manipulador, como registro em log, alteração de parâmetros globalmente usados ​​no modelo Spring, etc.

Para obter detalhes e várias implementações, dê uma olhada no artigoIntroduction to Spring MVC HandlerInterceptor.

A method annotated with @InitBinder is used to customize a request parameter, URI template, and backing/command objects. Nós o definimos em um controlador e ajuda no controle da solicitação. In this method, we register and configure our custom PropertyEditors, a formatter, and validators.

A anotação tem o elemento ‘value’. Se não o definirmos, os métodos anotados@InitBinder serão chamados em cada solicitação HTTP. Se definirmos o valor, os métodos serão aplicados apenas para determinados atributos de comando / formulário e / ou parâmetros de solicitação cujos nomes correspondem ao elemento ‘value’.

It’s important to remember that one of the arguments must be WebDataBinder. Outros argumentos podem ser de qualquer tipo que os métodos do manipulador suportem, exceto para objetos de comando / formulário e objetos de resultado de validação correspondentes.

The @ControllerAdvice annotation allows us to write global code applicable to a wide range of controllers. Podemos vincular a gama de controladores a um pacote escolhido ou a uma anotação específica.

Por padrão,@ControllerAdvice applies to the classes annotated with @Controller (or @RestController). Também temos algumas propriedades que usamos se queremos ser mais específicos.

If we want to restrict applicable classes to a package, we should add the name of the package to the annotation:

Também é possível usar vários pacotes, mas desta vez precisamos usar uma matriz em vez deString.

Besides restricting to the package by its name, we can do it by using one of the classes or interfaces from that package:

O elemento ‘assignableTypes’ aplica@ControllerAdvice às classes específicas, enquanto ‘annotations’ o faz para anotações particulares.

It’s noteworthy to remember that we should use it along with @ExceptionHandler. Essa combinação nos permitirá configurar um mecanismo global e mais específico de tratamento de erros, sem a necessidade de implementá-lo sempre para cada classe de controlador.

The @ExceptionHandler annotation allows us to define a method that will handle the exceptions. We may use the annotation independently, but it’s a far better option to use it together with the @ControllerAdvice. Assim, podemos configurar um mecanismo global de tratamento de erros. In this way, we don’t need to write the code for the exception handling within every controller.

Vamos dar uma olhada no exemplo de nosso artigo sobreError Handling for REST with Spring: