Java反射

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

反射机制主要提供了以下功能： 

• 在运行时判断任意一个对象所属的类；

• 在运行时构造任意一个类的对象；

• 在运行时判断任意一个类所具有的成员变量和方法；

• 在运行时调用任意一个对象的方法；

• 生成动态代理。

package com.elex.test;

import org.junit.Test;

import java.io.Serializable;
import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.List;

/**
 * ========================================================================
 * -  Class:        ReflectTest
 * -  Description:  demo
 * -  Author:       quliangliang
 * -  Email:        quliangliang@elex-tech.com
 * -  Created:      2017/6/9 16:28
 * -  (C) Copyright 2008 - 2017, www.elex-tech.com All Rights Reserved.
 * ========================================================================
 */
public class ReflectTest implements  Serializable{
    private String paramStr ="str";
    private Integer paramInteger = 0;
    private Long paramLong = 0l;
    private int paramInt = 0;

    @Override
    public String toString() {
        return paramStr+paramInteger+paramLong+paramInt;
    }

    public static void main(String[] args) throws  Exception{
        //获取所有构造方法及参数
        Class<?> clazz = Class.forName("com.elex.test.ReflectTest");
        Constructor<?> constructors[] = clazz.getConstructors();
        for(int i=0;i<constructors.length;i++){
            System.out.println("构造方法"+i+constructors[i].getName());
            Class<?> typeParameters[] = constructors[i].getParameterTypes();
            for(int j=0;j<typeParameters.length;j++){
                System.out.println("参数"+j+"类型为"+typeParameters[j].getName());
            }
        }
        ReflectTest rt = (ReflectTest)constructors[0].newInstance("str",0l,new Object());
        System.out.println(rt);
    }

    public ReflectTest() {
    }

    //通过一个对象获得完整的包名和类名
    @org.junit.Test
    public void test1(){
        ReflectTest reflectTest = new ReflectTest();
        System.out.println(reflectTest.getClass().getName());
    }
    //实例化Class类对象
    @Test
    public void test2() throws ClassNotFoundException {
        Class<?> class1 = null;
        Class<?> class2 = null;
        Class<?> class3 = null;
        class1 = Class.forName("com.elex.test.ReflectTest");
        class2 = new ReflectTest().getClass();
        class3 = ReflectTest.class;
        System.out.println("类名"+class1.getName());
        System.out.println("类名"+class2.getName());
        System.out.println("类名"+class3.getName());

    }
    //获取一个类父类和所有接口
    @Test
    public void test3() throws ClassNotFoundException {
        Class<?> clazz = Class.forName("com.elex.test.ReflectTest");
        String superClass =clazz.getSuperclass().getName();
        System.out.println("父类为"+superClass);

        Class<?>[] interfices = clazz.getInterfaces();
        for (Class c : interfices){
            System.out.println("实现的接口有"+c.getName());
        }
    }


    //获取某个类的全部属性
    @Test
    public void test4() throws Exception {
        Class<?> clazz = Class.forName("com.elex.test.ReflectTest");
        Field[] declaredFields = clazz.getDeclaredFields();//返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。
//        clazz.getFields();//返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
        for(int i=0;i<declaredFields.length;i++){
            int modifiers = declaredFields[i].getModifiers();//得到访问修饰符
            Class<?> type = declaredFields[i].getType();//得到字段类型
            String name = declaredFields[i].getName();//字段名称
            System.out.println(modifiers +" " + type +" " + name );
        }
    }

