首页 文章 精选 留言 我的

Java调用Restful API接口的几种方式–HTTPS

2018-01-20 675

最近有一个需求，为客户提供一些Restful API接口，QA使用postman进行测试，但是postman的测试接口与java调用的相似但并不相同，于是想自己写一个程序去测试Restful API接口，由于使用的是HTTPS，所以还要考虑到对于HTTPS的处理。由于我也是首次使用的Java调用REST风格的接口，所以还要研究一番，自然也是查阅了一些资料。

分析：这个问题与模块之间的调用不同，比如我有两个模块前端和后端，前端提供前台展示，后端提供数据支持。之前使用过Hession去把后端提供的服务注册成远程服务，在前端可以通过这种远程服务直接调到后端的接口。但这对于一个公司自己的一个项目耦合性比较高的情况下使用，没有问题。但是如果给客户注册这种远程服务，似乎不太好，耦合性太高。所以就考虑用一下方式进行处理。

一，HttpClient的

HttpClient的大家也许比较熟悉但又比较陌生，熟悉是知道他可以远程调用比如请求一个URL，然后在响应里获取到返回状态和返回信息，但是今天讲的稍微复杂一点，因为今天的主题是HTTPS，这个牵涉到证书或用户认证的问题。

确定使用的HttpClient之后，查询相关资料，发现的HttpClient的新版本与老版本不同，随然兼容老版本，但已经不提倡老版本是使用方式，很多都已经标记为过时的方法或类。今天就分别使用老版本4.2和最新版本4.5.3来写代码。

老版本4.2

需要认证

在准备证书阶段选择的是使用证书认证

  1. 包 com.darren.test.https.v42;
  3. import  java.io.File;
  4. import  java.io.FileInputStream;
  5. import  java.security.KeyStore;
  7. import  org.apache.http.conn.ssl.SSLSocketFactory;
  9. 公共类 HTTPSCertifiedClient  扩展 HTTPSClient {
  11.     public  HTTPSCertifiedClient（）{
  13.     }
  15.     @覆盖
  16.     公共无效 prepareCertificate（）  抛出 异常{
  17.         //获得密匙库
  18.         KeyStore trustStore = KeyStore.getInstance（KeyStore.getDefaultType（））;
  19.         FileInputStream instream =  new  FileInputStream（
  20.                 新 文件（“C：/Users/zhda6001/Downloads/software/xxx.keystore” ））;
  21.         // FileInputStream instream = new FileInputStream（new File（“C：/Users/zhda6001/Downloads/xxx.keystore”））;
  22.         //密匙库的密码
  23.         trustStore.load（instream，  “password” .toCharArray（））;
  24.         //注册密匙库
  25.         this .socketFactory =  new  SSLSocketFactory（trustStore）;
  26.         //不校验域名
  27.         socketFactory.setHostnameVerifier（SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER）;
  28.     }
  29. }

跳过认证

在准备证书阶段选择的是跳过认证

  1. 包 com.darren.test.https.v42;
  3. import  java.security.cert.CertificateException;
  4. import  java.security.cert.X509Certificate;
  6. import  javax.net.ssl.SSLContext;
  7. import  javax.net.ssl.TrustManager;
  8. import  javax.net.ssl.X509TrustManager;
  10. import  org.apache.http.conn.ssl.SSLSocketFactory;
  12. 公共类 HTTPSTrustClient  扩展 HTTPSClient {
  14.     public  HTTPSTrustClient（）{
  16.     }
  18.     @覆盖
  19.     公共无效 prepareCertificate（）  抛出 异常{
  20.         //跳过证书验证
  21.         SSLContext ctx = SSLContext.getInstance（“TLS” ）;
  22.         X509TrustManager tm =  new  X509TrustManager（）{
  23.             @覆盖
  24.             公共无效 checkClientTrusted（X509Certificate []链，字符串authType）  抛出 CertificateException {
  25.             }
  27.             @覆盖
  28.             公共无效 checkServerTrusted（X509Certificate []链，字符串authType）  抛出 CertificateException {
  29.             }
  31.             @覆盖
  32.             public  X509Certificate [] getAcceptedIssuers（）{
  33.                 返回null ;
  34.             }
  35.         };
  36.         //设置成已信任的证书
  37.         ctx.init（null ，  new  TrustManager [] {tm}，  null ）;
  38.         //穿件SSL socket工厂，并且设置不检查主机名称
  39.         this .socketFactory =  new  SSLSocketFactory（ctx，SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER）;
  40.     }
  41. }

