您的位置：首页 > 编程语言 > Java开发

基于spring创建通用的Mybatis类

2015-06-29 21:56 387 查看

基于spring创建通用的Mybatis类

一、环境

1. 开发环境：windows7，jdk1.8, mysql5.5，maven3

2. 使用工具：eclipse(Luna Service Release 1 (4.4.1))

二、简单说明

使用mybatis的拦截器进行通用类设计。同时使用注解方法进行sql脚本的生成,可用于项目中，虽然与不使用拦截器，使用XML进行SQL脚本生成在性能上有一定的差异（第一次执行时性能差异很大），但不大，而且简化开发。

三、源代码

1. 表生成SQL脚本

CREATE TABLE `user_info` (

`user_id` bigint(14) NOT NULL AUTO_INCREMENT COMMENT '用户ID',

`user_name` varchar(30) NOT NULL COMMENT '用户姓名',

`pass_word` varchar(32) NOT NULL COMMENT '用户密码',

`account` varchar(30) NOT NULL COMMENT '用户账号',

PRIMARY KEY (`user_id`)

) ENGINE=InnoDB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8 COMMENT='用户基础信息表'

2. Pom.xml

<projectxmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion>
<groupId>common</groupId>
<artifactId>common-mybatis</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>common-mybatis</name>
<description>创建通用的dao</description>
<properties>
<commons.lang.version>2.6</commons.lang.version>
<spring.version>3.1.4.RELEASE</spring.version>
<slf4j.version>1.6.1</slf4j.version>
<mybatis.version>3.2.8</mybatis.version>
<mybatis-spring.version>1.2.2</mybatis-spring.version>
<c3p0.version>0.9.1.2</c3p0.version>
<mysql-connector-java.version>5.1.10</mysql-connector-java.version>
<junit.version>4.12</junit.version>

</properties>
<dependencies>
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>${commons.lang.version}</version>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>${c3p0.version}</version>
</dependency>
<dependency>

<groupId>org.aspectj</groupId>

<artifactId>aspectjweaver</artifactId>

<version>1.8.5</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql-connector-java.version}</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>${mybatis-spring.version}</version>
</dependency>
<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>${junit.version}</version>
</dependency>
</dependencies>
</project>

3. 注解 (Id, Virtual)

package com.common.annotation;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

* 用于DTO，标明此DTO属性对应为主键

* @author szy

*

*/

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)

public @interface Id {

}

package com.common.annotation;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

* 用于DTO，当此DTO上的属性不需要DML时使用

* @author szy

*

*/

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)

public @interface Virtual {

}

4. DO

package com.common.mybatis.model;
import java.io.Serializable;
import com.common.annotation.Id;
publicclass UserInfoimplements Serializable
{
privatestaticfinallongserialVersionUID
= 3307279233947614156L;

@Id
private LonguserId;
private StringuserName;
private StringpassWord;
private Stringaccount;
public Long getUserId() {
returnuserId;
}
publicvoid setUserId(LonguserId)
{
this.userId =userId;
}
public String getUserName() {
returnuserName;
}
publicvoid setUserName(StringuserName)
{
this.userName =userName;
}
public String getPassWord() {
returnpassWord;
}
publicvoid setPassWord(StringpassWord)
{
this.passWord =passWord;
}
public String getAccount() {
returnaccount;
}
publicvoid setAccount(Stringaccount)
{
this.account =account;
}
}

5. DAO(baseDao,UserInfoDao)

package com.common.mybatis.dao;

import java.util.List;

import java.util.Map;

import org.apache.ibatis.annotations.DeleteProvider;

import org.apache.ibatis.annotations.InsertProvider;

import org.apache.ibatis.annotations.Options;

import org.apache.ibatis.annotations.Param;

import org.apache.ibatis.annotations.SelectProvider;

import org.apache.ibatis.annotations.UpdateProvider;

import com.common.utils.MyBatisTemplate;

/**

* 继承此类注意：泛型为Serializable接口实现Bean,bean中使用@Id声明主键(不支持联合主键，只有一个属性是主键)，使用@NotColumn声明不持久化的属性

* 子类class上使用@RegisterDto注册要持久化的Bean

* 继承的子类不得覆盖此类方法

* @author szy

*

* @param <T>

*/

public interface BaseDao<T> {

/**

* 插入数据

* @param obj

*/

@InsertProvider(type = MyBatisTemplate.class,method = "insert")

@Options(useGeneratedKeys = true)

void insert(T obj);

/**

* 根据主键更新数据中不为空的属

* @param obj

* @return

*/

@UpdateProvider(type=MyBatisTemplate.class,method="updateNotNullById")

int updateNotNullById(T obj);

/**

* 根据主键更新数据的全部属

* @param obj

* @return

*/

@UpdateProvider(type=MyBatisTemplate.class,method="updateById")

int updateById(T obj);

/**

* 根据主键删除数据

* @param id

* @return

*/

@DeleteProvider(type=MyBatisTemplate.class,method="deleteById")

int deleteById(Number id);

/**

* 根据对象中不为空的条件删除数据

* @param id

* @return

*/

@DeleteProvider(type=MyBatisTemplate.class,method="deleteByObject")

int deleteByObject(T obj);

/**

* 根据参数中不为空的条件删除数据,key对应dto中的属性

* @param id

* @return

*/

@DeleteProvider(type=MyBatisTemplate.class,method="deleteByParamNotEmpty")

int deleteByParamNotEmpty(Map<String,Object> param);

/**

* 根据参数中条件删除数据,key对应dto中的属性

* @param id

* @return

*/

@DeleteProvider(type=MyBatisTemplate.class,method="deleteByParam")

int deleteByParam(Map<String,Object> param);

/**

* 根据主键查询数据

* @param id

* @return

*/

@SelectProvider(type=MyBatisTemplate.class,method="queryById")

T queryById(Number id);

/**

* 根据对象中不为空的属性查询列表

* @param id

* @return

*/

@SelectProvider(type=MyBatisTemplate.class,method="queryByObject")

List<T> queryByObject(T obj);

/**

* 根据参数中不为空的属性查询列表，key对应dto中的属性

* @param id

* @return

*/

@SelectProvider(type=MyBatisTemplate.class,method="queryByParamNotEmpty")

List<T> queryByParamNotEmpty(Map<String,Object> params);

/**

* 根据参数查询列表，key对应dto中的属性

* @param id

* @return

*/

@SelectProvider(type=MyBatisTemplate.class,method="queryByParam")

List<T> queryByParam(Map<String,Object> params);

/**

* 根据对象中不为空的属性查询总数

* @param id

* @return

*/

@SelectProvider(type=MyBatisTemplate.class,method="queryByObjectCount")

Integer queryByObjectCount(T obj);

/**

* 根据参数中不为空的属性查询总数，key对应dto中的属性

* @param id

* @return

*/

@SelectProvider(type=MyBatisTemplate.class,method="queryByParamNotEmptyCount")

Integer queryByParamNotEmptyCount(Map<String,Object> params);

/**

* 根据参数查询总数，key对应dto中的属性

* @param id

* @return

*/

@SelectProvider(type=MyBatisTemplate.class,method="queryByParamCount")

Integer queryByParamCount(Map<String,Object> params);

/**

* 根据参数中不为空的属性查询总数，key对应dto中的属性

* @param id

* @return

*/

@SelectProvider(type=MyBatisTemplate.class,method="queryPageByParamNotEmpty")

List<T> queryPageByParamNotEmpty(Map<String,Object> params);

/**

* 根据参数查询总数，key对应dto中的属性

* @param id

* @return

*/

@SelectProvider(type=MyBatisTemplate.class,method="queryPageByParam")

List<T> queryPageByParam(Map<String,Object> params);

}

