Java面试系列总结 ：Spring

1. SpringMVC的工作原理

• a. 用户向服务器发送请求，请求被springMVC前端控制器DispatchServlet捕获；
• b. DispatcherServle对请求URL进行解析，得到请求资源标识符（URL），然后根据该URL调用HandlerMapping将请求映射到处理器HandlerExcutionChain；
• c. DispatchServlet根据获得Handler选择一个合适的HandlerAdapter适配器处理；
• d. Handler对数据处理完成以后将返回一个ModelAndView（）对象给DisPatchServlet;
• e. Handler 返回的 ModelAndView()只是一个逻辑视图并不是一个正式的视图，DispatcherSevlet 通过ViewResolver试图解析器将逻辑视图转化为真正的视图View;
• h. DispatcherServle 通过 model 解析出 ModelAndView()中的参数进行解析最终展现出完整的 view 并返回给客户端

2. SpringMVC常用注解都有哪些？

• @requestMapping 用于请求 url 映射。
• @RequestBody 注解实现接收 http 请求的 json 数据，将 json 数据转换为 java 对象。
• @ResponseBody 注解实现将 controller 方法返回对象转化为 json 响应给客户。

3. 如何开启注解处理器和适配器？

我们在项目中一般会在 springmvc.xml 中通过开启 <mvc:annotation-driven>来实现注解处 理器和适配器的开启。

4. 如何解决get和post乱码问题？

解决 post 请求乱码:我们可以在 web.xml 里边配置一个 CharacterEncodingFilter 过滤器。 设置为 utf-8. 解决 get 请求的乱码:有两种方法。对于 get 请求中文参数出现乱码解决方法有两个:

1. 修改 tomcat 配置文件添加编码与工程编码一致。
2. 另外一种方法对参数进行重新编码 String userName = New String(Request.getParameter(“userName”).getBytes(“ISO8859-1”), “utf-8”);

5. 谈谈你对Spring的理解

Spring是一个开源框架，为简化企业级应用开发而生。Spring可以是使简单的JavaBean实现以前只有EJB才能实现的功能。Spring是一个IOC和AOP容器框架。

Spring容器的主要核心是：

控制反转（IOC），传统的java开发模式中，当需要一个对象时，我们会自己使用new或者getInstance等直接或者间接调用构造方法创建一个对象。而在spring开发模式中，spring容器使用了工厂模式为我们创建了所需要的对象，不需要我们自己创建了，直接调用spring提供的对象就可以了，这是控制反转的思想。

依赖注入（DI），spring 使用 javaBean 对象的 set 方法或者带参数的构造方法为我们在创建所需对象时将其属性自动设置所需要的值的过程，就是依赖注入的思想。

面向切面编程（AOP），在面向对象编程（oop）思想中，我们将事物纵向抽成一个个的对象。而在面向切面编程中，我们将一个个的对象某些类似的方面横向抽成一个切面，对这个切面进行一些如权限控制、事物管理，记录日志等公用操作处理的过程就是面向切面编程的思想。AOP底层是动态代理，如果是接口采用JDK动态代理，如果是类采用CGLIB方式实现动态代理。

6. Spring中的设计模式

• a. 单例模式——spring中两种代理方式，若目标对象实现了若干接口，spring使用jdk的java.lang.reflect.Proxy类代理。若目标兑现没有实现任何接口，spring使用CGLIB库生成目标类的子类。在spring的配置文件中设置bean默认为单例模式。
• b. 模板方式模式——用来解决代码重复的问题。
  比如：RestTemplate、JmsTemplate、JpaTemplate
• d. 前端控制器模式——spring提供了前端控制器DispatherServlet来对请求进行分发。
• e. 试图帮助（view helper）——spring提供了一系列的JSP标签，高效宏来帮助将分散的代码整合在试图中。
• f. 依赖注入——贯穿于BeanFactory/ApplacationContext 接口的核心理念。
• g. 工厂模式——在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用同一个接口来指向新创建的对象。Spring中使用beanFactory来创建对象的实例。

7. Spring的常用注解

Spring在2.5版本以后开始支持注解的方式来配置依赖注入。可以用注解的方式来代替xml中bean的描述。注解注入将会被容器在XML注入之前被处理，所以后者会覆盖掉前者对于同一个属性的处理结果。

注解装配在 spring 中默认是关闭的。所以需要在 spring 的核心配置文件中配置一下才能使用基于注解的装配模式。配置方式如下：

