Spring 远程调用Rest服务工具类，包含Get、Post、Put、Delete四种调用方式。

依赖jar

  1.         <dependency>
  2.             <groupId>org.springframework</groupId>
  3.             <artifactId>spring-context</artifactId>
  4.             <version>5.0.9.RELEASE</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.springframework</groupId>
  8.             <artifactId>spring-web</artifactId>
  9.             <version>5.0.9.RELEASE</version>
  10.         </dependency>

RestTemplateUtils.java

  1. package javax.utils;
  2.  
  3. import java.util.Map;
  4.  
  5. import org.springframework.http.HttpEntity;
  6. import org.springframework.http.HttpHeaders;
  7. import org.springframework.http.HttpMethod;
  8. import org.springframework.http.ResponseEntity;
  9. import org.springframework.web.client.RestTemplate;
  10.  
  11. /**
  12.  * RestTemplate 远程调用工具类
  13.  *
  14.  * @author Logan
  15.  * @createDate 2019-02-08
  16.  *
  17.  */
  18. public class RestTemplateUtils {
  19.  
  20.     private static final RestTemplate restTemplate = new RestTemplate();
  21.  
  22.     // ----------------------------------GET-------------------------------------------------------
  23.  
  24.     /**
  25.      * GET请求调用方式
  26.      *
  27.      * @param url 请求URL
  28.      * @param responseType 返回对象类型
  29.      * @return ResponseEntity 响应对象封装类
  30.      */
  31.     public static <T> ResponseEntity<T> get(String url, Class<T> responseType) {
  32.         return restTemplate.getForEntity(url, responseType);
  33.     }
  34.  
  35.     /**
  36.      * GET请求调用方式
  37.      *
  38.      * @param url 请求URL
  39.      * @param responseType 返回对象类型
  40.      * @param uriVariables URL中的变量，按顺序依次对应
  41.      * @return ResponseEntity 响应对象封装类
  42.      */
  43.     public static <T> ResponseEntity<T> get(String url, Class<T> responseType, Object... uriVariables) {
  44.         return restTemplate.getForEntity(url, responseType, uriVariables);
  45.     }
  46.  
  47.     /**
  48.      * GET请求调用方式
  49.      *
  50.      * @param url 请求URL
  51.      * @param responseType 返回对象类型
  52.      * @param uriVariables URL中的变量，与Map中的key对应
  53.      * @return ResponseEntity 响应对象封装类
  54.      */
  55.     public static <T> ResponseEntity<T> get(String url, Class<T> responseType, Map<String, ?> uriVariables) {
  56.         return restTemplate.getForEntity(url, responseType, uriVariables);
  57.     }
  58.  
  59.     /**
  60.      * 带请求头的GET请求调用方式
  61.      *
  62.      * @param url 请求URL
  63.      * @param headers 请求头参数
  64.      * @param responseType 返回对象类型
  65.      * @param uriVariables URL中的变量，按顺序依次对应
  66.      * @return ResponseEntity 响应对象封装类
  67.      */
  68.     public static <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
  69.         HttpHeaders httpHeaders = new HttpHeaders();
  70.         httpHeaders.setAll(headers);
  71.         return get(url, httpHeaders, responseType, uriVariables);
  72.     }
  73.  
  74.     /**
  75.      * 带请求头的GET请求调用方式
  76.      *
  77.      * @param url 请求URL
  78.      * @param headers 请求头参数
  79.      * @param responseType 返回对象类型
  80.      * @param uriVariables URL中的变量，按顺序依次对应
  81.      * @return ResponseEntity 响应对象封装类
  82.      */
  83.     public static <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
  84.         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
  85.         return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
  86.     }
  87.  
  88.     /**
  89.      * 带请求头的GET请求调用方式
  90.      *
  91.      * @param url 请求URL
  92.      * @param headers 请求头参数
  93.      * @param responseType 返回对象类型
  94.      * @param uriVariables URL中的变量，与Map中的key对应
  95.      * @return ResponseEntity 响应对象封装类
  96.      */
  97.     public static <T> ResponseEntity<T> get(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
  98.         HttpHeaders httpHeaders = new HttpHeaders();
  99.         httpHeaders.setAll(headers);
  100.         return get(url, httpHeaders, responseType, uriVariables);
  101.     }
  102.  
  103.     /**
  104.      * 带请求头的GET请求调用方式
  105.      *
  106.      * @param url 请求URL
  107.      * @param headers 请求头参数
  108.      * @param responseType 返回对象类型
  109.      * @param uriVariables URL中的变量，与Map中的key对应
  110.      * @return ResponseEntity 响应对象封装类
  111.      */
  112.     public static <T> ResponseEntity<T> get(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
  113.         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
  114.         return exchange(url, HttpMethod.GET, requestEntity, responseType, uriVariables);
  115.     }
  116.  
  117.     // ----------------------------------POST-------------------------------------------------------
  118.  
  119.     /**
  120.      * POST请求调用方式
  121.      *
  122.      * @param url 请求URL
  123.      * @param responseType 返回对象类型
  124.      * @return
  125.      */
  126.     public static <T> ResponseEntity<T> post(String url, Class<T> responseType) {
  127.         return restTemplate.postForEntity(url, HttpEntity.EMPTY, responseType);
  128.     }
  129.  
  130.     /**
  131.      * POST请求调用方式
  132.      *
  133.      * @param url 请求URL
  134.      * @param requestBody 请求参数体
  135.      * @param responseType 返回对象类型
  136.      * @return ResponseEntity 响应对象封装类
  137.      */
  138.     public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType) {
  139.         return restTemplate.postForEntity(url, requestBody, responseType);
  140.     }
  141.  
  142.     /**
  143.      * POST请求调用方式
  144.      *
  145.      * @param url 请求URL
  146.      * @param requestBody 请求参数体
  147.      * @param responseType 返回对象类型
  148.      * @param uriVariables URL中的变量，按顺序依次对应
  149.      * @return ResponseEntity 响应对象封装类
  150.      */
  151.     public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
  152.         return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
  153.     }
  154.  
  155.     /**
  156.      * POST请求调用方式
  157.      *
  158.      * @param url 请求URL
  159.      * @param requestBody 请求参数体
  160.      * @param responseType 返回对象类型
  161.      * @param uriVariables URL中的变量，与Map中的key对应
  162.      * @return ResponseEntity 响应对象封装类
  163.      */
  164.     public static <T> ResponseEntity<T> post(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
  165.         return restTemplate.postForEntity(url, requestBody, responseType, uriVariables);
  166.     }
  167.  
  168.     /**
  169.      * 带请求头的POST请求调用方式
  170.      *
  171.      * @param url 请求URL
  172.      * @param headers 请求头参数
  173.      * @param requestBody 请求参数体
  174.      * @param responseType 返回对象类型
  175.      * @param uriVariables URL中的变量，按顺序依次对应
  176.      * @return ResponseEntity 响应对象封装类
  177.      */
  178.     public static <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
  179.         HttpHeaders httpHeaders = new HttpHeaders();
  180.         httpHeaders.setAll(headers);
  181.         return post(url, httpHeaders, requestBody, responseType, uriVariables);
  182.     }
  183.  
  184.     /**
  185.      * 带请求头的POST请求调用方式
  186.      *
  187.      * @param url 请求URL
  188.      * @param headers 请求头参数
  189.      * @param requestBody 请求参数体
  190.      * @param responseType 返回对象类型
  191.      * @param uriVariables URL中的变量，按顺序依次对应
  192.      * @return ResponseEntity 响应对象封装类
  193.      */
  194.     public static <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
  195.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
  196.         return post(url, requestEntity, responseType, uriVariables);
  197.     }
  198.  
  199.     /**
  200.      * 带请求头的POST请求调用方式
  201.      *
  202.      * @param url 请求URL
  203.      * @param headers 请求头参数
  204.      * @param requestBody 请求参数体
  205.      * @param responseType 返回对象类型
  206.      * @param uriVariables URL中的变量，与Map中的key对应
  207.      * @return ResponseEntity 响应对象封装类
  208.      */
  209.     public static <T> ResponseEntity<T> post(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
  210.         HttpHeaders httpHeaders = new HttpHeaders();
  211.         httpHeaders.setAll(headers);
  212.         return post(url, httpHeaders, requestBody, responseType, uriVariables);
  213.     }
  214.  
  215.     /**
  216.      * 带请求头的POST请求调用方式
  217.      *
  218.      * @param url 请求URL
  219.      * @param headers 请求头参数
  220.      * @param requestBody 请求参数体
  221.      * @param responseType 返回对象类型
  222.      * @param uriVariables URL中的变量，与Map中的key对应
  223.      * @return ResponseEntity 响应对象封装类
  224.      */
  225.     public static <T> ResponseEntity<T> post(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
  226.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
  227.         return post(url, requestEntity, responseType, uriVariables);
  228.     }
  229.  
  230.     /**
  231.      * 自定义请求头和请求体的POST请求调用方式
  232.      *
  233.      * @param url 请求URL
  234.      * @param requestEntity 请求头和请求体封装对象
  235.      * @param responseType 返回对象类型
  236.      * @param uriVariables URL中的变量，按顺序依次对应
  237.      * @return ResponseEntity 响应对象封装类
  238.      */
  239.     public static <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
  240.         return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
  241.     }
  242.  
  243.     /**
  244.      * 自定义请求头和请求体的POST请求调用方式
  245.      *
  246.      * @param url 请求URL
  247.      * @param requestEntity 请求头和请求体封装对象
  248.      * @param responseType 返回对象类型
  249.      * @param uriVariables URL中的变量，与Map中的key对应
  250.      * @return ResponseEntity 响应对象封装类
  251.      */
  252.     public static <T> ResponseEntity<T> post(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
  253.         return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseType, uriVariables);
  254.     }
  255.  
  256.     // ----------------------------------PUT-------------------------------------------------------
  257.  
  258.     /**
  259.      * PUT请求调用方式
  260.      *
  261.      * @param url 请求URL
  262.      * @param responseType 返回对象类型
  263.      * @param uriVariables URL中的变量，按顺序依次对应
  264.      * @return ResponseEntity 响应对象封装类
  265.      */
  266.     public static <T> ResponseEntity<T> put(String url, Class<T> responseType, Object... uriVariables) {
  267.         return put(url, HttpEntity.EMPTY, responseType, uriVariables);
  268.     }
  269.  
  270.     /**
  271.      * PUT请求调用方式
  272.      *
  273.      * @param url 请求URL
  274.      * @param requestBody 请求参数体
  275.      * @param responseType 返回对象类型
  276.      * @param uriVariables URL中的变量，按顺序依次对应
  277.      * @return ResponseEntity 响应对象封装类
  278.      */
  279.     public static <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
  280.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
  281.         return put(url, requestEntity, responseType, uriVariables);
  282.     }
  283.  
  284.     /**
  285.      * PUT请求调用方式
  286.      *
  287.      * @param url 请求URL
  288.      * @param requestBody 请求参数体
  289.      * @param responseType 返回对象类型
  290.      * @param uriVariables URL中的变量，与Map中的key对应
  291.      * @return ResponseEntity 响应对象封装类
  292.      */
  293.     public static <T> ResponseEntity<T> put(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
  294.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
  295.         return put(url, requestEntity, responseType, uriVariables);
  296.     }
  297.  
  298.     /**
  299.      * 带请求头的PUT请求调用方式
  300.      *
  301.      * @param url 请求URL
  302.      * @param headers 请求头参数
  303.      * @param requestBody 请求参数体
  304.      * @param responseType 返回对象类型
  305.      * @param uriVariables URL中的变量，按顺序依次对应
  306.      * @return ResponseEntity 响应对象封装类
  307.      */
  308.     public static <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
  309.         HttpHeaders httpHeaders = new HttpHeaders();
  310.         httpHeaders.setAll(headers);
  311.         return put(url, httpHeaders, requestBody, responseType, uriVariables);
  312.     }
  313.  
  314.     /**
  315.      * 带请求头的PUT请求调用方式
  316.      *
  317.      * @param url 请求URL
  318.      * @param headers 请求头参数
  319.      * @param requestBody 请求参数体
  320.      * @param responseType 返回对象类型
  321.      * @param uriVariables URL中的变量，按顺序依次对应
  322.      * @return ResponseEntity 响应对象封装类
  323.      */
  324.     public static <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
  325.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
  326.         return put(url, requestEntity, responseType, uriVariables);
  327.     }
  328.  
  329.     /**
  330.      * 带请求头的PUT请求调用方式
  331.      *
  332.      * @param url 请求URL
  333.      * @param headers 请求头参数
  334.      * @param requestBody 请求参数体
  335.      * @param responseType 返回对象类型
  336.      * @param uriVariables URL中的变量，与Map中的key对应
  337.      * @return ResponseEntity 响应对象封装类
  338.      */
  339.     public static <T> ResponseEntity<T> put(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
  340.         HttpHeaders httpHeaders = new HttpHeaders();
  341.         httpHeaders.setAll(headers);
  342.         return put(url, httpHeaders, requestBody, responseType, uriVariables);
  343.     }
  344.  
  345.     /**
  346.      * 带请求头的PUT请求调用方式
  347.      *
  348.      * @param url 请求URL
  349.      * @param headers 请求头参数
  350.      * @param requestBody 请求参数体
  351.      * @param responseType 返回对象类型
  352.      * @param uriVariables URL中的变量，与Map中的key对应
  353.      * @return ResponseEntity 响应对象封装类
  354.      */
  355.     public static <T> ResponseEntity<T> put(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
  356.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
  357.         return put(url, requestEntity, responseType, uriVariables);
  358.     }
  359.  
  360.     /**
  361.      * 自定义请求头和请求体的PUT请求调用方式
  362.      *
  363.      * @param url 请求URL
  364.      * @param requestEntity 请求头和请求体封装对象
  365.      * @param responseType 返回对象类型
  366.      * @param uriVariables URL中的变量，按顺序依次对应
  367.      * @return ResponseEntity 响应对象封装类
  368.      */
  369.     public static <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
  370.         return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
  371.     }
  372.  
  373.     /**
  374.      * 自定义请求头和请求体的PUT请求调用方式
  375.      *
  376.      * @param url 请求URL
  377.      * @param requestEntity 请求头和请求体封装对象
  378.      * @param responseType 返回对象类型
  379.      * @param uriVariables URL中的变量，与Map中的key对应
  380.      * @return ResponseEntity 响应对象封装类
  381.      */
  382.     public static <T> ResponseEntity<T> put(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
  383.         return restTemplate.exchange(url, HttpMethod.PUT, requestEntity, responseType, uriVariables);
  384.     }
  385.  
  386.     // ----------------------------------DELETE-------------------------------------------------------
  387.  
  388.     /**
  389.      * DELETE请求调用方式
  390.      *
  391.      * @param url 请求URL
  392.      * @param responseType 返回对象类型
  393.      * @param uriVariables URL中的变量，按顺序依次对应
  394.      * @return ResponseEntity 响应对象封装类
  395.      */
  396.     public static <T> ResponseEntity<T> delete(String url, Class<T> responseType, Object... uriVariables) {
  397.         return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
  398.     }
  399.  
  400.     /**
  401.      * DELETE请求调用方式
  402.      *
  403.      * @param url 请求URL
  404.      * @param responseType 返回对象类型
  405.      * @param uriVariables URL中的变量，与Map中的key对应
  406.      * @return ResponseEntity 响应对象封装类
  407.      */
  408.     public static <T> ResponseEntity<T> delete(String url, Class<T> responseType, Map<String, ?> uriVariables) {
  409.         return delete(url, HttpEntity.EMPTY, responseType, uriVariables);
  410.     }
  411.  
  412.     /**
  413.      * DELETE请求调用方式
  414.      *
  415.      * @param url 请求URL
  416.      * @param requestBody 请求参数体
  417.      * @param responseType 返回对象类型
  418.      * @param uriVariables URL中的变量，按顺序依次对应
  419.      * @return ResponseEntity 响应对象封装类
  420.      */
  421.     public static <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Object... uriVariables) {
  422.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
  423.         return delete(url, requestEntity, responseType, uriVariables);
  424.     }
  425.  
  426.     /**
  427.      * DELETE请求调用方式
  428.      *
  429.      * @param url 请求URL
  430.      * @param requestBody 请求参数体
  431.      * @param responseType 返回对象类型
  432.      * @param uriVariables URL中的变量，与Map中的key对应
  433.      * @return ResponseEntity 响应对象封装类
  434.      */
  435.     public static <T> ResponseEntity<T> delete(String url, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
  436.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody);
  437.         return delete(url, requestEntity, responseType, uriVariables);
  438.     }
  439.  
  440.     /**
  441.      * 带请求头的DELETE请求调用方式
  442.      *
  443.      * @param url 请求URL
  444.      * @param headers 请求头参数
  445.      * @param responseType 返回对象类型
  446.      * @param uriVariables URL中的变量，按顺序依次对应
  447.      * @return ResponseEntity 响应对象封装类
  448.      */
  449.     public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Object... uriVariables) {
  450.         HttpHeaders httpHeaders = new HttpHeaders();
  451.         httpHeaders.setAll(headers);
  452.         return delete(url, httpHeaders, responseType, uriVariables);
  453.     }
  454.  
  455.     /**
  456.      * 带请求头的DELETE请求调用方式
  457.      *
  458.      * @param url 请求URL
  459.      * @param headers 请求头参数
  460.      * @param responseType 返回对象类型
  461.      * @param uriVariables URL中的变量，按顺序依次对应
  462.      * @return ResponseEntity 响应对象封装类
  463.      */
  464.     public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Object... uriVariables) {
  465.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
  466.         return delete(url, requestEntity, responseType, uriVariables);
  467.     }
  468.  
  469.     /**
  470.      * 带请求头的DELETE请求调用方式
  471.      *
  472.      * @param url 请求URL
  473.      * @param headers 请求头参数
  474.      * @param responseType 返回对象类型
  475.      * @param uriVariables URL中的变量，与Map中的key对应
  476.      * @return ResponseEntity 响应对象封装类
  477.      */
  478.     public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Class<T> responseType, Map<String, ?> uriVariables) {
  479.         HttpHeaders httpHeaders = new HttpHeaders();
  480.         httpHeaders.setAll(headers);
  481.         return delete(url, httpHeaders, responseType, uriVariables);
  482.     }
  483.  
  484.     /**
  485.      * 带请求头的DELETE请求调用方式
  486.      *
  487.      * @param url 请求URL
  488.      * @param headers 请求头参数
  489.      * @param responseType 返回对象类型
  490.      * @param uriVariables URL中的变量，与Map中的key对应
  491.      * @return ResponseEntity 响应对象封装类
  492.      */
  493.     public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Class<T> responseType, Map<String, ?> uriVariables) {
  494.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(headers);
  495.         return delete(url, requestEntity, responseType, uriVariables);
  496.     }
  497.  
  498.     /**
  499.      * 带请求头的DELETE请求调用方式
  500.      *
  501.      * @param url 请求URL
  502.      * @param headers 请求头参数
  503.      * @param requestBody 请求参数体
  504.      * @param responseType 返回对象类型
  505.      * @param uriVariables URL中的变量，按顺序依次对应
  506.      * @return ResponseEntity 响应对象封装类
  507.      */
  508.     public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
  509.         HttpHeaders httpHeaders = new HttpHeaders();
  510.         httpHeaders.setAll(headers);
  511.         return delete(url, httpHeaders, requestBody, responseType, uriVariables);
  512.     }
  513.  
  514.     /**
  515.      * 带请求头的DELETE请求调用方式
  516.      *
  517.      * @param url 请求URL
  518.      * @param headers 请求头参数
  519.      * @param requestBody 请求参数体
  520.      * @param responseType 返回对象类型
  521.      * @param uriVariables URL中的变量，按顺序依次对应
  522.      * @return ResponseEntity 响应对象封装类
  523.      */
  524.     public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Object... uriVariables) {
  525.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
  526.         return delete(url, requestEntity, responseType, uriVariables);
  527.     }
  528.  
  529.     /**
  530.      * 带请求头的DELETE请求调用方式
  531.      *
  532.      * @param url 请求URL
  533.      * @param headers 请求头参数
  534.      * @param requestBody 请求参数体
  535.      * @param responseType 返回对象类型
  536.      * @param uriVariables URL中的变量，与Map中的key对应
  537.      * @return ResponseEntity 响应对象封装类
  538.      */
  539.     public static <T> ResponseEntity<T> delete(String url, Map<String, String> headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
  540.         HttpHeaders httpHeaders = new HttpHeaders();
  541.         httpHeaders.setAll(headers);
  542.         return delete(url, httpHeaders, requestBody, responseType, uriVariables);
  543.     }
  544.  
  545.     /**
  546.      * 带请求头的DELETE请求调用方式
  547.      *
  548.      * @param url 请求URL
  549.      * @param headers 请求头参数
  550.      * @param requestBody 请求参数体
  551.      * @param responseType 返回对象类型
  552.      * @param uriVariables URL中的变量，与Map中的key对应
  553.      * @return ResponseEntity 响应对象封装类
  554.      */
  555.     public static <T> ResponseEntity<T> delete(String url, HttpHeaders headers, Object requestBody, Class<T> responseType, Map<String, ?> uriVariables) {
  556.         HttpEntity<Object> requestEntity = new HttpEntity<Object>(requestBody, headers);
  557.         return delete(url, requestEntity, responseType, uriVariables);
  558.     }
  559.  
  560.     /**
  561.      * 自定义请求头和请求体的DELETE请求调用方式
  562.      *
  563.      * @param url 请求URL
  564.      * @param requestEntity 请求头和请求体封装对象
  565.      * @param responseType 返回对象类型
  566.      * @param uriVariables URL中的变量，按顺序依次对应
  567.      * @return ResponseEntity 响应对象封装类
  568.      */
  569.     public static <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
  570.         return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
  571.     }
  572.  
  573.     /**
  574.      * 自定义请求头和请求体的DELETE请求调用方式
  575.      *
  576.      * @param url 请求URL
  577.      * @param requestEntity 请求头和请求体封装对象
  578.      * @param responseType 返回对象类型
  579.      * @param uriVariables URL中的变量，与Map中的key对应
  580.      * @return ResponseEntity 响应对象封装类
  581.      */
  582.     public static <T> ResponseEntity<T> delete(String url, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
  583.         return restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, responseType, uriVariables);
  584.     }
  585.  
  586.     // ----------------------------------通用方法-------------------------------------------------------
  587.  
  588.     /**
  589.      * 通用调用方式
  590.      *
  591.      * @param url 请求URL
  592.      * @param method 请求方法类型
  593.      * @param requestEntity 请求头和请求体封装对象
  594.      * @param responseType 返回对象类型
  595.      * @param uriVariables URL中的变量，按顺序依次对应
  596.      * @return ResponseEntity 响应对象封装类
  597.      */
  598.     public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) {
  599.         return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
  600.     }
  601.  
  602.     /**
  603.      * 通用调用方式
  604.      *
  605.      * @param url 请求URL
  606.      * @param method 请求方法类型
  607.      * @param requestEntity 请求头和请求体封装对象
  608.      * @param responseType 返回对象类型
  609.      * @param uriVariables URL中的变量，与Map中的key对应
  610.      * @return ResponseEntity 响应对象封装类
  611.      */
  612.     public static <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) {
  613.         return restTemplate.exchange(url, method, requestEntity, responseType, uriVariables);
  614.     }
  615.  
  616.     /**
  617.      * 获取RestTemplate实例对象，可自由调用其方法
  618.      *
  619.      * @return RestTemplate实例对象
  620.      */
  621.     public static RestTemplate getRestTemplate() {
  622.         return restTemplate;
  623.     }
  624.  
  625. }

