// 原方法
@Select("SELECT * FROM user WHERE id = #{id}")
User selectById(@Param("id") Long id); 
// DM專用方法（僅當(dāng)原SQL不兼容時(shí)需實(shí)現(xiàn)）
@Select("SELECT * FROM user WHERE id = #{id}") // 修改后的DM兼容SQL
User selectByIdDM(@Param("id") Long id);

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; // 數(shù)據(jù)庫(kù)類(lèi)型配置
 
  @Override
  public Object plugin(Object target) {
    return Plugin.wrap(target, this); // 包裝目標(biāo)對(duì)象
  }
 
  @Override
  public void setProperties(Properties properties) {} // 設(shè)置屬性方法
 
  @Override
  public Object intercept(Invocation invocation) throws Throwable {
    System.out.println("intercept-開(kāi)始執(zhí)行方法-" + invocation.getMethod().getName());
    // 獲取StatementHandler
    Object[] args = invocation.getArgs(); // 方法參數(shù)
    MappedStatement ms = (MappedStatement) args[0]; // 映射語(yǔ)句
    String methodId = ms.getId(); // 方法ID
    RowBounds rowBounds = (RowBounds)args[2];
    // 如果是DM數(shù)據(jù)庫(kù)且方法名不帶Dm后綴
    if ("dm".equals(dbType) && !methodId.endsWith("DM")) {
      try {
        // 嘗試查找對(duì)應(yīng)的Dm方法
        Configuration configuration = ms.getConfiguration();
        // 處理 namespace 邏輯
        String fullMethodId = methodId;
        String noFullMethodId = methodId;
        if (!methodId.contains(".")) {
          // 如果不包含點(diǎn)(.)，說(shuō)明是簡(jiǎn)短的方法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方法則替換執(zhí)行
        if (dmMs != null) {
          BoundSql newBoundSql = dmMs.getBoundSql(parameter);
          log.info("intercept執(zhí)行的方法是-" + dmMethodId);
          args[0] = dmMs; // 替換為DM方法
          if (args.length == 4) {
            args[2] = newBoundSql;
          } else {
            args[5] = newBoundSql;
          }
 
        }
      } catch (Exception e) {
        log.error("intercept-沒(méi)有找到對(duì)應(yīng)的Dm方法-繼續(xù)執(zhí)行原方法-或嘗試使用sql替換-" + methodId,e);
      }
    }
    Object proceed = invocation.proceed(); // 執(zhí)行攔截方法
    log.info(JSONUtil.parse(proceed).toStringPretty()); // 記錄執(zhí)行結(jié)果
    return proceed;
  }
  public MappedStatement getDmMappedStatement(Configuration configuration, String methodId) {
    return configuration.getMappedStatement(methodId);
  }
}

@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);
 
    // 用反射重新設(shè)置 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)轉(zhuǎn)換為to_char(...)格式
   * @param sql
   * @return {@link String}
   */
  public static String convertCastToToChar(String sql) {
    // 正則表達(dá)式匹配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內(nèi)部的表達(dá)式
      String innerExpression = matcher.group(1).trim();
      // 替換為T(mén)O_CHAR格式
      matcher.appendReplacement(result, "TO_CHAR(" + innerExpression + ")");
    }
    matcher.appendTail(result);
 
    return result.toString();
  }

@Configuration
@ConditionalOnExpression("'${spring.datasource.url}'.startsWith('jdbc:dm:')")//必須是達(dá)夢(mèng)的驅(qū)動(dòng)才生效
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());
        };
    }
}

@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;
    }
}

<!-- 通用SQL（所有數(shù)據(jù)庫(kù)都會(huì)嘗試使用） -->
<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（僅達(dá)夢(mèng)使用） -->
<select id="selectUser" resultType="User" databaseId="dm">
  SELECT TOP 1 * FROM user
</select>

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))
                )
 
                // ?? 注意：下面這個(gè)攔截器是追加，而不是覆蓋上面
                .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);
    }
}

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();
    }
}

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());
        }
    }
}

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; // 手動(dòng)強(qiáng)轉(zhuǎn)（運(yùn)行時(shí)）
            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);
                // 重寫(xiě) 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 {
            // 清理，防止內(nèi)存泄漏
            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