总结

现在发现这两个类都继承了同一个类HTTPSClient，并且HTTPSClient继承了DefaultHttpClient类，可以发现，这里使用了模板方法模式。

  1. 包 com.darren.test.https.v42;
  3. 导入 org.apache.http.conn.ClientConnectionManager;
  4. import  org.apache.http.conn.scheme.Scheme;
  5. import  org.apache.http.conn.scheme.SchemeRegistry;
  6. import  org.apache.http.conn.ssl.SSLSocketFactory;
  7. import  org.apache.http.impl.client.DefaultHttpClient;
  9. 公共抽象类 HTTPSClient  扩展 DefaultHttpClient {
  11.     受保护的 SSLSocketFactory socketFactory;
  13.     / **
  14.      *初始化HTTPSClient
  15.      * 
  16.      * @return返回当前实例
  17.      * @例外
  18.      * /
  19.     公共 HTTPSClient init（）  抛出 异常{
  20.         这个.prepareCertificate（）;
  21.         这个.regist（）;
  23.         返回这个;
  24.     }
  26.     / **
  27.      *准备证书验证
  28.      * 
  29.      * @例外
  30.      * /
  31.     public abstract void  prepareCertificate（）  throws  Exception;
  33.     / **
  34.      *注册协议和端口，此方法也可以被子类重写
  35.      * /
  36.     保护无效的 注册表（）{
  37.         ClientConnectionManager ccm =  this .getConnectionManager（）;
  38.         SchemeRegistry sr = ccm.getSchemeRegistry（）;
  39.         sr.register（new  Scheme（“https” ，  443 ，socketFactory））;
  40.     }
  41. }

