代理IP可以分为Http代理，Https代理，Socks代理：

1). Http代理: www对于每一个上网的人都再熟悉不过了，www连接请求就是采用的http协议，所以我们在浏览网页，下载数据（也可采用ftp协议）时就是用http代理。它通常绑定在代理服务器的80、3128、8080等端口上。

2). Https代理: HTTPS（Secure Hypertext Transfer Protocol）安全超文本传输协议 ,它是由Netscape开发并内置于其浏览器中，用于对数据进行压缩和解压操作，并返回网络上传送回的结果。HTTPS实际上应用了Netscape的完全套接字层（SSL）作为HTTP应用层的子层。（HTTPS使用端口443，而不是象HTTP那样使用端口80来和TCP/IP进行通信。）SSL使用40 位关键字作为RC4流加密算法，这对于商业信息的加密是合适的。HTTPS和SSL支持使用X.509数字认证，如果需要的话用户可以确认发送者是谁。

3). Socks代理：采用socks协议的代理服务器就是SOCKS服务器，是一种通用的代理服务器。Socks是个电路级的底层网关，是DavidKoblas在1990年开发的，此后就一直作为Internet RFC标准的开放标准。Socks 不要求应用程序遵循特定的操作系统平台，Socks 代理与应用层代理、HTTP层代理不同，Socks 代理只是简单地传递数据包，而不必关心是何种应用协议（比如FTP、HTTP和NNTP请求）。

所以，Socks代理比其他应用层代理要快得多。它通常绑定在代理服务器的1080端口上。如果您在企业网或校园网上，需要透过防火墙或通过代理服务器访问 Internet就可能需要使用SOCKS。一般情况下，对于拨号上网用户都不需要使用它。注意，浏览网页时常用的代理服务器通常是专门的http代理，它和SOCKS是不同的。因此，您能浏览网页不等于 您一定可以通过SOCKS访问Internet。常用的防火墙，或代理软件都支持SOCKS。

🍅 Java学习路线配套文章：Java学习路线总结，搬砖工逆袭Java架构师（全网最强）
🍅 基础推荐：Java基础教程系列
🍅 实战推荐：Spring Boot基础教程
🍅 简介：Java领域优质创作者🏆、CSDN哪吒公众号作者✌ 、Java架构师奋斗者💪
🍅 扫描主页左侧二维码，加入群聊，一起学习、一起进步
🍅 欢迎点赞 👍 收藏 ⭐留言 📝

一、代理模式

代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

著名的代理模式例子为引用计数（英语：reference counting）指针对象。

当一个复杂对象的多份副本须存在时，代理模式可以结合享元模式以减少存储器用量。典型作法是创建一个复杂对象及多个代理者，每个代理者会引用到原本的复杂对象。而作用在代理者的运算会转送到原本对象。一旦所有的代理者都不存在时，复杂对象会被移除。

二、组成

抽象角色：通过接口或抽象类声明真实角色实现的业务方法。

代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

三、优点

1、职责清晰

真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件完成事务，附带的结果就是编程简洁清晰。

2、保护对象

代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了中介的作用和保护了目标对象的作用。

3、高扩展性

四、模式结构

一个是真正的你要访问的对象(目标类)，一个是代理对象,真正对象与代理对象实现同一个接口,先访问代理类再访问真正要访问的对象。

代理模式分为静态代理、动态代理。

静态代理是由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

动态代理是在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。

五、静态代理

创建一个接口，然后创建被代理的类实现该接口并且实现该接口中的抽象方法。之后再创建一个代理类，同时使其也实现这个接口。在代理类中持有一个被代理对象的引用，而后在代理类方法中调用该对象的方法。

使用静态代理很容易就完成了对一个类的代理操作。但是静态代理的缺点也暴露了出来：由于代理只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。

六、动态代理

1、动态代理流程图

2、动态代理代码实现

（1）代理类

利用反射机制在运行时创建代理类。
接口、被代理类不变，我们构建一个ProxyInvocationHandler类来实现InvocationHandler接口。

