RestTemplate 使用总结

 

场景:

认证服务器需要有个 http client 把前端发来的请求转发到 backend service, 然后把 backend service 的结果再返回给前端,服务器本身只做认证功能。

遇到的问题:

  • 长连接以保证高性能。RestTemplate 本身也是一个 wrapper 其底层默认是 SimpleClientHttpRequestFactory ,如果要保证长连接, HttpComponentsClientHttpRequestFactory 是个更好的选择,它不仅可以控制能够建立的连接数还能细粒度的控制到某个 server 的连接数,非常方便。在默认情况下,RestTemplate 到某个 server 的最大连接数只有 2, 一般需要调的更高些,最好等于 server 的 CPU 个数

  • access_token 不应传到 backend service. backend service 之间通信不需要 token,因为到这些服务的请求都是已经认证过的,是可信赖的用户发出的请求。因此转发请求时要把 parameter 从 request url 中删掉。删除 parameter 说难不难,说简单其实还有点麻烦,网上有一个 UrlEncodedQueryString 可以参考下,它封装了很多函数,其中就包括从url 中摘掉指定 header

  • 请求的 HttpMethod 问题。 HttpMethod 有很多种,http client 不应该对每种 Http method 都单独处理,所以应选用 RestTemplate 的 exchange 方法。exchange 方法要求给出 RequestBody 参数,而对于 Get 请求,这部分往往为空,所以我们要在 controller 中声明 @RequestBody(required = false) String body

  • exchange 的返回值和 controller 的返回值。Restful API 一般都是返回 json 的,所以最简单的是 exchange 和 controller 直接返回 String,但是返回 String 会有很多问题: 首先是如果某些 API 返回的是图片,那么这个 client 就傻掉了,需要为图片接口专门写 API,此外如果 backend service 返回的是 Gzip,那么此 client 必须对 gzip 先解压缩再返回请求者,如果不解压缩的话,相当于对着 gzip 数据做了到 String 类型的强制转换,使得请求者拿到的数据无法解析,所以最好的返回值是 byte[]。对于那种比较大的 json 返回值,省去了对 String 的类型转换后还能带来很大的性能提升

  • 关于返回值是 byte[] 还是 ResponseEntity<byte[]> 的问题。我觉得还是 ResponseEntity<byte[]> 好些,因为它就是 backend service 的结果。如果返回 byte[] 的话,还要对 HttpServletResponse 的 Header 进行修改,设置 Content-type, Content-encoding 等等。

    https://www.cnblogs.com/xinsheng/p/5546221.html

Spring Boot忽略https证书:No subject alternative names present

springboot--resttemplate访问https请求

  1. <!--http请求包-->
  2. <dependency>
  3. <groupId>org.apache.httpcomponents</groupId>
  4. <artifactId>httpclient</artifactId>
  5. <version>4.5.3</version>
  6. </dependency>
  1. import org.apache.http.config.Registry;
  2. import org.apache.http.config.RegistryBuilder;
  3. import org.apache.http.conn.socket.ConnectionSocketFactory;
  4. import org.apache.http.conn.socket.PlainConnectionSocketFactory;
  5. import org.apache.http.conn.ssl.NoopHostnameVerifier;
  6. import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
  7. import org.apache.http.conn.ssl.TrustStrategy;
  8. import org.apache.http.impl.client.CloseableHttpClient;
  9. import org.apache.http.impl.client.HttpClientBuilder;
  10. import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
  11. import org.apache.http.ssl.SSLContextBuilder;
  12.  
  13. import javax.net.ssl.HostnameVerifier;
  14. import javax.net.ssl.SSLContext;
  15. import java.security.KeyManagementException;
  16. import java.security.KeyStoreException;
  17. import java.security.NoSuchAlgorithmException;
  18. import java.security.cert.CertificateException;
  19. import java.security.cert.X509Certificate;
  20.  
  21. public class HttpClientUtils {
  22.  
  23. public static CloseableHttpClient acceptsUntrustedCertsHttpClient() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
  24. HttpClientBuilder b = HttpClientBuilder.create();
  25.  
  26. // setup a Trust Strategy that allows all certificates.
  27. //
  28. SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
  29. @Override
  30. public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
  31. return true;
  32. }
  33. }).build();
  34. b.setSSLContext(sslContext);
  35.  
  36. // don't check Hostnames, either.
  37. // -- use SSLConnectionSocketFactory.getDefaultHostnameVerifier(), if you don't want to weaken
  38. HostnameVerifier hostnameVerifier = NoopHostnameVerifier.INSTANCE;
  39.  
  40. // here's the special part:
  41. // -- need to create an SSL Socket Factory, to use our weakened "trust strategy";
  42. // -- and create a Registry, to register it.
  43. //
  44. SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContext, hostnameVerifier);
  45. Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
  46. .register("http", PlainConnectionSocketFactory.getSocketFactory())
  47. .register("https", sslSocketFactory)
  48. .build();
  49.  
  50. // now, we create connection-manager using our Registry.
  51. // -- allows multi-threaded use
  52. PoolingHttpClientConnectionManager connMgr = new PoolingHttpClientConnectionManager( socketFactoryRegistry);
  53. connMgr.setMaxTotal(200);
  54. connMgr.setDefaultMaxPerRoute(100);
  55. b.setConnectionManager( connMgr);
  56.  
  57. // finally, build the HttpClient;
  58. // -- done!
  59. CloseableHttpClient client = b.build();
  60.  
  61. return client;
  62. }
  63.  
  64. }

SpringBoot启动类添加配置

在启动类上配置RestTemplate(因为启动类也是配置类,比较方便)

  1. @Bean
  2. public RestTemplate httpsRestTemplate(HttpComponentsClientHttpRequestFactory httpsFactory) {
  3. RestTemplate restTemplate = new RestTemplate(httpsFactory);
  4. restTemplate.setErrorHandler(
  5. new ResponseErrorHandler() {
  6. @Override
  7. public boolean hasError(ClientHttpResponse clientHttpResponse) {
  8. return false;
  9. }
  10.  
  11. @Override
  12. public void handleError(ClientHttpResponse clientHttpResponse) {
  13. // 默认处理非200的返回,会抛异常
  14. }
  15. });
  16. return restTemplate;
  17. }
  18.  
  19. @Bean(name = "httpsFactory")
  20. public HttpComponentsClientHttpRequestFactory httpComponentsClientHttpRequestFactory()
  21. throws Exception {
  22. CloseableHttpClient httpClient = HttpClientUtils.acceptsUntrustedCertsHttpClient();
  23. HttpComponentsClientHttpRequestFactory httpsFactory =
  24. new HttpComponentsClientHttpRequestFactory(httpClient);
  25. httpsFactory.setReadTimeout(40000);
  26. httpsFactory.setConnectTimeout(40000);
  27. return httpsFactory;
  28. }

