Perguntas e Respostas da Entrevista de Primavera

Tutoriais
Spring

I have posted a lot of Spring Tutorials recently. This post will help you get through Spring interview Questions explaining the core concepts in detail.

Spring Framework é um dos frameworks Java EE mais populares para aplicações web. Dependency Injection e Aspect-Oriented Programming estão no cerne do framework Spring. Se você domina o Spring Framework, as chances de ser selecionado aumentam significativamente em entrevistas de Java.

Dica Profissional: Core Java é a base de qualquer framework baseado em Java, então, se você está se preparando para entrevistas, por favor, revise os artigos de Core Java Interview Questions e Java Interview Questions.

Perguntas e Respostas para Entrevistas sobre o Spring

Aqui, estou fornecendo quase 50 perguntas de entrevista sobre o Spring e suas respostas. Está atualizado até o Spring 5, abrangendo todos os recursos mais recentes, como Spring WebFlux para programação reativa.

1. O que é o Spring Framework?

O Spring é um dos frameworks Java EE mais amplamente utilizados. Os conceitos principais do framework Spring são “Injeção de Dependência” e “Programação Orientada a Aspectos”.

O framework Spring pode ser usado em aplicações Java normais também para alcançar um baixo acoplamento entre diferentes componentes, implementando injeção de dependência. Podemos realizar tarefas de corte transversal, como registro e autenticação, usando o suporte do Spring para programação orientada a aspectos.

I like spring because it provides a lot of features and different modules for specific tasks such as Spring MVC and Spring JDBC. Since it’s an open-source framework with a lot of online resources and active community members, working with the Spring framework is easy and fun at the same time.

Leitura recomendada: Spring Framework

2. Quais são algumas das características importantes do Spring Framework?

O Spring Framework é construído com base em dois conceitos de design – Injeção de Dependência e Programação Orientada a Aspectos.

Algumas das características do framework Spring são:

  • Leve e com pouco overhead ao usar um framework para nosso desenvolvimento.
  • Injeção de Dependência ou Inversão de Controle para escrever componentes que são independentes entre si, o contêiner Spring cuida de conectá-los para alcançar nosso trabalho.
  • O contêiner IoC do Spring gerencia o ciclo de vida do Spring Bean e configurações específicas do projeto, como a busca JNDI.
  • O framework Spring MVC pode ser utilizado para criar aplicações web e serviços web restful capazes de retornar XML e JSON como resposta.
  • Suporte para gerenciamento de transações, operações JDBC, upload de arquivos, tratamento de exceções, etc., com poucas configurações, seja por meio de anotações ou pelo arquivo de configuração de beans do Spring.

3. Qual é a vantagem de usar o Spring Framework?

Algumas das vantagens de usar o Spring Framework são:

  • Redução de dependências diretas entre diferentes componentes da aplicação. O contêiner IoC do Spring é responsável por inicializar recursos ou beans e injetá-los como dependências.
  • Escrever casos de teste unitários é fácil no framework Spring, pois nossa lógica de negócios não tem dependências diretas com as classes de implementação de recursos reais. Podemos facilmente escrever uma configuração de teste e injetar nossos beans simulados para fins de teste.
  • Reduz a quantidade de código boilerplate, como inicialização de objetos, abertura/fechamento de recursos. Gosto muito da classe JdbcTemplate, pois nos ajuda a remover todo o código boilerplate que vem com a programação JDBC.
  • O framework Spring é dividido em vários módulos, o que nos ajuda a manter nossa aplicação leve. Por exemplo, se não precisarmos dos recursos de gerenciamento de transações do Spring, não é necessário adicionar essa dependência ao nosso projeto.
  • O framework Spring suporta a maioria dos recursos do Java EE e até mesmo muitos outros. Ele está sempre atualizado com as novas tecnologias, por exemplo, existe um projeto Spring para Android que nos ajuda a escrever um código melhor para aplicações nativas do Android. Isso torna o framework Spring um pacote completo e não precisamos procurar por diferentes frameworks para diferentes requisitos.

4. Quais são as características importantes do Spring 5?

O Spring 5 é uma revisão importante do Spring 4. Algumas das características importantes são:

  • Suporte para Java 8 e versões superiores, permitindo o uso de expressões lambda.
  • Suporte para Java EE7 e especificações Servlet 4.0.
  • As operações de arquivo são realizadas por meio de fluxos NIO 2 agora, uma grande melhoria se sua aplicação lida com muitos arquivos.
  • Introdução do spring-jcl para simplificar o registro, antes era confuso devido à falta de um ponto único para fins de registro.
  • Suporte para Kotlin, Lombok, Reactor 3.1 Flux, e Mono, bem como RxJava.
  • Spring WebFlux que traz programação reativa para o Spring.
  • Suporte para JUnit 5
  • Suporte para fornecer informações sobre componentes Spring por meio do arquivo de índice “META-INF/spring.components” em vez de varredura no classpath.

Por favor, consulte Recursos do Spring 5 para obter uma visão detalhada desta versão.

5. O que é o Spring WebFlux?

