[JAVA][學習·練手·挖坑] 做個數據庫幫助庫雛形 · 二

Eric 發布于2019-08-16 10:49 / 567人閱讀

摘要：事實上，實現了接口，而也實現了接口。還記得之前說的，使用之后，其返回的實際上是一個裝飾器嗎。所以修改如下是默認全局工廠名稱，請使用別的名稱工廠已經配置完成，請不要重復配置。

這是做個數據庫幫助庫雛形的當晚的再一次嘗試 ORZ

在意識到原來的 ConnectionProvider 提供的只是一個普通(實現了AutoCloseable接口)的 Connection，這在 RepositoryInvocationHandler.handleFind中使用 try-with-resource 的情況下就相當于 ConnectionProvier沒啥卵用...

因此，今天晚上進行了一些大改：

注：寫到最后我還是想配個日志了... 不過鑒于這么晚了，還是明天再搞吧 : P

ConnectionProvier

/**
 * Created by krun on 2017/9/22.
 */
public class ConnectionProvider {

    public static ConnectionProvider configure (Configuration configuration) {
        return new ConnectionProvider(configuration);
    }

    private Class driverClass;
    private Configuration configuration;
    
    // 大改的核心之處
    private volatile MysqlPooledConnection pooledConnection;

    private ConnectionProvider (Configuration configuration) {
        this.configuration = configuration;
        try {
            this.driverClass = Class.forName(this.configuration.getDriverClass( ));
            System.out.println("加載驅動完畢");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("無法加載 JDBC 驅動: " + this.configuration.getDriverClass( ));
        }
    }

