spring5学习笔记

• 一、简介
• • 1. spring历史
  • 2. spring设计理念
  • 3. 几个经常用到的网站
  • 4. maven导入spring包
  • 5. 优点
• 二、组成
• • 1. 简介
  • 2. IOC理论推导
  • • 2.1 传统编程模式
    • • (1) UserDao接口
      • (2) UserDaoImpl实现类
      • (3) UserService接口
      • (4) UserServiceImpl实现类
      • (5) 编写测试类MyTest**：**用户实际调用是业务层,dao层不需要接触
    • 2.2 IOC原型模式
    • 2.3 两种模式的对比
  • 3. IOC本质
• 三、用spring容器来实现2.2 ioc原型程序
• • 1.创建实体类接口：UserDao
  • 2. 创建实体类的实现类：UserDaoMysqlImpl 、UserDaoOracleImpl、UserDaoImpl
  • 3. 创建业务类接口UserService
  • 4. 创建业务类的实现类UserServiceImpl
  • 5. 编写beans.xml文件
  • 6. 编写测试用的前段程序
  • 7. 小结
• 四、IOC创建对象的方式
• • 1. 使用无参构造创建对象,默认方式
  • 2. 使用有参构造创建对象
  • 3.完整代码
  • 4. 总结
• 五、Spring配置
• • 1. 别名
  • 2. bean的配置
  • 3. import
• 六、依赖注入
• • 1. 构造器注入
  • 2. set方式注入
  • • 2.1 依赖注入
    • 2.2 搭建环境
  • 3. 扩展注入方式:
  • • 3.1 P命名空间
    • 3.2 C命名空间
    • 3.3 完整代码
    • 3.4 注意点
  • 4. bean的作用域
• 七、bean的自动装配
• • 1. 知识点
  • 2. 隐式的自动装配bean
  • • 2.1 搭建环境
    • 2.2 ByName自动装配
    • 2.3 ByType自动装配
    • 2.4 小结
  • 3. 使用注解实现自动装配
  • • 3.1注解使用须知
    • 3.2 使用注解步骤
    • 3.3 小结
• 八、使用注解开发
• • 1. bean
  • 2. 属性如何注入
  • 3. 衍生的注解
  • 4. 自动装载配置
  • 5. 作用域
  • 6. 小结
• 九、使用Java方式配置spring
• • 1. ApplicationContext的实现类
  • 2. java配置spring的步骤
  • • 2.1 配置类
    • 2.2 需要加载到spring中的实体类
    • 2.3 测试类
  • 3. 小结
• 十、代理模式
• • 1. 代理模式的分类：
  • 2. 静态代理
  • • 2.1 角色分析：
    • 2.2 代理模式的好处：
    • 2.3 缺点：
    • 2.4 代码：
    • 2. 5 加深理解
    • 2.6 聊聊AOP
  • 3. 动态代理
  • • 3.1 角色分析
    • 3.2 两个重要的类
    • 3.3 实现代码
    • 3.4 动态代理的优点：
• 十一、AOP
• • 1. 什么是AOP
  • • 1.1 以增加日志为例显示AOP实现原理
    • 1.2 专业术语
    • 1.3 Advice的种类
  • 2. Spring实现Aop
  • • 2.1 导入依赖包pom.xml
    • 2.2 核心配置文件applicationContext.xml
    • 2.3 service接口及其实现类
    • 2.4 需要插入的日志类
    • 2.5 测试类
  • 3. 三种实现方式
  • • 3.1 方式一：使用Spring的api接口，【主要由Spring Api接口实现】
    • 3.2 方式二：自定义来实现AOP【主要是切片定义】
    • 3.3 使用注解实现
• 十二、 整合Mybatis
• • 1. 步骤
  • • 1.1 导入相关的jar包
    • 1.2 项目配置文件：依赖包的导入
  • 2. 回忆mybatis步骤
  • 3. mybatis-spring：
  • • 3.1 编写数据源:Spring的通用配置spring-dao.xml
    • 3.2 SqlSessonFactory:Spring的通用配置spring-dao.xml
    • 3.3 SqlSessonTemplate:Spring的通用配置spring-dao.xml
    • 3.4 需要给接口加实现类
    • 3.5 将自己写的实现类注入spring中，applicationContext.xml
    • 3.5 测试
    • 3.6 完整实现代码
  • 4. mybatis-spring 第二中实现方式
  • • 4.1 思路
    • 4.2 代码
• 十三、申明式事务
• • 1. spring中事务的种类
  • • 1.1申明式事务：结合AOP实现事务的植入，在Spring-dao.xml文件中配置
    • 1.2 编程式事务：需要在编程中实现代码的管理
  • 2. 申明式事务代码实现
  • • 2.1 实体类
    • 2.2 mapper类的接口、实现类及配置文件
    • 2.3 配置文件
    • 2.4 测试代码
    • 2.5 项目依赖包

一、简介

1. spring历史

(1) 2002年首次推出spring框架的雏形：interface21。
(2) spring框架以interface21框架为基础，通过重新设计并不断丰富其内涵，于2004年3月24日发布1.0版本。
(3) rod johnson:Spring的缔造者，音乐学博士。

2. spring设计理念

(1) spring使现有的技术更加容易使用；本身是一个大杂烩；整合了现有的技术框架。
(2) ssh：Structs2+Spring+Hibernate
(3) ssm：SpringMVC+Spring+Mybatis

3. 几个经常用到的网站

(1) 官网：https://docs.spring.io/spring-framework/docs/5.3.10-SNAPSHOT/reference/html/
(2) 官方下载地址：https://repo.spring.io/ui/native/libs-release-local/org/springframework/spring/
(3) GitHub地址：https://github.com/spring-projects/spring-framework/tags
(4) Spring-Mybatis中文帮助文档来源：http://mybatis.org/spring/zh/index.html

4. maven导入spring包

选择spring-web-MVC和spring jdbc，它会自动导入其它包

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

<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.8</version>
</dependency>

5. 优点

(1) Spring是一个开源的免费的框架（容器）。
(2) Spring是一个轻量级的非入侵式的框架。
(3) 控制反转（IOC），面向切面编程（AOP）。
(4) 支持事物的处理，对框架整合的处理。
总之：Spring是一个轻量级的控制反转（IOC）、面向切面编程（AOP）的框架。

二、组成

1. 简介

(1) Spring的官网有这个介绍：现代化的java开发，说白了就是基于Spring的开发。
(2) SpringBoot：一个快速开发的脚手架；基于SpringBoot可以快速开发单个微服务；约定大于配置。
(3) SpringCloud：SpringCloud是基于SpringBoot实现的，
(4) 现在大多数公司都在使用SpringBoot进行快速开发；学习SpringBoot的前提是要完全掌握Spring和SpringMVC。
(5) 弊端：发展了太久之后，违背了原来的理念，配置十分繁琐，人称“配置地狱”。

