反射机制的详解

一、什么是反射：
（1）Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。

（2）Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。

二、反射的优缺点：
1、优点：在运行时获得类的各种内容，进行反编译，对于Java这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。

2、缺点：（1）反射会消耗一定的系统资源，因此，如果不需要动态地创建一个对象，那么就不需要用反射；

（2）反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。

四、反射的用途：
1、反编译：.class-->.java

2、通过反射机制访问java对象的属性，方法，构造方法等

3、当我们在使用IDE,比如Ecplise时，当我们输入一个对象或者类，并想调用他的属性和方法是，一按点号，编译器就会自动列出他的属性或者方法，这里就是用到反射。

4、反射最重要的用途就是开发各种通用框架。比如很多框架（Spring）都是配置化的（比如通过XML文件配置Bean），为了保证框架的通用性，他们可能需要根据配置文件加载不同的类或者对象，调用不同的方法，这个时候就必须使用到反射了，运行时动态加载需要的加载的对象。

5、例如，在使用Strut2框架的开发过程中，我们一般会在struts.xml里去配置Action，比如

<action name="login" class="org.ScZyhSoft.test.action.SimpleLoginAction" method="execute">   
    <result>/shop/shop-index.jsp</result>           
    <result name="error">login.jsp</result>       
</action>
比如我们请求login.action时，那么StrutsPrepareAndExecuteFilter就会去解析struts.xml文件，从action中查找出name为login的Action，并根据class属性创建SimpleLoginAction实例，并用Invoke方法来调用execute方法，这个过程离不开反射。配置文件与Action建立了一种映射关系，当View层发出请求时，请求会被StrutsPrepareAndExecuteFilter拦截，然后StrutsPrepareAndExecuteFilter会去动态地创建Action实例。

比如，加载数据库驱动的，用到的也是反射。

Class.forName("com.mysql.jdbc.Driver"); // 动态加载mysql驱动
五、反射机制常用的类：
Java.lang.Class;

Java.lang.reflect.Constructor;

Java.lang.reflect.Field;

Java.lang.reflect.Method;

Java.lang.reflect.Modifier;

五、反射的基本使用：
1、获得Class：主要有三种方法：

（1）Object-->getClass

（2）任何数据类型（包括基本的数据类型）都有一个“静态”的class属性

（3）通过class类的静态方法：forName(String className)（最常用）

package com.zking.reflect;
public class Fanshe {
    public static void main(String[] args) {
        //第一种方式获取Class对象  
        Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。
        Class stuClass = stu1.getClass();//获取Class对象
        System.out.println(stuClass.getName());
        
        //第二种方式获取Class对象
        Class stuClass2 = Student.class;
        System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个
        
        //第三种方式获取Class对象
        try {
            Class stuClass3 = Class.forName("fanshe.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
            System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
    }
}

注意，在运行期间，一个类，只有一个Class对象产生，所以打印结果都是true；

三种方式中，常用第三种，第一种对象都有了还要反射干什么，第二种需要导入类包，依赖太强，不导包就抛编译错误。一般都使用第三种，一个字符串可以传入也可以写在配置文件中等多种方法。

2、判断是否为某个类的示例：

一般的，我们使用instanceof 关键字来判断是否为某个类的实例。同时我们也可以借助反射中Class对象的isInstance()方法来判断时候为某个类的实例，他是一个native方法。

public native boolean isInstance(Object obj);
3、创建实例：通过反射来生成对象主要有两种方法：

（1）使用Class对象的newInstance()方法来创建Class对象对应类的实例。

Class<?> c = String.class;
Object str = c.newInstance();
（2）先通过Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建对象，这种方法可以用指定的构造器构造类的实例。

//获取String的Class对象
Class<?> str = String.class;
//通过Class对象获取指定的Constructor构造器对象
Constructor constructor=c.getConstructor(String.class);
//根据构造器创建实例：
Object obj = constructor.newInstance(“hello reflection”);
4、通过反射获取构造方法并使用：

（1）批量获取的方法：
public Constructor[] getConstructors()：所有"公有的"构造方法
public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)

（2）单个获取的方法，并调用：
public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；

（3） 调用构造方法：

Constructor-->newInstance(Object... initargs)

newInstance是 Constructor类的方法（管理构造函数的类）

api的解释为：newInstance(Object... initargs) ，使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。

它的返回值是T类型，所以newInstance是创建了一个构造方法的声明类的新实例对象，并为之调用。

例子：

Student类：共六个构造方法。

package com.zking.reflect;
 
public class Student {
	private String sid;
 
	private String sname;
 
	public Integer age;
	
	static{
		System.out.println("加载进jvm中！");
	}
 
	public Student() {
		super();
		System.out.println("调用无参构造方法创建了一个学生对象");
	}
 
	public Student(String sid) {
		super();
		this.sid = sid;
		System.out.println("调用带一个参数的构造方法创建了一个学生对象");
	}
 
	public Student(String sid, String sname) {
		super();
		this.sid = sid;
		this.sname = sname;
		System.out.println("调用带二个参数的构造方法创建了一个学生对象");
	}
 