package com.common.mybatis.dao;
import com.common.mybatis.model.UserInfo;
publicinterface UserInfoDaoextends BaseDao<UserInfo>{
}

6. 拦截器

package com.common.utils;

import java.io.Serializable;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Properties;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.ibatis.executor.Executor;

import org.apache.ibatis.mapping.MappedStatement;

import org.apache.ibatis.mapping.ResultMap;

import org.apache.ibatis.plugin.Interceptor;

import org.apache.ibatis.plugin.Intercepts;

import org.apache.ibatis.plugin.Invocation;

import org.apache.ibatis.plugin.Plugin;

import org.apache.ibatis.plugin.Signature;

import org.apache.ibatis.session.ResultHandler;

import org.apache.ibatis.session.RowBounds;

import com.common.mybatis.dao.BaseDao;

@Intercepts({

@Signature(

type = Executor.class, method = "update",

args = { MappedStatement.class,Object.class }),

@Signature(

type = Executor.class, method = "query",

args = { MappedStatement.class,Object.class, RowBounds.class, ResultHandler.class})

})

public class BaseDaoInterceptor implements Interceptor {

private static final Log LOGGER = LogFactory.getLog(BaseDaoInterceptor.class);

private static final Method[] methods = BaseDao.class.getMethods();

public Object intercept(Invocation invocation) throws Throwable {

MappedStatement statement = (MappedStatement) invocation.getArgs()[0];

Object parameter = (Object) invocation.getArgs()[1];

String sqlId = statement.getId();

String methodId = sqlId.substring(sqlId.lastIndexOf(".")+1, sqlId.length());

DtoUtil.MapperWrap mapperWrap = setSqlMapper(sqlId,statement,parameter);

setDataSource(statement,parameter);

Class<?> currentClass = mapperWrap.getDaoClass();

Class<?> resultType = mapperWrap.getResultType();

if (!isBaseMethod(currentClass, methodId)) {

return invocation.proceed();

}

setPrimaryKey(statement,mapperWrap);

setPrimaryValue(parameter, invocation, resultType, methodId);

setResultClass(statement, resultType, methodId);

setClass(parameter, resultType);

return invocation.proceed();

}

public Object plugin(Object target) {

if (target instanceof Executor) {

return Plugin.wrap(target, this);

} else {

return target;

}

}

public void setProperties(Properties properties) {

}

private void setPrimaryKey(final MappedStatement statement,final DtoUtil.MapperWrap mapperWrap){

String[] keys = statement.getKeyProperties();

String[] keyColumns = statement.getKeyColumns();

keys[0]=mapperWrap.getIdParams();

if(StringUtils.isNotBlank(mapperWrap.getIdColumn())){

keyColumns = new String[]{mapperWrap.getIdColumn()};

}

}

private void setPrimaryValue(Object parameter, Invocation invocation, Class<?> paramClass,

String methodId) throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException {

if ("queryById".equals(methodId) || "deleteById".equals(methodId)) {

Object param = paramClass.newInstance();

Field field = paramClass.getDeclaredField("id");

field.setAccessible(true);

if (field.getType().getSimpleName().equals(Long.class.getSimpleName())) {

if (parameter instanceof Integer) {

field.set(param, ((Integer) parameter).longValue());

} else {

field.set(param, parameter);

}

} else {

if (parameter instanceof Long) {

field.set(param, ((Long) parameter).intValue());

} else {

field.set(param, parameter);

}

}

invocation.getArgs()[1] = param;

parameter = param;

}

}

private void setResultClass(MappedStatement statement, Class<?> currentClass, String methodId)

throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{

if (methodId.startsWith("query") && !methodId.endsWith("Count")) {

List<ResultMap> resultMaps = statement.getResultMaps();

ResultMap resultMap = resultMaps.get(0);

Field rf = resultMap.getClass().getDeclaredField("type");

rf.setAccessible(Boolean.TRUE);

rf.set(resultMap, currentClass);

} else if (methodId.endsWith("Count")) {

ResultMap resultMap = statement.getResultMaps().get(0);

Field rf = resultMap.getClass().getDeclaredField("type");

rf.setAccessible(Boolean.TRUE);

rf.set(resultMap, Integer.class);

}

}

@SuppressWarnings("unchecked")

private void setClass(Object parameter, Class<?> currentClass) throws InstantiationException,

IllegalAccessException, ClassNotFoundException {

if (parameter instanceof Map) {

((Map<String,Object>) parameter).put(DtoUtil.SPACE_TABLE_NAME, currentClass);

}

}

private boolean isBaseMethod(Class<?> currentClass, String methodId)

throws ClassNotFoundException {

Boolean isBaseMethod = Boolean.FALSE;

for (Method method : methods) {

String methodName = method.getName();

if (methodId.equals(methodName)) {

isBaseMethod = Boolean.TRUE;

}

}

if (!isBaseMethod) {

return Boolean.FALSE;

}

isBaseMethod = Boolean.FALSE;

for (Class<?> clazz : currentClass.getInterfaces()) {

if (clazz.equals(BaseDao.class)) {

isBaseMethod = Boolean.TRUE;

}

}

return isBaseMethod;

}

private Class<?> getClass(String className,Collection<Class<?>> clazzes) throws ClassNotFoundException {

for(Class<?> clazz : clazzes){

if(className.equals(clazz.getName())){

return clazz;

}

}

return null;

}

private Class<?> getResultType(Class<?> clazzDao){

Type[] params = clazzDao.getGenericInterfaces();

Type tc = null;

if(params!=null && params.length>0 && params[0] instanceof ParameterizedType){

tc = ((ParameterizedType)params[0]).getActualTypeArguments()[0];

}

return (Class<?>)tc;

}

private Map<String,Field> getResultMapping(Class<?> resultType){

Field[] fields = resultType.getDeclaredFields();

Map<String,Field> resultColumnMap = new HashMap<String,Field>();

for (Field field : fields) {

DtoUtil.putField(field,resultColumnMap);

}

Class<?> parentClass = resultType.getSuperclass();

if(null!=parentClass && !parentClass.getSimpleName().equals("Serializable")){

fields = resultType.getSuperclass().getDeclaredFields();

for (Field field : fields) {

DtoUtil.putField(field,resultColumnMap);

}

}

return resultColumnMap;

}

private Map<String,String> getResultColumn(Map<String,Field> resultMapping){

Map<String,String> resultColumnMap = new HashMap<String,String>();

for(Map.Entry<String,Field> entry : resultMapping.entrySet()){

Field field = entry.getValue();

DtoUtil.putFieldColumn(field,resultColumnMap);

}

return resultColumnMap;

}

private DtoUtil.MapperWrap setSqlMapper(final String sqlId,final MappedStatement statement,final Object parameter) throws ClassNotFoundException{

String daoClassName = sqlId.substring(0, sqlId.lastIndexOf("."));

if(!DtoUtil.DAO_METHOD_MAP.containsKey(daoClassName)){

String className = sqlId.substring(0, sqlId.lastIndexOf("."));

Class<?> currentClass = getClass(className,statement.getConfiguration().getMapperRegistry().getMappers());

DtoUtil.MapperWrap mapperWrap = new DtoUtil.MapperWrap();

Class<?> resultType = getResultType(currentClass);

String paramId = DtoUtil.id((Serializable) parameter);

mapperWrap.setKey(resultType.getName());

mapperWrap.setDaoClassName(daoClassName);

mapperWrap.setDaoClass(currentClass);

mapperWrap.setResultType(resultType);

mapperWrap.setResultTypeSimpleName(resultType.getSimpleName());

mapperWrap.setTableName(mapperWrap.getResultTypeSimpleName().replaceAll("([A-Z])", "_$1").replaceFirst("_", "").toLowerCase());

mapperWrap.setParamsType(resultType);

mapperWrap.setParamsTypeName(resultType.getName());

mapperWrap.setIdParams(paramId);

mapperWrap.setIdColumn(paramId.replaceAll("([A-Z])", "_$1").toLowerCase());

mapperWrap.setFieldMap(this.getResultMapping(resultType));

mapperWrap.setColumnMap(this.getResultColumn(mapperWrap.getFieldMap()));

DtoUtil.DAO_METHOD_MAP.put(daoClassName, mapperWrap);

DtoUtil.DAO_RESULT_MAP.put(mapperWrap.getKey(), mapperWrap);

}

return DtoUtil.DAO_METHOD_MAP.get(daoClassName);

}

private void setDataSource(final MappedStatement statement,final Object parameter){

}

}

