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.

O Spring Framework é um dos frameworks Java EE mais populares para aplicações web. A Injeção de Dependência e a Programação Orientada a Aspectos estão no cerne do framework Spring. Se você é bom no Spring Framework, as chances de ser selecionado são realmente altas em entrevistas de Java.

Dica Pro: O Java Principal é a base de qualquer framework baseado em Java, então se você está se preparando para entrevistas, por favor, revise as perguntas de entrevista de Java Principal e Perguntas de Entrevista de Java.

Perguntas e Respostas de Entrevista do Spring

Aqui estou fornecendo quase 50 perguntas de entrevista do Spring e suas respostas. Está atualizado até o Spring 5, então cobre 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 fundamentais do framework Spring são “Injeção de Dependência” e “Programação Orientada a Aspectos”.

O framework Spring pode ser utilizado em aplicações Java normais também para alcançar o desacoplamento entre diferentes componentes, implementando a injeção de dependência. Podemos realizar tarefas transversais, 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 pouca sobrecarga no desenvolvimento ao usar o framework.
  • Injeção de Dependência ou Inversão de Controle para escrever componentes independentes entre si, onde o contêiner Spring cuida da conexão para realizar nosso trabalho.
  • O contêiner Spring IoC gerencia o ciclo de vida do Spring Bean e as configurações específicas do projeto, como a busca JNDI.
  • O framework Spring MVC pode ser usado para criar aplicações web, bem como serviços web RESTful capazes de retornar XML e também resposta JSON.
  • Suporte para gerenciamento de transações, operações JDBC, upload de arquivos, tratamento de exceções, etc., com pouquíssimas configurações, seja usando anotações ou o arquivo de configuração de bean Spring.

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

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

  • Redução das dependências diretas entre diferentes componentes da aplicação. O contêiner Spring IoC é responsável por inicializar recursos ou beans e injetá-los como dependências.
  • Escrever casos de teste unitários é fácil no framework Spring porque 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 repetitivo, como a inicialização de objetos, abertura/fechamento de recursos. Eu gosto muito da classe JdbcTemplate porque ela nos ajuda a eliminar todo o código repetitivo 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 muito mais. 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 aplicativos Android nativos. Isso torna o framework Spring um pacote completo e não precisamos procurar por diferentes frameworks para atender a diferentes requisitos.

4. Quais são os recursos importantes do Spring 5?

O Spring 5 é uma grande atualização em relação ao Spring 4. Alguns dos recursos 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 do Servlet 4.0.
  • Operações de arquivo são realizadas via fluxos NIO 2 agora, uma grande melhoria se sua aplicação lida muito com manipulação de arquivos.
  • Introdução do spring-jcl para simplificar o registro, anteriormente era confuso devido à falta de um único ponto para fins de registro.
  • Suporte para Kotlin, Lombok, Reactor 3.1 Flux, e Mono, assim como RxJava.
  • Spring WebFlux, que traz programação reativa para o Spring.
  • Suporte para JUnit 5
  • Suporte para fornecer informações sobre os componentes do Spring por meio do arquivo de índice “META-INF/spring.components” em vez da varredura do 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. O Spring WebFlux é 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 Spring WebFlux.

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

O padrão de design de Injeção de Dependência nos permite remover as dependências codificadas diretamente 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.

Alguns dos benefícios do uso da Injeção de Dependência são a Separação de Preocupações, a redução do código boilerplate, componentes configuráveis e fácil teste unitário.

Leia mais em Tutorial de Injeção de Dependência. Também podemos utilizar o 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 a 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 utilizar a configuração baseada em XML e também baseada em anotações no Spring 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 formas com um caso de teste JUnit. O post também inclui 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 recursos importantes, como suporte ao Maven, modelos para criar diferentes tipos de projetos Spring e o servidor tc 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. Cite 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 aplicações web.
  • Spring MVC – Implementação do Modelo-Visão-Controlador para criar aplicações web, serviços web, etc.

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

Aplicações empresariais possuem algumas preocupações transversais comuns que são aplicáveis a diferentes tipos de objetos e módulos de aplicativos, como registro, gerenciamento de transações, validação de dados, autenticação, etc. A modularidade da aplicação é alcançada por classes na programação orientada a objetos. Na AOP, a modularidade da aplicação é alcançada por Aspectos e eles são configurados para cortar 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, 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. Leia mais sobre o suporte do Spring AOP em Exemplo de Spring AOP.

11. O que é Aspecto, Conselho, Ponto de Corte, Ponto de Junção e Argumentos do Conselho em AOP?

Aspecto: Aspecto é uma classe que implementa preocupações transversais, como gerenciamento de transações. Aspectos podem ser uma classe normal configurada e, em seguida, 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 no Conselho como interceptadores do Spring ou Filtros do Servlet.

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

JoinPoint: Um ponto de junção é um ponto específico na aplicação, como execução de método, tratamento de exceção, alteração de valores de variáveis de objeto, etc. No Spring AOP, 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 no início, mas se você passar por Spring Aspect, Exemplo de Conselho, então você pode facilmente relacionar-se com eles.

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 do 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 pode ser aplicado apenas a 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 pode ser aplicado apenas aos beans criados através do contexto do Spring.

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

