Spring源码深度解析(郝佳)-学习-源码解析-@AliasFor标签

最新推荐文章于 2023-03-07 12:48:13 发布
最新推荐文章于 2023-03-07 12:48:13 发布
阅读量466 收藏 2
点赞数
分类专栏： Spring源码
自己的博客
本文链接：https://blog.csdn.net/quyixiao/article/details/109120363
版权

在研究Spring源码关于注解解析时，发现有源码中有很大的篇幅在处理关于AliasFor标签。我在网上找了一下，发现Spring中的@AliasFor标签 这篇博客对@AliasFor的使用己经介绍得很详细了，只是对源码的具体处理方面，我觉得，如果不是研究过源码的同学，可能还是觉得镜花水月，因此，今天，对其中的一个具体的示例做一下分析，希望对大家有用，先上示例吧

AliasFor.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface AliasFor {
	@AliasFor("attribute")
	String value() default "";
	
	@AliasFor("value")
	String attribute() default "";
	
	Class<? extends Annotation> annotation() default Annotation.class;

}

我们简单来看看@AliasFor标签的使用原理；
可以看到，@AliasFor标签自己就使用了自己，为value属性添加了attribute属性作为别名；

ParentMyAnnotation.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
public @interface ParentMyAnnotation {
    @AliasFor(value = "bbbb")
    String aaaa() default "";

    @AliasFor(value = "aaaa")
    String bbbb() default "";
}

MyAnnotation.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@ParentMyAnnotation
public @interface MyAnnotation {

    @AliasFor(attribute = "aaaa", annotation = ParentMyAnnotation.class)
    String xxxx() default "";

    @AliasFor(attribute = "bbbb", annotation = ParentMyAnnotation.class)   //缺省指明继承的父注解的中的属性名称，则默认继承父注解中同名的属性名
    String yyyy() default "";

    @AliasFor(attribute = "bbbb", annotation = ParentMyAnnotation.class)   //缺省指明继承的父注解的中的属性名称，则默认继承父注解中同名的属性名
    String zzzz() default "";

}

SubMyAnnotation.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@MyAnnotation
public @interface SubMyAnnotation {

    @AliasFor(annotation = ParentMyAnnotation.class,attribute = "aaaa")
    String iiii() default "";

    @AliasFor(annotation = MyAnnotation.class, attribute = "zzzz")
    String jjjj() default "";

}

GrandsonMyAnnotation.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@SubMyAnnotation
public @interface GrandsonMyAnnotation {

    @AliasFor(annotation = MyAnnotation.class,attribute = "zzzz")
    String mmmm() default "";

    @AliasFor(annotation = SubMyAnnotation.class, attribute = "iiii")
    String nnnn() default "";


}

定义三个注解类 ParentMyAnnotation，MyAnnotation，SubMyAnnotation，他们之间的关系是SubMyAnnotation继承MyAnnotation，MyAnnotation继承ParentMyAnnotation,GrandsonMyAnnotation 继承SubMyAnnotation。

MyAliasClass.java

@SubMyAnnotation(iiii = "11111111111")
public class MyAliasClass {
}

今天我们要测试的是，别名的传递，因为这个也是解析最为复杂的形式
@AliasFor注解是允许别名之间的传递的，简单理解，如果A是B的别名，并且B是C的别名，那么A是C的别名；
测试：

@Test
public void test2() {
    MyAliasClass aliasTest  = new MyAliasClass();
    MyAnnotation myAnnotation = AnnotationUtils.getAnnotation(aliasTest.getClass(), MyAnnotation.class);
    System.out.println("xxxx:" + myAnnotation.xxxx() + ";yyyy:" + myAnnotation.yyyy());
}

结果：
在这里插入图片描述

为什么SubMyAnnotation中的属性iiii,和jjjj相等呢？那我们来直接进入源码分析吧

AnnotationUtils.java

