生而为人

程序员的自我修养

0%

Posted on In

mybatis注解

1 介绍

mybatis 最初配置信息是基于 XML ,映射语句(SQL)也是定义在 XML 中的。而到了 MyBatis 3提供了新的基于注解的配置。mybatis提供的注解有很多，大致可以分为以下几类：

  • 增删改查：@Insert、@Update、@Delete、@Select、@MapKey、@Options、@SelelctKey、@Param、@InsertProvider、@UpdateProvider、@DeleteProvider、@SelectProvider

  • 结果集映射：@Results、@Result、@ResultMap、@ResultType、@ConstructorArgs、@Arg、@One、@Many、@TypeDiscriminator、@Case

  • 缓存：@CacheNamespace、@Property、@CacheNamespaceRef、@Flush

    绝大部分注解，在xml映射文件中都有元素与之对应，但是不是所有。此外在mybatis-spring中提供了@Mapper注解和@MapperScan注解，用于和spring进行整合。

2 增删改查相关注解

注解 使用对象 相对应的 XML 描述
@Insert @Update @Delete @Select 方法 这四个注解分别代表将会被执行的 SQL 语句。它们用字符串数组（或单个字符串）作为参数。如果传递的是字符串数组，字符串之间先会被填充一个空格再连接成单个完整的字符串。这有效避免了以 Java 代码构建 SQL 语句时的“丢失空格”的问题。然而，你也可以提前手动连接好字符串。属性有：value，填入的值是用来组成单个 SQL 语句的字符串数组。
@Options 方法 映射语句的属性 这个注解提供访问大范围的交换和配置选项的入口，它们通常在映射语句上作为属性出现。Options 注解提供了通俗易懂的方式来访问它们，而不是让每条语句注解变复杂。属性有：useCache=true, flushCache=FlushCachePolicy.DEFAULT, resultSetType=FORWARD_ONLY, statementType=PREPARED, fetchSize=-1, timeout=-1, useGeneratedKeys=false, keyProperty=“id”, keyColumn=“”, resultSets=“”。值得一提的是， Java 注解无法指定 null 值。因此，一旦你使用了 Options 注解，你的语句就会被上述属性的默认值所影响。要注意避免默认值带来的预期以外的行为。 注意： keyColumn 属性只在某些数据库中有效（如 Oracle、PostgreSQL等）。请在插入语句一节查看更多关于 keyColumn 和 keyProperty 两者的有效值详情。
@MapKey 方法 这是一个用在返回值为 Map 的方法上的注解。它能够将存放对象的 List 转化为 key 值为对象的某一属性的 Map。属性有： value，填入的是对象的属性名，作为 Map 的 key 值。
@SelectKey 方法 这个注解的功能与 标签完全一致，用在已经被 @Insert 或 @InsertProvider 或 @Update 或 @UpdateProvider 注解了的方法上。若在未被上述四个注解的方法上作 @SelectKey 注解则视为无效。如果你指定了 @SelectKey 注解，那么 MyBatis 就会忽略掉由 @Options 注解所设置的生成主键或设置（configuration）属性。属性有：statement 填入将会被执行的 SQL 字符串数组，keyProperty 填入将会被更新的参数对象的属性的值，before 填入 true 或 false 以指明 SQL 语句应被在插入语句的之前还是之后执行。resultType 填入 keyProperty 的 Java 类型和用 Statement、 PreparedStatement 和 CallableStatement 中的 STATEMENT、 PREPARED 或 CALLABLE 中任一值填入 statementType。默认值是 PREPARED。
@Param 参数 N/A 如果你的映射方法的形参有多个，这个注解使用在映射方法的参数上就能为它们取自定义名字。若不给出自定义名字，多参数（不包括 RowBounds 参数）则先以 “param” 作前缀，再加上它们的参数位置作为参数别名。例如 #{param1}, #{param2}，这个是默认值。如果注解是 @Param(“person”)，那么参数就会被命名为 #{person}。
@InsertProvider @UpdateProvider @DeleteProvider @SelectProvider 方法 允许构建动态 SQL。这些备选的 SQL 注解允许你指定类名和返回在运行时执行的 SQL 语句的方法。（自从MyBatis 3.4.6开始，你可以用 CharSequence 代替 String 来返回类型返回值了。）当执行映射语句的时候，MyBatis 会实例化类并执行方法，类和方法就是填入了注解的值。你可以把已经传递给映射方法了的对象作为参数，“Mapper interface type” 和 “Mapper method” 会经过 ProviderContext （仅在MyBatis 3.4.5及以上支持）作为参数值。（MyBatis 3.4及以上的版本，支持多参数传入）属性有： type, method。type 属性需填入类。method 需填入该类定义了的方法名。注意 接下来的小节将会讨论类，能帮助你更轻松地构建动态 SQL。

映射器接口示例，假设有以下UserMapper接口：

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
public interface UserMapper {

   @Insert("INSERT INTO user(id,name) VALUES (#{id},#{name})”)
   @Options(useGeneratedKeys = true, keyColumn = "id", keyProperty = "id") 
   public int insert(User user);

   @Update(" UPDATE user SET name=#{name} WHERE id=#{id}")
   public int update(User user);

   @Delete(“ DELETE FROM user WHERE id=#{id}")
   public int delete(int id);

   @Select("SELECT id,name FROM user WHERE id= #{id}")
   public User selectById(int id);

   @Select("SELECT id,name FROM user")
   public List<User> selectAll();

   @Select("SELECT id,name FROM user")
   @MapKey("id")
   public Map<Integer,User> selectMap();

   @Select({ "<script>",
      "SELECT id,name " + "FROM user " + "WHERE id IN "
            + "<foreach item='id' index='index' collection=‘array' open='(' separator=',' close=')'> " 
                 + "#{id}"
            + "</foreach> ",
      "</script>" })
   public List<User> selectByIds(int... ids);

   @Select("SELECT id,name FROM user LIMIT #{offset},#{limit}")
   public List<User> selectPage(@Param("offset") int offset, @Param("limit") int limit);
}

说明：

2.1 @Insert、@Update、@Delete、@Options、@SelectKey注解

mybatis会根据接口方法上的@Insert、@Update、@Delete注解，分别去调用SqlSession的insert、update、delete方法。这个几个方法返回的都是一个int，表示影响的记录行数。

特别的，在UserMapper接口的insert方法上，除了添加了@Insert注解，还添加了@Options注解。在上面的案例中，@Options注解用于获取自动生成主键，并设置到User实体中。此外，@SelectKey注解也可以用于获取自动生成的主键，使用方式如下：

1
2
3
@Insert("INSERT INTO user(id,name) VALUES (#{id},#{name})")
@SelectKey(statement = "SELECT LAST_INSERT_ID()", keyProperty = "id", before = false, resultType = Integer.class) 
public int insert(User user);

2.2 @Select注解

在上面的案例中，UserMapper的selectById、selectAll、selectMap、selectByIds、selectPage方法都添加了@Select注解。mybatis会根据方法的返回值类型User、List、Map<Integer,User>判断是调用SqlSession的selectOne、selectList还是selectMap方法。

2.3 @MapKey注解

特别的，对于返回值是Map的情况，UserMapper的selectMap方法上额外添加了一个@MapKey(“id”)注解，表示将User实例的id属性当做Map的key。

2.4 动态sql与，这是因为SQL中使用了动态sql标签。不管是@Insert、@Update、@Delete、@Select注解，只要SQL里使用了mybatis的动态sql标签(包括：if、choose …when …otherwise、trim 、where、 set、foreach、bind)等，都建议在sql前后分别加上，否则可能会出现一些参数找不到的情况。

2.5 @Param注解

@Param注解用于给方法参数起一个名字。以下是笔者总结的使用原则：

  • 在方法只接受一个参数的情况下，可以不使用@Param。

  • 在方法接受多个参数的情况下，建议一定要使用@Param注解给参数命名。

    例如上述案例的selectPage方法接受2个参数，所以其两个参数都使用了@Param注解。@Param注解看起来配置最简单，实际上理解确实最复杂，下面进行详细的介绍。

    前面已经提到，当映射器接口定义的方法被调用时，mybatis内部根据方法上注解：@Insert、@Update、@Delete、@Select来选择调用SqlSession的insert、update、delete、selectXXX方法。以下是SqlSession接口的相关方法定义(部分省略)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public interface SqlSession extends Closeable {
  ...
  <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);
  <K, V> Map<K, V> selectMap(String statement, String mapKey);
  <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey);
  ...
  int insert(String statement);
  int insert(String statement, Object parameter);
  int update(String statement);
  int update(String statement, Object parameter);
  int delete(String statement);
  int delete(String statement, Object parameter);
  ...
}