下边是工具类

  1. 包 com.darren.test.https.v42;
  3. import  java.util.ArrayList;
  4. import  java.util.List;
  5. import  java.util.Map;
  6. import  java.util.Set;
  8. 导入 org.apache.http.HttpEntity;
  9. 导入 org.apache.http.HttpResponse;
  10. import  org.apache.http.NameValuePair;
  11. import  org.apache.http.client.entity.UrlEncodedFormEntity;
  12. import  org.apache.http.client.methods.HttpGet;
  13. import  org.apache.http.client.methods.HttpPost;
  14. import  org.apache.http.client.methods.HttpRequestBase;
  15. import  org.apache.http.message.BasicNameValuePair;
  16. import  org.apache.http.util.EntityUtils;
  18. 公共类 HTTPSClientUtil {
  19.     private static final  String DEFAULT_CHARSET =  “UTF-8” ;
  21.     public static  String doPost（HTTPSClient httpsClient，String url，Map <String，String> paramHeader，
  22.             Map <String，String> paramBody）  throws  Exception {
  23.         返回 doPost（httpsClient，url，paramHeader，paramBody，DEFAULT_CHARSET）;
  24.     }
  26.     public static  String doPost（HTTPSClient httpsClient，String url，Map <String，String> paramHeader，
  27.             Map <String，String> paramBody，String charset）  throws  Exception {
  29.         String result =  null ;
  30.         HttpPost httpPost =  new  HttpPost（url）;
  31.         setHeader（httpPost，paramHeader）;
  32.         setBody（httpPost，paramBody，charset）;
  34.         HttpResponse响应= httpsClient.execute（httpPost）;
  35.         if  （response！=  null ）{
  36.             HttpEntity resEntity = response.getEntity（）;
  37.             if  （resEntity！=  null ）{
  38.                 结果= EntityUtils.toString（resEntity，字符集）;
  39.             }
  40.         }
  42.         返回 结果;
  43.     }
  45.     public static  String doGet（HTTPSClient httpsClient，String url，Map <String，String> paramHeader，
  46.             Map <String，String> paramBody）  throws  Exception {
  47.         返回 doGet（httpsClient，url，paramHeader，paramBody，DEFAULT_CHARSET）;
  48.     }
  50.     public static  String doGet（HTTPSClient httpsClient，String url，Map <String，String> paramHeader，
  51.             Map <String，String> paramBody，String charset）  throws  Exception {
  53.         String result =  null ;
  54.         HttpGet httpGet =  new  HttpGet（url）;
  55.         setHeader（httpGet，paramHeader）;
  57.         HttpResponse响应= httpsClient.execute（httpGet）;
  58.         if  （response！=  null ）{
  59.             HttpEntity resEntity = response.getEntity（）;
  60.             if  （resEntity！=  null ）{
  61.                 结果= EntityUtils.toString（resEntity，字符集）;
  62.             }
  63.         }
  65.         返回 结果;
  66.     }
  68.     private static void  setHeader（HttpRequestBase request，Map <String，String> paramHeader）{
  69.         //设置标题
  70.         if  （paramHeader！=  null ）{
  71.             设置<String> keySet = paramHeader.keySet（）;
  72.             for  （String key：keySet）{
  73.                 request.addHeader（key，paramHeader.get（key））;
  74.             }
  75.         }
  76.     }
  78.     private static void  setBody（HttpPost httpPost，Map <String，String> paramBody，String charset）  throws  Exception {
  79.         //设置参数
  80.         if  （paramBody！=  null ）{
  81.             List <NameValuePair> list =  new  ArrayList <NameValuePair>（）;
  82.             设置<String> keySet = paramBody.keySet（）;
  83.             for  （String key：keySet）{
  84.                 list.add（new  BasicNameValuePair（key，paramBody.get（key）））;
  85.             }
  87.             if  （list.size（）>  0 ）{
  88.                 UrlEncodedFormEntity entity =  new  UrlEncodedFormEntity（list，charset）;
  89.                 httpPost.setEntity（实体）;
  90.             }
  91.         }
  92.     }
  93. }

然后是测试类：

  1. 包 com.darren.test.https.v42;
  3. import  java.util.HashMap;
  4. import  java.util.Map;
  6. 公共类 HTTPSClientTest {
  8.     公共静态无效的 主要（字符串[]参数）  抛出 异常{
  9.         HTTPSClient httpsClient =  null ;
  11.         httpsClient =  new  HTTPSTrustClient（）。init（）;
  12.         // httpsClient = new HTTPSCertifiedClient（）。init（）;
  14.         String url =  “https://1.2.6.2:8011/xxx/api/getToken” ;
  15.         // String url =“https://1.2.6.2:8011/xxx/api/getHealth”;
  17.         Map <String，String> paramHeader =  new  HashMap <>（）;
  18.         //paramHeader.put(“Content-Type“，”application / json“）;
  19.         paramHeader.put（“Accept” ，  “application / xml” ）;
  20.         Map <String，String> paramBody =  new  HashMap <>（）;
  21.         paramBody.put（“client_id” ，  “ankur.tandon.ap@xxx.com” ）;
  22.         paramBody.put（“client_secret” ，  “P @ ssword_1” ）;
  23.         String result = HTTPSClientUtil.doPost（httpsClient，url，paramHeader，paramBody）;
  25.         // String result = HTTPSClientUtil.doGet（httpsClient，url，null，null）;
  27.         的System.out.println（结果）;
  28.     }
  30.  }