测试示例如下：

RestTest.java

  1. package test;
  2.  
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.util.ArrayList;
  6. import java.util.HashMap;
  7. import java.util.List;
  8. import java.util.Map;
  9.  
  10. import org.apache.commons.io.FileUtils;
  11. import org.junit.Test;
  12. import org.springframework.core.io.FileSystemResource;
  13. import org.springframework.http.HttpStatus;
  14. import org.springframework.http.ResponseEntity;
  15. import org.springframework.util.LinkedMultiValueMap;
  16. import org.springframework.util.MultiValueMap;
  17.  
  18. import com.alibaba.fastjson.JSONObject;
  19.  
  20. import utils.RestTemplateUtils;
  21.  
  22. /**
  23.  * RestTemplate 功能测试类
  24.  *
  25.  * @author Logan
  26.  * @createDate 2019-02-08
  27.  *
  28.  */
  29. public class RestTest {
  30.  
  31.     /**
  32.      * 测试HTTPS请求访问博客园
  33.      */
  34.     @Test
  35.     public void test() {
  36.         String url = "https://www.cnblogs.com/{id}/p/{pageName}.html";
  37.         String id = "jonban";
  38.         List<String> pages = new ArrayList<>();
  39.         pages.add("rest");
  40.         pages.add("jsoup");
  41.         pages.add("sms");
  42.         pages.add("rememberMe");
  43.         pages.add("properties");
  44.         pages.add("async");
  45.  
  46.         for (String pageName : pages) {
  47.             ResponseEntity<String> entity = RestTemplateUtils.get(url, String.class, id, pageName);
  48.             System.out.println(entity.getStatusCode());
  49.             System.out.println(entity.getBody());
  50.         }
  51.  
  52.     }
  53.  
  54.     /**
  55.      * 测试带请求头参数Headers的GET请求，POST类似
  56.      */
  57.     @Test
  58.     public void testHeaders() {
  59.         String url = "http://127.0.0.1:8080/test/Logan?age=16";
  60.         Map<String, String> headers = new HashMap<>();
  61.         headers.put("appId", "Basic MyAppId");
  62.         ResponseEntity<String> entity = RestTemplateUtils.get(url, headers, String.class);
  63.         System.out.println(entity.getStatusCode());
  64.         System.out.println(entity.getBody());
  65.     }
  66.  
  67.     /**
  68.      * 测试普通表单参数的POST请求
  69.      */
  70.     @Test
  71.     public void sayHello() {
  72.         String url = "http://127.0.0.1:8080/test/sayHello";
  73.         MultiValueMap<String, Object> requestBody = new LinkedMultiValueMap<>();
  74.         requestBody.add("name", "Logan");
  75.         requestBody.add("age", 12);
  76.         ResponseEntity<JSONObject> response = RestTemplateUtils.post(url, requestBody, JSONObject.class);
  77.  
  78.         System.out.println(response.getStatusCode());
  79.         System.out.println(response.getBody());
  80.     }
  81.  
  82.     /**
  83.      * 测试JSON格式请求体Body方式POST请求
  84.      */
  85.     @Test
  86.     public void sayHelloBody() {
  87.         String url = "http://127.0.0.1:8080/test/sayHelloBody";
  88.         JSONObject requestBody = new JSONObject();
  89.         requestBody.put("name", "Logan");
  90.         requestBody.put("age", 16);
  91.         ResponseEntity<JSONObject> response = RestTemplateUtils.post(url, requestBody, JSONObject.class);
  92.  
  93.         System.out.println(response.getStatusCode());
  94.         System.out.println(response.getBody());
  95.     }
  96.  
  97.     /**
  98.      * 测试上传文件
  99.      */
  100.     @Test
  101.     public void uploadFile() {
  102.         String url = "http://127.0.0.1:8080/test/uploadFile";
  103.         MultiValueMap<String, Object> requestBody = new LinkedMultiValueMap<>();
  104.         requestBody.add("uploadPath", "G:\\Temp\\Test");
  105.         requestBody.add("file", new FileSystemResource("G:\\Java\\JavaStyle.xml"));
  106.         requestBody.add("file2", new FileSystemResource("G:\\Java\\jad.exe"));
  107.  
  108.         ResponseEntity<JSONObject> response = RestTemplateUtils.post(url, requestBody, JSONObject.class);
  109.  
  110.         System.out.println(response.getStatusCode());
  111.         System.out.println(response.getBody());
  112.     }
  113.  
  114.     @Test
  115.     public void downloadFile() {
  116.         try {
  117.             String url = "http://127.0.0.1:8080/test/downloadFile?filePath={filePath}&fileName={fileName}";
  118.  
  119.             String filePath = "G:\\Java";
  120.             String fileName = "JavaStyle.xml";
  121.  
  122.             ResponseEntity<byte[]> response = RestTemplateUtils.get(url, byte[].class, filePath, fileName);
  123.             System.out.println(response.getStatusCode());
  124.             System.out.println(response.getHeaders().getContentType());
  125.  
  126.             // 如果返回时文本内容，则直接输出
  127.             if ("text/html;charset=UTF-8".equals(response.getHeaders().getContentType().toString())) {
  128.                 System.out.println(new String(response.getBody(), "UTF-8"));
  129.             }
  130.  
  131.             // 输出响应内容到本地文件
  132.             else {
  133.  
  134.                 File file = new File("G:\\Temp\\Test", fileName);
  135.                 if (HttpStatus.OK.equals(response.getStatusCode())) {
  136.                     FileUtils.writeByteArrayToFile(file, response.getBody());
  137.                 }
  138.             }
  139.         } catch (IOException e) {
  140.             e.printStackTrace();
  141.         }
  142.  
  143.     }
  144.  
  145.     /**
  146.      * 测试下载阿里巴巴的fastjson-1.2.56.jar
  147.      */
  148.     @Test
  149.     public void downloadFile2() {
  150.         try {
  151.             String url = "http://central.maven.org/maven2/com/alibaba/fastjson/1.2.56/fastjson-1.2.56.jar";
  152.  
  153.             ResponseEntity<byte[]> response = RestTemplateUtils.get(url, byte[].class);
  154.             System.out.println(response.getStatusCode());
  155.  
  156.             // 下载文件路径，可根据本地磁盘位置选择下载路径
  157.             File file = new File("G:\\Temp\\Test\\fastjson-1.2.56.jar");
  158.             if (HttpStatus.OK.equals(response.getStatusCode())) {
  159.                 FileUtils.writeByteArrayToFile(file, response.getBody());
  160.             }
  161.         } catch (IOException e) {
  162.             e.printStackTrace();
  163.         }
  164.  
  165.     }
  166.  
  167. }

