对mybastis 的理解3--dao层数据库主通道工具类

package org.xnat.dao.util;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.xnat.dao.BaseDao;
import org.xnat.dao.DataSourceContextHolder;
import org.xnat.dao.Utils_dao;
import org.xnat.dao.annotation.Entity;
import org.xnat.dao.annotation.ForeignKey;
import org.xnat.util.Utils;

/**
 * dao 层通用　用的是　BaseDao(第一版)
 * @author xnat
 * Nov 1, 2014 2:50:21 PM
 */
@Component
public class BaseDaoUtil_v3 {
    @Autowired
    private BaseDao baseDao;
    
    /**
     * 切换数据源
     * @param clazz
     * Oct 16, 2014 4:19:27 PM
     */
    public static <T> void setDataSource(Class<T> clazz) {
        if (DataSourceContextHolder.DATASOURCE1.equals(clazz.getAnnotation(Entity.class).dataSourceId())) {
            DataSourceContextHolder.setDbType(DataSourceContextHolder.DATASOURCE1);
        }
        else if (DataSourceContextHolder.DATASOURCE2.equals(clazz.getAnnotation(Entity.class).dataSourceId())) {
            DataSourceContextHolder.setDbType(DataSourceContextHolder.DATASOURCE2);
        }
        
    }
    /**
     * sql insert区
     */
    
    /**
     * 插入一条记录
     * @param obj
     * @return
     * Oct 16, 2014 4:23:09 PM
     */
    public Integer insert(Object obj) {
        setDataSource(obj.getClass());
        return baseDao.insert(Utils_dao.getTableName(obj.getClass()), AutoMap.configSelf(obj));
    }
    /**
     * 插入一条记录 返回自增长id
     * @param obj
     * @param map　(保存tableName, autoMaps)
     * @return
     */
    public Integer insert(Object obj, Map<String, Object> map) {
        setDataSource(obj.getClass());
        map.put("tableName", Utils_dao.getTableName(obj.getClass()));
        map.put("autoMaps", AutoMap.configSelf(obj));
        return baseDao.insert_v1_2(map);
    }
    
    /**
     * 自定义条件删除
     * @param clazz
     * @param conditions
     * @return
     */
    public <T> int delete(Class<T> clazz, List<AutoMap> conditions) {
        setDataSource(clazz);
        return baseDao.delete_v3(Utils_dao.getTableName(clazz), conditions);
    }
    public <T> int delete(Object obj) {
        return delete(obj.getClass(), AutoMap.configSelf(obj));
    }
    public <T> int delete(Class<T> clazz, String conditionSql) {
        setDataSource(clazz);
        return baseDao.delete_v3_2(Utils_dao.getTableName(clazz), conditionSql);
    }
    /**
     * 根据一个字段的值删除
     * @param clazz
     * @param fieldName
     * @param fieldValue
     * @return
     */
    public <T> int deleteByField(Class<T> clazz, String fieldName, Object fieldValue) {
        List<AutoMap> conditions = new ArrayList<AutoMap>();
        conditions.add(new AutoMap(fieldName, "=", fieldValue));
        return delete(clazz, conditions);
    }
    /**
     * 根据id字段删除
     * @param clazz
     * @param id
     * @return
     */
    public <T> int deleteById(Class<T> clazz, Object id) {
        return deleteByField(clazz, Utils_dao.getIdField(clazz).getName(), id);
    }
    
    
    
    /**
     * sql update区
     */
    
    /**
     * 根据自定义(多个)条件更新
     * @param clazz
     * @param setFields
     * @param conditions
     * @return
     * Oct 10, 2014 5:53:49 PM
     */
    public <T> int update(Class<T> clazz, List<AutoMap> setFields, List<AutoMap> conditions) {
        setDataSource(clazz);
        return baseDao.update_v2(Utils_dao.getTableName(clazz), setFields, conditions);
    }
    public <T> int update(Class<T> clazz, List<AutoMap> setFields, String conditionSql) {
        setDataSource(clazz);
        return baseDao.update_v2_2(Utils_dao.getTableName(clazz), setFields, conditionSql);
    }
    
