mybatis常用注解

注解	目标	相应的XML	描述
@CacheNamespace	类	<cache>	为给定的命名空间（比如类）配置缓存。属性： implemetation,eviction, flushInterval , size 和 readWrite 。
@CacheNamespaceRef	类	<cacheRef>	参照另外一个命名空间的缓存来使用。 属性：value，也就是类的完全限定名。
@ConstructorArgs	方法	<constructor>	收集一组结果传递给对象构造方法。 属性：value，是形式参数的数组
@Arg	方法	<arg> <idArg>	单独的构造方法参数，是ConstructorArgs 集合的一部分。属性：id,column,javaType，typeHandler。 id属性是布尔值，来标识用于比较的属性，和<idArg>XML 元素相似
@TypeDiscriminator	方法	<discriminator>	一组实例值被用来决定结果映射的表 现。属性：Column, javaType , jdbcType typeHandler，cases。 cases属性就是实例的数组。
@Case	方法	<case>	单独实例的值和它对应的映射。属性：value ，type ，results 。 Results 属性是结果数组，因此这个注解和实际的ResultMap 很相似，由下面的 Results注解指定
@Results	方法	<resultMap>	结果映射的列表，包含了一个特别结果 列如何被映射到属性或字段的详情。 属性：value ，是Result注解的数组
@Result	方法	<result> <id>	在列和属性或字段之间的单独结果映 射。属性：id ，column ， property ， javaType ，jdbcType ，type Handler ， one，many。id 属性是一个布尔值，表 示了应该被用于比较的属性。one 属性是单独的联系，和 <association> 相似，而many 属性是对集合而言的，和 <collection>相似。
@One	方法	<association>	复杂类型的单独属性值映射。属性： select，已映射语句（也就是映射器方 法）的完全限定名，它可以加载合适类 型的实例。注意：联合映射在注解 API 中是不支持的。
@Many	方法	<collection>	复杂类型的集合属性映射。属性： select，是映射器方法的完全限定名，它可加载合适类型的一组实例。注意：联合映射在 Java注解中是不支持的。
@Options	方法	映射语句的属性	这个注解提供访问交换和配置选项的宽广范围，它们通常在映射语句上作为属性出现。而不是将每条语句注解变复杂，Options 注解提供连贯清晰的方式来访问它们。属性：useCache=true， flushCache=false， resultSetType=FORWARD_ONLY， statementType=PREPARED， fetchSize= -1，timeout=-1 ， useGeneratedKeys=false ， keyProperty=”id“。 理解Java 注解是很重要的，因为没有办法来指定“null ”作为值。因此，一旦你使用了 Options注解，语句就受所有默认值的支配。要注意什么样的默认值来避免不期望的行为
@Insert @Update @Delete	方法	<insert> <update> <delete>	这些注解中的每一个代表了执行的真实 SQL。它们每一个都使用字符串数组（或单独的字符串）。如果传递的是字符串数组，它们由每个分隔它们的单独空间串联起来。属性：value，这是字符串数组用来组成单独的SQL语句
@InsertProvider @UpdateProvider @DeleteProvider @SelectProvider	方法	<insert> <update> <delete> <select> 允许创建动态 SQL。	这些可选的SQL注解允许你指定一个 类名和一个方法在执行时来返回运行 的SQL。基于执行的映射语句， MyBatis 会实例化这个类，然后执行由 provider 指定的方法. 这个方法可以选择性的接 受参数对象作为它的唯一参数，但是必 须只指定该参数或者没有参数。属性： type，method。type 属性是类的完全限定名。method 是该类中的那个方法名。
@Param	参数	N/A	当映射器方法需多个参数，这个注解可以被应用于映射器方法参数来给每个参数一个名字。否则，多参数将会以它们的顺序位置来被命名。比如 #{1}，#{2} 等，这是默认的。 使用@Param(“person”)，SQL中参数应该被命名为#{person}。

这些注解都是运用到传统意义上映射器接口中的方法、类或者方法参数中的。

今天主要介绍两种使用注解的方式。

一种是直接在映射器接口中写SQL语句，一种是利用SqlBuilder来创建SQL再由映射器接口来调用

准备前提：

1，配置常规的MyBatis主配置文件，即各种数据源，别名等设置。在利用注解配置SQL的时候，一般不需要在主配置文件中配置Mapper，个别情况下需要配置。

2，数据库表Blog：

01. DROPTABLEIF EXISTS `blog`;

