mybatis动态表名(分库分表)

已于 2023-08-15 15:04:23 修改
阅读量712 收藏 1
点赞数
文章标签： mybatis mysql
于 2023-08-15 14:45:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CTLLIN/article/details/132298615
版权 
//测试代码
@RestController
public class UserController {

    @Resource
    private UserMapper userMapper;


    @Autowired
    MysqlTbNameUtil mysqlTbNameUtil;

    @GetMapping("/selectByAge")
    @ResponseBody
    public Object selectByAge() {
        return mysqlTbNameUtil.getMapperPlus(UserMapper.class, "tb001").selectByAge(27);
//        return userMapper.selectByAge(27);
    }

    @GetMapping("/selectByAge2")
    @ResponseBody
    public Object selectByAge2() {
        return mysqlTbNameUtil.getMapperPlus(UserMapper.class, "tb001").selectByAge2(27);
//        return userMapper.selectByAge2(27);
    }

    @GetMapping("/selectByAgeAndName")
    @ResponseBody
    public Object selectByAgeAndName() {
        return mysqlTbNameUtil.getMapperPlus(UserMapper.class, "tb001").selectByAgeAndName(1, "ctl");
//        return userMapper.selectByAgeAndName(1, "ctl");
    }

    @GetMapping("/selectByAgeAndName2")
    @ResponseBody
    public Object selectByAgeAndName2() {
        return mysqlTbNameUtil.getMapperPlus(UserMapper.class, "tb001").selectByAgeAndName2(1, "ctl");
//        return userMapper.selectByAgeAndName2(1, "ctl");
    }

    @GetMapping("/selectByUser")
    @ResponseBody
    public Object selectByUser() {
        return mysqlTbNameUtil.getMapperPlus(UserMapper.class, "tb001").selectByUser(new User().withAge(1));
//        return userMapper.selectByUser(new User().withAge(1));
    }

    @GetMapping("/selectByUser2")
    @ResponseBody
    public Object selectByUser2() {
        return mysqlTbNameUtil.getMapperPlus(UserMapper.class, "tb001").selectByUser2(new User().withId(1L));
//        return userMapper.selectByUser2(new User().withId(1L));
    }

    @GetMapping("/selectByMap")
    @ResponseBody
    public Object selectByMap() {
        Map<String, Object> map = new HashMap<>();
        map.put(User.Fields.age.name(), "27");
        return mysqlTbNameUtil.getMapperPlus(UserMapper.class, "tb001").selectByMap(map);
//        return userMapper.selectByMap(map);
    }

    @GetMapping("/update")
    @ResponseBody
    public Object update() {

        return mysqlTbNameUtil.getMapperPlus(UserMapper.class, "tb001").update(new User().withId(26L).withAge(1).withUserName("ctl").withAddress("新乡" + System.currentTimeMillis()));
//        return userMapper.update(new User().withId(26L).withAge(1).withUserName("ctl").withAddress("新乡" + System.currentTimeMillis()));
    }

}



//mapper.java

@Mapper
public interface UserMapper {

    List<User> selectByAgeAndName(int age,String userName);
    List<User> selectByAgeAndName2(@Param("age") int age2,@Param("name") String userName2);

    List<User> selectByAge(@Param("age") int age2);

    List<User> selectByAge2(int age3);

    List<User>  selectByUser(User user);
    List<User>  selectByUser2(@Param("u") User user);
    List<User>  selectByMap(Map<String,Object> user);

    long update(User user);

}



//mapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ctl.domain.mapper.UserMapper">

    <resultMap id="userResultMap" type="com.ctl.domain.model.User">
        <result column="id" property="id"/>
        <result column="user_name" property="userName"/>
        <result column="age" property="age"/>
        <result column="address" property="address"/>
    </resultMap>

    <select id="selectByAge" resultMap="userResultMap">
        SELECT * FROM user where age=#{age}
    </select>
    <select id="selectByAge2" resultMap="userResultMap">
        SELECT * FROM user where age=#{id}
    </select>
    <select id="selectByAgeAndName" resultMap="userResultMap">
        SELECT * FROM user where user_name = #{param2} and age=#{param1}
    </select>
    <select id="selectByAgeAndName2" resultMap="userResultMap">
        SELECT * FROM user where user_name = #{name} and age=#{age}
    </select>
    <select id="selectByUser" resultMap="userResultMap">
        SELECT * FROM user
        <where>
            <if test="userName!=null and userName!=''">
                user_name = #{userName}
            </if>
            <if test="age!=null ">
                age = #{age}
            </if>
            <if test="id!=null ">
                id = #{id}
            </if>
        </where>
    </select>
    <select id="selectByUser2" resultMap="userResultMap">
        SELECT * FROM user
        <where>
            <if test="u.userName!=null and u.userName!=''">
                user_name = #{u.userName}
            </if>
            <if test="u.age!=null ">
                age = #{u.age}
            </if>
            <if test="u.id!=null ">
                id = #{u.id}
            </if>
        </where>
    </select>
    <select id="selectByMap" resultMap="userResultMap">
        SELECT * FROM user
        <where>
            <if test="userName!=null and userName!=''">
                user_name = #{userName}
            </if>
            <if test="age!=null ">
                age = #{age}
            </if>
            <if test="id!=null ">
                id = #{id}
            </if>
        </where>
    </select>
 
    <update id="update" parameterType="com.ctl.domain.model.User">
        update user
        <set>
            <if test="userName!=null and userName!=''">
                user_name = #{userName},
            </if>
            <if test="age!=null ">
                age = #{age},
            </if>
            <if test="address!=null and address!=''">
                address = #{address},
            </if>
        </set>
        where id = #{id,jdbcType=INTEGER}
    </update>
</mapper>



//MysqlTbNameUtil
@Component("mysqlTbNameUtil")
public class MysqlTbNameUtil {
    public static final String TB_PREFIX_PARAMKEY="tbPrefix";

    private final  ThreadLocal<String> holder= new ThreadLocal<>();
    public String get(){
        String value = holder.get();
        return ObjectUtils.isEmpty(value)?"":value;
    }
    public void set(String prefix){
        if(prefix==null){
            throw new RuntimeException("tenantId not null.");
        }
        holder.set(prefix);
    }
    public void clear(){
        holder.remove();
    }

    public <T> T getMapperPlus(Class<T> clazz, String prefix) {
        try {
            holder.set(prefix + "_");
            return SpringContextUtils.getApplicationContext().getBean(clazz);
        } catch (Exception e) {
            return null;
        }
    }

}




//ReplaceTablePlugin

/**
 * mybatis插件实现动态表名，可以拦截器新增、编辑、删除、查询等
 * MyBatis插件是一种拦截器，可以在MyBatis某个行为执行时进行拦截并改变这个行为。
 * 通常，MyBatis的插件可以作用于MyBatis中的四大接口，
 * 分别为Executor，ParameterHandler，ResultSetHandler和StatementHandler
 */
@Component
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})})
public class ReplaceTablePlugin implements Interceptor {
    @Autowired
    MysqlTbNameUtil mysqlTbNameUtil;
    private static final Logger log = LoggerFactory.getLogger(ReplaceTablePlugin.class);

    private final static Map<String, String> TABLE_MAP = new LinkedHashMap<>();

