代理是什么及如何使用

已于 2022-10-08 17:23:39 修改
阅读量2.8k 收藏 24
点赞数 9
分类专栏： 后端学习 文章标签： java 开发语言
于 2022-09-23 11:38:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Whoo_/article/details/126527709
版权

什么是代理？

  代理是什么？简单举个例子，你想和某某明星说话，但是某明星肯定不会直接和你说话（除非你很有身份，当我没说），这时候你就得去找他的助理交流，然后助手再和这个明星交流。对于明星来说，助手就是代理，你们其他人沟通都不要全部来找我了，全去找我的助手吧。

  在代码中也差不多是这样一个场景，直接交流就相当于直接调用目标类的方法（非代理），而代理就是新创建一个类（我们叫他代理类），由这个类去调用目标类的方法，然后其他类就不去直接调用目标类的方法了，调用方式改成其他类去告诉代理类，让代理类来调用目标类方法。

  我这里就用一个故事来说明：A、B和C是朋友，平时都有交流。但是某一天，B生A的气了，这时候B就不和A说话了，于是B告诉A说：要想和我说什么叫我做什么，你去找C说，C听完再来告诉我。于是C就成为B的收话员（代理人）了，什么事情以后都由C来叫B做。C收到A的消息再告诉B去做事，这就是代理。

当然A和B能对话，B也可以找C来做自己的代理人，这都是没问题的

非代理：

开始A可以直接和B交流（直接调用B的方法），如下：

A类代码：

public class A {
    private B b = new B();
    
    public void let_B_do(String something){
        b.doSomething(something);
    }
    
	public static void main(String[] args) {
	        A a = new A();
	        a.let_B_do("Sweep");
	    }
	}

B类代码：

public class B {
    public void doSomething(String something){
        System.out.println("B -> " + something);
    }
}

A直接叫（调用）B去做事：B -> Sweep

不使用代理就是A类直接去调用B类的方法。

使用代理：

B生气了，A就无法和B交流了（A无法直接调用B类的方法了），于是A就去找C说（调用C的方法），叫C告诉B（C调用B）去做某事，使用了C类就相当于使用了代理

A类代码：

public class A {
    private C c = new C();
    public void let_C_info_B_do(String something){
        c.info_B_do(something);
    }

    public static void main(String[] args) {
        A a = new A();
        a.let_C_info_B_do("Sweep");
    }
}

B类代码：

public class B {
    public void doSomething(String something){
        System.out.println("B -> " + something);
    }
}

C类代码：

public class C {
    private B b = new B();
    public void info_B_do(String something){
        System.out.println("找B去做事");
        b.doSomething(something);
    }
}

这样一个过程就是代理，这里找C办事的A就是委托人，也就是委托类，C就是代理人，也就是代理类，代理B的事务

注意：C只是代理，它可以告诉B去做事，当然也可以刷小手段，从中添油加醋，这就要看你在info_B_do()这个方法里面怎么写。

代理的用处：

  就像我上面所说的，C收到消息可以选择如实告诉A，当然也可以添油加醋，补充功能。在现实中的项目，比如我们有一个登录的功能，但是没有做验证，我们可以对用户类的登录方法做代理，在登录的时候，做一些验证啥的（当然我们也可以修改登录的方法，但是修改会造成很多问题。这就涉及到一些原则，设计模式提倡开闭原则：对扩展开放，对修改关闭。因为直接修改会导致出现更多的问题，维护起来可能会更加麻烦，而且有的时候这份代码可能是别人写的，其他很多地方可能依赖了你修改的地方，修改可能会导致程序崩溃。而且代理类可以有选择的使用，不需要代理还可以选择原来的类。）
  总结成一句话就是，可以插入需要的操作（功能添加），这是AOP的体现。（面向切面编程，切开添加一些东西进去）

代理的几种实现：

  • 静态代理
  • 动态代理（JDK代理）
  • CGLib代理

