Spring 学习

1、Spring

1.1、简介

• Spring：春天
• 2002年，首次推出Spring框架雏形：interface21框架
• spring框架以interface21框架为基础，重新设计，于2004年3月24日发布了1.0正式版
• Spring理念：使现有更加容易使用，整合了现有的技术框架

官方下载地址：https://repo.spring.io/libs-release-local/org/springframework/spring/

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.8.RELEASE</version>
</dependency>

1.2、优点

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

Spring是一个轻量级的控制反转（IOC）和面向切面（AOP）的容器（）框架

1.3、组成

1.4、扩展

在Spring的官网介绍：现代化的Java开发，就是基于Spring的开发

• Spring Boot
  • 一个快速开发的手脚架
  • 基于SpringBoot可以快速的开发单个微服务
• Spring Cloud
  • SpringCloud是基于SpringBoot实现

现在大多数公式都在使用SpringBoot进行快速开发，学习SpringBoot前提，需要完全掌握Spring及SpringMVC。承上启下的作用

2、IOC理论推导

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码，如果程序代码量十分大，修改一次的成本代价十分昂贵

我们使用一个Set接口实现

public void setUserDao(UserDao userDao){
    this.userDao = userDap;
}

• 之前，程序是主动创建对象，控制权在程序员手上
• 使用set注入后，程序不再具有主动性，变成了被动接受的对象

这种思想，从本质上解决了问题，我们程序员不用在去管理对象的创建了。系统的耦合性降低，可以专注于业务的实现上！这是IOC的原型

2.1、IOC本质

控制反转IOC（Inversion Of Control），是一种设计思想，DI（依赖注入）是实现IOC的一种方法，也有人认为DI只是IOC的另一种说法。没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建有程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓的控制反转就是：获得依赖对象的方式反转了。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，器实现方法是依赖注入（Dependency Injection，DI）

3、HelloSpring

Dao层接口

public interface UserDao {
    public void getUser();
}

Dao层接口实现类

public class UserDaoByMySqlImpl implements UserDao{
    public void getUser() {
        System.out.println("Mysql用户");
    }
}

public class UserDaoBySqlServerImpl implements UserDao{
    public void getUser() {
        System.out.println("SqlServer用户");
    }
}

Servic层接口

public interface UserService {
    public void getUser();
}

Service层接口实现类

public class UserServiceImpl implements UserService{
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void getUser() {
        userDao.getUser();
    }
}

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <beans>
        <bean id="Mysql" class="com.xu.Dao.UserDaoByMySqlImpl"/>
        <bean id="SqlServer" class="com.xu.Dao.UserDaoBySqlServerImpl"/>
        <bean id="UserService" class="com.xu.Service.UserServiceImpl">
            <!--
                ref: 引用Spring容器中创建好的对象
                Value：具体的值，基本类型
            -->
            <property name="userDao" ref="Mysql"/>
        </bean>
    </beans>
</beans>

测试

public class MyText {
    public static void main(String[] args) {
        // 获取ApplicationContext;拿到Spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        // 从容器中获取对象
        UserServiceImpl userService = (UserServiceImpl) context.getBean("UserService");

        userService.getUser();
    }
}

思考问题

• 在上面的程序中，程序没有new对象，那UserServiceImpl是由谁创建的？
  • UserServiceImpl是由Spring创建
  • 在Beans.xml配置文件中
• 对象的属性设置
  • 在Beans.xml配置文件中
  • Bean标签下有 ref、value两个属性
    • ref：引用Spring容器中创建好的对象
    • Value：具体的值，基本类型

这个过程就叫控制反转：

• 控制：谁来控制对象的创建，传统的应用程序的对象是由程序本身控制创建，使用Spring后，对象是由Spring来创建。
• 反转：程序本身不创建对象，而变成被动的接收对象
• 依赖注入：就是利用Set方法进行注入

