springboot2.7集成sharding-jdbc4.1.1实现业务分表

最新推荐文章于 2024-04-24 14:50:01 发布
最新推荐文章于 2024-04-24 14:50:01 发布
阅读量1k 收藏 25
点赞数 27
文章标签： java springboot 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32003379/article/details/135498902
版权

1、引入maven

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

2、基本代码示例

基本逻辑：利用数据库存在的租户uuid，做租户级别的数据分表，如 user_${uuid},order_${uuid}等，因为好像pgsql无法支持使用 “-”这个特殊字符做为表名，所以需要吧uuid中的 - 全部替换掉

DynamicTableConfig.java

用于初始化动态分表信息

MybatisPlusConfig.java

sql拦截器，针对所有插入，查询和更新，判断所用sql是否属于分表范围内

OrgAutoShardingSphereFixture.java

自定义分片算法,继承实现Hint分片，用于动态分表

ShardingAlgorithmTool

动态分表工具类

ShardingTablesLoadRunner

项目启动后 读取已有分表 进行缓存

SqlParserHandler

sql工具类

TablesNamesConfig

分表信息和sql集合类，所需要做分表的，均需要配置在这里

EdgeUserAndOrderServiceInterceptor做sql拦截器

TablesNamesConfig类：
public class TablesNamesConfig {
//这里是你要做分表的表名
    public final static String TABLES_NAMES = "edge_cs_user,edge_order_info";

    /**
     * 模板sql
     *
     * @param tableName
     * @return
     */
    public static List<String> selectTableCreateSql(String tableName) {
        List<String> res = new ArrayList<>();
        if (tableName.equals("edge_cs_user")) {
            res.add("替换成你要创建的sql语句");
        } else if (tableName.equals("edge_order_info")) {
            res.add("替换成你要创建的sql语句");
        }
        return res;
    }
}
SqlParserHandler类
import com.baomidou.mybatisplus.core.injector.methods.Insert;
import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.alter.Alter;
import net.sf.jsqlparser.statement.create.index.CreateIndex;
import net.sf.jsqlparser.statement.create.table.CreateTable;
import net.sf.jsqlparser.statement.create.view.CreateView;
import net.sf.jsqlparser.statement.delete.Delete;
import net.sf.jsqlparser.statement.drop.Drop;
import net.sf.jsqlparser.statement.execute.Execute;
import net.sf.jsqlparser.statement.merge.Merge;
import net.sf.jsqlparser.statement.replace.Replace;
import net.sf.jsqlparser.statement.select.*;
import net.sf.jsqlparser.statement.truncate.Truncate;
import net.sf.jsqlparser.statement.update.Update;
import net.sf.jsqlparser.statement.upsert.Upsert;
import net.sf.jsqlparser.util.TablesNamesFinder;

import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;

/**
 * sql解析工具
 *
 * @Created by xieyaoyi
 * @Created_date 2023/12/12
 */
public class SqlParserHandler {

    /**
     * 由于jsqlparser没有获取SQL类型的原始工具，并且在下面操作时需要知道SQL类型，所以编写此工具方法
     *
     * @param sql sql语句
     * @return sql类型，
     * @throws JSQLParserException
     */
    public static String getSqlType(String sql) throws JSQLParserException {
        Statement sqlStmt = CCJSqlParserUtil.parse(new StringReader(sql));
        if (sqlStmt instanceof Alter) {
            return "ALTER";
        } else if (sqlStmt instanceof CreateIndex) {
            return "CREATEINDEX";
        } else if (sqlStmt instanceof CreateTable) {
            return "CREATETABLE";
        } else if (sqlStmt instanceof CreateView) {
            return "CREATEVIEW";
        } else if (sqlStmt instanceof Delete) {
            return "DELETE";
        } else if (sqlStmt instanceof Drop) {
            return "DROP";
        } else if (sqlStmt instanceof Execute) {
            return "EXECUTE";
        } else if (sqlStmt instanceof Insert) {
            return "INSERT";
        } else if (sqlStmt instanceof Merge) {
            return "MERGE";
        } else if (sqlStmt instanceof Replace) {
            return "REPLACE";
        } else if (sqlStmt instanceof Select) {
            return "SELECT";
        } else if (sqlStmt instanceof Truncate) {
            return "TRUNCATE";
        } else if (sqlStmt instanceof Update) {
            return "UPDATE";
        } else if (sqlStmt instanceof Upsert) {
            return "UPSERT";
        } else {
            return "NONE";
        }
    }