<context:annotation-config /> 

常用的注解：

• @Required:该注解应用于设值方法
• @Autowired：该注解应用于有值设值方法、非设值方法、构造方法和变量。
• @Qualifier：该注解和@Autowired搭配使用，用于消除特定bean自动装配的歧义。

8. 简单介绍一下Spring bean的生命周期

bean定义：在配置文件里面用<bean></bean>来进行定义。

bean初始化：有两种方式初始化:
1.在配置文件中通过指定init-method属性来完成
2.实现 org.springframwork.beans.factory.InitializingBean接口

bean调用：有三种方式可以得到bean实例，并进行调用

bean销毁：销毁有两种方式
1.使用配置文件指定的destroy-method属性
2.实现 org.springframwork.bean.factory.DisposeableBean接口

参考资料：https://www.cnblogs.com/zrtqsk/p/3735273.html

9. Spring结构图

（1）核心容器：包括Core、Beans、Context、EL模块。

Core模块：封装了框架依赖的最底层部分，包括资源访问、类型转换及一些常用工具类。

Beans模块：提供了框架的基础部分，包括反转控制和依赖注入。其中Bean Factory是容器核心，本质是“工厂设计模式”的实现，而且无需编程实现“单例设计模式”，单例完全由容器控制，而且提倡面向接口编程，而非面向实现编程；所有应用程序对象及对象间关系由框架管理，从而真正把你从程序逻辑中把维护对象之间的依赖关系提取出来，所有这些依赖关系都由BeanFactory来维护。

Context模块：以Core和Beans为基础，集成Beans模块功能并添加资源绑定、数据验证、国际化、Java EE支持、容器生命周期、事件传播等；核心接口是ApplicationContext。

EL模块：提供强大的表达式语言支持，支持访问和修改属性值，方法调用，支持访问及修改数组、容器和索引器，命名变量，支持算数和逻辑运算，支持从Spring 容器获取Bean，它也支持列表投影、选择和一般的列表聚合等。

（2）AOP、Aspects模块：

AOP模块：Spring AOP模块提供了符合 AOP Alliance规范的面向方面的编程（aspect-oriented programming）实现，提供比如日志记录、权限控制、性能统计等通用功能和业务逻辑分离的技术，并且能动态的把这些功能添加到需要的代码中；这样各专其职，降低业务逻辑和通用功能的耦合。

Aspects模块：提供了对AspectJ的集成，AspectJ提供了比Spring ASP更强大的功能。

（3）数据访问/集成模块：该模块包括了JDBC、ORM、OXM、JMS和事务管理。

事务模块：该模块用于 Spring 管理事务，只要是 Spring 管理对象都能得到 Spring 管理事务的好处，无需在代码中进行事务控制了，而且支持编程和声明性的事务管理。

JDBC模块：提供了一个JBDC的样例模板，使用这些模板能消除传统冗长的JDBC编码还有必须的事务控制，而且能享受到Spring管理事务的好处。

ORM模块：提供与流行的“对象-关系”映射框架的无缝集成，包括Hibernate、JPA、MyBatis等。而且可以使用Spring事务管理，无需额外控制事务。

OXM模块：提供了一个对Object/XML映射实现，将java对象映射成XML数据，或者将XML数据映射成java对象，Object/XML映射实现包括JAXB、Castor、XMLBeans和XStream。

JMS模块：用于JMS(Java Messaging Service)，提供一套 “消息生产者、消息消费者”模板用于更加简单的使用JMS，JMS用于用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。

（4）Web/Remoting模块：Web/Remoting模块包含了Web、Web-Servlet、Web-Struts、Web-Porlet模块。

Web模块：提供了基础的web功能。例如多文件上传、集成IoC容器、远程过程访问（RMI、Hessian、Burlap）以及Web Service支持，并提供一个RestTemplate类来提供方便的Restful services访问。

Web-Servlet模块：提供了一个Spring MVC Web框架实现。Spring MVC框架提供了基于注解的请求资源注入、更简单的数据绑定、数据验证等及一套非常易用的JSP标签，完全无缝与Spring其他技术协作。

Web-Struts模块：提供了与Struts无缝集成，Struts1.x 和Struts2.x都支持

（5）Test模块

Test模块： Spring支持Junit和TestNG测试框架，而且还额外提供了一些基于Spring的测试功能，比如在测试Web框架时，模拟Http请求的功能。

