@Override public C getDelegate() { if (isAccessToUnderlyingConnectionAllowed()) { return getDelegateInternal(); } return null; }
/** * Creates a PoolableManagedConnectionFactory and attach it to a connection pool. * * @param connFactory * XAConnectionFactory * @param dataSourceJmxName * The data source name. */ public PoolableManagedConnectionFactory(final XAConnectionFactory connFactory, final ObjectName dataSourceJmxName) { super(connFactory, dataSourceJmxName); this.transactionRegistry = connFactory.getTransactionRegistry(); }
@Override public void afterCompletion(final int status) { listener.afterCompletion(TransactionContext.this, status == Status.STATUS_COMMITTED); } });
public DataSource wrapDataSource(XADataSource xaDataSource) throws Exception { TransactionManager transactionManager = this.beanFactory.getTransactionManager(); BasicManagedDataSource bds = new BasicManagedDataSource(); bds.setXaDataSourceInstance(xaDataSource); bds.setTransactionManager(transactionManager); return bds; }
@Override public Connection getConnection() throws SQLException { if (getPool() == null) { throw new IllegalStateException("Pool has not been set"); } if (transactionRegistry == null) { throw new IllegalStateException("TransactionRegistry has not been set"); } return new ManagedConnection<>(getPool(), transactionRegistry, isAccessToUnderlyingConnectionAllowed()); } }
@Override protected DataSource createDataSourceInstance() throws SQLException { final PoolingDataSource<PoolableConnection> pds = new ManagedDataSource<>(getConnectionPool(), transactionRegistry); pds.setAccessToUnderlyingConnectionAllowed(isAccessToUnderlyingConnectionAllowed()); return pds; }
@Override public Connection createConnection() throws SQLException { // create a new connection final Connection connection = connectionFactory.createConnection(); // create a XAResource to manage the connection during XA transactions final XAResource xaResource = new LocalXAResource(connection); // register the xa resource for the connection transactionRegistry.registerConnection(connection, xaResource); return connection; }
@Override public void close() throws SQLException, RuntimeException { try { super.close(); } catch (SQLException | RuntimeException e) { throw e; } catch (Exception e) { Debug.log(e); } }
@Override public void connectionErrorOccurred(final ConnectionEvent event) { connectionClosed(event); } });
/** * Unregisters a destroyed connection from {@link TransactionRegistry}. * * @param connection * A destroyed connection from {@link TransactionRegistry}. */ public synchronized void unregisterConnection(final Connection connection) { final Connection key = getConnectionKey(connection); xaResources.remove(key); }
public String getJdbcUrl() { final ReentrantLock l = lock; l.lock(); try { return super.getUrl(); } finally { l.unlock(); } }
@Override public void setPassword(final String password) { final ReentrantLock l = lock; l.lock(); try { // keep the encrypted value if it's encrypted this.initialPassword = password; super.setPassword(password); } finally { l.unlock(); } }
public void setMaxWait(final int maxWait) { final ReentrantLock l = lock; l.lock(); try { super.setMaxWaitMillis((long) maxWait); } finally { l.unlock(); } }
public void setUserName(final String string) { final ReentrantLock l = lock; l.lock(); try { super.setUsername(string); } finally { l.unlock(); } }
public String getJdbcDriver() { final ReentrantLock l = lock; l.lock(); try { return super.getDriverClassName(); } finally { l.unlock(); } }
public void setJdbcDriver(final String string) { final ReentrantLock l = lock; l.lock(); try { super.setDriverClassName(string); } finally { l.unlock(); } }
public void setJdbcUrl(final String string) { final ReentrantLock l = lock; l.lock(); try { super.setUrl(string); } finally { l.unlock(); } }
/** * Actually close the underlying connection. */ @Override public void reallyClose() throws SQLException { try { super.reallyClose(); } finally { transactionRegistry.unregisterConnection(this); } } }
@Override protected void checkOpen() throws SQLException { super.checkOpen(); updateTransactionStatus(); }
@Override public Connection getInnermostDelegate() { if (isAccessToUnderlyingConnectionAllowed()) { return super.getInnermostDelegateInternal(); } return null; } }