spring太强了！两万多字干货超详细讲解

太过爱你忘了你带给我的痛 2023-10-05 08:49 60阅读 0赞

**本文原创首发CSDN，本文链接[https://blog.csdn.net/qq\_41464123/article/details/108118680][https_blog.csdn.net_qq_41464123_article_details_108118680] ，作者博客[https://blog.csdn.net/qq\_41464123][https_blog.csdn.net_qq_41464123] ，转载请带上本链接，谢谢配合。**

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

#### 文章目录 ####

*  一、第一个Spring程序
 *   *  1.1 spring简介
     *  1.2 环境配置
     *   *  软件版本
         *  idea新建项目配置
         *  所需依赖
         *  jdk发型版本配置
         *  所需过滤器
     *  1.3 编写实体类
     *  1.4 编写配置文件
     *  1.5 测试
 *  二、IOC 控制反转
 *   *  2.1传统开发
     *   *  谈恋爱接口(Dao层)
         *  女朋友一号(Dao层实现1)
         *  女朋友二号(Dao层实现2)
         *  女朋友三号(Dao层实现3)
         *  谈恋爱接口(Service层)
         *  谈恋爱实现(Service层)
     *  2.2 IOC控制反转实现
     *   *  谈恋爱实现(Service层)
         *  测试
 *  三、DI 依赖注入
 *   *  3.1 概念
     *  3.2 根据属性名注入（推荐）
     *   *  实体类User
         *  XML注入
         *  测试
     *  3.3 根据构造器下标注入
     *   *  实体类Book
         *  XML注入
         *  测试
     *  3.4 根据构造器数据类型注入
     *   *  XML注入
         *  测试
     *  3.5 C / P 命名空间注入
     *   *  实体类Book
         *  XML注入
         *  测试
     *  3.6 单例/原型模式
     *   *  XML配置
         *  测试
     *  3.7 自动装配
     *   *  实体类BookUser
         *  测试
     *  3.8 Java注解开发（推荐）
     *   *  实体类House
         *  XML配置
         *  测试
     *  3.9 spring常用注解
 *  四、 AOP 面向切面编程
 *   *  4.1 静态代理
     *  4.2 动态代理
     *  4.3 Spring API接口实现
     *  4.4 自定义类实现
     *  4.5 Java注解实现
 *  五、总结
 *   *  5.1 总结&附录
     *  5.2 模板文件
     *   *  applicationContext.xml
         *  mybatis-config.xml
     *  5.3 spring配置标签
     *   *   *  bean
             *  alias
             *  import
             *  context

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

## 一、第一个Spring程序 ##

### 1.1 spring简介 ###

*  spring：春天，给软件行业带来春天！
 *  spring理念：使现有的技术更加易用，是一个粘合剂，整合了现有的技术框架
 *  spring是一个轻量级的开源免费框架
 *  核心：**控制反转（IOC），面向切面编程（AOP）**
 *  支持对事务的支持，支持整合其他框架  
      
      
    **Spring是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架。**

**spring官方文档： https://spring.io/projects/spring-framework\#learn**

**maven官网：https://mvnrepository.com/**

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

### 1.2 环境配置 ###

#### 软件版本 ####

*  jdk 11.0.6
 *  maven 3.6.2 阿里云
 *  idea 2019.3

#### idea新建项目配置 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDY0MTIz_size_16_color_FFFFFF_t_70_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDY0MTIz_size_16_color_FFFFFF_t_70_pic_center 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDY0MTIz_size_16_color_FFFFFF_t_70_pic_center 2]

**需要注意以下几点：**

#### 所需依赖 ####

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.2</version>
        </dependency>
    </dependencies>

#### jdk发型版本配置 ####

如果不配置，运行测试方法时，可能会报“不支持发行版本5”错误

#### 所需过滤器 ####

过滤器的作用，是在程序编译时，将xml、properties等静态配置文件也加入 target 包中，否则程序无法读取到xml文件

<build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

### 1.3 编写实体类 ###

User类有两个变量，分别是姓名name和年龄age

类上方的三个注解均在lombok包中

**@Data** 是用来自动生成set和get方法

**@AllArgsConstructor**是用来自动生成全部参数的构造方法

**@NoArgsConstructor**是用来自动生成无参构造方法

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
        
        private String name;
        private int age;
    }

### 1.4 编写配置文件 ###

