vertx-mysql-client/java/

其他 2019-12-13 08:34:12 阅读次数: 0

Reactive MySQL Client是MySQL的客户端，它具有直接的API，专注于可伸缩性和低开销。

特征

  • 事件驱动

  • 轻巧的

  • 内置连接池

  • 准备查询缓存

  • 游标支持

  • 行流

  • RxJava 1和RxJava 2

  • 直接存储到对象，没有不必要的副本

  • Java 8日期和时间

  • 存储过程支持

  • TLS / SSL支持

  • MySQL实用程序命令支持

  • 使用MySQL和MariaDB

  • 丰富的排序规则和字符集支持

用法

要使用反应性MySQL客户端，请将以下依赖项添加到构建描述符的“ 依赖项”部分：

  • Maven（在您的中pom.xml）：

<dependency>
 <groupId>io.vertx</groupId>
 <artifactId>vertx-mysql-client</artifactId> <version>3.8.4</version> </dependency>

  • Gradle（在您的build.gradle文件中）：

dependencies {
 compile 'io.vertx:vertx-mysql-client:3.8.4' }

入门

这是连接，查询和断开连接的最简单方法

MySQLConnectOptions connectOptions = new MySQLConnectOptions()
  .setPort(3306) .setHost("the-host") .setDatabase("the-db") .setUser("user") .setPassword("secret"); // Pool options PoolOptions poolOptions = new PoolOptions() .setMaxSize(5); // Create the client pool MySQLPool client = MySQLPool.pool(connectOptions, poolOptions); // A simple query client.query("SELECT * FROM users WHERE id='julien'", ar -> { if (ar.succeeded()) { RowSet<Row> result = ar.result(); System.out.println("Got " + result.size() + " rows "); } else { System.out.println("Failure: " + ar.cause().getMessage()); } // Now close the pool client.close(); });

连接到MySQL

大多数时候，您将使用池连接到MySQL：

MySQLConnectOptions connectOptions = new MySQLConnectOptions()
  .setPort(3306) .setHost("the-host") .setDatabase("the-db") .setUser("user") .setPassword("secret"); // Pool options PoolOptions poolOptions = new PoolOptions() .setMaxSize(5); // Create the pooled client MySQLPool client = MySQLPool.pool(connectOptions, poolOptions);

池化的客户端使用连接池，任何操作都将从池中借用连接以执行该操作并将其释放到池中。

如果使用Vert.x运行，则可以将其传递给您的Vertx实例：

MySQLConnectOptions connectOptions = new MySQLConnectOptions()
  .setPort(3306) .setHost("the-host") .setDatabase("the-db") .setUser("user") .setPassword("secret"); // Pool options PoolOptions poolOptions = new PoolOptions() .setMaxSize(5); // Create the pooled client MySQLPool client = MySQLPool.pool(vertx, connectOptions, poolOptions);

当您不再需要池时，您需要释放它：

pool.close();

当您需要在同一连接上执行多个操作时，需要使用一个client connection。

您可以轻松地从游泳池中获得一个：

MySQLConnectOptions connectOptions = new MySQLConnectOptions()
  .setPort(3306) .setHost("the-host") .setDatabase("the-db") .setUser("user") .setPassword("secret"); // Pool options PoolOptions poolOptions = new PoolOptions() .setMaxSize(5); // Create the pooled client MySQLPool client = MySQLPool.pool(vertx, connectOptions, poolOptions); // Get a connection from the pool client.getConnection(ar1 -> { if (ar1.succeeded()) { System.out.println("Connected"); // Obtain our connection SqlConnection conn = ar1.result(); // All operations execute on the same connection conn.query("SELECT * FROM users WHERE id='julien'", ar2 -> { if (ar2.succeeded()) { conn.query("SELECT * FROM users WHERE id='emad'", ar3 -> { // Release the connection to the pool conn.close(); }); } else { // Release the connection to the pool conn.close(); } }); } else { System.out.println("Could not connect: " + ar1.cause().getMessage()); } });

完成连接后，必须关闭它才能将其释放到池中，以便可以重用它。

组态