测试远程服务器接口示例如下：

1.   新建Maven项目 test-server

2.   pom.xml

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
  4.         http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.  
  6.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.java</groupId>
  8.     <artifactId>test-server</artifactId>
  9.     <version>1.0.0</version>
  10.  
  11.     <parent>
  12.         <groupId>org.springframework.boot</groupId>
  13.         <artifactId>spring-boot-starter-parent</artifactId>
  14.         <version>2.0.5.RELEASE</version>
  15.     </parent>
  16.  
  17.     <dependencies>
  18.  
  19.         <!-- Spring Boot -->
  20.         <dependency>
  21.             <groupId>org.springframework.boot</groupId>
  22.             <artifactId>spring-boot-starter-web</artifactId>
  23.         </dependency>
  24.  
  25.         <dependency>
  26.             <groupId>commons-fileupload</groupId>
  27.             <artifactId>commons-fileupload</artifactId>
  28.             <version>1.3.3</version>
  29.         </dependency>
  30.         <dependency>
  31.             <groupId>com.alibaba</groupId>
  32.             <artifactId>fastjson</artifactId>
  33.             <version>1.2.56</version>
  34.         </dependency>
  35.  
  36.         <!-- 热部署 -->
  37.         <dependency>
  38.             <groupId>org.springframework</groupId>
  39.             <artifactId>springloaded</artifactId>
  40.             <version>1.2.8.RELEASE</version>
  41.         </dependency>
  42.         <dependency>
  43.             <groupId>org.springframework.boot</groupId>
  44.             <artifactId>spring-boot-devtools</artifactId>
  45.         </dependency>
  46.  
  47.     </dependencies>
  48.  
  49.     <build>
  50.         <finalName>${project.artifactId}</finalName>
  51.         <plugins>
  52.             <plugin>
  53.                 <groupId>org.apache.maven.plugins</groupId>
  54.                 <artifactId>maven-compiler-plugin</artifactId>
  55.                 <configuration>
  56.                     <source>1.8</source>
  57.                     <target>1.8</target>
  58.                     <encoding>UTF-8</encoding>
  59.                 </configuration>
  60.             </plugin>
  61.  
  62.             <plugin>
  63.                 <groupId>org.springframework.boot</groupId>
  64.                 <artifactId>spring-boot-maven-plugin</artifactId>
  65.                 <executions>
  66.                     <execution>
  67.                         <goals>
  68.                             <goal>repackage</goal>
  69.                         </goals>
  70.                     </execution>
  71.                 </executions>
  72.             </plugin>
  73.         </plugins>
  74.     </build>
  75. </project>