7. 其它工具类

package com.common.utils;

import java.util.ArrayList;

import java.util.List;

/**

* 存放公共常量

* @author szy

*

*/

public final class Constant {

public enum MYBATIS_SPECIAL_STRING{

ORDER_BY,LIMIT,COLUMNS,TABLES,WHERE,LIKE;

public static List<String> list(){

List<String> result = new ArrayList<String>();

for (MYBATIS_SPECIAL_STRING entry : MYBATIS_SPECIAL_STRING.values()) {

result.add(entry.name());

}

return result;

}

}

}

package com.common.utils;

import java.io.Serializable;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

import com.common.annotation.Id;

import com.common.annotation.Virtual;

public final class DtoUtil {

public final static String SPLIT_DAO_RESULT_SIGN="|";

public final static Map<String,Class<?>> FIELD_TYPE_MAP = new HashMap<String,Class<?>>();

static{

FIELD_TYPE_MAP.put("Double", Double.class);

FIELD_TYPE_MAP.put("Short", Short.class);

FIELD_TYPE_MAP.put("Long", Long.class);

FIELD_TYPE_MAP.put("Float", Float.class);

FIELD_TYPE_MAP.put("Integer", Integer.class);

FIELD_TYPE_MAP.put("Byte", Byte.class);

FIELD_TYPE_MAP.put("String", String.class);

FIELD_TYPE_MAP.put("Character", Character.class);

FIELD_TYPE_MAP.put("sDate", Date.class);

FIELD_TYPE_MAP.put("Boolean", Boolean.class);

FIELD_TYPE_MAP.put("Date", java.util.Date.class);

}

public static final String SPACE_TABLE_NAME="SPACE_TABLE_NAME";

/**

* 用于存放POJO的列信息

*/

private final static Map<Class<? extends Serializable>,Map<String,String>> columnMap = new ConcurrentHashMap<Class<? extends Serializable>, Map<String,String>>();

public final static Map<String,MapperWrap> DAO_METHOD_MAP = new ConcurrentHashMap<String,MapperWrap>();

public final static Map<String,MapperWrap> DAO_RESULT_MAP = new ConcurrentHashMap<String,MapperWrap>();

/**

* 获取POJO对应的表名需要POJO中的属性定义@Table(name)

*

* @return

*/

public static String tableName(Serializable obj) {

String objClassName =obj.getClass().getSimpleName();

return objClassName.replaceAll("([A-Z])", "_$1")

.replaceFirst("_", "").toLowerCase();

}

/**

* 获取POJO中的主键字段名需要定义@Id

*

* @return

*/

public static String id(Serializable obj) {

for (Field field : obj.getClass().getDeclaredFields()) {

if (null != field.getAnnotation(Id.class))

return field.getName();

}

if(obj.getClass().equals(Long.class) || obj.getClass().equals(long.class) || obj.getClass().equals(int.class)|| obj.getClass().equals(Integer.class)){

return "id";

}

throw new RuntimeException("undefine " + obj.getClass().getName()

+ " @Id");

}

private static boolean isNull(Serializable obj, String fieldname) {

try {

Field field = obj.getClass().getDeclaredField(fieldname);

return isNull(obj, field);

} catch (SecurityException e) {

e.printStackTrace();

} catch (NoSuchFieldException e) {

e.printStackTrace();

} catch (IllegalArgumentException e) {

e.printStackTrace();

}

return false;

}

private static boolean isNull(Serializable obj, Field field) {

try {

field.setAccessible(true);

return field.get(obj) == null;

} catch (SecurityException e) {

e.printStackTrace();

} catch (IllegalArgumentException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

}

return false;

}

/**

* 用于计算类定义需要POJO中的属性定义

*/

public static void caculationColumnList(Serializable obj) {

Class<? extends Serializable> className = obj.getClass();

if (columnMap.containsKey(className))

return;

Field[] fields = className.getDeclaredFields();

Map<String,String> fieldMap = new HashMap<String,String>();

for (Field field : fields) {

Virtual notColumn =field.getAnnotation(Virtual.class);

boolean isStatic = Modifier.isStatic(field.getModifiers());

boolean isFinal= Modifier.isFinal(field.getModifiers());

boolean isPrimitive =field.getType().isPrimitive() || FIELD_TYPE_MAP.containsValue(field.getType());

if(null!=notColumn || isStatic || isFinal ||!isPrimitive){

continue;

}

String fieldName = field.getName();

String column = fieldName.replaceAll("([A-Z])", "_$1").toLowerCase();

fieldMap.put(fieldName, column);

}

columnMap.put(className, fieldMap);

Class<?> parentClass = className.getSuperclass();

if(null!=parentClass && !parentClass.getSimpleName().equals("Serializable")){

fields = className.getSuperclass().getDeclaredFields();

for (Field field : fields) {

Virtual notColumn =field.getAnnotation(Virtual.class);

boolean isStatic = Modifier.isStatic(field.getModifiers());

boolean isFinal= Modifier.isFinal(field.getModifiers());

boolean isPrimitive =field.getType().isPrimitive() || FIELD_TYPE_MAP.containsValue(field.getType());

if(null!=notColumn || isStatic || isFinal ||!isPrimitive){

continue;

}

String fieldName = field.getName();

String column = fieldName.replaceAll("([A-Z])", "_$1").toLowerCase();

fieldMap.put(fieldName, column);

}

}

}

public static void putField(final Field field,final Map<String,Field> fieldMap){

Virtual notColumn =field.getAnnotation(Virtual.class);

boolean isStatic = Modifier.isStatic(field.getModifiers());

boolean isFinal= Modifier.isFinal(field.getModifiers());

boolean isPrimitive =field.getType().isPrimitive() || FIELD_TYPE_MAP.containsValue(field.getType());

if(null!=notColumn || isStatic || isFinal ||!isPrimitive){

return;

}

fieldMap.put(field.getName(), field);

}

public static void putFieldColumn(final Field field,final Map<String,String> fieldMap){

Virtual notColumn =field.getAnnotation(Virtual.class);

boolean isStatic = Modifier.isStatic(field.getModifiers());

boolean isFinal= Modifier.isFinal(field.getModifiers());

boolean isPrimitive =field.getType().isPrimitive() || FIELD_TYPE_MAP.containsValue(field.getType());

if(null!=notColumn || isStatic || isFinal ||!isPrimitive){

return;

}

String fieldName = field.getName();

String column = fieldName.replaceAll("([A-Z])", "_$1").toLowerCase();

fieldMap.put(fieldName, column);

}

@SuppressWarnings("unchecked")

public static void caculationColumnList(Class<?> className) {

if (columnMap.containsKey(className))

return;

Field[] fields = className.getDeclaredFields();

Map<String,String> fieldMap = new HashMap<String,String>();

for (Field field : fields) {

Virtual notColumn =field.getAnnotation(Virtual.class);

boolean isStatic = Modifier.isStatic(field.getModifiers());

boolean isFinal= Modifier.isFinal(field.getModifiers());

boolean isPrimitive =field.getType().isPrimitive() || FIELD_TYPE_MAP.containsValue(field.getType());

if(null!=notColumn || isStatic || isFinal ||!isPrimitive){

continue;

}

String fieldName = field.getName();

String column = fieldName.replaceAll("([A-Z])", "_$1").toLowerCase();

fieldMap.put(fieldName, column);

}

columnMap.put((Class<? extends Serializable>) className, fieldMap);

Class<?> parentClass = className.getSuperclass();

if(null!=parentClass && !parentClass.getSimpleName().equals("Serializable")){

fields = className.getSuperclass().getDeclaredFields();

for (Field field : fields) {

Virtual notColumn =field.getAnnotation(Virtual.class);

boolean isStatic = Modifier.isStatic(field.getModifiers());

boolean isFinal= Modifier.isFinal(field.getModifiers());

boolean isPrimitive =field.getType().isPrimitive() || FIELD_TYPE_MAP.containsValue(field.getType());

if(null!=notColumn || isStatic || isFinal ||!isPrimitive){

continue;

}

String fieldName = field.getName();

String column = fieldName.replaceAll("([A-Z])", "_$1").toLowerCase();

fieldMap.put(fieldName, column);

}

}

}

/**

* Where条件信息

*/

public class WhereColumn {

public String name;

public boolean isString;

public WhereColumn(String name, boolean isString) {

this.name = name;

this.isString = isString;

}

}

/**

* 用于获取Insert的字段累加

*

* @return

*/

public static String returnInsertColumnsName(Serializable obj) {

StringBuilder sb = new StringBuilder();

Map<String,String> fieldMap = columnMap.get(obj.getClass());

Iterator<String> iterator= fieldMap.keySet().iterator();

int i = 0;

while(iterator.hasNext()){

String fieldname=iterator.next();

if (isNull(obj, fieldname) && !fieldname.contains("createTime") && !fieldname.contains("updateTime"))

continue;

if(i++!=0){

sb.append(',');

}

sb.append(fieldMap.get(fieldname));

}

return sb.toString();

}

/**

* 用于获取Insert的字段映射累加

*

* @return

*/

public static String returnInsertColumnsDefine(Serializable obj) {

StringBuilder sb = new StringBuilder();

Map<String,String> fieldMap = columnMap.get(obj.getClass());

Iterator<String> iterator= fieldMap.keySet().iterator();

int i = 0;

while(iterator.hasNext()){

String fieldname=iterator.next();

boolean isTime = fieldname.equalsIgnoreCase("createTime") || fieldname.equalsIgnoreCase("updateTime");

if ((!isTime) && isNull(obj, fieldname))

continue;

if(i++!=0){

sb.append(',');

}

if(isTime){

sb.append("NOW()");

}else{

sb.append("#{").append(fieldname).append('}');

}

}

return sb.toString();

}

/**

* 用于获取Update Set的字段累加

*

* @return

*/

public static String returnUpdateSetFull(Serializable obj) {

StringBuilder sb = new StringBuilder();

Map<String,String> fieldMap = columnMap.get(obj.getClass());

int i = 0;

for (Map.Entry<String, String> column : fieldMap.entrySet()) {

boolean isUpdateTime = column.getKey().equalsIgnoreCase("updateTime");

boolean isCreateTime = column.getKey().equalsIgnoreCase("createTime");

if (i++ != 0)

sb.append(',');

if(isUpdateTime){

sb.append("update_time=NOW()");

}else if(isCreateTime && isNull(obj, column.getKey())){

sb.append("create_time=NOW()");

}else{

sb.append(column.getValue()).append("=#{").append(column.getKey()).append('}');

}

}

return sb.toString();

}

/**

* 用于获取Update Set的字段累加

*

* @return

*/

public static String returnUpdateSet(Serializable obj) {

StringBuilder sb = new StringBuilder();

Map<String,String> fieldMap = columnMap.get(obj.getClass());

int i = 0;

for (Map.Entry<String, String> column : fieldMap.entrySet()) {

String key = column.getKey();

boolean isUpdateTime = key.equalsIgnoreCase("updateTime");

if (isNull(obj, key) && !isUpdateTime)

continue;

if (i++ != 0)

sb.append(',');

if(isUpdateTime){

sb.append("update_time=NOW()");

}else{

sb.append(column.getValue()).append("=#{").append(column.getKey()).append('}');

}

}

return sb.toString();

}

/**

* 用于获取select、delete的条件组装

* @return

*/

public static String whereColumnNotNull(Serializable obj) {

StringBuilder sb = new StringBuilder();

Map<String,String> fieldMap = columnMap.get(obj.getClass());

int i = 0;

for (Map.Entry<String, String> column : fieldMap.entrySet()) {

if (isNull(obj, column.getKey()))

continue;

if (i++ != 0)

sb.append(" AND ");

sb.append(column.getValue()).append("=#{").append(column.getKey()+"}");

}

return sb.toString();

}

/**

* 用于获取select、delete的条件组装

* @return

*/

public static String whereColumn(Map<String,Object> param) {

StringBuilder sb = new StringBuilder();

int i = 0;

for (Map.Entry<String, Object> column : param.entrySet()) {

if (i++ != 0)

sb.append(" AND ");

if(!Constant.MYBATIS_SPECIAL_STRING.list().contains(column.getKey().toUpperCase())){

sb.append(column.getKey().replaceAll("([A-Z])", "_$1").toLowerCase()).append("=#{").append(column.getKey()+"}");

}else if(Constant.MYBATIS_SPECIAL_STRING.LIKE.name().equalsIgnoreCase(column.getKey())){

sb.append(column.getValue());

} else if (Constant.MYBATIS_SPECIAL_STRING.COLUMNS.name().equalsIgnoreCase(column.getKey())) {

sb.append(column.getValue());

}

}

return sb.toString();

}

/**

* 用于获取select、delete的条件组装

* @return

*/

public static String whereColumnNotEmpty(Map<String,Object> param) {

StringBuilder sb = new StringBuilder();

int i = 0;

for (Map.Entry<String, Object> column : param.entrySet()) {

if (column.getValue()==null)

continue;

if (i++ != 0)

sb.append(" AND ");

if(!Constant.MYBATIS_SPECIAL_STRING.list().contains(column.getKey().toUpperCase())){

sb.append(column.getKey().replaceAll("([A-Z])", "_$1").toLowerCase()).append("=#{").append(column.getKey()+"}");

}else if(Constant.MYBATIS_SPECIAL_STRING.LIKE.name().equalsIgnoreCase(column.getKey())){

sb.append(column.getValue());

} else if (Constant.MYBATIS_SPECIAL_STRING.COLUMNS.name().equalsIgnoreCase(column.getKey())) {

sb.append(column.getValue());

}

}

return sb.toString();

}

public static String queryColumn(Serializable obj){

StringBuilder sb = new StringBuilder();

Map<String,String> fieldMap = columnMap.get(obj.getClass());

int i = 0;

for (Map.Entry<String, String> column : fieldMap.entrySet()) {

if (i++ != 0)

sb.append(',');

sb.append(column.getValue()).append(" as ").append(column.getKey());

}

return sb.toString();

}

public static String queryColumn(Map<String,String> fieldColumnMap){

StringBuilder sb = new StringBuilder();

int i = 0;

for (Map.Entry<String, String> column : fieldColumnMap.entrySet()) {

if (i++ != 0)

sb.append(',');

sb.append(column.getValue()).append(" as ").append(column.getKey());

}

return sb.toString();

}

/*

public Integer getId(Serializable obj) {

return 0;

}*/

/**

* 打印类字段信息

*/

public static String objString(Serializable obj) {

Field[] fields = obj.getClass().getDeclaredFields();

StringBuilder sb = new StringBuilder();

sb.append('[');

for (Field f : fields) {

if (Modifier.isStatic(f.getModifiers())

|| Modifier.isFinal(f.getModifiers()))

continue;

Object value = null;

try {

f.setAccessible(true);

value = f.get(obj);

} catch (IllegalArgumentException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

}

if (value != null)

sb.append(f.getName()).append('=').append(value).append(',');

}

sb.append(']');

return sb.toString();

}

static class MapperWrap implements Serializable{

/**

*

*/

private static final long serialVersionUID = -7578889926308207995L;

private String key;

private String daoClassName;

private String tableName;

private String idColumn;

private String idParams;

private Map<String,String> columnMap = new HashMap<String,String>();

private Map<String,Field> fieldMap = new HashMap<String,Field>();

private String paramsTypeName;

private String resultTypeSimpleName;

private Class<?> daoClass;

private Class<?> paramsType;

private Class<?> resultType= paramsType;

public String getKey() {

return key;

}

public void setKey(String key) {

this.key = key;

}

public String getDaoClassName() {

return daoClassName;

}

public void setDaoClassName(String daoClassName) {

this.daoClassName = daoClassName;

}

public String getTableName() {

return tableName;

}

public void setTableName(String tableName) {

this.tableName = tableName;

}

public String getIdColumn() {

return idColumn;

}

public void setIdColumn(String idColumn) {

this.idColumn = idColumn;

}

public String getIdParams() {

return idParams;

}

public void setIdParams(String idParams) {

this.idParams = idParams;

}

public Map<String, String> getColumnMap() {

return columnMap;

}

public void setColumnMap(Map<String, String> columnMap) {

this.columnMap = columnMap;

}

public String getParamsTypeName() {

return paramsTypeName;

}

public void setParamsTypeName(String paramsTypeName) {

this.paramsTypeName = paramsTypeName;

}

public Class<?> getDaoClass() {

return daoClass;

}

public void setDaoClass(Class<?> daoClass) {

this.daoClass = daoClass;

}

public Class<?> getParamsType() {

return paramsType;

}

public void setParamsType(Class<?> paramsType) {

this.paramsType = paramsType;

}

public Class<?> getResultType() {

return resultType;

}

public void setResultType(Class<?> resultType) {

this.resultType = resultType;

}

public Map<String, Field> getFieldMap() {

return fieldMap;

}

public void setFieldMap(Map<String, Field> fieldMap) {

this.fieldMap = fieldMap;

}

public String getResultTypeSimpleName() {

return resultTypeSimpleName;

}

public void setResultTypeSimpleName(String resultTypeSimpleName) {

this.resultTypeSimpleName = resultTypeSimpleName;

}

}

}

