BATCH-891: Created JobExecutionListenerAdapter which supports @BeforeJob and @AfterJob annotation. Also added listners tag to XSD.

Author: lucasward

spring-batch-core/src/main/java/org/springframework/batch/core/annotation/BeforeJob.java

@@ -12,6 +12,7 @@
 import org.springframework.batch.core.JobExecution;
 import org.springframework.batch.core.JobExecutionListener;
 import org.springframework.batch.core.Step;
+import org.springframework.beans.factory.annotation.Qualifier;
 
 /**
  * Marks a method to be called before a {@link Job} is executed, which comes
@@ -24,6 +25,7 @@
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ElementType.METHOD})
+@Qualifier("JobExecutionListener")
 public @interface BeforeJob {
 
 }

spring-batch-core/src/main/java/org/springframework/batch/core/configuration/util/AnnotationMethodResolver.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2002-2008 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.batch.core.configuration.util;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import java.lang.reflect.Method;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.springframework.aop.support.AopUtils;
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
+import org.springframework.util.ReflectionUtils;
+
+/**
+ * MethodResolver implementation that finds a <em>single</em> Method on the
+ * given Class that contains the specified annotation type.
+ * 
+ * @author Mark Fisher
+ */
+public class AnnotationMethodResolver implements MethodResolver {
+
+	private Class<? extends Annotation> annotationType;
+
+
+	/**
+	 * Create a MethodResolver for the specified Method-level annotation type
+	 */
+	public AnnotationMethodResolver(Class<? extends Annotation> annotationType) {
+		Assert.notNull(annotationType, "annotationType must not be null");
+		Assert.isTrue(ObjectUtils.containsElement(
+				annotationType.getAnnotation(Target.class).value(), ElementType.METHOD),
+				"Annotation [" + annotationType + "] is not a Method-level annotation.");
+		this.annotationType = annotationType;
+	}
+
+
+	/**
+	 * Find a <em>single</em> Method on the Class of the given candidate object
+	 * that contains the annotation type for which this resolver is searching.
+	 * 
+	 * @param candidate the instance whose Class will be checked for the
+	 * annotation
+	 * 
+	 * @return a single matching Method instance or <code>null</code> if the
+	 * candidate's Class contains no Methods with the specified annotation
+	 * 
+	 * @throws IllegalArgumentException if more than one Method has the
+	 * specified annotation
+	 */
+	public Method findMethod(Object candidate) {
+		Assert.notNull(candidate, "candidate object must not be null");
+		Class<?> targetClass = AopUtils.getTargetClass(candidate);
+		if (targetClass == null) {
+			targetClass = candidate.getClass();
+		}
+		return this.findMethod(targetClass);
+	}
+
+	/**
+	 * Find a <em>single</em> Method on the given Class that contains the
+	 * annotation type for which this resolver is searching.
+	 * 
+	 * @param clazz the Class instance to check for the annotation
+	 * 
+	 * @return a single matching Method instance or <code>null</code> if the
+	 * Class contains no Methods with the specified annotation
+	 * 
+	 * @throws IllegalArgumentException if more than one Method has the
+	 * specified annotation
+	 */
+	public Method findMethod(final Class<?> clazz) {
+		Assert.notNull(clazz, "class must not be null");
+		final AtomicReference<Method> annotatedMethod = new AtomicReference<Method>();
+		ReflectionUtils.doWithMethods(clazz, new ReflectionUtils.MethodCallback() {
+			public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
+				Annotation annotation = AnnotationUtils.findAnnotation(method, annotationType);
+				if (annotation != null) {
+					Assert.isNull(annotatedMethod.get(), "found more than one method on target class ["
+							+ clazz + "] with the annotation type [" + annotationType + "]");
+					annotatedMethod.set(method);
+				}
+			}
+		});
+		return annotatedMethod.get();
+	}
+
+}

spring-batch-core/src/main/java/org/springframework/batch/core/configuration/util/MethodInvoker.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2002-2008 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.batch.core.configuration.util;
+
+/**
+ * A strategy interface for invoking a method.
+ * Typically used by adapters.
+ * 
+ * @author Mark Fisher
+ */
+public interface MethodInvoker {
+
+	Object invokeMethod(Object ... args);
+
+}

spring-batch-core/src/main/java/org/springframework/batch/core/configuration/util/MethodResolver.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2002-2008 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.batch.core.configuration.util;
+
+import java.lang.reflect.Method;
+
+/**
+ * Strategy interface for detecting a single Method on a Class.
+ * 
+ * @author Mark Fisher
+ */
+public interface MethodResolver {
+
+	/**
+	 * Find a single Method on the provided Object that matches this resolver's
+	 * criteria.
+	 * 
+	 * @param candidate the candidate Object whose Class should be searched for
+	 * a Method
+	 * 
+	 * @return a single Method or <code>null</code> if no Method matching this
+	 * resolver's criteria can be found.
+	 * 
+	 * @throws IllegalArgumentException if more than one Method defined on the
+	 * given candidate's Class matches this resolver's criteria
+	 */
+	Method findMethod(Object candidate) throws IllegalArgumentException;
+
+	/**
+	 * Find a <em>single</em> Method on the given Class that matches this
+	 * resolver's criteria.
+	 * 
+	 * @param clazz the Class instance on which to search for a Method
+	 * 
+	 * @return a single Method or <code>null</code> if no Method matching this
+	 * resolver's criteria can be found.
+	 * 
+	 * @throws IllegalArgumentException if more than one Method defined on the
+	 * given Class matches this resolver's criteria
+	 */
+	Method findMethod(Class<?> clazz);
+
+}