2. IOC理论推导

2.1 传统编程模式

(1) UserDao接口

package com.sxsl.dao;
public interface UserDao {
    public void getUser();
}

(2) UserDaoImpl实现类

package com.sxsl.dao;
public class UserDaoImpl implements UserDao {
    public void getUser() {
        System.out.printf("默认获取用户数据");
    }
}

(3) UserService接口

package com.sxsl.service;
public interface UserService {
    void getUser();
}

(4) UserServiceImpl实现类

package com.sxsl.service;

import com.sxsl.dao.UserDao;
import com.sxsl.dao.UserDaoImpl;
import com.sxsl.dao.UserDaoMysqlImpl;

public class UserServiceImpl implements UserService {
    //传统模式通过程序员手工加载具体实现类完成具体业务
    private UserDao userDao = new UserDaoImpl();

//    IOC思想利用set方法实现动态值的注入,接口的思想
//    public void setUserDao(UserDao userDao) {
//        this.userDao = userDao;
//    }

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

(5) 编写测试类MyTest**：**用户实际调用是业务层,dao层不需要接触

import com.sxsl.dao.UserDaoImpl;
import com.sxsl.dao.UserDaoMysqlImpl;
import com.sxsl.dao.UserDaoOracleImpl;
import com.sxsl.service.UserServiceImpl;
import com.sxsl.service.*;

public class MyTest {
    public static void main(String[] args) {
        //用户实际调用是业务层,dao层不需要接触
        UserService userService=new UserServiceImpl();
        //用户主动加载具体实现类完成具体业务
        //((UserServiceImpl) userService).setUserDao(new UserDaoOracleImpl());
        userService.getUser();
    }
}

2.2 IOC原型模式

(1) 定义若干个UserDAO的具体实现类如：UserDaoImpl、UserDaoMysqlImpl、UserDaoOracleImpl。
(2) 修改UserServiceImpl实现类，利用set方法实现动态值的注入,接口的思想。

package com.sxsl.service;

import com.sxsl.dao.UserDao;
import com.sxsl.dao.UserDaoImpl;
import com.sxsl.dao.UserDaoMysqlImpl;

public class UserServiceImpl implements UserService {
    //传统模式通过程序员手工加载具体实现类完成具体业务
    //private UserDao userDao = new UserDaoImpl();
    private UserDao userDao;

    //利用set方法实现动态值的注入,接口的思想
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

(3) 修改MyTest测试类：用户动态new UserDaoOracleImp、UserDaoImpl、UserDaoMysqlImpl实现类，掌握程序运行的主动权。

import com.sxsl.dao.UserDaoImpl;
import com.sxsl.dao.UserDaoMysqlImpl;
import com.sxsl.dao.UserDaoOracleImpl;
import com.sxsl.service.UserServiceImpl;
import com.sxsl.service.*;

public class MyTest {
    public static void main(String[] args) {
        //用户实际调用是业务层,dao层不需要接触
        UserService userService=new UserServiceImpl();
        //用户主动加载具体实现类完成具体业务
        ((UserServiceImpl) userService).setUserDao(new UserDaoOracleImpl());
        userService.getUser();
    }
}

2.3 两种模式的对比

(1) 在传统模式中，用户的不同需求可能会影响我们原来的代码，我们需要根据用户的需求修改源代码，如果程序代码十分庞大，修改程序的代价高昂；IOC模式中我们使用一个set接口，整个程序发生革命化的变化。

    private UserDao userDao;

    //利用set方法实现动态值的注入,接口的思想
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

(2) 传统模式下，程序是主动创建对象，控制权在程序员手上；IOC模式使用set注入后，程序不再具有主动性，而是变成了被动的接受对象。
(3) 这种思想从本质上解决了问题，程序员不再管理对象的创建；系统的耦合性大大降低，可以更加专注于业务上的实现，这就是IOC原型。

3. IOC本质

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

(2) IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。
(3) Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

(4) 采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
(5) 控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

三、用spring容器来实现2.2 ioc原型程序

1.创建实体类接口：UserDao

package com.sxsl.dao;

public interface UserDao {
    public void getUser();
}

2. 创建实体类的实现类：UserDaoMysqlImpl 、UserDaoOracleImpl、UserDaoImpl

//以UserDaoMysqlImpl 为例，其他类似
package com.sxsl.dao;

public class UserDaoMysqlImpl implements UserDao {
    public void getUser() {
        System.out.println("Mysql获取用户数据！！");
    }
}

package com.sxsl.dao;

public class UserDaoImpl implements UserDao {
    public void getUser() {
        System.out.printf("默认获取用户数据");
    }
}

package com.sxsl.dao;

public class UserDaoOracleImpl implements UserDao {
    public void getUser() {
        System.out.println("Oracle获取用户数据！！");
    }
}

3. 创建业务类接口UserService

package com.sxsl.service;

public interface UserService {
    void getUser();
}

4. 创建业务类的实现类UserServiceImpl

package com.sxsl.service;

import com.sxsl.dao.UserDao;
import com.sxsl.dao.UserDaoImpl;
import com.sxsl.dao.UserDaoMysqlImpl;

public class UserServiceImpl implements UserService {
    //传统模式通过程序员手工加载具体实现类完成具体业务
    //private UserDao userDao = new UserDaoImpl();
    private UserDao userDao;

    //利用set方法实现动态值的注入,接口的思想
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

5. 编写beans.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-3.0.xsd">

    <!--使用Spring来创建对象,在spring中这些均成为bean
      类型 变量名 = new 类型();
      Hello hello=new Hello();
      bean=对象
      id=变量名
      class=new 的对象
      property相当于给对象中的属性设置一个值
    -->
    <bean id="mysqlImpl" class="com.sxsl.dao.UserDaoMysqlImpl"/>
    <bean id="oracleImpl" class="com.sxsl.dao.UserDaoOracleImpl"/>
    <!--<bean id="userImpl" class="com.sxsl.dao.UserDaoImpl"/>-->
    <bean id="userServiceImpl" class="com.sxsl.service.UserServiceImpl">
        <!--ref:引用容器中创建好的对象，编辑该引用对象，即可完成不同实体类方法的调用
            value:具体的值，基本数据类型可以用这个选项
        -->
        <property name="userDao" ref="userImpl"/>
    </bean>
</beans>

6. 编写测试用的前段程序

import com.sxsl.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //获取applicationContext;拿到spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //容器在手，天下我有,需要啥就直接get啥
        UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("userServiceImpl");
        userServiceImpl.getUser();
    }
}

7. 小结

(1) 在beans.xml文件中，bean=对象， id=变量名，class=new 的对象对应的类，property相当于给对象中的属性设置一个值。
(2) 对象（各个bean）由spring创建，对象的属性由spring容器来设置。
(3) 控制：谁来控制对象的创建？传统应用程序中对象的创建由程序完成，而spring中由spring容器通过起配置文件来实现。
(4) 反转：程序本身不创建对象，而是被动接受配置文件中定义的由spring创建的对象。
(5) 依赖注入：就是利用set方法进行注入。

