基于spring创建通用的Mybatis类

来源：互联网发布：日本深夜节目软件编辑：程序博客网时间：2024/05/27 12:21

一、环境

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">

<groupId>common</groupId>

<artifactId>common-mybatis</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>common-mybatis</name>

<description>创建通用的dao</description>

<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>

<groupId>commons-lang</groupId>

<artifactId>commons-lang</artifactId>

<version>${commons.lang.version}</version>

</dependency>

<version>${c3p0.version}</version>

</dependency>

<groupId>org.aspectj</groupId>

<artifactId>aspectjweaver</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-beans</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context-support</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-tx</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

<version>${mysql-connector-java.version}</version>

</dependency>

<groupId>org.mybatis</groupId>

<artifactId>mybatis</artifactId>

<version>${mybatis.version}</version>

</dependency>

<groupId>org.mybatis</groupId>

<artifactId>mybatis-spring</artifactId>

<version>${mybatis-spring.version}</version>

</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

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"/>

<beanid="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

<propertyname="driverClass" value="#{meta['db.driver']}"/>

<propertyname="jdbcUrl" value="#{meta['db.driverUrl']}"/>

<propertyname="maxPoolSize" value="#{meta['proxool.maximumConnectionCount']}"/>

<propertyname="minPoolSize" value="#{meta['proxool.minimumConnectionCount']}"/>

<propertyname="initialPoolSize" value="#{meta['proxool.prototypeCount']}"/>

<propertyname="maxIdleTime" value="60"/>

<propertyname="acquireRetryAttempts" value="5"/>

<propertyname="idleConnectionTestPeriod" value="60"/>

</bean>

<beanid="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">

<constructor-argindex="0" ref="sqlSessionFactory"/>

</bean>

<beanid="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"

name="mainSqlSessionFactory">

</bean>

<beanid="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">

</bean>

</beans>

0 0