    private synchronized MysqlPooledConnection create ( ) {
        if (driverClass == null) {
            throw new RuntimeException("尚未加載 JDBC 驅動.");
        } else {
            try {
                System.out.println("創建新的 MysqlPooledConnection");
                return new MysqlPooledConnection((com.mysql.jdbc.Connection)
                        DriverManager.getConnection(
                                this.configuration.getConnectionURL( ),
                                this.configuration.getUsername( ),
                                this.configuration.getPassword( )));
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public synchronized Connection provide ( ) throws SQLException {
        if (pooledConnection == null) {
            System.out.println("初始化 pooledConnection");
            pooledConnection = create( );
        } else if (pooledConnection.getConnection().isClosed()) {
            System.out.println("重新獲取 pooledConnection");
            pooledConnection = create( );
        } else {
            System.out.println("使用緩存 pooledConnection");
        }
        return pooledConnection.getConnection();
    }

}

可以發現，最大的改變之處在于 create方法返回的是 MysqlPooledConnection 了。
我用記憶中殘存的 PooledConnection 作為關鍵字搜索后，發現了這篇文章。

這東西事實上并不算完整的連接池實現，有興趣可以用 MysqlPooledConnection 作為關鍵字進行搜索 : P

改用這個東西后，后面其實沒啥改的，因為這個東西所創建的 PreparedStatement 是一個裝飾器。

Connection pooledConnection = ConnectionProvider.provide();
//這里返回的實際類型是 JDBC42PreparedStatementWrapper
PreparedStatement ps = pooledConnection.prepareStatement(...);

JDBC42PreparedStatementWrapper 這個東西包裝了 com.mysql.jdbc.PreparedStatement。
事實上，JDBC42PreparedStatementWrapper 實現了 java.sql.PreparedStatement接口，而com.mysql.jdbc.PreparedStatement也實現了 java.sql.PreparedStatement接口。

那么來看看修改了一些 connection 獲取邏輯的 RepositoryInvocationHandler:

RepositoryInvocationHandler

/**
 * Created by krun on 2017/9/22.
 */
public class RepositoryInvocationHandler implements InvocationHandler {

    //緩存表名，避免多次從方法注解獲取該信息
    private final String entityName;
    private RepositoryFactory factory;
    private Class invokeRepositoryClass;
    //對 PreparedStatement 做一層緩存，避免每次調用方法都創建一個 statement
    private LinkedHashMap preparedStatementMap;
    //緩存連接，主要是批量創建`statement`時避免頻繁調用 ConnectionProvider.provide()
    private Connection connection;

    public RepositoryInvocationHandler (RepositoryFactory factory, Class invokeRepositoryClass) {

        this.factory = factory;
        this.invokeRepositoryClass = invokeRepositoryClass;
        this.preparedStatementMap = new LinkedHashMap<>( );
        this.entityName = getEntityName( );
        this.connection = getConnection();

        try {
            PreparedStatement preparedStatementWrapper;
            Query query;
            //批量創建 statement，替換表名占位符，存入緩存
            for (Method method : invokeRepositoryClass.getMethods( )) {
                query = method.getAnnotation(Query.class);
                if (query == null) continue;
                preparedStatementWrapper = createPreparedStatementWrapper(String.format(query.value( ), entityName));
                System.out.println("為方法 [" + method.getName() + "] 緩存 preparedStatement" );
                this.preparedStatementMap.put(method.getName( ), preparedStatementWrapper);
            }
        } catch (SQLException e) {
            e.printStackTrace( );
        }

    }

    public Object invoke (Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName( );
        if (methodName.startsWith("find")) {
            return handleFind(method, args);
        } else if (methodName.startsWith("save")) {

        } else if (methodName.startsWith("delete")) {

        } else if (methodName.startsWith("exist")) {

        } else if ("close".equals(methodName)) {
            // 暴露 Repository.close 接口來釋放一些資源
            for (String key : this.preparedStatementMap.keySet( )) {
                this.preparedStatementMap.get(key).close( );
            }
            this.connection.close();
            
            //注釋掉這句，避免 close 后再次調用方法時拋出 Statement 已被關閉的錯誤。
            //this.preparedStatementMap.clear();
            System.out.println("釋放 " + invokeRepositoryClass.getSimpleName() + " 的資源");
        }
        return null;
    }

    // 因為獲取連接的動作被抽出來給類里的方法公用，所以要做一層緩存處理
    private Connection getConnection() {
        try {
            synchronized ( this ) {
                if (this.connection == null) {
                    System.out.println("第一次從 provider 獲取連接");
                    this.connection = this.factory.getConnectionProvider().provide();
                } else if (this.connection.isClosed()) {
                    System.out.println("從 provider 獲取新的連接");
                    this.connection = this.factory.getConnectionProvider().provide();
                } else {
                    System.out.println("使用緩存連接");
                }
            }
            return this.connection;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    //把創建 statement 的動作抽出來，配合 getConnection
    private PreparedStatement createPreparedStatementWrapper(String preparedSql) throws SQLException {
        System.out.println("為 [" + preparedSql + "] 創建PreparedStatemen");
        return getConnection()
                .prepareStatement(preparedSql);
    }

    private String getEntityName ( ) {
        if (! Repository.class.isAssignableFrom(this.invokeRepositoryClass)) {
            throw new RuntimeException(String.format("接口 [%s] 并沒有繼承 Repository", this.invokeRepositoryClass.getName( )));
        }
        System.out.println("獲取表名");
        ParameterizedType parameterizedType = (ParameterizedType) this.invokeRepositoryClass.getGenericInterfaces( )[0];
        return ((Class) parameterizedType.getActualTypeArguments( )[0]).getSimpleName( ).toLowerCase( );
    }

    //由于緩存了 statement，需要對其持有的 connection 進行有效性檢查
    private PreparedStatement keepAlive (PreparedStatement preparedStatementWrapper, Method method) {
        try {
            try {
                // 這里有個坑,詳情見代碼塊下的說明
                boolean isClosed = preparedStatementWrapper.isClosed( );
                if (! isClosed) {
                    System.out.println("使用緩存 [" + method.getName() + "] 的 PreparedStatemen");
                    return preparedStatementWrapper;
                }
                System.out.println("[" + method.getName() + "] 的緩存PreparedStatemen已被關閉，創建新的");
                preparedStatementWrapper = createPreparedStatementWrapper(String.format(method.getAnnotation(Query.class).value( ), entityName));
                this.preparedStatementMap.put(method.getName( ), preparedStatementWrapper);
            } catch (SQLException ignore) {
                System.out.println("[" + method.getName() + "] 的緩存PreparedStatemen的stm已被關閉，創建新的");
                preparedStatementWrapper = createPreparedStatementWrapper(String.format(method.getAnnotation(Query.class).value( ), entityName));
                this.preparedStatementMap.put(method.getName( ), preparedStatementWrapper);
            }
            return preparedStatementWrapper;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    @SuppressWarnings ("unchecked")
    private Object handleFind (Method method, Object... args) {
        PreparedStatement preparedStatementWrapper = this.preparedStatementMap.get(method.getName( ));
        if (preparedStatementWrapper == null) {
            throw new IllegalArgumentException("也許你忘了為 " + method.getDeclaringClass( ).getSimpleName( ) + "." + method.getName( ) + "() 設置 @Query 注解");
        }
        try {
            System.out.println("檢查 [" + method.getName() + "] 的 preparedStatement 是否有效");
            preparedStatementWrapper = this.keepAlive(preparedStatementWrapper, method);
            System.out.println("填充參數...");
            for (int i = 1; i <= args.length; i++) {
                preparedStatementWrapper.setObject(i, args[i - 1]);
            }
            System.out.println(preparedStatementWrapper.toString( ));
            ResultSet resultSet = preparedStatementWrapper.executeQuery( );
            ResultSetMetaData metaData = resultSet.getMetaData( );
            while (resultSet.next( )) {
                for (int i = 1; i <= metaData.getColumnCount( ); i++) {
                    System.out.print(String.valueOf(resultSet.getObject(i)) + "	");
                }
                System.out.println();
            }
            resultSet.close( );
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
        try {
            return method.getReturnType( ).newInstance( );
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace( );
        }
        return null;
    }
}

代碼塊中有個地方要多帶帶拿出來說一下:

0        try {
1            try {
2                boolean isClosed = preparedStatementWrapper.isClosed( );
3                if (! isClosed) {
4                    System.out.println("使用緩存 [" + method.getName() + "] 的 PreparedStatemen");
5                    return preparedStatementWrapper;
6                }
7                System.out.println("[" + method.getName() + "] 的緩存PreparedStatemen已被關閉，創建新的");
8                preparedStatementWrapper = createPreparedStatementWrapper(String.format(method.getAnnotation(Query.class).value( ), entityName));
9                this.preparedStatementMap.put(method.getName( ), preparedStatementWrapper);
10            } catch (SQLException ignore) {
11                System.out.println("[" + method.getName() + "] 的緩存PreparedStatemen的stm已被關閉，創建新的");
12                preparedStatementWrapper = createPreparedStatementWrapper(String.format(method.getAnnotation(Query.class).value( ), entityName));
13                this.preparedStatementMap.put(method.getName( ), preparedStatementWrapper);
14            }
15            return preparedStatementWrapper;
16        } catch (SQLException e) {
17            throw new RuntimeException(e);
18        }

重點在于第二行的 preparedStatementWrapper.isClosed()。

還記得之前說的，使用 MysqlPooledConnection之后，其返回的PreparedStatement實際上是一個裝飾器JDBC43PreparedStatementWrapper嗎。

而在 invoke() 中我們對 close方法進行了一個釋放資源的操作，調用的是 statement.close()。

那么這個 statement 是裝飾器的話，它的 close 操作到底是關得誰呢？看看源碼吧：

//JDBC42PreparedStatementWrapper的close實現是由JDBC4PreparedStatementWrapper做的。
public class JDBC4PreparedStatementWrapper extends PreparedStatementWrapper {
    public synchronized void close() throws SQLException {
        if (this.pooledConnection == null) {
            // no-op
            return;
        }

        MysqlPooledConnection con = this.pooledConnection; // we need this later...

        try {
            super.close();
        } finally {
            try {
                StatementEvent e = new StatementEvent(con, this);
                // todo: pull this all up into base classes when we support *only* JDK6 or newer
                if (con instanceof JDBC4MysqlPooledConnection) {
                    ((JDBC4MysqlPooledConnection) con).fireStatementEvent(e);
                } else if (con instanceof JDBC4MysqlXAConnection) {
                    ((JDBC4MysqlXAConnection) con).fireStatementEvent(e);
                } else if (con instanceof JDBC4SuspendableXAConnection) {
                    ((JDBC4SuspendableXAConnection) con).fireStatementEvent(e);
                }
            } finally {
                this.unwrappedInterfaces = null;
            }
        }
    }
}

嗯，看來調用的是 super.close()，那么我們需要再往上看 StatementWrapper:

    public void close() throws SQLException {
        try {
            if (this.wrappedStmt != null) {
                this.wrappedStmt.close();
            }
        } catch (SQLException sqlEx) {
            checkAndFireConnectionError(sqlEx);
        } finally {
            this.wrappedStmt = null;
            this.pooledConnection = null;
        }
    }

問題就在 this.wrappedStmt = null;這一句，它把所裝飾的 statement 實例置空了，再來看看 JDBC4PreparedStatementWrapper 的 isClosed實現:

    public boolean isClosed() throws SQLException {
        try {
            if (this.wrappedStmt != null) {
                return this.wrappedStmt.isClosed();
            } else {
                throw SQLError.createSQLException("Statement already closed", SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
            }
        } catch (SQLException sqlEx) {
            checkAndFireConnectionError(sqlEx);
        }

        return false; // never get here - compiler can"t tell
    }

在 wrappedStmt 為空時，會直接拋出錯誤 ORZ

這就意味著，在調用 JDBC4PreparedStatementWrapper.close() 后，再調用 JDBC4PreparedStatementWrapper.isClosed() 一定會拋出錯誤 ORZ

這就導致我們必須嘗試獲取一下 isClosed()的結果，在獲取成功(雖然我不知道這在什么情況下才會出現)后，在 isClosed == true 的情況下重新創建 JDBC4PreparedStatementWrapper；而 catch 塊里也需要做一個重新創建的操作。

看起來是重復語句，但實際上不能直接把重建操作放在 finally 塊中，那樣會導致每次調用 keepAlive 時都重建 PreparedStatement。

RepositoryFactory

寫完上篇筆記時，我就想起來沒有做一個檢查：

用戶創建一個給定名稱的Repository時，確保這個給定名稱不是 GLOBAL，因為這是全局工廠的名稱。

所以修改如下：

    private static boolean isSelfCall (StackTraceElement[] stackTraceElements) {
        return stackTraceElements[1].getClassName( ).equals(RepositoryFactory.class.getName( ));
    }

    public static RepositoryFactory configure (String name, Configuration configure) {
        if (! isSelfCall(new Exception( ).getStackTrace( )) &&
                FACTORY_GLOBAL.equals(name)) {
            throw new RuntimeException("GLOBAL 是默認全局工廠名稱，請使用別的名稱.");
        }
        RepositoryFactory factory;
        synchronized ( RepositoryFactory.factoryMap ) {
            factory = RepositoryFactory.factoryMap.get(name);
            if (factory != null) {
                throw new RuntimeException(name + " 工廠已經配置完成，請不要重復配置。");
            }
            System.out.println("創建新的工廠: " + name);
            factory = new RepositoryFactory(ConnectionProvider.configure(configure));
            RepositoryFactory.factoryMap.put(name, factory);
        }
        return factory;
    }

云數據庫SQL Server 云數據庫MySQL java編程練手 python 庫幫助 java 做個cms 幫助孩子學習的機器人

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/70523.html

[JAVA][學習·練手·挖坑] 做個數據庫幫助庫雛形

摘要：前者是數據庫驅動，由于這是個挖坑性質的東西，所以只針對做功能了后者是代碼生成框架，挺好用的，強烈推薦也就是說，并不使用常見的數據庫連接池，比如。的工廠已經被初始化了，不能再對其進行配置。在以往的編碼中，使用過 spring-data-jpa，也用過 hibernate 和 mybatis。在簡單的數據庫操作中，spring-data-jpa 是用起來最爽的，畢竟在 IntelliJ ...

rickchen 2019-08-16 10:49 評論0 收藏0
[Java][數據庫工具][坑] Juice README

摘要：注意供應器只會在倉庫工廠第一次創建工廠時調用，而參數處理器和結果解析器將在每次倉庫方法被調用時調用。解析器接收一個語句表模型的類聲明觸發解析器的倉庫方法聲明。因此當您配置了一個結果解析器，語句的執行時機將推遲到這里。 Juice 這是我自己做的一個小項目，也可能會棄坑... 留作紀念吧。GitHub 地址簡介 Juice 是一個簡易的、尚不完善的基于 Java 的SQL數據庫工具，它...

CoXie 2019-08-16 10:50 評論0 收藏0
全棧最后一公里 - Node.js 項目的線上服務器部署與發布

摘要：沒有耐心閱讀的同學，可以直接前往學習全棧最后一公里。我下面會羅列一些，我自己錄制過的一些項目，或者其他的我覺得可以按照這個路線繼續深入學習的項目資源。 showImg(https://segmentfault.com/img/bVMlke?w=833&h=410); 本文技術軟文，閱讀需謹慎，長約 7000 字，通讀需 5 分鐘大家好，我是 Scott，本文通過提供給大家學習的方法，...

Nosee 2019-06-26 17:14 評論0 收藏0
我，27歲，程序員，10月無情被辭：想給學python的人提個醒......

摘要：就在最新的指數中，數據科學和機器學習項目的首選語言，現在排名僅次于語言，排在第二位，將打落到第三位。特別是在深度學習機器學習等領域的廣泛使用，讓一躍成為人工智能時代的網紅語言。 ...

ZweiZhao 2021-11-15 11:38 評論0 收藏0