百度面试官：来聊聊Spring吧

秒速五厘米 2021-08-29 17:36 342阅读 0赞

### 文章目录 ###

*  Spring入门和IOC介绍
 *   *  1. Spring介绍
     *   *  1.1侵入式概念
         *  1.2 松耦合概念
         *  1.3 切面编程
     *  2. 引出Spring
     *   *  2.1 IOC控制反转
     *  3.Spring模块
     *  4. Core模块快速入门
     *   *  4.1搭建配置环境
         *  4.2 得到Spring容器对象【IOC容器】
         *   *  4.2.1通过Resource获取BeanFactory
             *  4.2.2类路径下XML获取ApplicationContext
         *  4.3XML配置方式
         *   *  4.3.1带参数的构造函数创建对象
             *  4.3.2工厂静态方法创建对象
             *  4.3.3工厂非静态方法创建对象
             *  4.3.4 c名称空间
             *  4.3.5装载集合
         *  4.4注解方式
         *  4.5通过JavaConfig方式
         *  4.6三种方式混合使用？
     *  5. bean对象创建细节
     *   *  5.1 scope属性
         *  5.2lazy-init属性
         *  5.3 init-method和destroy-method
         *  5.4 Bean创建细节总结
 *  对象依赖
 *   *  1. 回顾以前对象依赖
     *   *  1.1 直接new对象
         *  1.2 写DaoFactory，用字符串来维护依赖关系
         *  1.3 DaoFactory读取配置文件
     *  2. Spring依赖注入
     *   *  2.1 搭建测试环境
         *  2.2构造函数给属性赋值
         *  2.3通过set方法给属性注入值
         *  2.4 内部Bean
         *  2.5 p 名称空间注入属性值
         *  2.6 自动装配
         *   *  2.6.1XML配置根据名字
             *  2.6.2 XML配置根据类型
         *  2.7 使用注解来实现自动装配
 *  AOP入门
 *   *  1. cglib代理
     *   *  1.1 编写cglib代理
     *  2. 手动实现AOP编程
     *   *  2.1案例分析：
         *  2.2工厂静态方法：
         *  2.3 工厂非静态方法
     *  3. AOP的概述
     *  4. 使用Spring AOP开发步骤
     *   *  4.1 引入名称空间
         *  4.2注解方式实现AOP编程
         *   *  4.2.1在配置文件中开启AOP注解方式
             *  4.2.2代码：
         *  4.3目标对象没有接口
         *  4.4 AOP注解API
         *  4.5表达式优化
         *  4.6 XML方式实现AOP编程
     *  5. 切入点表达式
     *   *  5.1 查官方文档
         *  5.2语法解析
         *  5.3 测试代码
 *  JDBCTemplate和Spring事务
 *   *  1. 回顾对模版代码优化过程
     *  2. 使用Spring的JDBC
     *   *  2.1 JdbcTemplate查询
     *  3. 事务控制概述
     *   *  3.1 编程式事务控制
         *  3.2声明式事务控制
         *  3.3 声明式事务控制教程
         *   *  3.3.1搭建配置环境
             *  3.3.2XML方式实现声明式事务控制
             *  3.3.3 使用注解的方法实现事务控制
     *  4.事务属性
     *   *  4.1事务传播行为:
         *  4.2 当事务传播行为是Propagation.REQUIRED
         *  4.3当事务传播行为是Propagation.REQUIRED\_NEW
 *  Spring事务原理
 *   *  一、阅读本文需要的基础知识
     *  二、两个不靠谱直觉的例子
     *   *  2.1第一个例子
         *  2.2第二个例子
         *   *  2.2.1再延伸一下
     *  三、Spring事务传播机制
     *  四、多线程问题
     *  五、啥是BPP？
     *   *  5.1为什么特意讲BPP？
     *  六、认识Spring事务几个重要的接口
 *  Spring事务的一个线程安全问题
 *   *  一、我的思考
     *  二、图解出现的原因
     *  三、解决问题
     *  最后
 *  IOC再回顾和面试题
 *   *  一、Spring IOC全面认知
     *   *  1.1IOC和DI概述
         *  1.2IOC容器的原理
         *  1.3IOC容器装配Bean
         *   *  1.3.1装配Bean方式
             *  1.3.2依赖注入方式
             *  1.3.3对象之间关系
             *  1.3.4Bean的作用域
             *  1.3.6处理自动装配的歧义性
             *  1.3.7引用属性文件以及Bean属性
             *  1.3.8组合配置文件
             *  1.3.9装配Bean总结
     *  二、Spring IOC相关面试题
     *   *  2.1什么是spring?
         *  2.2使用Spring框架的好处是什么？
         *  2.3Spring由哪些模块组成?
         *  2.4BeanFactory 实现举例
         *  2.5什么是Spring的依赖注入？
         *  2.6有哪些不同类型的IOC（依赖注入）方式？
         *  2.7哪种依赖注入方式你建议使用，构造器注入，还是 Setter方法注入？
         *  2.8什么是Spring beans?
         *  2.9解释Spring框架中bean的生命周期
         *  2.10解释不同方式的自动装配
         *  2.11IOC的优点是什么？
         *  2.12哪些是重要的bean生命周期方法？ 你能重载它们吗？
         *  2.13怎么回答面试官：你对Spring的理解？
         *  2.14Spring框架中的单例Beans是线程安全的么？
         *  2.15FileSystemResource和ClassPathResource有何区别？
 *  AOP再回顾
 *   *  一、Spring AOP全面认知
     *   *  1.1AOP概述
         *  1.2Spring AOP原理
         *  1.3AOP的实现者
         *  1.4AOP的术语
         *  1.5Spring对AOP的支持
     *  二、基于代理的经典SpringAOP
     *  三、拥抱基于注解和命名空的AOP编程
     *   *  3.1使用引介/引入功能实现为Bean引入新方法
         *  3.2在XML中声明切面
     *  四、总结
     *  各类知识点总结
     *   *   *  涵盖Java后端所有知识点的开源项目（已有8K+ star）：

# Spring入门和IOC介绍 #

## 1. Spring介绍 ##

Spring诞生：

*  创建Spring的目的就是用来**替代更加重量级的的企业级Java技术**
 *  **简化Java的开发**
    
     *  基于POJO轻量级和**最小侵入式开发**
     *  通过依赖注入和面向接口实现**松耦合**
     *  **基于切面**和惯例进行声明式编程
     *  通过切面和模板\*\*减少样板式代码 \*\*

### 1.1侵入式概念 ###

**侵入式**：对于EJB、Struts2等一些传统的框架，**通常是要实现特定的接口，继承特定的类才能增强功能**

*  **改变了java类的结构**

**非侵入式**：对于Hibernate、Spring等框架，**对现有的类结构没有影响，就能够增强JavaBean的功能**

### 1.2 松耦合概念 ###

前面我们在写程序的时候，都是**面向接口编程，通过DaoFactroy等方法来实现松耦合**

private CategoryDao categoryDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.CategoryDAOImpl", CategoryDao.class);
    
    private BookDao bookDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.BookDaoImpl", BookDao.class);
    
    private UserDao userDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.UserDaoImpl", UserDao.class);
    
    private OrderDao orderDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.OrderDaoImpl", OrderDao.class);

代码如下：

![format_png][]

DAO层和Service层通过DaoFactory来实现松耦合，如果Serivce层直接`new DaoBook()`，那么DAO和Service就紧耦合了【Service层依赖紧紧依赖于Dao】。

而Spring给我们更加合适的方法来实现松耦合，并且更加灵活、功能更加强大！---->**IOC控制反转**（这个后面会说）

### 1.3 切面编程 ###

切面编程也就是AOP编程，其实我们在之前也接触过…**动态代理就是一种切面编程了**…

当时我们使用**动态代理+注解的方式给Service层的方法添加权限**.

@Override
        @permission("添加分类")
        /*添加分类*/
        public void addCategory(Category category) { 
            categoryDao.addCategory(category);
        }
    
    
        /*查找分类*/
        @Override
        public void findCategory(String id) { 
            categoryDao.findCategory(id);
        }
    
        @Override
        @permission("查找分类")
        /*查看分类*/
        public List<Category> getAllCategory() { 
            return categoryDao.getAllCategory();
        }
    
        /*添加图书*/
        @Override
        public void addBook(Book book) { 
            bookDao.addBook(book);
    
        }

Controller调用Service的时候，Service返回的是一个代理对象，代理对象得到Controller想要调用的方法，通过**反射**来看看该方法上有没有注解

如果有注解的话，那么就判断该用户是否有权限来调用 此方法，如果没有权限，就抛出异常给Controller，Controller接收到异常，就可以提示用户没有权限了。

AOP编程可以简单理解成：**在执行某些代码前，执行另外的代码**（Struts2的拦截器也是面向切面编程【在执行Action业务方法之前执行拦截器】）

Spring也为我们**提供更好地方式来实现面向切面编程**！

## 2. 引出Spring ##

我们试着回顾一下没学Spring的时候，是怎么开发Web项目的

*  **1. 实体类—>class User\{ \}**
 *  **2. daoclass–> UserDao\{ … 访问db\}**
 *  **3. service—>class UserService\{ UserDao userDao = new UserDao();\}**
 *  **4. actionclass UserAction\{UserService userService = new UserService();\}**

**用户访问：Tomcat->servlet->service->dao**

我们来思考几个问题：

*  ①：**对象创建创建能否写死？**
 *  ②：对象创建细节
    
     *  **对象数量**
        
         *      action  多个   【维护成员变量】
         *      service 一个   【不需要维护公共变量】
         *      dao     一个   【不需要维护公共变量】
     *  **创建时间**
        
         *      action    访问时候创建
         *      service   启动时候创建
         *      dao       启动时候创建
 *  ③：对象的依赖关系
    
     *  **action 依赖 service**
     *  **service依赖 dao**

对于第一个问题和第三个问题，**我们可以通过DaoFactory解决掉(虽然不是比较好的解决方法)**

对于第二个问题，我们要**控制对象的数量和创建时间就有点麻烦了**…

而**Spring框架通过IOC就很好地可以解决上面的问题**…

### 2.1 IOC控制反转 ###

Spring的核心思想之一：**Inversion of Control , 控制反转 IOC**

那么控制反转是什么意思呢？？？**对象的创建交给外部容器完成，这个就做控制反转。**

*  **Spring使用控制反转来实现对象不用在程序中写死**
 *  **控制反转解决对象处理问题【把对象交给别人创建】**

那么对象的对象之间的依赖关系Spring是怎么做的呢？？**依赖注入：dependency injection.**

*  **Spring使用依赖注入来实现对象之间的依赖关系**
 *  **在创建完对象之后，对象的关系处理就是依赖注入**

上面已经说了，控制反转是通过外部容器完成的，**而Spring又为我们提供了这么一个容器，我们一般将这个容器叫做：IOC容器.**

**无论是创建对象、处理对象之间的依赖关系、对象创建的时间还是对象的数量，我们都是在Spring为我们提供的IOC容器上配置对象的信息就好了。**

那么使用IOC控制反转这一思想有什么作用呢？？？我们来看看一些优秀的回答…

