一、引入依赖
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.30</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.34</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j-impl</artifactId>
<version>2.12.1</version>
<scope>compile</scope>
</dependency>
</dependencies>
二、定义一个注解
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyReference {
}
三、创建一个FactoryBean
@Slf4j
public class MyFactoryBean<Service> implements FactoryBean<Service> {
/**
* 缓存
*/
private final ConcurrentMap<String, Service> factoryBeanCache = new ConcurrentHashMap<>(32);
private final Class<Service> serviceClass;
public MyFactoryBean(Class<Service> serviceClass) {
this.serviceClass = serviceClass;
}
public static <T> MyFactoryBean<T> of(Class<T> serviceClass) {
return new MyFactoryBean<>(serviceClass);
}
@Override
public Service getObject() throws Exception {
log.info("create my factoryBean, serviceClass={}", serviceClass.getName());
String key = getObjectType().getName();
Service bean = this.factoryBeanCache.get(key);
if (bean == null) {
synchronized (this.factoryBeanCache) {
bean = this.factoryBeanCache.get(key);
if (bean == null) {
// 创建对象
bean = createObject();
this.factoryBeanCache.put(key, bean);
}
}
}
return bean;
}
private Service createObject() {
return (Service) Proxy.newProxyInstance(this.getObjectType().getClassLoader(),
new Class[]{serviceClass},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log.info("myFactoryBean proxy before, method name={}", method.getName());
log.info("myFactoryBean proxy after");
return null;
}
});
}
@Override
public Class<?> getObjectType() {
return this.serviceClass;
}
}
四、创建一个BeanPostProcessor
@Slf4j
public class ReferenceAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter implements MergedBeanDefinitionPostProcessor, PriorityOrdered,
BeanFactoryAware, EnvironmentAware, DisposableBean, ApplicationListener, ApplicationContextAware {
private static final int CACHE_SIZE = Integer.getInteger("", 32);
/**
* 需要扫描的注解集合
*/
private final Class<? extends Annotation>[] annotationTypes;
/**
* 是否以Spring IoC容器中Bean优先
* true：如果Spring IoC容器中存在，直接注入，多个注入第一个
*/
private final Boolean isSpringIoCBeanPreferred;
private final ConcurrentMap<String, AnnotatedInjectionMetadata> injectionMetadataCache =
new ConcurrentHashMap<String, AnnotatedInjectionMetadata>(CACHE_SIZE);
private final ConcurrentMap<String, MyFactoryBean<?>> injectedObjectsCache = new ConcurrentHashMap<>(CACHE_SIZE);
private ConfigurableListableBeanFactory beanFactory;
private Environment environment;
private ApplicationContext applicationContext;
private int order = Ordered.LOWEST_PRECEDENCE - 3;
private boolean classValuesAsString = true;
private boolean nestedAnnotationsAsMap = true;
private boolean ignoreDefaultValue = true;
private boolean tryMergedAnnotation = true;
private static Map<String, TreeSet<String>> referencedBeanNameIdx = new HashMap<>();
private final ConcurrentMap<String, MyFactoryBean<?>> factoryBeanCache =
new ConcurrentHashMap<>(CACHE_SIZE);
private final ConcurrentMap<InjectionMetadata.InjectedElement, MyFactoryBean<?>> injectedFieldMyFactoryBeanCache =
new ConcurrentHashMap<>(CACHE_SIZE);
private final ConcurrentMap<InjectionMetadata.InjectedElement, MyFactoryBean<?>> injectedMethodMyFactoryBeanCache =
new ConcurrentHashMap<>(CACHE_SIZE);
public ReferenceAnnotationBeanPostProcessor(Class<? extends Annotation>[] annotationTypes) {
this(annotationTypes, true);
}
public ReferenceAnnotationBeanPostProcessor(Class<? extends Annotation>[] annotationTypes, Boolean isSpringIoCBeanPreferred) {
Assert.notEmpty(annotationTypes, "The argument of annotations' types must not empty");
Assert.notEmpty(annotationTypes, "The argument of isSpringIoCBeanPreferred must not empty");
this.annotationTypes = annotationTypes;
this.isSpringIoCBeanPreferred = isSpringIoCBeanPreferred;
}
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds,
Object bean, String beanName) throws BeanCreationException {
// 查找注入元数据
InjectionMetadata metadata = findInjectionMetadata(beanName, bean.getClass(), pvs);
try {
// 注入
metadata.inject(bean, beanName, pvs);
} catch (BeanCreationException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of @" + bean.getClass().getSimpleName()
+ " dependencies is failed", ex);
}
return pvs;
}
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
/**
* 执行的时间节点是bean刚刚初始化完 但在属性填充之前;
* spring会为每个beanDefinition依次调用实现了MergedBeanDefinitionPostProcessor接口的PostProcessor的改方法
*/
if (beanType == null) {
return;
}
// 查找注入元数据
InjectionMetadata metadata = this.findInjectionMetadata(beanName, beanType, (PropertyValues) null);
metadata.checkConfigMembers(beanDefinition);
}
/**
* 查找注入元数据
*
* @param beanName
* @param clazz
* @param pvs
* @return
*/
private InjectionMetadata findInjectionMetadata(String beanName, Class<?> clazz, PropertyValues pvs) {
String cacheKey = StringUtils.hasLength(beanName) ? beanName : clazz.getName();
AnnotatedInjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
// double check
metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
metadata.clear(pvs);
}
try {
// build
metadata = this.buildAnnotatedMetadata(clazz);
this.injectionMetadataCache.put(cacheKey, metadata);
} catch (NoClassDefFoundError e) {
throw new IllegalStateException("Failed to introspect object class [" + clazz.getName() + "] for annotation metadata: could not find class that it depends on", e);
}
}
}
}
return metadata;
}
private AnnotatedInjectionMetadata buildAnnotatedMetadata(final Class<?> beanClass) {
// field
Collection<AnnotatedFieldElement> fieldElements = findFieldAnnotationMetadata(beanClass);
// method
Collection<AnnotatedMethodElement> methodElements = findAnnotatedMethodMetadata(beanClass);
return new AnnotatedInjectionMetadata(beanClass, fieldElements, methodElements);
}
private List<AnnotatedMethodElement> findAnnotatedMethodMetadata(final Class<?> beanClass) {
final List<AnnotatedMethodElement> elements = new LinkedList<AnnotatedMethodElement>();
ReflectionUtils.doWithMethods(beanClass, new ReflectionUtils.MethodCallback() {
@Override
public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
Method bridgedMethod = findBridgedMethod(method);
if (!isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
for (Class<? extends Annotation> annotationType : getAnnotationTypes()) {
AnnotationAttributes attributes = doGetAnnotationAttributes(bridgedMethod, annotationType);
if (attributes != null && method.equals(ClassUtils.getMostSpecificMethod(method, beanClass))) {
if (Modifier.isStatic(method.getModifiers())) {
if (log.isWarnEnabled()) {
log.warn("@" + annotationType.getName() + " annotation is not supported on static methods: " + method);
}
return;
}
if (method.getParameterTypes().length == 0) {
if (log.isWarnEnabled()) {
log.warn("@" + annotationType.getName() + " annotation should only be used on methods with parameters: " +
method);
}
}
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, beanClass);
elements.add(new AnnotatedMethodElement(method, pd, attributes, applicationContext));
}
}
}
});
return elements;
}
protected AnnotationAttributes doGetAnnotationAttributes(AnnotatedElement annotatedElement,
Class<? extends Annotation> annotationType) {
return AnnotationUtils.getAnnotationAttributes(annotatedElement, annotationType, this.environment,
classValuesAsString, nestedAnnotationsAsMap, ignoreDefaultValue, tryMergedAnnotation);
}
protected final Class<? extends Annotation>[] getAnnotationTypes() {
return annotationTypes;
}
private List<AnnotatedFieldElement> findFieldAnnotationMetadata(final Class<?> beanClass) {
final List<AnnotatedFieldElement> elements = new LinkedList<AnnotatedFieldElement>();
ReflectionUtils.doWithFields(beanClass, new ReflectionUtils.FieldCallback() {
@Override
public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
for (Class<? extends Annotation> annotationType : getAnnotationTypes()) {
AnnotationAttributes attributes = doGetAnnotationAttributes(field, annotationType);
if (attributes != null) {
// 非静态方法
if (Modifier.isStatic(field.getModifiers())) {
if (log.isWarnEnabled()) {
log.warn("@" + annotationType.getName() + " is not supported on static fields: " + field);
}
return;
}
elements.add(new AnnotatedFieldElement(field, attributes, applicationContext));
}
}
}
});
return elements;
}
@Override
public int getOrder() {
return this.order;
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
Assert.isInstanceOf(ConfigurableListableBeanFactory.class, beanFactory,
"AnnotationInjectedBeanPostProcessor requires a ConfigurableListableBeanFactory");
this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
}
@Override
public void destroy() throws Exception {
for (Object object : injectedObjectsCache.values()) {
if (log.isInfoEnabled()) {
log.info(object + " was destroying!");
}
if (object instanceof DisposableBean) {
((DisposableBean) object).destroy();
}
}
this.injectedObjectsCache.clear();
injectionMetadataCache.clear();
injectedObjectsCache.clear();
if (log.isInfoEnabled()) {
log.info(getClass() + " was destroying success!");
}
}
@Override
public void setEnvironment(Environment environment) {
this.environment = environment;
}
protected MyFactoryBean<?> getInjectedObject(AnnotationAttributes attributes, Object bean, String beanName, Class<?> injectedType,
InjectionMetadata.InjectedElement injectedElement) throws Exception {
String cacheKey = this.buildInjectedObjectCacheKey(attributes, bean, beanName, injectedType, injectedElement);
MyFactoryBean<?> injectedObject = this.injectedObjectsCache.get(cacheKey);
if (injectedObject == null) {
synchronized (this.injectedObjectsCache) {
// double check
injectedObject = this.injectedObjectsCache.get(cacheKey);
if (injectedObject == null) {
// 获取需要注入的Bean
injectedObject = this.doGetInjectedBean(attributes, bean, beanName, injectedType, injectedElement);
this.injectedObjectsCache.putIfAbsent(cacheKey, injectedObject);
}
}
}
return injectedObject;
}
protected MyFactoryBean<?> doGetInjectedBean(AnnotationAttributes attributes, Object bean, String beanName, Class<?> injectedType,
InjectionMetadata.InjectedElement injectedElement) throws Exception {
log.info("doGetInjectedBean bean={}, beanName={}", bean.getClass().getName(), beanName);
// String referencedBeanName = buildReferencedBeanName(attributes, injectedType);
/**
* The name of bean that is declared by {@link Reference @MyReference} annotation injection
*/
String factoryBeanName = getMyFactoryBeanName(attributes, injectedType);
referencedBeanNameIdx.computeIfAbsent(factoryBeanName, k -> new TreeSet<String>()).add(factoryBeanName);
MyFactoryBean<?> factoryBean = buildMyFactoryBeanIfAbsent(factoryBeanName, attributes, injectedType);
if (!isSpringIoCBeanPreferred) {
// 注入 Bean 到spring IoC 中
registerMyFactoryBean(factoryBean, factoryBeanName);
}
// 缓存
cacheInjectedReferenceBean(factoryBean, injectedElement);
// 执行初始化后应用Bean后处理器
return (MyFactoryBean<?>) getBeanFactory().applyBeanPostProcessorsAfterInitialization(factoryBean, factoryBeanName);
}
private void cacheInjectedReferenceBean(MyFactoryBean<?> factoryBean,
InjectionMetadata.InjectedElement injectedElement) {
if (injectedElement.getMember() instanceof Field) {
injectedFieldMyFactoryBeanCache.put(injectedElement, factoryBean);
} else if (injectedElement.getMember() instanceof Method) {
injectedMethodMyFactoryBeanCache.put(injectedElement, factoryBean);
}
}
private void registerMyFactoryBean(MyFactoryBean<?> factoryBean, String beanName) {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsBean(beanName)) {
Object bean = beanFactory.getBean(beanName);
if (!Objects.equals(bean.getClass().getName(), factoryBean.getObjectType().getName())) {
throw new RuntimeException("bean name '" + beanName + "' is exists in the container");
}
} else {
beanFactory.registerSingleton(beanName, factoryBean);
}
}
protected ConfigurableListableBeanFactory getBeanFactory() {
return beanFactory;
}
private MyFactoryBean<?> buildMyFactoryBeanIfAbsent(String referenceBeanName, AnnotationAttributes attributes,
Class<?> referencedType) throws Exception {
MyFactoryBean<?> factoryBean = factoryBeanCache.get(referenceBeanName);
if (factoryBean == null) {
factoryBean = MyFactoryBean.of(referencedType);
factoryBeanCache.putIfAbsent(referenceBeanName, factoryBean);
}
return factoryBeanCache.get(referenceBeanName);
}
private String getMyFactoryBeanName(AnnotationAttributes attributes, Class<?> interfaceClass) {
String beanName = AnnotationUtils.getAttribute(attributes, "id");
if (!hasText(beanName)) {
beanName = generateMyFactoryBeanName(attributes, interfaceClass);
}
return beanName;
}
private String generateMyFactoryBeanName(AnnotationAttributes attributes, Class<?> interfaceClass) {
StringBuilder beanNameBuilder = new StringBuilder("@MyReference");
if (!attributes.isEmpty()) {
beanNameBuilder.append('(');
for (Map.Entry<String, Object> entry : attributes.entrySet()) {
String value;
if ("parameters".equals(entry.getKey())) {
ArrayList<String> pairs = getParameterPairs(entry);
value = convertAttribute(pairs.stream().sorted().toArray());
} else {
value = convertAttribute(entry.getValue());
}
beanNameBuilder.append(entry.getKey())
.append('=')
.append(value)
.append(',');
}
// replace the latest "," to be ")"
beanNameBuilder.setCharAt(beanNameBuilder.lastIndexOf(","), ')');
}
beanNameBuilder.append(" ").append(interfaceClass.getName());
return beanNameBuilder.toString();
}
private String convertAttribute(Object obj) {
if (obj == null) {
return null;
}
if (obj instanceof Annotation) {
AnnotationAttributes attributes = AnnotationUtils.getAnnotationAttributes((Annotation) obj, true);
for (Map.Entry<String, Object> entry : attributes.entrySet()) {
entry.setValue(convertAttribute(entry.getValue()));
}
return String.valueOf(attributes);
} else if (obj.getClass().isArray()) {
Object[] array = ObjectUtils.toObjectArray(obj);
String[] newArray = new String[array.length];
for (int i = 0; i < array.length; i++) {
newArray[i] = convertAttribute(array[i]);
}
return Arrays.toString(Arrays.stream(newArray).sorted().toArray());
} else {
return String.valueOf(obj);
}
}
private ArrayList<String> getParameterPairs(Map.Entry<String, Object> entry) {
String[] entryValues = (String[]) entry.getValue();
ArrayList<String> pairs = new ArrayList<>();
// parameters spec is {key1,value1,key2,value2}
for (int i = 0; i < entryValues.length / 2 * 2; i = i + 2) {
pairs.add(entryValues[i] + "=" + entryValues[i + 1]);
}
return pairs;
}
protected String buildInjectedObjectCacheKey(AnnotationAttributes attributes, Object bean, String beanName,
Class<?> injectedType, InjectionMetadata.InjectedElement injectedElement) {
return buildReferencedBeanName(attributes, injectedType) +
"#source=" + (injectedElement.getMember()) +
"#attributes=" + AnnotationUtils.getAttributes(attributes, getEnvironment());
}
private String buildReferencedBeanName(AnnotationAttributes attributes, Class<?> serviceInterfaceType) {
ServiceBeanNameBuilder serviceBeanNameBuilder = create(attributes, serviceInterfaceType, getEnvironment());
return serviceBeanNameBuilder.build();
}
public static ServiceBeanNameBuilder create(AnnotationAttributes attributes, Class<?> defaultInterfaceClass, Environment environment) {
return new ServiceBeanNameBuilder(attributes, defaultInterfaceClass, environment);
}
private static <T> Collection<T> combine(Collection<? extends T>... elements) {
List<T> allElements = new ArrayList<T>();
for (Collection<? extends T> e : elements) {
allElements.addAll(e);
}
return allElements;
}
@Override
public void onApplicationEvent(ApplicationEvent event) {
if (event instanceof ContextRefreshedEvent) {
referencedBeanNameIdx.entrySet().stream().filter(e -> e.getValue().size() > 1).forEach(e -> {
String logPrefix = e.getKey() + " has " + e.getValue().size() + " reference instances, there are: ";
log.warn(e.getValue().stream().collect(Collectors.joining(", ", logPrefix, "")));
});
referencedBeanNameIdx.clear();
}
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
private class AnnotatedInjectionMetadata extends InjectionMetadata {
private final Collection<AnnotatedFieldElement> fieldElements;
private final Collection<AnnotatedMethodElement> methodElements;
public AnnotatedInjectionMetadata(Class<?> targetClass, Collection<AnnotatedFieldElement> fieldElements, Collection<AnnotatedMethodElement> methodElements) {
super(targetClass, ReferenceAnnotationBeanPostProcessor.combine(fieldElements, methodElements));
this.fieldElements = fieldElements;
this.methodElements = methodElements;
}
public Collection<AnnotatedFieldElement> getFieldElements() {
return this.fieldElements;
}
public Collection<AnnotatedMethodElement> getMethodElements() {
return this.methodElements;
}
}
public class AnnotatedFieldElement extends InjectionMetadata.InjectedElement {
private final Field field;
private final AnnotationAttributes attributes;
private volatile Object bean;
private ApplicationContext applicationContext;
protected AnnotatedFieldElement(Field field, AnnotationAttributes attributes, ApplicationContext applicationContext) {
super(field, (PropertyDescriptor) null);
this.field = field;
this.attributes = attributes;
this.applicationContext = applicationContext;
}
@Override
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
Class<?> injectedType = this.resolveInjectedType(bean, this.field);
ReflectionUtils.makeAccessible(this.field);
MyFactoryBean<?> injectedObject = getInjectedObject(this.attributes, bean, beanName, injectedType, this);
String factoryBeanName = getMyFactoryBeanName(attributes, injectedType);
// 注入
this.field.set(bean, getFinallyInjectedBean(injectedObject, factoryBeanName));
}
private Class<?> resolveInjectedType(Object bean, Field field) {
Type genericType = field.getGenericType();
return genericType instanceof Class ? field.getType() : GenericTypeResolver.resolveTypeArgument(AopUtils.getTargetClass(bean), field.getDeclaringClass());
}
}
private class AnnotatedMethodElement extends InjectionMetadata.InjectedElement {
private final Method method;
private final AnnotationAttributes attributes;
private volatile Object object;
private ApplicationContext applicationContext;
protected AnnotatedMethodElement(Method method, PropertyDescriptor pd, AnnotationAttributes attributes, ApplicationContext applicationContext) {
super(method, pd);
this.method = method;
this.attributes = attributes;
this.applicationContext = applicationContext;
}
@Override
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
Class<?> injectedType = this.pd.getPropertyType();
// 获取需要注入的Bean
MyFactoryBean<?> injectedObject = ReferenceAnnotationBeanPostProcessor.this.getInjectedObject(this.attributes, bean, beanName, injectedType, this);
ReflectionUtils.makeAccessible(this.method);
String factoryBeanName = getMyFactoryBeanName(attributes, injectedType);
// 注入
this.method.invoke(bean, getFinallyInjectedBean(injectedObject, factoryBeanName));
}
}
/**
* 获取最终需要注入的Bean
*
* @param factoryBean
* @param beanName
* @return
* @throws Exception
*/
private Object getFinallyInjectedBean(MyFactoryBean<?> factoryBean, String beanName) throws Exception {
if (!isSpringIoCBeanPreferred) {
return factoryBean.getObject();
}
Object injected = null;
String[] beanNames = this.applicationContext.getBeanNamesForType(factoryBean.getObjectType());
if (beanNames.length >= 1) {
// find first
injected = this.applicationContext.getBean(beanNames[0]);
}
if (injected == null) {
injected = factoryBean.getObject();
// 注入到spring Ioc容器中
registerMyFactoryBean(factoryBean, beanName);
}
return injected;
}
public Environment getEnvironment() {
return this.environment;
}
}
4.1 其他关联类
AnnotationUtils
public class AnnotationUtils {
public static final String ANNOTATED_ELEMENT_UTILS_CLASS_NAME = "org.springframework.core.annotation.AnnotatedElementUtils";
public static <T> T getAttribute(Map<String, Object> attributes, String attributeName) {
return getAttribute(attributes, attributeName, false);
}
public static <T> T getAttribute(Map<String, Object> attributes, String attributeName, boolean required) {
T value = getAttribute(attributes, attributeName, null);
if (required && value == null) {
throw new IllegalStateException("The attribute['" + attributeName + "] is required!");
}
return value;
}
public static <T> T getAttribute(Map<String, Object> attributes, String attributeName, T defaultValue) {
T value = (T) attributes.get(attributeName);
return value == null ? defaultValue : value;
}
public static String resolveInterfaceName(AnnotationAttributes attributes, Class<?> defaultInterfaceClass) {
Boolean generic = getAttribute(attributes, "generic");
if (generic != null && generic) {
// it's a generic reference
String interfaceClassName = getAttribute(attributes, "interfaceName");
Assert.hasText(interfaceClassName,
"@Reference interfaceName() must be present when reference a generic service!");
return interfaceClassName;
}
return resolveServiceInterfaceClass(attributes, defaultInterfaceClass).getName();
}
public static Class<?> resolveServiceInterfaceClass(AnnotationAttributes attributes, Class<?> defaultInterfaceClass)
throws IllegalArgumentException {
ClassLoader classLoader = defaultInterfaceClass != null ? defaultInterfaceClass.getClassLoader() : Thread.currentThread().getContextClassLoader();
Class<?> interfaceClass = getAttribute(attributes, "interfaceClass");
if (void.class.equals(interfaceClass)) { // default or set void.class for purpose.
interfaceClass = null;
String interfaceClassName = getAttribute(attributes, "interfaceName");
if (hasText(interfaceClassName)) {
if (ClassUtils.isPresent(interfaceClassName, classLoader)) {
interfaceClass = resolveClassName(interfaceClassName, classLoader);
}
}
}
if (interfaceClass == null && defaultInterfaceClass != null) {
// Find all interfaces from the annotated class
Class<?>[] allInterfaces = getAllInterfacesForClass(defaultInterfaceClass);
if (allInterfaces.length > 0) {
interfaceClass = allInterfaces[0];
}
}
return interfaceClass == null ? defaultInterfaceClass : interfaceClass;
}
public static AnnotationAttributes getAnnotationAttributes(AnnotatedElement annotatedElement,
Class<? extends Annotation> annotationType,
PropertyResolver propertyResolver,
boolean classValuesAsString,
boolean nestedAnnotationsAsMap,
boolean ignoreDefaultValue,
boolean tryMergedAnnotation,
String... ignoreAttributeNames) {
AnnotationAttributes attributes = null;
if (tryMergedAnnotation) {
attributes = tryGetMergedAnnotationAttributes(annotatedElement, annotationType, propertyResolver,
classValuesAsString, nestedAnnotationsAsMap, ignoreDefaultValue, ignoreAttributeNames);
}
if (attributes == null) {
attributes = getAnnotationAttributes(annotatedElement, annotationType, propertyResolver,
classValuesAsString, nestedAnnotationsAsMap, ignoreDefaultValue, ignoreAttributeNames);
}
return attributes;
}
public static AnnotationAttributes getAnnotationAttributes(AnnotatedElement annotatedElement,
Class<? extends Annotation> annotationType,
PropertyResolver propertyResolver,
boolean classValuesAsString,
boolean nestedAnnotationsAsMap,
boolean ignoreDefaultValue,
String... ignoreAttributeNames) {
Annotation annotation = annotatedElement.getAnnotation(annotationType);
return annotation == null ? null : getAnnotationAttributes(annotation, propertyResolver,
classValuesAsString, nestedAnnotationsAsMap, ignoreDefaultValue, ignoreAttributeNames);
}
public static Annotation tryGetMergedAnnotation(AnnotatedElement annotatedElement,
Class<? extends Annotation> annotationType,
boolean classValuesAsString,
boolean nestedAnnotationsAsMap) {
Annotation mergedAnnotation = null;
ClassLoader classLoader = annotationType.getClassLoader();
if (ClassUtils.isPresent(ANNOTATED_ELEMENT_UTILS_CLASS_NAME, classLoader)) {
Class<?> annotatedElementUtilsClass = resolveClassName(ANNOTATED_ELEMENT_UTILS_CLASS_NAME, classLoader);
// getMergedAnnotation method appears in the Spring Framework 4.2
Method getMergedAnnotationMethod = findMethod(annotatedElementUtilsClass, "getMergedAnnotation",
AnnotatedElement.class, Class.class, boolean.class, boolean.class);
if (getMergedAnnotationMethod != null) {
mergedAnnotation = (Annotation) invokeMethod(getMergedAnnotationMethod, null,
annotatedElement, annotationType, classValuesAsString, nestedAnnotationsAsMap);
}
}
return mergedAnnotation;
}
public static AnnotationAttributes tryGetMergedAnnotationAttributes(AnnotatedElement annotatedElement,
Class<? extends Annotation> annotationType,
PropertyResolver propertyResolver,
boolean classValuesAsString,
boolean nestedAnnotationsAsMap,
boolean ignoreDefaultValue,
String... ignoreAttributeNames) {
Annotation annotation = tryGetMergedAnnotation(annotatedElement, annotationType, classValuesAsString, nestedAnnotationsAsMap);
return annotation == null ? null : getAnnotationAttributes(annotation, propertyResolver,
classValuesAsString, nestedAnnotationsAsMap, ignoreDefaultValue, ignoreAttributeNames);
}
public static AnnotationAttributes getAnnotationAttributes(Annotation annotation, boolean ignoreDefaultValue,
String... ignoreAttributeNames) {
return getAnnotationAttributes(annotation, null, ignoreDefaultValue, ignoreAttributeNames);
}
public static AnnotationAttributes getAnnotationAttributes(Annotation annotation, PropertyResolver propertyResolver,
boolean ignoreDefaultValue, String... ignoreAttributeNames) {
return getAnnotationAttributes(annotation, propertyResolver, false, false, ignoreDefaultValue, ignoreAttributeNames);
}
public static AnnotationAttributes getAnnotationAttributes(Annotation annotation,
PropertyResolver propertyResolver,
boolean classValuesAsString,
boolean nestedAnnotationsAsMap,
boolean ignoreDefaultValue,
String... ignoreAttributeNames) {
return fromMap(getAttributes(annotation, propertyResolver, classValuesAsString, nestedAnnotationsAsMap,
ignoreDefaultValue, ignoreAttributeNames));
}
public static Map<String, Object> getAttributes(Annotation annotation,
PropertyResolver propertyResolver,
boolean classValuesAsString,
boolean nestedAnnotationsAsMap,
boolean ignoreDefaultValue,
String... ignoreAttributeNames) {
Map<String, Object> annotationAttributes = org.springframework.core.annotation.AnnotationUtils.getAnnotationAttributes(annotation, classValuesAsString, nestedAnnotationsAsMap);
String[] actualIgnoreAttributeNames = ignoreAttributeNames;
if (ignoreDefaultValue && !isEmpty(annotationAttributes)) {
List<String> attributeNamesToIgnore = new LinkedList<String>(asList(ignoreAttributeNames));
for (Map.Entry<String, Object> annotationAttribute : annotationAttributes.entrySet()) {
String attributeName = annotationAttribute.getKey();
Object attributeValue = annotationAttribute.getValue();
if (nullSafeEquals(attributeValue, getDefaultValue(annotation, attributeName))) {
attributeNamesToIgnore.add(attributeName);
}
}
// extends the ignored list
actualIgnoreAttributeNames = attributeNamesToIgnore.toArray(new String[attributeNamesToIgnore.size()]);
}
return getAttributes(annotationAttributes, propertyResolver, actualIgnoreAttributeNames);
}
public static Map<String, Object> getAttributes(Map<String, Object> annotationAttributes,
PropertyResolver propertyResolver, String... ignoreAttributeNames) {
Set<String> ignoreAttributeNamesSet = new HashSet<String>();
if (ignoreAttributeNames != null && ignoreAttributeNames.length > 0) {
for (String ignoreAttributeName : ignoreAttributeNames) {
ignoreAttributeNamesSet.add(ignoreAttributeName);
}
}
Map<String, Object> actualAttributes = new LinkedHashMap<String, Object>();
for (Map.Entry<String, Object> annotationAttribute : annotationAttributes.entrySet()) {
String attributeName = annotationAttribute.getKey();
Object attributeValue = annotationAttribute.getValue();
// ignore attribute name
if (ignoreAttributeNamesSet.contains(attributeName)) {
continue;
}
if (attributeValue instanceof String) {
attributeValue = resolvePlaceholders(valueOf(attributeValue), propertyResolver);
} else if (attributeValue instanceof String[]) {
String[] values = (String[]) attributeValue;
for (int i = 0; i < values.length; i++) {
values[i] = resolvePlaceholders(values[i], propertyResolver);
}
attributeValue = values;
}
actualAttributes.put(attributeName, attributeValue);
}
return actualAttributes;
}
private static String resolvePlaceholders(String attributeValue, PropertyResolver propertyResolver) {
String resolvedValue = attributeValue;
if (propertyResolver != null) {
resolvedValue = propertyResolver.resolvePlaceholders(resolvedValue);
resolvedValue = trimWhitespace(resolvedValue);
}
return resolvedValue;
}
}
ServiceBeanNameBuilder
public class ServiceBeanNameBuilder {
private static final String SEPARATOR = ":";
// Required
private final String interfaceClassName;
private final Environment environment;
// Optional
private String version;
private String group;
private ServiceBeanNameBuilder(Class<?> interfaceClass, Environment environment) {
this(interfaceClass.getName(), environment);
}
private ServiceBeanNameBuilder(String interfaceClassName, Environment environment) {
this.interfaceClassName = interfaceClassName;
this.environment = environment;
}
public ServiceBeanNameBuilder(AnnotationAttributes attributes, Class<?> defaultInterfaceClass, Environment environment) {
this(AnnotationUtils.resolveInterfaceName(attributes, defaultInterfaceClass), environment);
this.group(AnnotationUtils.getAttribute(attributes, "group"));
this.version(AnnotationUtils.getAttribute(attributes, "version"));
}
public static ServiceBeanNameBuilder create(AnnotationAttributes attributes, Class<?> defaultInterfaceClass, Environment environment) {
return new ServiceBeanNameBuilder(attributes, defaultInterfaceClass, environment);
}
public static ServiceBeanNameBuilder create(Class<?> interfaceClass, Environment environment) {
return new ServiceBeanNameBuilder(interfaceClass, environment);
}
private static void append(StringBuilder builder, String value) {
if (StringUtils.hasText(value)) {
builder.append(SEPARATOR).append(value);
}
}
public ServiceBeanNameBuilder group(String group) {
this.group = group;
return this;
}
public ServiceBeanNameBuilder version(String version) {
this.version = version;
return this;
}
public String build() {
StringBuilder beanNameBuilder = new StringBuilder("ServiceBean");
// Required
append(beanNameBuilder, interfaceClassName);
// Optional
append(beanNameBuilder, version);
append(beanNameBuilder, group);
// Build and remove last ":"
String rawBeanName = beanNameBuilder.toString();
// Resolve placeholders
return environment.resolvePlaceholders(rawBeanName);
}
}
五、注入InstantiationAwareBeanPostProcessor到IoC中
5.1 实现ImportBeanDefinitionRegistrar接口
public class RefImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
BeanNameGenerator importBeanNameGenerator) {
RootBeanDefinition beanDefinition = new RootBeanDefinition();
beanDefinition.setBeanClass(ReferenceAnnotationBeanPostProcessor.class);
ConstructorArgumentValues values = new ConstructorArgumentValues();
// 添加需要扫描的注解
values.addIndexedArgumentValue(0, new Class[]{MyReference.class});
// isSpringIoCBeanPreferred：是否以Spring IoC容器中Bean优先
values.addIndexedArgumentValue(1, true);
beanDefinition.setConstructorArgumentValues(values);
String beanName = importBeanNameGenerator.generateBeanName(beanDefinition, registry);
registry.registerBeanDefinition(beanName, beanDefinition);
}
}
5.2 通过@Import注入
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({RefImportBeanDefinitionRegistrar.class})
public @interface EnableReference {
}
六、使用
6.1 打jar包
将上面代码打成一个jar
6.2 引用jar
<dependency>
<groupId>com.tortoise</groupId>
<artifactId>my-reference</artifactId>
<version>1.0.0-SNAPSHOT</version>
</dependency>
6.3 调用
扫一扫
910
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