02. CREATETABLE`blog` (

03. `id`int(10)NOTNULLauto_increment,

04. `title`varchar(200)NOTNULL,

05. `date`varchar(50)NOTNULL,

06. `authername`varchar(15)NOTNULL,

07. `content`varchar(500)NOTNULL,

08. PRIMARYKEY (`id`)

09. ) ENGINE=InnoDBDEFAULTCHARSET=utf8;

数据库表User：

1. DROPTABLEIF EXISTS `user`;

2. CREATETABLE`user` (

3. `id`int(11)NOTNULLauto_increment,

4. `userName`varchar(50)defaultNULL,

5. `userAge`int(11)defaultNULL,

6. `userAddress`varchar(200)defaultNULL,

7. PRIMARYKEY (`id`)

8. ) ENGINE=InnoDBDEFAULTCHARSET=utf8;

3，分别写User和Blog对应的JavaBean即setter和getter实体类。

第一种 映射器接口中写SQL语句

映射器接口注解

 

01. packagecom.whut.inter;

02. importjava.util.List;

03. importorg.apache.ibatis.annotations.Delete;

04. importorg.apache.ibatis.annotations.Insert;

05. importorg.apache.ibatis.annotations.Param;

06. importorg.apache.ibatis.annotations.Select;

07. importorg.apache.ibatis.annotations.Update;

08. importcom.whut.model.User;

09. //最基本的注解CRUD

10. publicinterfaceIUserDAO {

11. @Select("select *from User")

12. publicList<User> retrieveAllUsers();

13.  

14. //注意这里只有一个参数，则#{}中的标识符可以任意取

15. @Select("select *from User where id=#{idss}")

16. publicUser retrieveUserById(intid);

17.  

18. @Select("select *from User where id=#{id} and userName like #{name}")

19. publicUser retrieveUserByIdAndName(@Param("id")intid,@Param("name")String names);

20.  

21. @Insert("INSERT INTO user(userName,userAge,userAddress) VALUES(#{userName},"

22. +"#{userAge},#{userAddress})")

23. publicvoidaddNewUser(User user);

24.  

25. @Delete("delete from user where id=#{id}")

26. publicvoiddeleteUser(intid);

27.  

28. @Update("update user set userName=#{userName},userAddress=#{userAddress}"

29. +" where id=#{id}")

30. publicvoidupdateUser(User user);

31. }

测试代码：

001. packagecom.whut.test;

002. importjava.io.IOException;

003. importjava.io.Reader;

004. importjava.util.List;

005. importorg.apache.ibatis.io.Resources;

006. importorg.apache.ibatis.session.SqlSession;

007. importorg.apache.ibatis.session.SqlSessionFactory;

008. importorg.apache.ibatis.session.SqlSessionFactoryBuilder;

009. importcom.whut.inter.IUserDAO;

010. importcom.whut.model.User;

011. publicclassTestUser {

012. privatestaticSqlSessionFactory sqlSessionFactory;

013. privatestaticReader reader;

014. static{

015. try{

016. Reader reader = Resources.getResourceAsReader("mybatic-config.xml");

017. sqlSessionFactory =newSqlSessionFactoryBuilder().build(reader);

018. // 由于使用了注解，所以在主配置文件没有mapper，需要在代码里显示注册该mapper接口

019. sqlSessionFactory.getConfiguration().addMapper(IUserDAO.class);

020. }catch(IOException e) {

021. e.printStackTrace();

022. }

023. }

024. publicstaticvoidmain(String[] args) {

025. // testSelectAll();

026. // testSelectByConditions();

027. //testAddUser();

028. //testDeleteUser();

029.  

030. testUpateUser();

031. }

032. publicstaticvoidtestSelectAll() {

033. // sqlSessionFactory.getConfiguration().addMapper(IUserDAO.class);

034. SqlSession session = sqlSessionFactory.openSession();

035. try{

036. IUserDAO userDAO = session.getMapper(IUserDAO.class);

037. List<User> users = userDAO.retrieveAllUsers();

038. System.out.println("用户编号\t"+"姓名\t"+ "年龄\t住址");

039. for(User u : users) {

040. System.out.println(u.getId() +"\t"+ u.getUserName() +"\t"

041. + u.getUserAge() +"\t"+ u.getUserAddress());

042. }

043. }finally{

044. session.close();

045. }

046. }

047. publicstaticvoidtestSelectByConditions() {

048. SqlSession session = sqlSessionFactory.openSession();

049. try{

050. IUserDAO userDAO = session.getMapper(IUserDAO.class);

051. User u = userDAO.retrieveUserByIdAndName(4,"%spring%");

052. if(u !=null) {

053. System.out.println("用户编号\t"+"姓名\t"+ "年龄\t住址");

054. System.out.println(u.getId() +"\t"+ u.getUserName() +"\t"

055. + u.getUserAge() +"\t"+ u.getUserAddress());

056. }

057. }finally{

058. session.close();

059. }

060. }

061. publicstaticvoidtestAddUser() {

062. User u =newUser();

063. u.setUserName("dongtian");

064. u.setUserAge(51);

065. u.setUserAddress("hubeisheng");

066. SqlSession session = sqlSessionFactory.openSession();

067. try{

068. IUserDAO userDAO = session.getMapper(IUserDAO.class);

069. userDAO.addNewUser(u);

070. session.commit();

071. }finally{

072. session.close();

073. }

074. }

075. publicstaticvoidtestDeleteUser() {

076. SqlSession session = sqlSessionFactory.openSession();

077. try{

078. IUserDAO userDAO = session.getMapper(IUserDAO.class);

079. userDAO.deleteUser(7);

080. session.commit();

081. }finally{

082. session.close();

083. }

084. }

085.  

086. publicstaticvoidtestUpateUser() {

087. User u =newUser();

088. u.setId(4);

089. u.setUserName("dongtian");

090. u.setUserAge(51);

091. u.setUserAddress("hubeisheng");

092. SqlSession session = sqlSessionFactory.openSession();

093. try{

094. IUserDAO userDAO = session.getMapper(IUserDAO.class);

095. userDAO.updateUser(u);

096. session.commit();

097. }finally{

098. session.close();

099. }

100. }

101. }

 

