详解Java中的反射机制和动态代理

//Class<T> clazz = Class.forName("类的全限定名");这是通过Class类中的静态方法forName直接获取一个Class的对象
Class<?> clazz1 = null;
try {
    clazz1 = Class.forName("reflect.Person");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}
System.out.println(clazz1); //class reflect.Person

//Class<T> clazz = xxx.getClass(); //通过类的实例获取类的Class对象
Class<?> clazz3 = new Person().getClass();
System.out.println(clazz3); //class reflect.Person

Class<?> stringClass = "string".getClass();
System.out.println(stringClass); //class java.lang.String

/**
 * [代表数组，
 * B代表byte；
 * I代表int；
 * Z代表boolean；
 * L代表引用类型
 * 组合起来就是指定类型的一维数组，如果是[[就是二维数组
 */
Class<?> arrClass = new byte[20].getClass();
System.out.println(arrClass); //class [B

Class<?> arrClass1 = new int[20].getClass();
System.out.println(arrClass1); //class [I

Class<?> arrClass2 = new boolean[20].getClass();
System.out.println(arrClass2); //class [Z

Class<?> arrClass3 = new Person[20].getClass();
System.out.println(arrClass3); //class [Lreflect.Person;

Class<?> arrClass4 = new String[20].getClass();
System.out.println(arrClass4); //class [Ljava.lang.String;

//Class<T> clazz = XXXClass.class; 当类已经被加载为.class文件时候，
Class<Person> clazz2 = Person.class;
System.out.println(clazz2);
System.out.println(int [][].class);//class [[I
System.out.println(Integer.class);//class java.lang.Integer

/**
     * The {@code Class} instance representing the primitive type
     * {@code int}.
     *
     * @since   JDK1.1
     */
    @SuppressWarnings("unchecked")
    public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

Class c0 = Byte.TYPE; //byte
Class c1 = Integer.TYPE; //int
Class c2 = Character.TYPE; //char
Class c3 = Boolean.TYPE; //boolean
Class c4 = Short.TYPE; //short
Class c5 = Long.TYPE; //long
Class c6 = Float.TYPE; //float
Class c7 = Double.TYPE; //double
Class c8 = Void.TYPE; //void

Class c1 = Integer.class;
Class par = c1.getSuperclass();
System.out.println(par); //class java.lang.Number

package reflect;

interface Test {
    String test = "interface";
}

public class Person  implements Test{

    private String id;
    private String name;

    public void sing(String name) {
        System.out.println(getName() + "会唱" + name +"歌");
    }

    private void dance(String name) {
        System.out.println(getName() + "会跳" + name + "舞");
    }