10. Spring能帮我们做什么？

• a. Spring能帮我们根据配置文件创建及组装对象之间的依赖关系。
  Spring根据配置文件来进行创建及组装对象间依赖关系，只需要改配置文件即可

• b. Spring 面向切面编程能帮助我们无耦合的实现日志记录，性能统计，安全控制。
  Spring 面向切面编程能提供一种更好的方式来完成，一般通过配置方式，而且不需要在现有代码中添加任何额外代码，现有代码专注业务逻辑。

• c. Spring能非常简单的帮我们管理数据库事务。
  采用Spring，我们只需获取连接，执行SQL，其他事物相关的都交给Spring来管理了。

• d. Spring还能与第三方数据库访问框架（如Hibernate、JPA）无缝集成，而且自己也提供了一套JDBC访问模板，来方便数据库访问。

• e. Spring还能与第三方Web（如Struts、JSF）框架无缝集成，而且自己也提供了一套Spring MVC框架，来方便web层搭建。

• f. Spring能方便的与Java EE（如Java Mail、任务调度）整合，与更多技术整合（比如缓存框架）。

11. 请描述一下Spring的事务

声明式事务管理的定义：用在Spring配置文件中声明式的处理事务来代替代码式的处理事务。这样的好处是，事务管理不侵入开发的组件，具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可，这样维护起来极其方便。

基于 TransactionInterceptor 的声明式事务管理：两个次要的属性： transactionManager，用来指定一个事务治理器，并将具体事务相关的操作请托给它；其他一个是 Properties 类型的 transactionAttributes 属性，该属性的每一个键值对中，键指定的是方法名，方法名可以行使通配符，而值就是表现呼应方法的所运用的事务属性。

<beans...>
 ...... 
    <bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor"> 
        <property name="transactionManager" ref="transactionManager"/> 
        <property name="transactionAttributes"> 
            <props> 
                <prop key="transfer">PROPAGATION_REQUIRED</prop> 
            </props> 
        </property> 
    </bean>
    <bean id="bankServiceTarget" class="footmark.spring.core.tx.declare.origin.BankServiceImpl"> 
        <property name="bankDao" ref="bankDao"/> 
    </bean> 
    <bean id="bankService" class="org.springframework.aop.framework.ProxyFactoryBean"> 
        <property name="target" ref="bankServiceTarget"/> 
        <property name="interceptorNames"> 
            <list> 
                <idref bean="transactionInterceptor"/> 
            </list> 
        </property> 
    </bean>
 ...... 
</beans>  

基于 TransactionProxyFactoryBean 的声明式事务管理：设置配置文件与先前比照简化了许多。我们把这类设置配置文件格式称为 Spring 经典的声明式事务治理

<beans......> 
 ...... 
    <bean id="bankServiceTarget" class="footmark.spring.core.tx.declare.classic.BankServiceImpl"> 
        <property name="bankDao" ref="bankDao"/> 
    </bean> 
    <bean id="bankService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> 
        <property name="target" ref="bankServiceTarget"/> 
        <property name="transactionManager" ref="transactionManager"/> 
        <property name="transactionAttributes"> 
            <props> 
                <prop key="transfer">PROPAGATION_REQUIRED</prop> 
            </props> 
        </property> 
    </bean> 
 ...... 
 </beans>

基于 <tx> 命名空间的声明式事务治理：在前两种方法的基础上，Spring 2.x 引入了 <tx> 命名空间，连络行使 <aop> 命名空间，带给开发人员设置配备声明式事务的全新体验。

<beans......> 
 ...... 
    <bean id="bankService"  class="footmark.spring.core.tx.declare.namespace.BankServiceImpl"> 
        <property name="bankDao" ref="bankDao"/>
    </bean> 
    <tx:advice id="bankAdvice" transaction-manager="transactionManager"> 
        <tx:attributes> 
            <tx:method name="transfer" propagation="REQUIRED"/> 
        </tx:attributes> 
    </tx:advice> 

    <aop:config> 
        <aop:pointcut id="bankPointcut" expression="execution(* *.transfer(..))"/> 
        <aop:advisor advice-ref="bankAdvice" pointcut-ref="bankPointcut"/> 
    </aop:config> 
 ...... 
</beans>

基于 @Transactional 的声明式事务管理：Spring 2.x 还引入了基于 Annotation 的体式格式，具体次要触及@Transactional 标注。@Transactional 可以浸染于接口、接口方法、类和类方法上。算作用于类上时，该类的一切 public 方法将都具有该类型的事务属性。

