本站的合作过的网站：北风网极客学院柠檬学院图灵学院
开启辅助访问 最新回复帖子最新发表帖子

Java学习者论坛

 找回密码
 立即注册

QQ登录

只需一步，快速开始

手机号码，快捷登录

恭喜Java学习者论坛（https://www.javaxxz.com）已经为数万Java学习者服务超过8年了！积累会员资料超过10000G+！
成为本站VIP会员，下载本站10000G+会员资源，购买链接：点击进入购买VIP会员
Java学习者论坛»论坛 › 论坛互动 › 经验心得总结 › Apache HttpClient 实现 Java 调用 Http 接口
JAVA高级面试进阶视频教程Java架构师系统进阶VIP课程

分布式高可用全栈开发微服务教程

Go语言视频零基础入门到精通

Java架构师3期(课件+源码)

Java开发全终端实战租房项目视频教程

SpringBoot2.X入门到高级使用教程

大数据培训第六期全套视频教程

深度学习（CNN RNN GAN）算法原理

Java亿级流量电商系统视频教程

互联网架构师视频教程

年薪50万Spark2.0从入门到精通

年薪50万！人工智能学习路线教程

年薪50万！大数据从入门到精通学习路线年薪50万！机器学习入门到精通视频教程
仿小米商城类app和小程序视频教程深度学习数据分析基础到实战最新黑马javaEE2.1就业课程从 0到JVM实战高手教程 MySQL入门到精通教程
返回列表 发新帖
查看: 346|回复: 0

[默认分类] Apache HttpClient 实现 Java 调用 Http 接口