可以看到部分方法接受一个Object类型的parameter参数，另外一些方法则没有此参数。mybatis在执行前，除了会根据方法上注解：@Insert、@Update、@Delete、@Select来选择调用SqlSession的insert、update、delete、selectXXX方法；还会提前对传入映射器接口方法中的参数进行一些处理，然后再调用SqlSession的相应方法。逻辑如下：

1、如果映射器接口方法不接受参数，mybatis在执行时会调用相应无parameter参数的方法重载形式。例如，如UserMapper接口的selectAll方法，其不接受参数，返回值类型为List，因此调用SqlSession不接受paramter参数的selectList方法：

1
<E> List<E> selectList(String statement);

2、如果映射器方法只有一个参数，并且这个参数没有使用@Param注解，则直接用这个参数来调用SqlSession相应接受Object类型parameter方法参数的重载形式。例如，如UserMapper接口的selectByIds方法，其接受1个int[]数组类型参数作为查询条件，返回值类型为List，因此调用SqlSession接受paramter参数的selectList方法：

1
<E> List<E> selectList(String statement, Object parameter);

3、如果映射器方法只接受一个参数，但是使用了@Param注解，也会先封装到Map中；活着映射器方法总是接受多个参数，不管有没有使用@Param注解指定参数，总是会先封装到一个Map中。之后，调用SqlSession的相应方法把这个Map当做parameter参数传入。

例如：UserMapper接口的selectPage方法， 通过@Param("offset”)和@Param("limit”)为2个int参数指定了名字。

1
2
@Select("SELECT id,name FROM user LIMIT #{offset},#{limit}")
public List<User> selectPage(@Param("offset") int offset, @Param("limit") int limit);

假设我们传入0和10，那么参数封装后的Map结构如下：

key value

--------------------

offset 0 //1

limit 10 //2

param1 0 //3

param2 10 //4

关于Map中1、2两个key-value，比较好理解，是我们通过@Param注解指定的映射关系。而3、4两个key-value，实际上是参数位置(param1、param2…，下标从1开始)和参数值的映射关系，不管我们有没有使用@Param注解，存在多个参数的情况下，我们总是可以按照位置进行引用。

因此，将UserMapper的selectPage方法定义改成以下形式也是正确的：

1
2
3
4
5
6
7
//使用了@Param注解的情况下，依然根据参数位置进行引用(param1，param2…，下标从1开始)
@Select("SELECT id,name FROM user LIMIT #{param1},#{param2}")
public List<User> selectPage(@Param("offset") int offset, @Param("limit") int limit); 

//不使用@Param注解，直接根据参数位置进行引用
@Select("SELECT id,name FROM user LIMIT #{param1},#{param2}")
public List<User> selectPage(int offset, int limit);

显然，根据参数位置进行引用不太直观，因此建议在存在多个参数的情况，总是通过@Param注解显式的指定参数名。

2.6 @InsertProvider、@UpdateProvider、@DeleteProvider、@SelectProvider注解

这几个注解主要用于动态sql构建。

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
public interface UserBuilderMapper {

   @SelectProvider(type = UserSqlBuilder.class, method = "buildSelectByIdSql")
   public User selectById(@Param("id") int id);

   @InsertProvider(type = UserSqlBuilder.class, method = "buildInsertSql")
   @Options(useGeneratedKeys = true, keyColumn = "id", keyProperty = "id")
   public int insert(User user);

   @UpdateProvider(type = UserSqlBuilder.class, method = "buildUpdateSql")
   public int update(User user);

   @DeleteProvider(type = UserSqlBuilder.class, method = "buildDeleteSql")
   public int delete(@Param("id") int id);


    //建议将sql builder以映射器接口内部类的形式进行定义
    public static class UserSqlBuilder {
      public static String buildSelectByIdSql(@Param("id") int id) {
         return new SQL() {
            {
               SELECT("id, name");
               FROM("user");
               WHERE("id=#{id}");
            }
         }.toString();
      }

      public static String buildInsertSql(User user) {
         return new SQL() {
            {
               INSERT_INTO("user");
               VALUES("name", "#{name}");
            }
         }.toString();
      }

      public static String buildUpdateSql(User user) {
         return new SQL() {
            {
               UPDATE("user");
               SET("name=#{name}");
               WHERE("id=#{id}");
            }
         }.toString();
      }

      public static String buildDeleteSql(@Param("id") int id) {
         return new SQL() {
            {
               DELETE_FROM("user");
                    WHERE("id=#{id}");
            }
         }.toString();
      }
   }
 }

}

3 结果集映射相关注解

注解 使用对象 相对应的 XML 描述
@Results 方法 结果映射的列表，包含了一个特别结果列如何被映射到属性或字段的详情。属性有：value, id。value 属性是 Result 注解的数组。这个 id 的属性是结果映射的名称。
@Result 方法 在列和属性或字段之间的单独结果映射。属性有：id, column, javaType, jdbcType, typeHandler, one, many。id 属性是一个布尔值，来标识应该被用于比较（和在 XML 映射中的相似）的属性。one 属性是单独的联系，和 相似，而 many 属性是对集合而言的，和相似。它们这样命名是为了避免名称冲突。
@ResultMap 方法 N/A 这个注解给 @Select 或者 @SelectProvider 提供在 XML 映射中的 的id。这使得注解的 select 可以复用那些定义在 XML 中的 ResultMap。如果同一 select 注解中还存在 @Results 或者 @ConstructorArgs，那么这两个注解将被此注解覆盖。
@ResultType 方法 N/A 此注解在使用了结果处理器的情况下使用。在这种情况下，返回类型为 void，所以 Mybatis 必须有一种方式决定对象的类型，用于构造每行数据。如果有 XML 的结果映射，请使用 @ResultMap 注解。如果结果类型在 XML 的
@ConstructorArgs 方法 收集一组结果传递给一个结果对象的构造方法。属性有：value，它是形式参数数组。
@Arg N/A 单参数构造方法，是 ConstructorArgs 集合的一部分。属性有：id, column, javaType, jdbcType, typeHandler, select和 resultMap。id 属性是布尔值，来标识用于比较的属性，和 XML 元素相似。
@One N/A 复杂类型的单独属性值映射。属性有：select，已映射语句（也就是映射器方法）的全限定名，它可以加载合适类型的实例。fetchType会覆盖全局的配置参数 lazyLoadingEnabled。注意 联合映射在注解 API中是不支持的。这是因为 Java 注解的限制,不允许循环引用。
@Many N/A 映射到复杂类型的集合属性。属性有：select，已映射语句（也就是映射器方法）的全限定名，它可以加载合适类型的实例的集合，fetchType 会覆盖全局的配置参数 lazyLoadingEnabled。注意 联合映射在注解 API中是不支持的。这是因为 Java 注解的限制，不允许循环引用
@TypeDiscriminator 方法 一组实例值被用来决定结果映射的表现。属性有：column, javaType, jdbcType, typeHandler 和 cases。cases 属性是实例数组。
@Case N/A 单独实例的值和它对应的映射。属性有：value, type, results。results 属性是结果数组，因此这个注解和实际的 ResultMap 很相似，由下面的 Results 注解指定。

3.1 @ConstructorArgs、@Arg注解

如果实体类没有无参的构造方法，那么我们就必须通过@ConstructorArgs与@Arg注解来提供实体类的构造方法参数信息。例如上述UserMapper的selectById方法，其返回一个User对象。假设User对象只有以下构造方法：

