千锋2023课件62课spring

最新推荐文章于 2024-10-15 22:37:49 发布

源码头

最新推荐文章于 2024-10-15 22:37:49 发布

阅读量56

点赞数

分类专栏： java 文章标签： spring java 后端

本文链接：https://blog.csdn.net/sucaiwa/article/details/129850937

版权

java 专栏收录该内容

129 篇文章 57 订阅

订阅专栏

今日内容

0 复习昨日
1 AOP编程
2 注解实现AOP

0 复习昨日

1 ioc+di用注解实现,都用了哪些注解,什么作用

用于创建对象的: @Controller,@Service,@Repository,@Component
属性赋值
基本类型赋值@Value
引用类型赋值
按类型@Autowired
按名称@Resources
按名称@Autowired+@Qualifier

applicationContext.xml要扫描注解
从容器中获得对象,默认对象名是类名首字母小写

2 spring创建的对象默认是单例?多例?

默认是单例:singleton
也可以指定scope=prototype,多例

3 代理是什么?为什么需要代理?代理类型有几种?什么特点?

代理的是某个类;代理之后,就可以改变对象的访问方式
好处: 保护对象;对原有方法增强
类型: 静态和动态
区别
静态代理: 提前自己创建好,每个类都会有一个代理,这样不好,因为代理类越来越多,代码会有冗余
动态代理: 给定一个目标类,会运行时自动创建出代理

动态代理的类型
JDK: 目标类必须有接口,即只能代理接口
CGLIB: 目标类可以有接口,也可以没有接口,即可以代理接口也可以代理实现类
CGLIB动态代理,有时候也叫做字节码增强

4 什么是AOP

1 AOP

1.1 概念

Spring中另外一个核心功能,AOP

AOP(Aspect Oriented Programming),即面向切面编程.

OOP(Object Oriented Programming ),即面向对象编程.

AOP面向切面编程,利用一种称为"横切"的技术，剖开封装的对象内部，并将那些影响了 多个类的公共行为抽取出封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

在这里插入图片描述

面向切面编程的作用:就是将项目中与核心逻辑无关的代码横向抽取成切面类,通过织入作用到目标方法,以使目标方法执行前后达到增强的效果.

原理: AOP底层使用的就是动态代理,给AOP指定哪些类型(目标类)需要增强,就会产生对应的代理对象,代理对象执行方法前后会先执行增强的方法.

好处:减少系统的重复代码，降低模块之间的耦合度,便于维护,可以只关注核心业务

1.2 AOP术语

连接点(Joinpoint)：连接点是程序类中客观存在的方法，可被Spring拦截并切入内容。即每个方法在切入之前,都是连接点

切入点(Pointcut)：被Spring切入连接点。即真正会增强的目标方法

通知、增强(Advice)：可以为切入点添加额外功能，分为：前置通知、后置通知、异常通知、环绕通知等。

目标对象(Target)：被代理的目标对象

织入(Weaving)：把通知应用到具体的类，进而创建新的代理类的过程。

代理(Proxy)：被AOP织入通知后，产生的结代理类。

切面(Aspect)：由切点和通知组成，将横切逻辑织入切面所指定的连接点中。

1.3 应用场景

事务管理
后续spring管理事务用的AOP原理

权限校验
后期使用Spring Security注解开发时,其实利用了AOP思想

日志记录
性能检测
等等

1.4 AOP入门编程【重点】

需求: UserService以及UserServiceImpl,在其中方法执行前,后执行增强的方法

编程的过程:

创建项目
导入依赖
核心依赖
切面依赖

目标类
切面类
织入(配置文件设置)
测试

1.4.1导入依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.1.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

1.4.2 目标类

public interface UserService {

    void findUserById();

    void deleteUserById();

}

public class UserServiceImpl implements UserService {

    @Override
    public void findUserById() {

        System.out.println("核心业务---> 查询用户" );

    }
    @Override
    public void deleteUserById() {

        System.out.println("核心业务---> 删除用户" );

    }
}