<?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"
           xmlns:p="http://www.springframework.org/schema/p"
           xmlns:tx="http://www.springframework.org/schema/tx"
           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/tx
           http://www.springframework.org/schema/tx/spring-tx.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">
    
        <bean id="user" class="zwz.pojo.User">
            
            <property name="name" value="ZWZ"/>
            <property name="age" value="18"/>
        </bean>
    </beans>

### 1.5 测试 ###

先是用传统的方法new一个对象

@Test
    public void testtTradition(){
        
        User user = new User("ZWZ",18);
        System.out.println(user);
    }

接着用spring的方式从容器获取一个对象

@Test
    public void testSpring(){
        
        // ApplicationContext Spring上下文对象 | ClassPathXmlApplicationContext 从配置文件中去取
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 从容器中取出user对象
        User user = (User) context.getBean("user");
        System.out.println(user);
    }

都可以得到相同的运行结果

User(name=ZWZ, age=18)
    
    Process finished with exit code 0

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

## 二、IOC 控制反转 ##

### 2.1传统开发 ###

我们就以\*\*张三想找一个女朋友谈恋爱\*\*为例，结合Java代码，说明spring控制反转和传统开发的区别

web开发后端的层次，**从上到下可以分为：Controller（控制器层）、Service（业务逻辑层）、Dao（数据持久层）**

#### 谈恋爱接口(Dao层) ####

这是一个Dao层的接口，**描述谈恋爱这一个抽象性行为**

public interface LoveDao {
        
        // 谈恋爱的mapper层接口
        void talkLove();
    }

#### 女朋友一号(Dao层实现1) ####

这是接口的第一个实现，是活灵活现的女朋友

public class LoveDaoImpl1 implements LoveDao {
        
        @Override
        public void talkLove() {
        
            System.out.println("女朋友1号和你谈恋爱了!");
        }
    }

#### 女朋友二号(Dao层实现2) ####

这是接口的第二个实现，是活灵活现的女朋友

public class LoveDaoImpl2 implements LoveDao{
        
        @Override
        public void talkLove() {
        
            System.out.println("女朋友2号和你谈恋爱了!");
        }
    }

#### 女朋友三号(Dao层实现3) ####

这是接口的第三个实现，是活灵活现的女朋友

public class LoveDaoImpl3 implements LoveDao{
        
        @Override
        public void talkLove() {
        
            System.out.println("女朋友3号和你谈恋爱了!");
        }
    }

#### 谈恋爱接口(Service层) ####

这是业务逻辑层的接口，和Dao层一样，是一个**抽象性接口**

public interface LoveService {
        
        // 谈恋爱的Service层接口
        void talkLove();
    }

#### 谈恋爱实现(Service层) ####

业务逻辑层调用Dao层的方法，完善业务逻辑层接口的具体实现

如果你选择和女朋友一号谈恋爱，那么…

public class LoveServiceImpl implements LoveService {
        
    
        private LoveDao loveDao = new LoveDaoImpl1();
        @Override
        public void talkLove() {
        
            loveDao.talkLove();
        }
    }

测试

@Test
    public void testTradition(){
        
        LoveService loveService = new LoveServiceImpl();
        loveService.talkLove();
    }

女朋友1号和你谈恋爱了!
    
    Process finished with exit code 0

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

如果张三的\*\*需求改变了\*\*，他只想和女朋友二号谈恋爱

那么，我们就\*\*必须修改service层的实现类\*\*

private LoveDao loveDao = new LoveDaoImpl2();

女朋友2号和你谈恋爱了!
    
    Process finished with exit code 0

*  该程序适应不了需求的变更，需求变了要更改源代码，这是万万不行的！
 *  如何解决？如何让程序不动，让客户端去改变？这就需要控制反转

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

### 2.2 IOC控制反转实现 ###

首先，Dao层的接口、Dao层的实现类、Service层的接口不改动，我们只改service实现类和测试方法

#### 谈恋爱实现(Service层) ####

原有代码直接new出一个Dao层实现，**现在我们使用构造器，将Dao层实现类的选择权交给用户，从而实现了控制反转**

public class LoveServiceImpl implements LoveService {
        
    
        // 传统开发代码
        // private LoveDao loveDao = new LoveDaoImpl1();
        
        // IOC控制反转    LoveDao的选择,放权给用户
        private LoveDao loveDao;
    
