数据库连接封装

最新推荐文章于 2022-08-11 21:55:18 发布
最新推荐文章于 2022-08-11 21:55:18 发布
阅读量111 收藏 1
点赞数
文章标签： 数据库 java
原文链接：http://www.cnblogs.com/wwdwmyw/p/8607783.html
版权

public class DBConnection {

    private String dbusername;
    
    private String dbpasswd;
    
    private DBType dbtype;
    
    private String JDBCString;
    
    public DBConnection(DBType type, String host, String username, String passwd, String base, String port) {
        dbusername = username;
        dbpasswd = passwd;
        switch (type) {
        case MYSQL:
            dbtype = DBType.MYSQL;
        case MYSQL3:
            dbtype = DBType.MYSQL3;
        case MYSQL4:
            dbtype = DBType.MYSQL4;
        case MYSQL5: {
            dbtype = DBType.MYSQL5;
            if (port.isEmpty()) port = "3306";
            JDBCString = String.format("jdbc:mysql://%s:%s/%s?zeroDateTimeBehavior=convertToNull", host, port, base);
            break;
        }
        case ORCALE8:
            dbtype = DBType.ORCALE8;
        case ORCALE9:
            dbtype = DBType.ORCALE9;
        case ORCALE10:
            dbtype = DBType.ORCALE10;
        case ORCALE11:
            dbtype = DBType.ORCALE11;
        case ORCALE: {
            dbtype = DBType.ORCALE;
            if (port.isEmpty()) port = "1521";
            JDBCString = String.format("jdbc:oracle:thin:@%s:%s:%s", host, port, base);
            break;
        }
        case MSSQL2000:
            dbtype = DBType.MSSQL2000;
        case MSSQL2005:
            dbtype = DBType.MSSQL2005;
        case MSSQL2008:
            dbtype = DBType.MSSQL2008;
        case MSSQL: {
            dbtype = DBType.MSSQL;
            if (port.isEmpty()) port = "1433";
            JDBCString = String.format("jdbc:sqlserver://%s:%s;DatabaseName=%s", host, port, base);
            break;
        }
        default:
            break;
        }
    }
    
    public String getJDBCString() {
        return JDBCString;
    }
    
    public String getJDBCDriver() {
        return dbtype.getDBType();
    }
    
    public String getDbusername() {
        return dbusername;
    }

    public String getDbpasswd() {
        return dbpasswd;
    }

}

 

-----------------------------------------------

public enum DBType {

    MSSQL2000("com.microsoft.jdbc.sqlserver.SQLServerDriver"),
    MSSQL2005("com.microsoft.sqlserver.jdbc.SQLServerDriver"),
    MSSQL2008("com.microsoft.sqlserver.jdbc.SQLServerDriver"),
    MSSQL(DBType.MSSQL2005.getDBType()),
    
    MYSQL3("com.mysql.jdbc.Driver"),
    MYSQL4("com.mysql.jdbc.Driver"),
    MYSQL5(    "com.mysql.jdbc.Driver"),
    MYSQL(DBType.MYSQL5.getDBType()),

    ORCALE8("oracle.jdbc.driver.OracleDriver"),
    ORCALE9("oracle.jdbc.driver.OracleDriver"),
    ORCALE10("oracle.jdbc.driver.OracleDriver"),
    ORCALE11("oracle.jdbc.driver.OracleDriver"),
    ORCALE(DBType.ORCALE11.getDBType());

    private String db;

    private DBType(String u) {
        db = u;
    }

    public String getDBType() {
        return db;
    }
}

-----------------------------------------------------------------

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Types;
import java.util.List;
import java.util.Map;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.testng.Assert;

public class DBUtil {
    public static QueryRunner queryRunner;

    private Connection conn;

    private DBConnection dbct;

    private DBType type;

    static {
        queryRunner = new QueryRunner();
    }

    public DBUtil() {
        String key = System.getProperty("DB.instance");
        Assert.assertTrue(key != null && !key.isEmpty(), String.format("无法获取数据库连接信息，请在配置文件中配置%s值", "DB.instance"));
        try {
            type = DBType.valueOf(System.getProperty("DB." + key + ".type", "MYSQL").toUpperCase());
        } catch (Exception e) {
            type = DBType.MYSQL;
        }
        dbct = new DBConnection(type, System.getProperty("DB." + key + ".host"),
                System.getProperty("DB." + key + ".username"), System.getProperty("DB." + key + ".password"),
                System.getProperty("DB." + key + ".database"), System.getProperty("DB." + key + ".port", ""));
    }

