项目里用到@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内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

推荐阅读

• 

  空想社会主义的贡献
• 

  剥蒜皮的小窍门有哪些 一起来看看吧
• 

  腾逸是什么意思 腾逸的解释
• 

  王者荣耀这游戏,从一个新手小白到星耀需要多长时间？
• 

  python实现迭代法解方程
• 

  格力空调ul故障代码
• 

  寻人
• 

  神话胡歌版人物关系 神话胡歌和谁在一起了
• 

  维他命b6可以回奶吗
• 

  redissql
• 

  asp.net书籍文献，aspnet web开发 书籍
• 

  哪个购物平台可以通过完成任务来返现？
• 

  谷雨|谷雨|春色撩不尽，一枚雨衣入目来
• 

  女人哪些行为说明她在“撩”你？
• 

  1270v3支持d4内存吗,h81主板能用1270v3吗
• 

  2021高考一本压线该不该复读
• 

  k850座位表是怎样的？k850次列车为什么停运
• 

  python封装几个函数 python封装函数计算1到100的累加
• 

  格力空调E1故障解决方法及维修技巧，快速修复您的空调问题
• 

  活动游戏策划

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