mybatis注解

来源：互联网发布：淘宝众筹不发货怎么办编辑：程序博客网时间：2024/05/29 10:52

MyBatis可以利用SQL映射文件来配置，也可以利用Annotation来设置。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.DROP TABLE IF EXISTS `blog`;
02.CREATE TABLE `blog` (
03.`id` int(10) NOT NULL auto_increment,
04.`title` varchar(200) NOT NULL,
05.`date` varchar(50) NOT NULL,
06.`authername` varchar(15) NOT NULL,
07.`content` varchar(500) NOT NULL,
08.PRIMARY KEY (`id`)
09.) ENGINE=InnoDB DEFAULT CHARSET=utf8;
数据库表User：
1.DROP TABLE IF EXISTS `user`;
2.CREATE TABLE `user` (
3.`id` int(11) NOT NULL auto_increment,
4.`userName` varchar(50) default NULL,
5.`userAge` int(11) default NULL,
6.`userAddress` varchar(200) default NULL,
7.PRIMARY KEY (`id`)
8.) ENGINE=InnoDB DEFAULT CHARSET=utf8;
3，分别写User和Blog对应的JavaBean即setter和getter实体类。
第一种映射器接口中写SQL语句
映射器接口注解

01.package com.whut.inter;
02.import java.util.List;
03.import org.apache.ibatis.annotations.Delete;
04.import org.apache.ibatis.annotations.Insert;
05.import org.apache.ibatis.annotations.Param;
06.import org.apache.ibatis.annotations.Select;
07.import org.apache.ibatis.annotations.Update;
08.import com.whut.model.User;
09.//最基本的注解CRUD
10.public interface IUserDAO {
11.@Select("select *from User")
12.public List<User> retrieveAllUsers();
13.
14.//注意这里只有一个参数，则#{}中的标识符可以任意取
15.@Select("select *from User where id=#{idss}")
16.public User retrieveUserById(int id);
17.
18.@Select("select *from User where id=#{id} and userName like #{name}")
19.public User retrieveUserByIdAndName(@Param("id")int id,@Param("name")String names);
20.
21.@Insert("INSERT INTO user(userName,userAge,userAddress) VALUES(#{userName},"
22.+ "#{userAge},#{userAddress})")
23.public void addNewUser(User user);
24.
25.@Delete("delete from user where id=#{id}")
26.public void deleteUser(int id);
27.
28.@Update("update user set userName=#{userName},userAddress=#{userAddress}"
29.+ " where id=#{id}")
30.public void updateUser(User user);
31.}
测试代码：
001.package com.whut.test;
002.import java.io.IOException;
003.import java.io.Reader;
004.import java.util.List;
005.import org.apache.ibatis.io.Resources;
006.import org.apache.ibatis.session.SqlSession;
007.import org.apache.ibatis.session.SqlSessionFactory;
008.import org.apache.ibatis.session.SqlSessionFactoryBuilder;
009.import com.whut.inter.IUserDAO;
010.import com.whut.model.User;
011.public class TestUser {
012.private static SqlSessionFactory sqlSessionFactory;
013.private static Reader reader;
014.static {
015.try {
016.Reader reader = Resources.getResourceAsReader("mybatic-config.xml");
017.sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
018.// 由于使用了注解，所以在主配置文件没有mapper，需要在代码里显示注册该mapper接口
019.sqlSessionFactory.getConfiguration().addMapper(IUserDAO.class);
020.} catch (IOException e) {
021.e.printStackTrace();
022.}
023.}
024.public static void main(String[] args) {
025.// testSelectAll();
026.// testSelectByConditions();
027.//testAddUser();
028.//testDeleteUser();
029.
030.testUpateUser();
031.}
032.public static void testSelectAll() {
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.public static void testSelectByConditions() {
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.public static void testAddUser() {
062.User u = new User();
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.public static void testDeleteUser() {
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.public static void testUpateUser() {
087.User u = new User();
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.package com.whut.inter;
02.import java.util.List;
03.import org.apache.ibatis.annotations.CacheNamespace;
04.import org.apache.ibatis.annotations.DeleteProvider;
05.import org.apache.ibatis.annotations.InsertProvider;
06.import org.apache.ibatis.annotations.Options;
07.import org.apache.ibatis.annotations.Param;
08.import org.apache.ibatis.annotations.Result;
09.import org.apache.ibatis.annotations.ResultMap;
10.import org.apache.ibatis.annotations.Results;
11.import org.apache.ibatis.annotations.SelectProvider;
12.import org.apache.ibatis.annotations.UpdateProvider;
13.import org.apache.ibatis.type.JdbcType;
14.import com.whut.model.Blog;
15.import com.whut.sqlTool.BlogSqlProvider;
16.@CacheNamespace(size=100)
17.public interface IBlogDAO {
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.public Blog getBlog(@Param("id") int id);
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.public List<Blog> getAllBlog();
37.
38.@SelectProvider(type = BlogSqlProvider.class, method = "getSqlByTitle")
39.@ResultMap(value = "sqlBlogsMap")
40.//这里调用resultMap，这个是SQL配置文件中的,必须该SQL配置文件与本接口有相同的全限定名
41.//注意文件中的namespace路径必须是使用@resultMap的类路径
42.public List<Blog> getBlogByTitle(@Param("title")String title);
43.
44.@InsertProvider(type = BlogSqlProvider.class, method = "insertSql")
45.public void insertBlog(Blog blog);
46.
47.@UpdateProvider(type = BlogSqlProvider.class, method = "updateSql")
48.public void updateBlog(Blog blog);
49.
50.@DeleteProvider(type = BlogSqlProvider.class, method = "deleteSql")
51.@Options(useCache = true, flushCache = false, timeout = 10000)
52.public void deleteBlog(int ids);
53.
54.}

SQL生成器(利用SqlBuilder生成)
01.package com.whut.sqlTool;
02.import java.util.Map;
03.import static org.apache.ibatis.jdbc.SqlBuilder.*;
04.public class BlogSqlProvider {
05.private final static String TABLE_NAME = "blog";
06.public String 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.return SQL();
14.}
15.public String getAllSql() {
16.BEGIN();
17.SELECT("*");
18.FROM(TABLE_NAME);
19.return SQL();
20.}
21.public String 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.return SQL();
29.}
30.public String 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.return SQL();
40.}
41.public String deleteSql() {
42.BEGIN();
43.DELETE_FROM(TABLE_NAME);
44.WHERE("id = #{id}");
45.return SQL();
46.}
47.public String updateSql() {
48.BEGIN();
49.UPDATE(TABLE_NAME);
50.SET("content = #{content}");
51.WHERE("id = #{id}");
52.return SQL();
53.}
54.}

注意由于在映射器接口中调用了@ResultMap,该注解内容是SQL配置文件ResultMap的ID，它是允许访问SQL配置文件中的ResultMap，则需要在相应的SQL配置相应ResultMap，然后再在主配置文件加上该SQL配置的Mapper路径。并且该SQL配置文件的namespace必须与使用@ResultMap的映射器接口的全限定相同。Blog.xml如下。
01.<?xml version="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.<mapper namespace="com.whut.inter.IBlogDAO">
05.<resultMap type="Blog" id="sqlBlogsMap">
06.<id property="id" column="id"/>
07.<result property="title" column="title"/>
08.<result property="authername" column="authername"/>
09.<result property="date" column="date"/>
10.<result property="content" column="content"/>
11.</resultMap>
12.</mapper>
再在主配置文件mybatis-config.xml加入一句mapper。
1.<mappers>
2.<mapper resource="com/whut/model/Blog.xml"/>
3.</mappers>

测试类
001.package com.whut.test;
002.import java.io.IOException;
003.import java.io.Reader;
004.import java.util.List;
005.import org.apache.ibatis.io.Resources;
006.import org.apache.ibatis.session.SqlSession;
007.import org.apache.ibatis.session.SqlSessionFactory;
008.import org.apache.ibatis.session.SqlSessionFactoryBuilder;
009.import com.whut.inter.IBlogDAO;
010.import com.whut.model.Blog;
011./**
012.* 注意这里是一种利用SqlBuilder以及多种设置来注解使用
013.* @author zxl
014.*
015.*/
016.public class TestBlog {
017.private static SqlSessionFactory sqlSessionFactory;
018.private static Reader reader;
019.static {
020.try {
021.Reader reader = Resources.getResourceAsReader("mybatic-config.xml");
022.sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
023.// 由于使用了注解，所以在主配置文件没有mapper，需要在代码里显示注册该mapper接口
024.//sqlSessionFactory.getConfiguration().addMapper(IBlogDAO.class);
025.} catch (IOException e) {
026.e.printStackTrace();
027.}
028.}
029.
030.public static void main(String[] args) {
031.//testOneBlog();
032.//testAllBlog();
033.//testBlogByTitle();
034.//testAddBlog();
035.//testDeleteBlog();
036.
037.testUpdateBlog();
038.}
039.
040.public static void testOneBlog()
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.public static void testAllBlog()
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.public static void testBlogByTitle()
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.public static void testAddBlog()
080.{
081.SqlSession session=sqlSessionFactory.openSession();
082.Blog blog=new Blog();
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.public static void testDeleteBlog()
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.public static void testUpdateBlog()
109.{
110.SqlSession session=sqlSessionFactory.openSession();
111.Blog blog=new Blog();
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。

0 0