3.   TestServerStarter.java

  1. package com.java;
  2.  
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5.  
  6. /**
  7.  * 测试服务器主启动类
  8.  *
  9.  * @author Logan
  10.  * @createDate 2019-02-08
  11.  *
  12.  */
  13. @SpringBootApplication
  14. public class TestServerStarter {
  15.  
  16.     public static void main(String[] args) {
  17.         SpringApplication.run(TestServerStarter.class, args);
  18.     }
  19.  
  20. }

4.   Person.java

  1. package com.java.entity;
  2.  
  3. /**
  4.  * 测试实体类
  5.  *
  6.  * @author Logan
  7.  * @createDate 2019-02-08
  8.  *
  9.  */
  10. public class Person {
  11.  
  12.     private String name;
  13.  
  14.     private int age;
  15.  
  16.     public String getName() {
  17.         return name;
  18.     }
  19.  
  20.     public void setName(String name) {
  21.         this.name = name;
  22.     }
  23.  
  24.     public int getAge() {
  25.         return age;
  26.     }
  27.  
  28.     public void setAge(int age) {
  29.         this.age = age;
  30.     }
  31.  
  32.     @Override
  33.     public String toString() {
  34.         return "Person [name=" + name + ", age=" + age + "]";
  35.     }
  36.  
  37. }