    /**
     * 根据自定义(多个)条件更新
     * @param obj
     * @param conditions
     * @return
     */
    public int update(Object obj, List<AutoMap> conditions) {
        return update(obj.getClass(), AutoMap.configSelf(obj), conditions);
    }
    public int update(Object obj, String conditionSql) {
        return update(obj.getClass(), AutoMap.configSelf(obj), conditionSql);
    }
    /**
     * 根据任意一个字段更新
     * @param obj
     * @param fieldName
     * @return
     */
    public int updateByField(Object obj, String fieldName) {
        ArrayList<AutoMap> conditions = new ArrayList<AutoMap>();
        conditions.add(new AutoMap(fieldName, "=", DataUtils.bean_getFieldValue(obj, fieldName)));
        return update(obj, conditions);
    }
    /**
     * 根据id字段更新
     * @param obj
     * @return
     * @throws Exception
     */
    public int updateById(Object obj) {
        return updateByField(obj, Utils_dao.getIdField(obj.getClass()).getName());
    }
    
    /**
     * 查询专区 包含各种便捷查询
     */
    
    /**
     * baseDao select_v4
     * @param <T>
     * @param tableName 表名
     * @param selectFields 要查询的字段
     * @param conditions 查询的条件
     * @param group　分组
     * @param havingSql 分组having Sql语句
     * @param sort 排序条件
     * @param page 分页查询
     * @return
     */
    private <T> List<Map<String, Object>> select(Class<T> clazz,
            List<String> selectFields, List<AutoMap> conditions, List<String> group, String havingSql, List<AutoMap> sort, Page page) {
        setDataSource(clazz);
        return baseDao.select_v4(Utils_dao.getTableName(clazz), selectFields, conditions, group, havingSql, sort, page);
    }
    /**
     * baseDao select_v4_2
     * @param tableName
     * @param selectFields
     * @param conditionSql 条件为字符串 以 "where 开头"
     * @param group
     * @param havingSql
     * @param sort
     * @param page
     * @return
     * Oct 16, 2014 3:13:49 PM
     */
    private <T> List<Map<String, Object>> select(Class<T> clazz, List<String> selectFields,
            String conditionSql, List<String> group, String havingSql, List<AutoMap> sort, Page page) {
        setDataSource(clazz);
        return baseDao.select_v4_2(Utils_dao.getTableName(clazz), selectFields, conditionSql, group, havingSql, sort, page);
    }
    /**
     * 默认查询所有字段
     * @param clazz
     * @param conditions 条件为List<AutoMap>
     * @param group
     * @param havingSql
     * @param sort
     * @param page
     * @return
     */
    public <T> List<Map<String, Object>> select(Class<T> clazz,
            List<AutoMap> conditions, List<String> group, String havingSql, List<AutoMap> sort, Page page) {
        return select(clazz, Utils_dao.getAllFields(clazz), conditions, group, havingSql, sort, page);
    }
    /**
     * 默认查询所有字段
     * @param clazz
     * @param conditionSql 条件为字符串 以 "where 开头"
     * @param group
     * @param havingSql
     * @param sort
     * @param page
     * @return
     */
    public <T> List<Map<String, Object>> select(Class<T> clazz,
            String conditionSql, List<String> group, String havingSql, List<AutoMap> sort, Page page) {
        return select(clazz, Utils_dao.getAllFields(clazz), conditionSql, group, havingSql, sort, page);
    }
    /**
     *
     * @param clazz
     * @param conditionSql 条件为字符串 以 "where 开头"
     * @param page
     * @return
     */
    public <T> List<Map<String, Object>> select(Class<T> clazz, String conditionSql, Page page) {
        return select(clazz, Utils_dao.getAllFields(clazz), conditionSql, null, null, null, page);
    }
    /**
     *
     * @param clazz
     * @param selectFields 自定义要查询的字段
     * @param conditionSql 条件为字符串 以 "where 开头"
     * @param page
     * @return
     * Oct 16, 2014 3:33:22 PM
     */
    public <T> List<Map<String, Object>> select(Class<T> clazz,
            List<String> selectFields, String conditionSql, Page page) {
        return select(clazz, selectFields, conditionSql, null, null, null, page);
    }
    /**
     *
     * @param clazz
     * @param conditionSql
     * @param sort
     * @param page
     * @return
     * Oct 16, 2014 3:34:34 PM
     */
    public <T> List<Map<String, Object>> select(Class<T> clazz,
            String conditionSql, List<AutoMap> sort, Page page) {
        return select(clazz, Utils_dao.getAllFields(clazz), conditionSql, null, null, sort, page);
    }
    /**
     *
     * @param clazz
     * @param conditions
     * @param sorts
     * @param page
     * @return
     */
    public <T> List<Map<String, Object>> select(Class<T> clazz, List<AutoMap> conditions, List<AutoMap> sorts, Page page) {
        return select(clazz, Utils_dao.getAllFields(clazz), conditions, null, null, sorts, page);
    }
    
