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());


	}


}