Socket与Http方式解析发送xml消息封装中间件jar包

  最近项目代码中太多重复的编写Document,不同的接口需要不同的模板,于是重写提取公共部分打成jar包,方便各个系统统一使用~

  提取结构:

  Socket与Http方式解析发送xml消息封装中间件jar包

Http连接方式:

import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.List;
import java.util.Map; import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.client.RestTemplate; public class HttpConnect { final Logger logger = LoggerFactory.getLogger(this.getClass()); public static final String SECCUESS_CODE = "000000"; private RestTemplate restTemplate ; private int connectTimeout = 1000; private int readTimeout = 15000; private static final String CHARSET_GBK = "GBK"; public String getMessages(Map<String,Object> sendData){
restTemplate = createRestTemplate();
HttpHeaders headers = new HttpHeaders();
MediaType type = new MediaType("text", "xml",
Charset.forName(CHARSET_GBK));
headers.setContentType(type);
String connectIp = (String) sendData.get("RequestIp");
String connectPort = (String) sendData.get("RequestPort");
String content = (String) sendData.get("message");
String url = "http://" + connectIp + ":" + connectPort;
HttpEntity<String> entity = new HttpEntity<String>(content, headers);
String result = restTemplate.postForObject(url, entity, String.class);
logger.info("send data:{},result:{}", content, result); return result;
} public RestTemplate createRestTemplate() {
HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
requestFactory.setConnectTimeout(connectTimeout);
requestFactory.setReadTimeout(readTimeout); RestTemplate restTemplate = new RestTemplate(requestFactory);
restTemplate.getMessageConverters().add(0,
new MyStringHttpMessageConverter());
return restTemplate;
} static class MyStringHttpMessageConverter extends
StringHttpMessageConverter { List<Charset> acceptedCharsets = Arrays.asList(Charset.forName("GBK"),
Charset.forName("GB2312"), Charset.forName("GB18030"),
Charset.forName("UTF-8")); @Override
protected List<Charset> getAcceptedCharsets() {
return acceptedCharsets;
}
}
}

Socket方式:

package SocketClient;
 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ConnectException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.net.UnknownHostException;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class SocketClient {
 
final Logger logger = LoggerFactory.getLogger(this.getClass());
 
private Socket socket;
 
public SocketClient() {
 
}
 
public SocketClient(String connectIp, String connectPort,
  String connectTime, String readTime) throws SocketTimeoutException,
  ConnectException, UnknownHostException, Exception {
  createSocket(connectIp, connectPort, connectTime, readTime);
}
 
private void createSocket(String hostName, String port, String connectTime,
String readTime) throws SocketTimeoutException, ConnectException,
  UnknownHostException, Exception {
  InetAddress address = InetAddress.getByName(hostName);
  int timeOut = Integer.parseInt(connectTime);
  int readTimeOut = Integer.parseInt(readTime);
  socket = new Socket();
  int connectPort = Integer.valueOf(port);
  InetSocketAddress socketAddr = new InetSocketAddress(address,
  connectPort);
  // 连接后返回结果超时时间
  socket.setSoTimeout(readTimeOut);
  socket.setReuseAddress(true);
  socket.connect(socketAddr, timeOut);
}
 
public void sendData(byte[] data) throws IOException,RuntimeException{
  DataOutputStream dos = null;
 
try {
  dos = new DataOutputStream(socket.getOutputStream());
  dos.writeInt(data.length);
  dos.write(data);
} catch (IOException e) {
  e.printStackTrace();
} catch (RuntimeException e) {
  e.printStackTrace();
} finally {
  if (dos != null) {
    dos.close();
  }
  }
}
 
public byte[] recvData() throws Exception {
  byte[] data = null;
  DataInputStream dis = null;
 
  try {
    dis = new DataInputStream(socket.getInputStream());
    int dataLen = dis.readInt();
    data = new byte[dataLen];
    dis.readFully(data);
    } catch (IOException e) {
      e.printStackTrace();
    }finally {
      if (dis != null) {
        dis.close();
      }
    }
    return data;
}
 
public void destory()  {
if (this.socket != null && !this.socket.isClosed()) {
  try {
    this.socket.close();
    this.socket = null;
    } catch (IOException e) {
    logger.error("Socket Destory Error",e);
    }
    }
  }
}