您可以通过多种方法来配置客户端。

数据对象

配置客户端的一种简单方法是指定MySQLConnectOptions数据对象。

MySQLConnectOptions connectOptions = new MySQLConnectOptions()
  .setPort(3306) .setHost("the-host") .setDatabase("the-db") .setUser("user") .setPassword("secret"); // Pool Options PoolOptions poolOptions = new PoolOptions().setMaxSize(5); // Create the pool from the data object MySQLPool pool = MySQLPool.pool(vertx, connectOptions, poolOptions); pool.getConnection(ar -> { // Handling your connection });

排序规则和字符集

Reactive MySQL客户端支持配置排序规则或字符集，并将它们映射到相关的java.nio.charset.Charset。例如，您可以为类似的连接指定字符集

MySQLConnectOptions connectOptions = new MySQLConnectOptions();

// set connection character set to utf8 instead of the default charset utf8mb4 connectOptions.setCharset("utf8");

您也可以为连接指定排序规则，例如

MySQLConnectOptions connectOptions = new MySQLConnectOptions();

// set connection collation to utf8_general_ci instead of the default collation utf8mb4_general_ci // setting a collation will override the charset option connectOptions.setCharset("gbk"); connectOptions.setCollation("utf8_general_ci");

MySQL将utf8mb4作为默认字符集。请注意，在数据对象上设置排序规则将覆盖charset选项。

您可以执行SQL SHOW COLLATION;或SHOW CHARACTER SET;获取受支持的排序规则和字符集。

有关MySQL字符集和排序规则的更多信息，请参见《MySQL参考手册》。

连接属性

您也可以使用setProperties或addProperty方法配置连接属性。注意setProperties将覆盖默认的客户端属性。

MySQLConnectOptions connectOptions = new MySQLConnectOptions();

// Add a connection attribute
connectOptions.addProperty("_java_version", "1.8.0_212"); // Override the attributes Map<String, String> attributes = new HashMap<>(); attributes.put("_client_name", "myapp"); attributes.put("_client_version", "1.0.0"); connectOptions.setProperties(attributes);

有关客户端连接属性的更多信息，请参见《MySQL参考手册》。

useAffectedRows

您可以配置useAffectedRows选项，以决定CLIENT_FOUND_ROWS在连接到服务器时是否设置标志。如果CLIENT_FOUND_ROWS指定了标志，则受影响的行数是找到的而不是受影响的行的数值。

有关更多信息，请参见《MySQL参考手册》。

连接URI

除了使用MySQLConnectOptions数据对象进行配置之外，当您要使用连接URI进行配置时，我们还为您提供了另一种连接方法：

String connectionUri = "mysql://dbuser:[email protected]:3211/mydb"; // Create the pool from the connection URI MySQLPool pool = MySQLPool.pool(connectionUri); // Create the connection from the connection URI MySQLConnection.connect(vertx, connectionUri, res -> { // Handling your connection });

有关连接字符串格式的更多信息，请参见《MySQL参考手册》。

当前客户端在连接uri中支持以下参数关键字（关键字不区分大小写）

  • 主办

  • 港口

  • 用户

  • 密码

  • 图式

  • 插座

  • useAffectedRows

运行查询

当您不需要事务或运行单个查询时，可以直接在池上运行查询。池将使用其连接之一来运行查询并将结果返回给您。

这是运行简单查询的方法：

