Data Sources

/**
 * MariaDB DataSource implementation
 * Implements DataSource, ConnectionPoolDataSource, and XADataSource
 */
public class MariaDbDataSource implements DataSource, ConnectionPoolDataSource, XADataSource {
  /**
   * Get a connection to the database
   * @return Connection instance
   * @throws SQLException if connection fails
   */
  public Connection getConnection() throws SQLException;
  
  /**
   * Get a connection with specific credentials
   * @param username Database username
   * @param password Database password
   * @return Connection instance
   * @throws SQLException if connection fails
   */
  public Connection getConnection(String username, String password) throws SQLException;
  
  /**
   * Get a pooled connection
   * @return PooledConnection instance
   * @throws SQLException if connection fails
   */
  public PooledConnection getPooledConnection() throws SQLException;
  
  /**
   * Get a pooled connection with specific credentials
   * @param username Database username
   * @param password Database password
   * @return PooledConnection instance
   * @throws SQLException if connection fails
   */
  public PooledConnection getPooledConnection(String username, String password) throws SQLException;
  
  /**
   * Get an XA connection for distributed transactions
   * @return XAConnection instance
   * @throws SQLException if connection fails
   */
  public XAConnection getXAConnection() throws SQLException;
  
  /**
   * Get an XA connection with specific credentials
   * @param username Database username
   * @param password Database password
   * @return XAConnection instance
   * @throws SQLException if connection fails
   */
  public XAConnection getXAConnection(String username, String password) throws SQLException;
  
  // Configuration methods
  public void setUrl(String url);
  public String getUrl();
  public void setUser(String user);
  public String getUser();
  public void setPassword(String password);
  public void setDatabaseName(String databaseName);
  public String getDatabaseName();
  public void setServerName(String serverName);
  public String getServerName();
  public void setPort(int port);
  public int getPort();
  public void setLoginTimeout(int seconds) throws SQLException;
  public int getLoginTimeout() throws SQLException;
}

// Basic DataSource configuration
MariaDbDataSource dataSource = new MariaDbDataSource();
dataSource.setUrl("jdbc:mariadb://localhost:3306/mydb");
dataSource.setUser("myuser");
dataSource.setPassword("mypass");

// Get connection from DataSource
Connection conn = dataSource.getConnection();

// Alternative: specify credentials at connection time
Connection conn2 = dataSource.getConnection("otheruser", "otherpass");

// For enterprise applications with connection pooling
PooledConnection pooledConn = dataSource.getPooledConnection();
Connection conn3 = pooledConn.getConnection();

// For distributed transactions
XAConnection xaConn = dataSource.getXAConnection();
Connection conn4 = xaConn.getConnection();
XAResource xaResource = xaConn.getXAResource();

/**
 * MariaDB DataSource with built-in connection pooling
 * Extends MariaDbDataSource with pooling capabilities
 */
public class MariaDbPoolDataSource extends MariaDbDataSource implements Closeable, AutoCloseable {
  /**
   * Close the connection pool and all its connections
   * @throws SQLException if closing fails
   */
  public void close() throws SQLException;
  
  // Inherits all methods from MariaDbDataSource
  // Pool configuration through URL parameters or setUrl()
}

// Create pooled DataSource
MariaDbPoolDataSource poolDataSource = new MariaDbPoolDataSource();
poolDataSource.setUrl("jdbc:mariadb://localhost:3306/mydb?pool=true&maxPoolSize=20&minPoolSize=5");
poolDataSource.setUser("myuser");
poolDataSource.setPassword("mypass");

try {
    // Use pooled connections
    Connection conn1 = poolDataSource.getConnection();
    Connection conn2 = poolDataSource.getConnection();
    
    // Connections are managed by the pool
    conn1.close(); // Returns to pool
    conn2.close(); // Returns to pool
    
} finally {
    // Close entire pool when done
    poolDataSource.close();
}

// Try-with-resources for automatic cleanup
try (MariaDbPoolDataSource poolDataSource = new MariaDbPoolDataSource()) {
    poolDataSource.setUrl("jdbc:mariadb://localhost:3306/mydb?pool=true");
    poolDataSource.setUser("user");
    poolDataSource.setPassword("pass");
    
    Connection conn = poolDataSource.getConnection();
    // Use connection...
} // Pool automatically closed

/**
 * Pooled connection implementation
 * Implements both PooledConnection and XAConnection interfaces
 */
public class MariaDbPoolConnection implements PooledConnection, XAConnection {
  /**
   * Get the underlying database connection
   * @return Connection instance
   * @throws SQLException if connection retrieval fails
   */
  public Connection getConnection() throws SQLException;
  
  /**
   * Close the pooled connection
   * @throws SQLException if closing fails
   */
  public void close() throws SQLException;
  
  /**
   * Add listener for connection events
   * @param listener Event listener
   */
  public void addConnectionEventListener(ConnectionEventListener listener);
  