1.4.3 切面类

演示的环绕通知

public class MyAspect {

    /**
     * 定义增强的方法:如果前后都要增强的方法
     * 那么就还使用环绕通知/增强
     */
    /**
     * 自定义环绕通知
     * @param joinPoint 连接点/切入点,即目标方法
     * @return 目标方法的返回值
     */
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 目标方法前:
        System.out.println("开启事务/权限校验" );

        // 目标方法执行
        Object ret = joinPoint.proceed( );
        System.out.println("目标方法返回值---> " + ret );
        // 目标方法后:
        System.out.println("提交事务/日志记录" );
        return ret;
    }

}

1.4.4 配置(织入)

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

    <!-- 目标类,UserService -->
    <bean id="userService" class="com.qf.service.impl.UserServiceImpl"/>

    <!-- 切面类 -->
    <bean id="myAspect" class="com.qf.aspect.MyAspect"/>

    <!-- 织入 -->
    <aop:config>
        <!-- 确定切面-->
        <aop:aspect ref="myAspect">
            <!-- 1确定通知/增强类型 -->
            <!-- 2确定切面中增强的方法 -->
            <!-- 3确定目标类以及目标方法
               execution(返回值类型 包路径.类名.方法名(参数))
               返回值类型任意,写 *
               包路径,写com.qf
               类名,UserServiceImpl,如果是所有类,写 *
               方法名,findUserById,如果是所有方法,写 *
               () 参数列表
               (..) 代表任意参数
            -->
            <aop:around method="myAround"
                        pointcut="execution(* com.qf.service.impl.*.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

1.4.5 测试

    @Test
    public void testAspect() {
        String path = "applicationContext.xml";
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(path);

        UserService userService = context.getBean("userService", UserService.class);
        userService.findUserById();

        System.out.println("-----------------" );

        userService.deleteUserById();
    }

开启事务/权限校验
核心业务---> 查询用户
目标方法返回值---> null
提交事务/日志记录
-----------------
开启事务/权限校验
核心业务---> 删除用户
目标方法返回值---> null
提交事务/日志记录

练习: 重复

完了之后,要再回头看昨天代理介绍,今天AOP介绍

1.5 其他增强【重点】

环绕通知: 目标方法执行前,后都有增强的方法(已经演示过)
常用于事务管理

前置通知
常用于权限检验

后置通知
常用于日志记录,或者释放资源

后置返回通知
常用于获得目标方法的返回值,处理返回值

异常通知
常用于代码有异常后去执行一些功能,处理异常

1.5.1 各种增强

package com.qf.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc
 */
public class MyAspect {

    /**
     * 定义增强的方法:如果前后都要增强的方法
     * 那么就还使用环绕通知/增强
     */

    /**
     * 自定义环绕通知
     * @param joinPoint 连接点/切入点,即目标方法
     * @return 目标方法的返回值
     */
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 目标方法前:
        System.out.println("开启事务/权限校验" );

        // 目标方法执行
        Object ret = joinPoint.proceed( );
        System.out.println("目标方法返回值---> " + ret );
        // 目标方法后:
        System.out.println("提交事务/日志记录" );
        return ret;
    }


    /**
     * 自定义前置通知
     * @param joinPoint,目标对象
     */
    public void myBefore(JoinPoint joinPoint) {
        // 目标对象
        Object target = joinPoint.getTarget( );
        System.out.println("target = " + target);
        // 获得目标方法签名(方法名)
        Signature signature = joinPoint.getSignature( );
        System.out.println("signature = " + signature);

        System.out.println("前置通知--->权限校验--->OK" );

        // 假设权限校验没有通过,通过抛出异常让代码停下,不再执行目标方法
        // System.out.println("前置通知--->权限校验--->ERROR" );
        // throw new RuntimeException("权限校验--->ERROR");
    }


    /**
     * 自定义后置通知
     */
    public void myAfter() {
        System.out.println("后置通知--->记录日志,释放资源" );
    }

    /**
     * 自定义后置返回通知
     * @param ret 用于接收目标方法返回的数据
     * @return
     */
    public Object myAfterRet(Object ret) {
        System.out.println("后置返回通知,接收到目标方法返回值--->" + ret);
        // 可以对返回的数据进行处理
        if (ret instanceof Integer) {
            Integer value = (Integer) ret;
            value *= 3;
            // 【BUG,返回值没有返回给目标方法】
            return value;
        }
        return ret;
    }

    public void myException(Exception e) {
        System.out.println("目标方法报的错---> " + e.getMessage());
    }
}

