使用注解和spring的JdbcTemplate进行封装实现类似Hibernate的功能

工具类DBUtils：

/**2014-05修改

增加对查询语句的缓存

增加对jdbcTemplt查询出的Map转换成Bean的方法*/privatestaticLogger log = Logger.getLogger(SQLUtils.class);


    privatestaticMap cacheMap =new HashMap();

    privatestaticMap insertSqlCache =new HashMap();

    privatestaticMap updateSqlCache =new HashMap();

    privatestaticMap deleteSqlCache =new HashMap();

    privatestaticMap selectSqlCache =new HashMap();


    /**    * 根据pojo类的class来构建select * from 的SQL语句

    * @param pojoClass

    * @return*/publicstatic String buildSelectSql(Class pojoClass){

        List fieldInfoList = loadPojoSqlInfo(pojoClass);

        String sql = buildSelectSql(pojoClass, fieldInfoList);

        if(log.isDebugEnabled()){

            log.debug("select sql is:"+sql);

        }

        return sql;

    }


    /**    * 根据pojo类的class来构建insert的SQL语句

    * @param pojoClass

    * @return*/publicstatic String buildInsertSql(Class pojoClass){

        List fieldInfoList = loadPojoSqlInfo(pojoClass);

        String sql = buildInsertSql(pojoClass, fieldInfoList);

        if(log.isDebugEnabled()){

            log.debug("insert sql is:"+sql);

        }

        return sql;

    }


    /**    * 根据pojo类的class构建根据pk来update的SQL语句

    * @param pojoObject

    * @return*/publicstatic String buildUpdateSql(Class pojoClass){

        List fieldInfoList = loadPojoSqlInfo(pojoClass);

        String sql = buildUpdateSqlByPK(pojoClass, fieldInfoList);

        if(log.isDebugEnabled()){

            log.debug("update sql is:"+sql);

        }

        return sql;

    }


    /**    * 根据pojo类的Class和更新的条件字段来生成upate的SQL语句

    * @param pojoClass

    * @param columns

    * @return    * @throws Exception

    */publicstaticString buildUpdateSqlByColumns(Class pojoClass,String[] columns)throws Exception{

        if(null!=columns && columns.length>0){

            List fieldInfoList = loadPojoSqlInfo(pojoClass);

            String sql = buildUpdateSqlByColumns(pojoClass, fieldInfoList, columns);

            if(log.isDebugEnabled()){

                log.debug("update sql is:"+sql);

            }

            return sql;

        }else{

            if(log.isDebugEnabled()){

                log.debug("生成update sql error! 参数columns必须有值"  );

            }

            thrownewException("参数columns必须有值！");

        }

    }


    /**    * 根据pojo类的Class生成根据pk来delete的SQL语句

    * @param pojoClass

    * @return*/publicstatic String buildDeleteSql(Class pojoClass){

        List fieldInfoList = loadPojoSqlInfo(pojoClass);

        String sql = buildDeleteSqlByPK(pojoClass,fieldInfoList);

        if(log.isDebugEnabled()){

            log.debug("delete sql is:"+sql);

        }

        return sql;

    }


    /**    * 根据pojo类的Class和更新的条件字段来生成delete的SQL语句

    * @param pojoClass

    * @param columns

    * @return    * @throws Exception

    */publicstaticString buildDeleteSqlByColumns(Class pojoClass,String[] columns)throws Exception{

        if(null!=columns && columns.length>0){

            List fieldInfoList = loadPojoSqlInfo(pojoClass);

            String sql = buildDeleteSqlByColumns(pojoClass, fieldInfoList, columns);

            if(log.isDebugEnabled()){

                log.debug("delete sql is:"+sql);

            }

            return sql;

        }else{

            if(log.isDebugEnabled()){

                log.debug("生成delete sql error! 参数columns必须有值"  );

            }

            thrownewException("参数columns必须有值！");

        }

    }


    /**    * 将SQL查询出来的map对象转成实体对象

    * @param map

    * @param pojoClass

    * @return    * @throws Exception

    */publicstaticObject coverMapToBean(Map map,Class pojoClass)throws Exception{

        Object result = pojoClass.newInstance();


        List list = loadPojoSqlInfo(pojoClass);

        for(FieldInfo fieldInfo : list){

            String dbName = fieldInfo.getDbFieldName().toUpperCase();

            String fieldName = fieldInfo.getPojoFieldName();

            String setMethoName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);

            if(map.get(dbName)!=null){

                Method m = pojoClass.getMethod(setMethoName, fieldInfo.getType());

                m.invoke(result, map.get(dbName));

            }

        }

        return result;

    }


    /**    * 加载读取pojo的注解信息

    * @param pojoClass

    * @return*/    @SuppressWarnings("unchecked")

    privatestaticList loadPojoSqlInfo(Class pojoClass){

        List resultList =null;

        if(null== cacheMap.get(pojoClass.getName())){

            resultList =newArrayList();


            Field[] fields = pojoClass.getDeclaredFields();

            for(Field field : fields){

                FieldInfo fieldInfo =new FieldInfo();

                fieldInfo.setPojoFieldName(field.getName());


                if(field.isAnnotationPresent(com.test.anno.Field.class)){

                    String value = ((com.test.anno.Field)field.getAnnotation(com.test.anno.Field.class)).value();//得到配置的数据库字段名if(StringUtils.isEmpty(value)){//没有设置数据库的字段名，则取pojo的字段名                        fieldInfo.setDbFieldName(lowerStrToUnderline(field.getName()));

                    }else{

                        fieldInfo.setDbFieldName(value);

                    }

                }else{

                    fieldInfo.setDbFieldName(lowerStrToUnderline(field.getName()));

                }


                if(field.isAnnotationPresent(com.test.anno.PK.class)){

                    fieldInfo.setIsPk(true);

                }

                if(field.isAnnotationPresent(com.test.anno.NoInsert.class)){

                    fieldInfo.setIsInsert(false);

                }

                if(field.isAnnotationPresent(com.test.anno.NoUpdate.class)){

                    fieldInfo.setIsUpdate(false);

                }


                fieldInfo.setType(field.getType());


                resultList.add(fieldInfo);

            }

            cacheMap.put(pojoClass.getName(), resultList);

        }else{

            resultList = (List)cacheMap.get(pojoClass.getName());

        }


        return resultList;

    }


    /**    * 评价select语句

    * @param pojoClass

    * @param fieldInfoList

    * @return*/privatestaticString buildSelectSql(Class pojoClass,List fieldInfoList){

        if(selectSqlCache.get(pojoClass.getName()) !=null){

            return (String)selectSqlCache.get(pojoClass.getName());

        }

        return"select * from " + loadTableName(pojoClass);

    }


    /**    * 拼接insert的SQL

    * @param pojoClass

    * @param fieldInfoList

    * @return*/    @SuppressWarnings("unchecked")

    privatestaticString buildInsertSql(Class pojoClass,List fieldInfoList){

        String result =null;

        if(insertSqlCache.get(pojoClass.getName()) !=null){

            result = (String)insertSqlCache.get(pojoClass.getName());

            return result;

        }


        String tableName = loadTableName(pojoClass);


        StringBuffer temp1 =new StringBuffer();

        StringBuffer temp2 =new StringBuffer();

        for(FieldInfo fieldInfo : fieldInfoList){

            if(fieldInfo.getIsInsert()){

                temp1.append(fieldInfo.getDbFieldName()).append(",");

                temp2.append(":").append(fieldInfo.getPojoFieldName()).append(",");

            }

        }

        temp1.deleteCharAt(temp1.length()-1);

        temp2.deleteCharAt(temp2.length()-1);


        StringBuffer resultSql =new StringBuffer();

        resultSql.append("insert into ");

        resultSql.append(tableName);

        resultSql.append("(");

        resultSql.append(temp1);

        resultSql.append(") values (");

        resultSql.append(temp2);

        resultSql.append(")");


        result = resultSql.toString();

        insertSqlCache.put(pojoClass.getName(), result);

        return result;

    }


    /**    * 生成根据主键生成删除的SQL

    * @param pojoClass

    * @param fieldInfoList

    * @return*/    @SuppressWarnings("unchecked")

    privatestaticString buildDeleteSqlByPK(Class pojoClass,List fieldInfoList){

        String result =null;

        if(deleteSqlCache.get(pojoClass.getName()+"_pk") !=null){

            result = (String)deleteSqlCache.get(pojoClass.getName());

            return result;

        }


        StringBuffer resultSql =new StringBuffer();

        resultSql.append(appendBaseDeleteSQL(pojoClass));


        for(FieldInfo fieldInfo : fieldInfoList){

            if(fieldInfo.getIsPk()){

                resultSql.append(fieldInfo.getDbFieldName());

                resultSql.append("=:").append(fieldInfo.getPojoFieldName()).append(" and ");

            }

        }

        resultSql.delete(resultSql.length()-4, resultSql.length());

        result = resultSql.toString();

        deleteSqlCache.put(pojoClass.getName()+"_pk", result);


        return result;

    }


    /**    * 拼接根据主键来update的SQL

    * @param pojoClass

    * @param fieldInfoList

    * @return*/    @SuppressWarnings("unchecked")

    privatestaticString buildUpdateSqlByPK(Class pojoClass, List fieldInfoList){

        String result =null;

        if(updateSqlCache.get(pojoClass.getName()+"_pk") !=null){

            result = (String)updateSqlCache.get(pojoClass.getName()+"_pk");

            return result;

        }


        StringBuffer resultSql =new StringBuffer();

        resultSql.append(appendBaseUpdateSQL(pojoClass, fieldInfoList));


        for(FieldInfo fieldInfo : fieldInfoList){

            if(fieldInfo.getIsPk()){

                resultSql.append(fieldInfo.getDbFieldName());

                resultSql.append("=:").append(fieldInfo.getPojoFieldName()).append(" and ");

            }

        }

        resultSql.delete(resultSql.length()-4, resultSql.length());

        result = resultSql.toString();

        updateSqlCache.put(pojoClass.getName()+"_pk", result);


        return result;

    }


    /**    * 根据用户指定的更新条件(字段)来生成update的SQL

    * @param pojoClass

    * @param fieldInfoList

    * @param columns

    * @return*/privatestaticString buildUpdateSqlByColumns(Class pojoClass, List fieldInfoList,String[] columns){

        StringBuffer resultSql =new StringBuffer();

        if(updateSqlCache.get(pojoClass.getName()+"_columns") !=null){

            resultSql.append((String)updateSqlCache.get(pojoClass.getName()+"_columns"));

        }else{

            resultSql.append(appendBaseUpdateSQL(pojoClass, fieldInfoList));

        }


        for(String column : columns){

            for(FieldInfo fieldInfo : fieldInfoList){

                if(column.equals(fieldInfo.getPojoFieldName())){

                    resultSql.append(fieldInfo.getDbFieldName());

                    resultSql.append("=:").append(column).append(" and ");

                    break;

                }

            }

        }

        resultSql.delete(resultSql.length()-4, resultSql.length());

        return resultSql.toString();

    }


    /**    * 拼接update语句的where之前的sql

    * @param pojoClass

    * @param fieldInfoList

    * @param resultSql

    */    @SuppressWarnings("unchecked")

    privatestaticString appendBaseUpdateSQL(Class pojoClass, List fieldInfoList){

        String result =null;

        if(updateSqlCache.get(pojoClass.getName()+"_columns") !=null){

            result = (String)updateSqlCache.get(pojoClass.getName()+"_columns");

        }else{

            StringBuffer resultSql =new StringBuffer();

            String tableName = loadTableName(pojoClass);


            resultSql.append("update ").append(tableName).append(" set ");

            for(FieldInfo fieldInfo : fieldInfoList){

                if(fieldInfo.getIsUpdate() && !fieldInfo.getIsPk()){

                    resultSql.append(fieldInfo.getDbFieldName());

                    resultSql.append("=:").append(fieldInfo.getPojoFieldName()).append(",");

                }

            }

            resultSql.deleteCharAt(resultSql.length()-1);

            resultSql.append(" where ");


            result = resultSql.toString();

            updateSqlCache.put(pojoClass.getName()+"_columns", result);

        }

        return result;

    }


    /**    * 根据用户指定的更新条件(字段)来生成delete的SQL

    * @param pojoClass

    * @param fieldInfoList

    * @param columns

    * @return*/privatestaticString buildDeleteSqlByColumns(Class pojoClass, List fieldInfoList,String[] columns){

        StringBuffer resultSql =new StringBuffer();

        if(deleteSqlCache.get(pojoClass.getName()+"_columns") !=null){

            resultSql.append((String)deleteSqlCache.get(pojoClass.getName()+"_columns"));

        }else{

            resultSql.append(appendBaseUpdateSQL(pojoClass, fieldInfoList));

        }


        for(String column : columns){

            for(FieldInfo fieldInfo : fieldInfoList){

                if(column.equals(fieldInfo.getPojoFieldName())){

                    resultSql.append(fieldInfo.getDbFieldName());

                    resultSql.append("=:").append(column).append(" and ");

                    break;

                }

            }

        }

        resultSql.delete(resultSql.length()-4, resultSql.length());

        return resultSql.toString();

    }


    /**    * 拼接delete语句的where之前的sql

    * @param pojoClass

    * @param fieldInfoList

    * @param resultSql

    */    @SuppressWarnings("unchecked")

    privatestatic String appendBaseDeleteSQL(Class pojoClass){

        if(deleteSqlCache.get(pojoClass.getName()+"_columns") !=null){

            return(String)deleteSqlCache.get(pojoClass.getName()+"_columns");

        }else{

            String result = "delete from " + loadTableName(pojoClass) + " where ";

            deleteSqlCache.put(pojoClass.getName()+"_columns", result);

            return result;

        }

    }


    /**    * 通过类获取表名

    * @param pojoClass

    * @return*/    @SuppressWarnings("unchecked")

    privatestatic String loadTableName(Class pojoClass){

        if(pojoClass.isAnnotationPresent(Table.class)){

            Table table = (Table)pojoClass.getAnnotation(Table.class);

            return table.value();

        }else{

            return lowerStrToUnderline(pojoClass.getSimpleName());

        }

    }


    /**    * 将大写字母转换成下划线加小写字母

    * 例:userName--> user_name

    * @param str

    * @return*/privatestatic String lowerStrToUnderline(String str) {

        if(StringUtils.isEmpty(str)){

            return"";

        }

        StringBuilder sb =new StringBuilder(str);

        char c;

        intcount = 0;

        for(inti = 0; i < str.length(); i++) {

            c = str.charAt(i);

            if(c >= 'A' && c <= 'Z') {

                sb.replace(i+count, i+count+1, (c+"").toLowerCase());

                sb.insert(i+count, "_");

                count++;

            }

        }

        return sb.toString();

    }