    //利用set方法实现动态值的注入,接口的思想
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

(6) new ClassPathXmlApplicationContext是ApplicationContext其中的一个实现类。

        //获取applicationContext;拿到spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

(7) 总之：我们彻底不用在程序中去改动代码，要实现不同的操作，只需在xml配置文件中进行修改；所谓的IOC就是一句话：对象由spring来创建、管理和装配。

四、IOC创建对象的方式

1. 使用无参构造创建对象,默认方式

    <bean id="user" class="com.sxsl.pojo.User">
        <property name="name" value="李维平"/>
    </bean>

2. 使用有参构造创建对象

<!--有参构造一：使用下标赋值创建对象-->
    <!--
    <bean id="user" class="com.sxsl.pojo.User">
        <constructor-arg index="0" value="lwp"/>
    </bean>
    -->

    <!--有参构造二：使用类型赋值创建对象，多个相同类型的参数就失灵，不建议使用-->
    <!--
    <bean id="user" class="com.sxsl.pojo.User">
       <constructor-arg type="java.lang.String" value="zwh"  />
    </bean>
    -->

    <!--有参构造三：直接通过参数名来设置-->
    <bean id="user" class="com.sxsl.pojo.User">
        <constructor-arg name="name" value="李维平zwh"/>
    </bean>

3.完整代码

(1) 编写实体类

package com.sxsl.pojo;

public class User {
    private String name;
    public User(String name ){
        this.name=name;
        System.out.println("User的有参构造创建对象！！");
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void show(){
        System.out.println("name="+name);
    }
}

(2) 编写beans.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--无参构造创建对象-->
    <!--
    <bean id="user" class="com.sxsl.pojo.User">
        <property name="name" value="李维平"/>
    </bean>
    -->

    <!--有参构造一：使用下标赋值创建对象-->
    <!--
    <bean id="user" class="com.sxsl.pojo.User">
        <constructor-arg index="0" value="lwp"/>
    </bean>
    -->

    <!--有参构造二：使用类型赋值创建对象，多个相同类型的参数就失灵，不建议使用-->
    <!--
    <bean id="user" class="com.sxsl.pojo.User">
       <constructor-arg type="java.lang.String" value="zwh"  />
    </bean>
    -->

    <!--有参构造三：直接通过参数名来设置-->
    <bean id="user" class="com.sxsl.pojo.User">
        <constructor-arg name="name" value="李维平zwh"/>
    </bean>

</beans>

(3) 编写测试代码

import com.sxsl.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user");
        user.show();
    }
}

4. 总结

(1) spring创建对象的方式：一种无参构造创建，三种有参构造创建。
(2) 在配置文件加载时,容器管理的对象就已经初始化了。

五、Spring配置

1. 别名

    <!--添加了别名，我们可以通过别名获取到对象-->
    <alias name="user" alias="ll"/>

2. bean的配置

    <!--
    id:bean的唯一标识符，相对于我们学过的对象名
    class：bean对象所对用的全限定名，包名+类名
    name：别名，可以同时取多个别名
     -->
         <bean id="user" class="com.sxsl.pojo.User" name="user1,user2 u3">
        <constructor-arg name="name" value="李维平zwh"/>
    </bean>

3. import

import一般用于团队开发使用，它可以将多个配置文件导入合并一个，相同的bean以最后导入的为准。

六、依赖注入

1. 构造器注入

详见3种有参构造创建对象时，参数值的注入方式。

2. set方式注入

2.1 依赖注入

(1) 依赖：bean对象的创建依赖于容器。
(2) 注入：bean对象的所有属性，由容器来注入。

2.2 搭建环境

(1) 复杂类型

package com.sxsl.pojo;

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

(2) 真实测试对象

package com.sxsl.pojo;

import java.util.*;

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String ,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
。。。。//get/set方法
}

(3) beans.xml：点击右上角弹出的“configure application context ”

<?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">
    <!--定义一个复杂注入类型的类-->
    <bean id="address" class="com.sxsl.pojo.Address">
        <property name="address" value="重庆市万州区"/>
    </bean>

    <bean id="student" class="com.sxsl.pojo.Student">
        <!--第一种：普通值注入，value=-->
        <property name="name" value="李维平"/>
        <!--第二种：bean注入，ref=-->
        <property name="address" ref="address"/>
        <!--第三种：数组注入-->
        <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="111111111122222222"/>
                <entry key="银行卡" value="4564212440014125"/>
            </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="driver">20210545</prop>
                <prop key="url">男</prop>
                <prop key="username">root</prop>
                <prop key="password">dwgslwp8</prop>
            </props>
        </property>
    </bean>
</beans>

(4) 编写测试类:MyTest.java

import com.sxsl.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());
        /*Student{
            name='李维平',
            address=Address{address='重庆市万州区'},
            books=[红楼梦, 西游记, 水浒传, 三国演义],
            hobbys=[听歌, 敲代码, 看电影],
            card={
                身份证=111111111122222222,
                银行卡=4564212440014125
            },
            games=[LOL, COC, BOB],
            wife='null',
            info={
                password=dwgslwp8,
                url=男,
                driver=20210545,
                username=root
            }
         }
        * */
    }
}

3. 扩展注入方式:

3.1 P命名空间

       xmlns:p="http://www.springframework.org/schema/p"
    <!--P命名空间注入：可以直接注入属性的值:property-->
    <bean id="user" class="com.sxsl.pojo.User" p:name="李维平" p:age="28"  />

3.2 C命名空间

       xmlns:c="http://www.springframework.org/schema/c"
    <!--C命名空间注入：通过构造器注入,constructs-args -->
    <bean id="user1" class="com.sxsl.pojo.User" c:age="32" c:name="lwp"/>

3.3 完整代码

(1) 实体类：

package com.sxsl.pojo;

public class User {
    private String name;
    private int age;
。。。//get、set、toString方法
}

(2) 配置文件userbeans.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
       https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--P命名空间注入：可以直接注入属性的值:property-->
    <bean id="user" class="com.sxsl.pojo.User" p:name="李维平" p:age="28"  />
    <!--C命名空间注入：通过构造器注入,constructs-args -->
    <bean id="user1" class="com.sxsl.pojo.User" c:age="32" c:name="lwp"/>

</beans>

(3) 测试代码

import com.sxsl.pojo.Student;
import com.sxsl.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());
    }    
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user = (User) context.getBean("user1");
        System.out.println(user.toString());
    }
}

3.4 注意点

C命名和P命名空间不能直接使用，需要导入xml约束。

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

4. bean的作用域