package com.common.utils;

import static com.common.utils.DtoUtil.SPACE_TABLE_NAME;

import static com.common.utils.DtoUtil.caculationColumnList;

import static com.common.utils.DtoUtil.id;

import static com.common.utils.DtoUtil.queryColumn;

import static com.common.utils.DtoUtil.returnInsertColumnsDefine;

import static com.common.utils.DtoUtil.returnInsertColumnsName;

import static com.common.utils.DtoUtil.returnUpdateSet;

import static com.common.utils.DtoUtil.returnUpdateSetFull;

import static com.common.utils.DtoUtil.tableName;

import static com.common.utils.DtoUtil.whereColumn;

import static com.common.utils.DtoUtil.whereColumnNotEmpty;

import static com.common.utils.DtoUtil.whereColumnNotNull;

import static org.apache.ibatis.jdbc.SqlBuilder.BEGIN;

import static org.apache.ibatis.jdbc.SqlBuilder.DELETE_FROM;

import static org.apache.ibatis.jdbc.SqlBuilder.FROM;

import static org.apache.ibatis.jdbc.SqlBuilder.INSERT_INTO;

import static org.apache.ibatis.jdbc.SqlBuilder.ORDER_BY;

import static org.apache.ibatis.jdbc.SqlBuilder.SELECT;

