<bean id="person" class="wen.pojo.Person">
    <property id="name" value="天赐"/>
    <property id="matepad" ref="matepad"/>
    <property id="phone" ref="phone"/>
</bean>

1.2、ByName自动装配

<!--    byname：会自动在容器上下文中查找和自己对象set方法后面的值对应的bean id-->
<bean id="person" class="wen.pojo.Person" autowire="byName">
    <property id="name" value="天赐"/>
</bean>

1.3、ByType自动装配

<!--ByType：会自动在容器上下文中查找和自己对象属性类型相同的bean-->
<bean id="person" class="wen.pojo.Person" autowire="byType">
    <property name="name" value="小文"/>
</bean>

1.4、小结：

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

1.5、使用注解自动装配

使用注解注意事项：

导入约束：context约束
配置注解的支持：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>

1.5.1、@Autowired注解

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

可以不需要set方法，前提是自动装配的属性在IOC（Spring）容器中存在，且符合属性bytype。

public class Person {
    @Autowired
    private MatePad matepad;
    @Autowired
    private Phone phone;
    private String name;

    public MatePad getMatepad() {
        return matepad;
    }
    public Phone getPhone() {
        return phone;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{" +
            "matepad=" + matepad +
            ", phone=" + phone +
            ", name='" + name + '\'' +
            '}';
    }
}

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

例：

<bean id="matepad" class="wen.pojo.MatePad"/>
<bean id="matepad2" class="wen.pojo.MatePad"/>
<bean id="phone2" class="wen.pojo.Phone"/>
<bean id="phone" class="wen.pojo.Phone"/>
<bean id="person" class="wen.pojo.Person" p:name="天赐"/>

@Autowired
private MatePad matepad;
@Autowired
@Qualifier(value = "phone2") //两个组合在一起，选择指定一个唯一的bean对象注入
private Phone phone;
private String name;

1.5.2、@Resource注解

@Resource
private MatePad matepad;
@Resource(name = "phone2")
private Phone phone;
private String name;

1.5.3、小结

@Autowired与@Resource的区别：

都是用来自动装配的，都可以放在属性字段上
@Autowired 通过byType的方式实现，如果找不到，则通过byname实现，而且必须要求这个对象存在【常用】
@Resource默认通过byname的方式，如果找不到名字，则通过byType实现，如果两个都找不到的情况下，就报错【常用】
执行顺序不同：@Autowired通过byType的方式实现

2、使用注解开发

2.1、注解说明：

在Spring4之后，要用注解开发，必须要保证aop的包导入了

使用注解需要导入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"
       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:component-scan base-package="wen.pojo"/>
    <context:annotation-config/>
</beans>

2.2、属性如何注入

@Component
public class User {
    //相当于<property name="name" value="天赐"/>
    public String name;
    @Value("天赐")
    public void setName(String name) {
        this.name = name;
    }
}

2.3、衍生的注解

@Component 有几个衍生注解，在web开发中，会按照MVC三层架构分层

dao【@Repository】
service【@Service】
controller【@Controller】

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

2.4、自动装配置

@Autowired ：自动装配通过类型，名字，如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value="xxx")；
@Resource ：自动装配通过名字，类型；
@Nullable ：字段标记了这个注解，说明这个字段可以为null；
@Component ：组件，放在类上，说明这个类被Spring管理了，就是bean。

2.5、作用域

//等价于<bean id="user" class="wen.pojo.User"/>
//@Component 组件
@Component
@Scope("prototype") //原型模式：prototype 单例模式：singleton
public class User {
    //相当于<property name="name" value="天赐"/>
    public String name;
    @Value("天赐")
    public void setName(String name) {
        this.name = name;
    }
}

2.6、小结

xml与注解：

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

xml与注解的最佳实践：

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

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

<bean id="user" class="wen.pojo.User">
    <property name="name" value="天赐"/>
</bean>

3、使用Java的方式配置Spring

完全不用Spring的xml配置，全权交给Java来做。

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

实体类：

//@Component这个注解说明这个类被Spring接管了，注册到了容器中
@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }

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

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

配置文件：

//@Configuration也会被Spring注册到容器中，其本身就是@Component(在他的方法内)
//@Configuration代表这是一个配置类，就是applicationContext.xml
//也可以引入(import):@Import(src)
@Configuration
public class MyConfig {

