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

Merge branch '5.1.x'

This commit is contained in:
Juergen Hoeller 2019-02-15 17:16:28 +01:00
parent 5e29ea30a3 e307dd58db
commit 6db75956b9
10 changed files with 127 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
spring-aop/src/main/java/org/springframework/aop/framework/ObjenesisCglibAopProxy.java
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");
* you may not use this file except in compliance with the License.
@ -29,7 +29,7 @@ import org.springframework.util.ReflectionUtils;
/**
* Objenesis-based extension of {@link CglibAopProxy} to create proxy instances
* without invoking the constructor of the class.
* without invoking the constructor of the class. Used by default as of Spring 4.
*
* @author Oliver Gierke
* @author Juergen Hoeller

41
spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/AbstractJCacheOperation.java vendored
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");
* you may not use this file except in compliance with the License.
@ -62,12 +62,15 @@ abstract class AbstractJCacheOperation<A extends Annotation> implements JCacheOp
this.allParameterDetails = initializeAllParameterDetails(methodDetails.getMethod());
}
/**
* Return the {@link ExceptionTypeFilter} to use to filter exceptions thrown while
* invoking the method.
*/
public abstract ExceptionTypeFilter getExceptionTypeFilter();
private static List<CacheParameterDetail> initializeAllParameterDetails(Method method) {
int parameterCount = method.getParameterCount();
List<CacheParameterDetail> result = new ArrayList<>(parameterCount);
for (int i = 0; i < parameterCount; i++) {
CacheParameterDetail detail = new CacheParameterDetail(method, i);
result.add(detail);
}
return result;
}
@Override
@ -113,12 +116,25 @@ abstract class AbstractJCacheOperation<A extends Annotation> implements JCacheOp
return result.toArray(new CacheInvocationParameter[0]);
}
/**
* Return the {@link ExceptionTypeFilter} to use to filter exceptions thrown while
* invoking the method.
* @see #createExceptionTypeFilter
*/
public abstract ExceptionTypeFilter getExceptionTypeFilter();
/**
* Convenience method for subclasses to create a specific {@code ExceptionTypeFilter}.
* @see #getExceptionTypeFilter()
*/
protected ExceptionTypeFilter createExceptionTypeFilter(
Class<? extends Throwable>[] includes, Class<? extends Throwable>[] excludes) {
return new ExceptionTypeFilter(Arrays.asList(includes), Arrays.asList(excludes), true);
}
@Override
public String toString() {
return getOperationDescription().append("]").toString();
@ -137,17 +153,6 @@ abstract class AbstractJCacheOperation<A extends Annotation> implements JCacheOp
}
private static List<CacheParameterDetail> initializeAllParameterDetails(Method method) {
int parameterCount = method.getParameterCount();
List<CacheParameterDetail> result = new ArrayList<>(parameterCount);
for (int i = 0; i < parameterCount; i++) {
CacheParameterDetail detail = new CacheParameterDetail(method, i);
result.add(detail);
}
return result;
}
/**
* Details for a single cache parameter.
*/