1.5.2 配置

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

    <!-- 目标类,UserService -->
    <bean id="userService" class="com.qf.service.impl.UserServiceImpl"/>
    <bean id="houseService" class="com.qf.service.impl.HouseServiceImpl"/>


    <!-- 切面类 -->
    <bean id="myAspect" class="com.qf.aspect.MyAspect"/>

    <!-- 织入 -->
    <aop:config>
        <!-- 确定切面-->
        <aop:aspect ref="myAspect">
            <!-- 1确定通知/增强类型 -->
            <!-- 2确定切面中增强的方法 -->
            <!-- 3确定目标类以及目标方法
               execution(返回值类型 包路径.类名.方法名(参数))
               返回值类型任意,写 *
               包路径,写com.qf
               类名,UserServiceImpl,如果是所有类,写 *
               方法名,findUserById,如果是所有方法,写 *
               () 参数列表
               (..) 代表任意参数
            -->
            <!--<aop:around method="myAround"
                        pointcut="execution(* com.qf.service.impl.*.*(..))"/>
            -->


            <!--<aop:before method="myBefore"
                        pointcut="execution(* com.qf.service.impl.*.*(..))"/>
            -->
            
            <!--<aop:after method="myAfter" pointcut="execution(* com.qf.service.impl.*.*(..))"/>-->

            <!--
                returning用来绑定目标方法执行后返回值,ret是myAfterRet方法的参数名
            -->
            <!--<aop:after-returning returning="ret" method="myAfterRet"
                                 pointcut="execution(* com.qf.service.impl.*.*(..))"/>-->

            <!-- throwing绑定目标方法抛出的异常,要传入给增强方法myException的参数 -->
            <aop:after-throwing throwing="e" method="myException" pointcut="execution(* com.qf.service.impl.*.*(..))"/>

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

</beans>

1.6 总结

通过AOP提供的编码流程，更便利的定制切面，更方便的定制了动态代理。
进而彻底解决了辅助功能(事务管理,日志记录,权限校验)冗余的问题；
业务类中职责单一性得到更好保障；
辅助功能也有很好的复用性。

1.7 AOP底层动态代理【面试】

AOP的底层使用的就是动态代理,使用的技术

jdk+cglib都用了

当目标类有接口的时候使用JDK动态代理
当目标类没有实现接口时,使用CGLIB动态代理

2 注解开发AOP【重点】

IOC,DI,AOP全部使用注解开发

注解	解释
@Aspect	声明类为切面类
@Around	环绕通知
@Before	前置通知
@After	后置通知
@AfterReturning	后置返回通知
@AfterThrowing	异常通知
@Pointcut	抽取切入点表达式

业务层类加注解@Service,@Autowired

重点是给切面类加注解

package com.qf.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc 切面
 */
@Component // 该注解,spring创建该类对象
@Aspect    // 该注解,该类是切面类
public class MyAspectAnno {

    /**
     * 定义一个切入点表达式公共方法
     */
    @Pointcut("execution(* com.qf.service.impl.*.*(..))")
    public void myPointcut(){}


    @Around("myPointcut()")
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 目标方法前:
        System.out.println("开启事务/权限校验" );

