java反射机制
java语言允许通过程序化的方式间接对Class的对象实例操作，Class文件由类加载器装载后，在JVM中将形成一份描述class结构的元信息对象，通过该元信息对象可以获知class的结构信息，通过该源信息对象可以获知class的结构信息，如构造函数、属性和方法等
举一个反射的小例子：
car类主要包含三个属性，和一个无参构造函数与一个带参构造函数
public class Car { private String brand; private String color; private int maxspeed; public Car() { System.out.println("init car"); } public Car(String brand, String color, int maxspeed) { this.brand = brand; this.color = color; this.maxspeed = maxspeed; } public void introduce(){ System.out.println("品牌："+brand+"颜色："+color+"最大速度："+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; } }
这里利用反射获取构造器实例化对象
public class ReflectTest { //通过默认构造方法初始化car对象 public static Car initDefaultConst() throws Throwable{ //1.通过类装载器获取Car类对象 ClassLoader loader = Thread.currentThread().getContextClassLoader(); Class clazz =loader.loadClass("com.xiongda.spring.reflect.Car"); //2.获取类的默认构造器对象并实例化Car Constructor cons =clazz.getDeclaredConstructor(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 initParamConst() throws Throwable{ //1.通过类装载器获取Car类对象 ClassLoader loader = Thread.currentThread().getContextClassLoader(); Class clazz =loader.loadClass("com.xiongda.spring.reflect.Car"); //2.获取类的带参构造器对象并实例化Car Constructor cons =clazz.getDeclaredConstructor(String.class,String.class,int.class); Car car =(Car) cons.newInstance("宝马","红色",180); return car; } public static void main(String[] args) throws Throwable { Car car1 =ReflectTest.initDefaultConst(); Car car2 =ReflectTest.initParamConst(); car1.introduce(); car2.introduce(); } }
在传统方法中，我们一般是使用构造函数设置属性或者set方法设置属性
类装载器ClassLoader
类装载器就是寻找类的字节码文件并构造出类在JVM内部表示的对象组件，主要工作由ClassLoader及其子类负责，ClassLoader是一个重要的java运行时系统组件，它负责在运行时查找和装入class字节码文件
工作机制：
1.装载：查找和导入class文件
2.链接：执行校验，准备和解析步骤
3.初始化：对类的静态变量、静态代码块执行初始化工作
重要方法：
1.Class loadClass(String name)
2.Class defineClass(String name,byte[] b, int off, int len)
3.Class findSystemClass(String name)
4.Class findLoadedClass(String name)
5.ClassLoader getParent()
Class反射对象描述类语义结构，可以从Class对象中获取构造函数，成员变量，方法等类元素的反射对象，并以编程的方式通过这些反射对象对目标对象进行操作。这些反射对象类在java.reflect包中定义
三个最主要的反射类：
Constructor
Method
Field
在Spring中，通过IOC可以将实现类、参数信息等配置在其对应的配置文件中，那么当需要更改实现类或参数信息时，，只需要修改配置文件即可，我们还可以对其对象所需要的其它对象进行注入，这种注入都是在配置文件中做的
Spring的IOC的实现原理利用的就是java的反射机制，Spring的工厂类会帮我们完成配置文件的读取、利用反射机制注入对象等工作，我们可以通过bean的名称获取对应的对象
基本的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; } }
读取配置文件，然后通过Java反射机制实例化javabean
public class BeanFactory { private Map<String, Object> beanMap = new HashMap<>(); /** * bean工厂的初始化 * @param xml */ public void init(String sxml){ InputStream ins= null; Document doc = null; try { //1.创建读取配置文件的reader对象 SAXReader reader =new SAXReader(); //2.获取当前线程中的类装载器对象 ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); //3.从class目录下获取指定的xml文件 ins = classLoader.getResourceAsStream(sxml); if(ins == null){ System.out.println("获取流失败"); } 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属性 for(Iterator ite = foo.elementIterator("property");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 (ClassNotFoundException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | DocumentException | IntrospectionException e) { // TODO Auto-generated catch block if(doc ==null){ System.out.println("获取失败"); } e.printStackTrace(); } } public Object getBean(String beanName){ Object obj =beanMap.get(beanName); return obj; } public static void main(String[] args) throws Throwable { BeanFactory factory = new BeanFactory(); factory.init("config.xml"); JavaBean javabean =(JavaBean)factory.getBean("javaBean"); System.out.println("username "+javabean.getUsername()); System.out.println("password "+javabean.getPassword()); } }
xml文件
<?xml version="1.0" encoding="UTF-8"?> <beans> <bean id="javaBean" class="com.xiongda.spring.reflect.JavaBean"> <property name="username"> <value>极客学院</value> </property> <property name="password"> <value>1234567890</value> </property> </bean> </beans>
注意：如果你是用eclipse的话，你这个xml文件一定要放在bin目录里面，否则会报出一个空指针异常。但是后来我发现，用IDEA的话就不存在这个问题。（解决这东西花了不少时间，至今还未明白为啥会存在这种区别）
（备注：使用SAXReader需要导包dom4j）