  /**
   * Remove connection event listener
   * @param listener Event listener to remove
   */
  public void removeConnectionEventListener(ConnectionEventListener listener);
  
  /**
   * Add listener for statement events
   * @param listener Statement event listener
   */
  public void addStatementEventListener(StatementEventListener listener);
  
  /**
   * Remove statement event listener
   * @param listener Statement event listener to remove
   */
  public void removeStatementEventListener(StatementEventListener listener);
  
  // XA transaction support
  /**
   * Get XA resource for distributed transactions
   * @return XAResource instance
   * @throws SQLException if XA resource retrieval fails
   */
  public XAResource getXAResource() throws SQLException;
}

// Using pooled connections with event listeners
PooledConnection pooledConn = dataSource.getPooledConnection();

// Add connection event listener
pooledConn.addConnectionEventListener(new ConnectionEventListener() {
    public void connectionClosed(ConnectionEvent event) {
        System.out.println("Connection closed");
    }
    
    public void connectionErrorOccurred(ConnectionEvent event) {
        System.out.println("Connection error: " + event.getSQLException().getMessage());
    }
});

// Get and use the underlying connection
Connection conn = pooledConn.getConnection();
// Use connection...
conn.close(); // Triggers connectionClosed event

// For XA transactions
XAConnection xaConn = (XAConnection) pooledConn;
XAResource xaResource = xaConn.getXAResource();

// Distributed transaction management
Xid xid = new MariaDbXid(1, "global".getBytes(), "branch".getBytes());
xaResource.start(xid, XAResource.TMNOFLAGS);
// Perform database operations
Connection conn2 = xaConn.getConnection();
Statement stmt = conn2.createStatement();
stmt.executeUpdate("INSERT INTO table VALUES (1, 'data')");
xaResource.end(xid, XAResource.TMSUCCESS);
xaResource.prepare(xid);
xaResource.commit(xid, false);

/**
 * Pinned pooled connection for global transactions
 * Maintains connection affinity for transaction consistency
 */
public class MariaDbPoolPinnedConnection extends MariaDbPoolConnection {
  // Inherits all PooledConnection and XAConnection methods
  // Provides connection pinning for global transaction contexts
}

<!-- In application server configuration (e.g., Tomcat context.xml) -->
<Resource name="jdbc/MariaDB"
          auth="Container"
          type="javax.sql.DataSource"
          factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"
          driverClassName="org.mariadb.jdbc.Driver"
          url="jdbc:mariadb://localhost:3306/mydb"
          username="myuser"
          password="mypass"
          maxActive="20"
          maxIdle="10"
          minIdle="5"
          initialSize="5"
          maxWait="10000" />

// Lookup DataSource from JNDI
InitialContext ctx = new InitialContext();
DataSource dataSource = (DataSource) ctx.lookup("java:comp/env/jdbc/MariaDB");
Connection conn = dataSource.getConnection();

// Spring configuration
@Configuration
public class DatabaseConfig {
    
    @Bean
    @Primary
    public DataSource dataSource() {
        MariaDbDataSource dataSource = new MariaDbDataSource();
        dataSource.setUrl("jdbc:mariadb://localhost:3306/mydb");
        dataSource.setUser("myuser");
        dataSource.setPassword("mypass");
        return dataSource;
    }
    
    @Bean
    public DataSource pooledDataSource() {
        MariaDbPoolDataSource dataSource = new MariaDbPoolDataSource();
        dataSource.setUrl("jdbc:mariadb://localhost:3306/mydb?pool=true&maxPoolSize=20");
        dataSource.setUser("myuser");
        dataSource.setPassword("mypass");
        return dataSource;
    }
}

// Using in Spring components
@Service
public class UserService {
    
    @Autowired
    private DataSource dataSource;
    
    public List<User> getUsers() throws SQLException {
        try (Connection conn = dataSource.getConnection();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
            
            List<User> users = new ArrayList<>();
            while (rs.next()) {
                users.add(new User(rs.getString("name"), rs.getString("email")));
            }
            return users;
        }
    }
}

// Pool configuration parameters
String poolUrl = "jdbc:mariadb://localhost:3306/mydb?" +
    "pool=true&" +                    // Enable pooling
    "poolName=MyPool&" +              // Pool name for JMX
    "maxPoolSize=25&" +               // Maximum connections
    "minPoolSize=5&" +                // Minimum connections
    "maxIdleTime=600&" +              // Max idle time (seconds)
    "poolValidMinDelay=1000&" +       // Validation delay (ms)
    "registerJmxPool=true";           // Enable JMX monitoring

MariaDbPoolDataSource poolDataSource = new MariaDbPoolDataSource();
poolDataSource.setUrl(poolUrl);
poolDataSource.setUser("user");
poolDataSource.setPassword("password");