目前动态数据源注解只对mapper.java做了适配，现在需要优化完善，可以针对 自动注入的mapp...

下面给一套「字段（注入点）> 方法 > 类」完整适配方案，并且把你现在的 ThreadLocal 单值改成 栈（Stack）上下文，解决嵌套调用时“内层 clear 把外层数据源清掉”的隐患，同时实现“高优先级不被低优先级覆盖；同优先级内层可覆盖外层”。

---

1）新增优先级枚举

java
package com.wiscom.basic.config.datasource;

public enum DataSourcePriority {
    DEFAULT(0),
    CLASS(1),
    METHOD(2),
    FIELD(3);

    private final int level;

    DataSourcePriority(int level) {
        this.level = level;
    }

    public int level() {
        return level;
    }
}

---

2）新增上下文 Holder（ThreadLocal + Deque）

关键点：

• 支持嵌套：push / pop 恢复外层
• 覆盖规则：priority >= 当前priority 时允许覆盖（同优先级也允许内层覆盖外层）
• 如果候选值与当前完全相同，则不 push（减少开销）

java
package com.wiscom.basic.config.datasource;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Objects;

public final class DynamicDataSourceContextHolder {

    private DynamicDataSourceContextHolder() {
    }

    private static final ThreadLocal<Deque<Context>> HOLDER = ThreadLocal.withInitial(ArrayDeque::new);

    public static String peek() {
        Context ctx = HOLDER.get().peek();
        return ctx == null ? null : ctx.name;
    }

    public static int peekPriority() {
        Context ctx = HOLDER.get().peek();
        return ctx == null ? Integer.MIN_VALUE : ctx.priority;
    }

    /**
     * 尝试切换数据源：
     * - 当 priority >= 当前 priority 时允许覆盖（同优先级内层覆盖外层）
     * - 当候选与当前完全一致时不入栈
     *
     * @return 是否真的发生了 push（发生 push 才需要 pop）
     */
    public static boolean pushIfNeeded(String name, int priority) {
        String current = peek();
        int currentPriority = peekPriority();

        if (Objects.equals(name, current) && priority == currentPriority) {
            return false;
        }
        if (priority >= currentPriority) {
            HOLDER.get().push(new Context(name, priority));
            return true;
        }
        return false;
    }

    public static void pop() {
        Deque<Context> deque = HOLDER.get();
        if (!deque.isEmpty()) {
            deque.pop();
        }
        if (deque.isEmpty()) {
            HOLDER.remove();
        }
    }

    private static final class Context {
        private final String name;
        private final int priority;

        private Context(String name, int priority) {
            this.name = name;
            this.priority = priority;
        }
    }
}

---

3）改造 DynamicDataSource：使用栈上下文 + setDataSource 返回是否 push

java
package com.wiscom.basic.config.datasource;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

import javax.sql.DataSource;
import java.util.Map;

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return getDataSource();
    }

    /** 兼容旧调用：默认优先级 DEFAULT */
    public static boolean setDataSource(String dataSource) {
        return setDataSource(dataSource, DataSourcePriority.DEFAULT.level());
    }

    /** 新调用：带优先级 */
    public static boolean setDataSource(String dataSource, int priority) {
        return DynamicDataSourceContextHolder.pushIfNeeded(dataSource, priority);
    }

    public static String getDataSource() {
        return DynamicDataSourceContextHolder.peek();
    }

    public static void clearDataSource() {
        DynamicDataSourceContextHolder.pop();
    }

    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }
}

---

4）改造 Aspect：字段 > 方法 > 类（并且“字段”适配自动注入 mapper）

实现要点：

• 字段（FIELD）：在当前执行的 Bean（通常是 Service/Dao）里扫描：
  @Autowired/@Resource 且字段类型是 mapper/dao（按包名或注解判断），并且字段上有 @TargetDataSource
  • 若扫描到 多个不同数据源，无法判定该方法用哪个 mapper，安全起见忽略字段规则，降级走方法/类（建议这种场景用方法注解明确指定）
• 方法（METHOD）：优先取“最具体实现方法”（兼容 CGLIB / 继承），再取接口方法
• 类（CLASS）：目标类、其接口、以及声明类型（mapper interface）都查一遍
• 默认：elss
• 嵌套恢复：只有当本次真的 push 了，finally 才 pop

