# spring-study

**Repository Path**: mnmnwq/spring-study

## Basic Information

- **Project Name**: spring-study
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-07-23
- **Last Updated**: 2021-07-26

## Categories & Tags

**Categories**: Uncategorized

**Tags**: spring学习, java学习

## README

## 目录结构

#### spring-01-ioc   传统开发目录结构

#### spring-02-hellospring    第一个spring程序

#### spring-03-di  DI依赖注入几种方式

#### spring-04-autowired 自动装配

#### spring-05-anno  注解开发

#### spring-07-appconfig     java配置spring

#### spring-08-proxy  代理模式

- demo01 静态代理
- demo02 动态代理

#### spring-09-aop 切面

#### spring-10-mybatis  整合mybatis

#### spring-12-transaction 声明式事务

## Spring

#### 简介

- Spring：春天->给软件行业的带来了春天

- 2002，首次推出了 Spring框架的雏形：interface21框架！

- Spring框架即以interface21框架为基础，经过重新设计 ，并不断丰富其内涵，于2004年 3月24日发布了1.0正式版

- Rod Johnson 创始人，著名作者。

- Srring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！

- SSH：Struts2+Spring+Hibernate

- SSM：SpringMVC+Spring+Mybatis

- maven

  ```xml
  <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.9</version>
  </dependency>
  <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.3.9</version>
  </dependency>
  
  ```
  
  

####  优点

- Spring是一个开源免费的框架（容器）！
- Spring是一个轻量级的，非入侵式的框架！
- 控制反转（IOC），面向前面编程（AOP）！ 
- 支持事务的处理，对框架整合的支持！

**总结一句话：Spring就是一个轻量级的控制反转（IOC）和面向切面（AOP）编程的框架！**

#### 组成

- Spring的7大模块

![spring七大模块](./readme-img/spring七大模块.PNG)

#### 拓展

- 现代化的java开发，就是基于Spring的开发

  ![现代java开发](./readme-img/现代java开发.PNG)

- Srpring Boot

  - 一个快速开发的脚手架
  - 基于SpringBoot可以快速的开发单个微服务
  - 约定大于配置！

- Spring Cloud

  - SpringCloud是基于SpringBoot实现的

**弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称：“配置地狱”**

## IOC理论推导

 这种思想，从本质上解决了一个问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低~，可以更加专注在业务上。这是IOC的原型。 

## 第一个spring程序，hellospring

1. 创建com.test.pojo.Hello.java

```java
package com.test.pojo;

public class Hello {
    //
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }

}
```



2. 在resources里面创建beans.xml[官方名称ApplicationContext.xml]

```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">
    <!--使用spring来创建我们的对象，在spring这些被称为Bean-->
    <bean id="hello" class="com.test.pojo.Hello">
        <!-- value基本类型；ref可以引用其他的bean标签的类 -->
        <property name="str" value="Spring"/>
    </bean>
</beans>
```

3. 调用

```java
import com.test.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        // 获取spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        // 我们的对象现在都在spring中管理了，我们要使用直接去里面取出来就可以了
        Hello hello = (Hello)context.getBean("hello");
        System.out.println(hello.toString());
    }
}
```

## IOC创建对象的方式

#### 使用无参构造创建对象[默认]

#### 使用有参构造创建对象 

```xml	
<!--第一种 下标赋值-->
<bean id="user" class="com.test.pojo.User">
	<constructor-arg index="0" value="JAVA"/>
</bean>
<!--第二种 通过类型赋值 不建议使用-->
<bean id="user" class="com.test.pojo.User">
    <constructor-arg type="java.lang.String" value="java"/>
</bean>
<!--第三种 直接通过参数名赋值 -->
<bean id="user" class="com.test.pojo.User">
    <constructor-arg name="name" value="java"/>
</bean>
```

#### 总结

在配置文件加载的时候，容器中管理的对象就已经初始化了！

## Spring配置

#### 别名

```xml
<!--添加了别名，原来的名字和别名都可以使用-->
<bean id="user" class="com.test.pojo.User">
	<property name="str" value="Spring"/>
</bean>
<alias name="user" alias="userAlias">
```

#### bean的配置

```xml	
<!--
id : bean的唯一标识符，也就是相当于我们学的对象名
class: bean所对应的全限定名： 包名 + 类型
name：也是别名，而且name可以同时取多个别名
-->
<bean id="user" class="com.test.pojo.User" name="user2,u2,u3">
	<property name="str" value="Spring"/>
</bean>
```

#### import

```xml
<!-- 一般用户团队开发，它可以将多个配置文件导入为一个[相当于include] -->
<import resource="beans-02.xml">
```

