Java编写ip代理池（一）

各位盟友，第一次在github上发布源码，不足之处还往多多指教。

这是给朋友爬虫使用的ip代理池，保证ip的有效性和可靠性，使用java实现。

话不多说开始上干货

本次采用的是apache开源对象池PoolableObjectFactory管理所有ip

首先引项目所需依赖

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>2.1.3.RELEASE</version>

</parent>

<groupId>com.shimmer</groupId>

<artifactId>iphttps</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>iphttps</name>

<description>Demo project for Spring Boot</description>

<java.version>1.8</java.version>

</properties>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-test</artifactId>

</dependency>

<groupId>org.apache.commons</groupId>

<artifactId>commons-lang3</artifactId>

</dependency>

<groupId>commons-codec</groupId>

<artifactId>commons-codec</artifactId>

</dependency>

<groupId>commons-httpclient</groupId>

<artifactId>commons-httpclient</artifactId>

</dependency>

<groupId>org.apache.poi</groupId>

</dependency>

<groupId>org.apache.poi</groupId>

<artifactId>poi-ooxml</artifactId>

</dependency>

<groupId>com.alibaba</groupId>

<artifactId>fastjson</artifactId>

</dependency>

<groupId>commons-pool</groupId>

<artifactId>commons-pool</artifactId>

</dependency>

<groupId>org.apache.httpcomponents</groupId>

<artifactId>httpclient</artifactId>

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-test</artifactId>

</dependency>

<groupId>org.junit.jupiter</groupId>

<artifactId>junit-jupiter-api</artifactId>

<version>RELEASE</version>

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-test</artifactId>

<version>2.1.3.RELEASE</version>

</dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

<version>5.1.5.RELEASE</version>

</dependency>

</dependencies>

<build>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

</plugin>

</plugins>

</build>

</project>

核心配置文件application.yml

# PROXY代理配置

ip-proxy:

# 最大活动数

maxActive: 200

# 最大空闲数

maxIdle: 20

# 最大等待时间

maxWait: 100

#返回是否校验

testOnReturn: false

#借出是否校验

testOnBorrow: true

#是否后进先出

lifo: false

#提前多少分钟销毁对象

testTime: 3

#设定间隔每过多少毫秒进行一次后台对象清理的行动。如果这个值不是正数，则实际上不会进行后台对象清理。

timeBetweenEvictionRunsMillis: -1000

#设定在进行后台对象清理时，是否还对没有过期的池内对象进行有效性检查。不能通过有效性检查的对象也将被回收。

testWhileIdle: true

#设定在进行后台对象清理时，每次检查几个对象。如果这个值不是正数，则每次检查的对象数是检查时池内对象的总数乘以这个值的负倒数再向上取整的结果――也就是说，

#如果这个值是-2（-3、-4、-5……）的话，那么每次大约检查当时池内对象总数的1/2（1/3、1/4、1/5……）左右。

numTestsPerEvictionRun: 3

# 获取ip 方式 0 为免费 1 为付费 2 为免费和付费同时进行

iPType: 2

# IP代理请求路径某某第三方ip代理

httpPath: "http://"

# IP代理请求参数

httpProxy:

#所有的参数和对应的值如下：

num: "1"

type: "2"

pro: ""

city: ""

yys: "0"

port: "1"

pack: "1111"

amount: "1"

ts: "1"

ys: "1"

cs: "1"

lb: "1"

sb: "0"

pb: "4"

mr: "1"

regions: ""

获取配置类

package com.sunshine.http_proxy.utils;

import java.util.HashMap;

import java.util.Map;

import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.context.annotation.Configuration;

