java中的代理

最新推荐文章于 2024-09-16 21:37:07 发布
最新推荐文章于 2024-09-16 21:37:07 发布
阅读量967 收藏 18
点赞数 19
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/isolusion/article/details/141966675
版权

一.什么是代理

代理的本质是一种设计模式

我们以银行转账系统为例：

1.在不适用代理的情况下实现银行转账系统：
在这里插入图片描述
我们需要将验证、转账、事后服务三个方法写成一个大方法，这样一来代码的功能量过大，我们需要通过代理来降低代码功能量。

2.通过代理实现银行转账系统：
在这里插入图片描述

我们不妨只将转账这个核心功能交给银行自己负责，其他功能交给需要的代理商（比如支付宝、微信等）。这样一来，我们既能降低银行自己本身的工作量，也可以使用户通过代理商进行转账的核心功能，用户通过代理商也无法直接接触到核心功能

在这里插入图片描述

二.代理的好处

1.防止用户直接访问核心，带来一些不必要的危机

2.能够对核心方法进行功能的增强

三.代理的应用

代理分为静态代理和动态代理

静态代理是基于jdk实现

动态代理分为基于jdk实现的动态代理和基于CGLB实现的动态代理
在这里插入图片描述

四.静态代理

1.静态代理的运行模式

在这里插入图片描述
在这里插入图片描述
其模式为由核心类（目标类）生成核心对象（目标对象），由代理类生成代理对象，在由代理对象代理核心对象，而核心类和代理类都会实现同一个接口。
接口起到了一个沟通（通知）的作用，即通知代理类所要代理的核心是什么。

2.通过静态代理实现银行转账系统

zhuanzhang接口：

public interface ZhuanZhang {
    //定义核心方法（转账）
    public void zhuanzhang(String A,String B,Double money);
}

YinHang类：

public class YinHang implements ZhuanZhang{
    public void zhuanzhang(String A,String B,Double money){
        System.out.println(A+"给"+B+"转了"+money+"元");
    }
}

ZhiFuBao类：


public class ZhiFuBao implements ZhuanZhang{
    //定义被代理的类---核心类
    private YinHang yinHang=new YinHang();
 
    private void yanzheng(String A,String B,Double money){
        System.out.println("对A进行了身份验证");
        System.out.println("对B进行了身份验证");
        System.out.println("对转账金额进行了验证");
    }
 
    public void zhuanzhang(String A,String B,Double money){
        yanzheng(A,B,money);
        yinHang.zhuanzhang(A,B,money);
        fuwu();
    }
    private void fuwu(){
        System.out.println("转账完成后进行了服务");
    }
}

Test类：

public class Test {
    public static void main(String[] args) {
        ZhiFuBao zhiFuBao=new ZhiFuBao();
        zhiFuBao.zhuanzhang("张三","李四",100.0);
    }
}

结果如下：
在这里插入图片描述

执行流程如下：
在这里插入图片描述
main()方法入栈，创建zhifubao对象，其中包括转账的方法、验证和服务方法。还会创建yinhang对象。该对象中也有转账方法。首先是zhifubao的转账方法入栈，然后调用yinhang的转账方法在这个过程中也完成了业务的增强。

3.静态代理的优点

1.代理对象和目标对象在编译时就确定了关系，所以这种代理方式的安全性较高。
2.代理类可以拥有额外的功能，比如可以在调用目标方法前后增加一些额外的操作。

4.静态代理的缺点

1.用一个代理类代理多个目标类是很难实现的，工作量巨大。
2.一旦目标接口增加方法，代理类也需要修改，不符合开闭原则（对扩展开放，对修改关闭）

举例：

以衣服工厂和鞋子工厂为例：

销售衣服：

Clothes接口：

public interface Clothes {
    public void ByClothes(String size);
}

ClothesFactory类：

public class ClothesFactory implements Clothes{
    @Override
    public void ByClothes(String size) {
        System.out.println("定制一件"+size+"的衣服");
    }
}