注解类：

import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)public@interface Field {

    //数据库字段名publicString value()default"";

}

import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)public@interface NoInsert {

}

import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)public@interface NoUpdate {

}

import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)public@interface PK {

}

import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)public@interface Table {

    public String value();

}

用来保存pojo类的字段信息的类：

publicclass FieldInfo {

    //java字段名private String pojoFieldName;

    //数据库字段名private String dbFieldName;

    //是否是主键privatebooleanisPk =false;

    //update时是否需要更新privatebooleanisUpdate =true;

    //insert时是否需要插入privatebooleanisInsert =true;


    publicboolean isPk() {

        return isPk;

    }

    publicvoidsetIsPk(boolean isPk) {

        this.isPk = isPk;

    }

    publicboolean isUpdate() {

        return isUpdate;

    }

    publicvoidsetIsUpdate(boolean isUpdate) {

        this.isUpdate = isUpdate;

    }

    public String getPojoFieldName() {

        return pojoFieldName;

    }

    publicvoid setPojoFieldName(String pojoFieldName) {

        this.pojoFieldName = pojoFieldName;

    }

    public String getDbFieldName() {

        return dbFieldName;

    }

    publicvoid setDbFieldName(String dbFieldName) {

        this.dbFieldName = dbFieldName;

    }

    publicboolean isInsert() {

        return isInsert;

    }

    publicvoidsetIsInsert(boolean isInsert) {

        this.isInsert = isInsert;

    }

}