## 依赖注入

#### 构造器方式注入

上面说的就是这个

#### set方式注入[重点]

- 依赖注入：set注入！

  - 依赖：bean对象的创建，依赖于容器
  - 注入：bean对象中的所有属性，由容器来注入

  ```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="student" class="com.test.pojo.Student">
          <!--普通注入-->
          <property name="name" value="小明"/>
          <!--Bean注入，ref-->
          <property name="address" ref="address"/>
          <!--数组注入，ref-->
          <property name="books">
              <array>
                  <value>红楼梦</value>
                  <value>西游记</value>
                  <value>三国演义</value>
                  <value>水浒传</value>
              </array>
          </property>
          <!--List注入-->
          <property name="hobbys">
              <list>
                  <value>听歌</value>
                  <value>看电影</value>
                  <value>玩游戏</value>
              </list>
          </property>
          <!--Map注入-->
          <property name="card">
              <map>
                  <entry key="身份证" value="123456789123456789" />
                  <entry key="银行卡" value="123456782323237892" />
              </map>
          </property>
          <!--set注入-->
          <property name="games">
              <set>
                  <value>LOL</value>
                  <value>COC</value>
                  <value>BOB</value>
              </set>
          </property>
          <!--null注入-->
          <property name="wife">
              <null/>
          </property>
          <!--Properties注入-->
          <property name="info">
              <props>
                  <prop key="学号">123456</prop>
                  <prop key="性别">男</prop>
              </props>
          </property>
      </bean>
  
      <bean id="address" class="com.test.pojo.Address">
          <property name="address" value="北京市随便哪里"/>
      </bean>
  </beans>
  ```

#### 扩展方式注入

- p命名空间注入

  需要在xml头加入如下信息

  ```xml
  xmlns:p="http://www.springframework.org/schema/p"
  ```

  使用

  ```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"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd">
      <!--p命名空间的注入，可以注入属性的值-->
      <bean id="user" class="com.test.pojo.User" p:name="小明" p:age="20"/>
  </beans>
  ```

- c命名空间注入

  需要在xml头加入如下信息

  ```xml
  xmlns:c="http://www.springframework.org/schema/c"
  ```

  使用

  ```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:c="http://www.springframework.org/schema/c"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd">
      
      <!--c命名空间注入，可以通过构造器注入：contruct-args-->
      <bean id="user2" class="com.test.pojo.User" c:name="小红" c:age="18"/>
  
  </beans>
  ```

## Bean的作用域

#### 单例模式（Spring的默认机制）

```xml
<!--每次从容器get的时候，不会产生新对象-->
<bean id="user" class="com.test.pojo.User" p:name="小明" p:age="20" scope="singleton"/>
```

#### 原型模式

```xml
<!--每次从容器get的时候，都会产生新对象-->
<bean id="user" class="com.test.pojo.User" p:name="小明" p:age="20" scope="prototype"/>
```

## Bean的自动装配

#### 自动装配

是spring满足bean依赖的一种方式，spring在上下文中自动寻找，并自动给bean装配属性！

- spring有三种装配的方式

  1. 在xml中显示的配置
  2. 在java中显示的配置
  3. 隐式的自动装配bean【掌握】

  ```xml
  <!--
      自动装配
      byName 会自动在容器上下文中查找，和自己对象set后面的值对应的beanid
  -->
  <bean id="people" class="com.test.pojo.People" autowire="byName">
      <property name="name" value="小明"/>
  </bean>
  ```

  ```xml
  <!--
      自动装配
      byName 会自动在容器上下文中查找，和自己对象set后面的值对应的beanid
      byType 会自动在容器上下文中查找，和自己对象对象属性类型相同的beanid
  -->
  <bean id="people" class="com.test.pojo.People" autowire="byType">
      <property name="name" value="小明"/>
  </bean>
  ```

总结：

- byName的时候，需要保证所有的bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
- byType的时候，需要保证所有的bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！

#### 注解自动装配

jdk1.5支持的注解，Spring2.5支持的注解。

使用注解须知：

1. 导入约束

   ```xml
   xmlns:context="http://www.springframework.org/schema/context"
   ```

   

2. 配置注解的支持

   ```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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           https://www.springframework.org/schema/context/spring-context.xsd">
       
   	<!--开启注解支持-->
       <context:annotation-config/>
       
   </beans>
   ```