1
2
3
4
public User(Integer id, String name) { 
this.id = id; 
this.name = name; 
}

那么需要在selectById方法上，添加@ConstructorArgs注解，提供构造方法信息，如下：

1
2
3
4
5
@Select("SELECT id,name FROM user where id= #{id}")
@ConstructorArgs({
@Arg(column = "id",javaType = Integer.class,id = true), 
@Arg(column = "name",javaType = String.class)}) 
public User selectById(int id);

注意，通常情况下，我们都建议为实体类提供无参的构造方法的，这是最佳实践的总结，因此@ConstructorArgs注解和@Arg注解基本使用不到。

3.2 @Results、@Result注解

如果实体字段的名称与数据库表字段名称不一致时，我们就需要显式的指定映射关系。这是通过@Results、@Result注解来指定的，例如为UserMapper的selectById指定映射关系：

1
2
3
4
5
@Select("SELECT id,name FROM user where id= #{id}")
@Results(id = "userMap", value = { 
       @Result(property = "id", column = "id", javaType = Integer.class,jdbcType = JdbcType.INTEGER,id = true), 
       @Result(property = "name", column = "name",javaType = String.class,jdbcType = JdbcType.VARCHAR)}) 
public User selectById(int id);

其中：

@Results注解：id属性用于给这个映射关系起一个名字(这里指定的为userMap)，其内部还包含了一个@Result[]来表示实体属性和数据库表字段的映射关系

@Result注解：property属性是java实体属性的名称，column表示对应的数据库字段的名称。javaType和JdbcType属性可以不指定。

3.3 @ResultMap注解

上述selectById方法已经通过@Results注解指定了结果映射关系，通过@ConstructorArgs指定了构造方法(必要的情况下才使用)，那么在其他的查询方法中，我们不需要重复定义，可以通过@ResultMap来引用@Results的id属性值进行复用。如我们在UserMapper的selectAll方法进行复用：

1
2
3
@Select("SELECT id,name FROM user")
@ResultMap("userMap")
public List<User> selectAll();

3.4 @TypeDiscriminator、@Case注解

鉴别器注解基本没用，有空的时候再补充

3.5 @Many、@One注解

主要用于关联关系映射

假设有作者(author)和文章(article)两张数据库表，一个author可以有多个article，一个article只能属于一个author。相关表结构以及初始数据如下所示：

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
--author表
CREATE TABLE `author` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO `author` (`id`, `name`) 
VALUES 
    (1, 'tianshouzhi');


--article表
CREATE TABLE `article` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `title` varchar(255) NOT NULL,
  `content` longtext NOT NULL,
  `author_id` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO `article` (`id`, `title`, `content`, `author_id`)
VALUES
    (1, 'title1', 'content1', 1),
    (2, 'title2', 'content2', 1);

相应的Java实体类如下所示：

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

   private Integer id;

   private String title;

   private String content;

   private Author author;

   //...setters getters and toString...
}

public class Author {
   private Integer id;

   private String name;

   private List<Article> articles;
  
   //...setters getters and toString...
}

映射器接口定义分别如下：

ArticleMapper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public interface ArticleMapper {
    //1、根据文章id查询文章Article对象，同时通过One注解关联查询出作者Author信息
    @Select("SELECT id,title,content,author_id FROM article where id= #{articleId}")
    @Results(id = "articleWithAuthor", value = {
            @Result(property = "id", column = "id"),
            @Result(property = "title", column = "title"),
            @Result(property = "content", column = "content"),
            //property属性：指定将关联查询的结果封装到Article对象的author属性上
            //column属性指定：指定在执行@One注解中定义的select语句时，把article表的author_id字段当做参数传入
            //one属性：通过@One注解定义关联查询的语句是AuthorMapper中的findAuthorByAuthorId方法
            @Result(property = "author",column = "author_id”,
                    one = @One(select = "com.tianshouzhi.mapper.AuthorMapper.findAuthorByAuthorId"))})
    public Article findArticleWithAuthorByArticleId(@Param("articleId") int articleId);
    
    //2、根据作者(Author)的id查询其所有的文章(Article)
   @Select("SELECT id,title,content,author_id FROM article WHERE author_id=#{authorId}")
   @Results(id = "articlesWithoutAuthor", value = {
           @Result(property = "id", column = "id"),
            @Result(property = "title", column = "title"),
            @Result(property = "content", column = "content")})
   List<Article> findArticlesByAuthorId(@Param("authorId") int authorId);
}

