1.1 mybatis快速入门

最新推荐文章于 2024-02-07 09:09:26 发布
最新推荐文章于 2024-02-07 09:09:26 发布
阅读量256 收藏
点赞数
分类专栏： MyBatis 文章标签： mybatis java
原文链接：http://www.tianshouzhi.com/api/tutorials/mybatis
版权
本文详细介绍了MyBatis的快速入门，包括环境搭建、XML配置、Java类映射、SqlSessionFactory和SqlSession的使用。通过示例展示了如何进行增删改查操作，并对比了直接操作SqlSession和使用Mapper接口两种方式。此外，还提及了基于注解的映射配置。
摘要由CSDN通过智能技术生成

1.1 mybatis快速入门

1 开发环境搭建

1、项目使用maven构建，在pom.xml中引入以下依赖

<!-- mybatis -->
<dependency>   
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>  
    <version>3.4.0</version>
</dependency>
<!-- mysql数据库驱动 -->
<dependency>   
    <groupId>mysql</groupId> 
    <artifactId>mysql-connector-java</artifactId>  
    <version>5.1.39</version>
</dependency>
<!-- juint测试框架 -->
<dependency> 
    <groupId>junit</groupId>  
    <artifactId>junit</artifactId>    
    <version>4.12</version>
</dependency>

在基础篇开篇中，我们提到过mybatis在工作过程中，依赖数据源(DataSource)，由于mybatis自带了几个简单的DataSource实现，这里我们直接使用mybatis自带的即可，不需要引入其他数据源的依赖。

2、建库建表

数据库使用mysql，在test库中新建一张user表，建表语句如下

CREATE TABLE user(id int, name VARCHAR(255) not NULL, age int, PRIMARY KEY (id))ENGINE = INNODB DEFAULT CHARSET=utf8;

3、创建java类User，与user表对应

package com.tianshouzhi.mybatis.quickstart.domain;

public class User {    
    private int id; 
    private String name;  
    private int age;  
    public int getId() {    
        return id;  
    }   
    public void setId(int id) {  
        this.id = id; 
    }  
    public String getName() {      
        return name;  
    }  
    public void setName(String name) {       
        this.name = name; 
    }   
    public int getAge() {    
        return age;  
    }  
    public void setAge(int age) {    
        this.age = age; 
    }    
    @Override  
    public String toString() {    
        return "User{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age +
            '}'; 
    }
}

2 基于XML的使用方式

mybatis的xml配置文件分为2类：

全局配置文件：

​ 主要是进行一些全局配置(废话)，通常命名为mybatis-config.xml。例如前面提到mybatis在操作数据库时需要依赖DataSource获取数据库连接，DataSource应该是全局唯一的，此时就应该在mybatis-config.xml中编写。当然，mybatis-config.xml中还会包含一些mybatis其他全局属性的配置。

映射文件：

​ 通常我们会针对一个表，就建立一个映射文件，因此映射文件可能会有多个。映射文件的命名习惯如下："类名+Mapper.xml"。例如这里要操作的User类，其映射文件名字就应该是UserMapper.xml，表示其是User类的映射文件。而如果还有一个UserAccount类的话，其映射文件名称则应该为UserAccountMapper.xml。下图表示了完整映射关系：

72FCEAB9-EE55-40D6-833C-F860ABFD2151.png

可以看到数据库表和Java实体类，本身都是独立的，我们映射文件来建立数据库表字段和和Java类属性之间的映射关系。

2.1 全局配置文件

在classpath下新建配置文件：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> 
    <environments default="development">    
        <environment id="development">      
            <transactionManager type="MANAGED" />   
            <dataSource type="POOLED">     
                <property name="driver" value="com.mysql.jdbc.Driver" />  
                <!--修改为你自己的用户名密码-->   
                <property name="username" value="your username" />   
                <property name="password" value="your password" />   
            </dataSource>       
        </environment>
    </environments> 
    <mappers>       
        <mapper resource="mappers/UserMapper.xml"/>  
    </mappers>
</configuration>

说明：

cofiguration元素：

​ 全局配置文件的根元素，作为mybatis对配置进行解析的入口

environments元素：

​ 表示环境配置。在实际开发中，我们通常有多个环境，例如开发环境(development)、测试环境(test)、生产环境(production)等，不同的环境的配置都是不同的。因此在environments元素中，可以配置多个表示具体某个环境的environment子元素。而default属性用于指定默认的环境。

environment元素：