3. 直接在属性上使用即可！也可以在set方法上使用！【可以省略set方法，前提是在beans里面设置过值了】

   @Nullable 标记了字段可以为null

   ```java
   package com.test.pojo;
   
   import org.springframework.beans.factory.annotation.Autowired;
   
   public class People {
   	// 默认为true，如果显示的设置为false。说明这个对象可以为null，否则不允许为null
       @Autowired(required = false)
       @Qualifier(value="aaa") // 如果bean设置的id名字不和此处一致，可以显示的设置下其他的名字
       @Resource(name="aaa")  //这个也是可以实现自动转配的
       private Cat cat;
       @Autowired
       private Dog dog;
       private String name;
   
       @Override
       public String toString() {
           return "People{" +
                   "cat=" + cat +
                   ", dog=" + dog +
                   ", name='" + name + '\'' +
                   '}';
       }
   
       public Cat getCat() {
           return cat;
       }
   
   
       public Dog getDog() {
           return dog;
       }
   
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   }
   ```

   @Autowired和@Resource的区别：

   都是用来自动装配的，可以放在属性字段上

   @Autowired通过byType的方式实现，而且必须要求这个对象存在！【常用】

   @Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的话就会报错【常用】

   执行顺序不同：@Autowired通过byType的方式实现；@Resource默认通过byName的方式实现。

## Spring注解开发

在Spring4之后，要使用注解开发，必须要保证aop包已经导入

使用注解需要导入context约束，增加注解的支持

1. bean

2. 属性如何注入

   ```java
   package com.test.pojo;
   
   import org.springframework.beans.factory.annotation.Value;
   import org.springframework.stereotype.Component;
   
   // 等价于 <bean id="user" class="com.test.pojo.User"/>
   // @Component 组件
   @Component
   public class User {
       @Value("小明")  //赋值  相当于 <property name="name" value="小明"/>
       public String name;
   }
   ```

3. 衍生的注解

   @Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层，它们的作用和@Component功能是一样的

   - dao              @Repository
   - service        @Service
   - controller   @Controller

4. 自动装配注解

   - @Autowired：自动装配通过类型。名字。【如果@Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value="XXX")】

   - @Nullable：字段标记了这个注解，说明这个字段可以为null
   - @Resource：自动装配通过名字。类型。

5. 作用域

   - @Scope("singleton")   标注为单例模式

6. 小结

   xml与注解：

   - xml更加万能，适用于任何场合！维护简单方便
   - 注解不是自己类使用不了，维护相对复杂

   xml与注解的最佳实践

   - xml用来管理bean
   - 注解只负责完成属性的注入
   - 我们在使用的过程中，只需要哦注意一个问题：必须让注解生效，就需要开启注解的支持

## 使用Java的方式配置Spring

JavaConfig是Spring的子项目，在Spring4之后，成为了一个核心功能。

- 创建个类，加入@Configuration注解就可以声明为配置类 

  ```java
  package com.test.config;
  
  import com.test.pojo.User;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.ComponentScan;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.context.annotation.Import;
  
  @Configuration  // 这个会被Spring容器脱管，注册到容器中，因为它本来就是一个@Component
  //@Configuration代表这个是一个配置类，就和我们之前看到的beans.xml是一样的
  @ComponentScan("com.test.pojo")
  @Import(MyConfig2.class)  //引入其他的配置类
  public class MyConfig {
      @Bean //注册一个bean，就相当于之前写的一个bean标签，id是这个方法的名字，这个方法的返回值相当于bean标签的class属性
      public User getUser(){
          return new User(); //这个就是返回注入bean的对象
      }
  }
  
  ```

- 实体类注解脱管

  ```java
  package com.test.pojo;
  
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.stereotype.Component;
  
  @Component
  public class User {
      @Value("小明")  //赋值
      private String name;
  
      @Override
      public String toString() {
          return "User{" +
                  "name='" + name + '\'' +
                  '}';
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  }
  
  ```

- 测试类

  ```java
  import com.test.config.MyConfig;
  import com.test.pojo.User;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  
  public class MyTest {
      public static void main(String[] args) {
          //如果完全使用了配置类方式，我们就只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载！
          ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
          User user = context.getBean("getUser", User.class);
          System.out.println(user.getName());
      }
  }
  ```

  这种纯java配置，在SpringBoot种随处可见。

## 代理模式

为什么要学习代理模式？因为这是SpringAOP的底层！

代理模式的好处：

1. 可使真实的角色的操作更加纯粹，不用去关注一些共用的业务。
2. 公共业务就交给了代理角色！实现了业务的分工
3. 公共业务发生扩展的时候，方便集中管理

缺点：

1. 一个真实角色就会产生一个代理角色；代码量会翻倍，开发效率会变低~

代理模式的分类：

