org.milyn.javabean.factory.BasicFactoryDefinitionParser Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of milyn-smooks-javabean Show documentation
There is a newer version: 1.7.1
Show newest version
/*
 * Milyn - Copyright (C) 2006 - 2010
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License (version 2.1) as published by the Free Software
 *  Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 *  See the GNU Lesser General Public License for more details:
 *  http://www.gnu.org/licenses/lgpl.txt
 */
package org.milyn.javabean.factory;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.milyn.container.ExecutionContext;
import org.milyn.util.ClassUtil;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * The BasicFactoryDefinitionParser supports two kinds of
 * factory definitions:
 * 
 * 	some.package.SomeFactory#createObject

 * 		 	This defines that the 'createObject' of the class 'some.package.SomeFactory'
 * 			should be called for creating the target object.
 *  
some.package.SomeFactorySingleton#getFactoryMethod.createObject

 *  	 	This defines that the 'getFactoryMethod' of the class 'some.package.SomeFactorySingleton'
 * 			should be called to retrieve the factory object on which the 'createObject' should
 * 			be called for creating the target object.

 * 			The factory retrieval method should never return null. This
 * 			will result in a {@link NullPointerException}.
 * 
 *
 *
 *
 * @author [email protected]
 *
 */
@Alias("basic")
public class BasicFactoryDefinitionParser extends
		AbstractCachingFactoryDefinitionParser {


	/**
	 * Parses the factory definition and creates a {@link StaticMethodFactory}
	 * or {@link FactoryInstanceFactory#} accordingly.
	 */
	@Override
	protected Factory createFactory(String factoryDefinition) {

		String[] defParts = StringUtils.split(factoryDefinition, '#');
		if (defParts.length == 2) {
			String className = defParts[0];
			String methodDef = defParts[1];
			try {
				String[] methodParts = StringUtils.split(methodDef, '.');

				if (methodParts.length == 1) {

					return createStaticMethodFactory(factoryDefinition, className, methodDef);

				} else if (methodParts.length == 2) {

					String staticGetInstanceMethodDef = methodParts[0];
					String factoryMethodDef = methodParts[1];

					return createFactoryInstanceFactory(factoryDefinition, className, staticGetInstanceMethodDef, factoryMethodDef);

				} else {
					throw createInvalidDefinitionException(factoryDefinition);
				}
			} catch (InvalidFactoryDefinitionException e) {
				throw e;
			} catch (Exception e) {
				throw new FactoryException("The factory could not be created from the definition '"+ factoryDefinition +"'.", e);
			}

		} else {
			throw createInvalidDefinitionException(factoryDefinition);
		}
	}

	/**
	 * Creates a StaticMethodFactory object.
	 *
	 * @param factoryDefinition
	 * @param className
	 * @param methodDef
	 * @return
	 * @throws ClassNotFoundException
	 * @throws SecurityException
	 * @throws NoSuchMethodException
	 */
	private Factory createStaticMethodFactory(String factoryDefinition, String className, String methodDef) throws ClassNotFoundException, SecurityException, NoSuchMethodException {
		Class factoryClass = ClassUtil.forName(className, this.getClass());
		Method factoryMethod = factoryClass.getMethod(methodDef);

		if(!Modifier.isStatic(factoryMethod.getModifiers())) {
			throw new NoSuchMethodException("No static method with the name '"+ methodDef +"' can be found on the class '" + className + "' while processing the factory definition '"+ factoryDefinition +"'.");
		}

		return new StaticMethodFactory(factoryDefinition, factoryMethod);
	}

	/**
	 * Creates a FactoryInstanceFactory object.
	 *
	 * @param factoryDefinition
	 * @param className
	 * @param staticGetInstanceMethodDef
	 * @param factoryMethodDef
	 * @return
	 * @throws ClassNotFoundException
	 * @throws SecurityException
	 * @throws NoSuchMethodException
	 */
	private Factory createFactoryInstanceFactory(String factoryDefinition, String className, String staticGetInstanceMethodDef, String factoryMethodDef) throws ClassNotFoundException, SecurityException, NoSuchMethodException{
		Class factoryClass = ClassUtil.forName(className, this.getClass());
		Method getInstanceMethod = factoryClass.getMethod(staticGetInstanceMethodDef);
		Class factoryType = getInstanceMethod.getReturnType();
		Method factoryMethod = factoryType.getMethod(factoryMethodDef);

		if(!Modifier.isStatic(getInstanceMethod.getModifiers())) {
			throw new NoSuchMethodException("No static method with the name '"+ staticGetInstanceMethodDef +"' can be found on the class '" + className + "'.");
		}

		return new FactoryInstanceFactory(factoryDefinition, getInstanceMethod, factoryMethod);
	}


	private InvalidFactoryDefinitionException createInvalidDefinitionException(String factoryDefinition) {
		return new InvalidFactoryDefinitionException("The factory definition '" + factoryDefinition +"' " +
						"isn't valid. The definition is 'some.package.SomeFactory#createObject' or " +
						"'some.package.SomeFactorySingleton#getFactoryMethod.createObject'");
	}

	private static String toClassDefinition(Method method) {
		return method.getDeclaringClass().getName() + "#" + method.getName() + "()";
	}

	/**
	 * The StaticMethodFactory uses a static factory method create the target objects.
	 */
	private static class StaticMethodFactory implements Factory