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
Adicione a dependência do driver JDBC do MySQL ao seu projeto.
Inicialize o driver e estabeleça uma conexão usando uma URL JDBC que aponte para o endpoint compatível com MySQL do LindormTable.
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:
O recurso de compatibilidade com MySQL ativado na sua instância do Lindorm. Consulte Ativar o recurso de compatibilidade com MySQL
JDK 1.8 ou posterior instalado
O endereço IP do seu cliente adicionado à lista de permissões da instância do Lindorm. Consulte Configure uma lista de permissões
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'
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 |
|
|
A URL JDBC para acessar o LindormTable via MySQL. Formato: |
|
|
O banco de dados de destino. Se omitido, assume o banco de dados padrão. |
|
|
O nome de usuário para acesso ao LindormTable. Para redefinir uma senha esquecida, consulte Alterar a senha de um usuário. |
|
|
A senha correspondente ao usuário do LindormTable. |
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 |
|
|
|
Desativa a criptografia SSL para melhorar o desempenho. |
|
|
|
Recupera a chave pública RSA do servidor durante a autenticação. |
|
|
|
Habilita prepared statements no lado do servidor, aumentando o desempenho e reduzindo riscos de injeção de SQL. |
|
|
|
Usa o estado da sessão local para diminuir o número de idas e vindas ao servidor de banco de dados. |
|
|
|
Reescreve chamadas de |
|
|
|
Armazena prepared statements em cache no cliente, reduzindo a sobrecarga de criação para instruções executadas frequentemente. |
|
|
|
Define a quantidade de prepared statements mantidos em cache. Só tem efeito quando |
|
|
|
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
Referência de SQL — sintaxe completa do Lindorm SQL
Visualize endpoints — localize seu endpoint compatível com MySQL
Configure uma lista de permissões — gerencie o controle de acesso por IP