不出意外就可以愉快的访问https请求了!

---------------------
作者:别浪呀
来源:CSDN
原文:https://blog.csdn.net/adminBfl/article/details/84819735
版权声明:本文为博主原创文章,转载请附上博文链接!

https://stackoverflow.com/questions/17619871/access-https-rest-service-using-spring-resttemplate

前面我们介绍了如何使用Apache的HttpClient发送HTTP请求,这里我们介绍Spring的Rest客户端(即:RestTemplate)
如何发送HTTP、HTTPS请求。注:HttpClient如何发送HTTPS请求,有机会的话也会再给出示例。

声明:本人一些内容摘录自其他朋友的博客,链接在本文末给出!

基础知识
         微服务都是以HTTP接口的形式暴露自身服务的,因此在调用远程服务时就必须使用HTTP客户端。我们可以使用JDK原生的URLConnection、Apache的Http Client、Netty的异步HTTP Client,最方便、最优雅的Feign, Spring的RestTemplate等。

RestTemplate简述
        RestTemplate是Spring提供的用于访问Rest服务(Rest风格、Rest架构)的客户端。

RestTemplate提供了多种便捷访问远程Http服务的方法,能够大大提高客户端的编写效率。

调用RestTemplate的默认构造函数,RestTemplate对象在底层通过使用java.net包下的实现创建HTTP 请求;我们也可以通过使用ClientHttpRequestFactory指定不同的请求方式:

ClientHttpRequestFactory接口主要提供了两种实现方式:

1.常用的一种是SimpleClientHttpRequestFactory,使用J2SE提供的方式(既java.net包提供的方式)创建底层
            的Http请求连接。

2.常用的另一种方式是使用HttpComponentsClientHttpRequestFactory方式,底层使用HttpClient访问远程的
             Http服务,使用HttpClient可以配置连接池和证书等信息。

软硬件环境: Windows10、Eclipse、JDK1.8、SpringBoot

准备工作:引入相关依赖

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>

HTTP之GET请求(示例)

  1. import java.io.UnsupportedEncodingException;
  2. import java.net.URI;
  3. import java.net.URLEncoder;
  4. import java.nio.charset.StandardCharsets;
  5. import java.util.List;
  6.  
  7. import org.junit.Test;
  8. import org.junit.runner.RunWith;
  9. import org.springframework.boot.test.context.SpringBootTest;
  10. import org.springframework.http.HttpEntity;
  11. import org.springframework.http.HttpHeaders;
  12. import org.springframework.http.HttpMethod;
  13. import org.springframework.http.ResponseEntity;
  14. import org.springframework.http.converter.HttpMessageConverter;
  15. import org.springframework.http.converter.StringHttpMessageConverter;
  16. import org.springframework.test.context.junit4.SpringRunner;
  17. import org.springframework.web.client.RestTemplate;
  18.  
  19. import com.google.gson.Gson;
  20.  
  21. /**
  22. * 单元测试
  23. *
  24. * @author JustryDeng
  25. * @DATE 2018年9月7日 下午6:37:05
  26. */
  27. @RunWith(SpringRunner.class)
  28. @SpringBootTest
  29. public class AbcHttpsTestApplicationTests {
  30.  
  31. /**
  32. * RestTemplate 发送 HTTP GET请求 --- 测试
  33. * @throws UnsupportedEncodingException
  34. *
  35. * @date 2018年7月13日 下午4:18:50
  36. */
  37. @Test
  38. public void doHttpGetTest() throws UnsupportedEncodingException {
  39. // -------------------------------> 获取Rest客户端实例
  40. RestTemplate restTemplate = new RestTemplate();
  41.  
  42. // -------------------------------> 解决(响应数据可能)中文乱码 的问题
  43. List<HttpMessageConverter<?>> converterList = restTemplate.getMessageConverters();
  44. converterList.remove(1); // 移除原来的转换器
  45. // 设置字符编码为utf-8
  46. HttpMessageConverter<?> converter = new StringHttpMessageConverter(StandardCharsets.UTF_8);
  47. converterList.add(1, converter); // 添加新的转换器(注:convert顺序错误会导致失败)
  48. restTemplate.setMessageConverters(converterList);
  49.  
  50. // -------------------------------> (选择性设置)请求头信息
  51. // HttpHeaders实现了MultiValueMap接口
  52. HttpHeaders httpHeaders = new HttpHeaders();
  53. // 给请求header中添加一些数据
  54. httpHeaders.add("JustryDeng", "这是一个大帅哥!");
  55.  
  56. // -------------------------------> 注:GET请求 创建HttpEntity时,请求体传入null即可
  57. // 请求体的类型任选即可;只要保证 请求体 的类型与HttpEntity类的泛型保持一致即可
  58. String httpBody = null;
  59. HttpEntity<String> httpEntity = new HttpEntity<String>(httpBody, httpHeaders);
  60.  
  61. // -------------------------------> URI
  62. StringBuffer paramsURL = new StringBuffer("http://127.0.0.1:9527/restTemplate/doHttpGet");
  63. // 字符数据最好encoding一下;这样一来,某些特殊字符才能传过去(如:flag的参数值就是“&”,不encoding的话,传不过去)
  64. paramsURL.append("?flag=" + URLEncoder.encode("&", "utf-8"));
  65. URI uri = URI.create(paramsURL.toString());
  66.  
  67. // -------------------------------> 执行请求并返回结果
  68. // 此处的泛型 对应 响应体数据 类型;即:这里指定响应体的数据装配为String
  69. ResponseEntity<String> response =
  70. restTemplate.exchange(uri, HttpMethod.GET, httpEntity, String.class);
  71.  
  72. // -------------------------------> 响应信息
  73. //响应码,如:401、302、404、500、200等
  74. System.err.println(response.getStatusCodeValue());
  75. Gson gson = new Gson();
  76. // 响应头
  77. System.err.println(gson.toJson(response.getHeaders()));
  78. // 响应体
  79. if(response.hasBody()) {
  80. System.err.println(response.getBody());
  81. }
  82.  
  83. }
  84.  
  85. }