加载hdfs中的模板文件,并转化为map形式嵌入项目中,存入内存缓存

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map; import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory; public class LoadHdfsTemplate {
static final Logger logger = LoggerFactory
.getLogger(LoadHdfsTemplate.class); protected FileSystem fileSystem; public final boolean checkFile(String filePath) {
boolean exists = false;
try {
Path path = new Path(filePath);
exists = fileSystem.exists(path);
} catch (IOException e) {
logger.error("模板文件不存在!", e);
} catch (Exception e) {
logger.error("", e);
}
return exists;
} public Map<String,Object> readHdfsFile(String hdfsPath) throws IOException{
Path path = new Path(hdfsPath);
InputStream in = fileSystem.open(path);
List<String> lines = IOUtils.readLines(in);
if(null == lines || lines.isEmpty()){
return null;
}
Map<String,Object> map = new HashMap<String,Object>();
int rowNum = 0;
for(String line : lines){
rowNum++;
String[] content = line.split(" ");
String code = content[0];
String template = content[1];
if(StringUtils.isEmpty(line) || StringUtils.isEmpty(template)){
logger.error("第{}条模板格式错误!内容为:{}",rowNum,line);
continue;
}
map.put(code, template);
}
return map; }
}

加载本地文件,用于测试

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map; import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import com.google.common.base.Charsets;
import com.google.common.io.Files;
import com.google.common.io.LineProcessor; public class LoadTemplate{ final Logger logger = LoggerFactory.getLogger(LoadTemplate.class); private String filePath = "D:/template.txt"; public Map<String,Object> templateMap = new HashMap<String,Object>(); public Map<String, Object> loadTemplate() {
try {
File file = new File(filePath);
Integer lineCount = Files.readLines(file, Charsets.UTF_8,
new LineProcessor<Integer>() {
private int lineCount; public boolean processLine(String line)
throws IOException {
doSync(line);
lineCount++;
logger.debug("{} : {}", lineCount, line);
return true;
} public Integer getResult() {
return lineCount;
}
}); logger.info("读取{}行数据。", lineCount);
} catch (Exception e) {
logger.error("载入模板文件出错!", e);
}
return templateMap;
} private void doSync(String line) {
if(StringUtils.isEmpty(line)){
return;
} String[] content = line.split(" ");
String code = content[0];
String template = content[1];
templateMap.put(code, template);
}
}

解析发送的xml模板: (这里说明下,在系统调用时候,会传入调用的接口对应的模板,与封装的对应模板的值,与模板进行匹配封装)

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;

import com.google.common.base.Preconditions;

public class ParseTemplate {

public Map<String,Object> parseData(Map<String,Object> data,String template) throws DocumentException{
Map<String,Object> parseMap = new HashMap<String,Object>();
  Document documnet = DocumentHelper.parseText(template);
  Element root = documnet.getRootElement();
  Element headElement = root.element("Head");
  Preconditions.checkArgument(headElement != null, "XML中无Head元素");
  HeadElements(parseMap,headElement);

  Element bodyElement = root.element("body");
  if(null == bodyElement){
    bodyElement = root.element("Body");
  }else{
    Preconditions.checkArgument(bodyElement != null, "XML中无body元素");
  }
  bodyElements(data,bodyElement);
  parseMap.put("message", "<?xml version='1.0' encoding='gb18030'?>"+root.asXML());
  return parseMap;
}
//
@SuppressWarnings("unchecked")
private void HeadElements(Map<String,Object> parseMap , Element parentElement) {
  List<Element> fieldElements = parentElement.elements();
  for (Element fieldElement : fieldElements) {
    if(fieldElement.getName().equals("RequestType")){
      parentElement.remove(fieldElement);
      parseMap.put("RequestType", fieldElement.getText());
    }
    if(fieldElement.getName().equals("RequestIp")){
      parentElement.remove(fieldElement);
      parseMap.put("RequestIp", fieldElement.getText());
    }
    if(fieldElement.getName().equals("RequestPort")){
      parentElement.remove(fieldElement);
      parseMap.put("RequestPort", fieldElement.getText());
    }
    if(fieldElement.getName().equals("CreateTime")){
      String now = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
      fieldElement.setText(now);
    }
  }
}

@SuppressWarnings("unchecked")
private void bodyElements(Map<String,Object> data , Element parentElement) {
@SuppressWarnings("rawtypes")
  Iterator iter = parentElement.elementIterator();
  while(iter.hasNext()){
    Element childElement = (Element) iter.next();
    String filedName = childElement.getName();
    if(filedName.equals("field")){ //如果数据为filed,则进行填充处理
      String name = childElement.attributeValue("name");
      String value = (String) data.get(name);
      if(null != value){
        childElement.setText(value);
      }
    }else if(filedName.equals("struct")){
    //如果存在该节点对应的field填充数据,则进行后续处理
    String name = childElement.attributeValue("name");
    if(data.containsKey(name)){
      Map<String,Object> childData = (Map<String, Object>) data.get(name);
      bodyElements(childData, childElement);
    }
  }
}
}

/**
* 解析返回报文
* @param input
* @return
* @throws DocumentException
*/
public Map<String,Object> parseXml(String input) throws DocumentException{
  Map<String, Object> resultMap = new HashMap<String,Object>();
  Map<String,Object> result = new HashMap<String,Object>();
  Document documnet = DocumentHelper.parseText(input);
  Element root = documnet.getRootElement();
  Element headElement = root.element("Head");
  Preconditions.checkArgument(headElement != null, "XML中无Head元素");
  result.putAll(setHeadData(resultMap, headElement));
  Element bodyElement = root.element("Body");
  Preconditions.checkArgument(bodyElement != null, "XML中无Body元素");
  result.putAll(setBodyData(resultMap, bodyElement));
  return result;
}

@SuppressWarnings("unchecked")
public Map<String,Object> setHeadData(Map<String,Object> dataMap,Element parentElement){
  List<Element> fieldElements = parentElement.elements();
  for (Element fieldElement : fieldElements) {
    String name = fieldElement.getName();
    String value = fieldElement.getText();
    dataMap.put(name, value);
  }
  return dataMap;

}

@SuppressWarnings("unchecked")
private Map<String,Object> setBodyData(Map<String, Object> dataMap, Element parentElement) {
  List<Element> fieldElements = parentElement.elements("field");
  if(fieldElements.size() != 0){
    Preconditions.checkArgument(
    (fieldElements != null && !fieldElements.isEmpty()),
    "XML缺少field元素");
    for (Element fieldElement : fieldElements) {
      String name = fieldElement.attributeValue("name");
      String value = StringUtils.trimToNull(fieldElement.getTextTrim());
      dataMap.put(name, value);
    }
  }
  return dataMap;
}
}

