面试总结：springMVC,spring 44道Spring面试题和答案

一、SpringMVC

1. SpringMVC 的工作原理

• 1）用户向服务器发送请求，请求被springMVC 前端控制器 DispatchServlet 捕获；
• 2）DispatcherServlet 对请求 URL 进行解析，得到请求资源标识符（URL），然后根据该 URL 调用 HandlerMapping
  将请求映射到处理器 HandlerExcutionChain；
• 3）DispatchServlet 根据获得 Handler 选择一个合适的HandlerAdapter 适配器处理；
• 4）Handler 对数据处理完成以后将返回一个 ModelAndView（）对象给 DisPatchServlet;
• 5）Handler 返回的 ModelAndView() 只是一个逻辑视图并不是一个正式的视图， DispatcherSevlet 通过
  ViewResolver 试图解析器将逻辑视图转化为真正的视图View;
• 6）DispatcherServlet 通过 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.

 <!--2.字符编码过滤器-->
 <filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>utf-8</param-value>
    </init-param>
 </filter>
 <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
 </filter-mapping>

解决 get 请求的乱码: 有两种方法

• 1.修改 tomcat 配置文件添加编码与工程编码一致。
• 2.对 参 数 进 行 重 新 编 码

String	userName  =	New String(Request.getParameter(“userName”).getBytes(“ISO8859-1”), “utf-8”);

---

二、Spring

1. 谈谈你对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 方式实现动态代理。

---

2. Spring 中的设计模式

1.简单工厂模式

又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。

spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。如下配置

 <beans>
 <!--2.1.创建 SecurityManager-->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <!--注入Realm-->
        <property name="realm" ref="authRealm"/>
    </bean>
 </beans>

2.工厂方法模式

我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用同一个接口来指向新创建的对象, 通常由应用程序直接使用new创建新的对象，为了将对象的创建和使用相分离，采用工厂模式,即应用程序将对象的创建及初始化职责交给工厂对象。Spring 中使用 beanFactory 来创建对象的实例。
Spring框架的IOC就是基于工厂模式

3.单例模式

在 spring 的配置文件中设置 bean 默认为单例模式

4.适配器模式

在Spring的Aop中，使用的Advice（通知）来增强被代理类的功能。Spring实现这一AOP功能的原理就使用代理模式（1、JDK动态代理。2、CGLib字节码生成技术代理。）对类进行方法级别的切面增强，即，生成被代理类的代理类， 并在代理类的方法前，设置拦截器，通过执行拦截器重的内容增强了代理方法的功能，实现的面向切面编程。
Spring框架的AOP就是基于适配器模式

5.包装器模式

在我们的项目中遇到这样一个问题：我们的项目需要连接多个数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库。我们以往在spring和hibernate框架中总是配置一个数据源，因而sessionFactory的dataSource属性总是指向这个数据源并且恒定不变，所有DAO在使用sessionFactory的时候都是通过这个数据源访问数据库。

但是现在，由于项目的需要，我们的DAO在访问sessionFactory的时候都不得不在多个数据源中不断切换，问题就出现了：如何让sessionFactory在执行数据持久化的时候，根据客户的需求能够动态切换不同的数据源？我们能不能在spring的框架下通过少量修改得到解决？是否有什么设计模式可以利用呢？

首先想到在spring的applicationContext中配置所有的dataSource。这些dataSource可能是各种不同类型的，比如不同的数据库：Oracle、SQL Server、MySQL等，也可能是不同的数据源：比如apache 提供的org.apache.commons.dbcp.BasicDataSource、spring提供的org.springframework.jndi.JndiObjectFactoryBean等。然后sessionFactory根据客户的每次请求，将dataSource属性设置成不同的数据源，以到达切换数据源的目的。

spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。

<!--db.properties-->
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/saas-export?characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456



<!--读取db.properties文件-->
<context:property-placeholder location="classpath:properties/db.properties">
</context:property-placeholder>

<!--1.配置数据源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="url" value="${jdbc.url}"/>
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

6.代理模式

为其他对象提供一种代理以控制对这个对象的访问。 从结构上来看和装饰者(Decorator)模式类似，但代理（Proxy）模式是控制，更像是一种对功能的限制，而装饰者(Decorator)模式是增加职责。
spring的Proxy模式在aop中有体现，比如JdkDynamicAopProxy和Cglib2AopProxy。

7.观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
spring中Observer模式常用的地方是listener的实现。如ApplicationListener。

8.策略模式

定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。
spring中在实例化对象的时候用到

9.模板方法模式

用来解决代码重复的问题，一般是需要继承的。
比如：RestTemplate、JmsTemplate、JpaTemplate、
--------JdbcTemplate（spring-jdbc提供的数据库核心操作类）

---

3.Spring 的常用注解

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

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

<context:annotation-config />

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

---

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

定义-》初始化-》调用-》销毁
bean 定义：在配置文件里面用来进行定义。
bean 初始化：有两种方式初始化:

1. 在配置文件中通过指定 init-method 属性来完成
2. 实现 org.springframwork.beans.factory.InitializingBean 接口

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

1. 使用配置文件指定的 destroy-method 属性
2. 实现 org.springframwork.bean.factory.DisposeableBean 接口

---

5.Spring 结构图

---

6. Spring 能帮我们做什么？

1. Spring 能帮我们根据配置文件创建及组装对象之间的依赖关系。

