现在我们来模拟一下，某位学生去考试。
假设他（小明）正常的考试。
运行结果：
结果：
突然某一天，他睡过头了，来不急去考试，所有他打算叫另一个人（Cheater）去代替他考试。
运行结果：
结果：
上面的这些例子就是一个简单的代理行为。这个简单代理，耦合性太强了。作为演示就好了。
静态代理：
优点：
1、 实现松散耦合。
2、做到在不修改目标对象的功能前提下，对目标功能扩展。
还是拿上面的例子进行修改吧，小明还是一样起晚了，叫Cheater去代替他考试。
定义一个Exam接口 ，代表着考试的行为。
public interface Exam {//考试的接口
void exam();
}
去Student类中实现此接口，并实现方法。 （被代理）
public class Student implements Exam {
public void exam(){
System.out.println("奋笔疾书，完成考试啦");
}
}
Cheater也实现Exam接口，并实现方法 （代理）
public class Cheater implements Exam {
//被代理的对象
private final Exam student;
public Cheater(Exam student){
this.student = student;
}
public void exam() {
System.out.println("考试的时候唱了一首凉凉，差点被劝退了。");
student.exam();//调用Student类的方法
}
}
测试：
public class Main {
public static void main(String[] args) {
Exam xiaoMing = new Student();
xiaoMing.exam();//原来的行为
System.out.println("-----------下面是代理的行为------------");
Exam cheater = new Cheater(xiaoMing);
cheater.exam();//代理的行为
}
}
结果：
奋笔疾书，完成考试啦
-----------下面是代理的行为------------
考试的时候唱了一首凉凉，差点被劝退了。
奋笔疾书，完成考试啦
静态代理的缺点：
如果项目中有多个类，则需要编写多个代理类，工作量大，不好修改，不好维护，不能应对变化。
如果想解决上面的问题，可以使用动态代理。
动态代理：
1、使用JDK内置的Proxy实现
还是拿上面的例子进行修改吧，小明还是一样起晚了，叫人去代替他考试。（重新开始哈）
定义一个Exam接口。
public interface Exam {
void exam();
}
Student 实现 Exam接口
public class Student implements Exam {
public void exam() {
System.out.println("奋笔疾书，完成考试啦");
}
}
创建一个 JdkProxy 类 实现 InvocationHandler 接口
public class JdkProxy implements InvocationHandler {
private Object object;//被代理的对象
public JdkProxy(){}
public JdkProxy(Object object){//初始化的时候就赋值
this.object = object;
}/**
* 当用户调用对象中的每个方法时都通过下面的方法执行，方法必须在接口
* proxy 被代理后的对象
* method 将要被执行的方法信息（反射）
* args 执行方法时需要的参数
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("考试的时候，吃颗糖压压惊，没有人知道，这次不是本人来考试的");
Object invoke = null;
try{
invoke = method.invoke(object, args);
}catch (Exception x){
System.out.println("异常信息："+x.getMessage());
}return invoke;//调用被代理对象原来的方法(行为)
}
}
测试：
public class Main {
public static void main(String[] args) {
/*
* 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
* 第一个参数 handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
* 第二个参数person1.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
* 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
*/
ClassLoader cl = Thread.currentThread().getContextClassLoader();
Exam o = (Exam) Proxy.newProxyInstance(
cl,//类加载器
new Class[]{Exam.class},//获取被代理对象的所有接口
new JdkProxy(new Student())//InvocationHandler对象
);
o.exam();//代理后的行为
// 另一种写法
// Exam o1 = (Exam) Proxy.newProxyInstance(
// Thread.currentThread().getContextClassLoader(),
// Student.class.getInterfaces(),
// new JdkProxy(new Student())
// );
// o1.exam();
}
}
运行结果：
考试的时候，吃颗糖压压惊，没有人知道，这次不是本人来考试的
奋笔疾书，完成考试啦
使用内置的Proxy实现动态代理有一个问题：被代理的类必须实现接口，未实现接口则没办法完成动态代理。
2、动态代理，使用cglib实现
还是拿上面的例子来说吧。
这次我们不写接口了。不过 我们要实现MethodInterceptor接口，并实现方法
去maven 中心仓库 找到 CGlib 的依赖
Student类
public class Student {
public void exam(){
System.out.println("奋笔疾书，完成考试啦");
}
}
创建一个 CglibProxy 的类 并 实现 MethodInterceptor 接口 ，并实现方法
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy; import java.lang.reflect.Method; public class CglibProxy implements MethodInterceptor { /*
* 参数
* Object 为由CGLib动态生成的代理类实例
* method 为上文中实体类所调用的被代理的方法引用
* objects 为参数值列表
* methodProxy 为生成的代理类对方法的代理引用
* return 从代理实例的方法调用返回的值
* */
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("考试的时候，唱了一首 我爱洗澡 ，差点被劝退 ");
return methodProxy.invokeSuper(o,objects);
} }
测试：
import net.sf.cglib.proxy.Enhancer;
public class Main {
public static void main(String[] args) {
//增强器，动态代码生成器
Enhancer enhancer = new Enhancer();
//设置 生成类 的 父类
enhancer.setSuperclass(Student.class);
//回调函数
enhancer.setCallback(new CglibProxy());
//动态生成字节码并返回代理对象
Student o = (Student) enhancer.create();
o.exam();
//这里是简化写法
//第一个参数 设置 生成类 的父类 ，第二参数 被代理类的所有接口 ，回调函数
Student student = (Student) new Enhancer().create(Student.class, null, new CglibProxy());
student.exam();
}
}
运行结果：
考试的时候，唱了一首 我爱洗澡 ，差点被劝退
奋笔疾书，完成考试啦
这种代理的缺点：被代理的类必须不是final类。
小结：
使用cglib可以实现动态代理，即使被代理的类没有实现接口，但被代理的类必须不是final类。