返回信息：

  1. <？xml version = “1.0” encoding = “utf-8” ？>
  3. < 令牌> jkf8RL0sw + Skkflj8RbKI5hP1bEQK8PrCuTZPpBINqMYKRMxY1kWCjmCfT191Zpp88VV1aGHW8oYNWjEYS0axpLuGAX89ejCoWNbikCc1UvfyesXHLktcJqyUFiVjevhrEQxJPHncLQYWP + Xse5oD9X8vKFKk7InNTMRzQK7YBTZ / e3U7gswM / 5cvAHFl6o9rEq9cWPXavZNohyvnXsohSzDo + BXAtXxa1xpEDLy / 8小时/ UaP4n4dlZDJJ3B8t1Xh + CRRIoMOPxf7c5wKhHtOkEOeXW + xoPQKKSx5CKWwJpPuGIIFWF / PaqWg + JUOsVT7QGdPv8PMWJ9DwEwjTdxguDg == </ 令牌>

新版本4.5.3

需要认证

  1. 包 com.darren.test.https.v45;
  3. import  java.io.File;
  4. import  java.io.FileInputStream;
  5. import  java.security.KeyStore;
  7. import  javax.net.ssl.SSLContext;
  9. import  org.apache.http.conn.ssl.SSLConnectionSocketFactory;
  10. import  org.apache.http.conn.ssl.TrustSelfSignedStrategy;
  11. import  org.apache.http.ssl.SSLContexts;
  13. 公共类 HTTPSCertifiedClient  扩展 HTTPSClient {
  15.     public  HTTPSCertifiedClient（）{
  17.     }
  19.     @覆盖
  20.     公共无效 prepareCertificate（）  抛出 异常{
  21.         //获得密匙库
  22.         KeyStore trustStore = KeyStore.getInstance（KeyStore.getDefaultType（））;
  23.         FileInputStream instream =  new  FileInputStream（
  24.                 新 文件（“C：/Users/zhda6001/Downloads/software/xxx.keystore” ））;
  25.         // FileInputStream instream = new FileInputStream（new File（“C：/Users/zhda6001/Downloads/xxx.keystore”））;
  26.         尝试 {
  27.             //密匙库的密码
  28.             trustStore.load（instream，  “password” .toCharArray（））;
  29.         }  最后 {
  30.             instream.close（）;
  31.         }
  33.         SSLContext sslcontext = SSLContexts.custom（）。loadTrustMaterial（trustStore，TrustSelfSignedStrategy.INSTANCE）
  34.                 。建立（）;
  35.         this .connectionSocketFactory =  new  SSLConnectionSocketFactory（sslcontext）;
  36.     }
  38. }

跳过认证

  1. 包 com.darren.test.https.v45;
  3. import  java.security.cert.CertificateException;
  4. import  java.security.cert.X509Certificate;
  6. import  javax.net.ssl.SSLContext;
  7. import  javax.net.ssl.TrustManager;
  8. import  javax.net.ssl.X509TrustManager;
  10. import  org.apache.http.conn.ssl.SSLConnectionSocketFactory;
  12. 公共类 HTTPSTrustClient  扩展 HTTPSClient {
  14.     public  HTTPSTrustClient（）{
  16.     }
  18.     @覆盖
  19.     公共无效 prepareCertificate（）  抛出 异常{
  20.         //跳过证书验证
  21.         SSLContext ctx = SSLContext.getInstance（“TLS” ）;
  22.         X509TrustManager tm =  new  X509TrustManager（）{
  23.             @覆盖
  24.             公共无效 checkClientTrusted（X509Certificate []链，字符串authType）  抛出 CertificateException {
  25.             }
  27.             @覆盖
  28.             公共无效 checkServerTrusted（X509Certificate []链，字符串authType）  抛出 CertificateException {
  29.             }
  31.             @覆盖
  32.             public  X509Certificate [] getAcceptedIssuers（）{
  33.                 返回null ;
  34.             }
  35.         };
  36.         //设置成已信任的证书
  37.         ctx.init（null ，  new  TrustManager [] {tm}，  null ）;
  38.         this .connectionSocketFactory =  new  SSLConnectionSocketFactory（ctx）;
  39.     }
  40. }