O Spring WebFlux é o novo módulo introduzido no Spring 5. O Spring WebFlux é o primeiro passo em direção ao modelo de programação reativa no framework Spring.

O Spring WebFlux é a alternativa ao módulo Spring MVC. Ele é usado para criar uma aplicação totalmente assíncrona e não bloqueante construída no modelo de execução de loop de eventos.

Você pode ler mais sobre isso em Tutorial do Spring WebFlux.

6. O que você entende por Injeção de Dependência?

O padrão de design Injeção de Dependência nos permite remover as dependências codificadas e tornar nossa aplicação fracamente acoplada, extensível e fácil de manter. Podemos implementar o padrão de injeção de dependência para transferir a resolução de dependência do tempo de compilação para o tempo de execução.

Algumas vantagens de usar Injeção de Dependência são a Separação de Preocupações, a redução de Código Redundante, componentes configuráveis e facilidade de teste unitário.

Leia mais em Tutorial de Injeção de Dependência. Também podemos usar Google Guice para Injeção de Dependência para automatizar o processo de injeção de dependência. Mas na maioria dos casos, buscamos mais do que apenas injeção de dependência, e é aí que o Spring se destaca.

7. Como implementamos a Injeção de Dependência no Spring Framework?

Podemos usar a configuração baseada em XML do Spring, bem como a configuração baseada em anotações para implementar a Injeção de Dependência em aplicações Spring. Para uma compreensão melhor, por favor, leia o exemplo de Injeção de Dependência no Spring, onde você pode aprender ambas as maneiras com um caso de teste JUnit. O post também contém um arquivo zip do projeto de exemplo, que você pode baixar e explorar para aprender mais.

8. Quais são os benefícios de usar o Spring Tool Suite?

Podemos instalar plugins no Eclipse para obter todos os recursos do Spring Tool Suite. No entanto, o STS vem com o Eclipse com alguns outros tipos importantes de recursos, como suporte ao Maven, modelos para criar diferentes tipos de projetos Spring e tc server para melhor desempenho com aplicativos Spring.

I like STS because it highlights the Spring components and if you are using AOP pointcuts and advice, then it clearly shows which methods will come under the specific pointcut. So rather than installing everything on our own, I prefer using STS when developing Spring-based applications.

9. Nomeie alguns dos módulos importantes do Spring?

Alguns dos módulos importantes do Spring Framework são:

  • Spring Context – para injeção de dependência.
  • Spring AOP – para programação orientada a aspectos.
  • Spring DAO – para operações de banco de dados usando o padrão DAO
  • Spring JDBC – para suporte JDBC e DataSource.
  • Spring ORM – para suporte a ferramentas ORM como Hibernate
  • Módulo Web Spring – para criar aplicativos da web.
  • Spring MVC – Implementação Model-View-Controller para criar aplicativos da web, serviços da web, etc.

10. O que você entende por Programação Orientada a Aspectos?

Aplicações empresariais têm algumas preocupações transversais comuns que são aplicáveis a diferentes tipos de objetos e módulos de aplicação, como registro (logging), gerenciamento de transações, validação de dados, autenticação, etc. A modularidade da aplicação é alcançada por meio de classes na programação orientada a objetos. Na AOP, a modularidade da aplicação é alcançada por Aspectos e eles são configurados para atravessar diferentes métodos de classe.

A AOP retira a dependência direta de tarefas transversais de classes que não é possível na programação orientada a objetos normal. Por exemplo, podemos ter uma classe separada para registro (logging), mas as outras classes terão que chamar esses métodos. No entanto, na AOP, configuramos os aspectos e a execução do método acontece automaticamente. Saiba mais sobre o suporte do Spring AOP em Exemplo de Spring AOP.

11. O que são Aspecto, Conselho (Advice), Ponto de Corte (Pointcut), Ponto de Junção (JointPoint) e Argumentos de Conselho (Advice Arguments) na AOP?

Aspecto: Aspecto é uma classe que implementa preocupações transversais, como gerenciamento de transações. Os aspectos podem ser uma classe normal configurada e então configurada no arquivo de configuração do Spring Bean ou podemos usar o suporte do Spring AspectJ para declarar uma classe como um Aspecto usando a anotação @Aspect.

Conselho: Conselho é a ação tomada para um ponto de junção específico. Em termos de programação, são métodos que são executados quando um ponto de junção específico com um pointcut correspondente é alcançado na aplicação. Você pode pensar em Conselho como interceptadores do Spring ou Filtros Servlet.

Pointcut: Pointcuts são expressões regulares que são correspondidas com pontos de junção para determinar se o conselho precisa ser executado ou não. Pointcut usa diferentes tipos de expressões que são correspondidas com os pontos de junção. O framework Spring usa a linguagem de expressão de ponto de junção do AspectJ para determinar os pontos de junção onde os métodos de conselho serão aplicados.

Ponto de Junção: Um ponto de junção é um ponto específico na aplicação, como execução de método, tratamento de exceção, mudança de valores de variáveis de objeto, etc. No AOP do Spring, um ponto de junção é sempre a execução de um método.

