introspector.java

来自「纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统」· Java 代码 · 共 479 行 · 第 1/2 页

	 * @param beanClass the Bean class.
	 * @param stopClass the class to stop at.
	 * @return the BeanInfo object representing the class.
	 */
	public static BeanInfo getBeanInfo(Class beanClass, Class stopClass) throws IntrospectionException {
		ExplicitInfo explicit = new ExplicitInfo(beanClass, stopClass);

		IntrospectionIncubator ii = new IntrospectionIncubator();
		ii.setPropertyStopClass(explicit.propertyStopClass);
		ii.setEventStopClass(explicit.eventStopClass);
		ii.setMethodStopClass(explicit.methodStopClass);
		ii.addMethods(beanClass.getMethods());

		BeanInfoEmbryo currentInfo = ii.getBeanInfoEmbryo();
		PropertyDescriptor[] p = explicit.explicitPropertyDescriptors;
		if (p != null) {
			for (int i = 0; i < p.length; i++) {
				if (!currentInfo.hasProperty(p[i])) {
					currentInfo.addProperty(p[i]);
				}
			}
			if (explicit.defaultProperty != -1) {
				currentInfo.setDefaultPropertyName(p[explicit.defaultProperty].getName());
			}
		}
		EventSetDescriptor[] e = explicit.explicitEventSetDescriptors;
		if (e != null) {
			for (int i = 0; i < e.length; i++) {
				if (!currentInfo.hasEvent(e[i])) {
					currentInfo.addEvent(e[i]);
				}
			}
			if (explicit.defaultEvent != -1) {
				currentInfo.setDefaultEventName(e[explicit.defaultEvent].getName());
			}
		}
		MethodDescriptor[] m = explicit.explicitMethodDescriptors;
		if (m != null) {
			for (int i = 0; i < m.length; i++) {
				if (!currentInfo.hasMethod(m[i])) {
					currentInfo.addMethod(m[i]);
				}
			}
		}

		if (explicit.explicitBeanDescriptor != null) {
			currentInfo.setBeanDescriptor(new BeanDescriptor(beanClass, explicit.explicitBeanDescriptor.getCustomizerClass()));
		} else {
			currentInfo.setBeanDescriptor(new BeanDescriptor(beanClass, null));
		}

		currentInfo.setAdditionalBeanInfo(explicit.explicitBeanInfo);
		currentInfo.setIcons(explicit.im);

		return currentInfo.getBeanInfo();
	}

	/** 
	 * Get the search path for BeanInfo classes.
	 *
	 * @return the BeanInfo search path.
	 */
	public static String[] getBeanInfoSearchPath() {
		return beanInfoSearchPath;
	}

	/** 
	 * Set the search path for BeanInfo classes.
	 * @param beanInfoSearchPath the new BeanInfo search
	 *        path.
	 */
	public static void setBeanInfoSearchPath(String[] beanInfoSearchPath) {
		Introspector.beanInfoSearchPath = beanInfoSearchPath;
	}

	/** 
	 * A helper method to convert a name to standard Java
	 * naming conventions: anything with two capitals as the
	 * first two letters remains the same, otherwise the
	 * first letter is decapitalized.  URL = URL, I = i,
	 * MyMethod = myMethod.
	 *
	 * @param name the name to decapitalize.
	 * @return the decapitalized name.
	 */
	public static String decapitalize(String name) {
		try {
			if (!Character.isUpperCase(name.charAt(0))) {
				return name;
			} else {
				try {
					if (Character.isUpperCase(name.charAt(1))) {
						return name;
					} else {
						char[] c = name.toCharArray();
						c[0] = Character.toLowerCase(c[0]);
						return new String(c);
					}
				} catch (StringIndexOutOfBoundsException E) {
					char[] c = new char[1];
					c[0] = Character.toLowerCase(name.charAt(0));
					return new String(c);
				}
			}
		} catch (StringIndexOutOfBoundsException E) {
			return name;
		} catch (NullPointerException E) {
			return null;
		}
	}

	static BeanInfo copyBeanInfo(BeanInfo b) {
		java.awt.Image[] icons = new java.awt.Image[4];
		for (int i = 1; i <= 4; i++) {
			icons[i - 1] = b.getIcon(i);
		}
		return new ExplicitBeanInfo(
			b.getBeanDescriptor(),
			b.getAdditionalBeanInfo(),
			b.getPropertyDescriptors(),
			b.getDefaultPropertyIndex(),
			b.getEventSetDescriptors(),
			b.getDefaultEventIndex(),
			b.getMethodDescriptors(),
			icons);
	}
}

