1.说明

• 以[hibernate的dao层封装-基础功能]所说明的方法为基础
• 某些需求不太确定,根据实际需要进行调整.
• 代码不做详细说明

2.根据实体id,删除数据库的数据

 /**
     * 删除多个entity
     * @param clazz 要删除的实体类
     * @param ids 被删除的数据id数组
     * @return
     * @time 2018年11月13日 上午11:46:34
     * @author authstr
     */
    @Override
    public int removeIds(Class clazz, Serializable[] ids) {
        //从实体类获取数据表名称
        String tableName=ReflectionUtils.getEntityTableName(clazz);
        //如果没有get到值,抛出一个内部异常
        Assert.isTrue(StringUtils.hasText(tableName),
                "该实体类["+clazz.getSimpleName()+"]没有设置表映射!",true);
        return removeIds(tableName,ids);
    }
    /**
     * 删除多个entity
     * @param tableName 要删除的数据表名称
     * @param ids 被删除的数据id数组
     * @return
     * @time 2018年11月13日 上午11:46:34
     * @author authstr
     */
    public int removeIds(String tableName, Serializable[] ids) {
        StringBuffer sqlstring = new StringBuffer();
        sqlstring.append(" delete from " +tableName);
        sqlstring.append(" where id in (:ids) ");
        Map<String,Object> para=new HashMap<String,Object>();
        para.put("ids", ids);
        return this.executeSQl(sqlstring.toString(), para);
    }


    /**
     * 通过一个id删除一个entiy
     * @time 2018年11月13日14:04:43
     * @author authstr
     */
    @Override
    public int remove(Class clazz, Serializable id) {
        return removeIds(clazz,new Serializable[]{id});
    }

3.快捷构建简单sql语句进行查询

    /**
     * 根据相关参数构建简单的sql语句进行查询(执行方法)
     * @param tableName 要查询的表名
     * @param fields    where限制的字段名称
     * @param values where限制的字段值
     * @param sqlResult 查询要返回的信息
     * @return list集合
     * @time 2018年9月17日18:00:44
     * @author authstr
     */
    public  List queryByEntity(String tableName,String[] fields,Object[] values,String sqlResult,Class returnType){
        StringBuffer sql =new StringBuffer();
        sql.append("select  "+sqlResult+"  from "+tableName+" a  where 1=1");
        for(int i=0;i<fields.length;i++){
            sql.append(" and "+fields[i]+" =  :"+fields[i]);
        }
        return getBySQL(sql.toString(),fields,values,returnType);
    }

  /**
     * 根据实体和字段参数构建简单的sql语句进行查询(执行方法)
     * @param entity 要查询的实体
     * @param fields    where限制的字段名称
     * @param values where限制的字段值
     * @return list集合
     * @time 2018年9月17日18:02:49
     * @author authstr
     */
    public <T> List<T> queryByEntity(T entity,String[] fields,Object[] values){
        String tableName=ReflectionUtils.getEntityTableName(entity);//获取实体对应的表名
        //没获取到表名,抛出一个内部异常
        Assert.isTrue(StringUtils.hasText(tableName),
                "该实体类["+entity.getClass().getSimpleName()+"]没有设置表映射!",true);
        return queryByEntity(tableName,fields,values,"*",entity.getClass());
    }

• 还有一些扩展的方法,不过不一定会用上,代码中没有保留,这里只是备份一下

    /**
     * 根据实体查询一条数据
     * @see #queryOneByEntity(Object, String[])
     * @param entity entity 要解析的实体类
     * @param fields 要作为where限制条件的属性名称,属性值自动从实体中获取
     * @return 查询结果
     * @time 2018年9月17日22:37:52
     * @author authstr
     */
    @Override
    public <T> T queryOneByEntity(T entity,String fields){
        return queryOneByEntity(entity,new String[]{fields});
    }

    /**
     * 根据实体查询一条数据
     * @see #queryByEntity(Object, String[])
     * @see #queryByEntity(Object)
     * @param entity 要解析的实体类
     * @param fields 要作为where限制条件的属性名称,属性值自动从实体中获取
     * @return 查询结果
     * @time 2018年9月17日22:31:25
     * @author authstr
     */
    @Override
    public <T> T queryOneByEntity(T entity,String[] fields){
        List<T> res=queryByEntity(entity,fields);
        if(res==null||res.size()==0)return null;
        return res.get(0);
    }

    /**
     * 根据一个实体类构建简单的sql查询语句;     表名为该实体类映射的表,where限制字段为实体里值非空的属性,where限制的值为实体该属性的值,查询返回为"*";
     * 注意! 如果实体内有short,char,boolean类型的属性,会被加到限制条件中
     * @param entity 要解析的实体类
     * @return 查询结果
     * @time 2018年9月17日18:09:25
     * @author authstr
     */
    @Override
    public <T> List<T> queryByEntity(T entity){
        Map<String,Object> pv=ReflectionUtils.getFieldAndValue(entity);//获取实体类中已经存在的属性值
        return queryByEntity(entity,pv);
    }

    /**
     *  根据一个实体类和一些属性名称构建简单的sql查询语句;
     * @param entity 要解析的实体类
     * @param fields 要作为where限制条件的属性名称,属性值自动从实体中获取
     * @return 查询结果list
     * @time 2018年9月17日20:37:01
     * @author authstr
     */
    @Override
    public <T> List<T> queryByEntity(T entity,String[] fields){
        Map<String,Object> pv =new HashMap<String, Object>();
        for(int i=0;i<fields.length;i++){//遍历,从实体中取出对应属性的值
            //执行对应属性的get方法
            Object val=ReflectionUtils.executeGetMethod(entity, fields[i]);
            //如果没有get到值,抛出一个内部异常
            Assert.isTrue(val!=null,
                    "指定的属性["+fields[i]+"],未能在["+entity.getClass().getName()+"]类型中get到值!",true);
            pv.put(fields[i], val);//将值保存
        }
        return queryByEntity(entity,pv);
    }

    public <T> List<T> queryByEntity(T entity,Map<String,Object> pv){
        String[] fields=new String[pv.size()];
        Object[] values=new Object[pv.size()];
        int i=0;
        for (Entry<String, Object> entry : pv.entrySet()) {//遍历
            fields[i]= entry.getKey();
            values[i]= entry.getValue();
        }
        return queryByEntity(entity,fields,values);
    }

