diff --git a/spring-aop/src/main/java/org/springframework/aop/framework/ObjenesisCglibAopProxy.java b/spring-aop/src/main/java/org/springframework/aop/framework/ObjenesisCglibAopProxy.java index c0f4e87178..02c1d4dfe8 100644 --- a/spring-aop/src/main/java/org/springframework/aop/framework/ObjenesisCglibAopProxy.java +++ b/spring-aop/src/main/java/org/springframework/aop/framework/ObjenesisCglibAopProxy.java @@ -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 diff --git a/spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/AbstractJCacheOperation.java b/spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/AbstractJCacheOperation.java index 03a34939d1..f853a02689 100644 --- a/spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/AbstractJCacheOperation.java +++ b/spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/AbstractJCacheOperation.java @@ -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 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 initializeAllParameterDetails(Method method) { + int parameterCount = method.getParameterCount(); + List 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 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[] includes, Class[] 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 implements JCacheOp } - private static List initializeAllParameterDetails(Method method) { - int parameterCount = method.getParameterCount(); - List 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. */ diff --git a/spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/JCacheOperation.java b/spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/JCacheOperation.java index 330d236a29..7a8a8475a9 100644 --- a/spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/JCacheOperation.java +++ b/spring-context-support/src/main/java/org/springframework/cache/jcache/interceptor/JCacheOperation.java @@ -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. - *

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. + * + *

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 diff --git a/spring-context/src/main/java/org/springframework/context/ResourceLoaderAware.java b/spring-context/src/main/java/org/springframework/context/ResourceLoaderAware.java index ce148b8aca..672a2b37a0 100644 --- a/spring-context/src/main/java/org/springframework/context/ResourceLoaderAware.java +++ b/spring-context/src/main/java/org/springframework/context/ResourceLoaderAware.java @@ -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 ResourceLoader (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. * - *

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. + *

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. * - *

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. + *

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. * - *

A passed-in ResourceLoader can also be checked for the - * ResourcePatternResolver 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. + *

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. * - *

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. + *

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 { diff --git a/spring-core/src/main/java/org/springframework/core/io/support/ResourcePatternUtils.java b/spring-core/src/main/java/org/springframework/core/io/support/ResourcePatternUtils.java index 4689fe754a..6bdc4c6cac 100644 --- a/spring-core/src/main/java/org/springframework/core/io/support/ResourcePatternUtils.java +++ b/spring-core/src/main/java/org/springframework/core/io/support/ResourcePatternUtils.java @@ -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. - *

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}. + *

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 diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/CompoundExpression.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/CompoundExpression.java index 2a8dc53008..9b75ffbc53 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/CompoundExpression.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/CompoundExpression.java @@ -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); } diff --git a/spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttribute.java b/spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttribute.java index 2b0ecdc6c2..77ae4f5bd4 100644 --- a/spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttribute.java +++ b/spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttribute.java @@ -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. *

This may be used for choosing a corresponding transaction manager * to process this specific transaction. + * @since 3.0 */ @Nullable String getQualifier(); diff --git a/spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttributeEditor.java b/spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttributeEditor.java index a7d2abdfed..ed284719e9 100644 --- a/spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttributeEditor.java +++ b/spring-tx/src/main/java/org/springframework/transaction/interceptor/TransactionAttributeEditor.java @@ -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); diff --git a/src/docs/asciidoc/core/core-beans.adoc b/src/docs/asciidoc/core/core-beans.adoc index cf2c520443..a0410c2630 100644 --- a/src/docs/asciidoc/core/core-beans.adoc +++ b/src/docs/asciidoc/core/core-beans.adoc @@ -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 <>. 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 <>) can provide a dependency of type +`ApplicationContext`. The "`traditional`" `constructor` and `byType` autowiring modes +(as described in <>) 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 -<>), 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 <>), +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. | <> | `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. diff --git a/src/docs/asciidoc/core/core-resources.adoc b/src/docs/asciidoc/core/core-resources.adoc index 97e1211f41..a3535d570c 100644 --- a/src/docs/asciidoc/core/core-resources.adoc +++ b/src/docs/asciidoc/core/core-resources.adoc @@ -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 <>) are now capable -of providing a dependency of type `ResourceLoader` for either a constructor argument or a +`byType` autowiring modes (as described in <>) 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 <>. +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 <>.