package org.frameworkset.spi.assemble;

import java.beans.IntrospectionException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.log4j.Logger;
import org.frameworkset.spi.ApplicationContextAware;
import org.frameworkset.spi.BaseApplicationContext;
import org.frameworkset.spi.BeanClassLoaderAware;
import org.frameworkset.spi.BeanInfoAware;
import org.frameworkset.spi.BeanNameAware;
import org.frameworkset.spi.CallContext;
import org.frameworkset.spi.DisposableBean;
import org.frameworkset.spi.InitializingBean;
import org.frameworkset.spi.LocalCallContextImpl;
import org.frameworkset.spi.ResourceLoaderAware;
import org.frameworkset.spi.SPIException;
import org.frameworkset.spi.assemble.plugin.IocPlugin;
import org.frameworkset.spi.support.ApplicationObjectSupport;
import org.frameworkset.spi.support.MessageSourceAware;
import org.frameworkset.util.ClassUtil;
import org.frameworkset.util.ClassUtil.ClassInfo;
import org.frameworkset.util.ClassUtil.PropertieDescription;

import com.frameworkset.spi.assemble.BeanInstanceException;
import com.frameworkset.spi.assemble.CurrentlyInCreationException;
import com.frameworkset.util.BeanUtils;
import com.frameworkset.util.EditorInf;
import com.frameworkset.util.NoSupportTypeCastException;
import com.frameworkset.util.ValueObjectUtil;

/**
 * 
 * <p>
 * Title: BeanAccembleHelper.java
 * </p>
 * <p>
 * Description:
 * </p>
 * <p>
 * bboss workgroup
 * </p>
 * <p>
 * Copyright (c) 2007
 * </p>
 * 
 * @Date 2009-9-19 下午11:01:02
 * @author biaoping.yin
 * @version 1.0
 */
public class BeanAccembleHelper {
	private static Logger log = Logger.getLogger(BeanAccembleHelper.class);

	private Class<?>[] constructParamTypes = null;

	private Constructor constructor = null;
	
	public static class LoopObject
	{
		Object obj;
		public LoopObject()
		{
//			this.obj = obj;
		}
		public Object getObj() {
			return obj;
		}
		public void setObj(Object obj) {
			this.obj = obj;
		}
		
		
		
	}

	/**
	 * 获取属性的引用值
	 * 
	 * @param property
	 * @param context
	 * @param defaultValue
	 * @return
	 */
	public Object getRefValue(Pro property, CallContext callcontext,
			Object defaultValue) {
		if (callcontext != null )
		{
//			if(callcontext.isSOAApplication())
//			{
//				
//			}
//			else
			{
				Context context = callcontext.getLoopContext();
				
//				if (context != null && context.isLoopIOC(property.getRefid())) {
//					throw new CurrentlyInCreationException(
//							"loop inject constructor error. the inject context path is ["
//									+ context + ">" + property.getRefid()
//									+ "],请检查配置文件是否配置正确[" + property.getConfigFile()
//									+ "]");
//				}
				LoopObject lo = new LoopObject();
				boolean loopobject = context != null?context.isLoopIOC(property.getRefid(),lo):false;
				if (loopobject && lo.getObj() == null) {
					throw new CurrentlyInCreationException(
							"loop inject constructor error. the inject context path is ["
									+ context + ">" + property.getRefid()
									+ "],请检查配置文件是否配置正确[" + property.getConfigFile()
									+ "]");
				}
				if(lo.getObj() != null)
					return lo.getObj();
			}
		}
			
		
		if (!property.isServiceRef()) {//识别新的模式
			/**
			 * 需要对refid进行内部识别的处理
			 * test1->test2->test3
			 * 
			 */
			Object ret = null;
			if(property.getRefidLink() == null)
				ret = property.getApplicationContext().getBeanObject(
			                                        					callcontext, property.getRefid());
			else
				ret = property.getApplicationContext().getBeanObjectFromRefID(
    					callcontext, property.getRefidLink(),property.getRefid(),null);
			if (ret == null)
				return defaultValue;
			if (property.getClazz() != null && !property.getClazz().equals("")) {
				try {					
					ret = ValueObjectUtil.typeCast(ret, ret.getClass(),
							property.getType());
					return ret;
				} catch (NumberFormatException e) {
					throw new CurrentlyInCreationException(
							"providerManagerInfo[" + property.getName()
									+ "],请检查配置文件是否配置正确["
									+ property.getConfigFile() + "]", e);
				} catch (IllegalArgumentException e) {
					throw new CurrentlyInCreationException(
							"providerManagerInfo[" + property.getName()
									+ "],请检查配置文件是否配置正确["
									+ property.getConfigFile() + "]", e);
				} catch (NoSupportTypeCastException e) {
					throw new CurrentlyInCreationException(
							"providerManagerInfo[" + property.getName()
									+ "],请检查配置文件是否配置正确["
									+ property.getConfigFile() + "]", e);
				} catch (BeanInstanceException e) {
					throw e;
				} catch (Exception e) {
					throw new CurrentlyInCreationException(
							"providerManagerInfo[" + property.getName()
									+ "],请检查配置文件是否配置正确["
									+ property.getConfigFile() + "]", e);
				}
			} else {
				return ret;
			}
			
		} else {
			Object ret = property.getApplicationContext().getProvider(
			                                      					callcontext, property.getRefid(), property.getReftype());
  			if (ret == null)
  				return defaultValue;
  			return ret;
			                                      			
			
		}
	}
	
	/**
	 * 获取bean创建工厂对象
	 * 
	 * @param property
	 * @param context
	 * @param defaultValue
	 * @return
	 */
	public Object getFactoryRefValue(Pro property,String factoryname, CallContext callcontext,
			Object defaultValue) {
		Context context = null;
		if (callcontext != null)
			context = callcontext.getLoopContext();
//		Object loopobject = context != null?context.isLoopIOC(factoryname):null;
//		if (context != null && context.isLoopIOC(factoryname)) {
//			throw new CurrentlyInCreationException(
//					"loop inject constructor error. the inject context path is ["
//							+ context + ">" + property.getRefid()
//							+ "],请检查配置文件是否配置正确[" + property.getConfigFile()
//							+ "]");
//		}
		LoopObject lo = new LoopObject();
		boolean loopobject = context != null?context.isLoopIOC(factoryname,lo):false;
		if (loopobject && lo.getObj() == null) {
			throw new CurrentlyInCreationException(
					"loop inject constructor error. the inject context path is ["
							+ context + ">" + factoryname
							+ "],请检查配置文件是否配置正确[" + property.getConfigFile()
							+ "]");
		}
		if(lo.getObj() != null)
			return lo.getObj();
		
		Object ret = property.getApplicationContext().getBeanObject(
				callcontext, factoryname);
		if (ret == null)
		{
			return defaultValue;
		
		} else {
			return ret;
		}
		
	}

	@SuppressWarnings("unchecked")
	public Class<?>[] getParamsTypes(List<Pro> params) {
		if (constructParamTypes != null)
			return constructParamTypes;
		synchronized (this) {
			if (constructParamTypes != null)
				return constructParamTypes;
			if (params == null || params.size() == 0)
				return new Class<?>[0];
			constructParamTypes = new Class<?>[params.size()];
			int i = 0;
			for (Pro pro : params) {

				if (pro.getType() == null)
					return null;
				constructParamTypes[i] = pro.getType();

				i++;
			}
		}
		return constructParamTypes;
	}