IOC是一种编程思想，由主动的编程变成被动的接收

使用IOC，我们彻底不用在去程序中改动，要实现不同的操作，只需要在配置文件中进行修改。

所谓的IOC，就是对象由Spring来创建，管理，装配！

4、IOC创建对象的方式

1. 使用无参构造创建对象，默认实现

   // POJO
   public class User {
       private String name;
   
       public User() {
           System.out.println("创建User对象");
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   }
   
   // TEXT
   public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
       User user = (User) context.getBean("user");
   }
   

2. 假设我们要使用有参构造

   1. 构造函数参数索引

      <beans>
          <bean id="user" class="com.xu.pojo.User">
              <constructor-arg index="0" value="徐安康"/>
          </bean>
      </beans>
      

   2. 构造函数参数类型匹配

      <beans>
          <bean id="user" class="com.xu.pojo.User">
              <constructor-arg type="java.lang.String" value="徐安康"/>
          </bean>
      </beans>
      

   3. 参数名

      <beans>
          <bean id="user" class="com.xu.pojo.User">
              <constructor-arg name="name" value="徐安康"/>
          </bean>
      </beans>
      

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

5、Spring配置

5.1、别名

<!--别名，添加别名后可以通过别名获取对象-->
<alias name="user" alias="user1"/>

5.2、Bean的配置

• id：bean的唯一标识符，相当于对象名
• class：bean对象所对应的全限定名：包名+类型
• name：别名，可以同时去多个别名

5.3、Import

Import可以将多个配置文件，导入合并为一个

多人开发项目，通过Import将所有人的Beans.xml合并为一个总的ApplicationContext.xml

6、DI依赖注入

6.1、通过构造器注入

前面介绍过，见IOC创建对象的方式

6.2、Set方式注入【重点】

• 依赖注入：Set注入
  • 依赖：Bean对象创建依赖容器
  • 注入：Bean对象中的所有属性，有容器来注入

    <bean id="student" class="com.xu.pojo.Student">
        <property name="name" value="徐安康"/>
        <property name="address" ref="address"/>
        <property name="books">
            <array>
                <value>《红楼梦》</value>
                <value>《水浒传》</value>
                <value>《三国演义》</value>
                <value>《西游记》</value>
            </array>
        </property>
        <property name="card">
            <map>
                <entry key="身份证" value="56465465465"/>
                <entry key="银行卡" value="56465465465"/>
            </map>
        </property>
        <property name="games">
            <set>
                <value>游戏</value>
                <value>睡觉</value>
                <value>吃饭</value>
            </set>
        </property>
        <property name="hobbies">
            <list>
                <value>游戏</value>
                <value>睡觉</value>
                <value>吃饭</value>
            </list>
        </property>
        <property name="info">
            <props>
                <prop key="driver">JDBC</prop>
                <prop key="url">jdbc:mysql://127.0.0.1:3306?mybatis&amp;serverTimezone=UTC&amp;characterEncoding=utf-8</prop>
                <prop key="username">root</prop>
                <prop key="password">xakxak</prop>
            </props>
        </property>
    </bean>
    <bean id="address" class="com.xu.pojo.Address">
        <property name="address" value="孝感"/>
    </bean>

6.3、拓展方式注入

我们可以使用P命名空间和C命名空间进行注入

<bean id="student" class="com.xu.pojo.Student" p:name="徐安康">
    <!--        <property name="name" value="徐安康"/>-->

<bean id="address" class="com.xu.pojo.Address" C:address="孝感"/>

注意点：

P命名空间和C命名空间需要导入

xmlns:p="http://www.springframework.org/schema/p"
xmlns:C="http://www.springframework.org/schema/c"

6.4、Bean的作用域

1. 单例模式：singleton（Spring默认机制）

   <bean id="address" class="com.xu.pojo.Address" C:address="孝感" scope="singleton"/>
   