​ 表示具体的某个环境，以id属性作为标识。每个environment元素内部都必须要配置2个子元素：transactionManager和dataSource。

  • transactionManager:事务管理器，属性type取值有2个，JDBC | MANAGED。其中：JDBC表示任何对数据库的修改操作，mybatis都会自动开启事务。这里配置的是MANAGED，表示事务由应用程序来控制，也就是我们需要手动的开启事务和提交事务。和spring整合时，开启和提交事务的操作交由spring来管理。
  • dataSource：表示数据源配置。这个更好理解，因为不同的环境中，我们访问的数据库url、username、password都是不同的，因此在每个environment元素下面都有一个dataSource配置。属性type表示使用的数据源类型，取值有三个：UNPOOLED|POOLED|JNDI，这里指定POOLED，表示使用mybatis自带的PooledDataSource。而dataSource内部通过property元素配置的属性，都是PooledDataSource支持的。注意不同的数据源实现，可以配置的property是不同的。

mappers元素：

​ 表示映射文件列表，前面提到通常我们针对数据库中每张表，都会建立一个映射文件。而在mappers元素中，就通过mapper元素，列出了所有配置文件的路径。例如mapper元素可以通过以下属性指定映射文件的路径：

​ resource属性：表示映射文件位于classpath下。例如上面的配置中就表示在classpath的mappers目录下，有一个UserMapper.xml映射文件

​ url属性：使用完全限定资源定位符指定映射文件路径，如file:///var/mappers/AuthorMapper.xml

​ class属性：通过java类来配置映射关系，可以一个java映射类对应一个xml映射文件

​ package：如果有多个java映射类，且位于同一个包下面，我们可以直接使用package属性指定包名，不需要为每个java映射配置一个class属性。

最常见的方式还是通过resource属性来指定。

2.2 XML映射文件