public static <A extends Annotation> A getAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType) {
	try {
		//获取当前类的注解，这里主要是获取到interface com.spring_1_100.test_61_70.test64_1.SubMyAnnotation 的注解
		A annotation = annotatedElement.getAnnotation(annotationType);
		if (annotation == null) {
			for (Annotation metaAnn : annotatedElement.getAnnotations()) {
				annotation = metaAnn.annotationType().getAnnotation(annotationType);
				if (annotation != null) {
					break;
				}
			}
		}
		//获取合成注解,可能返回的是一个代理类
		return synthesizeAnnotation(annotation, annotatedElement);
	}
	catch (Exception ex) {
		handleIntrospectionFailure(annotatedElement, ex);
	}
	return null;
}


public static <A extends Annotation> A synthesizeAnnotation(A annotation, AnnotatedElement annotatedElement) {
	//注解为空，直接返回
	if (annotation == null) {
		return null;
	}
	//如果是合成注解，直接返回
	if (annotation instanceof SynthesizedAnnotation) {
		return annotation;
	}
	//获取注解的类型
	Class<? extends Annotation> annotationType = annotation.annotationType();
	//非合成注解类型，直接返回,【重点分析，注解类型到底是不是合成注解】
	if (!isSynthesizable(annotationType)) {
		return annotation;
	}
	//如果是合成注解类型，创建合成注解代理类
	DefaultAnnotationAttributeExtractor attributeExtractor =
			new DefaultAnnotationAttributeExtractor(annotation, annotatedElement);
	InvocationHandler handler = new SynthesizedAnnotationInvocationHandler(attributeExtractor);
	A synthesizedAnnotation = (A) Proxy.newProxyInstance(ClassUtils.getDefaultClassLoader(),
			new Class<?>[] {(Class<A>) annotationType, SynthesizedAnnotation.class}, handler);

	return synthesizedAnnotation;
}


//从缓存中获取的情况，我们不考虑，只分析没有缓存的情况
private static boolean isSynthesizable(Class<? extends Annotation> annotationType) {
	Boolean synthesizable = synthesizableCache.get(annotationType);
	if (synthesizable != null) {
		return synthesizable.booleanValue();
	}

	synthesizable = Boolean.FALSE;
	for (Method attribute : getAttributeMethods(annotationType)) {
		//获取当前注解的别名，如果别名不为空，则表示是可合并属性
		if (!getAttributeAliasNames(attribute).isEmpty()) {
			synthesizable = Boolean.TRUE;
			break;
		}
		Class<?> returnType = attribute.getReturnType();
		if (Annotation[].class.isAssignableFrom(returnType)) {
			Class<? extends Annotation> nestedAnnotationType =
					(Class<? extends Annotation>) returnType.getComponentType();
			if (isSynthesizable(nestedAnnotationType)) {
				synthesizable = Boolean.TRUE;
				break;
			}
		}
		else if (Annotation.class.isAssignableFrom(returnType)) {
			Class<? extends Annotation> nestedAnnotationType = (Class<? extends Annotation>) returnType;
			if (isSynthesizable(nestedAnnotationType)) {
				synthesizable = Boolean.TRUE;
				break;
			}
		}
	}

	synthesizableCache.put(annotationType, synthesizable);
	return synthesizable.booleanValue();
}


static List<Method> getAttributeMethods(Class<? extends Annotation> annotationType) {
	List<Method> methods = attributeMethodsCache.get(annotationType);
	if (methods != null) {
		return methods;
	}

	methods = new ArrayList<Method>();
	//遍历注解所有的属性方法，将注解属性方法参数个数为0，并且返回值不为void类型的保存到methods中，并返回
	for (Method method : annotationType.getDeclaredMethods()) {
		if (isAttributeMethod(method)) {
			ReflectionUtils.makeAccessible(method);
			methods.add(method);
		}
	}

	attributeMethodsCache.put(annotationType, methods);
	return methods;
}


