ShardingJDBC底层项目实战：新手入门教程

概述

本文详细介绍了ShardingJDBC底层项目实战，包括基础环境搭建、核心概念详解、简单实战案例以及常见问题与解决方法。通过丰富的配置和示例代码，帮助开发者理解和应用ShardingJDBC的分片功能。文章还涵盖了性能优化技巧和项目部署与维护的要点，旨在帮助读者全面掌握ShardingJDBC底层项目实战。

ShardingJDBC简介

ShardingJDBC的基本概念

ShardingJDBC 是一款开源的分布式数据库中间件，主要功能包括分布式数据库的分片、读写分离、分布式事务和数据治理等。它支持多种数据库类型，如 MySQL、SQL Server、PostgreSQL、Oracle 等，并且可以在 Java 应用中通过 JDBC 驱动的方式进行使用。

ShardingJDBC 的核心特点是：

• 透明分片：对于应用开发者来说，使用 ShardingJDBC 像使用单一数据库一样简单。ShardingJDBC 会在 SQL 层面自动进行分片，将分片逻辑封装在中间件内部。
• SQL 解析：ShardingJDBC 可以解析 SQL 语句，根据分片策略将 SQL 语句分解为针对多个数据库的分片 SQL 语句。
• 动态分片：支持动态增加或减少数据库实例，无需修改应用代码。
• 轻量级：不依赖任何额外的数据库服务器，仅通过配置可以实现高度可扩展的分布式数据库方案。

ShardingJDBC的功能特点

ShardingJDBC 提供了丰富的功能特性，包括：

• 分片：支持水平分片和垂直分片，可以按照不同的维度对数据进行分片。
• 读写分离：支持将读操作和写操作分离到不同的数据库实例上，提高系统的并发性能。
• 分布式事务：提供分布式事务支持，确保多个数据库之间的数据一致性。
• SQL 解析：能够解析复杂的 SQL 语句，并根据分片策略执行相应的操作。
• 数据治理：支持数据的报警、监控、迁移等功能。

ShardingJDBC与传统数据库分片技术的区别

ShardingJDBC 的优势在于其透明的分片逻辑，和传统的数据库分片技术相比，ShardingJDBC 无需修改应用代码即可实现分片，极大地降低了开发和维护成本。传统数据库分片技术通常需要在应用代码中直接处理分片逻辑，增加了开发和运维的复杂性。

概念对比

• 传统数据库分片：通常需要在应用代码中手动实现分片逻辑，比如通过轮询或哈希计算等算法将数据分布到不同的数据库实例上。
• ShardingJDBC：提供了一层中间件，自动处理分片逻辑，应用代码只需专注于业务逻辑即可。

ShardingJDBC的基础环境搭建

开发环境准备

在开始使用 ShardingJDBC 之前，需要准备开发环境：

• 操作系统：Windows、Linux、macOS 等
• Java 版本：JDK 1.8 或更高版本
• IDE：Eclipse、IntelliJ IDEA、STS 等
• 数据库：MySQL、PostgreSQL、SQL Server 等
• 构建工具：Maven 或 Gradle

安装 JDK

首先，确保已安装并配置好 JDK。可以通过以下命令检查 JDK 版本：

java -version

如果未安装 JDK，可从官网下载并安装。

安装数据库

安装 MySQL 数据库：

sudo apt-get update
sudo apt-get install mysql-server

启动 MySQL 服务：

sudo service mysql start

创建数据库和表

在 MySQL 中创建数据库和表：

CREATE DATABASE sharding_db;
USE sharding_db;

CREATE TABLE t_order (
  id INT PRIMARY KEY,
  user_id INT,
  status VARCHAR(20),
  address VARCHAR(255)
);

ShardingJDBC的下载与安装

ShardingJDBC 是一个纯 Java 实现的库，不需要单独安装，只需将 ShardingJDBC 的 jar 包添加到项目的依赖中。

下载 ShardingJDBC

ShardingJDBC 的官方仓库地址为 https://github.com/apache/sharding-jdbc。可以从仓库中下载最新的版本，或者直接使用 Maven 或 Gradle 依赖管理工具进行引入。

添加 Maven 依赖

在项目的 pom.xml 文件中添加 ShardingJDBC 依赖：

<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
    <version>4.1.1</version>
</dependency>

添加 Gradle 依赖

在项目的 build.gradle 文件中添加 ShardingJDBC 依赖：

dependencies {
    implementation 'org.apache.shardingsphere:sharding-jdbc-spring-boot-starter:4.1.1'
}