Argumentos de Conselho: Podemos passar argumentos nos métodos de conselho. Podemos usar a expressão args() no ponto de corte para ser aplicada a qualquer método que corresponda ao padrão de argumento. Se usarmos isso, então precisamos usar o mesmo nome no método de conselho de onde o tipo de argumento é determinado.

Esses conceitos parecem confusos a princípio, mas se você passar por Exemplo de Aspecto Spring, Conselho, então você pode facilmente relacioná-los.

12. Qual é a diferença entre Spring AOP e AspectJ AOP?

O AspectJ é a implementação padrão da indústria para Programação Orientada a Aspectos, enquanto o Spring implementa AOP para alguns casos. As principais diferenças entre Spring AOP e AspectJ são:

  • O Spring AOP é mais simples de usar do que o AspectJ porque não precisamos nos preocupar com o processo de tecelagem.
  • O Spring AOP suporta anotações AspectJ, então se você estiver familiarizado com o AspectJ, trabalhar com o Spring AOP é mais fácil.
  • O Spring AOP suporta apenas AOP baseado em proxy, então ele pode ser aplicado apenas aos pontos de junção de execução de método. O AspectJ suporta todos os tipos de pontos de corte.
  • Uma das limitações do Spring AOP é que ele só pode ser aplicado aos beans criados através do Contexto Spring.

13. O que é o Contêiner Spring IoC?

Inversão de Controle (IoC) é o mecanismo para alcançar o acoplamento fraco entre as dependências dos objetos. Para alcançar um acoplamento fraco e vinculação dinâmica dos objetos em tempo de execução, os objetos definem suas dependências que são injetadas por outros objetos montadores. O contêiner Spring IoC é o programa que injeta dependências em um objeto e o torna pronto para o nosso uso.

As classes do contêiner IoC do Spring Framework fazem parte dos pacotes org.springframework.beans e org.springframework.context e nos fornecem diferentes maneiras de desacoplar as dependências do objeto.

Algumas das implementações úteis do ApplicationContext que usamos são;

  • AnnotationConfigApplicationContext: Para aplicativos Java autônomos usando configuração baseada em anotações.
  • ClassPathXmlApplicationContext: Para aplicativos Java autônomos usando configuração baseada em XML.
  • FileSystemXmlApplicationContext: Semelhante ao ClassPathXmlApplicationContext, exceto que o arquivo de configuração XML pode ser carregado de qualquer lugar no sistema de arquivos.
  • AnnotationConfigWebApplicationContext e XmlWebApplicationContext para aplicativos web.

14. O que é um Spring Bean?

Qualquer classe Java normal que seja inicializada pelo contêiner Spring IoC é chamada de Spring Bean. Usamos o ApplicationContext do Spring para obter a instância do Spring Bean.

O contêiner Spring IoC gerencia o ciclo de vida do Spring Bean, escopos de bean e injeta quaisquer dependências necessárias no bean.

15. Qual é a importância do arquivo de configuração do Spring bean?

Usamos o arquivo de configuração do Spring Bean para definir todos os beans que serão inicializados pelo Contexto Spring. Quando criamos a instância do ApplicationContext do Spring, ele lê o arquivo XML de beans do Spring e os inicializa. Uma vez que o contexto é inicializado, podemos usá-lo para obter diferentes instâncias de beans.

Além da configuração do Spring Bean, este arquivo também contém interceptadores MVC do Spring, resolvedores de visualização e outros elementos para suportar configurações baseadas em anotações.

16. Quais são as diferentes maneiras de configurar uma classe como Spring Bean?

Existem três maneiras diferentes de configurar o Spring Bean.

Configuração XML: Esta é a configuração mais popular e podemos usar o elemento bean no arquivo de contexto para configurar um Spring Bean. Por exemplo:

<bean name="myBean" class="com.journaldev.spring.beans.MyBean"></bean>

Configuração Baseada em Java: Se você estiver usando apenas anotações, pode configurar um Spring Bean usando a anotação @Bean. Esta anotação é usada com classes @Configuration para configurar um Spring Bean. Exemplo de configuração:

@Configuration
@ComponentScan(value="com.journaldev.spring.main")
public class MyConfiguration {

	@Bean
	public MyService getService(){
		return new MyService();
	}
}

Para obter esse bean do contexto do Spring, precisamos usar o seguinte trecho de código:

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(
		MyConfiguration.class);
MyService service = ctx.getBean(MyService.class);

Configuração Baseada em Anotações: Também podemos usar as anotações @Component, @Service, @Repository e @Controller com classes para configurá-las como Spring Bean. Para isso, precisaríamos fornecer a localização do pacote base para escanear essas classes. Por exemplo:

<context:component-scan base-package="com.journaldev.spring" />

17. Quais são os diferentes escopos do Spring Bean?