pojo类：

@Table("t_log")publicclass WorkLog {

    //id    @PK

    @Field("id")

    private String logId ; 

    //日志日期    @NoUpdate

    privateDate logDate;//log_date

    //所属项目private String projectId;

    //工作类型private String    jobTypeId; 

    //日志内容private String    content;   

    //工作时长privatedouble    workTime;   

    //填写时间private Timestamp fillTime;   

    //日志填写人    @NoUpdate

    private String employeeId;   

    //状态    @NoUpdate

    private String archivingState;

　　//.....get set method}


分装一个基础的操作的BaseDao类（这里只封装了几个常用的CRUD操作，具体运用可以再增加）：

@Resource

    private JdbcTemplate jdbcTemplate;

    @Resource

    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;


    /**    * 保存新增的实体对象

    * @param bean

    * @return*/publicboolean baseSave(Object bean){

        String sql = SQLUtils.buildInsertSql(bean.getClass());

        SqlParameterSource sps =new BeanPropertySqlParameterSource(bean);

        returnthis.namedParameterJdbcTemplate.update(sql, sps)>0?true:false;

    }


    /**    * 根据主键保存修改的实体对象

    * @param bean

    * @return*/publicboolean baseSaveUpdate(Object bean){

        String sql = SQLUtils.buildUpdateSql(bean.getClass());

        SqlParameterSource sps =new BeanPropertySqlParameterSource(bean);

        returnthis.namedParameterJdbcTemplate.update(sql, sps)>0?true:false;

    }


    /**    * 根据bean的部分字段的条件来更新bean的信息

    * @param bean

    * @param fileds

    * @return    * @throws Exception

    */publicbooleanbaseSaveUpdateWithColumn(Object bean,String[] fileds)throws Exception{

        String sql = SQLUtils.buildUpdateSqlByColumns(bean.getClass(), fileds);

        SqlParameterSource sps =new BeanPropertySqlParameterSource(bean);

        returnthis.namedParameterJdbcTemplate.update(sql, sps)>0?true:false;

    }


    /**    * 根据bean的pk来删除bean

    * @param bean

    * @return*/publicboolean baseDelete(Object bean){

        String sql = SQLUtils.buildDeleteSql(bean.getClass());

        SqlParameterSource sps =new BeanPropertySqlParameterSource(bean);

        returnthis.namedParameterJdbcTemplate.update(sql, sps)>0?true:false;

    }


    /**    * 根据bean的部分字段的条件来删除bean

    * @param bean

    * @param fileds

    * @return    * @throws Exception

    */publicbooleanbaseDeleteWithColumn(Object bean,String[] fileds)throws Exception{

        String sql = SQLUtils.buildDeleteSqlByColumns(bean.getClass(), fileds);

        SqlParameterSource sps =new BeanPropertySqlParameterSource(bean);

        returnthis.namedParameterJdbcTemplate.update(sql, sps)>0?true:false;

    }


    /**    * 自动分页/不分页查询返回list

    * @param cs

    * @param conditionDef

    * @param paramMap

    * @return*/public List baseQueryForList(Class cs, ConditionDef conditionDef, Map paramMap){

        Condition condition=new Condition(conditionDef,paramMap);

        String sql = SQLUtils.buildSelectSql(cs) + condition.getConditionClauseWithWhere();


        if(PagingUtils.isPagingSearchRequest(paramMap)) {

            return PagingUtils.pagingQuery(namedParameterJdbcTemplate, sql, paramMap);

        }else {

            return namedParameterJdbcTemplate.queryForList(sql, paramMap);

        }

    }


    /**    * 查询满足条件的单条记录的实体对象，如果超过1条则抛出异常，没查询到则返回null

    * @param cs

    * @param conditionDef

    * @param paramMap

    * @return    * @throws Exception

    */publicObject baseQueryForEntity(Class cs, ConditionDef conditionDef, Map paramMap)throws Exception{

        Condition condition=new Condition(conditionDef,paramMap);

        String sql = SQLUtils.buildSelectSql(cs) + condition.getConditionClauseWithWhere();

        List list =this.namedParameterJdbcTemplate.queryForList(sql, paramMap);


        if(null==list || list.size()==0 || list.size()>1){

            returnnull;

        }elseif(list.size()>1){

            thrownewException("query return record more then one!!");

        }else{

            Map map = (Map)list.get(0);

            return SQLUtils.coverMapToBean(map, cs);

        }

    }


    public JdbcTemplate getJdbcTemplate() {

        return jdbcTemplate;

    }


    public NamedParameterJdbcTemplate getNamedParameterJdbcTemplate() {

        return namedParameterJdbcTemplate;

    }

 对查询参数进行封装的类：

ConditionDef.java

publicclass ConditionDef {

    privateMap paraNameAndSubConditionClauseMap =new LinkedHashMap();

    privateMap paraNameAndClassTypeMap =new HashMap();

    privateMap> paraNameAndLikeMatchInfoMap =new HashMap();

    public ConditionDef(Object[][] defineArr) {

        for (Object[] subDefine : defineArr) {

            Pattern pattern = Pattern.compile(":([\\w\\d_]+)");

            String currDefClause = (String) subDefine[0];

            intcurrDefClauseLen = currDefClause.length();

            Matcher matcher = pattern.matcher(currDefClause);

            //System.out.println(currDefClause);Set varNameSet =new HashSet();

            intvarNameCount = 0;


            charclauseMode = Condition.STANDARD_MODE;

            String oneVarName =null;

            booleanisUsedSameMatchMode=true;

            List matchModeList=new ArrayList();

            while (matcher.find()) {

                String varName = matcher.group(1);


                oneVarName = varName;

                intstart = matcher.start();

                intend = matcher.end();

                charprefix = currDefClause.charAt(start - 1);

                charsuffix = end >= currDefClauseLen ? ' ' : currDefClause.charAt(end);

                charsubConditionMatchMode = Condition.STANDARD_MODE;

                if(prefix == '%' && suffix == '%') {

                    clauseMode = subConditionMatchMode = Condition.GLOBAL_MATCH;

                    matchModeList.add(clauseMode);


                } elseif(prefix == '%') {

                    clauseMode = subConditionMatchMode = Condition.PREFIX_MATCH;

                    matchModeList.add(clauseMode);

                } elseif(suffix == '%') {

                    clauseMode = subConditionMatchMode = Condition.SUFFIX_MATCH;

                    matchModeList.add(clauseMode);

                }

                varNameSet.add(varName);

                varNameCount++;

                if(varNameCount>1&&matchModeList.size()>=2) {

                    intsize=matchModeList.size();

                    if(!matchModeList.get(size-1).equals(matchModeList.get(size-2))) {

                        isUsedSameMatchMode=false;

                    }

                }

            }

            if(varNameSet.size() != 1) {

                thrownewRuntimeException("One sub condition clause must only have one var name ! clause :"                        + currDefClause);

            }

            if(oneVarName ==null) {

                thrownewRuntimeException("Sub condition is not have any var name ! clause :" + currDefClause);

            }


            if(subDefine.length > 1) {

                paraNameAndClassTypeMap.put(oneVarName, (Class) subDefine[1]);

                //System.out.println("save var type : " + oneVarName + "," + ((Class) subDefine[1]).getSimpleName());            }

            if(clauseMode != Condition.STANDARD_MODE) {

                if(isUsedSameMatchMode&&varNameCount==matchModeList.size()) {

                    paraNameAndLikeMatchInfoMap.put(oneVarName, matchModeList.subList(0,1));

                } else {

                    currDefClause=currDefClause.replaceAll("%:"+oneVarName+"%", ":"+oneVarName+"_globalMatch");

                    currDefClause=currDefClause.replaceAll("%:"+oneVarName, ":"+oneVarName+"_suffixMatch");

                    currDefClause=currDefClause.replaceAll(":"+oneVarName+"%", ":"+oneVarName+"_prefixMatch");

                    paraNameAndLikeMatchInfoMap.put(oneVarName, matchModeList);

                }

                currDefClause = currDefClause.replaceAll("'\\%", "");

                currDefClause = currDefClause.replaceAll("\\%'", "");

                currDefClause = currDefClause.replaceAll("\\%", "");

                currDefClause = currDefClause.replaceAll("'", "");

                //System.out.println("processed clause : " + currDefClause);            }

            String tempClause=currDefClause.toUpperCase();

            if(tempClause.indexOf("AND")!=-1||tempClause.indexOf("OR")!=-1) {

                currDefClause="("+currDefClause+")";

            }

            paraNameAndSubConditionClauseMap.put(oneVarName, currDefClause);

        }

    }

    public String[] getConditionVarNames() {

        // TODO Auto-generated method stubreturnparaNameAndSubConditionClauseMap.keySet().toArray(new String[paraNameAndSubConditionClauseMap.keySet().size()]);

    }

    public String getSubConditionClause(String varName) {

        // TODO Auto-generated method stubreturn paraNameAndSubConditionClauseMap.get(varName);

    }

    publicboolean isExistClassTypeInfo(String varName) {

        // TODO Auto-generated method stubreturn paraNameAndClassTypeMap.containsKey(varName);

    }

    public Class getClassTypeInfo(String varName) {

        // TODO Auto-generated method stubreturn paraNameAndClassTypeMap.get(varName);

    }

    publicboolean isExistMatchModeInfo(String varName) {

        // TODO Auto-generated method stubreturn paraNameAndLikeMatchInfoMap.containsKey(varName);

    }

    publicList getMatchModeInfo(String varName) {

        // TODO Auto-generated method stubreturn paraNameAndLikeMatchInfoMap.get(varName);

    }

}

Condition.java

publicclass Condition {

    publicstaticfinalString AND = " AND ";

    publicstaticfinalString OR = " OR ";

    publicstaticfinalcharPREFIX_MATCH = 'P';

    publicstaticfinalcharSUFFIX_MATCH = 'S';

    publicstaticfinalcharGLOBAL_MATCH = 'G';

    publicstaticfinalcharLIKE_MODE = 'L';

    publicstaticfinalcharSTANDARD_MODE = 0;

    List varTypesList =new ArrayList();

    privateString conditionClauseStr = "";

    privateString relateOperate = AND;

    public Condition(ConditionDef def, Map valueMap) {

        this(def, valueMap, AND);

    }

    public Condition(ConditionDef def, Map valueMap, String relateOperate) {

        this.relateOperate = relateOperate;

        String[] varNameArr = def.getConditionVarNames();

        List usedSubConditionClauseList =new ArrayList();

        for (String varName : varNameArr) {

            if(!StringUtils.isEmpty(valueMap.get(varName))) {

                usedSubConditionClauseList.add(def.getSubConditionClause(varName));

                Object priValue =  valueMap.get(varName);

                if (def.isExistClassTypeInfo(varName)) {

                    Class targetClass = def.getClassTypeInfo(varName);

                    Object newValue =null;

                    if(targetClass == java.sql.Date.class) {

                        newValue = java.sql.Date.valueOf((String)priValue);

                        valueMap.put(varName, newValue);

                    } elseif(targetClass == java.sql.Timestamp.class) {

                        newValue = java.sql.Timestamp.valueOf((String)priValue);

                        valueMap.put(varName, newValue);

                    } elseif(targetClass == java.sql.Time.class) {

                        newValue = java.sql.Time.valueOf((String)priValue);

                        valueMap.put(varName, newValue);

                    } elseif(targetClass == java.util.List.class) {

                        List valueList=new ArrayList();

                        if (priValue.getClass().isArray()){

                            String[] valueArr=(String[])priValue;

                            for (String string : valueArr) {

                                valueList.add(string);

                            }

                        }else{

                            valueList.add(priValue);

                        }

                        valueMap.put(varName, valueList);

                    }

                }

                if (def.isExistMatchModeInfo(varName)) {

                    List matchModeList = def.getMatchModeInfo(varName);

                    if(matchModeList.size() == 1) {

                        if(matchModeList.get(0) == Condition.GLOBAL_MATCH) {

                            priValue = "%" + priValue + "%";

                        } elseif(matchModeList.get(0) == Condition.PREFIX_MATCH) {

                            priValue = priValue + "%";

                        } elseif(matchModeList.get(0) == Condition.SUFFIX_MATCH) {

                            priValue = "%" + priValue;

                        }

                        valueMap.put(varName , priValue);

                    } else {

                        for(char currMatchMode : matchModeList) {

                            if(currMatchMode == Condition.GLOBAL_MATCH) {

                                String newValue = "%" + priValue + "%";

                                valueMap.put(varName + "_globalMatch", newValue);

                            } elseif(currMatchMode == Condition.PREFIX_MATCH) {

                                String newValue = priValue + "%";

                                valueMap.put(varName + "_prefixMatch", newValue);

                            } elseif(currMatchMode == Condition.SUFFIX_MATCH) {

                                String newValue = "%" + priValue;

                                valueMap.put(varName + "_suffixMatch", newValue);

                            }

                        }

                    }

                }

            }

        }

        this.conditionClauseStr = StringUtils.join(usedSubConditionClauseList, relateOperate);


    }

    public String getConditionClause() {

        returnthis.conditionClauseStr;

    }

    public String getConditionClauseWithWhere() {

        return"".equals(conditionClauseStr)?"":" WHERE " + conditionClauseStr;

    }

    public String getConditionClauseWithStartRelateOperatorIfNeeded() {

        if(conditionClauseStr.trim().equals("")) {

            return"";

        }else {

            returnthis.relateOperate + " " + conditionClauseStr;

        }


    }

    public String getConditionClauseWithRelateOperatorAtStart() {

        returnthis.relateOperate + " " + conditionClauseStr;

    }

    public Integer[] getConditionVarTypes() {

        returnvarTypesList.toArray(new Integer[]{});

    }

}


调用Dao：

publicclassTestDaoextends BaseDao{

    privateConditionDef conditionDef=new ConditionDef(

        new Object[][] {

            {"DEPTNO = :deptno"},

            {"MGRNO = :mgrno"}

        }

    );


    public List query(Map paramMap){

        returnthis.baseQueryForList(Department.class, conditionDef, paramMap);

    }


    publicvoid save(){

        Department dep =new Department();

        dep.setDeptno("S22");

        dep.setDeptname("my depart");

        dep.setMgrno("000060");

        dep.setAdmrdept("E01");

        dep.setLocation("haha");

        this.baseSave(dep);

    }


    publicvoidupdate()throws Exception{

        Map paramMap =new HashMap();

        paramMap.put("deptno", "S22");


        Object o =this.baseQueryForEntity(Department.class, conditionDef, paramMap);

        Department dept =null;

        if(o!=null){

            dept = (Department)o;


            dept.setLocation("update");

            this.baseSaveUpdate(dept);

        }

    }


    publicvoid delete(){

        Department dept =new Department();

        dept.setDeptno("S22");

        this.baseDelete(dept);

    }

}

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 205,386评论 6赞 479
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,939评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,851评论 0赞 341
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,953评论 1赞 278
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,971评论 5赞 369
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,784评论 1赞 283
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,126评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,765评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,148评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,744评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,858评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,479评论 4赞 322
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,080评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,053评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,278评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,245评论 2赞 352
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,590评论 2赞 343

推荐阅读更多精彩内容