总结

  1. 包 com.darren.test.https.v45;
  3. import  org.apache.http.config.Registry;
  4. import  org.apache.http.config.RegistryBuilder;
  5. import  org.apache.http.conn.socket.ConnectionSocketFactory;
  6. import  org.apache.http.conn.socket.PlainConnectionSocketFactory;
  7. import  org.apache.http.impl.client.CloseableHttpClient;
  8. import  org.apache.http.impl.client.HttpClientBuilder;
  9. import  org.apache.http.impl.client.HttpClients;
  10. import  org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
  12. 公共抽象类 HTTPSClient  扩展 HttpClientBuilder {
  13.     私有的 CloseableHttpClient客户端;
  14.     受保护的 ConnectionSocketFactory connectionSocketFactory;
  16.     / **
  17.      *初始化HTTPSClient
  18.      * 
  19.      * @return返回当前实例
  20.      * @例外
  21.      * /
  22.     public  closeableHttpClient init（）  抛出 Exception {
  23.         这个.prepareCertificate（）;
  24.         这个.regist（）;
  26.         返回这个.client;
  27.     }
  29.     / **
  30.      *准备证书验证
  31.      * 
  32.      * @例外
  33.      * /
  34.     public abstract void  prepareCertificate（）  throws  Exception;
  36.     / **
  37.      *注册协议和端口，此方法也可以被子类重写
  38.      * /
  39.     保护无效的 注册表（）{
  40.         //设置协议http和https对应的处理socket链接工厂的对象
  41.         注册表<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder。<ConnectionSocketFactory> create（）
  42.                 .register（“http” ，PlainConnectionSocketFactory.INSTANCE）
  43.                 .register（“https” ，  this .connectionSocketFactory）
  44.                 。建立（）;
  45.         PoolingHttpClientConnectionManager connManager =  new  PoolingHttpClientConnectionManager（socketFactoryRegistry）;
  46.         HttpClients.custom（）setConnectionManager（连接管理）。
  48.         //创建自定义的httpclient对象
  49.         这个.client = HttpClients.custom（）。setConnectionManager（connManager）.build（）;
  50.         // CloseableHttpClient client = HttpClients.createDefault（）;
  51.     }
  52. }