Existem cinco escopos definidos para os Spring Beans.

  1. singleton: Apenas uma instância do bean será criada para cada contêiner. Este é o escopo padrão para os beans de primavera. Ao usar este escopo, certifique-se de que o bean de primavera não tenha variáveis de instância compartilhadas, caso contrário, pode levar a problemas de inconsistência de dados porque não é seguro para threads.
  2. prototype: Uma nova instância será criada sempre que o bean for solicitado.
  3. request: Este é o mesmo escopo que o prototype, no entanto, é destinado a ser usado para aplicações web. Uma nova instância do bean será criada para cada solicitação HTTP.
  4. session: Um novo bean será criado para cada sessão HTTP pelo contêiner.
  5. global-session: Isso é usado para criar beans de sessão global para aplicações de Portlet.

O Framework Spring é extensível e podemos criar nossos próprios escopos também. Mas na maioria das vezes estamos bem com os escopos fornecidos pelo framework. Para definir os escopos dos beans do Spring, podemos usar o atributo “scope” no elemento bean ou @Scope anotação para configurações baseadas em anotações.

18. Qual é o ciclo de vida do Spring Bean?

Os Spring Beans são inicializados pelo Contêiner Spring e todas as dependências também são injetadas. Quando o contexto é destruído, ele também destrói todos os beans inicializados. Isso funciona bem na maioria dos casos, mas às vezes queremos inicializar outros recursos ou fazer alguma validação antes de tornar nossos beans prontos para uso. O framework Spring fornece suporte para métodos de pós-inicialização e pré-destruição nos beans do Spring.

Podemos fazer isso de duas maneiras – implementando as interfaces InitializingBean e DisposableBean ou usando o atributo init-method e destroy-method nas configurações de beans do Spring. Para mais detalhes, por favor leia Métodos do Ciclo de Vida do Spring Bean.

19. Como obter o objeto ServletContext e ServletConfig em um Bean do Spring?

Há duas maneiras de obter objetos específicos do Contêiner no bean Spring.

  • Implementando interfaces *Aware do Spring, para essas interfaces ServletContextAware e ServletConfigAware, para um exemplo completo dessas interfaces aware, por favor, leia Interfaces Aware do Spring.
  • Usando a anotação @Autowired com uma variável de bean do tipo ServletContext e ServletConfig. Elas funcionarão apenas em ambientes específicos do contêiner de servlets.
@Autowired
ServletContext servletContext;

20. O que é o cabeamento de beans e a anotação @Autowired?

O processo de injeção de dependências de beans do Spring durante a inicialização é chamado de Cabeamento de Beans do Spring.

Geralmente, é uma prática recomendada fazer o cabeamento explícito de todas as dependências de bean, mas o framework Spring também suporta a auto-cabeação. Podemos usar a anotação @Autowired com campos ou métodos para cabeamento por tipo. Para que essa anotação funcione, também precisamos habilitar a configuração baseada em anotações no arquivo de configuração de beans do Spring. Isso pode ser feito pelo elemento context:annotation-config.

Para mais detalhes sobre a anotação @Autowired, por favor, leia Exemplo de Autowire do Spring.

21. Quais são os diferentes tipos de autowiring de Spring Bean?

Há quatro tipos de autowiring no framework Spring.

  1. autowire byName
  2. autowire byType
  3. autowire by constructor
  4. autowiring por meio das anotações @Autowired e @Qualifier

Antes do Spring 3.1, o autowire by autodetect também era suportado, sendo similar ao autowire by constructor ou byType. Para mais detalhes sobre essas opções, por favor leia Autowiring de Beans Spring.

22. O Bean Spring oferece segurança de thread?

O escopo padrão do bean Spring é singleton, então haverá apenas uma instância por contexto. Isso significa que todas as variáveis de nível de classe que qualquer thread pode atualizar levarão a dados inconsistentes. Portanto, no modo padrão, os beans Spring não são seguros para threads.

No entanto, podemos alterar o escopo do spring bean para solicitação, protótipo ou sessão para alcançar a segurança de thread ao custo de desempenho. É uma decisão de design com base nos requisitos do projeto.

23. O que é um Controlador no Spring MVC?

Assim como o padrão de design MVC, o Controlador é a classe que cuida de todas as solicitações do cliente e as envia para os recursos configurados para lidar com elas. No Spring MVC, DispatcherServlet é a classe do controlador frontal que inicializa o contexto com base nas configurações dos beans do spring.

A Controller class is responsible to handle a different kind of client requests based on the request mappings. We can create a controller class by using @Controller annotation. Usually, it’s used with @RequestMapping annotation to define handler methods for specific URI mapping.

24. Qual é a diferença entre @Component, @Controller, @Repository & @Service anotações no Spring?

@Componente é usado para indicar que uma classe é um componente. Essas classes são usadas para auto-detecção e configuradas como um bean quando são usadas configurações baseadas em anotações.

@Controlador é um tipo específico de componente, usado em aplicações MVC e principalmente utilizado com a anotação RequestMapping.

@Repositório é uma anotação usada para indicar que um componente é usado como um repositório e um mecanismo para armazenar/recuperar/pesquisar dados. Podemos aplicar esta anotação com classes de implementação do padrão DAO.