static List<String> getAttributeAliasNames(Method attribute) {
	Assert.notNull(attribute, "attribute must not be null");
	AliasDescriptor descriptor = AliasDescriptor.from(attribute);
	return (descriptor == null ? Collections.<String> emptyList() : descriptor.getAttributeAliasNames());
}

AliasDescriptor.java

public static AliasDescriptor from(Method attribute) {
	AliasDescriptor descriptor = aliasDescriptorCache.get(attribute);
	if (descriptor != null) {
		return descriptor;
	}
	//注解的属性方法中是否配置了@AliasFor注解
	AliasFor aliasFor = attribute.getAnnotation(AliasFor.class);
	if (aliasFor == null) {
		return null;
	}
	
	descriptor = new AliasDescriptor(attribute, aliasFor);
	
	descriptor.validate();
	aliasDescriptorCache.put(attribute, descriptor);
	return descriptor;
}

private AliasDescriptor(Method sourceAttribute, AliasFor aliasFor) {
	// 注解类
	Class<?> declaringClass = sourceAttribute.getDeclaringClass();
	Assert.isTrue(declaringClass.isAnnotation(), "sourceAttribute must be from an annotation");
	// 源注解属性
	this.sourceAttribute = sourceAttribute;
	// 注解类
	this.sourceAnnotationType = (Class<? extends Annotation>) declaringClass;
	// 源注解属性名称
	this.sourceAttributeName = this.sourceAttribute.getName();
	//如果注解属性没有配置annotation，则别名注解类型是当前注解类
	//如果如果注解属性配置了annotation，则别名注解类型是配置的注解类型
	this.aliasedAnnotationType = (Annotation.class.equals(aliasFor.annotation()) ?
			this.sourceAnnotationType : aliasFor.annotation());
	//获取注解属性所配置的@aliasFor注解的attribute 属性值 ，或name属性值
	// 而 attribute 和 name 有且只有一个不为空或空串的值，则取出来
	// 比如  attribute = "aaa", name="bbb" 抛出异常
	// 比如  attribute = "", name="" 抛出异常
	// 比如  attribute = "zzzz", name="" 或 attribute = "", name="bbb" ，不会抛出异常，并返回zzzz或bbb
	this.aliasedAttributeName = getAliasedAttributeName(aliasFor, this.sourceAttribute);
	try {
		// 这个不好理解，我们举个例子吧 配置如下 
		// @AliasFor(annotation = MyAnnotation.class, attribute = "zzzz")
    	// String jjjj() default "";
		// sourceAttribute ：public abstract java.lang.String com.spring_1_100.test_61_70.test64_1.SubMyAnnotation.jjjj()
		// sourceAnnotationType ：interface com.spring_1_100.test_61_70.test64_1.SubMyAnnotation
		// aliasedAnnotationType  ：interface com.spring_1_100.test_61_70.test64_1.MyAnnotation
		// 得到 aliasedAttribute ：public abstract java.lang.String com.spring_1_100.test_61_70.test64_1.MyAnnotation.zzzz()
		// 假如：@MyAnnotation注解中没有zzzz属性，将抛出下面异常
		this.aliasedAttribute = this.aliasedAnnotationType.getDeclaredMethod(this.aliasedAttributeName);
	}
	catch (NoSuchMethodException ex) {
		String msg = String.format(
				"Attribute [%s] in annotation [%s] is declared as an @AliasFor nonexistent attribute [%s] in annotation [%s].",
				this.sourceAttributeName, this.sourceAnnotationType.getName(), this.aliasedAttributeName,
				this.aliasedAnnotationType.getName());
		throw new AnnotationConfigurationException(msg, ex);
	}
	//如果注解属性配置了@AliasFor 并且设置了annotation属性，isAliasPair为false,否则为true
	this.isAliasPair = this.sourceAnnotationType.equals(this.aliasedAnnotationType);
}