    /**
     *
     * @param clazz
     * @param conditions
     * @param sorts
     * @param page
     * @param lookupForeignKey 是否查找其关联的外键
     * @return
     * Oct 16, 2014 9:38:43 PM
     */
    public <T> List<Map<String, Object>> select(Class<T> clazz,
            List<AutoMap> conditions, List<AutoMap> sorts, Page page, boolean lookupForeignKey) {
        List<Map<String, Object>> list = select(clazz, conditions, sorts, page);
        if (!lookupForeignKey) return list;
        
        for (Field field :clazz.getDeclaredFields()) {
            ForeignKey foreignKeyAnnotation = field.getAnnotation(ForeignKey.class);
            if (foreignKeyAnnotation == null) continue;
            
            for (Map<String, Object> map : list) {
                List<Map<String, Object>> maps = getObjsByField(foreignKeyAnnotation.refEntity(),
                        foreignKeyAnnotation.refFiled(), map.get(field.getName()), page);
                if (maps.size() > 1) {
                    map.put(Utils.firstLetterToLower(foreignKeyAnnotation.refEntity().getSimpleName()), maps);
                }
                else {
                    map.put(Utils.firstLetterToLower(foreignKeyAnnotation.refEntity().getSimpleName()), DataUtils.listmap_getFirstMap(maps));
                }
            }
        }
        return list;
    }
    
    /**
     * 分页,排序,条件
     * @param obj
     * @param page
     * @param sorts
     * @return
     */
    public List<Map<String, Object>> select(Object obj, Page page, List<AutoMap> sorts) {
        return select(obj.getClass(), Utils_dao.getAllFields(obj.getClass()),
                AutoMap.configSelf(obj), null, null, sorts, page);
    }
    