@Serviço é usado para indicar que uma classe é um Serviço. Geralmente, as classes de fachada de negócios que fornecem alguns serviços são anotadas com esta.

Podemos usar qualquer uma das anotações acima para uma classe para auto-detecção, mas diferentes tipos são fornecidos para que você possa distinguir facilmente o propósito das classes anotadas.

25. O que é DispatcherServlet e ContextLoaderListener?

O DispatcherServlet é o controlador frontal na aplicação Spring MVC e carrega o arquivo de configuração de feijão spring e inicializa todos os feijões que estão configurados. Se as anotações estiverem habilitadas, ele também verifica os pacotes e configura qualquer feijão anotado com @Component, @Controller, @Repository ou @Service.

O ContextLoaderListener é o ouvinte para iniciar e desligar o root WebApplicationContext da Primavera. Suas funções importantes são vincular o ciclo de vida do ApplicationContext ao ciclo de vida do ServletContext e automatizar a criação do ApplicationContext. Podemos usá-lo para definir feijões compartilhados que podem ser usados em diferentes contextos da Primavera.

26. O que é o ViewResolver no Spring?

As implementações do ViewResolver são usadas para resolver as páginas de visualização pelo nome. Configuramos isso no arquivo de configuração de feijão spring. Por exemplo:

<!-- Resolve as visualizações selecionadas para renderização pelos @Controllers para recursos .jsp no diretório /WEB-INF/views -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<beans:property name="prefix" value="/WEB-INF/views/" />
	<beans:property name="suffix" value=".jsp" />
</beans:bean>

O InternalResourceViewResolver é uma das implementações da interface ViewResolver, e fornecemos o diretório das páginas de visualização e a localização do sufixo por meio das propriedades do bean. Portanto, se um método manipulador do controlador retornar “home”, o resolvedor de visualização usará a página de visualização localizada em /WEB-INF/views/home.jsp.

27. O que é um MultipartResolver e quando é usado?

A interface MultipartResolver é usada para fazer upload de arquivos – CommonsMultipartResolver e StandardServletMultipartResolver são duas implementações fornecidas pelo framework Spring para o upload de arquivos. Por padrão, não há resolutores multipartidos configurados, mas para usá-los para o upload de arquivos, tudo o que precisamos fazer é definir um bean chamado “multipartResolver” com o tipo MultipartResolver nas configurações de beans do Spring.

Uma vez configurado, qualquer solicitação multipartida será resolvida pelo MultipartResolver configurado e passará por um HttpServletRequest encapsulado. Em seguida, é usado na classe do controlador para obter o arquivo e processá-lo. Para um exemplo completo, leia Exemplo de Upload de Arquivo no Spring MVC.

28. Como lidar com exceções no Framework Spring MVC?

O Framework Spring MVC fornece as seguintes maneiras de nos ajudar a alcançar um tratamento de exceção robusto.

Baseado em Controlador – Podemos definir métodos de tratamento de exceção em nossas classes de controlador. Tudo o que precisamos fazer é anotar esses métodos com a anotação @ExceptionHandler.

Tratador de Exceções Global – O Tratamento de Exceções é uma preocupação transversal e o Spring fornece a anotação @ControllerAdvice que podemos usar com qualquer classe para definir nosso tratador de exceções global.

Implementação do HandlerExceptionResolver – Para exceções genéricas, na maioria das vezes, servimos páginas estáticas. O Spring Framework fornece uma interface HandlerExceptionResolver que podemos implementar para criar um tratador de exceções global. A razão por trás dessa maneira adicional de definir o tratador de exceções global é que o framework Spring também fornece classes de implementação padrão que podemos definir em nosso arquivo de configuração de bean Spring para obter benefícios de tratamento de exceção do framework Spring.

Para um exemplo completo, por favor leia o Exemplo de Tratamento de Exceções no Spring.

29. Como criar ApplicationContext em um Programa Java?

Existem as seguintes maneiras de criar contexto spring em um programa java independente.

  1. AnnotationConfigApplicationContext: Se estivermos usando o Spring em aplicações Java independentes e usando anotações para Configuração, então podemos usar isso para inicializar o contêiner e obter os objetos bean.
  2. ClassPathXmlApplicationContext: Se tivermos um arquivo de configuração de beans Spring em um aplicativo independente, então podemos usar essa classe para carregar o arquivo e obter o objeto do contêiner.
  3. FileSystemXmlApplicationContext: Isso é semelhante ao ClassPathXmlApplicationContext, exceto que o arquivo de configuração XML pode ser carregado de qualquer lugar no sistema de arquivos.

30. Podemos ter vários arquivos de configuração Spring?

Para aplicações Spring MVC, podemos definir múltiplos arquivos de configuração de contexto Spring através do `contextConfigLocation`. Esta string de localização pode consistir em múltiplos locais separados por qualquer número de vírgulas e espaços. Por exemplo;

<servlet>
	<servlet-name>appServlet</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
            <param-name>contextConfigLocation</param-name>
	    <param-value>/WEB-INF/spring/appServlet/servlet-context.xml,/WEB-INF/spring/appServlet/servlet-jdbc.xml</param-value>
	</init-param>
	<load-on-startup>1</load-on-startup>
