HttpClient 调用第三方接口-短信网关

 根据接口的请求规范生成签名、组装请求信息，利用httpClient调用请求，调用第三方接口一般都是如此。

	<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    
   	  <!-- log4j日志文件管理包版本 -->
    <slf4j.version>1.8.0-beta2</slf4j.version>
    <log4j.version>1.2.17</log4j.version>
  </properties>	
<!-- log start -->
	<dependency>
		<groupId>log4j</groupId>
		<artifactId>log4j</artifactId>
		<version>${log4j.version}</version>
	</dependency>
	<dependency>
		<groupId>org.slf4j</groupId>
		<artifactId>slf4j-api</artifactId>
		<version>${slf4j.version}</version>
	</dependency>
	<dependency>
		<groupId>org.slf4j</groupId>
		<artifactId>slf4j-log4j12</artifactId>
		<version>${slf4j.version}</version>
	</dependency>
		<!-- log end -->

import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.jws.WebService;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;



public class SmsSenderEventImpl  {
	
    private static final Log logger = LogFactory.getLog(SmsSenderEventImpl.class);
    
    private final static String url;
    private final static String name;
    private final static String password;
    static{

       url = "http://127.0.0.1:9091/smsTest";//发送短信地址	
       name="name";//账号    
       password = "password";//密码
    }
				
	public void sendSms(String[] phones, String content) throws SmsException {
		String phonesStr = "";
		String returnCode = "";//返回结果		
		String returnIdent="";//身份验证返回结果
		try { 
			if(phones.length>30000){
				throw new SmsException("请少于30000个号码");
			}			
			if(content.length()>478) {
				throw new SmsException("信息长度请小于478");
			}
			phonesStr = getPhoneStr(phones);
			if(StringUtils.isBlank(phonesStr)){
	    		throw new SmsException("号码不能为空");
	    	}					
			//发送短信		
			returnIdent = this.send(phonesStr,content);	
			logger .info("sendSms HttpClient 返回信息="+returnIdent);
			//请求信息组装出现异常
			if(StringUtils.isBlank(returnIdent)) {
				throw new SmsException("北京空间畅想短信网关请求信息组装失败");
			}
			if("-999".equals(returnIdent)){
				throw new SmsException("短信网关无法建立链接");
			}
			String status =getStatus(returnIdent);
			//发送成功 或返回信息解析失败
			if("999".equals(status)){	
				return;
			}else if("wrongText".equals(status)) {
				throw new SmsException("身份验证返回信息格式错误");
			}else if("wrongResult".equals(status)){
				throw new SmsException("身份验证返回值解析错误");
			}
			//发送失败，根据错误返回码查找失败原因
			returnCode = this.getResultByCode(status);
			throw new SmsException("发送失败："+returnCode);
		}  catch (SmsException e) {
			throw e;
		} catch (Exception e) {
			logger.error("err=3,发送失败。phones="+phonesStr, e);
			throw new SmsException("err=3,发送失败。phones="+phonesStr, e);
		}

	}		
	
	/**
	 * 组装、发送接口
	 * @param name用户名
	 * @param phones手机号用,隔开
	 * @param msg信息
	 * @return
	 */
	private String send(String phones, String msg) {
		String sendresult = "";
		try{
			String seed =getStringDate();
			String key = this.getKey(seed);
			StringBuilder str = new StringBuilder();
			str.append("name=").append(name);
			str.append("&seed=").append(seed);
			str.append("&key=").append(key);
			str.append("&dest=").append(phones);
			str.append("&content=").append(key).append(msg);
			sendresult = post(str.toString());
		}catch(Exception e){
			logger.error("",e);
		}				
        return sendresult;
	}
	
	/**
	  * 获取现在时间
	  * @return返回字符串格式 yyyyMMddHHmmss
	  */
	
	private String getStringDate() {
	  Date currentTime = new Date();
	  //当前时间， 格式： yyyyMMddHHmmss， 例如： 20180919141404
	  SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMddHHmmss");
	  String dateString = formatter.format(currentTime);
	  return dateString;
	}
	
	
	/**
	 * 获取key 签名
	 * @param seed
	 * @return
	 * @throws Exception 
	 */
	private String getKey( String seed) throws Exception {
		return getMD5(getMD5(password)+seed);
	}
	