被http请求的对应的方法逻辑为:

注:我们也可以使用@RequestHeader()来获取到请求头中的数据信息,如:

结果(效果)展示

1.进行HTTP请求的方法获得响应后输出结果为:

2.被HTTP请求的方法被请求后的输出结果为:

HTTP之POST请求(示例)

  1. /**
  2. * RestTemplate 发送 HTTP POST请求 --- 测试
  3. * @throws UnsupportedEncodingException
  4. *
  5. * @date 2018年9月8日 下午2:12:50
  6. */
  7. @Test
  8. public void doHttpPostTest() throws UnsupportedEncodingException {
  9. // -------------------------------> 获取Rest客户端实例
  10. RestTemplate restTemplate = new RestTemplate();
  11.  
  12. // -------------------------------> 解决(响应数据可能)中文乱码 的问题
  13. List<HttpMessageConverter<?>> converterList = restTemplate.getMessageConverters();
  14. converterList.remove(1); // 移除原来的转换器
  15. // 设置字符编码为utf-8
  16. HttpMessageConverter<?> converter = new StringHttpMessageConverter(StandardCharsets.UTF_8);
  17. converterList.add(1, converter); // 添加新的转换器(注:convert顺序错误会导致失败)
  18. restTemplate.setMessageConverters(converterList);
  19.  
  20. // -------------------------------> (选择性设置)请求头信息
  21. // HttpHeaders实现了MultiValueMap接口
  22. HttpHeaders httpHeaders = new HttpHeaders();
  23. // 设置contentType
  24. httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);
  25. // 给请求header中添加一些数据
  26. httpHeaders.add("JustryDeng", "这是一个大帅哥!");
  27.  
  28. // ------------------------------->将请求头、请求体数据,放入HttpEntity中
  29. // 请求体的类型任选即可;只要保证 请求体 的类型与HttpEntity类的泛型保持一致即可
  30. // 这里手写了一个json串作为请求体 数据 (实际开发时,可使用fastjson、gson等工具将数据转化为json串)
  31. String httpBody = "{\"motto\":\"唉呀妈呀!脑瓜疼!\"}";
  32. HttpEntity<String> httpEntity = new HttpEntity<String>(httpBody, httpHeaders);
  33.  
  34. // -------------------------------> URI
  35. StringBuffer paramsURL = new StringBuffer("http://127.0.0.1:9527/restTemplate/doHttpPost");
  36. // 字符数据最好encoding一下;这样一来,某些特殊字符才能传过去(如:flag的参数值就是“&”,不encoding的话,传不过去)
  37. paramsURL.append("?flag=" + URLEncoder.encode("&", "utf-8"));
  38. URI uri = URI.create(paramsURL.toString());
  39.  
  40. // -------------------------------> 执行请求并返回结果
  41. // 此处的泛型 对应 响应体数据 类型;即:这里指定响应体的数据装配为String
  42. ResponseEntity<String> response =
  43. restTemplate.exchange(uri, HttpMethod.POST, httpEntity, String.class);
  44.  
  45. // -------------------------------> 响应信息
  46. //响应码,如:401、302、404、500、200等
  47. System.err.println(response.getStatusCodeValue());
  48. Gson gson = new Gson();
  49. // 响应头
  50. System.err.println(gson.toJson(response.getHeaders()));
  51. // 响应体
  52. if(response.hasBody()) {
  53. System.err.println(response.getBody());
  54. }
  55.  
  56. }

被http请求的对应的方法逻辑为:

注:我们也可以使用@RequestHeader()来获取到请求头中的数据信息,如:

结果(效果)展示

进行HTTP请求的方法获得响应后输出结果为:

被HTTP请求的方法被请求后的输出结果为:

HTTPS请求的准备工作
HTTPS请求 = 超文本传输协议HTTP + 安全套接字层SSL。