9
spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/JCacheOperation.java vendored
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");
* you may not use this file except in compliance with the License.
@ -24,9 +24,10 @@ import org.springframework.cache.interceptor.BasicOperation;
import org.springframework.cache.interceptor.CacheResolver;
/**
* Model the base of JSR-107 cache operation.
* <p>A cache operation can be statically cached as it does not contain
* any runtime operation of a specific cache invocation.
* Model the base of JSR-107 cache operation through an interface contract.
*
* <p>A cache operation can be statically cached as it does not contain any
* runtime operation of a specific cache invocation.
*
* @author Stephane Nicoll
* @since 4.1

56
spring-context/src/main/java/org/springframework/context/ResourceLoaderAware.java
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");
* you may not use this file except in compliance with the License.
@ -20,44 +20,44 @@ import org.springframework.beans.factory.Aware;
import org.springframework.core.io.ResourceLoader;
/**
* Interface to be implemented by any object that wishes to be notified of
* the <b>ResourceLoader</b> (typically the ApplicationContext) that it runs in.
* This is an alternative to a full ApplicationContext dependency via the
* ApplicationContextAware interface.
* Interface to be implemented by any object that wishes to be notified of the
* {@link ResourceLoader} (typically the ApplicationContext) that it runs in.
* This is an alternative to a full {@link ApplicationContext} dependency via
* the {@link org.springframework.context.ApplicationContextAware} interface.
*
* <p>Note that Resource dependencies can also be exposed as bean properties
* of type Resource, populated via Strings with automatic type conversion by
* the bean factory. This removes the need for implementing any callback
* interface just for the purpose of accessing a specific file resource.
* <p>Note that {@link org.springframework.core.io.Resource} dependencies can also
* be exposed as bean properties of type {@code Resource}, populated via Strings
* with automatic type conversion by the bean factory. This removes the need for
* implementing any callback interface just for the purpose of accessing a
* specific file resource.
*
* <p>You typically need a ResourceLoader when your application object has
* to access a variety of file resources whose names are calculated. A good
* strategy is to make the object use a DefaultResourceLoader but still
* implement ResourceLoaderAware to allow for overriding when running in an
* ApplicationContext. See ReloadableResourceBundleMessageSource for an example.
* <p>You typically need a {@link ResourceLoader} when your application object has to
* access a variety of file resources whose names are calculated. A good strategy is
* to make the object use a {@link org.springframework.core.io.DefaultResourceLoader}
* but still implement {@code ResourceLoaderAware} to allow for overriding when
* running in an {@code ApplicationContext}. See
* {@link org.springframework.context.support.ReloadableResourceBundleMessageSource}
* for an example.
*
* <p>A passed-in ResourceLoader can also be checked for the
* <b>ResourcePatternResolver</b> interface and cast accordingly, to be able
* to resolve resource patterns into arrays of Resource objects. This will always
* work when running in an ApplicationContext (the context interface extends
* ResourcePatternResolver). Use a PathMatchingResourcePatternResolver as default.
* See also the {@code ResourcePatternUtils.getResourcePatternResolver} method.
* <p>A passed-in {@code ResourceLoader} can also be checked for the
* {@link org.springframework.core.io.support.ResourcePatternResolver} interface
* and cast accordingly, in order to resolve resource patterns into arrays of
* {@code Resource} objects. This will always work when running in an ApplicationContext
* (since the context interface extends the ResourcePatternResolver interface). Use a
* {@link org.springframework.core.io.support.PathMatchingResourcePatternResolver} as
* default; see also the {@code ResourcePatternUtils.getResourcePatternResolver} method.
*
* <p>As alternative to a ResourcePatternResolver dependency, consider exposing
* bean properties of type Resource array, populated via pattern Strings with
* automatic type conversion by the bean factory.
* <p>As an alternative to a {@code ResourcePatternResolver} dependency, consider
* exposing bean properties of type {@code Resource} array, populated via pattern
* Strings with automatic type conversion by the bean factory at binding time.
*
* @author Juergen Hoeller
* @author Chris Beams
* @since 10.03.2004
* @see ApplicationContextAware
* @see org.springframework.beans.factory.InitializingBean
* @see org.springframework.core.io.Resource
* @see org.springframework.core.io.ResourceLoader
* @see org.springframework.core.io.support.ResourcePatternResolver
* @see org.springframework.core.io.support.ResourcePatternUtils#getResourcePatternResolver
* @see org.springframework.core.io.DefaultResourceLoader
* @see org.springframework.core.io.support.PathMatchingResourcePatternResolver
* @see org.springframework.context.support.ReloadableResourceBundleMessageSource
*/
public interface ResourceLoaderAware extends Aware {

10
spring-core/src/main/java/org/springframework/core/io/support/ResourcePatternUtils.java
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");
* you may not use this file except in compliance with the License.
@ -49,10 +49,10 @@ public abstract class ResourcePatternUtils {
}
/**
* Return a default ResourcePatternResolver for the given ResourceLoader.
* <p>This might be the ResourceLoader itself, if it implements the
* ResourcePatternResolver extension, or a PathMatchingResourcePatternResolver
* built on the given ResourceLoader.
* Return a default {@link ResourcePatternResolver} for the given {@link ResourceLoader}.
* <p>This might be the {@code ResourceLoader} itself, if it implements the
* {@code ResourcePatternResolver} extension, or a default
* {@link PathMatchingResourcePatternResolver} built on the given {@code ResourceLoader}.
* @param resourceLoader the ResourceLoader to build a pattern resolver for
* (may be {@code null} to indicate a default ResourceLoader)
* @return the ResourcePatternResolver

4
spring-expression/src/main/java/org/springframework/expression/spel/ast/CompoundExpression.java
View File

@ -125,8 +125,8 @@ public class CompoundExpression extends SpelNodeImpl {
@Override
public void generateCode(MethodVisitor mv, CodeFlow cf) {
for (int i = 0; i < this.children.length;i++) {
this.children[i].generateCode(mv, cf);
for (SpelNodeImpl child : this.children) {
child.generateCode(mv, cf);
}
cf.pushDescriptor(this.exitTypeDescriptor);
}

7
spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttribute.java
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");
* you may not use this file except in compliance with the License.
@ -21,8 +21,8 @@ import org.springframework.transaction.TransactionDefinition;
/**
* This interface adds a {@code rollbackOn} specification to {@link TransactionDefinition}.
* As custom {@code rollbackOn} is only possible with AOP, this class resides
* in the AOP transaction package.
* As custom {@code rollbackOn} is only possible with AOP, it resides in the AOP-related
* transaction subpackage.
*
* @author Rod Johnson
* @author Juergen Hoeller
@ -36,6 +36,7 @@ public interface TransactionAttribute extends TransactionDefinition {
* Return a qualifier value associated with this transaction attribute.
* <p>This may be used for choosing a corresponding transaction manager
* to process this specific transaction.
* @since 3.0
*/
@Nullable
String getQualifier();

35
spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttributeEditor.java
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");
* you may not use this file except in compliance with the License.
@ -45,7 +45,6 @@ public class TransactionAttributeEditor extends PropertyEditorSupport {
/**
* Format is PROPAGATION_NAME,ISOLATION_NAME,readOnly,timeout_NNNN,+Exception1,-Exception2.
* Null or the empty string means that the method is non transactional.
* @see java.beans.PropertyEditor#setAsText(java.lang.String)
*/
@Override
public void setAsText(String text) throws IllegalArgumentException {
@ -53,36 +52,36 @@ public class TransactionAttributeEditor extends PropertyEditorSupport {
// tokenize it with ","
String[] tokens = StringUtils.commaDelimitedListToStringArray(text);
RuleBasedTransactionAttribute attr = new RuleBasedTransactionAttribute();
for (int i = 0; i < tokens.length; i++) {
for (String token : tokens) {
// Trim leading and trailing whitespace.
String token = StringUtils.trimWhitespace(tokens[i].trim());
String trimmedToken = StringUtils.trimWhitespace(token.trim());
// Check whether token contains illegal whitespace within text.
if (StringUtils.containsWhitespace(token)) {
if (StringUtils.containsWhitespace(trimmedToken)) {
throw new IllegalArgumentException(
"Transaction attribute token contains illegal whitespace: [" + token + "]");
"Transaction attribute token contains illegal whitespace: [" + trimmedToken + "]");
}
// Check token type.
if (token.startsWith(RuleBasedTransactionAttribute.PREFIX_PROPAGATION)) {
attr.setPropagationBehaviorName(token);
if (trimmedToken.startsWith(RuleBasedTransactionAttribute.PREFIX_PROPAGATION)) {
attr.setPropagationBehaviorName(trimmedToken);
}
else if (token.startsWith(RuleBasedTransactionAttribute.PREFIX_ISOLATION)) {
attr.setIsolationLevelName(token);
else if (trimmedToken.startsWith(RuleBasedTransactionAttribute.PREFIX_ISOLATION)) {
attr.setIsolationLevelName(trimmedToken);
}
else if (token.startsWith(RuleBasedTransactionAttribute.PREFIX_TIMEOUT)) {
String value = token.substring(DefaultTransactionAttribute.PREFIX_TIMEOUT.length());
else if (trimmedToken.startsWith(RuleBasedTransactionAttribute.PREFIX_TIMEOUT)) {
String value = trimmedToken.substring(DefaultTransactionAttribute.PREFIX_TIMEOUT.length());
attr.setTimeout(Integer.parseInt(value));
}
else if (token.equals(RuleBasedTransactionAttribute.READ_ONLY_MARKER)) {
else if (trimmedToken.equals(RuleBasedTransactionAttribute.READ_ONLY_MARKER)) {
attr.setReadOnly(true);
}
else if (token.startsWith(RuleBasedTransactionAttribute.PREFIX_COMMIT_RULE)) {
attr.getRollbackRules().add(new NoRollbackRuleAttribute(token.substring(1)));
else if (trimmedToken.startsWith(RuleBasedTransactionAttribute.PREFIX_COMMIT_RULE)) {
attr.getRollbackRules().add(new NoRollbackRuleAttribute(trimmedToken.substring(1)));
}
else if (token.startsWith(RuleBasedTransactionAttribute.PREFIX_ROLLBACK_RULE)) {
attr.getRollbackRules().add(new RollbackRuleAttribute(token.substring(1)));
else if (trimmedToken.startsWith(RuleBasedTransactionAttribute.PREFIX_ROLLBACK_RULE)) {
attr.getRollbackRules().add(new RollbackRuleAttribute(trimmedToken.substring(1)));
}
else {
throw new IllegalArgumentException("Invalid transaction attribute token: [" + token + "]");
throw new IllegalArgumentException("Invalid transaction attribute token: [" + trimmedToken + "]");
}
}
setValue(attr);

46
src/docs/asciidoc/core/core-beans.adoc
View File

@ -3534,16 +3534,16 @@ Thus, beans can programmatically manipulate the `ApplicationContext` that create
through the `ApplicationContext` interface or by casting the reference to a known
subclass of this interface (such as `ConfigurableApplicationContext`, which exposes
additional functionality). One use would be the programmatic retrieval of other beans.
Sometimes this capability is useful. However, in general, you should avoid it, because it
couples the code to Spring and does not follow the Inversion of Control style, where
collaborators are provided to beans as properties. Other methods of the
`ApplicationContext` provide access to file resources, publishing application events, and
accessing a `MessageSource`. These additional features are described in
Sometimes this capability is useful. However, in general, you should avoid it, because
it couples the code to Spring and does not follow the Inversion of Control style,
where collaborators are provided to beans as properties. Other methods of the
`ApplicationContext` provide access to file resources, publishing application events,
and accessing a `MessageSource`. These additional features are described in
<<context-introduction>>.
As of Spring 2.5, autowiring is another alternative to obtain a reference to the
`ApplicationContext`. The "`traditional`" `constructor` and `byType` autowiring modes (as
described in <<beans-factory-autowire>>) can provide a dependency of type
`ApplicationContext`. The "`traditional`" `constructor` and `byType` autowiring modes
(as described in <<beans-factory-autowire>>) can provide a dependency of type
`ApplicationContext` for a constructor argument or a setter method parameter,
respectively. For more flexibility, including the ability to autowire fields and
multiple parameter methods, use the new annotation-based autowiring features. If you do,
@ -3575,11 +3575,10 @@ init-method.
[[aware-list]]
=== Other `Aware` Interfaces
Besides `ApplicationContextAware` and `BeanNameAware` (discussed
<<beans-factory-aware,earlier>>), Spring offers a range of `Aware` interfaces that let
beans indicate to the container that they require a certain infrastructure dependency. As
a general rule, the name is a good indication of the dependency type. The following table
summarizes the most important `Aware` interfaces:
Besides `ApplicationContextAware` and `BeanNameAware` (discussed <<beans-factory-aware,earlier>>),
Spring offers a wide range of `Aware` callback interfaces that let beans indicate to the container
that they require a certain infrastructure dependency. As a general rule, the name indicates the
dependency type. The following table summarizes the most important `Aware` interfaces:
[[beans-factory-nature-aware-list]]
.Aware interfaces
@ -3608,7 +3607,7 @@ summarizes the most important `Aware` interfaces:
| `BootstrapContextAware`
| Resource adapter `BootstrapContext` the container runs in. Typically available only in
JCA aware `ApplicationContext` instances.
JCA-aware `ApplicationContext` instances.
| <<integration.adoc#cci, JCA CCI>>
| `LoadTimeWeaverAware`
@ -8809,19 +8808,18 @@ specific and appropriate to the actual application context type.
You can configure a bean deployed into the application context to implement the special
callback interface, `ResourceLoaderAware`, to be automatically called back at
initialization time with the application context itself passed in as the
`ResourceLoader`. You can also expose properties of type `Resource`, to be used to
access static resources. They are injected into it like any other properties. You
can specify those `Resource` properties as simple `String` paths and rely on a special
JavaBean `PropertyEditor` (which is automatically registered by the context) to convert
those text strings to actual `Resource` objects when the bean is deployed.
initialization time with the application context itself passed in as the `ResourceLoader`.
You can also expose properties of type `Resource`, to be used to access static resources.
They are injected into it like any other properties. You can specify those `Resource`
properties as simple `String` paths and rely on automatic conversion from those text
strings to actual `Resource` objects when the bean is deployed.
The location path or paths supplied to an `ApplicationContext` constructor are actually
resource strings and, in simple form, are treated appropriately according to the specific context
implementation. For example `ClassPathXmlApplicationContext` treats a simple location path as a
classpath location. You can also use location paths (resource strings) with special
prefixes to force loading of definitions from the classpath or a URL, regardless of the
actual context type.
resource strings and, in simple form, are treated appropriately according to the specific
context implementation. For example `ClassPathXmlApplicationContext` treats a simple
location path as a classpath location. You can also use location paths (resource strings)
with special prefixes to force loading of definitions from the classpath or a URL,
regardless of the actual context type.

38
src/docs/asciidoc/core/core-resources.adoc
View File

@ -311,9 +311,9 @@ The following table summarizes the strategy for converting `String` objects to `
[[resources-resourceloaderaware]]
== The `ResourceLoaderAware` interface
The `ResourceLoaderAware` interface is a special marker interface that identifies objects
that expect to be provided with a `ResourceLoader` reference. The following listing shows
the definition of the `ResourceLoaderAware` interface:
The `ResourceLoaderAware` interface is a special callback interface which identifies
components that expect to be provided with a `ResourceLoader` reference. The following
listing shows the definition of the `ResourceLoaderAware` interface:
[source,java,indent=0]
[subs="verbatim,quotes"]
@ -324,29 +324,29 @@ the definition of the `ResourceLoaderAware` interface:
}
----
When a class implements `ResourceLoaderAware` and is deployed into an application
context (as a Spring-managed bean), it is recognized as `ResourceLoaderAware` by the
application context. The application context then invokes
`setResourceLoader(ResourceLoader)`, supplying itself as the argument (remember, all
application contexts in Spring implement the `ResourceLoader` interface).
When a class implements `ResourceLoaderAware` and is deployed into an application context
(as a Spring-managed bean), it is recognized as `ResourceLoaderAware` by the application
context. The application context then invokes `setResourceLoader(ResourceLoader)`,
supplying itself as the argument (remember, all application contexts in Spring implement
the `ResourceLoader` interface).
Since an `ApplicationContext` is a `ResourceLoader`, the bean could also
implement the `ApplicationContextAware` interface and use the supplied application
context directly to load resources. However, in general, it is better to use the specialized
`ResourceLoader` interface if that is all you need. The code would be coupled only
to the resource loading interface (which can be considered a utility interface) and not to
the whole Spring `ApplicationContext` interface.
Since an `ApplicationContext` is a `ResourceLoader`, the bean could also implement the
`ApplicationContextAware` interface and use the supplied application context directly to
load resources. However, in general, it is better to use the specialized `ResourceLoader`
interface if that is all you need. The code would be coupled only to the resource loading
interface (which can be considered a utility interface) and not to the whole Spring
`ApplicationContext` interface.
As of Spring 2.5, you can rely upon autowiring of the `ResourceLoader` as an alternative
to implementing the `ResourceLoaderAware` interface. The "`traditional`" `constructor` and
`byType` autowiring modes (as described in <<beans-factory-autowire>>) are now capable
of providing a dependency of type `ResourceLoader` for either a constructor argument or a
`byType` autowiring modes (as described in <<beans-factory-autowire>>) are now capable of
providing a dependency of type `ResourceLoader` for either a constructor argument or a
setter method parameter, respectively. For more flexibility (including the ability to
autowire fields and multiple parameter methods), consider using the annotation-based
autowiring features. In that case, the `ResourceLoader` is autowired into a field,
constructor argument, or method parameter that expects the `ResourceLoader` type as
long as the field, constructor, or method in question carries the `@Autowired`
annotation. For more information, see <<beans-autowired-annotation>>.
constructor argument, or method parameter that expects the `ResourceLoader` type as long
as the field, constructor, or method in question carries the `@Autowired` annotation.
For more information, see <<beans-autowired-annotation>>.