    /**
     * 获取sql操作接口,与上面类型判断结合使用
     * example:
     * String sql = "create table a(a string)";
     * SqlType sqlType = SqlParserTool.getSqlType(sql);
     * if(sqlType.equals(SqlType.SELECT)){
     * Select statement = (Select) SqlParserTool.getStatement(sql);
     * }
     *
     * @param sql
     * @return
     * @throws JSQLParserException
     */
    public static Statement getStatement(String sql) throws JSQLParserException {
        Statement sqlStmt = CCJSqlParserUtil.parse(new StringReader(sql));
        return sqlStmt;
    }

    /**
     * 获取tables的表名
     *
     * @param statement
     * @return
     */
    public static <T> List<String> getTableList(T statement) {
        TablesNamesFinder tablesNamesFinder = new TablesNamesFinder();
        List<String> tableList = tablesNamesFinder.getTableList((Statement) statement);
        return tableList;
    }

    /**
     * 获取join层级
     *
     * @param selectBody
     * @return
     */
    public static List<Join> getJoins(SelectBody selectBody) {
        if (selectBody instanceof PlainSelect) {
            List<Join> joins = ((PlainSelect) selectBody).getJoins();
            return joins;
        }
        return new ArrayList<Join>();
    }

    /**
     * @param selectBody
     * @return
     */
    public static List<Table> getIntoTables(SelectBody selectBody) {
        if (selectBody instanceof PlainSelect) {
            List<Table> tables = ((PlainSelect) selectBody).getIntoTables();
            return tables;
        }
        return new ArrayList<Table>();
    }

    /**
     * @param selectBody
     * @return
     */
    public static void setIntoTables(SelectBody selectBody, List<Table> tables) {
        if (selectBody instanceof PlainSelect) {
            ((PlainSelect) selectBody).setIntoTables(tables);
        }
    }

    /**
     * 获取limit值
     *
     * @param selectBody
     * @return
     */
    public static Limit getLimit(SelectBody selectBody) {
        if (selectBody instanceof PlainSelect) {
            Limit limit = ((PlainSelect) selectBody).getLimit();
            return limit;
        }
        return null;
    }

    /**
     * 为SQL增加limit值
     *
     * @param selectBody
     * @param l
     */
    public static void setLimit(SelectBody selectBody, long l) {
        if (selectBody instanceof PlainSelect) {
            Limit limit = new Limit();
            limit.setRowCount(new LongValue(String.valueOf(l)));
            ((PlainSelect) selectBody).setLimit(limit);
        }
    }

    /**
     * 获取FromItem不支持子查询操作
     *
     * @param selectBody
     * @return
     */
    public static FromItem getFromItem(SelectBody selectBody) {
        if (selectBody instanceof PlainSelect) {
            FromItem fromItem = ((PlainSelect) selectBody).getFromItem();
            return fromItem;
        } else if (selectBody instanceof WithItem) {
            getFromItem(selectBody);
        }
        return null;
    }

    /**
     * 获取子查询
     *
     * @param selectBody
     * @return
     */
    public static SubSelect getSubSelect(SelectBody selectBody) {
        if (selectBody instanceof PlainSelect) {
            FromItem fromItem = ((PlainSelect) selectBody).getFromItem();
            if (fromItem instanceof SubSelect) {
                return ((SubSelect) fromItem);
            }
        } else if (selectBody instanceof WithItem) {
            getSubSelect(selectBody);
        }
        return null;
    }