第二种 映射器接口调用SqlBuilder生成的SQL进行执行

映射器接口

 

01. packagecom.whut.inter;

02. importjava.util.List;

03. importorg.apache.ibatis.annotations.CacheNamespace;

04. importorg.apache.ibatis.annotations.DeleteProvider;

05. importorg.apache.ibatis.annotations.InsertProvider;

06. importorg.apache.ibatis.annotations.Options;

07. importorg.apache.ibatis.annotations.Param;

08. importorg.apache.ibatis.annotations.Result;

09. importorg.apache.ibatis.annotations.ResultMap;

10. importorg.apache.ibatis.annotations.Results;

11. importorg.apache.ibatis.annotations.SelectProvider;

12. importorg.apache.ibatis.annotations.UpdateProvider;

13. importorg.apache.ibatis.type.JdbcType;

14. importcom.whut.model.Blog;

15. importcom.whut.sqlTool.BlogSqlProvider;

16. @CacheNamespace(size=100)

17. publicinterfaceIBlogDAO {

18. @SelectProvider(type = BlogSqlProvider.class, method = "getSql")

19. @Results(value ={

20. @Result(id=true, property="id",column="id",javaType=Integer.class,jdbcType=JdbcType.INTEGER),

21. @Result(property="title",column="title",javaType=String.class,jdbcType=JdbcType.VARCHAR),

22. @Result(property="date",column="date",javaType=String.class,jdbcType=JdbcType.VARCHAR),

23. @Result(property="authername",column="authername",javaType=String.class,jdbcType=JdbcType.VARCHAR),

24. @Result(property="content",column="content",javaType=String.class,jdbcType=JdbcType.VARCHAR),

25. })

26. publicBlog getBlog(@Param("id")intid);

27.  

28. @SelectProvider(type = BlogSqlProvider.class, method = "getAllSql")

29. @Results(value ={

30. @Result(id=true, property="id",column="id",javaType=Integer.class,jdbcType=JdbcType.INTEGER),

31. @Result(property="title",column="title",javaType=String.class,jdbcType=JdbcType.VARCHAR),

32. @Result(property="date",column="date",javaType=String.class,jdbcType=JdbcType.VARCHAR),

33. @Result(property="authername",column="authername",javaType=String.class,jdbcType=JdbcType.VARCHAR),

34. @Result(property="content",column="content",javaType=String.class,jdbcType=JdbcType.VARCHAR),

35. })

36. publicList<Blog> getAllBlog();

37.  

38. @SelectProvider(type = BlogSqlProvider.class, method = "getSqlByTitle")

39. @ResultMap(value ="sqlBlogsMap")

40. //这里调用resultMap，这个是SQL配置文件中的,必须该SQL配置文件与本接口有相同的全限定名

41. //注意文件中的namespace路径必须是使用@resultMap的类路径

42. publicList<Blog> getBlogByTitle(@Param("title")String title);

43.  

44. @InsertProvider(type = BlogSqlProvider.class, method = "insertSql")

45. publicvoidinsertBlog(Blog blog);

46.  

47. @UpdateProvider(type = BlogSqlProvider.class, method = "updateSql")

48. publicvoidupdateBlog(Blog blog);

49.  

50. @DeleteProvider(type = BlogSqlProvider.class, method = "deleteSql")

51. @Options(useCache =true, flushCache = false, timeout = 10000)

52. publicvoiddeleteBlog(intids);

53.  

54. }

 

