服务从mysql迁移达梦数据库的实现方案_Mysql

一、背景

根据信创国产适配要求，针对业务系统迁移至达梦数据库，保持系统稳定、可靠。当前系统技术栈：springboot+mybatis(3.5.9)+mybaits plus 我们采用的是拦截器方案，结合javaagent字节码增强技术，实现最小化代码改动。

二、迁移方案

通过拦截器实现
通过mybatis自带的databaseid 多数据源机制

三、梳理现有使用方式

使用方式	demomapperxml	demomapperanno	demomapper	demobeanservice	querywrap

四、方案实现

4.1 拦截器方式实现

主要实现两个拦截器：

拦截器作用备注 mapper调用方法级别拦截器拦截复杂sql的执行方法精确到单个方法的拦截，仅对达梦不支持的方法进行更改 sql函数拦截器简单的函数替换例如（group_concat->wm_conca ）

4.1.1 方法拦截器

实现原理：

在mybatis调用mapper方法时进行拦截自动将原方法调用重定向到对应的dm版本方法示例:

// 原方法
@select("select * from user where id = #{id}")
user selectbyid(@param("id") long id); 
// dm专用方法（仅当原sql不兼容时需实现）
@select("select * from user where id = #{id}") // 修改后的dm兼容sql
user selectbyiddm(@param("id") long id);

拦截逻辑：

检查是否存在原方法名+dm后缀的方法存在则调用dm版本方法，否则调用原方法

4.1.2 sql函数拦截器

对sql的进行拦截并处理，处理简单函数转换

例如：

group_concat → wm_concat 迁移sql分类处理

类别	处理方式	描述	示例
无需更改	直接执行	dm 数据库原生兼容的 sql 语法，无需任何转换。	`select * from employees where id = 1;`
仅替换函数	函数拦截器处理	仅需将源数据库特有的函数名一对一映射为 dm 的等效函数。	`group_concat(name)` → `wm_concat(name)`
需要重写sql	方法拦截器 + dm 方法	sql 的语义或语法结构不同，需用 dm 的特定语法重写整条语句。	`replace into table ...` → `merge into table ...`
重写sql + 替换函数	方法拦截器 + dm 方法	复杂的 sql 语句，其结构需要重写，并且其中包含需要替换的特殊函数。	包含 `group_concat` 和 `limit` 分页的复杂查询，需重写为使用 `wm_concat` 和 `rownum` 的 dm 语法。

代码整体情况

方法拦截器代码

import cn.hutool.json.jsonutil;
import java.util.properties;
import lombok.extern.slf4j.slf4j;
import org.apache.ibatis.cache.cachekey;
import org.apache.ibatis.executor.executor;
import org.apache.ibatis.mapping.boundsql;
import org.apache.ibatis.mapping.mappedstatement;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.configuration;
import org.apache.ibatis.session.resulthandler;
import org.apache.ibatis.session.rowbounds;
import org.springframework.beans.factory.annotation.value;
import org.springframework.stereotype.component;
 
// 定义拦截器签名
@intercepts({
        @signature(
                type = executor.class,
                method = "update",
                args = {mappedstatement.class, object.class}),
         @signature(
        type = executor.class,
        method = "query",
        args = {mappedstatement.class, object.class, rowbounds.class, resulthandler.class}),
        @signature(
                type = executor.class,
                method = "query",
                args = {mappedstatement.class, object.class, rowbounds.class, resulthandler.class, cachekey.class, boundsql.class})
})
//@component
@slf4j
public class methodinterceptor implements interceptor {
  @value("${task.dbtype:mysql}")
  private string dbtype; // 数据库类型配置
 
  @override
  public object plugin(object target) {
    return plugin.wrap(target, this); // 包装目标对象
  }
 
  @override
  public void setproperties(properties properties) {} // 设置属性方法
 