        // 目标方法执行
        Object ret = joinPoint.proceed( );
        System.out.println("目标方法返回值---> " + ret );
        // 目标方法后:
        System.out.println("提交事务/日志记录" );
        return ret;
    }

    @Before("myPointcut()")
    public void myBefore(JoinPoint joinPoint) {
        // 目标对象
        Object target = joinPoint.getTarget( );
        System.out.println("target = " + target);
        // 获得目标方法签名(方法名)
        Signature signature = joinPoint.getSignature( );
        System.out.println("signature = " + signature);

        System.out.println("前置通知--->权限校验--->OK" );

        // 假设权限校验没有通过,通过抛出异常让代码停下,不再执行目标方法
        // System.out.println("前置通知--->权限校验--->ERROR" );
        // throw new RuntimeException("权限校验--->ERROR");
    }

    @After("myPointcut()")
    public void myAfter() {
        System.out.println("后置通知--->记录日志,释放资源" );
    }

    @AfterReturning(value = "myPointcut()",returning = "ret")
    public Object myAfterRet(Object ret) {
        System.out.println("后置返回通知,接收到目标方法返回值--->" + ret);
        // 可以对返回的数据进行处理
        if (ret instanceof Integer) {
            Integer value = (Integer) ret;
            value *= 3;
            // 【BUG,返回值没有返回给目标方法】
            return value;
        }
        return ret;
    }

    @AfterThrowing(value = "myPointcut()",throwing = "e")
    public void myException(Exception e) {
        System.out.println("目标方法报的错---> " + e.getMessage());
    }
}

配置文件扫描注解,让注解生效

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


    <!-- 扫描IOC,DI注解 -->
    <context:component-scan base-package="com.qf"/>

    <!-- AOP开启自动代理,注解生效 -->
    <aop:aspectj-autoproxy/>

</beans>

测试即可

    @Test
    public void testAspectByAnno() {
        String path = "applicationContextAnno.xml";
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(path);
        // 使用注解,对象名,默认是类名首字母小写
        UserService userService = context.getBean("userServiceImpl", UserService.class);
        userService.findUserById();

        System.out.println("-----------------" );

        userService.deleteUserById();

        System.out.println("-----------------" );
        HouseService houseService = context.getBean("houseServiceImpl", HouseService.class);
        int i = houseService.deleteHouse( );
        System.out.println("i = " + i);
    }

3 Spring+Mybatis整合【重点】

Spring学完了,主要学习Spring两个内容:IOC+AOP

利用这两个知识来完成spring和mybatis的整合

IOC: 控制反转,用来创建对象
XxxService
通过数据源创建数据库连接
创建SqlSessionFactory
创建SqlSession
获得XxxMapper代理对象

AOP: 面向切面
控制事务

具体的整合思路

创建项目
导入依赖
spring依赖
aop依赖
mybatis依赖
数据库驱动依赖
连接池依赖
日志依赖
专业用于spring整合mybatis依赖
spring-jdbc依赖,用于Dao层支持

配置文件
spring配置文件
基本的IOC,DI扫描注解配置
加载配置文件
配置数据源
配置关于Mybatis

mybatis配置文件
db配置文件
log4j配置文件

具体的业务代码
UserService+UserServiceImpl
UserMapper.java+ UserMapper.xml

测试

3.1 创建项目

3.2 依赖

<?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.qf</groupId>
    <artifactId>day62_spring_mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.1.6.RELEASE</version>
        </dependency>

        <!-- spring支持Dao -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        <!-- spring整合mybatis专业包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>
    </dependencies>

    <build>
        <!--IDEA的maven项目中，默认源代码(java)目录下的xml等资源文件并不会在编译的时候一块打包进classes文件夹，而是直接舍弃掉。
            方法1：将xml或properties等配置文件放到resource下，并修改获取配置文件的代码，比如注册mapper.xml的位置等；
            方法2：在maven中添加过滤：将java下的xml过滤-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>*.xml</include><!-- 默认（新添加自定义则失效） -->
                    <include>**/*.xml</include><!-- 新添加 */代表1级目录 **/代表多级目录 -->
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

