Ⅰ 使用java 测试网络连通性的几种方法
概述在网络编程中，有时我们需要判断两台机器之间的连通性，或者说是一台机器到另一台机器的网络可达性。在系统层面的测试中，我们常常用 Ping 命令来做验证。尽管 Java 提供了比较丰富的网络编程类库（包括在应用层的基于 URL 的网络资源读取，基于 TCP/IP 层的 Socket 编程，以及一些辅助的类库），但是没有直接提供类似 Ping 命令来测试网络连通性的方法。本文将介绍如何通过 Java 已有的 API，编程实现各种场景下两台机器之间的网络可达性判断。在下面的章节中，我们会使用 Java 网络编程的一些类库 java.net.InetAddress 和 java.net.Socket，通过例子解释如何模拟 Ping 命令。回页首简单判断两台机器的可达性一般情况下，我们仅仅需要判断从一台机器是否可以访问（Ping）到另一台机器，此时，可以简单的使用 Java 类库中 java.net.InetAddress 类来实现，这个类提供了两个方法探测远程机器是否可达 �0�2boolean isReachable(int�0�2timeout) //�0�2测试地址是否可达�0�2boolean isReachable(NetworkInterface�0�2netif, int�0�2ttl, int�0�2timeout) //�0�2测试地址是否可达. 简单说来，上述方法就是通过远端机器的 IP 地址构造 InetAddress 对象，然后调用其 isReachable 方法，测试调用机器和远端机器的网络可达性。注意到远端机器可能有多个 IP 地址，因而可能要迭代的测试所有的情况。清单1：简单判断两台机器的可达性 void isAddressAvailable(String ip){ try{ InetAddress address = InetAddress.getByName(ip);//ping this IP if(address instanceof java.net.Inet4Address){ System.out.println(ip + " is ipv4 address"); }else if(address instanceof java.net.Inet6Address){ System.out.println(ip + " is ipv6 address"); }else{ System.out.println(ip + " is unrecongized"); } if(address.isReachable(5000)){ System.out.println("SUCCESS - ping " + IP + " with no interface specified"); }else{ System.out.println("FAILURE - ping " + IP + " with no interface specified"); } System.out.println("
-------Trying different interfaces--------
"); Enumeration<NetworkInterface> netInterfaces = NetworkInterface.getNetworkInterfaces(); while(netInterfaces.hasMoreElements()) { NetworkInterface ni = netInterfaces.nextElement(); System.out.println( "Checking interface, DisplayName:" + ni.getDisplayName() + ", Name:" + ni.getName()); if(address.isReachable(ni, 0, 5000)){ System.out.println("SUCCESS - ping " + ip); }else{ System.out.println("FAILURE - ping " + ip); } Enumeration<InetAddress> ips = ni.getInetAddresses(); while(ips.hasMoreElements()) { System.out.println("IP: " + ips.nextElement().getHostAddress()); } System.out.println("-------------------------------------------"); } }catch(Exception e){ System.out.println("error occurs."); e.printStackTrace(); } } 程序输出 --------------START-------------- 10.13.20.70 is ipv4 address SUCCESS - ping 10.13.20.70 with no interface specified -------Trying different interfaces-------- Checking interface, DisplayName:MS TCP Loopback interface, Name:lo FAILURE - ping 10.13.20.70 IP: 127.0.0.1 ------------------------------------------- Checking interface, DisplayName:Intel(R) Centrino(R) Advanced-N 6200 AGN - Teefer2 Miniport, Name:eth0 FAILURE - ping 10.13.20.70 IP: 9.123.231.40 ------------------------------------------- Checking interface, DisplayName:Intel(R) 82577LM Gigabit Network Connection - Teefer2 Miniport, Name:eth1 SUCCESS - ping 10.13.20.70 ------------------------------------------- Checking interface, DisplayName:WAN (PPP/SLIP) Interface, Name:ppp0 SUCCESS - ping 10.13.20.70 IP: 10.0.50.189 ------------------------------------------- --------------END-------------- 从上可以看出 isReachable 的用法，可以不指定任何接口来判断远端网络的可达性，但这不能区分出数据包是从那个网络接口发出去的 ( 如果本地有多个网络接口的话 )；而高级版本的 isReachable 则可以指定从本地的哪个网络接口测试，这样可以准确的知道远端网络可以连通本地的哪个网络接口。但是，Java 本身没有提供任何方法来判断本地的哪个 IP 地址可以连通远端网络，Java 网络编程接口也没有提供方法来访问 ICMP 协议数据包，因而通过 ICMP 的网络不可达数据包实现这一点也是不可能的 ( 当然可以用 JNI 来实现，但就和系统平台相关了 ), 此时可以考虑本文下一节提出的方法。回页首指定本地和远程网络地址，判断两台机器之间的可达性在某些情况下，我们可能要确定本地的哪个网络地址可以连通远程网络，以便远程网络可以回连到本地使用某些服务或发出某些通知。一个典型的应用场景是，本地启动了文件传输服务 ( 如 FTP)，需要将本地的某个 IP 地址发送到远端机器，以便远端机器可以通过该地址下载文件；或者远端机器提供某些服务，在某些事件发生时通知注册了获取这些事件的机器 ( 常见于系统管理领域 )，因而在注册时需要提供本地的某个可达 ( 从远端 ) 地址。虽然我们可以用 InetAddress.isReachabl 方法判断出本地的哪个网络接口可连通远程玩过，但是由于单个网络接口是可以配置多个 IP 地址的，因而在此并不合适。我们可以使用 Socket 建立可能的 TCP 连接，进而判断某个本地 IP 地址是否可达远程网络。我们使用 java.net.Socket 类中的 connect 方法 void connect(SocketAddress�0�2endpoint, int�0�2timeout) �0�2//使用Socket连接服务器，指定超时的时间 这种方法需要远程的某个端口，该端口可以是任何基于 TCP 协议的开放服务的端口（如一般都会开放的 ECHO 服务端口 7, Linux 的 SSH 服务端口 22 等）。实际上，建立的 TCP 连接被协议栈放置在连接队列，进而分发到真正处理数据的各个应用服务，由于 UDP 没有连接的过程，因而基于 UDP 的服务（如 SNMP）无法在此方法中应用。具体过程是，枚举本地的每个网络地址，建立本地 Socket，在某个端口上尝试连接远程地址，如果可以连接上，则说明该本地地址可达远程网络。程序清单 2：指定本地地址和远程地址，判断两台机器之间的可达性 void printReachableIP(InetAddress remoteAddr, int port){ String retIP = null; Enumeration<NetworkInterface> netInterfaces; try{ netInterfaces = NetworkInterface.getNetworkInterfaces(); while(netInterfaces.hasMoreElements()) { NetworkInterface ni = netInterfaces.nextElement(); Enumeration<InetAddress> localAddrs = ni.getInetAddresses(); while(localAddrs.hasMoreElements()){ InetAddress localAddr = localAddrs.nextElement(); if(isReachable(localAddr, remoteAddr, port, 5000)){ retIP = localAddr.getHostAddress(); break; } } } } catch(SocketException e) { System.out.println( "Error occurred while listing all the local network addresses."); } if(retIP == null){ System.out.println("NULL reachable local IP is found!"); }else{ System.out.println("Reachable local IP is found, it is " + retIP); } } boolean isReachable(InetAddress localInetAddr, InetAddress remoteInetAddr, int port, int timeout) { booleanisReachable = false; Socket socket = null; try{ socket = newSocket(); // 端口号设置为 0 表示在本地挑选一个可用端口进行连接 SocketAddress localSocketAddr = new InetSocketAddress(localInetAddr, 0); socket.bind(localSocketAddr); InetSocketAddress endpointSocketAddr = new InetSocketAddress(remoteInetAddr, port); socket.connect(endpointSocketAddr, timeout); System.out.println("SUCCESS - connection established! Local: " + localInetAddr.getHostAddress() + " remote: " + remoteInetAddr.getHostAddress() + " port" + port); isReachable = true; } catch(IOException e) { System.out.println("FAILRE - CAN not connect! Local: " + localInetAddr.getHostAddress() + " remote: " + remoteInetAddr.getHostAddress() + " port" + port); } finally{ if(socket != null) { try{ socket.close(); } catch(IOException e) { System.out.println("Error occurred while closing socket.."); } } } return isReachable; } 运行结果 --------------START-------------- FAILRE - CAN not connect! Local: 127.0.0.1 remote: 10.8.1.50 port22 FAILRE - CAN not connect! Local: 9.123.231.40 remote: 10.8.1.50 port22 SUCCESS - connection established! Local: 10.0.50.189 remote: 10.8.1.50 port22 Reachable local IP is found, it is 10.0.50.189 --------------END-------------- 回页首IPv4 和 IPv6 混合网络下编程当网络环境中存在 IPv4 和 IPv6，即机器既有 IPv4 地址，又有 IPv6 地址的时候，我们可以对程序进行一些优化，比如 由于IPv4 和 IPv6 地址之间是无法互相访问的，因此仅需要判断 IPv4 地址之间和 IPv6 地址之间的可达性。 对于IPv4 的换回地址可以不做判断，对于 IPv6 的 Linklocal 地址也可以跳过测试 根据实际的需要，我们可以优先考虑选择使用 IPv4 或者 IPv6，提高判断的效率程序清单 3: 判断本地地址和远程地址是否同为 IPv4 或者 IPv6 // 判断是 IPv4 还是 IPv6 if(!((localInetAddr instanceofInet4Address) && (remoteInetAddr instanceofInet4Address) || (localInetAddr instanceofInet6Address) && (remoteInetAddr instanceofInet6Address))){ // 本地和远程不是同时是 IPv4 或者 IPv6，跳过这种情况，不作检测 break; } 程序清单 4：跳过本地地址和 LinkLocal 地址 if( localAddr.isLoopbackAddress() || localAddr.isAnyLocalAddress() || localAddr.isLinkLocalAddress() ){ // 地址为本地环回地址，跳过 break; } 回页首总结和展望本文列举集中典型的场景，介绍了通过 Java 网络编程接口判断机器之间可达性的几种方式。在实际应用中，可以根据不同的需要选择相应的方法稍加修改即可。对于更加特殊的需求，还可以考虑通过 JNI 的方法直接调用系统 API 来实现，能提供更加强大和灵活的功能，这里就不再赘述了。参考资料 学习 参考developerWorks 的文章 Java 应用程序的网络运行环境编程，获取更多网络编程相关的信息。
如果要通过 JNI 进行网络编程，可以参考 developerWorks 上的文章 用JNI 进行 Java 编程，了解更多 JNI 相关的信息和例子。
参考Javadoc 获取更多关于 Java 网络编程的 API 的信息。
developerWorks Java 技术专区：这里有数百篇关于 Java 编程各个方面的文章。
讨论加入developerWorks 中文社区。查看开发人员推动的博客、论坛、组和维基，并与其他 developerWorks 用户交流。
作者简介吴校军，IBM CSTL 软件工程师，长期从事 IBM 系统管理相关软件的开发，目前负责 Director6.1 Update Manager 的开发。刘冠群现为 IBM 上海系统科技开发中心(CSTL)的软件工程师，有多年的 Java 和 C++ 编程经验，对于操作系统，网络和编程语言的内部实现有强烈兴趣。关闭[x]关于报告滥用的帮助报告滥用谢谢! 此内容已经标识给管理员注意。关闭[x]关于报告滥用的帮助报告滥用报告滥用提交失败。 请稍后重试。关闭[x]developerWorks：登录IBM ID：需要一个 IBM ID？忘记IBM ID？密码：忘记密码？更改您的密码 保持登录。单击提交则表示您同意developerWorks 的条款和条件。 使用条款 当您初次登录到 developerWorks 时，将会为您创建一份概要信息。您在developerWorks 概要信息中选择公开的信息将公开显示给其他人，但您可以随时修改这些信息的显示状态。您的姓名（除非选择隐藏）和昵称将和您在 developerWorks 发布的内容一同显示。所有提交的信息确保安全。关闭[x]请选择您的昵称：当您初次登录到 developerWorks 时，将会为您创建一份概要信息，您需要指定一个昵称。您的昵称将和您在 developerWorks 发布的内容显示在一起。昵称长度在 3 至 31 个字符之间。 您的昵称在 developerWorks 社区中必须是唯一的，并且出于隐私保护的原因，不能是您的电子邮件地址。昵称：（长度在 3 至 31 个字符之间）单击提交则表示您同意developerWorks 的条款和条件。 使用条款. 所有提交的信息确保安全。
Ⅱ java如何实现使用HTTP POST 的方式调用webservice
packagecom.weixin.util;
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.io.StringWriter;
importjava.io.UnsupportedEncodingException;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.Map;
importorg.apache.http.Header;
importorg.apache.http.HttpHost;
importorg.apache.http.HttpResponse;
importorg.apache.http.HttpStatus;
importorg.apache.http.HttpVersion;
importorg.apache.http.ParseException;
importorg.apache.http.client.ClientProtocolException;
importorg.apache.http.client.HttpClient;
importorg.apache.http.client.entity.UrlEncodedFormEntity;
importorg.apache.http.client.methods.HttpGet;
importorg.apache.http.client.methods.HttpPost;
importorg.apache.http.client.params.CookiePolicy;
importorg.apache.http.client.params.HttpClientParams;
importorg.apache.http.conn.params.ConnRoutePNames;
importorg.apache.http.impl.client.DefaultHttpClient;
importorg.apache.http.message.BasicNameValuePair;
importorg.apache.http.params.BasicHttpParams;
importorg.apache.http.params.HttpConnectionParams;
importorg.apache.http.params.HttpParams;
importorg.apache.http.params.HttpProtocolParams;
importorg.apache.http.protocol.HTTP;
//importbsh.ParseException;
importcom.google.gson.Gson;
/**
*TODO
*@Version1.0
*/
publicclassHttpClients{
/**UTF-8*/
privatestaticfinalStringUTF_8="UTF-8";
/**日志记录tag*/
privatestaticfinalStringTAG="HttpClients";
/**用户host*/
privatestaticStringproxyHost="";
/**用户端口*/
privatestaticintproxyPort=80;
/**是否使用用户端口*/
privatestaticbooleanuseProxy=false;
/**连接超时*/
privatestaticfinalintTIMEOUT_CONNECTION=60000;
/**读取超时*/
privatestaticfinalintTIMEOUT_SOCKET=60000;
/**重试3次*/
privatestaticfinalintRETRY_TIME=3;
/**
*@paramurl
*@paramrequestData
*@return
*/
publicStringdoHtmlPost(HttpClienthttpClient,HttpPosthttpPost)
{
StringresponseBody=null;
intstatusCode=-1;
try{
HttpResponsehttpResponse=httpClient.execute(httpPost);
HeaderlastHeader=httpResponse.getLastHeader("Set-Cookie");
if(null!=lastHeader)
{
httpPost.setHeader("cookie",lastHeader.getValue());
}
statusCode=httpResponse.getStatusLine().getStatusCode();
if(statusCode!=HttpStatus.SC_OK){
System.out.println("HTTP"+""+"HttpMethodfailed:"+httpResponse.getStatusLine());
}
InputStreamis=httpResponse.getEntity().getContent();
responseBody=getStreamAsString(is,HTTP.UTF_8);
}catch(Exceptione){
//发生网络异常
e.printStackTrace();
}finally{
// httpClient.getConnectionManager().shutdown();
// httpClient=null;
}
returnresponseBody;
}
/**
*
*发起网络请求
*
*@paramurl
*URL
*@paramrequestData
*requestData
*@returnINPUTSTREAM
*@throwsAppException
*/
publicstaticStringdoPost(Stringurl,StringrequestData)throwsException{
StringresponseBody=null;
HttpPosthttpPost=null;
HttpClienthttpClient=null;
intstatusCode=-1;
inttime=0;
do{
try{
httpPost=newHttpPost(url);
httpClient=getHttpClient();
//设置HTTPPOST请求参数必须用NameValuePair对象
List<BasicNameValuePair>params=newArrayList<BasicNameValuePair>();
params.add(newBasicNameValuePair("param",requestData));
UrlEncodedFormEntityentity=newUrlEncodedFormEntity(params,HTTP.UTF_8);
//设置HTTPPOST请求参数
httpPost.setEntity(entity);
HttpResponsehttpResponse=httpClient.execute(httpPost);
statusCode=httpResponse.getStatusLine().getStatusCode();
if(statusCode!=HttpStatus.SC_OK){
System.out.println("HTTP"+""+"HttpMethodfailed:"+httpResponse.getStatusLine());
}
InputStreamis=httpResponse.getEntity().getContent();
responseBody=getStreamAsString(is,HTTP.UTF_8);
break;
}catch(UnsupportedEncodingExceptione){
time++;
if(time<RETRY_TIME){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione1){
}
continue;
}
//发生致命的异常，可能是协议不对或者返回的内容有问题
e.printStackTrace();
}catch(ClientProtocolExceptione){
time++;
if(time<RETRY_TIME){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione1){
}
continue;
}
//发生致命的异常，可能是协议不对或者返回的内容有问题
e.printStackTrace();
}catch(IOExceptione){
time++;
if(time<RETRY_TIME){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione1){
}
continue;
}
//发生网络异常
e.printStackTrace();
}catch(Exceptione){
time++;
if(time<RETRY_TIME){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione1){
}
continue;
}
//发生网络异常
e.printStackTrace();
}finally{
httpClient.getConnectionManager().shutdown();
httpClient=null;
}
}while(time<RETRY_TIME);
returnresponseBody;
}
/**
*
*将InputStream转化为String
*
*@paramstream
*inputstream
*@paramcharset
*字符集
*@return
*@throwsIOException
*/
(InputStreamstream,Stringcharset)throwsIOException{
try{
BufferedReaderreader=newBufferedReader(newInputStreamReader(stream,charset),8192);
StringWriterwriter=newStringWriter();
char[]chars=newchar[8192];
intcount=0;
while((count=reader.read(chars))>0){
writer.write(chars,0,count);
}
returnwriter.toString();
}finally{
if(stream!=null){
stream.close();
}
}
}
/**
*得到httpClient
*
*@return
*/
(){
finalHttpParamshttpParams=newBasicHttpParams();
if(useProxy){
HttpHostproxy=newHttpHost(proxyHost,proxyPort,"http");
httpParams.setParameter(ConnRoutePNames.DEFAULT_PROXY,proxy);
}
HttpConnectionParams.setConnectionTimeout(httpParams,TIMEOUT_CONNECTION);
HttpConnectionParams.setSoTimeout(httpParams,TIMEOUT_SOCKET);
HttpClientParams.setRedirecting(httpParams,true);
finalStringuserAgent="Mozilla/5.0(Windows;U;WindowsNT6.1;zh-CN;rv:1.9.2.14)Gecko/20110218Firefox/3.6.14";
HttpProtocolParams.setUserAgent(httpParams,userAgent);
HttpProtocolParams.setVersion(httpParams,HttpVersion.HTTP_1_1);
HttpClientParams.setCookiePolicy(httpParams,CookiePolicy.RFC_2109);
HttpProtocolParams.setUseExpectContinue(httpParams,false);
HttpClientclient=newDefaultHttpClient(httpParams);
returnclient;
}
/**
*
*得到httpClient
*
*@return
*/
(){
finalHttpParamshttpParams=newBasicHttpParams();
if(useProxy){
HttpHostproxy=newHttpHost(proxyHost,proxyPort,"http");
httpParams.setParameter(ConnRoutePNames.DEFAULT_PROXY,proxy);
}
HttpConnectionParams.setConnectionTimeout(httpParams,TIMEOUT_CONNECTION);
HttpConnectionParams.setSoTimeout(httpParams,TIMEOUT_SOCKET);
HttpClientParams.setRedirecting(httpParams,true);
finalStringuserAgent="Mozilla/5.0(Windows;U;WindowsNT6.1;zh-CN;rv:1.9.2.14)Gecko/20110218Firefox/3.6.14";
HttpProtocolParams.setUserAgent(httpParams,userAgent);
HttpProtocolParams.setVersion(httpParams,HttpVersion.HTTP_1_1);
HttpClientParams.setCookiePolicy(httpParams,CookiePolicy.BROWSER_COMPATIBILITY);
HttpProtocolParams.setUseExpectContinue(httpParams,false);
HttpClientclient=newDefaultHttpClient(httpParams);
returnclient;
}
/**
*打印返回内容
*@paramresponse
*@throwsParseException
*@throwsIOException
*/
publicstaticvoidshowResponse(Stringstr)throwsException{
Gsongson=newGson();
Map<String,Object>map=(Map<String,Object>)gson.fromJson(str,Object.class);
Stringvalue=(String)map.get("data");
//StringdecodeValue=Des3Request.decode(value);
//System.out.println(decodeValue);
//logger.debug(decodeValue);
}
/**
*
*发起网络请求
*
*@paramurl
*URL
*@paramrequestData
*requestData
*@returnINPUTSTREAM
*@throwsAppException
*/
publicstaticStringdoGet(Stringurl)throwsException{
StringresponseBody=null;
HttpGethttpGet=null;
HttpClienthttpClient=null;
intstatusCode=-1;
inttime=0;
do{
try{
httpGet=newHttpGet(url);
httpClient=getHttpClient();
HttpResponsehttpResponse=httpClient.execute(httpGet);
statusCode=httpResponse.getStatusLine().getStatusCode();
if(statusCode!=HttpStatus.SC_OK){
System.out.println("HTTP"+""+"HttpMethodfailed:"+httpResponse.getStatusLine());
}
InputStreamis=httpResponse.getEntity().getContent();
responseBody=getStreamAsString(is,HTTP.UTF_8);
break;
}catch(UnsupportedEncodingExceptione){
time++;
if(time<RETRY_TIME){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione1){
}
continue;
}
//发生致命的异常，可能是协议不对或者返回的内容有问题
e.printStackTrace();
}catch(ClientProtocolExceptione){
time++;
if(time<RETRY_TIME){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione1){
}
continue;
}
//发生致命的异常，可能是协议不对或者返回的内容有问题
e.printStackTrace();
}catch(IOExceptione){
time++;
if(time<RETRY_TIME){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione1){
}
continue;
}
//发生网络异常
e.printStackTrace();
}catch(Exceptione){
time++;
if(time<RETRY_TIME){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione1){
}
continue;
}
//发生网络异常
e.printStackTrace();
}finally{
httpClient.getConnectionManager().shutdown();
httpClient=null;
}
}while(time<RETRY_TIME);
returnresponseBody;
}
}
Ⅲ java中try到某个异常catch中如何重新运行异常的该行代码
把trycatch 放在循环里面，在catch部分重新运行就好了。
Ⅳ java问题，项目运行时，for循环会有3中状态1.成功 2.失败 3.可重试
你好 首先这段代码运行的结果是1 2 4 3 2 4 3 2 8。从运行结果可以看出这段程序执行for循环执行了两次（因为输出两次4）。
要理解for循环的本质：首先执行test（‘1’）方法输出1，
再判断test('2')&&(x<=2)为真所以输出2,4，这时第一次进入循环。注意这时x的值是2.结束第一次循环后，执行test（‘3’），所以输出3。
这时又要判断test('2')&&(x<=2)是否为真，因为为真所以执行循环，所以输出：2,4，这时又要去执行test（‘3’），所以输出3。执行之后再判断test('2')&&(x<=2)是否为真，因为此时x的值为3，不满足判断条件（但是test（‘2’）执行了）所以输出2，退出循环输出count的值为8（因为之前调用test（char num）方法8次），所以输出8。因此最终结果为1 2 4 3 2 4 3 2 8。其实这个for循环语句和for（int i=0；i<2;i++）本质一样，好好想想这个for循环的执行过程就明白了。
希望我的回答对你有帮助，谢谢~
Ⅳ java如何实现发送短信验证码功能
1、创建一个Http的模拟请求工具类，然后写一个POST方法或者GET方法
/** * 文件说明 * @Description:扩展说明 * @Copyright: XXXX dreamtech.com.cn Inc. All right reserved * @Version: V6.0 */package com.demo.util; import java.io.IOException;import java.util.Map; import org.apache.commons.httpclient.HttpClient;import org.apache.commons.httpclient.HttpException;import org.apache.commons.httpclient.SimpleHttpConnectionManager;import org.apache.commons.httpclient.methods.GetMethod;import org.apache.commons.httpclient.methods.PostMethod; /** * @Author: feizi * @Date: XXXX年XX月XX日 XX:XX:XX * @ModifyUser: feizi * @ModifyDate: XXXX年XX月XX日 XX:XX:XX * @Version:V6.0 */public class HttpRequestUtil { /** * HttpClient 模拟POST请求 * 方法说明 * @Discription:扩展说明 * @param url * @param params * @return String * @Author: feizi * @Date: XXXX年XX月XX日 XX:XX:XX * @ModifyUser：feizi * @ModifyDate: XXXX年XX月XX日 XX:XX:XX */ public static String postRequest(String url, Map<String, String> params) { //构造HttpClient的实例 HttpClient httpClient = new HttpClient(); //创建POST方法的实例 PostMethod postMethod = new PostMethod(url); //设置请求头信息 postMethod.setRequestHeader("Connection", "close"); //添加参数 for (Map.Entry<String, String> entry : params.entrySet()) { postMethod.addParameter(entry.getKey(), entry.getValue()); } //使用系统提供的默认的恢复策略,设置请求重试处理，用的是默认的重试处理：请求三次 httpClient.getParams().setBooleanParameter("http.protocol.expect-continue", false); //接收处理结果 String result = null; try { //执行Http Post请求 httpClient.executeMethod(postMethod); //返回处理结果 result = postMethod.getResponseBodyAsString(); } catch (HttpException e) { // 发生致命的异常，可能是协议不对或者返回的内容有问题 System.out.println("请检查输入的URL!"); e.printStackTrace(); } catch (IOException e) { // 发生网络异常 System.out.println("发生网络异常!"); e.printStackTrace(); } finally { //释放链接 postMethod.releaseConnection(); //关闭HttpClient实例 if (httpClient != null) { ((SimpleHttpConnectionManager) httpClient.getHttpConnectionManager()).shutdown(); httpClient = null; } } return result; } /** * HttpClient 模拟GET请求 * 方法说明 * @Discription:扩展说明 * @param url * @param params * @return String * @Author: feizi * @Date: XXXX年XX月XX日 XX:XX:XX * @ModifyUser：feizi * @ModifyDate: XXXX年XX月XX日 XX:XX:XX */ public static String getRequest(String url, Map<String, String> params) { //构造HttpClient实例 HttpClient client = new HttpClient(); //拼接参数 String paramStr = ""; for (String key : params.keySet()) { paramStr = paramStr + "&" + key + "=" + params.get(key); } paramStr = paramStr.substring(1); //创建GET方法的实例 GetMethod method = new GetMethod(url + "?" + paramStr); //接收返回结果 String result = null; try { //执行HTTP GET方法请求 client.executeMethod(method); //返回处理结果 result = method.getResponseBodyAsString(); } catch (HttpException e) { // 发生致命的异常，可能是协议不对或者返回的内容有问题 System.out.println("请检查输入的URL!"); e.printStackTrace(); } catch (IOException e) { // 发生网络异常 System.out.println("发生网络异常!"); e.printStackTrace(); } finally { //释放链接 method.releaseConnection(); //关闭HttpClient实例 if (client != null) { ((SimpleHttpConnectionManager) client.getHttpConnectionManager()).shutdown(); client = null; } } return result; }}
2、在创建一个类，生成验证码，然后传递相应的参数（不同的短信平台接口会有不同的参数要求，这个一般短信平台提供的接口文档中都会有的，直接看文档然后按要求来即可）
/** * 文件说明 * @Description:扩展说明 * @Copyright: XXXX dreamtech.com.cn Inc. All right reserved * @Version: V6.0 */package com.demo.util; import java.net.URLEncoder;import java.util.HashMap;import java.util.Map; /** * @Author: feizi * @Date: XXXX年XX月XX日 XX:XX:XX * @ModifyUser: feizi * @ModifyDate: XXXX年XX月XX日 XX:XX:XX * @Version:V6.0 */public class SendMsgUtil { /** * 发送短信消息 * 方法说明 * @Discription:扩展说明 * @param phones * @param content * @return * @return String * @Author: feizi * @Date: 2015年4月17日 下午7:18:08 * @ModifyUser：feizi * @ModifyDate: 2015年4月17日 下午7:18:08 */ @SuppressWarnings("deprecation") public static String sendMsg(String phones,String content){ //短信接口URL提交地址 String url = "短信接口URL提交地址"; Map<String, String> params = new HashMap<String, String>(); params.put("zh", "用户账号"); params.put("mm", "用户密码"); params.put("dxlbid", "短信类别编号"); params.put("extno", "扩展编号"); //手机号码，多个号码使用英文逗号进行分割 params.put("hm", phones); //将短信内容进行URLEncoder编码 params.put("nr", URLEncoder.encode(content)); return HttpRequestUtil.getRequest(url, params); } /** * 随机生成6位随机验证码 * 方法说明 * @Discription:扩展说明 * @return * @return String * @Author: feizi * @Date: 2015年4月17日 下午7:19:02 * @ModifyUser：feizi * @ModifyDate: 2015年4月17日 下午7:19:02 */ public static String createRandomVcode(){ //验证码 String vcode = ""; for (int i = 0; i < 6; i++) { vcode = vcode + (int)(Math.random() * 9); } return vcode; } /** * 测试 * 方法说明 * @Discription:扩展说明 * @param args * @return void * @Author: feizi * @Date: XXXX年XX月XX日 XX:XX:XX * @ModifyUser：feizi * @ModifyDate: XXXX年XX月XX日 XX:XX:XX */ public static void main(String[] args) {// System.out.println(SendMsgUtil.createRandomVcode());// System.out.println("&ecb=12".substring(1)); System.out.println(sendMsg("18123456789,15123456789", "尊敬的用户，您的验证码为" + SendMsgUtil.createRandomVcode() + "，有效期为60秒，如有疑虑请详询XXX-XXX-XXXX【XXX中心】")); }
然后执行一下，一般的情况下参数传递正确，按照接口文档的规范来操作的话，都会发送成功的，手机都能收到验证码的，然后可能会出现的问题就是：发送的短信内容有可能会出现中文乱码，然后就会发送不成功，按照短信平台的要求进行相应的编码即可。一般都会是UTF-8编码。
Ⅵ java客户端调用webservice时 连接超时知道是网络原因 ，如何重试如果不重试程序就死琐了，
先把连接超时的时间设置长一点！
抛异常处理时，空处理异常，继续调用连接方法，不过，服务器一般都有连接超时的时间的，超过时间连接不上，就会自动中断客户端的请求。释放资源！
Ⅶ 手机解锁手势和密码怎么用java实现的
"若手机屏幕锁屏密码忘记，建议您参考以下内容：
1.若设置的是图案/签名解锁方式，可使用绘制解锁图案/签名时设置的PIN码进行解锁。操作：
1).输入五次不正确的解锁图案，屏幕上会显示“请在30秒后重试“的提示信息，点击“确定“。点击屏幕右下角的“备份PIN“（忘记密码），输入之前设置好的PIN密码，点击确定即可。
2).如果是签名解锁方式，输入五次不正确的签名后，屏幕会出现输入PIN码的提示，输入之前设置好的PIN密码，点击确定即可。
提示：解锁时提示的PIN码，是您在设置图案锁定等时设置的备份密码。
若无效、备份PIN密码忘记或不符合上述要求，请您将机器送到就近的服务中心，由售后工程师帮助您进行安全解锁。 "
Ⅷ elasticsearch中,如何与java中TransportClient在断开后自动重连
不建议使用TransportClient，因为es官方自己都放弃了。建议使用java自身的http客户端，使用rest api进行操作即可。不存在断开重连，只存在api失败重试。
Ⅸ java怎么实现redis分布式锁
Redis有一系列的命令，特点是以NX结尾，NX是Not eXists的缩写，如SETNX命令就应该理解为：SET if Not eXists。这系列的命令非常有用，这里讲使用SETNX来实现分布式锁。
用SETNX实现分布式锁
利用SETNX非常简单地实现分布式锁。例如：某客户端要获得一个名字foo的锁，客户端使用下面的命令进行获取：
SETNX lock.foo <current Unix time + lock timeout + 1>
如返回1，则该客户端获得锁，把lock.foo的键值设置为时间值表示该键已被锁定，该客户端最后可以通过DEL lock.foo来释放该锁。
如返回0，表明该锁已被其他客户端取得，这时我们可以先返回或进行重试等对方完成或等待锁超时。
解决死锁
上面的锁定逻辑有一个问题：如果一个持有锁的客户端失败或崩溃了不能释放锁，该怎么解决？我们可以通过锁的键对应的时间戳来判断这种情况是否发生了，如果当前的时间已经大于lock.foo的值，说明该锁已失效，可以被重新使用。
发生这种情况时，可不能简单的通过DEL来删除锁，然后再SETNX一次，当多个客户端检测到锁超时后都会尝试去释放它，这里就可能出现一个竞态条件,让我们模拟一下这个场景：
C0操作超时了，但它还持有着锁，C1和C2读取lock.foo检查时间戳，先后发现超时了。
C1 发送DEL lock.foo
C1 发送SETNX lock.foo 并且成功了。
C2 发送DEL lock.foo
C2 发送SETNX lock.foo 并且成功了。
这样一来，C1，C2都拿到了锁！问题大了！
幸好这种问题是可以避免D，让我们来看看C3这个客户端是怎样做的：
C3发送SETNX lock.foo 想要获得锁，由于C0还持有锁，所以Redis返回给C3一个0
C3发送GET lock.foo 以检查锁是否超时了，如果没超时，则等待或重试。
反之，如果已超时，C3通过下面的操作来尝试获得锁：
GETSET lock.foo <current Unix time + lock timeout + 1>
通过GETSET，C3拿到的时间戳如果仍然是超时的，那就说明，C3如愿以偿拿到锁了。
如果在C3之前，有个叫C4的客户端比C3快一步执行了上面的操作，那么C3拿到的时间戳是个未超时的值，这时，C3没有如期获得锁，需要再次等待或重试。留意一下，尽管C3没拿到锁，但它改写了C4设置的锁的超时值，不过这一点非常微小的误差带来的影响可以忽略不计。
注意：为了让分布式锁的算法更稳键些，持有锁的客户端在解锁之前应该再检查一次自己的锁是否已经超时，再去做DEL操作，因为可能客户端因为某个耗时的操作而挂起，操作完的时候锁因为超时已经被别人获得，这时就不必解锁了。
示例伪代码
根据上面的代码，我写了一小段Fake代码来描述使用分布式锁的全过程：
# get lock
lock = 0
while lock != 1:
timestamp = current Unix time + lock timeout + 1
lock = SETNX lock.foo timestamp
if lock == 1 or (now() > (GET lock.foo) and now() > (GETSET lock.foo timestamp)):
break;
else:
sleep(10ms)
# do your job
do_job()
# release
if now() < GET lock.foo:
DEL lock.foo
是的，要想这段逻辑可以重用，使用python的你马上就想到了Decorator，而用Java的你是不是也想到了那谁？AOP + annotation？行，怎样舒服怎样用吧，别重复代码就行。
Ⅹ java怎么实现同步非阻塞
1.非阻塞算法
非阻塞算法属于并发算法，它们可以安全地派生它们的线程，不通过锁定派生，而是通过低级的原子性的硬件原生形式 —— 例如比较和交换。非阻塞算法的设计与实现极为困难，但是它们能够提供更好的吞吐率，对生存问题（例如死锁和优先级反转）也能提供更好的防御。使用底层的原子化机器指令取代锁,比如比较并交换(CAS,compare-and-swap).
2.悲观技术
独占锁是一种悲观的技术.它假设最坏的情况发生(如果不加锁,其它线程会破坏对象状态),即使没有发生最坏的情况,仍然用锁保护对象状态.
3.乐观技术
依赖冲突监测.先更新,如果监测发生冲突发生,则放弃更新后重试,否则更新成功.现在处理器都有原子化的读-改-写指令,比如比较并交换(CAS,compare-and-swap).
4.CAS操作
CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。CAS典型使用模式是：首先从V中读取A，并根据A计算新值B，然后再通过CAS以原子方式将V中的值由A变成B（只要在这期间没有任何线程将V的值修改为其他值）。
清单 3. 说明比较并交换的行为（而不是性能）的代码
public class SimulatedCAS {
private int value;
public synchronized int getValue() { return value; }
public synchronized int compareAndSwap(int expectedValue, int newValue) {
int oldValue = value;
if (value == expectedValue)
value = newValue;
return oldValue;
}
}
清单 4. 使用比较并交换实现计数器
public class CasCounter {
private SimulatedCAS value;
public int getValue() {
return value.getValue();
}
public int increment() {
int oldValue = value.getValue();
while (value.compareAndSwap(oldValue, oldValue + 1) != oldValue)
oldValue = value.getValue();
return oldValue + 1;
}
}
5.原子变量
原子变量支持不用锁保护就能原子性更新操作，其底层用CAS实现。共有12个原子变量，可分为4组：标量类、更新器类、数组类以及复合变量类。最常用的原子变量就是标量类：AtomicInteger、AtomicLong、AtomicBoolean以及AtomicReference。所有类型都支持CAS。
6.性能比较：锁与原子变量
在中低程度的竞争下，原子变量能提供很高的可伸缩性，原子变量性能超过锁；而在高强度的竞争下，锁能够更有效地避免竞争，锁的性能将超过原子变量的性能。但在更真实的实际情况中，原子变量的性能将超过锁的性能。