Java tutorial
/* * Copyright 2002-2013 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.listener; import static org.springframework.batch.support.MethodInvokerUtils.getMethodInvokerByAnnotation; import static org.springframework.batch.support.MethodInvokerUtils.getMethodInvokerForInterface; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.aop.TargetSource; import org.springframework.aop.framework.Advised; import org.springframework.aop.framework.ProxyFactory; import org.springframework.aop.support.DefaultPointcutAdvisor; import org.springframework.batch.support.MethodInvoker; import org.springframework.batch.support.MethodInvokerUtils; import org.springframework.beans.factory.FactoryBean; import org.springframework.beans.factory.InitializingBean; import org.springframework.core.Ordered; import org.springframework.util.Assert; /** * {@link FactoryBean} implementation that builds a listener based on the * various lifecycle methods or annotations that are provided. There are three * possible ways of having a method called as part of a listener lifecycle: * * <ul> * <li>Interface implementation: By implementing any of the subclasses of a * listener interface, methods on said interface will be called * <li>Annotations: Annotating a method will result in registration. * <li>String name of the method to be called, which is tied to a * {@link ListenerMetaData} value in the metaDataMap. * </ul> * * It should be noted that methods obtained by name or annotation that don't * match the listener method signatures to which they belong will cause errors. * However, it is acceptable to have no parameters at all. If the same method is * marked in more than one way. (i.e. the method name is given and it is * annotated) the method will only be called once. However, if the same class * has multiple methods tied to a particular listener, each method will be * called. Also note that the same annotations cannot be applied to two separate * methods in a single class. * * @author Lucas Ward * @author Dan Garrette * @since 2.0 * @see ListenerMetaData */ public abstract class AbstractListenerFactoryBean<T> implements FactoryBean<Object>, InitializingBean { private static final Log logger = LogFactory.getLog(AbstractListenerFactoryBean.class); private Object delegate; private Map<String, String> metaDataMap; @Override public Object getObject() { if (metaDataMap == null) { metaDataMap = new HashMap<String, String>(); } // Because all annotations and interfaces should be checked for, make // sure that each meta data // entry is represented. for (ListenerMetaData metaData : this.getMetaDataValues()) { if (!metaDataMap.containsKey(metaData.getPropertyName())) { // put null so that the annotation and interface is checked metaDataMap.put(metaData.getPropertyName(), null); } } Set<Class<?>> listenerInterfaces = new HashSet<Class<?>>(); // For every entry in the map, try and find a method by interface, name, // or annotation. If the same Map<String, Set<MethodInvoker>> invokerMap = new HashMap<String, Set<MethodInvoker>>(); boolean synthetic = false; for (Entry<String, String> entry : metaDataMap.entrySet()) { final ListenerMetaData metaData = this.getMetaDataFromPropertyName(entry.getKey()); Set<MethodInvoker> invokers = new HashSet<MethodInvoker>(); MethodInvoker invoker; invoker = getMethodInvokerForInterface(metaData.getListenerInterface(), metaData.getMethodName(), delegate, metaData.getParamTypes()); if (invoker != null) { invokers.add(invoker); } invoker = getMethodInvokerByName(entry.getValue(), delegate, metaData.getParamTypes()); if (invoker != null) { invokers.add(invoker); synthetic = true; } if (metaData.getAnnotation() != null) { invoker = getMethodInvokerByAnnotation(metaData.getAnnotation(), delegate, metaData.getParamTypes()); if (invoker != null) { invokers.add(invoker); synthetic = true; } } if (!invokers.isEmpty()) { invokerMap.put(metaData.getMethodName(), invokers); listenerInterfaces.add(metaData.getListenerInterface()); } } if (listenerInterfaces.isEmpty()) { listenerInterfaces.add(this.getDefaultListenerClass()); } if (!synthetic) { int count = 0; for (Class<?> listenerInterface : listenerInterfaces) { if (listenerInterface.isInstance(delegate)) { count++; } } // All listeners can be supplied by the delegate itself if (count == listenerInterfaces.size()) { return delegate; } } boolean ordered = false; if (delegate instanceof Ordered) { ordered = true; listenerInterfaces.add(Ordered.class); } // create a proxy listener for only the interfaces that have methods to // be called ProxyFactory proxyFactory = new ProxyFactory(); if (delegate instanceof Advised) { proxyFactory.setTargetSource(((Advised) delegate).getTargetSource()); } else { proxyFactory.setTarget(delegate); } proxyFactory.setInterfaces(listenerInterfaces.toArray(new Class[0])); proxyFactory .addAdvisor(new DefaultPointcutAdvisor(new MethodInvokerMethodInterceptor(invokerMap, ordered))); return proxyFactory.getProxy(); } protected abstract ListenerMetaData getMetaDataFromPropertyName(String propertyName); protected abstract ListenerMetaData[] getMetaDataValues(); protected abstract Class<?> getDefaultListenerClass(); protected MethodInvoker getMethodInvokerByName(String methodName, Object candidate, Class<?>... params) { if (methodName != null) { return MethodInvokerUtils.getMethodInvokerByName(candidate, methodName, false, params); } else { return null; } } @Override public boolean isSingleton() { return true; } public void setDelegate(Object delegate) { this.delegate = delegate; } public void setMetaDataMap(Map<String, String> metaDataMap) { this.metaDataMap = metaDataMap; } @Override public void afterPropertiesSet() throws Exception { Assert.notNull(delegate, "Delegate must not be null"); } /** * Convenience method to check whether the given object is or can be made * into a listener. * * @param target the object to check * @return true if the delegate is an instance of any of the listener * interface, or contains the marker annotations */ public static boolean isListener(Object target, Class<?> listenerType, ListenerMetaData[] metaDataValues) { if (target == null) { return false; } if (listenerType.isInstance(target)) { return true; } if (target instanceof Advised) { TargetSource targetSource = ((Advised) target).getTargetSource(); if (targetSource != null && targetSource.getTargetClass() != null && listenerType.isAssignableFrom(targetSource.getTargetClass())) { return true; } if (targetSource != null && targetSource.getTargetClass() != null && targetSource.getTargetClass().isInterface()) { logger.warn(String.format( "%s is an interface. The implementing class will not be queried for annotation based listener configurations. If using @StepScope on a @Bean method, be sure to return the implementing class so listener annotations can be used.", targetSource.getTargetClass().getName())); } } for (ListenerMetaData metaData : metaDataValues) { if (MethodInvokerUtils.getMethodInvokerByAnnotation(metaData.getAnnotation(), target) != null) { return true; } } return false; } }