diff --git a/spring-context/src/main/java/org/springframework/context/weaving/AspectJWeavingEnabler.java b/spring-context/src/main/java/org/springframework/context/weaving/AspectJWeavingEnabler.java index ab78f5c35b3..e93e500baff 100644 --- a/spring-context/src/main/java/org/springframework/context/weaving/AspectJWeavingEnabler.java +++ b/spring-context/src/main/java/org/springframework/context/weaving/AspectJWeavingEnabler.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2013 the original author or authors. + * Copyright 2002-2016 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. @@ -16,7 +16,6 @@ package org.springframework.context.weaving; - import java.lang.instrument.ClassFileTransformer; import java.lang.instrument.IllegalClassFormatException; import java.security.ProtectionDomain; @@ -44,12 +43,13 @@ import org.springframework.instrument.classloading.LoadTimeWeaver; public class AspectJWeavingEnabler implements BeanFactoryPostProcessor, BeanClassLoaderAware, LoadTimeWeaverAware, Ordered { + public static final String ASPECTJ_AOP_XML_RESOURCE = "META-INF/aop.xml"; + + private ClassLoader beanClassLoader; private LoadTimeWeaver loadTimeWeaver; - public static final String ASPECTJ_AOP_XML_RESOURCE = "META-INF/aop.xml"; - @Override public void setBeanClassLoader(ClassLoader classLoader) { @@ -71,6 +71,12 @@ public class AspectJWeavingEnabler enableAspectJWeaving(this.loadTimeWeaver, this.beanClassLoader); } + + /** + * Enable AspectJ weaving with the given {@link LoadTimeWeaver}. + * @param weaverToUse the LoadTimeWeaver to apply to (or {@code null} for a default weaver) + * @param beanClassLoader the class loader to create a default weaver for (if necessary) + */ public static void enableAspectJWeaving(LoadTimeWeaver weaverToUse, ClassLoader beanClassLoader) { if (weaverToUse == null) { if (InstrumentationLoadTimeWeaver.isInstrumentationAvailable()) { @@ -80,8 +86,8 @@ public class AspectJWeavingEnabler throw new IllegalStateException("No LoadTimeWeaver available"); } } - weaverToUse.addTransformer(new AspectJClassBypassingClassFileTransformer( - new ClassPreProcessorAgentAdapter())); + weaverToUse.addTransformer( + new AspectJClassBypassingClassFileTransformer(new ClassPreProcessorAgentAdapter())); } @@ -108,4 +114,5 @@ public class AspectJWeavingEnabler return this.delegate.transform(loader, className, classBeingRedefined, protectionDomain, classfileBuffer); } } + } diff --git a/spring-core/src/main/java/org/springframework/core/MethodParameter.java b/spring-core/src/main/java/org/springframework/core/MethodParameter.java index 171575693a3..e34b8d00b90 100644 --- a/spring-core/src/main/java/org/springframework/core/MethodParameter.java +++ b/spring-core/src/main/java/org/springframework/core/MethodParameter.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2015 the original author or authors. + * Copyright 2002-2016 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,15 +29,13 @@ import java.util.Map; import org.springframework.util.Assert; /** - * Helper class that encapsulates the specification of a method parameter, i.e. - * a {@link Method} or {@link Constructor} plus a parameter index and a nested - * type index for a declared generic type. Useful as a specification object to - * pass along. + * Helper class that encapsulates the specification of a method parameter, i.e. a {@link Method} + * or {@link Constructor} plus a parameter index and a nested type index for a declared generic + * type. Useful as a specification object to pass along. * - *

As of 4.2, there is a {@link org.springframework.core.annotation.SynthesizingMethodParameter - * SynthesizingMethodParameter} subclass available which synthesizes annotations - * with attribute aliases. That subclass is used for web and message endpoint - * processing, in particular. + *

As of 4.2, there is a {@link org.springframework.core.annotation.SynthesizingMethodParameter} + * subclass available which synthesizes annotations with attribute aliases. That subclass is used + * for web and message endpoint processing, in particular. * * @author Juergen Hoeller * @author Rob Harrop @@ -167,7 +165,14 @@ public class MethodParameter { } /** - * Returns the wrapped member. + * Return the class that declares the underlying Method or Constructor. + */ + public Class getDeclaringClass() { + return getMember().getDeclaringClass(); + } + + /** + * Return the wrapped member. * @return the Method or Constructor as Member */ public Member getMember() { @@ -183,7 +188,9 @@ public class MethodParameter { } /** - * Returns the wrapped annotated element. + * Return the wrapped annotated element. + *

Note: This method exposes the annotations declared on the method/constructor + * itself (i.e. at the method/constructor level, not at the parameter level). * @return the Method or Constructor as AnnotatedElement */ public AnnotatedElement getAnnotatedElement() { @@ -198,13 +205,6 @@ public class MethodParameter { } } - /** - * Return the class that declares the underlying Method or Constructor. - */ - public Class getDeclaringClass() { - return getMember().getDeclaringClass(); - } - /** * Return the index of the method/constructor parameter. * @return the parameter index (-1 in case of the return type) @@ -338,8 +338,8 @@ public class MethodParameter { /** * Return the nested type of the method/constructor parameter. * @return the parameter type (never {@code null}) - * @see #getNestingLevel() * @since 3.1 + * @see #getNestingLevel() */ public Class getNestedParameterType() { if (this.nestingLevel > 1) { @@ -370,8 +370,8 @@ public class MethodParameter { /** * Return the nested generic type of the method/constructor parameter. * @return the parameter type (never {@code null}) - * @see #getNestingLevel() * @since 4.2 + * @see #getNestingLevel() */ public Type getNestedGenericParameterType() { if (this.nestingLevel > 1) { @@ -423,33 +423,37 @@ public class MethodParameter { return this.parameterAnnotations; } + /** + * Return {@code true} if the parameter has at least one annotation, + * {@code false} if it has none. + * @see #getParameterAnnotations() + */ + public boolean hasParameterAnnotations() { + return (getParameterAnnotations().length != 0); + } + /** * Return the parameter annotation of the given type, if available. * @param annotationType the annotation type to look for * @return the annotation object, or {@code null} if not found */ @SuppressWarnings("unchecked") - public T getParameterAnnotation(Class annotationType) { + public A getParameterAnnotation(Class annotationType) { Annotation[] anns = getParameterAnnotations(); for (Annotation ann : anns) { if (annotationType.isInstance(ann)) { - return (T) ann; + return (A) ann; } } return null; } /** - * Return true if the parameter has at least one annotation, false if it has none. - */ - public boolean hasParameterAnnotations() { - return (getParameterAnnotations().length != 0); - } - - /** - * Return true if the parameter has the given annotation type, and false if it doesn't. + * Return whether the parameter is declared with the given annotation type. + * @param annotationType the annotation type to look for + * @see #getParameterAnnotation(Class) */ - public boolean hasParameterAnnotation(Class annotationType) { + public boolean hasParameterAnnotation(Class annotationType) { return (getParameterAnnotation(annotationType) != null); } diff --git a/spring-core/src/main/java/org/springframework/core/convert/ConversionService.java b/spring-core/src/main/java/org/springframework/core/convert/ConversionService.java index 75f9a276c70..382e5ad3536 100644 --- a/spring-core/src/main/java/org/springframework/core/convert/ConversionService.java +++ b/spring-core/src/main/java/org/springframework/core/convert/ConversionService.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2013 the original author or authors. + * Copyright 2002-2016 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. @@ -64,11 +64,11 @@ public interface ConversionService { /** * Convert the given {@code source} to the specified {@code targetType}. - * @param source the source object to convert (may be null) + * @param source the source object to convert (may be {@code null}) * @param targetType the target type to convert to (required) * @return the converted object, an instance of targetType * @throws ConversionException if a conversion exception occurred - * @throws IllegalArgumentException if targetType is null + * @throws IllegalArgumentException if targetType is {@code null} */ T convert(Object source, Class targetType); @@ -76,7 +76,7 @@ public interface ConversionService { * Convert the given {@code source} to the specified {@code targetType}. * The TypeDescriptors provide additional context about the source and target locations * where conversion will occur, often object fields or property locations. - * @param source the source object to convert (may be null) + * @param source the source object to convert (may be {@code null}) * @param sourceType context about the source type to convert from * (may be {@code null} if source is {@code null}) * @param targetType context about the target type to convert to (required) diff --git a/spring-orm-hibernate5/src/main/java/org/springframework/orm/hibernate5/HibernateTransactionManager.java b/spring-orm-hibernate5/src/main/java/org/springframework/orm/hibernate5/HibernateTransactionManager.java index 4067c176e17..53f6b01a0ee 100644 --- a/spring-orm-hibernate5/src/main/java/org/springframework/orm/hibernate5/HibernateTransactionManager.java +++ b/spring-orm-hibernate5/src/main/java/org/springframework/orm/hibernate5/HibernateTransactionManager.java @@ -69,9 +69,9 @@ import org.springframework.transaction.support.TransactionSynchronizationManager * and services which use plain JDBC (without being aware of Hibernate)! * Application code needs to stick to the same simple Connection lookup pattern as * with {@link org.springframework.jdbc.datasource.DataSourceTransactionManager} - * (i.e. {@link DataSourceUtils#getConnection} + * (i.e. {@link org.springframework.jdbc.datasource.DataSourceUtils#getConnection} * or going through a - * {@link TransactionAwareDataSourceProxy}). + * {@link org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy}). * *

Note: To be able to register a DataSource's Connection for plain JDBC code, * this instance needs to be aware of the DataSource ({@link #setDataSource}). @@ -235,7 +235,6 @@ public class HibernateTransactionManager extends AbstractPlatformTransactionMana *

Default is "false". Turning this flag on enforces over-commit holdability on the * underlying JDBC Connection (if {@link #prepareConnection "prepareConnection"} is on) * and skips the disconnect-on-completion step. - * @since 4.2 * @see Connection#setHoldability * @see ResultSet#HOLD_CURSORS_OVER_COMMIT * @see #disconnectOnCompletion(Session) @@ -687,7 +686,6 @@ public class HibernateTransactionManager extends AbstractPlatformTransactionMana *

The default implementation simply calls {@link Session#disconnect()}. * Subclasses may override this with a no-op or with fine-tuned disconnection logic. * @param session the Hibernate Session to disconnect - * @since 4.2 * @see Session#disconnect() */ protected void disconnectOnCompletion(Session session) { diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/HandlerInterceptor.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/HandlerInterceptor.java index 2aa28d5dfba..6f8e803674f 100644 --- a/spring-webmvc/src/main/java/org/springframework/web/servlet/HandlerInterceptor.java +++ b/spring-webmvc/src/main/java/org/springframework/web/servlet/HandlerInterceptor.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2015 the original author or authors. + * Copyright 2002-2016 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. @@ -33,8 +33,8 @@ import org.springframework.web.method.HandlerMethod; * or common handler behavior like locale or theme changes. Its main purpose * is to allow for factoring out repetitive handler code. * - *

In an async processing scenario, the handler may be executed in a separate - * thread while the main thread exits without rendering or invoking the + *

In an asynchronous processing scenario, the handler may be executed in a + * separate thread while the main thread exits without rendering or invoking the * {@code postHandle} and {@code afterCompletion} callbacks. When concurrent * handler execution completes, the request is dispatched back in order to * proceed with rendering the model and all methods of this contract are invoked @@ -77,16 +77,13 @@ public interface HandlerInterceptor { /** * Intercept the execution of a handler. Called after HandlerMapping determined * an appropriate handler object, but before HandlerAdapter invokes the handler. - * *

DispatcherServlet processes a handler in an execution chain, consisting * of any number of interceptors, with the handler itself at the end. * With this method, each interceptor can decide to abort the execution chain, * typically sending a HTTP error or writing a custom response. - * *

Note: special considerations apply for asynchronous * request processing. For more details see * {@link org.springframework.web.servlet.AsyncHandlerInterceptor}. - * * @param request current HTTP request * @param response current HTTP response * @param handler chosen handler to execute, for type and/or instance evaluation @@ -102,19 +99,16 @@ public interface HandlerInterceptor { * Intercept the execution of a handler. Called after HandlerAdapter actually * invoked the handler, but before the DispatcherServlet renders the view. * Can expose additional model objects to the view via the given ModelAndView. - * *

DispatcherServlet processes a handler in an execution chain, consisting * of any number of interceptors, with the handler itself at the end. * With this method, each interceptor can post-process an execution, * getting applied in inverse order of the execution chain. - * *

Note: special considerations apply for asynchronous * request processing. For more details see * {@link org.springframework.web.servlet.AsyncHandlerInterceptor}. - * * @param request current HTTP request * @param response current HTTP response - * @param handler handler (or {@link HandlerMethod}) that started async + * @param handler handler (or {@link HandlerMethod}) that started asynchronous * execution, for type and/or instance examination * @param modelAndView the {@code ModelAndView} that the handler returned * (can also be {@code null}) @@ -127,21 +121,17 @@ public interface HandlerInterceptor { * Callback after completion of request processing, that is, after rendering * the view. Will be called on any outcome of handler execution, thus allows * for proper resource cleanup. - * *

Note: Will only be called if this interceptor's {@code preHandle} * method has successfully completed and returned {@code true}! - * *

As with the {@code postHandle} method, the method will be invoked on each * interceptor in the chain in reverse order, so the first interceptor will be * the last to be invoked. - * *

Note: special considerations apply for asynchronous * request processing. For more details see * {@link org.springframework.web.servlet.AsyncHandlerInterceptor}. - * * @param request current HTTP request * @param response current HTTP response - * @param handler handler (or {@link HandlerMethod}) that started async + * @param handler handler (or {@link HandlerMethod}) that started asynchronous * execution, for type and/or instance examination * @param ex exception thrown on handler execution, if any * @throws Exception in case of errors diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/handler/AbstractHandlerMethodExceptionResolver.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/handler/AbstractHandlerMethodExceptionResolver.java index 5a4c7d92480..7f9bc066651 100644 --- a/spring-webmvc/src/main/java/org/springframework/web/servlet/handler/AbstractHandlerMethodExceptionResolver.java +++ b/spring-webmvc/src/main/java/org/springframework/web/servlet/handler/AbstractHandlerMethodExceptionResolver.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2012 the original author or authors. + * Copyright 2002-2016 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. @@ -34,7 +34,7 @@ public abstract class AbstractHandlerMethodExceptionResolver extends AbstractHan /** * Checks if the handler is a {@link HandlerMethod} and then delegates to the - * base class implementation of {@link #shouldApplyTo(HttpServletRequest, Object)} + * base class implementation of {@code #shouldApplyTo(HttpServletRequest, Object)} * passing the bean of the {@code HandlerMethod}. Otherwise returns {@code false}. */ @Override @@ -54,8 +54,7 @@ public abstract class AbstractHandlerMethodExceptionResolver extends AbstractHan @Override protected final ModelAndView doResolveException( - HttpServletRequest request, HttpServletResponse response, - Object handler, Exception ex) { + HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) { return doResolveHandlerMethodException(request, response, (HandlerMethod) handler, ex); } @@ -75,7 +74,6 @@ public abstract class AbstractHandlerMethodExceptionResolver extends AbstractHan * @return a corresponding ModelAndView to forward to, or {@code null} for default processing */ protected abstract ModelAndView doResolveHandlerMethodException( - HttpServletRequest request, HttpServletResponse response, - HandlerMethod handlerMethod, Exception ex); + HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod, Exception ex); } diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/ExceptionHandlerExceptionResolver.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/ExceptionHandlerExceptionResolver.java index c897a4196ab..572f0b7c620 100644 --- a/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/ExceptionHandlerExceptionResolver.java +++ b/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/ExceptionHandlerExceptionResolver.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2015 the original author or authors. + * Copyright 2002-2016 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. @@ -95,7 +95,7 @@ public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExce public ExceptionHandlerExceptionResolver() { StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter(); - stringHttpMessageConverter.setWriteAcceptCharset(false); // See SPR-7316 + stringHttpMessageConverter.setWriteAcceptCharset(false); // see SPR-7316 this.messageConverters = new ArrayList>(); this.messageConverters.add(new ByteArrayHttpMessageConverter()); @@ -264,11 +264,15 @@ public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExce ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(adviceBean.getBeanType()); if (resolver.hasExceptionMappings()) { this.exceptionHandlerAdviceCache.put(adviceBean, resolver); - logger.info("Detected @ExceptionHandler methods in " + adviceBean); + if (logger.isInfoEnabled()) { + logger.info("Detected @ExceptionHandler methods in " + adviceBean); + } } if (ResponseBodyAdvice.class.isAssignableFrom(adviceBean.getBeanType())) { this.responseBodyAdvice.add(adviceBean); - logger.info("Detected ResponseBodyAdvice implementation in " + adviceBean); + if (logger.isInfoEnabled()) { + logger.info("Detected ResponseBodyAdvice implementation in " + adviceBean); + } } } }