AuthorMapper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public interface AuthorMapper {
    //根据作者id查询Author信息
    @Select("SELECT id,name FROM author WHERE id=#{authorId}")
    Author findAuthorByAuthorId(int authorId);

    //根据作者id查询Author信息，通过@Many注解关联查询出所有的文章信息
    @Select("SELECT id,name FROM author WHERE id=#{authorId}")
    @Results(id = "authorWithArticles", value = {
            @Result(property = "id", column = "id"),
            @Result(property = "name", column = "name”),
           //property属性：指定将关联查询的结果封装到Author对象的articles属性上
            //column属性指定：指定在执行@Many注解中定义的select语句时，把author表的id字段当做参数传入
            //many属性：指定通过@Many注解定义关联查询的语句是ArticleMapper中的findArticlesByAuthorId方法
            @Result(property = "articles",column = "id”,
                    many = @Many(select = "com.tianshouzhi.mapper.ArticleMapper.findArticlesByAuthorId"))})
    Author findAuthorWithArticlesByAuthorId(int authorId);
}

测试如下：

1
2
3
4
5
6
7
8
9
10
@Test
public void testOneAndMany(){
       System.out.println("===========通过@One注解查询出Article关联的Auhtor===========");
       Article article = articleMapper.findArticleWithAuthorByArticleId(1);
       System.out.println(article);

       System.out.println("===========通过@Many注解查询出Auhtor关联的Article==========");
       Author author = authorMapper.findAuthorWithArticlesByAuthorId(1);
       System.out.println(author);
   }

控制台输出结果为：

===========通过@One注解查询出Article关联的Auhtor===========

Article{id=1, title=‘title1’, content=‘content1’, author=Author{id=1, name=‘tianshouzhi’, articles=null}}

===========通过@Many注解查询出Auhtor关联的Article==========

Author{id=1, name=‘tianshouzhi’, articles=[Article{id=1, title=‘title1’, content=‘content1’, author=null}, Article{id=2, title=‘title2’, content=‘content2’, author=null}]}

4 缓存相关注解

注解 使用对象 相对应的 XML 描述
@CacheNamespace 类 为给定的命名空间（比如类）配置缓存。属性有：implemetation, eviction, flushInterval, size, readWrite, blocking 和properties。
@Property N/A 指定参数值或占位值（placeholder）（能被 mybatis-config.xml内的配置属性覆盖）。属性有：name, value。（仅在MyBatis 3.4.2以上版本生效）
@CacheNamespaceRef 类 参照另外一个命名空间的缓存来使用。属性有：value, name。如果你使用了这个注解，你应设置 value 或者 name 属性的其中一个。value 属性用于指定 Java 类型而指定命名空间（命名空间名就是指定的 Java 类型的全限定名），name 属性（这个属性仅在MyBatis 3.4.2以上版本生效）直接指定了命名空间的名字。
@Flush 方法 N/A 如果使用了这个注解，定义在 Mapper 接口中的方法能够调用 SqlSession#flushStatements() 方法。（Mybatis 3.3及以上）

Posted on In

mybatis与spring整合

mybatis可以单独使用，也可以与spring进行整合。我们在自己的项目中，需要引入相关依赖，如你的项目管理工具使用的是maven，可以在pom.xml中添加以下配置

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
<!--spring依赖-->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.17.RELEASE</version>
  </dependency>
  <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-context</artifactId>
     <version>4.3.17.RELEASE</version>
  </dependency>
  <!--mybatis spring 依赖-->
  <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
  </dependency>
  <!--mybatis依赖-->
  <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.0</version>
  </dependency>
  <!--数据库连接池依赖-->
  <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.9</version>
  </dependency>
  <!--数据库驱动依赖-->
  <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.39</version>
  </dependency>

在整合之后，框架的之间的依赖关系如下图所示：

依赖关系

整合一：SqlSessionFactoryBean

在单独使用mybatis时，我们通过SqlSessionFactoryBuilder 来创建SqlSessionFactory。当mybatis与spring进行整合时，我们使用mybatis-spring提供的SqlSessionFactoryBean 来替代，SqlSessionFactoryBean实现了 Spring 的 FactoryBean 接口，用于创建 SqlSessionFactory 对象实例。

SqlSessionFactoryBean的配置有2种风格：

  • 保留mybatis的核心配置文件
  • 不保留mybatis的核心配置文件

保留mybatis的核心配置文件

我们将绝大部分关于mybatis的配置依然保留在mybatis的核心配置文件mybatis-config文件中，以下是一个示例：

mybatis-config.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?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="cacheEnabled" value="true"/>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <setting name="defaultExecutorType" value="SIMPLE"/>
    </settings>

    <typeAliases>
        <package name="com.tianshouzhi.mybatis.entity"/>
    </typeAliases>

    <mappers>
        <mapper resource="mybatis/mappers/UserMapper.xml"/>
    </mappers>
</configuration>

细心的读者注意到，在mybatis-config.xml文件中我们并没有通过的子元素、来配置数据源和事务管理器。即使配置了，也会被SqlSessionFactoryBean忽略。我们需要显式的为SqlSessionFactoryBean的dataSource属性引用一个数据源配置，如果不指定，在其初始化时就会抛出异常。

​ 此时SqlSessionFactoryBean配置方式如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!—-SqlSessionFactoryBean-—>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean”>
     <!--数据源配置-->
     <property name="dataSource" ref="dataSource”/>
     <!--通过configLocation属性指定mybatis核心配置文件mybatis-config.xml路径-->
     <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"/>
</bean>

<!--数据源使用druid-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="root"/>
        <property name="password" value=“your password"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver”/>
        <!--其他配置-->
</bean>

不保留mybatis的核心配置文件

从mybatis-spring 1.3.0之后，我们可以移除mybatis-config.xml文件，将所有关于myabtis的配置都通过SqlSessionFactoryBean来指定。

以下配置案例演示了与上述等价的配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.tianshouzhi.zebracost.entity”/>
        <!--从类路径下加载在mybatis/mappers包和它的子包中所有的 MyBatis 映射器 XML 文件-->
        <property name="mapperLocations" value="classpath*:mybatis/mappers/**/*.xml"></property>
        <property name="configuration">
            <bean class="org.apache.ibatis.session.Configuration">
                <property name="mapUnderscoreToCamelCase" value="true"/>
                <property name="cacheEnabled" value="true"/>
                <property name="defaultExecutorType" value="SIMPLE"/>
            </bean>
        </property>
 </bean>

在mybatis与spring整合后, 通常我们不会再直接使用SqlSessionFactory。mybatis-spring提供了其他更加易于操作的工具类，如SqlSessionTemplate、SqlSessionDaoSupport，当然还有其他更加高级的使用方式，如：MapperFactoryBean，MapperScannerConfigurer。

整合二：使用SqlSessionTemplate

SqlSessionTemplate 是 mybatis-spring 的核心，其实现了SqlSession接口。在使用了SqlSessionTemplate之后，我们不再需要通过SqlSessionFactory.openSession()方法来创建SqlSession实例；使用完成之后，也不要调用SqlSession.close()方法进行关闭。另外，对于事务，SqlSessionTemplate 将会保证使用的 SqlSession 是和当前 Spring 的事务相关的。

SqlSessionTemplate依赖于SqlSessionFactory，其配置方式如下所示：

1
2
3
4
<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
<bean id="userDao" class="com.tianshouzhi.mybatis.dao.UserDao"/>

之后我们可以在UserD类中直接进行注入。SqlSessionTemplate 是线程安全的, 可以被多个 DAO 所共享使用，以下是一个示例：

1
2
3
4
5
6
7
8
9
10
11
public class UserDao {
    private static String NAMESPACE = "com.tianshouzhi.zebracost.UserMapper";

    @Autowired
    SqlSessionTemplate sqlSession;

    public User selectById(int id) {
        User user = sqlSession.selectOne(NAMESPACE + ".selectById",id);
        return user;
    }
}

SqlSessionTemplate本质上是一个代理，关于SqlSessionTemplate的源码分析，后期会抽空编写。

整合三：继承SqlSessionDaoSupport

mybatis提供了抽象类SqlSessionDaoSupport，调用其getSqlSession()方法你会得到一个 SqlSessionTemplate,之后可以用于执行 SQL 方法, 就像下面这样:

1
2
3
4
5
6
7
8
public class UserDao extends SqlSessionDaoSupport{
    private static String NAMESPACE = "com.tianshouzhi.zebracost.UserMapper";

    public User selectById(int id) {
        User user = getSqlSession().selectOne(NAMESPACE + ".selectById",id);
        return user;
    }
}

SqlSessionDaoSupport 需要一个 sqlSessionFactory 或 sqlSessionTemplate 属性来设置 。如果两者都被设置了 , 那么SqlSessionFactory是被忽略的。由于我们的UserDao类继承了SqlSessionDaoSupport，所以你可以在UserDao类中进行设置：

1
2
3
<bean id="userDao" class="com.tianshouzhi.zebracost.dao.UserDao">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
 </bean>

或：

1
2
3
<bean id="userDao" class="com.tianshouzhi.zebracost.dao.UserDao">
     <property name="sqlSessionTemplate" ref="sqlSessionTemplate"/>
 </bean>

事实上，如果你提供的是一个SqlSessionFactory，SqlSessionDaoSupport内部也会使用其来构造一个SqlSessionTemplate实例。

整合四：MapperFactoryBean

无论是使用SqlSessionTemplate，还是继承SqlSessionDaoSupport，我们都需要手工编写DAO类的代码。熟悉mybatis同学知道，SqlSession有一个getMapper()方法，可以让我们通过映射器接口的方式来使用mybatis。

例如针对有以下UserMapper.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
<?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.mapper.UserMapper”>

  <select id="selectById" resultType="Blog">
    select * from user where id = #{id}
  </select>
  <insert id="insert" paramterType="com.tianshouzhi.mybatis.domain.User”>
    insert into user(name,age) values(#{name},#{age})
  </insert>
</mapper>

我们可以定义以下UserMapper接口：

1
2
3
4
5
6
7
package com.tianshouzhi.mybatis.mapper;
import com.tianshouzhi.mybatis.domain.User;

public interface UserMapper {
    public int insert(User user);
    public User selectById(int id);
}

细心的读者注意到：

1、映射文件的namespace属性值”com.tianshouzhi.mybatis.mapper.UserMapper"就是UserMapper接口的全路径

2、映射文件中的

之后，我们调用UserMapper接口中的方法，就会执行UserMapper.xml中对应的sql。

你甚至可以通过注解的方式直接将sql写到UserMapper接口的方法上，此时你就不再需要UserMapper.xml，如：

1
2
3
4
5
6
7
8
9
10
11
package com.tianshouzhi.mybatis.mapper;
import com.tianshouzhi.mybatis.quickstart.domain.User;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;

public interface UserMapper {
    @Insert("insert into user(name,age) values(#{id},#{name},#{age})")
    public int insert(User user);
    @Select("select * from user where id = #{id}")
    public User selectById(int id);
}

此时我们可以修改mybatis-config.xml中元素的resource属性为class属性，指定UserMapper接口的全路径，如下

1
2
3
4
5
<mappers>
   <!--<mapper resource="mappers/UserMapper.xml"/>—>
   <!--使用class属性指定UserMapper接口全路径-->
   <mapper class="com.tianshouzhi.mybatis.mapper.UserMapper"/>
</mappers>

之后，我们可以通过以下方式来使用UserMapper接口，更加直观，不容易出错。

1
2
3
4
5
6
7
SqlSession session = sqlSessionFactory.openSession();
try {
  UserMapper mapper = session.getMapper(UserMapper.class);
  User user = mapper.selectById(1);//等价于执行UserMapper中id属性值为”selectById”的<select>元素中的sql，或者selectById方法上注解的sql
} finally {
  session.close();
}

但是在与spring进行整合时，是否有更加简单的使用方法呢？能够在一个业务Bean中注入UserMapper接口，不需要通过SqlSession的getMapper来创建。我们期望的使用方式如下：

1
2
3
4
5
6
7
8
9
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public void insert(User user){
        System.out.println("create a new user!"+user);
        userMapper.insert(user);
    }
}

直接这样操作显然是会报错的，因为UserMapper是一个接口，且不是spring管理的bean，因此无法直接注入。

这个时候，本节的主角MapperFactoryBean登场了，通过如下配置，MapperFactoryBean会针对UserMapper接口创建一个代理，并将其变成spring的一个bean。MapperFactoryBean继承了SqlSessionDaoSupport类，这也是为什么我们先介绍SqlSessionDaoSupport，再介绍MapperFactoryBean的原因。显然的，你可以想到，我们可以为MapperFactoryBean指定一个SqlSessionTemplate或者SqlSessionFactory，如果两个属性都设置了,那么 SqlSessionFactory 就会被忽略。

通过以下配置，我们就可以在一个业务bean中直接注入UserMapper接口了：

1
2
3
4
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
  <property name="mapperInterface" value="com.tianshouzhi.mybatis.mapper.UserMapper" />
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

你可能想知道MapperFactoryBean为什么具有这样的魔力，但是这不是本文的重点，本文讲解的是mybatis是如何spring进行整合的。笔者将其会在其他章节分析MapperFactoryBean的源码。

上述方式，已经是mybatis与spring进行时理想的方式了。但是如果你的业务很复杂，有许多的XxxMapper接口要配置，针对每个接口都配置一个MapperFactoryBean，会使得我们的配置文件很臃肿。关于这一点，mybatis团队提供了MapperScannerConfigurer来帮助你解决这个问题。

整合五：MapperScannerConfigurer

通常我们在开发时，会将同一类型的类放于同一个包下，例如现在我们com.tianshouzhi.mybatis.mappers包下，有两个接口：UserMapper、UserAccountMapper。

MapperScannerConfigurer可以指定扫描某个包，将这个包下的所有接口，自动的为每个映射器接口都注册一个MapperFactoryBean。配置如下：

1
2
3
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="basePackage" value="org.tianshouzhi.mybatis.user.mappers" />
</bean>

其中：basePackage 属性是让你为映射器接口的包路径。如果的映射器接口位于不同的包下，可以使用分号”;”或者逗号”,”进行分割。如：

1
2
3
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="basePackage" value=“org.tianshouzhi.mybatis.user.mappers;org.tianshouzhi.mybatis.product.mappers" />
</bean>

如果你指定的还包含子包，子包中的映射器接口递归地被搜索到。因此对于上述配置，我们可以通过公共的包名"org.tianshouzhi.mybatis”进行简化。如：

1
<property name="basePackage" value="org.tianshouzhi.mybatis" />

你可能想到了，如果指定的公共的包名下面还包含了一些其他的接口，这些接口是你作为其他用途使用到的，并不能作为mybatis的映射器接口来使用。此时，你可以通过markerInterface属性或者annotationClass属性来进行过滤。

对于markerInterface，首先，你需要定义一个标记接口，接口名随意，这个接口中不需要定义任何方法，如：

1
public interface MybatisMapperInterface{}

接着，你需要将你的映射器接口继承MybatisMapperInterface，如：

1
2
3
public interface UserMapper implements MybatisMapperInterface{
   //...映射器方法
}

此时你可以指定MapperScannerConfigurer中指定，只有继承了MybatisMapperInterface接口的子接口，才为其自动注册MapperFactoryBean，如：

1
<property name="markerInterface" value="com.tianshouzhi.mybatis.MybatisMapperInterface"/>

对于annotationClass属性，作用是类似的，根据注解进行过滤。一般我们是映射器接口上添加mybatis提供的@Mapper注解进行过滤，你也可以自定义一个注解。配置如下：

1
<property name="annotationClass" value="org.apache.ibatis.annotations.Mapper"/>

​ 如果同时指定了markerInterface和annotationClass属性，那么只有同时满足这两个条件的接口才会被注册为MapperFactoryBean。

细心的读者可能意识到了，到目前，我们还没有为MapperScannerConfigurer指定一个SqlSessionFactory，或者SqlSessionTemplate。前面配置MapperFactoryBean的时候，我们已经看到，我们至少需要为其提供一项。之所以不指定，是因为MapperScannerConfigurer将会spring上下文中自动进行寻找类型为SqlSessionFactory，或者SqlSessionTemplate的bean，然后利用其来创建MapperFactoryBean实例。

当然你也可以手工的进行指定任意一个，如：

1
2
<property name="sqlSessionFactory" ref=“sqlSessionFactory"/>
<!--<property name="sqlSessionTemplate" ref=“sqlSessionTemplate"/>-->

然而，sqlSessionFactory和sqlSessionTemplate属性已经不建议使用了。原因在于，这两个属性不支持你使用spring提供的PropertyPlaceholderConfigurer的属性替换。例如你配置了SqlSessionFactoryBean来创建SqlSessionFactory实例，前面已经看到必须为其指定一个dataSource属性。很多用户习惯将数据源的配置放到一个独立的配置文件，如jdbc.properties文件中，之后在spring配置中，通过占位符来替换，如：

1
2
3
4
5
6
7
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <!--其他配置-->
</bean>

对于这样的配置，spring在初始化时会报错，因为MapperScannerConfigurer会在PropertyPlaceholderConfigurer初始化之前，就加载dataSource的配置，而此时PropertyPlaceholderConfigurer还未准备好替换的占位符的内容，所以抛出异常。

当然，这个问题并不是无解，我们可以使用sqlSessionFactoryBeanName、sqlSessionTemplateBeanName属性来替代sqlSessionFactory和sqlSessionTemplate属性。如下：

1
2
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
<!--<property name="sqlSessionTemplateBeanName" value="sqlSessionTemplate”/>-->

此时，你依然可以放心大胆的在你的数据源配置中，使用占位符了。

事实上，笔者总是建议你，在MapperScannerConfigurer的配置中，显示的指定sqlSessionFactoryBeanName或sqlSessionTemplateBeanName。如果你不指定，MapperScannerConfigurer就会在spring上下文中自动的寻找类型为SqlSessionFactory或者SqlSessionTemplate的bean。如果你的数据源配置中使用了占位符，还是会报错。

最后，你可能想知道，为什么MapperScannerConfigurer指定一个basePackage属性，就可以为包下的每个接口都注册一个MapperFactoryBean？其内部是如何自动在spring上下文中寻找类型为SqlSessionFactory或者SqlSessionTemplate的bean实例的？以及为什么又做了如此多限制，只有指定sqlSessionFactoryBeanName或sqlSessionTemplateBeanName才能在数据源的配置中使用占位符？

关于这些问题，笔者将在MapperScannerConfigurer的源码分析中进行解答。

整合六：@MapperScan

如果读者习惯使用注解，而不是xml文件的方式进行配置，mybatis-spring提供了@MapperScan注解，其用于取代MapperScannerConfigurer。以下演示了如何通过注解的方式来配置mybatis。

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
@MapperScan(basePackages = "com.tianshouzhi.security.mapper”,//等价于MapperScannerConfigurer的basePackage属性
        markerInterface = MybatisMapperInterface.class,//等价于MapperScannerConfigurer的markerInterface属性, 默认为null
        annotationClass = MybatisMapper.class,//等价于MapperScannerConfigurer的annotationClass属性，默认为null
        sqlSessionFactoryRef = "sqlSessionFactory")//等价于MapperScannerConfigurer的sqlSessionFactoryBeanName属性
public class DatabaseConfig {
    //定义数据源
    @Bean
    public DataSource dataSource() {
        SimpleDriverDataSource dataSource = new SimpleDriverDataSource();
        dataSource.setUsername(“your username");
        dataSource.setPassword(“you password");
        dataSource.setUrl("jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8");
        dataSource.setDriverClass(com.mysql.jdbc.Driver.class);
        return dataSource;
    }
    //定义SqlSessionFactoryBean
    @Autowired
    @Bean("sqlSessionFactory")
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
}

整合七：事务

上述所有的配置，还没有涉及到mybatis与spring进行整合另一个核心要点，即事务。整合后，我们需要将事务委派给spring来管理。

spring使用PlatformTransactionManager接口来表示一个事务管理器。其有2个重要的实现类：

​ DataSourceTransactionManager：用于支持本地事务，简单理解，你可以认为就是操作单个数据库的事务，其内部也是通过操作java.sql.Connection来开启、提交(commit)和回滚(rollback)事务。

​ JtaTransactionManager：用于支持分布式事务，其实现了JTA规范，使用XA协议进行两阶段提交。

在本文中，我们主要介绍的是DataSourceTransactionManager，绝大部分情况下， 我们使用的都是这个事务管理器。其配置方式如下：

1
2
3
4
5
6
7
8
9
<!--spring 事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--默认事务超时时间-->
        <property name="defaultTimeout" value="30000"/>
        <!--数据源-->
        <property name="dataSource" ref="dataSource" />
        <!--提交失败的话，也进行回滚-->
        <property name="rollbackOnCommitFailure" value="true"/>
    </bean>

关于事务管理器使用方式有2种：声明式事务管理、编程式事务管理

声明式事务管理

1、基于注解

首先，你需要配置事务管理是基于注解驱动的，如下：

1
<tx:annotation-driven transaction-manager="transactionManager"/>

之后，在业务bean的方法上添加@Transactional注解，此时这个方法就自动具备了事务的功能，如果出现异常，会自动回滚，没有出现异常则自动交。

1
2
3
4
5
6
@Transactional  
public void transfer(final String out,final String in,final Double money) {  
            accountMapper.outMoney(out, money);  
            int i=1/0;  
            accountMapper.inMoney(in, money);  
    }

基于注解的形式的声明式事务管理器，是最为简单的，也是建议使用的方式。

2、基于切面

如果你有很多方法，都需要有事务管理，你觉得每个方法都添加@Transactional注解比较麻烦，此时你可以使用以下配置取代tx:annotation-driven元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!-- 1.配置事务通知：（事务的增强） -->  
   <tx:advice id="txAdvice" transaction-manager="transactionManager">  
   <tx:attributes>  
        <tx:method name="transfer"/>  
   </tx:attributes>  
   </tx:advice>  
    
<!-- 2.配置切面 -->  
<aop:config>  
   <!-- 配置切入点 -->  
   <aop:pointcut id="tx_pointcut" expression="execution(*com.tianshouzhi.mybatis.AccountService+.*(..))"/>  
   <!-- 配置切面 -->  
   <aop:advisor pointcut-ref="tx_pointcut" advice-ref="txAdvice" />
</aop:config>

事实上，基于切面的配置，太麻烦了，即使对于一些老鸟，长时间没有编写过类似的配置，可能也无法立即正确的进行配置，没有@Transactional注解来的直观。

编程式事务管理

如果上述两种声明式事务的配置都不是你要想要，那么你可以采取编程式事务。你可以在业务bean中注入事务管理器，然后进行编程式事务的管理，如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class AccountService{
  @Autowired
  private DataSourceTransactionManager transactionManager;

  @Autowired
  private AccountMapper accountMapper;

  public void transfer(final String out,final String in,final Double money){
      DefaultTransactionDefinition def = new DefaultTransactionDefinition();
      def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    
      TransactionStatus status = transactionManager.getTransaction(def);
      try {
         accountMapper.outMoney(out, money);  
         int i=1/0;  
         accountMapper.inMoney(in, money);  
        transactionManager.commit(status);
      }
      catch (MyException ex) {
         transactionManager.rollback(status);
         throw ex;
      }
   }
}

另外，Spring还提供了一个TransactionTemplate，用于简化编程式事务代码的编写，配置方式如下：

1
2
3
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">  
    <property name="transactionManager"ref="transactionManager"></property>  
</bean>

使用方式如下：

1
2
3
4
5
6
7
8
9
10
11
public void transfer(final String out,final String in,final Double money) {  
    //在事务模板中执行操作  
    transactionTemplate.execute(new TransactionCallbackWithoutResult(){  
    @Override  
    protected void doInTransactionWithoutResult(TransactionStatustransactionstatus){  
        accountMapper.outMoney(out, money);  
        int i=1/0;  
        accountMapper.inMoney(in, money);  
     }  
    });  
}

总的来说，编程式事务管理还是显得略微麻烦。

整合八：springboot

mybatis开发团队为Spring Boot 提供了 mybatis-spring-boot-starter。你需要引入如下依赖：

1
2
3
4
5
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.1.1</version>
</dependency>

​ 使用了该starter之后，只需要定义一个DataSource即可，它会自动利用该DataSource创建需要使用到的SqlSessionFactoryBean、SqlSessionTemplate、以及ClassPathMapperScanner来自动扫描你的映射器接口，并针对每个接口都创建一个MapperFactoryBean，注册到Spring上下文中。

​ 关于mybatis-spring-boot-starter如何实现自动配置的相关源码，参见：org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration类。

默认情况下，扫描的basePackage是spring boot的根目录(这里指的是应用启动类Application.java类所在的目录)，且只会对添加了@Mapper注解的映射器接口进行注册。

因此，最简单的情况下，你只需要在application.yml中进行数据源的相关配置即可，以下配置依赖于spring-boot-starter-jdbc：

1
2
3
4
5
6
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis
    username: root
    password: your password

之后，你就可以直接在你的业务bean中注入映射器接口来使用了。

需要注意的是，一旦你自己提供了MapperScannerConfigurer，或者配置了MapperFactoryBean，那么mybatis-spring-boot-starter的自动配置功能将会失效。此时所有关于mybatis与spring进行整合的配置，都需要由你自行控制。

整合九：多数据源

有的时候，应用需要访问多个数据库，假设现在有两个mysql库db_user、db_acount。这个时候我们就需要配置2个数据源，来连接不同的库，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<bean id="ds_user" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="root"/>
        <property name="password" value="shxx12151022"/>
        <property name="url" value="jdbc:mysql://192.168.0.1:3306/db_user"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <!--其他配置-->
</bean>

<bean id="ds_account" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="root"/>
        <property name="password" value=“your password"/>
        <property name="url" value="jdbc:mysql://192.168.0.2:3306/db_account"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver”/>
        <!--其他配置-->
</bean>

针对上述的数据源ds_user,ds_account，我们需要为每个都配置一个SqlSessionFactoryBean，如下：

1
2
3
4
5
6
7
8
9
<bean id="ssf_user" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="ds_user"/>
        <property name="mapperLocations" value="classpath*:mybatis/mappers/db_user/**/*.xml"></property>
</bean>

<bean id="ssf_account" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="ds_account"/>
        <property name="mapperLocations" value="classpath*:mybatis/mappers/db_account/**/*.xml"></property>
</bean>

细心的读者可能已经注意到，这两个SqlSessionFactoryBean分别操作数据源ds_user、ds_account，且mapperLocations属性值指向的是不同的目录：

  • 在ssf_user中，指定关于ds_user的映射器xml文件都位于类路径的mybatis/mappers/db_user/目录下

  • 在ssf_account中，指定关于ds_account的映射器xml文件都位于类路径的mybatis/mappers/db_account/目录下

    如果你是使用映射接口的方式来操作mybatis，那么还应该针对ssf_user和ssf_account两个SqlSessionFactoryBean，各配置一个MapperScannerConfigurer。如下：

1
2
3
4
5
6
7
8
9
10
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="basePackage" value="com.tianshouzhi.mybatis.mappers.user" />
  <property name="sqlSessionFactoryBeanName" value="ssf_user"/>
</bean>


<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="basePackage" value="com.tianshouzhi.mybatis.mappers.account" />
  <property name="sqlSessionFactoryBeanName" value="ssf_account"/>
</bean>

可以看到，两个MapperScannerConfigurer的basePackage属性是不同的，我们将操作db_user库下的映射器XxxMapper接口都放在com.tianshouzhi.mybatis.mappers.user包中，将我们将操作db_account库下的映射器XxxMapper接口都放在com.tianshouzhi.mybatis.mappers.account包中。

再次提醒，在使用多数据源时，将操作不同库的xml映射文件、以及对应的映射器接口放到不同的目录下很重要，如果不这样，在使用时你几乎100%会遇到问题。

最后，由于你现在有2个数据源，因此你应该配置两个事务管理器，如：

1
2
3
4
5
6
7
<bean id="userTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="ds_user" />
</bean>

<bean id="accountTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="ds_account" />
</bean>

如果你是使用@Transactional注解来进行声明式事务管理，应该要指定你使用的是哪一个事务管理器，如：

1
2
3
4
5
6
@Transactional("accountTxManager")  
public void transfer(final String out,final String in,final Double money) {  
            accountMapper.outMoney(out, money);  
            int i=1/0;  
            accountMapper.inMoney(in, money);  
    }

一个事务管理器，只能保证操作单个库的事务，例如在这里，accountTxManager只能保证db_account库的事务，证userTxManager只能保证db_user库的事务。

如果你在一个方法内，想同时操作两个库，并保证事务，使用普通的DataSourceTransactionManager已经无法满足这种需求，这属于分布式事务的范畴。在笔者的另一篇文章atomikos JTA/XA全局事务演示了如何使用atomikos与mybatis、spring进行整合，来进行分布式事务的管理。

整合十：zebra

你应该使用：

1、使用zebra-api中提供了GroupDataSource(读写分离)或者ShardDataSource(分库分表)，而不是直接使用第三方的数据库连接池。

2、使用zebra-dao提供了ZebraMapperScannerConfigurer替代mybatis-spring原生的MapperScannerConfigurer

3、此外，你应该使用zebra-ds-monitor-client，只需引入依赖即可，会自动将连接池的监控信息上报到cat中

Posted on In
Mybatis中判断集合的 size 不为空
1
2
3
4
5
6
<if test="null != staffCodeList and staffCodeList.size > 0">
and gui.USER_CODE not in
    <foreach collection="staffCodeList" item="staffCode" open="(" separator=","  close=")">
    #{staffCode}
    </foreach>
</if>
判断参数为空

1.判断Double类型：probability = #{probability},，在实体类中probability字段是Double类型；

2.判断Integer类型：face_value = #{faceValue}, ，在实体类中faceValue字段是Integer类型；

3.判断String类型：coupon_name = #{couponName}, ，在实体类中couponName是String类型；

4.判断Date类型：begin_time = #{beginTime}, ，在实体类中beginTime字段是Date类型；

因为String类型是符合的，但是如果是Integer类型的话，如果变量的值是0,即 faceValue = 0, mybatis在进行 faceValue != ‘’ 的时候会认为 faceValue 的值是空字符串, 即 faceValue == ‘’ 为true；

同理，Double，Date也是如此。所以如果是Integer类型，Double类型，Date类型只需要判断 != null 即可。如果String类型需要判断不等于0，则需要写name != ‘0’.toString()，否则会报错。

mybatis 中 foreach collection的三种用法

mybatis 中 foreach collection的三种用法

Mybatis使用IN语句查询

Mybatis使用IN语句查询

返回数据

mybatis插入数据后返回对象id

mybatis插入返回id或对象

Posted on In

写入数据库的po，不要给字段设置默认值，除非能保证在update时，默认值不会覆盖错误。

Posted on In

selectById

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
@Select({
        "select",
        "id, source_type, source_id, name, creator, user_type, count, create_mode, status, detail_status, ",
        "build_start_time, build_end_time, import_start_time, import_end_time, front_end, create_time",
        "from dim_wm_grouping_status",
        "where id = #{id,jdbcType=INTEGER}"
    })
    @Results({
        @Result(column="id", property="id", jdbcType=JdbcType.INTEGER, id=true),
        @Result(column="source_type", property="sourceType", jdbcType=JdbcType.SMALLINT),
        @Result(column="source_id", property="sourceId", jdbcType=JdbcType.BIGINT),
        @Result(column="name", property="name", jdbcType=JdbcType.VARCHAR),
        @Result(column="creator", property="creator", jdbcType=JdbcType.VARCHAR),
        @Result(column="user_type", property="userType", jdbcType=JdbcType.INTEGER),
        @Result(column="count", property="count", jdbcType=JdbcType.INTEGER),
        @Result(column="create_mode", property="createMode", jdbcType=JdbcType.SMALLINT),
        @Result(column="status", property="status", jdbcType=JdbcType.VARCHAR),
        @Result(column="detail_status", property="detailStatus", jdbcType=JdbcType.VARCHAR),
        @Result(column="build_start_time", property="buildStartTime", jdbcType=JdbcType.TIMESTAMP),
        @Result(column="build_end_time", property="buildEndTime", jdbcType=JdbcType.TIMESTAMP),
        @Result(column="import_start_time", property="importStartTime", jdbcType=JdbcType.TIMESTAMP),
        @Result(column="import_end_time", property="importEndTime", jdbcType=JdbcType.TIMESTAMP),
        @Result(column="front_end", property="frontEnd", jdbcType=JdbcType.LONGVARCHAR),
        @Result(column="create_time", property="createTime", jdbcType=JdbcType.TIMESTAMP)
    })
    GroupingMsgPo selectById(Integer id);

selectByCondition

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
@Select({
    "<script>",
            "select",
            "id, source_type, source_id, name, creator, user_type, count, create_mode, status, detail_status, ",
            "build_start_time, build_end_time, import_start_time, import_end_time, front_end, create_time",
            "from dim_wm_grouping_status",
            "where status != '0' and create_time between #{startDate} and #{endDate}",
            "<if test='id != null'> and id=#{id} </if>",
            "<if test='name != null'> and name like concat('%', #{name}, '%') </if>",
            "<if test='creator != null'> and creator like concat('%', #{creator}, '%') </if>",
            "<if test='userType != null and userType.size > 0' >",
                "and user_type in ",
                "<foreach collection='userType' item='item' index='index' open='(' close=')' separator=','>",
                    "${item}",
                "</foreach>",
            "</if>",
            "<if test='createMode != null and createMode.size > 0' >",
                "and create_mode in",
                "<foreach collection='createMode' item='item' index='index' open='(' close=')' separator=','>",
                    "#{item}",
                "</foreach>",
            "</if>",
            "order by id desc",
            "<if test='offset != null and pageSize != null'> limit ${offset}, ${pageSize} </if>",
    "</script>"
    })
    @Results({
            @Result(column="id", property="id", jdbcType=JdbcType.INTEGER, id=true),
            @Result(column="source_type", property="sourceType", jdbcType=JdbcType.SMALLINT),
            @Result(column="source_id", property="sourceId", jdbcType=JdbcType.BIGINT),
            @Result(column="name", property="name", jdbcType=JdbcType.VARCHAR),
            @Result(column="creator", property="creator", jdbcType=JdbcType.VARCHAR),
            @Result(column="user_type", property="userType", jdbcType=JdbcType.INTEGER),
            @Result(column="count", property="count", jdbcType=JdbcType.INTEGER),
            @Result(column="create_mode", property="createMode", jdbcType=JdbcType.SMALLINT),
            @Result(column="status", property="status", jdbcType=JdbcType.VARCHAR),
            @Result(column="detail_status", property="detailStatus", jdbcType=JdbcType.VARCHAR),
            @Result(column="build_start_time", property="buildStartTime", jdbcType=JdbcType.TIMESTAMP),
            @Result(column="build_end_time", property="buildEndTime", jdbcType=JdbcType.TIMESTAMP),
            @Result(column="import_start_time", property="importStartTime", jdbcType=JdbcType.TIMESTAMP),
            @Result(column="import_end_time", property="importEndTime", jdbcType=JdbcType.TIMESTAMP),
            @Result(column="front_end", property="frontEnd", jdbcType=JdbcType.LONGVARCHAR),
            @Result(column="create_time", property="createTime", jdbcType=JdbcType.TIMESTAMP)
    })
    List<GroupingMsgPo> selectByCondition(UserGroupingMetaBo userGroupingMetaBo);

分页查询的两个参数，分别是偏移量和size。偏移量需要通过页数和size计算出来。

insert

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Insert({
        "insert into dim_wm_grouping_status (source_type, source_id, ",
        "name, creator, user_type, ",
        "count, create_mode, ",
        "status, detail_status, ",
        "build_start_time, build_end_time, ",
        "import_start_time, import_end_time, front_end, create_time)",
        "values (#{sourceType,jdbcType=SMALLINT}, #{sourceId,jdbcType=BIGINT}, ",
        "#{name,jdbcType=VARCHAR}, #{creator,jdbcType=VARCHAR}, #{userType,jdbcType=INTEGER}, ",
        "#{count,jdbcType=INTEGER}, #{createMode,jdbcType=SMALLINT}, ",
        "#{status,jdbcType=VARCHAR}, #{detailStatus,jdbcType=VARCHAR}, ",
        "#{buildStartTime,jdbcType=TIMESTAMP}, #{buildEndTime,jdbcType=TIMESTAMP}, ",
        "#{importStartTime,jdbcType=TIMESTAMP}, #{importEndTime,jdbcType=TIMESTAMP}, ",
        "#{frontEnd,jdbcType=LONGVARCHAR}, #{createTime,jdbcType=TIMESTAMP})"
    })
    @SelectKey(statement="SELECT LAST_INSERT_ID()", keyProperty="id", before=false, resultType=Integer.class)
    int insert(GroupingMsgPo record);

batchInsert

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Insert({
    "<script>",
        "insert into dim_wm_grouping_status (source_type, source_id, ",
        "name, creator, ",
        "user_type, count, ",
        "create_mode, status, ",
        "detail_status, build_start_time, ",
        "build_end_time, import_start_time, ",
        "import_end_time, front_end, create_time)",
        "values",
        "<foreach collection='list' item='item' index='index' separator=','>",
            " (#{item.sourceType,jdbcType=SMALLINT}, #{item.sourceId,jdbcType=BIGINT}, ",
            "#{item.name,jdbcType=VARCHAR}, #{item.creator,jdbcType=VARCHAR}, ",
            "#{item.userType,jdbcType=INTEGER}, #{item.count,jdbcType=INTEGER}, ",
            "#{item.createMode,jdbcType=SMALLINT}, #{item.status,jdbcType=VARCHAR}, ",
            "#{item.detailStatus,jdbcType=VARCHAR}, #{item.buildStartTime,jdbcType=TIMESTAMP}, ",
            "#{item.buildEndTime,jdbcType=TIMESTAMP}, #{item.importStartTime,jdbcType=TIMESTAMP}, ",
            "#{item.importEndTime,jdbcType=TIMESTAMP}, #{item.frontEnd,jdbcType=LONGVARCHAR},",
            "#{item.createTime,jdbcType=TIMESTAMP})",
        "</foreach>",
    "</script>",
    })
    @Options(useGeneratedKeys=true,keyProperty="id")
    int batchInsert(@Param("list") List<GroupingMsgPo> list);

update

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Update({
    "<script>",
        "update dim_wm_grouping_status",
        "set id = #{id,jdbcType=INTEGER}",
            "<if test='sourceType != null'> ,source_type = #{sourceType,jdbcType=SMALLINT}</if>",
            "<if test='sourceId != null'> ,source_id = #{sourceId,jdbcType=BIGINT} </if>",
            "<if test='name != null'> ,name = #{name,jdbcType=VARCHAR} </if>",
            "<if test='creator != null'> ,creator = #{creator,jdbcType=VARCHAR} </if>",
            "<if test='userType != null'> ,user_type = #{userType,jdbcType=INTEGER} </if>",
            "<if test='count != null'> ,count = #{count,jdbcType=INTEGER} </if>",
            "<if test='createMode != null'> ,create_mode = #{createMode,jdbcType=SMALLINT} </if>",
            "<if test='status != null'> ,status = #{status,jdbcType=VARCHAR} </if>",
            "<if test='detailStatus != null'> ,detail_status = #{detailStatus,jdbcType=VARCHAR} </if>",
            "<if test='buildStartTime != null'> ,build_start_time = #{buildStartTime,jdbcType=TIMESTAMP} </if>",
            "<if test='buildEndTime != null'> ,build_end_time = #{buildEndTime,jdbcType=TIMESTAMP} </if>",
            "<if test='importStartTime != null'> ,import_start_time = #{importStartTime,jdbcType=TIMESTAMP} </if>",
            "<if test='importEndTime != null'> ,import_end_time = #{importEndTime,jdbcType=TIMESTAMP} </if>",
            "<if test='frontEnd != null'> ,front_end = #{frontEnd,jdbcType=LONGVARCHAR} </if>",
            "<if test='createTime != null'> ,create_time = #{createTime,jdbcType=TIMESTAMP} </if>",
        "where id = #{id,jdbcType=INTEGER}",
    "</script>"
    })
    int updateById(GroupingMsgPo record);

用法对比

jdbcType=“DATE” 和 jdbcType=“TIMESTAMP” 两种类型的区别

  1. DATE只有年月日，没有时分秒

Posted on In
  1. 如果包含了不同版本的包，它的加载顺序是如何的？
  2. NoSuchMethod的报错是error级别的，exception是catch不住的。

Posted on 
1
2
21/09/08 03:17:10 WARN AbstractCoordinator [kafka-coordinator-heartbeat-thread | spark-kafka-source-babd462a-415a-413a-aeea-e55435fff762-448121830-driver-0]: [Consumer clientId=consumer-1, groupId=spark-kafka-source-babd462a-415a-413a-aeea-e55435fff762-448121830-driver-0] This member will leave the group because consumer poll timeout has expired. This means the time between subsequent calls to poll() was longer than the configured max.poll.interval.ms, which typically implies that the poll loop is spending too much time processing messages. You can address this either by increasing max.poll.interval.ms or by reducing the maximum size of batches returned in poll() with max.poll.records.

1
2
3
4
5
21/09/06 07:15:58 WARN TaskSetManager [task-result-getter-3]: Lost task 78.0 in stage 11.0 (TID 3591, wn29-msnbi.awfbdxsze1iudhhki0l2sbzfaf.bx.internal.cloudapp.net, executor 22): org.apache.kafka.common.errors.TimeoutException: Failed to allocate memory within the configured max blocking time 60000 ms.

21/09/06 07:16:57 WARN TaskSetManager [task-result-getter-1]: Lost task 112.0 in stage 11.0 (TID 3625, wn29-msnbi.awfbdxsze1iudhhki0l2sbzfaf.bx.internal.cloudapp.net, executor 22): org.apache.kafka.common.errors.TimeoutException: Expiring 22 record(s) for sambeacon-pressure-test-183:120029 ms has passed since batch creation

21/09/06 07:16:57 WARN TaskSetManager [task-result-getter-0]: Lost task 248.0 in stage 11.0 (TID 3761, wn29-msnbi.awfbdxsze1iudhhki0l2sbzfaf.bx.internal.cloudapp.net, executor 22): org.apache.kafka.common.errors.NetworkException: The server disconnected before a response was received.
1
2
3
4
5
6
7
8
9
10
Cannot fetch record for offset xxx in 120000 milliseconds

backgroud:
1. 读取3个topic，每个256partition
2. 后续的default shuffle partitions 为1200，但还没执行到这个相关的
3. offset xxx 不是我指定的startingOffsets
4. 现象是卡在读取数据的stage，并且没有任何task完成

结论：
1. 没有设置maxOffsetPerTrigger，导致读了从startingOffsets以后全部的历史数据，数据量太大，导致卡死