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

下面给你一套可落地的改造方案：同时支持

1. 自动注入的 mapper 字段（@Autowired private XxxMapper xxxMapper; 这种字段上加注解）
2. mapper.java 具体方法（方法上加注解）
3. mapper.java 类/接口（接口上加注解，已有能力）

并且满足你要的优先级：字段 > 方法 > 类。
另外我会顺手把一个“隐形坑”修掉：你现在 AOP 在没注解时强行 setDataSource("elss")，会导致外层先把 elss 写进 ThreadLocal，从而内层 mapper 方法/类注解永远没有机会生效。正确做法是：没匹配到注解时不设置，让 AbstractRoutingDataSource 走默认数据源即可（你已经在 DynamicDataSource(elss, dsMap) 配了默认）。

---

一、增加一个“带优先级 + 支持嵌套”的上下文 Holder

目的：

• 支持嵌套调用时 push/pop 恢复上一个数据源
• 让“字段 > 方法 > 类”的优先级在嵌套场景也成立
• 只有更高/同级优先级才允许覆盖（同级内层覆盖外层更符合直觉）

新增文件：DynamicDataSourceContextHolder.java

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

import org.springframework.util.StringUtils;

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

public final class DynamicDataSourceContextHolder {

    private DynamicDataSourceContextHolder() {
    }

    public enum Priority {
        MANUAL(0),
        FIELD(1),
        METHOD(2),
        CLASS(3);

        private final int level;

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

        public int level() {
            return level;
        }
    }

    private static final class Context {
        private final String key;
        private final Priority priority;

        private Context(String key, Priority priority) {
            this.key = key;
            this.priority = priority;
        }
    }

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

    public static String peek() {
        Deque<Context> deque = HOLDER.get();
        return deque.isEmpty() ? null : deque.peek().key;
    }

    public static Priority peekPriority() {
        Deque<Context> deque = HOLDER.get();
        return deque.isEmpty() ? null : deque.peek().priority;
    }

    /**
     * @return true 表示本次确实 push 了（需要在 finally pop）
     */
    public static boolean push(String key, Priority priority) {
        if (!StringUtils.hasText(key) || priority == null) {
            return false;
        }
        Deque<Context> deque = HOLDER.get();
        Context current = deque.peek();

        // 允许同级覆盖：内层 > 外层（同优先级时）
        if (current == null || priority.level() <= current.priority.level()) {
            deque.push(new Context(key, priority));
            return true;
        }
        return false;
    }

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

    public static void clear() {
        HOLDER.remove();
    }
}

---

二、让 DynamicDataSource 从 Holder 里取当前 key（并保留你原有 API）

修改 DynamicDataSource：

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

    /**
     * 兼容旧用法：手动指定时认为最高优先级
     */
    public static void setDataSource(String dataSource) {
        DynamicDataSourceContextHolder.push(dataSource, DynamicDataSourceContextHolder.Priority.MANUAL);
    }

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

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

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

关键点：没设置 key 时返回 null，AbstractRoutingDataSource 会自动用默认数据源（你默认就是 elss）。

---

三、改造 AOP：字段 > 方法 > 类，并且加缓存避免反射频繁扫描

你原来的 TargetDataSourceAspect 只看了接口类注解，而且没注解就强制设 elss。下面改造后：

• 字段：扫描当前被调用 Bean 的字段（通常是 service/dao），找 @TargetDataSource(name="...")
  • 如果同一个类里有多个字段注解且数据源不同：认为歧义，不使用字段级（打印 warn），你就用方法/类来明确
  • 如果多个字段但数据源相同：OK
• 方法：优先取 “最具体方法”（兼容代理/接口）
• 类：先看 ms.getDeclaringType()（对 mapper 接口很关键），再看 targetClass