    //注册一个bean，相当于xml里的一个bean标签
    //这个方法的名字相当于bean标签中的id属性
    //这个方法的返回值，相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();//返回要注入到bean的对象
    }
}

测试：

public class MyTest {
    public static void main(String[] args) {
        //如果完全使用了配置类方式去做，就只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        User getUser = context.getBean("getUser", User.class);
        System.out.println(getUser.toString());
    }
}

4、代理模式

代理模式就是SpringAOP的底层【SpringAOP和SpringMVC】

代理模式的分类：

静态代理
动态代理

4.1、静态代理

个人感觉就相当于service（服务层）层

角色分析：

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

代码步骤：

接口

//出租房屋
public interface Rent {
    public void rent();
}

2.真实角色

//房东
public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房屋");
    }
}

3.代理角色

//中介，代理
public class Proxy implements Rent{
    private Host host;
    public Proxy() {
    }
    public Proxy(Host host) {
        this.host = host;
    }
    @Override
    public void rent() {
        host.rent();
    }
    //看房
    public void seeHouse(){
        System.out.println("中介带你看房子");
    }
    //签合同
    public void hetong(){
        System.out.println("签合同");
    }
    //收中介费
    public void fee(){
        System.out.println("收中介费");
    }
}

4.客户端访问代理角色

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

代理模式的好处：

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

缺点：

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

4.2、加深理解

代码实现：

1.接口：

public interface UserService {
    //增、删、考、查
    public void add();
    public void delete();
    public void update();
    public void query();
}

2.业务步骤：

public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改一个用户");
    }

    @Override
    public void query() {
        System.out.println("查询一个用户");
    }
}

3.代理业务（不改变原有代码的基础上添加业务）

public class UserServiceProxy implements UserService{
    //相当于增加了一层！！！
    private UserServiceImpl userService;
    //set方法
    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }
    @Override
    public void add() {
        log("add");
        userService.add();
    }
    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }
    @Override
    public void update() {
        log("update");
        userService.update();
    }
    @Override
    public void query() {
        log("query");
        userService.query();
    }
    //日志方法
    public void log(String msg){
        System.out.println("使用了"+msg+"方法");
    }
}

4.客户端访问代理

public class Client{
    public static void main(String[] args) {
        //不改变原有代码的情况下扩展业务！！
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);

        proxy.add();
    }
}

简述AOP：

4.3、动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是直接写好的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口---JDK动态代理
- 基于类---cglib
- java字节码实现---javasist

需要了解两个类：Proxy，Invokation！！！！

Proxy：生成动态代理这个实例的(代理)
Invokation：是由代理实例的，调用处理程序实现的接口（处理代理实例，并返回结果）

动态代理的好处：

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

代码步骤：

1、ProxyInvocationHandler

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

//使用这个类时，会自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口(吧接口写成Object万能的)
    private Object target;

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

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

    //处理代理实例，并返回结果
    @Override
    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+"方法");
    }
}

2、客户端访问代理

public class Client {

    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色，使用方法自动创建
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.settarget(userService);//设置要代理的对象
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.add();
    }
}

5、AOP

5.1、什么是AOP

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

5.2、AOP在Spring中的作用

提供申明式事务：允许用户自定义切面

横切关注点：跨越应用程序多个模块的方法或功能。即使是与我们业务逻辑无关的，但却仍需关注的部分，就是横切关注点。如：日志，安全，缓存，事务等等。。。
切面(Aspect)：横切关注点被模块化的特殊对象，即它是一个类
通知(Advice)：切面必须要完成的工作。即它是类中的一个方法
目标(Target)：被通知对像
切入点(PointCut)：切面通知执行的“地点”的定义
连接点(JoinPoint)：与切入点匹配的执行点

SpringAOOP中，通过Advice定义横切逻辑，Spring中支持5中类型的Advice：

就是AOP在不改变原有代码的情况下去增加新的功能，和前面的代理模式一样的，只不过这个是通过Spring来执行的！！！

5.3使用Spring实现AOP

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

<dependencies>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
</dependencies>

5.3.1、方式一：使用Spring的API接口

【主要SpringAPI接口实现】

1、增加的方法（要切入的方法）

1.1、前置日志（log类）：

//前置日志
public class log implements MethodBeforeAdvice {
    //method:要执行的目标对象的方法
    //args：参数
    //target：目标对象
    @Override
    public void before(Method method, Object[] objects, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

1.2、后置日志（AfterLog类）：

//后置日志
public class AfterLog implements AfterReturningAdvice {
    //returnValue:返回值
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"返回结果为："+returnValue);
    }
}