创建项目并引入ShardingJDBC依赖

使用 Spring Boot 创建一个新的项目，并将 ShardingJDBC 依赖引入到项目中。

创建 Spring Boot 项目

使用 Spring Initializr 创建一个新的 Spring Boot 项目，并引入 ShardingJDBC 依赖。

1. 访问 https://start.spring.io
2. 选择 Maven 项目
3. 选择 Java 语言和 Spring Boot 版本
4. 在 Dependencies 中添加 Spring Web 和 Sharding-JDBC
5. 下载并解压项目文件

配置 Spring Boot 项目

在项目的主类中添加 @SpringBootApplication 注解，并在 application.yml 或 application.properties 文件中配置数据库和 ShardingJDBC 的配置。

spring:
  application:
   name: sharding-example
  datasource:
    test1:
      url: jdbc:mysql://localhost:3306/sharding_db1?serverTimezone=UTC
      username: root
      password: root
    test2:
      url: jdbc:mysql://localhost:3306/sharding_db2?serverTimezone=UTC
      username: root
      password: root
sharding:
  default-data-source-name: test1
  tables:
    t_order:
      actual-data-nodes: test$->{0..1}.t_order
      table-strategy:
        standard:
          sharding-column: user_id
          sharding-algorithm-name: mod-flat-sharding-algorithm
  sharding-algorithms:
    mod-flat-sharding-algorithm:
      type: MOD
      props:
        sharding-count: 2

运行项目

通过命令行或 IDE 运行 Spring Boot 应用程序：

mvn spring-boot:run

ShardingJDBC的核心概念详解

数据分片规则

数据分片规则是 ShardingJDBC 的核心概念之一，用于定义如何将数据分布在不同的数据库实例中。数据分片规则主要包括水平分片和垂直分片。

水平分片

水平分片是指将数据按照一定的规则拆分成多个子集，并将这些子集分布在不同的数据库实例上。例如，可以将用户订单数据按用户 ID 进行水平分片，每个用户 ID 对应一个分片数据库。

sharding:
  tables:
    t_order:
      actual-data-nodes: test$->{0..1}.t_order

垂直分片

垂直分片是指将不同的表分布在不同的数据库实例上。例如，可以将用户信息表和订单信息表分别存储在不同的数据库中。

sharding:
  tables:
    t_user:
      actual-data-nodes: test$->{0..1}.t_user
    t_order:
      actual-data-nodes: test$->{0..1}.t_order

分片键

分片键是指用于分片的字段，例如用户 ID 或订单 ID。通过分片键，ShardingJDBC 可以确定数据应该存储在哪个分片数据库上。

sharding:
  tables:
    t_order:
      actual-data-nodes: test$->{0..1}.t_order
      table-strategy:
        standard:
          sharding-column: user_id
          sharding-algorithm-name: mod-flat-sharding-algorithm

SQL解析与执行流程

ShardingJDBC 对 SQL 语句进行解析和执行的过程主要包括以下几个步骤：

1. SQL 解析：ShardingJDBC 会解析 SQL 语句，确定 SQL 语句的类型（例如 SELECT、INSERT、UPDATE、DELETE）。
2. 分片策略应用：根据配置的分片策略，确定数据应该存储在哪个分片数据库上。
3. SQL 重写：根据分片策略重写 SQL 语句，生成针对具体分片数据库的 SQL 语句。
4. SQL 执行：执行重写后的 SQL 语句，并返回结果。
5. 结果合并：如果 SQL 语句涉及多个分片数据库，ShardingJDBC 会合并各个分片数据库的结果。

示例代码

示例代码展示了如何使用 ShardingJDBC 执行 SQL 语句：

import org.apache.shardingsphere.api.ShardingSphere;
import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.KeyGeneratorConfiguration;
import org.apache.shardingsphere.api.config.sharding.strategy.StandardShardingStrategyConfiguration;
import org.apache.shardingsphere.shardingjdbc.api.config.ShardingJdbcDataSourceFactory;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;

public class ShardingJDBCDemo {
    public static void main(String[] args) {
        // 配置分片规则
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration("t_order", "sharding_db$->{0..1}.t_order");
        orderTableRuleConfig.setKeyGeneratorConfig(new KeyGeneratorConfiguration("SNOWFLAKE", "order_id"));
        orderTableRuleConfig.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("user_id", "mod-flat-sharding-algorithm"));
        shardingRuleConfig.getTables().add(orderTableRuleConfig);