2. 原型模式：prototype 每次从容器中get的时候，都会产生一个新对象

   <bean id="address" class="com.xu.pojo.Address" C:address="孝感" scope="prototype"/>
   

3. 其余的request，session，application这些只能在web开发中使用

7、Bean的自动装配

• 自动装配是Spring满足Bean依赖的一种方式
• Spring会在上下文中自动寻找，并自动给Bean装配属性

在Spring中有三种装配方式

1. 在XMl中显示的配置
2. 在Java中显示配置
3. 隐式的自动装配Bean

7.1、ByName自动装配

<bean id="dog" class="com.xu.pojo.Dog"/>
<bean id="cat" class="com.xu.pojo.Cat"/>
<bean id="person" class="com.xu.pojo.Person" autowire="byName"/>

7.2、ByType自动装配

<bean id="dog" class="com.xu.pojo.Dog"/>
<bean id="cat" class="com.xu.pojo.Cat"/>
<bean id="person" class="com.xu.pojo.Person" autowire="byType"/>

小结：

• ByName的时候，需要保证bean的Id唯一，并且这个bean需要和自动注入的属性Set方法的值一致
• ByType的时候，需要保证所有的Bean的class唯一，并且这个bean需要和自动注入的属性类型一致

7.3、使用注解实现自动装配

JDK1.5支持注解，Spring2.5开始支持注解

使用注解须知：

1. 导入约束：Context约束

   <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
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">
   

2. 配置注解支持

   <context:annotation-config/>
   

@Autowired

直接在属性上使用即可，也可以在Set方法上使用

使用@Autowired我们可以不用编写Set方法，前提是你这个装配的属性在IOC容器中存在

    @Autowired
    private Dog dog;
    @Autowired
    private Cat cat;

<bean id="dog" class="com.xu.pojo.Dog"/>
<bean id="cat" class="com.xu.pojo.Cat"/>
<bean id="person" class="com.xu.pojo.Person"/>

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value=“xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入

public class Person {
    @Autowired
    @Qualifier(value = "dog1")
    private Dog dog;
    @Autowired
    @Qualifier(value = "cat1")
    private Cat cat;

<bean id="dog1" class="com.xu.pojo.Dog"/>
<bean id="dog2" class="com.xu.pojo.Dog"/>
<bean id="cat1" class="com.xu.pojo.Cat"/>
<bean id="cat2" class="com.xu.pojo.Cat"/>
<bean id="person" class="com.xu.pojo.Person"/>

@Resource

Java自带的装配注解

public class Person {
    @Resource(name = "dog1")
    private Dog dog;
    @Resource(name = "cat1")
    private Cat cat;

<bean id="dog1" class="com.xu.pojo.Dog"/>
<bean id="dog2" class="com.xu.pojo.Dog"/>
<bean id="cat1" class="com.xu.pojo.Cat"/>
<bean id="cat2" class="com.xu.pojo.Cat"/>
<bean id="person" class="com.xu.pojo.Person"/>

小结：

@Resource和@Autowired的区别：

• 都是用来自动装配，都可以放在属性字段上
• @Autowired通过byType的方式实现
• @Resource默认是通过byName的方式实现，如果找不到名字，则通过byType实现，如果两个找不到就报错

8、使用注解开发

在Spring4之后，想要使用注解形式，必须得要引入AOP包

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

<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
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

8.1、Bean的实现

我们之前使用的是Bean标签，在实际开发中使用的是注解

1. 配置扫描包

   <context:component-scan base-package="com.xu"/>
   <!--扫描com.xu包下的注解-->
   

2. 在指定包下编写类，增加注解

   @Component // 等价于 在xml中配置Bean标签
   public class User {
       @Value("徐安康")// 相当于 在Bean标签下的property标签
       private String name;
   }
   

3. 测试