5.   UploadConfig.java

  1. package com.java.config;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.multipart.commons.CommonsMultipartResolver;
  6.  
  7. /**
  8.  * 上传文件配置
  9.  *
  10.  * @author Logan
  11.  * @createDate 2019-02-08
  12.  *
  13.  */
  14. @Configuration
  15. public class UploadConfig {
  16.  
  17.     @Bean
  18.     public CommonsMultipartResolver multipartResolver() {
  19.         CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
  20.  
  21.         // 设置最大上传文件大小为4GB
  22.         multipartResolver.setMaxUploadSize(4294967296l);
  23.         return multipartResolver;
  24.     }
  25.  
  26. }

6.   TestController.java

  1. package com.java.controller;
  2.  
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileNotFoundException;
  6. import java.io.IOException;
  7. import java.io.OutputStream;
  8. import java.io.PrintWriter;
  9. import java.net.URLEncoder;
  10. import java.util.ArrayList;
  11. import java.util.HashMap;
  12. import java.util.List;
  13. import java.util.Map;
  14.  
  15. import javax.servlet.http.HttpServletRequest;
  16. import javax.servlet.http.HttpServletResponse;
  17.  
  18. import org.apache.commons.io.IOUtils;
  19. import org.springframework.beans.factory.annotation.Autowired;
  20. import org.springframework.web.bind.annotation.GetMapping;
  21. import org.springframework.web.bind.annotation.PathVariable;
  22. import org.springframework.web.bind.annotation.PostMapping;
  23. import org.springframework.web.bind.annotation.RequestBody;
  24. import org.springframework.web.bind.annotation.RequestMapping;
  25. import org.springframework.web.bind.annotation.RequestParam;
  26. import org.springframework.web.bind.annotation.RestController;
  27. import org.springframework.web.multipart.commons.CommonsMultipartFile;
  28.  
  29. import com.java.entity.Person;
  30.  
  31. /**
  32.  * 测试服务器测试接口类
  33.  *
  34.  * @author Logan
  35.  * @createDate 2019-02-08
  36.  *
  37.  */
  38. @RestController
  39. @RequestMapping("/test")
  40. public class TestController {
  41.  
  42.     @Autowired
  43.     private HttpServletRequest request;
  44.  
  45.     @GetMapping("/{name}")
  46.     public Person test(@PathVariable("name") String name, int age) {
  47.         String appId = request.getHeader("appId");
  48.         System.out.println("appId: " + appId);
  49.  
  50.         Person person = new Person();
  51.         person.setName(name);
  52.         person.setAge(age);
  53.         System.out.println(person);
  54.  
  55.         return person;
  56.     }
  57.  
  58.     @PostMapping("/sayHello")
  59.     public Person sayHello(Person person) {
  60.         System.out.println(person);
  61.         return person;
  62.     }
  63.  
  64.     @PostMapping("/sayHelloBody")
  65.     public Person sayHelloBody(@RequestBody Person person) {
  66.         System.out.println(person);
  67.         return person;
  68.     }
  69.  
  70.     @RequestMapping("/uploadFile")
  71.     public Map<String, Object> uploadFile(@RequestParam(required = true) CommonsMultipartFile file, @RequestParam(required = true) CommonsMultipartFile file2, String uploadPath) {
  72.         Map<String, Object> result = new HashMap<String, Object>();
  73.         try {
  74.  
  75.             // 上傳文件
  76.             File path = new File(uploadPath);
  77.             if (!path.isDirectory() || !path.exists()) {
  78.                 path.mkdirs();
  79.             }
  80.             File outFile = new File(uploadPath, file.getOriginalFilename());
  81.             file.transferTo(outFile);
  82.  
  83.             File outFile2 = new File(uploadPath, file2.getOriginalFilename());
  84.             file2.transferTo(outFile2);
  85.  
  86.             List<String> files = new ArrayList<>();
  87.             files.add(outFile.getAbsolutePath());
  88.             files.add(outFile2.getAbsolutePath());
  89.  
  90.             result.put("successful", true);
  91.             result.put("files", files);
  92.         } catch (Exception e) {
  93.             e.printStackTrace();
  94.             result.put("successful", false);
  95.             result.put("msg", e.getMessage());
  96.         }
  97.         return result;
  98.     }
  99.  
  100.     @GetMapping("/downloadFile")
  101.     public void downloadFile(HttpServletResponse response, String filePath, String fileName) {
  102.         File file = new File(filePath, fileName);
  103.         if (file.exists() && file.isFile()) {
  104.  
  105.             try (
  106.                     OutputStream out = response.getOutputStream();
  107.                     FileInputStream in = new FileInputStream(file);
  108.             ) {
  109.  
  110.                 // 对文件名进行URL转义，防止中文乱码
  111.                 fileName = URLEncoder.encode(fileName, "UTF-8");
  112.  
  113.                 // 空格用URLEncoder.encode转义后会变成"+"，所以要替换成"%20"，浏览器会解码回空格
  114.                 fileName = fileName.replace("+", "%20");
  115.  
  116.                 // "+"用URLEncoder.encode转义后会变成"%2B"，所以要替换成"+"，浏览器会解码回"+"
  117.                 fileName = fileName.replace("%2B", "+");
  118.                 response.setContentType("application/x-msdownload;charset=UTF-8");
  119.                 response.setHeader("Content-Disposition", "attachment; filename=" + fileName);
  120.                 IOUtils.copy(in, out);
  121.             } catch (FileNotFoundException e) {
  122.                 e.printStackTrace();
  123.             } catch (IOException e) {
  124.                 e.printStackTrace();
  125.             }
  126.         }
  127.  
  128.         // 无法下载时给出提示信息
  129.         else {
  130.             response.setContentType("text/html;charset=UTF-8");
  131.  
  132.             try (
  133.                     PrintWriter writer = response.getWriter();
  134.             ) {
  135.                 writer.write("找不到对应文件，请确认后重试！");
  136.                 writer.flush();
  137.             } catch (IOException e) {
  138.                 e.printStackTrace();
  139.             }
  140.         }
  141.  
  142.     }
  143.  
  144. }