        public LoveServiceImpl(LoveDao loveDao) {
        
            this.loveDao = loveDao;
        }
    
        @Override
        public void talkLove() {
        
            loveDao.talkLove();
        }
    }

#### 测试 ####

1.  张三如果想和一号女朋友谈恋爱

@Test
    public void testIoc(){
        
        // 用户需求发生改变，没有改动内部代码
        LoveServiceImpl loveService = new LoveServiceImpl(new LoveDaoImpl1());
        loveService.talkLove();
    }

输出

女朋友1号和你谈恋爱了!
    
    Process finished with exit code 0

1.  如果他跟女朋友二号谈恋爱，只需要更改测试方法

@Test
    public void testIoc(){
        
        // 用户需求发生改变，没有改动内部代码
        LoveServiceImpl loveService = new LoveServiceImpl(new LoveDaoImpl2());
        loveService.talkLove();
    }

输出

女朋友2号和你谈恋爱了!
    
    Process finished with exit code 0

**通过 UserServiceImpl 的构造器，对UserDao进行动态注入，用户可以自己选择需要使用的UserDao的实现类，从而灵活变动**

*  在传统开发中，需求变更需要修改源代码，如果系统代码量大，修改会非常麻烦，牵一发而动全身！
 *  在传统开发中，对象创建在程序中实现；控制反转之后，程序变成了被动接受对象！
 *  控制反转是一种设计思想，让第三方去管理对象的创建和获取。在spring中实现控制反转是IOC容器，实现方法是依赖注入DI

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