XSD类：

public class XSD implements Clothes{
    //代理目标类
    private ClothesFactory clothesFactory=new ClothesFactory();
    private void fuwu(){
        System.out.println("销售店进行一系列服务");
    }
 
    @Override
    public void ByClothes(String size) {
        clothesFactory.ByClothes(size);
        fuwu();
    }
}

Test类：

public class Test {
    public static void main(String[] args) {
        //静态代理
        XSD xsd=new XSD();
        xsd.ByClothes("XXL");
}

继续销售鞋子：

Shoes接口：

public interface Shoes {
    public void ByShoes(String size);
}

ShoesFactory类：

public class ShoesFactory implements Shoes{
    @Override
    public void ByShoes(String size) {
        System.out.println("定制一件"+size+"的鞋子");
    }
}

XSD类：

public class XSD implements Clothes,Shoes{
    //代理目标类
    private ClothesFactory clothesFactory=new ClothesFactory();
    private ShoesFactory shoesFactory=new ShoesFactory();
 
    private void fuwu(){
        System.out.println("销售店进行一系列服务");
    }
 
    @Override
    public void ByClothes(String size) {
        clothesFactory.ByClothes(size);
        fuwu();
    }
 
    @Override
    public void ByShoes(String size) {
        shoesFactory.ByShoes(size);
        fuwu();
    }
}

首先定义一个Clothes接口和一个核心方法ByClothes，在创建一个核心类ClothesFactory并实现核心方法ByClothes，接着创建代理类XSD，实现核心方法，首先第一步代理目标类，创建ClothesFactory对象，然后实现代理类的核心方法，调用核心类对象的核心方法。然后添加一个服务方法。在创建一个Test类测试。

接着定义一个Shoes接口和一个核心方法ByShoes，在创建一个核心类ShoeFactory并实现核心方法Byshoes。接着在代理类继承Shoes接口并 在代理类当中创建ShoeFactory对象，并实现Shoes接口当中的核心方法。

此时我们发现每增加一个目标类，就需要创建新的接口并在代理类当中不断进行扩充。每个代理对象代理的目标太多，模式图如下。

在这里插入图片描述

五.动态代理

动态代理是指在程序运行时动态地创建代理类，无需程序员手动编写代理类的源代码。动态代理主要依靠JDK的反射（Reflection）API来实现。Java中提供了两种动态代理机制：JDK动态代理和CGLIB动态代理。
基于上述问题就引出了动态代理。以上述问题为例（衣服工厂、鞋子工厂）。一个代理类可以实现多个的代理对象，每个代理对象只匹配一个目标对象，即代理类动态的生成一个代理对象去匹配一个目标对象。
在这里插入图片描述
而对于静态代理来说，哪怕如动态代理一样生成一个新的对象，新的对象依旧包含所有目标对象，无法单独匹配一个对象，比如在上述举例中Test类中创建两个XSD对象，其展示图和内存图如下。

在这里插入图片描述
在这里插入图片描述

1.动态代理的实现

DTXSD类：

public class DTXSD{
    private Object object;
    private DTXSD(Object o){
        object=o;
    }
}

Test类：

public class Test{
    public static void main(String[] args){
        ClothesFactory clothesFactory=new ClothesFactory();
        DTXSD dtxsd1=new DTXSD(clothesFactory);
        //也可以写成：DTXSD dtxsd1=new DTXSD(new ClothesFactory());
 
 
        ShoesFactory shoesFactory=new ShoesFactory();
        DTXSD dtxsd2=new DTXSD(shoesFactory);
    }
}

流程图：
在这里插入图片描述

2.动态代理模式的调用

(1)DTXSD类中写一个getProxyInstance()方法

//动态实现相关接口
//object.getClass()：获取目标类的类对象
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces() ,this);
}

(2)在Test类中调用getProxyInstance()方法

调用getProxyInstance()方法就能获取接口，就能知道目标类中的核心方法是什么