静态代理：

  首先就是静态代理，就和我们上面例子比较类似，但是有一点不同，不同就在之前我们C调用B的do()方法用的是info_B_do()，而静态代理用的是相同的方法名去调用的，也就是info_B_do()改成do()，这个怎么理解呢？C可以去叫B做事，C类相当于可以完成B做的事情，那么就可以当作C做了这件事。静态代理的代理类的代理方法是提前写好的，是固定不变的，只可以代理固定的几个方法，新添加的方法要去代理，就得添加代理类的方法
  要实现静态代理要满足：继承相同的接口或者父类（这样委托类就和代理类的方法名一样了，其次使用到被代理类的地方都可以替换成代理类）

代码实现：

共同的接口类：

public interface FuncInterface {
    public void work();
    public void rest();
}

被代理类：（被代理类需要实现接口）

public class Tool implements FuncInterface{

    @Override
    public void work() {
        System.out.println("Tool工作");
    }

    @Override
    public void rest() {
        System.out.println("Tool休息");
    }
}

代理类：（也要实现接口）

public class ProxyObj implements FuncInterface{

    private Tool tool;

    public ProxyObj(FuncInterface obj) {
        tool = (Tool)obj;
    }

    @Override
    public void work() {
        System.out.println("代理类在被代理对象work的时候可以选择做些事情...");
        tool.work();
    }

    @Override
    public void rest() {
        System.out.println("代理类在被代理对象rest时候可以选择做些事情...");
        tool.rest();
    }
}

调用对象：（想去调用工具，通过代理）

public class OtherUser {
    public static void main(String[] args) {
        ProxyObj proxyObj = new ProxyObj(new Tool());
        System.out.println("xxx希望使用Tool");
        proxyObj.work();
        System.out.println("xxx使用完Tool");
        proxyObj.rest();
    }
}

运行截图：

在这里插入图片描述

  上面我们使用了静态代理，对Tool类进行了代理，我们调用Tool类对象的时候，通过调用代理类的相应方法就可以达成我们的目标。为什么叫静态代理呢？从代码中我们可以知道，我们的代理类只能对work()和rest()方法进行代理，假设我们在Tool添加了其他的方法，那新增的方法proxy对象就没法代理，去调用newFunc()的话就会出现错误了，你就得手动把新的代理的方法添加进去。动态代理就可以不用手动添加代理方法，它自动会帮你生成代理（具体原理后面说）。

动态代理

  上面我说到了静态代理的时候也说了，静态代理只能对当前的被代理类中的方法生效，要是被代理类添加了功能，那么我们的代理类对新方法就失效了，要是这时候用代理类去调用新的方法，可能会出错。这样操作起来就会很麻烦，这时候我们就可以使用动态代理。

原理：

  为什么从原理开始讲，这是有原因的，因为动态代理并没有静态代理直观，学着学着可能就会陷入一知半解的状态。

  动态代理其实原理也和静态代理原理差不多，创建动态代理的过程中会自动生成代理类，生成的代理类继承自Proxy类并实现了我们的接口（这个代理类不是我们自己写的，是调用过程中生成的），实现了相同的接口意味着我们可以用这个代理类去调用与被代理类相同的方法，动态代理调用方法之后不会像静态代理一样直接去调用被代理类，而是通过我们自己写的一个InvocationHandler实例去调用被代理类（可以在Proxy对象中使用getInvocation()方法获取到），然后我们的功能的补充及增强都是在这个InvocationHandler实例中完成。下面涉及到Java反射的知识，没有的话看起来可能会很费劲。

FuncInterFace：（共同实现的接口）

public interface FuncInterface {
    public void work();
    public void rest();
}

Tool类：

public class Tool implements FuncInterface{

    @Override
    public void work() {
        System.out.println("Tool工作");
    }

    @Override
    public void rest() {
        System.out.println("Tool休息");
    }
}

ProxyHandlerOfTool类：（就是我们需要传入的InvocationHandler，使用到反射，不会的可以去看下java反射的内容：http://t.csdn.cn/sDgEL）

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class ProxyHandlerOfTool implements InvocationHandler {

    private Object proxied;

    public ProxyHandlerOfTool(Object proxied){
        this.proxied = proxied;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method " + method.getName());
        Object obj = method.invoke(proxied,args);
        System.out.println("After method " + method.getName());
        return obj;
    }
}

  在这里我们才去调用代理对象，而代理对象需要在构造的时候传进来，这里我们使用的反射来调用的被代理对象的方法：method.invoke(proxied,args)，在这之前你可以写一些补充功能等等。