package com.guor.aop.dynamicproxy;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
public class ProxyInvocationHandler implements InvocationHandler {
	private Object target;
	
	public Object getTarget() {
		return target;
	}
 
	public void setTarget(Object target) {
		this.target = target;
	}
 
	//生成得到代理类
	public Object getProxy() {
		return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
	}
	
	//处理代理实例，并返回结果
	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 msg) {
		System.out.println("执行了"+msg+"方法");
	}
}

通过Proxy类的静态方法newProxyInstance返回一个接口的代理实例。针对不同的代理类，传入相应的代理程序控制器InvocationHandler。

（2）被代理类UserService

package com.guor.aop;
 
public interface UserService {
	public void add();
	public void delete();
	public void update();
	public void query();
}

package com.guor.aop;
 
public class UserServiceImpl implements UserService {
 
	public void add() {
		System.out.println("add");
	}
 
	public void delete() {
		System.out.println("delete");
	}
 
	public void update() {
		System.out.println("update");
	}
 
	public void query() {
		System.out.println("query");
	}
 
}

（3）执行动态代理

package com.guor.aop.dynamicproxy;
 
import com.guor.aop.UserService;
import com.guor.aop.UserServiceImpl;
 
public class Client {
 
	public static void main(String[] args) {
		//真实角色
		UserService userService = new UserServiceImpl();
		
		//代理角色
		ProxyInvocationHandler pih = new ProxyInvocationHandler();
		//通过调用程序处理角色来处理我们要调用的接口对象
		pih.setTarget(userService);
		
		UserService proxy = (UserService) pih.getProxy();
		proxy.update();
	}
 
}

（4）控制台输出

更多代理进阶，详见：【Java基础知识 14】java动态代理原理

上一篇：Java零基础入门 19：java8 lambda表达式
下一篇：敬请期待

添加微信，备注1024，赠送Java学习路线思维导图

二、代理模式（Proxy Pattern）

根据B站狂神视频整理：https://www.bilibili.com/video/BV1mc411h719?p=9
参考1：https://blog.csdn.net/kongsanjin/article/details/105419414
参考2：https://www.cnblogs.com/cenyu/p/6289209.html
参考3：https://blog.csdn.net/weixin_36759405/article/details/82770422

代理模式属于结构型模式

代理模式定义：为其他对象提供一种代理，以控制对这个对象的访问。代理对象起到中介作用，可去掉功能或者增加额外功能。

1、常见的几种代理模式：

远程代理，负责与远程JVM通信，以实现本地调用者与远程被调用者之间的正常交互。
虚拟代理，用来代替巨大对象，确保它在需要的时候才被创建。
保护代理，给被调用者提供访问控制，确认调用者的权限。
智能引用代理，比如火车票在各地都有售票处，房屋中介等。

以智能引用代理讲讲代理怎么实现的。有两种实现方式：静态代理和动态代理

2、静态代理

静态代理：代理和被代理对象在代理之前是确定的。它们都实现相同的接口或者继承相同的抽象类。

角色分析：

• 抽象角色：一般使用接口或者抽象类
• 真实角色：被代理的
• 代理角色：代理真角色。代理真角色后会做一些附属操作
• 客户：访问代理对象的人

代码

（1）接口类：Rent.java

//租房。抽象角色
public interface Rent {
    void rent();
}

（2）房东类：Host.java

//房东 真实角色
public class Host implements Rent{
    public void rent() {
        System.out.println("房东要出租房子了");
    }
}

（3）代理类：Proxy.java

//代理角色。代理房东租房
public class Proxy implements Rent{
    private Host host;
    public Proxy(){
    }
    public Proxy(Host host){
        this.host = host;
    }

    //租房操作，可以添加一些额外操作
    public void rent() {
        seeHouse();//看房
        host.rent();
        hetong();//签合同
        fare();//收中介费
    }

