多库多表动态查询dao

最新推荐文章于 2022-06-25 08:04:50 发布
最新推荐文章于 2022-06-25 08:04:50 发布
阅读量962 收藏 1
点赞数
文章标签： apache 数据库 sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41982570/article/details/122070417
版权

多库多表动态查询dao

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;


/**
 * @author 
 * @ClassName: DynamicTableDao
 * @Description:多库多表动态查询dao
 * @date 
 * @Copyright 
 */

public class DynamicTableDao {
    private static final Logger LOGGER = LoggerFactory.getLogger(DynamicTableDao.class);

    /**
     * 根据sql查询动态表中的数据总数
     *
     * @param entitySql 要执行sql
     * @param dbName    数据库名称
     * @return 记录数
     */
    public static Integer queryDataCount(String entitySql, String dbName) {
        //获取连接池
        DruidDataSource dataSource = DruidDataSourceUtils.getDataSource(BouleraiConstans.BUSINESS_DBNAME);
        QueryRunner qr = new QueryRunner(dataSource);
        //获取所有条数
        Integer totalCount = 0;
        try {
            totalCount = ((Long) qr.query(entitySql, new ScalarHandler())).intValue();
        } catch (SQLException e) {
            LOGGER.error("sql查询失败! " + entitySql, e);
        }
        return totalCount;
    }

    /**
     * 根据sql查询动态表中的分页数据列表
     *
     * @param entitySql 要执行sql
     * @param dbName    数据库名称
     * @return 分页数据列表
     */
    public static List<Map<String, Object>> queryPageDataList(String entitySql, String dbName) {
        //获取连接池
        DruidDataSource dataSource = DruidDataSourceUtils.getDataSource(BouleraiConstans.BUSINESS_DBNAME);
        QueryRunner qr = new QueryRunner(dataSource);
        List<Map<String, Object>> dbList = null;
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            dbList = qr.query(connection, entitySql, new MapListHandler());
        } catch (Exception ex) {
            LOGGER.error("sql查询失败! " + entitySql, ex);
        } finally {
            try {
                DbUtils.close(connection);
            } catch (Exception e1) {
                LOGGER.error("close  error! ", e1);
            }
        }
        return dbList;
    }
}


public class BouleraiConstans {

    public  static volatile  Boolean  finishFinished=false;

    /**
     *  返回的一次性多少条记录
     */
    public static final   int  PAGE_SIZE=100;


    /**
     *数据库
     */
    public static final String BUSINESS_DBNAME = "eimos_business";


    /**
     *执行数据库删除
     */
    public final static  String DB_ACTION_DELETE ="delete";

    /**
     *执行数据库更新
     */
    public final static  String DB_ACTION_UPDATE ="update";


    /**
     *执行数据库新增
     */
    public final static  String DB_ACTION_CREATE ="create";

    /**
     *客户端请求类型：option
     */
    public final static  String REQUEST_TYPE_OPTION ="option";

    /**
     *客户端请求类型: tree
     */
    public final static  String REQUEST_TYPE_TREE="tree";

    /**
     *客户端请求类型: others
     */
    public final static  String REQUEST_TYPE_OTHERS="others";

    /**
     *顶层树id
     */
    public final static  Long  BUSINESS_TREE_ROOT_ID =0L;



    /**
     * 返回所有data_type类型列表
     */
    public final static  String ALL_DATA_TYPE_LIST_SQL="select bd_basic_data_type_id  as id,type_code,type_name  from bd_basic_data_type  where is_delete is false  ";


    public final static String DATE_LONG_FORMAT = "yyyy-MM-dd HH:mm:ss";

    public final static String DATE_SHORT_FORMAT = "yyyy-MM-dd";


    public final static String PG_TABLE_SCHEMAL_SQL = "yyyy-MM-dd";
}

数据源工具

import com.alibaba.druid.pool.DruidDataSource;
import com.boulderaitech.data.config.rules.entity.C3p0ConfigEntity;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.Connection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author 
 * @ClassName: DruidDataSourceUtils
 * @Description: 数据源工具
 * @date 
 * @Copyright 
 */
public class DruidDataSourceUtils {
    private final static Logger LOGGER = LoggerFactory.getLogger(DruidDataSourceUtils.class);

    /**
     * 数据库连接池保存map： name:DruidDataSource
     */
    private static Map<String, DruidDataSource> databaseMap = new HashMap<String, DruidDataSource>();