工具类：

  1. 包 com.darren.test.https.v45;
  3. import  java.util.ArrayList;
  4. import  java.util.List;
  5. import  java.util.Map;
  6. import  java.util.Set;
  8. 导入 org.apache.http.HttpEntity;
  9. 导入 org.apache.http.HttpResponse;
  10. import  org.apache.http.NameValuePair;
  11. import  org.apache.http.client.HttpClient;
  12. import  org.apache.http.client.entity.UrlEncodedFormEntity;
  13. import  org.apache.http.client.methods.HttpGet;
  14. import  org.apache.http.client.methods.HttpPost;
  15. import  org.apache.http.client.methods.HttpRequestBase;
  16. import  org.apache.http.message.BasicNameValuePair;
  17. import  org.apache.http.util.EntityUtils;
  19. 公共类 HTTPSClientUtil {
  20.     private static final  String DEFAULT_CHARSET =  “UTF-8” ;
  22.     public static  String doPost（HttpClient httpClient，String url，Map <String，String> paramHeader，
  23.             Map <String，String> paramBody）  throws  Exception {
  24.         返回 doPost（httpClient，url，paramHeader，paramBody，DEFAULT_CHARSET）;
  25.     }
  27.     public static  String doPost（HttpClient httpClient，String url，Map <String，String> paramHeader，
  28.             Map <String，String> paramBody，String charset）  throws  Exception {
  30.         String result =  null ;
  31.         HttpPost httpPost =  new  HttpPost（url）;
  32.         setHeader（httpPost，paramHeader）;
  33.         setBody（httpPost，paramBody，charset）;
  35.         HttpResponse响应= httpClient.execute（httpPost）;
  36.         if  （response！=  null ）{
  37.             HttpEntity resEntity = response.getEntity（）;
  38.             if  （resEntity！=  null ）{
  39.                 结果= EntityUtils.toString（resEntity，字符集）;
  40.             }
  41.         }
  43.         返回 结果;
  44.     }
  46.     public static  String doGet（HttpClient httpClient，String url，Map <String，String> paramHeader，
  47.             Map <String，String> paramBody）  throws  Exception {
  48.         返回 doGet（httpClient，url，paramHeader，paramBody，DEFAULT_CHARSET）;
  49.     }
  51.     public static  String doGet（HttpClient httpClient，String url，Map <String，String> paramHeader，
  52.             Map <String，String> paramBody，String charset）  throws  Exception {
  54.         String result =  null ;
  55.         HttpGet httpGet =  new  HttpGet（url）;
  56.         setHeader（httpGet，paramHeader）;
  58.         HttpResponse响应= httpClient.execute（httpGet）;
  59.         if  （response！=  null ）{
  60.             HttpEntity resEntity = response.getEntity（）;
  61.             if  （resEntity！=  null ）{
  62.                 结果= EntityUtils.toString（resEntity，字符集）;
  63.             }
  64.         }
  66.         返回 结果;
  67.     }
  69.     private static void  setHeader（HttpRequestBase request，Map <String，String> paramHeader）{
  70.         //设置标题
  71.         if  （paramHeader！=  null ）{
  72.             设置<String> keySet = paramHeader.keySet（）;
  73.             for  （String key：keySet）{
  74.                 request.addHeader（key，paramHeader.get（key））;
  75.             }
  76.         }
  77.     }
  79.     private static void  setBody（HttpPost httpPost，Map <String，String> paramBody，String charset）  throws  Exception {
  80.         //设置参数
  81.         if  （paramBody！=  null ）{
  82.             List <NameValuePair> list =  new  ArrayList <NameValuePair>（）;
  83.             设置<String> keySet = paramBody.keySet（）;
  84.             for  （String key：keySet）{
  85.                 list.add（new  BasicNameValuePair（key，paramBody.get（key）））;
  86.             }
  88.             if  （list.size（）>  0 ）{
  89.                 UrlEncodedFormEntity entity =  new  UrlEncodedFormEntity（list，charset）;
  90.                 httpPost.setEntity（实体）;
  91.             }
  92.         }
  93.     }
  94. }

测试类：

  1. 包 com.darren.test.https.v45;
  3. import  java.util.HashMap;
  4. import  java.util.Map;
  6. import  org.apache.http.client.HttpClient;
  8. 公共类 HTTPSClientTest {
  10.     公共静态无效的 主要（字符串[]参数）  抛出 异常{
  11.         HttpClient httpClient =  null ;
  13.         // httpClient = new HTTPSTrustClient（）。init（）;
  14.         httpClient =  new  HTTPSCertifiedClient（）。init（）;
  16.         String url =  “https://1.2.6.2:8011/xxx/api/getToken” ;
  17.         // String url =“https://1.2.6.2:8011/xxx/api/getHealth”;
  19.         Map <String，String> paramHeader =  new  HashMap <>（）;
  20.         paramHeader.put（“Accept” ，  “application / xml” ）;
  21.         Map <String，String> paramBody =  new  HashMap <>（）;
  22.         paramBody.put（“client_id” ，  “ankur.tandon.ap@xxx.com” ）;
  23.         paramBody.put（“client_secret” ，  “P @ ssword_1” ）;
  24.         String result = HTTPSClientUtil.doPost（httpClient，url，paramHeader，paramBody）;
  26.         // String result = HTTPSClientUtil.doGet（httpsClient，url，null，null）;
  28.         的System.out.println（结果）;
  29.     }
  31. }