Spring 根据配置文件来进行创建及组装对象间依赖关系，只需要改配置文件即可

2. Spring 面向切面编程(Aspect)能帮助我们无耦合的实现日志记录，性能统计，安全控制。

Spring 面向切面编程能提供一种更好的方式来完成，一般通过配置方式，而且不需要在现有代码中添加任何额外代码，现有代码专注业务逻辑。

3. Spring 能非常简单的帮我们管理数据库事务。

采用 Spring，我们只需获取连接，执行 SQL，其他事物相关的都交给 Spring 来管理了。

4. Spring还能与第三方数据库访问框架（如 Hibernate、JPA）无缝集成

自己也提供了一套 JDBC访问模板，来方便数据库访问。

5. Spring 还能与第三方Web（如Struts、JSF）框架无缝集成

自己也提供了一套 Spring MVC 框架，来方便web 层搭建。

6. Spring 能方便的与 Java EE（如Java Mail、任务调度）整合

与更多技术整合（比如缓存框架）。

---

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

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

-------------------我用到的BeanFactory ,配置分页pagehelper-----------------
<!--2.配置Spring整合Mybatis *** 由Spring创建SqlSessionFactory对象-->
    <!--2.1 配置SqlSessionFactoryBean-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!-- com.wzx.domain.company.Company  company-->
        <property name="typeAliasesPackage" value="com.ly.domain"/>
        <property name="plugins">
            <array>
                <bean class="com.github.pagehelper.PageInterceptor">
                    <property name="properties">
                        <!--使用下面的方式配置参数，一行配置一个 -->
                        <!-- pageNum<=0 时会查询第一页 -->
                        <!-- 指定数据库方言 -->
                        <value>
                            reasonable=true
                            helperDialect=mysql
                        </value>
                    </property>
                </bean>
            </array>
        </property>

    </bean>

---

8. 解释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 模块。

---

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

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

---

12. 什么是Spring IOC 容器？

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

---

13. IOC 的优点是什么？

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

---

14. ApplicationContext 的实现类有哪些?

FileSystemXmlApplicationContext：此容器从一个XML 文件中加载beans 的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。
ClassPathXmlApplicationContext：此容器也从一个 XML 文件中加载 beans 的定义，这里，你需要正确设置classpath 因为这个容器将在 classpath 里找 bean 配置。
WebXmlApplicationContext：此容器加载一个 XML 文件，此文件定义了一个WEB 应用的所有 bean。

---

15. BeanFactory 与 AppliacationContext 有什么区别?

1. BeanFactory
   基础类型的 IOC 容器，提供完成的 IOC 服务支持。如果没有特殊指定，默认采用延迟初始化策略。相对来说，容器启动初期速度较快，所需资源有限。
2. ApplicationContext
   ApplicationContext 是在 BeanFactory 的基础上构建，是相对比较高级的容器实现，除了 BeanFactory 的所有支持外，ApplicationContext 还提供了事件发布、国际化支持等功能。ApplicationContext 管理的对象，在容器启动后默认全部初始化并且绑定完成。

---

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

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

---

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

Spring 提供了多种依赖注入的方式。

1. Set 注入
2. 构造器注入
3. 静态工厂的方法注入
4. 实例工厂的方法注入

参考链接：不同类型的 IOC（依赖注入）方式

---

18. 什么是Spring beans?

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

---

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

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

---

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

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

---

21. 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。

---

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

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

---

23. 什么是Spring 的内部 bean？

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

---

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

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

---

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

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

---

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

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

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

• autowire=“no”

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

• autowire=“byName”

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

• autowire=“byType”

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

• autowire=“constructor”

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

• autowire=“autodetect”

---

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

基于Java 的配置，允许你在少量的Java 注解的帮助下，进行你的大部分 Spring 配置而非通过 XML 文件。

以@Configuration 注解为例，它用来标记类可以当做一个 bean 的定义，被 Spring IOC 容器使用。

另一个例子是@Bean 注解，它表示此方法将要返回一个对象，作为一个bean 注册进 Spring 应用上下文。

---

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

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

---

29. 怎样开启注解装配？

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

---

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

使用 SpringJDBC 框架，资源管理和错误处理的代价都会被减轻。所以开发者只需写 statements 和 queries 从数据存取数据，JDBC 也可以在 Spring 框架提供的模板类的帮助下更有效地被使用，这个模板叫 JdbcTemplate 。

JdbcTemplate 类提供了很多便利的方法解决诸如把数据库数据转变成基本数据类型或对象，执行写好的或可调用的数据库操作语句，提供自定义的数据错误处理。

---

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

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

---

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

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

---

33. 简单解释一下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 注解的类实现。

---

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

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

---

35. 什么是连接点？

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

---

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

通知是个在方法执行前或执行后要做的动作，实际上是程序执行时要通过 SpringAOP 框架触发的代码段。
Spring 切面可以应用五种类型的通知：

• 1） before：前置通知，在一个方法执行前被调用。
• 2） after: 在方法执行之后调用的通知，无论方法执行是否成功。
• 3） after-returning: 仅当方法成功完成后执行的通知。
• 4） after-throwing: 在方法抛出异常退出时执行的通知。
• 5） around: 在方法执行之前和之后调用的通知。

---

37. 什么是切点？

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

---

38. 什么是目标对象?

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

---

39. 什么是代理?

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

---

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

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

---