mybatis注解详解

mybatis的原身是ibatis，现在已经脱离了apache基金会，新官网是http://www.mybatis.org/。

mybatis3中增加了使用注解来配置Mapper的新特性，本篇文章主要介绍其中几个@Provider的使用方式，他们是：@SelectProvider、@UpdateProvider、@InsertProvider和@DeleteProvider。

MyBatis 3 User Guide中的最后一章描述了注解的简单用法，但是对于这几个Provider的具体使用方式并没有说的很清楚，特别是参数传递的方式，完全没有提及，对于初次使用的同学来说，会造成不小的困扰。

经过一些尝试后，我总结了一些Provider的使用经验，下面以@SelectProvider为例，依次描述几种典型的使用场景。

1.使用@SelectProvider

@SelectProvider是声明在方法基本上的，这个方法定义在Mapper对应的的interface上。

1 public interface UserMapper {
2     @SelectProvider(type = SqlProvider.class, method = "selectUser")
3     @ResultMap("userMap")
4     public User getUser(long userId);
5 }

上例中是个很简单的Mapper接口，其中定义了一个方法：getUser，这个方法根据提供的用户id来查询用户信息，并返回一个User实体bean。
这是一个很简单很常用的查询场景：根据key来查询记录并将结果封装成实体bean。其中：

@SelectProvider注解用于生成查询用的sql语句，有别于@Select注解，@SelectProvide指定一个Class及其方法，并且通过调用Class上的这个方法来获得sql语句。在我们这个例子中，获取查询sql的方法是SqlProvider.selectUser。
@ResultMap注解用于从查询结果集RecordSet中取数据然后拼装实体bean。

2.定义拼装sql的类

@SelectProvide中type参数指定的Class类，必须要能够通过无参的构造函数来初始化。

@SelectProvide中method参数指定的方法，必须是public的，返回值必须为String，可以为static。

1 public class SqlProvider {
2     public String selectUser(long userId) {
3         return "select * from user where userId=" + userId;
4     }
5 }

3.无参数@SelectProvide方法
在Mapper接口方法上和@SelectProvide指定类方法上，均无参数：
UserMapper.java：

1     @SelectProvider(type = SqlProvider.class, method = "selectAllUser")
2     @ResultMap("userMap")
3     public List<User> getAllUser();

SqlProvider.java：

1     public String selectAllUser() {
2         return "select * from user";
3     }

4.一个参数的@SelectProvide方法
对于只有一个参数的情况，可以直接使用，参见前面的getUser和selectUser。
但是，如果在getUser方法中，对userId方法使用了@Param注解的话，那么相应selectUser方法必须接受Map<String, Object>做为参数：
UserMapper.java：

1     @SelectProvider(type = SqlProvider.class, method = "selectUser2")
2     @ResultMap("userMap")
3     public User getUser2(@Param("userId") long userId);

SqlProvider.java：

1     public String selectUser2(Map<String, Object> para) {
2         return "select * from user where userId=" + para.get("userId");
3     }

5.更多参数的@SelectProvide方法
在超过一个参数的情况下，@SelectProvide方法必须接受Map<String, Object>做为参数，
如果参数使用了@Param注解，那么参数在Map中以@Param的值为key，如下例中的userId；
如果参数没有使用@Param注解，那么参数在Map中以参数的顺序为key，如下例中的password：

UserMapper.java：

1     @SelectProvider(type = SqlProvider.class, method = "selectUserCheck")
2     @ResultMap("userMap")
3     public User getUserCheck(@Param("userId") long userId, String password);

SqlProvider.java：

1     public String selectUserCheck(Map<String, Object> para) {
2         return "select * from user where userId=" + para.get("userId") + " and password=‘" + para.get("1") + "‘";
3     }

6.一些限制
在Mapper接口和@SelectProvide方法类中，不要使用重载，也就是说，不要使用方法名相同参数不同的方法，以避免发生诡异问题。

http://www.blogjava.net/dbstar/archive/2011/08/08/355825.html

