root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Code cleanup on new baseline

This commit is contained in:
Juergen Hoeller 2021-09-28 19:02:44 +02:00
parent 4d7fa9a632
commit f32f04d841
3 changed files with 9 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
spring-beans/src/main/java/org/springframework/beans/factory/annotation/ParameterResolutionDelegate.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2019 the original author or authors.
* Copyright 2002-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -18,7 +18,6 @@ package org.springframework.beans.factory.annotation;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Constructor;
import java.lang.reflect.Executable;
import java.lang.reflect.Parameter;
@ -30,7 +29,6 @@ import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.core.annotation.SynthesizingMethodParameter;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
/**
* Public delegate for resolving autowirable parameters on externally managed
@ -81,10 +79,9 @@ public final class ParameterResolutionDelegate {
*/
public static boolean isAutowirable(Parameter parameter, int parameterIndex) {
Assert.notNull(parameter, "Parameter must not be null");
AnnotatedElement annotatedParameter = getEffectiveAnnotatedParameter(parameter, parameterIndex);
return (AnnotatedElementUtils.hasAnnotation(annotatedParameter, Autowired.class) ||
AnnotatedElementUtils.hasAnnotation(annotatedParameter, Qualifier.class) ||
AnnotatedElementUtils.hasAnnotation(annotatedParameter, Value.class));
return (AnnotatedElementUtils.hasAnnotation(parameter, Autowired.class) ||
AnnotatedElementUtils.hasAnnotation(parameter, Qualifier.class) ||
AnnotatedElementUtils.hasAnnotation(parameter, Value.class));
}
/**
@ -125,8 +122,7 @@ public final class ParameterResolutionDelegate {
Assert.notNull(containingClass, "Containing class must not be null");
Assert.notNull(beanFactory, "AutowireCapableBeanFactory must not be null");
AnnotatedElement annotatedParameter = getEffectiveAnnotatedParameter(parameter, parameterIndex);
Autowired autowired = AnnotatedElementUtils.findMergedAnnotation(annotatedParameter, Autowired.class);
Autowired autowired = AnnotatedElementUtils.findMergedAnnotation(parameter, Autowired.class);
boolean required = (autowired == null || autowired.required());
MethodParameter methodParameter = SynthesizingMethodParameter.forExecutable(
@ -136,36 +132,4 @@ public final class ParameterResolutionDelegate {
return beanFactory.resolveDependency(descriptor, null);
}
/**
* Due to a bug in {@code javac} on JDK versions prior to JDK 9, looking up
* annotations directly on a {@link Parameter} will fail for inner class
* constructors.
* <h4>Bug in javac in JDK &lt; 9</h4>
* <p>The parameter annotations array in the compiled byte code excludes an entry
* for the implicit <em>enclosing instance</em> parameter for an inner class
* constructor.
* <h4>Workaround</h4>
* <p>This method provides a workaround for this off-by-one error by allowing the
* caller to access annotations on the preceding {@link Parameter} object (i.e.,
* {@code index - 1}). If the supplied {@code index} is zero, this method returns
* an empty {@code AnnotatedElement}.
* <h4>WARNING</h4>
* <p>The {@code AnnotatedElement} returned by this method should never be cast and
* treated as a {@code Parameter} since the metadata (e.g., {@link Parameter#getName()},
* {@link Parameter#getType()}, etc.) will not match those for the declared parameter
* at the given index in an inner class constructor.
* @return the supplied {@code parameter} or the <em>effective</em> {@code Parameter}
* if the aforementioned bug is in effect
*/
private static AnnotatedElement getEffectiveAnnotatedParameter(Parameter parameter, int index) {
Executable executable = parameter.getDeclaringExecutable();
if (executable instanceof Constructor && ClassUtils.isInnerClass(executable.getDeclaringClass()) &&
executable.getParameterAnnotations().length == executable.getParameterCount() - 1) {
// Bug in javac in JDK <9: annotation array excludes enclosing instance parameter
// for inner classes, so access it with the actual parameter index lowered by 1
return (index == 0 ? EMPTY_ANNOTATED_ELEMENT : executable.getParameters()[index - 1]);
}
return parameter;
}
}

4
spring-context/src/main/java/org/springframework/context/annotation/CommonAnnotationBeanPostProcessor.java
View File

@ -227,7 +227,7 @@ public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBean
/**
* Specify the factory for objects to be injected into {@code @Resource} /
* {@code @WebServiceRef} / {@code @EJB} annotated fields and setter methods,
* {@code @EJB} annotated fields and setter methods,
* <b>for {@code mappedName} attributes that point directly into JNDI</b>.
* This factory will also be used if "alwaysUseJndiLookup" is set to "true" in order
* to enforce JNDI lookups even for {@code name} attributes and default names.
@ -243,7 +243,7 @@ public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBean
/**
* Specify the factory for objects to be injected into {@code @Resource} /
* {@code @WebServiceRef} / {@code @EJB} annotated fields and setter methods,
* {@code @EJB} annotated fields and setter methods,
* <b>for {@code name} attributes and default names</b>.
* <p>The default is the BeanFactory that this post-processor is defined in,
* if any, looking up resource names as Spring bean names. Specify the resource

5
spring-jcl/src/main/java/org/apache/commons/logging/LogAdapter.java
View File

@ -681,7 +681,6 @@ final class LogAdapter {
setSourceMethodName(sourceMethodName);
}
@SuppressWarnings("deprecation")
protected Object writeReplace() {
LogRecord serialized = new LogRecord(getLevel(), getMessage());
serialized.setLoggerName(getLoggerName());
@ -691,8 +690,8 @@ final class LogAdapter {
serialized.setSourceMethodName(getSourceMethodName());
serialized.setSequenceNumber(getSequenceNumber());
serialized.setParameters(getParameters());
serialized.setThreadID(getThreadID());
serialized.setMillis(getMillis());
serialized.setLongThreadID(getLongThreadID());
serialized.setInstant(getInstant());
serialized.setThrown(getThrown());
return serialized;
}