SQL生成器(利用SqlBuilder生成)

01. packagecom.whut.sqlTool;

02. importjava.util.Map;

03. importstaticorg.apache.ibatis.jdbc.SqlBuilder.*;

04. publicclassBlogSqlProvider {

05. privatefinalstaticString TABLE_NAME = "blog";

06. publicString getSql(Map<Integer, Object> parameter) {

07. BEGIN();

08. //SELECT("id,title,authername,date,content");

09. SELECT("*");

10. FROM(TABLE_NAME);

11. //注意这里这种传递参数方式，#{}与map中的key对应，而map中的key又是注解param设置的

12. WHERE("id = #{id}");

13. returnSQL();

14. }

15. publicString getAllSql() {

16. BEGIN();

17. SELECT("*");

18. FROM(TABLE_NAME);

19. returnSQL();

20. }

21. publicString getSqlByTitle(Map<String, Object> parameter) {

22. String title = (String) parameter.get("title");

23. BEGIN();

24. SELECT("*");

25. FROM(TABLE_NAME);

26. if(title !=null)

27. WHERE(" title like #{title}");

28. returnSQL();

29. }

30. publicString insertSql() {

31. BEGIN();

32. INSERT_INTO(TABLE_NAME);

33. VALUES("title","#{title}");

34. //  VALUES("title", "#{tt.title}");

35. //这里是传递一个Blog对象的，如果是利用上面tt.方式，则必须利用Param来设置别名

36. VALUES("date","#{date}");

37. VALUES("authername","#{authername}");

38. VALUES("content","#{content}");

39. returnSQL();

40. }

41. publicString deleteSql() {

42. BEGIN();

43. DELETE_FROM(TABLE_NAME);

44. WHERE("id = #{id}");

45. returnSQL();

46. }

47. publicString updateSql() {

48. BEGIN();

49. UPDATE(TABLE_NAME);

50. SET("content = #{content}");

51. WHERE("id = #{id}");

52. returnSQL();

53. }

54. }

 

注意由于在映射器接口中调用了@ResultMap,该注解内容是SQL配置文件ResultMap的ID，它是允许访问SQL配置文件中的ResultMap，则需要在相应的SQL配置相应ResultMap，然后再在主配置文件加上该SQL配置的Mapper路径。并且该SQL配置文件的namespace必须与使用@ResultMap的映射器接口的全限定相同。Blog.xml如下。

01. <?xmlversion="1.0"encoding="UTF-8"?>

02. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

03. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

04. <mappernamespace="com.whut.inter.IBlogDAO">

05. <resultMaptype="Blog"id="sqlBlogsMap">

06. <idproperty="id"column="id"/>

07. <resultproperty="title"column="title"/>

08. <resultproperty="authername"column="authername"/>

09. <resultproperty="date"column="date"/>

10. <resultproperty="content"column="content"/>

11. </resultMap>

12. </mapper>

再在主配置文件mybatis-config.xml加入一句mapper。

1. <mappers>

2. <mapperresource="com/whut/model/Blog.xml"/>

3. </mappers>

 

测试类

001. packagecom.whut.test;

002. importjava.io.IOException;

003. importjava.io.Reader;

004. importjava.util.List;

005. importorg.apache.ibatis.io.Resources;

006. importorg.apache.ibatis.session.SqlSession;

007. importorg.apache.ibatis.session.SqlSessionFactory;

008. importorg.apache.ibatis.session.SqlSessionFactoryBuilder;

009. importcom.whut.inter.IBlogDAO;

010. importcom.whut.model.Blog;

011. /**

012. * 注意这里是一种利用SqlBuilder以及多种设置来注解使用

013. * @author zxl

014. *

015. */