    /**
     * 需要替换的表(替换前的表名和替换后的表名)
     * 方案一、直接使用TABLE_MAP的表替换,写死不友好
     * 方案二、使用mysqlTbNameUtil获取前缀,友好且线程安全
     */
    static {
//        TABLE_MAP.put("user", "tb001_user");
        TABLE_MAP.put("user", "");
    }

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler statementHandler = realTarget(invocation.getTarget());
        MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
        doTable(statementHandler, metaObject);
        return invocation.proceed();
    }

    /**
     * 是否为基本数据类型
     *
     * @param clazz
     * @return
     */
    public static boolean isPrimitiveType(Class<?> clazz) {
        List<String> extracted = extracted();
        return extracted.contains(clazz.getName());
    }

    private static List<String> extracted() {
        List<String> list = new ArrayList<>();
        list.add(Boolean.class.getName());
        list.add(Byte.class.getName());
        list.add(Character.class.getName());
        list.add(Short.class.getName());
        list.add(Integer.class.getName());
        list.add(Long.class.getName());
        list.add(Float.class.getName());
        list.add(Double.class.getName());
        list.add(String.class.getName());
        list.add(Date.class.getName());
        list.add(LocalDate.class.getName());
        list.add(LocalDateTime.class.getName());
        return list;
    }

    /**
     * 是否为基本数据类型
     *
     * @param obj
     * @return
     */
    public static boolean isPrimitiveType(Object obj) {
        return isPrimitiveType(obj.getClass());
    }

    private void doTable(StatementHandler handler, MetaObject metaStatementHandler) throws ClassNotFoundException {
        BoundSql boundSql = handler.getBoundSql();
        String originalSql = boundSql.getSql();
        ParameterHandler parameterHandler = handler.getParameterHandler();
        Object parameterObject = parameterHandler.getParameterObject();
        boolean primitiveType = isPrimitiveType(parameterObject);
        if (primitiveType) {
            MapperMethod.ParamMap paramMap = new MapperMethod.ParamMap();
            paramMap.put("id", parameterObject);
            paramMap.put(TB_PREFIX_PARAMKEY, mysqlTbNameUtil.get());
            ReflectUtil.setFieldValue(parameterHandler, "parameterObject", paramMap);
            log.info("基本类型{},更改为ParamMap={}", parameterObject.getClass().getName(), paramMap);
        } else {
            if (parameterObject instanceof MapperMethod.ParamMap) {
                MapperMethod.ParamMap paramMap = (MapperMethod.ParamMap) parameterObject;
                paramMap.put(TB_PREFIX_PARAMKEY, mysqlTbNameUtil.get());
                log.info("非基本类型ParamMap,更新为ParamMap={}", paramMap);
            } else {
                Map<String, Object> map = new HashMap<>();
                BeanUtil.beanToMap(parameterObject, map, false, true);
                MapperMethod.ParamMap paramMap = new MapperMethod.ParamMap();
                paramMap.put(TB_PREFIX_PARAMKEY, mysqlTbNameUtil.get());
                paramMap.putAll(map);
                ReflectUtil.setFieldValue(parameterHandler, "parameterObject", paramMap);
                log.info("非基本类型{},更改为ParamMap={}", parameterObject.getClass().getName(), paramMap);
            }
        }
        log.info("parameterObject={}", JacksonMapper.getJsonStr(parameterHandler.getParameterObject()));
        if (originalSql != null && !originalSql.equals("")) {
            log.info("拦截前的sql:{}", originalSql);
            originalSql= originalSql.replace(","," , ").replaceAll("\\s+", " ").replaceAll("\\n"," ");
            if (isReplaceTableName(originalSql)) {
                originalSql = replaceTableName(originalSql);
                log.info("拦截后的sql:{}", originalSql);
                metaStatementHandler.setValue("delegate.boundSql.sql", originalSql);
            }
        }
    }

    private boolean isReplaceTableName(String sql) {
        TablesNamesFinder tablesNamesFinder = new TablesNamesFinder();
        try {
            List<String> tableList = tablesNamesFinder.getTableList(CCJSqlParserUtil.parse(sql));
            String[] splits = sql.split(" ");
            for (int i = 0; i < splits.length; i++) {
                String split = splits[i].toLowerCase();
                if (!ObjectUtils.isEmpty(TABLE_MAP.keySet().contains(split)) && tableList.contains(split)) {
                    return true;
                }
            }
        } catch (Exception e) {
            log.error("", e);
        }
        return false;
    }

    /**
     * 替换sql中的表名得到分表表名
     * @param sql
     * @return
     */
    private String replaceTableName(String sql) {
        TablesNamesFinder tablesNamesFinder = new TablesNamesFinder();
        try {
            List<String> tableList = tablesNamesFinder.getTableList(CCJSqlParserUtil.parse(sql));
            log.info("tableList={}", tableList);
            String[] splits = sql.split(" ");
            for (int i = 0; i < splits.length; i++) {
                String split = splits[i].toLowerCase();
                if (!ObjectUtils.isEmpty(TABLE_MAP.keySet().contains(split)) && tableList.contains(split)) {
                    splits[i]=mysqlTbNameUtil.get()+split;
                }
            }
            StringJoiner stringJoiner =new StringJoiner(" ");
            for (int i = 0; i < splits.length; i++) {
                stringJoiner.add(splits[i]);
            }
            return stringJoiner.toString();
        } catch (Exception e) {
            log.error("", e);
        }
        return sql;
    }
    @Override
    public Object plugin(Object target) {
        if (target instanceof StatementHandler) {
            return Plugin.wrap(target, this);
        }
        return target;
    }

    @Override
    public void setProperties(Properties properties) {
    }

    public static <T> T realTarget(Object target) {
        if (Proxy.isProxyClass(target.getClass())) {
            MetaObject metaObject = SystemMetaObject.forObject(target);
            return realTarget(metaObject.getValue("h.target"));
        }
        return (T) target;
    }
}