先给出等下需要用到的一个SimpleClientHttpRequestFactory的实现类

  1. /**
  2. * 声明:此代码摘录自https://blog.csdn.net/wltsysterm/article/details/80977455
  3. * 声明:关于Socket的相关知识,本人会在后面的闲暇时间进行学习整理,请持续关注博客更新
  4. *
  5. * @author JustryDeng
  6. * @DATE 2018年9月8日 下午4:34:02
  7. */
  8. public class HttpsClientRequestFactory extends SimpleClientHttpRequestFactory {
  9.  
  10. @Override
  11. protected void prepareConnection(HttpURLConnection connection, String httpMethod) {
  12. try {
  13. if (!(connection instanceof HttpsURLConnection)) {
  14. throw new RuntimeException("An instance of HttpsURLConnection is expected");
  15. }
  16.  
  17. HttpsURLConnection httpsConnection = (HttpsURLConnection) connection;
  18.  
  19. TrustManager[] trustAllCerts = new TrustManager[]{
  20. new X509TrustManager() {
  21. @Override
  22. public java.security.cert.X509Certificate[] getAcceptedIssuers() {
  23. return null;
  24. }
  25. @Override
  26. public void checkClientTrusted(X509Certificate[] certs, String authType) {
  27. }
  28. @Override
  29. public void checkServerTrusted(X509Certificate[] certs, String authType) {
  30. }
  31.  
  32. }
  33. };
  34. SSLContext sslContext = SSLContext.getInstance("TLS");
  35. sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
  36. httpsConnection.setSSLSocketFactory(new MyCustomSSLSocketFactory(sslContext.getSocketFactory()));
  37.  
  38. httpsConnection.setHostnameVerifier(new HostnameVerifier() {
  39. @Override
  40. public boolean verify(String s, SSLSession sslSession) {
  41. return true;
  42. }
  43. });
  44.  
  45. super.prepareConnection(httpsConnection, httpMethod);
  46. } catch (Exception e) {
  47. e.printStackTrace();
  48. }
  49. }
  50.  
  51. /**
  52. * We need to invoke sslSocket.setEnabledProtocols(new String[] {"SSLv3"});
  53. * see http://www.oracle.com/technetwork/java/javase/documentation/cve-2014-3566-2342133.html (Java 8 section)
  54. */
  55. // SSLSocketFactory用于创建 SSLSockets
  56. private static class MyCustomSSLSocketFactory extends SSLSocketFactory {
  57.  
  58. private final SSLSocketFactory delegate;
  59.  
  60. public MyCustomSSLSocketFactory(SSLSocketFactory delegate) {
  61. this.delegate = delegate;
  62. }
  63.  
  64. // 返回默认启用的密码套件。除非一个列表启用,对SSL连接的握手会使用这些密码套件。
  65. // 这些默认的服务的最低质量要求保密保护和服务器身份验证
  66. @Override
  67. public String[] getDefaultCipherSuites() {
  68. return delegate.getDefaultCipherSuites();
  69. }
  70.  
  71. // 返回的密码套件可用于SSL连接启用的名字
  72. @Override
  73. public String[] getSupportedCipherSuites() {
  74. return delegate.getSupportedCipherSuites();
  75. }
  76.  
  77. @Override
  78. public Socket createSocket(final Socket socket, final String host, final int port,
  79. final boolean autoClose) throws IOException {
  80. final Socket underlyingSocket = delegate.createSocket(socket, host, port, autoClose);
  81. return overrideProtocol(underlyingSocket);
  82. }
  83.  
  84. @Override
  85. public Socket createSocket(final String host, final int port) throws IOException {
  86. final Socket underlyingSocket = delegate.createSocket(host, port);
  87. return overrideProtocol(underlyingSocket);
  88. }
  89.  
  90. @Override
  91. public Socket createSocket(final String host, final int port, final InetAddress localAddress,
  92. final int localPort) throws
  93. IOException {
  94. final Socket underlyingSocket = delegate.createSocket(host, port, localAddress, localPort);
  95. return overrideProtocol(underlyingSocket);
  96. }
  97.  
  98. @Override
  99. public Socket createSocket(final InetAddress host, final int port) throws IOException {
  100. final Socket underlyingSocket = delegate.createSocket(host, port);
  101. return overrideProtocol(underlyingSocket);
  102. }
  103.  
  104. @Override
  105. public Socket createSocket(final InetAddress host, final int port, final InetAddress localAddress,
  106. final int localPort) throws
  107. IOException {
  108. final Socket underlyingSocket = delegate.createSocket(host, port, localAddress, localPort);
  109. return overrideProtocol(underlyingSocket);
  110. }
  111.  
  112. private Socket overrideProtocol(final Socket socket) {
  113. if (!(socket instanceof SSLSocket)) {
  114. throw new RuntimeException("An instance of SSLSocket is expected");
  115. }
  116. ((SSLSocket) socket).setEnabledProtocols(new String[]{"TLSv1"});
  117. return socket;
  118. }
  119. }
  120. }

HTTPS之GET请求
说明:RestTemplate发送HTTPS与发送HTTP的代码,除了在创建RestTemplate时不一样以及协议不一样
         (一个URL是http开头,一个是https开头)外,其余的都一样。

HTTP获取RestTemplate实例

HTTPS获取RestTemplate实例

给出具体HTTPS发送GET请求代码示例(HTTPS发送POST请求类比即可)

注:HTTPS与HTTP的使用不同之处,在途中已经圈出了。

注:上图中请求的https://tcc.taobao.com/cc/json/mobile_tel_segment.htm是阿里提供的一个简单查询手机信息的地址。

运行该主函数,控制台打印出的结果为:

注:如果用HTTP协议开头的URL去访问HTTPS开头的URL的话(这两个URL除了协议不同其它都相同),是访问不了的;除非服
     务端有相应的设置。

注:发送HTTPS的逻辑代码是可以拿来发送HTTP的。但是根据我们写得HttpsClientRequestFactory类中的代码可知,会打
     印出异常(异常抛出后被catch了):

如果用HTTPS访问HTTP时不想抛出异常,那么把对应的这个逻辑去掉即可。

提示:“发送HTTPS的逻辑代码是可以拿来发送HTTP的”这句话的意思是:拿来做发HTTPS请求的逻辑,可以复用来作发HTTP请
         求的逻辑。并不是说说一个API能被HTTPS协议的URL访问,就一定能被HTTP协议的URL访问。

HTTPS之GET请求
注:关于HTTPS这里只给出了一个GET示例,使用HTTPS进行POST请求也是与HTTP进行POST请求也只是创建
      RestTemplate实例和协议不一样,其余的都一样;类比GET即可,这里就不再给出示例了。

参考链接、摘录内容出处
        https://www.cnblogs.com/duanxz/p/3510622.html
        https://blog.csdn.net/wltsysterm/article/details/80977455
        https://blog.csdn.net/zhoumengshun/article/details/79100053
如有不当之处,欢迎指正
本次示例测试代码项目托管链接
        https://github.com/JustryDeng/PublicRepository
本文已经被收录进《程序员成长笔记(三)》,笔者JustryDeng
---------------------
作者:justry_deng
来源:CSDN
原文:https://blog.csdn.net/justry_deng/article/details/82531306
版权声明:本文为博主原创文章,转载请附上博文链接!

spring boot resttemplate 使用及支持https协议
RestTemplate 使用
添加httpclient依赖

  1. <!-- httpclient -->
  2. <dependency>
  3. <groupId>org.apache.httpcomponents</groupId>
  4. <artifactId>httpclient</artifactId>
  5. </dependency>

