使用了httpclient做代理请求。
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import jef.database.Condition.Operator;
import jef.database.QB;
import jef.database.query.Query;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIUtils;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import com.ailk.easyframe.web.common.exception.BusinessException;
import com.ailk.so.redo.MessageCode;
import com.ailk.so.redo.constants.Constants;
import com.ailk.so.redo.persistence.paramconf.entity.SoRedoParam;
import com.ailk.so.redo.service.paramconf.SoRedoParamService;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
@Transactional
public class AjaxProxyServiceImpl extends AjaxProxyServiceSkeleton implements AjaxProxyService{
private Log log = LogFactory.getLog(AjaxProxyServiceImpl.class);
@Autowired
protected SoRedoParamService paramconf_soRedoParamService;
public void setParamconf_soRedoParamService(SoRedoParamService obj){
this.paramconf_soRedoParamService = obj;
}
public Map<String, Object> doRequest(Map<String,String> requestParams) {
Map<String, String> dbParamMap = getDBParamMap(requestParams);
/** 得到url参数*/
String requestUrl = dbParamMap.get(requestParams.get(Constants.REQUEST_URL_KEY));
if(requestUrl == null) {
BusinessException ex = new BusinessException(MessageCode.E1013);
log.error(ex.getFormattedMessage());
throw ex;
}
log.info("requestUrl:" + requestUrl);
/** 建立一个NameValuePair数组，用于存储欲传送的参数*/
List<NameValuePair> qparams = new ArrayList<NameValuePair>();
HttpClient hc = new DefaultHttpClient();
/** 给数组加入参数*/
if(requestParams != null && !requestParams.isEmpty()) {
Set<Entry<String, String>> pSet = requestParams.entrySet();
for(Entry<String, String> entry : pSet) {
String key = entry.getKey();
String value = entry.getValue();
if(log.isDebugEnabled()) {
log.debug("request param " + key + ":" + value);
}
if(Constants.REQUEST_URL_KEY.equals(key)) {
continue;
}
//优先查询参数表，如果请求的code在参数表有配置，则用参数表的配置，否则直接使用页面传过来的值
if(Constants.REQUEST_CODE_KEY.equals(key)) {
String codeValue = dbParamMap.get(value);
if(codeValue == null || codeValue.trim().length() == 0) {
log.info("can not found job code in db by key:" + key);
codeValue = value;
}
qparams.add(new BasicNameValuePair(key, codeValue));
continue;
}
qparams.add(new BasicNameValuePair(key, value));
}
}
HttpResponse response;
try {
/** 创建url对象并设置编码等属性*/
URL url = new URL(requestUrl);
URI uri = URIUtils.createURI(url.getProtocol(), url.getHost(),
url.getPort(), url.getPath(),
URLEncodedUtils.format(qparams, "UTF-8"), null);
/** 创建一个get请求对象*/
HttpGet httpget = new HttpGet(uri);
/** 发送get请求,并返回一个HttpResponse对象*/
response = hc.execute(httpget);
HttpEntity entity = response.getEntity();
StringBuffer responseTxtSb = new StringBuffer();
/** 将返回值得到并放入stringBuffer中*/
if (entity != null) {
InputStream instream = entity.getContent();
int len;
byte[] tmp = new byte[2048];
while ((len = instream.read(tmp)) != -1) {
if(len < 2048) {
byte[] last = new byte[len];
System.arraycopy(tmp, 0, last, 0, len);
responseTxtSb.append(new String(last));
} else {
responseTxtSb.append(new String(tmp));
}
}
String responseTxt = responseTxtSb.toString();
log.info("ajax proxy response:" + responseTxt);
/** 解析返回值字符串*/
if(responseTxt.length() != 0) {
Type type = new TypeToken<ProxyResponse>() {}.getType();
ProxyResponse result = new Gson().fromJson(responseTxt, type);
String urlKey = requestParams.get(Constants.REQUEST_URL_KEY);
if(!urlKey.equals("check_status_url")) {
if(!result.getSuccess()) {
throw new BusinessException(-1, result.getMessage());
}
} else {
if(!result.getSuccess()) {
log.error("check job status error.");
return null;
}
}
Object data = result.getData();
Integer tatal = result.getTotal();
Map<String, Object> resultMap = new HashMap<String, Object>();
if(data != null) {
resultMap.put("data", data);
}
if(tatal != null) {
resultMap.put("tatal", tatal);
}
if(!resultMap.isEmpty()) {
return resultMap;
}
return null;
}
}
} catch (ClientProtocolException ce) {
log.error(ce.getMessage());
ce.printStackTrace();
throw new BusinessException(-1, ce.getMessage());
} catch (IOException ie) {
log.error(ie.getMessage());
ie.printStackTrace();
throw new BusinessException(-1, ie.getMessage());
} catch (URISyntaxException ue) {
log.error(ue.getMessage());
ue.printStackTrace();
throw new BusinessException(-1, ue.getMessage());
}
return null;
}
private Map<String, String> getDBParamMap(Map<String,String> requestParams) {
String urlKey = requestParams.get(Constants.REQUEST_URL_KEY);
String code = requestParams.get(Constants.REQUEST_CODE_KEY);
if(urlKey == null || urlKey.trim().length() == 0) {
throw new BusinessException(MessageCode.E1012);
}
List<SoRedoParam> paramList = getParamList(Constants.AJAX_PROXY_PARAM_TYPE, urlKey,code);
Map<String, String> paramMap = new HashMap<String, String>();
for(SoRedoParam param : paramList) {
log.info("ajax request info:" + param.getParamName() + "=" + param.getParamValue());
paramMap.put(param.getParamName(), param.getParamValue());
}
return paramMap;
}
private List<SoRedoParam> getParamList(String paramType, String... paramNames) {
Query<SoRedoParam> paramQuery = QB.create(SoRedoParam.class);
paramQuery.addCondition(SoRedoParam.Field.paramType, paramType);
if(paramNames == null) {
log.error("param name is null");
return null;
}
paramQuery.addCondition(SoRedoParam.Field.paramName, Operator.IN, paramNames);
List<SoRedoParam> paramList = paramconf_soRedoParamService.find(paramQuery.getInstance());
if(paramList == null || paramList.size() == 0) {
String errMsg = "not found param value by param name:" +paramNames;
log.error(errMsg);
throw new BusinessException(MessageCode.E1000, errMsg);
}
return paramList;
}
class ProxyResponse {
/**成功标记*/
private Boolean success;
/**错误对象 */
private String message;
/**待传输数据*/
private Object data;
/**数据总数 当返回结果为数组时*/
private Integer total;
public Boolean getSuccess() {
return success;
}
public void setSuccess(Boolean success) {
this.success = success;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public Integer getTotal() {
return total;
}
public void setTotal(Integer total) {
this.total = total;
}
};
}