2、接口

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

3、实现接口类

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

4、Spring配置文件（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: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">

    <!--注册bin-->
    <bean id="afterlog" class="com.wen.log.AfterLog"/>
    <bean id="log" class="com.wen.log.log"/>
    <bean id="userservice" class="com.wen.service.UserServiceImpl"/>

    <!--方式一：使用原生Spring API接口-->
    <!--配置AOP:需要导入AOP的约束-->
    <aop:config>
        <!--切入点:expression:表达式，execution(要执行的位置),需要在那个地方执行特定代码-->
        <!--execution(* com.wen.service.UserServiceImpl.*(..)):
        任意东西，给UserServiceImpl类插入携带任意参数的任意方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.wen.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/><!--将log这个类切入pointcut内-->
        <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

5、客户端实现

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        //动态代理的是接口(注意)
        UserService userservice = context.getBean("userservice",UserService.class);
        userservice.delete();
    }
}

6、测试结果

注：execution表达式详解：

在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut”切入点”

例如定义切入点表达式 execution (* com.wen.service.UserServiceImpl. *(..))

execution()是最常用的切点函数，其语法如下所示：

整个表达式可以分为五个部分：

1、execution(): 表达式主体。

2、第一个*号：表示返回类型， *号表示所有的类型（project、private.....）。

3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.wen.service.UserServiceImpl包、子孙包下所有类的方法。

4、第二个 * 号：表示类名，*号表示所有的类。

5、(..):最后这个星号表示方法名，号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数

详细内容可看：AspectJ的切入点表达式---execution表达式详解_大叔比较胖的博客-CSDN博客_execution

5.3.2、方式二：自定义实现AOP

【主要是切面定义】

1、自定义方法类

public class DipPointCut {
    public void before(){
        System.out.println("======任务开始前======");
    }
    public void after(){
        System.out.println("======任务开始后======");
    }
}

2、Spring配置

<!--方式二：自定义类-->
<bean id="diy" class="com.wen.diy.DipPointCut"/>
<bean id="userservice" class="com.wen.service.UserServiceImpl"/>

<aop:config>
    <!--自定义切面，ref表示要引用的类-->
    <aop:aspect ref="diy">
        <!--切入点-->
        <aop:pointcut id="point" expression="execution(* com.wen.service.UserServiceImpl.*(..))"/>
        <!--通知-->
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

3、客户端实现

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        //动态代理的是接口(注意)
        UserService userservice = context.getBean("userservice",UserService.class);
        userservice.delete();
    }
}

4、测试结果

5.3.3、方式三：使用注解实现

1、切面（AnnotationPointCut类）

@Aspect //标注这个类是一个切面
public class AnnotationPointCut {

    @Before("execution(* com.wen.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("======方法执行前======");
    }
    @After("execution(* com.wen.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("======方法执行后======");    //这个是最后执行了
    }

    //在环绕增强中，可以给定一个参数，代表要获取的切入的点
    @Around("execution(* com.wen.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前");  //先执行的这个，在执行proceed()，然后执行before...
        joinPoint.proceed();//相当于过滤器，执行方法
        System.out.println("环绕后");
    }
}

2、Spring配置

<!--方式三：使用注解（可以直接在java里使用@C）-->
<bean id="annotationPointCut" class="com.wen.diy.AnnotationPointCut"/>
<!--开启注解支持  JDK(默认 proxy-target-class="false") cglib(proxy-target-class="true")-->
<aop:aspectj-autoproxy/>

3、客户端实现

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        //动态代理的是接口(注意)
        UserService userservice = context.getBean("userservice",UserService.class);
        userservice.delete();
    }
}

4、测试结果

6、整合Mybatis

6.1、什么是Mybatis-Spring

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许 MyBatis 参与到 Spring 的事务管理之中，创建映射器 Mapper 和 SqlSession 并注入到 Bean 中，以及将 Mybatis 的异常转换为 Spring 的 DataAccessException。最终，可以做到应用代码不依赖于 MyBatis。

6.2、Mybatis-Spring需要版本条件

Mybatis-Spring	Mybatis	Spring框架	Spring Batch	Jva
2.0	3.5+	5.0+	4.0+	Java 8+
1.3	3.4+	3.2.2+	2.1+	Java 6+

6.3、快速上手