//进行验证
private void validate() {
	// 如果注解属性的注解@AliasFor配置了annotation，但是annotation 不是当前注解类的父类或者祖先类，抛出异常
	// 如果annotation配置了是当前类的子类，比如在SubMyAnnotation的属性中配置了GrandsonMyAnnotation，
	// 而GrandsonMyAnnotation继承SubMyAnnotation，将抛出异常 
	if (!this.isAliasPair && !isAnnotationMetaPresent(this.sourceAnnotationType, this.aliasedAnnotationType)) {
		String msg = String.format("@AliasFor declaration on attribute [%s] in annotation [%s] declares " +
				"an alias for attribute [%s] in meta-annotation [%s] which is not meta-present.",
				this.sourceAttributeName, this.sourceAnnotationType.getName(), this.aliasedAttributeName,
				this.aliasedAnnotationType.getName());
		throw new AnnotationConfigurationException(msg);
	}

	if (this.isAliasPair) {
		AliasFor mirrorAliasFor = this.aliasedAttribute.getAnnotation(AliasFor.class);
		if (mirrorAliasFor == null) {
			String msg = String.format(
					"Attribute [%s] in annotation [%s] must be declared as an @AliasFor [%s].",
					this.aliasedAttributeName, this.sourceAnnotationType.getName(), this.sourceAttributeName);
			throw new AnnotationConfigurationException(msg);
		}
		// 如果源属性和别名注解属性的值不相等，抛出异常
		String mirrorAliasedAttributeName = getAliasedAttributeName(mirrorAliasFor, this.aliasedAttribute);
		if (!this.sourceAttributeName.equals(mirrorAliasedAttributeName)) {
			String msg = String.format(
					"Attribute [%s] in annotation [%s] must be declared as an @AliasFor [%s], not [%s].",
					this.aliasedAttributeName, this.sourceAnnotationType.getName(), this.sourceAttributeName,
					mirrorAliasedAttributeName);
			throw new AnnotationConfigurationException(msg);
		}
	}
	Class<?> returnType = this.sourceAttribute.getReturnType();
	Class<?> aliasedReturnType = this.aliasedAttribute.getReturnType();
	//如果源注解属性和别名注解属性返回值不相等，抛出异常
	if (!returnType.equals(aliasedReturnType)) {
		String msg = String.format("Misconfigured aliases: attribute [%s] in annotation [%s] " +
				"and attribute [%s] in annotation [%s] must declare the same return type.",
				this.sourceAttributeName, this.sourceAnnotationType.getName(), this.aliasedAttributeName,
				this.aliasedAnnotationType.getName());
		throw new AnnotationConfigurationException(msg);
	}

	if (this.isAliasPair) {
		validateDefaultValueConfiguration(this.aliasedAttribute);
	}
}


private void validateDefaultValueConfiguration(Method aliasedAttribute) {
	Assert.notNull(aliasedAttribute, "aliasedAttribute must not be null");
	Object defaultValue = this.sourceAttribute.getDefaultValue();
	Object aliasedDefaultValue = aliasedAttribute.getDefaultValue();
	//如果默认值为空，抛出异常
	if (defaultValue == null || aliasedDefaultValue == null) {
		String msg = String.format("Misconfigured aliases: attribute [%s] in annotation [%s] " +
				"and attribute [%s] in annotation [%s] must declare default values.",
				this.sourceAttributeName, this.sourceAnnotationType.getName(), aliasedAttribute.getName(),
				aliasedAttribute.getDeclaringClass().getName());
		throw new AnnotationConfigurationException(msg);
	}
	//如果源注解属性和别名注解属性值默认值不相等，抛出异常
	if (!ObjectUtils.nullSafeEquals(defaultValue, aliasedDefaultValue)) {
		String msg = String.format("Misconfigured aliases: attribute [%s] in annotation [%s] " +
				"and attribute [%s] in annotation [%s] must declare the same default value.",
				this.sourceAttributeName, this.sourceAnnotationType.getName(), aliasedAttribute.getName(),
				aliasedAttribute.getDeclaringClass().getName());
		throw new AnnotationConfigurationException(msg);
	}
}

