J2EE_07 快速入门之反射

一：什么是反射？

           反射是一种机制,利用反射机制动态的实例化对象、读写属性、调用方法、构造函数。就是程序中的X光,当一个类被加载到JVM（java虚拟机），这个类就会变得透明(属性，方法)全部都可以看到,可以调用， 反射效率低,如果是私有化的方法或者属性可能会报错

二：如何得到类对象？

        一切反射相关的代码都从获得类对象开始

•  3种获取方式：

     ①: 类名.class;
     ②：对象名.getClass();
     ③：Class.forName(全限定名/全路径名)

三：根据类得到类名（全限定名/全路径名）

    ①：cName.getName();       -------------获取全限定名
    ②：cName.getSimpleName();   ---------------获取类名
    ③：cName.getPackage();     ---------------获取包名

        //1.获取当前类的对象
		Class c1 = this.getClass();
		//2.通过类名来获取类对象
		Class c2=Test.class;
		//3.通过全路径名称来获得类对象
		Class c3=(Class) Class.forName("com.test.Test");
		System.out.println("全路径名称"+c3.getName());
		System.out.println("类名称"+c3.getSimpleName());
		System.out.println("包名称"+c3.getPackage());
		//修饰符:	public private protected final static
		System.out.println("修饰符"+Modifier.toString(c3.getModifiers()));

四：根据类得到类的属性

Field field=cla.getField(“属性名”);

field.getName();	获取属性名
filed.getType();	获取属性类型
field.getModifiers();	获取属性访问修饰符
field.set(Object,Object);	设置属性值，参数1：要设置属性所在对象；参数2：要设置的值;
field.get(Object);	获取属性值，参数：要获取属性值的对象
field.getDeclaredField(“属性名”);	获取单个属性（私有、公有、受保护、默认、静态）
field.getDeclaredFields();	获取所有属性（私有、公有、受保护、默认、静态）

  Class clz = obj.getClass();
		//获取stu中所有的属性
		Field[] fs = clz.getDeclaredFields();
		/** 
		只能取到public
		Field[] fields = clz.getFields();
		**/
		for (Field f : fs) {
			System.out.println("属性名"+f.getName());
			System.out.println("属性修饰符"+Modifier.toString(f.getModifiers()));
			System.out.println("属性类型"+f.getType());
			//f.get()  从某个对象中获取该属性
			f.setAccessible(true);//当前不进行安全检查
			System.out.println(f.get(obj));
		}
		//修改她的年龄
		Field f = clz.getDeclaredField("age");
		//set(你要设置的对象,设置什么值)
		//  obj.age=15
		f.setAccessible(true);
		f.set(obj, 15);
		System.out.println(obj);

五：根据类得到类的方法

cla.getMethod();	获取单个公有方法
cla.getDeclaredMethod();	获取当个方法(包括私有、受保护、默认、公有)
cla.getMethods();	获取所有公有方法
cla.getDeclaredMethods();	获取所有的方法(包括私有、受保护、默认、公有)

        Stu s=new Stu("效率",90);
		//获取这个类中方法
		Class clz = s.getClass();
		//获得名字 getName
		Method m1 = clz.getDeclaredMethod("getName");
		//invoke(谁来调用这个方法，参数值) 执行方法
		m1.setAccessible(true);
		Object obj = m1.invoke(s);
		System.out.println(obj);
		//设置当前学生的年龄为18 setAge
		Method m2 = clz.getDeclaredMethod("setAge",int.class);
		Object obj2 = m2.invoke(s, 18);
		System.out.println(obj2);
		Method[] methods = clz.getDeclaredMethods();
		for (Method m : methods) {
			System.out.println(m);
			System.out.println("方法修饰符"+Modifier.toString(m.getModifiers()));
		}

六：根据类得到类的构造方法
    

cla.getConstrutor();	获取单个公有构造方法
cla.getDeclaredConstrutor();	获取单个构造方法(包括私有、受保护、默认、公有)
cla.getConstrutors();	获取所有的公有构造方法
cla.getDeclaredConstrutors();	获取所有的构造方法(包括私有、受保护、默认、公有)

      // Stu stu=new Stu();
		
		//1.通过类对象生产实例 Stu
		Class c=Stu.class;
		//调用方法 newInstance 得到实例
		//	Stu s = c.newInstance();//调用无参构造
		
		//2.直接获取类上面的构造函数
		Constructor constructor = c.getConstructor(String.class,int.class);
		//基本类型必须使用基本类型的class
		Stu s1 = constructor.newInstance("小黑",19);
		System.out.println(s1);
		Constructor[] constructors = c.getConstructors();
		for (Constructor cs : constructors) {
			System.out.println(cs);
		}

七：根据类得到类的实现接口列表

Class[] interface=cla.getInterfaces();  -----------获取类对象中所有实现接口列表

//单继承 拿父类
		Class clz = this.getClass().getSuperclass();
		System.out.println(clz);
		//多实现 多个接口
		Class[] interfaces = this.getClass().getInterfaces();
		for (Class c : interfaces) {
			System.out.println(c.getName());
		}

八：案例：

1. 完成对应的建模
2. 根据用户输入的path获取到对应的action
3. 根据action中的type加载对应的类
4. 调用类中的excute方法
    该方法返回String类型
    根据一定规则返回 failed或者success
5. 根据执行的结果找到对应的forward 并输出对应的path

package com.temp;

import java.lang.reflect.Method;
import java.util.Scanner;

import com.demo.ActionModel;
import com.demo.ConfigModel;
import com.demo.ConfigModelFactory;
import com.demo.ForwardModel;

public class Test {
	
	@SuppressWarnings("all")
	public static void main(String[] args) throws Exception {
		ConfigModel cModel = ConfigModelFactory.bulid("/com/config/config.xml");
		Scanner mys=new Scanner(System.in);
		System.out.println("请输入对应的action的path");
		String path = mys.next();
		ActionModel aModel = cModel.pop(path);
		// aModel.type 是需要执行操作的类的全路径
		Class clz = Class.forName(aModel.getType());
		//拿到方法
		Method m = clz.getDeclaredMethod("excute");
		//执行方法并拿到结果
		m.setAccessible(true);
		Object result = m.invoke(clz.newInstance());
		//根据结果找到对应的执行操作
		System.out.println(result);
		ForwardModel fModel = aModel.pop(result.toString());
		System.out.println(fModel);
	}

}