- 静态代理

  - 抽象角色：一般会使用接口或抽象类来解决
  - 真实角色：被代理的角色
  - 代理角色：代理真实角色后，会做一些附属操作
  - 客户：访问代理对象的人！

  代码：模拟中介帮房东租房

  1. 接口

  ```java
  package com.test.demo01;
  // 租房接口
  public interface Rent {
      public void rent(); //出租房屋
  }
  ```

  2. 真实角色

  ```java
  package com.test.demo01;
  // 房东
  public class Host implements Rent {
      public void rent() {
          //
          System.out.println("房东要出租房子");
      }
  }
  ```

  3. 代理角色

  ```java
  package com.test.demo01;
  // 代理中介
  public class Proxy implements Rent {
      private Host host;
  
      public Proxy() {
      }
  
      public Proxy(Host host) {
          this.host = host;
      }
  
      public void rent() {
          //
          seeHose(); //看房
          host.rent();
          fare();
      }
  
      //看房，属于附加的操作，可以看多个房子
      public void seeHose(){}
      // 收中介费
      public void fare(){}
  }
  ```

  4. 客户端访问代理角色

  ```java
  package com.test.demo01;
  
  public class Client {
      public static void main(String[] args) {
          Host host = new Host();
          // 代理，代理角色有一个附属操作
          Proxy proxy = new Proxy(host);
          proxy.rent();
      }
  }
  
  ```

- 动态代理

  1. 动态代理和静态代理角色一样

  2. 动态代理的代理类是动态生成的，不是我们直接写好的

  2. 动态代理分为两大类：基于接口的动态代理，基于类的的动态代理
     - 基于接口 ------- JDK动态代理； 需要了解两个类：Proxy代理，InvocationHandler调用处理程序，代码见 **spring-08-proxy**的demo2代码
     - 基于类：cglib
     - java字节码实现：javassist

## AOP

- spring使用aop需要导入一个包

  ```xml
  <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
  <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.4</version>
  </dependency>
  ```

  方式一：使用Spring的API接口

  1. bean的配置

  ```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:aop="http://www.springframework.org/schema/aop"        <!--aop约束-->
         xsi:schemaLocation="http://www.springframework.org/schema/beans
          https://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/aop                   <!--aop约束-->
          https://www.springframework.org/schema/aop/spring-aop.xsd">  <!--aop约束-->
  
  
      <!--注册bean-->
      <bean id="userService" class="com.test.service.UserServiceImpl"/>
      <bean id="log" class="com.test.log.Log"/>
      <bean id="afterLog" class="com.test.log.AfterLog"/>
      <!--方式一：使用原生Spring API接口-->
      <!--配置aop 需要导入aop的约束-->
      <aop:config>
          <!--切入点 expression:表达式;execution():要执行的位置-->
          <aop:pointcut id="pointcut" expression="execution(* com.test.service.UserServiceImpl.*(..))"/>
          <!--执行环绕增加-->
          <aop:advisor advice-ref="log" pointcut-ref="pointcut" />
          <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut" />
      </aop:config>
  
  </beans>
  ```

  2. 测试类

  ```java
  import com.test.service.UserService;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  public class MyTest {
      public static void main(String[] args) {
          ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
          // 动态代理代理的是接口
          UserService userService = (UserService) context.getBean("userService");
          userService.add();
      }
  }
  ```

  方式二：自定义类来实现

  1. bean的配置

     ```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:aop="http://www.springframework.org/schema/aop"
            xsi:schemaLocation="http://www.springframework.org/schema/beans
             https://www.springframework.org/schema/beans/spring-beans.xsd
             http://www.springframework.org/schema/aop
             https://www.springframework.org/schema/aop/spring-aop.xsd">
         <!--注册bean-->
         <bean id="userService" class="com.test.service.UserServiceImpl"/>
         <bean id="log" class="com.test.log.Log"/>
         <bean id="afterLog" class="com.test.log.AfterLog"/>
         <!--方式二:使用自定义类-->
         <bean id="diy" class="com.test.diy.DiyPointCut"/>
         <aop:config>
             <!--自定义切面，ref要引用的类-->
             <aop:aspect ref="diy">
                 <!--切入点-->
                 <aop:pointcut id="point" expression="execution(* com.test.service.UserServiceImpl.*(..))"/>
                 <!--通知-->
                 <aop:before method="before" pointcut-ref="point"/>
                 <aop:after method="after" pointcut-ref="point"/>
             </aop:aspect>
         </aop:config>
     </beans>
     ```

  2. 自定义类

     ```java
     package com.test.diy;
     
     public class DiyPointCut {
     
         public void before(){
             System.out.println("方法执行前");
         }
         public void after(){
             System.out.println("方法执行后");
         }
     }
     ```

  3. 测试类

     ```java
     import com.test.service.UserService;
     import org.springframework.context.ApplicationContext;
     import org.springframework.context.support.ClassPathXmlApplicationContext;
     
     public class MyTest {
         public static void main(String[] args) {
             ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
             // 动态代理代理的是接口
             UserService userService = (UserService) context.getBean("userService");
             userService.add();
         }
     }
     ```

  方式三：注解方式实现

  1. 配置文件

  ```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:aop="http://www.springframework.org/schema/aop"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
          https://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/aop
          https://www.springframework.org/schema/aop/spring-aop.xsd">
      <!--注册bean-->
      <bean id="userService" class="com.test.service.UserServiceImpl"/>
      <bean id="log" class="com.test.log.Log"/>
      <bean id="afterLog" class="com.test.log.AfterLog"/>
  
      <!--方式三 注解的方式-->
      <bean id="annocationPointCut" class="com.test.diy.AnnotationPointCut"/>
      <!--开启注解支持-->
      <aop:aspectj-autoproxy/>
  </beans>
  ```

  2. 注解类

  ```java
  package com.test.diy;
  
  import org.aspectj.lang.annotation.After;
  import org.aspectj.lang.annotation.Aspect;
  import org.aspectj.lang.annotation.Before;
  
  // 使用注解方式实现aop
  @Aspect
  public class AnnotationPointCut {
      @Before("execution(* com.test.service.UserServiceImpl.*(..))")
      public void before(){
          System.out.println("方法执行前");
      }
      @After("execution(* com.test.service.UserServiceImpl.*(..))")
      public void after(){
          System.out.println("方法执行后");
      }
  }
  ```

  3. 测试类

  ```java
  import com.test.service.UserService;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  public class MyTest {
      public static void main(String[] args) {
          ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
          // 动态代理代理的是接口
          UserService userService = (UserService) context.getBean("userService");
          userService.add();
      }
  }
  ```

