Todos los productos
Search
Centro de documentos

Lindorm:Use Java JDBC APIs to develop applications

Última actualización: Sep 09, 2026

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

  1. Agregue la dependencia del controlador JDBC de MySQL a su proyecto.

  2. Inicialice el controlador y establezca una conexión mediante una URL JDBC que apunte al endpoint compatible con MySQL de LindormTable.

  3. 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:

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'
Importante

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

url

La URL JDBC para conectarse a LindormTable mediante MySQL. Formato: jdbc:mysql://<endpoint compatible con MySQL>/<base de datos>?<configuración de conexión>. Si no se especifica ninguna base de datos, el cliente se conecta a la base de datos predeterminada. Para obtener el endpoint compatible con MySQL, consulte View endpoints.

database

La base de datos a la que se conectará. Si se omite, se usa la base de datos predeterminada.

username

El nombre de usuario de LindormTable. Para restablecer una contraseña olvidada, consulte Change the password of a user.

password

La contraseña de LindormTable.

Importante

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

sslMode

disabled

Deshabilita el cifrado SSL. Mejora el rendimiento.

allowPublicKeyRetrieval

true

Recupera la clave pública RSA del servidor durante la autenticación.

useServerPrepStmts

true

Utiliza sentencias preparadas del lado del servidor, lo cual mejora el rendimiento y reduce el riesgo de inyección SQL.

useLocalSessionState

true

Emplea el estado de sesión local para reducir los viajes de ida y vuelta al servidor de base de datos.

rewriteBatchedStatements

true

Reescribe las llamadas por lotes de INSERT como sentencias de varias filas, lo que mejora notablemente el rendimiento de escritura. Por ejemplo, tres inserciones independientes se envían como una sola sentencia: INSERT INTO t (a) VALUES (1), (2), (3) en lugar de tres llamadas individuales a INSERT INTO t (a) VALUES (?).

cachePrepStmts

true

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.

prepStmtCacheSize

100

Cantidad de sentencias preparadas almacenadas en caché. Solo surte efecto cuando cachePrepStmts=true. Aumente este valor si su carga de trabajo utiliza muchas sentencias SQL distintas. Tenga en cuenta que una caché más grande consume más memoria.

prepStmtCacheSqlLimit

50000000

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