静态代理和动态代理

静态代理：

package com.company.Proxy;

public class StaticProxy {
    public static void main(String[] args) {
        // write your code here
        Person student = new Student("张三");
        Person monitor = new Monitor(student);
        monitor.giveMoney();

    }
}

interface Person{
    void giveMoney();
}

/*
被代理类:学生
 */
class Student implements Person{

    private String name;

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

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

/*
代理类:班长
 */
class Monitor implements Person{

    private Student student;

    public Monitor(Person student) {
        this.student = (Student) student;
    }

    @Override
    public void giveMoney() {
        System.out.println("张三第一个交班费");
        student.giveMoney();
    }
}

动态代理：

package com.company.Proxy;

import com.company.util.MonitorUtil;

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

public class DynamicProxy {
    public static void main(String[] args){
        Person1 student = new Student1("zhangsan");
        InvocationHandler stuHandler = new StuInvocationHandler<Person1>(student);
        Person1 stuProxy = (Person1) Proxy.newProxyInstance(Person1.class.getClassLoader(),student.getClass().getInterfaces(),stuHandler);
        stuProxy.giveMoney();
        stuProxy.info();
    }
}

interface Person1{
    void giveMoney();
    void info();
}

class Student1 implements Person1 {
    private String name;
    public Student1(String name) {
        this.name = name;
    }

    @Override
    public void giveMoney() {
        try {
            //假设数钱花了一秒时间
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + "上交班费50元");
    }

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

class StuInvocationHandler<T> implements InvocationHandler{

    T target;

    public StuInvocationHandler(T target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("正在代理"+method.getName()+"方法");
        MonitorUtil.start();
        Object result = method.invoke(target,args);
        MonitorUtil.finish(method.getName());
        return result;
    }
}

动态代理相比于静态代理的好处是：

当被代理类增加某个方法时，静态代理需要修改代理类，而动态代理可以直接调用新方法。