016. publicclassTestBlog {

017. privatestaticSqlSessionFactory sqlSessionFactory;

018. privatestaticReader reader;

019. static{

020. try{

021. Reader reader = Resources.getResourceAsReader("mybatic-config.xml");

022. sqlSessionFactory =newSqlSessionFactoryBuilder().build(reader);

023. // 由于使用了注解，所以在主配置文件没有mapper，需要在代码里显示注册该mapper接口

024. //sqlSessionFactory.getConfiguration().addMapper(IBlogDAO.class);

025. }catch(IOException e) {

026. e.printStackTrace();

027. }

028. }

029.  

030. publicstaticvoidmain(String[] args) {

031. //testOneBlog();

032. //testAllBlog();

033. //testBlogByTitle();

034. //testAddBlog();

035. //testDeleteBlog();

036.  

037. testUpdateBlog();

038. }

039.  

040. publicstaticvoidtestOneBlog()

041. {

042. SqlSession session=sqlSessionFactory.openSession();

043. try{

044. IBlogDAO dao=session.getMapper(IBlogDAO.class);

045. Blog  blog=dao.getBlog(2);

046. System.out.println(blog.getId()+"\t"+blog.getAuthername()+"\t"+blog.getTitle());

047. }finally{

048. session.close();

049. }

050.  

051. }

052. publicstaticvoidtestAllBlog()

053. {

054. SqlSession session=sqlSessionFactory.openSession();

055. try{

056. IBlogDAO dao=session.getMapper(IBlogDAO.class);

057. List<Blog>  blogs=dao.getAllBlog();

058. System.out.println("编号\t作者\t标题");

059. for(Blog blog:blogs)

060. System.out.println(blog.getId()+"\t"+blog.getAuthername()+"\t"+blog.getTitle());

061. }finally{

062. session.close();

063. }

064. }

065. publicstaticvoidtestBlogByTitle()

066. {

067. SqlSession session=sqlSessionFactory.openSession();

068. try{

069. IBlogDAO dao=session.getMapper(IBlogDAO.class);

070. List<Blog>  blogs=dao.getBlogByTitle("%<a href="http://www.it165.net/edu/ebg/" target="_blank" class="keylink">word</a>%");

071. System.out.println("编号\t作者\t标题");

072. for(Blog blog:blogs)

073. System.out.println(blog.getId()+"\t"+blog.getAuthername()+"\t"+blog.getTitle());

074. }finally{

075. session.close();

076. }

077. }

078.  

079. publicstaticvoidtestAddBlog()

080. {

081. SqlSession session=sqlSessionFactory.openSession();

082. Blog blog=newBlog();

083. blog.setTitle("chuntian");

084. blog.setAuthername("xiaohua");

085. blog.setDate("2013/12/25");

086. blog.setContent("bushuangyayya");

087. try{

088. IBlogDAO dao=session.getMapper(IBlogDAO.class);

089. dao.insertBlog(blog);

090. session.commit();

091. }finally{

092. session.close();

093. }

094. }

095.  

096. publicstaticvoidtestDeleteBlog()

097. {

098. SqlSession session=sqlSessionFactory.openSession();

099. try{

100. IBlogDAO dao=session.getMapper(IBlogDAO.class);

101. dao.deleteBlog(5);

102. session.commit();

103. }finally{

104. session.close();

105. }

106. }

107.  

108. publicstaticvoidtestUpdateBlog()

109. {

110. SqlSession session=sqlSessionFactory.openSession();

111. Blog blog=newBlog();

112. blog.setId(6);

113. blog.setTitle("daxuexiaoyuan");

114. blog.setAuthername("xiaohua");

115. blog.setDate("2013/2/25");

116. blog.setContent("冷死了");

117. try{

118. IBlogDAO dao=session.getMapper(IBlogDAO.class);

119. dao.updateBlog(blog);

120. session.commit();

121. }finally{

122. session.close();

123. }

124. }

125. }

 

注意事项：

1） 在利用注解配置映射器接口的时候，必须要通过

sqlSessionFactory.getConfiguration().addMapper(IBlogDAO.class);来对给映射器接口注册，如果映射器接口中使用了@ResultMap注解，则由于已经在mybatis-config.xml配置了Mapper，则就不需要再次在代码中添加mapper。

2）当方法有多个参数的时候，为了与SQL语句中的#{}对应，一般可以使用@Param("")来为每个参数命别名，使得该别名与#{}对应。当参数只有一个的时候，不需要别名。

3 在进行更新删除添加的时候，如果传递的是一个实体对象，则SQL可以直接使用实体的属性。

4）映射器接口调用SqlBuilder中的方法，都是将参数转换为Map中的key，可以在SqlBuilder的方法中利用Map来获取传递的参数值，进而进行逻辑操作判断。

5）注解中对于返回多条记录的查询可以直接利用@Results和@Result来配置映射，或者利用@ResultMap来调用SQL配置文件中的ResultMap。