java自定義連線池

阿新 • • 發佈：2019-01-13

1、java自定義連線池

　　1.1連線池的概念：

　　　實際開發中"獲取連線"或“釋放資源”是非常消耗系統資源的兩個過程，為了姐姐此類效能問題，通常情況我們採用連線池技術來貢獻連線Connection

　　　用池來管理Connection，這樣可以重複使用Connection，有了池，所以我們就不用自己來建立Connection，而是通過池來獲取Connection物件，當使用完Connection後，呼叫Connection的close()方法也不會真的關閉Connection,而是把Connection“歸還”給池，池也就可以再利用這個Connection物件啦

　　1.2 自定義連線池需要如下步驟

　　　　1.2.1 建立連線池實現（資料來源），並實現介面javax.sql.DataSource.簡化本案案例，我們可以自己提供方法，沒有實現介面

　　　　1.2.2 提供一個集合，用於存放連線，因為移除/新增操作過多，所以選用LinkedList較好

　　　　1.2.3 為連線池初始化5個連線

　　　　1.2.4 程式如果需要連線，呼叫實現類的getConnection(),本方法姜蔥連線池（容器List）獲取連線，為了保證當前連線只是停工給一個執行緒使用，我們需要將連線先從連線池衝移除。

　　　　1.2.5 當用戶使用完連線，釋放資源時，不執行close()方法，而是將連線新增到連線池中

　　程式碼實現：

package com.rookie.bigdata.utils;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

/**
 *  
@author
 * @date 2019/1/13
 */
public class JDBCUtils {

    private static String driver;
    private static String url;
    private static String username;
    private static String password;

    /**
     * 靜態程式碼塊載入配置檔案資訊
     */
    static {
        try {
            // 1.通過當前類獲取類載入器
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            // 2.通過類載入器的方法獲得一個輸入流
            InputStream is = classLoader.getResourceAsStream("db.properties");
            // 3.建立一個properties物件
            Properties props = new Properties();
            // 4.載入輸入流
            props.load(is);
            // 5.獲取相關引數的值
            driver = props.getProperty("driver");
            url = props.getProperty("url");
            username = props.getProperty("username");
            password = props.getProperty("password");
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 獲取連線方法
     *
     * @return
     */
    public static Connection getConnection() {
        Connection conn = null;
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, username, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }

    /**
     * 釋放資源方法
     *
     * @param conn
     * @param pstmt
     * @param rs
     */
    public static void release(Connection conn, PreparedStatement pstmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (pstmt != null) {
            try {
                pstmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

package com.rookie.bigdata.datasource;

import com.rookie.bigdata.utils.JDBCUtils;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.LinkedList;
import java.util.logging.Logger;

/**
 * @author liuxili
 * @date 2019/1/13
 */
public class MyDataSource implements DataSource {

    //建立一個容器，用於存放connection物件
    private static LinkedList<Connection> pool = new LinkedList<>();

    //初始化5個連線，放到容器中
    static {
        for (int i = 0; i < 5; i++) {
            Connection connection = JDBCUtils.getConnection();
            pool.add(connection);
        }
    }

    /**
     * 獲取連線的方法
     *
     * @return
     * @throws SQLException
     */
    @Override
    public Connection getConnection() throws SQLException {

        //當連線池中沒有連線的時候，需要建立連結
        if (pool.size() == 0) {
            for (int i = 0; i < 5; i++) {
                Connection connection = JDBCUtils.getConnection();
                pool.add(connection);
            }
        }

        //從池中獲取連線
        return pool.remove(0);
    }


    /**
     * 歸還連線到連線池中
     *
     * @param connection
     */
    public void releaseConnetion(Connection connection) {
        pool.add(connection);

    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }

    @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 Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }
}

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/web?useUnicode=true&characterEncoding=utf8
username=root
password=root

　　測試類：

package com.rookie.bigdata.datasource;

import org.junit.Test;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import static org.junit.Assert.*;

/**
 * @author
 * @date 2019/1/13
 */
public class MyDataSourceTest {

    @Test
    public void test1() throws SQLException {
        MyDataSource myDataSource = new MyDataSource();
        Connection connection = myDataSource.getConnection();
        String sql = "insert into H_USER values(?,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setInt(1,1);
        preparedStatement.setString(2, "張三");
        preparedStatement.setInt(3, 23);

        int rows = preparedStatement.executeUpdate();
        System.out.println(rows);

        myDataSource.releaseConnetion(connection);


    }


}

java自定義連線池改進

　　實現Connection介面

package com.rookie.bigdata.datasource;

import java.sql.*;
import java.util.LinkedList;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;

/**
 * @author
 * @date 2019/1/13
 */
//實現一個Connection介面
public class MyConnection implements Connection {
    //定義一個變數
    private Connection connection;

    private LinkedList<Connection> pool;

    //編寫構造方法
    public MyConnection(Connection connection, LinkedList<Connection> pool){

        this.connection=connection;
        this.pool=pool;
    }

    @Override
    public void close() throws SQLException {
        pool.add(connection);

    }
    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
        return connection.prepareStatement(sql);
    }

    @Override
    public Statement createStatement() throws SQLException {
        return null;
    }



    @Override
    public CallableStatement prepareCall(String sql) throws SQLException {
        return null;
    }

    @Override
    public String nativeSQL(String sql) throws SQLException {
        return null;
    }

    @Override
    public void setAutoCommit(boolean autoCommit) throws SQLException {

    }

    @Override
    public boolean getAutoCommit() throws SQLException {
        return false;
    }

    @Override
    public void commit() throws SQLException {

    }

    @Override
    public void rollback() throws SQLException {

    }


    @Override
    public boolean isClosed() throws SQLException {
        return false;
    }

    @Override
    public DatabaseMetaData getMetaData() throws SQLException {
        return null;
    }

    @Override
    public void setReadOnly(boolean readOnly) throws SQLException {

    }

    @Override
    public boolean isReadOnly() throws SQLException {
        return false;
    }

    @Override
    public void setCatalog(String catalog) throws SQLException {

    }

    @Override
    public String getCatalog() throws SQLException {
        return null;
    }

    @Override
    public void setTransactionIsolation(int level) throws SQLException {

    }

    @Override
    public int getTransactionIsolation() throws SQLException {
        return 0;
    }

    @Override
    public SQLWarning getWarnings() throws SQLException {
        return null;
    }

    @Override
    public void clearWarnings() throws SQLException {

    }

    @Override
    public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
        return null;
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
        return null;
    }

    @Override
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
        return null;
    }

    @Override
    public Map<String, Class<?>> getTypeMap() throws SQLException {
        return null;
    }

    @Override
    public void setTypeMap(Map<String, Class<?>> map) throws SQLException {

    }

    @Override
    public void setHoldability(int holdability) throws SQLException {

    }

    @Override
    public int getHoldability() throws SQLException {
        return 0;
    }

    @Override
    public Savepoint setSavepoint() throws SQLException {
        return null;
    }

    @Override
    public Savepoint setSavepoint(String name) throws SQLException {
        return null;
    }

    @Override
    public void rollback(Savepoint savepoint) throws SQLException {

    }

    @Override
    public void releaseSavepoint(Savepoint savepoint) throws SQLException {

    }

    @Override
    public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
        return null;
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
        return null;
    }

    @Override
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {
        return null;
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
        return null;
    }

    @Override
    public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
        return null;
    }