import static org.apache.ibatis.jdbc.SqlBuilder.SET;

import static org.apache.ibatis.jdbc.SqlBuilder.SQL;

import static org.apache.ibatis.jdbc.SqlBuilder.UPDATE;

import static org.apache.ibatis.jdbc.SqlBuilder.VALUES;

import static org.apache.ibatis.jdbc.SqlBuilder.WHERE;

import java.io.Serializable;

import java.util.Iterator;

import java.util.Map;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

public class MyBatisTemplate<T extends Serializable> {

private final static Log log = LogFactory.getLog(MyBatisTemplate.class);

public String insert(T obj) {

BEGIN();

INSERT_INTO(tableName(obj));

caculationColumnList(obj);

VALUES(returnInsertColumnsName(obj), returnInsertColumnsDefine(obj));

return SQL();

}

public String updateById(T obj) {

String idname = id(obj);

BEGIN();

UPDATE(tableName(obj));

caculationColumnList(obj);

SET(returnUpdateSetFull(obj));

WHEREID(idname);

return SQL();

}

public String updateNotNullById(T obj) {

String idname = id(obj);

BEGIN();

UPDATE(tableName(obj));

caculationColumnList(obj);

SET(returnUpdateSet(obj));

WHEREID(idname);

return SQL();

}

public String deleteById(T obj) {

String idname = id(obj);

BEGIN();

DELETE_FROM(tableName(obj));

WHEREID(idname);

return SQL();

}

public String deleteByObject(T obj){

caculationColumnList(obj);

BEGIN();

DELETE_FROM(tableName(obj));

WHERE(whereColumnNotNull(obj));

return SQL();

}

public String deleteByParamNotEmpty(Map<String,Object> param){

removeEmpty(param);

BEGIN();

Serializable obj = (Serializable) param.get(SPACE_TABLE_NAME);

String limit ="";

if(param.containsKey(Constant.MYBATIS_SPECIAL_STRING.LIMIT.name())){

limit=addlimit(param);

}

DELETE_FROM(tableName(obj));

param.remove(SPACE_TABLE_NAME);

if(param!=null && param.values()!=null && param.values().size()>0)

WHERE(whereColumnNotEmpty(param));

return SQL()+limit;

}

public String deleteByParam(Map<String,Object> param){

BEGIN();

Serializable obj = (Serializable) param.get(SPACE_TABLE_NAME);

String limit ="";

if(param.containsKey(Constant.MYBATIS_SPECIAL_STRING.LIMIT.name())){

limit=addlimit(param);

}

DELETE_FROM(tableName(obj));

param.remove(SPACE_TABLE_NAME);

if(param!=null && param.values()!=null && param.values().size()>0)

WHERE(whereColumn(param));

return SQL()+limit;

}

public String queryById(T obj){

String idname = id(obj);

caculationColumnList(obj);

BEGIN();

SELECT(queryColumn(obj));

FROM(tableName(obj)+" "+obj.getClass().getSimpleName());

WHEREID(idname);

return SQL();

}

public String queryByObject(T obj){

caculationColumnList(obj);

BEGIN();

SELECT(queryColumn(obj));

FROM(tableName(obj)+" "+obj.getClass().getSimpleName());

if(!"".equals(whereColumnNotNull(obj))){

WHERE(whereColumnNotNull(obj));

}

return SQL();

}

public String queryByParamNotEmpty(Map<String,Object> param){

try{

removeEmpty(param);

Serializable obj =(Serializable) param.get(SPACE_TABLE_NAME);

param.remove(SPACE_TABLE_NAME);

Object orderBy = param.get(Constant.MYBATIS_SPECIAL_STRING.ORDER_BY.name());

param.remove(Constant.MYBATIS_SPECIAL_STRING.ORDER_BY.name());

caculationColumnList(obj);

BEGIN();

SELECT(queryColumn(obj));

FROM(tableName(obj)+" "+obj.getClass().getSimpleName());

if(!param.isEmpty())

WHERE(whereColumnNotEmpty(param));

if(null!=orderBy)

ORDER_BY(orderBy.toString());

String sql = SQL();

log.debug(sql);

return sql;

}catch(Exception e){

log.error("出错了！"+param);

e.printStackTrace();

return null;

}

}

public String queryByParam(Map<String,Object> param){

try{

Serializable obj =(Serializable) param.get(SPACE_TABLE_NAME);

Object orderBy = param.get(Constant.MYBATIS_SPECIAL_STRING.ORDER_BY.name());

param.remove(SPACE_TABLE_NAME);

param.remove(Constant.MYBATIS_SPECIAL_STRING.ORDER_BY.name());

caculationColumnList(obj);

BEGIN();

SELECT(queryColumn(obj));

FROM(tableName(obj)+" "+obj.getClass().getSimpleName());

if(!param.isEmpty())

WHERE(whereColumn(param));

if(null!=orderBy)

ORDER_BY(orderBy.toString());

String sql = SQL();

log.debug(sql);

return sql;

}catch(Exception e){

log.error("出错了！"+param);

e.printStackTrace();

return null;

}

}

public String queryByObjectCount(T obj) {

caculationColumnList(obj);

BEGIN();

SELECT(" count(*) total ");

FROM(tableName(obj) + " " + obj.getClass().getSimpleName());

WHERE(whereColumnNotNull(obj));

return SQL();

}

public String queryByParamNotEmptyCount(Map<String, Object> param) {

try{

removeEmpty(param);

Serializable obj = (Serializable)param.remove(SPACE_TABLE_NAME);

caculationColumnList(obj);

BEGIN();

SELECT(" count(*) total ");

FROM(tableName(obj) + " " + obj.getClass().getSimpleName());

Object orderBy = param.remove(Constant.MYBATIS_SPECIAL_STRING.ORDER_BY.name());

if(!param.isEmpty())

WHERE(whereColumn(param));

param.put(Constant.MYBATIS_SPECIAL_STRING.ORDER_BY.name(), orderBy);

String sql = SQL();

log.debug(sql);

return sql;

}catch(Exception e){

log.error("出错了！"+param);

e.printStackTrace();

return null;

}

}

public String queryByParamCount(Map<String, Object> param) {

try{

Serializable obj = (Serializable) param.get(SPACE_TABLE_NAME);

param.remove(SPACE_TABLE_NAME);

caculationColumnList(obj);

BEGIN();

SELECT(" count(*) total ");

FROM(tableName(obj) + " " + obj.getClass().getSimpleName());

Object orderBy = param.remove(Constant.MYBATIS_SPECIAL_STRING.ORDER_BY.name());

if(!param.isEmpty())

WHERE(whereColumn(param));

param.put(Constant.MYBATIS_SPECIAL_STRING.ORDER_BY.name(), orderBy);

String sql = SQL();

log.debug(sql);

return sql;

}catch(Exception e){

log.error("出错了！"+param);

e.printStackTrace();

return null;

}

}

public String queryPageByParamNotEmpty(Map<String,Object> param){

removeEmpty(param);

Serializable obj =(Serializable)param.remove(SPACE_TABLE_NAME);

String limit = addlimit(param);

Object orderBy = param.remove(Constant.MYBATIS_SPECIAL_STRING.ORDER_BY.name());

caculationColumnList(obj);

BEGIN();

SELECT(queryColumn(obj));

FROM(tableName(obj)+" "+obj.getClass().getSimpleName());

if(!param.isEmpty())

WHERE(whereColumnNotEmpty(param));

if(orderBy!=null){

ORDER_BY(orderBy.toString());

}

return SQL()+limit;

}

public String queryPageByParam(Map<String,Object> param){

Serializable obj =(Serializable)param.remove(SPACE_TABLE_NAME);

String limit = addlimit(param);

Object orderBy = param.remove(Constant.MYBATIS_SPECIAL_STRING.ORDER_BY.name());

caculationColumnList(obj);

BEGIN();

SELECT(queryColumn(obj));

FROM(tableName(obj)+" "+obj.getClass().getSimpleName());

if(!param.isEmpty())

WHERE(whereColumn(param));

if(orderBy!=null){

ORDER_BY(orderBy.toString());

}

return SQL()+limit;

}

@SuppressWarnings("unchecked")

public String queryPageByParams(Map<String,Object> param){

Serializable obj =(Serializable)param.remove(SPACE_TABLE_NAME);

Object orderBy = param.remove(Constant.MYBATIS_SPECIAL_STRING.ORDER_BY.name());

caculationColumnList(obj);

BEGIN();

SELECT(queryColumn(obj));

FROM(tableName(obj)+" "+obj.getClass().getSimpleName());

if(!((Map<String,Object>)param.get("params")).isEmpty())

WHERE(whereColumn((Map<String,Object>)param.get("params")));

if(orderBy!=null){

ORDER_BY(orderBy.toString());

}

return SQL();

}

public void WHEREID(final String idname){

WHERE(idname.replaceAll("([A-Z])", "_$1").toLowerCase() + "=#{" + idname + "}");

}

public String addlimit(Map<String,Object> param){

String subsql =" "+ Constant.MYBATIS_SPECIAL_STRING.LIMIT.name()+" ";

Object obj =param.remove(Constant.MYBATIS_SPECIAL_STRING.LIMIT.name());

if(null==obj){

subsql = subsql+"0,10";

}else{

subsql = subsql+obj;

}

return subsql;

}

private void removeEmpty(Map<String,Object> params){

Iterator<String> iterator = params.keySet().iterator();

while(iterator.hasNext()){

String key = iterator.next();

if(params.get(key)==null){

params.remove(key);

iterator = params.keySet().iterator();

}

}

}

}