java
package com.wiscom.basic.config.datasource;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;

@Component
@Aspect
@Slf4j
@Order(-100)
public class TargetDataSourceAspect {

    private static final String DEFAULT_DS = "elss";

    @Pointcut("execution(* com.wiscom..*.service..*.*(..)) || execution(* com.wiscom..*.dao..*.*(..)) || execution(* com.wiscom..*.mapper..*.*(..))")
    private void dsPointCut() {
    }

    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        ResolveResult rr = resolveDataSource(joinPoint);

        String ds = (rr != null && StringUtils.hasText(rr.dsName)) ? rr.dsName : DEFAULT_DS;
        int priority = (rr != null) ? rr.priority.level() : DataSourcePriority.DEFAULT.level();

        boolean pushed = DynamicDataSource.setDataSource(ds, priority);

        if (pushed) {
            log.debug("切换数据源 => {} (priority={})", ds, priority);
        } else {
            log.debug("保持数据源 => {} (currentPriority >= {})", DynamicDataSource.getDataSource(), priority);
        }

        try {
            return joinPoint.proceed();
        } finally {
            if (pushed) {
                DynamicDataSource.clearDataSource();
                log.debug("数据源上下文已恢复/弹栈");
            }
        }
    }

    private ResolveResult resolveDataSource(ProceedingJoinPoint joinPoint) {
        MethodSignature ms = (MethodSignature) joinPoint.getSignature();
        Method signatureMethod = ms.getMethod();
        Class<?> declaringType = ms.getDeclaringType();

        Object target = joinPoint.getTarget();
        Class<?> targetClass = (target != null) ? AopUtils.getTargetClass(target) : declaringType;

        // 1) 字段：自动注入 mapper 字段（FIELD 最高）
        ResolveResult byField = resolveByAutowiredMapperField(targetClass);
        if (byField != null) {
            return byField;
        }

        // 2) 方法：mapper.java 具体方法（METHOD）
        ResolveResult byMethod = resolveByMethod(signatureMethod, targetClass);
        if (byMethod != null) {
            return byMethod;
        }

        // 3) 类：mapper 类/接口（CLASS）
        ResolveResult byClass = resolveByClass(targetClass, declaringType);
        if (byClass != null) {
            return byClass;
        }

        // 4) 默认
        return new ResolveResult(DEFAULT_DS, DataSourcePriority.DEFAULT);
    }

    /**
     * 解析字段注解：仅当能“唯一确定一个数据源”时才返回。
     * 如果发现多个不同的数据源（多个 mapper 字段各自标了不同 ds），则忽略字段规则，避免误切换。
     */
    private ResolveResult resolveByAutowiredMapperField(Class<?> targetClass) {
        if (targetClass == null) {
            return null;
        }

        Set<String> dsNames = new LinkedHashSet<>();

        for (Field field : getAllFields(targetClass)) {
            // 只处理注入字段（你说的“自动注入 mapper 字段”）
            if (!isInjectionField(field)) {
                continue;
            }
            // 只处理 mapper/dao 类型字段，避免误伤其它注入字段
            if (!looksLikeMapperOrDao(field.getType())) {
                continue;
            }

            TargetDataSource ann = AnnotatedElementUtils.findMergedAnnotation(field, TargetDataSource.class);
            if (ann == null || !StringUtils.hasText(ann.name())) {
                continue;
            }
            dsNames.add(ann.name());
        }

        if (dsNames.isEmpty()) {
            return null;
        }

        if (dsNames.size() == 1) {
            String ds = dsNames.iterator().next();
            return new ResolveResult(ds, DataSourcePriority.FIELD);
        }

        // 多个 mapper 字段对应多个数据源：无法判断当前方法用哪个 mapper => 安全降级
        log.warn("发现多个 @TargetDataSource 注入字段且数据源不同：{}，本次不使用字段优先级，建议用方法注解明确指定", dsNames);
        return null;
    }

    private ResolveResult resolveByMethod(Method signatureMethod, Class<?> targetClass) {
        if (signatureMethod == null) {
            return null;
        }

        // 取“最具体方法”（兼容 CGLIB / 继承）
        Method specific = (targetClass != null) ? AopUtils.getMostSpecificMethod(signatureMethod, targetClass) : signatureMethod;

        TargetDataSource ann = AnnotatedElementUtils.findMergedAnnotation(specific, TargetDataSource.class);
        if (ann == null) {
            // 兼容 JDK 代理时注解写在接口方法上
            ann = AnnotatedElementUtils.findMergedAnnotation(signatureMethod, TargetDataSource.class);
        }

        if (ann != null && StringUtils.hasText(ann.name())) {
            return new ResolveResult(ann.name(), DataSourcePriority.METHOD);
        }
        return null;
    }

    private ResolveResult resolveByClass(Class<?> targetClass, Class<?> declaringType) {
        // 目标类
        TargetDataSource ann = (targetClass != null)
                ? AnnotatedElementUtils.findMergedAnnotation(targetClass, TargetDataSource.class)
                : null;

        // 目标类接口（mapper 通常是接口）
        if (ann == null && targetClass != null) {
            for (Class<?> itf : targetClass.getInterfaces()) {
                ann = AnnotatedElementUtils.findMergedAnnotation(itf, TargetDataSource.class);
                if (ann != null) {
                    break;
                }
            }
        }

        // 声明类型（MethodSignature.getDeclaringType()）
        if (ann == null && declaringType != null) {
            ann = AnnotatedElementUtils.findMergedAnnotation(declaringType, TargetDataSource.class);
        }

        if (ann != null && StringUtils.hasText(ann.name())) {
            return new ResolveResult(ann.name(), DataSourcePriority.CLASS);
        }
        return null;
    }

    private boolean isInjectionField(Field field) {
        return field.isAnnotationPresent(Autowired.class) || field.isAnnotationPresent(Resource.class);
    }

    /**
     * 你可以按项目实际情况增强判断：
     * - 包名包含 .mapper. / .dao.
     * - 或者类型/接口上有 @Mapper/@Repository 等
     */
    private boolean looksLikeMapperOrDao(Class<?> type) {
        if (type == null) {
            return false;
        }
        String name = type.getName();
        return name.contains(".mapper.") || name.contains(".dao.");
    }

    private List<Field> getAllFields(Class<?> type) {
        List<Field> fields = new ArrayList<>();
        Class<?> cur = type;
        while (cur != null && cur != Object.class) {
            fields.addAll(Arrays.asList(cur.getDeclaredFields()));
            cur = cur.getSuperclass();
        }
        return fields;
    }

    private static final class ResolveResult {
        private final String dsName;
        private final DataSourcePriority priority;

        private ResolveResult(String dsName, DataSourcePriority priority) {
            this.dsName = dsName;
            this.priority = priority;
        }
    }
}