/**

* @author xaingzi

* 配置类

* 从配置文件中读取数据映射到map

* 注意：必须实现set方法

@Configuration

@ConfigurationProperties(prefix = "ip-proxy")

public class HttpProxyConfig {

private int maxActive;

private int maxIdle;

private int maxWait;

private int testTime;

private int numTestsPerEvictionRun;

private int iPType;

private boolean testOnReturn;

private boolean testOnBorrow;

private boolean lifo;

private String httpPath;

private boolean testWhileIdle;

private long timeBetweenEvictionRunsMillis;

private Map<String, String> httpProxy = new HashMap<>();

public int getMaxActive() {

return maxActive;

}

public void setMaxActive(int maxActive) {

this.maxActive = maxActive;

}

public int getMaxIdle() {

return maxIdle;

}

public void setMaxIdle(int maxIdle) {

this.maxIdle = maxIdle;

}

public int getMaxWait() {

return maxWait;

}

public void setMaxWait(int maxWait) {

this.maxWait = maxWait;

}

public boolean isTestOnReturn() {

return testOnReturn;

}

public void setTestOnReturn(boolean testOnReturn) {

this.testOnReturn = testOnReturn;

}

public boolean isTestOnBorrow() {

return testOnBorrow;

}

public void setTestOnBorrow(boolean testOnBorrow) {

this.testOnBorrow = testOnBorrow;

}

public boolean isLifo() {

return lifo;

}

public void setLifo(boolean lifo) {

this.lifo = lifo;

}

public String getHttpPath() {

return httpPath;

}

public void setHttpPath(String httpPath) {

this.httpPath = httpPath;

}

public Map<String, String> getHttpProxy() {

return httpProxy;

}

public void setHttpProxy(Map<String, String> httpProxy) {

this.httpProxy = httpProxy;

}

public int getTestTime() {

return testTime;

}

public void setTestTime(int testTime) {

this.testTime = testTime;

}

public boolean isTestWhileIdle() {

return testWhileIdle;

}

public void setTestWhileIdle(boolean testWhileIdle) {

this.testWhileIdle = testWhileIdle;

}

public long getTimeBetweenEvictionRunsMillis() {

return timeBetweenEvictionRunsMillis;

}

public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis) {

this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;

}

public int getNumTestsPerEvictionRun() {

return numTestsPerEvictionRun;

}

public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun) {

this.numTestsPerEvictionRun = numTestsPerEvictionRun;

}

public int getiPType() {

return iPType;

}

public void setiPType(int iPType) {

this.iPType = iPType;

}

ip对象存储基类

package com.sunshine.http_proxy.pool;

/**

* 代理对象

* @author xaingzi

import java.io.Serializable;

public class ProxyHost implements Serializable {

/**

* 序列化

private static final long serialVersionUID = 1L;

private String ip;

private Integer port;

private String creaTime;

private String expireTime;

private String city;

private String isp;

public String getIp() {

return ip;

}

public void setIp(String ip) {

this.ip = ip;

}

public Integer getPort() {

return port;

}

public void setPort(Integer port) {

this.port = port;

}

public String getCreaTime() {

return creaTime;

}

public void setCreaTime(String creaTime) {

this.creaTime = creaTime;

}

public String getExpireTime() {

return expireTime;

}

public void setExpireTime(String expireTime) {

this.expireTime = expireTime;

}

public String getCity() {

return city;

}

public void setCity(String city) {

this.city = city;

}

public String getIsp() {

return isp;

}

public void setIsp(String isp) {

this.isp = isp;

}

@Override

public String toString() {

return "ip：" + ip + " 端口：" + port + " 到期时间：" + expireTime + " 创建时间：" + creaTime + " 城市：" + city + " isp：" + isp;

}

http请求获取第三方代理ip和扫描免费代理ip

package com.sunshine.http_proxy;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.net.InetSocketAddress;

import java.net.MalformedURLException;

import java.net.Proxy;

import java.net.URL;

import java.net.URLConnection;

import java.text.SimpleDateFormat;

import java.util.*;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

import com.sunshine.http_proxy.utils.DateUtil;

import com.sunshine.http_proxy.utils.HttpClientUtil;

import com.sunshine.http_proxy.utils.HttpProxyConfig;

import org.apache.commons.httpclient.HttpClient;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONObject;

/**

* @author xaingzi

@SuppressWarnings({"unchecked", "rawtypes"})

public class HttpProxyClientLocat implements Runnable {

public static Logger log = LoggerFactory.getLogger(HttpProxyClientLocat.class);

private static final String BAIDU_PATH = "http://youxingyang.com";

private static Map<String, String> hashMap = new Hashtable<String, String>();

private static JSONObject json = new JSONObject();

private static int[] ports = new int[]{80, 443, 8883, 4271, 8886, 8080, 8888, 8887, 8889, 8081};

private static String expireTime, city, isp;

private static int i = 0;

/**

* @param path

* @param map

* @return

public static JSONObject getHttpClientProxyIp(String path, Map<String, String> map) {

List list = new ArrayList<HashMap<String, String>>();

JSONObject json = new JSONObject();

do {

String result = HttpClientUtil.httpGet(path, map);

log.info("获取ip信息：" + result);

List<String> parseArray = JSON.parseArray(JSON.parseObject(result).getString("data"), String.class);

for (String str : parseArray) {

String ip = JSON.parseObject(str).getString("ip");

String port = JSON.parseObject(str).getString("http_port_secured");

// String id =

// JSON.parseObject(result).getJSONArray("data").getJSONObject(0).getString("id");

Map<String, Integer> map1 = new HashMap<String, Integer>();

map1.put(ip, Integer.valueOf(port));

checkProxyIp(map1, BAIDU_PATH);

}

} while ((i < 3) && (hashMap.size() < 1));

list.add(hashMap);

json.put("status", 0);

json.put("data", list);

return json;

}

/**

* @param httpProxyConfig

* @return

public static JSONObject getHttpClientProxyIp(HttpProxyConfig httpProxyConfig) {

hashMap.clear();

JSONObject json = new JSONObject();

if (httpProxyConfig.getiPType() == 0) {

try {

json = getHttpChilentProxyApi();

} catch (InterruptedException e) {

e.printStackTrace();

}

} else if (httpProxyConfig.getiPType() == 1) {

json = getHttpClient(httpProxyConfig);

} else if (httpProxyConfig.getiPType() == 2) {

if (Math.random() > 0.3) {

json = getHttpClient(httpProxyConfig);

} else {

try {

json = getHttpChilentProxyApi();

} catch (InterruptedException e) {

e.printStackTrace();

}

return json;

}

private static JSONObject getHttpClient(HttpProxyConfig httpProxyConfig) {

List list = new ArrayList<HashMap<String, String>>();

do {

log.info("发送Get请求：" + httpProxyConfig.getHttpPath());

String result = HttpClientUtil.httpGet(httpProxyConfig.getHttpPath(), httpProxyConfig.getHttpProxy());

log.info("获取ip信息：" + result);

List<String> parseArray = JSON.parseArray(JSON.parseObject(result).getString("data"), String.class);

for (String str : parseArray) {

String ip = JSON.parseObject(str).getString("ip");

String port = JSON.parseObject(str).getString("port");

expireTime = JSON.parseObject(str).getString("expire_time");

isp = city = JSON.parseObject(str).getString("isp");

city = JSON.parseObject(str).getString("city");

// String id =

// JSON.parseObject(result).getJSONArray("data").getJSONObject(0).getString("id");

Map<String, Integer> map1 = new HashMap<String, Integer>();

map1.put(ip, Integer.valueOf(port));

checkProxyIp(map1, BAIDU_PATH);

}

} while ((i < 3) && (hashMap.size() < 1));

list.add(hashMap);

json.put("status", 0);

json.put("data", list);

return json;

}

/**

* 单个代理IP有效检测

* @param ip

* @param port

public void createIPAddress(String ip, int port) {

URL url = null;

try {

url = new URL("http://www.baidu.com");

} catch (MalformedURLException e) {

log.info("url invalidate");

}

InetSocketAddress addr = null;

addr = new InetSocketAddress(ip, port);

Proxy proxy = new Proxy(Proxy.Type.HTTP, addr); // http proxy

InputStream in = null;

try {

URLConnection conn = url.openConnection(proxy);

conn.setConnectTimeout(1000);

in = conn.getInputStream();

} catch (Exception e) {

log.info(Thread.currentThread().getName() + " ip " + ip + " : " + port + " is not aviable");// 异常IP

}

String s = convertStreamToString(in);

//log.info(s);

// log.info(s);http://ip.taobao.com/service/getIpInfo.php?ip=210.32.158.14

synchronized (this){

if (s.indexOf("html") > 0) {// 有效IP

log.info(Thread.currentThread().getName() + " " + ip + ":" + port + " is ok");

hashMap.put("ip", ip);

hashMap.put("port", port + "");

String s1 = HttpClientUtil.getResult("http://ip.taobao.com/service/getIpInfo.php", "ip=" + ip, "utf-8");

//String[] split = JSON.parseObject(s1).getJSONArray("data").getJSONObject(0).getString("location")

//.split(" ");

JSONObject data = JSON.parseObject(JSON.parseObject(s1).getString("data"));

hashMap.put("ip", ip);

hashMap.put("port", port + "");

hashMap.put("creaTime", (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).format(new Date()));

hashMap.put("expireTime", DateUtil.format(DateUtil.addMinute(new Date(), 30), DateUtil.TIME_PATTERN_DEFAULT));

if (StringUtils.equals(data.getString("region"), data.getString("city"))) {

hashMap.put("city", data.getString("region") + "市" + data.getString("city") + "市");

} else {

hashMap.put("city", data.getString("region") + "省" + data.getString("city") + "市");

}

hashMap.put("isp", data.getString("isp"));

}

public static JSONObject getHttpChilentProxyApi() throws InterruptedException {

Vector vector = new Vector();

log.info("获取免费ip");

Vector<Thread> vec = new Vector<Thread>();

HttpProxyClientLocat httptest2 = new HttpProxyClientLocat();

int threadNumber = 320;

for (int i = 0; i < threadNumber; i++) {

Thread thread = new Thread(httptest2);

thread.start();

vec.add(thread);

}

for (Thread thread : vec) {

thread.join();

}

vector.add(hashMap);

json.put("status", 0);

json.put("data", vector);

log.info(json.toString());

return json;

}

@Override

public void run() {

while (hashMap.size() < 1) {

String randomIp = getRandomIp();

log.info(randomIp);

for (int port : ports) {

createIPAddress(randomIp, port);

}

public static String convertStreamToString(InputStream is) {

if (is == null)

return "";

BufferedReader reader = new BufferedReader(new InputStreamReader(is));

StringBuilder sb = new StringBuilder();

String line = null;

try {

while ((line = reader.readLine()) != null) {

sb.append(line + "/n");

}

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

is.close();

} catch (IOException e) {

e.printStackTrace();

}

return sb.toString();

}

/**

* 批量代理IP有效检测

* @param proxyIpMap

* @param reqUrl

public static void checkProxyIp(Map<String, Integer> proxyIpMap, String reqUrl) {

log.info("检测ip是否有效");

for (String proxyHost : proxyIpMap.keySet()) {

Integer proxyPort = proxyIpMap.get(proxyHost);

int statusCode = 0;

try {

HttpClient httpClient = new HttpClient();

httpClient.getHostConfiguration().setProxy(proxyHost, proxyPort);

// 连接超时时间（默认10秒 10000ms）单位毫秒（ms）

int connectionTimeout = 10000;

// 读取数据超时时间（默认30秒 30000ms）单位毫秒（ms）

int soTimeout = 30000;

httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(connectionTimeout);

httpClient.getHttpConnectionManager().getParams().setSoTimeout(soTimeout);

String httpGet = HttpClientUtil.httpGet(reqUrl, new HashMap<>());

log.info(httpGet);

statusCode = httpGet.indexOf("html");

} catch (Exception e) {

i++;

log.error("ip " + proxyHost + " is not aviable");

}

Lock l = new ReentrantLock();

l.lock();

try {

if (statusCode > 0) {

log.info(Thread.currentThread().getName() + " " + proxyHost + ":" + proxyPort + " is ok");

System.out.format("%s:%s-->%s/n", proxyHost, proxyPort, statusCode);

hashMap.put("creaTime", (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).format(new Date()));

hashMap.put("expireTime", expireTime);

hashMap.put("city", city);

hashMap.put("ip", proxyHost);

hashMap.put("port", proxyPort + "");

}

} finally {

l.unlock();

}

public static JSONObject connectHttpChilentStatus(String http) {

List list = new ArrayList<HashMap<String, String>>();

log.info("开始校验" + http);

JSONObject json = new JSONObject();

if (null != http && "" != http) {

String[] ips = http.split(",");

for (String ip : ips) {

if (null != ip && "" != ip) {

Map<String, Object> map = new HashMap<>();

String[] str = ip.split(":");

int statusCode = 0;

map.put("ip", str[0]);

map.put("port", str[1]);

try {

HttpClient httpClient = new HttpClient();

httpClient.getHostConfiguration().setProxy(str[0], Integer.valueOf(str[1]));

// 连接超时时间（默认10秒 10000ms）单位毫秒（ms）

int connectionTimeout = 10000;

// 读取数据超时时间（默认30秒 30000ms）单位毫秒（ms）

int soTimeout = 30000;

httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(connectionTimeout);

httpClient.getHttpConnectionManager().getParams().setSoTimeout(soTimeout);

String httpGet = HttpClientUtil.httpGet(BAIDU_PATH, new HashMap<>());

log.info(httpGet);

statusCode = httpGet.indexOf("html");

} catch (Exception e) {

map.put("status", 500);

map.put("msg", "连接超时");

}

if (statusCode > 0) {

map.put("status", 0);

map.put("msg", "连接成功");

}

list.add(map);

}

json.put("status", 0);

json.put("data", list);

return json;

}

public static String getRandomIp() {

// ip范围

int[][] range = {{607649792, 608174079}, // 36.56.0.0-36.63.255.255

{1038614528, 1039007743}, // 61.232.0.0-61.237.255.255

{1783627776, 1784676351}, // 106.80.0.0-106.95.255.255

{2035023872, 2035154943}, // 121.76.0.0-121.77.255.255

{2078801920, 2079064063}, // 123.232.0.0-123.235.255.255

{-1950089216, -1948778497}, // 139.196.0.0-139.215.255.255

{-1425539072, -1425014785}, // 171.8.0.0-171.15.255.255

{-1236271104, -1235419137}, // 182.80.0.0-182.92.255.255

{-770113536, -768606209}, // 210.25.0.0-210.47.255.255

{-569376768, -564133889}, // 222.16.0.0-222.95.255.255

};

Random rdint = new Random();

int index = rdint.nextInt(10);

String ip = num2ip(range[index][0] + new Random().nextInt(range[index][1] - range[index][0]));

return ip;

}

public static String num2ip(int ip) {

int[] b = new int[4];

String x = "";

b[0] = (int) ((ip >> 24) & 0xff);

b[1] = (int) ((ip >> 16) & 0xff);

b[2] = (int) ((ip >> 8) & 0xff);

b[3] = (int) (ip & 0xff);

x = Integer.toString(b[0]) + "." + Integer.toString(b[1]) + "." + Integer.toString(b[2]) + "."

+ Integer.toString(b[3]);

return x;

}

因为用到了时间转换和 httpClient请求所以我也把这两个工具类贴出来方便使用

httpClientUtil

package com.sunshine.http_proxy.utils;

import java.io.*;

import java.net.HttpURLConnection;

import java.net.URL;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.apache.http.HttpEntity;

import org.apache.http.NameValuePair;

import org.apache.http.client.config.CookieSpecs;

import org.apache.http.client.config.RequestConfig;

import org.apache.http.client.entity.UrlEncodedFormEntity;

import org.apache.http.client.methods.CloseableHttpResponse;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.entity.StringEntity;

import org.apache.http.impl.client.CloseableHttpClient;

import org.apache.http.impl.client.HttpClients;

import org.apache.http.message.BasicNameValuePair;

import org.apache.http.util.EntityUtils;

public class HttpClientUtil {

public static String httpGet(String url, Map<String, String> params) {

CloseableHttpClient httpClient = HttpClients.createDefault();

Iterator<String> keysIte = params.keySet().iterator();

int index = 0;

while (keysIte.hasNext()) {

String key = keysIte.next();

if (index == 0) {

url = url + "?" + key + "=" + params.get(key);

} else {

url = url + "&" + key + "=" + params.get(key);

}

index++;

}

HttpGet httpget = new HttpGet(url);

CloseableHttpResponse response = null;

StringBuilder result = new StringBuilder();

// 设置请求和传输超时时间5s,设置cookie策略

RequestConfig requestconfig = RequestConfig.custom()

.setSocketTimeout(5000).setConnectTimeout(5000)

.setCookieSpec(CookieSpecs.BEST_MATCH).build();

httpget.setConfig(requestconfig);

try {

response = httpClient.execute(httpget);

HttpEntity entity = response != null ? response.getEntity() : null;

if (entity != null) {

InputStream in = entity.getContent();

BufferedReader br = new BufferedReader(new InputStreamReader(

in, "UTF-8"));

String line;

while ((line = br.readLine()) != null) {

result.append(line);

result.append("\n");

}

in.close();

br.close();

}

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

if (response != null) response.close();

httpClient.close();

} catch (IOException e) {

e.printStackTrace();

}

return result.toString();

}

public static String httpPost(String url, String body) {

CloseableHttpClient httpClient = HttpClients.createDefault();

HttpPost httpPost = new HttpPost(url);

CloseableHttpResponse response = null;

String result = null;

try {

StringEntity stringEntity = new StringEntity(body, "UTF-8");

httpPost.setEntity(stringEntity);

response = httpClient.execute(httpPost);

HttpEntity entity = response != null ? response.getEntity() : null;

if (entity != null) {

result = EntityUtils.toString(entity, "UTF-8");

}

EntityUtils.consume(entity);

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

if (response != null) response.close();

httpClient.close();

} catch (IOException e) {

e.printStackTrace();

}

return result;

}

public static String httpPost(String url, Map<String, String> params) {

CloseableHttpClient httpClient = HttpClients.createDefault();

HttpPost httpPost = new HttpPost(url);

CloseableHttpResponse response = null;

String result = null;

try {

List<NameValuePair> nvps = new ArrayList<NameValuePair>();

for (String key : params.keySet()) {

nvps.add(new BasicNameValuePair(key, params.get(key)));

}

httpPost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));

response = httpClient.execute(httpPost);

HttpEntity entity = response != null ? response.getEntity() : null;

if (entity != null) {

result = EntityUtils.toString(entity, "UTF-8");

}

EntityUtils.consume(entity);

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

if (response != null) response.close();

httpClient.close();

} catch (IOException e) {

e.printStackTrace();

}

return result;

}

public static String getBodyString(BufferedReader br) {

String inputLine;

String str = "";

try {

while ((inputLine = br.readLine()) != null) {

str += inputLine;

}

br.close();

} catch (IOException e) {

System.out.println("IOException: " + e);

}

return str;

}

/**

* 设置url以及键值对参数

* @param url

* @param params

* @return

public static String getUrlWithParams(String url, Map<String, String> params) {

Iterator<String> keysIte = params.keySet().iterator();

int index = 0;

while (keysIte.hasNext()) {

String key = keysIte.next();

if (index == 0) {

url = url + "?" + key + "=" + params.get(key);

} else {

url = url + "&" + key + "=" + params.get(key);

}

index++;

}

return url;

}

/**

* 按照一定顺序设置url以及键值对参数

* @param url

* @param params

* @param orderList

* @return

public static String getUrlWithParams(String url, Map<String, String> params, List<String> orderList) {

int index = 0;

for (String key : orderList) {

if (index == 0) {

url = url + "?" + key + "=" + params.get(key);

} else {

url = url + "&" + key + "=" + params.get(key);

}

index++;

}

return url;

}

/**

* @param urlStr 请求的地址

* @param content 请求的参数格式为：name=xxx&pwd=xxx

* @param encoding 服务器端请求编码。如GBK,UTF-8等

* @return

public static String getResult(String urlStr, String content, String encoding) {

URL url = null;

HttpURLConnection connection = null;

try {

url = new URL(urlStr);

connection = (HttpURLConnection) url.openConnection();// 新建连接实例

connection.setConnectTimeout(2000);// 设置连接超时时间，单位毫秒

connection.setReadTimeout(2000);// 设置读取数据超时时间，单位毫秒

connection.setDoOutput(true);// 是否打开输出流 true|false

connection.setDoInput(true);// 是否打开输入流true|false

connection.setRequestMethod("GET");// 提交方法POST|GET

connection.setUseCaches(false);// 是否缓存true|false

connection.connect();// 打开连接端口

DataOutputStream out = new DataOutputStream(connection

.getOutputStream());// 打开输出流往对端服务器写数据

out.writeBytes(content);// 写数据,也就是提交你的表单 name=xxx&pwd=xxx

out.flush();// 刷新

out.close();// 关闭输出流

BufferedReader reader = new BufferedReader(new InputStreamReader(

connection.getInputStream(), encoding));// 往对端写完数据对端服务器返回数据

// ,以BufferedReader流来读取

StringBuffer buffer = new StringBuffer();

String line = "";

while ((line = reader.readLine()) != null) {

buffer.append(line);

}

reader.close();

return buffer.toString();

} catch (IOException e) {

e.printStackTrace();

} finally {

if (connection != null) {

connection.disconnect();// 关闭连接

}

return null;

}

DateUtil

/**

* 时间操作工具

* @author xaingzi

package com.sunshine.http_proxy.utils;

import org.apache.commons.lang3.StringUtils;

import javax.xml.datatype.DatatypeConfigurationException;

import javax.xml.datatype.DatatypeFactory;

import javax.xml.datatype.XMLGregorianCalendar;

import java.sql.Timestamp;

import java.text.DateFormatSymbols;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.*;

/**

* 日期转换工具

public class DateUtil {

public static final String DATE_DIVISION = "-";

/**

* yyyy-MM-dd HH:mm:ss

public static final String TIME_PATTERN_DEFAULT = "yyyy-MM-dd HH:mm:ss";

public static final String TIME_PATTERN_DEFAULT_NO_SS = "yyyy-MM-dd HH:mm";

/**

* yyyy-MM-dd

public static final String DATE_PATTERN_DEFAULT = "yyyy-MM-dd";

/**

* yyyyMMdd

public static final String DATA_PATTERN_YYYYMMDD = "yyyyMMdd";

/**

* HH:mm:ss

public static final String TIME_PATTERN_HHMMSS = "HH:mm:ss";

/**

* yyyy-MM-dd HH-mm-ss

public static final String TIME_PATTERN = "yyyy-MM-dd HH-mm-ss";

/**

* yyyyMMddHHmmss

public static final String TIME_PATTERN_DEFAULT_STR = "yyyyMMddHHmmss";

public static final String TIME_PATTERN_SSSS_STR = "yyyyMMddHHmmssSSSS";

public static final int SECOND = 1000;

public static final int MINUTE = 60 * SECOND;

public static final int HOUR = 60 * MINUTE;

public static final long DAY = 24l * HOUR;

/**

* Return the current date

* @return － DATE<br>

public static Date now() {

Calendar cal = Calendar.getInstance();

Date currDate = cal.getTime();

return currDate;

}

public static Timestamp nowTimestamp() {

Calendar cal = Calendar.getInstance();

return new Timestamp(cal.getTimeInMillis());

}

/**

* 给一个时间加上N分种或减去N分种后得到一个新的日期

* @param startDate

* 需要增加的日期时间

* @param addnos

* 添加的分钟数，可以是正数也可以是负数

* @return 操作后的日期

public static Date addMinute(Date startDate, int addnos) {

if (startDate == null) {

return null;

}

Calendar cc = Calendar.getInstance();

cc.setTime(startDate);

cc.add(Calendar.MINUTE, addnos);

return cc.getTime();

}

/**

* Return the current date string

* @return －产生的日期字符串<br>

public static String nowString() {

Calendar cal = Calendar.getInstance();

Date currDate = cal.getTime();

return formatDate(currDate);

}

/**

* Return the current date in the specified format

* @param strFormat

* @return

public static String nowString(String pattern) {

Calendar cal = Calendar.getInstance();

Date currDate = cal.getTime();

return format(currDate, pattern);

}

public static Timestamp parseTimestampDefault(String dateValue) {

return new Timestamp(parse(dateValue, TIME_PATTERN_DEFAULT).getTime());

}

public static Timestamp parseTimestamp(String dateValue) {

return new Timestamp(parse(dateValue, TIME_PATTERN_HHMMSS).getTime());

}

public static Timestamp parseTimestampYYMMDD(String dateValue) {

return new Timestamp(parse(dateValue, DATE_PATTERN_DEFAULT).getTime());

}

public static Timestamp parseTimestamp(String dateValue,String partten) {

return new Timestamp(parse(dateValue, partten).getTime());

}

public static Timestamp parseTimeNoStamp(String dateValue) {

if(null==dateValue||dateValue.trim().length()==0) {

dateValue=getNowDateString();

}

return new Timestamp(parse(dateValue, DATE_PATTERN_DEFAULT).getTime());

}

public static String getNowDateString() {

return format(new Date(),DATE_PATTERN_DEFAULT);

}

/**

* Parse a string and return a date value

* @param dateValue

* @return

* @throws Exception

public static Date parseDate(String dateValue) {

return parse(dateValue, DATE_PATTERN_DEFAULT);

}

/**

* Parse a strign and return a datetime value

* @param dateValue

* @return

public static Date parseTime(String dateValue) {

return parse(dateValue, TIME_PATTERN_DEFAULT);

}

/**

* Parse a string and return the date value in the specified format

* @param strFormat

* @param dateValue

* @return

* @throws ParseException

* @throws Exception

public static Date parse(String dateValue, String pattern) {

if (StringUtils.isEmpty(dateValue))

return null;

SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);

try {

return dateFormat.parse(dateValue);

} catch (ParseException pe) {

return null;

}

/**

* 将Timestamp类型的日期转换为系统参数定义的格式的字符串。

* @param aTs_Datetime

* 需要转换的日期。

* @return 转换后符合给定格式的日期字符串

public static String formatDate(Date d) {

return format(d, DATE_PATTERN_DEFAULT);

}

public static String formatDate(Timestamp d) {

return format(d, DATE_PATTERN_DEFAULT);

}

public static String formatDateddmmss(Date d) {

return format(d, TIME_PATTERN_DEFAULT);

}

/**

* 将Timestamp类型的日期转换为系统参数定义的格式的字符串(只有数字)。

* @param aTs_Datetime

* 需要转换的日期。

* @return 转换后符合给定格式的日期字符串

public static String formatTimeTargetStr(Date t) {

String timestr = null;

timestr = format(t, TIME_PATTERN_DEFAULT_STR);

return timestr;

}

/**

* 将Timestamp类型的日期转换为系统参数定义的格式的字符串(只有数字)。

* @param aTs_Datetime

* 需要转换的日期。

* @return 转换后符合给定格式的日期字符串

public String formatTimeStr(Date t) {

String timestr = null;

synchronized (this) {

timestr = format(t, TIME_PATTERN_DEFAULT_STR);

}

return timestr;

}

/**

* 豪秒将Timestamp 类型的日期转换为系统参数定义的格式的字符串(只有数字)。

* @param aTs_Datetime

* 需要转换的日期。

* @return 转换后符合给定格式的日期字符串

public String formatTimeSSSSStr(Date t) {

String timestr = null;

synchronized (this) {

timestr = format(t, TIME_PATTERN_SSSS_STR);

}

return timestr;

}

/**

* 将Timestamp类型的日期转换为系统参数定义的格式的字符串。

* @param aTs_Datetime

* 需要转换的日期。

* @return 转换后符合给定格式的日期字符串

public static String formatTime(Date t) {

return format(t, TIME_PATTERN_DEFAULT);

}

/**

* 将Date类型的日期转换为系统参数定义的格式的字符串。

* @param aTs_Datetime

* @param as_Pattern

* @return

public static String format(Date d, String pattern) {

if (d == null)

return null;

SimpleDateFormat dateFromat = new SimpleDateFormat(pattern);

return dateFromat.format(d);

}

/**

* 将Timestamp类型的日期转换为系统参数定义的格式的字符串。

* @param t

* @param pattern

* @return

public static String format(Timestamp t, String pattern) {

if (t == null)

return null;

Date date = new Date(t.getTime());

return DateUtil.format(date, pattern);

}

/**

* 将Timestamp类型的日期转换Date类型。

* @param t

* @return

public static Date timestamp2Date(Timestamp t) {

if (t == null)

return null;

return new Date(t.getTime());

}

/**

* 取得指定日期N天后的日期

* @param date

* @param days

* @return

public static Date addDays(Date date, int days) {

Calendar cal = Calendar.getInstance();

cal.setTime(date);

cal.add(Calendar.DAY_OF_MONTH, days);

return cal.getTime();

}

更详细的代码https://github.com/Shimmer8618/sunshine

最后编辑于：2019.10.20 23:54:38

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 204,684评论 6赞 478
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 87,143评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 151,214评论 0赞 337
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,788评论 1赞 277
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,796评论 5赞 368
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,665评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,027评论 3赞 399
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,679评论 0赞 258
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 41,346评论 1赞 299
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,664评论 2赞 321
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,766评论 1赞 331
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,412评论 4赞 321
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,015评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,974评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,203评论 1赞 260
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,073评论 2赞 350
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,501评论 2赞 343

Java编写ip代理池（一）

推荐阅读更多精彩内容