来自知乎：[https://www.zhihu.com/question/23277575/answer/24259844][https_www.zhihu.com_question_23277575_answer_24259844]

我摘取一下核心的部分：

> ioc的思想最核心的地方在于，资源不由使用资源的双方管理，而由不使用资源的第三方管理，这可以带来很多好处。**第一，资源集中管理，实现资源的可配置和易管理**。**第二，降低了使用资源双方的依赖程度，也就是我们说的耦合度**。
> 
> 也就是说，甲方要达成某种目的不需要直接依赖乙方，它只需要达到的目的告诉第三方机构就可以了，比如甲方需要一双袜子，而乙方它卖一双袜子，它要把袜子卖出去，并不需要自己去直接找到一个卖家来完成袜子的卖出。它也只需要找第三方，告诉别人我要卖一双袜子。这下好了，甲乙双方进行交易活动，都不需要自己直接去找卖家，相当于程序内部开放接口，卖家由第三方作为参数传入。甲乙互相不依赖，而且只有在进行交易活动的时候，甲才和乙产生联系。反之亦然。这样做什么好处么呢，甲乙可以在对方不真实存在的情况下独立存在，而且保证不交易时候无联系，想交易的时候可以很容易的产生联系。甲乙交易活动不需要双方见面，避免了双方的互不信任造成交易失败的问题。**因为交易由第三方来负责联系，而且甲乙都认为第三方可靠。那么交易就能很可靠很灵活的产生和进行了**。这就是ioc的核心思想。生活中这种例子比比皆是，支付宝在整个淘宝体系里就是庞大的ioc容器，交易双方之外的第三方，提供可靠性可依赖可灵活变更交易方的资源管理中心。另外人事代理也是，雇佣机构和个人之外的第三方。  
> update=
> 
> 在以上的描述中，诞生了两个专业词汇，依赖注入和控制反转所谓的依赖注入，则是，甲方开放接口，在它需要的时候，能够讲乙方传递进来(注入)所谓的控制反转，甲乙双方不相互依赖，交易活动的进行不依赖于甲乙任何一方，整个活动的进行由第三方负责管理。

参考优秀的博文②：[这里写链接内容][Link 1]

**知乎@Intopass的回答：**

1.  不用自己组装，拿来就用。
2.  享受单例的好处，效率高，不浪费空间。
3.  便于单元测试，方便切换mock组件。
4.  便于进行AOP操作，对于使用者是透明的。
5.  统一配置，便于修改。

## 3.Spring模块 ##

**Spring可以分为6大模块：**

*  Spring Core spring的核心功能： IOC容器, 解决对象创建及依赖关系
 *  Spring Web Spring对web模块的支持。
    
     *      可以与struts整合,让struts的action创建交给spring
     *      spring mvc模式
 *  Spring DAO Spring 对jdbc操作的支持 【JdbcTemplate模板工具类】
 *  Spring ORM spring对orm的支持：
    
     *      既可以与hibernate整合，【session】
     *      也可以使用spring的对hibernate操作的封装
 *  Spring AOP 切面编程
 *  SpringEE spring 对javaEE其他模块的支持

![这里写图片描述][format_png 1]

上面文主要引出了为啥我们需要使用Spring框架，以及大致了解了Spring是分为六大模块的…**下面主要讲解Spring的core模块！**

![format_png 2][]

## 4. Core模块快速入门 ##

### 4.1搭建配置环境 ###

**更新：如果使用maven的同学，引入pom文件就好了**

本博文主要是core模块的内容，**涉及到Spring core的开发jar包有五个**：

*  **commons-logging-1.1.3.jar 日志**
 *  **spring-beans-3.2.5.RELEASE.jar bean节点**
 *  **spring-context-3.2.5.RELEASE.jar spring上下文节点**
 *  **spring-core-3.2.5.RELEASE.jar spring核心功能**
 *  **spring-expression-3.2.5.RELEASE.jar spring表达式相关表**

这次使用的是Spring3.2版本

\*\*编写配置文件:\*\*Spring核心的配置文件`applicationContext.xml`或者叫`bean.xml`

那这个配置文件怎么写呢？？一般地，我们都知道框架的配置文件都是有约束的…**我们可以在`spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html`找到XML配置文件的约束**

我是使用Intellij Idea集成开发工具的，可以选择自带的Spring配置文件,它长的是这样：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    </beans>

前面在介绍Spring模块的时候已经说了，**Core模块是：IOC容器，解决对象创建和之间的依赖关系**。

因此**Core模块主要是学习如何得到IOC容器，通过IOC容器来创建对象、解决对象之间的依赖关系、IOC细节。**

### 4.2 得到Spring容器对象【IOC容器】 ###

Spring容器不单单只有一个，可以归为两种类型

*  \*\*Bean工厂，BeanFactory【功能简单】 \*\*
 *  **应用上下文，ApplicationContext【功能强大，一般我们使用这个】**

#### 4.2.1通过Resource获取BeanFactory ####

步骤

*  **加载Spring配置文件**
 *  **通过XmlBeanFactory+配置文件来创建IOC容器**

//加载Spring的资源文件
            Resource resource = new ClassPathResource("applicationContext.xml");
    
            //创建IOC容器对象【IOC容器=工厂类+applicationContext.xml】
            BeanFactory beanFactory = new XmlBeanFactory(resource);

--------------------

#### 4.2.2类路径下XML获取ApplicationContext ####

**直接通过ClassPathXmlApplicationContext对象来获取**

// 得到IOC容器对象
            ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
            
            System.out.println(ac);

在Spring中总体来看可以通过四种方式来配置对象:

*  **使用XML文件配置**
 *  **使用注解来配置**
 *  **使用JavaConfig来配置**
 *  groovy脚本 DSL

### 4.3XML配置方式 ###

在上面我们已经可以得到IOC容器对象了。**接下来就是在applicationContext.xml文件中配置信息【让IOC容器根据applicationContext.xml文件来创建对象】**

首先我们先有个JavaBean的类

/** * Created by ozc on 2017/5/10. */
    public class User { 
    
        private String id;
        private String username;
    
    
        public String getId() { 
            return id;
        }
    
        public void setId(String id) { 
            this.id = id;
        }
    
        public String getUsername() { 
            return username;
        }
    
        public void setUsername(String username) { 
            this.username = username;
        }
    }

以前我们是通过new User的方法创建对象的…

User user = new User();

现在我们有了IOC容器，可以让IOC容器帮我们创建对象了。在applicationContext.xml文件中配置对应的信息就行了

<bean id="user" class="User"/>

**通过IOC容器对象获取对象:在外界通过IOC容器对象得到User对象**

// 得到IOC容器对象
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    User user = (User) ac.getBean("user");
    
    System.out.println(user);

![这里写图片描述][format_png 3]

上面我们使用的是IOC通过无参构造函数来创建对象，我们来回顾一下一般有几种创建对象的方式：

*  无参构造函数创建对象
 *  带参数的构造函数创建对象
 *  工厂创建对象
    
     *  静态方法创建对象
     *  非静态方法创建对象

使用无参的构造函数创建对象我们已经会了，接下来我们看看使用剩下的IOC容器是怎么创建对象的。

#### 4.3.1带参数的构造函数创建对象 ####

首先，**JavaBean就要提供带参数的构造函数：**

public User(String id, String username) { 
            this.id = id;
            this.username = username;
        }

接下来，关键是怎么配置applicationContext.xml文件了。

![这里写图片描述][format_png 4]

在constructor上如果构造函数的值是一个对象，而不是一个普通类型的值，我们就需要用到ref属性了，而不是value属性

比如说：**我在User对象上维护了Person对象的值，想要在构造函数中初始化它**。因此，就需要用到ref属性了

#### 4.3.2工厂静态方法创建对象 ####

首先，**使用一个工厂的静态方法返回一个对象**

public class Factory { 
    
        public static User getBean() { 
    
            return new User();
        }
          
    }

**配置文件中使用工厂的静态方法返回对象**

<bean id="user" class="Factory" factory-method="getBean" >
    
        </bean>

![这里写图片描述][format_png 5]

#### 4.3.3工厂非静态方法创建对象 ####

首先，也是通过工厂的非非静态方法来得到一个对象

public class Factory { 
    
        
        public User getBean() { 
    
            return new User();
        }
    
    
    }

**配置文件中使用工厂的非静态方法返回对象**

<bean id="factory" class="Factory"/>
    
        
        <bean id="user" class="User" factory-bean="factory" factory-method="getBean"/>

![这里写图片描述][format_png 5]

#### 4.3.4 c名称空间 ####

我们在使用XML配置创建Bean的时候，如果该Bean有构造器，那么我们使用`<constructor-arg>`这个节点来对构造器的参数进行赋值…

`<constructor-arg>`未免有点太长了，为了简化配置，Spring来提供了c名称空间…

**要想c名称空间是需要导入`xmlns:c="http://www.springframework.org/schema/c"`的**

c名称空间有个\*\*缺点：不能装配集合，\*\*当我们要装配集合的时候还是需要`<constructor-arg>`这个节点

#### 4.3.5装载集合 ####

如果对象上的属性或者构造函数拥有集合的时候，而我们又需要为集合赋值，那么怎么办？

**在构造函数上，普通类型**

**在属性上,引用类型**

### 4.4注解方式 ###

自从jdk5有了注解这个新特性，我们可以看到Struts2框架、Hibernate框架都支持使用注解来配置信息…

**通过注解来配置信息就是为了简化IOC容器的配置，注解可以把对象添加到IOC容器中、处理对象依赖关系**，我们来看看怎么用吧：

使用注解步骤：

*  **1）先引入context名称空间**
 *      xmlns:context="http://www.springframework.org/schema/context"
 *  **2）开启注解扫描器**
 *      `<context:component-scan base-package=""></context:component-scan>`
 *      第二种方法:也可以通过自定义扫描类以@CompoentScan修饰来扫描IOC容器的bean对象。如下代码:

//表明该类是配置类
    @Configuration
    
    //启动扫描器，扫描bb包下的
    	//也可以指定多个基础包
    	//也可以指定类型
    @ComponentScan("bb")
    public class AnnotationScan { 
    
    }

在使用@ComponentScan()这个注解的时候，在测试类上需要@ContextConfiguration这个注解来加载配置类…

*  @ContextConfiguration这个注解又在Spring的test包下…

创建对象以及处理对象依赖关系，相关的注解：

*  @ComponentScan扫描器
 *  @Configuration表明该类是配置类
 *  @Component 指定把一个对象加入IOC容器—>@Name也可以实现相同的效果【一般少用】
 *  @Repository 作用同@Component； 在持久层使用
 *  @Service 作用同@Component； 在业务逻辑层使用
 *  @Controller 作用同@Component； 在控制层使用
 *  @Resource 依赖关系
    
     *  如果@Resource不指定值，那么就根据类型来找，相同的类型在IOC容器中不能有两个
     *  如果@Resource指定了值，那么就根据名字来找

测试代码:UserDao

package aa;
    
    import org.springframework.stereotype.Repository;
    
    /** * Created by ozc on 2017/5/10. */
    
    //把对象添加到容器中,首字母会小写
    @Repository
    public class UserDao { 
    
        public void save() { 
            System.out.println("DB:保存用户");
        }
    
    
    }

userService

package aa;
    
    
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    
    
    //把UserService对象添加到IOC容器中,首字母会小写
    @Service
    public class UserService { 
    
        //如果@Resource不指定值，那么就根据类型来找--->UserDao....当然了，IOC容器不能有两个UserDao类型的对象
        //@Resource
    
        //如果指定了值，那么Spring就在IOC容器找有没有id为userDao的对象。
        @Resource(name = "userDao")
        private UserDao userDao;
    
        public void save() { 
            userDao.save();
        }
    }

userAction

package aa;
    
    import org.springframework.stereotype.Controller;
    
    import javax.annotation.Resource;
    
    /** * Created by ozc on 2017/5/10. */
    
    //把对象添加到IOC容器中,首字母会小写
    @Controller
    public class UserAction { 
    
        @Resource(name = "userService")
        private UserService userService;
    
        public String execute() { 
            userService.save();
            return null;
        }
    }

测试

package aa;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /** * Created by ozc on 2017/5/10. */
    public class App { 
    
        public static void main(String[] args) { 
    
            // 创建容器对象
            ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");
    
            UserAction userAction = (UserAction) ac.getBean("userAction");
    
            userAction.execute();
        }
    }

![这里写图片描述][format_png 6]

--------------------

### 4.5通过JavaConfig方式 ###

怎么通过java代码来配置Bean呢？？

*  编写一个java类，使用@Configuration修饰该类
 *  被@Configuration修饰的类就是配置类

**编写配置类:**

@org.springframework.context.annotation.Configuration
    	public class Configuration { 
    	  
    	}

**使用配置类创建bean:**

*  使用@Bean来修饰方法，该方法返回一个对象。
 *  不管方法体内的对象是怎么创建的，Spring可以获取得到对象就行了。
 *  Spring内部会将该对象加入到Spring容器中
 *  容器中bean的ID默认为方法名

@org.springframework.context.annotation.Configuration
    public class Configuration { 
    
        @Bean
        public UserDao userDao() { 
    
            UserDao userDao = new UserDao();
            System.out.println("我是在configuration中的"+userDao);
            return userDao;
        }
    
    }

*  测试代码：要使用@ContextConfiguration加载配置类的信息【引入test包】

package bb;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.test.context.ContextConfiguration;
    
    /** * Created by ozc on 2017/5/11. */
    //加载配置类的信息
    @ContextConfiguration(classes = Configuration.class)
    public class Test2 { 
    
        @Test
        public void test33() { 
    
            ApplicationContext ac =
                    new ClassPathXmlApplicationContext("bb/bean.xml");
    
            UserDao userDao = (UserDao) ac.getBean("userDao");
    
            System.out.println(userDao);
        }
    }

结果如下：

![format_png 7][]

### 4.6三种方式混合使用？ ###

**注解和XML配置是可以混合使用的，JavaConfig和XML也是可以混合使用的…**

如果JavaConfig的配置类是分散的，我们一般再创建一个更高级的配置类（root），然后使用\*\*@Import来将配置类进行组合\*\*  
如果XML的配置文件是分散的，我们也是创建一个更高级的配置文件（root），然后**使用`<import>`来将配置文件组合**

在JavaConfig引用XML

*  使用@ImportResource()

在XML引用JavaConfig

*  使用`<bean>`节点就行了

在公司的项目中，一般我们是`XML+注解`

## 5. bean对象创建细节 ##

既然我们现在已经初步了解IOC容器了，那么这些问题我们都是可以解决的。并且是十分简单【对象写死问题已经解决了，IOC容器就是控制反转创建对象】

### 5.1 scope属性 ###

指定scope属性，IOC容器就知道创建对象的时候是单例还是多例的了。

属性的值就只有两个：单例/多例

![这里写图片描述][format_png 8]

当我们使用singleton【单例】的时候，从IOC容器获取的对象都是同一个：

![这里写图片描述][format_png 9]

当我们使用prototype【多例】的时候，从IOC容器获取的对象都是不同的：

![这里写图片描述][format_png 10]

scope属性除了控制对象是单例还是多例的，**还控制着对象创建的时间**！

我们在User的构造函数中打印出一句话，就知道User对象是什么时候创建了。

public User() { 
    
            System.out.println("我是User，我被创建了");
        }

当使用singleton的时候，对象在IOC容器之前就已经创建了

![这里写图片描述][format_png 11]

当使用prototype的时候，对象在使用的时候才创建

![format_png 12][]

### 5.2lazy-init属性 ###

lazy-init属性**只对singleton【单例】的对象有效**…lazy-init默认为false…

有的时候，可能我们**想要对象在使用的时候才创建，那么将lazy-init设置为ture就行了**

![这里写图片描述][format_png 13]

--------------------

### 5.3 init-method和destroy-method ###

如果我们想要**对象在创建后，执行某个方法**，我们指定为init-method属性就行了。。

如果我们想要**IOC容器销毁后，执行某个方法**，我们指定destroy-method属性就行了。

### 5.4 Bean创建细节总结 ###

/** * 1) 对象创建： 单例/多例 * scope="singleton", 默认值， 即 默认是单例 【service/dao/工具类】 * scope="prototype", 多例； 【Action对象】 * * 2) 什么时候创建? * scope="prototype" 在用到对象的时候，才创建对象。 * scope="singleton" 在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。 * 3)是否延迟创建 * lazy-init="false" 默认为false, 不延迟创建，即在启动时候就创建对象 * lazy-init="true" 延迟初始化， 在用到对象的时候才创建对象 * （只对单例有效） * 4) 创建对象之后，初始化/销毁 * init-method="init_user" 【对应对象的init_user方法，在对象创建之后执行 】 * destroy-method="destroy_user" 【在调用容器对象的destroy方法时候执行，(容器用实现类)】 */

![aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY25tdTFsYjJ2ZzMwNm8wNm9qdGcuZ2lm][]

# 对象依赖 #

## 1. 回顾以前对象依赖 ##

我们来看一下我们以前关于对象依赖，是怎么的历程

### 1.1 直接new对象 ###

在最开始，我们是直接new对象给serice的userDao属性赋值…

class  UserService{ 
    	UserDao userDao = new UserDao();
    }

### 1.2 写DaoFactory，用字符串来维护依赖关系 ###

后来，我们发现service层紧紧耦合了dao层。**我们就写了DaoFactory，在service层只要通过字符串就能够创建对应的dao层的对象了。**

DaoFactory

public class DaoFactory { 
    
        private static final DaoFactory factory = new DaoFactory();
        private DaoFactory(){ }
    
        public static DaoFactory getInstance(){ 
            return factory;
        }
    
        public <T> T createDao(String className,Class<T> clazz){ 
            try{ 
                T t = (T) Class.forName(className).newInstance();
                return t;
            }catch (Exception e) { 
                throw new RuntimeException(e);
            }
        }
    
    }

serivce

private CategoryDao categoryDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.CategoryDAOImpl", CategoryDao.class);
    
        private BookDao bookDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.BookDaoImpl", BookDao.class);
    
        private UserDao userDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.UserDaoImpl", UserDao.class);
    
        private OrderDao orderDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.OrderDaoImpl", OrderDao.class);

### 1.3 DaoFactory读取配置文件 ###

再后来，我们发现要修**改Dao的实现类，还是得修改service层的源代码**呀…**于是我们就在DaoFactory中读取关于daoImpl的配置文件，根据配置文件来创建对象，这样一来，创建的是哪个daoImpl对service层就是透明的**

DaoFactory

public class DaoFactory { 
    	
    	private  UserDao userdao = null;
    	
    	private DaoFactory(){ 
    		try{ 
    			InputStream in = DaoFactory.class.getClassLoader().getResourceAsStream("dao.properties");
    			Properties prop = new Properties();
    			prop.load(in);
    			
    			String daoClassName = prop.getProperty("userdao");
    			userdao = (UserDao)Class.forName(daoClassName).newInstance();
    			
    		}catch (Exception e) { 
    			throw new RuntimeException(e);
    		}
    	}
    	
    	private static final DaoFactory instance = new DaoFactory();
    	
    	public static DaoFactory getInstance(){ 
    		return instance;
    	}
    	
    	
    	public UserDao createUserDao(){ 
    		return userdao;
    	}
    	
    }

service

UserDao dao = DaoFactory.getInstance().createUserDao();

## 2. Spring依赖注入 ##

通过上面的历程，我们可以清晰地发现：**对象之间的依赖关系，其实就是给对象上的属性赋值！因为对象上有其他对象的变量，因此存在了依赖**…

Spring提供了好几种的方式来给属性赋值

*  **1) 通过构造函数**
 *  **2) 通过set方法给属性注入值**
 *  1.  p名称空间
 *  4)自动装配(了解)
 *  **5) 注解**

### 2.1 搭建测试环境 ###

UserService中使用userDao变量来维护与Dao层之间的依赖关系，UserAction中使用userService变量来维护与Service层之间的依赖关系。

userDao

public class UserDao { 
    
    	public void save() { 
    		System.out.println("DB:保存用户");
    	}
    }

userService

public class UserService { 
    	
    	private UserDao userDao; 
    
    	public void save() { 
    		userDao.save();
    	}
    }

userAnction

public class UserAction { 
    
    	private UserService userService;
    
    	public String execute() { 
    		userService.save();
    		return null;
    	}
    }

### 2.2构造函数给属性赋值 ###

其实我们在讲解**创建带参数的构造函数的时候已经讲过了**…我们还是来回顾一下呗…

我们**测试service和dao的依赖关系就好了**…在**serice中加入一个构造函数，参数就是userDao**

public UserService(UserDao userDao) { 
      this.userDao = userDao;
    
      //看看有没有拿到userDao
      System.out.println(userDao);
    }

**applicationContext.xml配置文件**

<bean id="userDao" class="UserDao"/>
    
    
    <bean id="userService" class="UserService">
      
      <constructor-arg index="0" name="userDao" type="UserDao" ref="userDao"></constructor-arg>
    </bean>

测试：可以成功获取到userDao对象

// 创建容器对象
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    //得到service对象
    UserService userService = (UserService) ac.getBean("userService");

![这里写图片描述][format_png 14]

![aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY256MDF5MXJmZzMwNm8wNm93ZWguZ2lm][]

### 2.3通过set方法给属性注入值 ###

我们这里也是测试service和dao层的依赖关系就好了…**在service层通过set方法来把userDao注入到UserService中**

为UserService添加set方法

public class UserService { 
    
        private UserDao userDao;
    
    
        public void setUserDao(UserDao userDao) { 
            this.userDao = userDao;
    
            //看看有没有拿到userDao
            System.out.println(userDao);
        }
    
        public void save() { 
            userDao.save();
        }
    }

applicationContext.xml配置文件：通过property节点来给属性赋值

*  **引用类型使用ref属性**
 *  **基本类型使用value属性**

<bean id="userDao" class="UserDao"/>
    
    
    <bean id="userService" class="UserService">
      <property name="userDao" ref="userDao"/>
    </bean>

测试：

![这里写图片描述][format_png 15]

### 2.4 内部Bean ###

我们刚才是**先创建userDao对象，再由userService对userDao对象进行引用**…我们还有另一种思维：**先创建userService，发现userService需要userDao的属性，再创建userDao**…我们来看看这种思维方式是怎么配置的：

applicationContext.xml配置文件：property节点内置bean节点

<bean id="userService" class="UserService">
            <property name="userDao">
                <bean id="userDao" class="UserDao"/>
            </property>
        </bean>

测试

![这里写图片描述][format_png 16]

我们发现这种思维方式和服务器访问的执行顺序是一样的，但是**如果userDao要多次被其他service使用的话，就要多次配置了**…

### 2.5 p 名称空间注入属性值 ###

p名称控件这种方式**其实就是set方法的一种优化，优化了配置而已**…p名称空间这个内容**需要在Spring3版本以上才能使用**…我们来看看：

applicationContext.xml配置文件：使用p名称空间

测试

![这里写图片描述][format_png 17]

--------------------

### 2.6 自动装配 ###

**Spring还提供了自动装配的功能，能够非常简化我们的配置**

自动装载默认是不打开的，自动装配常用的可分为两种：

*  **根据名字来装配**
 *  **根据类型类装配**

#### 2.6.1XML配置根据名字 ####

applicationContext.xml配置文件：使用自动装配，根据名字

测试

![这里写图片描述][format_png 18]

--------------------

#### 2.6.2 XML配置根据类型 ####

applicationContext.xml配置文件：使用自动装配，根据类型

值得注意的是：**如果使用了根据类型来自动装配，那么在IOC容器中只能有一个这样的类型，否则就会报错！**

测试：

![这里写图片描述][format_png 19]

我们这只是测试两个对象之间的依赖关系，如果我们有很多对象，我们也可以**使用默认自动分配**

![这里写图片描述][format_png 20]

### 2.7 使用注解来实现自动装配 ###

@Autowired注解来实现自动装配：

*  **可以在构造器上修饰**
 *  **也可以在setter方法上修饰**
 *  **来自java的@Inject的和@AutoWired有相同的功能**

如果没有匹配到bean，又为了避免异常的出现，我们可以使用required属性上设置为false。【谨慎对待】

测试代码

@Component
    public class UserService { 
    
        private UserDao userDao ;
    
    
        @Autowired
        public void setUserDao(UserDao userDao) { 
            this.userDao = userDao;
        }
    }

顺利拿到userDao的引用

![这里写图片描述][format_png 21]

![aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY256MmR2bTF4ZzMwNzMwNzNxNjUuZ2lm][]

# AOP入门 #

在讲解AOP模块之前，首先我们来讲解一下**cglib代理、以及怎么手动实现AOP编程**