    public void playBalls() {
        System.out.println(getName() + "会打篮球");
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    public Person() {
    }

    public Person(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public Person(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}
//Person

public void test4() throws Exception{
    Class clazz =Class.forName("reflect.Person");
    Person person = (Person)clazz.newInstance();
    System.out.println(person);
}

@Test
public void test5() throws Exception {
    Class clazz = Class.forName("reflect.Person");
    //获取带参构造器
    Constructor constructor = clazz.getConstructor(String.class, String .class);
    //通过构造器来实例化对象
    Person person = (Person) constructor.newInstance("p1", "person");
    System.out.println(person);
}

@Test
public void test6() throws Exception {
    Class clazz1 = Class.forName("reflect.Person");
    Constructor[] constructors = clazz1.getConstructors();
    for (Constructor constructor : constructors) {
        Class[] parameters = constructor.getParameterTypes();
        System.out.println("构造函数名：" + constructor + "\n" + "参数");
        for (Class c: parameters) {
            System.out.print(c.getName() + " ");
        }
        System.out.println();
    }
}

@Test
public void test7() throws Exception {
    Class clazz1 = Class.forName("reflect.Person");
    //获得实例对象
    Person person = (Person) clazz1.newInstance();
    /**
     * 获得类的属性信息
     * 使用getField(name),通过指定的属性name获得
     * 如果属性不是public的，使用getDeclaredField(name)获得
     */
    Field field = clazz1.getDeclaredField("id");
    //如果是private的，需要设置权限为可访问
    field.setAccessible(true);
    //设置成员变量的属性值
    field.set(person, "person1");
    //获取成员变量的属性值，使用get方法，其中第一个参数表示获得字段的所属对象，第二个参数表示设置的值
    System.out.println(field.get(person)); //这里的field就是id属性，打印person对象的id属性的值
}

@Test
public void test8() throws Exception{
    Class clazz1 = Class.forName("reflect.Person");
    //获得实例对象
    Person person = (Person) clazz1.newInstance();
    person.setId("person1");
    person.setName("person1_name");
    Field[] fields = clazz1.getDeclaredFields();
    for (Field f : fields) {
        //打开private成员变量的可访问权限
        f.setAccessible(true);
        System.out.println(f+ ":" + f.get(person));
    }
}

@Test
public void test9() throws Exception{
    Class clazz1 = Class.forName("reflect.Person");
    //获得实例对象
    Person person = (Person) clazz1.newInstance();
    person.setName("Person");
    //①不带参数的public方法
    Method playBalls = clazz1.getMethod("playBalls");
    //调用获得的方法，需要指定是哪一个对象的
    playBalls.invoke(person);

    //②带参的public方法：第一个参数是方法名，后面的可变参数列表是参数类型的Class类型
    Method sing = clazz1.getMethod("sing",String.class);
    //调用获得的方法，调用时候传递参数
    sing.invoke(person,"HaHaHa...");

    //③带参的private方法：使用getDeclaredMethod方法
    Method dance = clazz1.getDeclaredMethod("dance", String.class);
    //调用获得的方法，需要先设置权限为可访问
    dance.setAccessible(true);
    dance.invoke(person,"HaHaHa...");
}

@Test
public void test10() throws Exception{
    Class clazz1 = Class.forName("reflect.Person");
    //获得实例对象
    Person person = (Person) clazz1.newInstance();
    person.setName("Person");
    Method[] methods = clazz1.getDeclaredMethods();
    for (Method method: methods) {
        System.out.print("方法名" + method.getName() + "的参数是：");
        //获得方法参数
        Class[] params = method.getParameterTypes();
        for (Class c : params) {
            System.out.print(c.getName() + " ");
        }
        System.out.println();
    }
}

@Test
public void test11() throws Exception{
    Class clazz1 = Class.forName("reflect.Person");
    Class[] interfaces = clazz1.getInterfaces();
    for (Class inter : interfaces) {
        System.out.println(inter);
    }
}

@Test
public void test12() throws Exception {
    ClassLoader loader = this.getClass().getClassLoader();
    System.out.println(loader);//sun.misc.Launcher$AppClassLoader@18b4aac2 ,应用程序类加载器
    System.out.println(loader.getParent());//sun.misc.Launcher$ExtClassLoader@31befd9f ,扩展类加载器
    System.out.println(loader.getParent().getParent());//null ,不能获得启动类加载器

    Class clazz = Person.class;//自定义的类
    ClassLoader loader2 = clazz.getClassLoader();
    System.out.println(loader2);//sun.misc.Launcher$AppClassLoader@18b4aac2

    //下面是获得InputStream的例子
    ClassLoader inputStreamLoader = this.getClass().getClassLoader();
    InputStream inputStream = inputStreamLoader.getResourceAsStream("person.properties");
    Properties properties = new Properties();
    properties.load(inputStream);
    System.out.println("id:" + properties.get("id"));
    System.out.println("name:" + properties.get("name"));
}

package proxy;

/**
 * 静态代理
 */
//产品接口
interface ProductFactory {
    void action();
}

//一个具体产品的实现类,作为一个被代理类
class TeaProduct implements ProductFactory{
    @Override
    public void action() {
        System.out.println("我是生产茶叶的......");
    }
}

//TeaProduct的代理类
class ProxyTeaProduct implements ProductFactory {
    //我们需要ProductFactory的一个实现类，去代理这个实现类中的方法（多态）
    ProductFactory productFactory;

    //通过构造器传入实际被代理类的对象，这时候代理类调用action的时候就可以在其中执行被代理代理类的方法了
    public ProxyTeaProduct(ProductFactory productFactory) {
        this.productFactory = productFactory;
    }

    @Override
    public void action() {
        System.out.println("我是代理类，我开始代理执行方法了......");
        productFactory.action();
    }
}
public class TestProduct {

    public static void main(String[] args) {
        //创建代理类的对象
        ProxyTeaProduct proxyTeaProduct = new ProxyTeaProduct(new TeaProduct());
        //执行代理类代理的方法
        proxyTeaProduct.action();
    }
}

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * JDK中的动态代理
 */
//第一个接口
interface TargetOne {
    void action();
}
//第一个接口的被代理类
class TargetOneImpl implements TargetOne{
    @Override
    public void action() {
        System.out.println("我会实现父接口的方法...action");
    }
}


//动态代理类
class DynamicProxyHandler implements InvocationHandler {
    //接口的一个引用，多态的特性会使得在程序运行的时候，它实际指向的是实现它的子类对象
    private TargetOne targetOne;
    //我们使用Proxy类的静态方法newProxyInstance方法，将代理对象伪装成那个被代理的对象
    /**
     * ①这个方法会将targetOne指向实际实现接口的子类对象
     * ②根据被代理类的信息返回一个代理类对象
     */
    public Object setObj(TargetOne targetOne) {
        this.targetOne = targetOne;
        //    public static Object newProxyInstance(ClassLoader loader, //被代理类的类加载器
        //                                          Class<?>[] interfaces, //被代理类实现的接口
        //                                          InvocationHandler h) //实现InvocationHandler的代理类对象
        return Proxy.newProxyInstance(targetOne.getClass().getClassLoader(),targetOne.getClass().getInterfaces(),this);
    }
    //当通过代理类的对象发起对接口被重写的方法的调用的时候，都会转换为对invoke方法的调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("这是我代理之前要准备的事情......");
        /**
         *      这里回想一下在静态代理的时候，我们显示指定代理类需要执行的是被代理类的哪些方法；
         *      而在这里的动态代理实现中，我们并不知道代理类会实现什么方法，他是根据运行时通过反射来
         *  知道自己要去指定被代理类的什么方法的
         */
        Object returnVal = method.invoke(this.targetOne,args);//这里的返回值，就相当于真正调用的被代理类方法的返回值
        System.out.println("这是我代理之后要处理的事情......");
        return returnVal;
    }
}
public class TestProxy {
    public static void main(String[] args) {
        //创建被代理类的对象
        TargetOneImpl targetOneImpl = new TargetOneImpl();
        //创建实现了InvocationHandler的代理类对象，然后调用其中的setObj方法完成两项操作
        //①将被代理类对象传入，运行时候调用的是被代理类重写的方法
        //②返回一个类对象，通过代理类对象执行接口中的方法
        DynamicProxyHandler dynamicProxyHandler = new DynamicProxyHandler();
        TargetOne targetOne = (TargetOne) dynamicProxyHandler.setObj(targetOneImpl);
        targetOne.action(); //调用该方法运行时都会转为对DynamicProxyHandler中的invoke方法的调用
    }
}

package aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//基于jdk的针对接口实现动态代理，要求的接口
interface Target {
    void login();

    void logout();
}

//被代理类
class TargetImpl implements Target {
    @Override
    public void login() {
        System.out.println("log......");
    }

    @Override
    public void logout() {
        System.out.println("logout......");
    }
}

class Util {
    public void printLog() {
        System.out.println("我是记录打印日志功能的方法......");
    }

    public void getProperties() {
        System.out.println("我是获取配置文件信息功能的方法......");
    }
}

//实现了InvocationHandler的统一代理类
class DynamicProxyHandler implements InvocationHandler {
    private Object object;

    /**
     * 参数为obj，是应对对不同的被代理类，都能绑定与该代理类的代理关系
     * 这个方法会将targetOne指向实际实现接口的子类对象,即当前代理类实际要去代理的那个类
     */
    public void setObj(Object obj) {
        this.object = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Util util = new Util();
        util.getProperties();
        Object object = method.invoke(this.object, args); //这个方法是个动态的方法，可以是login,可以是logout，具体在测试调用中调用不同方法
        util.printLog();
        return object;
    }
}

//该类的主要作用就是动态的创建一个代理类的对象，同时需要执行被代理类
class MyDynamicProxyUtil {
    //参数obj表示动态的传递进来被代理类的对象
    public static Object getProxyInstance(Object object) {
        //获取代理类对象
        DynamicProxyHandler dynamicProxyHandler = new DynamicProxyHandler();
        dynamicProxyHandler.setObj(object);
        //设置好代理类与被代理类之间的关系后，返回一个代理类的对象
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), dynamicProxyHandler);
    }
}

public class TestAop {
    public static void main(String[] args) {
        //获得被代理类
        Target target = new TargetImpl();
        //通过代理类工具类，设置实际与代理类绑定的被代理类，并返回一个代理类对象执行实际的方法
        Target execute = (Target) MyDynamicProxyUtil.getProxyInstance(target);
        execute.login();
        execute.logout();
    }
}