    public void seeHouse(){
        System.out.println("中介带你看房子");
    }
    public void hetong(){
        System.out.println("签订租赁合同");
    }
    public void fare(){
        System.out.println("收中介费");
    }
}

（4）测试类：Client.java

//租客。访问代理对象的人
public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        //代理房东。可以加一些附属操作
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

静态代理简单总结：

根据上边代码可以看出，优点是在不修改房东类（被代理对象）的情况下，中介（代理对象）可以添加额外操作，比如看房，签合同等；缺点是中介和和房东都实现一样的接口，所以会有很多代理类，致命的是一旦接口中增加方法，实现这个接口的房东和中介都要做出修改。

怎么解决？使用动态代理

动态代理有两类，一是基于接口的JDK动态代理，另外一种是基于类的CGLib代理

3、JDK动态代理

代理对象不用实现接口，是利用JDK的API生成的，动态在内存中构建代理对象（需要我们指定）

代理类所在包：java.lang.reflect.Proxy

newProxyInstance方法

参数：

loader - 类加载器来定义类
interfaces - 代理类实现的接口
h - 调度方法动用的处理函数

上边是jdk-api上的，可能看的不是很懂，下边单独说一些，最好结合下边的JDKProxy类来看。

首先，JDKProxy类要实现InvocationHandler接口，而这个接口只有一个invoke方法，我们要重写这个方法，在里面写上我们的逻辑；

然后怎么生成代理类呢？就需要newProxyInstance方法了，参数详细介绍如下。

//处理代理实例上的方法调用并返回结果。
public Object invoke(Object proxy, //调用该方法的代理实例
                     Method method, //要执行的目标对象的方法
                     Object[] args) //执行方法需要的参数
        throws Throwable;

//返回指定接口的代理类的实例。
public static Object newProxyInstance(
		ClassLoader loader,	  //指定当前目标对象使用的类加载器
        类<?>[] interfaces,	 //目标对象实现的接口的类型
        InvocationHandler h   //事件处理器
)

代码如下：

接口Rent类和Host类是不变的，然后增加一个JDK动态代理类JDKProxy实现InvocationHandler，最后写测试类。

（1）代理类：JDKProxy.java

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

/**
 * jdk动态代理，不需要实现接口，需要指定接口类型
 * 写法一，好理解，以租房为例的话，targetObject就是Rent接口
 */
public class JDKProxy implements InvocationHandler {

    //需要代理的目标对象。
    //targetObject就是咱们的Rent接口
    public Object targetObject;
    //代理对象目标
    public void setTargetObject(Object targetObject) {
        this.targetObject = targetObject;
    }

    //生成得到代理类
    public Object getTargetObject(){
        /**
         * 返回代理对象
         * 参数一：指定当前目标对象使用的类加载器。
         * 参数二：目标对象实现的接口的类型。
         * 参数三：事件处理器。这里写的this是代表下边重写的invoke方法
         */
        return Proxy.newProxyInstance(
                targetObject.getClass().getClassLoader(),
                targetObject.getClass().getInterfaces(),
                this);
    }

    /**
     * 实现InvocationHandler接口，就要重写invoke方法。
     * proxy，调用该方法的代理实例
     * method，要执行的目标对象的方法(利用反射的原理)
     * args，执行某方法需要的参数。
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        seeHouse();//看房
        //动态代理的本质，就是使用反射机制实现
        Object result = method.invoke(targetObject,args);
        hetong();//签合同
        fare();//收费
        return result;
    }

    public void seeHouse(){
        System.out.println("中介带你看房子");
    }
    public void hetong(){
        System.out.println("签订租赁合同");
    }
    public void fare(){
        System.out.println("收中介费");
    }
}

（2）测试类：client2.java

public class client2 {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();

        //代理角色,现在没有
        JDKProxy jdkProxy = new JDKProxy();

        //通过调用程序处理角色来处理我们要用调用的接口对象
        jdkProxy.setTargetObject(host);//把要代理的对象传过去

        Rent proxy = (Rent) jdkProxy.getTargetObject();
        proxy.rent();
    }
}

代码2

上边的代码是比较好理解的一种写法，下边的这种写法很简单，直接使用newProxyInstance，在它里面重写InvocationHandler方法（参考2博客中的）。

（1）代理工厂类：ProxyFactory.java

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

/**
 * 创建动态代理对象
 * 动态代理不需要实现接口,但是需要指定接口类型
 */
public class ProxyFactory {