</servlet>

Também podemos definir múltiplas configurações de nível raiz do Spring e carregá-las através de `context-param`. Por exemplo;

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/spring/root-context.xml /WEB-INF/spring/root-security.xml</param-value>
</context-param>

Outra opção é usar o elemento `import` no arquivo de configuração de contexto para importar outras configurações, por exemplo:

<beans:import resource="spring-jdbc.xml"/>

31. O que é ContextLoaderListener?

O `ContextLoaderListener` é a classe de listener usada para carregar o contexto raiz e definir configurações de beans Spring que serão visíveis para todos os outros contextos. É configurado no arquivo `web.xml` como:

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>
	
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

32. Quais são as configurações mínimas necessárias para criar uma aplicação Spring MVC?

Para criar uma simples aplicação Spring MVC, precisaríamos realizar as seguintes tarefas.

  • Adicionar as dependências `spring-context` e `spring-webmvc` no projeto.
  • Configure DispatcherServlet no arquivo web.xml para lidar com solicitações através do contêiner Spring.
  • Arquivo de configuração de bean Spring para definir beans, se estiver usando anotações, então deve ser configurado aqui. Além disso, precisamos configurar o resolvedor de visualizações para páginas de visualização.
  • Classe do controlador com mapeamentos de solicitação definidos para lidar com as solicitações do cliente.

As etapas acima devem ser suficientes para criar uma aplicação simples de Spring MVC Hello World.

33. Como você relacionaria o Framework Spring MVC com a arquitetura MVC?

Como o nome sugere, o Spring MVC é construído sobre a arquitetura Model-View-Controller. DispatcherServlet é o Controlador Frontal na aplicação Spring MVC que cuida de todas as solicitações recebidas e as delega para diferentes métodos manipuladores de controlador.

O modelo pode ser qualquer Bean Java no Framework Spring, assim como em qualquer outro framework MVC, o Spring fornece o vínculo automático de dados de formulário para beans Java. Podemos definir beans de modelo como atributos a serem usados nas páginas de visualização.

As páginas de visualização podem ser JSP, HTML estático, etc. e os resolvedores de visualização são responsáveis por encontrar a página de visualização correta. Uma vez que a página de visualização é identificada, o controle é devolvido ao controlador DispatcherServlet. DispatcherServlet é responsável por renderizar a visualização e retornar a resposta final para o cliente.

34. Como alcançar a localização em aplicações Spring MVC?

O Spring oferece excelente suporte para localização ou i18n por meio de pacotes de recursos. As etapas básicas necessárias para tornar nossa aplicação localizada são:

  • Criar pacotes de recursos de mensagem para diferentes locais, como messages_en.properties, messages_fr.properties, etc.
  • Definir o bean messageSource no arquivo de configuração de beans Spring do tipo ResourceBundleMessageSource ou ReloadableResourceBundleMessageSource.
  • Para suporte à mudança de local, defina o bean localeResolver do tipo CookieLocaleResolver e configure o interceptor LocaleChangeInterceptor. Uma configuração de exemplo é mostrada a seguir:
<beans:bean id="messageSource"
class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
<beans:property name="basename" value="classpath:messages" />
<beans:property name="defaultEncoding" value="UTF-8" />
</beans:bean>
 
<beans:bean id="localeResolver"
    class="org.springframework.web.servlet.i18n.CookieLocaleResolver">
    <beans:property name="defaultLocale" value="en" />
    <beans:property name="cookieName" value="myAppLocaleCookie"></beans:property>
    <beans:property name="cookieMaxAge" value="3600"></beans:property>
</beans:bean>
 
<interceptors>
    <beans:bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
        <beans:property name="paramName" value="locale" />
    </beans:bean>
</interceptors>
  • Use o elemento spring:message nas páginas de visualização com nomes de chave, o DispatcherServlet escolhe o valor correspondente e renderiza a página no local correspondente e retorna como resposta.

Para um exemplo completo, por favor leia Exemplo de Localização do Spring.

35. Como podemos usar o Spring para criar um Serviço Web Restful que retorna uma resposta JSON?

Podemos utilizar o framework Spring para criar serviços web Restful que retornam dados em formato JSON. O Spring oferece integração com a API Jackson JSON, que podemos utilizar para enviar respostas em formato JSON em um serviço web Restful.

Para configurar nossa aplicação Spring MVC para enviar respostas em JSON, precisamos seguir as etapas a seguir.

1. Adicionar as dependências do Jackson JSON. Se estiver usando o Maven, pode ser feito com o seguinte código:

<!-- Jackson -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>${jackson.databind-version}</version>
</dependency>

2. Configurar o bean RequestMappingHandlerAdapter no arquivo de configuração de beans do Spring e definir a propriedade message converters para o bean MappingJackson2HttpMessageConverter. Uma configuração de exemplo seria:

<!-- Configurar para integrar JSON como solicitação e resposta no manipulador de método -->
<beans:bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <beans:property name="messageConverters">
        <beans:list>
            <beans:ref bean="jsonMessageConverter"/>
        </beans:list>
    </beans:property>
