Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Source Code for Connector/J 8.0.31 - User Impl
Where to get the Java source code for Connector/J 8.0 User Impl module?
✍: FYIcenter.com
Java source code files for Connector/J 8.0 User Impl module are:
⏎ com/mysql/cj/jdbc/ha/MultiHostConnectionProxy.java
/* * Copyright (c) 2015, 2021, Oracle and/or its affiliates. * * This program is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License, version 2.0, as published by the * Free Software Foundation. * * This program is also distributed with certain software (including but not * limited to OpenSSL) that is licensed under separate terms, as designated in a * particular file or component or in included license documentation. The * authors of MySQL hereby grant you an additional permission to link the * program and your derivative works with the separately licensed software that * they have included with MySQL. * * Without limiting anything contained in the foregoing, this file, which is * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, * version 1.0, a copy of which can be found at * http://oss.oracle.com/licenses/universal-foss-exception. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, * for more details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ package com.mysql.cj.jdbc.ha; import java.lang.reflect.InvocationHandler; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; import java.util.Properties; import java.util.concurrent.Executor; import com.mysql.cj.conf.ConnectionUrl; import com.mysql.cj.conf.HostInfo; import com.mysql.cj.conf.PropertyKey; import com.mysql.cj.conf.RuntimeProperty; import com.mysql.cj.jdbc.ConnectionImpl; import com.mysql.cj.jdbc.JdbcConnection; import com.mysql.cj.util.Util; /** * An abstract class that processes generic multi-host configurations. This class has to be sub-classed by specific multi-host implementations, such as * load-balancing and failover. */ public abstract class MultiHostConnectionProxy implements InvocationHandler { private static final String METHOD_GET_MULTI_HOST_SAFE_PROXY = "getMultiHostSafeProxy"; private static final String METHOD_EQUALS = "equals"; private static final String METHOD_CLOSE = "close"; private static final String METHOD_ABORT_INTERNAL = "abortInternal"; private static final String METHOD_ABORT = "abort"; private static final String METHOD_IS_CLOSED = "isClosed"; private static final String METHOD_GET_AUTO_COMMIT = "getAutoCommit"; private static final String METHOD_GET_CATALOG = "getCatalog"; private static final String METHOD_GET_SCHEMA = "getSchema"; private static final String METHOD_GET_DATABASE = "getDatabase"; private static final String METHOD_GET_TRANSACTION_ISOLATION = "getTransactionIsolation"; private static final String METHOD_GET_SESSION_MAX_ROWS = "getSessionMaxRows"; List<HostInfo> hostsList; protected ConnectionUrl connectionUrl; boolean autoReconnect = false; JdbcConnection thisAsConnection = null; JdbcConnection parentProxyConnection = null; JdbcConnection topProxyConnection = null; JdbcConnection currentConnection = null; boolean isClosed = false; boolean closedExplicitly = false; String closedReason = null; // Keep track of the last exception processed in 'dealWithInvocationException()' in order to avoid creating connections repeatedly from each time the same // exception is caught in every proxy instance belonging to the same call stack. protected Throwable lastExceptionDealtWith = null; /** * Proxy class to intercept and deal with errors that may occur in any object bound to the current connection. */ class JdbcInterfaceProxy implements InvocationHandler { Object invokeOn = null; JdbcInterfaceProxy(Object toInvokeOn) { this.invokeOn = toInvokeOn; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (METHOD_EQUALS.equals(method.getName())) { // Let args[0] "unwrap" to its InvocationHandler if it is a proxy. return args[0].equals(this); } synchronized (MultiHostConnectionProxy.this) { Object result = null; try { result = method.invoke(this.invokeOn, args); result = proxyIfReturnTypeIsJdbcInterface(method.getReturnType(), result); } catch (InvocationTargetException e) { dealWithInvocationException(e); } return result; } } } /** * Initializes a connection wrapper for this MultiHostConnectionProxy instance. * * @throws SQLException * if an error occurs */ MultiHostConnectionProxy() throws SQLException { this.thisAsConnection = getNewWrapperForThisAsConnection(); } /** * Constructs a MultiHostConnectionProxy instance for the given connection URL. * * @param connectionUrl * The connection URL. * @throws SQLException * if an error occurs */ MultiHostConnectionProxy(ConnectionUrl connectionUrl) throws SQLException { this(); initializeHostsSpecs(connectionUrl, connectionUrl.getHostsList()); } /** * Initializes the hosts lists and makes a "clean" local copy of the given connection properties so that it can be later used to create standard * connections. * * @param connUrl * The connection URL that initialized this multi-host connection. * @param hosts * The list of hosts for this multi-host connection. * @return * The number of hosts found in the hosts list. */ int initializeHostsSpecs(ConnectionUrl connUrl, List<HostInfo> hosts) { this.connectionUrl = connUrl; Properties props = connUrl.getConnectionArgumentsAsProperties(); this.autoReconnect = "true".equalsIgnoreCase(props.getProperty(PropertyKey.autoReconnect.getKeyName())) || "true".equalsIgnoreCase(props.getProperty(PropertyKey.autoReconnectForPools.getKeyName())); this.hostsList = new ArrayList<>(hosts); int numHosts = this.hostsList.size(); return numHosts; } /** * Get this connection's proxy. * A multi-host connection may not be at top level in the multi-host connections chain. In such case the first connection in the chain is available as a * proxy. * * @return * Returns this connection's proxy if there is one or itself if this is the first one. */ protected JdbcConnection getProxy() { return this.topProxyConnection != null ? this.topProxyConnection : this.thisAsConnection; } /** * Get this connection's parent proxy. * * @return * Returns this connection's proxy if there is one. */ protected JdbcConnection getParentProxy() { return this.parentProxyConnection; } /** * Sets this connection's proxy. This proxy should be the first connection in the multi-host connections chain. * After setting the connection proxy locally, propagates it through the dependent connections. * * @param proxyConn * The top level connection in the multi-host connections chain. */ protected final void setProxy(JdbcConnection proxyConn) { if (this.parentProxyConnection == null) { // Only set this once. this.parentProxyConnection = proxyConn; } this.topProxyConnection = proxyConn; propagateProxyDown(proxyConn); } /** * Propagates the connection proxy down through the multi-host connections chain. * This method is intended to be overridden in subclasses that manage more than one active connection at same time. * * @param proxyConn * The top level connection in the multi-host connections chain. */ protected void propagateProxyDown(JdbcConnection proxyConn) { this.currentConnection.setProxy(proxyConn); } /** * Wraps this object with a new multi-host Connection instance. * * @return * The connection object instance that wraps 'this'. * @throws SQLException * if an error occurs */ JdbcConnection getNewWrapperForThisAsConnection() throws SQLException { return new MultiHostMySQLConnection(this); } /** * If the given return type is or implements a JDBC interface, proxies the given object so that we can catch SQL errors and fire a connection switch. * * @param returnType * The type the object instance to proxy is supposed to be. * @param toProxy * The object instance to proxy. * @return * The proxied object or the original one if it does not implement a JDBC interface. */ Object proxyIfReturnTypeIsJdbcInterface(Class<?> returnType, Object toProxy) { if (toProxy != null) { if (Util.isJdbcInterface(returnType)) { Class<?> toProxyClass = toProxy.getClass(); return Proxy.newProxyInstance(toProxyClass.getClassLoader(), Util.getImplementedInterfaces(toProxyClass), getNewJdbcInterfaceProxy(toProxy)); } } return toProxy; } /** * Instantiates a new JdbcInterfaceProxy for the given object. Subclasses can override this to return instances of JdbcInterfaceProxy subclasses. * * @param toProxy * The object instance to be proxied. * @return * The new InvocationHandler instance. */ InvocationHandler getNewJdbcInterfaceProxy(Object toProxy) { return new JdbcInterfaceProxy(toProxy); } /** * Deals with InvocationException from proxied objects. * * @param e * The Exception instance to check. * @throws SQLException * if an error occurs * @throws Throwable * if an error occurs * @throws InvocationTargetException * if an error occurs */ void dealWithInvocationException(InvocationTargetException e) throws SQLException, Throwable, InvocationTargetException { Throwable t = e.getTargetException(); if (t != null) { if (this.lastExceptionDealtWith != t && shouldExceptionTriggerConnectionSwitch(t)) { invalidateCurrentConnection(); pickNewConnection(); this.lastExceptionDealtWith = t; } throw t; } throw e; } /** * Checks if the given throwable should trigger a connection switch. * * @return true if the given throwable should trigger a connection switch * @param t * The Throwable instance to analyze. */ abstract boolean shouldExceptionTriggerConnectionSwitch(Throwable t); /** * Checks if current connection is to a source host. * * @return true if current connection is to a source host */ abstract boolean isSourceConnection(); /** * Use {@link #isSourceConnection()} instead. * * @return boolean * @deprecated */ @Deprecated boolean isMasterConnection() { return isSourceConnection(); } /** * Invalidates the current connection. * * @throws SQLException * if an error occurs */ synchronized void invalidateCurrentConnection() throws SQLException { invalidateConnection(this.currentConnection); } /** * Invalidates the specified connection by closing it. * * @param conn * The connection instance to invalidate. * @throws SQLException * if an error occurs */ synchronized void invalidateConnection(JdbcConnection conn) throws SQLException { try { if (conn != null && !conn.isClosed()) { conn.realClose(true, !conn.getAutoCommit(), true, null); } } catch (SQLException e) { // swallow this exception, current connection should be useless anyway. } } /** * Picks the "best" connection to use from now on. Each subclass needs to implement its connection switch strategy on it. * * @throws SQLException * if an error occurs */ abstract void pickNewConnection() throws SQLException; /** * Creates a new physical connection for the given {@link HostInfo}. * * @param hostInfo * The host info instance. * @return * The new Connection instance. * @throws SQLException * if an error occurs */ synchronized ConnectionImpl createConnectionForHost(HostInfo hostInfo) throws SQLException { ConnectionImpl conn = (ConnectionImpl) ConnectionImpl.getInstance(hostInfo); JdbcConnection topmostProxy = getProxy(); if (topmostProxy != this.thisAsConnection) { conn.setProxy(this.thisAsConnection); // First call sets this connection as underlying connection parent proxy (its creator). } conn.setProxy(topmostProxy); // Set the topmost proxy in the underlying connection. return conn; } /** * Synchronizes session state between two connections. * * @param source * The connection where to get state from. * @param target * The connection where to set state. * @throws SQLException * if an error occurs */ void syncSessionState(JdbcConnection source, JdbcConnection target) throws SQLException { if (source == null || target == null) { return; } RuntimeProperty<Boolean> sourceUseLocalSessionState = source.getPropertySet().getBooleanProperty(PropertyKey.useLocalSessionState); boolean prevUseLocalSessionState = sourceUseLocalSessionState.getValue(); sourceUseLocalSessionState.setValue(true); boolean readOnly = source.isReadOnly(); sourceUseLocalSessionState.setValue(prevUseLocalSessionState); syncSessionState(source, target, readOnly); } /** * Synchronizes session state between two connections, allowing to override the read-only status. * * @param source * The connection where to get state from. * @param target * The connection where to set state. * @param readOnly * The new read-only status. * @throws SQLException * if an error occurs */ void syncSessionState(JdbcConnection source, JdbcConnection target, boolean readOnly) throws SQLException { if (target != null) { target.setReadOnly(readOnly); } if (source == null || target == null) { return; } RuntimeProperty<Boolean> sourceUseLocalSessionState = source.getPropertySet().getBooleanProperty(PropertyKey.useLocalSessionState); boolean prevUseLocalSessionState = sourceUseLocalSessionState.getValue(); sourceUseLocalSessionState.setValue(true); target.setAutoCommit(source.getAutoCommit()); String db = source.getDatabase(); if (db != null && !db.isEmpty()) { target.setDatabase(db); } target.setTransactionIsolation(source.getTransactionIsolation()); target.setSessionMaxRows(source.getSessionMaxRows()); sourceUseLocalSessionState.setValue(prevUseLocalSessionState); } /** * Executes a close() invocation; * * @throws SQLException * if an error occurs */ abstract void doClose() throws SQLException; /** * Executes a abortInternal() invocation; * * @throws SQLException * if an error occurs */ abstract void doAbortInternal() throws SQLException; /** * Executes a abort() invocation; * * @param executor * executor * @throws SQLException * if an error occurs */ abstract void doAbort(Executor executor) throws SQLException; /** * Proxies method invocation on the java.sql.Connection interface, trapping multi-host specific methods and generic methods. * Subclasses have to override this to complete the method invocation process, deal with exceptions and decide when to switch connection. * To avoid unnecessary additional exception handling overriders should consult #canDealWith(Method) before chaining here. * * @param proxy * proxy object * @param method * method to invoke * @param args * method parameters * @return method result * @throws Throwable * if an error occurs */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String methodName = method.getName(); if (METHOD_GET_MULTI_HOST_SAFE_PROXY.equals(methodName)) { return this.thisAsConnection; } if (METHOD_EQUALS.equals(methodName)) { // Let args[0] "unwrap" to its InvocationHandler if it is a proxy. return args[0].equals(this); } // Execute remaining ubiquitous methods right away. if (method.getDeclaringClass().equals(Object.class)) { return method.invoke(this, args); } synchronized (this) { if (METHOD_CLOSE.equals(methodName)) { doClose(); this.isClosed = true; this.closedReason = "Connection explicitly closed."; this.closedExplicitly = true; return null; } if (METHOD_ABORT_INTERNAL.equals(methodName)) { doAbortInternal(); this.currentConnection.abortInternal(); this.isClosed = true; this.closedReason = "Connection explicitly closed."; return null; } if (METHOD_ABORT.equals(methodName) && args.length == 1) { doAbort((Executor) args[0]); this.isClosed = true; this.closedReason = "Connection explicitly closed."; return null; } if (METHOD_IS_CLOSED.equals(methodName)) { return this.isClosed; } try { return invokeMore(proxy, method, args); } catch (InvocationTargetException e) { throw e.getCause() != null ? e.getCause() : e; } catch (Exception e) { // Check if the captured exception must be wrapped by an unchecked exception. Class<?>[] declaredException = method.getExceptionTypes(); for (Class<?> declEx : declaredException) { if (declEx.isAssignableFrom(e.getClass())) { throw e; } } throw new IllegalStateException(e.getMessage(), e); } } } /** * Continuation of the method invocation process, to be implemented within each subclass. * * @param proxy * proxy object * @param method * method to invoke * @param args * method parameters * @return method result * @throws Throwable * if an error occurs */ abstract Object invokeMore(Object proxy, Method method, Object[] args) throws Throwable; /** * Checks if the given method is allowed on closed connections. * * @param method * method * @return true if the given method is allowed on closed connections */ protected boolean allowedOnClosedConnection(Method method) { String methodName = method.getName(); return methodName.equals(METHOD_GET_AUTO_COMMIT) || methodName.equals(METHOD_GET_CATALOG) || methodName.equals(METHOD_GET_SCHEMA) || methodName.equals(METHOD_GET_DATABASE) || methodName.equals(METHOD_GET_TRANSACTION_ISOLATION) || methodName.equals(METHOD_GET_SESSION_MAX_ROWS); } }
⏎ com/mysql/cj/jdbc/ha/MultiHostConnectionProxy.java
Or download all of them as a single archive file:
File name: mysql-connector-java-user-impl-8.0.31.zip File size: 429580 bytes Release date: 2022-09-03 Download
⇒ Downloading mysql-connector-java-5.1.40.zip
⇐ Source Code for Connector/J 8.0.31 - User API
2023-05-09, 7622👍, 0💬
Popular Posts:
JDK 11 java.rmi.jmod is the JMOD file for JDK 11 RMI (Remote Method Invocation) module. JDK 11 RMI m...
JDK 11 jdk.jdeps.jmod is the JMOD file for JDK 11 JDeps tool, which can be invoked by the "jdeps" co...
maven-core-3.5.4.jar is the JAR file for Apache Maven 3.5.4 Core module. Apache Maven is a software ...
JDK 11 jdk.charsets.jmod is the JMOD file for JDK 11 Charsets module. JDK 11 Charsets module compile...
What is the sax\Counter.java provided in the Apache Xerces package? I have Apache Xerces 2.11.0 inst...