    /**
     * 自定义sql(用程序拼装任意sql) 查询
     * @param sql
     * @return
     */
    public List<Map<String, Object>> select(String sql) {
        return baseDao.selectSql(sql);
    }
    /**
     *
     * @param sql
     * @param clazz 为了确定数据源
     * @return
     * Oct 16, 2014 2:21:45 PM
     */
    public <T> List<Map<String, Object>> select(String sql, Class<T> clazz) {
        setDataSource(clazz);
        return baseDao.selectSql(sql);
    }
    /**
     * 查询所有
     * @param clazz
     * @return
     */
    public <T> List<Map<String, Object>> getAll(Class<T> clazz) {
        return getAllByPage(clazz, null, new Page(0, 500));
    }
    /**
     * 查询所有(有排序, 分页)
     * @param clazz
     * @param sorts
     * @return
     */
    public <T> List<Map<String, Object>> getAllByPage(Class<T> clazz, List<AutoMap> sorts, Page page) {
        return select(clazz, Utils_dao.getAllFields(clazz), (String)null, null, null, sorts, page);
    }
    /**
     * 从返回的 List<Map<String, Object>> 中查找一个
     * @param maps
     * @param key
     * @return
     */
//    public Map<String, Object> getMapFromList(List<Map<String, Object>> maps, String key) {
//        for (Map<String, Object> map: maps) {
//            Iterator<String> it = map.keySet().iterator();
//            while (it.hasNext()) if (key.equals(it.next())) return map;
//        }
//        return null;
//    }
    /**
     * 根据一个字段查找一个对象
     * @param obj
     * @param fieldName
     * @return
     */
    public Object getObjByField(Object obj, String fieldName) {
        List<AutoMap> conditions = new ArrayList<AutoMap>();
        conditions.add(new AutoMap(fieldName, "=", DataUtils.bean_getFieldValue(obj, fieldName)));
        List<Map<String, Object>> objs = select(obj.getClass(), conditions, null, null);
        
        if (objs == null || objs.size() < 1) return null;
        try {
            BeanUtils.populate(obj, objs.get(0));
        } catch (IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return obj;
    }
    
    /**
     *
     * @param clazz
     * @param fieldName 字段名
     * @param fieldValue　字段值
     * @param selectFields　选择要查询的字段
     * @return
     * Oct 31, 2014 5:38:49 PM
     */
    public <T> Object getObjByField(Class<T> clazz, String fieldName, Object fieldValue, List<String> selectFields) {
        String conditionSql = "where "+fieldName+"="+fieldValue;
        List<Map<String, Object>> objs = select(clazz, selectFields, conditionSql, new Page(10));
        if (objs == null || objs.size() < 1) return null;
        T obj = null;
        try {
            obj = clazz.newInstance();
            BeanUtils.populate(obj, objs.get(0));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }
    public <T> Object getObjByField(Class<T> clazz, String fieldName, Object fieldValue) {
        return getObjByField(clazz, fieldName, fieldValue, Utils_dao.getAllFields(clazz));
    }
    /**
     * 根据id查找对象
     * @param obj
     * @return
     */
    public <T> Object getObjById(Class<T> clazz, Integer id) {
        return getObjByField(clazz, Utils_dao.getIdField(clazz).getName(), id);
    }
    public Object getObjById(Object obj) {
        return getObjByField(obj, Utils_dao.getIdField(obj.getClass()).getName());
    }
    /**
     * 根据一个字段查找多条记录
     * @param obj
     * @param fieldName
     * @return
     */
    public List<Map<String, Object>> getObjsByField(Object obj, String fieldName) {
        return getObjsByField(obj.getClass(), fieldName, DataUtils.bean_getFieldValue(obj, fieldName));
    }
    /**
     * 根据一个字段查找多条记录
     * @param clazz
     * @param fieldName
     * @param fieldValue
     * @param page
     * @return
     * Oct 17, 2014 10:00:33 AM
     */
    public <T> List<Map<String, Object>> getObjsByField(Class<T> clazz, String fieldName, Object fieldValue, Page page) {
        List<AutoMap> conditions = new ArrayList<AutoMap>();
        conditions.add(new AutoMap(fieldName, "=", fieldValue));
        return select(clazz, conditions, null, page);
    }
    /**
     * 根据一个字段查找多条记录
     * @param <T>
     * @param obj
     * @param fieldName
     * @return
     */
    public <T> List<Map<String, Object>> getObjsByField(Class<T> clazz, String fieldName, Object fieldValue) {
        return getObjsByField(clazz, fieldName, fieldValue, null);
    }
    
    /**
     * getTotal 区
     */
    
    /**
     * 根据条件 得到此条件下的总数
     * @param clazz
     * @param conditions
     * @return
     */
    public <T> int getTotal(Class<T> clazz, List<AutoMap> conditions) {
        setDataSource(clazz);
        return baseDao.getTotal(Utils_dao.getTableName(clazz), conditions);
    }
    /**
     * 根据条件 得到此条件下的总数
     * @param clazz
     * @param conditionSql
     * @return
     */
    public <T> int getTotal(Class<T> clazz, String conditionSql) {
        setDataSource(clazz);
        return baseDao.getTotal_v1_2(Utils_dao.getTableName(clazz), conditionSql);
    }
    public <T> int getTotal(Class<T> clazz) {
        return getTotal(clazz, (String) null);
    }
    
    /**
     * 其它查询
     */
    
    /**
     *
     * @param clazz
     * @param fieldName
     * @param conditions
     * @return
     * Oct 16, 2014 4:07:44 PM
     */
    public <T> long countField(Class<T> clazz, String fieldName, List<AutoMap> conditions) {
        setDataSource(clazz);
        return baseDao.countField(Utils_dao.getTableName(clazz), fieldName, conditions);
    }
}

时间： 2024-10-15 07:27:40

对mybastis 的理解3--dao层数据库主通道工具类的相关文章

java 数据库查询工具类.

import java.util.List;import java.util.Map; /** * 数据库查询工具类. * */public class QueryTool {        /**     * Checks if is condition.     *     * @param obj the obj     * @return true, if is condition     */    public static boolean isCondition(Object ob

java 链接Oracle数据库的工具类

java连接Oracle数据库的方式 1 特点:oracle.jdbc.OracleDriver是注册oracle驱动类: jdbc:oracle:thin:@localhost:1521:xe:连接oracle的方式:网络协议+访问方式+IP+端口号+xe数据库: user:hr数据库用户名 Password:hr数据库的用户密码 缺点:statement方式连接数据库容易被黑客注入式攻击 所有不安全 现在企业中很少采用这种方式的了 连接数据库后一定的关闭连接,这个最容易忘记 调用close(

C#（.net） MySql数据库链接工具类

先下载和安装MySQLDriverCS http://sourceforge.net/projects/mysqldrivercs/ 在安装文件夹下面找到MySQLDriver.dll,然后将MySQLDriver.dll添加引用到项目中 应用程序配置文件: App.config: <?xml version="1.0" encoding="utf-8" ?> <configuration> <connectionStrings>

ASP.NET:分享一个操作SQL Server数据库的工具类

1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Web; 5 using System.Collections; 6 using System.Data.SqlClient; 7 8 public class DatabaseHelper 9 { 10 private string connectionString = Constants.ConnectionURL;

SSH框架中POJO层， Dao层，Service层， Action层的功能理解

pojo层就是对应的数据库表的实体类(如User类). dao层,一般可以再分为***dao接口和***daoImpl实现类,如userDao接口和userDaoImpl实现类,接口负责定义数据库curd的操作方法,实现类负责具体的实现,即实现Dao接口定义的方法. service层,引用对应的dao层数据库操作,在这里可以编写自己需要的代码(比如简单的判断),也可以再细分为service接口和serviceImpl实现类. action层:引用对应的Service层实现业务逻辑,在这里结合St

JAVA实现DAO层基本CRUD操作

随着shh2框架各种操作的便利性,越来越多的JAVA WEB开发人员选择通过加入这些框架以提高开发效率,但是,如果在不了解这些框架使用的场合的情况下,一拿到项目就盲目地选择这些框架进行系统架构的搭建,就有可能造成很多没必要的资源浪费. 在项目开发中,对数据库的CRUD操作我们一般都是无法避免的操作,虽然hibernate封装的很完美,但是,由于本人对这个框架的底层原理不是很了解,每次使用的时候心里总觉得没底,代码一旦出现异常,很多时候都没法快速有效地解决,因此,为了让代码异常处理风险控制在自己的

java web项目DAO层通用接口BaseDao与实现类BaseDaoImpl

在spring+hibernate的web项目中,处理数据层通常会使用Spring框架提供的HibernateTemplate类提供的方法.通常的用法是每一个实体类对应的去写DAO层的接口和实现类.每个实现类中都写hibernateTemp.save(entity).hibernateTemp.update(entity).hibernateTemp.get(id)...这样写固然没错,但存在着大量的重复代码.所以懒惰的程序员烦了,他们要写一个通用的实现类来解决这个问题,让DAO层解放出来.如果

我的Dao层

Spring 为整合 Hibernate3 提供了两个工具类,分别是 HibernateTemplate 和 HibernateDaoSupport ,但是 Spring 不推荐使用这两个实现 Dao 层,因为操作复杂 CRUD 不是很灵活,而是推荐使用通过注入 SessionFactory 的方式,用过 getCurrentSession() 获取当前线程的 Session 对象,然后进行持久化. 下面是我在自己练手项目中实现的 Dao 层: 1 .  Dao层的顶层接口类: package

JavaWeb中Dao层的接口和基本功能简单抽取技巧

在dao层书写具体实现类的时候会将dao层功能抽取到接口中,然后去实现该接口,实现具体方法,书写具体功能代码. 抽取如图: 但是这种抽取不是很友好,由图可以看出,每个实现类中都要书写共同的增删改查方法,这样就是使得代码存再冗余,重复代码多次书写.此时就需要考虑将增删改查的代码再次抽取出来,写在一个类中. 抽取如图: 将增删改查的共用代码抽取到BaseDaoImpl中,提高代码的重用性,在具体的Dao调用共用方法时,指定泛型类型即可.