</beans:bean>
     
<!-- Configurar bean para converter JSON para POJO e vice-versa -->
<beans:bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
</beans:bean>

3. Nos métodos do controlador, retornar o objeto como resposta usando a anotação @ResponseBody. Exemplo de código:

@RequestMapping(value = EmpRestURIConstants.GET_EMP, method = RequestMethod.GET)
public @ResponseBody Employee getEmployee(@PathVariable("id") int empId) {
    logger.info("Start getEmployee. ID="+empId);
     
    return empData.get(empId);
}

4. Você pode invocar o serviço Rest através de qualquer API, mas se desejar usar o Spring, pode fazê-lo facilmente usando a classe RestTemplate.

Para um exemplo completo, por favor, leia Exemplo de Spring Restful Webservice.

36. Quais são algumas das importantes anotações do Spring que você utilizou?

Algumas das anotações do Spring que utilizei no meu projeto são:

37. Podemos enviar um Objeto como resposta do método manipulador do Controlador?

Sim, podemos, usando a anotação @ResponseBody. É assim que enviamos uma resposta baseada em JSON ou XML em serviços web RESTful.

38. Como enviar arquivos na aplicação Spring MVC?

O Spring fornece suporte integrado para o envio de arquivos por meio de implementações da interface MultipartResolver. É muito fácil de usar e requer apenas mudanças de configuração para fazê-lo funcionar. Precisaríamos escrever um método manipulador do controlador para lidar com o arquivo recebido e processá-lo. Para um exemplo completo, consulte Exemplo de Envio de Arquivo Spring.

39. Como validar dados de formulário no Framework Spring Web MVC?

O Spring suporta validações baseadas em anotações JSR-303 e também fornece uma interface Validator que podemos implementar para criar nosso próprio validador personalizado. Para usar a validação baseada em JSR-303, precisamos anotar as variáveis do bean com as validações necessárias.

Para a implementação do validador personalizado, precisamos configurá-lo na classe do controlador. Para um exemplo completo, por favor leia Exemplo de Validação de Formulário Spring MVC.

40. O que é Interceptor Spring MVC e como usá-lo?

Os Interceptors do Spring MVC são como Filtros Servlet e nos permitem interceptar solicitações de clientes e processá-las. Podemos interceptar solicitações de clientes em três lugares – preHandle, postHandle, e afterCompletion.

Podemos criar um interceptor spring implementando a interface HandlerInterceptor ou estendendo a classe abstrata HandlerInterceptorAdapter.

Precisamos configurar interceptadores no arquivo de configuração do bean Spring. Podemos definir um interceptor para interceptar todas as solicitações do cliente ou podemos configurá-lo para um mapeamento de URI específico também. Para um exemplo detalhado, consulte Exemplo de Interceptor do Spring MVC.

41. O que é a classe Spring JdbcTemplate e como usá-la?

O Framework Spring oferece uma excelente integração com a API JDBC e fornece a classe de utilitário JdbcTemplate, que podemos usar para evitar código redundante em nossa lógica de operações de banco de dados, como abrir/fechar conexões, ResultSet, PreparedStatement, etc.

Para um exemplo de JdbcTemplate, consulte Exemplo de Spring JDBC.

42. Como usar Tomcat JNDI DataSource em uma aplicação Spring Web?

Para usar o contêiner servlet configurado com JNDI DataSource, precisamos configurá-lo no arquivo de configuração de beans do Spring e depois injetá-lo nos beans do Spring como dependências. Em seguida, podemos usá-lo com JdbcTemplate para realizar operações no banco de dados.

<beans:bean id="dbDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <beans:property name="jndiName" value="java:comp/env/jdbc/MyLocalDB"/>
</beans:bean>

Para um exemplo completo, consulte Exemplo Spring Tomcat JNDI.

43. Como você alcançaria o Gerenciamento de Transações no Spring?

O framework Spring oferece suporte ao gerenciamento de transações por meio do Gerenciamento de Transações Declarativo, bem como do gerenciamento programático de transações. O gerenciamento de transações declarativo é o mais amplamente utilizado porque é fácil de usar e funciona na maioria dos casos.

Nós utilizamos a anotação @Transactional para o gerenciamento de transações declarativo. Precisamos configurar o gerenciador de transações para o DataSource no arquivo de configuração de beans do Spring.

<bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

44. O que é o Spring DAO?

O suporte DAO do Spring é fornecido para trabalhar com tecnologias de acesso a dados como JDBC, Hibernate de maneira consistente e fácil. Por exemplo, temos JdbcDaoSupport, HibernateDaoSupport, JdoDaoSupport e JpaDaoSupport para as respectivas tecnologias.

O Spring DAO também oferece consistência na hierarquia de exceções e não precisamos capturar exceções específicas.

45. Como integrar os frameworks Spring e Hibernate?