OtherUser：

import java.lang.reflect.Proxy;

public class OtherUser {
    public static void main(String[] args) {
        Tool tool = new Tool();
        FuncInterface toolProxy = (FuncInterface) Proxy.newProxyInstance(tool.getClass().getClassLoader(),tool.getClass().getInterfaces(),new ProxyHandlerOfTool(tool));
        toolProxy.work();
    }
}

  这里我们使用的Proxy类给我们提供的创建代理类的方法，要求我们把被代理类的类加载器传入，被代理类实现的接口传入，以及一个InvocationHandler，传入后他就会帮我们生成一个代理类 （在Proxy.newProxyInstance(...)上面加上System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");如果没有生成的话，可以替换成
System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");）就可以看见一个$proxy0.class文件（IDEA中），这就是我们代理类的字节码文件，可以看到里面的内容，你可以发现它实现了我们的公共接口，然后它并没有直接调用被代理类的方法，而是在调用父类的InvocationHandler的invoke方法。这时候我们写的补充代码就生效了。

$Proxy0类

import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import jdkProxy.FuncInterface;

public final class $Proxy0 extends Proxy implements FuncInterface {
    private static final Method m0;
    private static final Method m1;
    private static final Method m2;
    private static final Method m3;
    private static final Method m4;

    public $Proxy0(InvocationHandler param1) {
        super(var1);
    }