配置类

  1. package net.fanci.stars.config;
  2.  
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.boot.web.client.RestTemplateBuilder;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.http.MediaType;
  8. import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
  9. import org.springframework.web.client.RestTemplate;
  10.  
  11. import java.util.Arrays;
  12. import java.util.List;
  13.  
  14. /**
  15. * @author xxx
  16. * @create 2018/06/28 15:32
  17. * @description RestTemplate配置类:
  18. * 1.将 HttpClient 作为 RestTemplate 的实现,添加 httpclient 依赖即可
  19. * 2.设置响应类型和内容类型
  20. */
  21. @Configuration
  22. public class RestConfiguration {
  23. @Autowired
  24. private RestTemplateBuilder builder;
  25.  
  26. @Bean
  27. public RestTemplate restTemplate() {
  28. return builder
  29. .additionalMessageConverters(new WxMappingJackson2HttpMessageConverter())
  30. .build();
  31. }
  32.  
  33. class WxMappingJackson2HttpMessageConverter extends MappingJackson2HttpMessageConverter {
  34. WxMappingJackson2HttpMessageConverter() {
  35. List<MediaType> mediaTypes = Arrays.asList(
  36. MediaType.TEXT_PLAIN,
  37. MediaType.TEXT_HTML,
  38. MediaType.APPLICATION_JSON_UTF8
  39. );
  40. setSupportedMediaTypes(mediaTypes);// tag6
  41. }
  42. }
  43.  
  44. }

使用方法(如:通过微信code获取token信息)

  1. @Autowired
  2. private RestTemplate restTemplate;
  3.  
  4. /**
  5. * 获取access_token的完整信息
  6. *
  7. * @param code
  8. * @return
  9. */
  10. @Override
  11. public WechatAuthAccesstoken getWechatAuthAccesstoken(String code) {
  12. String url = ACCESS_TOKEN_URL + "appid=" + wechatData.getAppID() +
  13. "&secret=" + wechatData.getAppsecret() +
  14. "&code=" + code +
  15. "&grant_type=authorization_code";
  16.  
  17. // com.alibaba.fastjson
  18. JSONObject jsonObject = restTemplate.getForObject(url, JSONObject.class);
  19.  
  20. WechatAuthAccesstoken wechatAuthAccesstoken = new WechatAuthAccesstoken();
  21. if (jsonObject != null) {
  22. wechatAuthAccesstoken.setId(PayUtil.genUniqueKey());
  23. wechatAuthAccesstoken.setCreatedDate(DateTime.now().toDate());
  24. wechatAuthAccesstoken.setModifiedDate(DateTime.now().toDate());
  25. wechatAuthAccesstoken.setAccessToken((String) jsonObject.get("access_token"));
  26. DateTime now = DateTime.now();
  27. DateTime expired = now.plusSeconds((Integer) jsonObject.get("expires_in"));
  28. wechatAuthAccesstoken.setExpires(expired.toDate());
  29. wechatAuthAccesstoken.setRefreshToken(jsonObject.getString("refresh_token"));
  30. wechatAuthAccesstoken.setOpenid((String) jsonObject.get("openid"));
  31. wechatAuthAccesstoken.setScope(jsonObject.getString("scope"));
  32. int isOk = tokenMapper.insert(wechatAuthAccesstoken);
  33. if (isOk > 0) {
  34. logger.info("本地存储access_token信息成功");
  35. return wechatAuthAccesstoken;
  36. } else {
  37. logger.error("本地存储access_token信息失败");
  38. }
  39. } else {
  40. logger.error("获取access_token信息失败");
  41. }
  42. return null;
  43. }

https支持
配置类

  1. import org.springframework.http.client.SimpleClientHttpRequestFactory;
  2.  
  3. import javax.net.ssl.*;
  4. import java.io.IOException;
  5. import java.net.HttpURLConnection;
  6. import java.net.InetAddress;
  7. import java.net.Socket;
  8. import java.security.cert.X509Certificate;
  9.  
  10. /**
  11. * @author xxx
  12. * @create 2018/07/16 11:41
  13. * @description 创建 HttpsClientRequestFactory 以支持 RestTemplate 调用 https 请求
  14. */
  15. public class HttpsClientRequestFactory extends SimpleClientHttpRequestFactory {
  16. @Override
  17. protected void prepareConnection(HttpURLConnection connection, String httpMethod) {
  18. try {
  19. if (!(connection instanceof HttpsURLConnection)) {
  20. throw new RuntimeException("An instance of HttpsURLConnection is expected");
  21. }
  22.  
  23. HttpsURLConnection httpsConnection = (HttpsURLConnection) connection;
  24.  
  25. TrustManager[] trustAllCerts = new TrustManager[]{
  26. new X509TrustManager() {
  27. public java.security.cert.X509Certificate[] getAcceptedIssuers() {
  28. return null;
  29. }
  30.  
  31. public void checkClientTrusted(X509Certificate[] certs, String authType) {
  32. }
  33.  
  34. public void checkServerTrusted(X509Certificate[] certs, String authType) {
  35. }
  36.  
  37. }
  38. };
  39. SSLContext sslContext = SSLContext.getInstance("TLS");
  40. sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
  41. httpsConnection.setSSLSocketFactory(new MyCustomSSLSocketFactory(sslContext.getSocketFactory()));
  42.  
  43. httpsConnection.setHostnameVerifier(new HostnameVerifier() {
  44. @Override
  45. public boolean verify(String s, SSLSession sslSession) {
  46. return true;
  47. }
  48. });
  49.  
  50. super.prepareConnection(httpsConnection, httpMethod);
  51. } catch (Exception e) {
  52. e.printStackTrace();
  53. }
  54. }
  55.  
  56. /**
  57. * We need to invoke sslSocket.setEnabledProtocols(new String[] {"SSLv3"});
  58. * see http://www.oracle.com/technetwork/java/javase/documentation/cve-2014-3566-2342133.html (Java 8 section)
  59. */
  60. private static class MyCustomSSLSocketFactory extends SSLSocketFactory {
  61.  
  62. private final SSLSocketFactory delegate;
  63.  
  64. public MyCustomSSLSocketFactory(SSLSocketFactory delegate) {
  65. this.delegate = delegate;
  66. }
  67.  
  68. @Override
  69. public String[] getDefaultCipherSuites() {
  70. return delegate.getDefaultCipherSuites();
  71. }
  72.  
  73. @Override
  74. public String[] getSupportedCipherSuites() {
  75. return delegate.getSupportedCipherSuites();
  76. }
  77.  
  78. @Override
  79. public Socket createSocket(final Socket socket, final String host, final int port, final boolean autoClose) throws IOException {
  80. final Socket underlyingSocket = delegate.createSocket(socket, host, port, autoClose);
  81. return overrideProtocol(underlyingSocket);
  82. }
  83.  
  84. @Override
  85. public Socket createSocket(final String host, final int port) throws IOException {
  86. final Socket underlyingSocket = delegate.createSocket(host, port);
  87. return overrideProtocol(underlyingSocket);
  88. }
  89.  
  90. @Override
  91. public Socket createSocket(final String host, final int port, final InetAddress localAddress, final int localPort) throws
  92. IOException {
  93. final Socket underlyingSocket = delegate.createSocket(host, port, localAddress, localPort);
  94. return overrideProtocol(underlyingSocket);
  95. }
  96.  
  97. @Override
  98. public Socket createSocket(final InetAddress host, final int port) throws IOException {
  99. final Socket underlyingSocket = delegate.createSocket(host, port);
  100. return overrideProtocol(underlyingSocket);
  101. }
  102.  
  103. @Override
  104. public Socket createSocket(final InetAddress host, final int port, final InetAddress localAddress, final int localPort) throws
  105. IOException {
  106. final Socket underlyingSocket = delegate.createSocket(host, port, localAddress, localPort);
  107. return overrideProtocol(underlyingSocket);
  108. }
  109.  
  110. private Socket overrideProtocol(final Socket socket) {
  111. if (!(socket instanceof SSLSocket)) {
  112. throw new RuntimeException("An instance of SSLSocket is expected");
  113. }
  114. ((SSLSocket) socket).setEnabledProtocols(new String[]{"TLSv1"});
  115. return socket;
  116. }
  117. }
  118. }