Podemos usar o módulo Spring ORM para integrar os frameworks Spring e Hibernate se estiver usando o Hibernate 3+ onde o SessionFactory fornece a sessão atual. Nesse caso, evite usar as classes HibernateTemplate ou HibernateDaoSupport e é melhor usar o padrão DAO com injeção de dependência para a integração.

O Spring ORM oferece suporte ao uso da gestão declarativa de transações do Spring, portanto, é recomendável utilizar isso em vez de recorrer ao código boilerplate do Hibernate para o gerenciamento de transações.

Para uma compreensão melhor, você deve consultar os seguintes tutoriais:

46. O que é o Spring Security?

O framework de segurança Spring foca em fornecer autenticação e autorização em aplicações Java. Ele também cuida da maioria das vulnerabilidades comuns de segurança, como ataques CSRF.

É muito benéfico e fácil usar o Spring Security em aplicações web, por meio do uso de anotações como @EnableWebSecurity. Recomenda-se revisar as postagens a seguir para aprender como usar o framework Spring Security.

47. Como injetar um java.util.Properties em um Bean Spring?

Temos que definir o bean propertyConfigurer que carregará as propriedades do arquivo de propriedades fornecido. Em seguida, podemos usar o suporte do Spring EL para injetar propriedades em outras dependências de beans. Por exemplo:

<bean id="propertyConfigurer" 
  class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer">
    <property name="location" value="/WEB-INF/application.properties" />
</bean> 

<bean class="com.journaldev.spring.EmployeeDaoImpl">
    <property name="maxReadResults" value="${results.read.max}"/>
</bean>

Se você estiver usando anotação para configurar o bean do Spring, então você pode injetar propriedade como abaixo.

@Value("${maxReadResults}") 
private int maxReadResults;

48. Nomeie alguns dos padrões de design usados no Spring Framework?

O Spring Framework está usando muitos padrões de design, alguns dos mais comuns são:

  1. Padrão Singleton: Criando beans com escopo padrão.
  2. Padrão Factory: Classes de fábrica de beans
  3. Padrão Prototype: Escopos de beans
  4. Padrão Adaptador: Spring Web e Spring MVC
  5. Padrão Proxy: Suporte à Programação Orientada a Aspectos do Spring
  6. Padrão Template Method: JdbcTemplate, HibernateTemplate, etc
  7. Controlador Frontal: DispatcherServlet do Spring MVC
  8. Objeto de Acesso a Dados: Suporte DAO do Spring
  9. Injeção de Dependência e Programação Orientada a Aspecto

49. Quais são algumas das melhores práticas para o Spring Framework?

Algumas das melhores práticas para o Spring Framework são:

  • Evitar números de versão na referência do esquema, para garantir que tenhamos as configurações mais recentes.
  • Dividir as configurações de beans do Spring com base em suas preocupações, como spring-jdbc.xml, spring-security.xml.
  • Para beans do Spring que são usados em vários contextos no Spring MVC, crie-os no contexto raiz e inicialize com o listener.
  • Configure as dependências de beans o máximo possível, evite a auto conexão o máximo possível.
  • Para propriedades de nível de aplicação, a melhor abordagem é criar um arquivo de propriedades e lê-lo no arquivo de configuração de beans do Spring.
  • Para aplicativos menores, as anotações são úteis, mas para aplicativos maiores, as anotações podem se tornar um problema. Se tivermos todas as configurações em arquivos XML, a manutenção será mais fácil.
  • Use anotações corretas para os componentes para entender facilmente o propósito. Para serviços, use @Service e para beans DAO use @Repository.
  • O framework Spring tem muitos módulos, use o que você precisa. Remova todas as dependências extras que geralmente são adicionadas ao criar projetos através de modelos do Spring Tool Suite.
  • Se estiver usando Aspectos, certifique-se de manter o ponto de junção o mais estreito possível para evitar conselhos em métodos indesejados. Considere anotações personalizadas que são mais fáceis de usar e evite quaisquer problemas.
  • Use injeção de dependência quando houver um benefício real, apenas para o acoplamento fraco não use porque é mais difícil de manter.

50. O que é o Spring Boot?

Spring Boot torna o framework Spring único. Ele nos proporciona uma maneira fácil de criar diferentes tipos de aplicações Java e conectá-las ao ambiente de execução do contêiner servlet. Assim, obtemos um único arquivo JAR que podemos executar para rodar o projeto. Isso economiza muito tempo ao obtermos rapidamente um projeto esqueleto pronto para implantação do produto. Dessa forma, podemos focar mais na lógica de negócios, evitando o processo comum de construir o código e, em seguida, implantá-lo em um contêiner servlet. Como é um tópico vasto, sugiro que você consulte Perguntas de Entrevista sobre o Spring Boot.

Isso é tudo para as perguntas de entrevista sobre o Spring Framework. Espero que essas perguntas o ajudem em entrevistas de Java EE. Continuarei adicionando mais perguntas à lista assim que as encontrar. Se souber de mais perguntas que deveriam fazer parte da lista, deixe um comentário e eu as incluirei.

Source:
https://www.digitalocean.com/community/tutorials/spring-interview-questions-and-answers