## 1. cglib代理 ##

在讲解cglib之前，首先我们来回顾一下静态代理和动态代理

**由于静态代理需要实现目标对象的相同接口，那么可能会导致代理类会非常非常多…不好维护**\---->因此出现了动态代理

动态代理也有个约束：**目标对象一定是要有接口的，没有接口就不能实现动态代理**…----->因此出现了cglib代理

cglib代理也叫子类代理，**从内存中构建出一个子类来扩展目标对象的功能！**

*  CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。

### 1.1 编写cglib代理 ###

接下来我们就讲讲怎么写cglib代理：

*  需要引入cglib – jar文件， 但是spring的核心包中已经包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。(**如果用maven的同学，引入pom依赖就好了**)
 *  引入功能包后，就可以在内存中动态构建子类
 *  **代理的类不能为final**，否则报错【在内存中构建子类来做扩展，当然不能为final，有final就不能继承了】
 *  **目标对象的方法如果为final/static, 那么就不会被拦截**，即不会执行目标对象额外的业务方法。

//需要实现MethodInterceptor接口
    public class ProxyFactory implements MethodInterceptor{ 
    	
    	// 维护目标对象
    	private Object target;
    	public ProxyFactory(Object target){ 
    		this.target = target;
    	}
    	
    	// 给目标对象创建代理对象
    	public Object getProxyInstance(){ 
    		//1. 工具类
    		Enhancer en = new Enhancer();
    		//2. 设置父类
    		en.setSuperclass(target.getClass());
    		//3. 设置回调函数
    		en.setCallback(this);
    		//4. 创建子类(代理对象)
    		return en.create();
    	}
    	
    
    	@Override
    	public Object intercept(Object obj, Method method, Object[] args,
    			MethodProxy proxy) throws Throwable { 
    		
    		System.out.println("开始事务.....");
    		
    		// 执行目标对象的方法
    		//Object returnValue = method.invoke(target, args);
    		 proxy.invokeSuper(object, args); 
    		System.out.println("提交事务.....");
    		
    		return returnValue;
    	}
    
    }

测试：

public class App { 
    
        public static void main(String[] args) { 
    
            UserDao userDao = new UserDao();
    
            UserDao factory = (UserDao) new ProxyFactory(userDao).getProxyInstance();
    
            factory.save();
        }
    }

结果如下：

![这里写图片描述][format_png 22]

![这里写图片描述][format_png 23]

使用cglib就是为了弥补动态代理的不足【动态代理的目标对象一定要实现接口】

## 2. 手动实现AOP编程 ##

AOP 面向切面的编程：**AOP可以实现“业务代码”与“关注点代码”分离**

下面我们来看一段代码：

// 保存一个用户
    public void add(User user) {  
    		Session session = null; 
    		Transaction trans = null; 
    		try {  
    			session = HibernateSessionFactoryUtils.getSession();   // 【关注点代码】
    			trans = session.beginTransaction();    // 【关注点代码】
    			 
    			session.save(user);     // 核心业务代码
    			 
    			trans.commit();     //…【关注点代码】
    
    		} catch (Exception e) {      
    			e.printStackTrace(); 
    			if(trans != null){  
    				trans.rollback();   //..【关注点代码】
    
    			} 
    		} finally{  
    			HibernateSessionFactoryUtils.closeSession(session);   ..【关注点代码】
    
    		} 
       }

关注点代码，就是指重复执行的代码。

业务代码与关注点代码分离，好处？

*  **关注点代码写一次即可**；
 *  **开发者只需要关注核心业务**；
 *  **运行时期，执行核心业务代码时候动态植入关注点代码； 【代理】**

### 2.1案例分析： ###

IUser接口

public interface IUser { 
    
        void save();
    }

我们一步一步来分析，**首先我们的UserDao有一个save()方法，每次都要开启事务和关闭事务**

//@Component -->任何地方都能用这个
    @Repository  //-->这个在Dao层中使用
        public class UserDao { 
    
        public void save() { 
    
            System.out.println("开始事务");
            System.out.println("DB:保存用户");
            System.out.println("关闭事务");
    
        }
    
    
    }

在刚学习java基础的时候，我们知道：**如果某些功能经常需要用到就封装成方法：**

//@Component -->任何地方都能用这个
    @Repository  //-->这个在Dao层中使用
        public class UserDao { 
    
        public void save() { 
    
            begin();
            System.out.println("DB:保存用户");
            close();
            
        }
    
        public void begin() { 
            System.out.println("开始事务");
        }
        public void close() { 
            System.out.println("关闭事务");
        }
    }

现在呢，**我们可能有多个Dao，都需要有开启事务和关闭事务的功能，现在只有UserDao中有这两个方法，重用性还是不够高。因此我们抽取出一个类出来**

public class AOP { 
        
        public void begin() { 
            System.out.println("开始事务");
        }
        public void close() { 
            System.out.println("关闭事务");
        }
    }

在UserDao维护这个变量，要用的时候，调用方法就行了。

@Repository  //-->这个在Dao层中使用
    public class UserDao { 
    
    
        AOP aop;
    
        public void save() { 
    
            aop.begin();
            System.out.println("DB:保存用户");
            aop.close();
    
        }
        
    }

现在的开启事务、关闭事务还是需要我在userDao中手动调用。还是不够优雅。。我想要的效果：当我在调用userDao的save()方法时，**动态地开启事务、关闭事务。因此，我们就用到了代理**。当然了，**真正执行方法的都是userDao、要干事的是AOP，因此在代理中需要维护他们的引用**。

public class ProxyFactory { 
        //维护目标对象
        private static Object target;
    
        //维护关键点代码的类
        private static AOP aop;
        public static Object getProxyInstance(Object target_, AOP aop_) { 
    
            //目标对象和关键点代码的类都是通过外界传递进来
            target = target_;
            aop = aop_;
    
            return Proxy.newProxyInstance(
                    target.getClass().getClassLoader(),
                    target.getClass().getInterfaces(),
                    new InvocationHandler() { 
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    
                            aop.begin();
                            Object returnValue = method.invoke(target, args);
                            aop.close();
    
                            return returnValue;
                        }
                    }
            );
        }
    }

### 2.2工厂静态方法： ###

把AOP加入IOC容器中

//把该对象加入到容器中
    @Component
    public class AOP { 
    
        public void begin() { 
            System.out.println("开始事务");
        }
        public void close() { 
            System.out.println("关闭事务");
        }
    }

把UserDao放入容器中

@Component
    public class UserDao { 
    
        public void save() { 
    
            System.out.println("DB:保存用户");
    
        }
    
    }

在配置文件中开启注解扫描,使用工厂静态方法创建代理对象

测试，得到UserDao对象，调用方法

public class App { 
    
        public static void main(String[] args) { 
    
            ApplicationContext ac =
                    new ClassPathXmlApplicationContext("aa/applicationContext.xml");
    
    
            IUser iUser = (IUser) ac.getBean("proxy");
    
            iUser.save();
    
    
    
        }
    }

![这里写图片描述][format_png 24]

### 2.3 工厂非静态方法 ###

上面使用的是工厂静态方法来创建代理类对象。我们也**使用一下非静态的工厂方法创建对象**。

package aa;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /** * Created by ozc on 2017/5/11. */
    
    public class ProxyFactory { 
    
        public Object getProxyInstance(final Object target_, final AOP aop_) { 
    
            //目标对象和关键点代码的类都是通过外界传递进来
    
            return Proxy.newProxyInstance(
                    target_.getClass().getClassLoader(),
                    target_.getClass().getInterfaces(),
                    new InvocationHandler() { 
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    
                            aop_.begin();
                            Object returnValue = method.invoke(target_, args);
                            aop_.close();
    
                            return returnValue;
                        }
                    }
            );
        }
    }

配置文件:**先创建工厂，再创建代理类对象**

效果如下：

![这里写图片描述][format_png 25]

## 3. AOP的概述 ##

**Aop： aspect object programming 面向切面编程**

*  **功能： 让关注点代码与业务代码分离！**
 *  面向切面编程就是指： **对很多功能都有的重复的代码抽取，再在运行的时候往业务方法上动态植入“切面类代码”。**

关注点：**重复代码就叫做关注点。**

切面：**关注点形成的类，就叫切面(类)！**

public class AOP { 
    
        public void begin() { 
            System.out.println("开始事务");
        }
        public void close() { 
            System.out.println("关闭事务");
        }
    }

切入点：

*  执行目标对象方法，动态植入切面代码。
 *  可以通过**切入点表达式**，**指定拦截哪些类的哪些方法； 给指定的类在运行的时候植入切面类代码**。

切入点表达式：

*  **指定哪些类的哪些方法被拦截**

![format_png 26][]

## 4. 使用Spring AOP开发步骤 ##

**更新：如果用maven的同学，引入pom依赖就好了**

1） **先引入aop相关jar文件** （aspectj aop优秀组件）

*  spring-aop-3.2.5.RELEASE.jar 【spring3.2源码】
 *  aopalliance.jar 【spring2.5源码/lib/aopalliance】
 *  aspectjweaver.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\\lib】
 *  aspectjrt.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\\lib】

注意： **用到spring2.5版本的jar文件，如果用jdk1.7可能会有问题**。

*  需要升级aspectj组件，即使用aspectj-1.8.2版本中提供jar文件提供。

2） **bean.xml中引入aop名称空间**

*  **`xmlns:context="http://www.springframework.org/schema/context"`**
 *  **`http://www.springframework.org/schema/context`**
 *  **`http://www.springframework.org/schema/context/spring-context.xsd`**

引入4个jar包：

![这里写图片描述][format_png 27]

### 4.1 引入名称空间 ###

--------------------

### 4.2注解方式实现AOP编程 ###

我们之前手动的实现AOP编程是需要自己来编写代理工厂的\*\*，现在有了Spring，就不需要我们自己写代理工厂了。Spring内部会帮我们创建代理工厂\*\*。也就是说，不用我们自己写代理对象了。

因此，我们**只要关心切面类、切入点、编写切入表达式指定拦截什么方法就可以了！**

还是以上一个例子为案例，使用Spring的注解方式来实现AOP编程

#### 4.2.1在配置文件中开启AOP注解方式 ####

#### 4.2.2代码： ####

切面类

@Component
    @Aspect//指定为切面类
    public class AOP { 
    
    
    	//里面的值为切入点表达式
        @Before("execution(* aa.*.*(..))")
        public void begin() { 
            System.out.println("开始事务");
        }
    
    
        @After("execution(* aa.*.*(..))")
        public void close() { 
            System.out.println("关闭事务");
        }
    }

UserDao实现了IUser接口

@Component
    public class UserDao implements IUser { 
    
        @Override
        public void save() { 
            System.out.println("DB:保存用户");
        }
    
    }

IUser接口

public interface IUser { 
        void save();
    }

测试代码：

public class App { 
    
        public static void main(String[] args) { 
    
            ApplicationContext ac =
                    new ClassPathXmlApplicationContext("aa/applicationContext.xml");
    
    		//这里得到的是代理对象....
            IUser iUser = (IUser) ac.getBean("userDao");
    
            System.out.println(iUser.getClass());
    
            iUser.save();
            
        }
    }

效果：

![这里写图片描述][format_png 28]

--------------------

### 4.3目标对象没有接口 ###

上面我们测试的是UserDao有IUser接口，内部使用的是动态代理…那么我们这次测试的是目标对象没有接口

OrderDao没有实现接口

@Component
    public class OrderDao { 
    
        public void save() { 
    
            System.out.println("我已经进货了！！！");
            
        }
    }

测试代码：

public class App { 
    
        public static void main(String[] args) { 
    
            ApplicationContext ac =
                    new ClassPathXmlApplicationContext("aa/applicationContext.xml");
    
            OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
    
            System.out.println(orderDao.getClass());
    
            orderDao.save();
    
        }
    }

效果：

![这里写图片描述][format_png 29]

--------------------

### 4.4 AOP注解API ###

api:

*  **@Aspect** 指定一个类为切面类
 *  *@Pointcut("execution( cn.itcast.e\_aop\_anno..(…))") 指定切入点表达式*\*
 *  **@Before(“pointCut\_()”)** 前置通知: 目标方法之前执行
 *  **@After(“pointCut\_()”)** **后置通知：目标方法之后执行（始终执行）**
 *  @AfterReturning(“pointCut\_()”) 返回后通知： **执行方法结束前执行(异常不执行)**
 *  @AfterThrowing(“pointCut\_()”) 异常通知: 出现异常时候执行
 *  @Around(“pointCut\_()”) 环绕通知： 环绕目标方法执行

// 前置通知 : 在执行目标方法之前执行
    	@Before("pointCut_()")
    	public void begin(){ 
    		System.out.println("开始事务/异常");
    	}
    	
    	// 后置/最终通知：在执行目标方法之后执行 【无论是否出现异常最终都会执行】
    	@After("pointCut_()")
    	public void after(){ 
    		System.out.println("提交事务/关闭");
    	}
    	
    	// 返回后通知： 在调用目标方法结束后执行 【出现异常不执行】
    	@AfterReturning("pointCut_()")
    	public void afterReturning() { 
    		System.out.println("afterReturning()");
    	}
    	
    	// 异常通知： 当目标方法执行异常时候执行此关注点代码
    	@AfterThrowing("pointCut_()")
    	public void afterThrowing(){ 
    		System.out.println("afterThrowing()");
    	}
    	
    	// 环绕通知：环绕目标方式执行
    	@Around("pointCut_()")
    	public void around(ProceedingJoinPoint pjp) throws Throwable{ 
    		System.out.println("环绕前....");
    		pjp.proceed();  // 执行目标方法
    		System.out.println("环绕后....");
    	}

### 4.5表达式优化 ###

我们的代码是这样的：**每次写Before、After等，都要重写一次切入点表达式，这样就不优雅了。**

@Before("execution(* aa.*.*(..))")
        public void begin() { 
            System.out.println("开始事务");
        }
    
    
        @After("execution(* aa.*.*(..))")
        public void close() { 
            System.out.println("关闭事务");
        }

于是乎，我们要**使用@Pointcut这个注解，来指定切入点表达式，在用到的地方中，直接引用就行了！**

那么我们的代码就可以改造成这样了：

@Component
    @Aspect//指定为切面类
    public class AOP { 
    
    
        // 指定切入点表达式，拦截哪个类的哪些方法
        @Pointcut("execution(* aa.*.*(..))")
        public void pt() { 
    
        }
    
        @Before("pt()")
        public void begin() { 
            System.out.println("开始事务");
        }
    
    
        @After("pt()")
        public void close() { 
            System.out.println("关闭事务");
        }
    }

--------------------

### 4.6 XML方式实现AOP编程 ###

XML文件配置

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    
        
        <bean id="userDao" class="aa.UserDao"/>
        <bean id="orderDao" class="aa.OrderDao"/>
    
        
        <bean id="aop" class="aa.AOP"/>
    
        
        <aop:config >
    
            
            <aop:pointcut id="pointCut" expression="execution(* aa.*.*(..))"/>
    
            
            <aop:aspect ref="aop">
    
                
                <aop:before method="begin" pointcut-ref="pointCut"/>
                <aop:after method="close" pointcut-ref="pointCut"/>
    
            </aop:aspect>
        </aop:config>
    
        
    </beans>

测试：

public class App { 
    
        @Test
        public  void test1() { 
    
            ApplicationContext ac =
                    new ClassPathXmlApplicationContext("aa/applicationContext.xml");
    
            OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
    
            System.out.println(orderDao.getClass());
    
            orderDao.save();
    
        }
    
        @Test
        public  void test2() { 
    
            ApplicationContext ac =
                    new ClassPathXmlApplicationContext("aa/applicationContext.xml");
    
            IUser userDao = (IUser) ac.getBean("userDao");
    
            System.out.println(userDao.getClass());
    
            userDao.save();
    
        }
    }

测试OrderDao

![这里写图片描述][format_png 30]

测试UserDao

![这里写图片描述][format_png 31]

--------------------

## 5. 切入点表达式 ##

切入点表达式主要就是来**配置拦截哪些类的哪些方法**

### 5.1 查官方文档 ###

我们去文档中找找它的语法…

![这里写图片描述][format_png 32]