结果：

  1. <？xml version = “1.0” encoding = “utf-8” ？>
  3. < 令牌> RxitF9 // 7NxwXJS2cjIjYhLtvzUNvMZxxEQtGN0u07sC9ysJeIbPqte3hCjULSkoXPEUYGUVeyI9jv7 / WikLrzxYKc3OSpaTSM0kCbCKphu0TB2Cn / nfzv9fMLueOWFBdyz + N0sEiI9K + 0Gp7920DFEncn17wUJVmC0u2jwvM5FAjQKmilwodXZ6a0Dq + D7dQDJwVcwxBvJ2ilhyIb3pr805Vppmi9atXrVAKO0ODa006wEJFOfcgyG5p70wpJ5rrBL85vfy9WCvkd1R7j6NVjhXgH2gNimHkjEJorMjdXW2gKiUsiWsELi / XPswao7 / CTWNwTnctGK8PX2ZUB0ZfA == </ 令牌>

二，HttpURLConnection类

三，春节的RestTemplate

其它方式以后补充

原文地址http://www.bieryun.com/562.html

上一篇 下一篇
优秀的个人博客,低调大师

微信关注我们

原文链接：https://yq.aliyun.com/articles/387833

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Python快速编程技巧

参与文末每日话题讨论,赠送异步新书 异步图书君 而在本文中，我们将看到更多特殊的例子，以便让你更加熟悉Scrapy的两个最重要的类——Request和Response。 1.1　需要登录的爬虫 通常情况下，你会发现自己想要抽取数据的网站存在登录机制。大部分情况下，网站会要求你提供用户名和密码用于登录。你可以从http://web:9312/dynamic（从dev机器访问）或http://localhost:9312/ dynamic（从宿主机浏览器访问）找到我们要使用的例子。如果使用"user"作为用户名，"pass"作为密码的话，你就可以访问到包含3个房产页面链接的网页。不过现在的问题是，要如何使用Scrapy执行相同的操作？ 让我们使用Google Chrome浏览器的开发者工具来尝试理解登录的工作过程（见图1.1）。首先，打开Network选项卡（1）。然后，填写用户名和密码，并单击Login（2）。如果用户名和密码正确，你将会看到包含3个链接的页面。如果用户名和密码不匹配，将会看到一个错误页。 图1.1　登录网站时的请求和响应 当按下Login按钮时，会在Google Chr...
2018-01-21
567
上一篇

redis从入门到实践

一. Redis安装使用 1.介绍 redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多， 包括string(字符串)、list(链表)、set(集合)、zset(sorted set--有序集合)和hash（哈希类型）。 这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且 这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样， 为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘 或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。 2.安装redis 1.下载官网最新redis安装包 http://download.redis.io/releases/redis-4.0.0.tar.gz 2.在/usr/local下创建文件redis cd /usr/local mkdir redis 3.将下载的redis-4.0.2.tar.gz安装包解压到redis文件夹中 cd ~ t...
2018-01-21
456
下一篇

相关文章

发表评论

资源下载

更多资源
Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

时间: 2025-12-21 大小: 189MB 下载: 2次
Spring

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2025-12-17 大小: 5MB 下载: 1次
Rocky Linux

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

时间: 2026-01-03 大小: 1.42GB 下载: 2次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2025-12-03 大小: 9.84MB 下载: 39次
手机查看

扫码在手机上查看文章

扫描二维码，手机阅读更方便

热门标签
DeepSeek HarmonyOS6 Gemini3 SpringCloud Kubernetes Rocky Jdk25 Service Mesh Redis OpenAi Docker SpringBoot4 Nacos3

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册