  @override
  public object intercept(invocation invocation) throws throwable {
    system.out.println("intercept-开始执行方法-" + invocation.getmethod().getname());
    // 获取statementhandler
    object[] args = invocation.getargs(); // 方法参数
    mappedstatement ms = (mappedstatement) args[0]; // 映射语句
    string methodid = ms.getid(); // 方法id
    rowbounds rowbounds = (rowbounds)args[2];
    // 如果是dm数据库且方法名不带dm后缀
    if ("dm".equals(dbtype) && !methodid.endswith("dm")) {
      try {
        // 尝试查找对应的dm方法
        configuration configuration = ms.getconfiguration();
        // 处理 namespace 逻辑
        string fullmethodid = methodid;
        string nofullmethodid = methodid;
        if (!methodid.contains(".")) {
          // 如果不包含点(.)，说明是简短的方法id，需要加上namespace
          string namespace = ms.getresource().replace(".", "/"); // 获取namespace
          fullmethodid = namespace + "." + methodid;
        }else{
           nofullmethodid = methodid.substring(methodid.lastindexof(".") + 1);
        }
 
        string dmfullmethodid = fullmethodid + "dm";
        string dmnofullmethodid = nofullmethodid + "dm";
        string dmmethodid = dmfullmethodid;
        mappedstatement dmms = getdmmappedstatement(configuration, dmfullmethodid);
        if(dmms == null){
          dmmethodid = dmnofullmethodid;
          dmms = getdmmappedstatement(configuration, dmnofullmethodid);
        }
        object parameter = args[1];
        // 如果找到dm方法则替换执行
        if (dmms != null) {
          boundsql newboundsql = dmms.getboundsql(parameter);
          log.info("intercept执行的方法是-" + dmmethodid);
          args[0] = dmms; // 替换为dm方法
          if (args.length == 4) {
            args[2] = newboundsql;
          } else {
            args[5] = newboundsql;
          }
 
        }
      } catch (exception e) {
        log.error("intercept-没有找到对应的dm方法-继续执行原方法-或尝试使用sql替换-" + methodid,e);
      }
    }
    object proceed = invocation.proceed(); // 执行拦截方法
    log.info(jsonutil.parse(proceed).tostringpretty()); // 记录执行结果
    return proceed;
  }
  public mappedstatement getdmmappedstatement(configuration configuration, string methodid) {
    return configuration.getmappedstatement(methodid);
  }
}

sql拦截器代码

@intercepts({
        @signature(
                type = statementhandler.class,
                method = "prepare",
                args = {connection.class, integer.class})
})
@log
public class rewriteinterceptor implements interceptor {
  @override
  public object intercept(invocation invocation) throws throwable {
    // 获取 statementhandler
    statementhandler handler = (statementhandler) invocation.gettarget();
    boundsql boundsql = handler.getboundsql();
    string originalsql = boundsql.getsql();
    log.info("originalsql: " + originalsql.replaceall("\n"," "));
    string rewrittensql = rewritesql(originalsql);
 
    // 用反射重新设置 sql
    field sqlfield = boundsql.getclass().getdeclaredfield("sql");
    sqlfield.setaccessible(true);
    sqlfield.set(boundsql, rewrittensql);
    object proceed = invocation.proceed();
    return proceed;
  }
 
  private string rewritesql(string originalsql) {
    // mysql ifnull(col1,col2) => nvl(col1,col2) dm
      originalsql = originalsql.replaceall("(?i)group_concat", "wm_concat");
      originalsql = originalsql.replaceall("(?i)!json_contains", " not json_contains ");
      originalsql = originalsql.replaceall("(?i)insert\\s+ignore\\s+into", "insert into ");
      originalsql = convertcasttotochar(originalsql);
      log.info("originalsql: " + originalsql+"\nrewrittensql: " + originalsql);
      return originalsql;
  }
 
  /**
   * 将cast(... as char)转换为to_char(...)格式
   * @param sql
   * @return {@link string}
   */
  public static string convertcasttotochar(string sql) {
    // 正则表达式匹配cast(... as char)模式
    pattern pattern = pattern.compile(
            "convert\\s*\\(\\s*(.+?)\\s*,\\s*(?:char|varchar|varchar2|text)\\s*(?:\\(\\d+\\))?\\s*\\)",
            pattern.case_insensitive
    );
 
    matcher matcher = pattern.matcher(sql);
    stringbuffer result = new stringbuffer();
 
    while (matcher.find()) {
      // 获取cast内部的表达式
      string innerexpression = matcher.group(1).trim();
      // 替换为to_char格式
      matcher.appendreplacement(result, "to_char(" + innerexpression + ")");
    }
    matcher.appendtail(result);
 
    return result.tostring();
  }

mybatis2dmautoconfiguration 代码

@configuration
@conditionalonexpression("'${spring.datasource.url}'.startswith('jdbc:dm:')")//必须是达梦的驱动才生效
public class mybatis2dmautoconfiguration {
    @bean
    public dmmethodrouterinterceptor dmmethodrouterinterceptor() {
        return new dmmethodrouterinterceptor();
    }
    @bean
    public rewriteinterceptor rewriteinterceptor() {
        return new rewriteinterceptor();
    }
    @bean
    public configurationcustomizer mybatisconfigurationcustomizer() {
        return configuration -> {
            configuration.addinterceptor(new dmmethodrouterinterceptor());
            configuration.addinterceptor(new rewriteinterceptor());
        };
    }
}

4.2 通过mybatis自带的databaseid 多数据源机制

话不多说，直接上代码。

mybatisconfig 代码

@configuration
public class mybatisconfig {
    