    /**
     * 判断是否为多级子查询
     *
     * @param selectBody
     * @return
     */
    public static boolean isMultiSubSelect(SelectBody selectBody) {
        if (selectBody instanceof PlainSelect) {
            FromItem fromItem = ((PlainSelect) selectBody).getFromItem();
            if (fromItem instanceof SubSelect) {
                SelectBody subBody = ((SubSelect) fromItem).getSelectBody();
                if (subBody instanceof PlainSelect) {
                    FromItem subFromItem = ((PlainSelect) subBody).getFromItem();
                    if (subFromItem instanceof SubSelect) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    /**
     * 获取查询字段
     *
     * @param selectBody
     * @return
     */
    public static List<SelectItem> getSelectItems(SelectBody selectBody) {
        if (selectBody instanceof PlainSelect) {
            List<SelectItem> selectItems = ((PlainSelect) selectBody).getSelectItems();
            return selectItems;
        }
        return null;
    }

    public static void main(String[] args) throws JSQLParserException {
        String sql = "SELECT table_name FROM information_schema.tables  WHERE table_name  like concat('edge_cs_user','%')";
        Statement statement = getStatement(sql);
        List<String> tableList = getTableList(statement);

        String sqlType = getSqlType(sql);
        System.out.println(sqlType);
        for (String s : tableList) {
            System.out.println(s);
        }
    }

}


ShardingAlgorithmTool工具类，为了可以指定数据库创建指定分表操作，并将创建好的数据表缓存起来，下次就不用再重复创建


import cn.hutool.core.io.resource.ClassPathResource;
import cn.hutool.core.util.StrUtil;
import com.youxin.commons.commonsdata.service.EdgeOrgData;
import com.youxin.edge_service.ifoodapi.utils.IfoodApiUtils;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.*;

@Slf4j
public class ShardingAlgorithmTool {
    private static final HashSet<String> tableNameCache = new HashSet<>();

    /**
     * 判断 分表获取的表名是否存在 不存在则自动建表
     *
     * @param logicTableName  逻辑表名(表头)
     * @param resultTableName 真实表名
     * @return 确认存在于数据库中的真实表名
     */
    public static String shardingTablesCheckAndCreatAndReturn(String logicTableName, String resultTableName) {
        log.error(String.valueOf(EdgeOrgData.orgListMap));
        synchronized (logicTableName.intern()) {
            // 缓存中有此表 返回
            if (tableNameCache.contains(resultTableName)) {
                return resultTableName;
            }
            // 缓存中无此表 建表 并添加缓存
            List<String> sqlList = TablesNamesConfig.selectTableCreateSql(logicTableName);
            for (int i = 0; i < sqlList.size(); i++) {
                sqlList.set(i, sqlList.get(i).replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS").replace(logicTableName, resultTableName));
            }
            if (executeSql(sqlList)){
                tableNameCache.add(resultTableName);
            }
        }
        return resultTableName;
    }

    /**
     * 缓存重载方法
     */
    public static void tableNameCacheReload(String active) {
        // 读取数据库中所有表名
        List<String> tableNameList = getAllTableNameBySchema(active);
        // 删除旧的缓存(如果存在)
        ShardingAlgorithmTool.tableNameCache.clear();
        // 写入新的缓存
        ShardingAlgorithmTool.tableNameCache.addAll(tableNameList);
    }


    private static boolean executeSql(List<String> sqlList) {
        final ClassPathResource resource = new ClassPathResource("application.yml");
        Properties properties = new Properties();
        try {
            properties.load(resource.getStream());
            String active = properties.getProperty("active");
            String propertiesname = "application.properties";
            switch (active) {
                case "dev":
                    propertiesname = "application-dev.properties";
                    break;
                case "test":
                    propertiesname = "application-test.properties";
                    break;
                case "prod":
                    propertiesname = "application-prod.properties";
                    break;
                default:
                    break;
            }
            final ClassPathResource resource1 = new ClassPathResource(propertiesname);
            properties.load(resource1.getStream());
        } catch (IOException e) {
            log.error("读取sharding.yaml文件失败{}",e);
            return false;
        }
        try (Connection conn1 = DriverManager.getConnection(properties.getProperty("spring.shardingsphere.datasource.ds1.jdbc-url"),
                properties.getProperty("spring.shardingsphere.datasource.ds1.username"),
                properties.getProperty("spring.shardingsphere.datasource.ds1.password"))) {
            try (Statement st = conn1.createStatement()) {
                conn1.setAutoCommit(false);
                for (String sql : sqlList) {
                    st.execute(sql);
                }
                conn1.commit();
            } catch (Exception ex) {
                log.error("执行sql失败,原因：{}", ex);
                conn1.rollback();
                return false;
            }
        } catch (Exception ex) {
            log.error("手动链接失败失败,原因：{}", ex);
            return false;
        }
        return true;
    }


    public static List<String> getAllTableNameBySchema(String active) {
        String propertiesname = "application.properties";
        switch (active) {
            case "dev":
                propertiesname = "application-dev.properties";
                break;
            case "test":
                propertiesname = "application-test.properties";
                break;
            case "prod":
                propertiesname = "application-prod.properties";
                break;
            default:
                break;
        }
        List<String> res = new ArrayList<>();
        final ClassPathResource resource = new ClassPathResource(propertiesname);
        Properties properties = new Properties();
        try {
            properties.load(resource.getStream());
        } catch (IOException e) {
            log.error("读取sharding.yaml文件失败");
            throw new RuntimeException(e);
        }
        String[] tablesNames = TablesNamesConfig.TABLES_NAMES.split(StrUtil.COMMA);
        for (String table_name : tablesNames) {
            String sql = "SELECT table_name FROM information_schema.tables  WHERE table_name  like concat(" + "'" + table_name + "'" + ",'%')";
            try (Connection connection = DriverManager.getConnection(properties.getProperty("spring.shardingsphere.datasource.ds1.jdbc-url"),
                    properties.getProperty("spring.shardingsphere.datasource.ds1.username"),
                    properties.getProperty("spring.shardingsphere.datasource.ds1.password"));
                 Statement st = connection.createStatement()) {
                try (ResultSet rs = st.executeQuery(sql)) {
                    while (rs.next()) {
                        res.add(rs.getString(1));
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return res;
    }

    public static HashSet<String> cacheTableNames() {
        return tableNameCache;
    }
}


DynamicTableConfig初始化

import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.strategy.HintShardingStrategyConfiguration;
import org.apache.shardingsphere.core.rule.ShardingDataSourceNames;
import org.apache.shardingsphere.core.rule.ShardingRule;
import org.apache.shardingsphere.core.rule.TableRule;
import org.apache.shardingsphere.shardingjdbc.jdbc.core.datasource.ShardingDataSource;
import org.springframework.context.EnvironmentAware;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import javax.sql.DataSource;
import java.sql.*;
import java.util.*;

/**
 * 初始化动态分表信息
 *
 * @author menshaojing
 */
@Component
@Slf4j
public class DynamicTableConfig implements EnvironmentAware {
    /**
     * 数据库集合key
     **/
    private final static String DBS_KEY = "spring.shardingsphere.datasource.names";
    /**
     * 自定义水平分表集合key
     **/
    private final static String TABLES_KEY = "shardingsphere.sharding.tables";

    private final static String DATASOURCE_KEY = "spring.shardingsphere.datasource";

    /**
     * 数据库集合
     **/
    private String dbs;
    /**
     * 动态分表集合
     **/
    private String tables;


    private String driverClassName;

    private String jdbcUrl;

    private String userName;

    private String password;

    private Connection connection;

    @Resource(name = "shardingDataSource")
    private DataSource dataSource;

    /**
     * 初始化动态分表信息
     * ds0.edge_cs_user_org_id
     */
    @PostConstruct
    public void initDynamicTable() throws SQLException, ClassNotFoundException {
        log.info("动态初始化添加分库分表策略.....");
        ShardingDataSource dataSource = (ShardingDataSource) this.dataSource;
        ShardingRule tableRule = dataSource.getRuntimeContext().getRule();
        final Collection<TableRule> tableRules = tableRule.getTableRules();
        final List<String> tableList = Arrays.asList(this.tables.split(StrUtil.COMMA));
        //进行添加实际数据节点，hit分片
        for (String table : tableList) {
            log.info("开始动态初始化添加[{}]分表策略", table);
            addDefaultHitAlgorithm(table, tableRules);
            log.info("结束动态初始化添加[{}]分表策略", table);

        }
    }

    public void loadDatabase() throws ClassNotFoundException, SQLException {
        Class.forName(this.driverClassName);
        connection = DriverManager.getConnection(this.jdbcUrl, this.userName, this.password);

    }


    /**
     * 添加实际数据节点：按照组织id进行水平分表
     *
     * @param table
     */
    public String addDefaultActualDataNodes(String table) throws SQLException, ClassNotFoundException {
        loadDatabase();
        List<String> allOrg = getAllOrg();
        connection.close();
        StringBuilder stringBuilder = new StringBuilder();
        for (String db : this.dbs.split(StrUtil.COMMA)) {
            for (String org_id : allOrg) {
                stringBuilder
                        .append(db)
                        .append(StrUtil.DOT)
                        .append(table)
                        .append(StrUtil.UNDERLINE)
                        .append(org_id.replaceAll("-", ""))
                        .append(StrUtil.COMMA);
            }
        }
        log.info("添加实际数据节点[{}] :{}", table, stringBuilder.substring(0, stringBuilder.length() - 1));
        return stringBuilder.substring(0, stringBuilder.length() - 1);
    }

    /**
     * 添加默认hit算法 algorithm
     *
     * @param table
     * @param tableRules
     */
    public void addDefaultHitAlgorithm(String table, Collection<TableRule> tableRules) throws SQLException, ClassNotFoundException {

        //表规则配置
        TableRuleConfiguration tableRuleConfiguration = new TableRuleConfiguration(table, addDefaultActualDataNodes(table));

        //添加默认数据库hit算法
        HintShardingStrategyConfiguration hintShardingStrategyConfiguration = new HintShardingStrategyConfiguration(new OrgAutoShardingSphereFixture());

        tableRuleConfiguration.setDatabaseShardingStrategyConfig(hintShardingStrategyConfiguration);
        log.info("添加默认数据库hit算法[{}]策略:{}", table, hintShardingStrategyConfiguration);
        //添加默认分表hit算法
        hintShardingStrategyConfiguration = new HintShardingStrategyConfiguration(new OrgAutoShardingSphereFixture());
        tableRuleConfiguration.setTableShardingStrategyConfig(hintShardingStrategyConfiguration);
        log.info("添加默认分表hit算法[{}]策略:{}", table, hintShardingStrategyConfiguration);
        //原始数据源集合
        Collection<String> rawDataSourceNames = new ArrayList<>();

        for (String db : this.dbs.split(StrUtil.COMMA)) {
            rawDataSourceNames.add(db);
        }

        ShardingRuleConfiguration shardingRuleConfiguration = new ShardingRuleConfiguration();

        ShardingDataSourceNames shardingDataSourceNames = new ShardingDataSourceNames(shardingRuleConfiguration, rawDataSourceNames);

        TableRule tableRule = new TableRule(tableRuleConfiguration, shardingDataSourceNames, null);

        tableRules.add(tableRule);
    }


    /**
     * 获取所有组织信息
     *
     * @return
     */
    private List<String> getAllOrg() throws SQLException {
        List<String> list = new ArrayList<>();
        final PreparedStatement preparedStatement = connection.prepareStatement("SELECT org_id from edge_org where activity != -1");
        final ResultSet resultSet = preparedStatement.executeQuery();
        while (resultSet.next()) {
            String org_id = resultSet.getObject(1, String.class);
            list.add(org_id);
        }
        preparedStatement.close();
        resultSet.close();
        return list;
    }


    @Override
    public void setEnvironment(Environment environment) {
        this.dbs = environment.getProperty(DBS_KEY);
        this.tables = TablesNamesConfig.TABLES_NAMES;
        String db = this.dbs.split(StrUtil.COMMA)[0];
        final String s = DATASOURCE_KEY + StrUtil.DOT + db + StrUtil.DOT + "driver-class-name";
        this.driverClassName = environment.getProperty(DATASOURCE_KEY + StrUtil.DOT + db + StrUtil.DOT + "driver-class-name");
        this.jdbcUrl = environment.getProperty(DATASOURCE_KEY + StrUtil.DOT + db + StrUtil.DOT + "jdbc-url");
        this.userName = environment.getProperty(DATASOURCE_KEY + StrUtil.DOT + db + StrUtil.DOT + "username");
        this.password = environment.getProperty(DATASOURCE_KEY + StrUtil.DOT + db + StrUtil.DOT + "password");
    }

}


OrgAutoShardingSphereFixture类，实现Hint分片,这里是最主要的业务核心


import com.google.common.collect.Range;
import lombok.extern.slf4j.Slf4j;
import org.apache.shardingsphere.api.sharding.hint.HintShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.hint.HintShardingValue;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 自定义分片算法,继承实现Hint分片
 *
 * @Created by xieyaoyi
 * @Created_date 2023/12/1
 */
@Slf4j
@Component
public class OrgAutoShardingSphereFixture implements HintShardingAlgorithm<String> {

    /**
     * @param collection        数据源集合
     *                          在分库时值为所有分片库的集合 databaseNames
     *                          分表时为对应分片库中所有分片表的集合 tablesNames
     * @param hintShardingValue 分片属性，包括
     *                          logicTableName 为逻辑表，
     *                          columnName 分片健（字段），hit策略此处为空 ""
     *                          <p>
     *                          value 【之前】都是 从 SQL 中解析出的分片健的值,用于取模判断
     *                          HintShardingAlgorithm不再从SQL 解析中获取值，而是直接通过
     *                          hintManager.addTableShardingValue("edge_cs_user", “003538e36799cec47ebbe1d56fa1671bde9”)参数进行指定
     * @return
     */
    @Override
    public Collection<String> doSharding(Collection<String> collection, HintShardingValue<String> hintShardingValue) {
        //collection.forEach(i -> System.out.println("节点配置表名为: " + i));
        Collection<String> result = new ArrayList<>();
        Set<String> tableSet = collection.stream().collect(Collectors.toSet());
        for (String shardingValue : hintShardingValue.getValues()) {
            String value = hintShardingValue.getLogicTableName() + "_" + shardingValue;
            if (!tableSet.isEmpty() && tableSet.contains(value)) {
                ShardingAlgorithmTool.shardingTablesCheckAndCreatAndReturn(hintShardingValue.getLogicTableName(), value);
                result.add(value);
            }else {
                ShardingAlgorithmTool.shardingTablesCheckAndCreatAndReturn(hintShardingValue.getLogicTableName(), value);
                result.add(value);
            }
        }
        return result;

    }


}

ShardingTablesLoadRunner类


import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 项目启动后 读取已有分表 进行缓存
 */
@Slf4j
@Order
@Component
public class ShardingTablesLoadRunner implements CommandLineRunner {

    @Value("${spring.profiles.active:prod}")
    private String active;

    @Override
    public void run(String... args) {
        ShardingAlgorithmTool.tableNameCacheReload(active);
    }
}


EdgeUserAndOrderServiceInterceptor类，做sql拦截，用于sql进行分表创建和查询


import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor;
import com.youxin.shardingsphere.SqlParserHandler;
import com.youxin.shardingsphere.TablesNamesConfig;
import lombok.extern.slf4j.Slf4j;
import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.statement.Statement;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.shardingsphere.api.hint.HintManager;
import org.springframework.stereotype.Component;


import java.sql.SQLException;
import java.util.List;

/**
 * 用户表、订单表分表
 *
 * @Created by xieyaoyi
 * @Created_date 2023/12/4
 */
@Component
@Slf4j
public class EdgeUserAndOrderServiceInterceptor implements InnerInterceptor {


    /**
     * 判断是否符合规则
     *
     * @param sql
     * @return
     */
    public boolean judgmentSql(String sql) {
        String[] tableames = TablesNamesConfig.TABLES_NAMES.split(StrUtil.COMMA);
        for (String table_name : tableames) {
            if (sql.toLowerCase().indexOf("from " + table_name) > 0
                    || sql.toLowerCase().indexOf("update " + table_name) >= 0
                    || sql.toLowerCase().indexOf("into " + table_name) > 0) {
                return true;
            }
        }
        return false;
    }

    @Override
    public void beforeUpdate(Executor executor, MappedStatement ms, Object parameter) throws SQLException {
        BoundSql boundSql = ms.getBoundSql(parameter);
        String sql = boundSql.getSql();
        if (!judgmentSql(sql)) {
            return;
        }
        String state = JSONObject.parseObject(JSON.toJSON(parameter).toString()).getString("state");
        if (parameter != null && StringUtils.isNotBlank(state)) {
            try {
                Statement statement = SqlParserHandler.getStatement(sql);
                final List<String> tableList = SqlParserHandler.getTableList(statement);
                //清除历史规则
                HintManager.clear();
                //获取对应的实例
                HintManager hintManager = HintManager.getInstance();
                for (String table : tableList) {
                    //设置表的分片键值，value是用于表分片
                    hintManager.addTableShardingValue(table, state);
                }
                log.info("解析SQL表名：{}", tableList);
            } catch (JSQLParserException e) {
                log.error("解析SQL表名失败:{}", e);
                throw new RuntimeException(e);
            }
        }
    }

    @Override
    public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        boundSql = ms.getBoundSql(parameter);
        String sql = boundSql.getSql();
        if (!judgmentSql(sql)) {
            return;
        }
        String state = JSONObject.parseObject(JSON.toJSON(parameter).toString()).getString("state");
        if (parameter != null && StringUtils.isNotBlank(state)) {
            try {
                Statement statement = SqlParserHandler.getStatement(sql);
                final List<String> tableList = SqlParserHandler.getTableList(statement);
                //清除历史规则
                HintManager.clear();
                //获取对应的实例
                HintManager hintManager = HintManager.getInstance();
                for (String table : tableList) {
                    //设置表的分片键值，value是用于表分片
                    hintManager.addTableShardingValue(table, state);
                }
                log.info("解析SQL表名：{}", tableList);
            } catch (JSQLParserException e) {
                log.error("解析SQL表名失败:{}", e);
                throw new RuntimeException(e);
            }
        }
    }
}

MybatisPlusConfig做拦截器扫描配置进来


import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import com.youxin.commons.interceptor.service.EdgeUserAndOrderServiceInterceptor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Created by xieyaoyi
 * @Created_date 2023/12/4
 */
@Slf4j
@Configuration
public class MybatisPlusConfig {



    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        addPaginationInnerInterceptor(interceptor);
        return interceptor;
    }

    private void addPaginationInnerInterceptor(MybatisPlusInterceptor interceptor) {
        //分页
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.POSTGRE_SQL));
        //动态表拦截器
        interceptor.addInnerInterceptor(new EdgeUserAndOrderServiceInterceptor());

    }

}

以上就是主要的分表业务代码了，但是注意的是以上只是显示了基本的框架，你在插入或者查询的时候，是需要带上分表关键字段的数据，才能做到真正的切换指定的表数据。

如：我这里是使用state这个字段作为分表的关键字段，所以在插入、查询、更新。或者删除的时候都必须传入这个参数，及时我的mapper里面不需要这个参数的使用

示例：

    public EdgeOrderInfo getEdgeOrderInfo(String order_no, String state) {
        return edgeOrderMapper.getOrderInfoByOrderNo(order_no, state);
    }


    public EdgeOrderInfo addOrUpdateEdgeOrderInfo(EdgeOrderInfo orderInfo) {
        if (StringUtils.isBlank(orderInfo.getOrder_no())) {
            orderInfo.setOrder_no(CreateNoUtils.getCreateOrderNo(6));
        }
        if (StringUtils.isBlank(orderInfo.getState())) {
            orderInfo.setState(orderInfo.getOrg_id().replaceAll("-", ""));
        }
        if (getEdgeOrderInfo(orderInfo.getOrder_no(), orderInfo.getState()) != null) {
            orderInfo.setUpdated_date(new Date());
            edgeOrderMapper.updateByOrderNo(orderInfo, orderInfo.getState());
        } else {
            edgeOrderMapper.insert(orderInfo);
        }
        return orderInfo;
    }

这样在sql拦截后，就会经过OrgAutoShardingSphereFixture类将edge_order_info替换edge_order_info_${uuid}了

数据库效果展示：

我也是参考别人的博客写的，推荐一下写得可以的博客一起学习一下

参考博客：

https://blog.csdn.net/weixin_39403349/article/details/130264892

名字只是一个称呼
关注
  • 27
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表
08-25
SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表 SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表是指在 Spring Boot 2.0 框架下使用 sharding-jdbc 中间件来实现数据分库分表的技术方案。在这个...
springboot项目整合ShardingSphere版本冲突问题
m0_62498006的博客
07-21 1780
气死人了，做这个项目的时候初学shardingsphere，参考了两篇文章写写出来，结果出错了。出错原因是sharding-jdbc的版本和springboot版本冲突了。这两个组合我自己都实验过了，没有报错。
sharding-jdbc-spring-boot-starter最简单使用
segegefe的博客
03-08 1501
前言 网上已经有很多的关于sharding-jdbc的使用，但是很多都是抄来抄去，说的也不是特别的完整，作者本来是闲来无事想跑起来试一下效果，但是找了一些文档都不是说的很明白。而且很多都是使用的是sharding-jdbc-core ，但是我们现在开发应该很少用spring mvc开发吧，大部分都是springboot开发，所以还是想用starter的方式。经历不断试错后搭建起最简单的、配置代码最少的测试案例。如果帮助到了你帮忙点赞啊。 一、引入依赖 mybatis-spring-boot-starte
Sharding-JDBC 5.2.0快速集成Springboot2.3.2
最新发布
tianqi11的博客
04-24 226
！之前记录了一篇Sharding-JDBC5.0.0的，升级成5.2.0配置稍微有点变动，重新记录一下。
springboot 使用shardingsphere-jdbc4.1.1按年月分表
W915120623的博客
12-07 970
访问记录表使用yyyyMM做后缀分表，表会每月自动创建分表规则配置如下文档：https://shardingsphere.apache.org/document/4.1.1/cn/overview/
Sharding-JDBC（二）- Sharding-JDBC介绍
及时当勉励，岁月不待人
09-12 3189
Sharding-JDBC（二）- Sharding-JDBC介绍
shardingjdbc+springboot分库分表
wokeyiba的博客
12-18 419
springboot+shardingjdbc分库分表
SpringBoot 整合 ShardingSphere4.1.1实现分库分表
nuoya989的博客
07-04 4943
ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（计划中）这3款相互独立的产品组成。 他们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于如Java同构、异构语言、容器、云原生等各种多样化的应用场景。
SpringBoot 整合 Sharding-JDBC
热门推荐
qq_35850889的博客
11-25 1万+
SpringBoot 整合 Mybatis Plus Sharding-JDBC
springboot+mybatis+sharding-jdbc整合示例代码
apply_bomb的博客
10-31 334
想要整合个sharding-jdbc，结果sharding-jdbc官网的入门示例居然下载不下来，无奈只能自己搭了个,下面的示例可以直接运行，并且提供了数据库脚本，对新手友好。sharding-jdbc:4.0.1(目前能在maven中找到的最新稳定发布版本)mybatis-plus：(目前能在maven中找到的最新稳定发布版本)测试运行过程和结果请见DemoController.java，都写那了。用于链接mybatis的xml文件。mysql版本：mysql8。mybatis官网链接。
集成sharding-jdbc实现分库分表.zip
12-19
集成sharding-jdbc实现分库分表.zip
Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能
09-07
主要介绍了Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
基于yml 配置方式 ，实现springBoot+sharding-jdbc+mybatis-plus 实现分库分表，读写分离，以及全局表，子表的配置
10-26
1、基于yml 配置方式 ，实现springBoot+sharding-jdbc+mybatis-plus 实现分库分表，读写分离，以及全局表，子表的配置。 2、实现mybatis-plus 整合到springboot 详细使用请看 测试用例
SpringBoot_shardDB_shardTable:SpringBoot集成Sharding-JDBC实现分库分表，自定义分片算法，基于一致性hash算法，易于扩容
05-31
整合了 Sharding-JDBC ，实现了 分库分表，并且在分库分表中实现了自定义的分片算法; 一致性Hash算法，易于扩容；添加了 单元测试，使用Spring提供的RestTemplate调用RestFul风格的API接口；整合了 quartz 定时任务...
springboot集成Sharding-JDBC
学亮编程手记
01-20 679
Sharding-JDBC是Apache ShardingSphere的一个子项目，它是一个轻量级的Java框架，用于实现分库分表。使用：在业务代码中，直接使用Repository接口进行CRUD操作，Sharding-JDBC会根据配置自动路由到正确的数据源和表。通过以上步骤，Sharding-JDBC就能基于配置的规则对SQL请求进行解析、路由以及结果归并，从而透明化地实现了分库分表的功能。中添加Sharding-JDBC的依赖。在上述配置中，我们定义了两个数据源。中配置多个数据源和分片策略。
shardingsphere-jdbc基础配置(4.1.1)
dengdai123654的博客
01-26 2084
shardingsphere基本配置
SpringBoot 2.2.5 整合Sharding-JDBC 4.1.1 自定义复合分片算法进行分库分表，并配置主从分离
qq_43659871的博客
12-19 760
定位为轻量级Java框架，在Java的JDBC层提供的额外服务。它使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。适用于任何基于JDBC的ORM框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template或直接使用JDBC。支持任何第三方的数据库连接池，如：DBCP, C3P0, BoneCP, Druid, HikariCP等。支持任意实现JDBC规范的数据库。
ShardingJdbc兼容达梦
guachiqi2340的博客
04-03 1174
本章详细说ShardingJdbc和达梦数据库的扩展和配置问题，ShardingJdbc和DruidDataSource、Mybatis整合的兼容、冲突问题，以及这些问题的解决方案。
Springboot整合shardingsphere-jdbc的5.0.0版本实现分库分表
Luffy的博客
04-15 6919
之前项目中一直使用的是shardingsphere的4.1.0版本，该版本有一些SQL是不支持的，如下。 为了使用例如子查询，case when语句等，今日将项目中的shardingsphere升级到5.0.0版本。该版本不支持项明显减少，更方便开发。 下面以两库十表为例，其中dbm为主库，db1、db2用于分库分表。user表分库分表，student表不分库分表。自定义精准分片策略，以user_id的倒数第一位数字对库数取模作为具体库，user_id的倒数第二三位数字对表数取模作为具体表。详细
若依框架集成sharding-jdbc实现单库分表详细流程
06-07
好的，下面是详细流程： 1. 引入Sharding-JDBC依赖 在pom.xml文件中添加Sharding-JDBC的依赖： ```xml <groupId>org.apache.shardingsphere ...以上就是使用Sharding-JDBC实现单库分表的详细流程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值