项目里用到@within时，出现了一些问题，使用@target就可以解决，但又会出现一些新的问题，因此本文探讨了在spring中，使用@within和@target的一些区别。
背景 项目里有一个动态切换数据源的功能，我们是用切面来实现的，是基于注解来实现的，但是父类的方法是可以切换数据源的，如果有一个类直接继承这个类，调用这个子类时，这个子类是不能够切换数据源的，除非这个子类重写父类的方法。
【详解Spring中使用@within与@target的区别】模拟项目例子

注解定义：@Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Inherited@Documentedpublic @interface MyAnnotation {String value() default "me"; }切面定义：@Order(-1)@Aspect@Componentpublic class MyAspect {@Before("@within(myAnnotation)")public void switchDataSource(JoinPoint point, MyAnnotation myAnnotation) {System.out.println("before, myAnnotation.value : " + myAnnotation.value()); }}父类Bean：@MyAnnotation("father")public class Father {public void hello() {System.out.println("father.hello()"); }public void hello2() {System.out.println("father.hello2()"); }}子类Bean：@MyAnnotation("son")public class Son extends Father {@Overridepublic void hello() {System.out.println("son.hello()"); }}配置类：@Configuration@EnableAspectJAutoProxy(exposeProxy = true)public class Config {@Beanpublic Father father() {return new Father(); }@Beanpublic Son son() {return new Son(); }}测试类：public class Main {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class,MyAspect.class); Father father = context.getBean("father", Father.class); father.hello(); father.hello2(); Son son = context.getBean(Son.class); son.hello(); son.hello2(); }}

我们定义了一个@Before通知，方法参数有point, myAnnotation，方法里输出了myAnnotation.value的值
下面是输出结果：

before, myAnnotation.value : father
father.hello()
before, myAnnotation.value : father
father.hello2()
before, myAnnotation.value : son
son.hello()
before, myAnnotation.value : father
father.hello2()

从上面的输出结果看出：Son类重写了hello方法，myAnnotation.value的输出的值是son，hello2方法没有重写，myAnnotation.value的输出的值是father
根据需求，我们肯定希望调用Son类的所有方法时，都希望myAnnotation.value的输出的值是son，因此就需要重写父类的所有public方法
那有没有办法不重写这些方法也能达到相同的效果呢，答案是可以的。
看看使用@within和@target的区别
我们分别在父类和子类上加上注解和去掉注解，一起来看看对应的结果
@within
父类无注解，子类有注解：

father.hello()father.hello2()before, myAnnotation.value : sonson.hello()father.hello2()

父类有注解，子类无注解：

before, myAnnotation.value : fatherfather.hello()before, myAnnotation.value : fatherfather.hello2()before, myAnnotation.value : fatherson.hello()before, myAnnotation.value : fatherfather.hello2()

父类有注解，子类有注解(其实就是上面那个例子的结果)：

before, myAnnotation.value : fatherfather.hello()before, myAnnotation.value : fatherfather.hello2()before, myAnnotation.value : sonson.hello()before, myAnnotation.value : fatherfather.hello2()

@target
把切面代码改成如下：

@Order(-1)@Aspect@Componentpublic class MyAspect {@Before("@target(myAnnotation)")public void switchDataSource(JoinPoint point, MyAnnotation myAnnotation) {System.out.println("before, myAnnotation.value : " + myAnnotation.value()); }}

我们再一起来看看测试结果：
父类无注解，子类有注解：

father.hello()father.hello2()before, myAnnotation.value : sonson.hello()before, myAnnotation.value : sonfather.hello2()

父类有注解，子类无注解：

before, myAnnotation.value : fatherfather.hello()before, myAnnotation.value : fatherfather.hello2()son.hello()father.hello2()

父类有注解，子类有注解

before, myAnnotation.value : fatherfather.hello()before, myAnnotation.value : fatherfather.hello2()before, myAnnotation.value : sonson.hello()before, myAnnotation.value : sonfather.hello2()

我们从上面总结出一套规律：
@within：@Before通知方法的myAnnotation参数指的是调用方法所在的类上面的注解，就是这个方法是在哪个类上定义的
@target：@Before通知方法的myAnnotation参数指的是调用方法运行时所属于的类上面的注解
我们最后总结一下，如果父类和子类上都标有注解，@within和@target的所得到实际注解的区别

@within	@target
父类方法	父类注解	父类注解
子类不重写方法	父类注解	子类注解
子类重写方法	子类注解	子类注解

@target 看起来跟合理一点
从上面的分析可以看出，其实用@target更符合我们想要的结果，在某个类上面加一个注解，拦截的时候就会获取这个类上面的注解，跟父类完全没有关系了
但这个时候会遇到一个问题，就是不相关的类都会生从代理类，
例子如下：

public class NormalBean {public void hello() {}}@Configuration@EnableAspectJAutoProxy(exposeProxy = true)public class Config {@Beanpublic Father father() {return new Father(); }@Beanpublic Son son() {return new Son(); }@Beanpublic NormalBean normalBean() {return new NormalBean(); }}public class Main {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class,MyAspect.class); Father father = context.getBean("father", Father.class); father.hello(); father.hello2(); Son son = context.getBean(Son.class); son.hello(); son.hello2(); NormalBean normalBean = context.getBean(NormalBean.class); System.out.println(normalBean.getClass()); }}

