Spring5框架深入学习理解使用初识代理模式
「这是我参与2022首次更文挑战的第25天，活动详情查看：2022首次更文挑战」。
关于作者
- 作者介绍
🍓 博客主页：作者主页
🍓 简介：JAVA领域优质创作者🥇、一名在校大三学生🎓、在校期间参加各种省赛、国赛，斩获一系列荣誉🏆、阿里云专家博主、51CTO专家博主
🍓 关注我：关注我学习资料、文档下载统统都有，每日定时更新文章，励志做一名JAVA资深程序猿👨💻
12、代理模式
初次体验设计模式，可能在上次的AOP中有些地方大家可能不太理解，我们先讲解一下AOP设计的思想及底层原理。之后在aop的理解会相对容易一些。
为什么要学习代理模式，因为AOP的底层机制就是动态代理！
代理模式：
- 静态代理
- 动态代理
UML图
12.1 静态代理
静态代理角色分析
ISubject(抽象角色)：使用接口和抽象类来实现。
RealSubject(真实角色)：被代理的角色。
proxy(代理)：代理真实的角色，在代理真实角色之后，会有一些附属的操作。
Client(用户)：使用代理来选择自己的需求。
代码实现
ISubject.java 抽象角色
package com.spring.demo01;
/**
* @ProjectName: Spring5study
* @Package: com.spring.demo01
* @ClassName: ISubject
* @Author: 张晟睿
* @Date: 2022/2/12 14:18
* @Version: 1.0
*/
//抽象角色：代理商
public interface ISubject {
public void shop();
}
Merchant.java 真实角色
package com.spring.demo01;
/**
* @ProjectName: Spring5study
* @Package: com.spring.demo01
* @ClassName: Merchant
* @Author: 张晟睿
* @Date: 2022/2/12 14:20
* @Version: 1.0
*/
//商户 真实角色
public class Merchant implements ISubject{
@Override
public void shop() {
System.out.println("商户将商品发出代理！！！");
}
}
Proxy.java 代理角色
package com.spring.demo01;
/**
* @ProjectName: Spring5study
* @Package: com.spring.demo01
* @ClassName: Proxy
* @Author: 张晟睿
* @Date: 2022/2/12 14:21
* @Version: 1.0
*/
//淘宝代理 代理角色
public class Proxy implements ISubject{
private Merchant merchant;
public Proxy(Merchant merchant) {
this.merchant = merchant;
}
//代理后的商品
@Override
public void shop() {
merchant.shop();
buy();
Insurance_service();
}
//客户购买商品
public void buy(){
System.out.println("用户购买商品");
}
//中介商赚差价
public void Insurance_service(){
System.out.println("代理给商品添加保险等其他服务");
}
}
Client.java 客户
package com.spring.demo01;
/**
* @ProjectName: Spring5study
* @Package: com.spring.demo01
* @ClassName: Client
* @Author: 张晟睿
* @Date: 2022/2/12 14:24
* @Version: 1.0
*/
//客户类，一般客户都会去找代理购买商品！
public class Client {
public static void main(String[] args) {
//客户买商品
Merchant merchant = new Merchant();
//商家找代理中介
Proxy proxy = new Proxy(merchant);
//客户直接找中介代理
proxy.shop();
}
}
分析
在这个过程中，客户直接接触的就是中介代理商，就如同现实生活中的样子，我们无法直接接触到商家，但是依然能够通过代理买到商户的商品，这就是所谓的代理模式，程序源自于生活，所以学编程的人，一般能够更加抽象的看待生活中发生的事情。
小结
- 以后如果是自己编写的接口如果想要取得接口的 实例化对象，第一反应写工厂类
- 简单工厂和工厂方法模式的不同在于前者生成产生产品的行为封装在一个方法中，根据参数的类型进行实例化，同时不存在抽象接口。而后者则增加了抽象工厂，通过实现不同的工厂方法来创建不同的产品，一个方法通常对应一个产品，这种方式相较于前者扩展性更高，在需求增加时完全符合开闭原则和依赖倒置原则
好处
- 可以使得我们的真实角色更加纯粹，不再去关注一些公共的事情 。
- 公共的业务由代理来完成 . 实现了业务的分工。
- 公共业务发生扩展时变得更加集中和方便。
缺点
- 类多了 , 多了代理类 , 工作量变大了，开发效率降低。
我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !
12.2 静态代理再理解
练习步骤：
-
创建一个抽象角色，比如咋们平时做的用户业务，抽象起来就是增删改查！
package com.spring.demo02; /** * @ProjectName: Spring5study * @Package: com.spring.demo02 * @ClassName: UserService * @Author: 张晟睿 * @Date: 2022/2/12 14:42 * @Version: 1.0 */ //抽象角色：增删改查业务 public interface UserService { void add(); void delete(); void update(); void query(); } -
我们需要一个真实对象来完成这些增删改查操作
package com.spring.demo02; /** * @ProjectName: Spring5study * @Package: com.spring.demo02 * @ClassName: UserServiceImpl * @Author: 张晟睿 * @Date: 2022/2/12 14:42 * @Version: 1.0 */ public class UserServiceImpl implements UserService{ @Override public void add() { System.out.println("增加了一个用户"); } @Override public void delete() { System.out.println("删除了一个用户"); } @Override public void update() { System.out.println("更新了一个用户"); } @Override public void query() { System.out.println("查询了一个用户"); } } -
需求来了，现在我们需要增加一个日志功能，怎么实现！
- 思路1 ：在实现类上增加代码 【麻烦！】
- 思路2：使用代理来做，能够不改变原来的业务情况下，实现此功能就是最好的了！
-
设置一个代理类来处理日志！ 代理角色
package com.spring.demo02; /** * @ProjectName: Spring5study * @Package: com.spring.demo02 * @ClassName: UserServiceProxy * @Author: 张晟睿 * @Date: 2022/2/12 14:43 * @Version: 1.0 */ public class UserServiceProxy implements UserService{ private UserServiceImpl userService; public void setUserService(UserServiceImpl userService) { this.userService = userService; } public void add() { log("add"); userService.add(); } public void delete() { log("delete"); userService.delete(); } public void update() { log("update"); userService.update(); } public void query() { log("query"); userService.query(); } public void log(String msg){ System.out.println("执行了"+msg+"方法"); } } -
测试访问类
package com.spring.demo02; /** * @ProjectName: Spring5study * @Package: com.spring.demo02 * @ClassName: Client * @Author: 张晟睿 * @Date: 2022/2/12 14:44 * @Version: 1.0 */ public class Client { public static void main(String[] args) { //真实业务 UserServiceImpl userService = new UserServiceImpl(); //代理类 UserServiceProxy proxy = new UserServiceProxy(); //使用代理类实现日志功能！ proxy.setUserService(userService); proxy.query(); } }
OK，到了现在代理模式大家应该都没有什么问题了，重点大家需要理解其中的思想；
我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想。
【聊聊AOP：纵向开发，横向开发】
12.3 动态代理
- 动态代理的角色和静态代理的一样
- 动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的。
- 动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
- 基于接口的动态代理----JDK动态代理
- 基于类的动态代理--cglib
- 现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
- 我们这里使用JDK的原生代码来实现，其余的道理都是一样的！
JDK的动态代理需要了解两个类核心 : InvocationHandler 和 Proxy ， 打开JDK帮助文档看看
【InvocationHandler：调用处理程序】
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。 方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。 原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean
Object invoke(Object proxy, 方法 method, Object[] args)；
【Proxy : 代理】
//生成代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
rent.getClass().getInterfaces(),this);
}
代码实现
抽象角色和真实角色和之前的一样！
ISubject.java
package com.spring.demo03;
/**
* @ProjectName: Spring5study
* @Package: com.spring.demo03
* @ClassName: ISubject
* @Author: 张晟睿
* @Date: 2022/2/12 15:52
* @Version: 1.0
*/
//抽象角色：代理商
public interface ISubject {
public void shop();
}
Merchant.java
package com.spring.demo03;
/**
* @ProjectName: Spring5study
* @Package: com.spring.demo03
* @ClassName: Merchant
* @Author: 张晟睿
* @Date: 2022/2/12 15:54
* @Version: 1.0
*/
//商户 真实角色
public class Merchant implements ISubject {
@Override
public void shop() {
System.out.println("商户将商品发出代理！！！");
}
}
ProxyInvocationHandler.java
package com.spring.demo03;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @ProjectName: Spring5study
* @Package: com.spring.demo03
* @ClassName: ProxyInvocationHandler
* @Author: 张晟睿
* @Date: 2022/2/12 15:57
* @Version: 1.0
*/
public class ProxyInvocationHandler implements InvocationHandler {
private ISubject iSubject;
public void setiSubject(ISubject iSubject) {
this.iSubject = iSubject;
}
//生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
iSubject.getClass().getInterfaces(),this);
}
// proxy : 代理类 method : 代理类的调用处理程序的方法对象.
// 处理代理实例上的方法调用并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//核心：本质利用反射实现！
Object result = method.invoke(iSubject, args);
return result;
}
}
Client.java
package com.spring.demo03;
/**
* @ProjectName: Spring5study
* @Package: com.spring.demo03
* @ClassName: Client
* @Author: 张晟睿
* @Date: 2022/2/12 16:01
* @Version: 1.0
*/
public class Client {
public static void main(String[] args) throws ClassCastException{
//真实角色
Merchant merchant = new Merchant();
//代理实例的调用处理程序
ProxyInvocationHandler invocationHandler = new ProxyInvocationHandler();
//将真实角色放置进去！
invocationHandler.setiSubject(merchant);
//动态生成对应的代理类！
ISubject proxy = (ISubject) invocationHandler.getProxy();
proxy.shop();
}
}
核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口
12.4 深化理解
使用动态代理实现代理我们后面写的UserService！
可以编写一个通用的动态代理实现的类！所有的代理对象设置为Object即可！
ProxyInvocationHandler模板
package com.spring.demo03;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @ProjectName: Spring5study
* @Package: com.spring.demo03
* @ClassName: ProxyInvocationHandler
* @Author: 张晟睿
* @Date: 2022/2/12 15:57
* @Version: 1.0
*/
public class ProxyInvocationHandler implements InvocationHandler {
private Object target;
public void setiSubject(Object target) {
this.target = target;
}
//生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}
// proxy : 代理类 method : 代理类的调用处理程序的方法对象.
// 处理代理实例上的方法调用并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log(method.getName());
//核心：本质利用反射实现！
Object result = method.invoke(target, args);
return result;
}
public void log(String methodName){
System.out.println("执行了"+methodName+"方法");
}
}
测试
package com.spring.demo04;
import com.spring.demo02.UserService;
import com.spring.demo02.UserServiceImpl;
/**
* @ProjectName: Spring5study
* @Package: com.spring.demo04
* @ClassName: Test
* @Author: 张晟睿
* @Date: 2022/2/12 16:25
* @Version: 1.0
*/
public class Test {
public static void main(String[] args) {
//真实对象
UserServiceImpl userService = new UserServiceImpl();
//代理对象的调用处理程序
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//设置要代理的对象
pih.setTarget(userService);
//动态生成代理类！
UserService proxy = (UserService)pih.getProxy();
proxy.delete();
}
}
好处：
静态代理有的它都有，静态代理没有的，它也有！
- 可以使得我们的真实角色更加纯粹，不再去关注一些公共的事情。
- 公共的业务由代理来完成，实现了业务的分工。
- 公共业务发生扩展时变得更加集中和方便。
- 一个动态代理， 一般代理某一类业务 。
- 一个动态代理可以代理多个类，代理的是接口！
后语
厂长写博客目的初衷很简单，希望大家在学习的过程中少走弯路，多学一些东西，对自己有帮助的留下你的赞赞👍或者关注➕都是对我最大的支持，你的关注和点赞给厂长每天更文的动力。
对文章其中一部分不理解，都可以评论区回复我，我们来一起讨论，共同学习，一起进步！
