1.jdk动态代理：
1）首先，定义需要被代理的接口，接口中包含需要被代理的方法
package com.gupaoedu.vip.proxy.jdk;
public interface Person {
//寻找真爱、相亲
void findLove();
}
2）定义被代理的类，也就是目标类
package com.gupaoedu.vip.proxy.jdk;
//小星星、单身
public class XiaoXingxing implements Person{
@Override
public void findLove() {
// System.out.println("我叫" + this.name + ",性别:" + this.sex + "我找对象的要求是:");
System.out.println("高富帅");
System.out.println("有房有车的");
System.out.println("身高要求180cm以上，体重70kg");
}
}
3）最后定义第三方类，需要实现InvocationHandler 接口：
能够从中拿到代理类的方法，与执行代理类的方法。
package com.gupaoedu.vip.proxy.jdk;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//媒婆
public class Meipo implements InvocationHandler {
private Person target; //被代理对象的引用作为一个成员变量保存下来了
//获取被代理人的个人资料
public Object getInstance(Person target) throws Exception{
this.target = target;
Class clazz = target.getClass();
System.out.println("被代理对象的class是:"+clazz);
return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("我是媒婆：" + "得给你找个异性才行");
System.out.println("开始进行海选...");
System.out.println("------------");
//调用的时候
method.invoke(this.target, args);
System.out.println("------------");
System.out.println("如果合适的话，就准备办事");
return null;
}
}
其中，代理类invoke方法中，method即为接口中定义的被代理的方法。
4）测试类
package com.gupaoedu.vip.proxy.jdk;
import java.io.FileOutputStream;
import com.gupaoedu.vip.custom.GPMeipo;
import sun.misc.ProxyGenerator;
public class TestFindLove {
public static void main(String[] args) {
try {
//
// Person obj = (Person)new Meipo().getInstance(new XiaoXingxing());
// System.out.println(obj.getClass());
// obj.findLove();
//原理：
//1.拿到被代理对象的引用，然后获取它的接口
//2.JDK代理重新生成一个类，同时实现我们给的代理对象所实现的接口
//3.把被代理对象的引用也拿到了
//4.重新动态生成一个class字节码
//5.然后编译
//获取字节码内容
// byte[] data = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Person.class});
// FileOutputStream os = new FileOutputStream("E:/GP_WORKSPACE/$Proxy0.class");
// os.write(data);
// os.close();
//是什么?
//为什么？
//怎么做？
Person obj = (Person)new GPMeipo().getInstance(new XiaoXingxing());
System.out.println(obj.getClass());
obj.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
}
2.cglib动态代理
1）首先，定义被代理的类，也就是目标类，它是一个普通的类，毫无防备。没想到被代理。
package com.gupaoedu.vip.proxy.cglib;
public class YunZhongYu {
public void findLove(){
System.out.println("肤白貌美大长腿");
}
}
2）定义一个第三方的类，需要实现MethodInterceptor接口，在该类中，定义获取代理类的方法，执行代理方法。
package com.gupaoedu.vip.proxy.cglib;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class GPMeipo implements MethodInterceptor{
//疑问？
//好像并没有持有被代理对象的引用
public Object getInstance(Class clazz) throws Exception{
Enhancer enhancer = new Enhancer();
//把父类设置为谁？
//这一步就是告诉cglib，生成的子类需要继承哪个类
enhancer.setSuperclass(clazz);
//设置回调
enhancer.setCallback(this);
//第一步、生成源代码
//第二步、编译成class文件
//第三步、加载到JVM中，并返回被代理对象
return enhancer.create();
}
//同样是做了字节码重组这样一件事情
//对于使用API的用户来说，是无感知
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("我是GP媒婆：" + "得给你找个异性才行");
System.out.println("开始进行海选...");
System.out.println("------------");
//这个obj的引用是由CGLib给我们new出来的
//cglib new出来以后的对象，是被代理对象的子类（继承了我们自己写的那个类）
//OOP, 在new子类之前，实际上默认先调用了我们super()方法的，
//new了子类的同时，必须先new出来父类，这就相当于是间接的持有了我们父类的引用
//子类重写了父类的所有的方法
//我们改变子类对象的某些属性，是可以间接的操作父类的属性的
proxy.invokeSuper(obj, args);
System.out.println("------------");
System.out.println("如果合适的话，就准备办事");
return null;
}
}
3）测试类
package com.gupaoedu.vip.proxy.cglib;
public class TestGglibProxy {
public static void main(String[] args) {
//JDK的动态代理是通过接口来进行强制转换的
//生成以后的代理对象，可以强制转换为接口
//CGLib的动态代理是通过生成一个被代理对象的子类，然后重写父类的方法
//生成以后的对象，可以强制转换为被代理对象（也就是用自己写的类）
//子类引用赋值给父类
try {
YunZhongYu obj = (YunZhongYu)new GPMeipo().getInstance(YunZhongYu.class);
obj.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
}