JAVA安全基础之代理模式（二）

上篇讲到静态代理模式，这时候我们发现，一个代理类只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。所以就有了动态代理

动态代理

动态代理的代理类，是在内存中构建代理对象，从而实现对目标对象的代理功能。

在这里我们需要知道两个类：1.InvocationHandler（接口）、2.Proxy（类）

来看下具体使用步骤

1.（接口）创建Person接口：

public interface Person {
    //上交班费
    void giveMoney();
}

2.（被代理类）Student类实现了Person接口。Student可以具体实施上交班费的动作。

public class Student implements Person{
    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void giveMoney() {
        System.out.println(name + "上交了班费");
    }

    public String getName() {
        return name;
    }
}

3.（InvocationHandler类）创建一个对象ProxyHandler，实现了InvocationHandler接口。也要持有一个Student类对象（这里换成了Object）。他可以通过反射来执行Student类的giveMoney()方法

public class ProxyHandler implements InvocationHandler {
	//这里写的是Object类
    private Object object;

    public ProxyHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("--------------begin-------------");
        //通过反射来调用被代理类的方法
        method.invoke(object, args);
        System.out.println("--------------end-------------");
        return null;
    }
}

InvocationHandler对象可以通过Proxy.newProxyInstance()来获得代理类对象，下面的proxyStudent就是代理类对象。

Person proxyStudent = (Person) Proxy.newProxyInstance(Student.class.getClassLoader(), Student.class.getInterfaces(), proxyHandler);

1.被动态代理的对象调用任意方法都是通过对应InvocationHandler#invoke方法中的method.invoke(object, args);中触发

2.代理对象每次执行方法都会放到InvocationHandler中的invoke去执行

4.测试动态代理：

public class ProxyTest {
    public static void main(String[] args) {
        //实例化被动态代理的对象
        Student student = new Student("xiaoming");
        //实例化实现了InvocationHandler接口的类
        InvocationHandler proxyHandler = new ProxyHandler(student);
        //创建代理类proxyStudent
        Person proxyStudent = (Person) Proxy.newProxyInstance(Student.class.getClassLoader(), Student.class.getInterfaces(), proxyHandler);
        //代理类对象调用被代理类的方法
        proxyStudent.giveMoney();
    }
}

运行结果：

加入来了个新的代理类mon

public interface Mom {
    void here();
}
public class MomImpl implements Mom {
    @Override
    public void here() {
        System.out.println("mom来了");
    }
}

测试类应该这么写：

public class ProxyTest {
    public static void main(String[] args) {

        Student student = new Student("xiaoming");
        MomImpl mom = new MomImpl();

        InvocationHandler proxyHandler = new ProxyHandler(student);
        InvocationHandler momHandler = new ProxyHandler(mom);

        Person proxyStudent = (Person) Proxy.newProxyInstance(Student.class.getClassLoader(), Student.class.getInterfaces(), proxyHandler);
        Mom proxyMon = (Mom) Proxy.newProxyInstance(MomImpl.class.getClassLoader(), MomImpl.class.getInterfaces(), momHandler);

        proxyStudent.giveMoney();
        proxyMon.here();
    }
}

运行结果：