(1) 单例模式（Spring的默认模式）

    <bean id="user1" class="com.sxsl.pojo.User" c:age="32" c:name="lwp" scope="singleton"/>

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

<bean id="user1" class="com.sxsl.pojo.User" c:age="32" c:name="lwp" scope="prototype"/>

(3) 其余的request、session、application等，只有在web开发中才能用到。

七、bean的自动装配

1. 知识点

(1) 自动装配时Spring满足bean依赖的一种方式；Spring会在上下文中自动寻找，并自动给bean装配属性。
(2) Spring的三种装配方式：在XML中显式的配置（前面已经介绍），在Java中显式配置，隐式的自动装配bean【本节学习重点】。

2. 隐式的自动装配bean

2.1 搭建环境

(1) 创建实体类：一个人拥有一只猫和一条狗。

package com.sxsl.pojo;

public class Dog {
    public void shout(){
        System.out.println("wang ...!");
    }
}

package com.sxsl.pojo;

public class Cat {
    public void shout(){
        System.out.println("miao ...!");
    }
}

package com.sxsl.pojo;

public class People {
    private Cat cat;
    private Dog dog;
    private String name;
。。。//set/get/toString方法
}

(2) 编写配置文件：beans.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
       https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="cat" class="com.sxsl.pojo.Cat"/>
    <bean id="dog234" class="com.sxsl.pojo.Dog"/>

    <!--
    ByName:会自动在容器的上下文中查找，和自己对象set方法后面的值想匹配的beanId
    ByType：会自动在容器的上下文中查找，和自己类型相同的bean，必须保证类型唯一，才自动装配
    -->
    <bean id="people" class="com.sxsl.pojo.People" autowire="byType">
        <property name="name" value="lwp"/>
    </bean>

</beans>

(3) 编写测试程序，确保环境可用。

import com.sxsl.pojo.People;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Mytest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        People people = context.getBean("people", People.class);
        people.getDog().shout();
        people.getCat().shout();
    }
}

2.2 ByName自动装配

    <!--
    ByName:会自动在容器的上下文中查找，和自己对象set方法后面的值想匹配的beanId
    -->
    <bean id="people" class="com.sxsl.pojo.People" autowire="byName">
        <property name="name" value="lwp"/>
    </bean>

2.3 ByType自动装配

    <!--
    ByName:会自动在容器的上下文中查找，和自己对象set方法后面的值想匹配的beanId
    ByType：会自动在容器的上下文中查找，和自己类型相同的bean，必须保证类型唯一，才自动装配
    -->
    <bean id="people" class="com.sxsl.pojo.People" autowire="byType">
        <property name="name" value="lwp"/>
    </bean>

2.4 小结

byname：保证所有bean的id唯一，且该bean与自动注入属性的set方法的值一致。
bytype：保证所有bean的class唯一，且该bean与自动注入属性的类型一致。

3. 使用注解实现自动装配

JDK1.5以上，Spring2.5以上支持注解
The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

3.1注解使用须知

(1) 导入约束context约束
(2) 配置注解的支持 context:annotation-config/【容易忘掉】

<?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.2 使用注解步骤

(1) 修改beans.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"
       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/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/context/spring-aop.xsd">

       <!--开启注解的支持-->
       <context:annotation-config/>
       <bean id="cat" class="com.sxsl.pojo.Cat"/>
       <bean id="dog" class="com.sxsl.pojo.Dog"/>
       <bean id="people" class="com.sxsl.pojo.People"/>

</beans>

(2) @Autowired

import org.springframework.beans.factory.annotation.Autowired;

public class People {
    //Autowired显式定义了required = false，说明这个属性可以为null，否则不能为空
    @Autowired(required = false)
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;
。。。//get、set、toString方法略
}

3.3 小结

(1) 直接在属性上使用即可，也可在set方法前使用。
(2) 使用Autowired我们可以不用编写set方法，前提是你这个自动装载的属性在IOC（Spring）容器中存在，且符合ByName规范。
(3) @Nullable:字段标记了这个注解，说明这个字段可以为null。
(4) 如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成自动装配的时候，我们可以使用 @Qualifier(value=“XXX”)去配合【@Autowired】的使用，指定一个唯一的bean对象注入。

public class People {
   //Autowired显式定义了required = false，说明这个属性可以为null，否则不能为空
    @Autowired(required = false)
    private Cat cat;
    @Autowired
    @Qualifier(value="dog11")
    private Dog dog;
    private String name;
 }

(5) @Resource注解：也能实现自动加载，功能更强大

public class People {
    //@Resource也能实现自动加载，功能更强大，先ByName,匹配不到再ByType。
    @Resource
    private Cat cat;
    @Resource(name="dog11")
    private Dog dog;
    private String name;

(6) @Resource与@Autowired对比
都是用于自动装载，均可放在属性字段上。
@Autowired通过ByType方式实现；必须要求该对象存在，无法匹配时可以与 @Qualifier(value = “cat23”)配合使用。
@Resource先通过ByName匹配，如果找不到名字，再用ByType来匹配；如果两种方式均匹配不到报错，可通过name="XXX"进行指定匹配。
执行顺序不同：@Autowired通过ByType方式实现，@Resource通过ByName实现。

八、使用注解开发

1. bean

package com.sxsl.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

//等价于 <bean id="user" class="com.sxsl.pojo.User"/>
//Component组件，注解后该class作为spring容器的一个组件，自动加载
@Component
public class User {
    public String name="lwp";
}

2. 属性如何注入

package com.sxsl.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

//等价于 <bean id="user" class="com.sxsl.pojo.User"/>
//Component组件
@Component
public class User {

    /*相当于下列代码
    <bean id="user" class="com.sxsl.pojo.User">
        <property name="name" value="lwp"/>
    </bean>
    * */
    public String name;
    @Value("lwp")
    public void setName(String name) {
        this.name = name;
    }
}

3. 衍生的注解

@Component的有几个衍生注解，我们在web开发中会安装MVC三层架构分层
(1) dao 【@Repository】
(2) service 【@Service】
(3) controller 【@Controller】
(4) 这4个注解功能都是一样的，都是代表将某个类注册到spring容器中，实现bean的自动装配。

4. 自动装载配置

@Autowired：自动装配，通过类别或名字；如果Autowired不能唯一装配上属性，则需要通过@Qualifier(value = "XXXX")来指定。
@Nullable：字段标记这个注解，说明这个字段可以为null。
@Resource：自动装配通过名字或类别。

5. 作用域

@Scope("singleton" )
public class User {
}

6. 小结

(1) xml与注解：XML更加万能适用于任何场所，维护简单方便；注解不是自己的类使用不了，维护相对复杂。
(2) xml与注解的最佳实践：xml负责管理bean；注解只负责属性的注入。
(3) 我们在使用过程中，唯一注意的问题：必须让注解生效，需要开启注解的支持。