Inversão de Controle (IoC) é o mecanismo para alcançar um acoplamento flexível entre as dependências do objeto. Para alcançar um acoplamento flexível e a 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 IoC do Spring é o programa que injeta dependências em um objeto e o prepara para o nosso uso.

As classes do contêiner IoC do Framework Spring fazem parte dos pacotes org.springframework.beans e org.springframework.context e nos fornecem maneiras diferentes 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 é 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 beans e a injeção de 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 do Spring MVC, 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 um 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 este bean do contexto spring, temos que usar o seguinte trecho de código:

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

Configuração Baseada em Anotação: 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?

Há cinco escopos definidos para Spring Beans.

  1. singleton: Apenas uma instância do bean será criada para cada contêiner. Este é o escopo padrão para os spring beans. Ao usar este escopo, certifique-se de que o spring bean não tenha variáveis de instância compartilhadas, caso contrário, pode levar a problemas de inconsistência de dados devido à falta de segurança em threads.
  2. prototype: Uma nova instância será criada sempre que o bean for solicitado.
  3. request: Este é o mesmo que o escopo prototype, no entanto, é destinado a ser usado em aplicativos da 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 globais para aplicativos de portlet.

O Spring Framework é extensível e podemos criar nossos próprios escopos também. Mas na maioria das vezes, estamos satisfeitos com os escopos fornecidos pelo framework. Para definir os escopos do Spring bean, podemos usar o atributo “scope” no elemento do bean ou a @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 em beans Spring.

Podemos fazer isso de duas maneiras – implementando as interfaces InitializingBean e DisposableBean ou usando os atributos init-method e destroy-method nas configurações de beans 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 Spring Bean?

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 Bean wiring e a anotação @Autowired?

O processo de injeção de dependências de bean do Spring durante a inicialização é chamado de Bean Wiring do Spring.

Geralmente, é uma prática recomendada fazer a conexão explícita de todas as dependências do bean, mas o framework Spring também suporta a autoconexão. Podemos usar a anotação @Autowired com campos ou métodos para autowiring 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 bean do Spring. Isso pode ser feito pelo elemento context:annotation-config.

Para obter 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?

Existem quatro tipos de autowiring no framework Spring.

  1. autowire byName
  2. autowire byType
  3. autowire by constructor
  4. Autowiring por @Autowired e @Qualifier annotations

Antes do Spring 3.1, autowire by autodetect também era suportado, semelhante ao autowire by constructor ou byType. Para mais detalhes sobre essas opções, leia Spring Bean Autowiring.

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

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

No entanto, podemos alterar o escopo do spring bean para request, prototype ou session para alcançar a segurança de thread com o custo de desempenho. É uma decisão de design e baseada nos requisitos do projeto.

23. O que é um Controlador no Spring MVC?

Assim como no 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 e @Service nas anotações do Spring?

O @Component é usado para indicar que uma classe é um componente. Essas classes são usadas para detecção automática e configuradas como um bean quando configurações baseadas em anotações são usadas.

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

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

@Service é 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 isso.

Podemos usar qualquer uma das anotações acima para uma classe para detecção automática, 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 do bean Spring e inicializa todos os beans que estão configurados. Se as anotações estiverem habilitadas, ele também verifica os pacotes e configura qualquer bean anotado com @Component, @Controller, @Repository ou @Service.

O ContextLoaderListener é o ouvinte para inicializar e encerrar o root WebApplicationContext do Spring. 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 beans compartilhados que podem ser usados em diferentes contextos do Spring.

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 do bean Spring. Por exemplo:

<!-- Resolve as visualizações selecionadas para renderização por @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>

InternalResourceViewResolver é uma das implementações da interface ViewResolver e estamos fornecendo 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 upload de arquivos. Por padrão, não há resolutores multipartidos configurados, mas para usá-los para fazer upload de arquivos, tudo o que precisamos fazer é definir um bean chamado “multipartResolver” com o tipo MultipartResolver nas configurações de beans 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, por favor, leia Exemplo de Upload de Arquivo 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ção 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ção 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ção global. O motivo por trás dessa forma adicional de definir o tratador de exceção 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 os benefícios de tratamento de exceção do framework Spring.

Para um exemplo completo, por favor, leia Exemplo de Manipulação de Exceção no Spring.

29. Como criar um ApplicationContext em um programa Java?

Há várias maneiras de criar um contexto Spring em um programa Java independente.

  1. AnnotationConfigApplicationContext: Se estamos utilizando o Spring em aplicativos 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 XML de bean do Spring em um aplicativo independente, podemos usar esta classe para carregar o arquivo e obter o objeto 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 do Spring?

Para aplicações Spring MVC, podemos definir vários arquivos de configuração de contexto Spring por meio de contextConfigLocation. Essa string de localização pode consistir em várias localizações separadas 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 várias configurações raiz do Spring e carregá-las por meio 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 é o ContextLoaderListener?