在文档中搜索:execution(

![这里写图片描述][format_png 33]

### 5.2语法解析 ###

那么它的语法是这样子的：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

**符号讲解：**

*  ?号代表0或1，可以不写
 *  “\*”号代表任意类型，0或多
 *  方法参数为…表示为可变参数

**参数讲解：**

*  modifiers-pattern?【修饰的类型，可以不写】
 *  ret-type-pattern【方法返回值类型，必写】
 *  declaring-type-pattern?【方法声明的类型，可以不写】
 *  name-pattern(param-pattern)【要匹配的名称，括号里面是方法的参数】
 *  throws-pattern?【方法抛出的异常类型，可以不写】

官方也有给出一些例子给我们理解：

![这里写图片描述][format_png 34]

### 5.3 测试代码 ###

![aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY25tcmwxeWxuZzMwNm8wNm9xM3QuZ2lm][]

# JDBCTemplate和Spring事务 #

上一篇Spring博文主要讲解了如何使用Spring来实现AOP编程，本博文主要讲解**Spring的DAO模块对JDBC的支持，以及Spring对事务的控制**…

对于JDBC而言，我们肯定不会陌生，我们**在初学的时候肯定写过非常非常多的JDBC模板代码**！

## 1. 回顾对模版代码优化过程 ##

我们来回忆一下我们怎么对模板代码进行优化的！

首先来看一下我们**原生的JDBC：需要手动去数据库的驱动从而拿到对应的连接**…

try { 
    			String sql = "insert into t_dept(deptName) values('test');";
    			Connection con = null;
    			Statement stmt = null;
    			Class.forName("com.mysql.jdbc.Driver");
    			// 连接对象
    			con = DriverManager.getConnection("jdbc:mysql:///hib_demo", "root", "root");
    			// 执行命令对象
    			stmt =  con.createStatement();
    			// 执行
    			stmt.execute(sql);
    			
    			// 关闭
    			stmt.close();
    			con.close();
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}

因为JDBC是面向接口编程的，因此数据库的驱动都是由数据库的厂商给做到好了，我们**只要加载对应的数据库驱动，便可以获取对应的数据库连接**…因此，我们**写了一个工具类，专门来获取与数据库的连接(Connection)**,当然啦，为了更加灵活，我们的**工具类是读取配置文件的方式来做的**。

/* * 连接数据库的driver，url，username，password通过配置文件来配置，可以增加灵活性 * 当我们需要切换数据库的时候，只需要在配置文件中改以上的信息即可 * * */
    
        private static String  driver = null;
        private static String  url = null;
        private static String  username = null;
        private static String password = null;
    
        static { 
            try { 
    
                //获取配置文件的读入流
                InputStream inputStream = UtilsDemo.class.getClassLoader().getResourceAsStream("db.properties");
    
                Properties properties = new Properties();
                properties.load(inputStream);
    
                //获取配置文件的信息
                driver = properties.getProperty("driver");
                url = properties.getProperty("url");
                username = properties.getProperty("username");
                password = properties.getProperty("password");
    
                //加载驱动类
                Class.forName(driver);
    
    
            } catch (IOException e) { 
                e.printStackTrace();
            } catch (ClassNotFoundException e) { 
                e.printStackTrace();
            }
    
        }
    
        public static Connection getConnection() throws SQLException { 
            return DriverManager.getConnection(url,username,password);
        }
        public static void release(Connection connection, Statement statement, ResultSet resultSet) { 
    
            if (resultSet != null) { 
                try { 
                    resultSet.close();
                } catch (SQLException e) { 
                    e.printStackTrace();
                }
            }
            if (statement != null) { 
                try { 
                    statement.close();
                } catch (SQLException e) { 
                    e.printStackTrace();
                }
            }
            if (connection != null) { 
                try { 
                    connection.close();
                } catch (SQLException e) { 
                    e.printStackTrace();
                }
            }
        }

经过上面一层的封装，我们可以\*\*在使用的地方直接使用工具类来得到与数据库的连接…那么比原来就方便很多了！\*\*但是呢，**每次还是需要使用Connection去创建一个Statement对象。并且无论是什么方法，其实就是SQL语句和传递进来的参数不同！**

于是我们可以使用**DBUtils**这样的组件来解决上面的问题

## 2. 使用Spring的JDBC ##

上面已经回顾了一下以前我们的JDBC开发了，那么看看Spring对JDBC又是怎么优化的

首先，想要使用Spring的JDBC模块，就必须引入两个jar文件：

*  引入jar文件（如果用maven的同学，直接使用pom文件依赖导入就好了）
    
     *  **spring-jdbc-3.2.5.RELEASE.jar**
     *  **spring-tx-3.2.5.RELEASE.jar**

首先还是看一下我们原生的JDBC代码：**获取Connection是可以抽取出来的，直接使用dataSource来得到Connection就行了**。

public void save() { 
    		try { 
    			String sql = "insert into t_dept(deptName) values('test');";
    			Connection con = null;
    			Statement stmt = null;
    			Class.forName("com.mysql.jdbc.Driver");
    			// 连接对象
    			con = DriverManager.getConnection("jdbc:mysql:///hib_demo", "root", "root");
    			// 执行命令对象
    			stmt =  con.createStatement();
    			// 执行
    			stmt.execute(sql);
    			
    			// 关闭
    			stmt.close();
    			con.close();
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}

值得注意的是，**JDBC对C3P0数据库连接池是有很好的支持的。因此我们直接可以使用Spring的依赖注入，在配置文件中配置dataSource就行了**！

// IOC容器注入
    	private DataSource dataSource;
    	public void setDataSource(DataSource dataSource) { 
    		this.dataSource = dataSource;
    	}
    
    	
    	public void save() { 
    		try { 
    			String sql = "insert into t_dept(deptName) values('test');";
    			Connection con = null;
    			Statement stmt = null;
    			// 连接对象
    			con = dataSource.getConnection();
    			// 执行命令对象
    			stmt =  con.createStatement();
    			// 执行
    			stmt.execute(sql);
    			
    			// 关闭
    			stmt.close();
    			con.close();
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}

**Spring来提供了JdbcTemplate这么一个类给我们使用！它封装了DataSource，也就是说我们可以在Dao中使用JdbcTemplate就行了。**

创建dataSource，创建jdbcTemplate对象

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:c="http://www.springframework.org/schema/c" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
            <property name="jdbcUrl" value="jdbc:mysql:///zhongfucheng"></property>
            <property name="user" value="root"></property>
            <property name="password" value="root"></property>
            <property name="initialPoolSize" value="3"></property>
            <property name="maxPoolSize" value="10"></property>
            <property name="maxStatements" value="100"></property>
            <property name="acquireIncrement" value="2"></property>
        </bean>
    
        
        <context:component-scan base-package="bb"/>
    
        
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
        
    </beans>

userDao

package bb;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.stereotype.Component;
    
    /** * Created by ozc on 2017/5/10. */
    
    
    @Component
    public class UserDao implements IUser { 
    
        //使用Spring的自动装配
        @Autowired
        private JdbcTemplate template;
    
        @Override
        public void save() { 
            String sql = "insert into user(name,password) values('zhoggucheng','123')";
            template.update(sql);
        }
    
    }

测试：

@Test
    public void test33() { 
      ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");
    
      UserDao userDao = (UserDao) ac.getBean("userDao");
      userDao.save();
    }

![这里写图片描述][format_png 35]

--------------------

### 2.1 JdbcTemplate查询 ###

我们要是使用JdbcTemplate查询会发现**有很多重载了query()方法**

![这里写图片描述][format_png 36]

一般地，**如果我们使用queryForMap()，那么只能封装一行的数据，如果封装多行的数据、那么就会报错**！并且，Spring是不知道我们想把一行数据封装成是什么样的，因此返回值是Map集合…我们得到Map集合的话还需要我们自己去转换成自己需要的类型。

我们一般使用下面这个方法：

![这里写图片描述][format_png 37]

我们可以**实现RowMapper，告诉Spriing我们将每行记录封装成怎么样的**。

public void query(String id) { 
            String sql = "select * from USER where password=?";
    
            List<User> query = template.query(sql, new RowMapper<User>() { 
    
    
                //将每行记录封装成User对象
                @Override
                public User mapRow(ResultSet resultSet, int i) throws SQLException { 
                    User user = new User();
                    user.setName(resultSet.getString("name"));
                    user.setPassword(resultSet.getString("password"));
    
                    return user;
                }
    
            },id);
    
    
            System.out.println(query);
        }

![这里写图片描述][format_png 38]

--------------------

当然了，一般我们都是**将每行记录封装成一个JavaBean对象的，因此直接实现RowMapper，在使用的时候创建就好了**。

class MyResult implements RowMapper<Dept>{ 
    
    		// 如何封装一行记录
    		@Override
    		public Dept mapRow(ResultSet rs, int index) throws SQLException { 
    			Dept dept = new Dept();
    			dept.setDeptId(rs.getInt("deptId"));
    			dept.setDeptName(rs.getString("deptName"));
    			return dept;
    		}
    		
    	}

![aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY256MDF5MXJmZzMwNm8wNm93ZWguZ2lm][]

## 3. 事务控制概述 ##

下面主要讲解Spring的事务控制，如何使用Spring来对程序进行事务控制…

*  **Spring的事务控制是属于Spring Dao模块的**。

一般地，我们**事务控制都是在service层做的**。。为什么是在service层而不是在dao层呢？？有没有这样的疑问…

**service层是业务逻辑层，service的方法一旦执行成功，那么说明该功能没有出错**。

一个**service方法可能要调用dao层的多个方法**…如果在dao层做事务控制的话，一个dao方法出错了，仅仅把事务回滚到当前dao的功能，这样是不合适的\[因为我们的业务由多个dao方法组成\]。如果没有出错，调用完dao方法就commit了事务，这也是不合适的\[导致太多的commit操作\]。

事务控制分为两种：

*  **编程式事务控制**
 *  **声明式事务控制**

### 3.1 编程式事务控制 ###

**自己手动控制事务，就叫做编程式事务控制。**

*  Jdbc代码：Conn.setAutoCommite(false); // 设置手动控制事务
 *  Hibernate代码：Session.beginTransaction(); // 开启一个事务
 *  特点：**细粒度的事务控制： 可以对指定的方法、指定的方法的某几行添加事务控制（比较灵活，但开发起来比较繁琐： 每次都要开启、提交、回滚.)**

### 3.2声明式事务控制 ###

**Spring提供对事务的控制管理就叫做声明式事务控制**

Spring提供了对事务控制的实现。

*  如果用户想要使用Spring的事务控制，**只需要配置就行了**。
 *  当不用Spring事务的时候，直接移除就行了。
 *  特点：Spring的事务控制是**基于Spring AOP实现的**。因此它的**耦合度是非常低**的。【粗粒度的事务控制： **只能给整个方法应用事务，不可以对方法的某几行应用事务。**】(因为aop拦截的是方法。)

**Spring给我们提供了事务的管理器类**，事务管理器类又分为两种，因为**JDBC的事务和Hibernate的事务是不一样的**。

*  Spring声明式事务管理器类：
 *      Jdbc技术：DataSourceTransactionManager
 *      Hibernate技术：HibernateTransactionManager

--------------------

### 3.3 声明式事务控制教程 ###

我们基于Spring的JDBC来做例子吧

引入相关jar包(如果用maven，那引入pom依赖就好了)

*  **AOP相关的jar包【因为Spring的声明式事务控制是基于AOP的，那么就需要引入AOP的jar包。】**
 *  **引入tx名称空间**
 *  **引入AOP名称空间**
 *  **引入jdbcjar包【jdbc.jar包和tx.jar包】**

--------------------

#### 3.3.1搭建配置环境 ####

编写一个接口

public interface IUser { 
        void save();
    }

UserDao实现类，使用JdbcTemplate对数据库进行操作！

@Repository
    public class UserDao implements IUser { 
    
        //使用Spring的自动装配
        @Autowired
        private JdbcTemplate template;
    
        @Override
        public void save() { 
            String sql = "insert into user(name,password) values('zhong','222')";
            template.update(sql);
        }
    
    }

userService

@Service
    public class UserService { 
    
        @Autowired
        private UserDao userDao;
        public void save() { 
    
            userDao.save();
        }
    }

bean.xml配置：配置数据库连接池、jdbcTemplate对象、扫描注解

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:c="http://www.springframework.org/schema/c" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    
    
        
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
            <property name="jdbcUrl" value="jdbc:mysql:///zhongfucheng"></property>
            <property name="user" value="root"></property>
            <property name="password" value="root"></property>
            <property name="initialPoolSize" value="3"></property>
            <property name="maxPoolSize" value="10"></property>
            <property name="maxStatements" value="100"></property>
            <property name="acquireIncrement" value="2"></property>
        </bean>
    
        
        <context:component-scan base-package="bb"/>
    
        
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
    </beans>

--------------------

前面搭建环境的的时候，是没有任何的事务控制的。也就是说，**当我在service中调用两次userDao.save()，即时在中途中有异常抛出，还是可以在数据库插入一条记录的**。

Service代码：

@Service
    public class UserService { 
    
        @Autowired
        private UserDao userDao;
        public void save() { 
    
            userDao.save();
    
            int i = 1 / 0;
            userDao.save();
        }
    }

测试代码：

public class Test2 { 
    
        @Test
        public void test33() { 
            ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");
    
            UserService userService = (UserService) ac.getBean("userService");
            userService.save();
        }
    }

![这里写图片描述][format_png 39]

--------------------

#### 3.3.2XML方式实现声明式事务控制 ####

首先，我们要配置事务的管理器类：因为JDBC和Hibernate的事务控制是不同的。

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

再而，**配置事务管理器类如何管理事务**

<tx:advice id="txAdvice" transaction-manager="txManage">
            
            
            <tx:attributes>
                
                <tx:method name="*" read-only="false"/>
            </tx:attributes>
        </tx:advice>

最后，**配置拦截哪些方法，**

<aop:config>
            <aop:pointcut id="pt" expression="execution(* bb.UserService.*(..) )"/>
            <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"></aop:advisor>
        </aop:config>

配置完成之后，service中的方法都应该被Spring的声明式事务控制了。因此我们再次测试一下：

@Test
    public void test33() { 
      ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");
    
      UserService userService = (UserService) ac.getBean("userService");
      userService.save();
    }

![这里写图片描述][format_png 40]

--------------------

#### 3.3.3 使用注解的方法实现事务控制 ####

当然了，有的人可能觉得到XML文件上配置太多东西了。**Spring也提供了使用注解的方式来实现对事务控制**

第一步和XML的是一样的，**必须配置事务管理器类：**

第二步：开启以注解的方式来实现事务控制

<tx:annotation-driven transaction-manager="txManage"/>

最后，\*\*想要控制哪个方法事务，在其前面添加@Transactional这个注解就行了！\*\*如果想要控制整个类的事务，那么在类上面添加就行了。

@Transactional
        public void save() { 
    
            userDao.save();
    
            int i = 1 / 0;
            userDao.save();
        }

![这里写图片描述][format_png 41]

## 4.事务属性 ##

其实我们\*\*在XML配置管理器类如何管理事务，就是在指定事务的属性！\*\*我们来看一下事务的属性有什么：

![这里写图片描述][format_png 42]

### 4.1事务传播行为: ###

看了上面的事务属性，没有接触过的属性其实就这么一个：`propagation = Propagation.REQUIRED`事务的传播行为。

事务传播行为的属性有以下这么多个，常用的就只有两个：

*  Propagation.REQUIRED【如果当前方法已经有事务了，**加入当前方法事务**】
 *  Propagation.REQUIRED\_NEW【如果当前方法有事务了，当前方法事务会挂起。**始终开启一个新的事务**，直到新的事务执行完、当前方法的事务才开始】

![这里写图片描述][format_png 43]

### 4.2 当事务传播行为是Propagation.REQUIRED ###

现在有一个日志类，它的事务传播行为是Propagation.REQUIRED

Class Log{ 
    			Propagation.REQUIRED  
    			insertLog();  
    	}

**现在，我要在保存之前记录日志**

Propagation.REQUIRED
    	Void  saveDept(){ 
    		insertLog();   
    		saveDept();
    	}

**saveDept()本身就存在着一个事务，当调用insertLog()的时候，insertLog()的事务会加入到saveDept()事务中**

也就是说，**saveDept()方法内始终是一个事务，如果在途中出现了异常，那么insertLog()的数据是会被回滚的【因为在同一事务内】**

Void  saveDept(){ 
    		insertLog();    // 加入当前事务
    		.. 异常, 会回滚
    		saveDept();
    	}

### 4.3当事务传播行为是Propagation.REQUIRED\_NEW ###

现在有一个日志类，它的事务传播行为是Propagation.REQUIRED\_NEW

Class Log{ 
    			Propagation.REQUIRED  
    			insertLog();  
    	}

**现在，我要在保存之前记录日志**

Propagation.REQUIRED
    	Void  saveDept(){ 
    		insertLog();   
    		saveDept();
    	}

当执行到saveDept()中的insertLog()方法时，**insertLog()方法发现 saveDept()已经存在事务了，insertLog()会独自新开一个事务，直到事务关闭之后，再执行下面的方法**

**如果在中途中抛出了异常，insertLog()是不会回滚的，因为它的事务是自己的，已经提交了**

Void  saveDept(){ 
    		insertLog();    // 始终开启事务
    		.. 异常, 日志不会回滚
    		saveDept();
    	}

![aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY255d283MWpyZzMwOGMwOGNhYTQuZ2lm][]

# Spring事务原理 #

Spring事务管理我相信大家都用得很多，但可能仅仅局限于一个`@Transactional`注解或者在`XML`中配置事务相关的东西。不管怎么说，日常**可能**足够我们去用了。但作为程序员，无论是为了面试还是说更好把控自己写的代码，还是应该得多多了解一下Spring事务的一些细节。

这里我抛出几个问题，看大家能不能瞬间答得上：

*  如果**嵌套调用**含有事务的方法，在Spring事务管理中，这属于哪个知识点？
 *  我们使用的框架可能是`Hibernate/JPA`或者是`Mybatis`，都知道的底层是需要一个`session/connection`对象来帮我们执行操作的。要保证事务的完整性，我们需要多组数据库操作要使用**同一个**`session/connection`对象，而我们又知道Spring IOC所管理的对象默认都是**单例**的，这为啥我们在使用的时候不会引发线程安全问题呢？内部Spring到底干了什么？
 *  人家所说的BPP又是啥东西？
 *  Spring事务管理重要接口有哪几个？

## 一、阅读本文需要的基础知识 ##

阅读这篇文章的同学我**默认**大家都对Spring事务相关知识有一定的了解了。(ps:如果不了解点解具体的文章去阅读再回到这里来哦)

我们都知道，Spring事务是Spring AOP的最佳实践之一，所以说[AOP入门基础知识(简单配置，使用)][AOP]是需要先知道的。如果想更加全面了解AOP可以看这篇文章：[AOP重要知识点(术语介绍、全面使用)][AOP 1]。说到AOP就不能不说[AOP底层原理：动态代理设计模式][AOP 2]。到这里，对AOP已经有一个基础的认识了。于是我们就可以[使用XML/注解方式来配置Spring事务管理][XML_Spring]。

在IOC学习中，可以知道的是[Spring中Bean的生命周期(引出BPP对象)][Spring_Bean_BPP]并且[IOC所管理的对象默认都是单例的：单例设计模式][IOC]，单例对象如果有"**状态**"(有成员变量)，那么多线程访问这个单例对象，可能就造成线程不安全。那么[何为线程安全？][Link 2]，解决线程安全有很多方式，但其中有一种：[让每一个线程都拥有自己的一个变量：ThreadLocal][ThreadLocal]

> 如果对我以上说的知识点不太了解的话，建议点击蓝字进去学习一番。

## 二、两个不靠谱直觉的例子 ##

### 2.1第一个例子 ###

之前朋友问了我一个例子：

在Service层抛出Exception，在Controller层捕获，那如果在Service中有异常，那会事务回滚吗？

// Service方法
    	
    @Transactional
    public Employee addEmployee() throws Exception { 
    
        Employee employee = new Employee("3y", 23);
        employeeRepository.save(employee);
    	// 假设这里出了Exception
        int i = 1 / 0;
    
        return employee;
    }
    
    // Controller调用
    @RequestMapping("/add")
    public Employee addEmployee() { 
        Employee employee = null;
        try { 
            employee = employeeService.addEmployee();
        } catch (Exception e) { 
            e.printStackTrace();
        }
        return employee;
    
    }

我**第一反应**：不会回滚吧。

*  我当时是这样想的：因为Service层已经抛出了异常，由Controller捕获。那是否回滚应该由Controller的catch代码块中逻辑来决定，如果catch代码块没有回滚，那应该是不会回滚。

但朋友经过测试说，可以回滚阿。(pappapa打脸)

![发生了运行时Exception，Spring事务管理自动回滚][Exception_Spring]

看了一下文档，原来文档有说明：

> By default checked exceptions do not result in the transactional interceptor marking the transaction for rollback and instances of RuntimeException and its subclasses do

结论：如果是编译时异常不会自动回滚，**如果是运行时异常，那会自动回滚**！

### 2.2第二个例子 ###

> 第二个例子来源于知乎@柳树文章，文末会给出相应的URL

我们都知道，带有`@Transactional`注解所包围的方法就能被Spring事务管理起来，那如果我在**当前类下使用一个没有事务的方法去调用一个有事务的方法**，那我们这次调用会怎么样？是否会有事务呢？

用代码来描述一下：

// 没有事务的方法去调用有事务的方法
    public Employee addEmployee2Controller() throws Exception { 
    
        return this.addEmployee();
    }
    
    @Transactional
    public Employee addEmployee() throws Exception { 
    
        employeeRepository.deleteAll();
        Employee employee = new Employee("3y", 23);
    
        // 模拟异常
        int i = 1 / 0;
    
        return employee;
    }

我第一直觉是：这跟Spring事务的传播机制有关吧。

其实这跟Spring事务的传播机制**没有关系**，下面我讲述一下：

*  Spring事务管理用的是AOP，AOP底层用的是动态代理。所以如果我们在类或者方法上标注注解`@Transactional`，那么会生成一个**代理对象**。

接下来我用图来说明一下：

![Spring会自动生成代理对象][Spring]

显然地，我们拿到的是代理(Proxy)对象，调用`addEmployee2Controller()`方法，而`addEmployee2Controller()`方法的逻辑是`target.addEmployee()`，调用回原始对象(target)的`addEmployee()`。所以这次的调用**压根就没有事务存在**，更谈不上说Spring事务传播机制了。

原有的数据：

![原有的数据][format_png 44]

测试结果：压根就没有事务的存在

![没有事务的存在][format_png 45]

#### 2.2.1再延伸一下 ####

从上面的测试我们可以发现：如果是在本类中没有事务的方法来调用标注注解`@Transactional`方法，最后的结论是没有事务的。那如果我将这个标注注解的方法**移到**别的Service对象上，有没有事务？

@Service
    public class TestService { 
    
        @Autowired
        private EmployeeRepository employeeRepository;
        
        @Transactional
        public Employee addEmployee() throws Exception { 
    
            employeeRepository.deleteAll();
    
            Employee employee = new Employee("3y", 23);
    
            // 模拟异常
            int i = 1 / 0;
    
            return employee;
        }
    
    }
    
    
    @Service
    public class EmployeeService { 
    
        @Autowired
        private TestService testService;
        // 没有事务的方法去调用别的类有事务的方法
        public Employee addEmployee2Controller() throws Exception { 
            return testService.addEmployee();
        }
    }

测试结果：

![抛出了运行时异常，但我们的数据还是存在的！][format_png 46]

因为我们用的是代理对象(Proxy)去调用`addEmployee()`方法，那就当然有事务了。

> 看完这两个例子，有没有觉得**3y的直觉是真的水**！

## 三、Spring事务传播机制 ##

> 如果**嵌套调用**含有事务的方法，在Spring事务管理中，这属于哪个知识点？

在当前**含有事务方法内部调用其他的方法**(无论该方法是否含有事务)，这就属于Spring事务传播机制的知识点范畴了。

Spring事务基于Spring AOP，Spring AOP底层用的动态代理，动态代理有两种方式：

*  基于接口代理(JDK代理)
    
     *  基于接口代理，凡是类的方法**非public修饰**，或者**用了static关键字**修饰，那这些方法都不能被Spring AOP增强
 *  基于CGLib代理(子类代理)
    
     *  基于子类代理，凡是类的方法**使用了private、static、final修饰**，那这些方法都不能被Spring AOP增强

> 至于为啥以上的情况不能增强，用你们的脑瓜子想一下就知道了。

值得说明的是：那些不能被Spring AOP增强的方法**并不是不能**在事务环境下工作了。只要它们**被外层的事务方法调用了**，由于Spring事务管理的传播级别，内部方法也可以**工作**在外部方法所启动的**事务上下文中**。

> 至于Spring事务传播机制的几个级别，我在这里就不贴出来了。这里只是再次解释“啥情况才是属于Spring事务传播机制的范畴”。

![format_png 47][]

## 四、多线程问题 ##

> 我们使用的框架可能是`Hibernate/JPA`或者是`Mybatis`，都知道的底层是需要一个`session/connection`对象来帮我们执行操作的。要保证事务的完整性，我们需要**多组数据库操作要使用同一个**`session/connection`对象，而我们又知道Spring IOC所管理的对象默认都是**单例**的，这为啥我们在使用的时候不会引发线程安全问题呢？内部Spring到底干了什么？

回想一下当年我们学Mybaits的时候，是怎么编写[Session工具类][Session]？

![Mybatis工具类部分代码截图][Mybatis]

没错，用的就是ThreadLocal，同样地，Spring也是用的ThreadLocal。

以下内容来源《精通 Spring4.x》

> 我们知道在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean（如RequestContextHolder、**TransactionSynchronizationManager**、LocaleContextHolder等）中非线程安全状态的“状态性对象”采用ThreadLocal封装，让它们也成为线程安全的“状态性对象”，因此，有状态的Bean就能够以singleton的方式在多线程中工作。

我们可以试着点一下进去TransactionSynchronizationManager中看一下：

![全都是ThreadLocal][ThreadLocal 1]

## 五、啥是BPP？ ##

BBP的全称叫做：BeanPostProcessor，一般我们俗称**对象后处理器**

*  简单来说，通过BeanPostProcessor可以对我们的对象进行“**加工处理**”。

Spring管理Bean(或者说Bean的生命周期)也是一个**常考**的知识点，我在秋招也**重新**整理了一下步骤，因为比较重要，所以还是在这里贴一下吧：

1.  ResouceLoader加载配置信息
2.  BeanDefintionReader解析配置信息，生成一个一个的BeanDefintion
3.  BeanDefintion由BeanDefintionRegistry管理起来
4.  BeanFactoryPostProcessor对配置信息进行加工(也就是处理配置的信息，一般通过PropertyPlaceholderConfigurer来实现)
5.  实例化Bean
6.  如果该Bean`配置/实现`了InstantiationAwareBean，则调用对应的方法
7.  使用BeanWarpper来完成对象之间的属性配置(依赖)
8.  如果该Bean`配置/实现了`Aware接口，则调用对应的方法
9.  如果该Bean配置了BeanPostProcessor的before方法，则调用
10. 如果该Bean配置了`init-method`或者实现InstantiationBean，则调用对应的方法
11. 如果该Bean配置了BeanPostProcessor的after方法，则调用
12. 将对象放入到HashMap中
13. 最后如果配置了destroy或者DisposableBean的方法，则执行销毁操作

![Application中Bean的声明周期][Application_Bean]

其中也有关于BPP图片：

![BBP所在的位置][BBP]

### 5.1为什么特意讲BPP？ ###

Spring AOP编程底层通过的是动态代理技术，在调用的时候肯定用的是**代理对象**。那么Spring是怎么做的呢？

> 我只需要写一个BPP，在postProcessBeforeInitialization或者postProcessAfterInitialization方法中，对对象进行判断，看他需不需要织入切面逻辑，如果需要，那我就根据这个对象，生成一个代理对象，然后返回这个代理对象，那么最终注入容器的，自然就是代理对象了。

Spring提供了BeanPostProcessor，就是让我们可以对有需要的对象进行“**加工处理**”啊！

## 六、认识Spring事务几个重要的接口 ##

Spring事务可以分为两种：

*  编程式事务(通过代码的方式来实现事务)
 *  声明式事务(通过配置的方式来实现事务)

编程式事务在Spring实现相对简单一些，而声明式事务因为封装了大量的东西(一般我们使用简单，里头都非常复杂)，所以声明式事务实现要难得多。

在编程式事务中有以下几个重要的了接口：

*  TransactionDefinition：定义了Spring兼容的**事务属性**(比如事务隔离级别、事务传播、事务超时、是否只读状态)
 *  TransactionStatus：代表了事务的具体**运行状态**(获取事务运行状态的信息，也可以通过该接口**间接**回滚事务等操作)
 *  PlatformTransactionManager：事务管理器接口(定义了一组行为，具体实现交由不同的持久化框架来完成—**类比**JDBC)

![PlatformTransactionManager解析][PlatformTransactionManager]

在声明式事务中，除了TransactionStatus和PlatformTransactionManager接口，还有几个重要的接口：

*  TransactionProxyFactoryBean：生成代理对象
 *  TransactionInterceptor：实现对象的拦截
 *  TransactionAttrubute：事务配置的数据

![aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY25tdTFsYjJ2ZzMwNm8wNm9qdGcuZ2lm][]

# Spring事务的一个线程安全问题 #

> 只有光头才能变强。

> 文本已收录至我的GitHub仓库，欢迎Star：[https://github.com/ZhongFuCheng3y/3y][https_github.com_ZhongFuCheng3y_3y]

大年初二，朋友问了我一个技术的问题(朋友实在是好学，佩服！)

该问题来源知乎(synchronized锁问题)：

*  [https://www.zhihu.com/question/277812143][https_www.zhihu.com_question_277812143]

> 开启10000个线程，每个线程给员工表的money字段【初始值是0】加1，没有使用悲观锁和乐观锁，但是在业务层方法上加了synchronized关键字，问题是代码执行完毕后数据库中的money 字段不是10000，而是小于10000 问题出在哪里？

Service层代码：

![代码][format_png 48]

SQL代码(没有加悲观/乐观锁)：

![SQL代码(没有加悲观/乐观锁)][SQL]

用1000个线程跑代码：

![用1000个线程跑代码：][1000]

简单来说：多线程跑一个使用**synchronized**关键字修饰的方法，方法内操作的是数据库，按正常逻辑应该最终的值是1000，但经过多次测试，结果是**低于**1000。这是为什么呢？

## 一、我的思考 ##

既然测试出来的结果是低于1000，那说明这段代码**不是线程安全**的。不是线程安全的，那问题出现在哪呢？众所周知，synchronized方法能够保证所修饰的`代码块、方法`保证`有序性、原子性、可见性`。

讲道理，以上的代码跑起来，问题中`Service`层的`increaseMoney()`是`有序的、原子的、可见的`，所以**断定**跟synchronized应该没关系。

(参考我之前写过的synchronize锁笔记：[Java锁机制了解一下][Java])

既然Java层面上找不到原因，那分析一下数据库层面的吧(因为方法内操作的是数据库)。在`increaseMoney()`方法前加了`@Transcational`注解，说明这个方法是带有**事务**的。事务能保证同组的SQL要么同时成功，要么同时失败。讲道理，如果没有报错的话，应该每个线程都对money值进行`+1`。从理论上来说，结果应该是1000的才对。

(参考我之前写过的Spring事务：[一文带你看懂Spring事务！][Spring 1])

根据上面的分析，我怀疑是**提问者没测试好**(hhhh，逃)，于是我也跑去测试了一下，发现是以提问者的方式来使用**是真的有问题**。

首先贴一下我的测试代码：

@RestController
    public class EmployeeController { 
    
        @Autowired
        private EmployeeService employeeService;
    
        @RequestMapping("/add")
        public void addEmployee() { 
            for (int i = 0; i < 1000; i++) { 
                new Thread(() -> employeeService.addEmployee()).start();
            }
        }
    
    
    }
    
    @Service
    public class EmployeeService { 
    
        @Autowired
        private EmployeeRepository employeeRepository;
    
    
        @Transactional
        public synchronized void addEmployee() { 
    
            // 查出ID为8的记录，然后每次将年龄增加一
            Employee employee = employeeRepository.getOne(8);
            System.out.println(employee);
            Integer age = employee.getAge();
            employee.setAge(age + 1);
    
            employeeRepository.save(employee);
        }
    
    }

简单地打印了每次拿到的employee值，并且拿到了SQL执行的顺序，如下(贴出小部分)：

![SQL执行的顺序][SQL 1]

从打印的情况我们可以得出：多线程情况下并**没有串行**执行`addEmployee()`方法。这就导致对同一个值做**重复**的修改，所以最终的数值比1000要少。

## 二、图解出现的原因 ##

发现并不是**同步**执行的，于是我就怀疑`synchronized`关键字和Spring肯定有点冲突。于是根据这两个关键字搜了一下，找到了问题所在。

我们知道Spring事务的底层是Spring AOP，而Spring AOP的底层是动态代理技术。跟大家一起回顾一下动态代理：

public static void main(String[] args) { 
    
            // 目标对象
            Object target ;
    
            Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), Main.class, new InvocationHandler() { 
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    
                    // 但凡带有@Transcational注解的方法都会被拦截
    
                    // 1... 开启事务
    
                    method.invoke(target);
    
                    // 2... 提交事务
    
                    return null;
                }
                
            });
        }

(详细请参考我之前写过的动态代理：[给女朋友讲解什么是代理模式][Link 3])

实际上Spring做的处理跟以上的思路是一样的，我们可以看一下TransactionAspectSupport类中`invokeWithinTransaction()`：

![Spring事务管理是如何实现的][Spring 2]

调用方法**前**开启事务，调用方法**后**提交事务

![Spring事务和synchronized锁互斥问题][Spring_synchronized]

在多线程环境下，就可能会出现：**方法执行完了(synchronized代码块执行完了)，事务还没提交，别的线程可以进入被synchronized修饰的方法，再读取的时候，读到的是还没提交事务的数据，这个数据不是最新的**，所以就出现了这个问题。

![事务未提交，别的线程读取到旧数据][format_png 49]

## 三、解决问题 ##

从上面我们可以发现，问题所在是因为`@Transcational`注解和`synchronized`一起使用了，**加锁的范围没有包括到整个事务**。所以我们可以这样做：

新建一个名叫SynchronizedService类，让其去调用`addEmployee()`方法，整个代码如下：

@RestController
    public class EmployeeController { 
    
        @Autowired
        private SynchronizedService synchronizedService ;
    
        @RequestMapping("/add")
        public void addEmployee() { 
            for (int i = 0; i < 1000; i++) { 
                new Thread(() -> synchronizedService.synchronizedAddEmployee()).start();
            }
        }
    }
    
    // 新建的Service类
    @Service
    public class SynchronizedService { 
    
        @Autowired
        private EmployeeService employeeService ;
    	
        // 同步
        public synchronized void synchronizedAddEmployee() { 
            employeeService.addEmployee();
    
        }
    }
    
    @Service
    public class EmployeeService { 
    
        @Autowired
        private EmployeeRepository employeeRepository;
    
        
        @Transactional
        public void addEmployee() { 
    
            // 查出ID为8的记录，然后每次将年龄增加一
            Employee employee = employeeRepository.getOne(8);
            System.out.println(Thread.currentThread().getName() + employee);
            Integer age = employee.getAge();
            employee.setAge(age + 1);
    
            employeeRepository.save(employee);
    
        }
    }

我们将synchronized锁的范围**包含到整个Spring事务上**，这就不会出现线程安全的问题了。在测试的时候，我们可以发现1000个线程跑起来**比之前要慢得多**，当然我们的数据是正确的：

![正确的数据][format_png 50]

## 最后 ##

可以发现的是，虽然说Spring事务用起来我们是非常方便的，但如果不了解一些Spring事务的细节，很多时候出现Bug了就百思不得其解。还是得继续加油努力呀~~~

![format_png 51][]

# IOC再回顾和面试题 #

本来想的是刷完《Spring 实战 (第4版)》和《精通Spring4.x 企业应用开发实战》的IOC章节后来重新编写一篇IOC的文章的，看了一下之前已经写过的入门系列[Spring入门这一篇就够了][Spring 3]和[Spring【依赖注入】就是这么简单][Spring 4]。最主要的知识点都已经讲过了，所以感觉就没必要重新来编写这些知识点了…

这篇文章主要是**补充和强化**一些比较重要的知识点，并会把上面的两本书关于IOC的知识点整理出来。

那么接下来就开始吧，如果有错的地方希望能多多包涵，并不吝在评论区指正！

## 一、Spring IOC全面认知 ##

结合《Spring 实战 (第4版)》和《精通Spring4.x 企业应用开发实战》两本书的IOC章节将其知识点整理起来~

### 1.1IOC和DI概述 ###

在《精通Spring4.x 企业应用开发实战》中对IOC的定义是这样的：

> IoC(Inversion of Control)控制反转，包含了两个方面：一、控制。二、反转

我们可以简单认为：

*  控制指的是：**当前对象对内部成员的控制权**。
 *  反转指的是：这种控制权**不由当前对象管理**了，由其他(类,第三方容器)来管理。

> IOC不够开门见山，于是Martin Fowler提出了DI(dependency injection)来替代IoC，即让调用类对某一接口实现类的依赖关系由第三方(容器或协作类)注入，以移除调用类对某一接口实现类的依赖。

在《Spring 实战 (第4版)》中并没有提及到IOC，而是直接来说DI的：

> 通过DI，对象的依赖关系将由系统中负责协调各对象的第三方组件在创建对象的时候进行设定，对象无需自行创建或管理它们的依赖关系，依赖关系将被自动注入到需要它们的对象当中去

从书上我们也可以发现：IoC和DI的定义(区别)并不是如此容易就可以说得清楚的了。这里我就**简单摘抄**一下：

*  IoC(思想，设计模式)主要的实现方式有两种：依赖查找，**依赖注入**。
 *  依赖注入是一种更可取的方式(实现的方式)

对我们而言，其实也没必要分得那么清，混合一谈也不影响我们的理解…

再通过昨天写过的[工厂模式理解了没有？][Link 4]，我们现在就可以很清楚的发现，其实**所谓的IOC容器就是一个大工厂**【第三方容器】(Spring实现的功能很强大！比我们自己手写的工厂要好很多)。

使用IOC的好处(知乎@Intopass的回答)：

参考资料：

*  [https://www.zhihu.com/question/23277575][https_www.zhihu.com_question_23277575]–Spring IoC有什么好处呢？

### 1.2IOC容器的原理 ###

从上面就已经说了：IOC容器其实就是一个大工厂，它用来管理我们所有的对象以及依赖关系。

*  原理就是通过Java的**反射技术**来实现的！通过反射我们可以获取类的所有信息(成员变量、类名等等等)！
 *  再通过配置文件(xml)或者注解来**描述**类与类之间的关系
 *  我们就可以通过这些配置信息和反射技术来**构建**出对应的对象和依赖关系了！

上面描述的技术只要学过点Java的都能说出来，这一下子可能就会被面试官问倒了，我们**简单**来看看实际Spring IOC容器是怎么实现对象的创建和依赖的：

![format_png 52][]

1.  根据Bean配置信息在容器内部创建Bean定义注册表
2.  根据注册表加载、实例化bean、建立Bean与Bean之间的依赖关系
3.  将这些准备就绪的Bean放到Map缓存池中，等待应用程序调用

Spring容器(Bean工厂)可简单分成两种：

*  BeanFactory
    
     *  这是最基础、面向Spring的
 *  ApplicationContext
    
     *  这是在BeanFactory基础之上，面向使用Spring框架的开发者。提供了一系列的功能！

几乎所有的应用场合**都是**使用ApplicationContext！

BeanFactory的继承体系：

![format_png 53][]

ApplicationContext的继承体系：

![format_png 54][]

其中在ApplicationContext子类中又有一个比较重要的：WebApplicationContext

专门为Web应用准备的

![format_png 55][]

Web应用与Spring融合：

![format_png 56][]

我们看看BeanFactory的生命周期：

![format_png 57][]

接下来我们再看看ApplicationContext的生命周期：

![format_png 58][]

初始化的过程都是比较长，我们可以**分类**来对其进行解析：

*  **Bean自身的方法**：如调用 Bean 构造函数实例化 Bean，调用 Setter 设置 Bean 的属性值以及通过的 init-method 和 destroy-method 所指定的方法；
 *  **Bean级生命周期接口方法**：如 BeanNameAware、 BeanFactoryAware、 InitializingBean 和 DisposableBean，这些接口方法由 Bean 类直接实现；
 *  **容器级生命周期接口方法**：在上图中带“★” 的步骤是由 InstantiationAwareBean PostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“ **后处理器**” 。 后处理器接口一般不由 Bean 本身实现，它们独立于 Bean，实现类以容器附加装置的形式注册到Spring容器中并通过接口反射为Spring容器预先识别。当Spring 容器创建任何 Bean 的时候，这些后处理器都会发生作用，所以这些后处理器的影响是全局性的。当然，用户可以通过合理地编写后处理器，让其仅对感兴趣Bean 进行加工处理

ApplicationContext和BeanFactory**不同之处**在于：

*  ApplicationContext会利用Java反射机制自动识别出配置文件中定义的BeanPostProcessor、 InstantiationAwareBeanPostProcesso 和BeanFactoryPostProcessor**后置器**，并**自动将它们注册到应用上**下文中。而BeanFactory需要在代码中通过**手工调用**`addBeanPostProcessor()`方法进行注册
 *  ApplicationContext在**初始化**应用上下文的时候**就实例化所有单实例的Bean**。而BeanFactory在初始化容器的时候并未实例化Bean，**直到**第一次访问某个Bean时**才**实例化目标Bean。

有了上面的知识点了，我们再来**详细**地看看Bean的初始化过程：

![format_png 59][]

简要总结：

*  BeanDefinitionReader**读取Resource所指向的配置文件资源**，然后解析配置文件。配置文件中每一个`<bean>`解析成一个**BeanDefinition对象**，并**保存**到BeanDefinitionRegistry中；
 *  容器扫描BeanDefinitionRegistry中的BeanDefinition；调用InstantiationStrategy**进行Bean实例化的工作**；使用**BeanWrapper完成Bean属性的设置**工作；
 *  单例Bean缓存池：Spring 在DefaultSingletonBeanRegistry类中提供了一个用于缓存单实例 Bean 的**缓存器**，它是一个用HashMap实现的缓存器，单实例的Bean**以beanName为键保存在这个HashMap**中。

### 1.3IOC容器装配Bean ###

#### 1.3.1装配Bean方式 ####

Spring4.x开始IOC容器装配Bean有**4种**方式：

*  XML配置
 *  注解
 *  JavaConfig
 *  基于Groovy DSL配置(这种很少见)

总的来说：我们以XML配置+注解来装配Bean得多，其中**注解这种方式占大部分**！

#### 1.3.2依赖注入方式 ####

依赖注入的方式有3种方式：

*  **属性注入**–>通过`setter()`方法注入
 *  构造函数注入
 *  工厂方法注入

总的来说使用**属性注入**是比较灵活和方便的，这是大多数人的选择！

#### 1.3.3对象之间关系 ####

`<bean>`对象之间有三种关系：

*  依赖–>挺少用的(使用depends-on就是依赖关系了–>前置依赖【依赖的Bean需要初始化之后，当前Bean才会初始化】)
 *  继承–>可能会用到(指定abstract和parent来实现继承关系)
 *  引用–>最常见(使用ref就是引用关系了)

#### 1.3.4Bean的作用域 ####

Bean的作用域：

*  单例Singleton
 *  多例prototype
 *  与Web应用环境相关的Bean作用域
    
     *  reqeust
     *  session

使用到了Web应用环境相关的Bean作用域的话，是需要我们**手动配置代理**的~

![format_png 60][]

原因也很简单：因为我们默认的Bean是单例的，为了适配Web应用环境相关的Bean作用域—>每个request都需要一个对象，此时我们**返回一个代理对象**出去就可以完成我们的需求了！

![format_png 61][]

--------------------

将Bean配置单例的时候还有一个问题：

*  如果我们的Bean配置的是单例，而Bean对象里边的**成员对象我们希望是多例的话**。那怎么办呢？？
 *  默认的情况下我们的Bean单例，返回的成员对象也默认是单例的(因为对象就只有那么一个)！

此时我们需要用到了`lookup`方法注入，使用也很简单，看看例子就明白了：

![format_png 62][]

#### 1.3.6处理自动装配的歧义性 ####

昨天在刷书的时候刚好看到了有人在知乎邀请我回答这个问题：

![format_png 63][]

结合两本书的知识点，可以归纳成两种解决方案：

*  使用`@Primary`注解设置为**首选**的注入Bean
 *  使用`@Qualifier`注解设置**特定名称的Bean**来限定注入！
    
     *  也可以使用自定义的注解来标识

#### 1.3.7引用属性文件以及Bean属性 ####

之前在写配置文件的时候都是直接将我们的数据库配置信息在里面写死的了：

![format_png 64][]

其实我们有**更优雅的做法**：将这些配置信息写到配置文件上(因为这些配置信息很可能是会变的，而且有可能被多个配置文件引用).

*  如此一来，我们**改的时候就十分方便**了。

![format_png 65][]

引用配置文件的数据使用的是`${}`

除了引用配置文件上的数据，我们还可以**引用Bean的属性**：

![format_png 66][]

![format_png 67][]

引用Bean的属性使用的是`#{}`

在这种技术在《Spring 实战 第四版》称之为Spring EL，跟我们之前学过的EL表达式是类似的。主要的功能就是上面的那种，想要更深入了解可参考下面的链接：

*  [http://www.cnblogs.com/leiOOlei/p/3543222.html][http_www.cnblogs.com_leiOOlei_p_3543222.html]

#### 1.3.8组合配置文件 ####

xml文件之间组合：

![format_png 68][]

xml和javaconfig互相组合的方式：

public static void main(String[] args) { 
    		
            //1.通过构造函数加载配置类
             ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConf.class);
    
            //2.通过编码方式注册配置类
    		 AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    		 ctx.register(DaoConfig.class);
    		 ctx.register(ServiceConfig.class);
    		 ctx.refresh();
    
            //3.通过XML组装@Configuration配置类所提供的配置信息
    		 ApplicationContext ctx = new ClassPathXmlApplicationContext("com/smart/conf/beans2.xml");
    
            //4.通过@Configuration组装XML配置所提供的配置信息
    		 ApplicationContext ctx = new AnnotationConfigApplicationContext(LogonAppConfig.class);
    
    		 //5.@Configuration的配置类相互引用
    		 ApplicationContext ctx = new AnnotationConfigApplicationContext(DaoConfig.class,ServiceConfig.class);
             LogonService logonService = ctx.getBean(LogonService.class);
             System.out.println((logonService.getLogDao() !=null));
             logonService.printHelllo();   
    	}

第一种的例子：

![format_png 69][]

第二种的例子：

![format_png 70][]

![format_png 71][]

第三种的例子：

![format_png 72][]

第四种的例子：

![format_png 73][]

#### 1.3.9装配Bean总结 ####

总的来说，Spring IOC容器就是在创建Bean的时候有很多的方式给了我们实现，其中也包括了很多关于Bean的配置~

对于Bean相关的注入教程代码和简化配置(p和c名称空间)我就不一一说明啦，你们去看[Spring入门这一篇就够了][Spring 3]和[Spring【依赖注入】就是这么简单][Spring 4]就行了。

总的对比图：

![format_png 74][]  
![format_png 75][]

分别的应用场景：

![format_png 76][]

至于一些小的知识点：

*  方法替换
    
     *  使用某个Bean的方法替换成另一个Bean的方法
 *  属性编辑器
    
     *  Spring可以对基本类型做转换就归结于属性编辑器的功劳！
 *  国际化
    
     *  使用不同语言(英语、中文)的操作系统去显式不同的语言
 *  profile与条件化的Bean
    
     *  满足了某个条件才初始化Bean，这可以方便切换生产环境和开发环境~
 *  容器事件
    
     *  类似于我们的Servlet的监听器，只不过它是在Spring中实现了~

上面这些小知识点比较少情况会用到，这也不去讲解啦。知道有这么一回事，到时候查查就会用啦~~~

![format_png 77][]

## 二、Spring IOC相关面试题 ##

将SpringIOC相关知识点整理了一遍，要想知道哪些知识点是比较重要的。很简单，我们去找找相关的面试题就知道了，如果该面试题是常见的，那么说明这个知识点还是相对比较重要的啦！

以下的面试题从各种博客上摘抄下来，摘抄量较大的会注明出处的~

### 2.1什么是spring? ###

> 什么是spring?

Spring 是个java企业级应用的开源开发框架。Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。Spring框架**目标是简化Java企业级应用开发**，并通过POJO为基础的编程模型促进良好的编程习惯。

### 2.2使用Spring框架的好处是什么？ ###

> 使用Spring框架的好处是什么？

*  **轻量**：Spring 是轻量的，基本的版本大约2MB。
 *  **控制反转**：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
 *  **面向切面的编程**(AOP)：Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
 *  **容器**：Spring 包含并管理应用中对象的生命周期和配置。
 *  **MVC框架**：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。
 *  **事务管理**：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。
 *  **异常处理**：Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO抛出的）转化为一致的unchecked 异常。

### 2.3Spring由哪些模块组成? ###

> Spring由哪些模块组成?

简单可以分成6大模块：

*  Core
 *  AOP
 *  ORM
 *  DAO
 *  Web
 *  Spring EE

![format_png 78][]

### 2.4BeanFactory 实现举例 ###

> BeanFactory 实现举例

Bean工厂是工厂模式的一个实现，提供了控制反转功能，**用来把应用的配置和依赖从正真的应用代码中分离**。

在spring3.2之前最常用的是XmlBeanFactory的，但现在被废弃了，取而代之的是：XmlBeanDefinitionReader和DefaultListableBeanFactory

### 2.5什么是Spring的依赖注入？ ###

> 什么是Spring的依赖注入？

依赖注入，是IOC的一个方面，是个通常的概念，它有多种解释。这概念是说你不用创建对象，而只需要描述它如何被创建。你**不在代码里直接组装你的组件和服务，但是要在配置文件里描述哪些组件需要哪些服务**，之后一个容器（IOC容器）负责把他们组装起来。

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

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

*  **构造器依赖注入**：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。
 *  **Setter方法注入**：Setter方法注入是容器通过调用无参构造器或无参static工厂 方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。
 *  工厂注入：这个是遗留下来的，很少用的了！

### 2.7哪种依赖注入方式你建议使用，构造器注入，还是 Setter方法注入？ ###

> 哪种依赖注入方式你建议使用，构造器注入，还是 Setter方法注入？

你两种依赖方式都可以使用，构造器注入和Setter方法注入。最好的解决方案是**用构造器参数实现强制依赖，setter方法实现可选依赖**。

### 2.8什么是Spring beans? ###

> 什么是Spring beans?

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

这里有四种重要的方法给Spring容器**提供配置元数据**。

*  XML配置文件。
 *  基于注解的配置。
 *  基于java的配置。
 *  Groovy DSL配置

### 2.9解释Spring框架中bean的生命周期 ###

> 解释Spring框架中bean的生命周期

*  Spring容器 从XML 文件中读取bean的定义，并实例化bean。
 *  Spring根据bean的定义填充所有的属性。
 *  如果bean实现了BeanNameAware 接口，Spring 传递bean 的ID 到 setBeanName方法。
 *  如果Bean 实现了 BeanFactoryAware 接口， Spring传递beanfactory 给setBeanFactory 方法。
 *  如果有任何与bean相关联的BeanPostProcessors，Spring会在postProcesserBeforeInitialization()方法内调用它们。
 *  如果bean实现IntializingBean了，调用它的afterPropertySet方法，如果bean声明了初始化方法，调用此初始化方法。
 *  如果有BeanPostProcessors 和bean 关联，这些bean的postProcessAfterInitialization() 方法将被调用。
 *  如果bean实现了 DisposableBean，它将调用destroy()方法。

### 2.10解释不同方式的自动装配 ###

> 解释不同方式的自动装配

*  no：默认的方式是不进行自动装配，通过显式设置ref 属性来进行装配。
 *  byName：通过参数名 自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byname，之后容器试图匹配、装配和该bean的属性具有相同名字的bean。
 *  byType:：通过参数类型自动装配，Spring容器在配置文件中发现bean的autowire属性被设置成byType，之后容器试图匹配、装配和该bean的属性具有相同类型的bean。如果有多个bean符合条件，则抛出错误。
 *  constructor：这个方式类似于byType， 但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。
 *  autodetect：首先尝试使用constructor来自动装配，如果无法工作，则使用byType方式。

只用注解的方式时，**注解默认是使用byType的**！

### 2.11IOC的优点是什么？ ###

> IOC的优点是什么？

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

### 2.12哪些是重要的bean生命周期方法？ 你能重载它们吗？ ###

> 哪些是重要的bean生命周期方法？ 你能重载它们吗？

有两个重要的bean 生命周期方法，第一个是`setup`， 它是在容器加载bean的时候被调用。第二个方法是 `teardown` 它是在容器卸载类的时候被调用。

The bean 标签有两个重要的属性（`init-method`和`destroy-method`）。用它们你可以自己定制初始化和注销方法。它们也有相应的注解（`@PostConstruct`和`@PreDestroy`）。

### 2.13怎么回答面试官：你对Spring的理解？ ###

> 怎么回答面试官：你对Spring的理解？

来源：

*  [https://www.zhihu.com/question/48427693?sort=created][https_www.zhihu.com_question_48427693_sort_created]

下面我就截几个答案：

一、

![format_png 79][]

二、

![format_png 80][]

### 2.14Spring框架中的单例Beans是线程安全的么？ ###

> Spring框架中的单例Beans是线程安全的么？

Spring框架并没有对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题需要开发者自行去搞定。但实际上，大部分的Spring bean并没有可变的状态(比如Serview类和DAO类)，所以在某种程度上说Spring的单例bean是线程安全的。**如果你的bean有多种状态的话**（比如 View Model 对象），就**需要自行保证线程安全**。

最浅显的解决办法就是将多态bean的作用域由“singleton”变更为“prototype”

### 2.15FileSystemResource和ClassPathResource有何区别？ ###

> FileSystemResource和ClassPathResource有何区别？

在FileSystemResource 中需要给出spring-config.xml文件在你项目中的相对路径或者绝对路径。在ClassPathResource中spring会在ClassPath中自动搜寻配置文件，所以要把ClassPathResource文件放在ClassPath下。

如果将spring-config.xml保存在了src文件夹下的话，只需给出配置文件的名称即可，因为src文件夹是默认。

简而言之，**ClassPathResource在环境变量中读取配置文件，FileSystemResource在配置文件中读取配置文件**。

![aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY256MmR2bTF4ZzMwNzMwNzNxNjUuZ2lm][]

# AOP再回顾 #

这篇文章主要是**补充和强化**一些比较重要的知识点

## 一、Spring AOP全面认知 ##

结合《Spring 实战 (第4版)》和《精通Spring4.x 企业应用开发实战》两本书的AOP章节将其知识点整理起来~

### 1.1AOP概述 ###

AOP称为面向切面编程，那我们怎么理解面向切面编程？？

我们可以先看看下面这段代码：

![format_png 81][]

我们学Java面向对象的时候，如果代码重复了怎么办啊？？可以分成下面几个步骤：

*  1：抽取成方法
 *  2：抽取类

抽取成类的方式我们称之为：**纵向抽取**

*  通过继承的方式实现纵向抽取

但是，我们现在的办法不行：即使抽取成类还是会出现重复的代码，因为这些逻辑(开始、结束、提交事务)**依附在我们业务类的方法逻辑中**！

![format_png 82][]

现在纵向抽取的方式不行了，AOP的理念：就是将**分散在各个业务逻辑代码中相同的代码通过横向切割的方式**抽取到一个独立的模块中！

![format_png 83][]

上面的图也很清晰了，将重复性的逻辑代码横切出来其实很容易(我们简单可认为就是封装成一个类就好了)，但我们要将这些**被我们横切出来的逻辑代码融合到业务逻辑中**，来完成和之前(没抽取前)一样的功能！这就是AOP首要解决的问题了！

### 1.2Spring AOP原理 ###

> 被我们横切出来的逻辑代码融合到业务逻辑中，来完成和之前(没抽取前)一样的功能

没有学Spring AOP之前，我们就可以使用代理来完成。

*  如果看过我写的[给女朋友讲解什么是代理模式][Link 5]这篇文章的话，一定就不难理解上面我说的那句话了
 *  代理能干嘛？代理可以帮我们**增强对象的行为**！使用动态代理实质上就是**调用时拦截对象方法，对方法进行改造、增强**！

其实Spring AOP的底层原理就是**动态代理**！

来源《精通Spring4.x 企业应用开发实战》一段话：

> Spring AOP使用纯Java实现，它不需要专门的编译过程，也不需要特殊的类装载器，它在**运行期通过代理方式向目标类织入增强代码**。在Spring中可以无缝地将Spring AOP、IoC和AspectJ整合在一起。

来源《Spring 实战 (第4版)》一句话：

> Spring AOP构建在动态代理基础之上，因此，**Spring对AOP的支持局限于方法拦截**。

在Java中动态代理有**两种**方式：

*  JDK动态代理
 *  CGLib动态代理

![format_png 84][]

JDK动态代理是需要实现某个接口了，而我们类未必全部会有接口，于是CGLib代理就有了~~

*  CGLib代理其生成的动态代理对象是目标类的子类
 *  Spring AOP**默认是使用JDK动态代理**，如果代理的类**没有接口则会使用CGLib代理**。

那么JDK代理和CGLib代理我们该用哪个呢？？在《精通Spring4.x 企业应用开发实战》给出了建议：

*  如果是**单例的我们最好使用CGLib代理**，如果是多例的我们最好使用JDK代理

原因：

*  JDK在创建代理对象时的性能要高于CGLib代理，而生成代理对象的运行性能却比CGLib的低。
 *  如果是单例的代理，推荐使用CGLib

看到这里我们就应该知道什么是Spring AOP(面向切面编程)了：**将相同逻辑的重复代码横向抽取出来，使用动态代理技术将这些重复代码织入到目标对象方法中，实现和原来一样的功能**。

*  这样一来，我们就在**写业务时只关心业务代码**，而不用关心与业务无关的代码

### 1.3AOP的实现者 ###

AOP除了有Spring AOP实现外，还有著名的AOP实现者：AspectJ，也有可能大家没听说过的实现者：JBoss AOP~~

我们下面来说说AspectJ扩展一下知识面：

> AspectJ是**语言级别**的AOP实现，扩展了Java语言，定义了AOP语法，能够在**编译期**提供横切代码的织入，所以它有**专门的编译器**用来生成遵守Java字节码规范的Class文件。

而Spring借鉴了AspectJ很多非常有用的做法，**融合了AspectJ实现AOP的功能**。但Spring AOP本质上**底层还是动态代理**，所以Spring AOP是不需要有专门的编辑器的~

### 1.4AOP的术语 ###

嗯，AOP搞了好几个术语出来~~两本书都有讲解这些术语，我会尽量让大家看得明白的：

**连接点**(Join point)：

*  **能够被拦截的地方**：Spring AOP是基于动态代理的，所以是方法拦截的。每个成员方法都可以称之为连接点~

**切点**(Poincut)：

*  **具体定位的连接点**：上面也说了，每个方法都可以称之为连接点，我们**具体定位到某一个方法就成为切点**。

**增强/通知**(Advice)：

*  表示添加到切点的一段**逻辑代码**，并定位连接点的**方位信息**。
    
     *  简单来说就定义了是干什么的，具体是在哪干
     *  Spring AOP提供了5种Advice类型给我们：前置、后置、返回、异常、环绕给我们使用！

**织入**(Weaving)：

*  将`增强/通知`添加到目标类的具体连接点上的过程。

**引入/引介**(Introduction)：

*  `引入/引介`允许我们**向现有的类添加新方法或属性**。是一种**特殊**的增强！

**切面**(Aspect)：

*  切面由切点和`增强/通知`组成，它既包括了横切逻辑的定义、也包括了连接点的定义。

在《Spring 实战 (第4版)》给出的总结是这样子的：

> 通知/增强包含了需要用于多个应用对象的横切行为；连接点是程序执行过程中能够应用通知的所有点；切点定义了通知/增强被应用的具体位置。其中关键的是切点定义了哪些连接点会得到通知/增强。

总的来说：

*  这些术语可能翻译过来不太好理解，但对我们正常使用AOP的话**影响并没有那么大**~~看多了就知道它是什么意思了。

### 1.5Spring对AOP的支持 ###

Spring提供了3种类型的AOP支持：

*  基于代理的经典SpringAOP
    
     *  需要实现接口，手动创建代理
 *  纯POJO切面
    
     *  使用XML配置，aop命名空间
 *  `@AspectJ`注解驱动的切面
    
     *  使用注解的方式，这是最简洁和最方便的！

![aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY25tdTFsYjJ2ZzMwNm8wNm9qdGcuZ2lm][]

## 二、基于代理的经典SpringAOP ##

这部分配置比较麻烦，用起来也很麻烦，这里我就主要整理一下书上的内容，大家看看了解一下吧，我们实际上使用Spring AOP基本不用这种方式了！

首先，我们来看一下增强接口的继承关系图：

![format_png 85][]

可以分成**五类**增强的方式：

![format_png 86][]

Spring提供了**六种的切点类型**：

![format_png 87][]

**切面类型主要分成了三种**：

*  **一般切面**
 *  **切点切面**
 *  **引介/引入切面**

![format_png 88][]

一般切面，切点切面，引介/引入切面介绍：

![format_png 89][]  
![format_png 90][]

对于切点切面我们一般都是直接用就好了，我们来看看引介/引入切面是怎么一回事：

*  引介/引入切面是引介/引入增强的封装器，通过引介/引入切面，**可以更容易地为现有对象添加任何接口的实现**！

继承关系图：

![format_png 91][]

引介/引入切面有两个实现类：

*  DefaultIntroductionAdvisor：常用的实现类
 *  DeclareParentsAdvisor：用于实现AspectJ语言的DeclareParent注解表示的引介/引入切面

实际上，我们使用AOP往往是**Spring内部使用BeanPostProcessor帮我们创建代理**。

这些代理的创建器可以分成三类：

*  基于Bean配置名规则的自动代理创建器：BeanNameAutoProxyCreator
 *  基于Advisor匹配机制的自动代理创建器：它会对容器所有的Advisor进行扫描，实现类为DefaultAdvisorAutoProxyCreator
 *  基于Bean中的AspectJ注解标签的自动代理创建器：AnnotationAwareAspectJAutoProxyCreator

对应的类继承图：

![format_png 92][]

嗯，基于代理的经典SpringAOP就讲到这里吧，其实我是不太愿意去写这个的，因为已经几乎不用了，在《Spring 实战 第4版》也没有这部分的知识点了。

*  但是通过这部分的知识点可以**更加全面地认识Spring AOP的各种接口**吧~

## 三、拥抱基于注解和命名空的AOP编程 ##

Spring在新版本中对AOP功能进行了增强，体现在这么几个方面：

*  在XML配置文件中为AOP提供了aop命名空间
 *  增加了AspectJ切点表达式语言的支持
 *  可以无缝地集成AspectJ

那我们使用`@AspectJ`来玩AOP的话，学什么？？其实也就是上面的内容，学如何设置切点、创建切面、增强的内容是什么…

![format_png 93][]

具体的切点表达式使用还是前往：[Spring【AOP模块】就这么简单][Spring_AOP]看吧~~

对应的增强注解：

![format_png 94][]

![format_png 95][]

### 3.1使用引介/引入功能实现为Bean引入新方法 ###

其实前置啊、后置啊这些很容易就理解了，整篇文章看下来就只有这个引介/引入切面有点搞头。于是我们就来玩玩吧~

我们来看一下具体的用法吧，现在我有个服务员的接口：

public interface Waiter { 
    
        // 向客人打招呼
        void greetTo(String clientName);
    
        // 服务
        void serveTo(String clientName);
    }

一位年轻服务员实现类：

public class NaiveWaiter implements Waiter { 
        public void greetTo(String clientName) { 
            System.out.println("NaiveWaiter:greet to " + clientName + "...");
        }
    
        @NeedTest
        public void serveTo(String clientName) { 
            System.out.println("NaiveWaiter:serving " + clientName + "...");
        }
    
    }

现在我想做的就是：**想这个服务员可以充当售货员的角色，可以卖东西**！当然了，我肯定不会加一个卖东西的方法到Waiter接口上啦，因为这个是暂时的~

所以，我搞了一个售货员接口：

public interface Seller { 
    
      // 卖东西
      int sell(String goods, String clientName);
    }

一个售货员实现类：

public class SmartSeller implements Seller { 
    
    	// 卖东西
    	public int sell(String goods,String clientName) { 
    		System.out.println("SmartSeller: sell "+goods +" to "+clientName+"...");
    		return 100;
    	}
    	
    }

此时，我们的类图是这样子的：

![format_png 96][]

现在我想干的就是：**借助AOP的引入/引介切面，来让我们的服务员也可以卖东西**！

我们的引入/引介切面具体是这样干的：

@Aspect
    public class EnableSellerAspect { 
        
        @DeclareParents(value = "com.smart.NaiveWaiter",  // 指定服务员具体的实现
                defaultImpl = SmartSeller.class) // 售货员具体的实现
        public Seller seller; // 要实现的目标接口
        
    }

写了这个切面类会发生什么？？

*  切面技术将SmartSeller融合到NaiveWaiter中，这样**NaiveWaiter就实现了Seller接口**！！！！

是不是很神奇？？我也觉得很神奇啊，我们来测试一下：

我们的`bean.xml`文件很简单：

测试一下：

public class Test { 
        public static void main(String[] args) { 
    
    
            ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("com/smart/aspectj/basic/beans.xml");
            Waiter waiter = (Waiter) ctx.getBean("waiter");
    
            // 调用服务员原有的方法
            waiter.greetTo("Java3y");
            waiter.serveTo("Java3y");
    
            // 通过引介/引入切面已经将waiter服务员实现了Seller接口，所以可以强制转换
            Seller seller = (Seller) waiter;
            seller.sell("水军", "Java3y");
    
        }
    }

![format_png 97][]

具体的调用过程是这样子的：

> 当引入接口方法被调用时，代理对象会把此调用委托给实现了新接口的某个其他对象。实际上，一个Bean的实现被拆分到多个类中

![format_png 98][]

### 3.2在XML中声明切面 ###

我们知道注解很方便，**但是**，要想使用**注解的方式**使用Spring AOP就**必须要有源码**(因为我们要在切面类上添加注解)。如果没有源码的话，我们就得使用XML来声明切面了~

其实就跟注解差不多的功能：

![format_png 99][]

我们就直接来个例子终结掉它吧：

首先我们来测试一下与传统的SpringAOP结合的advisor是怎么用的：

实现类：

![format_png 100][]

xml配置文件：

![format_png 101][]

…

一个一个来讲解还是太花时间了，我就一次性用图的方式来讲啦：

![format_png 102][]

最后还有一个切面类型总结图，看完就几乎懂啦：

![format_png 103][]

## 四、总结 ##

看起来AOP有很多很多的知识点，其实我们只要记住AOP的核心概念就行啦。

下面是我的简要总结AOP：

*  AOP的底层实际上是动态代理，动态代理分成了JDK动态代理和CGLib动态代理。如果被代理对象没有接口，那么就使用的是CGLIB代理(也可以直接配置使用CBLib代理)
 *  如果是单例的话，那我们最好使用CGLib代理，因为CGLib代理对象运行速度要比JDK的代理对象要快
 *  AOP既然是基于动态代理的，那么它只能对方法进行拦截，它的层面上是方法级别的
 *  无论经典的方式、注解方式还是XML配置方式使用Spring AOP的原理都是一样的，只不过形式变了而已。一般我们使用注解的方式使用AOP就好了。
 *  注解的方式使用Spring AOP就了解几个切点表达式，几个增强/通知的注解就完事了，是不是贼简单…使用XML的方式和注解其实没有很大的区别，很快就可以上手啦。
 *  引介/引入切面也算是一个比较亮的地方，可以用代理的方式为某个对象实现接口，从而能够使用借口下的方法。这种方式是非侵入式的~
 *  要增强的方法还可以接收与被代理方法一样的参数、绑定被代理方法的返回值这些功能…

![format_png 47][]

## 各类知识点总结 ##

> 下面的文章都有对应的**原创精美**PDF，在持续更新中，可以来找我催更~

*  [92页的Mybatis][92_Mybatis]
 *  [129页的多线程][129]
 *  [141页的Servlet][141_Servlet]
 *  [158页的JSP][158_JSP]
 *  [76页的集合][76]
 *  [64页的JDBC][64_JDBC]
 *  [105页的数据结构和算法][105]
 *  [142页的Spring][142_Spring]
 *  [58页的过滤器和监听器][58]
 *  [30页的HTTP][30_HTTP]
 *  [42页的SpringMVC][42_SpringMVC]
 *  Hibernate
 *  AJAX
 *  Redis
 *  …

#### 涵盖Java后端所有知识点的开源项目（已有8K+ star）： ####

*  [GitHub][https_github.com_ZhongFuCheng3y_3y]
 *  [Gitee访问更快][Gitee]

如果大家想要**实时**关注我更新的文章以及分享的干货的话，微信搜索**Java3y**。

PDF文档的内容**均为手打**，有任何的不懂都可以直接**来问我**（公众号有我的联系方式）。

![format_png 104][]

![format_png 105][]

![aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA2dE5iUndseTFnYjBuenBuOHo3ZzMwZ28wZ29rYnAuZ2lm][]

**我是三歪，一个想要变强的男人，感谢大家的点赞收藏和转发，下期见。**

[format_png]: /images/20210827/f14fc259448944e4a171b8f670478f21.png
[https_www.zhihu.com_question_23277575_answer_24259844]: https://www.zhihu.com/question/23277575/answer/24259844
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzAxOTc0NzExNg==&mid=2665513179&idx=1&sn=772226a5be436a0d08197c335ddb52b8#rd
[format_png 1]: /images/20210827/9e4c4006f77143a99cb2614d0016580b.png
[format_png 2]: /images/20210827/1d0e3399201049bb9f610f15ed7fe780.png
[format_png 3]: /images/20210827/dc302dfed880442c9e5755401d7a97bc.png
[format_png 4]: /images/20210827/6eb4b13d12884c7da438056b93396014.png
[format_png 5]: /images/20210827/46fb9c17c5a5403680da53f6dbc4a3c2.png
[format_png 6]: /images/20210827/b0c1f7291bee430092a670170c09f8e5.png
[format_png 7]: /images/20210827/93a8a6cd4b2d4978a5f3cade8be5391d.png
[format_png 8]: /images/20210827/47e3dfbd93cb4bf7946e96dd2de22584.png
[format_png 9]: /images/20210827/f7bba288e07e4d778572a06b2b1f7414.png
[format_png 10]: /images/20210827/ddb6758900364a83a7e7adf7d1ad34cc.png
[format_png 11]: /images/20210827/9cc20717d5c74694aa7a449b21c3e38f.png
[format_png 12]: /images/20210827/8e01bc0beacf4faba27c1bec07fa9c2a.png
[format_png 13]: /images/20210827/3d46f0e3e1c641e7b745eab60da15905.png
[aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY25tdTFsYjJ2ZzMwNm8wNm9qdGcuZ2lm]: /images/20210827/f3461c8647b54112b0e0a2a74dfa629b.png
[format_png 14]: /images/20210827/3c75f1ddd1f247bcbc834dc64093544b.png
[aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY256MDF5MXJmZzMwNm8wNm93ZWguZ2lm]: /images/20210827/e30d84d0241f4a5d962df3de8e0645be.png
[format_png 15]: /images/20210827/51a014c593544672a90057aea123d078.png
[format_png 16]: /images/20210827/5a195b7f188e45ed9c136d35c631aff2.png
[format_png 17]: /images/20210827/da1785e7996c4d53bf5c16122252a4a8.png
[format_png 18]: /images/20210827/2988a59b35fa42989de099b763ed25f3.png
[format_png 19]: /images/20210827/77810784d61a4a4980b895a65e468251.png
[format_png 20]: /images/20210827/5b28263c08ab49e3a54a3c8c9d9893bd.png
[format_png 21]: /images/20210827/1b52eecd33ab4b95a6fc69e670769d11.png
[aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY256MmR2bTF4ZzMwNzMwNzNxNjUuZ2lm]: /images/20210827/d7e65029e84e46a887bc923c90268bb8.png
[format_png 22]: /images/20210827/8f243878f9014305a86cff1ed6eb258a.png
[format_png 23]: /images/20210827/c8af3226697d4d1dbe32d3e3e4146023.png
[format_png 24]: /images/20210827/2af316d1c152442c8e6835dfa65360c8.png
[format_png 25]: /images/20210827/caa68dc6404c44bc92bdd5c881d42b37.png
[format_png 26]: /images/20210827/f9f2c8a531bd4b6598d76e63276b0d32.png
[format_png 27]: /images/20210827/fc23aa76bdce4f4ebb3cf733b34d0f09.png
[format_png 28]: /images/20210827/be511e4c06ac41f19cce6e8e95551666.png
[format_png 29]: /images/20210827/61ee0187583d4c4393cbb71043889b5e.png
[format_png 30]: /images/20210827/353a7913725d445a92685f4810a9df4c.png
[format_png 31]: /images/20210827/36c8e23ce1854b8781042f59445cf7f6.png
[format_png 32]: /images/20210827/6a7f84b2476b401f8f6844c7fe78a839.png
[format_png 33]: /images/20210827/6d6de7bcb23043209b15e0e8e1af5fcc.png
[format_png 34]: /images/20210827/cb578b7464404277963dc00eafa2c91a.png
[aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY25tcmwxeWxuZzMwNm8wNm9xM3QuZ2lm]: /images/20210827/874f3edd47a94eb6a5f44f68cda81d5a.png
[format_png 35]: /images/20210827/53d4f791462440e8a0e2c885e410ba7d.png
[format_png 36]: /images/20210827/fb84e10504024395a2fb1bd1c55a6dea.png
[format_png 37]: /images/20210827/fa11a0c9873c4cfbae53267077ea770e.png
[format_png 38]: /images/20210827/e903d60a58bb466783cfb421064ba533.png
[format_png 39]: /images/20210827/c8a50301799b4e4cae1d9b0ca0fad972.png
[format_png 40]: /images/20210827/3546cb180b3446df93619d094f34d666.png
[format_png 41]: /images/20210827/e24a81f56c314fa7af40077f18a189d0.png
[format_png 42]: /images/20210827/19e2d13305b2439b9e37966a87642133.png
[format_png 43]: /images/20210827/f13cd1f53de042258e6647b3b3f79144.png
[aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY255d283MWpyZzMwOGMwOGNhYTQuZ2lm]: /images/20210827/8bb7046674be497b86947f4301720a24.png
[AOP]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247483954&idx=1&sn=b34e385ed716edf6f58998ec329f9867&chksm=ebd74333dca0ca257a77c02ab458300ef982adff3cf37eb6d8d2f985f11df5cc07ef17f659d4&scene=21##wechat_redirect
[AOP 1]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484251&idx=1&sn=f792c5a1835af2c17f260be2055b5776&chksm=ebd7425adca0cb4cc3a4e2ee61bdfa99508ea564e4ba4fd4ed54054b12fed76694b2b3afc26e&scene=21##wechat_redirect
[AOP 2]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484222&idx=1&sn=5191aca33f7b331adaef11c5e07df468&chksm=ebd7423fdca0cb29cdc59b4c79afcda9a44b9206806d2212a1b807c9f5879674934c37c250a1&scene=21##wechat_redirect
[XML_Spring]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247483965&idx=1&sn=2cd6c1530e3f81ca5ad35335755ed287&chksm=ebd7433cdca0ca2a70cb8419306eb9b3ccaa45b524ddc5ea549bf88cf017d6e5c63c45f62c6e&scene=21##wechat_redirect
[Spring_Bean_BPP]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484247&idx=1&sn=e228e29e344559e469ac3ecfa9715217&chksm=ebd74256dca0cb40059f3f627fc9450f916c1e1b39ba741842d91774f5bb7f518063e5acf5a0&scene=21##wechat_redirect
[IOC]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484239&idx=1&sn=6560be96e456b513cb1e4f78a740a258&chksm=ebd7424edca0cb584906fb97679cf2ca557f430fbc87d2c86ce0652d2e3c36c2528466942df5&scene=21##wechat_redirect
[Link 2]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484194&idx=1&sn=ed1241fcba5d3e85b6d900d8667f04f6&chksm=ebd74223dca0cb35fe16a267c88ac9e5159825b27c278fb165a8c50d681e1340b73cfd69ae0d&scene=21##wechat_redirect
[ThreadLocal]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484118&idx=1&sn=da3e4c4cfd0642687c5d7bcef543fe5b&chksm=ebd743d7dca0cac19a82c7b29b5b22c4b902e9e53bd785d066b625b4272af2a6598a0cc0f38e&scene=21##wechat_redirect
[Exception_Spring]: /images/20210827/6498952eef75498c9dd4a0038f0198c6.png
[Spring]: /images/20210827/0d9d4a6a54244a688087b94db9e57d87.png
[format_png 44]: /images/20210827/51bc226040354928b30ec1067a6ba26b.png
[format_png 45]: /images/20210827/4e344b5189974652b928cbea3b5aa58e.png
[format_png 46]: /images/20210827/5c943899c48c48238af1420ff9c68611.png
[format_png 47]: /images/20210827/890c0ded9dea4002b81c2df407a9bd31.png
[Session]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247483937&idx=2&sn=28c7827639bb6ac0296746c4c4343c59&chksm=ebd74320dca0ca36b763b3975665fc38a7e921f9ecaef1aaea3a7c757063a29222cd00b3d3b6&scene=21##wechat_redirect
[Mybatis]: /images/20210827/59c03ceab9f9479db7d74c8cc0a9a6f3.png
[ThreadLocal 1]: /images/20210827/ecadb959f73340cf95841c4d337e8a7f.png
[Application_Bean]: /images/20210827/7648daa72b59433e881da7d78549cd91.png
[BBP]: /images/20210827/23609d8a2b2642b0a5eb628dac2a08a5.png
[PlatformTransactionManager]: /images/20210827/0a9bdf3a9bbf42b2894cbc34b4be5008.png
[https_github.com_ZhongFuCheng3y_3y]: https://github.com/ZhongFuCheng3y/3y
[https_www.zhihu.com_question_277812143]: https://www.zhihu.com/question/277812143
[format_png 48]: /images/20210827/b1f6f16e177743b0944c16c528a0fec4.png
[SQL]: /images/20210827/d4f17bef7bf64959ac15b4051f62559f.png
[1000]: /images/20210827/fab92670217a439b9312a96e0970758f.png
[Java]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484198&idx=1&sn=4d8e372165bb49987a6243f17153a9b4&chksm=ebd74227dca0cb31311886f835092c9360d08a9f0a249ece34d4b1e49a31c9ec773fa66c8acc&scene=21#wechat_redirect
[Spring 1]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484721&idx=5&sn=67467f35a9e9314aa3d1c07ff250af6b&chksm=ebd74430dca0cd26c94daf2d3e34806c29d05583de2255b98d20d34cd86e12ae94624d33be1b&token=1885756144&lang=zh_CN#rd
[SQL 1]: /images/20210827/18820346a3af49ae8f469333c283e338.png
[Link 3]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484222&idx=1&sn=5191aca33f7b331adaef11c5e07df468&chksm=ebd7423fdca0cb29cdc59b4c79afcda9a44b9206806d2212a1b807c9f5879674934c37c250a1&scene=21#wechat_redirect
[Spring 2]: /images/20210827/f307d1ac11fb489da7a9bb5fc24b470b.png
[Spring_synchronized]: /images/20210827/a4ea5be9e07044be822bd2b49353b81d.png
[format_png 49]: /images/20210827/449e08b6c15a467a93fc93e8ec23f3ee.png
[format_png 50]: /images/20210827/6089da1328104eecab348e7c03f5fc62.png
[format_png 51]: /images/20210827/0d352f0fb48c4b3383d7492184863ed0.png
[Spring 3]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247483942&idx=1&sn=f71e1adeeaea3430dd989ef47cf9a0b3&chksm=ebd74327dca0ca3141c8636e95d41629843d2623d82be799cf72701fb02a665763140b480aec#rd
[Spring 4]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247483946&idx=1&sn=bb21dfd83cf51214b2789c9ae214410f&chksm=ebd7432bdca0ca3ded6ad9b50128d29267f1204bf5722e5a0501a1d38af995c1ee8e37ae27e7#rd
[Link 4]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484243&idx=1&sn=972cbe6cdb578256e4d4771e7ca25de3&chksm=ebd74252dca0cb44419903758e8ca52d9ab287562f80be9365e305d6dcc2deaa45b40f9fd2e9#rd
[https_www.zhihu.com_question_23277575]: https://www.zhihu.com/question/23277575
[format_png 52]: /images/20210827/e8c29fd654f84abab7707db752ad3013.png
[format_png 53]: /images/20210827/465977e48a144f28affc29af824341a1.png
[format_png 54]: /images/20210827/1840c1438fc9453d817e4e0d6316bd7b.png
[format_png 55]: /images/20210827/650a97be5cc0417ab7039cbf698f3f7e.png
[format_png 56]: /images/20210827/e634d498c64c433db76a3a509d3dfa61.png
[format_png 57]: /images/20210827/0fb0fcf74dd9469a8a97e327abdacbeb.png
[format_png 58]: /images/20210827/5708c1f25e7d4a7180fc184ba1b28ffa.png
[format_png 59]: /images/20210827/c3364c1169bd46f79c3631514a0c7f65.png
[format_png 60]: /images/20210827/f2c527bc371643b0bf74c905c7410af9.png
[format_png 61]: /images/20210827/1fcb3626946647ee8a608a6ddd895119.png
[format_png 62]: /images/20210827/1108a01738db4c85aa719ceb0506771c.png
[format_png 63]: /images/20210827/27742863ee7c46019f727ac2d958edc4.png
[format_png 64]: /images/20210827/1f69a2ab5b1b49efbde3bf60099d558f.png
[format_png 65]: /images/20210827/e90488e82747428a8f3fd71ba1c353c6.png
[format_png 66]: /images/20210827/56c23376f6644b318c52d24108edd1dd.png
[format_png 67]: /images/20210827/4fb909f9162e45e3b91b0f20f059972a.png
[http_www.cnblogs.com_leiOOlei_p_3543222.html]: http://www.cnblogs.com/leiOOlei/p/3543222.html
[format_png 68]: /images/20210827/84a383a9eb924c51a93becadfcace383.png
[format_png 69]: /images/20210827/56647e90aae4407a8ad7730f9a8c7637.png
[format_png 70]: /images/20210827/0f48ce0a75ae424996c1b2ebb3b4580b.png
[format_png 71]: /images/20210827/3e6324f34c45438b8ccdc93a49524afc.png
[format_png 72]: /images/20210827/333c11d4060342d4b6988e9af32027a6.png
[format_png 73]: /images/20210827/63e634a6d2dc4cb587f59f6715d9268e.png
[format_png 74]: /images/20210827/3308b0d0606742f786d6c561d89ce641.png
[format_png 75]: /images/20210827/ce8af574901e4b35a1a57d31e8ba055a.png
[format_png 76]: /images/20210827/b68d8f3bb47c4089832379b22bd13ba1.png
[format_png 77]: /images/20210827/2927887cabb04dab866bb12d3eb9776c.png
[format_png 78]: /images/20210827/08b0bcb168cc498dbbd3f01e3edf25f5.png
[https_www.zhihu.com_question_48427693_sort_created]: https://www.zhihu.com/question/48427693?sort=created
[format_png 79]: /images/20210827/7c1ec8daf58a447e90ddf1aede691f09.png
[format_png 80]: /images/20210827/62737178a54b49ef8cee3220cd641f68.png
[format_png 81]: /images/20210827/1af5bbde75e1458daac6842a878665d2.png
[format_png 82]: /images/20210827/caf49c1ab7fe4c3b93c2a992b50fc51c.png
[format_png 83]: /images/20210827/492d91f0cb1745b78449cefc0974e595.png
[Link 5]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484222&idx=1&sn=5191aca33f7b331adaef11c5e07df468&chksm=ebd7423fdca0cb29cdc59b4c79afcda9a44b9206806d2212a1b807c9f5879674934c37c250a1#rd
[format_png 84]: /images/20210827/239260984e47455eada36e0317def601.png
[format_png 85]: /images/20210827/9512f96a7f4e499abdd1054f047f7992.png
[format_png 86]: /images/20210827/5b7e6481da174f87b35e36ee49e6f922.png
[format_png 87]: /images/20210827/41f312619925499991b3147866ccb3dc.png
[format_png 88]: /images/20210827/bbf7174774314590b768617470c65cef.png
[format_png 89]: /images/20210827/657d1e346eff4e309f122feffe4840a3.png
[format_png 90]: /images/20210827/36c7e872cf1a4ff987c843c9acc1a2ed.png
[format_png 91]: /images/20210827/4821ea5179454d5d8d5f6f773f6a4bfc.png
[format_png 92]: /images/20210827/f2720de20d0d4442bed4021fb6517c85.png
[format_png 93]: /images/20210827/e28c3aebfc764e07b0d17f7f6eaa1a74.png
[Spring_AOP]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247483954&idx=1&sn=b34e385ed716edf6f58998ec329f9867&chksm=ebd74333dca0ca257a77c02ab458300ef982adff3cf37eb6d8d2f985f11df5cc07ef17f659d4#rd
[format_png 94]: /images/20210827/3bb3490c0214470998687dca90fdccef.png
[format_png 95]: /images/20210827/15f1ec86376446dab251963fb31db759.png
[format_png 96]: /images/20210827/1f3dd1dc93aa4258ac50e3cb73d51ca7.png
[format_png 97]: /images/20210827/70b0ccc79c964c37899bc2828dfb9b7c.png
[format_png 98]: /images/20210827/822a7d91f57e49ae9fc09a2da67f94fb.png
[format_png 99]: /images/20210827/dfb55813376e4385b4923745bdf4966c.png
[format_png 100]: /images/20210827/8fa1f8b312bc473eb362d1e65f8ff496.png
[format_png 101]: /images/20210827/c038ca32d5a442beb9f22886e11305fb.png
[format_png 102]: /images/20210827/335c443076494422b47b9f4ae96cca46.png
[format_png 103]: /images/20210827/3189bfbb7c214949a84dceee61969162.png
[92_Mybatis]: https://mp.weixin.qq.com/s/0_zTBooRV4RTWQa8VOwiWg
[129]: https://mp.weixin.qq.com/s/r7IrmvBxG5W0hswfcgFjcQ
[141_Servlet]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247486798&idx=1&sn=ce900e97a495ffd681cd0ad9b78aa5ca&chksm=ebd74c4fdca0c559d0a32a3f3ddb3f579d3a16b47f70234c46ac2e5df315e7df90f93d1715b9&token=1109491988&lang=zh_CN#rd
[158_JSP]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247486854&idx=1&sn=fd77a6225b898b69c4f0e1a7e66cf105&chksm=ebd74c87dca0c5910a923a443ea6f694dd554b68df8cc00506570555b9cf7718a2ef2a058754&token=1109491988&lang=zh_CN#rd
[76]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247486873&idx=1&sn=ce0752f481336ffba9b8f44265b2550e&chksm=ebd74c98dca0c58ee04162d7e5d07fd36c8ec1b32460a8a2396168a9fc5885a208810f0916f2&token=1109491988&lang=zh_CN#rd
[64_JDBC]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247486905&idx=1&sn=67fcd0558cfbdf6cd36de98cbd93afaf&chksm=ebd74cb8dca0c5ae052e6d216ed13458a9a17fa1b0f245bf740379b1d4b04b4e55fcbfb5adb4&token=1109491988&lang=zh_CN#rd
[105]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247486831&idx=1&sn=0d4b05e10d66eda1129f43348a8e3952&chksm=ebd74c6edca0c5786a5109a131d0501ef6bd02077e5ce1ad75d906cf3612a320d1098163e2d0&token=1109491988&lang=zh_CN#rd
[142_Spring]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247487013&idx=1&sn=f0d8c292738eb49bcd09cb2f6458dc69&chksm=ebd74f24dca0c632fa3ef8f205a2dd5c96531f78a68eae805e15b84de0b59774196a188aed14&token=306734573&lang=zh_CN#rd
[58]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247487054&idx=1&sn=25f92798050d092027931e2ae0379e90&chksm=ebd74f4fdca0c6595bc795fd00354cf683d4593550cdd38ba7103893dd622606fc8f55fe6631&token=306734573&lang=zh_CN#rd
[30_HTTP]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247487071&idx=1&sn=511459730b3114fc77c60b82b54159b8&chksm=ebd74f5edca0c648c9b0c572fbc7fdbc26179ddcd7c45de37c06b6a2906a8ffc207f145b66f2&token=480724592&lang=zh_CN#rd
[42_SpringMVC]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247487665&idx=1&sn=cffb9d634a8b770562557b72a833e591&chksm=ebd751b0dca0d8a604d89b1e3c5d1728f35b752368f5a878311066cbc09ff8a5905ad05690c7&token=634601022&lang=zh_CN#rd
[Gitee]: https://gitee.com/zhongfucheng/Java3y
[format_png 104]: /images/20210827/7c8b22d3dabb4d0a8b06bf208733c497.png
[format_png 105]: /images/20210827/de8e35192d8d4b5f9a689164a573fd98.png
[aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA2dE5iUndseTFnYjBuenBuOHo3ZzMwZ28wZ29rYnAuZ2lm]: /images/20210827/c8f4f3d035de41d7adf71c9bab2d8324.png