8. 测试

package com.common.mybatis.dao;

importstatic org.junit.Assert.fail;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.common.mybatis.model.UserInfo;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath*:spring.xml" })
publicclass UserInfoDaoTest {
privatefinalstatic Loglog
= LogFactory.getLog(UserInfoDaoTest.class);
@Autowired
private UserInfoDaouserInfoDao;

@Before
publicvoid setUp()throws
Exception {
}

@Test
publicvoid testInsert() {
UserInfo
userInfo = new UserInfo();
userInfo.setUserName("测试用户");
userInfo.setAccount("test001");
userInfo.setPassWord("123243213");
userInfoDao.insert(userInfo);
}
}

9. 配置(jdbc.properties,log4j.properties,mybatis-config.xml,spring.xml)

db.driver=com.mysql.jdbc.Driver
db.driverUrl=jdbc\:mysql\://localhost\:3306/testmybatis?allowMultiQueries=true
db.user=root
db.password=1234
proxool.maximumConnectionCount=20
proxool.minimumConnectionCount=5
proxool.prototypeCount=3
proxool.simultaneousBuildThrottle=15
db1.driver=com.mysql.jdbc.Driver
db1.driverUrl=jdbc\:mysql\://localhost\:3306/testmybatis?allowMultiQueries=true
db1.user=root
db1.password=1234