---

5）怎么用（覆盖关系示例）

A. 自动注入 mapper 字段（最高优先级）

java
@Service
public class DemoService {

    @Autowired
    @TargetDataSource(name = "envs")
    private DemoMapper demoMapper;

    public void biz() {
        demoMapper.selectX(); // => envs
    }
}

B. mapper 方法级（字段不存在/无法唯一确定时生效）

java
@Mapper
public interface DemoMapper {

    @TargetDataSource(name = "auto-dm")
    List<String> selectX();
}

C. mapper 类/接口级（字段、方法都没有时生效）

java
@TargetDataSource(name = "ypm-sync")
@Mapper
public interface DemoMapper {
    List<String> selectX();
}

---

6）你现在代码里一个“隐患”已经顺手修掉了

你原来是单值 ThreadLocal + 每层 finally clear：

• service 方法进来 set
• mapper 方法进来 set
• mapper finally clear（把 service 的也清掉了）

改成 栈 之后：

• 内层 pop 只会恢复外层，不会把外层直接 remove 掉。

---

如果你们确实存在“一个 Service 同时注入多个 mapper 且各自不同数据源”的场景，我建议的做法是：字段注解只作为默认值，具体分支用 方法注解 明确标注（因为仅靠 AOP 无法知道某个 service 方法内部到底会用哪个字段）。我上面的实现也按这个原则做了“多字段不同 ds => 安全降级”。