    <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.sxsl"/>
    <!--开启注解的支持-->
    <context:annotation-config/>

(4) 在spring4之后要使用注解开发必须保证aop的包已导入,使用注解需要导入context约束，增加注解的支持。

九、使用Java方式配置spring

1. ApplicationContext的实现类

2. java配置spring的步骤

2.1 配置类

package com.sxsl.config;

import com.sxsl.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;

//这个注解也会被容易接管，注册到容器中，因为它本来就是一个@Component；
// @Configuration 代表这是一个配置类,其作用就与以前的beans.xml作用一样。
@Configuration
@ComponentScan("com.sxsl.pojo")
@Import(LwpConfig2.class) //可以导入其他配置类，类似于多个xml配置文件的合并
public class LwpConfig {
    //这个注解，注册一个bean，相当于在XML配置文件中写了一个bean标签<bean id="" class=""/>;
    //这个方法的名字getUser就相当于bean标签中的id;
    //这个方法的返回值User就相当于bean标签中的class属性值。
    @Bean
    public User getUser(){
        return new User();//就是返回要注入到spring中的对象
    }

}

2.2 需要加载到spring中的实体类

package com.sxsl.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Conditional;
import org.springframework.stereotype.Component;

//这个注解的意思是这个类被spring接管了，注册到了容器中
@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }

    @Value("lwp")//属性注入值
    public void setName(String name) {
        this.name = name;
    }

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

2.3 测试类

import com.sxsl.config.LwpConfig;
import com.sxsl.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(LwpConfig.class);
        User user = (User) context.getBean("getUser");
        System.out.println(user.getName());
    }
}

3. 小结

(1) 我们现在完全不适用Spring的xml来配置，全权交给java来做；JavaConfig是Spring的一个子项目，在spring4之后它成为已个核心功能。
(2) 这种纯Java的方式在springboot中随处可见。

十、代理模式

1. 代理模式的分类：

(1) 静态代理
(2) 动态代理

2. 静态代理

2.1 角色分析：

(1) 抽象角色：一般会采用抽象类或接口来实现。
(2) 真实角色：被代理的角色。
(3) 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作。
(4) 客户：访问代理对象的人。

2.2 代理模式的好处：

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

2.3 缺点：

一个真实角色将对应一个代理角色，代码量会翻倍，开发效率将变低。

2.4 代码：

(1) 接口：

package com.sxsl.demo01;

//租房的接口
public interface Rent {
    public void rent();
}

(2) 真实角色：

package com.sxsl.demo01;

//房东
public class Host implements Rent {

    public void rent() {
        System.out.println("房东要出租房！！");
    }
}

(3) 代理角色：

package com.sxsl.demo01;

public class Proxy {
     private Host host;

     public Proxy() {
        }

    public Proxy(Host host) {
        this.host = host;
    }

    public void rent() {
         seeHouse();
         host.rent();
         heTong();
         fare();
    }
    //看房
    public void seeHouse(){
        System.out.println("中介带你看房！！");
    }
    //签租赁合同
    public void heTong(){
        System.out.println("签租赁合同！！");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费！！");
    }
}

(4) 客户端访问代理角色：

package com.sxsl.demo01;

public class Client {
    public static void main(String[] args) {
        //房东出租房子
        Host host = new Host();
        //代理：中介帮房东租房子，代理角色一般会有附属操作
        Proxy proxy = new Proxy(host);
        //你不用面对房东，直接找中介租房即可
        proxy.rent();
    }
}

2. 5 加深理解

(1) 接口：

package com.sxsl.demo02;

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

(2) 真实对象：

package com.sxsl.demo02;

//真实对象
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 query() {
        System.out.println("查询到一个用户！！");
    }
}

(3) 代理对象：增加了日志功能

package com.sxsl.demo02;

public class UserServiceProxy implements UserService {

    private  UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    public void add() {
        log("add");
        userService.add();
    }

    public void delete() {
        log("delete");
        userService.delete();
    }

    public void update() {
        log("update");
        userService.update();
    }

    public void query() {
        log("query");
        userService.query();
    }
    //日志方法
    public void log(String msg){
        System.out.println("[debug]使用了"+msg+"方法");
    }
}

(4) 客户端访问代理对象：

package com.sxsl.demo02;

public class Clent {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();

        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);
        proxy.add();
        proxy.delete();
    }
}

2.6 聊聊AOP

3. 动态代理

3.1 角色分析

(1) 动态代理的角色与静态代理角色一样。
(2) 动态代理的代理类是动态生成的，不是我们直接写好的。
(3) 动态代理分为两大类：基于接口的动态代理、基于类的动态代理。
接口的动态代理：JDK动态代理【我们在这里使用】
类的动态代理：cglib
java字节码实现：javassist

3.2 两个重要的类

(1) Proxy(代理)
(2) InvocationHandler(调用处理程序)

3.3 实现代码

(1) 接口

package com.sxsl.demo04;

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

(2) 真实对象：

package com.sxsl.demo04;

//真实对象
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 query() {
        System.out.println("查询到一个用户！！");
    }
}

(3) 万能动态类生成器：

package com.sxsl.demo04;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//等会我们会用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {


    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    //处理代理实例,并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        //动态代理的本质就是使用反射机制实现
        Object result = method.invoke(target, args);
        return result;
    }
    //增加一个日志的功能
    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

(4) 客户端访问

package com.sxsl.demo04;

import com.sxsl.demo04.UserServiceImpl;
import com.sxsl.demo04.ProxyInvocationHandler;
import com.sxsl.demo04.UserService;

public class Clint {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();

        //代理角色：目前还没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象
        //设置要代理的对象
        pih.setTarget(userService);
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();//这里的proxy是动态生成的代理，我们并没有写
        proxy.add();
        proxy.update();
    }
}

3.4 动态代理的优点：

(1) 可以使真实角色的操作更加纯粹，不用关注一些公共的业务。
(2) 公共业务交给代理角色，实现了业务的分工。
(3) 公共业务发生扩展时，方便集中管理。
(4) 一个动态代理类代理的是一个接口，一般就是对应的一类业务一个
(5) 一个动态代理类可以代理多个类，只要是实现了同一个接口即可。

十一、AOP

1. 什么是AOP

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

1.1 以增加日志为例显示AOP实现原理

1.2 专业术语

1.3 Advice的种类

2. Spring实现Aop

2.1 导入依赖包pom.xml

(1) 父pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sxsl</groupId>
    <artifactId>spring-study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>spring-01-ioc1</module>
        <module>spring-02-hellospring</module>
        <module>spring-03-ioc2</module>
        <module>spring-04-di</module>
        <module>spring-05-autowired</module>
        <module>spring-06-anno</module>
        <module>spring-07-appconfig</module>
        <module>spring-08-proxy</module>
        <module>spring-09-aop</module>
    </modules>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.5</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