    public final int hashCode() {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final boolean equals(Object var1) {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void rest() {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void work() {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("jdkProxy.FuncInterface").getMethod("rest");
            m4 = Class.forName("jdkProxy.FuncInterface").getMethod("work");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

    private static Lookup proxyClassLookup(Lookup var0) throws IllegalAccessException {
        if (var0.lookupClass() == Proxy.class && var0.hasFullPrivilegeAccess()) {
            return MethodHandles.lookup();
        } else {
            throw new IllegalAccessException(var0.toString());
        }
    }
}

CGLib代理

  最后就是CGLib代理，上面两种方法都是基于被增强类实现某一接口的情况，如果被增强类未实现任何接口，那么上面两种代理方式都无法使用。这时候我们还有一种手段，那就是使用CGLib代理，使用这种方式，我们需要重写方法拦截器的intercept方法，CGLib代理方式原理是生成被代理类的子类，这个代理类进行方法调用的时候会进入到方法拦截器，而增强的方法就在我们之前重写的intercept方法中进行编写。

在进行该操作时需要去下载相关依赖包：
在这里插入图片描述
 前三个选择3.3.1，后一个选择2.2.2（我不知道其他版本会不会出现问题，这里是没有问题的）

 其次就是你在运行Enhancer enhancer = new Enhancer();时，如果出现了以下的问题，请将jdk版本换回1.8

在这里插入图片描述
操作步骤：file – Project Structure – Project – SDK项（Edit） – 选择JDK8或者是JDK1.8
在这里插入图片描述

Intercept类：

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class Interceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("Before method " + method.getName());
        Object obj = methodProxy.invokeSuper(o,objects); // 这里使用的是fastClass机制，非反射调用
        System.out.println("After method " + method.getName());
        return null;
    }
}

Tool类：

public class Tool {

    public void work() {
        System.out.println("Tool工作");
    }

    public void rest() {
        System.out.println("Tool休息");
    }
}

调用测试：
OhterUser类：

import net.sf.cglib.proxy.Enhancer;

public class OtherUser {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(Tool.class.getClassLoader());
        enhancer.setSuperclass(Tool.class);
        enhancer.setCallback(new Interceptor());
        Tool tool = (Tool) enhancer.create();
        tool.work();
        tool.rest();
    }
}

运行结果：
在这里插入图片描述
  至于如何实现的，这和JDK代理有点相似，都是会自动生成一个代理类，但是CGlib代理会生成代理类和目标类的fastClass，fastClass会给对象方法建立对应的索引，通过索引去获取方法再进行调用，我们这里的invokeSuper就是采用这种方式调用。具体过程就是：我们调用代理对象的方法会进入MethodInterceptor中，然后去调用我们重写的Intercept方法，从而达到方法增强的效果。具体CGlib我了解也不是很深，发现错误的话可以纠正以下。至于之后的内容之后再来补充了。

小柒、Q
关注
专栏目录
使用HTTP怎样进行代理设置
yingpu618的博客
07-08 3808
从事网络工作的人员都知道HTTP代理是经常使用到的。因为HTTP代理可以进行数据采集，我们都知道数据信息是很重要的，当我们进行数据采集的时候直接去别人的网站住区数据的话，是会被网站的反爬虫限制，如果我们是不使用代理ip，在数据采集的时候可能就不能顺利的完成工作。代理ip可以帮助我们隐藏真实的ip地址，我们就像一个真实的用户在浏览网页。可以放心的进行数据抓取。 因为互联网的发展很多的HTTP代理开始出现，很多的人不知道选择什么用哪个代理商。我们在选择的时候要看自己从事的什么业务，不能随便的选择。我自己使用过
静态代理和动态代理的区别,使用场景是什么
weixin_43666051的博客
11-30 2858
代理模式 (1)什么是代理? 代理是一种常用的设计模式,主要作用是为其他对象提供一种代理以控制对这个对象的访问.在某些情况下,一个对象不想或者不能直接引用另一个对象,而代理对象可以再客户端和目标对象之间起到中介的作用. (2)什么时候使用代理? 设计模式中有一个设计原则是开闭原则,是说对修改关闭对扩展开放,我们在工作中有时会接手很多前人的diamante,里面代码逻辑让人摸不到头脑,这是就会很难...
GITHUB上的一些DevSecOps
qq_44005305的博客
01-31 243
最近一直在完善自己的扫描器和攻击链，所以也一直在GITHUB上看自动化的一些知识，脑壳痛看起来比较优秀的如下，本人只推荐哈DefectDojoDefectDojo 是一个安全编排和平台。DefectDojo 允许您管理您的应用程序安全程序，维护 产品和应用信息、分类漏洞和 将结果推送到 JIRA 和 Slack 等系统。DefectDojo 丰富并 使用许多启发式算法来优化漏洞数据，这些算法 随着您使用该平台的次数越多越好。github；搭建好的运行截图如下。
网络代理ip怎么使用：从入门到精通的详细教程
最新发布
Eonjq的博客
09-06 751
在“代理”标签页中，勾选“Web代理（HTTP）”和“安全Web代理（HTTPS）”。选择您正在连接的Wi-Fi网络，长按网络名称，然后选择“修改网络”。打开“设置”应用，点击“网络和Internet”或“Wi-Fi”。勾选“为LAN使用代理服务器”，然后输入代理服务器的地址和端口。勾选“显示高级选项”，然后在“代理”部分选择“手动”。输入代理服务器的地址和端口，然后点击“保存”保存设置。在“手动代理设置”部分，开启“使用代理服务器”开关。打开“设置”应用，点击“网络和Internet”。
代理的使用
Huangqingmeng的博客
05-10 1217
代理
如何使用代理
GuodongSun0的专栏
05-10 587
使用代理的两种情况： 1.对象A内部发生了一些事情,想通知对象B 对象A想在自己的方法内部调用对象B的某个方法,并且对象A不能对对象B有耦合依赖 2.对象B想监听对象A内部发生了什么事情 对象A想传递数据给对象B（通过调用对象B中带参数的方法，这个参数就是想传递的数据） 以上情况,结果都一样:对象B是对象A的代理(delegate) 先搞清楚谁是谁的代理(delegate)
HTTP代理怎么用
pythonadiou的博客
04-30 940
我们因为各种各样的事情需要进行换IP。但是我们不一定清楚买来的HTTP代理IP都可以用在哪里，那就跟着小编一起来看看吧。 首先我们要先获取API提取IP。 获取到的IP后可以直接使用。 如果是电脑，就可以打开internet选项，在局域网设置中勾选代理服务器"为LAN使用代理服务器"，填入IP地址和对应端口号，保存后刷新浏览器IP就变了。 如果是手机。首先打开手机设置，选择“无线和网络”选项，进...
Java：什么是静态代理？什么是动态代理？二者有何区别？
Trouvailless的博客
04-06 4657
一、代理模式 代理模式（Proxy Pattern）是程序设计中的一种设计模式，它的特征是代理类和委托类实现有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。 代理类与委托类之间通常会存在关联关系，一个代理类对象与一个委托类对象（目标对象）关联，代理类对象本身并不真正实现服务，而是通过调用委托类对象的相关方法，来提供特定的服务。 即通过代理对象访问目标对象，这样我们可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。 以最近很火的贵州
阿里二面：为什么SpringBoot默认使用CGLIB作为代理的实现方式？
欢迎来到我的博客
09-11 1829
CGLIB是一种基于ASM的代码生成库，它可以在运行时动态地生成和修改Java字节码，从而实现对Java类和接口的扩展和代理。CGLIB是一种高性能、高质量的代码生成工具，被广泛应用于Hibernate、Spring AOP等框架中。CGLIB动态代理是通过继承机制来实现的，它不要求目标类必须实现接口，而是通过net.sf.cglib.proxy.Enhancer类来创建子类对象作为代理对象，并通过net.sf.cglib.proxy.MethodInterceptor接口来实现方法的拦截和增强。
青龙使用代理
u012426246的博客
02-24 4212
http_和https_proxy 这俩环境变量 python会自动读取并使用。nodejs则使用global-agent进行代理 如图配置环境变量。在容器bridge模式下,用172.17.0.1作为主机(默认情况)2.青龙可以在config中配置代理或者是环境变量。nodejs需要安装global-agent依赖。host模式下使用127.0.0.1。我个人喜欢在环境变量中添加。1.在服务器上配置好代理。
python3-python使用代理进行数据的请求，代理服务器。
记录和分享程序人生的点点滴滴
10-25 4635
代理的目的： 1)让服务器以为不是同一个客户端在请求； 2)防止我们的真实地址被泄露，防止被追究。 代理的执行流程： 数据的请求（request）：浏览器先向代理服务器请求，再由代理服务器向真正的服务器请求。 数据的响应（response）：则沿着相反的方向进行。 正向代理和反向代理 1)正向代理：对于浏览器知道服务器的真实地址，例如VPN； 2)反向代理：浏览器不知道服务器的真实地址，例如nginx。
HTTP代理怎么使用
Yiuunyun的博客
06-16 912
现在很多行业工作中都需要用到代理IP，但是很多人都不会使用，经常有小伙伴来问代理IP怎么使用，一般来说代理IP都会提供API链接，通过访问api链接提取代理IP，下面给您介绍三种代理IP使用方法。一、登录浏览器使用若是使用浏览器浏览网站，可以在浏览器上直接设置代理服务器，api复制到浏览器上会显示端口号和用户名密码，按照地址及其端口对应进行输入，输入代理ip地址之后确定即可二、编写代码使用代理在一点云后台点击API链接，编写代码，定时调用API接口，获取代理IP，在代码里连接代理服务器使用。三、第三方软件使
代理模式相关使用
weixin_33893473的博客
02-22 90
一、一般应用场景 提供一个代理来控制对象的访问。一般在无法访问或者不想访问某个对象时，可以通过一个代理对象间接进行访问。 二、Retrofit代理模式分析： 1、Retrofit使用： 定义接口： public interface MyService { @GET("users/{user}/list") Call<String> getMyList(@Path("us...
怎么使用代理服务器呢
weixin_42589700的博客
02-11 1231
使用代理服务器有以下几种方法： 直接在网络设置中进行设置：可以在操作系统的网络设置中直接配置代理服务器的地址和端口。 使用浏览器插件：可以使用浏览器的插件，例如“Proxy SwitchyOmega”，简化代理服务器的配置。 在程序中设置代理：如果您正在开发某些程序，您可以在代码中设置代理。例如，在Python中，您可以使用“requests”库设置代理。 通常情况下，代理服务器的配置需...
什么是Proxy 代理
06-10
代理（Proxy）是一种计算机网络服务，它充当客户端和服务器之间的中介，为客户端提供资源访问的授权和控制。代理服务器可以用来改善安全性、性能和可靠性等方面的网络连接，同时也可以实现对网络流量的过滤和监控。通过代理服务器，客户端可以间接地访问其他网络服务，而不必直接连接到这些服务。代理服务器可以在客户端和服务器之间进行缓存，以减少网络延迟和带宽使用。另外，代理服务器还可以对客户端和服务器之间的通信进行加密，提高网络安全性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值