    @Override
    public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
        return null;
    }

    @Override
    public Clob createClob() throws SQLException {
        return null;
    }

    @Override
    public Blob createBlob() throws SQLException {
        return null;
    }

    @Override
    public NClob createNClob() throws SQLException {
        return null;
    }

    @Override
    public SQLXML createSQLXML() throws SQLException {
        return null;
    }

    @Override
    public boolean isValid(int timeout) throws SQLException {
        return false;
    }

    @Override
    public void setClientInfo(String name, String value) throws SQLClientInfoException {

    }

    @Override
    public void setClientInfo(Properties properties) throws SQLClientInfoException {

    }

    @Override
    public String getClientInfo(String name) throws SQLException {
        return null;
    }

    @Override
    public Properties getClientInfo() throws SQLException {
        return null;
    }

    @Override
    public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
        return null;
    }

    @Override
    public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
        return null;
    }

    @Override
    public void setSchema(String schema) throws SQLException {

    }

    @Override
    public String getSchema() throws SQLException {
        return null;
    }

    @Override
    public void abort(Executor executor) throws SQLException {

    }

    @Override
    public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {

    }

    @Override
    public int getNetworkTimeout() 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;
    }
}

package com.rookie.bigdata.datasource;

import com.rookie.bigdata.utils.JDBCUtils;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.LinkedList;
import java.util.logging.Logger;

/**
 * @author liuxili
 * @date 2019/1/13
 */
public class MyDataSource1 implements DataSource {

    //建立一個容器，用於存放connection物件
    private static LinkedList<Connection> pool = new LinkedList<>();

    //初始化5個連線，放到容器中
    static {
        for (int i = 0; i < 5; i++) {
            Connection connection = JDBCUtils.getConnection();
            MyConnection myConnection= new MyConnection(connection,pool);
            pool.add(myConnection);
        }
    }

    /**
     * 獲取連線的方法
     *
     * @return
     * @throws SQLException
     */
    @Override
    public Connection getConnection() throws SQLException {
        Connection connection=null;
        //當連線池中沒有連線的時候，需要建立連結
        if (pool.size() == 0) {
            for (int i = 0; i < 5; i++) {
                 connection = JDBCUtils.getConnection();
                MyConnection myConnection= new MyConnection(connection,pool);
                pool.add(myConnection);
            }
        }

        //從池中獲取連線
        return pool.remove(0);
    }


//    /**
//     * 歸還連線到連線池中
//     *
//     * @param connection
//     */
//    public void releaseConnetion(Connection connection) {
//        pool.add(connection);
//
//    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }

    @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 Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }
}