**本文原创首发CSDN，本文链接[https://blog.csdn.net/qq\_41464123/article/details/108118680][https_blog.csdn.net_qq_41464123_article_details_108118680]，作者博客[https://blog.csdn.net/qq\_41464123][https_blog.csdn.net_qq_41464123]，转载请带上本链接，谢谢配合。**

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

## 三、DI 依赖注入 ##

### 3.1 概念 ###

在第一个Spring程序中已经体验了，传统赋值和依赖注入的区别

**传统赋值**

User user = new User("ZWZ",18);

**依赖注入**

在容器中配置bean,并注入值

在容器中取出对象

// ApplicationContext Spring上下文对象 | ClassPathXmlApplicationContext 从配置文件中去取
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 从容器中取出user对象
    User user = (User) context.getBean("user");

两种方式,都可以得到相同的运行结果

User(name=ZWZ, age=18)
    
    Process finished with exit code 0

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

### 3.2 根据属性名注入（推荐） ###

#### 实体类User ####

该实体类有各种各样的类型，我们尝试对这些复杂数据类型进行注入

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User {
        
    
        private String name;
        private Address address;
        private String[] books;
        private List<String> hobbys;
        private Map<String,String> card;
        private Set<String> games;
        private Properties info;
        private String girlFriend;
    }

#### XML注入 ####

一共八种数据类型，分别加以注入

<bean id="address" class="zwz.pojo.Address" scope="singleton">
        <property name="address" value="浙江宁波"/>
    </bean>
    <bean id="user" class="zwz.pojo.User">
        
        <property name="name" value="ZWZ"></property>
    
        
        <property name="address" ref="address"></property>
    
        
        <property name="books">
            <array>
                <value>Java程序设计</value>
                <value>JavaScript程序设计</value>
                <value>Python程序设计</value>
            </array>
        </property>
    
        
        <property name="hobbys">
            <list>
                <value>敲代码</value>
                <value>听歌</value>
                <value>看小说</value>
            </list>
        </property>
    
        
        <property name="card">
            <map>
                <entry key="card01" value="卡片1"></entry>
                <entry key="card02" value="卡片2"></entry>
                <entry key="card03" value="卡片3"></entry>
            </map>
        </property>
    
        
        <property name="games">
            <set>
                <value>QQ飞车手游</value>
                <value>DNF</value>
                <value>敲代码</value>
            </set>
        </property>
    
        
        <property name="girlFriend">
            <null></null>
        </property>
    
        
        <property name="info">
            <props>
                <prop key="id">0413170337</prop>
                <prop key="tel">17857054388</prop>
            </props>
        </property>
    </bean>

#### 测试 ####

@Test
    public void testPropertyName() {
        
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = (User) context.getBean("user");
        System.out.println(user);
    }

可以看出，八种数据类型，都已经成功注入到对象中

Student{
    name='ZWZ'
    , address=Address(address=浙江宁波)
    , books=[Java程序设计, JavaScript程序设计, Python程序设计]
    , hobbys=[敲代码, 听歌, 看小说]
    , card={card01=卡片1, card02=卡片2, card03=卡片3}
    , games=[QQ飞车手游, DNF, 敲代码]
    , info={tel=17857054388, id=0413170337}
    , girlFriend='null'}
    
    Process finished with exit code 0

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

### 3.3 根据构造器下标注入 ###

**@AllArgsConstructor** 注解在之间提到过，是生成全部参数的构造方法

我们可以**通过构造器的参数，实现值注入**

比如对于构造器0号下标的bookName，注入Java程序设计…

#### 实体类Book ####

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Book {
        
        private String bookName;
        private int pageNum;
    }

#### XML注入 ####

#### 测试 ####

@Test
        public void testConstructorIndex() {
        
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            Book book = (Book) context.getBean("bookIndex");
            System.out.println(book);
        }

Book(bookName=Java程序设计, pageNum=66)
    
    Process finished with exit code 0

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

### 3.4 根据构造器数据类型注入 ###

**@AllArgsConstructor** 注解在之间提到过，是生成全部参数的构造方法

我们可以**通过构造器的参数类型，实现值注入**

比如对于构造器的String类型变量bookName，注入Java程序设计…

当然构造器\*\*不同参数的数据类型必须不一致，否则会出错\*\*，所以这个注入方式说实话没什么用…

\#\#\# 实体类Book

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Book {
        
        private String bookName;
        private int pageNum;
    }

#### XML注入 ####

#### 测试 ####

@Test
    public void testConstructorType() {
        
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Book book = (Book) context.getBean("bookType");
        System.out.println(book);
    }

Book(bookName=Java程序设计, pageNum=66)
    
    Process finished with exit code 0

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

### 3.5 C / P 命名空间注入 ###

c命名空间注入或者p命名空间注入，分别利用变量名称和构造器下标进行值注入，和之前的没有本质性的区别

XML属性名注入、Java注解最为常用，而C/P命名空间注入一般不会去使用…

#### 实体类Book ####

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Book {
        
        private String bookName;
        private int pageNum;
    }

#### XML注入 ####

#### 测试 ####

@Test
    public void testC() {
        
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Book book = (Book) context.getBean("cBook");
        System.out.println(book);
    }
    
    @Test
    public void testP() {
        
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Book book = (Book) context.getBean("pBook");
        System.out.println(book);
    }

输出相同

Book(bookName=Java程序设计, pageNum=66)
    
    Process finished with exit code 0

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

### 3.6 单例/原型模式 ###

#### XML配置 ####

**singleton 为单例模式，从容器中多次获取bean，bean相同**

**prototype为原型模式，从容器中多次获取bean，bean不同**

#### 测试 ####

@Test
    public void testScope(){
        
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Book book1 = (Book) context.getBean("singletonBook");
        Book book2 = (Book) context.getBean("singletonBook");
        System.out.println("singletonBook: " + (book1 == book2));
    
        Book book3 = (Book) context.getBean("prototypeBook");
        Book book4 = (Book) context.getBean("prototypeBook");
        System.out.println("prototypeBook: " + (book3 == book4));
    }

\`\`\` singletonBook: true prototypeBook: false \`\`\`

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

### 3.7 自动装配 ###

自动装配的意思是，假设有两个实体Bean A、B

**如果A中包含B，且B已经配置在容器中，那么A可以通过自动装配，将B自动装配注入**

当然自动装配只对引用变量生效，对于int、String不支持

#### 实体类BookUser ####

定义一个包含Book的实体类BookUser

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class BookUser {
        
        Book book;
    }

\#\#\# XML配置

#### 测试 ####

@Test
    public void testAutowire(){
        
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookUser bookUser = (BookUser) context.getBean("bookUser");
        System.out.println(bookUser);
    }

BookUser(book=Book(bookName=自动装配的BookName, pageNum=66))
    
    Process finished with exit code 0

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

### 3.8 Java注解开发（推荐） ###

#### 实体类House ####

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class House {
        
    
        @Value("幸福之家")
        private String houseName;
    
        @Value("99")
        private String houseSize;
    }

#### XML配置 ####

<context:annotation-config/>
    
    <bean id="house" class="zwz.pojo.House"/>

#### 测试 ####

@Test
    public void testJava(){
        
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        House house= (House) context.getBean("house");
        System.out.println(house);
    }

House(houseName=幸福之家, houseSize=99)
    
    Process finished with exit code 0

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

### 3.9 spring常用注解 ###

*  **@Autowired** 直接在变量上使用，也可以在set方法上使用，需要符合名字byName原则 **【 最常用！！！】**
 *  **@Nullable** 直接在变量上使用，表示这个变量允许为空
 *  **@Qualifier(value=“xxx”)** 直接在变量上使用，指定bean的id
 *  **@Resource** 或者 **@Resource(value=“xxx”)** ，同 @Autowired 和 @Qualifier(value=“xxx”)
 *  **@Value(“xxx”)**，在实体类的某个变量注入值，也可放在set方法上
 *  **@Component**，在spring中注册装配bean，通用
 *  **@Repository**，在spring中注册装配bean，一般放在Dao层上
 *  **@Service**，在spring中注册装配bean，一般放在Service层上
 *  **@Controller**，在spring中注册装配bean，一般放在Controller层上
 *  **@Scope(“prototype/singleton”)**，配置实体类的单例/原型模式
 *  **@Configuration**，Java配置类的注解

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

## 四、 AOP 面向切面编程 ##

### 4.1 静态代理 ###

*  抽象角色：接口/抽象类，代表某种需求【租房】
 *  真实角色：被代理的角色【房东】
 *  代理角色：代理真实角色【租房中介】
 *  客户：访问代理对象【租房的人】

**假设场景：XX通信公司在高校内售卖校园卡**

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

**【抽象角色】就是卖卡这个需求**

// 卖校园卡
    public interface SellingCard {
        
        void sellingCard();
    }

**【真实角色】要卖卡的公司**

public class Company implements SellingCard{
        
        @Override
        public void sellingCard() {
        
            System.out.println("XX公司要卖校园卡!");
        }
    }

**【代理角色】高校内的各级代理，卖卡之余，还提供各种服务**

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Proxy implements SellingCard{
        
        private Company company;
    
        @Override
        public void sellingCard() {
        
            learnCard();
            company.sellingCard();
            contract();
            collectMoney();
        }
    
        // 了解校园卡功能
        public void learnCard(){
        
            System.out.println("校园卡代理带你了解校园卡费用");
        }
    
        // 收取卖卡推销费用
        public void collectMoney(){
        
            System.out.println("收取卖卡推销费用");
        }
    
        // 代理指导你签电子合同
        public void contract(){
        
            System.out.println("代理指导你签电子合同");
        }
    }

**【客户】买卡的学生，访问代理角色，buyCard()为直接找公司购卡，buyCardProxy()为找代理购卡**

public class Student {
        
    
        @Test
        public void buyCardProxy(){
        
            // XX校园卡公司,要卖校园卡
            Company company = new Company();
            //代理中介,帮公司卖卡，收取一定费用
            Proxy proxy = new Proxy(company);
            // 客户不用面对公司，直接找代理买卡即可
            proxy.sellingCard();
        }
        
        @Test
        public void buyCard(){
        
            Company company = new Company();
            company.sellingCard();
        }
    }

校园卡代理带你了解校园卡费用
    XX公司要卖校园卡!
    代理指导你签电子合同
    收取卖卡推销费用
    
    Process finished with exit code 0

**代理模式的优点：**

*  让真实角色的需求【房东卖房】更加简单，不用去关注一些其他手续【客户看房，签合同等】
 *  其他手续交给了代理，实现业务分工
 *  其他手续需求扩展时，方便集中管理

**代理模式的缺点：**

*  一个真实角色【房东】，就会产生一个代理角色【租房中介】，使得代码量会翻倍

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

### 4.2 动态代理 ###

和静态代理一样，也是卖卡这个场景

**【需求】卖卡（同静态代理一致）**

// 卖校园卡
    public interface SellingCard {
        
        void sellingCard();
    }

**【真实角色】要卖卡的公司（同静态代理一致）**

public class Company implements SellingCard {
        
        @Override
        public void sellingCard() {
        
            System.out.println("XX公司要卖校园卡!");
        }
    }

**【代理角色】动态代理**

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class ProxyAction implements InvocationHandler {
        
    
        // 被代理的接口
        private SellingCard sellingCard;
    
        public Object getProxy(){
        
            return  Proxy.newProxyInstance(this.getClass().getClassLoader(),
                    sellingCard.getClass().getInterfaces(),this);
        }
    
        // 处理代理实例，并返回结果
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
            learnCard();
            // 动态代理  反射机制实现
            Object result = method.invoke(sellingCard, args);
            collectMoney();
            contract();
            return result;
        }
    
        // 了解校园卡功能
        public void learnCard(){
        
            System.out.println("校园卡代理带你了解校园卡费用");
        }
    
        // 收取卖卡推销费用
        public void collectMoney(){
        
            System.out.println("收取卖卡推销费用");
        }
    
        // 代理指导你签电子合同
        public void contract(){
        
            System.out.println("代理指导你签电子合同");
        }
    }

**【客户】买卡的学生**

public class Student {
        
        @Test
        public void testProxyAction(){
        
            // 真实角色
            Company company = new Company();
    
            // 代理角色
            ProxyAction pa = new ProxyAction();
            // 通过调用程序处理调用的接口对象 | 就是让代理实现 SellingCard 卖卡的接口
            pa.setSellingCard(company);
            // 获得代理类 | proxy 就是动态生成的
            SellingCard proxy = (SellingCard) pa.getProxy();
            proxy.sellingCard();
        }
    }

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

### 4.3 Spring API接口实现 ###

*  Aop是什么？一般情况下，在程序执行时，是从上到下执行的
 *  如果要在执行的某个点，插入一个功能，如何实现？
 *  比如一个系统，我需要加入逻辑删除，我需要增加日志功能，难道我去修改原有代码？
 *  这就需要我们使用Aop来实现横向切入，增加功能！

**我们以增加日志功能为例，介绍Aop的实现流程之一 —— 基于Spring API接口实现**

**编写一个Service**

public interface BookService {
        
        void add();
        void delete();
        void update();
        void select();
    }

**编写Service的实现类**

public class BookServiceImpl implements BookService {
        
        public void add() {
        
            System.out.println("增加了一本书");
        }
    
        public void delete() {
        
            System.out.println("删除了一本书");
        }
    
        public void update() {
        
            System.out.println("修改了一本书");
        }
    
        public void select() {
        
            System.out.println("查询了一本书");
        }
    }

**编写方法前日志**

public class BeforeLog implements MethodBeforeAdvice {
        
        /**
         * method要执行的目标对象的方法
         * args 参数
         * target 目标对象
         */
        public void before(Method method, Object[] args, Object target) throws Throwable {
        
            System.out.println(target.getClass().getName() + " 的 "+method.getName() + " 被执行了!");
        }
    }

**编写方法后日志**

public class AfterLog implements AfterReturningAdvice {
        
        /**
         * returnValue  返回对象
         * method要执行的目标对象的方法
         * args 参数
         * target 目标对象
         */
        public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        
            System.out.println("执行了 " +method.getName() + " 方法, 返回结果为" + returnValue);
        }
    }

**配置文件配置切面、切入点**

<?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"
           xmlns:p="http://www.springframework.org/schema/p"
           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="bookService" class="zwz.demo1.service.BookServiceImpl"/>
        <bean id="beforeLog" class="zwz.demo1.log.BeforeLog"/>
        <bean id="afterLog" class="zwz.demo1.log.AfterLog"/>
    
        
        <aop:config>
            
            <aop:pointcut id="pointcut" expression="execution(* zwz.demo1.service.BookServiceImpl.*(..))"/>
            
            <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
            <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
        </aop:config>
    </beans>

**测试**

@Test
    public void testAop1(){
        
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookService bookService = (BookService) context.getBean("bookService");
        bookService.add();
    }

这样，我们就实现了在执行某个方法的时候，输出日志的功能了

**输出结果**

zwz.demo1.service.BookServiceImpl 的 add 被执行了!
    增加了一本书
    执行了 add 方法, 返回结果为null
    
    Process finished with exit code 0

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

### 4.4 自定义类实现 ###

**接下来是基于自定义类接口实现，和spring的API实现一样，先写业务的实现接口和实现类**

public interface BookService2 {
        
        void add();
        void delete();
        void update();
        void select();
    }

public class BookServiceImpl2 implements BookService2 {
        
        public void add() {
        
            System.out.println("增加了一本书");
        }
    
        public void delete() {
        
            System.out.println("删除了一本书");
        }
    
        public void update() {
        
            System.out.println("修改了一本书");
        }
    
        public void select() {
        
            System.out.println("查询了一本书");
        }
    }

**和spring API方法一致，编写两个切入日志类**

**编写自定义切入类**

public class DiyPointCut {
        
        public void before(){
        
            System.out.println("==============方法执行前==============");
        }
        public void after(){
        
            System.out.println("==============方法执行后==============");
        }
    }

**配置文件**

**测试**

@Test
        public void testAop2(){
        
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            BookService2 bookService2 = (BookService2) context.getBean("bookService2");
            bookService2.add();
        }

==============方法执行前==============
    增加了一本书
    ==============方法执行后==============

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

### 4.5 Java注解实现 ###

**和之前两个方法一样，先写Service服务层的接口和实现类**

public interface BookService3 {
        
        void add();
        void delete();
        void update();
        void select();
    }

public class BookServiceImpl3 implements BookService3 {
        
        public void add() {
        
            System.out.println("增加了一本书");
        }
        public void delete() {
        
            System.out.println("删除了一本书");
        }
        public void update() {
        
            System.out.println("修改了一本书");
        }
        public void select() {
        
            System.out.println("查询了一本书");
        }
    }

**切面类**

@Aspect  //标注这个类是一个切面
    public class PointCut {
        
        @Before("execution(* zwz.demo3.service.BookServiceImpl3.*(..))")
        public void before(){
        
            System.out.println("==============方法执行前==============");
        }
        @After("execution(* zwz.demo3.service.BookServiceImpl3.*(..))")
        public void after(){
        
            System.out.println("==============方法执行后==============");
        }
    }

**配置文件**

<bean id="bookService3" class="zwz.demo3.service.BookServiceImpl3"/>
    <bean id="pointCut" class="zwz.demo3.cut.PointCut"/>
    
    <aop:aspectj-autoproxy/>

**测试类**

@Test
    public void testAop3(){
        
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookService3 bookService3 = (BookService3) context.getBean("bookService3");
        bookService3.add();
    }

**输出结果**

==============方法执行前==============
    增加了一本书
    ==============方法执行后==============

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

## 五、总结 ##

### 5.1 总结&附录 ###

**spring是一个粘合剂，可以整合其他优秀的框架，大大简化了软件开发的复杂度**

我认为spring的核心内容：

*  IOC控制反转
 *  AOP面向切面编程

其他内容比如整合mybatis、声明式事务，在后续再写。

### 5.2 模板文件 ###

#### applicationContext.xml ####

#### mybatis-config.xml ####

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <typeAliases>
            <package name="zwz.pojo"/>
        </typeAliases>
        <environments default="zwz">
            <environment id="zwz">
                <transactionManager type="JDBC"></transactionManager>
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false"/>
                    <property name="username" value="root"/>
                    <property name="password" value="123456"/>
                </dataSource>
            </environment>
        </environments>
        <mappers>
            <mapper class="zwz.mapper.UserMybatisMapper"></mapper>
        </mappers>
    </configuration>

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

### 5.3 spring配置标签 ###

##### bean #####

bean用来注册实体类，可以注入相应的变量值

##### alias #####

设置别名，设置后原名和别名都可以使用

**bean 中的 name 属性也可以做别名，而且功能更加强大**

可以在测试类中这样调用别名bean

##### import #####

在团队开发中，每个人都需要拥有自己的配置文件，可以通过import标签将多个配置文件整合成一个

如张三的配置文件 —— bean1.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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="user" class="zwz.pojo.User">
            
            <property name="name" value="ZWZ"/>
            <property name="age" value="18"/>
        </bean>
        <alias name="user" alias="userZwz"/>
    </beans>

团队整体的配置文件 —— applicationContext.xml，可以将所有人的配置文件合并成一个总的

##### context #####

自动装配bean

<context:annotation-config/>

扫描指定包的组件

<context:component-scan base-package="zwz"/>

[https_blog.csdn.net_qq_41464123_article_details_108118680]: https://blog.csdn.net/qq_41464123/article/details/108118680
[https_blog.csdn.net_qq_41464123]: https://blog.csdn.net/qq_41464123
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDY0MTIz_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/2020082011031329.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDY0MTIz,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDY0MTIz_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200820110419890.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDY0MTIz,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDY0MTIz_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200820110508283.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDY0MTIz,size_16,color_FFFFFF,t_70#pic_center