    @bean
    public databaseidprovider databaseidprovider() {
        vendordatabaseidprovider databaseidprovider = new vendordatabaseidprovider();
        properties properties = new properties();
        properties.setproperty("mysql", "mysql");
        properties.setproperty("dm dbms", "dm");
        databaseidprovider.setproperties(properties);
        return databaseidprovider;
    }
}

xml代码

<!-- 通用sql（所有数据库都会尝试使用） -->
<select id="selectuser" resulttype="user">
  select * from user
</select>
 
<!-- mysql专用sql（仅mysql使用） -->
<select id="selectuser" resulttype="user" databaseid="mysql">
  select * from user limit 1
</select>
 
<!-- dm专用sql（仅达梦使用） -->
<select id="selectuser" resulttype="user" databaseid="dm">
  select top 1 * from user
</select>

在运行代码过程中，会根据databaseid来选择数据源运行对象的sql。

方案对比

方案特性	拦截器方式	原生 mybatis databaseid
实现原理	通过自定义 mybatis 拦截器（及javaagent字节码增强）动态解析和重写sql	依赖 mybatis 内置的 `<databaseidprovider>` 和 xml 中 `databaseid` 属性
支持的映射方式
- xml 映射文件 (`demomapperxml`)	✅ 支持	✅ 支持
- 注解方式 (`demomapperanno`)	✅ 支持	❌ 不支持
- mybatis-plus 等扩展 (`demomapper`)	✅ 支持	❌ 不支持
- service/bean 中的直接sql (`demobeanservice`)	✅ 支持	❌ 不支持
- 查询包装器 (`querywrap`)	✅ 支持	❌ 不支持
灵活性	高：可处理任意位置的sql，支持复杂逻辑和函数替换	低：仅限xml中定义的语句，无法处理运行时生成的sql
侵入性	低：对业务代码基本无侵入，通过配置和字节码增强实现	中：需要在所有xml语句中显式定义 `databaseid` 属性
维护成本	集中维护拦截规则，一改全改	分散维护，每个xml语句都需要适配不同数据库的版本

实施步骤

准备工作：对sql及其mapper方法进行分类标注
开发拦截器：实现方法级别拦截逻辑配置函数替换规则
javaagent集成：打包拦截器为javaagent 配置jvm启动参数加载agent
部署上线：添加javaagent到生产环境启动参数代码在最后面，具体的工程我后续会上传至:

github.com/qqinc/mybat…

优势

最小化代码改动：仅需为不兼容的方法添加dm版本非侵入式：通过字节码增强避免直接修改业务代码灵活可控：可精确控制哪些方法需要特殊处理易于维护：dm相关修改集中管理，与主逻辑分离补充点：事务都是支持的

最终实现代码

整体工程结构

rewriteagent

public class rewriteagent {
    public static void premain(string agentargs, instrumentation inst) {
        system.out.println("mysql2dm agent start");
 
        agentbuilder agentbuilder = new agentbuilder.default()
                .with(agentbuilder.redefinitionstrategy.retransformation)
                .with(agentbuilder.listener.streamwriting.tosystemout().withtransformationsonly());
 
// 拦截 baseexecutor.query 和 update
        agentbuilder = agentbuilder
                .type(elementmatchers.named("org.apache.ibatis.executor.baseexecutor"))
                .transform((builder, typedescription, classloader, module) ->
                        builder
                                .method(elementmatchers.named("query").or(elementmatchers.named("update")))
                                .intercept(advice.to(executoradvice.class))
                )
 
                // ⚠️ 注意：下面这个拦截器是追加，而不是覆盖上面
                .type(elementmatchers.named("org.apache.ibatis.executor.statement.routingstatementhandler"))
                .transform((builder, typedescription, classloader, module) ->
                        builder
                                .method(elementmatchers.named("prepare"))
                                .intercept(advice.to(sqlrewriteadvice.class))
                );
        agentbuilder.installon(inst);
    }
}

boundsqlholder

public class boundsqlholder {
    private static final threadlocal<boundsql> holder = new threadlocal<>();
 