AnnotationUtils.java

public List<String> getAttributeAliasNames() {
	// Explicit alias pair?
	if (this.isAliasPair) {
		return Collections.singletonList(this.aliasedAttributeName);
	}

	// Else: search for implicit aliases
	List<String> aliases = new ArrayList<String>();
	for (AliasDescriptor otherDescriptor : getOtherDescriptors()) {
		if (this.isAliasFor(otherDescriptor)) {
			//验证当前注解及otherDescriptor的默认值是否为空，任意一个为空，抛出异常，且如果不相等，抛出异常
			this.validateAgainst(otherDescriptor);
			//将otherDescriptor注解的别名加入到aliases
			aliases.add(otherDescriptor.sourceAttributeName);
		}
	}
	return aliases;
}


private List<AliasDescriptor> getOtherDescriptors() {
	List<AliasDescriptor> otherDescriptors = new ArrayList<AliasDescriptor>();
	for (Method currentAttribute : getAttributeMethods(this.sourceAnnotationType)) {
		//将非源注解的其他注解转化AliasDescriptor成加入到otherDescriptors中
		if (!this.sourceAttribute.equals(currentAttribute)) {
			AliasDescriptor otherDescriptor = AliasDescriptor.from(currentAttribute);
			if (otherDescriptor != null) {
				otherDescriptors.add(otherDescriptor);
			}
		}
	}
	return otherDescriptors;
}

// 递归当前注解及别名注解与其他注解属性的注解及别名注解，两者看有没有相等的，如果有相等，则返回true
private boolean isAliasFor(AliasDescriptor otherDescriptor) {
	for (AliasDescriptor lhs = this; lhs != null; lhs = lhs.getAttributeOverrideDescriptor()) {
		for (AliasDescriptor rhs = otherDescriptor; rhs != null; rhs = rhs.getAttributeOverrideDescriptor()) {
			if (lhs.aliasedAttribute.equals(rhs.aliasedAttribute)) {
				return true;
			}
		}
	}
	return false;
}

private AliasDescriptor getAttributeOverrideDescriptor() {
	//如果注解属性没有配置annotation
	if (this.isAliasPair) {
		return null;
	}
	//如果配置了annotation，则找当前注解属性的别名属性，转化为AliasDescriptor对象
	return AliasDescriptor.from(this.aliasedAttribute);
}

DefaultAnnotationAttributeExtractor.java

DefaultAnnotationAttributeExtractor(Annotation annotation, AnnotatedElement annotatedElement) {
	super(annotation.annotationType(), annotatedElement, annotation);
}

AbstractAliasAwareAnnotationAttributeExtractor.java

AbstractAliasAwareAnnotationAttributeExtractor(Class<? extends Annotation> annotationType,
		AnnotatedElement annotatedElement, S source) {

	Assert.notNull(annotationType, "annotationType must not be null");
	Assert.notNull(source, "source must not be null");
	this.annotationType = annotationType;
	this.annotatedElement = annotatedElement;
	this.source = source;
	this.attributeAliasMap = AnnotationUtils.getAttributeAliasMap(annotationType);
}

在这里插入图片描述

到这里终于将注解解析完成了，那么是如何获取iiii的值的呢？

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	if (isEqualsMethod(method)) {
		return annotationEquals(args[0]);
	}
	if (isHashCodeMethod(method)) {
		return annotationHashCode();
	}
	if (isToStringMethod(method)) {
		return annotationToString();
	}
	//方法的名称是annotationType，返回值为0
	if (isAnnotationTypeMethod(method)) {
		return annotationType();
	}
	//方法的参数个数为大于0或者方法返回值为void类型
	if (!isAttributeMethod(method)) {
		String msg = String.format("Method [%s] is unsupported for synthesized annotation type [%s]", method,
			annotationType());
		throw new AnnotationConfigurationException(msg);
	}
	return getAttributeValue(method);
}