	// @SuppressWarnings("unchecked")
	// public Constructor<Object> getConstructor(Class<Object> clazz, Class[] params)
	// {
	// try
	// {
	// if (params == null || params.length == 0)
	// {
	// return null;
	//
	// }
	//
	// // Class[] params_ = this.getParamsTypes(params);
	// Constructor<Object> constructor = null;
	// // if (params_ != null)
	// constructor = clazz.getConstructor(params);
	//            
	// return constructor;
	// }
	// catch (NoSuchMethodException e)
	// {
	// Constructor<Object>[] constructors = clazz.getConstructors();
	// if (constructors == null || constructors.length == 0)
	// throw new
	// CurrentlyInCreationException("Inject constructor error: no construction
	// define in the "
	// + clazz + ",请检查配置文件是否配置正确,参数个数是否正确.");
	// int l = constructors.length;
	// int size = params.length;
	// Class[] types = null;
	// Constructor fault_ = null;
	// for (int i = 0; i < l; i++)
	// {
	// Constructor temp = constructors[i];
	// types = temp.getParameterTypes();
	// if (types != null && types.length == size)
	// {
	// if(fault_ == null)
	// fault_ = temp;
	// if(isSameTypes(types,params))
	// return constructor = temp;
	// }
	//                
	// }
	// if(fault_ != null)
	// return fault_;
	// throw new CurrentlyInCreationException(
	// "Inject constructor error: Parameters with construction defined in the "
	// + clazz
	// +
	// " is not matched with the config paramenters .请检查配置文件是否配置正确,参数个数是否正确.");
	//
	//                        
	//            
	// // TODO Auto-generated catch block
	// // throw new BeanInstanceException("Inject constructor error:"
	// +clazz.getName(),e);
	// }
	// catch (Exception e)
	// {
	// // TODO Auto-generated catch block
	// throw new BeanInstanceException("Inject constructor error:"
	// +clazz.getName(),e);
	// }
	//
	//        
	// }

	// /**
	// *
	// * @param types 构造函数的参数类型
	// * @param params 外部传入的形式参数类型
	// * @return
	// */
	// private boolean isSameTypes(Class[] types, Class[] params)
	// {
	//        
	// if(types.length != params.length)
	// return false;
	// for(int i = 0; i < params.length; i ++)
	// {
	//            
	//            
	// // if(!ValueObjectUtil.isSameType(type, toType))
	// if(!ValueObjectUtil.isSameType(params[i], types[i]))
	// {
	// return false;
	// }
	//            
	// }
	// return true;
	// }

	public static Object[] getValue2ndTypes(List<Pro> params, CallContext context) {
		if (params == null || params.size() == 0) {
			return null;
		}

		Object[] valuetypes = new Object[2];
		Object[] values = new Object[params.size()];
		Class[] types = new Class[params.size()];
		valuetypes = new Object[] { values, types };
		Context currentLoopContext = context !=null ?context.getLoopContext():null;
		for (int i = 0; i < params.size(); i++) {
			Pro param = params.get(i);
			Object refvalue = null;
			if (param.getClazz() != null && !param.getClazz().equals("")) {
				try {
					types[i] = getClass(param.getClazz());
				} catch (Exception e) {
				}
			}
			try
			{
//				refvalue = param.getTrueValue(context);
				refvalue = param.getApplicationContext().proxyObject(param, 
						param.getTrueValue(context), 
						param.getXpath());
			}
			finally
			{
				if(context !=null)
					context.setLoopContext(currentLoopContext);
			}

			if (refvalue != null) {
				values[i] = refvalue;
				if (types[i] == null) {
					types[i] = refvalue.getClass();
				}
			} else {
				if (types[i] == null) {
					types[i] = Object.class;
				}
			}

			

		}
		return valuetypes;
	}
	
	