	/**
	 * httppost
	 * @param postStr
	 * @return
	 */
	@SuppressWarnings({ "deprecation", "resource" })
	public static String post(String postStr) {
		System.out.println("postStr"+postStr);
		//调用短信网关请求失败，无法建立连接
		String result = "-999";
		int i=1;
		try {
			HttpPost post = new HttpPost(url);
			StringEntity postEntity = new StringEntity(postStr,"UTF-8");
			postEntity.setContentType("application/x-www-form-urlencoded");  
			post.setEntity(postEntity);  
		    HttpClient client = null;
		    HttpResponse httpResponse =null;
		    while(i<=5) {
		    	client = new DefaultHttpClient();
		    	httpResponse = client.execute(post);
		    	int statusCode = httpResponse.getStatusLine().getStatusCode();
		    	System.out.println("HttpClient第"+i+"次发送请求,返回状态码statusCode="+statusCode);
		    	if( statusCode== HttpStatus.SC_OK) {
		    		result = EntityUtils.toString(httpResponse.getEntity(), HTTP.UTF_8);
					System.out.println("result:"+result);
					return result;
		    	}
		    	i++;
		    }
		} catch(Exception ex) {
			logger.error("",ex);
//			ex.printStackTrace();
		}
		return result;
	}
		
	
	/**
	 * 根据返回信息获得网关接口的code值
	 * @param returnIdent
	 * @return
	 */
	private String getStatus(String returnIdent){
		String result="";
		try{	
			String[] returnArr = returnIdent.split(":");
			if("success".equals(returnArr[0])) {
				//成功的返回码999，自己设置的
				result ="999";
			}else if("error".equals(returnArr[0])){
				//返回错误码
				result = returnArr[1];
			}else {
				result="wrongText";//返回信息格式错误
			}
		}catch(Exception e){
			logger.error("",e);
			result="wrongResult";//返回值解析错误
		}			           
		return result;
	}
	
	/**
	 * 根据code解析错误原因
	 * @param code
	 * @return
	 */
	private String getResultByCode(String code){
		
		if("104".equals(code)){
			return  "缺少手机号参数";
		}else if("105".equals(code)){
			return  "缺少短信内容参数";
		}else if("109".equals(code)){
			return  "短信内容不能超过50字符长度";
		}else if("201".equals(code)){
			return  "没有对应的网关账户";
		}else if("202".equals(code)){
			return  "网关账户已暂停";
		}else if("203".equals(code)){
			return  "网关账户已删除";
		}else if("301".equals(code)){
			return  "没有对应的短信网关";
		}else if("302".equals(code)){
			return  "短信网关已暂停";
		}else if("303".equals(code)){
			return  "短信网关已删除";
		}else if("304".equals(code)){
			return  "短信网关不在服务时间";
		}else if("401".equals(code)){
			return  "短信内容有屏蔽词";
		}
		else {
			return "其他错误，错误码为："+code;
		}
	}

	/**
	 * 将String[]转成String多个用 ,隔开
	 * @param phones
	 * @return
	 */
	private String getPhoneStr(String[] phones) {
		String phonesStr = "";
		for (int i=0;i<phones.length;i++) {
			phonesStr += phones[i] + ",";
		}
		if(phonesStr.endsWith(",")){
			phonesStr = phonesStr.substring(0, phonesStr.length()-1);
		} 
		return phonesStr;
	}		
		
	/**
	 * MD5 32位小写加密方法
	 * @param str
	 * @return
	 * @throws Exception 
	 */
	private String getMD5(String str) throws Exception   {
		MessageDigest md5 = null;
		md5 = MessageDigest.getInstance("MD5");
		md5.update((str).getBytes("UTF-8")); 
		byte b[] = md5.digest();  
		  
		int i;  
		StringBuffer buf = new StringBuffer("");  
		  
		for(int offset=0; offset<b.length; offset++){  
		    i = b[offset];  
		    if(i<0){  
		        i+=256;  
		    }  
		    if(i<16){  
		        buf.append("0");  
		    }  
		    buf.append(Integer.toHexString(i));  
		}  
		  
		String result = buf.toString().toLowerCase();
		return result;
		
	}

 

public class SmsException extends RuntimeException {

    /**	
     * Member Description
     */

    private static final long serialVersionUID = 1L;

    /**
     * 无参构造函数
     */
    public SmsException() {
    }

    /**
     * 构造函数，封装Throwable类型异常
     * @param t 可抛的异常
     */
    public SmsException(Throwable t) {
        super(t);
    }

    /**
     * 构造函数，带有提示信息
     * @param message 提示信息
     */
    public SmsException(String message) {
        super(message);
    }

    /**
     * 构造函数，封装Throwable类型异常，带有提示信息
     * @param message 提示信息
     * @param t 可抛的异常
     */
    public SmsException(String message, Throwable t) {
        super(message, t);
    }
}