    public static void setboundsql(boundsql boundsql) {
        holder.set(boundsql);
    }
 
    public static boundsql getboundsql() {
        return holder.get();
    }
 
    public static void clear() {
        holder.remove();
    }
}

executoradvice

public class executoradvice {
    @advice.onmethodenter
    public static void enter(@advice.allarguments object[] args) {
        try {
            mappedstatement originalms = (mappedstatement) args[0];
            string methodid = originalms.getid();
            if (methodid != null && !methodid.endswith("dm")) {
                configuration config = originalms.getconfiguration();
                string dmmethodid = methodid + "dm";
 
                if (config.hasstatement(dmmethodid)) {
                    mappedstatement dmms = config.getmappedstatement(dmmethodid);
                    system.out.println("[executoradvice] 替换为 dm 方法: " + dmmethodid);
                    args[0] = dmms;
                    object parameter = args[1];
                    boundsql newboundsql = dmms.getboundsql(parameter);
                    boundsqlholder.setboundsql(newboundsql);
                    system.out.println("[executoradvice] 替换后的 sql: " + newboundsql.getsql());
                }
            }
        } catch (exception e) {
            system.err.println("[executoradvice] 替换失败: " + e.getmessage());
        }
    }
}

sqlrewriteadvice

public class sqlrewriteadvice {
    @advice.onmethodenter
    public static void enter(@advice.this object handlerobj,
                             @advice.origin string method,
                             @advice.allarguments object[] args) {
        try {
            statementhandler handler = (statementhandler) handlerobj; // 手动强转（运行时）
            field delegatefield = handler.getclass().getdeclaredfield("delegate");
            delegatefield.setaccessible(true);
            statementhandler realhandler = (statementhandler) delegatefield.get(handler);
            boundsql boundsql = handler.getboundsql();
            boundsql newboundsql = boundsqlholder.getboundsql();
            if (newboundsql != null) {
                string originalsql = newboundsql.getsql();
                system.out.println("original sql: " + originalsql);
                // 重写 sql
                string rewrittensql = rewritesql(originalsql);
                field boundsqlfield = realhandler.getclass().getsuperclass().getdeclaredfield("boundsql");
                boundsqlfield.setaccessible(true);
                boundsqlfield.set(realhandler, newboundsql);
                system.out.println("rewritten sql: " + rewrittensql);
            }else {
                string originalsql = boundsql.getsql();
                system.out.println("original sql: " + originalsql);
                string rewrittensql = rewritesql(originalsql);
                field sqlfield = boundsql.getclass().getdeclaredfield("sql");
                sqlfield.setaccessible(true);
                sqlfield.set(boundsql, rewrittensql);
                system.out.println("rewritten sql: " + rewrittensql);
            }
 
        } catch (exception e) {
            system.out.println("sql rewrite error: " + e);
 
        }finally {
            // 清理，防止内存泄漏
            boundsqlholder.clear();
        }
    }
    public static string rewritesql(string originalsql) {
        originalsql = originalsql.replaceall("(?i)group_concat", "wm_concat");
        originalsql = originalsql.replaceall("(?i)!json_contains", " not json_contains ");
        originalsql = originalsql.replaceall("(?i)insert\\s+ignore\\s+into", "insert into ");
        originalsql = originalsql.replaceall("(?i)group_concat", "wm_concat");
        return originalsql;
    }

在启动方法参数上添加:

-javaagent:e:\\cbimworkspace\\mybatis2dm-agent\\target\\mybatis2dm-agent-1.0-snapshot.jar

完结，撒花！

总结

到此这篇关于服务从mysql迁移达梦数据库的文章就介绍到这了,更多相关mysql迁移达梦数据库内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

服务从mysql迁移达梦数据库的实现方案

2026年05月09日 • Mysql •我要评论