@Transactional(propagation = Propagation.REQUIRED) 
public boolean transfer(Long fromId， Long toId， double amount) { 
    return bankDao.transfer(fromId， toId， amount); 
} 

编程式事物管理的定义：在代码中显式挪用beginTransaction()、commit()、rollback()等事务治理相关的方法，这就是编程式事务管理。Spring对事物的编程式管理有基于底层API的编程式管理和基于 TransactionTemplate 的编程式事务管理两种方式。

基于底层 API 的编程式管理 ： 凭 证 PlatformTransactionManager 、 TransactionDefinition 和 TransactionStatus 三个焦点接口，来实现编程式事务管理。

public class BankServiceImpl implements BancService{ 
    private BanckDao bankDao; 
    private TransactionDefinition txDefinition; 
    private PlatformTransactionManager txManager; 
     ...... 
    public boolean transfer(Long fromId， Long toId， double amount) { 
        TransactionStatus txStatus = txManager.getTransaction(txDefinition); 
        boolean result = false; 
        try { 
            result = bankDao.transfer(fromId， toId， amount); 
            txManager.commit(txStatus); 
        } catch (Exception e) { 
            result = false; 
            txManager.rollback(txStatus); 
            System.out.println("Transfer Error!"); 
        } 
        return result; 
    }
}

基于 TransactionTemplate 的编程式事务管理:为了不损坏代码原有的条理性，避免出现每一个方法中都包括相同的启动事物、提交、回滚事物样板代码的现象，spring 提供了 transactionTemplate 模板来实现编程式事务管理。

public class BankServiceImpl implements BankService { 
    private BankDao bankDao; 
    private TransactionTemplate transactionTemplate; 
     ...... 
    public boolean transfer(final Long fromId， final Long toId， final double amount) { 
        return (Boolean) transactionTemplate.execute(new TransactionCallback(){ 
            public Object doInTransaction(TransactionStatus status) { 
                Object result; 
                try { 
                    result = bankDao.transfer(fromId， toId， amount); 
                } catch (Exception e) { 
                    status.setRollbackOnly(); 
                    result = false; 
                    System.out.println("Transfer Error!"); 
                } 
                return result; 
            } 
        }); 
    } 
} 

编程式事务与声明式事务的区别：
1）编程式事务是自己写事务处理的类，然后调用
2）声明式事务是在配置文件中配置，一般搭配在框架里面使用！

12. BeanFactory 常用的实现类有哪些？

Bean 工厂是工厂模式的一个实现，提供了控制反转功能，用来把应用的配置和依赖从正真的应用代码中分离。常用的BeanFactory 实现有DefaultListableBeanFactory 、 XmlBeanFactory 、 ApplicationContext等。 XMLBeanFactory，最常用的就是org.springframework.beans.factory.xml.XmlBeanFactory ，它根据XML文件中的定义加载beans。该容器从XML 文件读取配置元数据并用它去创建一个完全配置的系统或应用。

13. 解释Spring JDBC、Spring DAO和Spring ORM

Spring-DAO 并非 Spring 的一个模块，它实际上是指示你写 DAO 操作、写好 DAO 操作的一些规范。因此，对于访问你的数据它既没有提供接口也没有提供实现更没有提供模板。在写一个 DAO 的时候，你应该使用 @Repository 对其进行注解，这样底层技术(JDBC，Hibernate，JPA，等等)的相关异常才能一致性地翻译为相应的 DataAccessException 子类。

Spring-JDBC 提供了 Jdbc 模板类，它移除了连接代码以帮你专注于 SQL 查询和相关参数。Spring-JDBC 还提供了一个 JdbcDaoSupport，这样你可以对你的 DAO 进行扩展开发。它主要定义了两个属性：一个 DataSource 和一个 JdbcTemplate，它们都可以用来实现 DAO 方法。JdbcDaoSupport 还提供了一个将 SQL 异常转换为 Spring DataAccessExceptions 的异常翻译器。

Spring-ORM 是一个囊括了很多持久层技术(JPA，JDO，Hibernate，iBatis)的总括模块。对于这些技术中的每一个，Spring 都提供了集成类，这样每一种技术都能够在遵循 Spring 的配置原则下进行使用，并平稳地和 Spring 事务管理进行集成。

