编写自己的JDBC框架
一、数据库连接池：
在一般用JDBC 进行连接数据库进行CRUD操作时，每一次都会：
通过：java.sql.Connection conn = DriverManager.getConnection(url,user,password); 重新获取一个数据库的链接再进行操作，这样用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。
所以为了减少服务器的压力，便可用连接池的方法：在启动Web应用时，数据就创建好一定数量的Connection链接
存放到一个容器中，然后当用户请求时，服务器则向容器中获取Connection链接来处理用户的请求，当用户的请求完成后，
又将该Connection 链接放回到该容器中。这样的一个容器称为连接池。
编写一个基本的连接池实现连接复用
步骤：
1、建立一个数据库连接池容器。（因为方便存取，则使用LinkedList集合）
2、初始化一定数量的连接，放入到容器中。
3、等待用户获取连接对象。（该部分要加锁）
|---记得删除容器中对应的对象，放置别人同时获取到同一个对象。
4、提供一个方法，回收用户用完的连接对象。
5、要遵循先入先出的原则。
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.Properties;
/**
* 一个基本的数据连接池：
* 1、初始化时就建立一个容器，来存储一定数量的Connection 对象
* 2、用户通过调用MyDataSource 的getConnection 来获取Connection 对象。
* 3、再通过release 方法来回收Connection 对象，而不是直接关闭连接。
* 4、遵守先进先出的原则。
*
*
* @author 贺佐安
*
*/
public class MyDataSource {
private static String url = null;
private static String password = null;
private static String user = null ;
private static String DriverClass = null;
private static LinkedList<Connection> pool = new LinkedList<Connection>() ;
// 注册数据库驱动
static {
try {
InputStream in = MyDataSource.class.getClassLoader()
.getResourceAsStream("db.properties");
Properties prop = new Properties();
prop.load(in);
user = prop.getProperty("user");
url = prop.getProperty("url") ;
password = prop.getProperty("password") ;
DriverClass = prop.getProperty("DriverClass") ;
Class.forName(DriverClass) ;
} catch (Exception e) {
throw new RuntimeException(e) ;
}
}
//初始化建立数据连接池
public MyDataSource () {
for(int i = 0 ; i < 10 ; i ++) {
try {
Connection conn = DriverManager.getConnection(url, user, password) ;
pool.add(conn) ;
} catch (SQLException e) {
e.printStackTrace();
}
}
}
//、从连接池获取连接
public Connection getConnection() throws SQLException {
return pool.remove() ;
}
// 回收连接对象。
public void release(Connection conn) {
System.out.println(conn+"被回收");
pool.addLast(conn) ;
}
public int getLength() {
return pool.size() ;
}
}这样当我们要使用Connection 连接数据库时，则可以直接使用连接池中Connection 的对象。测试如下：
import java.sql.Connection;
import java.sql.SQLException;
import org.junit.Test;
public class MyDataSourceTest {
/**
* 获取数据库连接池中的所有连接。
*/
@Test
public void Test() {
MyDataSource mds = new MyDataSource() ;
Connection conn = null ;
try {
for (int i = 0 ; i < 20 ; i ++) {
conn = mds.getConnection() ;
System.out.println(conn+"被获取；连接池还有："+mds.getLength());
mds.release(conn) ;
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}再运行的时候，可以发现，循环10次后，又再一次获取到了第一次循环的得到的Connection对象。所以，这样可以大大的减轻数据库的压力。上面只是一个简单的数据库连接池，不完美的便是，回收需要调用数据池的release() 方法来进行回收，那么可以不可以直接调用Connection 实例的close 便完成Connection 对象的回收呢？
二、数据源：
> 编写连接池需实现javax.sql.DataSource接口。
> 实现DataSource接口，并实现连接池功能的步骤：
1、在DataSource构造函数中批量创建与数据库的连接，并把创建的连接加入LinkedList对象中。
2、实现getConnection方法，让getConnection方法每次调用时，从LinkedList中取一个Connection返回给用户。当用户使用完Connection，调用Connection.close()方法时，Collection对象应保证将自己返回到LinkedList中,而不要把conn还给数据库。
利用动态代理和包装设计模式来标准的数据源。
1、包装设计模式实现标准数据源：
这里的用包装设计模式，便是将Connection 接口进行包装。简单总结一下包装设计模式的步骤：
a)定义一个类，实现与被包装类（）相同的接口。
|----可以先自己写一个适配器，然后后面继承这个适配器，改写需要改写的方法，提高编程效率。
b)定义一个实例变量，记住被包装类的对象的引用。
c)定义构造方法，转入被包装类的对象。
e)对需要改写的方法，改写。
f)对不需要改写的方法，调用原来被包装类的对应方法。
所以先编写一个类似适配器的类，将Connection 接口的方法都进行实现：
View Code
然后再对Connection 接口进行包装，将close 方法修改掉：
import java.sql.Connection;
import java.sql.SQLException;
import java.util.LinkedList;
/**
* 对MyConnectionAdapter 进行包装处理
* @author 贺佐安
*
*/
public class MyConnectionWrap extends MyConnectionAdapter {
private LinkedList<Connection> pool = new LinkedList<Connection>() ;
public MyConnectionWrap(Connection conn ,LinkedList<Connection> pool ) {
super(conn);
this.pool = pool ;
}
//改写要实现的方法
public void close() throws SQLException {
pool.addLast(conn) ;
}
}编写标准数据源：
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.ResourceBundle;
import javax.sql.DataSource;
/**
* 编写标准的数据源：
* 1、实现DataSource 接口
* 2、获取在实现类的构造方法中批量获取Connection 对象，并将这些Connection 存储
* 在LinkedList 容器中。
* 3、实现getConnection() 方法，调用时返回LinkedList容器的Connection对象给用户。
* @author 贺佐安
*
*/
public class MyDataSource implements DataSource{
private static String url = null;
private static String password = null;
private static String user = null ;
private static String DriverClass = null;
private static LinkedList<Connection> pool = new LinkedList<Connection>() ;
// 注册数据库驱动
static {
try {
ResourceBundle rb = ResourceBundle.getBundle("db") ;
url = rb.getString("url") ;
password = rb.getString("password") ;
user = rb.getString("user") ;
DriverClass = rb.getString("DriverClass") ;
Class.forName(DriverClass) ;
//初始化建立数据连接池
for(int i = 0 ; i < 10 ; i ++) {
Connection conn = DriverManager.getConnection(url, user, password) ;
pool.add(conn) ;
}
} catch (Exception e) {
throw new RuntimeException(e) ;
}
}
public MyDataSource () {
}
//、从连接池获取连接:通过包装模式
public synchronized Connection getConnection() throws SQLException {
if (pool.size() > 0) {
MyConnectionWrap mcw = new MyConnectionWrap(pool.remove(), pool) ;
return mcw ;
}else {
throw new RuntimeException("服务器繁忙！");
}
}
// 回收连接对象。
public void release(Connection conn) {
System.out.println(conn+"被回收");
pool.addLast(conn) ;
}
public int getLength() {
return pool.size() ;
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return null;
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
}
@Override
public int getLoginTimeout() throws SQLException {
return 0;
}
@Override
public <T> T unwrap(Class<T> iface) throws SQLException {
return null;
}
@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
return false;
}
@Override
public Connection getConnection(String username, String password)
throws SQLException {
return null;
}
}2、动态代理实现标准数据源：
相对于用包装设计来完成标准数据源，用动态代理则方便许多：
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.ResourceBundle;
import javax.sql.DataSource;
/**
* 编写标准的数据源：
* 1、实现DataSource 接口
* 2、获取在实现类的构造方法中批量获取Connection 对象，并将这些Connection 存储
* 在LinkedList 容器中。
* 3、实现getConnection() 方法，调用时返回LinkedList容器的Connection对象给用户。
* @author 贺佐安
*
*/
public class MyDataSource implements DataSource{
private static String url = null;
private static String password = null;
private static String user = null ;
private static String DriverClass = null;
private static LinkedList<Connection> pool = new LinkedList<Connection>() ;
// 注册数据库驱动
static {
try {
ResourceBundle rb = ResourceBundle.getBundle("db") ;
url = rb.getString("url") ;
password = rb.getString("password") ;
user = rb.getString("user") ;
DriverClass = rb.getString("DriverClass") ;
Class.forName(DriverClass) ;
//初始化建立数据连接池
for(int i = 0 ; i < 10 ; i ++) {
Connection conn = DriverManager.getConnection(url, user, password) ;
pool.add(conn) ;
}
} catch (Exception e) {
throw new RuntimeException(e) ;
}
}
public MyDataSource () {
}
//、从连接池获取连接:通过动态代理
public Connection getConnection() throws SQLException {
if (pool.size() > 0) {
final Connection conn = pool.remove() ;
Connection proxyCon = (Connection) Proxy.newProxyInstance(conn.getClass().getClassLoader(), conn.getClass().getInterfaces(),
new InvocationHandler() {
//策略设计模式：
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if("close".equals(method.getName())){
//谁调用，
return pool.add(conn);//当调用close方法时，拦截了，把链接放回池中了
}else{
return method.invoke(conn, args);
}
}
});
return proxyCon ;
}else {
throw new RuntimeException("服务器繁忙！");
}
}
public int getLength() {
return pool.size() ;
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return null;
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
}
@Override
public int getLoginTimeout() throws SQLException {
return 0;
}
@Override
public <T> T unwrap(Class<T> iface) throws SQLException {
return null;
}
@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
return false;
}
@Override
public Connection getConnection(String username, String password)
throws SQLException {
return null;
}
}当然觉得麻烦的则可以直接使用一些开源的数据源如：DBCP、C3P0等。DBCP的原理是用包装设计模式开发的数据源，而C3P0则是动态代理的。
1、DBCP的使用：
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
/**
* 创建DBCP 工具类
* @author 贺佐安
*
*/
public class DbcpUtil {
private static DataSource ds = null ;
static {
try {
//读取配置文件
InputStream in = DbcpUtil.class.getClassLoader().getResourceAsStream("dbcpconfig.properties") ;
Properties prop = new Properties() ;
prop.load(in) ;
//通过BasicDataSourceFactory 的creatDataSurce 方法创建 BasicDataSource 对象。
ds = BasicDataSourceFactory.createDataSource(prop) ;
} catch (Exception e) {
e.printStackTrace();
}
}
public static DataSource getDs() {
return ds ;
}
public static Connection getConnection () {
try {
return ds.getConnection() ;
} catch (SQLException e) {
throw new RuntimeException() ;
}
}
}2、C3P0 的使用：
import java.sql.Connection;
import java.sql.SQLException;
import com.mchange.v2.c3p0.ComboPooledDataSource;
/**
* C3P0 开源数据源的使用
* @author 贺佐安
*
*/
public class C3p0Util {
private static ComboPooledDataSource cpds = null ;
static {
cpds = new ComboPooledDataSource() ;
}
public static Connection getConnection() {
try {
return cpds.getConnection() ;
} catch (SQLException e) {
throw new RuntimeException() ;
}
}
}使用这两个数据源时，直接调用获取到的Connection 连接的close 方法，也是将连接放到pool中去。
三、元数据（DatabaseMetaData）信息的获取
> 元数据：数据库、表、列的定义信息。
> 元数据信息的获取：为了编写JDBC框架使用。
1、数据库本身信息的获取：java.sql.DataBaseMateData java.sql.Connection.getMetaData() ;
DataBaseMateData 实现类的常用方法：
getURL()：返回一个String类对象，代表数据库的URL。
getUserName()：返回连接当前数据库管理系统的用户名。
getDatabaseProductName()：返回数据库的产品名称。
getDatabaseProductVersion()：返回数据库的版本号。
getDriverName()：返回驱动驱动程序的名称。
getDriverVersion()：返回驱动程序的版本号。
isReadOnly()：返回一个boolean值，指示数据库是否只允许读操作。
2、ParameterMetaData: 代表PerparedStatment 中的SQL 参数元数据信息： java.sql.ParameterMetaData java.sql.PerparedStatement.getParameterMetaData() ;
ParameterMetaData 实现类常用方法：
getParameterCount() ：获得指定参数的个数
getParameterType(int param) ：获得指定参数的sql类型（驱动可能不支持）
3、ResultSetMetaData : 代表结果集的源数据信息：相当于SQL 中的 ：DESC java.sql.ResultSetMetaData java.sql.ResultSet.getMetaData() ;
java.sql.ResultSetMetaData 接口中常用的方法：
a) getColumnCount() : 获取查询方法有几列。
b) getColumnName(int index) : 获取列名:index从1开始。
c) getColumnType(int index) : 获取列的数据类型。返回的是TYPES 中的常量值。
四、编写自己的JDBC框架：
JDBC框架的基本组成：
1、核心类：
a、定义一个指定javax.sql.DataSource 实例的引用变量,通过构造函数获取指定的实例并给定义的变量。
b、编写SQL运行框架。
DML 语句的编写：
1、通过获取的javax.sql.DataSource 实例，获取Connection 对象。
2、通过ParamenterMeteData 获取数据库元数据。
DQL 语句的编写：
1、通过获取的DataSource 实例，获取Connection 对象。
2、通过ParamenterMeteData、ResultSetMetaData 等获取数据库元数据。
3、用抽象策略设计模式：设计一个ResultSetHandler 接口，作用：将查找出的数据封装到指定的JavaBean中。
|————这里的JavaBean，由用户来指定。
抽象策略模式，用户可以更具具体的功能来扩展成具体策略设计模式。如：查找的一条信息、查找的所有信息。
import java.sql.Connection;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;
/**
* 实现JDBC 框架的核心类。
* 在该类中定义了SQL语句完成的方法；
* @author 贺佐安
*
*/
public class MyJdbcFrame {
/**
* javax.sql.DataSource 实例的引用变量
*/
private DataSource ds = null ;
/**
* 将用户指定的DataSource 指定给系统定义的DataSource 实例的引用变量
* @param ds
*/
public MyJdbcFrame(DataSource ds ) {
this.ds = ds ;
}
/**
* 执行UPDATE、DELETE、INSERT 语句。
* @param sql
* @param obj
*/
public void update(String sql , Object[] obj) {
Connection conn = null ;
PreparedStatement stmt = null ;
try {
//获取Connection 对象
conn = ds.getConnection() ;
stmt = conn.prepareStatement(sql) ;
// 获取ParameterMetaData 元数据对象。
ParameterMetaData pmd = stmt.getParameterMetaData() ;
//获取SQL语句中需要设置的参数的个数
int parameterCount = pmd.getParameterCount() ;
if (parameterCount > 0) {
if (obj == null || obj.length != parameterCount) {
throw new MyJdbcFrameException( "parameterCount is error!") ;
}
//设置参数：
for ( int i = 0 ; i < obj.length ; i++) {
stmt.setObject(i+1, obj[i]) ;
}
}
//执行语句：
stmt.executeUpdate() ;
} catch(Exception e ) {
throw new MyJdbcFrameException(e.getMessage()) ;
} finally {
release(stmt, null, conn) ;
}
}
public Object query(String sql , Object[] obj , ResultSetHandler rsh) {
Connection conn = null ;
PreparedStatement stmt = null ;
ResultSet rs = null ;
try {
//获取Connection 对象
conn = ds.getConnection() ;
stmt = conn.prepareStatement(sql) ;
// 获取ParameterMetaData 元数据对象。
ParameterMetaData pmd = stmt.getParameterMetaData() ;
//获取SQL语句中需要设置的参数的个数
int parameterCount = pmd.getParameterCount() ;
if (obj.length != parameterCount) {
throw new MyJdbcFrameException( "'" +sql +"' : parameterCount is error!") ;
}
//设置参数：
for ( int i = 0 ; i < obj.length ; i++) {
stmt.setObject(i+1, obj[i]) ;
}
//执行语句：
rs = stmt.executeQuery();
return rsh.handler(rs);
} catch(Exception e ) {
throw new MyJdbcFrameException(e.getMessage()) ;
} finally {
release(stmt, null, conn) ;
}
}
/**
* 释放资源
* @param stmt
* @param rs
* @param conn
*/
public static void release(Statement stmt
, ResultSet rs
, Connection conn) {
if(rs != null) {
try {
rs.close() ;
} catch (SQLException e) {
e.printStackTrace();
}
rs = null ;
}
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
stmt = null ;
}
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
conn = null ;
}
}
}2、接口：策略模式的接口：ResultSetHandler 。
import java.sql.ResultSet;
//抽象策略模式
public interface ResultSetHandler {
public Object handler(ResultSet rs) ;
}这里对ResultSetHandler 接口实现一个BeanHandler 实例 ：
import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
/**
* 该类获取ResultSet 结果集中的第一个值，封装到JavaBean中
* @author 贺佐安
*
*/
public class BeanHandler implements ResultSetHandler {
//获取要封装的JavaBean的字节码
private Class clazz ;
public BeanHandler (Class clazz) {
this.clazz = clazz ;
}
public Object handler(ResultSet rs) {
try {
if (rs.next()) {
//1、获取结果集的元数据。
ResultSetMetaData rsm = rs.getMetaData() ;
//2、创建JavaBean的实例：
Object obj = clazz.newInstance() ;
//3、将数据封装到JavaBean中。
for (int i = 0 ; i < rsm.getColumnCount() ; i ++) {
//获取属性名
String columnName = rsm.getColumnName(i+1) ;
//获取属性值
Object value = rs.getObject(i+1) ;
Field objField = obj.getClass().getDeclaredField(columnName) ;
objField.setAccessible(true) ;
objField.set(obj, value) ;
}
return obj ;
} else {
return null ;
}
} catch (Exception e) {
throw new RuntimeException(e) ;
}
}
}3、自定义异常类：继承RuntimeException。如：
public class MyJdbcFrameException extends RuntimeException {
public MyJdbcFrameException() {
super() ;
}
public MyJdbcFrameException(String e) {
super(e) ;
}
}然后就可以将其打包发布，在以后写数据库操作时就可以用自己的JDBC框架了，如果要完成查询多条语句什么的，则要实现ResultSetHandler 接口。来完成更多的功能。
当然，使用DBUtils 则更简单：Apache 组织提供的一个开源JDBC 工具类库。
熱AI工具
Undresser.AI Undress
人工智慧驅動的應用程序，用於創建逼真的裸體照片
AI Clothes Remover
用於從照片中去除衣服的線上人工智慧工具。
Undress AI Tool
免費脫衣圖片
Clothoff.io
AI脫衣器
Video Face Swap
使用我們完全免費的人工智慧換臉工具，輕鬆在任何影片中換臉！
熱門文章
熱工具
記事本++7.3.1
好用且免費的程式碼編輯器
SublimeText3漢化版
中文版，非常好用
禪工作室 13.0.1
強大的PHP整合開發環境
Dreamweaver CS6
視覺化網頁開發工具
SublimeText3 Mac版
神級程式碼編輯軟體(SublimeText3)
如何評估Java框架商業支援的性價比
Jun 05, 2024 pm 05:25 PM
評估Java框架商業支援的性價比涉及以下步驟：確定所需的保障等級和服務等級協定(SLA)保證。研究支持團隊的經驗和專業知識。考慮附加服務，如昇級、故障排除和效能最佳化。權衡商業支援成本與風險緩解和提高效率。
PHP 框架的學習曲線與其他語言框架相比如何？
Jun 06, 2024 pm 12:41 PM
PHP框架的學習曲線取決於語言熟練度、框架複雜性、文件品質和社群支援。與Python框架相比，PHP框架的學習曲線較高，而與Ruby框架相比，則較低。與Java框架相比，PHP框架的學習曲線中等，但入門時間較短。
PHP 框架的輕量級選項如何影響應用程式效能？
Jun 06, 2024 am 10:53 AM
輕量級PHP框架透過小體積和低資源消耗提升應用程式效能。其特點包括：體積小，啟動快，記憶體佔用低提升響應速度和吞吐量，降低資源消耗實戰案例：SlimFramework創建RESTAPI，僅500KB，高響應性、高吞吐量
Java框架的效能比較
Jun 04, 2024 pm 03:56 PM
根據基準測試，對於小型、高效能應用程序，Quarkus（快速啟動、低記憶體）或Micronaut（TechEmpower優異）是理想選擇。 SpringBoot適用於大型、全端應用程序，但啟動時間和記憶體佔用稍慢。
golang框架文件最佳實踐
Jun 04, 2024 pm 05:00 PM
編寫清晰全面的文件對於Golang框架至關重要。最佳實踐包括：遵循既定文件風格，例如Google的Go程式設計風格指南。使用清晰的組織結構，包括標題、子標題和列表，並提供導覽。提供全面且準確的信息，包括入門指南、API參考和概念。使用程式碼範例說明概念和使用方法。保持文件更新，追蹤變更並記錄新功能。提供支援和社群資源，例如GitHub問題和論壇。建立實際案例，如API文件。
如何為不同的應用場景選擇最佳的golang框架
Jun 05, 2024 pm 04:05 PM
根據應用場景選擇最佳Go框架：考慮應用類型、語言特性、效能需求、生態系統。常見Go框架：Gin（Web應用）、Echo（Web服務）、Fiber（高吞吐量）、gorm（ORM）、fasthttp（速度）。實戰案例：建構RESTAPI（Fiber），與資料庫互動（gorm）。選擇框架：效能關鍵選fasthttp，靈活Web應用選Gin/Echo，資料庫互動選gorm。
Java框架學習路線圖：不同領域中的最佳實踐
Jun 05, 2024 pm 08:53 PM
針對不同領域的Java框架學習路線圖：Web開發：SpringBoot和PlayFramework。持久層：Hibernate和JPA。服務端響應式程式設計：ReactorCore和SpringWebFlux。即時計算：ApacheStorm和ApacheSpark。雲端運算：AWSSDKforJava和GoogleCloudJava。
Golang框架學習過程中常見的迷思有哪些？
Jun 05, 2024 pm 09:59 PM
Go框架學習的迷思有以下5種：過度依賴框架，限制彈性。不遵循框架約定，程式碼難以維護。使用過時庫，帶來安全和相容性問題。過度使用包，混淆程式碼結構。忽視錯誤處理，導致意外行為和崩潰。
