Todos os produtos
Search
Central de documentação

Lindorm:Use Java JDBC APIs to develop applications

Última atualização: Jul 10, 2026

O Java Database Connectivity (JDBC) é uma API padrão do Java para conexão e gerenciamento de bancos de dados. Este tópico demonstra como se conectar ao LindormTable pelo protocolo MySQL usando o driver JDBC do MySQL e executar operações CRUD com o Lindorm SQL.

Como funciona

  1. Adicione a dependência do driver JDBC do MySQL ao seu projeto.

  2. Inicialize o driver e estabeleça uma conexão usando uma URL JDBC que aponte para o endpoint compatível com MySQL do LindormTable.

  3. Use as APIs JDBC padrão com o Lindorm SQL para criar tabelas, gravar dados, consultar e excluir registros.

Pré-requisitos

Antes de começar, verifique se você possui:

Etapa 1: Adicionar o driver JDBC do MySQL

Para projetos Maven, adicione a seguinte dependência à seção dependencies no arquivo pom.xml:

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.3.0</version>
</dependency>

Em projetos Gradle, adicione o seguinte ao seu arquivo build.gradle:

implementation 'com.mysql:mysql-connector-j:8.3.0'
Importante

Use a versão 8,0 ou posterior do driver JDBC do MySQL. Em projetos que não usam Maven ou Gradle, adicione manualmente o arquivo mysql-connector-java-x.x.x.jar ao seu CLASSPATH, caso contrário a conexão falhará.

Etapa 2: Conectar-se ao LindormTable

Inicialize o driver JDBC do MySQL e estabeleça a conexão:

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 conexão

Parâmetro

Descrição

url

A URL JDBC para acessar o LindormTable via MySQL. Formato: jdbc:mysql://<endpoint compatível com MySQL>/<banco de dados>?<configurações de conexão>. Se nenhum banco de dados for especificado, o cliente se conecta ao banco de dados padrão. Para obter o endpoint compatível com MySQL, consulte Visualize endpoints.

database

O banco de dados de destino. Se omitido, assume o banco de dados padrão.

username

O nome de usuário para acesso ao LindormTable. Para redefinir uma senha esquecida, consulte Alterar a senha de um usuário.

password

A senha correspondente ao usuário do LindormTable.

Importante

Escolha o endpoint conforme o método de acesso do seu cliente à instância do Lindorm:

  • Virtual Private Cloud (VPC) (recomendado): Use o endereço VPC compatível com MySQL. Aplicações executadas em instâncias do Elastic Compute Service (ECS) obtêm menor latência e maior segurança por meio de uma conexão VPC.

  • Rede pública: Ative o endpoint público no console do Lindorm e use o endereço de Internet compatível com MySQL. Consulte Visualize os endpoints do LindormTable.

Configurações de conexão

Todas as configurações de conexão na URL são obrigatórias. A tabela a seguir detalha cada parâmetro:

Parâmetro

Valor

Descrição

sslMode

disabled

Desativa a criptografia SSL para melhorar o desempenho.

allowPublicKeyRetrieval

true

Recupera a chave pública RSA do servidor durante a autenticação.

useServerPrepStmts

true

Habilita prepared statements no lado do servidor, aumentando o desempenho e reduzindo riscos de injeção de SQL.

useLocalSessionState

true

Usa o estado da sessão local para diminuir o número de idas e vindas ao servidor de banco de dados.

rewriteBatchedStatements

true

Reescreve chamadas de INSERT em lote como instruções de múltiplas linhas, melhorando significativamente a performance de escrita. Por exemplo, três inserções separadas são enviadas como uma única instrução: INSERT INTO t (a) VALUES (1), (2), (3) em vez de três chamadas individuais de INSERT INTO t (a) VALUES (?).

cachePrepStmts

true

Armazena prepared statements em cache no cliente, reduzindo a sobrecarga de criação para instruções executadas frequentemente.

prepStmtCacheSize

100

Define a quantidade de prepared statements mantidos em cache. Só tem efeito quando cachePrepStmts=true. Aumente este valor se sua carga de trabalho usar muitas instruções SQL distintas, lembrando que um cache maior consome mais memória.

prepStmtCacheSqlLimit

50000000

Define o tamanho máximo em bytes das instruções SQL elegíveis para cache. Instruções que excederem esse limite não serão armazenadas. Aumente este valor para cargas de trabalho sensíveis a desempenho que usem instruções SQL longas.

Etapa 3: Executar operações SQL

Após estabelecer a conexão, use o Lindorm SQL para criar tabelas, inserir, consultar e excluir dados:

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 a referência completa da sintaxe do Lindorm SQL, consulte Referência de SQL.

Observações de uso

Semântica de INSERT e UPSERT

No Lindorm SQL, o comando INSERT possui a mesma semântica do UPSERT. Como o cliente JDBC do MySQL otimiza instruções INSERT, use sempre INSERT para todas as gravações de dados.

Dimensionamento de escrita em lote

Escritas em lote reduzem a sobrecarga de chamadas de procedimento remoto (RPC) e permitem que o servidor processe múltiplas linhas por requisição, aumentando o throughput em comparação com escritas de linha única. No entanto, lotes excessivamente grandes podem causar erros de falta de memória (OOM) ou pausas prolongadas de coleta de lixo (Full GC), prejudicando a estabilidade do service. Mantenha o batchSize entre 50 e 100 linhas. Para elevar o throughput geral de escrita, aumente a concorrência de escrita em vez do tamanho do lote.

Próximos passos