O ContextLoaderListener é a classe de listener usada para carregar o contexto raiz e definir configurações de bean 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 aplicação simples 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 beans Spring para definir beans, se estiver usando anotações, elas devem ser configuradas aqui. Além disso, precisamos configurar o resolvedor de visualizações para páginas de visualização.
  • Classe do controlador com mapeamentos de solicitações definidas para lidar com as solicitações do cliente.

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

33. Como você relacionaria o Framework Spring MVC à 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 controladores.

O modelo pode ser qualquer Java Bean no Framework Spring, assim como em qualquer outro framework MVC, o Spring fornece a vinculação automática dos dados do formulário aos Java Beans. 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ções são responsáveis por encontrar a página de visualização correta. Uma vez identificada a página de visualização, o controle é devolvido ao controlador DispatcherServlet. O DispatcherServlet é responsável por renderizar a visualização e retornar a resposta final ao cliente.

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

Spring oferece excelente suporte para localização ou i18n através de pacotes de recursos. Os passos básicos necessários 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 bean 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 seleciona 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 da Primavera.

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 JSON em um serviço web Restful.

Para configurar nossa aplicação Spring MVC para enviar respostas JSON, precisamos seguir os seguintes passos.

1. Adicionar as dependências do Jackson JSON. Se estiver utilizando 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 como o bean MappingJackson2HttpMessageConverter. A configuração de exemplo será:

<!-- Configurar para incluir 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 utilizando a anotação @ResponseBody. Código de exemplo:

@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 quiser usar o Spring, pode fazê-lo facilmente usando a classe RestTemplate.

Para um exemplo completo, por favor, leia Exemplo de Serviço Web Restful Spring.

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

Algumas das anotações do Spring que eu 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 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 Upload 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 é Spring MVC Interceptor e como usá-lo?

Os Interceptors do Spring MVC são como Filtros Servlet e nos permitem interceptar solicitações do cliente e processá-las. Podemos interceptar solicitações do cliente 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 interceptador para interceptar todas as solicitações do cliente ou podemos configurá-lo para 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 Spring Framework 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ão, ResultSet, PreparedStatement, etc.

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

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

Para usar um contêiner servlet configurado com JNDI DataSource, precisamos configurá-lo no arquivo de configuração de beans do Spring e então injetá-lo nos beans do Spring como dependências. Em seguida, podemos utilizá-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 de JNDI no Spring Tomcat.

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 Declarativo de Transações, bem como do gerenciamento de transações programático. O gerenciamento declarativo de transações é o mais amplamente utilizado porque é fácil de usar e funciona na maioria dos casos.

Utilizamos a anotação @Transactional para o gerenciamento declarativo de transações. É necessário 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?

A 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 fornece 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 para o uso da gestão de transações declarativa 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 seguir os tutoriais a seguir:

46. O que é o Spring Security?

O framework Spring Security 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. Você deve ler os seguintes posts para aprender como usar o framework Spring Security.

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

Temos que definir o bean propertyConfigurer que irá 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 Spring, então você pode injetar a propriedade da seguinte forma.

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

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

O Spring Framework utiliza 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 Adapter: Spring Web e Spring MVC
  5. Padrão Proxy: Suporte à Programação Orientada a Aspectos no Spring
  6. Padrão Template Method: JdbcTemplate, HibernateTemplate, etc
  7. Controlador Frontal: Spring MVC DispatcherServlet
  8. Objeto de Acesso a Dados: Suporte DAO do Spring
  9. Injeção de Dependência e Programação Orientada a Aspectos

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

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

  • Evitar números de versão na referência de esquema, para garantir que tenhamos as configurações mais recentes.
  • Dividir as configurações de beans Spring com base em suas preocupações, como spring-jdbc.xml, spring-security.xml.
  • Para beans Spring que são usados em vários contextos no Spring MVC, criá-los no contexto raiz e inicializá-los com o listener.
  • Configurar dependências de beans o máximo possível, tentar evitar a autoconexão o máximo possível.
  • Para propriedades em nível de aplicação, a melhor abordagem é criar um arquivo de propriedades e lê-lo no arquivo de configuração de beans Spring.
  • Para aplicações menores, as anotações são úteis, mas para aplicações maiores, as anotações podem se tornar um problema. Se tivermos todas as configurações em arquivos XML, será mais fácil manter.
  • Use anotações corretas para os componentes para entender o propósito facilmente. 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 quando você cria projetos através dos modelos do Spring Tool Suite.
  • Se você está 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 por causa do acoplamento frouxo, não use porque é mais difícil de manter.

O que é o Spring Boot?

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

Isso é tudo para as perguntas de entrevista sobre o framework Spring. Espero que essas perguntas o ajudem em sua próxima entrevista de Java EE. Continuarei adicionando mais perguntas à lista assim que as encontrar. Se você conhece mais perguntas que deveriam fazer parte da lista, certifique-se de adicionar um comentário, e eu as incluirei.

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