输出：

class cn.eagleli.spring.aop.demo.NormalBean$$EnhancerBySpringCGLIB$$eebc2a39

可以看出NormalBean自己什么都没做，但却被代理了
我们再把@target换成@within：

class cn.eagleli.spring.aop.demo.NormalBean

可以看出使用@within时，不相关的类没有被代理
我们一起来看看为什么
在AbstractAutoProxyCreator类中的wrapIfNecessary方法打断点，看看什么情况：
@within

文章图片

@target

文章图片

我们从上面的图片就可以理解为什么@target会生成代理类
我们再深入看一下：
@within会走到如下：

public class ExactAnnotationTypePattern extends AnnotationTypePattern { @Override public FuzzyBoolean matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations) {// ......}}

我没深入研究，大致意思就是只要这个类或者这个类的祖先们带有这个注解，即匹配成功
@target会走到如下：

public class ThisOrTargetAnnotationPointcut extends NameBindingPointcut { @Override protected FuzzyBoolean matchInternal(Shadow shadow) {if (!couldMatch(shadow)) {return FuzzyBoolean.NO; }ResolvedType toMatchAgainst = (isThis ? shadow.getThisType() : shadow.getTargetType()).resolve(shadow.getIWorld()); annotationTypePattern.resolve(shadow.getIWorld()); if (annotationTypePattern.matchesRuntimeType(toMatchAgainst).alwaysTrue()) {return FuzzyBoolean.YES; } else {// a subtype may match at runtimereturn FuzzyBoolean.MAYBE; } }}public class AspectJExpressionPointcut extends AbstractExpressionPointcutimplements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware { @Override public boolean matches(Method method, Class targetClass, boolean hasIntroductions) {obtainPointcutExpression(); ShadowMatch shadowMatch = getTargetShadowMatch(method, targetClass); // Special handling for this, target, @this, @target, @annotation// in Spring - we can optimize since we know we have exactly this class,// and there will never be matching subclass at runtime.if (shadowMatch.alwaysMatches()) {return true; }else if (shadowMatch.neverMatches()) {return false; }else {// the maybe caseif (hasIntroductions) {return true; }// A match test returned maybe - if there are any subtype sensitive variables// involved in the test (this, target, at_this, at_target, at_annotation) then// we say this is not a match as in Spring there will never be a different// runtime subtype.RuntimeTestWalker walker = getRuntimeTestWalker(shadowMatch); return (!walker.testsSubtypeSensitiveVars() || walker.testTargetInstanceOfResidue(targetClass)); // 这里会返回true} }}

我没深入研究，大致意思是匹配的话就返回YES，否则就返回MAYBE，匹配逻辑是和@within一样的
因此所有不相关的类都会是一个MAYBE的结果，这个结果会让不相关的类最后生成代理类
通知方法中注解参数的值为什么是不一样的
经过调试，最终是在这里获取的：

public final class ReflectionVar extends Var { static final int THIS_VAR = 0; static final int TARGET_VAR = 1; static final int ARGS_VAR = 2; static final int AT_THIS_VAR = 3; static final int AT_TARGET_VAR = 4; static final int AT_ARGS_VAR = 5; static final int AT_WITHIN_VAR = 6; static final int AT_WITHINCODE_VAR = 7; static final int AT_ANNOTATION_VAR = 8; public Object getBindingAtJoinPoint(Object thisObject, Object targetObject, Object[] args,Member subject,Member withinCode,Class withinType) {switch( this.varType) {case THIS_VAR: return thisObject; case TARGET_VAR: return targetObject; case ARGS_VAR:if (this.argsIndex > (args.length - 1)) return null; return args[argsIndex]; case AT_THIS_VAR:if (annotationFinder != null) {return annotationFinder.getAnnotation(getType(), thisObject); } else return null; case AT_TARGET_VAR:if (annotationFinder != null) {return annotationFinder.getAnnotation(getType(), targetObject); } else return null; case AT_ARGS_VAR:if (this.argsIndex > (args.length - 1)) return null; if (annotationFinder != null) {return annotationFinder.getAnnotation(getType(), args[argsIndex]); } else return null; case AT_WITHIN_VAR:if (annotationFinder != null) {return annotationFinder.getAnnotationFromClass(getType(), withinType); } else return null; case AT_WITHINCODE_VAR:if (annotationFinder != null) {return annotationFinder.getAnnotationFromMember(getType(), withinCode); } else return null; case AT_ANNOTATION_VAR:if (annotationFinder != null) {return annotationFinder.getAnnotationFromMember(getType(), subject); } else return null; } return null; }}

@within：

case AT_WITHIN_VAR:if (annotationFinder != null) { return annotationFinder.getAnnotationFromClass(getType(), withinType); } else return null;

withinType追踪到如下：

public class PointcutExpressionImpl implements PointcutExpression { private ShadowMatch matchesExecution(Member aMember) {Shadow s = ReflectionShadow.makeExecutionShadow(world, aMember, this.matchContext); ShadowMatchImpl sm = getShadowMatch(s); sm.setSubject(aMember); sm.setWithinCode(null); sm.setWithinType(aMember.getDeclaringClass()); // 这里设置withinTypereturn sm; }}public abstract class AopUtils { public static boolean canApply(Pointcut pc, Class targetClass, boolean hasIntroductions) {Assert.notNull(pc, "Pointcut must not be null"); if (!pc.getClassFilter().matches(targetClass)) {return false; }MethodMatcher methodMatcher = pc.getMethodMatcher(); if (methodMatcher == MethodMatcher.TRUE) {// No need to iterate the methods if we're matching any method anyway...return true; }IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null; if (methodMatcher instanceof IntroductionAwareMethodMatcher) {introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher; }Set> classes = new LinkedHashSet<>(); if (!Proxy.isProxyClass(targetClass)) {classes.add(ClassUtils.getUserClass(targetClass)); }classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass)); for (Class clazz : classes) {Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz); for (Method method : methods) { // 这里获取所有methodif (introductionAwareMethodMatcher != null ?introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :methodMatcher.matches(method, targetClass)) {return true; }}}return false; }}

@target：

case AT_TARGET_VAR:if (annotationFinder != null) {return annotationFinder.getAnnotation(getType(), targetObject); } else return null;

targetObject 追踪到如下：

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupportimplements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware { protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {return bean; }if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {return bean; }if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; }// Create proxy if we have advice.Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); if (specificInterceptors != DO_NOT_PROXY) {this.advisedBeans.put(cacheKey, Boolean.TRUE); Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); // 这里，targetObject就是生成的beanthis.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; }this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } public SingletonTargetSource(Object target) {Assert.notNull(target, "Target object must not be null"); this.target = target; }}

想用@within，但又想得到想要的注解

@Order(-1)@Aspect@Componentpublic class MyAspect {@Before("@within(myAnnotation)")public void switchDataSource(JoinPoint point, MyAnnotation myAnnotation) {System.out.println(point.getTarget() + " " + point + " " + myAnnotation.value() + " " +point.getTarget().getClass().getAnnotation(MyAnnotation.class).value()); }}

很简单，从JoinPoint中得到target，然后从这个类上得到对应的注解即可
此时，父类和子类都加有注解，一起来看看输出结果：

cn.eagleli.spring.aop.demo.Father@194fad1 execution(void cn.eagleli.spring.aop.demo.Father.hello()) father father
cn.eagleli.spring.aop.demo.Father@194fad1 execution(void cn.eagleli.spring.aop.demo.Father.hello2()) father father
cn.eagleli.spring.aop.demo.Son@14fc5f04 execution(void cn.eagleli.spring.aop.demo.Son.hello()) son son
cn.eagleli.spring.aop.demo.Son@14fc5f04 execution(void cn.eagleli.spring.aop.demo.Father.hello2()) father son

能力有限，只能先探讨这么多了，不懂的或者有其他见解的，欢迎一起讨论呀~
到此这篇关于Spring中使用@within与@target的一些区别的文章就介绍到这了,更多相关Spring中使用@within与@target内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

推荐阅读

• 