DTXSD dtxsd1=new DTXSD(new ClothesFactory());
dtxsd1.getProxyInstance();

(3)调用该核心方法

DTXSD类中实现InvocationHandler接口，实现一个invoke()方法

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return null;
}

三个参数 ：

(1)Object：jdk创建的代理类，无需赋值

(2)Method：目标类中的方法，jdk提供，无需赋值

(3)Object[]：目标类中的方法的参数，jdk提供，无需赋值

调用核心方法:

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        method.invoke(object,args);
        return null;
}

(4)知道核心方法了，用接口去接收

Clothes clothe=(Clothes) dtxsd1.getProxyInstance();

Shoes shoes=(Shoes) dtxsd2.getProxyInstance();

为什么用接口进行接收？
因为在整个DTXSD类中，只是理论的知道了核心方法是什么，想要调用只能通过Clothes接口接收，对里面的ByClothes()方法进行调用，因为在整个流程中没有任何一个地方能显性的调用ByClothes()方法。

如果想要调用，只能通过Clothes接口或者ClothesFactory类，但是通过ClothesFactory类调用不行，原因如下

public class Test {
    public static void main(String[] args) {
        ClothesFactory clothesFactory=new ClothesFactory();
        clothesFactory.ByClothes("XXL");
        System.out.println("--------------------------------");
        DTXSD dtxsd1=new DTXSD(clothesFactory);
        Clothes clothes=(Clothes) dtxsd1.getProxyInstance();
        clothes.ByClothes("XL");
    }
}

在这里插入图片描述
第一种调用方法的流程图：
在这里插入图片描述
第二种调用方法的流程图：
在这里插入图片描述
代码如下：

Clothes接口：

public interface Clothes {
    public void ByClothes(String size);
}

ClothesFactory类：

public class ClothesFactory implements Clothes{
    @Override
    public void ByClothes(String size) {
        System.out.println("定制一件"+size+"的衣服");
    }
}

Shoes接口：

public interface Shoes {
    public void ByShoes(String size);
}

ShoesFactory类：

public class ShoesFactory implements Shoes{
    @Override
    public void ByShoes(String size) {
        System.out.println("定制一件"+size+"的鞋子");
    }
}

DTXSD类：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
//动态代理类
public class DTXSD implements InvocationHandler {
    private Object object;
    public DTXSD(Object o){
        object=o;
    }
 
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces() ,this);
    }
 
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        method.invoke(object,args);
        fuwu();
        return null;
    }
 
    private void fuwu(){
        System.out.println("销售点进行一系列服务");
    }
}

Test类：


public class Test {
    public static void main(String[] args) {
 
        //动态代理
        DTXSD dtxsd1=new DTXSD(new ClothesFactory());
        Clothes clothe=(Clothes) dtxsd1.getProxyInstance();//这里是用接口进行接收
        clothe.ByClothes("XXL");
 
        DTXSD dtxsd2=new DTXSD(new ShoesFactory());
        Shoes shoes=(Shoes) dtxsd2.getProxyInstance();//用接口进行接收
        shoes.ByShoes("42");
    }
}

输出如下：
在这里插入图片描述