方法调用入口: 从xml解析获得的连接方式为socket或http及其Ip和port 进行相应连接,发送并返回请求数据,随之进行解析封装入map,供应用系统提取使用字段值。

import java.io.UnsupportedEncodingException;
import java.util.Map; import org.apache.commons.lang3.StringUtils;
import org.dom4j.DocumentException; import Http.HttpConnect;
import Socket.SocketClient; import temlateRead.ParseTemplate; public class InterFaceCall { public Map<String,Object> getMessage(Map<String,Object> map,String template){
if(null != map && StringUtils.isNotBlank(template) && !map.isEmpty()){
try{
//解析封装模板
ParseTemplate parse = new ParseTemplate();
Map<String,Object> sendData = parse.parseData(map,template);
//连接方式
String connectType = (String) sendData.get("RequestType");
String connectIp = (String) sendData.get("RequestIp");
String connectPort = (String) sendData.get("RequestPort");
if("socket".equals(connectType)){
String content = (String) sendData.get("message");
SocketClient socketClient = new SocketClient(connectIp,connectPort);
socketClient.sendData(content.getBytes());
byte[] res = socketClient.recvData();
String resultData = new String(res,"gb18030");
map = parse.parseXml(resultData);
}else if("http".equals(connectType)){
HttpConnect request = new HttpConnect();
String resultData = request.getMessages(sendData);
map = parse.parseXml(resultData);
}
}catch(DocumentException e){
map.put("errorMessage", e);
e.printStackTrace();
}catch (UnsupportedEncodingException e) {
map.put("errorMessage", e);
e.printStackTrace();
}catch(Exception e){
map.put("errorMessage", e);
e.printStackTrace();
}
}else{
map.put("errorMessage", "传入数据或模板不能为空"); } return map; } }

测试类:

public static void main(String args[]){
String cusUseCashAmount = "";
Map<String,Object> resultData = null;
String template = "";
LoadTemplate aaa = new LoadTemplate();
Map<String,Object> temp = aaa.loadTemplate();;
//从****接口获取用户可用取现金额
String cardNo = "";
template = (String) temp.get("****");
InterFaceCall DataMap = new InterFaceCall();
Map<String,Object> sendData = new HashMap<String,Object>();
String SeqNo = UUID.randomUUID().toString().replace("-", "");
sendData.put("TrxType", "10010");
......
resultData = DataMap.getMessage(sendData, template);
cusUseCashAmount = (String)resultData.get("value1");
}

整理还没有完善,异常处理以及压力测试还没有进行,有空还要重写下。

  

上一篇:C# combobox 如何赋值


下一篇:REdis学习-14 Redis持久化之RDB(Redis DataBase)