星云-全栈知识体系

MyBatis入门案例

2024/1/7 MyBatis框架

在上一章节中我们从JDBC案例已经知道了如何连接数据库执行SQL语句，并获取数据，本章将采用MyBatis框架来完成同样的功能。

该章节所有源码：MyBatis-study案例源码 (opens new window)

# 1、需求分析

  • 从数据库中查询用户所有信息
  • 应用代码上区分三层架构
  • Dao层通过MyBatis框架方式实现

# 2、流程解析

整体请求流程图

  • 控制层只模拟调用Service方法，打印结果。
  • Service层通过调用MyBatis工具类创建数据库连接，并获取Dao层。
  • Dao层执行SQL并返回结果与PO实体类映射。

# 3、入门案例

MyBatis-study案例源码 (opens new window)

在开始前，IDEA先安装MyBatisX插件

数据库创建user表，并初始化数据

CREATE TABLE user (  
  id INT PRIMARY KEY,  
  username VARCHAR(50),  
  password VARCHAR(50),  
  email VARCHAR(100)  
);

INSERT INTO user (id, username, password, email) VALUES (1, 'zhangsan', '123456', '1685027245@126.com');
INSERT INTO user (id, username, password, email) VALUES (2, 'lsi', '123456', '1685027343@126.com');
1
2
3
4
5
6
7
8
9

# 3.1、项目结构

# 3.1、Maven依赖

创建Maven项目，并添加如下依赖

<?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.xygalaxy</groupId>
    <artifactId>MyBatis-study</artifactId>
    <version>1.0-SNAPSHOT</version>

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

    <dependencies>
        <!--  Spring  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.9</version>
        </dependency>
        <!-- mysql连接 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <!--  Mybatis  -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.11</version>
        </dependency>
        <!--  lombok简化实体  -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <!--   单元测试  -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

  • 加入Spring是为了简便流程，不用每次都new对象，当然该案例也可以作为Spring整合MyBatis的案例。
  • mysql-connector-java连接依赖是必须的。JDBC案例也是要依赖于该包。
  • MyBatis依赖是必须的。
  • lombok依赖是可选的，可以简化实体类的代码。
  • junit依赖是可选的，可以简化单元测试的代码。

# 3.2、MyBatisUtils工具类

MybatisUtils用于建立数据库连接，获取SqlSessionFactory，再获取SqlSession。

