Java Database Connectivity (JDBC) es una API estándar de Java que permite conectarse a bases de datos y gestionarlas. En este tema se explica cómo conectarse a LindormTable mediante el protocolo MySQL con el controlador JDBC de MySQL y ejecutar operaciones CRUD con Lindorm SQL.
Funcionamiento
Agregue la dependencia del controlador JDBC de MySQL a su proyecto.
Inicialice el controlador y establezca una conexión mediante una URL JDBC que apunte al endpoint compatible con MySQL de LindormTable.
Utilice las API JDBC estándar junto con Lindorm SQL para crear tablas, escribir datos, consultarlos y eliminar registros.
Requisitos previos
Antes de empezar, compruebe que cuenta con lo siguiente:
La función de compatibilidad con MySQL habilitada en su instancia de Lindorm. Consulte Enable the MySQL compatibility feature
JDK 1.8 o una versión posterior instalada
Su dirección IP cliente agregada a la lista de permitidos de la instancia de Lindorm. Consulte Configure a whitelist
Paso 1: Agregar el controlador JDBC de MySQL
En un proyecto Maven, agregue la siguiente dependencia a la sección dependencies del archivo pom.xml:
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>8.3.0</version>
</dependency>
En un proyecto Gradle, agregue lo siguiente a su archivo build.gradle:
implementation 'com.mysql:mysql-connector-j:8.3.0'
Use la versión 8.0 o posterior del controlador JDBC de MySQL. Si su proyecto no usa Maven ni Gradle, agregue manualmente el archivo mysql-connector-java-x.x.x.jar a su CLASSPATH; de lo contrario, la conexión fallará.
Paso 2: Conectarse a LindormTable
Inicialice el controlador JDBC de MySQL y establezca la conexión:
Class.forName("com.mysql.cj.jdbc.Driver");
// The database username from the Lindorm console.
String username = "root";
// The database password from the Lindorm console.
String password = "root";
// Specify the database to connect to. If omitted, the default database is used.
String database = "default";
// The LindormTable endpoint for MySQL. Port 33060 is fixed and must not be changed.
// Replace the hostname with your actual MySQL-compatible endpoint.
String url = "jdbc:mysql://ld-uf6k8yqb741t3****-proxy-sql-lindorm-public.lindorm.rds.aliyuncs.com:33060/"
+ database
+ "?sslMode=disabled"
+ "&allowPublicKeyRetrieval=true"
+ "&useServerPrepStmts=true"
+ "&useLocalSessionState=true"
+ "&rewriteBatchedStatements=true"
+ "&cachePrepStmts=true"
+ "&prepStmtCacheSize=100"
+ "&prepStmtCacheSqlLimit=50000000";
Properties properties = new Properties();
properties.put("user", username);
properties.put("password", password);
Connection connection = DriverManager.getConnection(url, properties);
Parámetros de conexión
|
Parámetro |
Descripción |
|
|
La URL JDBC para conectarse a LindormTable mediante MySQL. Formato: |
|
|
La base de datos a la que se conectará. Si se omite, se usa la base de datos predeterminada. |
|
|
El nombre de usuario de LindormTable. Para restablecer una contraseña olvidada, consulte Change the password of a user. |
|
|
La contraseña de LindormTable. |
Elija el endpoint según la forma en que su cliente accede a la instancia de Lindorm:
Virtual Private Cloud (VPC) (recomendado): use la dirección VPC compatible con MySQL. Las aplicaciones que se ejecutan en instancias de Elastic Compute Service (ECS) obtienen menor latencia y mayor seguridad con una conexión VPC.
Red pública: habilite el endpoint público en la consola de Lindorm y utilice la dirección de Internet compatible con MySQL. Consulte View the endpoints of LindormTable.
Configuración de conexión
Todos los parámetros de conexión de la URL son obligatorios. A continuación se describe cada uno:
|
Parámetro |
Valor |
Descripción |
|
|
|
Deshabilita el cifrado SSL. Mejora el rendimiento. |
|
|
|
Recupera la clave pública RSA del servidor durante la autenticación. |
|
|
|
Utiliza sentencias preparadas del lado del servidor, lo cual mejora el rendimiento y reduce el riesgo de inyección SQL. |
|
|
|
Emplea el estado de sesión local para reducir los viajes de ida y vuelta al servidor de base de datos. |
|
|
|
Reescribe las llamadas por lotes de |
|
|
|
Almacena en caché las sentencias preparadas en el cliente, lo que reduce la sobrecarga de creación en las sentencias que se ejecutan con frecuencia. |
|
|
|
Cantidad de sentencias preparadas almacenadas en caché. Solo surte efecto cuando |
|
|
|
Longitud máxima en bytes de las sentencias SQL aptas para almacenamiento en caché. Las sentencias que superen este valor no se almacenan. Increméntelo en cargas de trabajo sensibles al rendimiento que manejen sentencias SQL largas. |
Paso 3: Ejecutar operaciones SQL
Una vez establecida la conexión, utilice Lindorm SQL para crear tablas e insertar, consultar y eliminar datos:
String tableName = "sql_table_" + new Random().nextInt(1000);
// Create a table.
try (Statement statement = connection.createStatement()) {
String sql = "CREATE TABLE IF NOT EXISTS " + tableName
+ "(id VARCHAR, name VARCHAR, PRIMARY KEY(id))";
int ret = statement.executeUpdate(sql);
System.out.println(ret);
}
// Insert data in a batch. Use INSERT — in Lindorm SQL, INSERT has UPSERT semantics.
String upsertSql = "INSERT INTO " + tableName + "(id, name) VALUES(?, ?)";
try (PreparedStatement ps = connection.prepareStatement(upsertSql)) {
int batchSize = 100;
for (int i = 0; i < batchSize; i++) {
ps.setString(1, "aa" + i);
ps.setString(2, "bb" + i);
ps.addBatch();
}
int[] ret = ps.executeBatch();
System.out.println(Arrays.toString(ret));
}
// Query data.
String querySql = "SELECT * FROM " + tableName + " WHERE id = ?";
try (PreparedStatement ps = connection.prepareStatement(querySql)) {
ps.setString(1, "aa1");
ResultSet rs = ps.executeQuery();
while (rs.next()) {
String id = rs.getString(1);
String name = rs.getString(2);
System.out.println("id=" + id);
System.out.println("name=" + name);
}
}
// Delete data.
String deleteSql = "DELETE FROM " + tableName + " WHERE id = ?";
try (PreparedStatement ps = connection.prepareStatement(deleteSql)) {
ps.setString(1, "aa1");
ps.executeUpdate();
}
// Always close the connection to prevent resource leaks.
connection.close();
Para consultar la referencia completa de la sintaxis de Lindorm SQL, consulte SQL reference.
Notas de uso
Semántica de INSERT y UPSERT
En Lindorm SQL, INSERT tiene la misma semántica que UPSERT. El cliente JDBC de MySQL optimiza las sentencias INSERT, por lo que debe usar INSERT para todas las escrituras de datos.
Tamaño de las escrituras por lotes
Las escrituras por lotes reducen la sobrecarga de las llamadas a procedimientos remotos (RPC). Además, permiten que el servidor procese varias filas por solicitud, lo que aumenta el throughput frente a las escrituras de una sola fila. Sin embargo, los lotes demasiado grandes pueden provocar errores de falta de memoria (OOM) o pausas por recolección de basura completa (Full GC), lo que degrada la estabilidad del servicio. Mantenga batchSize entre 50 y 100 filas. Si necesita aumentar el throughput general de escritura, incremente la concurrencia en lugar del tamaño del lote.
Pasos siguientes
SQL reference: sintaxis completa de Lindorm SQL
View endpoints: ubicación de su endpoint compatible con MySQL
Configure a whitelist: gestión del control de acceso por IP