private Object getAttributeValue(Method attributeMethod) {
	String attributeName = attributeMethod.getName();
	Object value = this.valueCache.get(attributeName);
	if (value == null) {
		// 调用 DefaultAnnotationAttributeExtractor 的属性方法
		value = this.attributeExtractor.getAttributeValue(attributeMethod);
		if (value == null) {
			throw new IllegalStateException(String.format(
				"%s returned null for attribute name [%s] from attribute source [%s]",
				this.attributeExtractor.getClass().getName(), attributeName, this.attributeExtractor.getSource()));
		}

		// Synthesize nested annotations before returning them.
		if (value instanceof Annotation) {
			value = synthesizeAnnotation((Annotation) value, this.attributeExtractor.getAnnotatedElement());
		}
		else if (value instanceof Annotation[]) {
			value = synthesizeAnnotationArray((Annotation[]) value, this.attributeExtractor.getAnnotatedElement());
		}

		this.valueCache.put(attributeName, value);
	}
	// Clone arrays so that users cannot alter the contents of values in our cache.
	if (value.getClass().isArray()) {
		value = cloneArray(value);
	}

	return value;
}

AbstractAliasAwareAnnotationAttributeExtractor.java

public final Object getAttributeValue(Method attributeMethod) {
	//获取当前注解属性名称
	final String attributeName = attributeMethod.getName();
	//通过反射获取属性值
	Object attributeValue = getRawAttributeValue(attributeMethod);
	//获取当前注解的所有别名
	List<String> aliasNames = this.attributeAliasMap.get(attributeName);
	if (aliasNames != null) {
		//获取当前注解默认值
		final Object defaultValue = AnnotationUtils.getDefaultValue(getAnnotationType(), attributeName);
		for (String aliasName : aliasNames) {
			//获取别名注释用户配置的值，如果用户没有配置，则使用默认值
			Object aliasValue = getRawAttributeValue(aliasName);
			//如果 iiii="1111",jjjj="2222" 而iiii 的默认值为 "" ，抛出异常
			//如果iiii="1111"，jjjj="",默认值为"",不会抛出异常
			if (!ObjectUtils.nullSafeEquals(attributeValue, aliasValue) &&
					!ObjectUtils.nullSafeEquals(attributeValue, defaultValue) &&
					!ObjectUtils.nullSafeEquals(aliasValue, defaultValue)) {
				String elementName = (getAnnotatedElement() != null ? getAnnotatedElement().toString() : "unknown element");
				throw new AnnotationConfigurationException(String.format(
						"In annotation [%s] declared on %s and synthesized from [%s], attribute '%s' and its " +
						"alias '%s' are present with values of [%s] and [%s], but only one is permitted.",
						getAnnotationType().getName(), elementName, getSource(), attributeName, aliasName,
						ObjectUtils.nullSafeToString(attributeValue), ObjectUtils.nullSafeToString(aliasValue)));
			}
			// 如果iiii="",默认值为"",则使用别名属性值jjjj配置的值作为返回值
			if (ObjectUtils.nullSafeEquals(attributeValue, defaultValue)) {
				attributeValue = aliasValue;
			}
		}
	}
	return attributeValue;
}

到这里，我们终于将Spring的注解属性解析讲完了。整个过程比较繁索，下面我们来总结一下

  1. 如果注解属性中没有配置了annotation，那么整个过程比较简单，只要看别名注解属性的默认值，和返回值，是不是相等，如果相等，则可以创建代理注解类，来获取注解属性值。
  2. 如果注解属性中配置了annotation，要看annotation配置类是不是当前注解属性所在类的子孙类，如果不在，则抛出异常。再检测注解属性和别名属性返回值是否相等，不相等，抛出异常。
  3. 获取注解属性的所有别名，如果别名不为空，则是创建代理注解处理器
  4. 通过代理获取注解属性。

Spring的每一个细节都非常的有意思，读者，有意向，还是自己下载代码，研究一下，使我们不仅仅停留在表示肤浅的理解注解。