log4j.rootLogger=debug,fileout,stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d%-5psoa[%t](%F:%L)-%m%n

#daily run report,
#24 log files for every day
log4j.appender.fileout=org.apache.log4j.DailyRollingFileAppender
log4j.appender.fileout.File=../common-mybatis.log
log4j.appender.fileout.layout=org.apache.log4j.PatternLayout
log4j.appender.fileout.DatePattern='.'yyyy-MM-dd-HH
log4j.appender.fileout.layout.ConversionPattern=%d%-5psoa[%c](%F:%L)-%m%n

log4j.logger.com.common.mybatis =
debug,fileout,stdout
log4j.logger.java.org.apache.ibatis=debug,fileout,stdout
log4j.logger.java.sql=debug,fileout,stdout

<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation=" http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"
default-autowire="byName">
<aop:aspectj-autoproxy/>
<context:annotation-config/>
<util:properties id="meta"
location="classpath:jdbc.properties"/>

<bean
id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user"
value="#{meta['db.user']}"/>
<property name="password"
value="#{meta['db.password']}"/>
<property
name="driverClass" value="#{meta['db.driver']}"/>
<property
name="jdbcUrl" value="#{meta['db.driverUrl']}"/>
<property
name="maxPoolSize" value="#{meta['proxool.maximumConnectionCount']}"/>
<property
name="minPoolSize"
value="#{meta['proxool.minimumConnectionCount']}"/>
<property
name="initialPoolSize" value="#{meta['proxool.prototypeCount']}"/>
<property
name="maxIdleTime" value="60"/>
<property
name="acquireRetryAttempts" value="5"/>

<property
name="idleConnectionTestPeriod" value="60"/>
<property name="testConnectionOnCheckin"
value="true"/>
<property name="automaticTestTable"
value="c3p0Table"/>
<property name="numHelperThreads"
value="20"/>

<property name="debugUnreturnedConnectionStackTraces"
value="true"/>
<property name="unreturnedConnectionTimeout"
value="70"/>
</bean>


<bean
id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg
index="0"
ref="sqlSessionFactory"/>
</bean>
<bean
id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"
name="mainSqlSessionFactory">
<property name="dataSource"
ref="dataSource"/>
<property name="configLocation"
value="classpath:mybatis-config.xml"/>
</bean>

<bean
id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage"
value="com.common.mybatis.dao"/>
<property name="sqlSessionFactoryBeanName"
value="mainSqlSessionFactory"/>
</bean>

</beans>

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航