一、直接设置系统属性，设置后所有网络请求都有效

            System.setProperty("proxyType", "4");
            System.setProperty("proxyPort", "80"));
            System.setProperty("proxyHost", "127.0.0.1");
            System.setProperty("proxySet", "true");

二、用用java.net.Proxy类

package test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.URL;
import java.net.Proxy.Type;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
public class HttpAndHttpsProxy {
    public static String HttpsProxy(String url, String param, String proxy, int port) {
        HttpsURLConnection httpsConn = null;
        PrintWriter out = null;
        BufferedReader in = null;
        String result = "";
        BufferedReader reader = null;
        try {
            URL urlClient = new URL(url);
            System.out.println("请求的URL========：" + urlClient);
                SSLContext sc = SSLContext.getInstance("SSL");
                // 指定信任https
                sc.init(null, new TrustManager[] { new TrustAnyTrustManager() }, new java.security.SecureRandom());
                //创建代理虽然是https也是Type.HTTP
                Proxy proxy1=new Proxy(Type.HTTP, new InetSocketAddress(proxy, port));
                //设置代理
                httpsConn = (HttpsURLConnection) urlClient.openConnection(proxy1);
                httpsConn.setSSLSocketFactory(sc.getSocketFactory());
                httpsConn.setHostnameVerifier(new TrustAnyHostnameVerifier());
                 // 设置通用的请求属性
                httpsConn.setRequestProperty("accept", "*/*");
                httpsConn.setRequestProperty("connection", "Keep-Alive");
                httpsConn.setRequestProperty("user-agent",
                        "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
                // 发送POST请求必须设置如下两行
                httpsConn.setDoOutput(true);
                httpsConn.setDoInput(true);
                // 获取URLConnection对象对应的输出流
                out = new PrintWriter(httpsConn.getOutputStream());
                // 发送请求参数
                out.print(param);
                // flush输出流的缓冲
                out.flush();
                // 定义BufferedReader输入流来读取URL的响应
                in = new BufferedReader(
                        new InputStreamReader(httpsConn.getInputStream()));
                String line;
                while ((line = in.readLine()) != null) {
                    result += line;
                // 断开连接
                httpsConn.disconnect();
                System.out.println("====result===="+result);
                System.out.println("返回结果：" + httpsConn.getResponseMessage());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (reader != null) {
                    reader.close();
            } catch (IOException e) {
            try {
                if (in != null) {
                    in.close();
            } catch (IOException e) {
                e.printStackTrace();
            if (out != null) {
                out.close();
         return result;
    public static String HttpProxy(String url, String param, String proxy, int port) {
        HttpURLConnection httpConn = null;
        PrintWriter out = null;
        BufferedReader in = null;
        String result = "";
        BufferedReader reader = null;
        try {
            URL urlClient = new URL(url);
            System.out.println("请求的URL========：" + urlClient);
                //创建代理
                Proxy proxy1=new Proxy(Type.HTTP, new InetSocketAddress(proxy, port));
                //设置代理
                httpConn = (HttpURLConnection) urlClient.openConnection(proxy1);
                // 设置通用的请求属性
                httpConn.setRequestProperty("accept", "*/*");
                httpConn.setRequestProperty("connection", "Keep-Alive");
                httpConn.setRequestProperty("user-agent",
                        "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
                // 发送POST请求必须设置如下两行
                httpConn.setDoOutput(true);
                httpConn.setDoInput(true);
                // 获取URLConnection对象对应的输出流
                out = new PrintWriter(httpConn.getOutputStream());
                // 发送请求参数
                out.print(param);
                // flush输出流的缓冲
                out.flush();
                // 定义BufferedReader输入流来读取URL的响应
                in = new BufferedReader(
                        new InputStreamReader(httpConn.getInputStream()));
                String line;
                while ((line = in.readLine()) != null) {
                    result += line;
                // 断开连接
                httpConn.disconnect();
                System.out.println("====result===="+result);
                System.out.println("返回结果：" + httpConn.getResponseMessage());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (reader != null) {
                    reader.close();
            } catch (IOException e) {
            try {
                if (in != null) {
                    in.close();
            } catch (IOException e) {
                e.printStackTrace();
            if (out != null) {
                out.close();
         return result;
    private static class TrustAnyTrustManager implements X509TrustManager {
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[] {};
    private static class TrustAnyHostnameVerifier implements HostnameVerifier {
        public boolean verify(String hostname, SSLSession session) {
            return true;
    public static void main(String[] args) {
        HttpsProxy("https://www.baidu.com//", "", "127.0.0.1", 81);
        HttpProxy("http://www.aseoe.com/", "", "127.0.0.1", 81);
                    一、直接设置系统属性，设置后所有网络请求都有效            System.setProperty("proxyType", "4");            System.setProperty("proxyPort", "80"));            System.setProperty("proxyHost", "127.0.0.1");         
				
Java中使用代理发送指定请求http,https（get,post等）
发送HTTP请求
public static String HttpProxy(String url, String param, String proxy,
                                   int port) {
        HttpURLConnection httpConn = null;
        PrintWriter out = null;
        OutputStr




    

import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.Fi...
				
我本来在我本机写的代码，本机电脑是可以连外网没限制，对于https和http都可以。但是放在linux服务器上后，因为VM限制了不能访问外网，而且有ssl验证所以就一直报错，要么是连不上线上请求，要么是访问不了SSL 443端口，其实这2错一样。
package util_liyuan;
import java.io.BufferedReader;
import java....
				
Java HTTP 代理服务器
在当今的企业开发环境中，我们不得不与代理打交道，通常是作为系统管理员。在大多数情况下，应用程序将配置为系统的默认设置，但如果您想对应用程序进行非常严格的控制，例如代理设置，对于这种情况，Java允许使用 API。
该代理服务器是像客户端应用程序和其它服务器之间的中间系统。在企业应用程序中，用于跨网络边界提供对用户内容的控制。下图演示了代理服务器的行为：
在本主题中，我们将了解如何通过 Java 中的代理服务器进行连接。我们将遵循两种方法在 Java 中创建与代理服务
				
在使用Java动态代理时出现了一个很棘手的问题，实现类里抛出了一个自定义异常，但外面捕获不到。
	　　虽然使用 printStack 可以输出调试信息，但通过 getMessage 获取不到提示，因为项目需求是捕捉到同一种自定义异常的不同异常情况，通过 getMessage 获取异常提示反馈给用户，但因为使用了动态代理所以出现了异常捕获不到的情况。
	　　具体原因是因为我们通过动态代理终捕获到的异常时经过加工了的，也是捕获的已不再是开始我们希望抛出的异常，加工抛出的异常有两种：
	　　java.lang.reflect.UndeclaredThrowableException
	　　java.
显示任何两个接收到的数据包之间的差异
许多协议支持
支持HTTP1，HTTP2，HTTPS，WebSocket，FireBase，MQTT，gRPC，协议缓冲区，MessagePack和CBOR作为内置协议。
 轻松开发新协议
应用程序渗透测试的功能
同时发送多个数据包以进行数据库事务测试
用自签名证书替换服务器证书以进行客户端验证测试
具有内置的DNS服务器，可轻松进行数据包转发
保存/加载项目数据
支持Windows，macOS和Linux
与您的操作系统相对应的版本并运行安装程序。
如果在MacOS上使用Homebrew- $ brew cask install packetproxy只需键入$ brew cask install packetp
废话不多说，现在讲讲RPC到底是什么
RPC基本原理
RPC全程Remote Procedure Call Protocol，即远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC采用客户机/服务器模式。请求程序就是一个客户机，而服务提供程序就是一个服务器。首先，客户机调用进程发送一个有进程参数的调用信息到服务进程，然后等待应答信息。在服务器端，进程保持睡眠状态直到调用信息到达为止。当一个调用信息到达，服务器获得进程参数，计算结果，发送答复信息，然后等待下一个调用信息，最后，客户端调用进程接收答复信息，获得进程结果，然后调用执行继续进行。
看到这可能比较晕，没关系，我的理解是这样的，就是服务器上正在运行一个服务app，app有一个函数或接口plus(int
service_args = [
    '--proxy=%s' % ip_html,    # 代理 IP：prot    （eg：192.168.0.28:808）
    '--proxy-type=http’,            # 代理类型：http/https
    ‘--load-images=no’,          ...
				
我们在制作爬虫爬取想要的资料时，由于是计算机自动抓取，强度大、速度快，通常会给网站服务器带来巨大压力，所以同一个IP反复爬取同一个网页，就很可能被封，在这里介绍相关的技巧，以免被封；但在制作爬虫时，还是要适当加入延时代码，以减少对目标网站的影响。
一、requests设置代理:
import requests
proxies = { "http": "http://192.10.1.10:8080", "https": "http://193.121.1.10:9080", }
requests.get.
方法解析：
HttpGetUtils.doGetNoParameters(String requestURL, String proxyHost, Integer proxyPort);
requestURL：请求路径，必填
proxyHost：代理IP，即服务器代理地址，可为null
proxyPort：代理端口，可为null
说明：一般本地测试几乎是不会...
				
最近在爬取一个国外的购物网站商品，首先本地的VPN肯定是打开的，发现浏览器和postman每次都可以请求到内容，但是java代码尝试了各种方式都是Connection refused: connect，一开始以为是java代码的问题，后来突然意识到java是在虚拟机上运行的，可能需要使用代码进行代理，果然如此【虽然VPN打开的，但是java并不会自己去走VPN的那条通道】！
无法连接的错误消息如下：
java.net.ConnectException: Connection refused: con.
    @Override
    public void request() {
        System.out.println("RealSubject is handling the request.");
接着，定义一个代理类，实现同样的接口，比如说：
```java
public class ProxySubject implements Subject {
    private RealSubject realSubject;
    public ProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    @Override
    public void request() {
        System.out.println("ProxySubject is handling the request.");
        realSubject.request();
最后，在主函数中，可以这样使用：
```java
RealSubject realSubject = new RealSubject();
ProxySubject proxySubject = new ProxySubject(realSubject);
proxySubject.request();
动态代理：
首先，定义一个接口，比如说：
```java
public interface Subject {
    void request();
然后，定义一个实现该接口的被代理类，比如说：
```java
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject is handling the request.");
接着，定义一个InvocationHandler接口的实现类，比如说：
```java
public class DynamicProxyHandler implements InvocationHandler {
    private Object target;
    public DynamicProxyHandler(Object target) {
        this.target = target;
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("DynamicProxyHandler is handling the request.");
        Object result = method.invoke(target, args);
        return result;
最后，在主函数中，可以这样使用：
```java
RealSubject realSubject = new RealSubject();
InvocationHandler handler = new DynamicProxyHandler(realSubject);
Subject proxySubject = (Subject) Proxy.newProxyInstance(RealSubject.class.getClassLoader(),
    RealSubject.class.getInterfaces(), handler);
proxySubject.request();
                    CaiFei1215: 
java.net.ConnectException: Connection refused: connect我也是第二个，请问怎么弄[code=java]
[/code]java.net.ConnectException: Connection refused: connect
                JAVA设置代理的两种方式（HTTP和HTTPS）
                    请问：请求服务器a到网关是http请求，网关到接收服务器b是https请求。这种场景中，a到网关的请求（http/https）是怎么定义的？
                JAVA设置代理的两种方式（HTTP和HTTPS）
                    CaiFei1215: 
                    // 获取URLConnection对象对应的输出流
                out = new PrintWriter(httpsConn.getOutputStream());   
我直接拷了第二种方法，在HttpsProxy方法里面输出流out为null。控制台报 “java.net.ConnectException: Connection refused: connect” 81端口没有被占用，请教一下，这是什么缘故？
第一种方法的设置用在哪里？[code=java]
[/java.net.ConnectException: Connection refused: connect][code=java]
                win7下模拟溢出漏洞利用shellcode弹出计算器
                    bbtl_ast: 
                    请问方便问博主一些问题吗？