在classpath下创建目录mappers，并新建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">
<mapper namespace="com.tianshouzhi.mybatis.quickstart.mapper.UserMapper">
    <insert id="insert" parameterType="com.tianshouzhi.mybatis.quickstart.domain.User">
        INSERT INTO user(id, name, age) VALUES (#{id}, #{name}, #{age})   
    </insert>
    <select id="selectById" parameterType="int"
            resultType="com.tianshouzhi.mybatis.quickstart.domain.User">
        SELECT id, name, age FROM user where id = #{id}
    </select>
    <select id="selectAll" resultType="com.tianshouzhi.mybatis.quickstart.domain.User">
        SELECT id, name, age FROM user;
    </select>
    <update id="updateById" parameterType="com.tianshouzhi.mybatis.quickstart.domain.User">
        UPDATE user SET name = #{name}, age= # {age} WHERE id = #{id}
    </update>
    <delete id="deleteById" parameterType="int">
        DELETE FROM user WHERE id = #{id}
    </delete>
    <delete id="deleteAll">
        DELETE * FROM user
    </delete>
</mapper>

配置说明：

mapper元素：

​ xml映射文件的根元素。namespace属性表示命名空间，不同的xml映射文件namespace必须不同。原因在于mybatis使用namespace.id的方式来唯一定位一个sql，id指的是元素中内部包含对的insert、select、update、delete子元素中的id属性。

​ 例如现在还有另外一个mapper文件UserAccountMapper.xml，用于操作user_account表，其也要进行相应的增删改查。在这个配置文件中的元素中，我们可能也设置了id=“selectById”，那么只通过id属性无法进行区分，因此有了namespace的概念。

insert、select、delete、update元素：

​ 这四个元素都是mapper文件中表示增删改查操作的子元素，每个子元素都可以配置多个，例如这里配置了两个select元素，我们将sql直接写在这些子元素的内部。每个元素都有一个id属性，通过namespace.id唯一定位这个sql。

​ 前面一直提到，mapper文件是用于定义数据库表字段和java实体属性的映射关系，但是这里好像只看到了一些xml元素中，编写了一些语法有点奇怪sql而已，事实上，映射关系就是通过这种方式已经确定的。关于映射，可以分为正向映射和反向映射(这是笔者自己提出的概念)：

  • 正向映射：指的是，我们通过保存java对象，mybatis将java对象的属性名映射为数据库表字段名。
  • 反向映射：指的是，我们从数据库查询数据，mybatis自动将数据库表字段名映射到对应的java对象属性名。

​ 例如对于insert、update，使用了mybatis之后，我们在代码中插入和更新的都是一个java对象，由mybatis帮我们映射到数据库表的字段上，属于正向映射。对于select，我们是将数据库记录查出来封装到java对象中，属于反向映射。

正向映射：

​ 正向映射通过parameterType属性指定，如insert和update元素，parameterType属性值为com.tianshouzhi.mybatis.quickstart.User，这是一个java对象。mybatis会自动帮我们将java对象的值取出来，来替换sql中的变量。例如insert和update中的#{name}和#{age}就分别会被User对象的name和age属性值替换，即mybatis会调用user.getName()来替换#{name}，调用user.getAge()来替换#{age}。

​ 不过我们还看到了，delete和select元素也配置了parameterType属性，这是因为在删除和查询的时候，我们也是需要指定条件的。这两个元素指定parameterType类型都是int，对应java的包装数据类型Integer。

反向映射：

​ 反向映射通过resultType或者resultMap属性指定，这两个属性只能出现在元素中。在上面的UserMapper.xml配置中，只出现了resultType，resultMap我们将在之后讲解。

​ 这里元素配置的resultType属性值也是com.tianshouzhi.mybatis.quickstart.User，表示将数据库结果封装到这个类中。

​ resultType这种反向映射关系是基于数据库表字段与User类属性是完全对应的。例如对于数据库id、name、age字段，会自动调用User类的、setId、setName、setAge方法进行设置。如果表字段与实体属性不能一一对应的话，如数据库表字段为username，但是java类中定义的属性为name，则无法进行映射。

2.3 SqlSessionFactory&SqlSession介绍

在使用mybatis时，我们需要先创建一个SqlSessionFactory对象(在ibatis为SqlMapClient)，然后通过SqlSessionFactory来创建SqlSession，通过SqlSession提供的api去执行sql。

2.3.1 SqlSessionFactory

​ 顾名思义，是创建SqlSession实例的工厂类。SqlSessionFactory，某种程度上可以认为其是在数据源(Datasouce)的基础上做的一层封装，因此在整个程序中，最好只保存一个SqlSessionFactory实例。SqlSessionFactory与SqlSession之间的关系，就好像是Datasouce与Connection之间的关系一样。在使用一个数据源的时候，我们可以通过Datasouce的getConnection方法来获取Connection对象，而在mybatis中，我们通过SqlSessionFactory的openSession方法来获取SqlSession对象来操作数据库。

​ mybatis提供了一个SqlSessionFactoryBuilder对象，用于读取mybatis配置文件，创建SqlSessionFactory实例。以下代码演示了如何通过配置文件创建一个SqlSessionFactory实例。

String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

其中Resources是mybatis提供的一个工具类，用于读取classpath下的资源配置文件。

2.3.2 SqlSession

​ SqlSession可以认为是在数据库连接(Connection)的基础上做的一层封装。其提供我们操作数据库相关的API，一个SqlSession实例从创建到销毁整个过程中执行的所有sql，都是通过同一个Connection对象进行。需要注意的是，SqlSession 的实例不是线程安全的，因此我们不应该使用多个线程来操作同一个Sqlsession对象。最佳实践是：每次需要操作数据库时，都创建一个新的SqlSession实例，使用完成之后，将其关闭。相关代码片段如下所示：

SqlSession session = sqlSessionFactory.openSession();
try {
    // do work
} finally {
    session.close();
}

SqlSession中，为我们在xml映射文件中配置的<insert>、<update>、<delete>、<select>提供了相应的操作方法，如下所示：

public interface SqlSession extends Closeable {
    //<select>元素对应的相关方法
    <T> T selectOne(String statement);
    <T> T selectOne(String statement, Object parameter);
    <E> List<E> selectList(String statement);
    <E> List<E> selectList(String statement, Object parameter);
    <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds);
    <K, V> Map<K, V> selectMap(String statement, String mapKey);
    <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey);
    <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey,
                               RowBounds rowBounds);
    <T> Cursor<T> selectCursor(String statement);
    <T> Cursor<T> selectCursor(String statement, Object parameter);
    <T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds);
    void select(String statement, Object parameter, ResultHandler handler);
    void select(String statement, ResultHandler handler);
    void select(String statement, Object parameter, RowBounds rowBounds,
                ResultHandler handler);
    
    //<insert>元素对应的相关方法
    int insert(String statement);
    int insert(String statement, Object parameter);
    
    //<update>元素对应的相关方法
    int update(String statement);
    int update(String statement, Object parameter);
    
    //<delete>元素对应的相关方法
    int delete(String statement);
    int delete(String statement, Object parameter);
    
    //事务操作相关方法
    void commit();
    void commit(boolean force);
    void rollback();
    void rollback(boolean force);
    
    //其他方法
    List<BatchResult> flushStatements();
    @Override  void close();
    void clearCache();
    Configuration getConfiguration();
    <T> T getMapper(Class<T> type);
    Connection getConnection();
}

我们归纳一下增删改查相关方法的特点，眼神犀利的同学很快就会发现：

1、针对<insert>、<update>、<delete>、<select>元素，SqlSession中都提供了对应方法的多种重载形式

2、对应的方法，无一例外的都要接受一个String类型的statement参数。

前面提到过，mybatis是通过namespace.id的方式来唯一定位要执行哪个sql，这里的statement就是namespace.id的值。例如要执行UserMapper.xml文件中以下元素中的sql

<select id="selectById" parameterType="int"
        resultType="com.tianshouzhi.mybatis.quickstart.domain.User">
    SELECT id, name, age FROM user where id = #{id}
</select>

那么statement的值为"com.tianshouzhi.mybatis.quickstart.domain.User.selectById"。

3、有些方法需要接受一个Object类型的parameter参数，而另一些不需要。