(2) 子pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring-study</artifactId>
        <groupId>com.sxsl</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-09-aop</artifactId>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>

</project>

2.2 核心配置文件applicationContext.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"
       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-->
    <bean id="userService" class="com.sxsl.service.UserServiceImpl"/>
    <bean id="log" class="com.sxsl.log.Log"/>
    <bean id="afterLog" class="com.sxsl.log.AfterLog"/>

    <!--配置aop,需要导入aop的约束-->
    <!--方式一：使用原声Spring API接口-->
    <aop:config>
        <!--切入点：表达式execution(要执行的位置   * * * * *)-->
	   <!--5个位置对应   *（返回值）  *（类名） *（方法名） *（参数）)-->
        <aop:pointcut id="pointcut" expression="execution(* com.sxsl.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加！！-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog"  pointcut-ref="pointcut"/>
    </aop:config>

</beans>

2.3 service接口及其实现类

(1) 、UserService.java接口类

package com.sxsl.service;

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

(2) UserServiceImpl.java实现类

package com.sxsl.service;

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("查询了一个用户！！");
    }

}

2.4 需要插入的日志类

(1) Log.java

package com.sxsl.log;

import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.lang.Nullable;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {

    //method:要执行目标对象的方法，
    //args：参数
    //target：目标对象
    public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行！！");
    }
}

(2) AfterLog.java

package com.sxsl.log;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.lang.Nullable;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice{
    //returnValue：返回值
    public void afterReturning(@Nullable Object returnValue, Method method, Object[] agrs, @Nullable Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}

2.5 测试类

import com.sun.org.apache.xpath.internal.CachedXPathAPI;
import com.sxsl.service.UserService;
import com.sxsl.service.UserServiceImpl;
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();
    }
}

3. 三种实现方式

3.1 方式一：使用Spring的api接口，【主要由Spring Api接口实现】

完整步骤见第2点。

3.2 方式二：自定义来实现AOP【主要是切片定义】

(1) 相对于方式一，增加切片类及方法DivPointCut .java

package com.sxsl.div;

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

(2) 修改applicationContext.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"
       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/context https://www.springframework.org/schema/context/spring-context.xsd
       			   http://www.springframework.org/schema/aop  https://www.springframework.org/schema/aop/spring-aop.xsd">


<!--注册bean-->
<bean id="userService" class="com.sxsl.service.UserServiceImpl"/>
<bean id="log" class="com.sxsl.log.Log"/>
<bean id="afterLog" class="com.sxsl.log.AfterLog"/>

    <!---->
    <!--&lt;!&ndash;配置aop,需要导入aop的约束&ndash;&gt;-->
    <!--&lt;!&ndash;方式一：使用原声Spring API接口&ndash;&gt;-->
    <!--<aop:config>-->
    <!--&lt;!&ndash;切入点：表达式execution(要执行的位置)&ndash;&gt;-->
    <!--<aop:pointcut id="pointcut" expression="execution(* com.sxsl.service.UserServiceImpl.*(..))"/>-->
    <!--&lt;!&ndash;执行环绕增加！！&ndash;&gt;-->
    <!--<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>-->
    <!--<aop:advisor advice-ref="afterLog"  pointcut-ref="pointcut"/>-->
    <!--</aop:config>-->


    <!--方式二：自定义类-->
    <bean id="div" class="com.sxsl.div.DivPointCut"/>
    <aop:config >
        <!--自定义切片，ref要引用的类-->
        <aop:aspect ref="div" >
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* com.sxsl.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>

        </aop:aspect>
    </aop:config>
</beans>

3.3 使用注解实现

(1) 相对于方式一，增加一个注解类

package com.sxsl.div;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

//使用注解方式实现aop
@Aspect //标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.sxsl.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("-------方法执行前--------");
    }
    @After("execution(* com.sxsl.service.UserServiceImpl.*(..))")
        public void after(){
        System.out.println("-------方法执行后--------");
    }
    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理的切入点
    @Around("execution(* com.sxsl.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
//        Signature signature = jp.getSignature();//获得签名
//        System.out.println(signature);
        // 执行方法
        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }
}

(2) 修改applicationContext.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"
       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/context https://www.springframework.org/schema/context/spring-context.xsd
       			   http://www.springframework.org/schema/aop  https://www.springframework.org/schema/aop/spring-aop.xsd">


<!--注册bean-->
<bean id="userService" class="com.sxsl.service.UserServiceImpl"/>
<bean id="log" class="com.sxsl.log.Log"/>
<bean id="afterLog" class="com.sxsl.log.AfterLog"/>

<!---->
<!--&lt;!&ndash;配置aop,需要导入aop的约束&ndash;&gt;-->
<!--&lt;!&ndash;方式一：使用原声Spring API接口&ndash;&gt;-->
<!--<aop:config>-->
<!--&lt;!&ndash;切入点：表达式execution(要执行的位置)&ndash;&gt;-->
<!--<aop:pointcut id="pointcut" expression="execution(* com.sxsl.service.UserServiceImpl.*(..))"/>-->
<!--&lt;!&ndash;执行环绕增加！！&ndash;&gt;-->
<!--<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>-->
<!--<aop:advisor advice-ref="afterLog"  pointcut-ref="pointcut"/>-->
<!--</aop:config>-->


<!--&lt;!&ndash;方式二：自定义类&ndash;&gt;-->
<!--<bean id="div" class="com.sxsl.div.DivPointCut"/>-->
<!--<aop:config >-->
    <!--&lt;!&ndash;自定义切片，ref要引用的类&ndash;&gt;-->
    <!--<aop:aspect ref="div" >-->
        <!--&lt;!&ndash;切入点&ndash;&gt;-->
        <!--<aop:pointcut id="point" expression="execution(* com.sxsl.service.UserServiceImpl.*(..))"/>-->
        <!--&lt;!&ndash;通知&ndash;&gt;-->
        <!--<aop:before method="before" pointcut-ref="point"/>-->
        <!--<aop:after method="after" pointcut-ref="point"/>-->

    <!--</aop:aspect>-->
<!--</aop:config>-->

    <!--方式三：使用注解-->
    <bean id="annotationPointCut" class="com.sxsl.div.AnnotationPointCut"/>
    <!--开启注解支持 jdk(expose-proxy="false"),cglib(expose-proxy="true")-->
    <aop:aspectj-autoproxy expose-proxy="false"/>

</beans>

十二、 整合Mybatis

1. 步骤

1.1 导入相关的jar包

(1) 包名列表

1.2 项目配置文件：依赖包的导入