isolusion
关注
浅谈Java中的代理模式
yhb500234的博客
11-10 864
Java中的动态代理与静态代理
Java中的代理
swimming_in_IT_的博客
06-15 1329
我们大家都知道微商代理，简单地说就是代替厂家卖商品，厂家“委托”代理为其销售商品。关于微商代理，首先我们从他们那里买东西时通常不知道背后的厂家究竟是谁，也就是说，“委托者”对我们来说是不可见的;其次，微商代理主要以朋友圈的人为目标客户，这就相当于为厂家做了一次对客户群体的“过滤”。我们把微商代理和厂家进一步抽象，前者可抽象为代理类，后者可抽象为委托类(被代理类)。通过使用代理，通常有两个优点，并且能够分别与我们提到的微商代理的两个特点对应起来
Java 代理
小熊的学习记录
03-01 2302
Java的动态代理是基于接口的，它要求目标类必须实现一个或多个接口，而CGLib是基于类的，它不要求目标类实现任何接口。Java的动态代理是通过反射机制来创建代理对象和调用目标方法的，而CGLib是通过字节码生成技术来创建代理对象和调用目标方法的。Java的动态代理会生成一个实现了目标类所有接口的新类作为代理类，而CGLib会生成一个继承了目标类的子类作为代理类。
Java代理模式
qq_52519008的博客
09-30 2786
首先, 定义接口和接口的实现类, 然后定义接口的代理对象, 将接口的实例注入到代理对象中, 然后通过代理对象去调用真正的实现类，实现过程非常简单也比较容易理解, 静态代理的代理关系在编译期间就已经确定了的。首先通过 newProxyInstance 方法获取代理类的实例, 之后就可以通过这个代理类的实例调用代理类的方法，对代理类的方法调用都会调用中间类 (实现了 invocationHandle 的类) 的 invoke 方法，在 invoke 方法中我们调用委托类的对应方法，然后加上自己的处理逻辑。
Java中代理对象
xiaowu 专栏
10-11 5432
静态代理 静态代理通常用于对原有业务逻辑的扩充 ，通过对真实对象的封装，来实现扩展性。 三要素： 共同接口 public interface Action{ void doSomething(); } 真实对象 public class RealObject implements Action{ public void doSomething(){ Sy...
java 代理
qq_51274606的博客
03-12 7552
代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能. 这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法 java中的代理模式： *定义：给目标对象提供一个代理对象，并且由代理对象控制对目标对象的引用 *目的：①：通过代理对象的方式间接的访问目标对象，防止直接访问目标对象给系统带来不必要的复杂性 ②：
java的代理模式
qq_40820916的博客
10-29 1881
java的三种代理模式简介静态代理jdk动态代理cglib实现动态代理 简介 代理模式的定义： 为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 以上为百度百科对代理模式的定义；通俗一点讲，java中的代理模式就是你想要访问一个目标对象，但是不直接访问它，而是通过它的代理对象访问（因为代理对象可以对目标对象做增强操作），这就是java的代理模式。示意图如下： 在java中，有三种代理模式，分别为静态代
JAVA HTTP反向代理实现过程详解
08-18
在application.yml文件中增加代理参数配置，设置代理的servlet_url和target_url。例如： proxy: servlet_url: /webappB/* target_url: https://webappB_HOST_IP:8001/webappB 3. 注册servlet 在@Configuration类...
java + 动态代理 + 动态代理实际应用场景
04-28
1：静态代理出现的实际背景，静态代理时如何演化成动态代理 2： 动态代理demo 举例实际应用场景（载入数据库驱动的时候，使用AIDL与系统Servic进行通信） 3: 动态代理使用到基础理论：ClassLoader 加载.class字节码...
Java实现的反向代理程序（源码版）
11-22
使用Java编写的反向代理程序（源代码），通过简单的参数配置即可实现某些特定站点的反向代理，并在此过程中改变一些站点的特定行为。例如：允许特点站点跨域访问被代理的站点，或者屏蔽被代理站点识别请求访问客户端...
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1119
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 177
");
基于SpringBoot的考研资讯平台设计与实现
linzhongshu的专栏
09-13 897
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 929
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 350
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1214
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-16 855
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
07_Python数据类型_集合
最新发布
fx_yzjy101的专栏
09-16 424
可以使用大括号 {} 或者 set() 函数来创建集合。如果使用大括号，则至少需要包含一个元素；如果使用 set()，则可以创建一个空集合。# 创建一个空集合# 创建一个包含一个元素的集合# 创建一个包含几个元素的集合。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1074
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
Java动态代理机制解析
"Java代理机制是Java语言提供的一种动态创建代理类和代理对象的机制，主要涉及java.lang.reflect.Proxy和java.lang.reflect.InvocationHandler这两个核心类。代理类可以在运行时自动生成，它允许开发者在不修改原有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值