class ExplicitInfo {
	BeanDescriptor explicitBeanDescriptor;
	BeanInfo[] explicitBeanInfo;

	PropertyDescriptor[] explicitPropertyDescriptors;
	EventSetDescriptor[] explicitEventSetDescriptors;
	MethodDescriptor[] explicitMethodDescriptors;

	int defaultProperty;
	int defaultEvent;

	java.awt.Image[] im = new java.awt.Image[4];

	Class propertyStopClass;
	Class eventStopClass;
	Class methodStopClass;

	ExplicitInfo(Class beanClass, Class stopClass) {
		while (beanClass != null && !beanClass.equals(stopClass)) {
			BeanInfo explicit = findExplicitBeanInfo(beanClass);
			if (explicit != null) {
				if (explicitBeanDescriptor == null) {
					explicitBeanDescriptor = explicit.getBeanDescriptor();
				}
				if (explicitBeanInfo == null) {
					explicitBeanInfo = explicit.getAdditionalBeanInfo();
				}
				if (explicitPropertyDescriptors == null) {
					if (explicit.getPropertyDescriptors() != null) {
						explicitPropertyDescriptors = explicit.getPropertyDescriptors();
						defaultProperty = explicit.getDefaultPropertyIndex();
						propertyStopClass = beanClass;
					}
				}
				if (explicitEventSetDescriptors == null) {
					if (explicit.getEventSetDescriptors() != null) {
						explicitEventSetDescriptors = explicit.getEventSetDescriptors();
						defaultEvent = explicit.getDefaultEventIndex();
						eventStopClass = beanClass;
					}
				}
				if (explicitMethodDescriptors == null) {
					if (explicit.getMethodDescriptors() != null) {
						explicitMethodDescriptors = explicit.getMethodDescriptors();
						methodStopClass = beanClass;
					}
				}
				if (im[0] == null && im[1] == null && im[2] == null && im[3] == null) {
					im[0] = explicit.getIcon(0);
					im[1] = explicit.getIcon(1);
					im[2] = explicit.getIcon(2);
					im[3] = explicit.getIcon(3);
				}
			}
			beanClass = beanClass.getSuperclass();
		}
		if (propertyStopClass == null) {
			propertyStopClass = stopClass;
		}
		if (eventStopClass == null) {
			eventStopClass = stopClass;
		}
		if (methodStopClass == null) {
			methodStopClass = stopClass;
		}
	}

	static Hashtable explicitBeanInfos = new Hashtable();
	static Vector emptyBeanInfos = new Vector();

	static BeanInfo findExplicitBeanInfo(Class beanClass) {
		BeanInfo retval = (BeanInfo) explicitBeanInfos.get(beanClass);
		if (retval != null) {
			return retval;
		} else if (emptyBeanInfos.indexOf(beanClass) != -1) {
			return null;
		} else {
			retval = reallyFindExplicitBeanInfo(beanClass);
			if (retval != null) {
				explicitBeanInfos.put(beanClass, retval);
			} else {
				emptyBeanInfos.addElement(beanClass);
			}
			return retval;
		}
	}

	static BeanInfo reallyFindExplicitBeanInfo(Class beanClass) {
		try {
			try {
				return (BeanInfo) Class.forName(beanClass.getName() + "BeanInfo").newInstance();
			} catch (ClassNotFoundException E) {
			}
			String newName = ClassHelper.getTruncatedClassName(beanClass) + "BeanInfo";
			for (int i = 0; i < Introspector.beanInfoSearchPath.length; i++) {
				try {
					if (Introspector.beanInfoSearchPath[i].equals("")) {
						return (BeanInfo) Class.forName(newName).newInstance();
					} else {
						return (BeanInfo) Class.forName(Introspector.beanInfoSearchPath[i] + "." + newName).newInstance();
					}
				} catch (ClassNotFoundException E) {
				}
			}
		} catch (IllegalAccessException E) {
		} catch (InstantiationException E) {
		}
		return null;
	}
}