   public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
       User user = context.getBean("user", User.class);
       System.out.println(user.toString());
   }
   

8.2、衍生注解

注解就是代替了在配置文件中配置的步骤，更加快捷

@Component三个衍生注解

为了更好的进行分层，Spring可以使用其他三个注解，功能一样，目前使用哪一个功能都一样

• Dao层：@Repository
• Service层：@Service
• Controller：@Controller

这四个注解功能都是一样的，都是将某个类注册到Spring中，装配Bean

8.3、自动装配注解

@Autowired

@Resource

8.4、作用域

@Scope

• singleton：默认的，Spring会采用单例模式创建这个对象，关闭工厂，所有对象都会销毁
• prototype：多例模式（原型模式），关闭工厂，所有对象不会销毁。内部垃圾回收机制会回收

8.5、小结

XML与注解：

• xml更加万能，适合任何场景，维护简单方便
• 注解不是自己的类使用不了，维护相对复杂
  • 使用注解不能装配其他类

XML与注解的最佳实践：

• XML用来管理Bean

• 注解只负责完成属性的注入

• 要使用注解，必须开启注解的支持

  <context:component-scan base-package="com.xu"/>
  <context:annotation-config/>
  

8.6、基于Java类进行配置

我们现在完全不使用Spring的XML配置，全权交给Java来做

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

测试：

1、编写一个实体类，Dog

@Component  //将这个类标注为Spring的一个组件，放到容器中！
public class Dog {
   public String name = "dog";
}

2、新建一个config配置包，编写一个MyConfig配置类

@Configuration  //代表这是一个配置类
public class MyConfig {

   @Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
   public Dog dog(){
       return new Dog();
  }

}

3、测试

@Test
public void test2(){
   ApplicationContext applicationContext =
           new AnnotationConfigApplicationContext(MyConfig.class);
   Dog dog = (Dog) applicationContext.getBean("dog");
   System.out.println(dog.name);
}

4、成功输出结果！

导入其他配置如何做呢？

1、我们再编写一个配置类！

@Configuration  //代表这是一个配置类
public class MyConfig2 {
}

2、在之前的配置类中我们来选择导入这个配置类

@Configuration
@Import(MyConfig2.class)  //导入合并其他配置类，类似于配置文件中的 inculde 标签
public class MyConfig {

   @Bean
   public Dog dog(){
       return new Dog();
  }

}

关于这种Java类的配置方式，我们在之后的SpringBoot 和 SpringCloud中还会大量看到，我们需要知道这些注解的作用即可！

9、代理模式

9.1、静态代理

角色分析：

• 抽象角色（出租房）：一般会使用接口或者抽象类来解决
• 真实角色（房东）：被代理的角色
• 代理角色（中介）：代理真实角色，代理真实角色后，会进行一些附属操作
• 客户（要租房人）：访问代理角色的人

静态代理模式的好处：

• 可以使真实角色的操作根据纯粹，不用去关注一些公关业务
• 公共业务交给代理角色，实现了业务的分工
• 公共业务在发生扩展的时候，方便集中管理

缺点：

• 一个真实角色会产生一个代理角色：代码量会翻倍，开发效率变低

AOP：面向切面编程

9.2、动态代理

• 动态代理的角色和静态代理的一样
• 动态代理的代理类是动态生成的，静态代理的代理类是我们提前写好的
• 动态代理分为两类：一类是基于接口的动态代理，一类是基于类的动态代理
  • 基于接口的动态代理----JDK动态代理
  • 基于类的动态代理-----cglib
  • 现在用的比较多的是Javasist来生成动态代理
  • 我们这里使用JDK的原生代码来实现

JDK的动态代理需要了解两个类

核心：InvocationHandler 和Proxy，

【InvoactionHandler：调用处理程序】

Object invoke(Object proxy, 方法 method, Object[] args)；
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。

【Proxy：代理】

动态代理的好处

静态代理的好处它都有

• 可以使真实角色的操作根据纯粹，不用去关注一些公关业务
• 公共业务交给代理角色，实现了业务的分工
• 公共业务在发生扩展的时候，方便集中管理
• 一个动态代理，一般代理某一类业务
• 一个动态代理可以代理多个类，代理的是接口！

10、AOP

10.1、什么是AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

10.2、Aop在Spring中的作用

提供声明式事务；允许用户自定义切面

以下名词需要了解下：

• 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
• 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
• 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
• 目标（Target）：被通知对象。
• 代理（Proxy）：向目标对象应用通知之后创建的对象。
• 切入点（PointCut）：切面通知 执行的 “地点”的定义。
• 连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

即 Aop 在 不改变原有代码的情况下 , 去增加新的功能 .

10.3、使用Spring实现AOP

【重点】使用AOP织入，需要导入依赖包

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

10.3.1、通过Spring API实现

• 业务接口和实现类

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