</project>

3.3 配置文件

3.3.1 db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/java2217?useSSL=false
jdbc.username=root
jdbc.password=123456
jdbc.initialSize=5
jdbc.maxActive=20
jdbc.minIdle=3
jdbc.maxWait=0
jdbc.timeBetweenEvictionRunsMillis=0
jdbc.minEvictableIdleTimeMillis=0

3.3.2 log4j.properties

# ERROR是级别
# 级别从低到高: debug,info,warn,error (日志信息从详细到简单)
# stdout: standard output的缩写,标准输出,其实就是输出到控制台
log4j.rootLogger=error

# 因为整个mybatis日志太多,可以指定只输出自己项目中指定位置的日志
log4j.logger.com.qf.mapper=debug,stdout


# 上面的stdout,是跟此处的stdout一样
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

3.3.3 mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!-- 交给spring配置的,这里可以删除 -->

    <settings>
        <!-- 设置使用log4j日志 -->
        <setting name="logImpl" value="LOG4J"/>
        <!-- 开启下划线转驼峰 -->
        <!-- 把数据库create_time,变成createTime列 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        
        <!-- 开启缓存(默认就是true) -->
        <setting name="cacheEnabled" value="true"/>
    </settings>

</configuration>

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

    <!-- 开启注解扫描 -->
    <context:component-scan base-package="com.qf"/>

    <!-- 1 加载db.properties配置文件-->
    <context:property-placeholder location="classpath:db.properties" />

    <!-- 2 创建数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="initialSize" value="${jdbc.initialSize}"/>
    </bean>

    <!-- 3 创建SqlSessionFactory -->
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 这些配置,如果再mybatis-config.xml中写过,这里就不要写 -->
        <property name="typeAliasesPackage" value="com.qf.model"/>\

        <property name="plugins">
            <set>
                <bean class="com.github.pagehelper.PageInterceptor">
                    <property name="properties">
                        <props>
                            <prop key="helperDialect">mysql</prop>
                        </props>
                    </property>
                </bean>
            </set>
        </property>

        <!-- 这些配置,也可以通过mybatis-config.xml-->
        <property name="configLocation" value="mybatis-config.xml"/>
    </bean>

    <!-- 4 扫描mapper,使mapper加入spring容器 -->
    <!-- mapper加入容器后,Service中就可以注入使用mapper -->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 此处是上面工厂的id -->
        <property name="sqlSessionFactoryBeanName" value="sessionFactory"/>

        <!-- 扫描Mapper,产生代理对象,加入spring容器 -->
        <property name="basePackage" value="com.qf.mapper"/>
    </bean>
</beans>

3.4 业务类

3.4.1 业务层

public interface UserService {
    User indUserById(int id);
}

@Service
public class UserServiceImpl implements UserService {

    // 注入Mapper
    @Autowired
    private UserMapper userMapper;


    @Override
    public User indUserById(int id) {
        return userMapper.findUserById(id);
    }
}

3.4.2 数据层

public interface UserMapper {

    User findUserById(int id);

}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.qf.mapper.UserMapper">
    <select id="findUserById" resultType="User">
        SELECT
            *
        FROM
            tb_user
        WHERE
            id = #{id}
    </select>
</mapper>

```

3.4 业务类

3.4.1 业务层

public interface UserService {
    User indUserById(int id);
}

@Service
public class UserServiceImpl implements UserService {

    // 注入Mapper
    @Autowired
    private UserMapper userMapper;


    @Override
    public User indUserById(int id) {
        return userMapper.findUserById(id);
    }
}

3.4.2 数据层

public interface UserMapper {

    User findUserById(int id);

}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.qf.mapper.UserMapper">
    <select id="findUserById" resultType="User">
        SELECT
            *
        FROM
            tb_user
        WHERE
            id = #{id}
    </select>
</mapper>