(1) 父pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sxsl</groupId>
    <artifactId>spring-study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>spring-01-ioc1</module>
        <module>spring-02-hellospring</module>
        <module>spring-03-ioc2</module>
        <module>spring-04-di</module>
        <module>spring-05-autowired</module>
        <module>spring-06-anno</module>
        <module>spring-07-appconfig</module>
        <module>spring-08-proxy</module>
        <module>spring-09-aop</module>
        <module>spring-10-mybatis</module>
    </modules>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.5</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

(2) 子pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring-study</artifactId>
        <groupId>com.sxsl</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-10-mybatis</artifactId>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</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.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.4</version>
        </dependency>
        <!--spring操作数据库，还需要spring-jdbc包-->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.4</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</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>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
    </dependencies>

    <!--maven静态资源过滤-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

</project>

2. 回忆mybatis步骤

(1) 编写实体类

package com.sxsl.pojo;

import lombok.Data;
import org.omg.CosNaming.NamingContextExtPackage.StringNameHelper;

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

(2) 编写核心配置文件

<?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核心配置-->
<configuration>

    <!--引入外部配置文件，当外部文件和property 均有一个属性赋值时优先使用外部配置文件-->
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="dwgslwp8"/>
    </properties>
    <typeAliases>
        <package name="com.sxsl.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="${driver}" />
                <property name="url" value="${url}" />
                <property name="username" value="${username}" />
                <property name="password" value="${password}" />
            </dataSource>
        </environment>
    </environments>
    <!--每一个mapper.xml文件都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper class="com.sxsl.mapper.UserMapper"/>
    </mappers>
</configuration>

(3) 编写接口

package com.sxsl.mapper;

import com.sxsl.pojo.User;

import java.util.List;

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

(4) 编写UserMapper .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">
<!--configuration核心配置-->
<mapper namespace="com.sxsl.mapper.UserMapper">
    <select id="selectUser"  resultType="user">
        select * from Mytabis.user;
    </select>
</mapper>

(5) 测试

import com.sxsl.mapper.UserMapper;
import com.sxsl.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MyTest {
    @Test
    public void test() throws IOException {
        String resources="mybatis-config.xml";
        InputStream in = Resources.getResourceAsStream(resources);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.selectUser();
        for (User user : users) {
            System.out.println(user);
        }
    }
}

3. mybatis-spring：

中文帮助文档来源：http://mybatis.org/spring/zh/index.html

3.1 编写数据源:Spring的通用配置spring-dao.xml

   <!--
        DataSource，使用Spring的数据源替换Mybatis的配置 c3p0 dbcp drvid
        这里用Spring提供的jdbc:先导入依赖spring-jdbc
        注意：“&”必须要用“&amp;”即转义字符
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://192.168.0.100:3306/Mytabis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="dwgslwp8"/>
    </bean>