  public class UserServiceImpl implements UserService {
      public void add() {
          System.out.println("增加一个用户");
      }
  
      public void delete() {
          System.out.println("删除一个用户");
      }
  
      public void update() {
          System.out.println("更新一个用户");
      }
  
      public void select() {
          System.out.println("查询一个用户");
      }
  }
  

• 编写增强类，一个前置增强（MethodBeforeAdvice），一个后置增强（AfterReturningAdvice）

  public class Log implements MethodBeforeAdvice {
      /**
       * 在目标方法之前要执行的操作
       * @param method 要执行的目标对象中的方法
       * @param args 目标对象方法的参数
       * @param target 目标对象
       * @throws Throwable
       */
      public void before(Method method, Object[] args, Object target) throws Throwable {
          System.out.println(target.getClass().getName()+"的"+method.getName()+"方法");
      }
  }
  

• 在Spring配置文件中，实现AOP切入实现

  <?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
          http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop.xsd">
  
      <bean id="userService" class="com.xu.service.UserServiceImpl"/>
      <bean id="log" class="com.xu.pojo.Log"/>
      <!--配置AOP，需要导入AOP约束-->
      <aop:config>
          <!--切入点 execution：表达式 匹配要执行的方法-->
          <!--第一个*号：表示返回类型，*号表示所有的类型。-->
          <!--包名 可用*表示所有-->
          <!--*(..) 表示这个类里面的所有方法，参数为(..) 表示任何参数-->
          <aop:pointcut id="pointcut" expression="execution(* com.xu.service.UserServiceImpl.*(..))"/>
          <!--执行环绕 advice-ref 要切入的类 pointcut-ref 切入点-->
          <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
      </aop:config>
  </beans>
  

• 测试

  public class MyText {
      public static void main(String[] args) {
          ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
          UserService userservice = context.getBean("userService", UserService.class);
          userservice.add();
      }
  }
  

  Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块 .

  Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理 .

• 10.3.2、自定义类来实现AOP

  1. 写一个自定义的切入类

     @Component
     public class DiyPointCut {
         public void Before(){
             System.out.println("=====在方法执行之前==========");
         }
         public void After(){
             System.out.println("=====在方法执行之后==========");
         }
     }
     

  2. 去Spring中配置AOP

     <!--配置AOP-->
     <aop:config>
         <!--创建切面 ref 引用要切入的类-->
         <aop:aspect ref="diyPointCut">
             <!--切入点-->
             <aop:pointcut id="point" expression="execution(* com.xu.service.UserServiceImpl.*(..))"/>
             <!--通知 就是要切入的方法-->
             <aop:before method="Before" pointcut-ref="point"/>
             <aop:after method="After" pointcut-ref="point"/>
         </aop:aspect>
     </aop:config>
     

  3. 测试

     public class MyText {
         public static void main(String[] args) {
             ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
             UserService userservice = context.getBean("userService", UserService.class);
             userservice.add();
         }
     }
     

     Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块 .

     Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理 .

10.3.2、自定义类来实现AOP

1. 写一个自定义的切入类

