mybatis注解详解

  1. 云栖社区>
  2. 博客>
  3. 正文

mybatis注解详解

developerguy 2016-08-28 14:41:00 浏览2091
展开阅读全文

http://www.mybatis.org/mybatis-3/zh/sqlmap-xml.html

 

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:minhuang@hengtiansoft.com>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:minhuang@hengtiansoft.com>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

 

博客地址:【爱开卷360】http://www.cnblogs.com/ibook360

http://www.cnblogs.com/ibook360/archive/2012/07/16/2594056.html

 

网友评论

登录后评论
0/500
评论
developerguy
+ 关注