java静态代理和动态代理

先上图：

静态代理是一个接口，两个实现类，其中一个类是被代理类（Student），另外一个类是代理类MyProxy

代码：

public interface Person {
    public void showName(String name);
}

public class Student implements Person {
    @Override
    public void showName(String name) {
        System.out.println(name);
    }
}

public class MyProxy implements Person {
    private Person person;

    public MyProxy(Person person) {
        this.person = person;
    }

    @Override
    public void showName(String name) {
        System.out.println("Before");
        person.showName(name);
        System.out.println("After");
    }
}

public class Test {
    public static void main(String[] args) {
        Person person = new Student();
        MyProxy proxy = new MyProxy(person);
        proxy.showName("Jerny");
    }
}

动态代理(有接口的情况)：一个接口，两个实现类+回调类InvocationHandler。其中，一个实现类是被代理对象，另外一个实现类是通过newProxyInstance通过传入的参数动态生成的实现类，它是代理对象，此代理对象调用回调类的invoke方法。回调类中注入类被代理对象。

代码：

public class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        System.out.println("Before");
        Object o = method.invoke(target, args);
        System.out.println("After");
        return o;
    }
}

public class Test {
    public static void main(String[] args) {
        Person person = new Student();
        MyInvocationHandler h = new MyInvocationHandler(person);
        person = (Person) Proxy.newProxyInstance(person.getClass().getClassLoader, person.getClass().getInterfaces(), h);
        person.showName("Jerny");
    }
}

动态代理（无接口的情况）：动态生成被代理类的子类作为代理对象，代理对象作为子类可以覆盖父类的非final的方法，当调用代理类的方法时会回调invoke方法，invoke方法写在接口MethodInterceptor的实现类中。

代码：

public class Employee {
	public void work() {
		System.out.println("work...");
	}
}

public class MyMethodInterceptor implements MethodInterceptor{
	private Object target;
	
	public Object createProxyInstance(Object target) {
		this.target = target;
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(this.target.getClass());
		enhancer.setCallback(this);
		return enhancer.create();
	}

	@Override
	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
		System.out.println("Before");
		Object o = methodProxy.invoke(target, args);
		System.out.println("After");
		return o;
	}
}

public class Test {
    public static void main(String[] args) {
        Employee emp = new Employee();
		MyMethodInterceptor m = new MyMethodInterceptor();
		emp = (Employee)m.createProxyInstance(emp);
		emp.work();
    }
}