    /**
     * 根据配置初始化连接池
     *
     * @param dbconfigs 连接池配置
     */
    public static Boolean initDbList(List<C3p0ConfigEntity> dbconfigs) {
        if (dbconfigs == null || dbconfigs.isEmpty()) {
            LOGGER.error("数据库连接池配置无效！请检查");
            return false;
        }

        Boolean hasError = false;

        //遍历获取连接池
        for (C3p0ConfigEntity c3p0Config : dbconfigs) {
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setName(c3p0Config.getDbName());
            //dataSource.setDriverClassName(driverClassName);//如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName
            dataSource.setUrl(c3p0Config.getJdbcUrl());
            dataSource.setUsername(c3p0Config.getUserName());
            dataSource.setPassword(c3p0Config.getPassword());
            dataSource.setDriverClassName("org.postgresql.Driver");


            dataSource.setMaxActive(30);
            dataSource.setInitialSize(2);
            // 配置获取连接等待超时的时间
            dataSource.setMaxWait(10000);
            dataSource.setMinIdle(2);
            // 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
            dataSource.setTimeBetweenEvictionRunsMillis(60000);
            // 配置一个连接在池中最小生存的时间，单位是毫秒 超过这个时间每次会回收默认3个连接
            dataSource.setMinEvictableIdleTimeMillis(30000);
            // 线上配置的mysql断开闲置连接时间为1小时,数据源配置回收时间为3分钟,以最后一次活跃时间开始算
            dataSource.setMaxEvictableIdleTimeMillis(180000);
            // 连接最大存活时间，默认是-1(不限制物理连接时间)，从创建连接开始计算，如果超过该时间，则会被清理
            dataSource.setPhyTimeoutMillis(15000);
            dataSource.setValidationQuery("select 1");
            dataSource.setTestWhileIdle(true);
            dataSource.setTestOnBorrow(false);
            dataSource.setTestOnReturn(false);
            dataSource.setPoolPreparedStatements(true);
            dataSource.setMaxOpenPreparedStatements(20);
            dataSource.setUseGlobalDataSourceStat(true);
            dataSource.setKeepAlive(true);
            dataSource.setRemoveAbandoned(true);
            dataSource.setRemoveAbandonedTimeout(180);
            /**
             * //用来检测连接是否有效
             */
            dataSource.setValidationQuery(" select 1  ");


            try {
                dataSource.init();
            } catch (Exception e1) {
                LOGGER.error("动态数据初始化失败: " + c3p0Config, e1);
                hasError = true;
            }

            databaseMap.put(c3p0Config.getDbName(), dataSource);
        }
        return hasError;
    }


    /**
     * 根据数据库名称获取连接池
     *
     * @param dbName 数据库名称
     * @return 连接池
     */
    public static DruidDataSource getDataSource(String dbName) {
        DruidDataSource db = databaseMap.get(dbName);
        return db;
    }

    /**
     * 根据数据库名称获取连接
     *
     * @param dbName 数据库名称
     * @return 数据库连接
     */
    public static Connection getConnection(String dbName) {
        DruidDataSource db = databaseMap.get(dbName);
        Connection conn = null;
        try {
            conn = db.getConnection();
        } catch (Exception ex) {
            LOGGER.error("getConnection error!", ex);
        }
        return conn;

    }
}

数据库连接池配置


import java.util.Date;
import java.util.Objects;


/**
 * @ClassName: C3p0ConfigEntity
 * @Description:数据库连接池配置
 * @author  
 * @date 
 * @Copyright 
 */
public class C3p0ConfigEntity extends BaseBean {
    private static final long serialVersionUID = -2007678110412798920L;