   @Component
   public class DiyPointCut {
       public void Before(){
           System.out.println("=====在方法执行之前==========");
       }
       public void After(){
           System.out.println("=====在方法执行之后==========");
       }
   }
   

2. 去Spring中配置AOP

   <!--配置AOP-->
   <aop:config>
       <!--创建切面 ref 引用要切入的类-->
       <aop:aspect ref="diyPointCut">
           <!--切入点-->
           <aop:pointcut id="point" expression="execution(* com.xu.service.UserServiceImpl.*(..))"/>
           <!--通知 就是要切入的方法-->
           <aop:before method="Before" pointcut-ref="point"/>
           <aop:after method="After" pointcut-ref="point"/>
       </aop:aspect>
   </aop:config>
   

3. 测试

   public class MyText {
       public static void main(String[] args) {
           ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
           UserService userservice = context.getBean("userService", UserService.class);
           userservice.add();
       }
   }
   

10.3.3、使用注解实现AOP

1. 在Spring配置文件中开启AOP注解支持

   <!--开启AOP注解支持-->
   <aop:aspectj-autoproxy/>
   

2. 编写要切入的类

   @Component
   @Aspect
   public class DiyPointCut {
       @Before("execution(* com.xu.service.UserServiceImpl.*(..))")
       public void Before(){
           System.out.println("=====在方法执行之前==========");
       }
       @After("execution(* com.xu.service.UserServiceImpl.*(..))")
       public void After(){
           System.out.println("=====在方法执行之后==========");
       }
       @Around("execution(* com.xu.service.UserServiceImpl.*(..))")
       public void around(ProceedingJoinPoint jp) throws Throwable {
           System.out.println("环绕前");
           Object proceed = jp.proceed();
           System.out.println("环绕后");
       }
   }
   

11、整合Mybatis

11.1、导入相关的包

<dependencies>
        <!--Spring依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!--Lombok依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <!--AOP织入依赖-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
        <!--Mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.5</version>
        </dependency>
        <!--Mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.19</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--Spring-JDBC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <!--Mybatis-Spring-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.5</version>
        </dependency>
    </dependencies>

11.2、回顾Mybatis

1. 导包
2. 配置Mybatis-Config.xml文件
3. 创建实体类
4. 创建Mapper接口
5. 创建Mapper.xml
6. 在Mybatis-Config.xml中配置Mapper标签
7. 测试

11.3、Mybatis-Spring整合

什么是Mybatis-Spring

Mybatis-Spring会帮你将Mybatis代码无缝的整合到Spring中

如果使用Maven作为构建工具，需要导入

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.5</version>
</dependency>

要和 Spring 一起使用 MyBatis，需要在 Spring 应用上下文中定义至少两样东西：一个 SqlSessionFactory 和至少一个数据映射器类。

在 MyBatis-Spring 中，可使用 SqlSessionFactoryBean来创建 SqlSessionFactory。

11.3.1、整合方式一

1. 编写数据源配置

   <!--配置数据源  使用Spring的JDBC-->
   <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
       <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
       <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=UTC"/>
       <property name="username" value="root"/>
       <property name="password" value="xakxak"/>
   </bean>
   

2. 创建实体类

   @Data
   public class User {
       private int id;
       private String name;
       private String password;
   }
   

3. 创建Mapper接口

   public interface UserMapper {
       public List<User> getUserList();
   }
   

4. 创建Mapper.xml

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="com.xu.mapper.UserMapper">
       <select id="getUserList" resultType="user">
           select * from user;
       </select>
   </mapper>
   

5. 创建SQLSessionFactory

   <!--创建SQLSessionFactory-->
   <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
       <!--注入数据源-->
       <property name="dataSource" ref="dataSource"/>
       <!--导入Mybatis配置文件-->
       <property name="configLocation" value="classpath:Mybatis-config.xml"/>
       <!--导入Mapper.xml注册文件-->
       <property name="mapperLocations" value="classpath:com/xu/mapper/*.xml"/>
   </bean>
   

6. 创建SQLSessionTempLate