client.query("SELECT * FROM users WHERE id='julien'", ar -> { if (ar.succeeded()) { RowSet<Row> result = ar.result(); System.out.println("Got " + result.size() + " rows "); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

准备好的查询

您可以对准备好的查询执行相同的操作。

SQL字符串可以使用数据库语法“？”按位置引用参数。

client.preparedQuery("SELECT * FROM users WHERE id=?", Tuple.of("julien"), ar -> { if (ar.succeeded()) { RowSet<Row> rows = ar.result(); System.out.println("Got " + rows.size() + " rows "); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

查询方法提供了一个RowSet适用于SELECT查询的异步实例

client.preparedQuery("SELECT first_name, last_name FROM users", ar -> { if (ar.succeeded()) { RowSet<Row> rows = ar.result(); for (Row row : rows) { System.out.println("User " + row.getString(0) + " " + row.getString(1)); } } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

或UPDATE / INSERT查询：

client.preparedQuery("INSERT INTO users (first_name, last_name) VALUES (?, ?)", Tuple.of("Julien", "Viet"), ar -> { if (ar.succeeded()) { RowSet<Row> rows = ar.result(); System.out.println(rows.rowCount()); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

可Row让您按索引访问数据

System.out.println("User " + row.getString(0) + " " + row.getString(1));

或按名称

System.out.println("User " + row.getString("first_name") + " " + row.getString("last_name"));

客户端不会在这里做任何魔术，并且无论您的SQL文本如何，列名都将用表中的名称标识。

您可以访问多种类型

String firstName = row.getString("first_name"); Boolean male = row.getBoolean("male"); Integer age = row.getInteger("age");

您可以缓存准备好的查询：

connectOptions.setCachePreparedStatements(true);

分批

您可以执行准备好的批处理

List<Tuple> batch = new ArrayList<>(); batch.add(Tuple.of("julien", "Julien Viet")); batch.add(Tuple.of("emad", "Emad Alblueshi")); // Execute the prepared batch client.preparedBatch("INSERT INTO USERS (id, name) VALUES (?, ?)", batch, res -> { if (res.succeeded()) { // Process rows RowSet<Row> rows = res.result(); } else { System.out.println("Batch failed " + res.cause()); } });

MySQL LAST_INSERT_ID

如果在表中插入一条记录，则可以获得自动递增的值。

client.query("INSERT INTO test(val) VALUES ('v1')", ar -> { if (ar.succeeded()) { RowSet<Row> rows = ar.result(); int lastInsertId = rows.property(MySQLClient.LAST_INSERTED_ID); System.out.println("Last inserted id is: " + lastInsertId); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

有关更多信息，请参见如何获取最后插入行的唯一ID。

使用连接

当需要执行顺序查询（不执行事务）时，可以创建一个新连接或从池中借用一个：

pool.getConnection(ar1 -> {
  if (ar1.succeeded()) {
    SqlConnection connection = ar1.result();

    connection.query("SELECT * FROM users WHERE id='julien'", ar2 -> { if (ar1.succeeded()) { connection.query("SELECT * FROM users WHERE id='paulo'", ar3 -> { // Do something with rows and return the connection to the pool connection.close(); }); } else { // Return the connection to the pool connection.close(); } }); } });

可以创建准备好的查询：

connection.prepare("SELECT * FROM users WHERE first_name LIKE ?", ar1 -> { if (ar1.succeeded()) { PreparedQuery pq = ar1.result(); pq.execute(Tuple.of("julien"), ar2 -> { if (ar2.succeeded()) { // All rows RowSet<Row> rows = ar2.result(); } }); } });
注意
准备好的查询缓存取决于，setCachePreparedStatements而不取决于您是创建准备好的查询还是使用direct prepared queries

PreparedQuery 可以执行有效的批处理：

connection.prepare("INSERT INTO USERS (id, name) VALUES (?, ?)", ar1 -> { if (ar1.succeeded()) { PreparedQuery prepared = ar1.result(); // Create a query : bind parameters List<Tuple> batch = new ArrayList(); // Add commands to the createBatch batch.add(Tuple.of("julien", "Julien Viet")); batch.add(Tuple.of("emad", "Emad Alblueshi")); prepared.batch(batch, res -> { if (res.succeeded()) { // Process rows RowSet<Row> rows = res.result(); } else { System.out.println("Batch failed " + res.cause()); } }); } });

使用交易

连接交易

您可以使用SQL BEGIN/ COMMIT/ 执行事务ROLLBACK，如果这样做，则必须使用SqlConnection和自己进行管理。

或者，您可以使用的交易API SqlConnection：

pool.getConnection(res -> {
  if (res.succeeded()) {

    // Transaction must use a connection
    SqlConnection conn = res.result(); // Begin the transaction Transaction tx = conn.begin(); // Various statements conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')", ar1 -> { if (ar1.succeeded()) { conn.query("INSERT INTO Users (first_name,last_name) VALUES ('Emad','Alblueshi')", ar2 -> { if (ar2.succeeded()) { // Commit the transaction tx.commit(ar3 -> { if (ar3.succeeded()) { System.out.println("Transaction succeeded"); } else { System.out.println("Transaction failed " + ar3.cause().getMessage()); } // Return the connection to the pool conn.close(); }); } else { // Return the connection to the pool conn.close(); } }); } else { // Return the connection to the pool conn.close(); } }); } });

当PostgreSQL报告当前事务失败时（例如，臭名昭著的当前事务被中止，命令被忽略直到事务块结束），事务被回滚并被abortHandler 调用：

tx.abortHandler(v -> {
  System.out.println("Transaction failed => rollbacked"); });

简化的交易API

使用池时，可以直接在池上启动事务。

它从池中借用连接，开始事务，并在事务结束时释放与池的连接。

pool.begin(res -> {
  if (res.succeeded()) {

    // Get the transaction
    Transaction tx = res.result(); // Various statements tx.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')", ar1 -> { if (ar1.succeeded()) { tx.query("INSERT INTO Users (first_name,last_name) VALUES ('Emad','Alblueshi')", ar2 -> { if (ar2.succeeded()) { // Commit the transaction // the connection will automatically return to the pool tx.commit(ar3 -> { if (ar3.succeeded()) { System.out.println("Transaction succeeded"); } else { System.out.println("Transaction failed " + ar3.cause().getMessage()); } }); } }); } else { // No need to close connection as transaction will abort and be returned to the pool } }); } });
注意
此代码不会关闭连接，因为在事务处理时它将始终释放回池中

游标和流

默认情况下，准备好的查询执行会提取所有行，您可以使用 Cursor来控制要读取的行数：

connection.prepare("SELECT * FROM users WHERE age > ?", ar1 -> { if (ar1.succeeded()) { PreparedQuery pq = ar1.result(); // Create a cursor Cursor cursor = pq.cursor(Tuple.of(18)); // Read 50 rows cursor.read(50, ar2 -> { if (ar2.succeeded()) { RowSet<Row> rows = ar2.result(); // Check for more ? if (cursor.hasMore()) { // Repeat the process... } else { // No more rows - close the cursor cursor.close(); } } }); } });

游标过早释放时应将其关闭：

cursor.read(50, ar2 -> {
  if (ar2.succeeded()) {
    // Close the cursor cursor.close(); } });

还可以为游标提供流API，这会更加方便，特别是对于Rxified版本而言。

connection.prepare("SELECT * FROM users WHERE age > ?", ar1 -> { if (ar1.succeeded()) { PreparedQuery pq = ar1.result(); // Fetch 50 rows at a time RowStream<Row> stream = pq.createStream(50, Tuple.of(18)); // Use the stream stream.exceptionHandler(err -> { System.out.println("Error: " + err.getMessage()); }); stream.endHandler(v -> { System.out.println("End of stream"); }); stream.handler(row -> { System.out.println("User: " + row.getString("last_name")); }); } });

流将批量读取行50并将其流化，将行传递到处理程序后，将50读取新一批，依此类推。

可以恢复或暂停该流，已加载的行将保留在内存中，直到被传递为止，并且游标将停止迭代。

MySQL类型映射

当前客户端支持以下MySQL类型

  • BOOL，BOOLEAN（java.lang.Byte）

  • 忍者（java.lang.Byte）

  • SMALLINT（java.lang.Short）

  • MEDIUMINT（java.lang.Integer）

  • INT，INTEGER（java.lang.Integer）

  • 币种（java.lang.Long）

  • 浮标（java.lang.Float）

  • 双（java.lang.Double）

  • 数值（io.vertx.sqlclient.data.Numeric）

  • 日期（java.time.LocalDate）

  • DATETIME（java.time.LocalDateTime）

  • 时间（java.time.Duration）

  • 时间戳（java.time.LocalDateTime）

  • 年（java.lang.Short）

  • 字符（java.lang.String）

  • VARCHAR（java.lang.String）

  • 二进制（io.vertx.core.buffer.Buffer）

  • VARBINARY（io.vertx.core.buffer.Buffer）

  • 天黑宝（io.vertx.core.buffer.Buffer）

  • TINYTEXT（java.lang.String）

  • BLOB（io.vertx.core.buffer.Buffer）

  • 文字（java.lang.String）

  • 中号（io.vertx.core.buffer.Buffer）

  • MEDIUMTEXT（java.lang.String）

  • LONGBLOB（io.vertx.core.buffer.Buffer）

  • 长文本（java.lang.String）

  • 枚举（java.lang.String）

  • 设定（java.lang.String）

  • JSON（ ，io.vertx.core.json.JsonObject，io.vertx.core.json.JsonArray，Number，Boolean，）Stringio.vertx.sqlclient.Tuple#JSON_NULL

存储值时，元组解码使用上述类型

处理布尔

在MySQL中BOOLEAN，BOOL数据类型是的同义词TINYINT(1)。零值视为假，非零值视为真。一个BOOLEAN数据类型值存储在Row或Tuple作为java.lang.Byte类型，你可以调用Row#getValue来检索它的java.lang.Byte值，或者可以称之为Row#getBoolean检索它java.lang.Boolean的价值。

client.query("SELECT graduated FROM students WHERE id = 0", ar -> { if (ar.succeeded()) { RowSet<Row> rowSet = ar.result(); for (Row row : rowSet) { int pos = row.getColumnIndex("graduated"); Byte value = row.get(Byte.class, pos); Boolean graduated = row.getBoolean("graduated"); } } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

当您要使用参数BOOLEAN值执行准备好的语句时，只需将java.lang.Boolean值添加到参数列表中即可。

client.preparedQuery("UPDATE students SET graduated = ? WHERE id = 0", Tuple.of(true), ar -> { if (ar.succeeded()) { System.out.println("Updated with the boolean value"); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

处理JSON

MySQL JSON数据类型由以下Java类型表示：

  • String

  • Number

  • Boolean

  • io.vertx.core.json.JsonObject

  • io.vertx.core.json.JsonArray

  • io.vertx.sqlclient.Tuple#JSON_NULL 用于表示JSON空文字

Tuple tuple = Tuple.of(
  Tuple.JSON_NULL,
  new JsonObject().put("foo", "bar"), 3); // Retrieving json Object value = tuple.getValue(0); // Expect JSON_NULL // value = tuple.get(JsonObject.class, 1); // Expect JSON object // value = tuple.get(Integer.class, 2); // Expect 3 value = tuple.getInteger(2); // Expect 3

处理NUMERIC

该NumericJava类型用于表示MySQL的NUMERIC类型。

Numeric numeric = row.get(Numeric.class, 0); if (numeric.isNaN()) { // Handle NaN } else { BigDecimal value = numeric.bigDecimalValue(); }

收集器查询

您可以将Java收集器与查询API结合使用：

Collector<Row, ?, Map<Long, String>> collector = Collectors.toMap( row -> row.getLong("id"), row -> row.getString("last_name")); // Run the query with the collector client.query("SELECT * FROM users", collector, ar -> { if (ar.succeeded()) { SqlResult<Map<Long, String>> result = ar.result(); // Get the map created by the collector Map<Long, String> map = result.value(); System.out.println("Got " + map); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

收集器处理不得保留引用，Row因为只有一行用于处理整个集合。

Java Collectors提供了许多有趣的预定义收集器，例如，您可以直接从行集中轻松创建一个字符串：

Collector<Row, ?, String> collector = Collectors.mapping(
  row -> row.getString("last_name"), Collectors.joining(",", "(", ")") ); // Run the query with the collector client.query("SELECT * FROM users", collector, ar -> { if (ar.succeeded()) { SqlResult<String> result = ar.result(); // Get the string created by the collector String list = result.value(); System.out.println("Got " + list); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

MySQL存储过程

您可以在查询中运行存储过程。结果将按照MySQL协议从服务器检索，这里没有任何魔术。

client.query("CREATE PROCEDURE multi() BEGIN\n" + " SELECT 1;\n" + " SELECT 1;\n" + " INSERT INTO ins VALUES (1);\n" + " INSERT INTO ins VALUES (2);\n" + "END;", ar1 -> { if (ar1.succeeded()) { // create stored procedure success client.query("CALL multi();", ar2 -> { if (ar2.succeeded()) { // handle the result RowSet<Row> result1 = ar2.result(); Row row1 = result1.iterator().next(); System.out.println("First result: " + row1.getInteger(0)); RowSet<Row> result2 = result1.next(); Row row2 = result2.iterator().next(); System.out.println("Second result: " + row2.getInteger(0)); RowSet<Row> result3 = result2.next(); System.out.println("Affected rows: " + result3.rowCount()); } else { System.out.println("Failure: " + ar2.cause().getMessage()); } }); } else { System.out.println("Failure: " + ar1.cause().getMessage()); } });

注意：暂时不支持绑定OUT参数的预准备语句。

MySQL的本地文件

该客户端支持处理LOCAL INFILE请求，如果要将数据从本地文件加载到服务器中，则可以使用query LOAD DATA LOCAL INFILE '<filename>' INTO TABLE <table>;。更多信息可以在MySQL参考手册中找到。

认证方式

MySQL 8.0引入了一种新的身份验证方法caching_sha2_password，它是默认的身份验证方法。为了使用这种新的身份验证方法连接到服务器，您需要使用安全连接（即启用TLS / SSL）或使用RSA密钥对交换加密的密码，以避免密码泄漏。RSA密钥对在通信过程中会自动交换，但是服务器RSA公钥在此过程中可能会遭到黑客入侵，因为它是通过不安全的连接传输的。因此，如果您的连接不安全，并且希望避免暴露服务器RSA公钥的风险，则可以如下设置服务器RSA公钥：

MySQLConnectOptions options1 = new MySQLConnectOptions()
  .setPort(3306) .setHost("the-host") .setDatabase("the-db") .setUser("user") .setPassword("secret") .setServerRsaPublicKeyPath("tls/files/public_key.pem"); // configure with path of the public key MySQLConnectOptions options2 = new MySQLConnectOptions() .setPort(3306) .setHost("the-host") .setDatabase("the-db") .setUser("user") .setPassword("secret") .setServerRsaPublicKeyValue(Buffer.buffer("-----BEGIN PUBLIC KEY-----\n" + "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3yvG5s0qrV7jxVlp0sMj\n" + "xP0a6BuLKCMjb0o88hDsJ3xz7PpHNKazuEAfPxiRFVAV3edqfSiXoQw+lJf4haEG\n" + "HQe12Nfhs+UhcAeTKXRlZP/JNmI+BGoBduQ1rCId9bKYbXn4pvyS/a1ft7SwFkhx\n" + "aogCur7iIB0WUWvwkQ0fEj/Mlhw93lLVyx7hcGFq4FOAKFYr3A0xrHP1IdgnD8QZ\n" + "0fUbgGLWWLOossKrbUP5HWko1ghLPIbfmU6o890oj1ZWQewj1Rs9Er92/UDj/JXx\n" + "7ha1P+ZOgPBlV037KDQMS6cUh9vTablEHsMLhDZanymXzzjBkL+wH/b9cdL16LkQ\n" + "5QIDAQAB\n" + "-----END PUBLIC KEY-----\n")); // configure with buffer of the public key

有关caching_sha2_password身份验证方法的更多信息，请参见《MySQL参考手册》。

使用SSL / TLS

要配置客户端以使用SSL连接，您可以MySQLConnectOptions 像Vert.x这样进行配置NetClient。支持所有SSL模式，您可以进行配置sslmode。DISABLED默认情况下，客户端处于SSL模式。 ssl参数只是设置的捷径sslmode。setSsl(true)等同于setSslMode(VERIFY_CA)并setSsl(false)等同于setSslMode(DISABLED)。

MySQLConnectOptions options = new MySQLConnectOptions()
  .setPort(3306) .setHost("the-host") .setDatabase("the-db") .setUser("user") .setPassword("secret") .setSslMode(SslMode.VERIFY_CA) .setPemTrustOptions(new PemTrustOptions().addCertPath("/path/to/cert.pem")); MySQLConnection.connect(vertx, options, res -> { if (res.succeeded()) { // Connected with SSL } else { System.out.println("Could not connect " + res.cause()); } });

可以在Vert.x文档中找到更多信息。

MySQL实用程序命令

有时您想使用MySQL实用程序命令，我们为此提供支持。可以在MySQL实用程序命令中找到更多信息。

COM_PING

您可以使用COM_PING命令来检查服务器是否处于活动状态。如果服务器响应PING，则将通知处理程序，否则将永远不会调用该处理程序。

connection.ping(ar -> {
  System.out.println("The server has responded to the PING"); });

COM_RESET_CONNECTION

您可以使用COM_RESET_CONNECTION命令重置会话状态，这将重置连接状态，例如：-用户变量-临时表-准备好的语句

connection.resetConnection(ar -> {
  if (ar.succeeded()) {
    System.out.println("Connection has been reset now"); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

COM_CHANGE_USER

您可以更改当前连接的用户，这将执行重新认证并重置连接状态，如COM_RESET_CONNECTION。

MySQLAuthOptions authenticationOptions = new MySQLAuthOptions()
  .setUser("newuser") .setPassword("newpassword") .setDatabase("newdatabase"); connection.changeUser(authenticationOptions, ar -> { if (ar.succeeded()) { System.out.println("User of current connection has been changed."); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

COM_INIT_DB

您可以使用COM_INIT_DB命令更改连接的默认架构。

connection.specifySchema("newschema", ar -> { if (ar.succeeded()) { System.out.println("Default schema changed to newschema"); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

COM_STATISTICS

您可以使用COM_STATISTICS命令获取MySQL服务器中某些内部状态变量的可读字符串。

connection.getInternalStatistics(ar -> {
  if (ar.succeeded()) {
    System.out.println("Statistics: " + ar.result()); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

COM_DEBUG

您可以使用COM_DEBUG命令将调试信息转储到MySQL服务器的STDOUT。

connection.debug(ar -> {
  if (ar.succeeded()) {
    System.out.println("Debug info dumped to server's STDOUT"); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

COM_SET_OPTION

您可以使用COM_SET_OPTION命令设置当前连接的选项。目前只能CLIENT_MULTI_STATEMENTS设置。

例如，您可以CLIENT_MULTI_STATEMENTS使用此命令禁用。

connection.setOption(MySQLSetOption.MYSQL_OPTION_MULTI_STATEMENTS_OFF, ar -> {
  if (ar.succeeded()) {
    System.out.println("CLIENT_MULTI_STATEMENTS is off now"); } else { System.out.println("Failure: " + ar.cause().getMessage()); } });

MySQL和MariaDB版本支持表

的MySQL 玛丽亚数据库

版

支持的

版

支持的

5.5

✔

10.1

✔

5.6

✔

10.2

✔

5.7

✔

10.3

✔

8.0

✔

10.4

✔

已知的问题：

  • 重置连接实用程序命令在MySQL 5.5、5.6和MariaDB 10.1中不起作用

  • MariaDB 10.2和10.3不支持更改用户实用程序命令

猜你喜欢

转载自www.cnblogs.com/endv/p/12032889.html
今日推荐
NetBSD 禁止提交由 AI 生成的代码
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
周排行
女程序员是这样被恶搞的
B/S 和 C/S 的优缺点
vector一直申请会怎样？
座头鲸识别比赛(Humpback Whale Identification)总结
Linux高性能服务器编程——I/O复用 select
Mysql连接数据库（当包使用）
通过URI获取的文件路径为null的解决方法
1022-Primes on Interval(素数筛选+二分查找) ZCMU
Python出现： TypeError: expected string or buffer
bzoj2434: [Noi2011]阿狸的打字机 ac自动机+树状数组
每日归档
更多
2024-05-18(4)
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022