4.通过id获取实体对象

    /**
     * 通过id查询一个对象
     * @param clazz
     * @param id
     * @return
     * @time 2018年11月4日 下午4:19:01
     * @author authstr
     */
    @Override
    public <T> T get(Class<T> clazz, Serializable id) {
        return this.get(clazz, id, null);
    }

    /**
     * 根据id查询一个对象的指定字段
     * @param clazz
     * @param id
     * @param fields
     * @return
     * @time 2018年11月4日 下午4:18:30
     * @author authstr
     */
    @Override
    public <T> T get(Class<T> clazz, Serializable id, String[] fields) {
        //非空验证
        if (id == null || StringUtils.notText(id.toString())){
            return null;
        }
        //查询一个对象
        if (fields == null || fields.length <= 0){
            return this.getSession().get(clazz, id);
        }
        //拼接sql,查询指定字段
        StringBuffer sqlstring = new StringBuffer();
        sqlstring.append(" select  ");
        sqlstring.append(StringUtils.arrayToString(fields));
        sqlstring.append(" from " + clazz.getName());
        sqlstring.append(" where id=?");
        List<T> li= getByValuesSql(sqlstring.toString(),new Object[]{id},clazz);
        return CollectionUtils.listGetOneData(li);
    }

5.判断一个对象里一些属性的值是否具有唯一性

    /**
     * 判断一个对象里一些属性的值是否具有唯一性(参数重写)
     * @param model
     * @param field
     * @return
     * @time 2018年11月1日 上午11:26:41
     * @author authstr
     */
    @Override
    public <T extends AbstractModel> boolean isUnique(T model,String...field){
        String tableName=ReflectionUtils.getEntityTableName(model);
        //没获取到表名,抛出一个内部异常
        Assert.isTrue(StringUtils.hasText(tableName),
                "该实体类["+model.getClass().getSimpleName()+"]没有设置表映射!",true);
        return isUnique(model,tableName,field);
    }
    
    /**
     * 判断一个对象里一些属性的值是否具有唯一性
     * @param model 要判断的model对象
     * @param tableName  表名
     * @param field 字段名称
     * @return
     * @time 2018年11月1日 上午11:23:56
     * @author authstr
     */
    public <T extends AbstractModel> boolean isUnique(T model,String tableName,String...field){
        StringBuffer sqlstring= new StringBuffer();
        List<Object> values =new ArrayList<>();//参数值集合
        //构建查询语句
        sqlstring.append("select count(*) num from " + tableName + " a where 1=1 ");
        for(int i=0;i<field.length;i++){//遍历字段,拼接查询条件
            String fieldName=field[i].trim();
            if(StringUtils.hasText(fieldName)){
                 //获取属性值
                  Object propertyValue = ReflectionUtils.getProperty(model,fieldName);
                  sqlstring.append(" and a." + fieldName + "=?");
                  //记录属性值
                  values.add(propertyValue);
            }
        }
        //判断是否存在id
        if(model.getId()!=null){
            //id不等于当前id
            sqlstring.append(" and a.id <> ?");
            //记录属性值
            values.add(model.getId());
        }
        //执行查询
        List<Map>  list=getByValuesSql(sqlstring.toString(), values.toArray(), Map.class);
        Integer num= NumberUtils.toInteger(list.get(0).get("num"));
        if(num!=null&&num==0){
            return true;
        }
        return false;
    }

6.提供支持的反射工具类

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import javax.persistence.Table;
import org.apache.commons.beanutils.PropertyUtils;

/**
 * 反射操作的相关工具类
 * @author authstr
 *
 */
public class ReflectionUtils {
    