步骤：

1、导入相关jar包

要使用 MyBatis-Spring 模块，只需要在类路径下包含 mybatis-spring-2.0.6.jar 文件和相关依赖即可。

如果使用 Maven 作为构建工具，仅需要在 pom.xml 中加入以下代码即可：

junit
mybatis
mysql数据库
spring相关的
aop织入

mybatis-spring【new】

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

<dependencies>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.12</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.10</version>
    </dependency>
</dependencies>

<!--在build中配置resources，来防止资源导出失败的问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.xml</include>
                <include>**/*.properties</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
                <include>**/*.properties</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

2、实体类User

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

3、UserMapper接口定义方法

public interface UserMapper {
    //查询全部用户
    List<User> getUserList();
}

4、UserMapper.xmlSQL实现

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace:绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.wen.mapper.UserMapper">
    <!--这是一个查询语句-->
    <select id="getUserList" resultType="user">
        select * from mybatis.user
    </select>
</mapper>

5、因为是Spring所以要配置实现类UserMapperImpl

public class UserMapperImpl implements UserMapper{
    //用mybatis的时候是使用sqlSession进行操作的，但通过Spring使用的是SqlSessionTempLate
    private SqlSessionTemplate sqlSession;

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

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

6、Spring配置文件：spring-dao.xml

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

在 MyBatis-Spring 中，可使用 SqlSessionFactoryBean来创建 SqlSessionFactory。要配置这个工厂 bean，只需要把下面代码放在 Spring 的 XML 配置文件中：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!--
    数据源：
    DataSource:使用Spring的数据源替换Mybatis的配置：c3p0、druid
    这里使用Spring里的JDBC
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    <!--sqlSessionFatroy:可使用 SqlSessionFactoryBean来创建 SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--绑定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/><!--这里可以省略，但为了代码利于维护，在这个文件内可以只写setting和别名，如日志等-->
        <property name="mapperLocations" value="classpath:com/wen/mapper/*.xml"/>
    </bean>
    <!--SqlSessionTemplate:使用SqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFatory，因为没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <!--注册实现类-->
    <bean id="userMapper" class="com.wen.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

</beans>

7、mybatis配置文件mybatis-config.xml(一般放置setting设置和别名)

<?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>
    <!--设置-->
    <settings>
        <setting name="logImpl" value="Stdout_Logging"/>
    </settings>
    <!--别名-->
    <typeAliases>
        <package name="com.wen.pojo"/>
    </typeAliases>
</configuration>

8、测试

public class UserTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.getUserList()) {
            System.out.println(user);
        }
    }
}

9、结果

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@a530d0a] was not registered for synchronization because synchronization is not active
JDBC Connection [com.mysql.jdbc.JDBC4Connection@563f38c4] will not be managed by Spring
==>  Preparing: select * from mybatis.user 
==> Parameters: 
<==    Columns: id, name, pwd
<==        Row: 1, 老大, 123
<==        Row: 2, 老二, 456
<==        Row: 3, 老三, 789
<==      Total: 3
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@a530d0a]
User{id=1, name='老大', pwd='123'}
User{id=2, name='老二', pwd='456'}
User{id=3, name='老三', pwd='789'}

===============================================
Default Suite
Total tests run: 1, Passes: 1, Failures: 0, Skips: 0

10、项目结构

6.4、SqlSessionDaoSupport

1、SqlSessionDaoSupport 是一个抽象的支持类，用来为你提供 SqlSession。调用 getSqlSession() 方法你会得到一个 SqlSessionTemplate，之后可以用于执行 SQL 方法，就像下面这样:

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

这个过程就直接继承SqlSessionDaoSupport类，可以直接调用getSqlSession()方法获取sqlSession，且不用再写注入。

对于Spring的配置文件，在这里做了一个import处理，一个总的applicationContext.xml导入其它功能的配置文件如：spring-dao.xml

2、在applicationContext.xml中注册userMapper2实现类

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

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

    <!--注册实现类-->
    <bean id="userMapper" class="com.wen.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

    <!--注册实现类-->
    <bean id="userMapper2" class="com.wen.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>

如果使用SqlSessionDaoSupport，在spring-dao.xml配置中，只需要配置DataSource和sqlSessionFactory即可

3、测试

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

7、事务