	/**
	 * 
	 * @param providerManagerInfo
	 * @param context
	 * @param ignoreconstruction 工厂模式实例化工厂实例时需要忽略构造函数，因为构造函数是作为工厂方法创建组件实例的参数
	 * @return
	 */
	private Object initbean(BeanInf providerManagerInfo, CallContext context,boolean ignoreconstruction) {
		try {
			
			Class cls = null;
			ClassInfo classInfo = null;
			if(!ignoreconstruction)
			{
				cls = providerManagerInfo.getBeanClass();
				classInfo = ClassUtil.getClassInfo(cls);
			}
			else
			{
				if(providerManagerInfo.getIocplugin() == null)
					cls = providerManagerInfo.getFactoryClass();
				else
					cls = providerManagerInfo.getIocpluginClass();
				classInfo = ClassUtil.getClassInfo(cls);
				return context.getLoopContext().setCurrentObj(classInfo.getDefaultConstruction().newInstance());
			}
			
			if (providerManagerInfo.getConstruction() == null
					|| providerManagerInfo.getConstructorParams() == null
					|| providerManagerInfo.getConstructorParams().size() == 0 ) {
				
				return context.getLoopContext().setCurrentObj(classInfo.getDefaultConstruction().newInstance());
			}
			List<Pro> params = providerManagerInfo.getConstructorParams();
			Object[] valuetypes = getValue2ndTypes(params, context);
			Object[] values = (Object[]) valuetypes[0];
			Class[] types = (Class[]) valuetypes[1];
			if (constructor == null) {
				synchronized (this) {
					if (constructor == null) {
						constructor = ValueObjectUtil.getConstructor(cls,
								types, values);
					}
				}
			}

			Class<?>[] parameterTypes = constructor.getParameterTypes();
			
			for (int i = 0; i < parameterTypes.length; i++) {

				Object refvalue = values[i];
				if(refvalue != null)
				{
					if (!parameterTypes[i].isInstance(refvalue)) {
						if (refvalue != null) {
							refvalue = ValueObjectUtil.typeCast(refvalue, refvalue
									.getClass(), parameterTypes[i]);
							values[i] = refvalue;
						}
	
					} else {
	
					}
				}
				else
				{
					values[i] = ValueObjectUtil.getDefaultValue(parameterTypes[i]);
				}
					

			}

			

			return context.getLoopContext().setCurrentObj(constructor.newInstance(values));
		} catch (InstantiationException e) {
			throw new BeanInstanceException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]", e);
		} catch (IllegalAccessException e) {
			throw new BeanInstanceException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]", e);
		}
		catch(CurrentlyInCreationException e)
		{
			throw e;
		}
		catch(BeanInstanceException e)
		{
			throw e;
		} catch (Exception e) {
			throw new BeanInstanceException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]", e);
		}
	}

	public static Class<?> getClass(String type) throws ClassNotFoundException {
		if (type == null)
			return null;
		if (type.equals("int"))
			return int.class;
		else if (type.equals("string") || type.equals("String"))
			return String.class;
		else if (type.equals("boolean"))
			return boolean.class;
		else if (type.equals("double"))
			return double.class;
		else if (type.equals("float"))
			return float.class;
		else if (type.equals("short"))
			return short.class;
		else if (type.equals("char"))
			return char.class;
		else if (type.equals("long"))
			return long.class;
		else if (type.equals("Long"))
			return Long.class;

		else if (type.equals("Boolean"))
			return Boolean.class;
		else if (type.equals("Double"))
			return Double.class;
		else if (type.equals("Float"))
			return Float.class;
		else if (type.equals("Short"))
			return Short.class;
		else if (type.equals("Char") || type.equals("Character")
				|| type.equals("character"))
			return Character.class;
		Class<?> Type = Class.forName(type);
		return Type;
	}

	// private Object initbean(Pro<Object> providerManagerInfo, Context context)
	// {
	// try
	// {
	// Class<Object> cls = providerManagerInfo.getType();
	// if (providerManagerInfo.getConstruction() == null ||
	// providerManagerInfo.getConstructorParams() == null
	// || providerManagerInfo.getConstructorParams().size() == 0)
	// {
	// return cls.newInstance();
	// }
	//
	// List<Pro> params = providerManagerInfo.getConstructorParams();
	// Class<?>[] parameterTypes = this.getParamsTypes(params);
	// Constructor<Object> constructor = cls.getConstructor(parameterTypes);
	// // constructor.newInstance(initargs);
	//
	// Object[] values = new Object[parameterTypes.length];
	//
	// for (int i = 0; i < parameterTypes.length; i++)
	// {
	// Pro param = params.get(i);
	// Object refvalue = null;
	// if (param.isBean())
	// {
	// refvalue = BaseSPIManager.getBeanObject(context, param);
	// }
	// else if (param.isRefereced())
	// {
	// refvalue = BaseSPIManager.getBeanObject(context, param);
	// }
	// else
	// {
	// refvalue = param.getObject();
	// }
	// values[i] = refvalue;
	//
	// }
	// return constructor.newInstance(values);
	// }
	// catch (InstantiationException e)
	// {
	// throw new BeanInstanceException(e);
	// }
	// catch (IllegalAccessException e)
	// {
	// throw new BeanInstanceException(e);
	// }
	//
	// catch (Exception e)
	// {
	// throw new BeanInstanceException(e);
	// }
	// }

	public static void injectProperties(Object bean,
			Map<String, Pro> globalparams) throws IntrospectionException {
		injectProperties(bean, globalparams, null);
	}

	public static void injectCommonProperties(Object bean,
			Map<String, Object> globalparams) throws IntrospectionException {
		injectCommonProperties(bean, globalparams, null);
	}

	public static void injectCommonProperties(Object bean,
			Map<String, Object> globalparams,
			Map<String, Object> persistentparams) throws IntrospectionException {
//		BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
//		PropertyDescriptor[] attributes = beanInfo.getPropertyDescriptors();
		ClassInfo beanInfo = ClassUtil.getClassInfo(bean.getClass());
		List<PropertieDescription> attributes = beanInfo.getPropertyDescriptors();
		if (globalparams == null || globalparams.size() == 0) {
			return;
		}
		boolean persistentparams_ = persistentparams != null
				&& persistentparams.size() > 0;
		Set sets = globalparams.keySet();
		Iterator<String> it = sets.iterator();
		while (it.hasNext()) {
			String key = it.next();
			Object pvalue = globalparams.get(key);

			String filedName = key;
			try {

				if (persistentparams_) {
					pvalue = persistentparams.get(key);
				}

				boolean flag = false;
				for (int n = 0; attributes != null && n < attributes.size(); n++) {

					// get bean attribute name
					PropertieDescription propertyDescriptor = attributes.get(n);
					String attrName = propertyDescriptor.getName();

					if (filedName.equals(attrName)) {
						flag = true;

						Class type = propertyDescriptor.getPropertyType();

						// create attribute value of correct type
						Object value = null;

						value = ValueObjectUtil.typeCast(pvalue, pvalue
								.getClass(), type);

						// PropertyEditor editor =
						// PropertyEditorManager.findEditor(type);
						// editor.setAsText(ref.getValue());
						// Object value = editor.getValue();
//						Method wm = propertyDescriptor.getWriteMethod();

						try {
							if(propertyDescriptor.canwrite())
							{
								propertyDescriptor.setValue(bean, value);
								break;
							}
							else
							{
								log.warn("设置组件["+bean.getClass()+"]属性失败：Does not exist a writer method for field ["
										+ propertyDescriptor.getName() +"] ,请检查类定义文件是否正确设置了该字段的set方法，或者字段名称是否指定正确。");
								flag = false;
								break;
							}
//							if(wm == null)
//							{
//								log.warn("设置组件["+bean.getClass()+"]属性失败：Does not exist a writer method for field ["
//										+ propertyDescriptor.getName() +"] ,请检查类定义文件是否正确设置了该字段的set方法，或者字段名称是否指定正确。");
//								flag = false;
//								break;
//							}
//							wm.invoke(bean, new Object[] { value });
//							break;
						} catch (IllegalArgumentException e) {
							throw new CurrentlyInCreationException(
									"providerManagerInfo[" + bean.getClass()
											+ "]", e);
						} catch (IllegalAccessException e) {
							throw new CurrentlyInCreationException(
									"providerManagerInfo[" + bean.getClass()
											+ "]", e);
						}
						catch(CurrentlyInCreationException e)
						{
							throw e;
						}
						catch(InvocationTargetException e)
						{
							throw new CurrentlyInCreationException(e.getTargetException());
						}
						catch (Exception e) {
							throw new CurrentlyInCreationException(
									"providerManagerInfo[" + bean.getClass()
											+ "]", e);
						}
						// Object value = editor.getValue();
						// set attribute value on bean

					}
				}

				if (!flag) // 引用字段名称在provider中没有定义
				{
					// System.out.println("引用字段[" + filedName + "]在provider[" +
					// bean.getClass() + "]中没有定义");
//					log.warn("引用字段[" + filedName + "]在组件["
//							+ bean.getClass() + "]中没有定义");
					Exception e = new Exception("引用字段[" + filedName + "]在组件["
							+ bean.getClass() + "]中没有定义");
					log.warn("", e);
				}
			} 
			catch(CurrentlyInCreationException e)
			{
				throw e;
			}
			catch(BeanInstanceException e)
			{
				throw e;
			}
			
			catch (NumberFormatException e) {
				throw new CurrentlyInCreationException("injectProperties["
						+ bean.getClass() + "]", e);
			} catch (IllegalArgumentException e) {
				throw new CurrentlyInCreationException("injectProperties["
						+ bean.getClass() + "]", e);
			} catch (NoSupportTypeCastException e) {
				throw new CurrentlyInCreationException("injectProperties["
						+ bean.getClass() + "]", e);
			} catch (Exception e) {
				throw new CurrentlyInCreationException("injectProperties["
						+ bean.getClass() + "]", e);
			}

		}

	}

	public static void injectProperties(Object bean,
			Map<String, Pro> globalparams, Map<String, Pro> persistentparams)
			throws IntrospectionException {
//		BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
//		PropertyDescriptor[] attributes = beanInfo.getPropertyDescriptors();
		ClassInfo beanInfo = ClassUtil.getClassInfo(bean.getClass());
		List<PropertieDescription> attributes = beanInfo.getPropertyDescriptors();
		if (globalparams == null || globalparams.size() == 0) {
			return;
		}
		boolean persistentparams_ = persistentparams != null
				&& persistentparams.size() > 0;
		Set sets = globalparams.keySet();
		Iterator<String> it = sets.iterator();
		while (it.hasNext()) {
			String key = it.next();
			Pro pro = globalparams.get(key);
			String clazz = pro.getClazz();
			String filedName = pro.getName();
			try {
				Class ptype = BeanAccembleHelper.getClass(clazz);

				Object pvalue = pro.getObject();
				EditorInf editor = pro.getEditorInf();
				if (persistentparams_) {
					Pro newValue = persistentparams.get(pro.getName());
					if (newValue != null) {
						if (newValue.getEditorInf() == null && editor != null) {
							pvalue = editor.getValueFromObject(newValue
									.getObject());
						} else {
							pvalue = newValue.getObject();
						}
					}

				}

				if (ptype != null && editor == null)
					pvalue = ValueObjectUtil.typeCast(pvalue,
							pvalue.getClass(), ptype);

				boolean flag = false;
				for (int n = 0; n < attributes.size(); n++) {

					// get bean attribute name
					PropertieDescription propertyDescriptor = attributes.get(n);
					String attrName = propertyDescriptor.getName();

					if (filedName.equals(attrName)) {
						flag = true;

						Class type = propertyDescriptor.getPropertyType();

						// create attribute value of correct type
						Object value = null;
						if (editor == null) {
							value = ValueObjectUtil.typeCast(pvalue, pvalue
									.getClass(), type);
						} else {
							value = pvalue;
							// value = ValueObjectUtil.typeCast(pvalue,
							// pro.getEditorInf());
						}
						// PropertyEditor editor =
						// PropertyEditorManager.findEditor(type);
						// editor.setAsText(ref.getValue());
						// Object value = editor.getValue();
						

						try {
							if(propertyDescriptor.canwrite())
							{
//								Method wm = propertyDescriptor.getWriteMethod();
//								if(wm == null)
//								{
//									log.warn("初始化组件["+bean.getClass()+"]失败：Does not exist a writer method for field ["
//											+ propertyDescriptor.getName() +"] ,请检查类定义文件是否正确设置了该字段的set方法，或者字段名称是否指定正确。");
//									flag = false;
//									break;
//								}
//								wm.invoke(bean, new Object[] { value });
								propertyDescriptor.setValue(bean, value);
								break;
							}
							else
							{
								log.warn("初始化组件["+bean.getClass()+"]失败：Does not exist a writer method for field ["
										+ propertyDescriptor.getName() +"] ,请检查类定义文件是否正确设置了该字段的set方法，或者字段名称是否指定正确。");
								flag = false;
								break;
							}
							
						} catch (IllegalArgumentException e) {
							throw new CurrentlyInCreationException(
									pro.getName()+"@" + pro.getConfigFile() + "，providerManagerInfo[" + bean.getClass()
											+ "]", e);
						} 
						catch(CurrentlyInCreationException e)
						{
							throw e;
						}
						catch(InvocationTargetException e)
						{
							throw new CurrentlyInCreationException(e.getTargetException());
						}
						catch (IllegalAccessException e) {
							throw new CurrentlyInCreationException(
									pro.getName()+"@" + pro.getConfigFile() + "，providerManagerInfo[" + bean.getClass()
											+ "]", e);
						} 
						catch (Exception e) {
							throw new CurrentlyInCreationException(
									pro.getName()+"@" + pro.getConfigFile() + "，providerManagerInfo[" + bean.getClass()
											+ "]", e);
						}
						// Object value = editor.getValue();
						// set attribute value on bean

					}
				}

				if (!flag) // 引用字段名称在provider中没有定义
				{
					// System.out.println("引用字段[" + filedName + "]在provider[" +
					// bean.getClass() + "]中没有定义");
//					log.warn("引用字段[" + filedName + "]在provider["
//							+ bean.getClass() + "]中没有定义");
					Exception e = new Exception("引用字段[" + filedName + "]在组件["
							+ bean.getClass() + "]中没有定义,请检查配置文件是否配置正确["
											+ pro
													.getConfigFile() + "]");
					log.warn("", e);
				}
			}
			catch(CurrentlyInCreationException e)
			{
				throw e;
			}
			catch(BeanInstanceException e)
			{
				throw e;
			}catch (ClassNotFoundException e) {
				// TODO Auto-generated catch block
				throw new CurrentlyInCreationException(pro.getName()+"@" + pro.getConfigFile() + "，injectProperties["
						+ bean.getClass() + "]", e);
			} catch (NumberFormatException e) {
				throw new CurrentlyInCreationException(pro.getName()+"@" + pro.getConfigFile() + "，injectProperties["
						+ bean.getClass() + "]", e);
			} catch (IllegalArgumentException e) {
				throw new CurrentlyInCreationException(pro.getName()+"@" + pro.getConfigFile() + "，injectProperties["
						+ bean.getClass() + "]", e);
			} catch (NoSupportTypeCastException e) {
				throw new CurrentlyInCreationException(pro.getName()+"@" + pro.getConfigFile() + "，injectProperties["
						+ bean.getClass() + "]", e);
			} catch (Exception e) {
				throw new CurrentlyInCreationException(pro.getName()+"@" + pro.getConfigFile() + "，injectProperties["
						+ bean.getClass() + "]", e);
			}

		}

	}
	/**
	 * 通过工厂方法获取组件实例
	 * @param providerManagerInfo
	 * @param callcontext
	 * @return
	 */
	private Object getBeanFromFactory(BeanInf providerManagerInfo, CallContext callcontext)
	{
		Pro pro = (Pro)providerManagerInfo;
		String factoryMethod = pro.getFactory_method();
		if(factoryMethod == null || factoryMethod.equals(""))
			throw new CurrentlyInCreationException(pro.getName()+"@" + pro.getConfigFile() + "，没有指定工厂创建方法。请检查[factory-method]属性配置是否正确。");
		if(pro.getFactory_bean() != null)//使用工厂bean创建组件实例
		{
			//获取工厂对象
			Context cloopcontext = callcontext.getLoopContext();
			Object factory = null;
			try
			{
				String beanname = providerManagerInfo.getFactory_bean();
				factory = this.getFactoryRefValue(pro, beanname, callcontext, null);
				if(factory == null)
				{
					throw new CurrentlyInCreationException(pro.getName()+"@" + pro.getConfigFile() + "，没有找到对象工厂["+beanname+"]。请检查[factory-bean]属性配置是否正确。");
				}
//				//通过工厂对象创建组件实例
//				//1.构建工厂创建路径上下文，防止工厂对象在创建组件实例时产生循环依赖
//				
//				if (callcontext == null)
//					callcontext = new LocalCallContextImpl(providerManagerInfo
//							.getApplicationContext());
//				if (callcontext.getLoopContext() == null) {
//					context = new Context(providerManagerInfo.getXpath());
//					callcontext.setLoopContext(context);
//				} else {
//					context = new Context(callcontext.getLoopContext(),
//							providerManagerInfo.getXpath());
//					callcontext.setLoopContext(context);
//				}
			}
			finally
			{
				if(cloopcontext != null)
					callcontext.setLoopContext(cloopcontext);
			}
			//2.创建组件实例
			Object bean  = creatorBeanByFactoryBean(pro, factory,factoryMethod,callcontext);
			cloopcontext.setCurrentObj(bean);
			return bean;
		}
		else//使用工厂类静态方法创建组件实例
		{
			String factoryClass = pro.getFactory_class();
			try {
				Class cls = pro.getFactoryClass();
//				//通过工厂对象创建组件实例
//				//1.构建工厂创建路径上下文，防止工厂对象在创建组件实例时产生循环依赖
//				Context context = null;
//				if (callcontext == null)
//					callcontext = new LocalCallContextImpl(providerManagerInfo
//							.getApplicationContext());
//				if (callcontext.getLoopContext() == null) {
//					context = new Context(providerManagerInfo.getXpath());
//					callcontext.setLoopContext(context);
//				} else {
//					context = new Context(callcontext.getLoopContext(),
//							providerManagerInfo.getXpath());
//					callcontext.setLoopContext(context);
//				}
				Object bean  = creatorBeanByFactoryClass(pro, cls, factoryMethod,callcontext);
				callcontext.getLoopContext().setCurrentObj(bean);
				return bean;
			}
			catch(CurrentlyInCreationException e)
			{
				throw e;
			}
			catch(BeanInstanceException e)
			{
				throw e;
			}
			catch (Exception e) {
				throw new CurrentlyInCreationException(pro.getName()+"@" + pro.getConfigFile() + "，没有找到对象工厂["+factoryClass+"]类。请检查[factory-class]属性配置是否正确。",e);
			}
			
			
		}
	}
	
	/**
	 * 通过工厂方法获取组件实例
	 * @param providerManagerInfo
	 * @param callcontext
	 * @return
	 */
	private Object getBeanFromIOCPlugin(BeanInf providerManagerInfo, CallContext callcontext)
	{
		Pro pro = (Pro)providerManagerInfo;
		
		{
		 
			try {
				Class cls = pro.getIocpluginClass();
				//通过工厂对象创建组件实例
				//1.构建工厂创建路径上下文，防止工厂对象在创建组件实例时产生循环依赖
//				Context context = null;
//				if (callcontext == null)
//					callcontext = new LocalCallContextImpl(providerManagerInfo
//							.getApplicationContext());
//				if (callcontext.getLoopContext() == null) {
//					context = new Context(providerManagerInfo.getXpath());
//					callcontext.setLoopContext(context);
//				} else {
//					context = new Context(callcontext.getLoopContext(),
//							providerManagerInfo.getXpath());
//					callcontext.setLoopContext(context);
//				}
				Object bean  = this.creatorBeanByIocPluginClass(pro, cls, callcontext);
				callcontext.getLoopContext().setCurrentObj(bean);
				return bean;
			}
			catch(CurrentlyInCreationException e)
			{
				throw e;
			}
			catch(BeanInstanceException e)
			{
				throw e;
			}
			catch (Exception e) {
				throw new CurrentlyInCreationException(pro.getName()+"@" + pro.getConfigFile() + "，没有找到对象工厂["+pro.getIocplugin()+"]类。请检查[factory-class]属性配置是否正确。",e);
			}
			
			
		}
	}
	
	/**
	 * 通过工厂对象创建组件实例
	 * @param providerManagerInfo
	 * @param factory
	 * @param context
	 * @return
	 */
	private Object creatorBeanByFactoryBean(Pro  providerManagerInfo, Object factory,String factoryMethod,CallContext context)
	{
		try {
			Class cls = (Class) factory.getClass();
			
			if (providerManagerInfo.getConstruction() == null
					|| providerManagerInfo.getConstructorParams() == null
					|| providerManagerInfo.getConstructorParams().size() == 0) {
				Method method = cls.getMethod(factoryMethod,null);
				if(method == null)
				{
					throw new CurrentlyInCreationException(providerManagerInfo.getName()+"@" + providerManagerInfo.getConfigFile() + ",对象工厂["+factory.getClass().getName()+"]没有定义"+factoryMethod+"方法。请检查[factory-method]属性配置是否正确。");
				}
				/**
				 * 本地线程技术，存放CallContext上下文
				 * 如果有旧的还需要保存旧的callContext
				 */
//				return  method.invoke(factory, null);
				return invokerMethod(  providerManagerInfo,factory,method,null,context);
				
				/**
				 * 清理本地线程
				 * 如果有旧的callContext，还需要恢复旧的上下文
				 */
			}
			List<Pro> params = providerManagerInfo.getConstructorParams();
			Object[] valuetypes = getValue2ndTypes(params, context);
			Object[] values = (Object[]) valuetypes[0];
			Class[] types = (Class[]) valuetypes[1];
			Method method = getMethod(providerManagerInfo, cls, factoryMethod, types, values, false);
					

			Class<?>[] parameterTypes = method.getParameterTypes();

			for (int i = 0; i < parameterTypes.length; i++) {
				Object refvalue = values[i];
				if (!parameterTypes[i].isInstance(refvalue)) {
					if (refvalue != null) {
						refvalue = ValueObjectUtil.typeCast(refvalue, refvalue
								.getClass(), parameterTypes[i]);
						values[i] = refvalue;
					}
				} else {

				}

			}
			/**
			 * 采用本地线程技术存放CallContext上下文
			 * 如果有旧的还需要保存旧的callContext
			 */
			
//			Object bean =  method.invoke(factory,values);
			Object bean = invokerMethod(  providerManagerInfo,factory,method,values,context);
			return bean;
			
			/**
			 * 清理本地线程
			 * 如果有旧的callContext，还需要恢复旧的上下文
			 */
			
			
		}  catch (IllegalAccessException e) {
			throw new BeanInstanceException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]", e);
		}
		catch(CurrentlyInCreationException e)
		{
			throw e;
		}
		catch(InvocationTargetException e)
		{
			throw new BeanInstanceException(e.getTargetException());
		}
		catch (BeanInstanceException e) {
			throw e;
		} catch (Exception e) {
			throw new BeanInstanceException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]", e);
		}
	}
	
	
	/**
	 * 通过工厂对象创建组件实例
	 * @param providerManagerInfo
	 * @param factory
	 * @param context
	 * @return
	 */
	public static  MethodInvoker creatorMethodInvokerByBean( Pro providerManagerInfo, String beanName,String method)
	{
		try {
			Object instance  = providerManagerInfo.getApplicationContext().getBeanObject(beanName);
			Class cls = instance.getClass();
			
			if (providerManagerInfo.getConstruction() == null
					|| providerManagerInfo.getConstructorParams() == null
					|| providerManagerInfo.getConstructorParams().size() == 0) {
				Method method_ = cls.getMethod(method,null);
				if(method == null)
				{
					throw new CurrentlyInCreationException(providerManagerInfo.getName()+"@" 
							+ providerManagerInfo.getConfigFile() + ",对象工厂["+cls.getName()+"]没有定义"+method+"方法。请检查[factory-method]属性配置是否正确。");
				}
				
				/**
				 * 本地线程技术，存放CallContext上下文
				 * 如果有旧的还需要保存旧的callContext
				 */
//				return  method.invoke(factory, null);
				return new MethodInvoker(false, instance, null, method_,providerManagerInfo);
				
				/**
				 * 清理本地线程
				 * 如果有旧的callContext，还需要恢复旧的上下文
				 */
			}
			List<Pro> params = providerManagerInfo.getConstructorParams();
			Object[] valuetypes = getValue2ndTypes(params, null);
			Object[] values = (Object[]) valuetypes[0];
			Class[] types = (Class[]) valuetypes[1];
			Method method_ = getMethod(providerManagerInfo, cls, method, types, values, false);
					

			Class<?>[] parameterTypes = method_.getParameterTypes();

			for (int i = 0; i < parameterTypes.length; i++) {
				Object refvalue = values[i];
				if (!parameterTypes[i].isInstance(refvalue)) {
					if (refvalue != null) {
						refvalue = ValueObjectUtil.typeCast(refvalue, refvalue
								.getClass(), parameterTypes[i]);
						values[i] = refvalue;
					}
				} else {

				}

			}
	

			return new MethodInvoker(false, instance, values, method_,providerManagerInfo);
			
			
			
		} 
		catch(CurrentlyInCreationException e)
		{
			throw e;
		}
		
		catch (BeanInstanceException e) {
			throw e;
		} catch (Exception e) {
			throw new BeanInstanceException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]", e);
		}
	}
	
	private Object invokerMethod(Pro  providerManagerInfo,Object bean,Method method,Object[] params,CallContext context) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException
	{
		try {
			/**
			 * 本地线程技术，存放CallContext上下文
			 * 如果有旧的还需要保存旧的callContext
			 */
			return  method.invoke(bean, params);
		} 
		finally
		{
			/**
			 * 清理本地线程
			 * 如果有旧的callContext，还需要恢复旧的上下文
			 */
		}
		
		
		
	}
	
	
	/**
	 * 通过工厂类创建组件实例,工厂方法如果是静态的直接调用静态方法创建所需组件；
	 * 如果是非静态的安照普通组件处理，即先获取工厂对象实例，然后再创建组件
	 * @param providerManagerInfo
	 * @param factory
	 * @param context
	 * @return
	 */
	private Object creatorBeanByFactoryClass(Pro  providerManagerInfo, Class factoryClass,String factoryMethod,CallContext context)
	{
		try {
			Class cls = factoryClass;
			
			if (providerManagerInfo.getConstruction() == null
					|| providerManagerInfo.getConstructorParams() == null
					|| providerManagerInfo.getConstructorParams().size() == 0) {
				Method method = cls.getMethod(factoryMethod,null);
//				method.
				if(method == null)
				{
					throw new CurrentlyInCreationException(providerManagerInfo.getName()+"@" + providerManagerInfo.getConfigFile() + ",对象工厂["+factoryClass.getName()+"]没有定义"+factoryMethod+"方法。请检查[factory-method]属性配置是否正确。");
				}
				try {
					/**
					 * 本地线程技术，存放CallContext上下文
					 * 如果有旧的还需要保存旧的callContext
					 */
//					return  method.invoke(null);

					 int mode = method.getModifiers();
					 if( Modifier.isStatic(mode))//静态方法
						 return this.invokerMethod(providerManagerInfo, null, method, null, context);
					 else//非静态方法
					 {
						 Object factoryInf = getBeanFromClass( providerManagerInfo,  context,true);//先获取工厂类实例
						 return this.invokerMethod(providerManagerInfo, factoryInf, method, null, context);//然后调用工厂类实例方法创建组件实例
					 }
				}
				catch(CurrentlyInCreationException e)
				{
					throw e;
				}
				catch(InvocationTargetException e)
				{
					throw new BeanInstanceException(e.getTargetException());
				}
				catch (Exception e) {
					throw new CurrentlyInCreationException(providerManagerInfo.getName()+"@" + providerManagerInfo.getConfigFile() + ",对象工厂["+factoryClass.getName()+"]没有定义"+factoryMethod+"方法,或者是非静态方法。请检查[factory-method]属性配置是否正确。",e);
				}
				
				
				/**
				 * 清理本地线程
				 * 如果有旧的callContext，还需要恢复旧的上下文
				 */
			}
			List<Pro> params = providerManagerInfo.getConstructorParams();
			Object[] valuetypes = getValue2ndTypes(params, context);
			Object[] values = (Object[]) valuetypes[0];
			Class[] types = (Class[]) valuetypes[1];
			Method method = getMethod(providerManagerInfo, cls, factoryMethod, types, values, false);
					

			Class<?>[] parameterTypes = method.getParameterTypes();

			for (int i = 0; i < parameterTypes.length; i++) {

				Object refvalue = values[i];
				if (!parameterTypes[i].isInstance(refvalue)) {
					if (refvalue != null) {
						refvalue = ValueObjectUtil.typeCast(refvalue, refvalue
								.getClass(), parameterTypes[i]);
						values[i] = refvalue;
					}

				} else {

				}

			}
			/**
			 * 采用本地线程技术存放CallContext上下文
			 * 如果有旧的还需要保存旧的callContext
			 */
			
//			Object bean =  method.invoke(null,values);
			 int mode = method.getModifiers();
			 if( Modifier.isStatic(mode))//静态方法
			 {
				 return invokerMethod(providerManagerInfo, null, method, values, context);
			 }
			 else //非静态方法
			 {
				 Object factoryInf = getBeanFromClass( providerManagerInfo,  context,true);//先获取工厂类实例
				 return invokerMethod(providerManagerInfo, factoryInf, method, values, context);//然后调用工厂类实例方法创建组件实例
			 }
			
			/**
			 * 清理本地线程
			 * 如果有旧的callContext，还需要恢复旧的上下文
			 */
			
			
		}  catch (IllegalAccessException e) {
			throw new BeanInstanceException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]", e);
		} catch (BeanInstanceException e) {
			throw e;
		} 
		catch(CurrentlyInCreationException e)
		{
			throw e;
		}
		catch(InvocationTargetException e)
		{
			throw new BeanInstanceException(e.getTargetException());
		}
		catch (Exception e) {
			throw new BeanInstanceException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]", e);
		}
	}
	
	/**
	 * 通过ioc插件类创建组件实例
	 * @param providerManagerInfo
	 * @param factory
	 * @param context
	 * @return
	 */
	private Object creatorBeanByIocPluginClass(Pro  providerManagerInfo, Class iocpluginClass,CallContext context)
	{
		 
			 
			
			  
				try {
					/**
					 * 本地线程技术，存放CallContext上下文
					 * 如果有旧的还需要保存旧的callContext
					 */
//					return  method.invoke(null);

					
					 IocPlugin factoryInf = (IocPlugin)getBeanFromClass( providerManagerInfo,  context,true);//先获取工厂类实例
					 
					 return factoryInf.ioc(providerManagerInfo.getIocinputData(), context);
					
					 
				}
				catch(CurrentlyInCreationException e)
				{
					throw e;
				}
				catch (Exception e) {
					throw new CurrentlyInCreationException(providerManagerInfo.getName()+"@" + providerManagerInfo.getConfigFile() + ",插件["+iocpluginClass.getName()+"]解析组件异常。请检查[iocplugin]属性配置是否正确。",e);
				}
				
				
				  
	
	}
	
	/**
	 * 通过工厂对象创建组件实例
	 * @param providerManagerInfo
	 * @param factory
	 * @param context
	 * @return
	 */
	public static MethodInvoker creatorMethodInvokerByClass(Pro  providerManagerInfo, String beanClass,String method)
	{
		try {
			Class cls = Class.forName(beanClass);
			Object instance = BeanUtils.instantiateClass(cls);
			
			if (providerManagerInfo.getConstruction() == null
					|| providerManagerInfo.getConstructorParams() == null
					|| providerManagerInfo.getConstructorParams().size() == 0) {
				Method method_ = cls.getMethod(method,null);
//				method.
				if(method == null)
				{
					throw new CurrentlyInCreationException(providerManagerInfo.getName()+"@" + providerManagerInfo.getConfigFile() 
							+ ",对象工厂["+beanClass+"]没有定义"+method+"方法。请检查[factory-method]属性配置是否正确。");
				}
				try {
					/**
					 * 本地线程技术，存放CallContext上下文
					 * 如果有旧的还需要保存旧的callContext
					 */
//					return  method.invoke(null);
					return new MethodInvoker(true, instance, null, method_,providerManagerInfo);
				}
				catch(CurrentlyInCreationException e)
				{
					throw e;
				}
				
				catch (Exception e) {
					throw new CurrentlyInCreationException(providerManagerInfo.getName()+"@" + providerManagerInfo.getConfigFile() 
							+ ",对象工厂["+beanClass+"]没有定义"+method+"方法,或者是非静态方法。请检查[factory-method]属性配置是否正确。",e);
				}
				
				
				/**
				 * 清理本地线程
				 * 如果有旧的callContext，还需要恢复旧的上下文
				 */
			}
			List<Pro> params = providerManagerInfo.getConstructorParams();
			Object[] valuetypes = getValue2ndTypes(params, null);
			Object[] values = (Object[]) valuetypes[0];
			Class[] types = (Class[]) valuetypes[1];
			Method method_ = getMethod(providerManagerInfo, cls, method, types, values, false);
					

			Class<?>[] parameterTypes = method_.getParameterTypes();

			for (int i = 0; i < parameterTypes.length; i++) {

				Object refvalue = values[i];
				if (!parameterTypes[i].isInstance(refvalue)) {
					if (refvalue != null) {
						refvalue = ValueObjectUtil.typeCast(refvalue, refvalue
								.getClass(), parameterTypes[i]);
						values[i] = refvalue;
					}

				} else {

				}

			}
			
			return new MethodInvoker(true, instance, values, method_,providerManagerInfo);
			
			
		}catch (BeanInstanceException e) {
			throw e;
		} 
		catch(CurrentlyInCreationException e)
		{
			throw e;
		}
		
		catch (Exception e) {
			throw new BeanInstanceException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]", e);
		}
	}
	
	/**
     * 根据参数类型params_，获取clazz的构造函数，paramArgs为参数的值，如果synTypes为true方法会
     * 通过参数的值对参数类型进行校正 当符合params_类型的构造函数有多个时，返回最开始匹配上的构造函数，但是当synTypes为true时，
     * 就会返回严格符合paramArgs值类型对应的构造函数 paramArgs值的类型也会作为获取构造函数的辅助条件，
     * 
     * @param clazz
     * @param params_
     * @param paramArgs
     * @param synTypes
     * @return
     */
    public static Method getMethod(Pro pro,Class clazz,String methodName, Class[] params_, Object[] paramArgs, boolean synTypes)
    {
        if (params_ == null || params_.length == 0)
        {
            return null;

        }
        Class[] params = null;
        if (synTypes)
            params = ValueObjectUtil.synParamTypes(params_, paramArgs);
        else
        	params = params_;
        try
        {

        	Method method = clazz.getMethod(methodName,params);
            return method;
        }
        catch (NoSuchMethodException e)
        {
        	Method[] constructors = clazz.getMethods();
            if (constructors == null || constructors.length == 0)
                throw new CurrentlyInCreationException("Inject constructor error: no construction define in the "
                        + clazz + ",请检查配置文件是否配置正确,参数个数是否正确.");
            int l = constructors.length;
            int size = params.length;
            Class[] types = null;
            Method fault_ = null;
            for (int i = 0; i < l; i++)
            {
            	Method temp = constructors[i];
            	if(!temp.getName().equals(methodName))
            		continue;
                types = temp.getParameterTypes();
                if (types != null && types.length == size)
                {
                    if (fault_ == null)
                        fault_ = temp;
                    if (ValueObjectUtil.isSameTypes(types, params, paramArgs))
                        return temp;
                }

            }
            if (fault_ != null)
                return fault_;
            StringBuffer msg = new StringBuffer();
            
            msg.append(pro.getName()+"@" 
            		+ pro.getConfigFile() + "， 对象工厂["
            		+ clazz+"]没有定义"
            		+ methodName);
            msg.append("(");
            for(int i = 0; i < params.length; i ++)
            {
            	if(i > 0 && i < params.length - 1)
            		msg.append(",");
            	msg.append(params[i].getCanonicalName());
            	
            }
            
            msg.append(")方法。请检查[factory-method]属性配置是否正确。.");
            		
            throw new CurrentlyInCreationException(msg.toString());

            // TODO Auto-generated catch block
            // throw new BeanInstanceException("Inject constructor error:"
            // +clazz.getName(),e);
        }
        catch(CurrentlyInCreationException e)
        {
        	throw e;
        }
        catch (Exception e)
        {
        	StringBuffer msg = new StringBuffer();
            
            msg.append(pro.getName()+"@" 
            		+ pro.getConfigFile() + "， 对象工厂["
            		+ clazz+"]没有定义"
            		+ methodName);
            msg.append("(");
            for(int i = 0; i < params.length; i ++)
            {
            	if(i > 0 && i < params.length - 1)
            		msg.append(",");
            	msg.append(params[i].getCanonicalName());
            	
            }
            
            msg.append(")方法。请检查[factory-method]属性配置是否正确。.");
            		
            throw new CurrentlyInCreationException(msg.toString(),e);
        }

    }
    

    
    private Object getBeanFromClass(BeanInf providerManagerInfo, CallContext callcontext)
    {
    	return  getBeanFromClass( providerManagerInfo,  callcontext,false);
    }
	
	private Object getBeanFromClass(BeanInf providerManagerInfo, CallContext callcontext,boolean ignoreconstruction)
	{
		Object instance = null;
		try {
			
			Class<Object> cls = null;
			if(!ignoreconstruction)
				cls = providerManagerInfo.getBeanClass();
			else
			{
				if(providerManagerInfo.getIocplugin() == null)
					cls = providerManagerInfo.getFactoryClass();
				else
					cls = providerManagerInfo.getIocpluginClass();
			}
				
			
			instance = initbean(providerManagerInfo, callcontext,ignoreconstruction);

//			BeanInfo beanInfo = Introspector.getBeanInfo(cls);
//			PropertyDescriptor[] attributes = beanInfo.getPropertyDescriptors();

			List<Pro> refs = providerManagerInfo.getReferences();
			ClassInfo classInfo = ClassUtil.getClassInfo(cls);
			if (refs != null && refs.size() > 0) {
				//这里需要增加引用Pro的调用上下文
				Context currentLoopContext = callcontext != null?callcontext.getLoopContext():null;
				for (int i = 0; i < refs.size(); i++) {
					Pro ref = refs.get(i);
					
					String filedName = ref.getName();
					Object refvalue = null;
					try
					{
//						if(ref.getXpath() != null)
							refvalue = providerManagerInfo.getApplicationContext().proxyObject(ref, 
									ref.getTrueValue(callcontext), 
									ref.getXpath());
					}
					finally
					{
						if(callcontext != null)
							callcontext.setLoopContext(currentLoopContext);
					}				

					// get bean attribute name
					PropertieDescription propertyDescriptor = classInfo.getPropertyDescriptor(filedName);
					

					if (propertyDescriptor != null) {
						

						Class type = propertyDescriptor.getPropertyType();

						// create attribute value of correct type
						
						Object value = refvalue != null?ValueObjectUtil.typeCast(refvalue,
								refvalue.getClass(), type):ValueObjectUtil.getDefaultValue(type);
						
//						Method wm = propertyDescriptor.getWriteMethod();

						try {
							if(propertyDescriptor.canwrite())
							{
								propertyDescriptor.setValue(instance, value);
								continue;
							}
							else
							{
								log.warn("设置组件["+providerManagerInfo.getName()+"]属性失败：Does not exist a writer method for field ["
										+ propertyDescriptor.getName() +"] in class ["+instance.getClass().getCanonicalName()+"],请检查类定义文件是否正确设置了该字段的set方法，或者字段名称是否指定正确。");
								
								continue;
							}
//							if(wm == null)
//							{
//								log.warn("设置组件["+providerManagerInfo.getName()+"]属性失败：Does not exist a writer method for field ["
//										+ propertyDescriptor.getName() +"] in class ["+instance.getClass().getCanonicalName()+"],请检查类定义文件是否正确设置了该字段的set方法，或者字段名称是否指定正确。");
//								
//								continue;
//							}
//							wm.invoke(instance, new Object[] { value });
//							continue;
						} catch (IllegalArgumentException e) {
							throw new CurrentlyInCreationException(
									"providerManagerInfo["
											+ providerManagerInfo.getName()
											+ "],请检查配置文件是否配置正确["
											+ providerManagerInfo
													.getConfigFile() + "]",
									e);
						} catch (IllegalAccessException e) {
							throw new CurrentlyInCreationException(
									"providerManagerInfo["
											+ providerManagerInfo.getName()
											+ "],请检查配置文件是否配置正确["
											+ providerManagerInfo
													.getConfigFile() + "]",
									e);
						} catch (InvocationTargetException e) {
							throw new CurrentlyInCreationException(
									"providerManagerInfo["
											+ providerManagerInfo.getName()
											+ "],请检查配置文件是否配置正确["
											+ providerManagerInfo
													.getConfigFile() + "]",
									e);
						}
						catch(CurrentlyInCreationException e)
						{
							throw e;
						}
						catch(BeanInstanceException e)
						{
							throw e;
						}
						
						catch (Exception e) {
//								e.printStackTrace();
							throw new CurrentlyInCreationException(
									"providerManagerInfo["
											+ providerManagerInfo.getName()
											+ "],请检查配置文件是否配置正确["
											+ providerManagerInfo
													.getConfigFile() + "]",
									e);
						}
						

					}
					else // 引用字段名称在provider中没有定义
					{
						
//						log.warn("引用字段[" + filedName + "]在provider["
//								+ instance.getClass() + "]中没有定义");
						Exception e = new Exception("引用字段[" + filedName + "]在组件["
								+ instance.getClass() + "]中没有定义,请检查配置文件是否配置正确["
											+ providerManagerInfo
													.getConfigFile() + "]");
						log.warn("", e);
					}
				}
			}
		} catch (NumberFormatException e) {
			throw new CurrentlyInCreationException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]", e);
		} catch (IllegalArgumentException e) {
			throw new CurrentlyInCreationException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]", e);
		} catch (NoSupportTypeCastException e) {
			throw new CurrentlyInCreationException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]", e);
		} catch (BeanInstanceException e) {
			throw e;
		} catch (SPIException e) {
			throw e;
		} catch (CurrentlyInCreationException e) {
			throw e;
		}

		catch (Exception e) {
			throw new CurrentlyInCreationException("providerManagerInfo["
					+ providerManagerInfo.getName() + "],请检查配置文件是否配置正确["
					+ providerManagerInfo.getConfigFile() + "]" , e);
		}
		providerManagerInfo.getApplicationContext().initBean(instance,
				providerManagerInfo);
		
		return instance;
	}
	@SuppressWarnings("unchecked")
	public Object getBean(BeanInf providerManagerInfo, CallContext callcontext) {
		Context context = null;
		if (callcontext == null)
			callcontext = new LocalCallContextImpl(providerManagerInfo
					.getApplicationContext());
//		if(callcontext.isSOAApplication())
//		{
//			return getBeanFromClass( providerManagerInfo,  callcontext);
//		}
//		else
		{
			if (callcontext.getLoopContext() == null) {
				context = new Context(providerManagerInfo.getXpath());
				callcontext.setLoopContext(context);
			} else {
//				context = new Context(callcontext.getLoopContext(),
//						providerManagerInfo.getName());
				if(providerManagerInfo.getXpath() != null)
					context = new Context(callcontext.getLoopContext(),
							providerManagerInfo.getXpath());
				else
				{
					context = new Context(callcontext.getLoopContext(),
							providerManagerInfo.getName());
				}
				callcontext.setLoopContext(context);
			}
			if(providerManagerInfo.getFactory_bean() == null && providerManagerInfo.getFactory_class() == null)
			{
				if(providerManagerInfo.getIocplugin() == null)
					return getBeanFromClass( providerManagerInfo,  callcontext);
				else
					return getBeanFromIOCPlugin(providerManagerInfo, callcontext);
				
			}
			else
			{
				return getBeanFromFactory(providerManagerInfo, callcontext);
			}
		}
		
		
	}

	public static void initBean(Object bean, BeanInf providerManagerInfo,
			BaseApplicationContext context) throws BeanInstanceException {
		if(bean instanceof BeanClassLoaderAware)
		{
			((BeanClassLoaderAware)bean).setBeanClassLoader(context.getClassLoader());
		}
		if (bean instanceof ApplicationObjectSupport) {
			((ApplicationObjectSupport) bean).setApplicationContext(context);

		} else if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(context);
		}

		if(bean instanceof BeanNameAware)
		{
			if(providerManagerInfo != null)
				((BeanNameAware) bean).setBeanName(providerManagerInfo.getName());
		}
		if(bean instanceof BeanInfoAware)
		{
			if(providerManagerInfo != null && providerManagerInfo instanceof Pro)
				((BeanInfoAware) bean).setBeaninfo((Pro)providerManagerInfo);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(context);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(context);
		}
		
		afterPropertiesSet(bean, providerManagerInfo, context);
		registDestroy(bean, providerManagerInfo, context);

	}
	public static void initBean(Object bean, String beanname,
			BaseApplicationContext context) throws BeanInstanceException {		
		if (bean instanceof ApplicationObjectSupport) {
			((ApplicationObjectSupport) bean).setApplicationContext(context);

		} else if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(context);
		}
		if(bean instanceof BeanNameAware)
		{
			
				((BeanNameAware) bean).setBeanName(beanname);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(context);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(context);
		}
		

		afterPropertiesSet(bean, null, context);
		registDestroy(bean, null, context);

	}

	public static void registDestroy(Object instance,
			BeanInf providerManagerInfo, BaseApplicationContext context) {
		if (providerManagerInfo != null && !providerManagerInfo.isSinglable())
			return;
		if (instance != null && instance instanceof DisposableBean) {
			context.registDisableBean((DisposableBean) instance);
		} else if (providerManagerInfo != null
				&& providerManagerInfo.getDestroyMethod() != null
				&& !providerManagerInfo.getDestroyMethod().equals("")) {
			context.registDestroyMethod(providerManagerInfo.getDestroyMethod(),
					instance);
		}
	}

	public static void afterPropertiesSet(Object instance,
			BeanInf providerManagerInfo, BaseApplicationContext context)
			throws BeanInstanceException {
		if (instance == null)
			return;
		if (instance instanceof InitializingBean) {
			InitializingBean init = (InitializingBean) instance;
			try {
				init.afterPropertiesSet();
			} catch (BeanInstanceException e) {
				throw e;
			} catch (Exception e) {
				throw new BeanInstanceException(e);
			}
		} else if (providerManagerInfo != null
				&& providerManagerInfo.getInitMethod() != null
				&& !providerManagerInfo.getInitMethod().equals("")) {
			try {
				Method m = instance.getClass().getDeclaredMethod(
						providerManagerInfo.getInitMethod());
				m.invoke(instance, new Object[0]);
			} catch (SecurityException e) {
				throw new BeanInstanceException("InitializingBean["
						+ providerManagerInfo.getName()
						+ "] afterPropertiesSet 失败,请检查配置文件是否配置正确["
						+ providerManagerInfo.getConfigFile() + "]", e);
			} catch (NoSuchMethodException e) {
				throw new BeanInstanceException("InitializingBean["
						+ providerManagerInfo.getName()
						+ "] afterPropertiesSet 失败,请检查配置文件是否配置正确["
						+ providerManagerInfo.getConfigFile() + "]", e);
			}
			catch(CurrentlyInCreationException e)
			{
				throw e;
			}
			catch(InvocationTargetException e)
			{
				throw new BeanInstanceException(e.getTargetException());
			}
			catch (BeanInstanceException e) {
				throw e;
			} catch (Exception e) {
				throw new BeanInstanceException("InitializingBean["
						+ providerManagerInfo.getName()
						+ "] afterPropertiesSet 失败,请检查配置文件是否配置正确["
						+ providerManagerInfo.getConfigFile() + "]", e);
			}
		}

	}

	
}