对于每一种技术， 配 置 主 要 在 于 将 一 个 DataSource bean 注入到某种 SessionFactory 或者 EntityManagerFactory 等 bean 中。纯 JDBC 不需要这样的一个集成类(JdbcTemplate 除外)，因为 JDBC 仅依赖于一个 DataSource。

如果你计划使用一种 ORM 技术，比如 JPA 或者 Hibernate，那么你就不需要 Spring-JDBC 模块了，你需要的是这个 Spring-ORM 模块。

14. 简单介绍一下Spring WEB 模块。

Spring的WEB模块是构建在application context 模块基础之上，提供一个适合web应用的上下文。这个模块也包括支持多种面向web的任务，如透明地处理多个文件上传请求和程序级请求参数的绑定到你的业务对象。它也有对Jakarta Struts的支持。

15. Spring配置文件有什么作用？

Spring配置文件是个XML 文件，这个文件包含了类信息，描述了如何配置它们，以及如何相互调用。

16. 什么是Spring IOC 容器？

IOC 控制反转：Spring IOC 负责创建对象，管理对象。通过依赖注入（DI），装配对象，配置对象，并且管理这些对象的整个生命周期。

17. IOC的优点是什么

IOC 或 依赖注入把应用的代码量降到最低。它使应用容易测试，单元测试不再需要单例和 JNDI 查找机制。最小的代价和最小的侵入性使松散耦合得以实现。IOC容器支持加载服务时的饿汉式初始化和懒加载。

**18. ApplicationContext的实现类有哪些? **

FileSystemXmlApplicationContext ：此容器从一个XML文件中加载beans的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。

ClassPathXmlApplicationContext：此容器也从一个 XML 文件中加载 beans 的定义，这里，你需要正确设置classpath因为这个容器将在classpath里找bean配置。

WebXmlApplicationContext：此容器加载一个XML文件，此文件定义了一个WEB应用的所有bean。

19. BeanFactory与AppliacationContext有什么区别

1.BeanFactory

基础类型的IOC容器，提供完成的IOC服务支持。如果没有特殊指定，默认采用延迟初始化策略。相对来说，容器启动初期速度较快，所需资源有限。

2.ApplicationContext

ApplicationContext 是在 BeanFactory 的基础上构建，是相对比较高级的容器实现，除了 BeanFactory 的所有
支持外，ApplicationContext还提供了事件发布、国际化支持等功能。ApplicationContext管理的对象，在容器启动
后默认全部初始化并且绑定完成。

20. 什么是Spring的依赖注入？

平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过 spring 容器帮我们 new 指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们 new 一个实例，这个实例的控制权是我们程序员，而控制反转是指 new 实例工作不
由我们程序员来做而是交给spring容器来做。

21. 有哪些不同类型的IOC（依赖注入）方式？

Spring提供了多种依赖注入的方式。
1.Set注入
2.构造器注入
3.静态工厂的方法注入
4.实例工厂的方法注入

参考资料：https://www.cnblogs.com/java-class/p/4727775.html

22. 什么是Spring beans?

Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC 容器初始化，装配，和管理。这些beans通过容器中配置的元数据创建。比如，以XML文件中 的形式定义。 Spring 框架定义的beans都是单例 beans。

23. 一个 Spring Beans的定义需要包含什么？

一个 Spring Bean 的定义包含容器必知的所有配置元数据，包括如何创建一个 bean，它的生命周期详情及它的依赖。

24. 你怎样定义类的作用域?

当定义一个<bean> 在Spring里，我们还能给这个bean声明一个作用域。它可以通过bean 定义中的scope属性来定义。如，当 Spring 要在需要的时候每次生产一个新的 bean 实例，bean 的 scope 属性被指定为 prototype。另一方面，一个bean每次使用的时候必须返回同一个实例，这个bean的scope 属性必须设为 singleton。

25. Spring支持的几种bean的作用域。

Spring框架支持以下五种bean的作用域：

• singleton : bean在每个Spring ioc 容器中只有一个实例。
• prototype：一个bean的定义可以有多个实例。
• request：每次http请求都会创建一个bean，该作用域仅在基于web的Spring ApplicationContext情形下有效。
• session：在一个 HTTP Session 中，一个 bean 定义对应一个实例。该作用域仅在基于 web 的Spring ApplicationContext情形下有效。
• global-session：在一个全局的 HTTP Session 中，一个 bean 定义对应一个实例。该作用域仅在基于 web 的Spring ApplicationContext情形下有效。