3.2 SqlSessonFactory:Spring的通用配置spring-dao.xml

    <!--SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--绑定mybatis配置文件,项目不同这儿要根据项目调整，除此之外其余均固定，项目中需要注入其他类放在applicationContext.xml文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/sxsl/mapper/*.xml"/>
    </bean>

3.3 SqlSessonTemplate:Spring的通用配置spring-dao.xml

    <!--SqlSessionTemplate:就是我们使用的sqlSession-->
    <bean id="sqlSession"  class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能采用构造器注入，因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

3.4 需要给接口加实现类

import java.util.List;

//原来的操作，我们使用SQLSession来执行，现在都使用SqlSessionTemplate（模板）来执行
public class UserMapperImpl implements UserMapper {
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return  mapper.selectUser();
    }
}

3.5 将自己写的实现类注入spring中，applicationContext.xml

    <bean id="userMapper" class="com.sxsl.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

3.5 测试

import com.sxsl.mapper.UserMapper;
import com.sxsl.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;

public class MyTest {
    @Test
    public void test() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }
}

3.6 完整实现代码

(1) 项目配置文件：pom.xml
父pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sxsl</groupId>
    <artifactId>spring-study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>spring-01-ioc1</module>
        <module>spring-02-hellospring</module>
        <module>spring-03-ioc2</module>
        <module>spring-04-di</module>
        <module>spring-05-autowired</module>
        <module>spring-06-anno</module>
        <module>spring-07-appconfig</module>
        <module>spring-08-proxy</module>
        <module>spring-09-aop</module>
        <module>spring-10-mybatis</module>
    </modules>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.5</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

子pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring-study</artifactId>
        <groupId>com.sxsl</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-10-mybatis</artifactId>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</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.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.4</version>
        </dependency>
        <!--spring操作数据库，还需要spring-jdbc包-->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.4</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</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>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
    </dependencies>

    <!--maven静态资源过滤-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

</project>

(2) 实体类

package com.sxsl.pojo;

import lombok.Data;
import org.omg.CosNaming.NamingContextExtPackage.StringNameHelper;

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

(3) mapper接口类

package com.sxsl.mapper;

import com.sxsl.pojo.User;

import java.util.List;

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

(4) mapper接口类的实现类【相对与mybatis实现方式是新增的】

import com.sxsl.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

//原来的操作，我们使用SQLSession来执行，现在都使用SqlSessionTemplate（模板）来执行
public class UserMapperImpl implements UserMapper {
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return  mapper.selectUser();
    }
}

(5) UserMapper.xml配置对应UserMapper.java接口中的数据库操作方法

<?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">
<!--configuration核心配置-->
<mapper namespace="com.sxsl.mapper.UserMapper">
    <select id="selectUser"  resultType="user">
        select * from Mytabis.user;
    </select>
</mapper>

(6) 通用spring-dao.xml配置文件，通过spring整合mybatis操作数据的通用配置，不同项目配置基本固定

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

    <!--
        DataSource，使用Spring的数据源替换Mybatis的配置 c3p0 dbcp drvid
        这里用Spring提供的jdbc:先导入依赖spring-jdbc
        注意：“&”必须要用“&amp;”即转义字符
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://192.168.0.100:3306/Mytabis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="dwgslwp8"/>
    </bean>
    <!--SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--绑定mybatis配置文件,项目不同这儿要根据项目调整，除此之外其余均固定，项目中需要注入其他类放在applicationContext.xml文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/sxsl/mapper/*.xml"/>
    </bean>
    <!--SqlSessionTemplate:就是我们使用的sqlSession-->
    <bean id="sqlSession"  class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能采用构造器注入，因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

</beans>

(7) 项目的配置文件applicationContext.xml，该文件导入spring-dao.xml、spring-MVC.xml等框架的配置，以及本项目专用的XXXXMapperImpl实现类的bean注入

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

    <import resource="spring-dao.xml"/>

    <bean id="userMapper" class="com.sxsl.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

</beans>

(8) 测试类

import com.sxsl.mapper.UserMapper;
import com.sxsl.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;

public class MyTest {
    @Test
    public void test() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }
}

4. mybatis-spring 第二中实现方式

4.1 思路

(1) 相对于第一种方式：UserMapper的实现类继承了抽象类SqlSessionDaoSupport，该类的getSqlSession直接得到一个方式一种的sqlSession（sqlSessionTemplate）。

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    public List<User> selectUser() {
        return  getSqlSession().getMapper(UserMapper.class).selectUser();
    }
}

(2) 在注册该实现类时，其属性设置sqlSessionFactory而非sqlSessionTemplate

    <bean id="userMapper2" class="com.sxsl.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

4.2 代码

(1) 实现类UserMapperImpl2.java

package com.sxsl.mapper;

import com.sxsl.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    public List<User> selectUser() {
        return  getSqlSession().getMapper(UserMapper.class).selectUser();
    }
}

(2) 注册实现类，注意于方式一的区别,applicationContext.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"
       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/context https://www.springframework.org/schema/context/spring-context.xsd
       			   http://www.springframework.org/schema/aop  https://www.springframework.org/schema/aop/spring-aop.xsd">

    <import resource="spring-dao.xml"/>
    <!--方式1：注入-->
    <bean id="userMapper" class="com.sxsl.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
    <!--方式2：注入-->
    <bean id="userMapper2" class="com.sxsl.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>

(3) 测试代码：只改动一处，将userMapper改为userMapper2

import com.sxsl.mapper.UserMapper;
import com.sxsl.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;

public class MyTest {
    @Test
    public void test() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }
}

十三、申明式事务

1. spring中事务的种类

1.1申明式事务：结合AOP实现事务的植入，在Spring-dao.xml文件中配置

(1) 导入事务约束：在Spring-dao.xml文件头中增加以下内容

xmlns:tx="http://www.springframework.org/schema/tx"
http://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx.xsd

(2) 配置声明式事务

    <!--配置声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="dataSource"/>
    </bean>

(3) 配置事务通知

<!--结合AOP实现事务的植入-->
    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给哪些方法配置事务,propagation事务的传播属性-->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="query" read-only="true" />
            <tx:method name="*" propagation="REQUIRED"  />
        </tx:attributes>
    </tx:advice>

(4) 配置事务切入点

    <!--配置事务切入点-->
    <aop:config >
        <aop:pointcut id="txPointCut" expression="execution(* com.sxsl.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>

1.2 编程式事务：需要在编程中实现代码的管理

2. 申明式事务代码实现

2.1 实体类

package com.sxsl.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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

2.2 mapper类的接口、实现类及配置文件

(1) 接口类：UserMapper.java

package com.sxsl.mapper;

import com.sxsl.pojo.User;
import java.util.List;

public interface UserMapper {
    List<User> selectUser();
    int addUser(User user);
    int deleteUser(int id);
}

(2) 实现类：UserMapperImpl.java

package com.sxsl.mapper;

import com.sxsl.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

//原来的操作，我们使用SQLSession来执行，现在都使用SqlSessionTemplate（模板）来执行
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> selectUser() {
        User user = new User(4, "赵六", "23434543");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.addUser(user);
        mapper.deleteUser(1);
        return  mapper.selectUser();
    }

    public int addUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).addUser(user);
    }

    public int deleteUser(int id) {
        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
    }
}

(3) mapper配置文件：UserMapper.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">
<!--configuration核心配置-->
<mapper namespace="com.sxsl.mapper.UserMapper">
    <select id="selectUser"  resultType="user">
        select * from user;
    </select>

    <insert id="addUser" parameterType="com.sxsl.pojo.User">
      <!--一定注意name、pwd字段的类型，为字符串一定要加""-->
        insert into user(id,name,pwd ) VALUES (${id},"${name}","${pwd}");
    </insert>
    <delete id="deleteUser"  parameterType="int">
        delete FROM Mytabis.user where id=#{id};
    </delete>
</mapper>

2.3 配置文件

(1) spring通用配置文件：Spring-dao.xml，引入mybatis控制文件，mybatis-config.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
       			   http://www.springframework.org/schema/aop  https://www.springframework.org/schema/aop/spring-aop.xsd
                 http://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--
        DataSource，使用Spring的数据源替换Mybatis的配置 c3p0 dbcp drvid
        这里用Spring提供的jdbc:先导入依赖spring-jdbc
        注意：“&”必须要用“&amp;”即转义字符
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://192.168.0.100:3306/Mytabis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="dwgslwp8"/>
    </bean>
    <!--SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--绑定mybatis配置文件,项目不同这儿要根据项目调整，除此之外其余均固定，项目中需要注入其他类放在applicationContext.xml文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/sxsl/mapper/*.xml"/>
    </bean>
    <!--SqlSessionTemplate:就是我们使用的sqlSession-->
    <bean id="sqlSession"  class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能采用构造器注入，因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <!--配置声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="dataSource"/>
    </bean>
    <!--结合AOP实现事务的植入-->
    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给哪些方法配置事务,propagation事务的传播属性-->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="query" read-only="true" />
            <tx:method name="*" propagation="REQUIRED"  />
        </tx:attributes>
    </tx:advice>
    <!--配置事务切入点-->
    <aop:config >
        <aop:pointcut id="txPointCut" expression="execution(* com.sxsl.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
</beans>

(2) mybatis配置文件: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核心配置-->
<configuration>

    <typeAliases>
        <package name="com.sxsl.pojo"/>
    </typeAliases>

</configuration>

(3) 项目配置文件：applicationContext.xml，引入spring配置文件spring-dao.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"
       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/context https://www.springframework.org/schema/context/spring-context.xsd
       			   http://www.springframework.org/schema/aop  https://www.springframework.org/schema/aop/spring-aop.xsd">

    <import resource="spring-dao.xml"/>

    <bean id="userMapper" class="com.sxsl.mapper.UserMapperImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>

2.4 测试代码

import com.sxsl.mapper.UserMapper;
import com.sxsl.mapper.UserMapperImpl;
import com.sxsl.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        List<User> userList = userMapper.selectUser();
        for (User user1 : userList) {
            System.out.println(user1);
        }
    }
}

2.5 项目依赖包

(1) 父pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sxsl</groupId>
    <artifactId>spring-study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>spring-01-ioc1</module>
        <module>spring-02-hellospring</module>
        <module>spring-03-ioc2</module>
        <module>spring-04-di</module>
        <module>spring-05-autowired</module>
        <module>spring-06-anno</module>
        <module>spring-07-appconfig</module>
        <module>spring-08-proxy</module>
        <module>spring-09-aop</module>
        <module>spring-10-mybatis</module>
        <module>spring-11-trans</module>
    </modules>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.5</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.8</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

(2) 子pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring-study</artifactId>
        <groupId>com.sxsl</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-11-trans</artifactId>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</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.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.4</version>
        </dependency>
        <!--spring操作数据库，还需要spring-jdbc包-->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.4</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</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>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <!-- 必须在idea的setting——>plugins下载lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
    </dependencies>

    <!--maven静态资源过滤-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

</project>