public class MybatisUtils{

    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            // 加载mybatis-config核心配置文件
            String resource = "config/mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            // 通过SqlSessionFactoryBuilder获取SqlSessionFactory
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //有了SqlSessionFactory --> 去获取SqlSession连接
    public static SqlSession getSession(){
        return sqlSessionFactory.openSession();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 3.3、UserPO实体类

@Data // 提供get和set方法
@AllArgsConstructor // 全构造
@NoArgsConstructor // 无参构造
public class UserPO implements Serializable {

    private Integer id;

    private String username;

    private String password;

    private String email;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 3.4、Dao层

public interface UserDao {

    List<UserPO> getUserList();

}
1
2
3
4
5
6

# 3.5、Service层

Service层及其实现

public interface UserService {
    List<UserPO> queryUserList();
}


@Service
public class UserServiceImpl implements UserService {

    /**
     * 这里做业务逻辑处理
     * @return
     */
    @Override
    public List<UserPO> queryUserList() {
        // 通过MybatisUtils获取SqlSession
        SqlSession session = MybatisUtils.getSession();
        UserDao userDao = session.getMapper(UserDao.class);
        // 获取Dao层，并调用SQL查询方法
        List<UserPO> userList = userDao.getUserList();
        // 关闭连接
        session.close();
        return userList;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 3.6、Controller层

public class UserController {

    /**
     * 这里做请求数据处理、返回结果处理
     */
    @Test
    public void testGetUserList(){
        // 获取Bean对象
        ApplicationContext ac = new AnnotationConfigApplicationContext(UserServiceImpl.class);
        UserServiceImpl userServiceImpl = (UserServiceImpl) ac.getBean("userServiceImpl");
        // 调用Service层方法
        List<UserPO> userList = userServiceImpl.queryUserList();
        System.out.printf("用户信息: "+userList);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 3.7、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">
<!--mybatis核心配置文件-->
<configuration>
    <!--配置环境-->
    <environments default="development">
        <environment id="development">
            <!--配置事务管理-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源(连接池)-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/xygalaxy?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 每一个mapper.xml都需要在这个配置，获取指定的Mapper.xml文件-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 3.8、UserMapper.xml映射文件

<?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.xygalaxy.dao.UserDao">
    <!--  select查询语句，id对应接口中的方法；resultType返回结果 -->
    <select id="getUserList" resultType="com.xygalaxy.pojo.UserPO">
        select * from user
    </select>
</mapper>
1
2
3
4
5
6
7
8
9
10
11

# 3.9、测试验证

测试打印结果

# 4、案例总结

# 4.1、mybatis-config.xml解析

MyBatis的核心配置文件。用于将SQL查询与Java对象进行映射。

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">
<!--mybatis核心配置文件-->
<configuration>
    <!--配置环境-->
    <environments default="development">
        <environment id="development">
            <!--配置事务管理-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源(连接池)-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/xygalaxy?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 每一个mapper.xml都需要在这个配置，获取指定的Mapper.xml文件-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

  • <configuration>标签：这是MyBatis配置文件的根元素。
  • <environments>标签：这个元素定义了多个环境，每个环境可以配置不同的数据库连接信息。 default="development"：这表示当没有明确指定环境时，会使用“development”环境。
  • <environment>标签：定义了一个具体的环境，ID为“development”。
  • <transactionManager>标签：指定事务管理器类型为“JDBC”。
  • <dataSource>标签：定义数据源的类型为“POOLED”。POOLED是MyBatis的一种连接池实现方式。
  • <property>子标签：
    • driver：指定JDBC驱动类名，这里是MySQL的JDBC驱动。
    • url：数据库的URL，指向本地的MySQL数据库。URL中的参数useSSL=false表示不使用SSL连接，useUnicode=true和characterEncoding=utf8表示使用Unicode和UTF-8编码。
    • username和password：数据库的用户名和密码。
  • <mappers>标签：指定了所有Mapper XML文件的资源位置。这里只有一个Mapper XML文件，即“UserMapper.xml”。Mapper XML文件通常用于定义SQL查询、更新、插入和删除操作。
  • <mapper>标签：指定了“UserMapper.xml”文件的位置，它在“mapper”目录下。这意味着MyBatis会去“mapper”目录下查找并加载“UserMapper.xml”文件，并将其中定义的SQL语句与Java对象进行映射。

# 4.2、UserMapper.xml解析

定义了一个从“user”表中选择所有列的SQL查询，并将其映射到com.xygalaxy.dao.UserDao接口中的getUserList方法。查询的结果将被转换为com.xygalaxy.pojo.UserPO对象列表。

UserMapper.xml 
<?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.xygalaxy.dao.UserDao">
    <!--  select查询语句，id对应接口中的方法；resultType返回结果 -->
    <select id="getUserList" resultType="com.xygalaxy.pojo.UserPO">
        select * from user
    </select>
</mapper>
1
2
3
4
5
6
7
8
9
10
11

  • <mapper namespace="com.xygalaxy.dao.UserDao">

    • namespace属性定义了与该Mapper XML文件关联的Dao（数据访问对象）接口的完全限定名。这意味着这个XML文件是为com.xygalaxy.dao.UserDao接口提供映射定义的。

  • <select id="getUserList" resultType="com.xygalaxy.pojo.UserPO">

    • <select>元素定义了一个SQL查询语句。
    • id="getUserList"：此属性定义了这个查询语句的唯一标识符，它应与UserDao接口中的方法名匹配。这意味着当你在Java代码中调用getUserList方法时，MyBatis会执行这个SQL查询。
    • resultType="com.xygalaxy.pojo.UserPO"：此属性指定了查询结果的类型。这意味着查询返回的所有列都将映射到com.xygalaxy.pojo.UserPO类的属性中。

  • select * from user

    • 这是实际的SQL查询语句，从“user”表中选择所有列。

# 4.3、MybatisUtils解析

MybatisUtils 
public class MybatisUtils{

    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            // 使用mybatis，获取SqlSessionFactory，找到核心配置文件
            String resource = "config/mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //有了SqlSessionFactory -->去获取SqlSession连接
    public static SqlSession getSession(){
        return sqlSessionFactory.openSession();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

  • 使用 Resources.getResourceAsStream 方法尝试从指定的路径加载 MyBatis 配置文件。
  • SqlSessionFactory 是 MyBatis 中用于创建 SqlSession 的工厂类。
  • SqlSession 用于获取 Mapper 映射。

# 5、Spring整合MyBatis

# 5.1、案例问题

在上述案例中，我们已经通过应用分为三层架构的方式，通过MyBatis实现了查询数据库用户表数据。但是我们现在还有些问题：

  • 数据库配置没能统一管理，可以通过抽离配置参数。
  • 获取Bean的方式太过冗余了，我们可以通过注解方式注入。
  • 获取Dao层的Mapper太过繁杂，需要通过MybatisUtils，每次还得自己手动关闭，可以将对象交给Spring管理。

# 5.2、解决方法

  • 解决问题：数据库配置没能统一管理

抽离配置方式，将数据库信息配置到jdbc.properties中。

在resources下创建jdbc.properties文件，并添加如下内容：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/xygalaxy?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8
jdbc.username=root
jdbc.password=123456
1
2
3
4

修改mybatis-config.xml读取jdbc.properties中数据库配置

<?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">
<!--mybatis核心配置文件-->
<configuration>
    <!--添加properties配置文件路径(外部配置、动态替换)-->
    <properties resource="jdbc.properties" />
    <!--配置环境-->
    <environments default="development">
        <environment id="development">
            <!--配置事务管理-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源(连接池)-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 每一个mapper.xml都需要在这个配置，获取指定的Mapper.xml文件-->
    <mappers>
        <mapper resource="mapper/UserDao.xml"/>
    </mappers>
</configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
  • 解决问题：获取Bean的方式太过冗余了

我们将修改为通过注解自动注入的方式获取Bean对象。

加入spring-test依赖，用于单元测试自动注入bean

<!--  spring单元测试自动注入bean  -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.3.16</version>
</dependency>
1
2
3
4
5
6

新增配置类，用于扫描Spring注解

package com.xygalaxy.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.xygalaxy")
public class ScanConfig {
}
1
2
3
4
5
6
7
8
9

修改Controller层代码，通过自动注入的方式获取Bean对象

@ContextConfiguration(classes = ScanConfig.class) // 开启配置加载
@RunWith(SpringJUnit4ClassRunner.class) // 单元测试获取Bean
public class UserController {

    // 自动注入Service
    @Autowired
    private UserServiceImpl userService;

    /**
     * 这里做请求数据处理、返回结果处理
     */
    @Test
    public void testGetUserList(){
        List<UserPO> userList = userService.queryUserList();;
        System.out.printf("用户信息: "+userList);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  • 解决：获取Dao层的Mapper太过繁杂

这里就是Spring整合MyBatis的核心。

我们每次获取Dao层的Mapper时，都需要通过MybatisUtils工具类来间接的获取，而且还要手动关闭，这样显得有些繁琐。我们是不是可以将Mapper对象交给Spring来管理，这样就可以像获取Service层对象一样获取Dao层对象了。

  • 配置MyBatis的SqlSessionFactoryBean主要的需要配置DataSource和获取Mapper.xml文件。
  • 事务这里暂时不配置，还用不到。

坑点先说：

保证数据库（MySQL）、JDK、mysql-connector-java的版本一致，否则会报一直加载的问题，但没报错信息。

  • 本次案例使用MySQL版本为5.7.44，JDK版本为1.8，mysql-connector-java版本为5.1.34。
  • 如果使用了MySQL 8.0以上的版本，JDK要相应提高。

项目结构

新增Spring整合Mybatis的相关依赖

<!-- spring整合Mybatis  -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.6</version>
</dependency>
<!--  druid阿里的数据库连接池  -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.8</version>
</dependency>
<!--spring对jdbc封装的jar包也要导入进来，否则mybatis无法整合-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.2.RELEASE</version>
</dependency>
<!-- 添加slf4j日志api -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.20</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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.xygalaxy</groupId>
    <artifactId>MyBatis-study</artifactId>
    <version>1.0-SNAPSHOT</version>

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

    <dependencies>
        <!--  Spring  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.34</version>
        </dependency>
        <!--  Mybatis  -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.11</version>
        </dependency>
        <!--  lombok简化实体  -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <!--   单元测试  -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--   spring单元测试自动注入bean  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.16</version>
        </dependency>


        <!-- spring整合Mybatis  -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
        <!--  druid阿里的数据库连接池  -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        <!--spring对jdbc封装的jar包也要导入进来，否则mybatis无法整合-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.2.RELEASE</version>
        </dependency>
        <!-- 添加slf4j日志api -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.20</version>
        </dependency>

    </dependencies>

</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

新增UserMapper接口

Mapper接口就相当于Dao层接口，因为MyBatis对应的Mapper.xml文件，扫描的也是Mapper相关接口，Mapper为映射的意思，所以在MyBatis中，Dao层一般都用Mapper为后缀定义接口。

@Mapper // 标注为MyBatis的Mapper接口，并交给Spring管理，也可以用 @Repository 注解
public interface UserMapper {

    List<UserPO> getUserList();
   
}
1
2
3
4
5
6

UserService新增接口，并自动注入Mapper

public interface UserService {

    List<UserPO> queryUserList2();
}

// 接口实现
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public List<UserPO> queryUserList2() {
        return userMapper.getUserList();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

新增MyBatisConfig配置类

这里主要就是Spring整合MyBatis的核心配置了，就是将MyBatis的配置通过Bean方式配置。

@Configuration  // 声明配置类
@MapperScan("com.xygalaxy.mapper")   // MyBatis扫描dao层接口，也就是mapper接口
@Slf4j // 日志注解
public class MyBatisConfig {

    //定义属性 为属性注入数据（数据的来源上面引入的jdbc.properties文件）
    private static String driverClass;

    private static String url;

    private static String username;

    private static String password;

    /**
     * @PropertySource()读取不了jdbc.properties文件，没找到什么原因，换用读取写入方式
     */
    static {
        Properties properties = new Properties();
        try {
            InputStream inputStream = Resources.getResourceAsStream("jdbc.properties");
            properties.load(inputStream);
        } catch (IOException e) {
            log.error("读取jdbc.properties文件失败",e);
        }

        driverClass = properties.getProperty("jdbc.driver");
        url = properties.getProperty("jdbc.url");
        username = properties.getProperty("jdbc.username");
        password = properties.getProperty("jdbc.password");
    }

    /**
     * 创建数据源返回数据源，Spring会自动调用该方法，并将该对象交给IOC容器管理
     * @return
     */
    @Bean
    public DataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driverClass);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }

    /**
     * 创建SqlSessionFactoryBean对象,设置形参，Spring会自动去调用IOC容器中已有的数据源
     * @param dataSource
     * @return
     */
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setMapperLocations(resolveMapperLocations());
        return sqlSessionFactoryBean;
    }

    /**
     * 扫描mapper的文件，获取resources/mapper下，所有的mapper.xml文件
     * @return
     */
    public Resource[] resolveMapperLocations() {
        ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
        Resource[] mappers= null;
        try {
            mappers = resourceResolver.getResources("classpath*:mapper/*.xml");
        } catch (IOException e) {
            log.error("加总mapper文件失败");
        }
        return mappers;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

测试验证

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ScanConfig.class)
public class UserController {

    @Autowired
    private UserServiceImpl userService;

    @Test
    public void testGetUserList2(){
        System.out.printf("allUser: "+userService.queryUserList2());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

测试结果

# 5.3、注解方式

我们还可以使用注解方式进行查询SQL，这样Mapper.xml也可以不用配置了。

需要将Mapper.xml中的getUserList配置删除，否则会冲突报错。

@Mapper
public interface UserMapper {

    @Select("select * from user where id='1'")
    List<UserPO> getUserList();

}
1
2
3
4
5
6
7

测试结果

CRUD【增删改查】