    /**
     * 获取一个实体对象所映射的表名,该对象需要使用了@Table注解
     * @param obj 要获取的对象
     * @return 返回映射的表名,如果无法获取,返回null
     * @time 2018年9月17日14:58:52
     * @author authstr
     */
    public static String getEntityTableName(Object obj){
        return getEntityTableName(obj.getClass());
    }
    /**
     * 获取一个实体对象所映射的表名,该对象需要使用了@Table注解
     * @param clazz 要获取的类型
     * @return 返回映射的表名,如果无法获取,返回null
     * @time 2018年9月17日14:58:52
     * @author authstr
     */
    public static String getEntityTableName(Class clazz){
        try {
            return ((Table)clazz.getAnnotation(Table.class)).name();
        } catch (Exception e) {
            return null;
        }
    }
    
    /**
     *  <p> 通过get方法获取对象的所有 属性值不为null的  属性和属性值 </p>
     * <p><b> 注意!</b> </p>
     * <p> 对于基本数据类型,int,long,float,double,short如果属性值为0,视为值不存在,不会返回 </p>
     *  <p>short,char,boolean会返回实际的值         </p>       
     * @param obj 要操作的对象
     * @return Map,key为属性名称,value为属性的值
     * @time 2018年9月17日15:59:46
     * @author authstr
     */
    public static Map<String,Object>  getFieldAndValue(Object obj){
        Class<? extends Object> clazz=obj.getClass();
        Field[] field= clazz.getDeclaredFields();//获取所有属性
        Map<String,Object> res=new HashMap<String, Object>();
        for(int i=0;i<field.length;i++){
            Object getResult=executeGetMethod(obj,field[i].getName());//获取该属性的get方法执行结果
            if(getResult instanceof Integer&&(int)getResult==0)getResult=null;//如果该结果是int,且值0,说明这个属性的值是初始值,实际没有赋值的,置为null
            if(getResult instanceof Long&&(long)getResult==0L)getResult=null;//类同上
            if(getResult instanceof Float&&(float)getResult==0f)getResult=null;//类同上
            if(getResult instanceof Double&&(double)getResult==0d)getResult=null;//类同上
            if(getResult instanceof Short&&(short)getResult==(short)0)getResult=null;//类同上
            if(getResult!=null)res.put(field[i].getName(), getResult);//如果通过这个属性拿到了结果,保存
        }
        return res;
    }
    
    /**
     * 方法是否存在(仅判断公共方法)
     * @param clazz 要判断的类
     * @param methodName 要判断的方法名称
     * @return true 存在 false 不存在
     * @time 2018年10月8日14:03:21
     * @author authstr
     */
    public static boolean isMethodExist(Class clazz,String methodName){
          Method[] method = clazz.getDeclaredMethods();//获取所有方法
          for(int i=0;i<method.length;i++){
              if(methodName.equals(method[i].getName())){
                  return true;//名字一样,返回true;
              }
          }
          return false;
    }   
    
    /**
     * 属性是否存在
     * @param clazz 要判断的类
     * @param fieldName 要判断的字段名称
     * @return true 存在
     * @time 2018年10月8日14:12:45
     * @author authstr
     */
    public static boolean isFieldExist(Class clazz,String fieldName){
        //获取所有属性
        Field[] field= clazz.getDeclaredFields();
        for(int i=0;i<field.length;i++){
            //名字一样,返回true;
            if(fieldName.equals(field[i].getName())){
                return true;
            }
        }
        return false;
    }
    
    /**
     * 获取对象里指定属性的值,获取失败返回null
     * @param target 要获取的对象
     * @param name  属性名称
     * @return
     * @time 2018年11月1日 上午10:30:47
     * @author authstr
     */
    public static Object getProperty(Object target, String name) {
        try {
            return PropertyUtils.getProperty(target, name);
        }
        catch (Exception e) {
            return null;
        }
    }
    
    /**
     * 调用对象中一个属性的get方法
     * @param obj 要操作的对象
     * @param fieldName 属性名称
     * @return 该get方法的执行结果
     * @time 2018年9月17日15:27:43
     * @author authstr
     */
    public static Object executeGetMethod(Object obj,String fieldName){
        fieldName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1); // 将属性的首字符大写，方便构造get，set方法
        Method m=null;
        try {
            //获取get方法
            m = obj.getClass().getMethod("get" + fieldName);
            return m.invoke(obj);//执行
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }       
    }
    
    /**
     * 调用对象中一个属性的set方法
     * @param obj 要操作的对象
     * @param fieldName 属性名称
     * @param value 要set的值
     * @throws Exception  异常信息
     * @time 2018年10月8日14:27:27
     * @author authstr
     */
    public static <T> void executeSetMethod(Object obj,String fieldName,T value) throws Exception {
        // 将属性的首字符大写，方便构造get，set方法
        fieldName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
        Method m=null;
         try {
            //获取set方法
            m = obj.getClass().getMethod("set" + fieldName,value.getClass());
            m.invoke(obj,value);//执行
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
            throw new Exception("未发现字段["+fieldName+"]的set方法");
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception("无法执行["+fieldName+"]的set方法");
        }
    }
    
}