1 package com.hanqi;
2
3 import java.io.File;
4 import java.io.FileWriter;
5 import java.io.IOException;
6 import java.text.ParseException;
7 import java.text.SimpleDateFormat;
8 import java.util.ArrayList;
9 import java.util.Date;
10 import java.util.HashMap;
11 import java.util.List;
12 import java.util.Map;
13 import java.util.Set;
14 import java.util.regex.Matcher;
15 import java.util.regex.Pattern;
16
17 import org.json.JSONArray;
18 import org.json.JSONException;
19 import org.json.JSONObject;
20 import org.jsoup.Jsoup;
21 import org.jsoup.nodes.Document;
22 import org.jsoup.nodes.Element;
23
24 import com.alibaba.fastjson.JSON;
25 import com.hanqi.util.Attachment;
26 import com.hanqi.util.Common;
27 import com.hanqi.util.HttpCompoentsUtil;
28 import com.hanqi.util.Mail;
29
30 public class Mail163 {
31
32 private HttpCompoentsUtil httpUtil = new HttpCompoentsUtil();
33 private String sid;
34
35 //最新发送时间
36 private Date lastSendDate;
37 //已抓取邮件的mid集合
38 private Set<String> setMid;
39 //最近的采集邮件的mid
40 private String lastMid;
41
42 public Mail163() {
43 }
44 public static void main(String[] args) {
45 Mail163 lession = new Mail163();
46 lession.login("邮箱用户名", "密码");
47 lession.mailBox();
48 }
49 public Mail163(String lastMid) {
50 this.lastMid = lastMid;
51 }
52
53 public Mail163(Date lastSendDate) {
54 this.lastSendDate = lastSendDate;
55 }
56
57 public Mail163(Set<String> setMid) {
58 this.setMid = setMid;
59 }
60
61
62
63
64
65
66 // 获取邮件详细
67 public void mailDetail(Mail m)
68 {
69
70 String content = mailContent(m.getId());
71
72 //如果有附件，则进入执行
73 if (m.isAttached())
74 {
75 Map<String, String> params = new HashMap<String, String>();
76 params.put("var", "<?xml version=\"1.0\"?>"
77 + "<object><string name=\"id\">" + m.getId() + "</string>"
78 + "<boolean name=\"header\">true</boolean>"
79 + "<boolean name=\"returnImageInfo\">true</boolean>"
80 + "<boolean name=\"returnAntispamInfo\">true</boolean>"
81 + "<boolean name=\"autoName\">true</boolean>"
82 + "<object name=\"returnHeaders\">"
83 + "<string name=\"Resent-From\">A</string>"
84 + "<string name=\"Sender\">A</string>"
85 + "<string name=\"List-Unsubscribe\">A</string>"
86 + "<string name=\"Reply-To\">A</string></object>"
87 + "<boolean name=\"supportTNEF\">true</boolean></object>");
88
89 Map<String, String> headers = new HashMap<String, String>();
90 headers.put("Accept", "text/javascript");// 以JSON方式返回数据
91 String result = httpUtil.post(Common.MailDetailURL + sid, params, headers);
92
93 result = result.replaceAll("new Date\\(.*?\\)", "null");
94
95 try {
96 //从json提取相应的信息
97 JSONArray ja = new JSONObject(result)
98 .getJSONObject("var")
99 .getJSONArray("attachments");
100
101 List<Attachment> la = new ArrayList<>();
102
103 for (int i = 0; i < ja.length(); i++)
104 {
105 JSONObject jo = ja.getJSONObject(i);
106
107 Attachment am = new Attachment(jo.getString("id"), m.getId());
108 am.setContentLength(jo.getInt("contentLength"));
109 am.setFileName(jo.getString("filename"));
110 am.setContentType(jo.getString("contentType"));
111
112 // 下载附件
113 mailAttachment(m, am);
114
115 la.add(am);
116 }
117
118 m.setAttachments(la);
119
120 } catch (JSONException e) {
121
122 e.printStackTrace();
123 }
124 }
125
126 m.setContent(content);
127 }
128
129
130
131
132
133 // 获取邮件内容
134 public String mailContent(String mid) {
135 Map<String, String> params = new HashMap<String, String>();
136 String result = httpUtil.post(Common.MailContentURL + mid, params);
137
138
139 Document doc = Jsoup.parseBodyFragment(result);
140
141 Element el = doc.select("div").first();
142
143 String str = "";
144
145 if (el != null) {
146 str = el.text();
147 }
148
149 return str;
150 }
151
152
153 //存储附件
154 public void mailAttachment(Mail mail, Attachment att) {
155 Map<String, String> params = new HashMap<String, String>();
156
157 try {
158 String strFilePath = Common.DataFilePath;
159
160
161 String fileName = getFileName(mail);
162
163 String attPath = strFilePath + fileName + "_attachment/";
164
165 File file = new File(attPath);
166 //路径是否存在
167 if (!file.exists())
168 {
169 file.mkdirs();
170 }
171
172 file = new File(attPath, att.getId() + "_" + att.getFileName());
173 //文件是否存在
174 if (!file.exists())
175 {
176 file.createNewFile();
177 }
178
179 att.setSavefilePath(attPath);
180 att.setSaveFileName(file.getName());
181
182 httpUtil.postStream(Common.MailAttach
183 .replace("$part$", att.getId())
184 .replace("$sid$", sid)
185 .replace("$mid$", mail.getId()), params, file);
186
187 // 生成MD5
188 att.setMd5(Common.getMd5(file));
189
190 } catch (Exception ex) {
191 ex.printStackTrace();
192 }
193 }
194
195
196
197
198
199
200 public void mailBox()
201 {
202 Map<String, String> params = new HashMap<String, String>();
203 params.put("var", "<?xml version=\"1.0\"?>" + "<object><int name=\"fid\">1</int>"
204 + "<boolean name=\"skipLockedFolders\">false</boolean>" + "<string name=\"order\">date</string>"
205 + "<boolean name=\"desc\">true</boolean>" + "<int name=\"start\">0</int><int name=\"limit\">150</int>"
206 + "<boolean name=\"topFirst\">true</boolean>" + "<boolean name=\"returnTotal\">true</boolean>"
207 + "<boolean name=\"returnTag\">true</boolean></object>");
208
209 Map<String, String> headers = new HashMap<String, String>();
210 headers.put("Accept", "text/javascript");
211 String result = httpUtil.post(Common.MailBoxURL + sid, params, headers);
212
213 // 匹配发送时间的格式
214 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
215 Pattern p=Pattern.compile("‘sentDate‘:new Date\\(.*?\\)");
216 //共匹配到的数据
217 Matcher ma=p.matcher(result);
218 List<Date> sentDate = new ArrayList<>();
219
220 while(ma.find())
221 {
222 //得到所有内容
223 String group = ma.group();
224 //得到时间
225 group = group.replace("‘sentDate‘:new Date(", "").replace(")", "");
226 String[] date = group.split(",");
227
228 try
229 {
230 //生成正确的时间格式
231 sentDate.add(sdf.parse(date[0] + "-" +
232 date[1] + "-" + date[2] + " " +
233 date[3] + ":" + date[4] + ":" + date[5]));
234 }
235 catch (ParseException e)
236 {
237 e.printStackTrace();
238 }
239 }
240
241
242
243 // 匹配接收时间
244 p=Pattern.compile("‘receivedDate‘:new Date\\(.*?\\)");
245 ma=p.matcher(result);
246
247 List<Date> receivedDate = new ArrayList<>();
248
249 while(ma.find())
250 {
251 String group = ma.group();
252 group = group.replace("‘receivedDate‘:new Date(", "").replace(")", "");
253 String[] date = group.split(",");
254
255 try
256 {
257 receivedDate.add(sdf.parse(date[0] + "-" +
258 date[1] + "-" + date[2] + " " +
259 date[3] + ":" + date[4] + ":" + date[5]));
260 }
261 catch (ParseException e)
262 {
263 e.printStackTrace();
264 }
265 }
266 //去除不正确格式的数据
267 String resultJSON = result.replaceAll("new Date\\(.*?\\)", "null");
268
269
270 // 解析收件箱列表
271 List<Mail> lm = new ArrayList<Mail>();
272 try
273 {
274
275 JSONArray ja = new JSONObject(resultJSON).getJSONArray("var");
276
277 for (int i = 0; i < ja.length(); i++)
278 {
279 JSONObject jo = ja.getJSONObject(i);
280
281 Mail m = new Mail(jo.getString("id"));
282 m.setFrom(jo.getString("from"));
283 m.setTo(jo.getString("to"));
284 m.setSubject(jo.getString("subject"));
285
286 JSONObject flags = jo.getJSONObject("flags");
287 //判断是否有附件
288 if (flags.has("attached"))
289 {
290 m.setAttached(flags.getBoolean("attached"));
291 }
292
293 m.setSentDate(sentDate.get(i));
294 m.setReceivedDate(receivedDate.get(i));
295
296 lm.add(m);
297 }
298 }
299
300 catch (Exception e)
301 {
302 e.printStackTrace();
303 }
304
305 String lmid = lastMid;
306
307 // 遍历收件箱所有邮件的集合
308 for (int n = 0; n < lm.size(); n++)
309 {
310 Mail m = lm.get(n);
311
312 if (n == 0)
313 {
314 lmid = m.getId();
315 }
316
317 // 是否读取邮件内容
318 boolean isRead = false;
319
320 // 根据最近的mid
321 if (lastMid != null)
322 {
323 if (!m.getId().equals(lastMid))
324 {
325 isRead = true;
326 }
327 else
328 {
329 break;// 结束遍历
330 }
331 }
332
333 // 根据最新发送的时间
334 else
335 if (lastSendDate != null)
336 {
337 Date sendDate = m.getSentDate();
338
339 if (sendDate.compareTo(lastSendDate) > 0)
340 {
341 isRead = true;
342 }
343 else
344 {
345 break;
346 }
347 }
348
349
350 // 根据mid判断
351 else if (setMid != null)
352 {
353 String mid = m.getId();
354
355 if (!setMid.contains(mid))
356 {
357 isRead = true;
358 }
359 else
360 {
361 break;
362 }
363 }
364 else
365 {
366 isRead = true;
367 }
368
369 if (isRead)
370 {
371 //邮件详细信息
372 mailDetail(m);
373 System.out.println("抓取：" + m);
374 //最后进行保存
375 saveMail(m);
376 }
377 }
378
379 // 保存最近邮件的发送时间和保存最近邮件的mid
380 String midFilePath = Common.MidFilePath;
381
382 try
383 {
384
385 File midPath = new File(midFilePath);
386
387 if (!midPath.exists())
388 {
389 midPath.mkdirs();
390 }
391
392 File midFile = new File(midFilePath, Common.MidFileName);
393
394 if (!midFile.exists())
395 {
396 midFile.createNewFile();
397 }
398
399 FileWriter fw = new FileWriter(midFile);
400 fw.write(lmid);
401 fw.close();
402 }
403
404 catch (Exception e)
405 {
406 e.printStackTrace();
407 }
408 }
409
410
411
412
413
414
415 private String getFileName(Mail mail)
416 {
417 String rtn = "";
418 SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd_HHmmss");
419 String mid = mail.getId();
420 rtn = sdf.format(mail.getSentDate())
421 + "_" + mid.substring(mid.length() - 8);
422
423 return rtn;
424 }
425
426
427
428
429
430 private void saveMail(Mail mail) {
431 // 保存邮件到文件
432 // 流，文件名是时间戳
433 // 选择合适的格式，方便读取
434 String json = JSON.toJSONString(mail);
435
436
437 try {
438
439 String strFilePath = Common.DataFilePath;
440
441
442
443 File mailPath = new File(strFilePath);
444
445 if (!mailPath.exists()) {
446 mailPath.mkdirs();
447 }
448
449 File file = new File(strFilePath, getFileName(mail));
450
451 if (!file.exists()) {
452 file.createNewFile();
453 }
454
455 FileWriter fw = new FileWriter(file);
456
457 fw.write(json);
458
459 fw.close();
460
461 } catch (IOException e) {
462 // TODO 自动生成的 catch 块
463 e.printStackTrace();
464 }
465 }
466
467
468
469
470
471 public void login(String username, String password) {
472 Map<String, String> params = new HashMap<String, String>();
473 params.put("ds", "mail163_letter");
474 params.put("from", "web");
475 params.put("funcid", "loginone");
476 params.put("iframe", "1");
477 params.put("language", "-1");
478 params.put("passtype", "1");
479 params.put("product", "mail163");
480 params.put("net", "c");
481 params.put("stype", "-1");
482 params.put("race", "167_158_146_gz");
483 params.put("uid", "[email protected]");
484 params.put("savelogin", "0");
485 params.put("url2", "http://mail.163.com/errorpage/error163.htm");
486 params.put("username", username);
487 params.put("password", password);
488
489 String s = httpUtil.post(Common.LoginURL, params).trim();
490
491 int i = s.indexOf("http://");
492 String mainUrl = s.substring(i, s.indexOf("\";</script>"));
493 httpUtil.get(mainUrl);
494 sid = httpUtil.getCookie("Coremail.sid");
495
496 }
497 }
1 package com.hanqi_1;
2 import java.io.IOException;
3 import java.io.InterruptedIOException;
4 import java.net.UnknownHostException;
5 import java.security.cert.CertificateException;
6 import java.security.cert.X509Certificate;
7 import java.util.ArrayList;
8 import java.util.List;
9 import java.util.Map;
10
11 import javax.net.ssl.SSLContext;
12 import javax.net.ssl.SSLException;
13
14 import org.apache.http.HttpEntity;
15 import org.apache.http.HttpEntityEnclosingRequest;
16 import org.apache.http.HttpRequest;
17 import org.apache.http.HttpResponse;
18 import org.apache.http.NameValuePair;
19 import org.apache.http.client.HttpRequestRetryHandler;
20 import org.apache.http.client.config.CookieSpecs;
21 import org.apache.http.client.config.RequestConfig;
22 import org.apache.http.client.entity.UrlEncodedFormEntity;
23 import org.apache.http.client.methods.CloseableHttpResponse;
24 import org.apache.http.client.methods.HttpGet;
25 import org.apache.http.client.methods.HttpPost;
26 import org.apache.http.client.protocol.HttpClientContext;
27 import org.apache.http.config.RegistryBuilder;
28 import org.apache.http.conn.ConnectTimeoutException;
29 import org.apache.http.conn.ConnectionKeepAliveStrategy;
30 import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
31 import org.apache.http.conn.ssl.SSLContextBuilder;
32 import org.apache.http.conn.ssl.TrustStrategy;
33 import org.apache.http.cookie.Cookie;
34 import org.apache.http.cookie.CookieOrigin;
35 import org.apache.http.cookie.CookieSpec;
36 import org.apache.http.cookie.CookieSpecProvider;
37 import org.apache.http.cookie.MalformedCookieException;
38 import org.apache.http.impl.client.BasicCookieStore;
39 import org.apache.http.impl.client.CloseableHttpClient;
40 import org.apache.http.impl.client.DefaultConnectionKeepAliveStrategy;
41 import org.apache.http.impl.client.HttpClients;
42 import org.apache.http.impl.cookie.BestMatchSpecFactory;
43 import org.apache.http.impl.cookie.BrowserCompatSpec;
44 import org.apache.http.impl.cookie.BrowserCompatSpecFactory;
45 import org.apache.http.message.BasicNameValuePair;
46 import org.apache.http.protocol.HttpContext;
47 import org.apache.http.util.EntityUtils;
48
49 /**
50 * @author bangis
51 *
52 */
53 public class HttpCompoentsUtil {
54 private final String _DEFLAUT_CHARSET = "utf-8";
55 private CloseableHttpClient httpClient;
56
57 /**
58 * 设置超时，毫秒级别
59 */
60 private RequestConfig requestConfig = RequestConfig.custom()
61 .setSocketTimeout(1000).setConnectTimeout(1000).build();
62 private BasicCookieStore cookieStore = new BasicCookieStore();
63 {
64 try {
65 // 保持连接时长
66 ConnectionKeepAliveStrategy keepAliveStrat = new DefaultConnectionKeepAliveStrategy() {
67
68 @Override
69 public long getKeepAliveDuration(HttpResponse response,
70 HttpContext context) {
71 long keepAlive = super.getKeepAliveDuration(response,
72 context);
73 if (keepAlive == -1) {
74 // 如果服务器没有设置keep-alive这个参数，我们就把它设置成5秒
75 keepAlive = 5000;
76 }
77 return keepAlive;
78 }
79
80 };
81 // 重试机制
82 HttpRequestRetryHandler retryHandler = new HttpRequestRetryHandler() {
83 public boolean retryRequest(IOException exception,
84 int executionCount, HttpContext context) {
85 if (executionCount >= 5) {
86 // 如果已经重试了5次，就放弃
87 return false;
88 }
89 if (exception instanceof InterruptedIOException) {
90 // 超时
91 return false;
92 }
93 if (exception instanceof UnknownHostException) {
94 // 目标服务器不可达
95 return false;
96 }
97 if (exception instanceof ConnectTimeoutException) {
98 // 连接被拒绝
99 return false;
100 }
101 if (exception instanceof SSLException) {
102 // ssl握手异常
103 return false;
104 }
105 HttpClientContext clientContext = HttpClientContext
106 .adapt(context);
107 HttpRequest request = clientContext.getRequest();
108 boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
109 if (idempotent) {
110 // 如果请求是幂等的，就再次尝试
111 return true;
112 }
113 return false;
114 }
115
116 };
117 CookieSpecProvider easySpecProvider = new CookieSpecProvider() {
118
119 public CookieSpec create(HttpContext context) {
120
121 return new BrowserCompatSpec() {
122 @Override
123 public void validate(Cookie cookie, CookieOrigin origin)
124 throws MalformedCookieException {
125 // Oh, I am easy
126 }
127 };
128 }
129
130 };
131 SSLContext sslContext;
132 sslContext = new SSLContextBuilder().loadTrustMaterial(null,
133 new TrustStrategy() {
134 // 信任所有
135 public boolean isTrusted(X509Certificate[] chain,
136 String authType) throws CertificateException {
137 return true;
138 }
139 }).build();
140 SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
141 sslContext);
142
143 RegistryBuilder
144 .<CookieSpecProvider> create()
145 .register(CookieSpecs.BEST_MATCH,
146 new BestMatchSpecFactory())
147 .register(CookieSpecs.BROWSER_COMPATIBILITY,
148 new BrowserCompatSpecFactory())
149 .register("easy", easySpecProvider).build();
150
151 RequestConfig globalConfig = RequestConfig.custom()
152 .setCookieSpec("easy").build();
153
154 httpClient = HttpClients.custom()
155 .setKeepAliveStrategy(keepAliveStrat)
156 .setRetryHandler(retryHandler)
157 .setDefaultRequestConfig(globalConfig)
158 .setDefaultCookieStore(cookieStore)
159 // .setSslcontext(sslContext)
160 .build();
161 } catch (Exception e) {
162 e.printStackTrace();
163 }
164 }
165
166 public void setTimeOut(int socketTimeOut, int connectTimeOut) {
167 requestConfig = RequestConfig.custom().setSocketTimeout(socketTimeOut)
168 .setConnectTimeout(connectTimeOut).build();
169 }
170
171 public String get(String url) {
172 return get(url, _DEFLAUT_CHARSET);
173 }
174
175 public String get(String url, String charset) {
176 return get(url, null, charset);
177 }
178
179 public String get(String url, Map<String, String> headers, String charset) {
180 HttpClientContext context = HttpClientContext.create();
181 context.setCookieStore(cookieStore);
182 String useCharset = charset;
183 if (charset == null) {
184 useCharset = _DEFLAUT_CHARSET;
185 }
186 HttpGet httpGet = new HttpGet(url);
187 if (headers != null) {
188 for (String key : headers.keySet()) {
189 httpGet.setHeader(key, headers.get(key));
190 }
191 }
192 httpGet.setConfig(requestConfig);
193 try {
194 CloseableHttpResponse response = httpClient.execute(httpGet,
195 context);
196 try {
197 HttpEntity entity = response.getEntity();
198 return EntityUtils.toString(entity, useCharset);
199 } finally {
200 response.close();
201 }
202 } catch (Exception e) {
203 e.printStackTrace();
204 }
205 return null;
206 }
207
208 public String post(String url, Map<String, String> params) {
209 return post(url, params, null, null);
210 }
211
212 public String post(String url, Map<String, String> params,
213 Map<String, String> headers) {
214 return post(url, params, headers, null);
215 }
216
217 public String post(String url, Map<String, String> params, String charset) {
218 return post(url, params, null, charset);
219 }
220
221 public String post(String url, Map<String, String> params,
222 Map<String, String> headers, String charset) {
223 HttpClientContext context = HttpClientContext.create();
224 context.setCookieStore(cookieStore);
225 String useCharset = charset;
226 if (charset == null) {
227 useCharset = _DEFLAUT_CHARSET;
228 }
229 try {
230 HttpPost httpPost = new HttpPost(url);
231 if (headers != null) {
232 for (String key : headers.keySet()) {
233 httpPost.setHeader(key, headers.get(key));
234 }
235 }
236 List<NameValuePair> nvps = new ArrayList<NameValuePair>();
237 if (params != null) {
238 for (String key : params.keySet()) {
239 nvps.add(new BasicNameValuePair(key, params.get(key)));
240 }
241 httpPost.setEntity(new UrlEncodedFormEntity(nvps));
242 }
243 httpPost.setConfig(requestConfig);
244 CloseableHttpResponse response = httpClient.execute(httpPost,
245 context);
246 try {
247 HttpEntity entity = response.getEntity();
248 return EntityUtils.toString(entity, useCharset);
249 } finally {
250 response.close();
251 }
252 } catch (Exception e) {
253 e.printStackTrace();
254 }
255 return null;
256 }
257
258 public String getCookie(String key) {
259 List<Cookie> cookies = cookieStore.getCookies();
260 if (cookies != null) {
261 for (Cookie c : cookies) {
262 if (c.getName().equals(key)) {
263 return c.getValue();
264 }
265 }
266 }
267 return null;
268 }
269
270 public void printCookies() {
271 System.out.println("---查看当前Cookie---");
272 List<Cookie> cookies = cookieStore.getCookies();
273 if (cookies != null) {
274 for (Cookie c : cookies) {
275 System.out.print(c.getName() + " :" + c.getValue());
276 System.out.print(" domain:" + c.getDomain());
277 System.out.print(" expires:" + c.getExpiryDate());
278 System.out.print(" path:" + c.getPath());
279 System.out.println(" version:" + c.getVersion());
280 }
281 }
282 }
283
284 }
package com.hanqi;
import java.io.File;
import java.io.FileReader;
import org.json.JSONObject;
import com.hanqi.util.Common;
public class MailRun
{
public static void main(String[] args)
{
try
{
while (true)
{
String strFileName = Common.AccountFileName;
String strFilePath = Common.AccountFilePath;
File fa = new File(strFilePath, strFileName);
//如果account.json文件存在，从account.json文件中读出数据
if (fa.exists())
{
FileReader fr = new FileReader(fa);
char[] cbuf = new char[1024];
int i = 0;
String str = "";
if ((i = fr.read(cbuf)) > 0)
{
str += new String(cbuf, 0, i);
}
fr.close();
if (str != null && str.length() > 0)
{
//解析从account.json文件中读出来的json格式的数据
JSONObject jo = new JSONObject(str).getJSONObject("account");
String username = jo.getString("username");
String password = jo.getString("password");
System.out.println("username=" + username + " password=" + password);
// 获取最近的发送时间
// 最近的mid
String lastMid = null;
String midFilePath = Common.MidFilePath;
File midPath = new File(midFilePath);
//判断mid路径是否存在，不存在则创建
if (!midPath.exists())
{
midPath.mkdirs();
}
else
{
File midFile = new File(midFilePath, Common.MidFileName);
//判断mid.txt文件是否存在，不存在则创建
if (!midFile.exists())
{
midFile.createNewFile();
}
else
{
//从mid.txt文件中提取数据
FileReader frmid = new FileReader(midFile);
char[] c = new char[1024];
int m = 0;
lastMid = "";
while ((m = frmid.read(c)) > 0)
{
lastMid += new String(c, 0, m);
}
frmid.close();
}
}
System.out.println("lastMid = " + lastMid);
Mail163 spider = new Mail163(lastMid);
// 登录
spider.login(username, password);
// 得到收件箱
spider.mailBox();
}
}
else
{
System.out.println("account.json文件不存在");
}
System.out.println("休眠中");
Thread.sleep(Common.SleepTime);
}
}
catch (Exception ex)
{
ex.printStackTrace();
}
}
}
时间： 2024-12-22 00:02:14