7.   运行 TestServerStarter.java ，启动测试服务器。

运行RestTest.java 类中对应的测试方法，可以测试对应功能，各种情况典型示例已给出。

.

Spring 远程调用工具类RestTemplateUtils的更多相关文章

  1. Spring 的优秀工具类盘点

    文件资源操作 文件资源的操作是应用程序中常见的功能,如当上传一个文件后将其保存在特定目录下,从指定地址加载一个配置文件等等.我们一般使用 JDK 的 I/O 处理类完成这些操作,但对于一般的应用程序来 ...

  2. Spring 的优秀工具类盘点---转

    第 1 部分: 文件资源操作和 Web 相关工具类 http://www.ibm.com/developerworks/cn/java/j-lo-spring-utils1/ 文件资源操作 文件资源的 ...

  3. 【Java EE 学习 78 中】【数据采集系统第十天】【Spring远程调用】

    一.远程调用概述 1.远程调用的定义 在一个程序中就像调用本地中的方法一样调用另外一个远程程序中的方法,但是整个过程对本地完全透明,这就是远程调用.spring已经能够非常成熟的完成该项功能了. 2. ...

  4. Spring 的优秀工具类盘点第 2 部分

    特殊字符转义 由于 Web 应用程序需要联合使用到多种语言,每种语言都包含一些特殊的字符,对于动态语言或标签式的语言而言,如果需要动态构造语言的内容时,一个我们经常会碰到的问题就是特殊字符转义的问题. ...

  5. 带SSL证书的httpclient 远程接口工具类

    package com.iups.wx.util; import java.io.IOException; import java.io.UnsupportedEncodingException; i ...

  6. Spring的StringUtils工具类

    本文是转载文章,感觉比较好,如有侵权,请联系本人,我将及时删除. 原文网址:<Spring的StringUtils工具类> org.springframework.util.StringU ...

  7. Spring获取bean工具类,可用于在线程里面获取bean

    Spring获取bean工具类,可用于在线程里面获取bean import java.util.Locale; import org.springframework.beans.BeansExcept ...

  8. 简单了解Spring中常用工具类_java - JAVA

    文章来源:嗨学网 敏而好学论坛www.piaodoo.com 欢迎大家相互学习 文件资源操作 Spring 定义了一个 org.springframework.core.io.Resource 接口, ...

  9. spring -mvc service层调用工具类配置

    在service层时调用工具类时服务返回工具类对象为空 在此工具类上加上@Component注解就可以了 @Component:把普通pojo实例化到spring容器中,相当于配置文件中的 <b ...

