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

}

}