一个使用 MyBatis-Spring 的其中一个主要原因是它允许 MyBatis 参与到 Spring 的事务管理中。而不是给 MyBatis 创建一个新的专用事务管理器，MyBatis-Spring 借助了 Spring 中的 DataSourceTransactionManager 来实现事务管理。

一旦配置好了 Spring 的事务管理器，你就可以在 Spring 中按你平时的方式来配置事务。并且支持 @Transactional 注解和 AOP 风格的配置。在事务处理期间，一个单独的 SqlSession 对象将会被创建和使用。当事务完成时，这个 session 会以合适的方式提交或回滚。

事务配置好了以后，MyBatis-Spring 将会透明地管理事务。这样在你的 DAO 类中就不需要额外的代码了。

7.1、什么是事务

完成一组业务，要么都成功，要么都失败
确保一致性和完整性

事务的ACID 原则：

原子性
一致性
隔离性
1. 多个业务可能操作同一个资源，防止数据损坏
持久性
1. 事务一旦提交，无论系统怎么样，结果不会被影响，都会被持久化地写入存储器中

7.2、创建事务

事务的创建只需要在spring-dao.xml中配置事务即可

要开启 Spring 的事务处理功能，在 Spring 的配置文件中创建一个 DataSourceTransactionManager 对象：

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

<!--结合AOP实现事务的织入-->
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!--给哪些方法配置事务-->
    <!--配置事务的传播特性： propagation="REQUIRED" required：支持当前事务，如果没有事务就新建一个事务。。。。。-->
    <tx:attributes>
        <tx:method name="add" propagation="REQUIRED"/> <!--给所有的add方法配置事务-->
        <tx:method name="*" propagation="REQUIRED"/><!--给所有的方法配置事务-->
    </tx:attributes>
</tx:advice>

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

7.3、案例

1、依赖导入（与整合mybatis的依赖一样）

2、实体类User（与整合mybatis的一样）

2、UserMapper接口方法定义一个insert和delete用于验证事务

public interface UserMapper {
    //查询全部用户
    List<User> getUserList();

    //添加用户
    int insertUser(User user);

    //删除用户
    int deleteUser(int id);
}

3、创建对应的UserMapper.xml并写相关的SQL

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace:绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.wen.mapper.UserMapper">
    <!--这是一个查询语句-->
    <select id="getUserList" resultType="user">
        select * from mybatis.user
    </select>

    <insert id="insertUser" parameterType="user">
        insert into user(id,name,pwd) values(#{id},#{name},#{pwd})
    </insert>

    <!--deletes是SQL出错-->
    <delete id="deleteUser" parameterType="int">
        deletes from user where id = #{id}
    </delete>
</mapper>

4、UserMapper的配置文件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>
<!--设置-->
<settings>
<setting name="logImpl" value="Stdout_Logging"/>
</settings>
<!--别名-->
<typeAliases>
<package name="com.wen.pojo"/>
</typeAliases>

</configuration>

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

    <!--
    数据源：
    DataSource:使用Spring的数据源替换Mybatis的配置：c3p0、druid
    这里使用Spring里的JDBC
    -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    <!--sqlSessionFatroy:可使用 SqlSessionFactoryBean来创建 SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--绑定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/><!--这里可以省略，但为了代码利于维护，在这个文件内可以只写setting和别名，如日志等-->
        <property name="mapperLocations" value="classpath:com/wen/mapper/*.xml"/>
    </bean>

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

    <!--结合AOP实现事务的织入-->
    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给哪些方法配置事务-->
        <!--配置事务的传播特性： propagation="REQUIRED" required：支持当前事务，如果没有事务就新建一个事务。。。。。-->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/> <!--给所有的add方法配置事务-->
            <tx:method name="*" propagation="REQUIRED"/><!--给所有的方法配置事务-->
        </tx:attributes>
    </tx:advice>

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

</beans>

注意：在配置事务通知时要修改头部的信息，改成tx

xmlns:tx="Index of /schema/tx"

Index of /schema/tx http://www.springframework.org/schema/tx/spring-cache.xsd

6、整合Spring配置文件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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

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

    <!--注册实现类-->
    <bean id="userMapper" class="com.wen.mapper.UserMapperImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>

7、方法实现类UserMapperImpl

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper{
    @Override
    public List<User> getUserList() {
        User user = new User(4, "老四", "456");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.insertUser(user);
        mapper.deleteUser(user.getId());

        return mapper.getUserList();
    }

    @Override
    public int insertUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).insertUser(user);
    }

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