spring-batch-core/src/main/java/org/springframework/batch/core/configuration/util/SimpleMethodInvoker.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2002-2008 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright 2002-2008 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.batch.core.configuration.util;
+
+import java.lang.reflect.Method;
+
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+
+/**
+ * Simple implementation of the {@link MethodInvoker} interface that invokes a method on an
+ * object.  If the method has no arguments, but arguments are provided, they are ignored and the method
+ * is invoked anyway.  If there are more arguments than there are provided, then an exception is thrown.
+ * 
+ * @author Lucas Ward
+ * @since 2.0
+ */
+public class SimpleMethodInvoker implements MethodInvoker {
+
+	private final Object object;
+	private Method method;
+	
+	public SimpleMethodInvoker(Object object, Method method) {
+		Assert.notNull(object, "Object to invoke must not be null");
+		Assert.notNull(method, "Method to invoke must not be null");
+		this.object = object;
+		this.method = method;
+	}
+	
+	public SimpleMethodInvoker(Object object, String methodName, Class<?>... paramTypes){
+		Assert.notNull(object, "Object to invoke must not be null");
+		this.object = object;
+		this.method = ClassUtils.getMethodIfAvailable(object.getClass(), methodName, paramTypes);
+		if(this.method == null){
+			//try with no params
+			this.method = ClassUtils.getMethodIfAvailable(object.getClass(), methodName, new Class[]{});
+		}
+		if(this.method == null){
+			throw new IllegalArgumentException("No methods found for name: [" + methodName + "] in class: [" +
+					object.getClass() + "] with arguments of type: [" + paramTypes + "]");
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see org.springframework.batch.core.configuration.util.MethodInvoker#invokeMethod(java.lang.Object[])
+	 */
+	public Object invokeMethod(Object... args) {
+		
+		Class<?>[] parameterTypes = method.getParameterTypes();
+		Object[] invokeArgs = new Object[parameterTypes.length];
+		if(parameterTypes.length == 0){
+			invokeArgs = new Object[]{};
+		}
+		else if(parameterTypes.length > args.length){
+			throw new IllegalArgumentException("Wrong number of arguments, expected no more than: [" + parameterTypes.length + "]");
+		}
+		
+		method.setAccessible(true);
+		
+		try {
+			return method.invoke(object, invokeArgs);
+		} catch (Exception e) {
+			throw new IllegalArgumentException("Unable to invoke method: [" + method + "] on object: [" + 
+					object + "] with arguments: [" + args + "]");
+		} 
+	}
+}

spring-batch-core/src/main/java/org/springframework/batch/core/configuration/xml/JobExecutionListenerParser.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2002-2008 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.batch.core.configuration.xml;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.batch.core.JobExecutionListener;
+import org.springframework.batch.core.listener.JobExecutionListenerAdapter;
+import org.springframework.beans.factory.config.BeanReference;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.ManagedList;
+import org.springframework.beans.factory.xml.BeanDefinitionParser;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.util.StringUtils;
+import org.springframework.util.xml.DomUtils;
+import org.w3c.dom.Element;
+
+/**
+ * {@link BeanDefinitionParser} for {@link JobExecutionListener}s
+ * 
+ * @author Lucas Ward
+ *
+ */
+public class JobExecutionListenerParser {
+
+	
+	public ManagedList parse(Element element,
+			ParserContext parserContext) {
+		List<BeanReference> listeners = new ArrayList<BeanReference>();
+		
+		@SuppressWarnings("unchecked")
+		List<Element> listenerElements = (List<Element>) DomUtils.getChildElementsByTagName(element, "listener");
+		for(Element listenerElement : listenerElements){
+			BeanDefinitionBuilder listenerBuilder = BeanDefinitionBuilder.genericBeanDefinition(JobExecutionListenerAdapter.class);
+			String delegateName = listenerElement.getAttribute("ref");
+			listenerBuilder.addConstructorArgReference(delegateName);
+			
+			String beforeMethod = listenerElement.getAttribute("before-method");
+			if(StringUtils.hasText(beforeMethod)){
+				listenerBuilder.addPropertyValue("beforeMethod", beforeMethod);
+			}
+			
+			String afterMethod = listenerElement.getAttribute("after-method");
+			if(StringUtils.hasText(beforeMethod)){
+				listenerBuilder.addPropertyValue("afterMethod", afterMethod);
+			}
+			AbstractBeanDefinition beanDef = listenerBuilder.getBeanDefinition();
+			String id = listenerElement.getAttribute("id");
+			if (!StringUtils.hasText(id)) {
+				id = parserContext.getReaderContext().generateBeanName(beanDef);
+			}
+			parserContext.getRegistry().registerBeanDefinition(id, beanDef);
+	        BeanReference bean = new RuntimeBeanReference(id);
+			listeners.add(bean);
+		}
+		
+		ManagedList managedList = new ManagedList();
+		@SuppressWarnings( { "unchecked", "unused" })
+		boolean dummy = managedList.addAll(listeners);
+		
+		return managedList;
+	}
+
+}