## 整合Mybatis

步骤：

1. 导入相关jar包

   - junit
   - mybatis
   - mysql
   - spring
   - aop
   - mybatis-spring【new】

   ```xml
   <!--mysql驱动-->
   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>5.1.47</version>
   </dependency>
    <!--mybatis-->
   <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
   <dependency>
       <groupId>org.mybatis</groupId>
       <artifactId>mybatis</artifactId>
       <version>3.5.2</version>
   </dependency>
   <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-jdbc</artifactId>
       <version>5.3.9</version>
   </dependency>
   <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-webmvc</artifactId>
       <version>5.3.9</version>
   </dependency>
   
   <!--junit-->
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
   </dependency>
   <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
   <dependency>
       <groupId>org.aspectj</groupId>
       <artifactId>aspectjweaver</artifactId>
       <version>1.9.4</version>
   </dependency>
   <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
   <dependency>
       <groupId>org.mybatis</groupId>
       <artifactId>mybatis-spring</artifactId>
       <version>2.0.6</version>
   </dependency>
   
   ```

2. 编写配置文件

   ```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:aop="http://www.springframework.org/schema/aop"
          xsi:schemaLocation="http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/aop
           https://www.springframework.org/schema/aop/spring-aop.xsd">
   
       <!--
       DataSource 使用spring的数据源，替换mybatis的配置 c3p0  dbcp druid
       这里使用spring提供的JDBC
       -->
       <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
           <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
           <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=true"/>
           <property name="username" value="root"/>
           <property name="password" value="root"/>
       </bean>
   
       <!--sqlSessionFactory -->
       <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
           <property name="dataSource" ref="dataSource" />
           <!--绑定mybatis配置文件-->
           <property name="configLocation" value="classpath:mybatis-config.xml"/>
           <property name="mapperLocations" value="classpath:com/test/mapper/*.xml"/>
       </bean>
   
   
       <!--就是我们使用的sqlSession-->
       <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
           <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
           <constructor-arg index="0" ref="sqlSessionFactory"/>
       </bean>
   
   
       <bean id="userMapper" class="com.test.mapper.UserMapperImpl">
           <property name="sqlSession" ref="sqlSession"/>
       </bean>
   </beans>
   ```

   

3. 测试

## 声明式事务

#### propagation 传播特性 七种

## 附录 

#### 注解说明

- @Autowired：自动装配通过类型。名字。【如果@Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value="XXX")】

- @Nullable：字段标记了这个注解，说明这个字段可以为null
- @Resource：自动装配通过名字。类型。
- @Component：组件，放在类上，说明这个类被Spring管理了，就是bean！