[复制链接]
admin
  • TA的每日心情
    开心
    2021-12-13 21:45

    • 签到天数: 15 天

    [LV.4]偶尔看看III
    发表于 2018-6-30 10:06:06 | 显示全部楼层 |阅读模式
    本站已经为数万初学者服务超过7年！成为本站VIP会员，免金币下载本站10000G+VIP会员资料！

    本文内容大多基于官方文档和网上前辈经验总结，经过个人实践加以整理积累，仅供参考。

    1 新建一个测试用 Http URL，对登录的用户名和密码进行验证，并返回验证结果
    1.1 web.xml
    1. [code]<?xml version="1.0" encoding="UTF-8"?>
    2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3. xmlns="http://java.sun.com/xml/ns/javaee"
    4. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    5. http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    6. id="WebApp_ID"
    7. version="3.0">
    9.   <welcome-file-list>
    10.     <welcome-file>index.jsp</welcome-file>
    11.   </welcome-file-list>
    13.   <servlet>
    14.     <servlet-name>loginService</servlet-name>
    15.     <servlet-class>service.LoginService</servlet-class>
    16.     <load-on-startup>1</load-on-startup>
    17.   </servlet>
    18.   <servlet-mapping>
    19.     <servlet-name>loginService</servlet-name>
    20.     <url-pattern>/login</url-pattern>
    21.   </servlet-mapping>
    23. </web-app>
    复制代码
    [/code]
    1.2 Servlet
    1. [code]package service;
    3. import java.io.IOException;
    4. import java.io.OutputStream;
    6. import javax.servlet.ServletException;
    7. import javax.servlet.http.HttpServlet;
    8. import javax.servlet.http.HttpServletRequest;
    9. import javax.servlet.http.HttpServletResponse;
    11. public class LoginService extends HttpServlet {
    13.     @Override
    14.     protected void doGet(HttpServletRequest request, HttpServletResponse response)
    15.         throws ServletException, IOException {
    16.         String username = request.getParameter("username");
    17.         String password = request.getParameter("password");
    18.         OutputStream outputStream = response.getOutputStream();
    19.         response.setHeader("content-type", "application/json;charset=UTF-8");
    20.         String result = null;
    21.         if (username == null) {
    22.             result = "请输入用户名！";
    23.         } else if (password == null) {
    24.             result = "请输入密码！";
    25.         } else if (!username.equals("unique")) {
    26.             result = "用户名错误！";
    27.         } else if (!password.equals("ASDF")) {
    28.             result = "密码错误！";
    29.         } else {
    30.             result = "验证通过~~";
    31.         }
    32.         outputStream.write(result.getBytes("UTF-8"));
    33.     }
    35. }
    复制代码
    [/code]
    1.3 在浏览器中测试一下：





    2 通过 java 代码调用
    2.1 添加 Apache HttpClient 依赖包
    本文使用 Maven 管理依赖，关于 Maven 的使用可以参看：Apache Maven 或上网搜索相关资料
    注意：本文使用的 Apache HttpClient 版本是 4.5.3
    1. [code]<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.   <modelVersion>4.0.0</modelVersion>
    6.   <groupId>jyl</groupId>
    7.   <artifactId>Service</artifactId>
    8.   <version>0.0.1-SNAPSHOT</version>
    9.   <packaging>war</packaging>
    10.   <dependencies>
    11.     <dependency>
    12.       <groupId>org.apache.httpcomponents</groupId>
    13.       <artifactId>httpclient</artifactId>
    14.       <version>4.5.3</version>
    15.     </dependency>
    16.     <dependency>
    17.       <groupId>junit</groupId>
    18.       <artifactId>junit</artifactId>
    19.       <version>4.12</version>
    20.     </dependency>
    21.   </dependencies>
    22. </project>
    复制代码
    [/code]
    2.2 编写单元测试
    1. [code]import java.io.IOException;
    3. import org.apache.http.HttpEntity;
    4. import org.apache.http.client.ClientProtocolException;
    5. import org.apache.http.client.methods.CloseableHttpResponse;
    6. import org.apache.http.client.methods.HttpGet;
    7. import org.apache.http.impl.client.CloseableHttpClient;
    8. import org.apache.http.impl.client.HttpClients;
    9. import org.apache.http.util.EntityUtils;
    10. import org.junit.Test;
    12. public class TestHttpClient {
    14.     @Test
    15.     public void test() {
    16.         CloseableHttpClient httpClient = HttpClients.createDefault();
    17.         HttpGet httpGet = new HttpGet("http://localhost:8080/Service/login");
    18.         CloseableHttpResponse httpResponse = null;
    19.         try {
    20.             httpResponse = httpClient.execute(httpGet);
    21.             System.out.print("Protocol Version :: ");
    22.             System.out.println(httpResponse.getProtocolVersion());
    23.             System.out.println("--------------------------------------------------");
    24.             System.out.print("Status Code :: ");
    25.             System.out.println(httpResponse.getStatusLine().getStatusCode());
    26.             System.out.println("--------------------------------------------------");
    27.             System.out.print("Reason Phrase :: ");
    28.             System.out.println(httpResponse.getStatusLine().getReasonPhrase());
    29.             System.out.println("--------------------------------------------------");
    30.             System.out.print("Status Line :: ");
    31.             System.out.println(httpResponse.getStatusLine().toString());
    32.             System.out.println("--------------------------------------------------");
    33.             HttpEntity httpEntity = httpResponse.getEntity();
    34.             System.out.print("Content Length :: ");
    35.             System.out.println(httpEntity.getContentLength());
    36.             System.out.println("--------------------------------------------------");
    37.             System.out.print("Content Type :: ");
    38.             System.out.println(httpEntity.getContentType());
    39.             System.out.println("--------------------------------------------------");
    40.             System.out.print("Content :: ");
    41.             System.out.println(httpEntity.getContent());
    42.             System.out.println("--------------------------------------------------");
    43.             System.out.print("Content Text :: ");
    44.             System.out.println(EntityUtils.toString(httpEntity));
    45.         } catch (ClientProtocolException e) {
    46.             e.printStackTrace();
    47.         } catch (IOException e) {
    48.             e.printStackTrace();
    49.         } finally {
    50.             try {
    51.                 httpClient.close();
    52.                 httpResponse.close();
    53.             } catch (IOException e) {
    54.                 e.printStackTrace();
    55.             }
    56.         }
    58.     }
    60. }
    复制代码
    [/code]
    2.3 测试结果

    2.4 修改 HttpGet 参数测试返回的 Content Text
    1. [code]HttpGet httpGet = new HttpGet("http://localhost:8080/Service/login?username=unique");
    复制代码
    [/code]

    1. [code]HttpGet httpGet = new HttpGet("http://localhost:8080/Service/login?username=unique&password=ASDF");
    复制代码
    [/code]

    3 关于 org.apache.http.util.EntityUtils 的使用注意事项
    官方文档中建议严格控制使用 EntityUtils 读取 HttpEntity 的信息，除非请求的 HTTP 服务器是一个授信的服务器且返回的结果长度在一定范围内，下面是官方文档中的原文
    1. [code]However, the use of EntityUtils is strongly discouraged unless the response entities originate from a trusted HTTP server and are known to be of limited length.
    复制代码
    [/code]
    4 向 HttpGet 传递 URI 参数
    可以向 HttpGet 传递一个 java.net.URI 参数代替字符串参数
    1. [code]import java.io.IOException;
    2. import java.net.URI;
    3. import java.net.URISyntaxException;
    5. import org.apache.http.HttpEntity;
    6. import org.apache.http.client.methods.CloseableHttpResponse;
    7. import org.apache.http.client.methods.HttpGet;
    8. import org.apache.http.client.utils.URIBuilder;
    9. import org.apache.http.impl.client.CloseableHttpClient;
    10. import org.apache.http.impl.client.HttpClients;
    11. import org.apache.http.util.EntityUtils;
    12. import org.junit.Test;
    14. public class TestHttpClient {
    16.     @Test
    17.     public void test() {
    18.         CloseableHttpClient httpClient = HttpClients.createDefault();
    19.         HttpGet httpGet = null;
    20.         CloseableHttpResponse httpResponse = null;
    21.         try {
    22.             URI uri = new URIBuilder()
    23.                 .setScheme("http")
    24.                 .setHost("localhost")
    25.                 .setPort(8080)
    26.                 .setPath("/Service/login")
    27.                 .setParameter("username", "unique")
    28.                 .setParameter("password", "ASDF")
    29.                 .build();
    30.             httpGet = new HttpGet(uri);
    31.             httpResponse = httpClient.execute(httpGet);
    32.             HttpEntity httpEntity = httpResponse.getEntity();
    33.             System.out.println(EntityUtils.toString(httpEntity));
    34.         } catch (URISyntaxException | IOException e) {
    35.             e.printStackTrace();
    36.         } finally {
    37.             try {
    38.                 httpClient.close();
    39.                 httpResponse.close();
    40.             } catch (IOException e) {
    41.                 e.printStackTrace();
    42.             }
    43.         }
    44.     }
    46. }
    复制代码
    [/code]
    5 调用 Http Post 方法
    5.1 将 Servlet 的 doGet 方法修改为 doPost，逻辑不变
    1. [code]@Override
    2. protected void doPost(HttpServletRequest request, HttpServletResponse response)
    3.     throws ServletException, IOException {
    4.     String username = request.getParameter("username");
    5.     String password = request.getParameter("password");
    6.     OutputStream outputStream = response.getOutputStream();
    7.     response.setHeader("content-type", "application/json;charset=UTF-8");
    8.     String result = null;
    9.     if (username == null) {
    10.         result = "请输入用户名！";
    11.     } else if (password == null) {
    12.         result = "请输入密码！";
    13.     } else if (!username.equals("unique")) {
    14.         result = "用户名错误！";
    15.     } else if (!password.equals("ASDF")) {
    16.         result = "密码错误！";
    17.     } else {
    18.         result = "验证通过~~";
    19.     }
    20.     outputStream.write(result.getBytes("UTF-8"));
    21. }
    复制代码
    [/code]
    5.2 使用 org.apache.http.client.methods.HttpPost 替换 HttpGet
    1. [code]import java.io.IOException;
    2. import java.util.ArrayList;
    3. import java.util.List;
    5. import org.apache.http.Consts;
    6. import org.apache.http.HttpEntity;
    7. import org.apache.http.NameValuePair;
    8. import org.apache.http.client.entity.UrlEncodedFormEntity;
    9. import org.apache.http.client.methods.CloseableHttpResponse;
    10. import org.apache.http.client.methods.HttpPost;
    11. import org.apache.http.impl.client.CloseableHttpClient;
    12. import org.apache.http.impl.client.HttpClients;
    13. import org.apache.http.message.BasicNameValuePair;
    14. import org.apache.http.util.EntityUtils;
    15. import org.junit.Test;
    17. public class TestHttpClient {
    19.     @Test
    20.     public void test() {
    21.         List<NameValuePair> params = new ArrayList<>();
    22.         params.add(new BasicNameValuePair("username", "unique"));
    23.         params.add(new BasicNameValuePair("password", "ASDF"));
    24.         UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, Consts.UTF_8);
    25.         HttpPost httpPost = new HttpPost("http://localhost:8080/Service/login");
    26.         httpPost.setEntity(entity);
    27.         CloseableHttpClient httpClient = HttpClients.createDefault();
    28.         CloseableHttpResponse httpResponse = null;
    29.         try {
    30.             httpResponse = httpClient.execute(httpPost);
    31.             HttpEntity httpEntity = httpResponse.getEntity();
    32.             System.out.println(EntityUtils.toString(httpEntity));
    33.         } catch (IOException e) {
    34.             e.printStackTrace();
    35.         } finally {
    36.             try {
    37.                 httpClient.close();
    38.                 httpResponse.close();
    39.             } catch (IOException e) {
    40.                 e.printStackTrace();
    41.             }
    42.         }
    43.     }
    45. }
    复制代码
    [/code]
    5.3 同样给以给 HttpPost 传递 java.net.URI 参数取代字符串参数
    1. [code]import java.io.IOException;
    2. import java.net.URI;
    3. import java.net.URISyntaxException;
    4. import java.util.ArrayList;
    5. import java.util.List;
    7. import org.apache.http.Consts;
    8. import org.apache.http.HttpEntity;
    9. import org.apache.http.NameValuePair;
    10. import org.apache.http.client.entity.UrlEncodedFormEntity;
    11. import org.apache.http.client.methods.CloseableHttpResponse;
    12. import org.apache.http.client.methods.HttpPost;
    13. import org.apache.http.client.utils.URIBuilder;
    14. import org.apache.http.impl.client.CloseableHttpClient;
    15. import org.apache.http.impl.client.HttpClients;
    16. import org.apache.http.message.BasicNameValuePair;
    17. import org.apache.http.util.EntityUtils;
    18. import org.junit.Test;
    20. public class TestHttpClient {
    22.     @Test
    23.     public void test() {
    24.         List<NameValuePair> params = new ArrayList<>();
    25.         params.add(new BasicNameValuePair("username", "unique"));
    26.         params.add(new BasicNameValuePair("password", "ASDF"));
    27.         UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, Consts.UTF_8);
    28.         CloseableHttpClient httpClient = HttpClients.createDefault();
    29.         CloseableHttpResponse httpResponse = null;
    30.         try {
    31.             URI uri = new URIBuilder()
    32.                 .setScheme("http")
    33.                 .setHost("localhost")
    34.                 .setPort(8080)
    35.                 .setPath("/Service/login")
    36.                 .build();
    37.             HttpPost httpPost = new HttpPost(uri);
    38.             httpPost.setEntity(entity);
    39.             httpResponse = httpClient.execute(httpPost);
    40.             HttpEntity httpEntity = httpResponse.getEntity();
    41.             System.out.println(EntityUtils.toString(httpEntity));
    42.         } catch (IOException e) {
    43.             e.printStackTrace();
    44.         } catch (URISyntaxException e) {
    45.             e.printStackTrace();
    46.         } finally {
    47.             try {
    48.                 httpClient.close();
    49.                 httpResponse.close();
    50.             } catch (IOException e) {
    51.                 e.printStackTrace();
    52.             }
    53.         }
    54.     }
    56. }
    复制代码
    [/code]
    6 提取调用接口的工具类
    1. [code]import java.io.IOException;
    2. import java.net.URI;
    3. import java.net.URISyntaxException;
    4. import java.util.ArrayList;
    5. import java.util.List;
    6. import java.util.Map;
    8. import org.apache.http.Consts;
    9. import org.apache.http.HttpEntity;
    10. import org.apache.http.NameValuePair;
    11. import org.apache.http.client.ClientProtocolException;
    12. import org.apache.http.client.entity.UrlEncodedFormEntity;
    13. import org.apache.http.client.methods.CloseableHttpResponse;
    14. import org.apache.http.client.methods.HttpGet;
    15. import org.apache.http.client.methods.HttpPost;
    16. import org.apache.http.client.utils.URIBuilder;
    17. import org.apache.http.impl.client.CloseableHttpClient;
    18. import org.apache.http.impl.client.HttpClients;
    19. import org.apache.http.message.BasicNameValuePair;
    20. import org.apache.http.util.EntityUtils;
    22. public class HttpClientTool {
    24.     public class Method {
    25.         public static final String GET = "get";
    26.         public static final String POST = "post";
    27.     }
    29.     public static String invokeHttp(String method, String uri, Map<String, String> params)
    30.         throws IOException {
    31.         if (method.equals(HttpClientTool.Method.GET)) {
    32.             if (params == null) {
    33.                 return invokeHttpGet(uri);
    34.             } else {
    35.                 return invokeHttpGet(uri, params);
    36.             }
    37.         } else if (method.equals(HttpClientTool.Method.POST)) {
    38.             return invokeHttpPost(uri, params);
    39.         }
    40.         return null;
    41.     }
    43.     public static String invokeHttp(String method, URI uri, Map<String, String> params)
    44.         throws IOException, URISyntaxException {
    45.         if (method.equals(HttpClientTool.Method.GET)) {
    46.             if (params == null) {
    47.                 return invokeHttpGet(uri);
    48.             } else {
    49.                 return invokeHttpGet(uri, params);
    50.             }
    51.         } else if (method.equals(HttpClientTool.Method.POST)) {
    52.             return invokeHttpPost(uri, params);
    53.         }
    54.         return null;
    55.     }
    57.     public static String invokeHttp(String method, String scheme, String host, int port, String path, Map<String, String> params)
    58.         throws ClientProtocolException, URISyntaxException, IOException {
    59.         if (method.equals(HttpClientTool.Method.GET)) {
    60.             return invokeHttpGet(scheme, host, port, path, params);
    61.         } else if (method.equals(HttpClientTool.Method.POST)) {
    62.             return invokeHttpPost(scheme, host, port, path, params);
    63.         }
    64.         return null;
    65.     }
    67.     public static final String invokeHttpGet(String uri)
    68.         throws ClientProtocolException, IOException {
    69.         CloseableHttpClient client = HttpClients.createDefault();
    70.         CloseableHttpResponse response = null;
    71.         HttpGet httpGet = new HttpGet(uri);
    72.         try {
    73.             response = client.execute(httpGet);
    74.             HttpEntity entity = response.getEntity();
    75.             return EntityUtils.toString(entity);
    76.         } finally {
    77.             release(client, response);
    78.         }
    79.     }
    81.     public static final String invokeHttpGet(String uri, Map<String, String> params)
    82.         throws ClientProtocolException, IOException {
    83.         String executeUri = uri + "?";
    84.         for (Map.Entry<String, String> entry : params.entrySet()) {
    85.             executeUri += entry.getKey() + "=" + entry.getValue() + "&";
    86.         }
    87.         executeUri = executeUri.substring(0, executeUri.length() - 1);
    88.         CloseableHttpClient client = HttpClients.createDefault();
    89.         CloseableHttpResponse response = null;
    90.         HttpGet httpGet = new HttpGet(executeUri);
    91.         try {
    92.             response = client.execute(httpGet);
    93.             HttpEntity entity = response.getEntity();
    94.             return EntityUtils.toString(entity);
    95.         } finally {
    96.             release(client, response);
    97.         }
    98.     }
    100.     public static final String invokeHttpGet(URI uri)
    101.         throws ClientProtocolException, IOException {
    102.         CloseableHttpClient client = HttpClients.createDefault();
    103.         CloseableHttpResponse response = null;
    104.         HttpGet httpGet = new HttpGet(uri);
    105.         try {
    106.             response = client.execute(httpGet);
    107.             HttpEntity entity = response.getEntity();
    108.             return EntityUtils.toString(entity);
    109.         } finally {
    110.             release(client, response);
    111.         }
    112.     }
    114.     public static final String invokeHttpGet(URI uri, Map<String, String> params)
    115.         throws URISyntaxException, ClientProtocolException, IOException {
    116.         URIBuilder builder = new URIBuilder()
    117.             .setScheme(uri.getScheme())
    118.             .setHost(uri.getHost())
    119.             .setPort(uri.getPort())
    120.             .setPath(uri.getPath());
    121.         for (Map.Entry<String, String> entry : params.entrySet()) {
    122.             builder.setParameter(entry.getKey(), entry.getValue());
    123.         }
    124.         CloseableHttpClient client = HttpClients.createDefault();
    125.         CloseableHttpResponse response = null;
    126.         HttpGet httpGet = new HttpGet(builder.build());
    127.         try {
    128.             response = client.execute(httpGet);
    129.             HttpEntity entity = response.getEntity();
    130.             return EntityUtils.toString(entity);
    131.         } finally {
    132.             release(client, response);
    133.         }
    134.     }
    136.     public static final String invokeHttpGet(String scheme, String host, int port, String path, Map<String, String> params)
    137.         throws URISyntaxException, ClientProtocolException, IOException {
    138.         URIBuilder builder = new URIBuilder()
    139.             .setScheme(scheme)
    140.             .setHost(host)
    141.             .setPort(port)
    142.             .setPath(path);
    143.         for (Map.Entry<String, String> entry : params.entrySet()) {
    144.             builder.setParameter(entry.getKey(), entry.getValue());
    145.         }
    146.         URI uri = builder.build();
    147.         return invokeHttpGet(uri);
    148.     }
    150.     public static final String invokeHttpPost(String uri, Map<String, String> params)
    151.         throws ClientProtocolException, IOException {
    152.         CloseableHttpClient client = HttpClients.createDefault();
    153.         CloseableHttpResponse response = null;
    154.         HttpPost httpPost = new HttpPost(uri);
    155.         httpPost.setEntity(generatePostEntity(params));
    156.         try {
    157.             response = client.execute(httpPost);
    158.             HttpEntity httpEntity = response.getEntity();
    159.             return EntityUtils.toString(httpEntity);
    160.         } finally {
    161.             release(client, response);
    162.         }
    163.     }
    165.     public static final String invokeHttpPost(URI uri, Map<String, String> params)
    166.         throws ClientProtocolException, IOException {
    167.         CloseableHttpClient client = HttpClients.createDefault();
    168.         CloseableHttpResponse response = null;
    169.         HttpPost httpPost = new HttpPost(uri);
    170.         httpPost.setEntity(generatePostEntity(params));
    171.         try {
    172.             response = client.execute(httpPost);
    173.             HttpEntity httpEntity = response.getEntity();
    174.             return EntityUtils.toString(httpEntity);
    175.         } finally {
    176.             release(client, response);
    177.         }
    178.     }
    180.     public static final String invokeHttpPost(String scheme, String host, int port, String path, Map<String, String> params)
    181.         throws URISyntaxException, ClientProtocolException, IOException {
    182.         URIBuilder builder = new URIBuilder()
    183.             .setScheme(scheme)
    184.             .setHost(host)
    185.             .setPort(port)
    186.             .setPath(path);
    187.         URI uri = builder.build();
    188.         return invokeHttpPost(uri, params);
    189.     }
    191.     private static UrlEncodedFormEntity generatePostEntity(Map<String, String> params) {
    192.         List<NameValuePair> pairs = new ArrayList<>();
    193.         for (Map.Entry<String, String> entry : params.entrySet()) {
    194.             pairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
    195.         }
    196.         return new UrlEncodedFormEntity(pairs, Consts.UTF_8);
    197.     }
    199.     private static void release(CloseableHttpClient client, CloseableHttpResponse response)
    200.         throws IOException {
    201.         if (client != null) {
    202.             client.close();
    203.         }
    204.         if (response != null) {
    205.             response.close();
    206.         }
    207.     }
    209. }
    复制代码
    [/code]

    java, Servlet

    相关帖子
    回复

    使用道具 举报

    返回列表 发新帖
    高级模式
    B Color Image Link Quote Code Smilies
    您需要登录后才可以回帖 登录 | 立即注册

    本版积分规则

    QQ|手机版|Java学习者论坛 ( 声明：本站资料整理自互联网，用于Java学习者交流学习使用，对资料版权不负任何法律责任，若有侵权请及时联系客服屏蔽删除 )

    GMT+8, 2025-2-24 07:23 , Processed in 0.383744 second(s), 36 queries .

    Powered by Discuz! X3.4

    © 2001-2017 Comsenz Inc.

    快速回复 返回顶部 返回列表