	@SuppressWarnings("unused")
	private Student(Integer age) {
		System.out.println("调用Student类私有的构造方法创建一个学生对象");
		this.age = age;
	}
 
	public Integer getAge() {
		return age;
	}
 
	public void setAge(Integer age) {
		this.age = age;
	}
 
	public String getSid() {
		return sid;
	}
 
	public void setSid(String sid) {
		this.sid = sid;
	}
 
	public String getSname() {
		return sname;
	}
 
	public void setSname(String sname) {
		this.sname = sname;
	}
 
	public void hello() {
		System.out.println("你好！我是" + this.sname);
	}
 
	public void hello(String name) {
		System.out.println(name + "你好！我是" + this.sname);
	}
 
	@SuppressWarnings("unused")
	private Integer add(Integer a, Integer b) {
		return new Integer(a.intValue() + b.intValue());
	}
}

测试类：

package com.zking.reflect;
import java.lang.reflect.Constructor;
 
/*
 * 通过Class对象可以获取某个类中的：构造方法、成员变量、成员方法；并访问成员；
 * 
 * 1.获取构造方法：
 *         1).批量的方法：
 *             public Constructor[] getConstructors()：所有"公有的"构造方法
            public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
 *         2).获取单个的方法，并调用：
 *             public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
 *             public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；         
 *         3).调用构造方法：
 *             Constructor-->newInstance(Object... initargs)
 */

package com.zking.reflect;
 
public class Test {
	
	public static void main(String[] args) throws Exception {
		//1.Class.forName(),得到Student的模板
		Class<Student> stuClass = (Class<Student>)Class.forName("com.zking.reflect.Student");
		
		//2.Student.class
		Class<Student> stuClass01 = Student.class;
		
		//3.对象.getClass()
		Student stu = new Student();
		Class<Student> stuClass02 = (Class<Student>) stu.getClass();
		
		
	}
}

测试类：

package com.zking.reflect;
import java.lang.reflect.Method;
 
/*
 * 获取成员方法并调用：
 * 
 * 1.批量的：
 *         public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类）
 *         public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)
 * 2.获取单个的：
 *         public Method getMethod(String name,Class<?>... parameterTypes):
 *                     参数：
 *                         name : 方法名；
 *                         Class ... : 形参的Class类型对象
 *         public Method getDeclaredMethod(String name,Class<?>... parameterTypes)
 * 
 *      调用方法：
 *         Method --> public Object invoke(Object obj,Object... args):
 *                     参数说明：
 *                     obj : 要调用方法的对象；
 *                     args:调用方式时所传递的实参；
):
 */

package com.zking.reflect;
 
import java.lang.reflect.Method;
 
public class Test03 {
	
	public static void main(String[] args) throws Exception {
		//1.传统方式
		Student stu = new Student();
		stu.setSname("zs");
		
		Class<Student> stuClazz = (Class<Student>)Class.forName("com.zking.reflect.Student");
		Student stu02 = stuClazz.newInstance();
		stu02.setSid("01");
		stu02.setSname("zs");
		
		//通过反射来获取Method
		Method method = stuClazz.getMethod("hello");
		Object obj = method.invoke(stu02);
		System.out.println(obj);
		
		Method m02 = stuClazz.getMethod("hello", String.class);
		m02.invoke(stu02, "花花世界");
		
		//有返回值的情况,且是私有方法
		Method m03 = stuClazz.getDeclaredMethod("add", Integer.class,Integer.class);
		m03.setAccessible(true);
		int sum =(int) m03.invoke(stu02, 4444,3);
		System.out.println(sum);
		
		
		
		
		
		
	}
}

5、反射实例化
        1、getConstructor:获取单个共有构造方法；

        2、getDeclaredConstructor:获取单个构造方法（包括私有的、受保护的、默认、共有的）；

        3、newInstance:

        

Class<Student> stuClazz = (Class<Student>)Class.forName("com.zking.reflect.Student");
//实例化
Student stu02 = stuClazz.newInstance();

        使用 getDeclaredConstructor调用私有化方法时，记得打开访问权限

        

Constructor<Student> stuCon05 = stuClazz.getDeclaredConstructor(Integer.class);
        //打开私有方法的访问权限
        stuCon05.setAccessible(true);

6、反射读写属性
        1、getDeclaredField:获取单个属性；

        

//动态的获取属性的值
        Field f = stuClazz.getField("age");
        int age = (int)f.get(stu02);
        System.out.println(age);
        
        //获取私有的属性
        Field f2 = stuClazz.getDeclaredField("sname");
        f2.setAccessible(true);
        String name = (String) f2.get(stu02);
        System.out.println(name);
        
        f2.set(stu02, "花花世界");
        System.out.println("******"+stu02.getSname());
        

        2、getDeclaredFields:获取所有属性；

Field[] fs = stuClazz.getDeclaredFields();
		for (Field f3 : fs) {
			f3.setAccessible(true);
			System.out.println(f3.getName()+" : "+f3.get(stu02));
		}