GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Polishing

pull/22634/head
Juergen Hoeller 7 years ago
parent
88049e9b5c
commit
fe56aa6fa4
11 changed files with 382 additions and 362 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      spring-context/src/main/java/org/springframework/cache/interceptor/CacheAspectSupport.java
  2. 7
      spring-context/src/main/java/org/springframework/cache/interceptor/CacheOperationSource.java
  3. 9
      spring-context/src/main/java/org/springframework/cache/interceptor/CompositeCacheOperationSource.java
  4. 5
      spring-context/src/main/java/org/springframework/scripting/support/StandardScriptFactory.java
  5. 7
      spring-core/src/main/java/org/springframework/lang/NonNull.java
  6. 4
      spring-core/src/main/java/org/springframework/lang/NonNullFields.java
  7. 8
      spring-core/src/main/java/org/springframework/lang/Nullable.java
  8. 666
      spring-core/src/main/java/org/springframework/util/ReflectionUtils.java
  9. 12
      spring-tx/src/main/java/org/springframework/transaction/interceptor/CompositeTransactionAttributeSource.java
  10. 6
      spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttributeSource.java
  11. 8
      spring-web/src/main/java/org/springframework/http/server/ServerHttpRequest.java

12
spring-context/src/main/java/org/springframework/cache/interceptor/CacheAspectSupport.java vendored
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2018 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -313,9 +313,9 @@ public abstract class CacheAspectSupport extends AbstractCacheInvoker
* @param expectedType type for the bean * @param expectedType type for the bean
* @return the bean matching that name * @return the bean matching that name
* @throws org.springframework.beans.factory.NoSuchBeanDefinitionException if such bean does not exist * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException if such bean does not exist
* @see CacheOperation#keyGenerator * @see CacheOperation#getKeyGenerator()
* @see CacheOperation#cacheManager * @see CacheOperation#getCacheManager()
* @see CacheOperation#cacheResolver * @see CacheOperation#getCacheResolver()
*/ */
protected <T> T getBean(String beanName, Class<T> expectedType) { protected <T> T getBean(String beanName, Class<T> expectedType) {
if (this.beanFactory == null) { if (this.beanFactory == null) {
@ -353,8 +353,8 @@ public abstract class CacheAspectSupport extends AbstractCacheInvoker
/** /**
* Execute the underlying operation (typically in case of cache miss) and return * Execute the underlying operation (typically in case of cache miss) and return
* the result of the invocation. If an exception occurs it will be wrapped in * the result of the invocation. If an exception occurs it will be wrapped in a
* a {@link CacheOperationInvoker.ThrowableWrapper}: the exception can be handled * {@link CacheOperationInvoker.ThrowableWrapper}: the exception can be handled
* or modified but it <em>must</em> be wrapped in a * or modified but it <em>must</em> be wrapped in a
* {@link CacheOperationInvoker.ThrowableWrapper} as well. * {@link CacheOperationInvoker.ThrowableWrapper} as well.
* @param invoker the invoker handling the operation being cached * @param invoker the invoker handling the operation being cached

7
spring-context/src/main/java/org/springframework/cache/interceptor/CacheOperationSource.java vendored
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2012 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -27,13 +27,14 @@ import org.springframework.lang.Nullable;
* source level, or elsewhere. * source level, or elsewhere.
* *
* @author Costin Leau * @author Costin Leau
* @author Juergen Hoeller
* @since 3.1 * @since 3.1
*/ */
public interface CacheOperationSource { public interface CacheOperationSource {
/** /**
* Return the collection of cache operations for this method, or {@code null} * Return the collection of cache operations for this method,
* if the method contains no <em>cacheable</em> annotations. * or {@code null} if the method contains no <em>cacheable</em> annotations.
* @param method the method to introspect * @param method the method to introspect
* @param targetClass the target class (may be {@code null}, in which case * @param targetClass the target class (may be {@code null}, in which case
* the declaring class of the method must be used) * the declaring class of the method must be used)

9
spring-context/src/main/java/org/springframework/cache/interceptor/CompositeCacheOperationSource.java vendored
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2016 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -29,6 +29,7 @@ import org.springframework.util.Assert;
* over a given array of {@code CacheOperationSource} instances. * over a given array of {@code CacheOperationSource} instances.
* *
* @author Costin Leau * @author Costin Leau
* @author Juergen Hoeller
* @since 3.1 * @since 3.1
*/ */
@SuppressWarnings("serial") @SuppressWarnings("serial")
@ -42,7 +43,7 @@ public class CompositeCacheOperationSource implements CacheOperationSource, Seri
* @param cacheOperationSources the CacheOperationSource instances to combine * @param cacheOperationSources the CacheOperationSource instances to combine
*/ */
public CompositeCacheOperationSource(CacheOperationSource... cacheOperationSources) { public CompositeCacheOperationSource(CacheOperationSource... cacheOperationSources) {
Assert.notEmpty(cacheOperationSources, "cacheOperationSources array must not be empty"); Assert.notEmpty(cacheOperationSources, "CacheOperationSource array must not be empty");
this.cacheOperationSources = cacheOperationSources; this.cacheOperationSources = cacheOperationSources;
} }
@ -54,21 +55,21 @@ public class CompositeCacheOperationSource implements CacheOperationSource, Seri
return this.cacheOperationSources; return this.cacheOperationSources;
} }
@Override @Override
@Nullable @Nullable
public Collection<CacheOperation> getCacheOperations(Method method, @Nullable Class<?> targetClass) { public Collection<CacheOperation> getCacheOperations(Method method, @Nullable Class<?> targetClass) {
Collection<CacheOperation> ops = null; Collection<CacheOperation> ops = null;
for (CacheOperationSource source : this.cacheOperationSources) { for (CacheOperationSource source : this.cacheOperationSources) {
Collection<CacheOperation> cacheOperations = source.getCacheOperations(method, targetClass); Collection<CacheOperation> cacheOperations = source.getCacheOperations(method, targetClass);
if (cacheOperations != null) { if (cacheOperations != null) {
if (ops == null) { if (ops == null) {
ops = new ArrayList<>(); ops = new ArrayList<>();
} }
ops.addAll(cacheOperations); ops.addAll(cacheOperations);
} }
} }
return ops; return ops;
} }
} }

5
spring-context/src/main/java/org/springframework/scripting/support/StandardScriptFactory.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2017 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -36,7 +36,7 @@ import org.springframework.util.StringUtils;
/** /**
* {@link org.springframework.scripting.ScriptFactory} implementation based * {@link org.springframework.scripting.ScriptFactory} implementation based
* on the JSR-223 script engine abstraction (as included in Java 6+). * on the JSR-223 script engine abstraction (as included in Java 6+).
* Supports JavaScript, Groovy, JRuby and other JSR-223 compliant engines. * Supports JavaScript, Groovy, JRuby, and other JSR-223 compliant engines.
* *
* <p>Typically used in combination with a * <p>Typically used in combination with a
* {@link org.springframework.scripting.support.ScriptFactoryPostProcessor}; * {@link org.springframework.scripting.support.ScriptFactoryPostProcessor};
@ -151,6 +151,7 @@ public class StandardScriptFactory implements ScriptFactory, BeanClassLoaderAwar
if (script instanceof Class ? !requestedIfc.isAssignableFrom((Class<?>) script) : if (script instanceof Class ? !requestedIfc.isAssignableFrom((Class<?>) script) :
!requestedIfc.isInstance(script)) { !requestedIfc.isInstance(script)) {
adaptationRequired = true; adaptationRequired = true;
break;
} }
} }
if (adaptationRequired) { if (adaptationRequired) {

7
spring-core/src/main/java/org/springframework/lang/NonNull.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2018 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -26,8 +26,9 @@ import javax.annotation.meta.TypeQualifierNickname;
/** /**
* A common Spring annotation to declare that annotated elements cannot be {@code null}. * A common Spring annotation to declare that annotated elements cannot be {@code null}.
* Leverages JSR 305 meta-annotations to indicate nullability in Java to common tools with *
* JSR 305 support and used by Kotlin to infer nullability of Spring API. * <p>Leverages JSR-305 meta-annotations to indicate nullability in Java to common
* tools with JSR-305 support and used by Kotlin to infer nullability of Spring API.
* *
* <p>Should be used at parameter, return value, and field level. Method overrides should * <p>Should be used at parameter, return value, and field level. Method overrides should
* repeat parent {@code @NonNull} annotations unless they behave differently. * repeat parent {@code @NonNull} annotations unless they behave differently.

4
spring-core/src/main/java/org/springframework/lang/NonNullFields.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2017 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -36,7 +36,7 @@ import javax.annotation.meta.TypeQualifierDefault;
* *
* @author Sebastien Deleuze * @author Sebastien Deleuze
* @since 5.0 * @since 5.0
* @see NonNullFields * @see NonNullApi
* @see Nullable * @see Nullable
* @see NonNull * @see NonNull
*/ */

8
spring-core/src/main/java/org/springframework/lang/Nullable.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2018 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -27,8 +27,10 @@ import javax.annotation.meta.When;
/** /**
* A common Spring annotation to declare that annotated elements can be {@code null} under * A common Spring annotation to declare that annotated elements can be {@code null} under
* some circumstance. Leverages JSR 305 meta-annotations to indicate nullability in Java * some circumstance.
* to common tools with JSR 305 support and used by Kotlin to infer nullability of Spring API. *
* <p>Leverages JSR-305 meta-annotations to indicate nullability in Java to common
* tools with JSR-305 support and used by Kotlin to infer nullability of Spring API.
* *
* <p>Should be used at parameter, return value, and field level. Methods override should * <p>Should be used at parameter, return value, and field level. Methods override should
* repeat parent {@code @Nullable} annotations unless they behave differently. * repeat parent {@code @Nullable} annotations unless they behave differently.

666
spring-core/src/main/java/org/springframework/util/ReflectionUtils.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2018 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -61,13 +61,13 @@ public abstract class ReflectionUtils {
* @since 3.0.5 * @since 3.0.5
*/ */
public static final MethodFilter USER_DECLARED_METHODS = public static final MethodFilter USER_DECLARED_METHODS =
(method -> (!method.isBridge() && !method.isSynthetic() && method.getDeclaringClass() != Object.class)); (method -> !method.isBridge() && !method.isSynthetic() && method.getDeclaringClass() != Object.class);
/** /**
* Pre-built FieldFilter that matches all non-static, non-final fields. * Pre-built FieldFilter that matches all non-static, non-final fields.
*/ */
public static final FieldFilter COPYABLE_FIELDS = public static final FieldFilter COPYABLE_FIELDS =
field -> !(Modifier.isStatic(field.getModifiers()) || Modifier.isFinal(field.getModifiers())); (field -> !(Modifier.isStatic(field.getModifiers()) || Modifier.isFinal(field.getModifiers())));
/** /**
@ -76,9 +76,9 @@ public abstract class ReflectionUtils {
*/ */
private static final String CGLIB_RENAMED_METHOD_PREFIX = "CGLIB$"; private static final String CGLIB_RENAMED_METHOD_PREFIX = "CGLIB$";
private static final Method[] NO_METHODS = {}; private static final Method[] EMPTY_METHOD_ARRAY = new Method[0];
private static final Field[] NO_FIELDS = {}; private static final Field[] EMPTY_FIELD_ARRAY = new Field[0];
/** /**
@ -93,209 +93,7 @@ public abstract class ReflectionUtils {
private static final Map<Class<?>, Field[]> declaredFieldsCache = new ConcurrentReferenceHashMap<>(256); private static final Map<Class<?>, Field[]> declaredFieldsCache = new ConcurrentReferenceHashMap<>(256);
/** // Exception handling
* Attempt to find a {@link Field field} on the supplied {@link Class} with the
* supplied {@code name}. Searches all superclasses up to {@link Object}.
* @param clazz the class to introspect
* @param name the name of the field
* @return the corresponding Field object, or {@code null} if not found
*/
@Nullable
public static Field findField(Class<?> clazz, String name) {
return findField(clazz, name, null);
}
/**
* Attempt to find a {@link Field field} on the supplied {@link Class} with the
* supplied {@code name} and/or {@link Class type}. Searches all superclasses
* up to {@link Object}.
* @param clazz the class to introspect
* @param name the name of the field (may be {@code null} if type is specified)
* @param type the type of the field (may be {@code null} if name is specified)
* @return the corresponding Field object, or {@code null} if not found
*/
@Nullable
public static Field findField(Class<?> clazz, @Nullable String name, @Nullable Class<?> type) {
Assert.notNull(clazz, "Class must not be null");
Assert.isTrue(name != null || type != null, "Either name or type of the field must be specified");
Class<?> searchType = clazz;
while (Object.class != searchType && searchType != null) {
Field[] fields = getDeclaredFields(searchType);
for (Field field : fields) {
if ((name == null || name.equals(field.getName())) &&
(type == null || type.equals(field.getType()))) {
return field;
}
}
searchType = searchType.getSuperclass();
}
return null;
}
/**
* Set the field represented by the supplied {@link Field field object} on the
* specified {@link Object target object} to the specified {@code value}.
* In accordance with {@link Field#set(Object, Object)} semantics, the new value
* is automatically unwrapped if the underlying field has a primitive type.
* <p>Thrown exceptions are handled via a call to {@link #handleReflectionException(Exception)}.
* @param field the field to set
* @param target the target object on which to set the field
* @param value the value to set (may be {@code null})
*/
public static void setField(Field field, @Nullable Object target, @Nullable Object value) {
try {
field.set(target, value);
}
catch (IllegalAccessException ex) {
handleReflectionException(ex);
throw new IllegalStateException(
"Unexpected reflection exception - " + ex.getClass().getName() + ": " + ex.getMessage());
}
}
/**
* Get the field represented by the supplied {@link Field field object} on the
* specified {@link Object target object}. In accordance with {@link Field#get(Object)}
* semantics, the returned value is automatically wrapped if the underlying field
* has a primitive type.
* <p>Thrown exceptions are handled via a call to {@link #handleReflectionException(Exception)}.
* @param field the field to get
* @param target the target object from which to get the field
* @return the field's current value
*/
@Nullable
public static Object getField(Field field, @Nullable Object target) {
try {
return field.get(target);
}
catch (IllegalAccessException ex) {
handleReflectionException(ex);
throw new IllegalStateException(
"Unexpected reflection exception - " + ex.getClass().getName() + ": " + ex.getMessage());
}
}
/**
* Attempt to find a {@link Method} on the supplied class with the supplied name
* and no parameters. Searches all superclasses up to {@code Object}.
* <p>Returns {@code null} if no {@link Method} can be found.
* @param clazz the class to introspect
* @param name the name of the method
* @return the Method object, or {@code null} if none found
*/
@Nullable
public static Method findMethod(Class<?> clazz, String name) {
return findMethod(clazz, name, new Class<?>[0]);
}
/**
* Attempt to find a {@link Method} on the supplied class with the supplied name
* and parameter types. Searches all superclasses up to {@code Object}.
* <p>Returns {@code null} if no {@link Method} can be found.
* @param clazz the class to introspect
* @param name the name of the method
* @param paramTypes the parameter types of the method
* (may be {@code null} to indicate any signature)
* @return the Method object, or {@code null} if none found
*/
@Nullable
public static Method findMethod(Class<?> clazz, String name, @Nullable Class<?>... paramTypes) {
Assert.notNull(clazz, "Class must not be null");
Assert.notNull(name, "Method name must not be null");
Class<?> searchType = clazz;
while (searchType != null) {
Method[] methods = (searchType.isInterface() ? searchType.getMethods() : getDeclaredMethods(searchType));
for (Method method : methods) {
if (name.equals(method.getName()) &&
(paramTypes == null || Arrays.equals(paramTypes, method.getParameterTypes()))) {
return method;
}
}
searchType = searchType.getSuperclass();
}
return null;
}
/**
* Invoke the specified {@link Method} against the supplied target object with no arguments.
* The target object can be {@code null} when invoking a static {@link Method}.
* <p>Thrown exceptions are handled via a call to {@link #handleReflectionException}.
* @param method the method to invoke
* @param target the target object to invoke the method on
* @return the invocation result, if any
* @see #invokeMethod(java.lang.reflect.Method, Object, Object[])
*/
@Nullable
public static Object invokeMethod(Method method, @Nullable Object target) {
return invokeMethod(method, target, new Object[0]);
}
/**
* Invoke the specified {@link Method} against the supplied target object with the
* supplied arguments. The target object can be {@code null} when invoking a
* static {@link Method}.
* <p>Thrown exceptions are handled via a call to {@link #handleReflectionException}.
* @param method the method to invoke
* @param target the target object to invoke the method on
* @param args the invocation arguments (may be {@code null})
* @return the invocation result, if any
*/
@Nullable
public static Object invokeMethod(Method method, @Nullable Object target, @Nullable Object... args) {
try {
return method.invoke(target, args);
}
catch (Exception ex) {
handleReflectionException(ex);
}
throw new IllegalStateException("Should never get here");
}
/**
* Invoke the specified JDBC API {@link Method} against the supplied target
* object with no arguments.
* @param method the method to invoke
* @param target the target object to invoke the method on
* @return the invocation result, if any
* @throws SQLException the JDBC API SQLException to rethrow (if any)
* @see #invokeJdbcMethod(java.lang.reflect.Method, Object, Object[])
* @deprecated as of 5.0.11, in favor of custom SQLException handling
*/
@Deprecated
@Nullable
public static Object invokeJdbcMethod(Method method, @Nullable Object target) throws SQLException {
return invokeJdbcMethod(method, target, new Object[0]);
}
/**
* Invoke the specified JDBC API {@link Method} against the supplied target
* object with the supplied arguments.
* @param method the method to invoke
* @param target the target object to invoke the method on
* @param args the invocation arguments (may be {@code null})
* @return the invocation result, if any
* @throws SQLException the JDBC API SQLException to rethrow (if any)
* @see #invokeMethod(java.lang.reflect.Method, Object, Object[])
* @deprecated as of 5.0.11, in favor of custom SQLException handling
*/
@Deprecated
@Nullable
public static Object invokeJdbcMethod(Method method, @Nullable Object target, @Nullable Object... args)
throws SQLException {
try {
return method.invoke(target, args);
}
catch (IllegalAccessException ex) {
handleReflectionException(ex);
}
catch (InvocationTargetException ex) {
if (ex.getTargetException() instanceof SQLException) {
throw (SQLException) ex.getTargetException();
}
handleInvocationTargetException(ex);
}
throw new IllegalStateException("Should never get here");
}
/** /**
* Handle the given reflection exception. Should only be called if no * Handle the given reflection exception. Should only be called if no
@ -375,161 +173,184 @@ public abstract class ReflectionUtils {
throw new UndeclaredThrowableException(ex); throw new UndeclaredThrowableException(ex);
} }
/**
* Determine whether the given method explicitly declares the given // Constructor handling
* exception or one of its superclasses, which means that an exception
* of that type can be propagated as-is within a reflective invocation.
* @param method the declaring method
* @param exceptionType the exception to throw
* @return {@code true} if the exception can be thrown as-is;
* {@code false} if it needs to be wrapped
*/
public static boolean declaresException(Method method, Class<?> exceptionType) {
Assert.notNull(method, "Method must not be null");
Class<?>[] declaredExceptions = method.getExceptionTypes();
for (Class<?> declaredException : declaredExceptions) {
if (declaredException.isAssignableFrom(exceptionType)) {
return true;
}
}
return false;
}
/** /**
* Determine whether the given field is a "public static final" constant. * Obtain an accessible constructor for the given class and parameters.
* @param field the field to check * @param clazz the clazz to check
* @param parameterTypes the parameter types of the desired constructor
* @return the constructor reference
* @throws NoSuchMethodException if no such constructor exists
* @since 5.0
*/ */
public static boolean isPublicStaticFinal(Field field) { public static <T> Constructor<T> accessibleConstructor(Class<T> clazz, Class<?>... parameterTypes)
int modifiers = field.getModifiers(); throws NoSuchMethodException {
return (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers));
Constructor<T> ctor = clazz.getDeclaredConstructor(parameterTypes);
makeAccessible(ctor);
return ctor;
} }
/** /**
* Determine whether the given method is an "equals" method. * Make the given constructor accessible, explicitly setting it accessible
* @see java.lang.Object#equals(Object) * if necessary. The {@code setAccessible(true)} method is only called
* when actually necessary, to avoid unnecessary conflicts with a JVM
* SecurityManager (if active).
* @param ctor the constructor to make accessible
* @see java.lang.reflect.Constructor#setAccessible
*/ */
public static boolean isEqualsMethod(@Nullable Method method) { @SuppressWarnings("deprecation") // on JDK 9
if (method == null || !method.getName().equals("equals")) { public static void makeAccessible(Constructor<?> ctor) {
return false; if ((!Modifier.isPublic(ctor.getModifiers()) ||
!Modifier.isPublic(ctor.getDeclaringClass().getModifiers())) && !ctor.isAccessible()) {
ctor.setAccessible(true);
} }
Class<?>[] paramTypes = method.getParameterTypes();
return (paramTypes.length == 1 && paramTypes[0] == Object.class);
} }
/**
* Determine whether the given method is a "hashCode" method. // Method handling
* @see java.lang.Object#hashCode()
*/
public static boolean isHashCodeMethod(@Nullable Method method) {
return (method != null && method.getName().equals("hashCode") && method.getParameterCount() == 0);
}
/** /**
* Determine whether the given method is a "toString" method. * Attempt to find a {@link Method} on the supplied class with the supplied name
* @see java.lang.Object#toString() * and no parameters. Searches all superclasses up to {@code Object}.
* <p>Returns {@code null} if no {@link Method} can be found.
* @param clazz the class to introspect
* @param name the name of the method
* @return the Method object, or {@code null} if none found
*/ */
public static boolean isToStringMethod(@Nullable Method method) { @Nullable
return (method != null && method.getName().equals("toString") && method.getParameterCount() == 0); public static Method findMethod(Class<?> clazz, String name) {
return findMethod(clazz, name, new Class<?>[0]);
} }
/** /**
* Determine whether the given method is originally declared by {@link java.lang.Object}. * Attempt to find a {@link Method} on the supplied class with the supplied name
* and parameter types. Searches all superclasses up to {@code Object}.
* <p>Returns {@code null} if no {@link Method} can be found.
* @param clazz the class to introspect
* @param name the name of the method
* @param paramTypes the parameter types of the method
* (may be {@code null} to indicate any signature)
* @return the Method object, or {@code null} if none found
*/ */
public static boolean isObjectMethod(@Nullable Method method) { @Nullable
if (method == null) { public static Method findMethod(Class<?> clazz, String name, @Nullable Class<?>... paramTypes) {
return false; Assert.notNull(clazz, "Class must not be null");
} Assert.notNull(name, "Method name must not be null");
try { Class<?> searchType = clazz;
Object.class.getDeclaredMethod(method.getName(), method.getParameterTypes()); while (searchType != null) {
return true; Method[] methods = (searchType.isInterface() ? searchType.getMethods() : getDeclaredMethods(searchType));
} for (Method method : methods) {
catch (Exception ex) { if (name.equals(method.getName()) &&
return false; (paramTypes == null || Arrays.equals(paramTypes, method.getParameterTypes()))) {
return method;
}
}
searchType = searchType.getSuperclass();
} }
return null;
} }
/** /**
* Determine whether the given method is a CGLIB 'renamed' method, * Invoke the specified {@link Method} against the supplied target object with no arguments.
* following the pattern "CGLIB$methodName$0". * The target object can be {@code null} when invoking a static {@link Method}.
* @param renamedMethod the method to check * <p>Thrown exceptions are handled via a call to {@link #handleReflectionException}.
* @see org.springframework.cglib.proxy.Enhancer#rename * @param method the method to invoke
* @param target the target object to invoke the method on
* @return the invocation result, if any
* @see #invokeMethod(java.lang.reflect.Method, Object, Object[])
*/ */
public static boolean isCglibRenamedMethod(Method renamedMethod) { @Nullable
String name = renamedMethod.getName(); public static Object invokeMethod(Method method, @Nullable Object target) {
if (name.startsWith(CGLIB_RENAMED_METHOD_PREFIX)) { return invokeMethod(method, target, new Object[0]);
int i = name.length() - 1;
while (i >= 0 && Character.isDigit(name.charAt(i))) {
i--;
}
return ((i > CGLIB_RENAMED_METHOD_PREFIX.length()) &&
(i < name.length() - 1) && name.charAt(i) == '$');
}
return false;
} }
/** /**
* Make the given field accessible, explicitly setting it accessible if * Invoke the specified {@link Method} against the supplied target object with the
* necessary. The {@code setAccessible(true)} method is only called * supplied arguments. The target object can be {@code null} when invoking a
* when actually necessary, to avoid unnecessary conflicts with a JVM * static {@link Method}.
* SecurityManager (if active). * <p>Thrown exceptions are handled via a call to {@link #handleReflectionException}.
* @param field the field to make accessible * @param method the method to invoke
* @see java.lang.reflect.Field#setAccessible * @param target the target object to invoke the method on
* @param args the invocation arguments (may be {@code null})
* @return the invocation result, if any
*/ */
@SuppressWarnings("deprecation") // on JDK 9 @Nullable
public static void makeAccessible(Field field) { public static Object invokeMethod(Method method, @Nullable Object target, @Nullable Object... args) {
if ((!Modifier.isPublic(field.getModifiers()) || try {
!Modifier.isPublic(field.getDeclaringClass().getModifiers()) || return method.invoke(target, args);
Modifier.isFinal(field.getModifiers())) && !field.isAccessible()) {
field.setAccessible(true);
} }
catch (Exception ex) {
handleReflectionException(ex);
}
throw new IllegalStateException("Should never get here");
} }
/** /**
* Make the given method accessible, explicitly setting it accessible if * Invoke the specified JDBC API {@link Method} against the supplied target
* necessary. The {@code setAccessible(true)} method is only called * object with no arguments.
* when actually necessary, to avoid unnecessary conflicts with a JVM * @param method the method to invoke
* SecurityManager (if active). * @param target the target object to invoke the method on
* @param method the method to make accessible * @return the invocation result, if any
* @see java.lang.reflect.Method#setAccessible * @throws SQLException the JDBC API SQLException to rethrow (if any)
* @see #invokeJdbcMethod(java.lang.reflect.Method, Object, Object[])
* @deprecated as of 5.0.11, in favor of custom SQLException handling
*/ */
@SuppressWarnings("deprecation") // on JDK 9 @Deprecated
public static void makeAccessible(Method method) { @Nullable
if ((!Modifier.isPublic(method.getModifiers()) || public static Object invokeJdbcMethod(Method method, @Nullable Object target) throws SQLException {
!Modifier.isPublic(method.getDeclaringClass().getModifiers())) && !method.isAccessible()) { return invokeJdbcMethod(method, target, new Object[0]);
method.setAccessible(true);
}
} }
/** /**
* Make the given constructor accessible, explicitly setting it accessible * Invoke the specified JDBC API {@link Method} against the supplied target
* if necessary. The {@code setAccessible(true)} method is only called * object with the supplied arguments.
* when actually necessary, to avoid unnecessary conflicts with a JVM * @param method the method to invoke
* SecurityManager (if active). * @param target the target object to invoke the method on
* @param ctor the constructor to make accessible * @param args the invocation arguments (may be {@code null})
* @see java.lang.reflect.Constructor#setAccessible * @return the invocation result, if any
* @throws SQLException the JDBC API SQLException to rethrow (if any)
* @see #invokeMethod(java.lang.reflect.Method, Object, Object[])
* @deprecated as of 5.0.11, in favor of custom SQLException handling
*/ */
@SuppressWarnings("deprecation") // on JDK 9 @Deprecated
public static void makeAccessible(Constructor<?> ctor) { @Nullable
if ((!Modifier.isPublic(ctor.getModifiers()) || public static Object invokeJdbcMethod(Method method, @Nullable Object target, @Nullable Object... args)
!Modifier.isPublic(ctor.getDeclaringClass().getModifiers())) && !ctor.isAccessible()) { throws SQLException {
ctor.setAccessible(true); try {
return method.invoke(target, args);
}
catch (IllegalAccessException ex) {
handleReflectionException(ex);
}
catch (InvocationTargetException ex) {
if (ex.getTargetException() instanceof SQLException) {
throw (SQLException) ex.getTargetException();
}
handleInvocationTargetException(ex);
} }
throw new IllegalStateException("Should never get here");
} }
/** /**
* Obtain an accessible constructor for the given class and parameters. * Determine whether the given method explicitly declares the given
* @param clazz the clazz to check * exception or one of its superclasses, which means that an exception
* @param parameterTypes the parameter types of the desired constructor * of that type can be propagated as-is within a reflective invocation.
* @return the constructor reference * @param method the declaring method
* @throws NoSuchMethodException if no such constructor exists * @param exceptionType the exception to throw
* @since 5.0 * @return {@code true} if the exception can be thrown as-is;
* {@code false} if it needs to be wrapped
*/ */
public static <T> Constructor<T> accessibleConstructor(Class<T> clazz, Class<?>... parameterTypes) public static boolean declaresException(Method method, Class<?> exceptionType) {
throws NoSuchMethodException { Assert.notNull(method, "Method must not be null");
Class<?>[] declaredExceptions = method.getExceptionTypes();
Constructor<T> ctor = clazz.getDeclaredConstructor(parameterTypes); for (Class<?> declaredException : declaredExceptions) {
makeAccessible(ctor); if (declaredException.isAssignableFrom(exceptionType)) {
return ctor; return true;
}
}
return false;
} }
/** /**
@ -611,7 +432,7 @@ public abstract class ReflectionUtils {
public static Method[] getAllDeclaredMethods(Class<?> leafClass) { public static Method[] getAllDeclaredMethods(Class<?> leafClass) {
final List<Method> methods = new ArrayList<>(32); final List<Method> methods = new ArrayList<>(32);
doWithMethods(leafClass, methods::add); doWithMethods(leafClass, methods::add);
return methods.toArray(new Method[0]); return methods.toArray(EMPTY_METHOD_ARRAY);
} }
/** /**
@ -647,7 +468,7 @@ public abstract class ReflectionUtils {
methods.add(method); methods.add(method);
} }
}); });
return methods.toArray(new Method[0]); return methods.toArray(EMPTY_METHOD_ARRAY);
} }
/** /**
@ -679,7 +500,7 @@ public abstract class ReflectionUtils {
else { else {
result = declaredMethods; result = declaredMethods;
} }
declaredMethodsCache.put(clazz, (result.length == 0 ? NO_METHODS : result)); declaredMethodsCache.put(clazz, (result.length == 0 ? EMPTY_METHOD_ARRAY : result));
} }
catch (Throwable ex) { catch (Throwable ex) {
throw new IllegalStateException("Failed to introspect Class [" + clazz.getName() + throw new IllegalStateException("Failed to introspect Class [" + clazz.getName() +
@ -705,6 +526,168 @@ public abstract class ReflectionUtils {
return result; return result;
} }
/**
* Determine whether the given method is an "equals" method.
* @see java.lang.Object#equals(Object)
*/
public static boolean isEqualsMethod(@Nullable Method method) {
if (method == null || !method.getName().equals("equals")) {
return false;
}
Class<?>[] paramTypes = method.getParameterTypes();
return (paramTypes.length == 1 && paramTypes[0] == Object.class);
}
/**
* Determine whether the given method is a "hashCode" method.
* @see java.lang.Object#hashCode()
*/
public static boolean isHashCodeMethod(@Nullable Method method) {
return (method != null && method.getName().equals("hashCode") && method.getParameterCount() == 0);
}
/**
* Determine whether the given method is a "toString" method.
* @see java.lang.Object#toString()
*/
public static boolean isToStringMethod(@Nullable Method method) {
return (method != null && method.getName().equals("toString") && method.getParameterCount() == 0);
}
/**
* Determine whether the given method is originally declared by {@link java.lang.Object}.
*/
public static boolean isObjectMethod(@Nullable Method method) {
if (method == null) {
return false;
}
try {
Object.class.getDeclaredMethod(method.getName(), method.getParameterTypes());
return true;
}
catch (Exception ex) {
return false;
}
}
/**
* Determine whether the given method is a CGLIB 'renamed' method,
* following the pattern "CGLIB$methodName$0".
* @param renamedMethod the method to check
*/
public static boolean isCglibRenamedMethod(Method renamedMethod) {
String name = renamedMethod.getName();
if (name.startsWith(CGLIB_RENAMED_METHOD_PREFIX)) {
int i = name.length() - 1;
while (i >= 0 && Character.isDigit(name.charAt(i))) {
i--;
}
return (i > CGLIB_RENAMED_METHOD_PREFIX.length() && (i < name.length() - 1) && name.charAt(i) == '$');
}
return false;
}
/**
* Make the given method accessible, explicitly setting it accessible if
* necessary. The {@code setAccessible(true)} method is only called
* when actually necessary, to avoid unnecessary conflicts with a JVM
* SecurityManager (if active).
* @param method the method to make accessible
* @see java.lang.reflect.Method#setAccessible
*/
@SuppressWarnings("deprecation") // on JDK 9
public static void makeAccessible(Method method) {
if ((!Modifier.isPublic(method.getModifiers()) ||
!Modifier.isPublic(method.getDeclaringClass().getModifiers())) && !method.isAccessible()) {
method.setAccessible(true);
}
}
// Field handling
/**
* Attempt to find a {@link Field field} on the supplied {@link Class} with the
* supplied {@code name}. Searches all superclasses up to {@link Object}.
* @param clazz the class to introspect
* @param name the name of the field
* @return the corresponding Field object, or {@code null} if not found
*/
@Nullable
public static Field findField(Class<?> clazz, String name) {
return findField(clazz, name, null);
}
/**
* Attempt to find a {@link Field field} on the supplied {@link Class} with the
* supplied {@code name} and/or {@link Class type}. Searches all superclasses
* up to {@link Object}.
* @param clazz the class to introspect
* @param name the name of the field (may be {@code null} if type is specified)
* @param type the type of the field (may be {@code null} if name is specified)
* @return the corresponding Field object, or {@code null} if not found
*/
@Nullable
public static Field findField(Class<?> clazz, @Nullable String name, @Nullable Class<?> type) {
Assert.notNull(clazz, "Class must not be null");
Assert.isTrue(name != null || type != null, "Either name or type of the field must be specified");
Class<?> searchType = clazz;
while (Object.class != searchType && searchType != null) {
Field[] fields = getDeclaredFields(searchType);
for (Field field : fields) {
if ((name == null || name.equals(field.getName())) &&
(type == null || type.equals(field.getType()))) {
return field;
}
}
searchType = searchType.getSuperclass();
}
return null;
}
/**
* Set the field represented by the supplied {@link Field field object} on the
* specified {@link Object target object} to the specified {@code value}.
* In accordance with {@link Field#set(Object, Object)} semantics, the new value
* is automatically unwrapped if the underlying field has a primitive type.
* <p>Thrown exceptions are handled via a call to {@link #handleReflectionException(Exception)}.
* @param field the field to set
* @param target the target object on which to set the field
* @param value the value to set (may be {@code null})
*/
public static void setField(Field field, @Nullable Object target, @Nullable Object value) {
try {
field.set(target, value);
}
catch (IllegalAccessException ex) {
handleReflectionException(ex);
throw new IllegalStateException(
"Unexpected reflection exception - " + ex.getClass().getName() + ": " + ex.getMessage());
}
}
/**
* Get the field represented by the supplied {@link Field field object} on the
* specified {@link Object target object}. In accordance with {@link Field#get(Object)}
* semantics, the returned value is automatically wrapped if the underlying field
* has a primitive type.
* <p>Thrown exceptions are handled via a call to {@link #handleReflectionException(Exception)}.
* @param field the field to get
* @param target the target object from which to get the field
* @return the field's current value
*/
@Nullable
public static Object getField(Field field, @Nullable Object target) {
try {
return field.get(target);
}
catch (IllegalAccessException ex) {
handleReflectionException(ex);
throw new IllegalStateException(
"Unexpected reflection exception - " + ex.getClass().getName() + ": " + ex.getMessage());
}
}
/** /**
* Invoke the given callback on all locally declared fields in the given class. * Invoke the given callback on all locally declared fields in the given class.
* @param clazz the target class to analyze * @param clazz the target class to analyze
@ -778,7 +761,7 @@ public abstract class ReflectionUtils {
if (result == null) { if (result == null) {
try { try {
result = clazz.getDeclaredFields(); result = clazz.getDeclaredFields();
declaredFieldsCache.put(clazz, (result.length == 0 ? NO_FIELDS : result)); declaredFieldsCache.put(clazz, (result.length == 0 ? EMPTY_FIELD_ARRAY : result));
} }
catch (Throwable ex) { catch (Throwable ex) {
throw new IllegalStateException("Failed to introspect Class [" + clazz.getName() + throw new IllegalStateException("Failed to introspect Class [" + clazz.getName() +
@ -808,6 +791,35 @@ public abstract class ReflectionUtils {
}, COPYABLE_FIELDS); }, COPYABLE_FIELDS);
} }
/**
* Determine whether the given field is a "public static final" constant.
* @param field the field to check
*/
public static boolean isPublicStaticFinal(Field field) {
int modifiers = field.getModifiers();
return (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers));
}
/**
* Make the given field accessible, explicitly setting it accessible if
* necessary. The {@code setAccessible(true)} method is only called
* when actually necessary, to avoid unnecessary conflicts with a JVM
* SecurityManager (if active).
* @param field the field to make accessible
* @see java.lang.reflect.Field#setAccessible
*/
@SuppressWarnings("deprecation") // on JDK 9
public static void makeAccessible(Field field) {
if ((!Modifier.isPublic(field.getModifiers()) ||
!Modifier.isPublic(field.getDeclaringClass().getModifiers()) ||
Modifier.isFinal(field.getModifiers())) && !field.isAccessible()) {
field.setAccessible(true);
}
}
// Cache handling
/** /**
* Clear the internal method/field cache. * Clear the internal method/field cache.
* @since 4.2.4 * @since 4.2.4

12
spring-tx/src/main/java/org/springframework/transaction/interceptor/CompositeTransactionAttributeSource.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2012 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -39,7 +39,7 @@ public class CompositeTransactionAttributeSource implements TransactionAttribute
* Create a new CompositeTransactionAttributeSource for the given sources. * Create a new CompositeTransactionAttributeSource for the given sources.
* @param transactionAttributeSources the TransactionAttributeSource instances to combine * @param transactionAttributeSources the TransactionAttributeSource instances to combine
*/ */
public CompositeTransactionAttributeSource(TransactionAttributeSource[] transactionAttributeSources) { public CompositeTransactionAttributeSource(TransactionAttributeSource... transactionAttributeSources) {
Assert.notNull(transactionAttributeSources, "TransactionAttributeSource array must not be null"); Assert.notNull(transactionAttributeSources, "TransactionAttributeSource array must not be null");
this.transactionAttributeSources = transactionAttributeSources; this.transactionAttributeSources = transactionAttributeSources;
} }
@ -56,10 +56,10 @@ public class CompositeTransactionAttributeSource implements TransactionAttribute
@Override @Override
@Nullable @Nullable
public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) { public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
for (TransactionAttributeSource tas : this.transactionAttributeSources) { for (TransactionAttributeSource source : this.transactionAttributeSources) {
TransactionAttribute ta = tas.getTransactionAttribute(method, targetClass); TransactionAttribute attr = source.getTransactionAttribute(method, targetClass);
if (ta != null) { if (attr != null) {
return ta; return attr;
} }
} }
return null; return null;

6
spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttributeSource.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2018 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -27,6 +27,7 @@ import org.springframework.lang.Nullable;
* metadata attributes at source level (such as Java 5 annotations), or anywhere else. * metadata attributes at source level (such as Java 5 annotations), or anywhere else.
* *
* @author Rod Johnson * @author Rod Johnson
* @author Juergen Hoeller
* @since 15.04.2003 * @since 15.04.2003
* @see TransactionInterceptor#setTransactionAttributeSource * @see TransactionInterceptor#setTransactionAttributeSource
* @see TransactionProxyFactoryBean#setTransactionAttributeSource * @see TransactionProxyFactoryBean#setTransactionAttributeSource
@ -40,8 +41,7 @@ public interface TransactionAttributeSource {
* @param method the method to introspect * @param method the method to introspect
* @param targetClass the target class (may be {@code null}, * @param targetClass the target class (may be {@code null},
* in which case the declaring class of the method must be used) * in which case the declaring class of the method must be used)
* @return the TransactionAttribute the matching transaction attribute, * @return the matching transaction attribute, or {@code null} if none found
* or {@code null} if none found
*/ */
@Nullable @Nullable
TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass); TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass);

8
spring-web/src/main/java/org/springframework/http/server/ServerHttpRequest.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2011 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -21,6 +21,7 @@ import java.security.Principal;
import org.springframework.http.HttpInputMessage; import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpRequest; import org.springframework.http.HttpRequest;
import org.springframework.lang.Nullable;
/** /**
* Represents a server-side HTTP request. * Represents a server-side HTTP request.
@ -33,9 +34,10 @@ public interface ServerHttpRequest extends HttpRequest, HttpInputMessage {
/** /**
* Return a {@link java.security.Principal} instance containing the name of the * Return a {@link java.security.Principal} instance containing the name of the
* authenticated user. If the user has not been authenticated, the method returns * authenticated user.
* <code>null</code>. * <p>If the user has not been authenticated, the method returns <code>null</code>.
*/ */
@Nullable
Principal getPrincipal(); Principal getPrincipal();
/** /**

Write Preview
Loading…
Cancel
Save