代理模式你了解多少
代理模式
个人主页：不会写代码的满满
个人简介：大家好，我是满满，一个想要与大家共同进步的男人
目前状况：开学即将大三，目标就是半年内找到一份实习工作
欢迎大家：这里是CSDN，我总结知识的地方，欢迎来到我的博客，我亲爱的大佬
正文开始 ----------
代理模式
代理模式：目标对象不可访问，通过代理对象增强功能访问。
生活中：
房东 ====> 目标对象
房屋中介 ====> 代理对象
我们大家 ====> 客户端对象
服务生产商 ====> 目标对象
门店（旗舰店） ====> 目标对象
什么是代理模式 ？
代理模式是指，为其他对象提供一种代理以控制对这个对象的访问。在某些情况下， 一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户和目标对象之间起到中介的作用。
换句话说，使用代理对象，是为了在不修改目标对象的基础上，增强主业务逻辑。客户类真正的想要访问的对象是目标对象，但客户类真正可以访问的对象是代理对象。客户类对目标对象的访问是通过访问代理对象来实现的。当然，代理类与目标类要实现同一个接口。
例如： 有 A，B，C 三个类， A 原来可以调用 C 类的方法， 现在因为某种原因 C 类不允许A 类调用其方法，但 B 类可以调用 C 类的方法。A 类通过 B 类调用 C 类的方法。这里 B 是 C的代理。 A 通过代理 B 访问 C。
原来的访问关系：
Window 系统的快捷方式也是一种代理模式。快捷方式代理的是真实的程序，双击快捷方式是启动它代表的程序。
代理模式的作用
- 控制目标对象的访问
- 增强功能
代理模式的分类
静态代理动态代理又分为JDK动态代理和CGlib动态代理
代理模式的实现方式
- 静态代理实现
- 动态代理的实现又分为JDK代理和CGlib动态代理。
静态代理
静态代理的特点
静态代理要求目标对象和代理对象实现同一个业务接口。代理对象中的核心功能是由目标对象来完成，代理对象负责增强功能。
静态代理的实现
需求：
有个明星(目标对象)很大腕，档期很满，我们想约这个明星来学校表演。我们只能通过他的助理来约他，助理就是（代理对象）。具体的时间、地点、场合、费用都只能跟助理来谈。助理完全负责明星的所有行程。并且安排明星来表演。
实现步骤
1. 定义业务接口
定义业务接口 Service（目标对象和代理对象都要实现的业务接口）。
package com.manman.service;
/**
* @author 满满
* createDate 2022/6/18 21:46
* description : 测试绑定业务功能的接口
*/
public interface Service {
/**
* 定义一个唱歌的方法
*/
void sing();
}
2. 定义目标实现类对象
package com.manman.service.impl;
import com.manman.service.Service;
/**
* @author 满满
* createDate 2022/6/18 21:45
* description :
*/
public class SuperStarLiu implements Service {
@Override
public void sing() {
System.out.println("我是刘德华,我正在唱歌........ " );
}
}
3. 定义代理实现类功能
package com.manman;
import com.manman.service.Service;
import com.manman.service.impl.SuperStarLiu;
/**
* @author 满满
* createDate 2022/6/18 21:46
* description :
*/
public class Agent implements Service {
@Override
public void sing() {
System.out.println("我是华仔的助理,正在预定时间.....");
System.out.println("我是华仔的助理,正在预定场地.....");
// 创建刘德华对象
SuperStarLiu liu = new SuperStarLiu();
liu.sing();
System.out.println("我是华仔的助理,正在结算费用......");
}
}
4. 测试类
package com.manman.test;
import com.manman.Agent;
import com.manman.service.Service;
import org.junit.Test;
/**
* @author 满满
* createDate 2022/6/18 21:44
* description :
*/
public class MyTest {
@Test
/*
* 用于测试 : 静态代理
*/
public void test01() {
Service agent = new Agent();
agent.sing();
}
}
5. 运行结果
6. 代理功能改造
现在的代理类只能代理一个目标对象,不够灵活.如果需要代理多个目标对象,是可以使用面向接口编程.
面向接口编程的要点:
A. 类中的成员变量设计为接口
B. 方法的参数设计为接口
C. 方法的返回值设计为接口
D. 调用时接口指向实现类
切记:上了接口就是上灵活.
改造后Agent
package com.manman;
import com.manman.service.Service;
import com.manman.service.impl.SuperStarLiu;
/**
* @author 满满
* createDate 2022/6/18 21:46
* description :
*/
public class Agent implements Service {
// 将成员设置为接口类型
public Service target;
// 提供有参构造方法
public Agent(Service target) {
this.target = target;
}
@Override
public void sing() {
System.out.println("正在预定时间.....");
System.out.println("正在预定场地.....");
/* 创建刘德华对象
SuperStarLiu liu = new SuperStarLiu();
liu.sing();*/
target.sing();
System.out.println("正在结算费用......");
}
}
静态代理的缺陷
代理复杂，难于管理
代理类和目标类实现了相同的接口，每个代理都需要实现目标的方法，这样就出现了大量的代码重复。如果接口增加了一个新的业务方法，除了所有目标类要实现这个方法以外，所有的代理类也需要实现这个方法。增加了代码维护的复杂度。
代理类依赖于目标类，代理类过多
代理类只服务于一种类型的目标类，如果要服务多个类型。势必要为每一种目标类都进行代理， 静态代理在程序规模稍大时就无法胜任了，代理类数量过多
动态代理
动态代理是指代理类对象在程序运行时由 JVM 根据反射机制动态生成的。动态代理不需要定义代理类的.java 源文件。动态代理其实就是 jdk 运行期间，动态创建 class 字节码并加载到 JVM。动态代理的实现方式常用的有两种：使用
JDK 动态代理和CGLIB 动态代理。
代理运行对象在程序运行的过程中动态的在内存进行构建，可以灵活的进行业务功能的切换。
JDK动态代理
JDK动态代理是基于 Java 的反射机制实现的。使用 JDK中接口和类实现代理对象的动态创建。JDK的动态代理要求目标对象必须实现接口，而代理对象不必实现业务接口，这是 java 设计上的要求。从 jdk1.3 以来，java 语言通过 java.lang.reflect 包提供三个类和接口支持代理模式，它们分别Proxy, Method和 InvocationHandler。
- 目标对象必须实现业务接口
- JDK代理代理对象不需要实现业务接口
- 动态代理的对象在程序运行中不存在
- 动态代理灵活的进行业务功能的切换
Proxy类
通过JDK的java.lang.reflect.Proxy类实现动态代理，会使用其静态方法newProxyInstance()，依据目标对象、业务接口及调用处理器三者，自动生成一个动态代理对象。
public static newProxyInstance ( ClassLoader loader, Class<?>[] interfaces,
InvocationHandler handler)
loader：目标类的类加载器，通过目标对象的反射可获取
interfaces：目标类实现的接口数组，通过目标对象的反射可获取
handler：调用处理器。
Method类
invoke()方法的第二个参数为 Method 类对象，该类有一个方法也叫 invoke()，可以调用目标方法。这两个 invoke()方法，虽然同名，但无关。
- 反射用的类，用来进行目标的对象的方法的反射调用
public Object invoke ( Object obj, Object... args)
obj：表示目标对象
args：表示目标方法参数，就是其上一层 invoke 方法的第三个参数
该方法的作用是：调用执行 obj 对象所属类的方法，这个方法由其调用者 Method 对象确定。在代码中，一般的写法为
method.invoke(target, args);
其中，method 为上一层 invoke 方法的第二个参数。这样，即可调用了目标类的目标方法。
IocationHandler接口
InvocationHandler 接口叫做调用处理器，负责完成调用目标方法，并增强功能。通过代理对象执行目标接口中的方法 ， 会把方法的调用分派给调用处理器(InvocationHandler)的实现类，执行实现类中的 invoke()方法，我们需要把功能代理写在 invoke（）方法中 。此接口中只有一个方法。
在 invoke 方法中可以截取对目标方法的调用。在这里进行功能增强。Java 的动态代理是建立在反射机制之上的。实现了 InvocationHandler 接口的类用于加强目标类的主业务逻辑。这个接口中有一个方法 invoke()，具体加强的代码逻辑就是定义在该方法中的。通过代理对象执行接口中的方法时，会自动调用 invoke()方法。
invoke()方法的介绍如下：
public Object invoke ( Object proxy, Method method, Object[] args)
proxy：代表生成的代理对象
method：代表目标方法
args：代表目标方法的参数
第一个参数 proxy 是 jdk 在运行时赋值的，在方法中直接使用，第二个参数后面介绍，
第三个参数是方法执行的参数， 这三个参数都是 jdk 运行时赋值的，无需程序员给出。
实现步骤
-
代理对象不需要实现接口。
-
代理对象的生成是利用JDK中的proxy类，动态的在内存中构建代理对象。
-
代码实现接口
-
ProxyFactory.java代理实例生成工厂
package com.manman.proxy; import com.manman.service.Service; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /** * @author 满满 * createDate 2022/6/19 11:34 * description : 代理工厂演示 */ public class ProxyFactory { //任何的代理对象，都要清楚目标对象，在此得设置一个目标对象， private Service superStar; //传入目标对象 public ProxyFactory(Service superStar){ this.superStar=superStar; } //给目标对象生成代理实例 public Object getProxyInstance(){ Object o = Proxy.newProxyInstance( //指定当前目标对象，使用类加载器获得 superStar.getClass().getClassLoader(), //获得目标对象实现的所有接口 superStar.getClass().getInterfaces(), //处理代理实例上的方法并返回调用结果 new InvocationHandler() { @Override public Object invoke( //代理对象的实例 Object proxy, //代理的目标对象的实现方法 Method method, //代理的目标对象实现方法的参数 Object[] args) throws Throwable { System.out.println("预定场地.........."); System.out.println("预定时间.........."); //目标对象执行自己的方法 Object returnValue = method.invoke(superStar, args); System.out.println("结帐走人........."); return returnValue; } }); return o; } } -
测试类
package com.manman.test; import com.manman.proxy.ProxyFactory; import com.manman.service.Service; import com.manman.service.impl.SuperStarZhou; import org.junit.Test; /** * @author 满满 * createDate 2022/6/19 11:33 * description : JDK动态代理 */ public class MyTest { @Test /* * 用于测试 : JDK动态代理 */ public void test01() { // 创建代理工厂对象 ProxyFactory factory = new ProxyFactory(new SuperStarZhou()); Service agent = (Service) factory.getProxyInstance(); agent.sing(); } } -
结果截图
注意：JDK动态代理中，代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用JDK动态代理。
CGlib（Code Generation Library）动态代理
- 又称为子类通过动态的的在内存中构建子类对象，重写父类方法进行代理功能的增强。
想要功能扩展，但目标对象没有实现接口，怎样功能扩展？
解决方案：子类的方式
Class subclass extends UserDao{}
以子类的方式实现(cglib代理)，在内存中构建一个子类对象从而实现对目标对象功能的扩展。
CGlib动态代理的特点
- JDK动态代理有一个限制，就是使用动态代理的目标对象必须实现一个或多个接口。如果想代理没有实现类的接口，就可以使用CGLIB进行代理。
- CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception。
CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。
CGLIB的实现步骤
- 需要spring-core-5.2.5.jar依赖即可。
- 引入功能包后，就可以在内存中动态构建子类
- 被代理的类不能为final， 否则报错。
- 目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法。
- 代码实现结构
ProxyFactory.java
public class ProxyFactory implements MethodInterceptor {
//目标对象
private Object target;
//传入目标对象
public ProxyFactory(Object target){
this.target=target;
}
//Cglib采用底层的字节码技术，在子类中采用方法拦截的技术，拦截父类指定方法的调用，并顺势植入代理功能的代码
@Override
public Object intercept(Object obj, Method method, Object[] arg2, MethodProxy proxy) throws Throwable {
//代理对象的功能
System.out.println("预定场地............");
//调用目标对象的方法
Object returnValue=method.invoke(target, arg2);
//代理对象的功能
System.out.println("结帐走人............");
return returnValue;
}
//生成代理对象
public Object getProxyInstance(){
//1.使用工具类
Enhancer en=new Enhancer();
//2.设置父类
en.setSuperclass(target.getClass());
//3.设置回调函数
en.setCallback(this);
//4.创建子类（代理）对象
return en.create();
}}
测试类
@Test
public void testCglibProxy(){
SuperStar superStar=new SuperStar();
System.out.println(superStar.getClass());
SuperStar proxy=(SuperStar) new ProxyFactory(superStar).getProxyInstance();
System.out.println(proxy.getClass());
proxy.sing();
}
面向接口编程
面向接口编程的四大注意事项：
- 类中的成员方法设置为接口
- 方法的参数设置为接口
- 方法的返回值设置为接口
- 使用时接口指向实现类
总结