    //目标对象
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象生成代理对象
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        seeHouse();
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        hetong();
                        fare();
                        return returnValue;
                    }
                }
        );
    }
    
    public void seeHouse(){
        System.out.println("中介带你看房子");
    }
    public void hetong(){
        System.out.println("签订租赁合同");
    }
    public void fare(){
        System.out.println("收中介费");
    }
}

（2）测试类：client3.java

public class client3 {
    public static void main(String[] args) {
        //目标对象
        Rent target = new Host();

        //给目标对象创建代理对象
        Rent proxy = (Rent) new ProxyFactory(target).getProxyInstance();

        //执行方法
        proxy.rent();
    }
}

代理对象不用实现接口，但目标对象（房东host）一定要实现接口（Rent），否则不能使用JDK动态代理。

4、CGLib代理

上边的静态代理和JDK动态代理都需要目标对象实现一个接口（Host实现Rent），但有时候，目标对象就是一个对象，没有实现任何接口，就不能使用JDK动态代理。那这时候可以使用CGLib代理。

CGLibb代理也叫子类代理，它是在内存中构建一个子类对象，从而实现对目标对象功能的扩展。

注意：

代理的类不能为final，否则会报错。

如果目标对象的方法为final或static，不会执行额外添加的功能。比如看房，签合同。

代码

需要导入CGLib的jar文件，但spring的核心已包括了CGLib的功能，可以直接导入spring的核心包。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>

（1）CGLib代理工厂类：CGLibProxyFactory.java

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * CGLib子类代理工厂:内存中动态构建一个子类对象
 */
public class CGLibProxyFactory implements MethodInterceptor {
    //目标对象
    private Object target;
    public CGLibProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1、工具类
        Enhancer en = new Enhancer();
        //2、设置父类
        en.setSuperclass(target.getClass());
        //3、设置回调函数
        en.setCallback(this);
        //4、创建子类(代理对象)
        return en.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        seeHouse();//看房

        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);

        hetong();//签合同
        fare();//收费
        return returnValue;
    }

    public void seeHouse(){
        System.out.println("中介带你看房子");
    }
    public void hetong(){
        System.out.println("签订租赁合同");
    }
    public void fare(){
        System.out.println("收中介费");
    }
}

Enhancer是cglib中使用频率很高的一个类，它是一个字节码增强器，可以用来为无接口的类创建代理。

（2）测试类：client4.java

public class client4 {
    public static void main(String[] args) {
        //目标对象
        Host host = new Host();
        //生成代理对象
        Host proxy = (Host) new CGLibProxyFactory(host).getProxyInstance();
        //执行代理对象的方法
        proxy.rent();
    }
}

Spring在选择用JDK还是CGLiB的依据：

(1)当Bean实现接口时，Spring就会用JDK的动态代理

(2)当Bean没有实现接口时，Spring使用CGlib是实现

(3)可以强制使用CGlib，只需要在spring配置中加入

<aop:aspectj-autoproxy proxy-target-class="true"/>

5、CGLib和JDK动态代理的区别

（1）JDK动态代理是实现了被代理对象的接口，CGLib是继承了被代理对象。

（2）JDK和CGLib都是在运行期生成字节码，JDK是直接写Class字节码，CGLib使用ASM框架写Class字节码，CGLib代理实现更复杂，生成代理类比JDK效率低。

（3）JDK调用代理方法，是通过反射机制调用，CGLib是通过FastClass机制直接调用方法，CGLib执行效率更高。