  凉拌鸡爪——促进骨骼预防高血压
• 

  写在静心手触上海课程前
• 

  2345智能浏览器怎么更改主页 2345智能浏览器主页如何更改
• 

  原来是这些原因 为什么有时候手机收不到验证码
• 

  吃荔枝上火吗？
• 

  西门子新款冰箱系列：科技与品质的好融合，让您的厨房更智能
• 

  再见2018，活出精彩2019
• 

  清明何止雨纷纷
• 

  JS|深拷贝浅拷贝的区别（如何实现一个深拷贝？）
• 

  excel2019怎么提供声音反馈
• 

  上夜班不可以吃芒果和火龙果 芒果不能和什么一起吃
• 

  如何设置新买的服务器的映射？ 新买的服务器怎么映射
• 

  图文 虞姬是自刎还是被人杀死的，揭秘虞姬死亡的真相
• 

  三国志战略版卧薪尝胆战法攻略 S级战法卧薪尝胆简评
• 

  机动车怎么审车 机动车怎么审
• 

  边 刑法关于放行偷越国境人员法定量刑档次是怎样
• 

  mongodb的坑 mongodb凉了吗
• 

  怎么蒸豆包蒸豆包的方法 如何蒸酥皮豆包，酥皮包子的做法窍门
• 

  2023年10月份重庆多雨吗
• 

  违章代码46131是什么意思

• 热闹中的孤独
• Shell-Bash变量与运算符
• JS中的各种宽高度定义及其应用
• 2021-02-17|2021-02-17 小儿按摩膻中穴-舒缓咳嗽
• 深入理解Go之generate
• 异地恋中，逐渐适应一个人到底意味着什么（）
• Activiti（一）SpringBoot2集成Activiti6
• 我眼中的佛系经纪人
• 《魔法科高中的劣等生》第26卷（Invasion篇）发售
• “成长”读书社群招募