zoukankan      html  css  js  c++  java

  • httpClinent工具类

      1 package com.juchn.gateway.common.utils;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.IOException;
  5 import java.io.InputStream;
  6 import java.io.InputStreamReader;
  7 import java.security.KeyManagementException;
  8 import java.security.KeyStoreException;
  9 import java.security.NoSuchAlgorithmException;
 10 import java.security.cert.CertificateException;
 11 import java.security.cert.X509Certificate;
 12 import java.util.ArrayList;
 13 import java.util.Iterator;
 14 import java.util.List;
 15 import java.util.Map;
 16 import java.util.Map.Entry;
 17 
 18 import javax.net.ssl.SSLContext;
 19 
 20 import org.apache.commons.lang3.StringUtils;
 21 import org.apache.http.HttpEntity;
 22 import org.apache.http.HttpHost;
 23 import org.apache.http.NameValuePair;
 24 import org.apache.http.ParseException;
 25 import org.apache.http.client.config.RequestConfig;
 26 import org.apache.http.client.entity.UrlEncodedFormEntity;
 27 import org.apache.http.client.methods.CloseableHttpResponse;
 28 import org.apache.http.client.methods.HttpGet;
 29 import org.apache.http.client.methods.HttpPost;
 30 import org.apache.http.client.methods.HttpPut;
 31 import org.apache.http.client.utils.URLEncodedUtils;
 32 import org.apache.http.conn.ssl.NoopHostnameVerifier;
 33 import org.apache.http.entity.StringEntity;
 34 import org.apache.http.impl.client.CloseableHttpClient;
 35 import org.apache.http.impl.client.HttpClients;
 36 import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
 37 import org.apache.http.message.BasicNameValuePair;
 38 import org.apache.http.ssl.SSLContextBuilder;
 39 import org.apache.http.ssl.TrustStrategy;
 40 import org.apache.http.util.EntityUtils;
 41 import org.slf4j.Logger;
 42 import org.slf4j.LoggerFactory;
 43 
 44 /**
 45  * 新版httpClient的工具方法
 46  * 
 47  * @author tangzl
 48  * @since 2019年04月11日
 49  */
 50 public class HttpClientUtil {
 51 
 52     static Logger log = LoggerFactory.getLogger(HttpClientUtil.class);
 53     protected static final String CHARSET = "UTF-8";
 54     protected static final String CHARSET_GBK = "UTF-8";
 55     /** 默认超时时间 */
 56     private final static int default_timeout = 10000;
 57 
 58     private static PoolingHttpClientConnectionManager cm = null;
 59 
 60     private static CloseableHttpClient httpclient = null;
 61     static {
 62 
 63         // 多连接的线程安全的管理器
 64         cm = new PoolingHttpClientConnectionManager();
 65         cm.setDefaultMaxPerRoute(100); // 每个主机的最大并行链接数
 66         cm.setMaxTotal(200); // 客户端总并行链接最大数
 67 
 68         httpclient = HttpClients.custom().setConnectionManager(cm).build();
 69     }
 70 
 71     /**
 72      * 发送 get请求
 73      * 
 74      * @param url
 75      * @param timeout     超时时间
 76      * @param ignoreHttps 是否忽略https证书检查
 77      * @return
 78      */
 79     public static String get(String url, Map<String, String> params, Integer timeout, boolean ignoreHttps,
 80             HttpHost proxy) {
 81         CloseableHttpClient client = null;
 82         if (ignoreHttps) {
 83             client = getIgnoreHttpsClient();
 84         } else {
 85             client = httpclient;
 86         }
 87         try {
 88             HttpGet httpGet = null;
 89             if (params == null)
 90                 httpGet = new HttpGet(url);
 91             else {
 92                 List<NameValuePair> qparams = new ArrayList<NameValuePair>();
 93                 for (Entry<String, String> entry : params.entrySet()) {
 94                     qparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
 95                 }
 96                 String queryParams = URLEncodedUtils.format(qparams, "UTF-8");
 97                 if (url.indexOf("?") != -1) {
 98                     url += "&" + queryParams;
 99                 } else {
100                     url += "?" + queryParams;
101                 }
102                 httpGet = new HttpGet(url);
103             }
104             timeout = timeout != null ? timeout : default_timeout;
105             RequestConfig.Builder builder = RequestConfig.custom();// 设置请求和传输超时时间
106             if (null != proxy) {
107                 builder.setProxy(proxy);
108             }
109             RequestConfig requestConfig = builder.setSocketTimeout(timeout).setConnectTimeout(timeout).build();// 设置请求和传输超时时间
110             httpGet.setConfig(requestConfig);
111 
112             CloseableHttpResponse response = client.execute(httpGet);
113             HttpEntity entity = response.getEntity();
114             try {
115                 if (entity != null)
116                     return EntityUtils.toString(entity);
117             } finally {
118                 if (entity != null)
119                     EntityUtils.consume(entity);
120                 response.close();
121             }
122         } catch (ParseException e) {
123             log.error("发送HTTP请求时出现异常：" + e);
124             e.printStackTrace(System.out);
125         } catch (IOException e) {
126             log.error("发送HTTP请求时出现异常：" + e);
127             e.printStackTrace(System.out);
128         } catch (Exception e) {
129             log.error("发送HTTP请求时出现异常：" + e);
130             e.printStackTrace(System.out);
131         } finally {
132             /*
133              * try { httpclient.close(); } catch (IOException e) {
134              * log.error("关闭HTTP连接时出现异常：" + e); }
135              */
136         }
137         return null;
138     }
139 
140     /**
141      * 发送 get请求
142      * 
143      * @param url
144      * @param timeout     超时时间
145      * @param ignoreHttps 是否忽略https证书检查
146      * @return
147      */
148     public static String get(String url, Map<String, String> params, Map<String, Object> headers, Integer timeout,
149             boolean ignoreHttps) {
150         CloseableHttpClient client = null;
151         if (ignoreHttps) {
152             client = getIgnoreHttpsClient();
153         } else {
154             client = httpclient;
155         }
156         try {
157             HttpGet httpGet = null;
158             if (params != null && params.size() > 0) {
159                 List<NameValuePair> qparams = new ArrayList<NameValuePair>();
160                 for (Entry<String, String> entry : params.entrySet()) {
161                     qparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
162                 }
163                 String queryParams = URLEncodedUtils.format(qparams, "UTF-8");
164                 if (url.indexOf("?") != -1) {
165                     url += "&" + queryParams;
166                 } else {
167                     url += "?" + queryParams;
168                 }
169 
170             }
171             httpGet = new HttpGet(url);
172             httpGet.setHeader("Content-type", "application/json;charset=UTF-8");
173             if (headers != null && headers.size() > 0) {
174                 for (Iterator<String> iter = headers.keySet().iterator(); iter.hasNext();) {
175                     String key = iter.next();
176                     httpGet.setHeader(key, headers.get(key).toString());
177                 }
178             }
179 
180             timeout = timeout != null ? timeout : default_timeout;
181             RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
182                     .build();// 设置请求和传输超时时间
183             httpGet.setConfig(requestConfig);
184 
185             CloseableHttpResponse response = client.execute(httpGet);
186             HttpEntity entity = response.getEntity();
187             try {
188                 if (entity != null)
189                     return EntityUtils.toString(entity);
190             } finally {
191                 if (entity != null)
192                     EntityUtils.consume(entity);
193                 response.close();
194             }
195         } catch (ParseException e) {
196             log.error("发送HTTP请求时出现异常：" + e);
197             e.printStackTrace(System.out);
198         } catch (IOException e) {
199             log.error("发送HTTP请求时出现异常：" + e);
200             e.printStackTrace(System.out);
201         } catch (Exception e) {
202             log.error("发送HTTP请求时出现异常：" + e);
203             e.printStackTrace(System.out);
204         } finally {
205             /*
206              * try { httpclient.close(); } catch (IOException e) {
207              * log.error("关闭HTTP连接时出现异常：" + e); }
208              */
209         }
210         return null;
211     }
212 
213     /**
214      * 发送 get请求
215      * 
216      * @param url
217      * @param timeout     超时时间
218      * @param ignoreHttps 是否忽略https证书检查
219      * @return
220      */
221     public static String get(String url, Map<String, String> params, Integer timeout, boolean ignoreHttps) {
222         CloseableHttpClient client = null;
223         if (ignoreHttps) {
224             client = getIgnoreHttpsClient();
225         } else {
226             client = httpclient;
227         }
228         try {
229             HttpGet httpGet = null;
230             if (params == null)
231                 httpGet = new HttpGet(url);
232             else {
233                 List<NameValuePair> qparams = new ArrayList<NameValuePair>();
234                 for (Entry<String, String> entry : params.entrySet()) {
235                     qparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
236                 }
237                 String queryParams = URLEncodedUtils.format(qparams, "UTF-8");
238                 if (url.indexOf("?") != -1) {
239                     url += "&" + queryParams;
240                 } else {
241                     url += "?" + queryParams;
242                 }
243                 httpGet = new HttpGet(url);
244             }
245             timeout = timeout != null ? timeout : default_timeout;
246             RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
247                     .build();// 设置请求和传输超时时间
248             httpGet.setConfig(requestConfig);
249 
250             CloseableHttpResponse response = client.execute(httpGet);
251             HttpEntity entity = response.getEntity();
252             try {
253                 if (entity != null)
254                     return EntityUtils.toString(entity);
255             } finally {
256                 if (entity != null)
257                     EntityUtils.consume(entity);
258                 response.close();
259             }
260         } catch (ParseException e) {
261             log.error("发送HTTP请求时出现异常：" + e);
262             e.printStackTrace(System.out);
263         } catch (IOException e) {
264             log.error("发送HTTP请求时出现异常：" + e);
265             e.printStackTrace(System.out);
266         } catch (Exception e) {
267             log.error("发送HTTP请求时出现异常：" + e);
268             e.printStackTrace(System.out);
269         } finally {
270             /*
271              * try { httpclient.close(); } catch (IOException e) {
272              * log.error("关闭HTTP连接时出现异常：" + e); }
273              */
274         }
275         return null;
276     }
277 
278     /**
279      * 发送get请求
280      * 
281      * @param url
282      * @param timeout 超时时间(毫秒)
283      * @return
284      */
285     public static String get(String url, Map<String, String> params, Integer timeout) {
286         return get(url, params, timeout, false);
287     }
288 
289     /**
290      * 发送get请求
291      * 
292      * @param url
293      * @param timeout 超时时间(毫秒)
294      * @return
295      */
296     public static String get(String url, Map<String, String> params, Map<String, Object> headers) {
297         return get(url, params, headers, null, false);
298     }
299 
300     /**
301      * 发送 get请求
302      * 
303      * @param url
304      * @param timeout     超时时间
305      * @param ignoreHttps 是否忽略https证书检查
306      * @return
307      */
308     public static String get(String url, Integer timeout, boolean ignoreHttps) {
309         return get(url, null, timeout, ignoreHttps);
310     }
311 
312     /**
313      * 获取忽略https证书的client
314      * 
315      * @return
316      */
317     public static CloseableHttpClient getIgnoreHttpsClient() {
318         SSLContext sslContext = null;
319         try {
320             sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
321                 public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
322                     return true;
323                 }
324             }).build();
325         } catch (KeyManagementException e) {
326             e.printStackTrace();
327         } catch (NoSuchAlgorithmException e) {
328             e.printStackTrace();
329         } catch (KeyStoreException e) {
330             e.printStackTrace();
331         }
332 
333         return HttpClients.custom().setSslcontext(sslContext).setSSLHostnameVerifier(new NoopHostnameVerifier())
334                 .build();
335     }
336 
337     /**
338      * 发送 post请求
339      * 
340      * @param url
341      * @param timeout 超时时间(毫秒)
342      * @param params  请求参数
343      * @return
344      */
345     public static String post(String url, Map<String, String> params, Integer timeout) {
346 
347         CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(cm).build();
348         try {
349 
350             HttpPost httpPost = new HttpPost(url);
351             if (params != null) {
352                 List<NameValuePair> qparams = new ArrayList<NameValuePair>();
353                 for (Entry<String, String> entry : params.entrySet()) {
354                     qparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
355                 }
356                 httpPost.setEntity(new UrlEncodedFormEntity(qparams, "UTF-8"));
357             }
358             timeout = timeout != null ? timeout : default_timeout;
359             RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
360                     .build();// 设置请求和传输超时时间
361             httpPost.setConfig(requestConfig);
362 
363             CloseableHttpResponse response = httpclient.execute(httpPost);
364             HttpEntity entity = response.getEntity();
365             try {
366                 if (entity != null) {
367                     StringBuilder sb = new StringBuilder();
368                     String line = null;
369                     InputStream inputStream = entity.getContent();
370                     try {
371                         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
372                         while ((line = bufferedReader.readLine()) != null) {
373                             sb.append(line);
374                         }
375                     } finally {
376                         inputStream.close();
377                     }
378                     return sb.toString();
379                 }
380             } finally {
381                 response.close();
382             }
383 
384             /*
385              * try { if (entity != null) return EntityUtils.toString(entity); } finally { if
386              * (entity != null) EntityUtils.consume(entity); response.close(); }
387              */
388         } catch (ParseException e) {
389             log.error("发送HTTP请求时出现异常：" + e);
390             e.printStackTrace(System.out);
391         } catch (IOException e) {
392             log.error("发送HTTP请求时出现异常：" + e);
393             e.printStackTrace(System.out);
394         } catch (Exception e) {
395             log.error("发送HTTP请求时出现异常：" + e);
396             e.printStackTrace(System.out);
397         } finally {
398             /*
399              * try { httpclient.close(); } catch (IOException e) {
400              * log.error("关闭HTTP连接时出现异常：" + e); }
401              */
402         }
403         return null;
404     }
405 
406     /**
407      * 发送 post请求 带请求头
408      * 
409      * @param url
410      * @param params
411      * @param headers
412      * @param timeout
413      * @return
414      */
415     public static String post(String url, Map<String, String> params, Map<String, String> headers, Integer timeout) {
416 
417         CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(cm).build();
418         try {
419             HttpPost httpPost = new HttpPost(url);
420 
421             if (params != null) {
422                 List<NameValuePair> qparams = new ArrayList<NameValuePair>();
423                 for (Entry<String, String> entry : params.entrySet()) {
424                     qparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
425                 }
426                 httpPost.setEntity(new UrlEncodedFormEntity(qparams, CHARSET));
427             }
428             if (headers != null && headers.size() > 0) {
429                 for (Iterator<String> iter = headers.keySet().iterator(); iter.hasNext();) {
430                     String key = iter.next();
431                     httpPost.setHeader(key, headers.get(key));
432                 }
433             }
434             timeout = timeout != null ? timeout : default_timeout;
435             RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
436                     .build();// 设置请求和传输超时时间
437             httpPost.setConfig(requestConfig);
438 
439             CloseableHttpResponse response = httpclient.execute(httpPost);
440             HttpEntity entity = response.getEntity();
441 
442             // 方法一：
443             try {
444                 if (entity != null) {
445                     StringBuilder sb = new StringBuilder();
446                     String line = null;
447                     InputStream inputStream = entity.getContent();
448                     try {
449                         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
450                         while ((line = bufferedReader.readLine()) != null) {
451                             sb.append(line);
452                         }
453                     } finally {
454                         inputStream.close();
455                     }
456                     return sb.toString();
457                 }
458             } finally {
459                 response.close();
460             }
461 
462             // 方法二：
463             /*
464              * try { if (entity != null) return EntityUtils.toString(entity); } finally { if
465              * (entity != null) EntityUtils.consume(entity); response.close(); }
466              */
467         } catch (ParseException e) {
468             log.error("发送HTTP请求时出现异常：" + e);
469             e.printStackTrace(System.out);
470         } catch (IOException e) {
471             log.error("发送HTTP请求时出现异常：" + e);
472             e.printStackTrace(System.out);
473         } catch (Exception e) {
474             log.error("发送HTTP请求时出现异常：" + e);
475             e.printStackTrace(System.out);
476         } finally {
477             /*
478              * try { httpclient.close(); } catch (IOException e) {
479              * log.error("关闭HTTP连接时出现异常：" + e); }
480              */
481         }
482         return null;
483     }
484 
485     /**
486      * post body
487      * 
488      * @param url
489      * @param params 请求body内容
490      * @return
491      */
492     public static String postBody(String url, String params, Map<String, String> headers, Integer timeout) {
493 
494         CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(cm).build();
495         try {
496 
497             HttpPost httpPost = new HttpPost(url);
498             if (!StringUtils.isEmpty(params)) {
499                 httpPost.setEntity(new StringEntity(params, "UTF-8"));
500             }
501             if (headers != null && headers.size() > 0) {
502                 for (Iterator<String> iter = headers.keySet().iterator(); iter.hasNext();) {
503                     String key = iter.next();
504                     httpPost.setHeader(key, headers.get(key));
505                 }
506             }
507             timeout = timeout != null ? timeout : default_timeout;
508             RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
509                     .build();// 设置请求和传输超时时间
510             httpPost.setConfig(requestConfig);
511 
512             CloseableHttpResponse response = httpclient.execute(httpPost);
513             HttpEntity entity = response.getEntity();
514             // 方法一：
515             try {
516                 if (entity != null) {
517                     StringBuilder sb = new StringBuilder();
518                     String line = null;
519                     InputStream inputStream = entity.getContent();
520                     try {
521                         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
522                         while ((line = bufferedReader.readLine()) != null) {
523                             sb.append(line);
524                         }
525                     } finally {
526                         inputStream.close();
527                     }
528                     return sb.toString();
529                 }
530             } finally {
531                 response.close();
532             }
533             // 方法二：
534             /*
535              * try { if (entity != null) return EntityUtils.toString(entity); } finally { if
536              * (entity != null) EntityUtils.consume(entity); response.close(); }
537              */
538         } catch (ParseException e) {
539             log.error("发送HTTP请求时出现异常：" + e);
540             e.printStackTrace(System.out);
541         } catch (IOException e) {
542             log.error("发送HTTP请求时出现异常：" + e);
543             e.printStackTrace(System.out);
544         } catch (Exception e) {
545             log.error("发送HTTP请求时出现异常：" + e);
546             e.printStackTrace(System.out);
547         } finally {
548         }
549         return null;
550     }
551 
552     public static String postBodyJson(String url, String params, Map<String, String> headers, Integer timeout) {
553 
554         CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(cm).build();
555         try {
556 
557             HttpPost httpPost = new HttpPost(url);
558             httpPost.setHeader("Content-type", "application/json;charset=UTF-8");
559             if (!StringUtils.isEmpty(params)) {
560                 httpPost.setEntity(new StringEntity(params, "UTF-8"));
561             }
562             if (headers != null && headers.size() > 0) {
563                 for (Iterator<String> iter = headers.keySet().iterator(); iter.hasNext();) {
564                     String key = iter.next();
565                     httpPost.setHeader(key, headers.get(key));
566                 }
567             }
568             timeout = timeout != null ? timeout : default_timeout;
569             RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
570                     .build();// 设置请求和传输超时时间
571             httpPost.setConfig(requestConfig);
572 
573             CloseableHttpResponse response = httpclient.execute(httpPost);
574             HttpEntity entity = response.getEntity();
575             // 方法一：
576             try {
577                 if (entity != null) {
578                     StringBuilder sb = new StringBuilder();
579                     String line = null;
580                     InputStream inputStream = entity.getContent();
581                     try {
582                         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
583                         while ((line = bufferedReader.readLine()) != null) {
584                             sb.append(line);
585                         }
586                     } finally {
587                         inputStream.close();
588                     }
589                     return sb.toString();
590                 }
591             } finally {
592                 response.close();
593             }
594             // 方法二：
595             /*
596              * try { if (entity != null) return EntityUtils.toString(entity); } finally { if
597              * (entity != null) EntityUtils.consume(entity); response.close(); }
598              */
599         } catch (ParseException e) {
600             log.error("发送HTTP请求时出现异常：" + e);
601             e.printStackTrace(System.out);
602         } catch (IOException e) {
603             log.error("发送HTTP请求时出现异常：" + e);
604             e.printStackTrace(System.out);
605         } catch (Exception e) {
606             log.error("发送HTTP请求时出现异常：" + e);
607             e.printStackTrace(System.out);
608         } finally {
609         }
610         return null;
611     }
612     
613     public static String putBodyJson(String url, String params, Map<String, String> headers, Integer timeout) {
614 
615         CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(cm).build();
616         try {
617 
618             HttpPut httpPost = new HttpPut(url);
619             httpPost.setHeader("Content-type", "application/json;charset=UTF-8");
620             if (!StringUtils.isEmpty(params)) {
621                 httpPost.setEntity(new StringEntity(params, "UTF-8"));
622             }
623             if (headers != null && headers.size() > 0) {
624                 for (Iterator<String> iter = headers.keySet().iterator(); iter.hasNext();) {
625                     String key = iter.next();
626                     httpPost.setHeader(key, headers.get(key));
627                 }
628             }
629             timeout = timeout != null ? timeout : default_timeout;
630             RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
631                     .build();// 设置请求和传输超时时间
632             httpPost.setConfig(requestConfig);
633 
634             CloseableHttpResponse response = httpclient.execute(httpPost);
635             HttpEntity entity = response.getEntity();
636             // 方法一：
637             try {
638                 if (entity != null) {
639                     StringBuilder sb = new StringBuilder();
640                     String line = null;
641                     InputStream inputStream = entity.getContent();
642                     try {
643                         BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
644                         while ((line = bufferedReader.readLine()) != null) {
645                             sb.append(line);
646                         }
647                     } finally {
648                         inputStream.close();
649                     }
650                     return sb.toString();
651                 }
652             } finally {
653                 response.close();
654             }
655             // 方法二：
656             /*
657              * try { if (entity != null) return EntityUtils.toString(entity); } finally { if
658              * (entity != null) EntityUtils.consume(entity); response.close(); }
659              */
660         } catch (ParseException e) {
661             log.error("发送HTTP请求时出现异常：" + e);
662             e.printStackTrace(System.out);
663         } catch (IOException e) {
664             log.error("发送HTTP请求时出现异常：" + e);
665             e.printStackTrace(System.out);
666         } catch (Exception e) {
667             log.error("发送HTTP请求时出现异常：" + e);
668             e.printStackTrace(System.out);
669         } finally {
670         }
671         return null;
672     }
673 }
  • 相关阅读:
    js之iframe子页面与父页面通信
    PHP安全编程：HTTP请求欺骗
    PHP安全编程：防止SQL注入
    PHP多种序列化/反序列化的方法
    empty(),isset()与is_null()的实例测试
    &nbsp|&quot|&amp|&lt|&gt等html字符转义
    手把手叫你SQL注入攻防（PHP语法）
    HTTP协议详解
    Cache缓存机制与文件缓存原理PHP2
    数据变成了真正的生产资料，而且是人类第一次没有依赖大自然，单纯依靠自身行为获得的生产资料。
  • 原文地址：https://www.cnblogs.com/yangyang2018/p/11424489.html
Copyright © 2011-2022 走看看