   <!--创建SQLSession-->
   <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
       <!--需要使用构造器注入SQLSessionFactory-->
       <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
   </bean>
   

7. 创建接口的实现类

   /**
    * 接口实现类
    * 需要一个SQLSession对象
    */
   public class UserMapperImpl implements UserMapper{
       
       private SqlSessionTemplate sqlSession;
       // Set方法 Spring注入
       public void setSqlSession(SqlSessionTemplate sqlSession) {
           this.sqlSession = sqlSession;
       }
       
       public List<User> getUserList() {
           return sqlSession.getMapper(UserMapper.class).getUserList();
       }
   }
   

8. 在Spring中注册接口实现类

   <!--注册接口实现类 注入SQLSession-->
   <bean id="userMapperImpl" class="com.xu.mapper.UserMapperImpl">
       <property name="sqlSession" ref="sqlSession"/>
   </bean>
   

9. 测试

   public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
       UserMapperImpl userMapperImpl = context.getBean("userMapperImpl", UserMapperImpl.class);
       for (User user : userMapperImpl.getUserList()) {
           System.out.println(user);
       }
   }
   

11.3.2、整合方式二

在方式一的基础上，修改UserMapperImpl类

/**
 * 通过继承SqlSessionDaoSupport可以直接得到SQLSession
 */
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
    public List<User> getUserList() {
        return getSqlSession().getMapper(UserMapper.class).getUserList();
    }
}

创建一个新类需要在Spring中注册

<bean id="userMapperImpl2" class="com.xu.mapper.UserMapperImpl2">
    <!--这个类继承了SqlSessionDaoSupport它需要sqlSessionFactory-->
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

11.3.3、总结

总结 : 整合到spring以后可以完全不要mybatis的配置文件，除了这些方式可以实现整合之外，我们还可以使用注解来实现，这个等我们后面学习SpringBoot的时候还会测试整合！

12、声明式事务

回顾事务

• 要么都成功，要么都失败
• 事务在项目开发中非常重要，涉及到数据的一致性问题
• 事务管理在企业级应用程序开发中必备技术，用来确保数据的完整性和一致性

事务就是把一系列的动作当成一个独立的工作单元，这个动作要么都成功，要么都失败

事务的ACID原则

• 原子性
  • 事务是由一系列的动作组成，要么都成功，要么都失败
• 一致性
  • 事务完成后需要提交，确保数据之间的一致性
• 隔离性
  • 多个事务处理相同的数据，每个事务需要被隔离，防止数据损坏
• 持久性
  • 事务一旦提交，会被持久化到存储器中

Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

编程式事务管理

• 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
• 缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

声明式事务管理

• 一般情况下比编程式事务好用。
• 将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
• 将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

使用Spring管理事务，注意头文件的约束导入 : tx

xmlns:tx="http://www.springframework.org/schema/tx"

http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">

配置事务管理器

<!--配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

配置事务通知

<!--配置事务通知-->
<tx:advice id="interceptor" transaction-manager="transactionManager">
    <tx:attributes>
        <!--配置哪些方法使用什么样的事务-->
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

spring事务传播特性：

事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：

• propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
• propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
• propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
• propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
• propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
• propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
• propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作

Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况

配置AOP

导入AOP约束

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">

配置AOP

<!--配置AOP-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="transactionPointCut" expression="execution(* com.xu.mapper.*.*(..))"/>
    <!--切入通知-->
    <aop:advisor advice-ref="interceptor" pointcut-ref="transactionPointCut"/>
</aop:config>

测试

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
    UserMapper userMapper = context.getBean("userMapperImpl", UserMapper.class);
    for (User user : userMapper.getUserList()) {
        System.out.println(user);
    }
}