缺省的Spring bean 的作用域是Singleton。

26. Spring框架中的单例bean是线程安全的吗?

Spring框架中的单例bean不是线程安全的。

27. 什么是Spring的内部bean？

当一个 bean 仅被用作另一个 bean 的属性时，它能被声明为一个内部 bean，为了定义 inner bean，在Spring 的 基于XML的 配置元数据中，可以在 <property/>或 <constructor-arg/> 元素内使用<bean/> 元素，内部bean通常是匿名的，它们的Scope一般是prototype。

28. 在 Spring中如何注入一个java集合？

Spring提供以下几种集合的配置元素：
<list>类型用于注入一列值，允许有相同的值。
<set> 类型用于注入一组值，不允许有相同的值。
<map> 类型用于注入一组键值对，键和值都可以为任意类型。
<props>类型用于注入一组键值对，键和值都只能为String类型。

29. 什么是bean的自动装配？

无须在Spring配置文件中描述javaBean之间的依赖关系（如配置<property>、<constructor-arg>）。IOC容器会自动建立javabean之间的关联关系。

30. 解释不同方式的自动装配 。

有五种自动装配的方式，可以用来指导Spring容器用自动装配方式来进行依赖注入。

1）no：默认的方式是不进行自动装配，通过显式设置ref 属性来进行装配。

2）byName：通过参数名自动装配，Spring 容器在配置文件中发现 bean 的autowire 属性被设置成 byname，之后容器试图匹配、装配和该bean的属性具有相同名字的bean。

3）byType：通过参数类型自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byType，之后容器试图匹配、装配和该bean的属性具有相同类型的bean。如果有多个bean符合条件，则抛出错误。

4）constructor：这个方式类似于 byType， 但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。

5）autodetect：首先尝试使用constructor来自动装配，如果无法工作，则使用byType方式。

31. 什么是基于Java的Spring注解配置? 给一些注解的例子

基于Java的配置，允许你在少量的Java注解的帮助下，进行你的大部分Spring配置而非通过XML文件。 以@Configuration 注解为例，它用来标记类可以当做一个 bean 的定义，被 Spring IOC 容器使用。另一个例子是@Bean注解，它表示此方法将要返回一个对象，作为一个bean注册进Spring应用上下文。

32. 什么是基于注解的容器配置?

相对于XML文件，注解型的配置依赖于通过字节码元数据装配组件，而非尖括号的声明。开发者通过在相应的类，方法或属性上使用注解的方式，直接组件类中进行配置，而不是使用xml表述bean的装配关系。

33. 怎样开启注解装配？

注解装配在默认情况下是不开启的，为了使用注解装配，我们必须在 Spring 配置文件中配置 <context:annotation-config/>元素。

34. 在Spring框架中如何更有效地使用JDBC?

使用 SpringJDBC 框架，资源管理和错误处理的代价都会被减轻。所以开发者只需写 statements 和 queries 从数据存取数据，JDBC也可以在Spring框架提供的模板类的帮助下更有效地被使用，这个模板叫JdbcTemplate 。 JdbcTemplate 类提供了很多便利的方法解决诸如把数据库数据转变成基本数据类型或对象，执行写好的或可调用的数据库操作语句，提供自定义的数据错误处理。

**35. 使用Spring通过什么方式访问Hibernate? **

在Spring中有两种方式访问Hibernate：
1）控制反转 HibernateTemplate和 Callback。
2）继承 HibernateDAOSupport提供一个AOP 拦截器。

36. Spring支持的ORM框架有哪些？

Spring支持以下ORM：
Hibernate、iBatis、JPA (Java Persistence API)、TopLink、JDO (Java Data Objects)、OJB

37. 简单解释一下spring的AOP

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在 OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

AOP 技术恰恰相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。 AOP核心就是切面，它将多个类的通用行为封装成可重用的模块，该模块含有一组API提供横切功能。比如，一个日志模块可以被称作日志的AOP切面。根据需求的不同，一个应用程序可以有若干切面。在Spring AOP中，切面通过带有@Aspect注解的类实现。

38. 在Spring AOP 中，关注点和横切关注的区别是什么？

关注点是应用中一个模块的行为，一个关注点可能会被定义成一个我们想实现的一个功能。横切关注点是一个关注点，此关注点是整个应用都会使用的功能，并影响整个应用，比如日志，安全和数据传输，几乎应用的每个模块都需要的功能。因此这些都属于横切关注点。