最近在总结过去一年所做的项目，由于开发周期或者对需求的把握不是太到位，每个项目随着所做的项目进度，从需求分析到code阶段总或多或少有一些自己感觉不是太完美或没有尽善尽美的地方，使用开源框架和第三方接口只知道接口调用，对于其内部实现机理总是存在疑惑（这家伙是怎么做的，我怎么没有想到），虽然各个项目完成后一瘸一拐的还是能满足当初的开发需求。但是对于追求完美、刨根问底性选手，心中总有根刺，感觉不爽(不知道大家有没有这种感觉)。下面通过自己的理解使用java原生的注解方式实现 spring aop的运行机理 (还没看过spring /mybatis的源代码，过年的时候研究一下大侠们有好的想法可以共享一下，话说独乐乐不如众乐乐哦）

先说说spring AOP使用上的一些限制:

1.如果切点函数有重载时，定义的通知类中方法不能实现方法重载

2.spring AOP只支持方法层面的切口定义，当然这个也是spring的基本原则如spring mvc 与struts2的区别之一就是spring mvc是基于方法的设计struts2是基于类的设计；

3.spring aop 不支持参数级的切口定义，如有时候需要对传入切口的参数进行安全性，规范性、合法性处理的时候是不支持的。当然对参数处理涉及到解析参数类型获取、参数类型判断，对于使用反射机制获取这个是有一定难度滴。

下面通过详细的代码，来讲解如何通过使用java的annotation自定义切点接口和通过反射机制实现spring AOP机制。

第一步:自定义AOP中需要的注解接口

class层注解定义：

用途：类接口切点注解定义

package com.dbc.yangg.project;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 *
 * @ClassName: MyClassAnnotation
 * @Description: 类层注解定义
 * @author guoyang2011@gmail.com
 * @date 2014年1月18日 下午11:37:51
 *
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyClassAnnotation {
  String value() default "firstAnno";
}

method层advice定义类似于Spring AOP中@Before,@After,@Around,@AfterThrowing,@AfterReturning等

用途：方法切点接口注解定义

package com.dbc.yangg.project;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 *
 * @ClassName: MySecondMethodAnnotation
 * @Description: 方法层注解定义
 * @author guoyang2011@gmail.com
 * @date 2014年1月18日 下午11:44:44
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyPointcutAnnotation {
  /**
   *
   * @Title: className
   * @Description: TODO
   * @param @return    advicer class type
   * @return Class<?>
   * @throws
   */
  Class<?> className();
  /**
   *
   * @Title: method
   * @Description: TODO
   * @param @return advicer method name
   * @return String
   * @throws
   */
  String method();//
}

method parameters 层advicer定义类似mybatis中@Param注解

功能:参数层面切点接口注解定义

package com.dbc.yangg.project;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 *
 * @ClassName: MyParameterAnnotation
 * @Description: 方法中参数层注解定义
 * @author guoyang2011@gmail.com
 * @date 2014年1月18日 下午11:45:15
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface MyParameterAnnotation {
  /**
   *
   * @Title: opType
   * @Description: method 参数类型检查
   * @param @return
   * @return MyAopParameterOPType[]
   * @throws
   */
  MyAopParameterOPType[] opType();
  /**
   *
   * @Title: paraType
   * @Description: method 参数类型
   * @param @return
   * @return Class<?>
   * @throws
   */
  Class<?> paraType();
}

处理MyAopParameterOPType类型定义

功能:定义参数切口定义注解处理的类型

package com.dbc.yangg.project;
 /**
  *
  * @ClassName: MyAopParameterOPType
  * @Description: TODO
  * @author guoyang2011@gmail.com
  * @date 2014年1月18日 下午12:07:25
  *
  */
public enum MyAopParameterOPType {
  checkForDB("DB"),//特殊字符处理 ,通用转码或者其他处理
  checkForSecurity("security"),//参数是否合法等操作
  checkDeleteAuthority("DeleteAuthority"),
  checkUpdateAuthority("UpdateAuthority");
  private String value;
  private MyAopParameterOPType(String value){
    this.value=value;
  }
  public String getValue(){
    return this.value;
  }
}

第二步:自定义AOP管理模块

主要功能:自定义AOP处理类，负责解析实际调用切点函数定义的通知

package com.dbc.yangg.project;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.apache.ibatis.annotations.SelectProvider;
/**
 *
 * @ClassName: MyAOPUtils
 * @Description:
 * @author guoyang2011@gmail.com
 * @date 2014年1月18日 下午12:01:05
 *
 */
public class MyAOPUtils {
  /**
   *
   * @Title: myAopUtilsManager
   * @Description: 切点函数参数触发通知事件,所有通知事件的处理接口
   * @param @param advicerManagerClass
   * @param @param indexArg
   * @param @param paraValues
   * @param @param paraTypes
   * @param @return
   * @return boolean
   * @throws
   */
  private static boolean parameterAdvicerUtils(Annotation advicerManagerClass,int indexArg,Object[] paraValues, Class<?>... paraTypes){
    if(advicerManagerClass instanceof MyPointcutAnnotation){
      //接口参数验证通过后执行
      //切点通知处理
      MyPointcutAnnotation AdvicerClass=(MyPointcutAnnotation)advicerManagerClass;
      Class<?> adviceClass=AdvicerClass.className();
      try {
        Method adviceMethod=adviceClass.getMethod(AdvicerClass.method(),paraTypes);
        adviceMethod.invoke(adviceClass.newInstance(), paraValues);
      } catch (NoSuchMethodException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (SecurityException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (IllegalAccessException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (IllegalArgumentException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (InvocationTargetException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (InstantiationException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }

    }else if(advicerManagerClass instanceof MyParameterAnnotation){
      //对输入的参数做一些通用处理和安全性检查等等
      //一般用在DAO层sql拼装特殊字符检查，数据格式合法性检查，转码或对调用者使用定义切点接口使用权限，安全性，等信息进行检查和确认等场合；当切点参数通过通知类中定义的接口处理后再调用切点方法；如MyBatis中通过注解@SelectProvider方式生成合法的SQL语句需要对拼装的sql语句传入的参数进行验证等，还有就是从安全新考虑对传入的模块调用者身份进行检查，MyBatis通过注解方式定义接口实现动态SQL生成中关键就是对数据类型的解析
      if(indexArg<0){
        return true;
      }
      MyParameterAnnotation AdvicerClass=(MyParameterAnnotation)advicerManagerClass;
      //处理切点方法参数的通知，大概思路如下：
      //1.解析参数类型
      //2.获取参数值
      //3.调用通知处理接口检查参数合法性
      //4.返回检查结果 true:false
    }
    return true;
  }
  /**
   *
   * @Title: myAopUtilsManager
   * @Description: Pointcut method execute advice interface
   * @param @param advicerManagerClass 类型
   * @param @param paraValues pointcut传入参数
   * @param @param paraTypes  pointcut传入参数类型
   * @return void
   * @throws
   */
  private static boolean methodAdvicerUtils(Annotation advicerManagerClass,Object[] paraValues, Class<?>... paraTypes){
    return parameterAdvicerUtils(advicerManagerClass,-1,paraValues,paraTypes);
  }
  /**
   *
   * @Title: excuteMethodAdvicers
   * @Description: TODO
   * @param @param pointJoinMethod
   * @param @param paraValues
   * @return void
   * @throws
   */
  private static boolean excuteMethodAdvicers(Method pointJoinMethod,Object[] paraValues){
    boolean result=true;
    Annotation[] methodAnns=pointJoinMethod.getAnnotations();
    for(Annotation methodAnn:methodAnns){
      result=methodAdvicerUtils(methodAnn, paraValues,pointJoinMethod.getParameterTypes());
      if(!result){
        break;
      }
    }
    return result;
  }
  /**
   *
   * @Title: excuteParameterAdvicers
   * @Description: TODO
   * @param @param pointJoinMethod
   * @param @param paraValues
   * @param @return
   * @return boolean
   * @throws
   */
  private static boolean excuteParameterAdvicers(Method pointJoinMethod,Object[] paraValues){
    boolean result=true;

    Annotation[][] parameterAnns=pointJoinMethod.getParameterAnnotations();
    if(parameterAnns==null||parameterAnns.length==0){
      return result;
    }
    for(int index=0;index<parameterAnns.length;index++){
      if(!result){
        break;
      }
      Annotation[] argAnns=parameterAnns[index];
      for(Annotation argAnn:argAnns){
        result=parameterAdvicerUtils(argAnn,index, paraValues,pointJoinMethod.getParameterTypes());
        if(!result){
          break;
        }
      }
    }
    return result;
  }
  /**
   *
   * @Title: excuteAdvicer
   * @Description: TODO
   * @param @param pointJoinMethod 切点函数
   * @param @param paraValues 切点函数 实参
   * @param @param methodResultObj 切点函数 返回类型
   * @param @return
   * @return boolean
   * @throws
   */
  /**
   *
   * @Title: excuteAdvicer
   * @Description: TODO
   * @param @param pointJoinMethod 切点函数
   * @param @param paraValues 切点函数
   * @return void
   * @throws
   */
  public static boolean excuteAdvicer(Method pointJoinMethod,Object[] paraValues,Object methodResultObj){
    boolean result=false;
    if(excuteParameterAdvicers(pointJoinMethod,paraValues))//切点函数定义的需要验证的通知验证通过后执行
    {
      result=excuteMethodAdvicers(pointJoinMethod, paraValues);
    }
    return result;
  }
}

第三步:定义业务测试类

主要功能:实际开发中的业务核心类

package com.dbc.yangg.project;
/**
 *
 * @ClassName: TestAnnotation
 * @Description: 测试模块中核心逻辑处理类,使用AOP实现日志管理、安全管理、事务管理
 * @author guoyang2011@gmail.com
 * @date 2014年1月18日 下午11:41:55
 *
 */
@MyClassAnnotation("TestAnnotation")
public class TestAnnotation extends AbstractTestAnnotation{
  @MyMethodAnnotation(methodName = "print")
  public void print() {
    // TODO Auto-generated method stub
    System.out.println("pointcut method1  running,method name:print");
  }
  /**
   *
   *   定义切点
   *   通知类{@link MyTestAdvice}
   *   通知方式函数名:doSomeIdleThing
   * @param parameter
   * @see com.dbc.yangg.project.AbstractTestAnnotation#setParameter(java.lang.String[])
   */
  @MyPointcutAnnotation(className = MyTestAdvice.class, method = "doSomeIdleThing")
  public void setParameter(
      @MyParameterAnnotation(
          opType = { MyAopParameterOPType.checkForDB,MyAopParameterOPType.checkForSecurity },
          paraType = String[].class)
      String[] parameter) {
    // TODO Auto-generated method stub
    System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    System.out.println("business method  running...");
    System.out.println("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
  }
}

第四步:定义业务AOP处理类

功能：当执行核心业务中切点时执行的通知

package com.dbc.yangg.project;
/**
 *
 * @ClassName: MyTestAdvice
 * @Description: spring AOP{@link TestAnnotation}}切点处理类 (同spring AOP 切面类@Aspect)
 * @author guoyang2011@gmail.com
 * @date 2014年1月18日 下午11:38:09
 *
 */
public class MyTestAdvice {
  /**
   *
   * @Title: doSomeIdleThing
   * @Description: {@link TestAnnotation}中setParameter切点执行时触发此通知@Before,@After,@Around,@AfterThrowing,@AfterReturning<br>
   * @param @param parameter
   * @return void
   * @throws
   */
  public void doSomeIdleThing(String[] parameter){
    System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    System.out.println("proxy method start running...");
    for(String str:parameter){
      System.out.println("advice writer!print point args value:"+str);
    }
    System.out.println("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
  }
}

第五步:测试

package com.dbc.yangg.project;  

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Init {
  public static void main(String[] args){
    try {
      String[] arg={"hadoop","hbase","pig","hive","mahout","hdfs","mapreduce","yarn"};
      Object[] objs=new Object[1];
      objs[0]=arg;
      Class busClass=Class.forName(TestAnnotation.class.getName());
      Method busMethod=busClass.getMethod("setParameter", String[].class);
      busMethod.invoke(busClass.newInstance(), objs);
      MyAOPUtils.excuteAdvicer(busMethod,objs);
    } catch (ClassNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (NoSuchMethodException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (SecurityException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IllegalAccessException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IllegalArgumentException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (InvocationTargetException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (InstantiationException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
}

测试结果:

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
business method  running...
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
proxy method start running...
advice writer:hadoop
advice writer:hbase
advice writer:pig
advice writer:hive
advice writer:mahout
advice writer:hdfs
advice writer:mapreduce
advice writer:yarn
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

http://www.tuicool.com/articles/yAvmIb

首先当然得下载mybatis-3.0.5.jar和mybatis-spring-1.0.1.jar两个JAR包，并放在WEB-INF的lib目录下(如果你使用maven，则jar会根据你的pom配置的依赖自动下载，并存放在你指定的maven本地库中，默认是~/.m2/repository)，前一个是mybatis核心包，后一个是和spring整合的包。

使用mybatis，必须有个全局配置文件configuration.xml，来配置mybatis的缓存，延迟加载等等一系列属性，该配置文件示例如下：

Java代码

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3. PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN"
  4. "http://ibatis.apache.org/dtd/ibatis-3-config.dtd">
  5. <configuration>
  6. <settings>
  7. <!-- 全局映射器启用缓存 -->
  8. <setting name="cacheEnabled" value="true" />
  9. <!-- 查询时，关闭关联对象即时加载以提高性能 -->
  10. <setting name="lazyLoadingEnabled" value="true" />
  11. <!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指 定)，不会加载关联表的所有字段，以提高性能 -->
  12. <setting name="aggressiveLazyLoading" value="false" />
  13. <!-- 对于未知的SQL查询，允许返回不同的结果集以达到通用的效果 -->
  14. <setting name="multipleResultSetsEnabled" value="true" />
  15. <!-- 允许使用列标签代替列名 -->
  16. <setting name="useColumnLabel" value="true" />
  17. <!-- 允许使用自定义的主键值(比如由程序生成的UUID 32位编码作为键值)，数据表的PK生成策略将被覆盖 -->
  18. <setting name="useGeneratedKeys" value="true" />
  19. <!-- 给予被嵌套的resultMap以字段-属性的映射支持 -->
  20. <setting name="autoMappingBehavior" value="FULL" />
  21. <!-- 对于批量更新操作缓存SQL以提高性能 -->
  22. <setting name="defaultExecutorType" value="BATCH" />
  23. <!-- 数据库超过25000秒仍未响应则超时 -->
  24. <setting name="defaultStatementTimeout" value="25000" />
  25. </settings>
  26. <!-- 全局别名设置，在映射文件中只需写别名，而不必写出整个类路径 -->
  27. <typeAliases>
  28. <typeAlias alias="TestBean"
  29. type="com.wotao.taotao.persist.test.dataobject.TestBean" />
  30. </typeAliases>
  31. <!-- 非注解的sql映射文件配置，如果使用mybatis注解，该mapper无需配置，但是如果mybatis注解中包含@resultMap注解，则mapper必须配置，给resultMap注解使用 -->
  32. <mappers>
  33. <mapper resource="persist/test/orm/test.xml" />
  34. </mappers>
  35. </configuration>

该文件放在资源文件的任意classpath目录下，假设这里就直接放在资源根目录，等会spring需要引用该文件。

查看ibatis-3-config.dtd发现除了settings和typeAliases还有其他众多元素，比如properties,objectFactory,environments等等，这些元素基本上都包含着一些环境配置，数据源定义，数据库事务等等，在单独使用mybatis的时候非常重要，比如通过以构造参数的形式去实例化一个sqlsessionFactory，就像这样：

Java代码

  1. SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader);
  2. SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, properties);
  3. SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, environment, properties);

而typeHandlers则用来自定义映射规则，如你可以自定义将Character映射为varchar，plugins元素则放了一些拦截器接口，你可以继承他们并做一些切面的事情，至于每个元素的细节和使用，你参考mybatis用户指南即可。

现在我们用的是spring，因此除settings和typeAliases元素之外，其他元素将会失效，故不在此配置，spring会覆盖这些元素的配置，比如在spring配置文件中指定c3p0数据源定义如下：

Java代码

  1. <!-- c3p0 connection pool configuration -->
  2. <bean id="testDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
  3. destroy-method="close">
  4. <!-- 数据库驱动 -->
  5. <property name="driverClass" value="${db.driver.class}" />
  6. <!-- 连接URL串 -->
  7. <property name="jdbcUrl" value="${db.url}" />
  8. <!-- 连接用户名 -->
  9. <property name="user" value="${db.username}" />
  10. <!-- 连接密码 -->
  11. <property name="password" value="${db.password}" />
  12. <!-- 初始化连接池时连接数量为5个 -->
  13. <property name="initialPoolSize" value="5" />
  14. <!-- 允许最小连接数量为5个 -->
  15. <property name="minPoolSize" value="5" />
  16. <!-- 允许最大连接数量为20个 -->
  17. <property name="maxPoolSize" value="20" />
  18. <!-- 允许连接池最大生成100个PreparedStatement对象 -->
  19. <property name="maxStatements" value="100" />
  20. <!-- 连接有效时间，连接超过3600秒未使用，则该连接丢弃 -->
  21. <property name="maxIdleTime" value="3600" />
  22. <!-- 连接用完时，一次产生的新连接步进值为2 -->
  23. <property name="acquireIncrement" value="2" />
  24. <!-- 获取连接失败后再尝试10次，再失败则返回DAOException异常 -->
  25. <property name="acquireRetryAttempts" value="10" />
  26. <!-- 获取下一次连接时最短间隔600毫秒，有助于提高性能 -->
  27. <property name="acquireRetryDelay" value="600" />
  28. <!-- 检查连接的有效性，此处小弟不是很懂什么意思 -->
  29. <property name="testConnectionOnCheckin" value="true" />
  30. <!-- 每个1200秒检查连接对象状态 -->
  31. <property name="idleConnectionTestPeriod" value="1200" />
  32. <!-- 获取新连接的超时时间为10000毫秒 -->
  33. <property name="checkoutTimeout" value="10000" />
  34. </bean>

配置中的${}都是占位符，在你指定数据库驱动打war时会自动替换，替换的值在你的父pom中配置，至于c3p0连接池的各种属性详细信息和用法，你自行参考c3p0的官方文档，这里要说明的是checkoutTimeout元素，记得千万要设大一点，单位是毫秒，假如设置太小，有可能会导致没等数据库响应就直接超时了，小弟在这里吃了不少苦头，还是基本功太差。

数据源配置妥当之后，我们就要开始非常重要的sessionFactory配置了，无论是hibernate还是mybatis，都需要一个sessionFactory来生成session，sessionFactory配置如下：

Java代码

  1. <bean id="testSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  2. <property name="configLocation" value="classpath:configuration.xml" />
  3. <property name="dataSource" ref="testDataSource" />
  4. </bean>

testSqlSessionFactory有两处注入，一个就是前面提到的mybatis全局设置文件configuration.xml，另一个就是上面定义的数据源了（注：hibernate的sessionFactory只需注入hibernate.cfg.xml，数据源定义已经包含在该文件中），好了，sessionFactory已经产生了，由于我们用的mybatis3的注解，因此spring的sqlSessionTemplate也不用配置了，sqlSessionTemplate也不用注入到我们的BaseDAO中了，相应的，我们需要配置一个映射器接口来对应sqlSessionTemplate，该映射器接口定义了你自己的接口方法，具体实现不用关心，代码如下：

Java代码

  1. <!-- data OR mapping interface -->
  2. <bean id="testMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
  3. <property name="sqlSessionFactory" ref="testSqlSessionFactory" />
  4. <property name="mapperInterface" value="com.wotao.taotao.persist.test.mapper.TestMapper" />
  5. </bean>

对应于sqlSessionTemplate，testMapper同样需要testSqlSessionFactory注入，另外一个注入就是你自己定义的Mapper接口，该接口定义了操作数据库的方法和SQL语句以及很多的注解，稍后我会讲到。到此，mybatis和spring整合的文件配置就算OK了（注：如果你需要开通spring对普通类的代理功能，那么你需要在spring配置文件中加入<aop:aspectj-autoproxy />），至于其他的如事务配置，AOP切面注解等内容不在本文范围内，不作累述。

至此，一个完整的myabtis整合spring的配置文件看起来应该如下所示：

Java代码

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  4. xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  6. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  7. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
  8. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
  9. <!-- c3p0 connection pool configuration -->
  10. <bean id="testDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
  11. destroy-method="close">
  12. <property name="driverClass" value="${db.driver.class}" />
  13. <property name="jdbcUrl" value="${db.url}" />
  14. <property name="user" value="${db.username}" />
  15. <property name="password" value="${db.password}" />
  16. <property name="initialPoolSize" value="5" />
  17. <property name="minPoolSize" value="5" />
  18. <property name="maxPoolSize" value="20" />
  19. <property name="maxStatements" value="100" />
  20. <property name="maxIdleTime" value="3600" />
  21. <property name="acquireIncrement" value="2" />
  22. <property name="acquireRetryAttempts" value="10" />
  23. <property name="acquireRetryDelay" value="600" />
  24. <property name="testConnectionOnCheckin" value="true" />
  25. <property name="idleConnectionTestPeriod" value="1200" />
  26. <property name="checkoutTimeout" value="10000" />
  27. </bean>
  28. <bean id="testSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  29. <property name="configLocation" value="classpath:configuration.xml" />
  30. <property name="dataSource" ref="testDataSource" />
  31. </bean>
  32. <!-- data OR mapping interface -->
  33. <bean id="testMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
  34. <property name="sqlSessionFactory" ref="testSqlSessionFactory" />
  35. <property name="mapperInterface" value="com.wotao.taotao.persist.test.mapper.TestMapper" />
  36. </bean>
  37. <!-- add your own Mapper here -->
  38. <!-- comment here, using annotation -->
  39. <!-- <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate"> -->
  40. <!-- <constructor-arg index="0" ref="sqlSessionFactory" /> -->
  41. <!-- </bean> -->
  42. <!-- base DAO class, for module business, extend this class in DAO -->
  43. <!-- <bean id="testBaseDAO" class="com.test.dao.TestBaseDAO"> -->
  44. <!-- <property name="sqlSessionTemplate" ref="sqlSessionTemplate" /> -->
  45. <!-- </bean> -->
  46. <!-- <bean id="testDAO" class="com.test.dao.impl.TestDAOImpl" /> -->
  47. <!-- you can DI Bean if you don‘t like use annotation -->
  48. </beans>

到此为止，我们只讲了mybatis和spring的整合，还没有真正触及mybatis的核心：使用mybatis注解代替映射文件编程（不过官方文档也说了，如果真正想发挥mybatis功能，还是需要用到映射文件，看来myabtis自己都对mybatis注解没信心，呵呵），通过上述内容，我们知道配置搞定，但是testMapper还没有被实现，而注解的使用，全部集中在这个testMapper上，是mybatis注解的核心所在，先来看一下这个testMapper接口是个什么样的：

Java代码

  1. /**
  2. * The test Mapper interface.
  3. *
  4. * @author HuangMin <a href="mailto:[email protected]>send email</a>
  5. *
  6. * @since 1.6
  7. * @version 1.0
  8. *
  9. * #~TestMapper.java 2011-9-23 : afternoon 10:51:40
  10. */
  11. @CacheNamespace(size = 512)
  12. public interface TestMapper {
  13. /**
  14. * get test bean by UID.
  15. *
  16. * @param id
  17. * @return
  18. */
  19. @SelectProvider(type = TestSqlProvider.class, method = "getSql")
  20. @Options(useCache = true, flushCache = false, timeout = 10000)
  21. @Results(value = {
  22. @Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR),
  23. @Result(property = "testText", column = "test_text", javaType = String.class, jdbcType = JdbcType.VARCHAR) })
  24. public TestBean get(@Param("id") String id);
  25. /**
  26. * get all tests.
  27. *
  28. * @return
  29. */
  30. @SelectProvider(type = TestSqlProvider.class, method = "getAllSql")
  31. @Options(useCache = true, flushCache = false, timeout = 10000)
  32. @Results(value = {
  33. @Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR),
  34. @Result(property = "testText", column = "test_text", javaType = String.class, jdbcType = JdbcType.VARCHAR) })
  35. public List<TestBean> getAll();
  36. /**
  37. * get tests by test text.
  38. *
  39. * @param testText
  40. * @return
  41. */
  42. @SelectProvider(type = TestSqlProvider.class, method = "getByTestTextSql")
  43. @Options(useCache = true, flushCache = false, timeout = 10000)
  44. @ResultMap(value = "getByTestText")
  45. public List<TestBean> getByTestText(@Param("testText") String testText);
  46. /**
  47. * insert a test bean into database.
  48. *
  49. * @param testBean
  50. */
  51. @InsertProvider(type = TestSqlProvider.class, method = "insertSql")
  52. @Options(flushCache = true, timeout = 20000)
  53. public void insert(@Param("testBean") TestBean testBean);
  54. /**
  55. * update a test bean with database.
  56. *
  57. * @param testBean
  58. */
  59. @UpdateProvider(type = TestSqlProvider.class, method = "updateSql")
  60. @Options(flushCache = true, timeout = 20000)
  61. public void update(@Param("testBean") TestBean testBean);
  62. /**
  63. * delete a test by UID.
  64. *
  65. * @param id
  66. */
  67. @DeleteProvider(type = TestSqlProvider.class, method = "deleteSql")
  68. @Options(flushCache = true, timeout = 20000)
  69. public void delete(@Param("id") String id);
  70. }

下面逐个对里面的注解进行分析：
@CacheNamespace(size = 512) ： 定义在该命名空间内允许使用内置缓存，最大值为512个对象引用，读写默认是开启的，缓存内省刷新时间为默认3600000毫秒，写策略是拷贝整个对象镜像到全新堆（如同CopyOnWriteList）因此线程安全。

@SelectProvider(type = TestSqlProvider.class, method = "getSql") ： 提供查询的SQL语句，如果你不用这个注解，你也可以直接使用@Select("select * from ....")注解，把查询SQL抽取到一个类里面，方便管理，同时复杂的SQL也容易操作，type = TestSqlProvider.class就是存放SQL语句的类，而method = "getSql"表示get接口方法需要到TestSqlProvider类的getSql方法中获取SQL语句。

@Options(useCache = true, flushCache = false, timeout = 10000) ： 一些查询的选项开关，比如useCache = true表示本次查询结果被缓存以提高下次查询速度，flushCache = false表示下次查询时不刷新缓存，timeout = 10000表示查询结果缓存10000秒。

@Results(value = {
@Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR),
@Result(property = "testText", column = "test_text", javaType = String.class, jdbcType = JdbcType.VARCHAR) }) ： 表示sql查询返回的结果集，@Results是以@Result为元素的数组，@Result表示单条属性-字段的映射关系，如：@Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR)可以简写为：@Result(id = true, property = "id", column = "test_id")，id = true表示这个test_id字段是个PK，查询时mybatis会给予必要的优化，应该说数组中所有的@Result组成了单个记录的映射关系，而@Results则单个记录的集合。另外还有一个非常重要的注解@ResultMap也和@Results差不多，到时会讲到。

@Param("id") ：全局限定别名，定义查询参数在sql语句中的位置不再是顺序下标0,1,2,3....的形式，而是对应名称，该名称就在这里定义。

@ResultMap(value = "getByTestText") ：重要的注解，可以解决复杂的映射关系，包括resultMap嵌套，鉴别器discriminator等等。注意一旦你启用该注解，你将不得不在你的映射文件中配置你的resultMap，而value = "getByTestText"即为映射文件中的resultMap ID(注意此处的value = "getByTestText"，必须是在映射文件中指定命名空间路径)。@ResultMap在某些简单场合可以用@Results代替，但是复杂查询，比如联合、嵌套查询@ResultMap就会显得解耦方便更容易管理。
一个映射文件如下所示：

Java代码

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3. PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"
  4. "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">
  5. <mapper namespace="com.wotao.taotao.persist.test.mapper.TestMapper">
  6. <resultMap id="getByTestText" type="TestBean">
  7. <id property="id" column="test_id" javaType="string" jdbcType="VARCHAR" />
  8. <result property="testText" column="test_text" javaType="string" jdbcType="VARCHAR" />
  9. </resultMap>
  10. </mapper>

注意文件中的namespace路径必须是使用@resultMap的类路径，此处是TestMapper，文件中 id="getByTestText"必须和@resultMap中的value = "getByTestText"保持一致。

@InsertProvider(type = TestSqlProvider.class, method = "insertSql") ：用法和含义@SelectProvider一样，只不过是用来插入数据库而用的。

@Options(flushCache = true, timeout = 20000) ：对于需要更新数据库的操作，需要重新刷新缓存flushCache = true使缓存同步。

@UpdateProvider(type = TestSqlProvider.class, method = "updateSql") ：用法和含义@SelectProvider一样，只不过是用来更新数据库而用的。

@Param("testBean") ：是一个自定义的对象，指定了sql语句中的表现形式，如果要在sql中引用对象里面的属性，只要使用testBean.id，testBean.textText即可，mybatis会通过反射找到这些属性值。

@DeleteProvider(type = TestSqlProvider.class, method = "deleteSql") ：用法和含义@SelectProvider一样，只不过是用来删除数据而用的。

现在mybatis注解基本已经讲完了，接下来我们就要开始写SQL语句了，因为我们不再使用映射文件编写SQL，那么就不得不在java类里面写，就像上面提到的，我们不得不在TestSqlProvider这个类里面写SQL，虽然已经把所有sql语句集中到了一个类里面去管理，但听起来似乎仍然有点恶心，幸好mybatis提供SelectBuilder和SqlBuilder这2个小工具来帮助我们生成SQL语句，SelectBuilder专门用来生成select语句，而SqlBuilder则是一般性的工具，可以生成任何SQL语句，我这里选择了SqlBuilder来生成，TestSqlProvider代码如下：

Java代码

  1. /*
  2. * #~ test-afternoon10:51:40
  3. */
  4. package com.wotao.taotao.persist.test.sqlprovider;
  5. import static org.apache.ibatis.jdbc.SqlBuilder.BEGIN;
  6. import static org.apache.ibatis.jdbc.SqlBuilder.FROM;
  7. import static org.apache.ibatis.jdbc.SqlBuilder.SELECT;
  8. import static org.apache.ibatis.jdbc.SqlBuilder.SQL;
  9. import static org.apache.ibatis.jdbc.SqlBuilder.WHERE;
  10. import static org.apache.ibatis.jdbc.SqlBuilder.DELETE_FROM;
  11. import static org.apache.ibatis.jdbc.SqlBuilder.INSERT_INTO;
  12. import static org.apache.ibatis.jdbc.SqlBuilder.SET;
  13. import static org.apache.ibatis.jdbc.SqlBuilder.UPDATE;
  14. import static org.apache.ibatis.jdbc.SqlBuilder.VALUES;
  15. import java.util.Map;
  16. /**
  17. * The test sql Provider,define the sql script for mapping.
  18. *
  19. * @author HuangMin <a href="mailto:[email protected]>send email</a>
  20. *
  21. * @since 1.6
  22. * @version 1.0
  23. *
  24. * #~TestSqlProvider.java 2011-9-23 : afternoon 10:51:40
  25. */
  26. public class TestSqlProvider {
  27. /** table name, here is test */
  28. private static final String TABLE_NAME = "test";
  29. /**
  30. * get test by id sql script.
  31. *
  32. * @param parameters
  33. * @return
  34. */
  35. public String getSql(Map<String, Object> parameters) {
  36. String uid = (String) parameters.get("id");
  37. BEGIN();
  38. SELECT("test_id, test_text");
  39. FROM(TABLE_NAME);
  40. if (uid != null) {
  41. WHERE("test_id = #{id,javaType=string,jdbcType=VARCHAR}");
  42. }
  43. return SQL();
  44. }
  45. /**
  46. * get all tests sql script.
  47. *
  48. * @return
  49. */
  50. public String getAllSql() {
  51. BEGIN();
  52. SELECT("test_id, test_text");
  53. FROM(TABLE_NAME);
  54. return SQL();
  55. }
  56. /**
  57. * get test by test text sql script.
  58. *
  59. * @param parameters
  60. * @return
  61. */
  62. public String getByTestTextSql(Map<String, Object> parameters) {
  63. String tText = (String) parameters.get("testText");
  64. BEGIN();
  65. SELECT("test_id, test_text");
  66. FROM(TABLE_NAME);
  67. if (tText != null) {
  68. WHERE("test_text like #{testText,javaType=string,jdbcType=VARCHAR}");
  69. }
  70. return SQL();
  71. }
  72. /**
  73. * insert a test sql script.
  74. *
  75. * @return
  76. */
  77. public String insertSql() {
  78. BEGIN();
  79. INSERT_INTO(TABLE_NAME);
  80. VALUES("test_id", "#{testBean.id,javaType=string,jdbcType=VARCHAR}");
  81. VALUES("test_text", "#{testBean.testText,javaType=string,jdbcType=VARCHAR}");
  82. return SQL();
  83. }
  84. /**
  85. * update a test sql script.
  86. *
  87. * @return
  88. */
  89. public String updateSql() {
  90. BEGIN();
  91. UPDATE(TABLE_NAME);
  92. SET("test_text = #{testBean.testText,javaType=string,jdbcType=VARCHAR}");
  93. WHERE("test_id = #{testBean.id,javaType=string,jdbcType=VARCHAR}");
  94. return SQL();
  95. }
  96. /**
  97. * delete a test sql script.
  98. *
  99. * @return
  100. */
  101. public String deleteSql() {
  102. BEGIN();
  103. DELETE_FROM(TABLE_NAME);
  104. WHERE("test_id = #{id,javaType=string,jdbcType=VARCHAR}");
  105. return SQL();
  106. }
  107. }

BEGIN();表示刷新本地线程，某些变量为了线程安全，会先在本地存放变量，此处需要刷新。
SELECT，FROM，WHERE等等都是sqlbuilder定义的公用静态方法，用来组成你的sql字符串。如果你在testMapper中调用该方法的某个接口方法已经定义了参数@Param()，那么该方法的参数Map<String, Object> parameters即组装了@Param()定义的参数，比如testMapper接口方法中定义参数为@Param("testId"),@Param("testText")，那么parameters的形态就是：[key="testId",value=object1],[key="testText",value=object2]，如果接口方法没有定义@Param()，那么parameters的key就是参数的顺序小标：[key=0,value=object1],[key=1,value=object2]，SQL()将返回最终append结束的字符串，sql语句中的形如
#{id,javaType=string,jdbcType=VARCHAR}完全可简写为#{id}，我只是为了规整如此写而已。另外，对于复杂查询还有很多标签可用，比如：JOIN，INNER_JOIN，GROUP_BY，ORDER_BY等等，具体使用详情，你可以查看源码。

最后记得把你的Mapper接口注入到你的DAO类中，在DAO中引用Mapper接口方法即可。我在BaseDAO中的注解注入如下：

Java代码

  1. ......
  2. @Repository("testBaseDAO")
  3. public class TestBaseDAO {
  4. ......

Java代码

  1. ......
  2. /**
  3. * @param testMapper
  4. * the testMapper to set
  5. */
  6. @Autowired
  7. public void setTestMapper(@Qualifier("testMapper") TestMapper testMapper) {
  8. this.testMapper = testMapper;
  9. }
  10. ......

引自：http://wwww.iteye.com/blog/1235996

时间： 2024-10-17 17:00:18

mybatis注解详解的相关文章

MyBatis Geneator 详解

MyBatis Geneator详解 作者:abel533(isea533) 博客地址:http://blog.csdn.net/isea533 github:https://github.com/abel533 gitosc:http://git.oschina.net/free 本文使用Markdown进行编辑,但是博客显示效果不好,所以建议移步这里进行阅读 本文是作为个人筹划的<Mybatis最佳实践>(gitbook)其中的一节. 本文中所有节点的链接都是对应的中文文档地址,可以点击查

【转】@RequestParam @RequestBody @PathVariable 等参数绑定注解详解

@RequestParam @RequestBody @PathVariable 等参数绑定注解详解 2014-06-02 11:24 23683人阅读 评论(2) 收藏 举报 目录(?)[+] 引言: 接上一篇文章,对@RequestMapping进行地址映射讲解之后,该篇主要讲解request 数据到handler method 参数数据的绑定所用到的注解和什么情形下使用: 简介: handler method 参数绑定常用的注解,我们根据他们处理的Request的不同内容部分分为四类:(主

Spring中常用的配置和注解详解

一.  Spring中常用的配置文件详解 Spring中的配置文件详解 1.<!-- 配置注解bean的扫描路径 该配置表示从cn包下开始扫描--> <context:component-scan base-package="cn"></context:component-scan> 2.<!-- 加载资源文件 其中Location表示从哪个路径加载配置文件properties--> <context:property-placeh

Java——注解详解

Java注解同 classs 和 interface 一样,注解也属于一种类型.它是在 Java SE 5.0 版本中开始引入的概念. 注解的定义 通过 @interface 关键字进行定义. public @interface TestAnnotation { } 这段代码就创建了一个名字为 TestAnnotaion 的注解. 你可以简单理解为创建了一张名字为 TestAnnotation 的标签. 使用注解 @TestAnnotation public class Test { } 在类上

Java基础13：反射与注解详解

Java基础13:反射与注解详解 什么是反射? 反射(Reflection)是Java 程序开发语言的特征之一,它允许运行中的 Java 程序获取自身的信息,并且可以操作类或对象的内部属性. Oracle官方对反射的解释是 Reflection enables Java code to discover information about the fields, methods and constructors of loaded classes, and to use reflected fi

MyBatis—02—代替Dao层的mapper映射文件；MyBatis配置文件详解

一. Mapper 映射文件 在JDBC中,我们会把访问数据库的代码放在Dao层,也就是建一个com.dao的package: 但在 MyBatis 中, 我们的包名推荐使用 mapper ,  并且我们只需要写一个映射配置文件即可, 不需要写接口和实现类了. UserMapper.xml, 用于定义要执行的 SQL 语句, 同时设定返回结果的类型. 1.编写mapper层的xml映射文件 2. 在MyBatis核心配置文件中添加 mapper 扫描 3.测试 二. MyBatis 配置文件详解

MyBatis Generator 详解

MyBatis Generator中文文档 MyBatis Generator中文文档地址:http://mbg.cndocs.tk/ 该中文文档由于尽可能和原文内容一致,所以有些地方如果不熟悉,看中文版的文档的也会有一定的障碍,所以本章根据该中文文档以及实际应用,使用通俗的语言来讲解详细的配置. 本文中所有节点的链接都是对应的中文文档地址,可以点击查看详细信息. 注:本文后面提到的MBG全部指代MyBatis Generator. MyBatis Generator 1.3.4 扩展,可以设置

MyBatis Generator 详解 【转来纯为备忘】

版权声明:版权归博主所有,转载请带上本文链接!联系方式:[email protected] 目录(?)[+] MyBatis Generator中文文档 运行MyBatis Generator XML配置详解 配置文件头 根节点generatorConfiguration generatorConfiguration子元素 1 properties 元素 2 classPathEntry 元素 3 context 元素 31 plugin 元素 32 commentGenerator 元素 33

MyBatis Generator详解

MyBatis Generator中文文档 MyBatis Generator中文文档地址: http://mbg.cndocs.tk/ 本文中所有节点的链接都是对应的中文文档地址,可以点击查看详细信息. 下载本文档的PDF版本 注:本文后面提到的MBG全部指代MyBatis Generator. 运行MyBatis Generator 有4种运行MBG的方法,具体请看文档 运行 MyBatis Generator MBG下载地址:http://repo1.maven.org/maven2/or