    //获取某个类的全部方法
    @Test
    public void test5() throws Exception{
        Class<?> clazz = Class.forName("com.elex.test.ReflectTest");
        Method[] methods = clazz.getMethods();//得到所有方法
        for(int i=0;i<methods.length;i++){
            int modifiers = methods[i].getModifiers();//方法修饰符
            Class<?> returnType = methods[i].getReturnType();//返回值类型
            String name = methods[i].getName();//方法名
            System.out.print(modifiers +" " + returnType.toString() +" " + name +"(");
            Class<?>[] parameterTypes = methods[i].getParameterTypes();
            for(int j = 0;j<parameterTypes.length;j++){
                System.out.print(parameterTypes[j].getName()+" arg"+j);
                if (j < parameterTypes.length - 1) {
                    System.out.print(",");
                }
            }
            Class<?>[] exceptionTypes = methods[i].getExceptionTypes();//得到异常
            for(int n = 0;n<exceptionTypes.length;n++){
                System.out.print(" " + exceptionTypes[n].getName() + " ");
                if (n < exceptionTypes.length - 1) {
                    System.out.print(",");
                }
            }
            System.out.print(")");
        }
        
    }

    //通过反射机制调用某个类的方法
    @Test
    public void test6() throws  Exception{
        Class<?> clazz = Class.forName("com.elex.test.ReflectTest");
        Method sout1 = clazz.getMethod("sout1",String.class,String.class);
        sout1.invoke(clazz.newInstance(),"key","value");
    }

    //通过反射机制操作某个类的属性
    @Test
    public void test7() throws  Exception{
        Class<?> clazz = Class.forName("com.elex.test.ReflectTest");
        Object obj = clazz.newInstance();
        Field param = clazz.getDeclaredField("paramStr");
        param.set(obj,"str参数");
        System.out.println(obj);

    }






    //动态代理
    @Test
    public void test8(){
//        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
//        RealSubject realSubject = (RealSubject)myInvocationHandler.bind(new RealSubject());
//        realSubject.say("haha");

        MyInvocationHandler demo = new MyInvocationHandler();
        Subject sub = (Subject) demo.bind(new RealSubject());
        String info = sub.say("Rollen", 20);
        System.out.println(info);
    }

    //向arraylist<Integer>中加入String
    @Test
    public  void  test9() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        List<Integer> list = new ArrayList<Integer>();
        Method method = list.getClass().getMethod("add", Object.class);
        method.invoke(list,"Java反射机制");
        System.out.println(list.get(0));
    }
    //通过反射取得并修改数组的信息
    @Test
    public void  test10(){
        int[] temp = { 1, 2, 3, 4, 5 };
        Class<?> demo = temp.getClass().getComponentType();
        System.out.println("数组类型： " + demo.getName());
        System.out.println("数组长度  " + Array.getLength(temp));
        System.out.println("数组的第一个元素: " + Array.get(temp, 0));
        Array.set(temp, 0, 100);
        System.out.println("修改之后数组第一个元素为： " + Array.get(temp, 0));
    }

    //将反射机制应用于工厂模式
    @Test
    public  void  test11() throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        Subject subject =  Factory.getInstance("com.elex.test.RealSubject");
        System.out.println(subject.say("haha",21));
    }


    public void sout1(String str1,String str2){
        System.out.println(str1+":"+str2);
    }

    class User {
        private int age;
        private String name;
        public User() {
            super();
        }
        public User(String name) {
            super();
            this.name = name;
        }
        public User(int age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public String toString() {
            return "User [age=" + age + ", name=" + name + "]";
        }
    }
}

//Java反射动态代理
/*interface Subject{
    void say(String str);
}
class RealSubject implements  Subject{
    public void say(String str) {
        System.out.println("输出"+str);
    }
}
class MyInvocationHandler implements InvocationHandler{
    private  Object object;
    public Object bind(Object object){
        this.object = object;
        //返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
        //newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),this.getClass().getInterfaces(),this);
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        this.object = object;
        return method.invoke(object,args);
    }
}*/


//定义项目接口
interface Subject {
    public String say(String name, int age);
}
// 定义真实项目
class RealSubject implements Subject {
    public String say(String name, int age) {
        return name + "  " + age;
    }
}
class MyInvocationHandler implements InvocationHandler {
    private Object obj = null;
    public Object bind(Object obj) {
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//当执行真正要调用的方法时会走这个方法
        Object temp = method.invoke(this.obj, args);
        return temp;
    }
}


//反射工厂类
class Factory{
    public  static  Subject getInstance(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Subject subject = (Subject)Class.forName(className).newInstance();
        return  subject;
    }
}