39. 什么是连接点？

被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器。

40. Spring的通知是什么？有哪几种类型？

通知是个在方法执行前或执行后要做的动作，实际上是程序执行时要通过SpringAOP框架触发的代码段。
Spring切面可以应用五种类型的通知：
1）before：前置通知，在一个方法执行前被调用。
2）after: 在方法执行之后调用的通知，无论方法执行是否成功。
3）after-returning: 仅当方法成功完成后执行的通知。
4）after-throwing: 在方法抛出异常退出时执行的通知。
5）around: 在方法执行之前和之后调用的通知。

41. 什么是切点？

切入点是一个或一组连接点，通知将在这些位置执行。可以通过表达式或匹配的方式指明切入点。

42. 什么是目标对象?

被一个或者多个切面所通知的对象。它通常是一个代理对象。也指被通知（advised）对象。

43. 什么是代理?

代理是通知目标对象后创建的对象。从客户端的角度看，代理对象和目标对象是一样的。

44. 什么是织入？什么是织入应用的不同点？

织入是将切面和到其他应用类型或对象连接或创建一个被通知对象的过程。织入可以在编译时，加载时，或运行时完成。

45. SpringMvc 拦截器用过吗？什么场景会用到，过滤器，拦截器，监听器有什么区别？

拦截器是指通过统一拦截从浏览器发往服务器的请求来完成功能的增强。
使用场景：解决请求的共性问题（乱码问题、权限验证问题）

过滤器

Servlet 中的过滤器 Filter 是实现了 javax.servlet.Filter 接口的服务器端程序，主要的用途是过滤字符编码、做一些业务逻辑判断等。其工作原理是，只要你在web.xml文件配置好要拦截的客户端请求，它都会帮你拦截到请求，此时你就可以对请求或响应(Request、Response)统一设置编码，简化操作；同时还可进行逻辑判断，如用户是否已经登陆、有没有权限访问该页面等等工作。它是随你的web应用启动而启动的，只初始化一次，以后就可以拦截相关请求，只有当你的web应用停止或重新部署的时候才销毁。

监听器

现在来说说Servlet的监听器Listener，它是实现了javax.servlet.ServletContextListener 接口的服务器端程序，它也是随web应用的启动而启动，只初始化一次，随web应用的停止而销毁。主要作用是： 做一些初始化的内容添加工作、设置一些基本的内容、比如一些参数或者是一些固定的对象等等

拦截器

拦截器是在面向切面编程中应用的，就是在你的service或者一个方法前调用一个方法，或者在方法后调用一个方法。是基于JAVA的反射机制。拦截器不是在web.xml

46. SpringMVC request 接收设置是线程安全的吗？

是线程安全的，request、response以及requestcontext在使用时不需要进行同步。而根据spring的默认规则，controller对于beanfactory而言是单例的。即controller只有一个， controller 中的request等实例对象也只有一个

47. mvc 的各个部分都有哪些技术来实现？如何实现的？

MVC 是 Model－View－Controller 的简写。 Model 代表的是应用的业务逻辑（ 通过 JavaBean， EJB 组件实现）， View 是应用的表示面（ 由 JSP 页面产生）， Controller 是提供应用的处理过程控制（ 一般是一个 Servlet）， 通过这种设计模型把应用逻辑， 处 理过程和显示逻辑分成不同的组件实现。 这些组件可以进行交互和重用。

48. SpringMVC和SpringBoot的区别

Spring MVC是提供了一种轻度耦合的方式来开发web应用。
Spring Boot实现了自动配置，降低了项目搭建的复杂度。

49. SpringBoot多环境配置

配置激活选项
spring.profiles.active=development（变量）
添加其他文件
yaml多环境配置
1.配置激活选项，spring profiles.active
2.在配置文件添加三个英文状态的短横线即可区分

50. SpringBoot的理解

Springboot里面已经集成了spring，springMVC，还有MySQL，Oracle数据库等，当我们创建项目的时候，选择这些既可以，当然当我们需要其他依赖的时候在pom.xml中配置也可以。我觉得SpringBoot中最重要的是入口的main方法。它里面是有一个注解@SpringbootApplication。当我们启动springboot的项目时，会从这里自动配置SpringBean，SpringMvc等这些。而且Spring它有自带的Tomcat服务器。

欢迎关注作者的公众号《Java编程生活》，每日记载Java程序猿工作中遇到的问题