使用类

  1. String message = null;
  2. String url = "https://ip:port/xxx";
  3. RestTemplate restTemplateHttps = new RestTemplate(new HttpsClientRequestFactory());
  4.  
  5. List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
  6. StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));
  7. messageConverters.add(stringHttpMessageConverter);
  8. restTemplateHttps.setMessageConverters(messageConverters);
  9.  
  10. ResponseEntity<String> responseEntity = restTemplateHttps.postForEntity(url, paramsData, String.class);
  11. if (responseEntity != null && responseEntity.getStatusCodeValue() == 200) {
  12. message = responseEntity.getBody();
  13. }

离殇一曲与谁眠: 要依赖有什么用全是JDK和springboot自带的包
---------------------
作者:uanei
来源:CSDN
原文:https://blog.csdn.net/u013469944/article/details/84193792
版权声明:本文为博主原创文章,转载请附上博文链接!

1. 为什么使用HttpClient?

一开始其实是考虑使用RestTemplate的,但遇到的难题自然是SSL认证以及NTLM的认证.以目前的RestTemplate还做不到NTLM认证.而且使用SSL认证的过程也是挺复杂的. 复杂的是:居然还是要借助HttpClient .

  1. @Bean
  2. public RestTemplate buildRestTemplate(List<CustomHttpRequestInterceptor> interceptors) throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
  3. HttpComponentsClientHttpRequestFactory factory = new
  4. HttpComponentsClientHttpRequestFactory();
  5. factory.setConnectionRequestTimeout(requestTimeout);
  6. factory.setConnectTimeout(connectTimeout);
  7. factory.setReadTimeout(readTimeout);
  8. // https
  9. SSLContextBuilder builder = new SSLContextBuilder();
  10. builder.loadTrustMaterial(null, (X509Certificate[] x509Certificates, String s) -> true);
  11. SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(builder.build(), new String[]{"SSLv2Hello", "SSLv3", "TLSv1", "TLSv1.2"}, null, NoopHostnameVerifier.INSTANCE);
  12. Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
  13. .register("http", new PlainConnectionSocketFactory())
  14. .register("https", socketFactory).build();
  15. PoolingHttpClientConnectionManager phccm = new PoolingHttpClientConnectionManager(registry);
  16. phccm.setMaxTotal(200);
  17. CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(socketFactory).setConnectionManager(phccm).setConnectionManagerShared(true).build();
  18. factory.setHttpClient(httpClient);
  19.  
  20. RestTemplate restTemplate = new RestTemplate(factory);
  21. List<ClientHttpRequestInterceptor> clientInterceptorList = new ArrayList<>();
  22. for (CustomHttpRequestInterceptor i : interceptors) {
  23. ClientHttpRequestInterceptor interceptor = i;
  24. clientInterceptorList.add(interceptor);
  25. }
  26. restTemplate.setInterceptors(clientInterceptorList);
  27.  
  28. return restTemplate;
  29. }
  30. 复制代码

2. 为什么要绕过SSL认证?

至于为什么要绕过SSL认证,因为装证书的这些操作我并不会.同时也想试试能不能忽略这个证书认证调用接口.

  • 首先如果想绕过证书,都必先创建X509TrustManager这个对象并且重写它的方法.

X509TrustManager该接口是一个用于Https的证书信任管理器,我们可以在这里添加我们的证书,让该管理器知道我们有那些证书是可以信任的.

该接口会有三个方法:

  1. void checkClientTrusted(X509Certificate[] xcs, String str)
  2.  
  3. void checkServerTrusted(X509Certificate[] xcs, String str)
  4.  
  5. X509Certificate[] getAcceptedIssuers()
  6. 复制代码
  1. 第一个方法checkClientTrusted.该方法检查客户端的证书,若不信任该证书则抛出异常。由于我们不需要对客户端进行认证,因此我们只需要执行默认的信任管理器的这个方法。JSSE中,默认的信任管理器类为TrustManager。

  2. 第二个方法checkServerTrusted.该方法检查 服务器 的证书,若不信任该证书同样抛出异常。通过自己实现该方法,可以使之信任我们指定的任何证书。在实现该方法时,也可以简单的不做任何处理,即一个空的函数体,由于不会抛出异常,它就会信任任何证书。

  3. 第三个方法getAcceptedIssusers,返回受信任的X509证书数组。