本文的github地址是https://github.com/quyixiao/spring_tiny/tree/master/src/main/java/com/spring_1_100/test_61_70/test64_1

柳擎
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
异黄酮类天然产物抗糖尿病活性研究进展
01-05
异黄酮类天然产物抗糖尿病活性研究进展，郝佳，刘哲，异黄酮类化合物作为中草药来源的天然产物，来源广泛且不良反应较小，在有效阻止和延缓糖尿病及其并发症的发生、发展方面显示了良
AliasFor的实现原理
u010631140的博客
01-21 1013
什么是AliasFor   AliasFor是Spring 4.2引入的注解，它提供了给注解中的属性定义别名的功能。所谓注解中的属性，指的是注解中定义的方法，因为它无参并且有返回值。   Java标准定义了几个术语来表示注解A和被标注的元素E之间的关系： direct present：注解A是运行时可见的，并且A直接标注在E上，比如E是一个类，A标注在这个类上 indirect present：满足direct present语义，但是限定注解A必须是repeatable的 present：满足direc
深入解析SpringBoot中@Async注解原理
AE86的博客
05-09 4079
SpringBoot的@Async注解原理解析
Spring 注解属性别名与覆盖
u010141779的博客
04-27 1139
Spring 注解属性别名与覆盖 在Spring 中将多个注解组合注解到一个注解上，这个注解就可以发挥被注解的多个注解功能。 @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, cla
AnnotationUtil注解
weixin_33941350的博客
05-06 1512
为什么80%的码农都做不了架构师？>>> ...
@AliasFor注解详解（结合源码分析）
weixin_43899069的博客
08-25 1875
网上关于该注解的描述大都抄来抄去，没有涉及到最本质的源码问题， 下面是笔者结合注解源码， 以及其他常用的注解源码， 来分析@AliasFor注解的主要功能以及展示实际使用场景
@AliasFor的使用方法
Evan's Blog ٩(๑❛ᴗ❛๑)۶
03-07 2669
注意，我们需要在MyCombinedAnnotation中加上@MyAnnotation1、@MyAnnotation2、@MyAnnotation3三个注解，表示这个新注解中包含了这三个注解的所有属性，可以通过@MyCombinedAnnotation来代替这三个注解的使用。当然，你也可以理解为将一个注解上的属性值传递给另一个注解，我个人更习惯采用这种理解，因为后续可以通过一个注解组合多个注解进行使用，通过一个注解将值传递给多个注解，而这与java的继承的概念并不相同。
java注解编写_java 注解开发
weixin_39566773的博客
02-12 162
注解JDK自带的注解三个@Override: 限定重写父类方法, 实现接口方法。该注解只能用于方法@Deprecated: 用于表示所修饰的元素(类, 方法，构造器等等)已过时。通常是因为所修饰的结构危险或存在更好的选择，过时是可以用的，意义只是作为一种提示，因为原来的项目中用的老的代码必须要能用，过时是给我们后面做开发的提示@SuppressWarnings: 抑制编译器警告example@Su...
Attribute 'proxyBeanMethods' in annotation [```] is declared as an @AliasFor nonexistent attribute
m0_37827405的博客
02-17 1万+
在启动springboot的时候，如果出现这样的错误，基本说明maven的pom.xml里面的依赖配置错误，错误原因是版本没设置好，建议更新成最新版本，比如'proxyBeanMethods'现在更新到了5.2以上，而我配置里版本出现下图5.0.2，就报错了 更新成 5.2.3就可以了 ...
Spring - 注解解析器
u011614717的博客
08-13 7453
Spring Boot-注解解析器 Spring中使用了大量自定义的注解，如果通过我们自定义的注解解析器可能达不到预想的效果，必须使用Spring的AnnotationUtils.java类来获取方可正确解析。 一、自定义注解解析器解析Spring中的@AliasFor注解 @AliasFor注解是Spring中自定义的设置方法设置别名的注解，原理可查看：https://blog.c...
SpringFramework之@AliasFor
来啊 快活啊
06-19 3883
发博词Spring Boot和Spring Cloud里面的各个注解，大量用到了这个别名的注解。看了一下之后，发现这个注解异常强大，他可以将任意一个注解类任意一个属性，当作任意的一个注解（可以是当前注解，也可以是别的注解）的任意一个属性；定义下面是这个注解的实现，他自己也使用了自己。 [org.springframework.core.annotation.AliasFor]@Retention(
spring之@AliasFor
千霜的博客
09-20 1892
目录 一、介绍 二、使用 2.1、Explicit aliases within an annotation 2.2、Explicit alias for attribute in meta-annotation 2.3、Implicit aliases within an annotation 参考 一、介绍 @AliaFor是一个用于声明注解属性别名的注解。可以让同一个注解里的...
如何使用idea看注解的实现
wounler的博客
07-15 2636
想看看注解@AliasFor是如何实现的。
Spring @AliasFor 的三种用法，亲测可用，包含测试代码
热门推荐
ab411919134的专栏
08-17 1万+
查看Spring中的@AliasFor的文档，英文描述如下： Usage ScenariosExplicit aliases within an annotation: within a single annotation, @AliasFor can be declared on a pair of attributes to signal that they are interchangea...
优雅编程-自定义注解使用及元注解@interface 详细解读
beauty-coding 的博客
04-28 1955
优雅编程-自定义注解使用及元注解@interface 详细解读 相关注解解读（目前一共 6个） @Target Target源码 /** * Indicates the contexts in which an annotation type is applicable. The * declaration contexts and type contexts in which an anno...
spring cloud 启动报错-must be declared as an @AliasFor [serviceId], not [name].
chenglc1612的博客
12-05 1492
spring cloud 启动报错-must be declared as an @AliasFor [serviceId], not [name]. 项目加入FeignClient后再启动就报错，具体报错信息如下： org.springframework.core.annotation.AnnotationConfigurationExce...
Mybatis源码解析--Spring管理Mapper代理对象
weixin_43899290的博客
03-05 344
前言 在解析代码之前，我们先回顾一下spring容器是怎么管理bean的 对bean(xml配置，注解标识)进行解析生成BeanDefinition对象，注册到BeanDefinitionRegistry容器中 实例化容器中所有实现了BeanFactoryPostProcessor接口的bean,执行postProcessBeanFactory方法 实例化容器中所有的单例bean,并填充bean的属性 执行所有实现了BeanPostProcessor接口bean的postProcessBe
spring全家桶学习资料
最新发布
08-17
关于Spring全家桶的学习资料，有很多优质的资源可以供你参考。以下是一些推荐的学习资料： 1. 官方文档：Spring官方文档是学习Spring框架的首选资源，它提供了详尽的文档和示例代码，覆盖了Spring框架的各个模块和功能。你可以在Spring官网上找到官方文档。 2. Spring实战（第4版）：这是一本经典的Spring框架学习书籍，由Craig Walls撰写。书中通过实例展示了如何使用Spring框架构建企业级应用程序，并涵盖了Spring Boot、Spring MVC、Spring Data等核心模块。 3. Spring Boot实战：这本书由Craig Walls和其他作者合著，重点介绍了Spring Boot框架。它通过实例讲解了如何使用Spring Boot快速构建独立的、生产级别的应用程序。 4. Spring源码深度解析：这本书由郝佳编著，深入剖析了Spring框架的核心原理和源码实现。适合对Spring框架内部机制有较深入理解需求的读者。 5. Spring Boot 2精髓：这本书由杨开振编著，全面介绍了Spring Boot 2的核心特性、原理和最佳实践。适合对Spring Boot感兴趣的读者。 此外，你还可以通过网上的教程、博客和视频课程来学＊＊＊并参考这些资源。希望这些资料能对你的学习有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值