　　測試程式碼

    @Test
    public void test2() throws SQLException {



        MyDataSource1 myDataSource = new MyDataSource1();
        Connection connection = myDataSource.getConnection();
        String sql = "insert into H_USER values(?,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setInt(1,2);
        preparedStatement.setString(2, "張三");
        preparedStatement.setInt(3, 23);

        int rows = preparedStatement.executeUpdate();
        System.out.println(rows);
        JDBCUtils.release(connection,preparedStatement,null);


    }

　　至此自定義連線池實現完畢，參考黑馬程式設計師視訊教程

java自定義連線池

1、java自定義連線池　　1.1連線池的概念：　　　實際開發中"獲取連線"或“釋放資源”是非常消耗系統資源的兩個過程，為了姐姐此類效能問題，通常情況我們採用連線池技術來貢獻連線Connection 　　　用池來管理Connection，這樣可以重複使用Connection，有了池，所以我們就不用自

自定義連線池

package com.loaderman.demo.b_pool; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Pr

jdbc----自定義連線池

package cn.itcast.b_pool; import java.sql.Connection; import java.sql.DriverManager; import java.util.LinkedList; /** * 自定義連線池，管理連線 * 自

資料庫連線池原理詳解與自定義連線池實現

實現原理資料庫連線池在初始化時將建立一定數量的資料庫連線放到連線池中，這些資料庫連線的數量是由最小資料庫連線數制約。無論這些資料庫連線是否被使用，連線池都將一直保證至少擁有這麼多的連線數量。連線池的最大資料庫連線數量限定了這個連線池能佔有的最大連線數，當應用程式向連線池請求的連

經典的java自定義資料庫連線池程式碼

import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.Driver; import java.sql.DriverManager; import j

JAVA自定義阻塞型線程池

executors shutdown @class dna 執行指定 gin eject sta rup Java的線程池ThreadPoolExecutor是很常用的，常見構造如下： public ThreadPoolExecutor(int corePoolSiz

Java 自定義FTP連接池

Java 自定義線程池

dfa and hand blank epo cte 方法的參數 factor handler Java 自定義線程池 https://www.cnblogs.com/yaoxiaowen/p/6576898.html public ThreadPoolExecutor(i

java自定義模擬執行緒池

java 執行緒池API提供了newCachedThreadPool() newFixedThreadPool(int) 等方法 1 public static ExecutorService newCachedThreadPool() { 2 return

java自定義執行緒池--ThreadPoolExecutors

public class MyThreadPool { public static void main(String[] args) { /** * 1.在使用有界佇列的時候：若有新的任務需要執行，如果執行緒池實際執行緒數小於corePoolSize核心執行緒數的時候，則優先建立執行緒。

Java自定義執行緒池和執行緒總數控制

1 概述池化是常見的思想，執行緒池是非常典型的池化的實現，《Java併發程式設計實戰》也大篇幅去講解了Java中的執行緒池。本文實現一個簡單的執行緒池。 2 核心類【1】介面定義 public interface IThreadPool<Job extends

java自定義註解的方式連線MySQL資料庫來走進註解

最近在學習spring。裡面有一個非常的強大的功能叫做註解，剛才，同學們的每日一講講到了註解，學以致用來總計一下註解機制什麼是註解？註解（Annotation）：提供了一種安全的類似註釋的機制，為我們在程式碼中新增資訊提供了一種形式化的方法，使我們可

Java自定義異常

trace tex logs fin rate cat java自定義異常 leg pan package cn.Douzi.Lab7_4; public class Triangle { int a, b, c; publ

Java自定義註解反射校驗數據

sda new out 格式是否本地 imp 使用範圍數據類型 package com.annotations.ecargo; import java.lang.annotation.ElementType; import java.lang.annotati

[轉][Java]自定義標簽簡介

是否沒有 override include file sch lang oca uri 作用：自定義標簽主要用於移除 jsp 頁面中的 java 代碼。實現：需要完成以下兩個步驟：編寫一個實現 Tag 接口的 Java 類，把頁面 java 代碼移到這個 java

java自定義註解

不包含 doc 1.2 color 子類局部變量 ati 包含 ant Java註解是附加在代碼中的一些元信息，用於一些工具在編譯、運行時進行解析和使用，起到說明、配置的功能。註解不會也不能影響代碼的實際邏輯，僅僅起到輔助性的作用。包含在 java.lang.annot

Java自定義方法轉換前端提交的json字符串為JsonObject對象

eid test 提交 rac quest https std bject app 前端提交json字符串格式數據，Java後端通過自定義方法接收json字符串數據並轉換為JsonObject對象，代碼如下放到RequestData.Java類中： public stat

Java自定義類加載和ClassPath類加載器

訪問 pub 需要委派 iat 定義 pro logs repl 1 自定義類加載器：實現規則：自定義類加載器，需要重寫findClass，然後通過調用loadClass進行類加載（loadClass通過遞歸實現類的雙親委派加載） package com.daxin

java 自定義log類

comm deb null == bug void err getenv log4 目錄機構如下： package tpf.common; import org.apache.log4j.*; import java.io.File;

java自定義泛型面試題：接收任意數組進行反轉

static class ava div 叠代器類型應用 system length 不用泛型只能操作某種類型進行反轉代碼如下： package com.swift.fanxing; import org.junit.Test; public class Ren

java自定義連線池

相關推薦