java反射基础,Beanfactory原理反射解析

一、java反射基础

      1、创建一个类:  Car.java

public class Car {


	private String brand;
	private String color;
	private int maxSpeed;


	public String getBrand() {
		return brand;
	}


	public void setBrand(String brand) {
		this.brand = brand;
	}


	public String getColor() {
		return color;
	}


	public void setColor(String color) {
		this.color = color;
	}


	public int getMaxSpeed() {
		return maxSpeed;
	}


	public void setMaxSpeed(int maxSpeed) {
		this.maxSpeed = maxSpeed;
	}


	// 1.默认构造函数
	public Car() {
		System.out.println("init car!!");
	}


	// 2.带参数构造函数
	public Car(String brand, String color, int maxSpeed) {
		this.brand = brand;
		this.color = color;
		this.maxSpeed = maxSpeed;
	}


	// 3.未带参数的方法
	public void introduce() {
		System.out.println("brand:" + brand + "color:" + color + "maxSpeed:" + maxSpeed);
	}
}

      2、通过反射创建类：(ReflectTest.java)

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


public class ReflectTest {


	// 通过获取类的"默认"构造器对象来实例化Car,并且设置相关属性
	public static Car initByDefaultConst() throws Throwable {


		// 1.通过类装载器获取Car类对象
		ClassLoader loader = Thread.currentThread().getContextClassLoader();
		Class clazz = loader.loadClass("Car");


		// 2.获取类的默认构造器对象并实例化Car
		Constructor cons = clazz.getDeclaredConstructor((Class[]) null);
		Car car = (Car) cons.newInstance();


		// 3.通过反射方法设置属性
		Method setBrand = clazz.getMethod("setBrand", String.class);
		setBrand.invoke(car, "奔驰");
		Method setColor = clazz.getMethod("setColor", String.class);
		setColor.invoke(car, "白色");
		Method setMaxSpeed = clazz.getMethod("setMaxSpeed", int.class);
		setMaxSpeed.invoke(car, 200);
		return car;
	}


	// 通过获取类的"带有参数"的构造器对象来实例化Car，
	public static Car initByParamConst() throws Throwable {
		// 1.通过类装载器获取Car类对象
		ClassLoader loader = Thread.currentThread().getContextClassLoader();
		Class clazz = loader.loadClass("Car");


		// 2.获取类的带有参数的构造器对象
		Constructor cons = clazz.getDeclaredConstructor(new Class[] { String.class, String.class, int.class });


		// 3.使参数的构造器对象实例化Car
		Car car = (Car) cons.newInstance(new Object[] { "宝马", "蓝色", 180 });
		return car;
	}


	public static void main(String[] args) throws Throwable {
		Car car1 = initByDefaultConst();
		Car car2 = initByParamConst();
		car1.introduce();
		car2.introduce();
	}


}

二、Beanfactory反射的应用

      1、创建javabean对象:

public class JavaBean {


	private String userName;
	private String password;


	public String getUserName() {
		return userName;
	}


	public void setUserName(String userName) {
		this.userName = userName;
	}


	public String getPassword() {
		return password;
	}


	public void setPassword(String password) {
		this.password = password;
	}


}

 

      2、创建配置文件:(config.xml):

<?xml version="1.0" encoding="UTF-8"?>

<beans>
	<bean id="javaBean" class="JavaBean">
		<property name="userName">
			<value>朱煜</value>
		</property>
		<property name="password">
			<value>123456</value>
		</property>
	</bean>
</beans>

      3、通过配置文件,给对象注入相关属性(BeanFactory.java):

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;


import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;


public class BeanFactory {


	private Map<String, Object> beanMap = new HashMap<String, Object>();


	/**
	 * 初始化 引入xml文件，给对象注入相关属性
	 */


	public void init(String xml) {
		try {
			// 1.创建读取配置文件的reader对象
			SAXReader reader = new SAXReader();


			// 2.获取当前线程的类装载器对象
			ClassLoader classLoader = Thread.currentThread().getContextClassLoader();


			// 3.从class目录下获取指定的xml文件
			InputStream ins = classLoader.getResourceAsStream(xml);
			Document doc = reader.read(ins);
			Element root = doc.getRootElement();
			Element foo;


			// 4.遍历xml文件中的Bean实例
			for (Iterator i = root.elementIterator("bean"); i.hasNext();) {
				foo = (Element) i.next();


				// 5.针对每一个Bean实例，获取bean的属性id和class
				Attribute id = foo.attribute("id");
				Attribute cls = foo.attribute("class");


				// 6.利用java反射机制，通过class的名称获取Class对象
				Class bean = Class.forName(cls.getText());


				// 7.获取对应的class的信息
				java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);


				// 8.获取其属性描述
				java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();


				// 9.创建一个对象
				Object obj = bean.newInstance();


				// 10.遍历该bean的property的name属性
				for (Iterator ite = foo.elementIterator(); ite.hasNext();) {
					Element foo2 = (Element) ite.next();


					// 11.获取property的name属性
					Attribute name = foo2.attribute("name");
					String value = null;


					// 12.获取该property的子元素value的值
					for (Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {
						Element node = (Element) ite1.next();
						value = node.getText();
						break;
					}


					// 13.利用java的反射机制调用对象的某个set方法，并将值设进去
					for (int k = 0; k < pd.length; k++) {
						if (pd[k].getName().equalsIgnoreCase(name.getText())) {
							Method mSet = null;
							mSet = pd[k].getWriteMethod();
							mSet.invoke(obj, value);
						}
					}


				}


				// 14.将对象放入beanMap中，其中key为id值，value为对象
				beanMap.put(id.getText(), obj);
			}
		} catch (Exception e) {
			System.out.println(e.toString());
		}
	}


	public static void main(String[] args) {
		BeanFactory factory = new BeanFactory();
		factory.init("config.xml");
		JavaBean javaBean = (JavaBean) factory.beanMap.get("javaBean");
		System.out.println(javaBean.getUserName());
		System.out.println(javaBean.getPassword());


	}


}