mybatis框架

一、总结jdbc出现的问题

1、准备数据库，执行mysql语句。

1.  
   -- ----------------------------
2.  
   -- Table structure for `orders`
3.  
   -- ----------------------------
4.  
   DROP TABLE IF EXISTS `orders`;
5.  
   CREATE TABLE `orders` (
6.  
   `id` int(11) NOT NULL AUTO_INCREMENT,
7.  
   `user_id` int(11) NOT NULL COMMENT '下单用户id',
8.  
   `number` varchar(32) NOT NULL COMMENT '订单号',
9.  
   `createtime` datetime NOT NULL COMMENT '创建订单时间',
10.  
    `note` varchar(100) DEFAULT NULL COMMENT '备注',
11.  
    PRIMARY KEY (`id`),
12.  
    KEY `FK_orders_1` (`user_id`),
13.  
    CONSTRAINT `FK_order_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
14.  
    ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
15.  
     
16.  
    -- ----------------------------
17.  
    -- Records of orders
18.  
    -- ----------------------------
19.  
    INSERT INTO `orders` VALUES ('3', '1', '1000010', '2015-02-04 13:22:35', null);
20.  
    INSERT INTO `orders` VALUES ('4', '1', '1000011', '2015-02-03 13:22:41', null);
21.  
    INSERT INTO `orders` VALUES ('5', '10', '1000012', '2015-02-12 16:13:23', null);
22.  
     
23.  
    -- ----------------------------
24.  
    -- Table structure for `user`
25.  
    -- ----------------------------
26.  
    DROP TABLE IF EXISTS `user`;
27.  
    CREATE TABLE `user` (
28.  
    `id` int(11) NOT NULL AUTO_INCREMENT,
29.  
    `username` varchar(32) NOT NULL COMMENT '用户名称',
30.  
    `birthday` date DEFAULT NULL COMMENT '生日',
31.  
    `sex` char(1) DEFAULT NULL COMMENT '性别',
32.  
    `address` varchar(256) DEFAULT NULL COMMENT '地址',
33.  
    PRIMARY KEY (`id`)
34.  
    ) ENGINE=InnoDB AUTO_INCREMENT=35 DEFAULT CHARSET=utf8;
35.  
     
36.  
    -- ----------------------------
37.  
    -- Records of user
38.  
    -- ----------------------------
39.  
    INSERT INTO `user` VALUES ('1', '王五', null, '2', null);
40.  
    INSERT INTO `user` VALUES ('10', '张三', '2014-07-10', '1', '北京市');
41.  
    INSERT INTO `user` VALUES ('16', '张小明', null, '1', '河南郑州');
42.  
    INSERT INTO `user` VALUES ('22', '陈小明', null, '1', '河南郑州');
43.  
    INSERT INTO `user` VALUES ('24', '张三丰', null, '1', '河南郑州');
44.  
    INSERT INTO `user` VALUES ('25', '陈小明', null, '1', '河南郑州');
45.  
    INSERT INTO `user` VALUES ('26', '王五', null, null, null);

2、创建工程

    

3、配置pom.xml文件，加入数据库依赖驱动

1.  
   <project xmlns="http://maven.apache.org/POM/4.0.0"
2.  
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.  
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.  
   <modelVersion>4.0.0</modelVersion>
5.  
   <groupId>com.liwei</groupId>
6.  
   <artifactId>mybatis01</artifactId>
7.  
   <version>0.0.1-SNAPSHOT</version>
8.  
   <properties>
9.  
   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
10.  
    <!-- mysql版本 -->
11.  
    <mysql.version>5.1.30</mysql.version>
12.  
    <!-- junit版本 -->
13.  
    <junit.version>4.12</junit.version>
14.  
    </properties>
15.  
     
16.  
    <dependencies>
17.  
    <!-- mysql数据库依赖 -->
18.  
    <dependency>
19.  
    <groupId>mysql</groupId>
20.  
    <artifactId>mysql-connector-java</artifactId>
21.  
    <version>${mysql.version}</version>
22.  
    </dependency>
23.  
    <!-- junit依赖 -->
24.  
    <dependency>
25.  
    <groupId>junit</groupId>
26.  
    <artifactId>junit</artifactId>
27.  
    <version>${junit.version}</version>
28.  
    <scope>test</scope>
29.  
    </dependency>
30.  
    </dependencies>
31.  
     
32.  
    </project>

4、编写代码

1.  
   package com.liwei.jdbc;
2.  
    
3.  
   import java.sql.Connection;
4.  
   import java.sql.DriverManager;
5.  
   import java.sql.PreparedStatement;
6.  
   import java.sql.ResultSet;
7.  
    
8.  
   /**
9.  
   * @ClassName: JdbcTest
10.  
    * @Description:jdbc问题总结
11.  
    * @author: Li_Wei
12.  
    * @date: 2018年6月27日 上午10:13:52
13.  
    */
14.  
    public class JdbcTest {
15.  
     
16.  
    public static void main(String[] args) {
17.  
    Connection con = null;
18.  
    PreparedStatement psmt = null;
19.  
    ResultSet set = null;
20.  
    try {
21.  
    // 1.加载驱动
22.  
    Class.forName("com.mysql.jdbc.Driver");
23.  
    // 2.创建数据库的连接对象
24.  
    con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/liwei", "root", "root");
25.  
    // 3.定义sql语句
26.  
    String sql = "select * from user where id = ?";
27.  
    // 4.创建statement对象
28.  
    psmt = con.prepareStatement(sql);
29.  
    // 5.设置参数
30.  
    psmt.setInt(1, 1);
31.  
    // 6.执行
32.  
    set = psmt.executeQuery();
33.  
    // 7.处理结果集
34.  
    while (set.next()) {
35.  
    System.out.println("用户Id：" + set.getInt("id") + ",用户名称：" + set.getString("username"));
36.  
    }
37.  
    } catch (Exception e) {
38.  
    e.printStackTrace();
39.  
    } finally {
40.  
    try {
41.  
    //8.释放资源
42.  
    if (set != null)set.close();
43.  
    if (psmt != null)psmt.close();
44.  
    if (con != null)con.close();
45.  
    } catch (Exception e) {
46.  
    e.printStackTrace();
47.  
    }
48.  
    }
49.  
     
50.  
    }
51.  
     
52.  
    }

5、测试结果

    

6、总结jdbc开发出现的问题

• 频繁创建数据库连接对象、释放、容易造成系统资源浪费，影响系统性能。企业项目中可以使用连接池解决这个问题，但是使用Jdbc需要自己实现连接池。mybatis框架已经提供连接池。
• sql语句定义、参数设置、结果集处理存在硬编码。企业项目中sql语句变化的可能性较大，一旦发生变化，需要修改java代码，系统需要重新编译，重新发布。不好维护。
• 结果集处理存在重复代码，处理麻烦。如果可以映射成为java对象会比较方便。

二、mybatis介绍

        mybatis是Apache软件基金会下的一个开源项目，前身是Ibatis框架。2010年这个项目由apache 软件基金会迁移到google code下，改名为mybatis。2013年11月又迁移到了github（https://github.com/mybatis/mybatis-3/releases）。

        mybatis是一个持久层的框架，是对JDBC操作数据库的封装，使开发者只需要关注业务本身，不需要花费精力去处理加载驱动、创建数据库连接对象、创建statement语句对象、参数设置、结果集处理等一系列繁杂的过程代码。

        mybatis通过xml或注解进行配置，将java对象与sql语句中的参数自动映射生成最终执行的sql语句，并将sql语句执行结果自动映射成java对象，返回给业务层（service）应用。

三、mybatis的入门程序

    

需求：实现用户表（user）增、删、改、查操作。

1、配置pom.xml文件

1.  
   <project xmlns="http://maven.apache.org/POM/4.0.0"
2.  
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.  
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.  
   <modelVersion>4.0.0</modelVersion>
5.  
   <groupId>com.liwei</groupId>
6.  
   <artifactId>mybatis01</artifactId>
7.  
   <version>0.0.1-SNAPSHOT</version>
8.  
   <properties>
9.  
   <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
10.  
    <!-- mysql版本 -->
11.  
    <mysql.version>5.1.30</mysql.version>
12.  
    <!-- junit版本 -->
13.  
    <junit.version>4.12</junit.version>
14.  
    <!-- mybatis版本号 -->
15.  
    <mybatis.version>3.4.5</mybatis.version>
16.  
    <!-- log4j日志包版本 -->
17.  
    <slf4j.version>1.7.7</slf4j.version>
18.  
    <log4j.version>1.2.17</log4j.version>
19.  
    </properties>
20.  
     
21.  
    <dependencies>
22.  
    <!-- mysql数据库依赖 -->
23.  
    <dependency>
24.  
    <groupId>mysql</groupId>
25.  
    <artifactId>mysql-connector-java</artifactId>
26.  
    <version>${mysql.version}</version>
27.  
    </dependency>
28.  
    <!-- mybatis核心包 -->
29.  
    <dependency>
30.  
    <groupId>org.mybatis</groupId>
31.  
    <artifactId>mybatis</artifactId>
32.  
    <version>${mybatis.version}</version>
33.  
    </dependency>
34.  
    <!-- log4j日志包 -->
35.  
    <dependency>
36.  
    <groupId>log4j</groupId>
37.  
    <artifactId>log4j</artifactId>
38.  
    <version>${log4j.version}</version>
39.  
    </dependency>
40.  
    <dependency>
41.  
    <groupId>org.slf4j</groupId>
42.  
    <artifactId>slf4j-api</artifactId>
43.  
    <version>${slf4j.version}</version>
44.  
    </dependency>
45.  
    <dependency>
46.  
    <groupId>org.slf4j</groupId>
47.  
    <artifactId>slf4j-log4j12</artifactId>
48.  
    <version>${slf4j.version}</version>
49.  
    </dependency>
50.  
     
51.  
    <!-- junit依赖 -->
52.  
    <dependency>
53.  
    <groupId>junit</groupId>
54.  
    <artifactId>junit</artifactId>
55.  
    <version>${junit.version}</version>
56.  
    <scope>test</scope>
57.  
    </dependency>
58.  
    </dependencies>
59.  
     
60.  
    </project>

2、sqlMapConfig.xml配置文件，是mybatis框架的核心配置文件。

1.  
   <?xml version="1.0" encoding="UTF-8" ?>
2.  
   <!DOCTYPE configuration
3.  
   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4.  
   "http://mybatis.org/dtd/mybatis-3-config.dtd">
5.  
   <configuration>
6.  
   <!-- 运行环境配置 -->
7.  
   <!--default属性：指定使用哪一个运行环境 -->
8.  
   <environments default="development">
9.  
   <!--id属性：唯一标识一个运行环境 -->
10.  
    <environment id="development">
11.  
    <!-- 事务管理器配置，type="JDBC"：mybatis框架默认使用jdbc事务 -->
12.  
    <transactionManager type="JDBC" />
13.  
    <!--数据源配置，type="POOLED"：mybatis框架提供的连接池 -->
14.  
    <dataSource type="POOLED">
15.  
    <property name="driver" value="com.mysql.jdbc.Driver" />
16.  
    <property name="url" value="jdbc:mysql://127.0.0.1:3306/liwei" />
17.  
    <property name="username" value="root" />
18.  
    <property name="password" value="root" />
19.  
    </dataSource>
20.  
    </environment>
21.  
    </environments>
22.  
    <!-- 加载映射文件 -->
23.  
    <mappers>
24.  
    <mapper resource="mybatis/UserMapper.xml"/>
25.  
    </mappers>
26.  
    </configuration>

3、log4j.properties日志文件

   

1.  
   # Global logging configuration
2.  
   log4j.rootLogger=DEBUG, stdout
3.  
    
4.  
   # Console output...
5.  
   log4j.appender.stdout=org.apache.log4j.ConsoleAppender
6.  
   log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
7.  
   log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

4、实体类User.java文件

1.  
   package com.liwei.mybatis.domain;
2.  
    
3.  
   import java.util.Date;
4.  
    
5.  
   public class User {
6.  
   private Integer id; // 主键id
7.  
   private String username; // 用户名称
8.  
   private Date birthday; // 生日
9.  
   private String sex; // 性别
10.  
    private String address; // 地址
11.  
     
12.  
    public Integer getId() {
13.  
    return id;
14.  
    }
15.  
    public void setId(Integer id) {
16.  
    this.id = id;
17.  
    }
18.  
    public String getUsername() {
19.  
    return username;
20.  
    }
21.  
    public void setUsername(String username) {
22.  
    this.username = username;
23.  
    }
24.  
    public Date getBirthday() {
25.  
    return birthday;
26.  
    }
27.  
    public void setBirthday(Date birthday) {
28.  
    this.birthday = birthday;
29.  
    }
30.  
    public String getSex() {
31.  
    return sex;
32.  
    }
33.  
    public void setSex(String sex) {
34.  
    this.sex = sex;
35.  
    }
36.  
    public String getAddress() {
37.  
    return address;
38.  
    }
39.  
    public void setAddress(String address) {
40.  
    this.address = address;
41.  
    }
42.  
    @Override
43.  
    public String toString() {
44.  
    return "User [id=" + id + ", username=" + username + ", birthday=" + birthday + ", sex=" + sex + ", address="
45.  
    + address + "]";
46.  
    }
47.  
     
48.  
     
49.  
    }

5、UserMapper.xml文件

1.  
   <?xml version="1.0" encoding="UTF-8" ?>
2.  
   <!DOCTYPE mapper
3.  
   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4.  
   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5.  
   <mapper namespace="mybatis">
6.  
   <!-- 新增用户 -->
7.  
   <insert id="addUser" parameterType="com.liwei.mybatis.domain.User">
8.  
   insert into user (id,username,birthday,sex,address)
9.  
   values (#{id},#{username},#{birthday},#{sex},#{address})
10.  
    </insert>
11.  
     
12.  
    <!-- 根据用户id删除用户 -->
13.  
    <delete id="deleteUser" parameterType="int">
14.  
    delete from user where id = #{id}
15.  
    </delete>
16.  
     
17.  
    <!-- 根据用户id修改用户 -->
18.  
    <update id="updateUserById" parameterType="com.liwei.mybatis.domain.User">
19.  
    update user set username=#{username},sex=#{sex} where id=#{id}
20.  
    </update>
21.  
     
22.  
    <!-- 根据id查询 -->
23.  
    <select id="queryUserById" parameterType="int" resultType="com.liwei.mybatis.domain.User">
24.  
    select id,username,birthday,sex,address from user where id = #{id}
25.  
    </select>
26.  
     
27.  
    <!-- 方式一：根据用户名称模糊查询用户 -->
28.  
    <select id="queryUserByName1" parameterType="string" resultType="com.liwei.mybatis.domain.User">
29.  
    select id,username,birthday,sex,address from `user` where username like #{username}
30.  
    </select>
31.  
     
32.  
    <!-- 方式二：根据用户名称模糊查询用户 -->
33.  
    <select id="queryUserByName2" parameterType="string" resultType="com.liwei.mybatis.domain.User">
34.  
    select id,username,birthday,sex,address from `user` where username like '%${value}%'
35.  
    </select>
36.  
     
37.  
    </mapper>

6、MyBatisTest测试类

1.  
   package com.liwei.mybatis.test;
2.  
    
3.  
   import java.io.IOException;
4.  
   import java.io.InputStream;
5.  
   import java.util.Date;
6.  
   import java.util.List;
7.  
    
8.  
   import org.apache.ibatis.io.Resources;
9.  
   import org.apache.ibatis.session.SqlSession;
10.  
    import org.apache.ibatis.session.SqlSessionFactory;
11.  
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
12.  
    import org.junit.Test;
13.  
     
14.  
    import com.liwei.mybatis.domain.User;
15.  
     
16.  
    public class MyBatisTest {
17.  
    /**
18.  
    * @Title: getSqlSessionFactory
19.  
    * @Description: 将增、删、改、查公共使用的部分提出来
20.  
    * @param: @return
21.  
    * @param: @throws
22.  
    * IOException
23.  
    * @return: SqlSession
24.  
    * @throws @author
25.  
    * Li_Wei
26.  
    */
27.  
    public SqlSessionFactory getSqlSessionFactory() throws IOException {
28.  
    // 1.加载核心配置文件
29.  
    InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");
30.  
    // 2.读取配置文件的内容
31.  
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
32.  
    SqlSessionFactory sqlSessionFactory = builder.build(inputStream);
33.  
     
34.  
    return sqlSessionFactory;
35.  
    }
36.  
     
37.  
    /**
38.  
    * @Title: addUser
39.  
    * @Description: 新增用户
40.  
    * @param:
41.  
    * @return: void
42.  
    * @throws IOException
43.  
    * @throws @author
44.  
    * Li_Wei
45.  
    */
46.  
    @Test
47.  
    public void addUser() throws IOException {
48.  
    // 3.使用sqlSessionFactory对象，创建SqlSession对象，开启自动提交事务
49.  
    SqlSession sqlSession = this.getSqlSessionFactory().openSession(true);
50.  
    // 调用方法执行
51.  
    User user = new User();
52.  
    user.setId(4);
53.  
    user.setUsername("林诗音");
54.  
    user.setBirthday(new Date());
55.  
    user.setSex("女");
56.  
    user.setAddress("来自大明朝");
57.  
    sqlSession.insert("mybatis.addUser", user);
58.  
    // 事务提交
59.  
    // sqlSession.commit();
60.  
    // 释放资源
61.  
    sqlSession.close();
62.  
    }
63.  
     
64.  
    /**
65.  
    * @Title: deleteUser
66.  
    * @Description: 根据用户id删除用户
67.  
    * @param:
68.  
    * @return: void
69.  
    * @throws IOException
70.  
    * @throws @author
71.  
    * Li_Wei
72.  
    */
73.  
    @Test
74.  
    public void deleteUser() throws IOException {
75.  
    // 创建SqlSession对象
76.  
    SqlSession sqlSession = this.getSqlSessionFactory().openSession(true);
77.  
    // 调用方法执行
78.  
    sqlSession.delete("mybatis.deleteUser", 3);
79.  
    // 释放资源
80.  
    sqlSession.close();
81.  
    }
82.  
     
83.  
    /**
84.  
    * @Title: updateUser
85.  
    * @Description: 根据用户id修改用户
86.  
    * @param:
87.  
    * @return: void
88.  
    * @throws IOException
89.  
    * @throws @author
90.  
    * Li_Wei
91.  
    */
92.  
    @Test
93.  
    public void updateUserById() throws IOException {
94.  
    // 创建SqlSession对象
95.  
    SqlSession sqlSession = this.getSqlSessionFactory().openSession(true);
96.  
    // 调用方法执行
97.  
    // 创建用户对象
98.  
    User user = new User();
99.  
    user.setId(1);
100.  
     user.setUsername("林诗音和小李飞刀");
101.  
     user.setSex("1");
102.  
      
103.  
     sqlSession.update("mybatis.updateUserById", user);
104.  
     // 释放资源
105.  
     sqlSession.close();
106.  
     }
107.  
      
108.  
     /**
109.  
     * @Title: queryUserById
110.  
     * @Description: 根据id查询用户(查询)
111.  
     * @param:
112.  
     * @return: void
113.  
     * @throws IOException
114.  
     * @throws @author
115.  
     * Li_Wei
116.  
     */
117.  
     @Test
118.  
     public void queryUserById() throws IOException {
119.  
     // 3.使用sqlSessionFactory对象，创建SqlSession对象
120.  
     SqlSession sqlSession = this.getSqlSessionFactory().openSession();
121.  
     // 4.使用sqlSession对象，调用方法执行
122.  
     Object user = sqlSession.selectOne("mybatis.queryUserById", 24);
123.  
     System.out.println(user);
124.  
     // 5.释放资源
125.  
     sqlSession.close();
126.  
     }
127.  
      
128.  
     /**
129.  
     * @Title: queryUserNameLike
130.  
     * @Description: 方式一：根据用户名称模糊查询用户
131.  
     * @param:
132.  
     * @return: void
133.  
     * @throws IOException
134.  
     * @throws @author
135.  
     * Li_Wei
136.  
     */
137.  
     @Test
138.  
     public void queryUserByName1() throws IOException {
139.  
     // 3.使用sqlSessionFactory对象，创建SqlSession对象
140.  
     SqlSession sqlSession = this.getSqlSessionFactory().openSession();
141.  
     // 4.使用sqlSession对象，调用方法执行
142.  
     List<Object> userList = sqlSession.selectList("mybatis.queryUserByName1", "%小明%");
143.  
     for (Object object : userList) {
144.  
     System.out.println(object);
145.  
     }
146.  
     // 5.释放资源
147.  
     sqlSession.close();
148.  
     }
149.  
      
150.  
     /**
151.  
     * @Title: queryUserNameLike
152.  
     * @Description: 根据用户名称模糊查询用户
153.  
     * @param:
154.  
     * @return: void
155.  
     * @throws IOException
156.  
     * @throws @author
157.  
     * Li_Wei
158.  
     */
159.  
     @Test
160.  
     public void queryUserByName2() throws IOException {
161.  
     // 3.使用sqlSessionFactory对象，创建SqlSession对象
162.  
     SqlSession sqlSession = this.getSqlSessionFactory().openSession();
163.  
     // 4.使用sqlSession对象，调用方法执行
164.  
     List<Object> userList = sqlSession.selectList("mybatis.queryUserByName2", "小明");
165.  
     for (Object object : userList) {
166.  
     System.out.println(object);
167.  
     }
168.  
     // 5.释放资源
169.  
     sqlSession.close();
170.  
     }
171.  
     }

7、打印结果如下

新增用户：

            

    

删除：根据用户id删除用户

修改：根据用户id修改用户

查询：根据id查询

    

根据用户名称模糊查询：

方式一：使用#{}

方式二：使用${}

方式一与方式二具体看上面的代码。

在方式一与方式二中，我们使用到了#{}与${}两种方式，name这两种方式用什么区别呢？

四、占位符#{}与字符串拼接符${}区别

1. 占位符#{}，相当于jdbc中的问号？，当参数类型传递的是java简单类型的时候，花括号中的内容可以是任意字符串。
2. 字符串拼接符${}，当参数传递的是java简单类型的时候，花括号中的内容只能是：value
3. sql语句中使用字符串拼接，可能引起sql注入的问题。但是mybatis框架中字符串拼接符可以放心使用。原因是mybatis是后端dao层开发，参数在前端表现层（action）和业务层（service）已经处理好。

五、mybatis框架的原理

    

六、别名配置与映射文件加载方式

别名有两种方式：

映射文件加载：两种方法

注意：包扫描需要将映射文件放在相应的包下面

七、mybatis与hibernate的比较

相同点
都是对jdbc的封装，都是持久层的框架，都用于dao层的开发。

不同点

1. hibernate对sql语句做了封装，提供了HQL语句操作数据库，数据库无关性支持好，在项目需要支持多种数据库的情况下，代码开发量较少，sql语句优化困难。mybaits是直接使用sql语句操作数据库，不支持数据库无关性，在项目需要支持多种数据库的情况下，代码开发量较多，sql语句优化容易。
2. hibernate配置java对象与数据库表的对应关系，多表关联关系配置复杂。mybatis是配置java对象与sql语句的对应关系，多表关联关系配置简单。
3. hibernate是一个重量级的框架，学习使用门槛高，适合于需求相对稳定，中小型的项目，比如：办公自动化系统（OA）。mybatis是一个轻量级的框架，学习使用门槛低，适合于需求变化频繁，大型的项目，比如：互联网项目。目前企业项目中，mybatis框架使用更多。