beancreatorutil.java

一个简单的java邮件系统源码

package com.easyjf.container.impl;

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Comparator;

import org.apache.log4j.Logger;

import com.easyjf.beans.BeanUtils;
import com.easyjf.container.BeanDefinition;
import com.easyjf.container.ConstructorArgumentValue;
import com.easyjf.container.ConstructorArguments;
import com.easyjf.util.StringUtils;

public class BeanCreatorUtil {
	private static final Logger logger =Logger.getLogger(BeanCreatorUtil.class);
	/**
	 * 判断一个Bean是否需要在容器加载的时候加载,不以&开头，lazy为flase，scope为singleton或application的Bean将会在容器初始化的时候加载
	 * @param definition
	 * @return
	 */
	public static boolean isCreateOnStart(BeanDefinition definition)
	{		
		return (definition.getBeanName().charAt(0)!='&' && ("singleton".equalsIgnoreCase(definition.getScope())||"application".equalsIgnoreCase(definition.getScope()))&&(!definition.isLazy()));			
	}
	public static Object initBean(BeanDefinition beanDefinition)
	{
		Object bean=null;
		logger.debug("初始化Singleton Bean:"+beanDefinition.getBeanName()+","+beanDefinition.getBeanClass());
		//简单的无参工厂调用
		if(StringUtils.hasText(beanDefinition.getFactoryMethod()))
		{
			//StringUtils.class.get
			try{
			java.lang.reflect.Method m=beanDefinition.getBeanClass().getDeclaredMethod(beanDefinition.getFactoryMethod(), new Class[]{});
			bean=m.invoke(beanDefinition.getBeanClass(),null);
			return bean;
			}
			catch(java.lang.NoSuchMethodException e)
			{
				logger.error("设置的工厂方法不存在："+e);
			}
			catch(Exception e)
			{
				logger.error("工厂方法加载Bean错误："+e);
			}
		}		
		ConstructorArguments crgs=beanDefinition.getConstructorArguments();			
		if(crgs.getArgCount()<1)
		{		
			bean=BeanUtils.instantiateClass(beanDefinition.getBeanClass());			
		}
		else
		{
			//使用构造子注入
			
		}
		return bean;
	}
	public static Constructor resolverConstructor(Class type,
			ConstructorArguments args) {
		Constructor[] all = type.getDeclaredConstructors();
		Constructor constructorToUser = null;
		ConstructorArgumentValue[] values = new ConstructorArgumentValue[args
				.getArgCount()];
		args.getArguments().values().toArray(values);
		sortConstructors(all);	
		int argsLength = values.length;
		//System.out.println(argsLength);
		if (values[values.length - 1].getIndex() != null
				&& values[values.length - 1].getIndex().intValue() > argsLength)
			argsLength = values[values.length - 1].getIndex().intValue();
		for (int i = 0; i < all.length; i++) {
			Constructor c = all[i];
			if (c.getParameterTypes().length == argsLength
					&& argumentsTypeDiffWith(c.getParameterTypes(),
							getArgumentsValueType(argsLength, values))) {
				constructorToUser = c;
				break;
			}
		}
		return constructorToUser;
	}

	public static Class[] getArgumentsValueType(int max,
			ConstructorArgumentValue[] cvs) {
		Class[] c = new Class[max];
		for (int i = 0; i < c.length; i++) {
			Class vtype = null;
			for (int j =0; j < cvs.length; j++) {
				if (cvs[j].getIndex().intValue() == i)
					vtype = cvs[j].getType();
			}
			c[i] = vtype;
		}
		return c;
	}

	public static boolean argumentsTypeDiffWith(Class[] args, Class[] vs) {
		boolean ret = true;
		//System.out.println(args.length);
		for (int j = 0; j < args.length; j++) {
			//System.out.println(args[j]+"-"+vs[j]);
			if (!args[j].isAssignableFrom(vs[j])) {
				ret = false;
				break;
			}
		}
		return ret;
	}

	public static void sortArgumentsValue(ConstructorArgumentValue[] args) {
		Arrays.sort(args, new Comparator() {
			public int compare(Object o1, Object o2) {
				ConstructorArgumentValue cv1 = (ConstructorArgumentValue) o1;
				ConstructorArgumentValue cv2 = (ConstructorArgumentValue) o2;
				if (cv1.getIndex() != null && cv2.getIndex() != null)
					return cv1.getIndex().intValue()
							- cv2.getIndex().intValue();
				if (cv1.getIndex() == null)
					return -1;
				else if (cv2.getIndex() == null)
					return 1;
				else
					return 0;
			}
		});
	}

	/**
	 * Sort the given constructors, preferring public constructors and "greedy"
	 * ones with a maximum of arguments. The result will contain public
	 * constructors first, with decreasing number of arguments, then non-public
	 * constructors, again with decreasing number of arguments.
	 * 
	 * @param constructors
	 *            the constructor array to sort
	 */
	public static void sortConstructors(Constructor[] constructors) {
		Arrays.sort(constructors, new Comparator() {
			public int compare(Object o1, Object o2) {
				Constructor c1 = (Constructor) o1;
				Constructor c2 = (Constructor) o2;
				boolean p1 = Modifier.isPublic(c1.getModifiers());
				boolean p2 = Modifier.isPublic(c2.getModifiers());
				if (p1 != p2) {
					return (p1 ? -1 : 1);
				}
				int c1pl = c1.getParameterTypes().length;
				int c2pl = c2.getParameterTypes().length;
				return (new Integer(c1pl)).compareTo(new Integer(c2pl)) * -1;
			}
		});
	}
}