mongo动态分表参看 mongodb动态分表_ctllin的博客-CSDN博客



CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(128) NOT NULL DEFAULT '' COMMENT '用户名',
  `age` int(11) NOT NULL  COMMENT '年龄',
  `address` varchar(128) COMMENT '地址',
   PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8mb4 COMMENT='用户表';



CREATE TABLE `tb001_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(128) NOT NULL DEFAULT '' COMMENT '用户名',
  `age` int(11) NOT NULL  COMMENT '年龄',
  `address` varchar(128) COMMENT '地址',
   PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

ctllin
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring MVC +Spring + Mybatis 构建分库分表源码
03-10
本资源对应博文：http://blog.csdn.net/buchengbugui/article/details/60972176，可以通过博文进行学习，博文有详细教程，以及代码。
sharding + mybatis-plus 分库分表
02-15
sharding-jdbc 分库分表 CRUD
Mybatis创建表，动态表名
qq_39628803的博客
10-19 207
【代码】Mybatis创建表，动态表名。
Mybatis-Plus 之【动态表名】
t194978的博客
02-24 1223
MybatisPlus【动态表名（这里介绍按天分表）】前言一、方案一（动态传参）使用方法（Mapper自定义SQL）二、方案二(DynamicTableNameInnerInterceptor插件)使用方法（插件配置+ThreadLocal+辅助类）三、方案三(DynamicTableNameInnerInterceptor插件、省略辅助类)使用方法（插件配置+ThreadLocal）总结注意在某些情况下，需要将大量数据分散到多个数据表中，这样可以提高数据库的查询效率和数据处理能力。
mybatis-plus技巧--动态表名-多语句-拼接sql--关于mybatis的mysql分页查询总数的优化思考
余的日常学习
11-03 2894
mybatis-plus技巧--动态表名-多语句-拼接sql--关于mybatis的mysql分页查询总数的优化思考
MyBatis Plus中的动态表名实践
qq_30895747的博客
02-22 616
随着数据库应用的不断发展，面对复杂多变的业务需求，动态表名的处理变得愈发重要。在 MyBatis Plus（以下简称 MP）这一优秀的基于 MyBatis 的增强工具的支持下，我们可以更便捷地应对动态表名的挑战。本文将深入研究如何在实际项目中灵活运用 MyBatis Plus 处理动态表名，探讨相关的最佳实践。
mybatis动态表名，列名
q1424966670的博客
09-16 8484
@Override public Integer handleAlarmBatchRecovery(Map<String, Object> paramMap) { String idString = (String)paramMap.get("auuid");//旧告警id,sac告警id,新告警auuid String[] idList = idString.split(","); List<String> list = Arrays.asList(idList);.
Java --- mybatis动态设置表名
qq_46093575的博客
06-04 4117
无
mybatis-plus动态表名实现
热门推荐
zhangsuhua0702的博客
02-07 1万+
mybatis-plus动态表名实现 1.使用场景 一个mybatis entity 对应多张表（表明不同的表–> 多张表结构一致只有表名称不同），在使用时，可以动态映射表名称。 比如：按照时间分表，某些业务冷热数据分离后数据存在不同的表中等 2.一定要时常注意工具的更新，不吃亏 因为工作需要，最近需要实现一个类似如下业务等功能交互： 简单的描述就是：有一部分的表数据，采用了外部同步的模式，同步到了doris中，在业务中采用双数据源的方式，数据写在mysql，读走doris （此处不考虑数据同步的延
Mybatis动态设置表名
qq_47905231的博客
05-27 4140
有时在开发过程中java代码中的表名和数据库的表名并不是一致的，此时我们就需要动态的设置java代码中的表名。 实例如下： 原来的表名是user /*** 动态设置表名，查询所有的用户信息 定义接口代码： 使用@Param()定义表名 * @param tableName * * @return */ List<User> getAllUser(@Param("tableName") String tableName); mapper.xml配置sql语句，from后面是${tabl
动态表名实现（水平分表 mybatis 实例）
先养只猫的博客
07-18 3092
水平分表后如何实现动态表名（Mybatis）
spring动态数据源+mybatis分库分表
03-08
spring动态数据源整合mybatis实现的分库分表操作。 分库分表对业务代码是透明的，只需要在配置文件分配分库模版即可动态的实现分库分表的增删改查操作。
MyBatis实现Mysql数据库分库分表操作和总结（推荐）
08-29
主要介绍了MyBatis实现Mysql数据库分库分表操作和总结,需要的朋友可以参考下
Mybatis动态调用表名和字段名的解决方法
09-01
今天在项目开发中有个业务是需要限制各个用户对某些表里的字段查询以及某些字段是否显示，这种情况下，就需要构建sql来动态传入表名、字段名了,下面给大家介绍mybatis动态调用表名和字段名的解决方法，一起看看吧
Mysql_数据库事务
最新发布
weixin_69252724的博客
04-26 580
事务就是由单独单元的一个或多个sql语句组成，在这个单元中，每个sql语句都是相互依赖的。而整个单独单元是作为一个不可分割的整体存在，类似于化学当中的原子（一种不可分割的最小单位）。往通俗的讲就是，事务就是一个整体，里面的内容要么都执行成功，要么都不成功。不可能存在部分执行成功而部分执行不成功的情况。就是说如果单元中某条sql语句一旦执行失败或者产生错误，那么整个单元将会回滚(返回最初状态)。
MySQL--数据的增删改
pzn2506的博客
04-19 689
文中[ ]里面的内容可写可不写文中[ ]里。
一文整理完MySQL关系型数据库相关知识
打代码是一天，不打代码也是一天
04-23 1079
在开发中，数据库是专门用来存取数据的软件。数据库的职责就是管理数据的。根据存取数据的类型分为关系型数据库和非关系型数据库数据存储后呈现出来的效果类似上图的，是关系型数据库数据存储后呈现出来的效果类似上图的，是非关系型数据库。
MySQL 全表扫描成本计算
ZL4120505的博客
04-20 856
private:......IO 成本：从磁盘或内存读取数据页的成本。CPU 成本：访问记录需要消耗的 CPU 成本。导入成本：这一项直到 MySQL 8.0.29 都还没有被使用，先忽略。内存成本：这一项指的是占用内存字节数，计算 MRR（Multi Range Read）方式读取数据的成本时才会用到，也先忽略。全表扫描的成本就只剩 IO 成本、CPU 成本这两项了。全表扫描成本 =io_cost+ 1.1 +cpu_cost+ 1。
mybatis 动态表名
11-15
Mybatis可以通过动态SQL来实现动态表名的功能。下面是一个简单的例子： ```xml <select id="selectUserById" resultType="User"> SELECT * FROM ${tableName} WHERE id = #{id} </select> ``` 在这个例子中，`${tableName}`就是动态表名的部分，它会在运行时被替换成实际的表名。在Java代码中，可以通过传递一个包含表名的Map来实现动态表名的功能： ```java Map<String, Object> params = new HashMap<>(); params.put("tableName", "user_201901"); params.put("id", 1); User user = sqlSession.selectOne("selectUserById", params); ``` 在这个例子中，我们将表名作为一个参数传递给了Mybatis的SQL语句，Mybatis会将`${tableName}`替换成实际的表名，从而实现动态表名的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值