    public DBUtil(String key) {
        try {
            type = DBType.valueOf(System.getProperty("DB." + key + ".type", "MYSQL").toUpperCase());
        } catch (Exception e) {
            type = DBType.MYSQL;
        }
        dbct = new DBConnection(type, System.getProperty("DB." + key + ".host"),
                System.getProperty("DB." + key + ".username"), System.getProperty("DB." + key + ".password"),
                System.getProperty("DB." + key + ".database"), System.getProperty("DB." + key + ".port", ""));
    }

    /**
     * 数据库连接
     *
     * @return
     */
    public void connection() {
        try {
            Class.forName(dbct.getJDBCDriver()).newInstance();
            conn = DriverManager.getConnection(dbct.getJDBCString(), dbct.getDbusername(), dbct.getDbpasswd());
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    /**
     * 关闭Connection
     *
     * @param conn
     */
    public void closeConnection() {
        try {
            if (conn != null && conn.isValid(0)) {
                conn.close();
                conn = null;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 查询一行多列记录，将结果封装成一个Map，key为字段名，value为字段值
     *
     * @param sql
     * @param params
     * @return
     */
    public Map<String, Object> queryForMap(String sql, Object... params) {
        Map<String, Object> result = null;
        try {
            result = queryRunner.query(conn, sql, new MapHandler(), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 查询多行多列记录，将结果列表中的每一行封装成一个Map，key为字段名，value为字段值
     *
     * @param sql
     * @param params
     * @return
     */
    public List<Map<String, Object>> queryForMapList(String sql, Object... params) {
        List<Map<String, Object>> result = null;
        try {
            result = queryRunner.query(conn, sql, new MapListHandler(), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 查询多行一列数据
     *
     * @param <T>
     * @param sql
     * @param params
     * @return
     */
    public <T> List<T> queryForObjectList(String sql, Class<T> c, Object... params) {
        List<T> result = null;
        try {
            result = queryRunner.query(conn, sql, new ColumnListHandler<T>(), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 查询单个值
     *
     * @param <T>
     * @param sql
     * @param params
     * @return
     */
    public <T> T queryForObject(String sql, Class<T> c, Object... params) {
        T result = null;
        try {
            result = queryRunner.query(conn, sql, new ScalarHandler<T>(), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     *
     * 删除
     *
     * @param sql
     * @param params
     * @return
     */
    public void delete(String sql, Object[][] params) {
        try {
            queryRunner.batch(conn, sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 插入
     *
     * @param sql
     * @param params
     * @return
     */
    public void insert(String sql, Object... params) {
        try {
            queryRunner.update(conn, sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 插入(返回主键)
     *
     * @param sql
     * @param params
     * @return
     */
    public Object insertReturnPK(String sql, Object... params) {
        try {
            return queryRunner.insert(conn, sql, new ScalarHandler<Object>(), params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }

    /**
     * 批量插入
     *
     * @param sql
     * @param params
     * @return
     */
    public Object insertBatch(String sql, Object[][] params) {
        try {
            return queryRunner.batch(conn, sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }

    /**
     * 更新
     *
     * @param sql
     * @param params
     * @return
     */
    public int update(String sql, Object... params) {
        try {
            return queryRunner.update(conn, sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return 0;
    }

    /**
     * 批量更新
     *
     * @param sql
     * @param params
     * @return
     */
    public void updateBatch(String sql, Object[][] params) {
        try {
            queryRunner.batch(conn, sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 关闭PreparedStatement
     *
     * @param conn
     */
    public void closePreparedStatement(PreparedStatement stmt) {
        if (stmt != null) {
            try {
                stmt.close();
                stmt = null;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 关闭Connection 和 Statement
     *
     * @param conn
     * @param stmt
     */
    public void close(PreparedStatement stmt) {
        if (stmt != null) {
            try {
                stmt.close();
                stmt = null;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
                conn = null;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public PreparedStatement prepareStatement(String sql) {
        try {
            return conn.prepareStatement(sql);
        } catch (SQLException e) {
            return null;
        }
    }

    private ThreadLocal<PreparedStatement> threadLocal = null;
    private ThreadLocal<Short> threadLocal_cnt = null;

    /**
     * 批量操作准备
     *
     * @param sql
     */
    public void batchPrepare(final String sql) {
        if (threadLocal == null) {
            threadLocal = new ThreadLocal<PreparedStatement>() {
                @Override
                protected PreparedStatement initialValue() {
                    try {
                        return conn != null ? conn.prepareStatement(sql) : null;
                    } catch (SQLException e) {
                        return null;
                    }
                }
            };
        }
    }

    /**
     * 设置参数
     *
     * @param params
     */
    public void batchAdd(Object... params) {
        try {
            if (threadLocal != null) {
                PreparedStatement stmt = threadLocal.get();
                for (int i = 0; i < params.length; i++) {
                    if (params[i] != null) {
                        stmt.setObject(i + 1, params[i]);
                    } else {
                        stmt.setNull(i + 1, Types.VARCHAR);
                    }
                }
                stmt.addBatch();

                Short cnt = threadLocal_cnt.get();
                threadLocal_cnt.set(++cnt);
                if (cnt % 100 == 0) {
                    stmt.executeBatch();
                    stmt.clearBatch();
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 批量执行并且关闭连接
     */
    public void batchExecuteAndClose() {
        try {
            if (threadLocal != null) {
                PreparedStatement stmt = threadLocal.get();
                stmt.executeBatch();
                stmt.clearBatch();
                stmt.closeOnCompletion();
                stmt = null;
                threadLocal.remove();
                threadLocal = null;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

}

 

转载于:https://www.cnblogs.com/wwdwmyw/p/8607783.html

weixin_30699741
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JDBC 数据库连接和操作的封装
08-17
将数据库连接和增删查改的方法进行封装，将重复性的代码提取出去作为工具类，尽量减少类与类之间的固定依赖
MySql数据库连接封装类
06-12
`MySql数据库连接封装类`就是一种高效、便捷的方式来管理和操作数据库连接。它将连接的创建、关闭以及执行SQL语句等常见操作进行了抽象和封装，以便开发者能够更简单地进行数据库操作，无需每次都手动处理复杂的连接...
数据库连接工具类的封装
weixin_30321709的博客
02-28 142
第一种方式 直接获取驱动，地址，用户名，密码 并返回连接对象 package cn.tao.demo;import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public c...
与数据库连接的封装
郑林的专栏
05-14 967
前几天的时候一直在做与数据库的连接，虽然也是用到了数据库连接池进行连接，但是与数据库连接这方面很混乱，所以在这儿学习一下。如何将数据库的链接做的更加简洁和清楚。   1，首先先定义一个Exception。建立一个package(org.hrs.report.Exception)。 package org.hrs.report.Exception; import org.apac
Java 对数据库连接 的封装
yzcn2013的博客
05-06 359
import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; public class DBOperation { private
Oracle数据库连接封装类
06-12
总的来说，Oracle数据库连接封装类是Java开发中一个实用的工具，它简化了与Oracle数据库的交互，让开发者能更专注于业务逻辑，而不是数据库操作的细节。在学习和使用时，理解JDBC的基本原理以及封装类的设计思路，将...
用于实习jdbc的数据库连接封装类
05-24
java用于jdbc的连接的实现类,在数据库连接的时候直接new出来就OK了!DAO层自己加写...
Qt 数据库访问封装类
02-08
封装了常用的mysql,sqlserver,sqllite,access数据库的连接，数据访问等方法，原作者链接：http://www.qtcn.org/bbs/read-htm-tid-62347.html
数据库操作封装demo
最新发布
03-05
1. **数据库连接管理**：使用数据库连接池（如Apache的DBCP或HikariCP）来高效管理数据库连接，避免频繁创建和关闭连接。 2. **SQL操作接口**：定义一组方法，如`select()`, `insert()`, `update()`, `delete()`，...
数据库连接封装类
feifeiyaqi3的专栏
09-06 2189
using System;using System.Data;using System.Data.SqlClient;using System.Configuration;using System.IO;namespace DBclass...{    /**////     /// DBClass 的摘要说明。    ///     public class DBclass    ...{ 
数据库连接、操作（封装使用）
机智的兔子
09-27 426
private static String url = "jdbc:mysql://localhost:3306/jinxiaocun"; private static String user = "root"; private static String password = "root"; //数据库连接操作 private JdbcTool() { } static
【Java数据库连接类】封装数据库操作的连接类DBConnection
北风
03-12 2784
在项目开发中，操作数据库需要数据库连接对象，通过此公共类能方便的获得数据库连接对象。
MySQL连接池：连接的封装
weixin_43973403的博客
08-11 402
MySql客户端C++开发包封装
mysql jdbc 封装_详解JDBC数据库链接及相关方法的封装
weixin_32101377的博客
01-18 106
详解JDBC数据库链接及相关方法的封装使用的是MySQL数据库，首先导入驱动类，然后根据数据库URL和用户名密码获得数据的链接。由于使用的是MySQL数据库，它的URL一般为，jdbc：mysql：//主机地址：端口号/库名。下面是封装的具体类，用到了泛型和反射，不过还存在些问题，就是对使用的泛型对象有些限制，只能用于泛型类对象属性名与数据库表中列名相同的对象，而且初始化对象的方法必须为set+属...
JDBC——封装数据库连接操作
qq_43575044的博客
09-14 205
创建 JDBCUtils 类 package Test; import java.io.FileInputStream; import java.io.IOException; import java.sql.*; import java.util.Properties; /** * @Author: Gin * @Description: * @Modified By: Gin * @Date: Created in 11:28 2021/9/14 */ public class JDBC
JDBC —— 简单的连接数据库和封装
古道西风
12-20 3766
连接数据库，并读取表里的内容 eclipse连接数据库的一般过程是： 1，加载JDBC驱动（jar驱动包自己去下，这里有导入jar到eclipse的方法Eclipse下导入外部jar包的3种方式） 2，建立数据库连接（Connection接口） 3，建立与执行SQL语句（Statement接口） 4，处理结果集（选择适当的接口） 5，关闭数据连接（这里要注意顺序，要先关小门后关大门） ...
封装常用数据库方法及连接(config)
xbc1213的博客
11-23 504
封装连接字符串至 App.Config步骤: 1.右键添加应用程序配置文件,勿改名 2.在App.Config文件内写入. <connectionStrings> <add connectionString="Data Source=服务器名称;Initial Catalog=数据库名称;Integrated Security=是否采用默认系统验证" name="该连接名称" />
c#写一个数据库连接封装
05-19
以下是一个简单的数据库连接封装的示例代码，使用了C#中的ADO.NET： ```csharp using System; using System.Data; using System.Data.SqlClient; namespace DatabaseConnection { public class DatabaseConnector { private string connectionString; private SqlConnection connection; public DatabaseConnector(string connectionString) { this.connectionString = connectionString; this.connection = new SqlConnection(connectionString); } public void OpenConnection() { if (connection.State != ConnectionState.Open) { connection.Open(); } } public void CloseConnection() { if (connection.State != ConnectionState.Closed) { connection.Close(); } } public DataTable ExecuteQuery(string query) { DataTable dataTable = new DataTable(); try { OpenConnection(); SqlCommand command = new SqlCommand(query, connection); SqlDataAdapter adapter = new SqlDataAdapter(command); adapter.Fill(dataTable); } catch (Exception ex) { Console.WriteLine(ex.Message); } finally { CloseConnection(); } return dataTable; } public void ExecuteNonQuery(string query) { try { OpenConnection(); SqlCommand command = new SqlCommand(query, connection); command.ExecuteNonQuery(); } catch (Exception ex) { Console.WriteLine(ex.Message); } finally { CloseConnection(); } } } } ``` 使用方法： ```csharp string connectionString = "Data Source=.;Initial Catalog=MyDatabase;Integrated Security=True"; DatabaseConnector connector = new DatabaseConnector(connectionString); // 查询 string query = "SELECT * FROM MyTable"; DataTable dataTable = connector.ExecuteQuery(query); foreach (DataRow row in dataTable.Rows) { Console.WriteLine(row["ColumnName"]); } // 非查询操作 string insertQuery = "INSERT INTO MyTable (ColumnName) VALUES ('Value')"; connector.ExecuteNonQuery(insertQuery); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值