1.定义
代理模式是指为某个对象提供一个代理对象，来起到间接访问的一个目的，属于结构型设计模式，在某种情况下，一个对象不适合或者不能直接引用目标对象，代理对象在客户端和目标对象中间起到了一个中介的作用
2.静态代理
静态代理就是硬编码，在编码的过程中就已经知道要代理的对象，最常见的就是controller、service、dao 就是静态代理的一种实现。
/**
* create by yufeng on 2021/7/4 14:00
*/
public interface IPerson {
void findLove();
}
/**
* create by yufeng on 2021/7/4 14:00
*/
public class ZhangSan implements IPerson {
public void findLove() {
System.out.println("儿子要求：肤白貌美大长腿");
}
}
/**
* create by yufeng on 2021/7/4 14:00
*/
public class ZhangLaosan implements IPerson {
private ZhangSan zhangsan;
public ZhangLaosan(ZhangSan zhangsan) {
this.zhangsan = zhangsan;
}
public void findLove() {
System.out.println("张老三开始物色");
zhangsan.findLove();
System.out.println("开始交往");
}
}
/**
* create by yufeng on 2021/7/4 14:00
*/
public class Test {
public static void main(String[] args) {
ZhangLaosan zhangLaosan = new ZhangLaosan(new ZhangSan());
zhangLaosan.findLove();
}
}
执行结果：
张老三开始物色
儿子要求：肤白貌美大长腿
开始交往
3.动态代理
3.1jdk动态代理
静态代理的弊端，就是静态代理只能手动增加，如果代理类增加了新的方法，代理类也要同步增加，违背了开闭原则
动态代理在代码允许的过程中动态生成代码的形式，取消了对被代理类的扩展限制，遵循开闭原则。
/**
* create by yufeng on 2021/7/4 14:33
*/
public interface IPerson {
void findLove();
void buyInsure();
}
/**
* create by yufeng on 2021/7/4 14:33
*/
public class Zhangsan implements IPerson {
public void findLove() {
System.out.println("张三要求：肤白貌美大长腿");
}
public void buyInsure() {
System.out.println("30万");
}
}
/**
* create by yufeng on 2021/7/4 14:33
*/
public class ZhaoLiu implements IPerson {
public void findLove() {
System.out.println("赵六要求：有车有房学历高");
}
public void buyInsure() {
}
}
/**
* create by yufeng on 2021/7/4 14:33
*/
public class JdkMeipo implements InvocationHandler {
private IPerson target;
public IPerson getInstance(IPerson target){
this.target = target;
Class<?> clazz = target.getClass();
return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object result = method.invoke(this.target,args);
after();
return result;
}
private void after() {
System.out.println("双方同意，开始交往");
}
private void before() {
System.out.println("我是媒婆，已经收集到你的需求，开始物色");
}
}
/**
* create by yufeng on 2021/7/4 14:33
*/
public class Test {
public static void main(String[] args) {
JdkMeipo jdkMeipo = new JdkMeipo();
IPerson zhangsan = jdkMeipo.getInstance(new Zhangsan());
zhangsan.findLove();
zhangsan.buyInsure();
IPerson zhaoliu = jdkMeipo.getInstance(new ZhaoLiu());
zhaoliu.findLove();
}
}
执行结果：
我是媒婆，已经收集到你的需求，开始物色
张三要求：肤白貌美大长腿
双方同意，开始交往
我是媒婆，已经收集到你的需求，开始物色
30万
双方同意，开始交往
我是媒婆，已经收集到你的需求，开始物色
赵六要求：有车有房学历高
双方同意，开始交往
动态生成代理类，后面如有王五要相亲，是不需要改动代理类的。
3.2cglib 动态代理
/**
* create by yufeng on 2021/7/4 14:33
*/
public class Customer {
public void findLove(){
System.out.println("儿子要求：肤白貌美大长腿");
}
}
/**
* create by yufeng on 2021/7/4 15:33
*/
public class CGlibMeipo implements MethodInterceptor {
public Object getInstance(Class<?> clazz) throws Exception{
//相当于Proxy，代理的工具类
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before();
Object obj = methodProxy.invokeSuper(o,objects);
after();
return obj;
}
private void before(){
System.out.println("我是媒婆，我要给你找对象，现在已经确认你的需求");
System.out.println("开始物色");
}
private void after(){
System.out.println("OK的话，准备办事");
}
}
/**
* create by yufeng on 2021/7/4 14:33
*/
public class CglibTest {
public static void main(String[] args) {
try {
Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);
System.out.println(obj);
obj.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
}
3.3两种动态代理的区别
JDK是采用读取接口的信息；CGLib覆盖父类方法。目的都是动态生成一个新的类，去实现增加代码逻辑的功能。
JDK对应目标类来说必须实现某个接口；CGLib可以代理任意一个普通的类，没有特殊要求。
CGLib生成的代理逻辑更复杂，效率调用效率更高，生成一个抱哈所有逻辑的FastClass，不需要反射
JDK Proxy生成代理的逻辑简单，执行效率相对要低，每次都要反射动态调用
但是CGLib 有需要注意的地方，CGLib不能代理final的方法