而我们只需要重写这三个方法,并且不需要修改里面的内容.然后再交给HttpClient就可以实现绕过SSL认证了.

  1. X509TrustManager trustManager = new X509TrustManager() {
  2. @Override
  3. public X509Certificate[] getAcceptedIssuers() {
  4. return null;
  5. }
  6.  
  7. @Override
  8. public void checkClientTrusted(X509Certificate[] xcs, String str) {
  9. }
  10.  
  11. @Override
  12. public void checkServerTrusted(X509Certificate[] xcs, String str) {
  13. }
  14.  
  15. SSLContext ctx = SSLContext.getInstance(SSLConnectionSocketFactory.SSL);
  16. ctx.init(null, new TrustManager[]{trustManager}, null);
  17.  
  18. //生成工厂
  19. SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(ctx, NoopHostnameVerifier.INSTANCE);
  20.  
  21. //并注册到HttpClient中
  22. Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
  23. .register("http", PlainConnectionSocketFactory.INSTANCE)
  24. .register("https", socketFactory).build();
  25.  
  26. HttpClientBuilder httpClientBuilder = HttpClients.custom().setConnectionManager(connectionManager);
  27.  
  28. CloseableHttpClient httpClient = httpClientBuilder.build();
  29. 复制代码

回顾一下步骤:

  1. 创建X509TrustManager对象并重写方法.
  2. 创建SSLContext实例,并交到工厂管理.
  3. 注册到HttpClient中.通过ConnectionManager最后生成httpClient.

3. 什么是NTLM?

NTLM是NT LAN Manager的缩写,这也说明了协议的来源。NTLM 是 Windows NT 早期版本的标准安全协议,Windows 2000 支持 NTLM 是为了保持向后兼容。Windows 2000内置三种基本安全协议之一。

NTLM的原理

NTLM的工作原理描述

其实我对这个了解得不是很深,因为遇上这种情况的感觉不会很多,所以网上的资源也不太多. 这里只是针对HttpClient遇上NTLM认证的情况详细描述一下.有兴趣的朋友可以通过以上的链接了解下.

4. 如何使用HttpClient进行NTLM认证?

这个查阅了官网的文档.官网也给出了解决方案.

hc.apache.org/httpcompone…

需要把这几个类编写一下.

JCIFSEngine:

  1. public final class JCIFSEngine implements NTLMEngine {
  2.  
  3. private static final int TYPE_1_FLAGS =
  4. NtlmFlags.NTLMSSP_NEGOTIATE_56 |
  5. NtlmFlags.NTLMSSP_NEGOTIATE_128 |
  6. NtlmFlags.NTLMSSP_NEGOTIATE_NTLM2 |
  7. NtlmFlags.NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
  8. NtlmFlags.NTLMSSP_REQUEST_TARGET;
  9.  
  10. @Override
  11. public String generateType1Msg(final String domain, final String workstation) throws NTLMEngineException {
  12. final Type1Message type1Message = new Type1Message(TYPE_1_FLAGS, domain, workstation);
  13. return Base64.encode(type1Message.toByteArray());
  14. }
  15.  
  16. @Override
  17. public String generateType3Msg(final String username, final String password,
  18. final String domain, final String workstation, final String challenge)
  19. throws NTLMEngineException {
  20. Type2Message type2Message;
  21. try {
  22. type2Message = new Type2Message(Base64.decode(challenge));
  23. } catch (final IOException exception) {
  24. throw new NTLMEngineException("Invalid NTLM type 2 message", exception);
  25. }
  26. final int type2Flags = type2Message.getFlags();
  27. final int type3Flags = type2Flags
  28. & (0xffffffff ^ (NtlmFlags.NTLMSSP_TARGET_TYPE_DOMAIN | NtlmFlags.NTLMSSP_TARGET_TYPE_SERVER));
  29. final Type3Message type3Message = new Type3Message(type2Message, password, domain,
  30. username, workstation, type3Flags);
  31. return Base64.encode(type3Message.toByteArray());
  32. }
  33. }
  34. 复制代码

JCIFSNTLMSchemeFactory:

  1. public class JCIFSNTLMSchemeFactory implements AuthSchemeProvider {
  2.  
  3. public AuthScheme create(final HttpContext context){
  4. return new NTLMScheme(new JCIFSEngine());
  5. }
  6. }
  7. 复制代码

最后就在HttpClient注册:

  1. Registry<AuthSchemeProvider> authSchemeRegistry = RegistryBuilder.<AuthSchemeProvider>create()
  2. .register(AuthSchemes.NTLM, new JCIFSNTLMSchemeFactory())
  3. .register(AuthSchemes.BASIC, new BasicSchemeFactory())
  4. .register(AuthSchemes.DIGEST, new DigestSchemeFactory())
  5. .register(AuthSchemes.SPNEGO, new SPNegoSchemeFactory())
  6. .register(AuthSchemes.KERBEROS, new KerberosSchemeFactory())
  7. .build();
  8. CloseableHttpClient httpClient = HttpClients.custom()
  9. .setDefaultAuthSchemeRegistry(authSchemeRegistry)
  10. .build();
  11. 复制代码

最后就同时使用绕过SSL验证以及NTLM验证:

  1. private static PoolingHttpClientConnectionManager connectionManager;
  2. private static RequestConfig requestConfig;
  3. private static Registry<AuthSchemeProvider> authSchemeRegistry;
  4. private static Registry<ConnectionSocketFactory> socketFactoryRegistry;
  5. private static CredentialsProvider credsProvider;
  6.  
  7. public void init() {
  8. try {
  9. X509TrustManager trustManager = new X509TrustManager() {
  10. @Override
  11. public X509Certificate[] getAcceptedIssuers() {
  12. return null;
  13. }
  14.  
  15. @Override
  16. public void checkClientTrusted(X509Certificate[] xcs, String str) {
  17. }
  18.  
  19. @Override
  20. public void checkServerTrusted(X509Certificate[] xcs, String str) {
  21. }
  22. };
  23. SSLContext ctx = SSLContext.getInstance(SSLConnectionSocketFactory.SSL);
  24. ctx.init(null, new TrustManager[]{trustManager}, null);
  25. SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(ctx, NoopHostnameVerifier.INSTANCE);
  26. NTCredentials creds = new NTCredentials("用户名", "密码", "工作站(workstation)", "域名");
  27. credsProvider = new BasicCredentialsProvider();
  28. credsProvider.setCredentials(AuthScope.ANY, creds);
  29. socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
  30. .register("http", PlainConnectionSocketFactory.INSTANCE)
  31. .register("https", socketFactory).build();
  32. connectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
  33. connectionManager.setMaxTotal(18);
  34. connectionManager.setDefaultMaxPerRoute(6);
  35. requestConfig = RequestConfig.custom()
  36. .setSocketTimeout(30000)
  37. .setConnectTimeout(30000)
  38. .build();
  39. authSchemeRegistry = RegistryBuilder.<AuthSchemeProvider>create()
  40. .register(AuthSchemes.NTLM, new JCIFSNTLMSchemeFactory())
  41. .register(AuthSchemes.BASIC, new BasicSchemeFactory())
  42. .register(AuthSchemes.DIGEST, new DigestSchemeFactory())
  43. .register(AuthSchemes.SPNEGO, new SPNegoSchemeFactory())
  44. .register(AuthSchemes.KERBEROS, new KerberosSchemeFactory())
  45. .build();
  46. } catch (Exception e) {
  47. e.printStackTrace();
  48. }
  49. }
  50. 复制代码

以上就是本文的全部内容,希望本文的内容对大家的学习或者工作能带来一定的帮助,也希望大家多多支持 码农网

为你推荐:

https://www.codercto.com/a/36829.html

RestTemplate发送HTTP、HTTPS请求的更多相关文章

  1. Vert.x(vertx)发送 HTTP/HTTPS请求

    Vert.x Web服务有两种协议,一种是HTTP,另外一种是使用ssl的HTTPS,请求的方式有五种,分别是get.post.put.delete.head.为了简单,服务端主要实现对HTTP协议的 ...

  2. restTemplate 发送http post请求带有文件流、参数

    String httpMethod = ""; RestTemplate restTemplate = new RestTemplate(); String args = &quo ...

  3. 使用RestTemplate发送multipart/form-data格式的数据

    现有业务场景需要使用RestTemplate发送一个post请求,请求格式为multipart/form-data的,可以使用以下方法: public Object sendRequest(Objec ...

  4. 『言善信』Fiddler工具 — 15、使用Fiddler抓取HTTPS请求

    目录 1.Fiddler抓取HTTPS过程 2.拓展:SSL/TLS证书握手原理 3.Fiddler抓取HTTPS原理总结 4.Fiddler抓取HTTPS设置 步骤1:配置证书 步骤2:勾选设置 5 ...

  5. 在C#用HttpWebRequest中发送GET/HTTP/HTTPS请求

    通用辅助类  下面是我编写的一个辅助类,在这个类中采用了HttpWebRequest中发送GET/HTTP/HTTPS请求,因为有的时候需 要获取认证信息(如Cookie),所以返回的是HttpWeb ...

  6. 使用RestTemplate发送post请求

    最近使用RestTemplate发送post请求,遇到了很多问题,如转换httpMessage失败,中文乱码等,调了好久才找到下面较为简便的方法: RestTemplate restTemplate ...

  7. 【转载】JMeter学习(三十六)发送HTTPS请求

    Jmeter一般来说是压力测试的利器,最近想尝试jmeter和BeanShell进行接口测试.由于在云阅读接口测试的过程中需要进行登录操作,而登录请求是HTTPS协议.这就需要对jmeter进行设置. ...

  8. (转) 在C#用HttpWebRequest中发送GET/HTTP/HTTPS请求

    转自:http://blog.csdn.net/zhoufoxcn/article/details/6404236 通用辅助类 下面是我编写的一个辅助类,在这个类中采用了HttpWebRequest中 ...

  9. 【转】在C#用HttpWebRequest中发送GET/HTTP/HTTPS请求

    http://zhoufoxcn.blog.51cto.com/792419/561934 这个需求来自于我最近练手的一个项目,在项目中我需要将一些自己发表的和收藏整理的网文集中到一个地方存放,如果全 ...

随机推荐

  1. python之os库

    python之os库 os.name 判断现在正在实用的平台,Windows 返回 'nt'; Linux 返回'posix' >>> os.name 'nt' os.getcwd( ...

  2. 《mysql必知必会》学习_第18章_20180807_欢

    第18章 全文本搜索 P121  #创建一个新表,对表的列进行定义,定义之后,MySQL自动维护该索引# create table productnotes ( note_id  int   NOT ...

  3. Linux/unix 查看端口占用

    有的时候我们想找到某个端口被那个程序.程序占用,然后 kill 掉他,所以今天就来探讨一下. 1.netstat -apn|grep port | 关键字(java/kafka/nginx) 图中所示 ...

  4. Struts2下载及简介

    Struts2下载及简介 一.Struts2下载: 进入网址:http://struts.apache.org/download.cgi#struts23163 可以下载最新的Struts2. 1.F ...

  5. ASP.NET MVC下使用AngularJs语言(三):ng-options

    今天使用angularjs的ng-options实现一个DropDownList下拉列表. 准备ASP.NET MVC的model: public class MobilePhone { public ...

  6. 使用tomcat插件运行java web项目

    1 新建javaweb项目 使用骨架创建javaweb项目,具体步骤不熟悉的参见上一篇文章[idea集成maven]. 2 添加依赖 <dependency> <groupId> ...

  7. linux配置防火墙和重启防火墙

    1.在linux系统里面找到并打开编辑配置防火墙的文件,执行命令: vi /etc/sysconfig/iptables. 2.在上面打开的文件里面加入一下语句: -A INPUT -m state ...

  8. Java 数组的创建

    与C.C++不同,Java在定义数组时并不为数组元素分配内存,因此[ ]中无需指定数组元素的个数,即数组长度. 定义一个数组有两种方式: int[] array; int array[]; 对于如上定 ...

  9. linux中ftp的安装过程记录[运维篇]

    安装FTP的全过程记录,对于相同情况希望有所帮助.[centOS] 1.查询本机是否安装vsftpd: rpm -qa |grep vsftpd : 2.安装ftp服务 yum install vsf ...

  10. numpy 介绍

    NumPy系统是Python的一种开源的数值计算扩展.这种工具可用来存储和处理大型矩阵,比Python自身的嵌套列表(nested list structure)结构要高效的多(该结构也可以用来表示矩 ...