随机推荐

  1. Python入妖5-----正则的基本使用

    什么是正则表达式 正则表达式是对字符串操作的一种逻辑公式,就是 事先定义好的一些特定字符.及这些特定字符的组合,组成一个“规则字符”,这个“规则字符” 来表达对字符的一种过滤逻辑. 正则并不是pyth ...

  2. SQL Server 如何更改SQL Server和windows身份方式验证

    1.安装sql后先用windows账户登陆进去,然后在sql上右键,选择“安全性”-“SQL Server和windows身份验证模式”然后确定 2.找到安全性——登陆名(sa用户)右键——状态,在登 ...

  3. Silverlight 用户代码未处理 TypeLoadException

    在Silverlight中动态创建Enum时,多次调用改方法出现上图所示错误,后来发现定义名称都是一样的, 在程序中声明全局变量去区别就可以了. int num = 1; private Type C ...

  4. python_案例综合：教材记录管理

    class Book(): def __init__(self,ISBN,Ftile,Author,Publisher): self.ISBN = ISBN self.Ftile = Ftile se ...

  5. Mybatis学习笔记10 - 动态sql之if判断

    示例代码: 接口定义: package com.mybatis.dao; import com.mybatis.bean.Employee; import java.util.List; public ...

  6. svn被锁 The project was not built due to "org.apache.subversion.javahl.ClientException: Attempted to lock an already-locked dir

    解决办法  :  右键该项目  ,---->Team---->选"Team"-->"Refresh/Cleanup",并确认"Ref ...

  7. CAD安装失败怎样卸载CAD 2011？错误提示某些产品无法安装

    AUTODESK系列软件着实令人头疼,安装失败之后不能完全卸载!!!(比如maya,cad,3dsmax等).有时手动删除注册表重装之后还是会出现各种问题,每个版本的C++Runtime和.NET f ...

  8. rsync+inotify实现数据的实时同步更新

    rsync可以实现触发式的文件同步,但是通过crontab守护进程方式进行触发,同步的数据和实际数据会有差异,而inotify可以监控文件系统的各种变化,当文件有任何变动时,就触发rsync同步,这样 ...

  9. 详细记录vue项目实战步骤(含vue-cli脚手架)

    一.通过vue-cli创建了一个demo. (vue-cli是快速构建这个单页应用的脚手架,本身继承了多种项目模板:webpack(含eslit,unit)和webpack-simple(无eslin ...

  10. transient和volatile

    transient和volatile两个关键字一个用于对象序列化,一个用于线程同步,都是Java中比较高阶的话题,简单总结一下. transient transient是类型修饰符,只能用来修饰字段. ...