​ 回顾在xml映射文件中，我们配置的<insert>、<update>、<delete>、<select>元素，每个都可以配置一个parameterType属性，就是与此处传入的parameter参数相呼应。

​ 例如对于我们正在UserMapper.xml中配置的元素

<insert id="insert" parameterType="com.tianshouzhi.mybatis.quickstart.domain.User">
    INSERT INTO user(id, name, age) VALUES (#{id}, #{name}, #{age})
</insert>

我们配置的parameterType属性值为"com.tianshouzhi.mybatis.quickstart.domain.User"，表示执行这个元素内部的sql时，我们需要传递一个User对象。而以下元素中，我们配置的parameterType属性值为"int"，表示执行这个元素内部的sql时，我们需要传递一个Integer值。

<delete id="deleteById" parameterType="int">
    DELETE FROM user WHERE id = #{id}
</delete>

因为传递的参数类型是各种各样的，因此parameter的类型是Object。

​ 对于另外一些sql执行时不需要参数的，此时我们可以调用不要传递parameter参数的方法重载形式。如：

<delete id="deleteAll">
    DELETE FROM user
</delete>

4、insert、update、delete相关方法，调用后，返回值类型都是int

这些操作属于更新数据库的操作，int表示受影响的记录行数。如我们在mysql中插入一条语句：

mysql> insert into user(id, name, age) values(1, "tianshouzhi", 27);
Query OK, 1 row affected (0.11 sec)

这里的1 row affected表示的就是有1行记录受到了影响。

5、对于select相关方法，比insert、update、delete提供的方法都要多。

​ select元素对应的相关方法大致可以归为这几类：selectOne、selectList、selectMap、selectCursor、没有返回值的select方法。

​ 首先声明，对于映射文件中的一个元素，从API层面，上述方法我们都可以调用，但是在实际使用中，却要注意。

例如，对于以下元素：

<select id="selectAll" resultType="com.tianshouzhi.mybatis.quickstart.domain.User">
    SELECT id, name, age FROM user;
</select>

这个元素中执行的sql可能会查询到多条记录，每条记录都会被封装成一个User对象。

  • 当我们调用selectList方法执行这条sql时，表示将User对象放到一个List返回。

  • 当我们调用selectMap方法执行这条sql时，表示将User对象放到一个Map返回。特别的，selectMap方法需要额外指定一个mapKey参数，表示用哪一个字段作为Map的key，一般我们会把主键字段当做Map的key，而Map的value显然就是对应的User对象。

  • 而当我们调用selectOne方法来执行SQL时，如果数据库中没有记录，或者只有1条记录，那么没问题。但是如果数据库记录数>1，那么mybatis就会抛出一个TooManyResultsException异常，表示返回的结果记录数与预期不符。从selectOne方法的名字就可以看出来，我们希望的是执行了这个sql最终返回一条记录。

    所以，当我们调用selectOne方法执行一条sql时，一定要保证这个sql最多执行返回一条记录。例如调用selectOne执行以下元素中的sql，就是没问题的：

<select id="selectById" parameterType="int"
        resultType="com.tianshouzhi.mybatis.quickstart.domain.User">
    SELECT id, name, age FROM user where id = #{id}
</select>
  • selectCursor方法主要是为了处理超大结果集，这是mybatis 3.4.0版本中的新功能。例如数据库中有1000W条记录，selectMap和selectList方法会直接将所有的记录查询出来，封装到List或Map中，结果很显然是内存被撑爆掉。selectCursor是通过游标的方式来解决这个问题。

​ 对于没有返回值的select方法，相比其他方法多接受一个ResultHandler参数，其作用很明显，对数据库返回的结果进行自定义的处理。

​ 最后，除了selectOne方法，其他形式select方法中都可以接受一个RowBounds参数，这是mybatis对分页功能的支持。不过这里用的是逻辑分页，而不是物理分页，所以一般我们不会使用这种类型的重载形式。之后的章节中，我们会介绍物理分页和逻辑分页的区别。

2.4 测试代码编写

理解了SqlSession的用法之后，我们开始测试代码的编写。有两种使用方式：

  • 直接操作SqlSession的相关方法：这种方式是最基础的使用方式，但是对于理解mybatis的工作原理，却是最重要的，其他使用方式建立在这个基础上。
  • 通过Mapper接口。这是目前主流的使用方式。

2.4.1 基于SqlSession的测试代码

测试代码基于junit框架编写，如下所示：

public class QuickStartBasedSqlSession {
    public static SqlSessionFactory sqlSessionFactory;
    public static String namespace = "com.tianshouzhi.mybatis.quickstart.mapper.UserMapper";
    public SqlSession sqlSession;
    //通过SqlSessionFactoryBuilder构造SqlSessionFactory实例
    @BeforeClass
    public static void testBefore() throws IOException {
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
    }
    // 每个单元测试方法(添加@Test注解的方法)在执行前，此方法都会被juint框架回调，创建一个新的SqlSession实例
    @Before
    public void before() {
        sqlSession = sqlSessionFactory.openSession();
    }
    
    // 测试添加，调用sqlSession的insert方法
    @Test
    public void testInsert() {
        User user1 = new User();
        user1.setId(1);
        user1.setName("tianshouzhi");
        user1.setAge(27);
        User user2 = new User();
        user2.setId(2);
        user2.setName("wangxiaoxiao");
        user2.setAge(26);
        String statement = namespace + ".insert";
        sqlSession.insert(statement, user1);
        sqlSession.insert(statement, user2);
    }
    
    // 测试查询单条记录，调用sqlSession的selectOne方法
    @Test
    public void testSelectOne() {
        User user = sqlSession.selectOne(namespace + ".selectById", 1);
        assert user != null;
        System.out.println("id:" + user.getId() + ",name:" + user.getName()
                           + ",age:" + user.getAge());
    }
    
    // 测试查询多条记录，并将结果封装到一个List中，调用sqlSession的selectList方法
    @Test
    public void testSelectList() {
        List<User> userlist = sqlSession.selectList(namespace + ".selectAll");
        System.out.println(userlist);
    }
    
    // 测试查询多条记录，并将结果封装到一个Map中，调用sqlSession的selectMap方法
    @Test
    public void testSelectMap() {
        Map<Integer, User> userMap = sqlSession.selectMap(namespace + ".selectAll", "id");
        System.out.println(userMap);
    }
    
    // 测试更新，调用sqlSession的update方法
    @Test
    public void testUpdate() {
        User user = sqlSession.selectOne(namespace + ".selectById", 2);
        assert user != null;
        user.setName("huhuamin");
        user.setAge(26);
        int updateCount = sqlSession.update(namespace + ".updateById", user);
        assert updateCount == 1;
    }
    
    // 测试删除，调用sqlSession的delete方法
    @Test
    public void testDelete() {
        int deleteCount = sqlSession.delete(namespace + ".deleteById", 1);
        assert deleteCount == 1;
    }
    
    // 测试删除，调用sqlSession的delete方法
    @Test
    public void testDeleteAll() {
        int deleteCount = sqlSession.delete(namespace + ".deleteAll"); 
        assert deleteCount == 1;
    }
    
    // 每个单元测试方法(添加@Test注解的方法)在执行后，此方法都会被juint框架回调，关闭SqlSession实例
    @After
    public void after() {
        sqlSession.close();
    }
}

1、执行testInsert方法后，数据库中会增加两条记录：

mysql> select * from user;
+----+--------------+------+
|id| name         | age  |
+----+--------------+------+
|1 | tianshouzhi  |   27 |
|2 | wangxiaoxiao |   26 |
+----+--------------+------+
2 rows in set (0.00 sec)

2、执行testSelectOne方法后，控制台输出

id:1, name:tianshouzhi, age:27

3、执行testSelectList方法后，控制台输出

[User{id=1, name='tianshouzhi', age=27}, User{id=2, name='wangxiaoxiao', age=26}]

4、执行selectMap后，控制台输出

{1=User{id=1, name='tianshouzhi', age=27}, 2=User{id=2, name='wangxiaoxiao', age=26}}

注意:testSelectList和testSelectMap调用的都是UserMapper.xml文件中，id值为"selectAll"这个元素中的sql。

5、执行testUpdate方法后，数据库id为2的记录信息发生变更

mysql> select * from user;
+----+-------------+------+
| id | name        | age  |
+----+-------------+------+
|  1 | tianshouzhi |   27 |
|  2 | huhuamin    |   26 |
+----+-------------+------+
2 rows in set (0.00 sec)

6 执行testDelete方法后，1号记录被删除

mysql> select * from user;
+----+----------+------+
| id | name     | age  |
+----+----------+------+
|  2 | huhuamin |   26 |
+----+----------+------+
1 row in set (0.00 sec)

7 执行deleteAll方法，数据库中没有记录

mysql> select * from user;
Empty set (0.00 sec)

对于直接使用SqlSession可以帮助我们理解mybatis的内部工作原理，但是在实际开发中，直接使用SqlSession的情况越来越少，除非是老项目，或者老司机已经习惯了这种用法。

2.4.2 基于Mapper接口的测试代码

mybatis提供了一种更加直观的使用方式，通过Mapper接口。

首先我们定义一个接口UserMapper，如下所示：

package com.tianshouzhi.mybatis.quickstart.mapper;
import java.util.List;
import com.tianshouzhi.mybatis.quickstart.domain.User;
public interface UserMapper {
    public int insert(User user);
    public User selectById(int id);
    public List<User> selectAll();
    public int updateById(User user);
    public int deleteById(int id);
    public int deleteAll();
}

细心的读者会发现：

    1. UserMapper接口的全路径com.tianshouzhi.mybatis.quickstart.mapper.UserMapper，与UserMapper.xml中的namespace属性的值完全相同。
    2. 在UserMapper.xml中定义的各个元素<insert>、<delete>、<update>、<select>的id属性值刚好是UserMapper接口中定义的几个方法的名字。

看到这里，读者可能已经知道mybatis想干啥了，我们不再需要在代码中，通过指定namespace.id方式，告诉SqlSession去执行哪条sql了。直接操作UserMapper接口即可，mybatis内部会通过动态代理+反射技术，获得当前执行的UserMapper接口的全路径，对应到UserMapper.xml中的namespace属性，获得方法名对应到<insert>、<delete>、<update>、<select>的id属性。这样就可以知道要执行哪条sql了。

​ 对于查询操作，mybatis会根据方法返回值类型判断要调用SqlSession的哪个方法，如UserMapper接口中定义的selectById方法，其返回值是一个User对象，mybatis内部自动会调用SqlSession的selectOne方法，而对于selectAll这种返回值类型是List的情况，mybatis内部自动会调用SqlSession的selectList方法。

另外，根据接口的方法声明中，是否包含参数，mybatis也可以自动判断是否需要调用SqlSession有parameter参数的方法重载形式。

可以通过以下方式获得UserMapper接口的动态代理对象

SqlSession session = sqlSessionFactory.openSession();
try {
    UserMapper mapper = session.getMapper(UserMapper.class);
    User user = mapper.selectById(1);
} finally {
    session.close();
}

改造后的测试代码如下所示：

public class QuickStartBasedMapper {
    public static SqlSessionFactory sqlSessionFactory;
    public SqlSession sqlSession;
    //添加UserMapper接口
    public UserMapper userMapper;
    //通过SqlSessionFactoryBuilder构造SqlSessionFactory实例
    @BeforeClass
    public static void testBefore() throws IOException {
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
    }
    // 每个单元测试方法(添加@Test注解的方法)在执行前，创建一个新的SqlSession实例，并获得UserMapper接口的动态代理对象
    @Before
    public void before() {
        sqlSession = sqlSessionFactory.openSession();
        userMapper = sqlSession.getMapper(UserMapper.class);
    }
    
    // 测试添加，调用UserMapper的insert方法
    @Test
    public void testInsert() {
        User user1 = new User();
        user1.setId(1);
        user1.setName("tianshouzhi");
        user1.setAge(27);
        User user2 = new User();
        user2.setId(2);
        user2.setName("wangxiaoxiao");
        user2.setAge(26);
        userMapper.insert(user1); 
        userMapper.insert(user2);
    }
    
    // 测试查询单条记录，调用UserMapper的selectById方法
    @Test
    public void testSelectOne() {
        User user = userMapper.selectById(1);
        assert user != null;
        System.out.println("id:" + user.getId() + ",name:" + user.getName()
                           + ",age:" + user.getAge());
    }
    
    // 测试查询多条记录，并将结果封装到一个List中，调用userMapper的selectAll方法 
    @Test
    public void testSelectAll() {
        List<User> userlist = userMapper.selectAll();
        System.out.println(userlist);
    }
    
    // 测试更新，调用userMapper的updateById方法
    @Test
    public void testUpdate() {
        User user = userMapper.selectById(2);
        assert user != null;
        user.setName("huhuamin");
        user.setAge(26);
        int updateCount = userMapper.updateById(user);
        assert updateCount == 1;
    }
    
    // 测试删除，调用userMapper的deleteById方法
    @Test
    public void testDelete() {
        int deleteCount = userMapper.deleteById(1);
        assert deleteCount == 1;
    }
    
    // 测试删除，调用userMapper的deleteAll方法
    @Test
    public void testDeleteAll() {
        int deleteCount = userMapper.deleteAll();
        assert deleteCount == 1;
    }
    
    // 每个单元测试方法(添加@Test注解的方法)在执行后，此方法都会被juint框架回调，关闭SqlSession实例
    @After
    public void after() {
        sqlSession.close();
    }
}

基于Mapper接口方式的mybatis代码，与直接操作SqlSession的效果类似，这里不再赘述。

需要注意的是，如果我们的UserMapper接口全路径与UserMapper.xml配置文件namespace属性值不匹配时，会抛出类似以下的异常

org.apache.ibatis.binding.BindingException: Type interface com.tianshouzhi.mybatis.quickstart.mapper.UserMapper is not known to the MapperRegistry.

3、基于注解的映射配置

在前面的讨论中，mybatis的全局配置文件(mybatis-config.xml)和映射器配置(UserMapper.xml)都是基于xml文件格式配置的。事实上mybatis也支持将映射配置直接配置在Mapper接口中。此时要做2点改动：

1、修改mybatis-config.xml的mappers元素配置，用注解配合代替xml映射配置

<mappers>
    <!-- <mapper resource="mappers/UserMapper.xml"/> -->
    <!--通过class属性指定UserMapper接口的全路径-->
    <mapper class="com.tianshouzhi.mybatis.quickstart.mapper.UserMapper"/>
</mappers>

2、在UserMapper接口的方法上，添加相关注解

public interface UserMapper {
    @Insert("INSERT INTO user(id, name, age) VALUES (#{id}, #{name}, #{age})")
    public int insert(User user);
    
    @Select(" SELECT id, ame, age FROM user WHERE id = #{id}")
    public User selectById(int id);
    
    @Select(" SELECT id, name, age FROM user")
    public List<User> selectAll();
    
    @Update("UPDATE user SET name = #{name}, age = #{age} WHERE id = #{id}")
    public int updateById(User user);
    
    @Delete("DELETE FROM user WHERE id = #{id}")
    public int deleteById(int id);
    
    @Delete("DELETE FROM user")
    public int deleteAll();
}

其中@Insert、@Select、@Update、@Delete注解，分别对应xml配置中的<insert>、<update>、<delete>、<select>元素。而注解里的sql直接就是把UserMapper.xml文件中对应的元素中的sql搬过来。

​ 此时，我们再去运行1.4节中的QuickStartBasedMapper相关测试代码，可以达到相同的结果。

当然，mybatis中提供的注解远远不止这几个，我们接触的只是冰山一角。mybatis提供的注解org.apache.ibatis.annotations包下面，在后面的章节中，我会对这些注解逐一进行讲述。

4 总结

本节总共介绍了2种mybatis的使用方式

1、通过xml映射文件，配置<insert>、<update>、<delete>、<select>元素

  • 又细分为直接操作SqlSession
  • Mapper接口：通过SqlSession获得Mapper接口的动态代理，接口的全路径要与xml映射文件namespace属性值相匹配，接口中的方法名与映射文件中配置的<insert>、<update>、<delete>、<select>元素id属性值相匹配。

2、通过注解映射，在Mapper接口的相应方法上添加@Insert、@Update、@Delete、@Select注解。

总的来说，直接操作SqlSession是最基础的使用方式，也最能帮助我们了解mybatis内部的核心工作流程，其他都是在这个基础上的封装。从笔者的工作经验来看，目前还是xml映射文件+Mapper接口的方式使用的最多。对于基于注解的方式，笔者并不建议，因为经常会出现在一些xml映射文件中支持的功能，使用注解的方式就不支持了。

原文：http://www.tianshouzhi.com/api/tutorials/mybatis

陈菡静
关注
专栏目录
【MyBatis】MyBatis操作数据库
haoshaokang_的博客
03-04 662
MyBatis是一个持久层框架（用于实现数据持久化的框架），它的底层也是基于JDBC的，不过用MyBatis比直接用JDBC操作数据库要方便很多。MyBatis是一个ORM（Object Relational Mapping）框架，即对象关系映射框架，映射关系：数据表–>>映射成一个类一条记录–>>映射成一个对象表中的字段–>>映射成类中的属性由于MyBatis实现了这层映射关系，我们可以像操作对象一样来操作数据表。
mybatis在指定库建表_mybatis快速入门
weixin_39958248的博客
01-12 729
1 开发环境搭建1、项目使用maven构建，在pom.xml中引入以下依赖org.mybatismybatis3.4.0mysqlmysql-connector-java5.1.39junitjunit4.12在基础篇开篇中，我们提到过mybatis在工作过程中，依赖数据源(DataSource)，由于mybatis自带了几个简单的DataSource实现，这里我们直接使用mybatis自带的即可...
Hibernate API 详解
.
06-09 1667
Hibernate 主要的 API 详解 org.hibernate.cfg.Configuration 加载主配置文件以及映射文件，启动 hibernate。 主配置文件中主要有：数据库连接四要素，方言，数据源… 默认获取 hibernate.cfg.xml 配置文件 Configuration configer = new Configuration().configure(); ...
mybatis 动态指定表
liliang950210的博客
04-13 2372
今天在我的项目中，我发现自己需要在插入数据库的时候需要动态的指定我的表，这个在以前是没有了解，然后自己一百度，发现在这类的文章很少很少，可能只有看mybatis的文档才知道吧 在mybatis 的动态sql中我们常用的是#{}来指定我们需要动态填入的数据 @Insert("INSERT INTO t_news (category,title,content,url) VALUES(#{c
springboot mybatis_Spring boot学习（三） Spring boot整合mybatis
weixin_39631519的博客
11-26 131
前言前面我们介绍了如何创建一个Spring boot项目以及Spring boot项目的一些基本配置，在了解了这些知识的前提下本篇博客继续介绍在Spring boot中配置一个基于java的持久层框架---Mybatis。为什么使用Mybatis在实际的开发过程中是离不开数据库的，这里指的是关系型数据库，例如MySql，Oracle,SqlServer等。大家应该都清楚如果不使用任何框架的情况下，...
MyBatis快速入门
一枚有趣的灵魂~享受编程带来的快乐
11-03 695
MyBatis快速入门，教你认识什么是MyBatis，重点学习核心配置文件和映射配置的具体内容
1.1 mybatis环境搭建
fragile125的博客
01-30 271
mybatis的环境搭建 一：创建maven工程并导入坐标 如果遇到添加mybatis依赖显示 Dependency ‘org.mybatis:mybatis:3.4.5’ not found 解决办法1:pom.xml直接添加额外的仓库 <repositories> <repository> <id>JBoss repository</id> <url>https://reposi
Mybatis的入门
m0_58375976的博客
06-30 787
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录...
MyBatis从入门到精通
Sunblogy的博客
05-18 998
MyBatis 1.MyBatis介绍 1.1 MyBatis基本介绍 结合MyBatis官网一起阅读，效果更加哟~~~ 1.2 JDBC缺点 1.3 MyBatis 简化JDBC 2.MyBatis快速入门 要求： 2.1 创建数据库表 创建一个自己的表，属性自己去确定，也可以用我的： 输入以下数据库信息： 语句： create database mybatis; use mybatis; drop table if exists tb_user; create table tb_use
.Mybatis快速入门
xiashuang1011的博客
08-12 91
typora-copy-images-to: img 一.Mybatis快速入门 1.1 框架介绍 框架是一款半成品软件，我们可以基于这个半成品软件继续开发，来完成我们个性化的需求！ 如图: [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xwMvDrAc-1597197212697)(img/架构.png)] 生活中的例子，比如盖房子 张三想盖红色的房子，他需要先给架构搭起来，然后再给房子图上红色 李四想盖蓝色的房子，他也需要先给架构搭起来，然后再给房子图上蓝色.
mybatis-cursor:mybatis光标问题（https
05-13
Mybatis光标 mybatis光标问题
Mybatis的切换数据库
07-12
Mybatis的以传入参数的形式进行切换数据库。
mybatis学习总结
weixin_37607613的博客
09-18 720
目录 一、架构 二、入门程序 1、加入配置文件 2、创建pojo 3、创建pojo对应的sql映射文件 4、实现根据id查询用户 5、测试 6、测试结果 三、命令解释 1、#{}和${} 2、parameterType和resultType、resultMap 3、selectOne和selectList 4、事务 5、selectKey 6、properties 7、typeAliases（类型别名） 8、mappers（映射器） 四、Dao开发方式 1、Sql.
Mybatis操作数据库
m0_51928077的博客
09-17 1008
MyBatis是一款优秀的持久层框架,它支持自定义SQL,存储过程以及高级映射.MyBatis去除了几乎所有的JDBC代码以及设置参数和获取结果集的工作.MyBatis可以通过简单的XML或注解来配置和映射原始类型,接口和Java POJO(Plain Old Java Object,普通老式Java对象)为数据库中的记录.简单来说,MyBatis是更简单完成程序和数据库交互的工具,也就是更简单的操作和读取数据库工具.支持存储过程,存储sql,但(无法调试无debug,可维护性差)对于后端开发来说,程序是由
Mybatis游标Cursor查询
热门推荐
WannaRunning的博客
12-14 1万+
通常对一张表中大量数据处理时由于数据量太大都要使用分页分批查询处理，否则数据量太大会导致OOM等问题。 Cursor查询适用于这种场景下可以替代分页查询的方案，Cursor实现了Closeable和Iterable接口，我们可以通过迭代器来获取数据进行处理。 public interface Cursor<T> extends Closeable, Iterable<T> { boolean isOpen();//用于在取数据之前判断 Cursor 对象是否是打开状态。
mybatis操作数据库
qq_51691366的博客
10-14 999
1.引入第三方工具mybatis的场景启动器 y 如果有错误可以根据Ide提示修改 2.在resources下建立mybatis文件写入mybatis-config.xml全局配置文件 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/myba.
JAVA Web学习笔记11 Mybatis
qq_43336475的博客
04-06 882
什么是mybatis MyBatis是一款优秀的持久层框架，用于简化JDBC开发。 持久层： 负责将数据到保存到数据库的那一层代码 JavaEE三层架构：表现层、业务层、持久层 Mybatis快速入门
【MyBatis】MyBatis查询数据库
潘潘的博客
07-29 832
MyBatis查询数据库详解——干货满满
MySQL环境下，mybatis使用Cursor
最新发布
liangbo7的博客
02-07 532
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
MyBatis入门教程：配置与实践
本资源是一份关于MyBatis入门的教程，主要介绍了MyBatis的基本概念、安装环境配置以及与Hibernate的对比。以下是详细内容： **1. MyBatis简介** MyBatis是Apache的一个开源项目，于2010年由Google Code迁移到GitHub...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值