修改后的 TargetDataSourceAspect：

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.framework.AopProxyUtils;
import org.springframework.aop.support.AopUtils;
import org.springframework.core.BridgeMethodResolver;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.HashSet;

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

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

    private static final class DsSelection {
        private final String key;
        private final DynamicDataSourceContextHolder.Priority priority;

        private DsSelection(String key, DynamicDataSourceContextHolder.Priority priority) {
            this.key = key;
            this.priority = priority;
        }
    }

    // 缓存：类 -> 字段注解解析结果（"" 表示无/歧义）
    private final ConcurrentMap<Class<?>, String> fieldDsCache = new ConcurrentHashMap<>();
    // 缓存：方法 -> 方法注解解析结果（"" 表示无）
    private final ConcurrentMap<Method, String> methodDsCache = new ConcurrentHashMap<>();
    // 缓存：类 -> 类注解解析结果（"" 表示无）
    private final ConcurrentMap<Class<?>, String> classDsCache = new ConcurrentHashMap<>();

    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        DsSelection selection = resolve(joinPoint);

        boolean pushed = false;
        if (selection != null) {
            pushed = DynamicDataSourceContextHolder.push(selection.key, selection.priority);
            if (pushed) {
                log.debug("切换数据源：{}（来源：{}）", selection.key, selection.priority);
            } else {
                log.debug("保持当前数据源：{}（当前优先级：{}，尝试来源：{}）",
                        DynamicDataSourceContextHolder.peek(),
                        DynamicDataSourceContextHolder.peekPriority(),
                        selection.priority);
            }
        } else {
            // 不设置时走默认数据源（DynamicDataSource 的 defaultTargetDataSource）
            log.debug("未匹配到数据源注解，使用默认数据源（不写入上下文）");
        }

        try {
            return joinPoint.proceed();
        } finally {
            DynamicDataSourceContextHolder.pop(pushed);
            if (pushed) {
                log.debug("数据源上下文已恢复，当前：{}", DynamicDataSourceContextHolder.peek());
            }
        }
    }

    private DsSelection resolve(ProceedingJoinPoint joinPoint) {
        MethodSignature ms = (MethodSignature) joinPoint.getSignature();

        Object target = joinPoint.getTarget();
        Class<?> targetClass = (target == null) ? ms.getDeclaringType() : AopProxyUtils.ultimateTargetClass(target);

        // 取最具体方法（兼容接口/代理）
        Method interfaceMethod = ms.getMethod();
        Method specificMethod = AopUtils.getMostSpecificMethod(interfaceMethod, targetClass);
        specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);

        // 1) 字段（FIELD 优先级最高）
        String fieldKey = resolveFromFields(targetClass);
        if (StringUtils.hasText(fieldKey)) {
            return new DsSelection(fieldKey, DynamicDataSourceContextHolder.Priority.FIELD);
        }

        // 2) 方法（METHOD）
        String methodKey = resolveFromMethod(specificMethod);
        if (!StringUtils.hasText(methodKey) && interfaceMethod != specificMethod) {
            // 保险：接口方法上也可能有注解
            methodKey = resolveFromMethod(interfaceMethod);
        }
        if (StringUtils.hasText(methodKey)) {
            return new DsSelection(methodKey, DynamicDataSourceContextHolder.Priority.METHOD);
        }

        // 3) 类（CLASS）：优先 declaringType（对 mapper 接口很关键），再 targetClass
        Class<?> declaringType = ms.getDeclaringType();
        String declaringKey = resolveFromClass(declaringType);
        if (StringUtils.hasText(declaringKey)) {
            return new DsSelection(declaringKey, DynamicDataSourceContextHolder.Priority.CLASS);
        }

        String targetKey = resolveFromClass(targetClass);
        if (StringUtils.hasText(targetKey)) {
            return new DsSelection(targetKey, DynamicDataSourceContextHolder.Priority.CLASS);
        }

        return null;
    }

    private String resolveFromFields(Class<?> targetClass) {
        return fieldDsCache.computeIfAbsent(targetClass, cls -> {
            Set<String> names = new HashSet<>();

            ReflectionUtils.doWithFields(cls, field -> {
                if (Modifier.isStatic(field.getModifiers())) {
                    return;
                }
                TargetDataSource ann = field.getAnnotation(TargetDataSource.class);
                if (ann != null && StringUtils.hasText(ann.name())) {
                    names.add(ann.name());
                }
            });

            if (names.isEmpty()) {
                return "";
            }
            if (names.size() == 1) {
                return names.iterator().next();
            }

            // 歧义：同一个类多个字段不同数据源，无法自动判断当前方法用哪个 mapper
            log.warn("类 {} 存在多个字段 @TargetDataSource 且数据源不同：{}，字段级策略不生效，请用方法/类注解明确。",
                    cls.getName(), names);
            return "";
        });
    }

    private String resolveFromMethod(Method method) {
        return methodDsCache.computeIfAbsent(method, m -> {
            TargetDataSource ann = AnnotationUtils.findAnnotation(m, TargetDataSource.class);
            if (ann == null || !StringUtils.hasText(ann.name())) {
                return "";
            }
            return ann.name();
        });
    }

    private String resolveFromClass(Class<?> clazz) {
        return classDsCache.computeIfAbsent(clazz, c -> {
            TargetDataSource ann = AnnotationUtils.findAnnotation(c, TargetDataSource.class);
            if (ann == null || !StringUtils.hasText(ann.name())) {
                return "";
            }
            return ann.name();
        });
    }
}

---

四、怎么用（对应你三个适配点）

1）自动注入 mapper 字段适配（字段优先级最高）

java
@Service
public class DemoService {

    @TargetDataSource(name = "envs")
    @Autowired
    private UserMapper userMapper;

    public void test() {
        userMapper.selectById(1L);
    }
}

说明：

• 只要该 Service 类里字段注解不歧义（只有一个数据源，或多个字段但同名数据源），进入任意 service 方法就会切到 envs
• 如果一个类里确实有多个 mapper 字段不同库：会 warn 并不走字段级，你就用 方法注解 或 mapper 方法注解 精确指定

---

2）mapper.java 具体方法适配（方法优先级第二）

java
@Mapper
public interface UserMapper {

    @TargetDataSource(name = "envs")
    User selectById(Long id);

    User selectDefault(Long id);
}

---

3）mapper.java 类/接口适配（类优先级第三，你已有）

java
@TargetDataSource(name = "auto-dm")
@Mapper
public interface AutoMapper {
    int insertXxx(...);
}

---

五、你现在配置里一个容易踩的点（顺带提醒）

你 DataSourceConfig 里：

• Bean 名：@Bean(name = "elss_centrally")
• dsMap key：dsMap.put("elss-centrally", elssCentrally);

那你注解里必须写 elss-centrally 才能匹配（而不是 elss_centrally）。
建议统一成一个名字（要么都用下划线，要么都用中划线），避免线上排查很痛苦。

---

如果你希望“字段级”能精确到当前调用的是哪个 mapper 字段（同一 service 内多个 mapper 不同库也能自动判断），那就不是纯 AOP 能稳定做到的了，需要引入注入点代理或更深的调用链识别方案；但就你现在的诉求（字段/方法/类优先级）和现有工程复杂度，上面这套通常已经够用且稳定。