        // 创建数据源
        Properties props = new Properties();
        props.setProperty("sql.show", "true");
        Connection dataSource = ShardingJdbcDataSourceFactory.createDataSource(shardingRuleConfig, props);

        try {
            Statement stmt = dataSource.createStatement();
            stmt.executeUpdate("INSERT INTO t_order (user_id, status, address) VALUES (1, 'PAID', 'Beijing')");
            ResultSet rs = stmt.executeQuery("SELECT * FROM t_order WHERE user_id = 1");
            while (rs.next()) {
                System.out.println(rs.getInt("order_id") + "\t" + rs.getString("status"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

读写分离原理

读写分离是指将读操作和写操作分离到不同的数据库实例上，提高系统的并发性能。ShardingJDBC 支持通过配置主从数据库来实现读写分离。

配置主从数据库

在 ShardingJDBC 的配置文件中，可以定义主数据库和从数据库的信息，并指定读写分离策略。

sharding:
  master-slave-rules:
    ms_ds:
      master-data-source-name: ds
      slave-data-sources:
        - slave-0
        - slave-1
      load-balance-algorithm-name: round-robin

读写分离策略

ShardingJDBC 支持多种读写分离策略，包括轮询、随机选择等。

sharding:
  master-slave-rules:
    ms_ds:
      master-data-source-name: ds
      slave-data-sources:
        - slave-0
        - slave-1
      load-balance-algorithm-name: round-robin

SQL 执行流程

当执行 SQL 语句时，ShardingJDBC 会根据读写分离配置自动选择合适的数据库实例执行。

1. 写操作：写操作将发送到主数据库。
2. 读操作：读操作将发送到从数据库，根据配置的负载均衡策略选择合适的从数据库执行。

ShardingJDBC的简单实战

数据库分片配置

在 ShardingJDBC 的配置文件中，可以定义数据库分片的规则。例如，可以配置水平分片和垂直分片。

水平分片配置

水平分片配置示例：

sharding:
  tables:
    t_order:
      actual-data-nodes: test$->{0..1}.t_order
      table-strategy:
        standard:
          sharding-column: user_id
          sharding-algorithm-name: mod-flat-sharding-algorithm
  sharding-algorithms:
    mod-flat-sharding-algorithm:
      type: MOD
      props:
        sharding-count: 2

垂直分片配置

垂直分片配置示例：

sharding:
  tables:
    t_user:
      actual-data-nodes: test$->{0..1}.t_user
    t_order:
      actual-data-nodes: test$->{0..1}.t_order

SQL语句编写与执行

编写 SQL 语句时，可以使用标准的 SQL 语法，ShardingJDBC 会自动处理分片逻辑。

示例代码

示例代码展示了如何使用 ShardingJDBC 执行 SQL 语句：

import org.apache.shardingsphere.api.ShardingSphere;
import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.KeyGeneratorConfiguration;
import org.apache.shardingsphere.api.config.sharding.strategy.StandardShardingStrategyConfiguration;
import org.apache.shardingsphere.shardingjdbc.api.config.ShardingJdbcDataSourceFactory;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;

public class ShardingJDBCDemo {
    public static void main(String[] args) {
        // 配置分片规则
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration("t_order", "sharding_db$->{0..1}.t_order");
        orderTableRuleConfig.setKeyGeneratorConfig(new KeyGeneratorConfiguration("SNOWFLAKE", "order_id"));
        orderTableRuleConfig.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("user_id", "mod-flat-sharding-algorithm"));
        shardingRuleConfig.getTables().add(orderTableRuleConfig);

        // 创建数据源
        Properties props = new Properties();
        props.setProperty("sql.show", "true");
        Connection dataSource = ShardingJdbcDataSourceFactory.createDataSource(shardingRuleConfig, props);

        try {
            Statement stmt = dataSource.createStatement();
            stmt.executeUpdate("INSERT INTO t_order (user_id, status, address) VALUES (1, 'PAID', 'Beijing')");
            ResultSet rs = stmt.executeQuery("SELECT * FROM t_order WHERE user_id = 1");
            while (rs.next()) {
                System.out.println(rs.getInt("order_id") + "\t" + rs.getString("status"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

实战案例分析

假设有一个电商系统，需要存储大量的用户订单信息。由于订单数据量巨大，可以使用 ShardingJDBC 进行水平分片，将订单数据拆分到多个数据库实例上。

案例配置

案例配置示例：

sharding:
  tables:
    t_order:
      actual-data-nodes: sharding_db$->{0..1}.t_order
      table-strategy:
        standard:
          sharding-column: user_id
          sharding-algorithm-name: mod-flat-sharding-algorithm
  sharding-algorithms:
    mod-flat-sharding-algorithm:
      type: MOD
      props:
        sharding-count: 2

案例代码

案例代码展示了如何使用 ShardingJDBC 执行 SQL 语句：

import org.apache.shardingsphere.api.ShardingSphere;
import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.KeyGeneratorConfiguration;
import org.apache.shardingsphere.api.config.sharding.strategy.StandardShardingStrategyConfiguration;
import org.apache.shardingsphere.shardingjdbc.api.config.ShardingJdbcDataSourceFactory;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;

public class ShardingJDBCDemo {
    public static void main(String[] args) {
        // 配置分片规则
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration("t_order", "sharding_db$->{0..1}.t_order");
        orderTableRuleConfig.setKeyGeneratorConfig(new KeyGeneratorConfiguration("SNOWFLAKE", "order_id"));
        orderTableRuleConfig.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("user_id", "mod-flat-sharding-algorithm"));
        shardingRuleConfig.getTables().add(orderTableRuleConfig);

        // 创建数据源
        Properties props = new Properties();
        props.setProperty("sql.show", "true");
        Connection dataSource = ShardingJdbcDataSourceFactory.createDataSource(shardingRuleConfig, props);

        try {
            Statement stmt = dataSource.createStatement();
            stmt.executeUpdate("INSERT INTO t_order (user_id, status, address) VALUES (1, 'PAID', 'Beijing')");
            ResultSet rs = stmt.executeQuery("SELECT * FROM t_order WHERE user_id = 1");
            while (rs.next()) {
                System.out.println(rs.getInt("order_id") + "\t" + rs.getString("status"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ShardingJDBC的常见问题与解决方法

常见错误排查

在使用 ShardingJDBC 过程中，可能会遇到一些常见错误，如配置错误、SQL 语句错误等。

配置错误

配置错误通常是因为配置文件中的语法或逻辑错误。例如，分片规则配置错误、数据源配置错误等。

sharding:
  tables:
    t_order:
      actual-data-nodes: test$->{0..1}.t_order
      table-strategy:
        standard:
          sharding-column: user_id
          sharding-algorithm-name: mod-flat-sharding-algorithm
  sharding-algorithms:
    mod-flat-sharding-algorithm:
      type: MOD
      props:
        sharding-count: 2

SQL 语句错误

SQL 语句错误通常是因为 SQL 语句不符合 ShardingJDBC 的解析规则，例如使用了不支持的 SQL 语法。

import org.apache.shardingsphere.api.ShardingSphere;
import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.KeyGeneratorConfiguration;
import org.apache.shardingsphere.api.config.sharding.strategy.StandardShardingStrategyConfiguration;
import org.apache.shardingsphere.shardingjdbc.api.config.ShardingJdbcDataSourceFactory;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;

public class ShardingJDBCDemo {
    public static void main(String[] args) {
        // 配置分片规则
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration("t_order", "sharding_db$->{0..1}.t_order");
        orderTableRuleConfig.setKeyGeneratorConfig(new KeyGeneratorConfiguration("SNOWFLAKE", "order_id"));
        orderTableRuleConfig.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("user_id", "mod-flat-sharding-algorithm"));
        shardingRuleConfig.getTables().add(orderTableRuleConfig);

        // 创建数据源
        Properties props = new Properties();
        props.setProperty("sql.show", "true");
        Connection dataSource = ShardingJdbcDataSourceFactory.createDataSource(shardingRuleConfig, props);

        try {
            Statement stmt = dataSource.createStatement();
            stmt.executeUpdate("INSERT INTO t_order (user_id, status, address) VALUES (1, 'PAID', 'Beijing')");
            ResultSet rs = stmt.executeQuery("SELECT * FROM t_order WHERE user_id = 1");
            while (rs.next()) {
                System.out.println(rs.getInt("order_id") + "\t" + rs.getString("status"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

性能优化技巧

性能优化技巧包括以下几个方面：

合理设计分片策略

合理设计分片策略可以提高系统的性能。例如，选择合适的分片键，避免热点数据。

sharding:
  tables:
    t_order:
      actual-data-nodes: test$->{0..1}.t_order
      table-strategy:
        standard:
          sharding-column: user_id
          sharding-algorithm-name: mod-flat-sharding-algorithm
  sharding-algorithms:
    mod-flat-sharding-algorithm:
      type: MOD
      props:
        sharding-count: 2

读写分离

通过配置主从数据库实现读写分离，可以提高系统的并发性能。

sharding:
  master-slave-rules:
    ms_ds:
      master-data-source-name: ds
      slave-data-sources:
        - slave-0
        - slave-1
      load-balance-algorithm-name: round-robin

数据库优化

对数据库进行优化，例如创建索引、优化查询语句等。

CREATE INDEX idx_user_id ON t_order (user_id);

资源优化

对系统的资源进行优化，例如增加服务器资源、优化网络带宽等。

版本兼容性问题解决

在使用 ShardingJDBC 不同版本时，可能会遇到版本兼容性问题。例如，某些旧版本的 ShardingJDBC 无法兼容新版本的数据库驱动。

解决方法

解决版本兼容性问题的方法包括：

1. 升级数据库驱动：确保使用的数据库驱动版本与 ShardingJDBC 版本兼容。
2. 升级 ShardingJDBC：使用最新版本的 ShardingJDBC，以获得更好的兼容性和性能。
3. 查阅文档：查阅 ShardingJDBC 的文档，了解不同版本的兼容性信息。

示例代码

示例代码展示了如何升级数据库驱动：

import org.apache.shardingsphere.api.ShardingSphere;
import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.KeyGeneratorConfiguration;
import org.apache.shardingsphere.api.config.sharding.strategy.StandardShardingStrategyConfiguration;
import org.apache.shardingsphere.shardingjdbc.api.config.ShardingJdbcDataSourceFactory;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;

public class ShardingJDBCDemo {
    public static void main(String[] args) {
        // 配置分片规则
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration("t_order", "sharding_db$->{0..1}.t_order");
        orderTableRuleConfig.setKeyGeneratorConfig(new KeyGeneratorConfiguration("SNOWFLAKE", "order_id"));
        orderTableRuleConfig.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("user_id", "mod-flat-sharding-algorithm"));
        shardingRuleConfig.getTables().add(orderTableRuleConfig);

        // 创建数据源
        Properties props = new Properties();
        props.setProperty("sql.show", "true");
        Connection dataSource = ShardingJdbcDataSourceFactory.createDataSource(shardingRuleConfig, props);

        try {
            Statement stmt = dataSource.createStatement();
            stmt.executeUpdate("INSERT INTO t_order (user_id, status, address) VALUES (1, 'PAID', 'Beijing')");
            ResultSet rs = stmt.executeQuery("SELECT * FROM t_order WHERE user_id = 1");
            while (rs.next()) {
                System.out.println(rs.getInt("order_id") + "\t" + rs.getString("status"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ShardingJDBC项目的部署与维护

项目部署流程

项目部署流程包括以下几个步骤：

部署环境准备

确保部署环境满足项目运行的要求，例如操作系统、Java 版本、数据库版本等。

部署数据库

根据项目配置文件中的数据库配置，部署数据库实例。

部署 ShardingJDBC

将 ShardingJDBC 的 jar 包部署到项目的 classpath 中。

部署应用代码

将应用代码部署到目标服务器上。

启动应用

启动部署的应用程序，确保应用能够正常运行。

示例代码

示例代码展示了如何启动 Spring Boot 应用程序：

mvn spring-boot:run

日常维护要点

日常维护要点包括以下几个方面：

数据库维护

定期备份数据库，监控数据库性能，及时修复数据库问题。

配置维护

定期检查配置文件，确保配置正确无误。

性能监控

使用性能监控工具，监控应用的运行状态，及时发现性能瓶颈。

日志管理

记录应用的日志，便于问题排查和性能优化。

案例代码

示例代码展示了如何使用 Log4j 记录日志：

import org.apache.log4j.Logger;

public class LogExample {
    private static final Logger logger = Logger.getLogger(LogExample.class);

    public void logInfo(String message) {
        logger.info(message);
    }
}

监控与日志管理

监控与日志管理是日常维护的重要组成部分，可以使用监控工具和日志工具进行监控和日志管理。

监控工具

监控工具可以监控应用的运行状态，例如使用 Prometheus、Grafana 等工具。

日志工具

日志工具可以记录应用的日志，例如使用 Log4j、SLF4J 等工具。

案例代码

示例代码展示了如何使用 Log4j 记录日志：

import org.apache.log4j.Logger;

public class LogExample {
    private static final Logger logger = Logger.getLogger(LogExample.class);

    public void logInfo(String message) {
        logger.info(message);
    }
}

通过以上步骤，可以确保 ShardingJDBC 项目能够稳定运行，并及时发现问题和解决问题。