    /**
     *     c3p0配置相关参数，不注释，自己区看c3p0东西
     */
    private String dbName;
    private String  driverClass;
    private String jdbcUrl;
    private String userName;
    private String password;
    private int initialPoolSize;
    private int maxIdleTime;
    private int maxPoolSize;
    private int minPoolSize;
    private int maxStatements;
    private Boolean testConnectionOnCheckout=false;
    private Boolean testConnectionOnCheckin=false;
    private int acquireIncrement=3;
    private Boolean autoCommitOnClose=false;
    private int priority;
    private int status;
    private Date modifyTime;
    private Boolean canDropOdpsTable=false;

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        C3p0ConfigEntity that = (C3p0ConfigEntity) o;
        return Objects.equals(dbName, that.dbName);
    }

    public Boolean getCanDropOdpsTable() {
        return canDropOdpsTable;
    }

    public void setCanDropOdpsTable(Boolean canDropOdpsTable) {
        this.canDropOdpsTable = canDropOdpsTable;
    }

    @Override
    public int hashCode() {
        return Objects.hash(dbName);
    }

    public String getDbName() {
        return dbName;
    }

    public void setDbName(String dbName) {
        this.dbName = dbName;
    }

    public String getDriverClass() {
        return driverClass;
    }

    public void setDriverClass(String driverClass) {
        this.driverClass = driverClass;
    }


    public String getJdbcUrl() {
        return jdbcUrl;
    }

    public void setJdbcUrl(String jdbcUrl) {
        this.jdbcUrl = jdbcUrl;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getInitialPoolSize() {
        return initialPoolSize;
    }

    public void setInitialPoolSize(int initialPoolSize) {
        this.initialPoolSize = initialPoolSize;
    }

    public int getMaxIdleTime() {
        return maxIdleTime;
    }

    public void setMaxIdleTime(int maxIdleTime) {
        this.maxIdleTime = maxIdleTime;
    }

    public int getMaxPoolSize() {
        return maxPoolSize;
    }

    public void setMaxPoolSize(int maxPoolSize) {
        this.maxPoolSize = maxPoolSize;
    }

    public int getMinPoolSize() {
        return minPoolSize;
    }

    public void setMinPoolSize(int minPoolSize) {
        this.minPoolSize = minPoolSize;
    }

    public int getMaxStatements() {
        return maxStatements;
    }

    public void setMaxStatements(int maxStatements) {
        this.maxStatements = maxStatements;
    }

    public Boolean getTestConnectionOnCheckout() {
        return testConnectionOnCheckout;
    }

    public void setTestConnectionOnCheckout(Boolean testConnectionOnCheckout) {
        this.testConnectionOnCheckout = testConnectionOnCheckout;
    }

    public Boolean getTestConnectionOnCheckin() {
        return testConnectionOnCheckin;
    }

    public void setTestConnectionOnCheckin(Boolean testConnectionOnCheckin) {
        this.testConnectionOnCheckin = testConnectionOnCheckin;
    }

    public int getAcquireIncrement() {
        return acquireIncrement;
    }

    public void setAcquireIncrement(int acquireIncrement) {
        this.acquireIncrement = acquireIncrement;
    }

    public Boolean getAutoCommitOnClose() {
        return autoCommitOnClose;
    }

    public void setAutoCommitOnClose(Boolean autoCommitOnClose) {
        this.autoCommitOnClose = autoCommitOnClose;
    }

    public int getPriority() {
        return priority;
    }

    public void setPriority(int priority) {
        this.priority = priority;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public Date getModifyTime() {
        return modifyTime;
    }

    public void setModifyTime(Date modifyTime) {
        this.modifyTime = modifyTime;
    }

    @Override
    public String toString() {
        return "C3p0ConfigEntity{" +
                "dbName='" + dbName + '\'' +
                ", driverClass='" + driverClass + '\'' +
                ", jdbcUrl='" + jdbcUrl + '\'' +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", initialPoolSize=" + initialPoolSize +
                ", maxIdleTime=" + maxIdleTime +
                ", maxPoolSize=" + maxPoolSize +
                ", minPoolSize=" + minPoolSize +
                ", maxStatements=" + maxStatements +
                ", testConnectionOnCheckout=" + testConnectionOnCheckout +
                ", testConnectionOnCheckin=" + testConnectionOnCheckin +
                ", acquireIncrement=" + acquireIncrement +
                ", autoCommitOnClose=" + autoCommitOnClose +
                ", priority=" + priority +
                ", status=" + status +
                ", modifyTime=" + modifyTime +
                '}';
    }
}
高个子男孩
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Thinkphp 多库查询
文嘉
05-04 1991
thinkphp的多库查询有很多种，今天到需求是在每个工程中都有对某个数据库的操作，这个连接就一个model类使用。 反正就是解决多库查询，库可以不再一个服务器上。 连接写在model中 配置文件中： /* 全局数据库设置 */ 'DB_TYPE' => 'mysql', // 数据库类型 'DB_HOST' => 'localhost', // 服务器地址 'DB_NAME'
在DaoHibernate多表查询：
yuke98727的博客
01-03 747
在DaoHibernate多表查询： import org.hibernate.HibernateException; import org.hibernate.Query; import org.hibernate.Session; import org.springframework.orm.hibernate3.HibernateCallback; import org.s
Spring Data JPA 入门案例
weixin_40055163的博客
10-21 257
Spring Data JPA 入门案例 1.打开IDEA工具的界面如图所示，点击Create New Project。 2.选择Maven工程和JDK的版本，并点击Next。如图所示： 3.填写项目名称和保存的地址，点击Finish。如图所示： 4.导入相应的依赖jar包的代码如下： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmln
MySQL数据库多表查询
weixin_60754763的博客
06-25 101
本贴是关于多表查询的内容
mysql数据库全文多库多表查找，查询所有数据库中包含指定字符的数据。
06-07
1、支持所有数据库查询字符串，或者指定一个或者多个数据库查询字符串； 2、支持本地使用或者指定远程数据库地址； 3、支持命令行指定参数方便运行，支持省略参数； 4、支持显示匹配的数据来自数据库名称和表名称； ...
基于Oracle多库查询方法(分享)
09-09
总的来说，Oracle的多库查询功能通过Database Link和同义词提供了灵活的数据交互方式，使得在多个数据库间进行数据操作和分析变得简单高效。在实际工作中，这有助于提升数据管理和分析的效率，尤其在大型企业环境中...
sqlserver 多库查询 sp_addlinkedserver使用方法（添加链接服务器）
09-11
在SQL Server中，多库查询是一项重要功能，它允许用户跨多个数据库或甚至不同服务器的数据库执行查询。当需要从分布在不同服务器上的多个数据库中获取数据时，`sp_addlinkedserver` 存储过程就显得非常有用。这个...
thinkPHP5解决不同服务器不同数据库表关联查询问题
08-09
虽然MySQL本身不支持直接进行这样的查询，但通过配置多个数据库连接并结合thinkPHP5的DB类，我们可以灵活地解决这一问题。这种方法不仅适用于简单的关联查询，还可以根据具体需求进行更为复杂的查询操作。当然，如果...
tp5(thinkPHP5)框架实现多数据库查询的方法
10-17
### 多数据库查询的重要性 在复杂的系统中，比如一个综合性的管理后台，往往需要同时管理多个不同业务的数据。例如，商城管理、直播管理、消息管理等等，每个业务都可能有自己的数据库。这就要求后端框架能够方便地...
GreenDao的多表联结的实例
04-28
Android开发中的数据库框架很多，比如ormlite，sqlite，greendao等等。但是greendao以占用内存小，操作简单而被广泛使用。作为这个架构的初学者，我是通过一个demo来学习。这个demo中有详尽的代码，可以直接运行。
多库多表大数据查询讨论
weixin_30606669的博客
04-19 351
求问大神 1000张结构相同的表 分布在10个数据库每个数据库100张表每张表100w条数据，有什么高效的查询方法 不做跨库join什么都好 现在要跨裤啊 在分库分表的时候 肯定有规律吧 恩有规律 从第一个库的第一张表第一条数据是标号是0000001 你要查询多少出来 现在要查找某一条数据呢 某一条 的条件是什么呢能根据条件找到哪个库 哪张表吗 根据条件判断应该在哪个服务器，哪个...
MySql多库查询及连表查询
Z_hhhha的博客
12-01 1911
多库查询时，默认为当前连接的数据库，如果需要别的数据库时可在表面前加数据库名称即可实现，多库多表连接及查询
多条件查询数据库Dao
伍马
08-23 1977
package com.mkk.goods.books.bookDao; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; import org.apache.commons.dbutils.QueryRunner; import org.apache.commons.dbutils
传智播客---查看订单明细表的DAO多表查询写法
zhengwenju的专栏
11-19 911
<br /> public Order find(String id){<br />  <br />  try {<br />   QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());<br />   <br />   //查找订单表，找出订单的基本信息<br />   String sql = "select * from orders where id=?";<br />   Order order = (Order) runn
NutzDao多表关联分页查询
zhang_jingrui的专栏
04-21 580
StringBuilder selectSql = new StringBuilder(); selectSql.append("SELECT ******** "); selectSql.append(" ORDER BY beforeTime DESC "); StringBuilder countSql = new StringBuilder(); countSql.append("SELECT ...
数据库高级二———数据库多表查询
weixin_45600855的博客
02-20 452
数据库高级数据库的多表查询多表的关系**一对多/多对一关系****多对多关系****一对一关系**多表查询合并结果集连接查询内连接外连接a.左外连接b.右外连接自然连接子查询其他多行新增多表更新多表删除日期运算函数 数据库的多表查询 多表的关系 一对多/多对一关系 客户和订单，分类和商品，部门和员工. 一对多建表原则：在多的一方创建一个字段，字段作为外键指向一的一方的主键. 多对多关系 学生和课程 多对多关系建表原则：需要创建第三张表,中间表中至少两个字段，这两个字段分别作为外键指向各自一方的主键 一对一关
动态线程中获取spring dao或者service
szyyyp的专栏
01-10 3901
需要动态创建线程，然而 你又没有使用spring的线程池的情况下。 使用spring 的dao 或者service 第一步：获取context WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext(); 第二步 获取你需要的bean CompanyDao
mysql多表联合查询多库
最新发布
09-28
多表联合查询是在MySQL中使用多个表连接来检索数据的一种查询方式。通过使用JOIN关键字和条件来连接多个表，可以根据表中的共同列进行匹配，并从中获取所需的数据。在进行多表联合查询时，需要确保表之间有正确的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值