1.http请求
 
1.http请求类型：
 
分为post和get请求：
 
get请求传参只允许再请求url和请求头header中传递参数，一般用于传递少量参数用于查询等。
java代码实现：使用java自带的URLConnection实现get请求
 
//相应包导入
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.URL;
import java.net.URLConnection;
import java.util.List;
import java.util.Map; 

/**
     * 向指定URL发送GET方法的请求
     *
     * @param url
     *            发送请求的URL
     * @param param
     *            请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @return URL 所代表远程资源的响应结果
*/    
public String sendGet(String url, String param) {
        String result = "";
        BufferedReader in = null;
        try {
            String urlNameString = url + "?" + param;
            URL realUrl = new URL(urlNameString);
            // 打开和URL之间的连接
            URLConnection connection = realUrl.openConnection();
            // 设置通用的请求属性
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent",
                    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            // 建立实际的连接
            connection.connect();
            // 获取所有响应头字段
            Map<String, List<String>> map = connection.getHeaderFields();
            // 遍历所有的响应头字段
            /*for (String key : map.keySet()) {
                System.out.println(key + "--->" + map.get(key));
            }*/
            // 定义 BufferedReader输入流来读取URL的响应
            in = new BufferedReader(new InputStreamReader(
                    connection.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
        } catch (Exception e) {
            System.out.println("发送GET请求出现异常！" + e);
            e.printStackTrace();
        }
        // 使用finally块来关闭输入流
        finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        return result;
    }
 
 
 
post请求除了以上get请求的特性，还能够通过请求体发送参数，虽然请求体大多实际上都是以字符串的形式传到接口（文件字节传输除外），但其格式    却有不同分类。http请求默认是x-www-form-urlencoded 格式（表格键值对），目前比较流行的时json格式。 代码实现
  import com.alibaba.fastjson.JSONObject;//关键包

//maven引入
/**
*
<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
*/
/**
     * 向指定 URL 发送POST方法的请求
     * @param url
     *            发送请求的 URL
     * @param jsonObject
     *            请求参数，
     * @return 所代表远程资源的响应结果

      ************************  
        将参数对象转为jsonObject
        (JSONObject) JSONObject.toJSON(Object)
        Object 为你的参数对象

     */
    public static String sendPost(String url, JSONObject jsonObject) {
        String param = jsonObject.toJSONString();
        PrintWriter out = null;
        BufferedReader in = null;
        String result = "";
        try {
            URL realUrl = new URL(url);
            // 打开和URL之间的连接
            URLConnection conn = realUrl.openConnection();
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("Content-Type", "application/json; charset=utf-8");
            // 发送POST请求必须设置如下两行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setConnectTimeout(20000);
            conn.setReadTimeout(300000);
            // 获取URLConnection对象对应的输出流
            out = new PrintWriter(conn.getOutputStream());
            // 发送请求参数
            out.print(param);
            // flush输出流的缓冲
            out.flush();
            // 定义BufferedReader输入流来读取URL的响应
            in = new BufferedReader(
                    new InputStreamReader(conn.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        //使用finally块来关闭输出流、输入流
        finally{
            try{
                if(out!=null){
                    out.close();
                }
                if(in!=null){
                    in.close();
                }
            }
            catch(IOException ex){
                ex.printStackTrace();
            }
        }
        return result;
    }
 
还有xml格式的请求，比如关联微信相关的第三方请求等。xml格式请求的关键是xml格式的转换，代码如下：
 
import org.w3c.dom.Document;
import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.StringWriter;
import java.util.Map;

/**
 * @author gaohaojie
 * @date 2019/6/6 11:14
 */
public class XmlUtil {
    /**
     * 将Map转换为XML格式的字符串
     *
     * @param data Map类型数据
     * @return XML格式的字符串
     * @throws Exception
     */
    public static String mapToXml(Map<String, String> data) throws Exception {
        org.w3c.dom.Document document = XmlUtil.newDocument();
        //根标签，此处可根据需求将"xml"换成你需要的跟标签,如 "data"等
        org.w3c.dom.Element root = document.createElement("xml");
        document.appendChild(root);
        for (String key: data.keySet()) {
            String value = data.get(key);
            if (value == null) {
                value = "";
            }
            value = value.trim();
            org.w3c.dom.Element filed = document.createElement(key);
            filed.appendChild(document.createTextNode(value));
            root.appendChild(filed);
        }
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer transformer = tf.newTransformer();
        DOMSource source = new DOMSource(document);
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        StringWriter writer = new StringWriter();
        StreamResult result = new StreamResult(writer);
        transformer.transform(source, result);
        String output = writer.getBuffer().toString(); //.replaceAll("\n|\r", "");
        try {
            writer.close();
        }
        catch (Exception ex) {
        }
        return output;
    }

    public static DocumentBuilder newDocumentBuilder() throws ParserConfigurationException {
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        documentBuilderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
        documentBuilderFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
        documentBuilderFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
        documentBuilderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
        documentBuilderFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
        documentBuilderFactory.setXIncludeAware(false);
        documentBuilderFactory.setExpandEntityReferences(false);

        return documentBuilderFactory.newDocumentBuilder();
    }

    public static Document newDocument() throws ParserConfigurationException {
        return newDocumentBuilder().newDocument();
    }
}
 
接下来是将xml格式数据发送并接收xml格式响应数据，代码如下：
 
//导入的包
import org.w3c.dom.Document;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;

//http请求并获取xml返回值
    public static Map postOfXml(String strUrl,String xmlString)throws Exception {
        Map resultMap = new HashMap();
        HttpURLConnection conn = null;
        try {
            URL url = new URL(strUrl);
            conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setDoOutput(true);
            conn.setUseCaches(false);
            conn.setConnectTimeout(10000);
            conn.setReadTimeout(10000);
            conn.setInstanceFollowRedirects(false);
            conn.connect();
            if (xmlString!= null) {
                try {
                    //请求接口
                    DataOutputStream out = new DataOutputStream(conn.getOutputStream());
                    out.writeBytes(urlencode(xmlString));
                } catch (Exception e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }
            }
            InputStream input = conn.getInputStream();//获取XX接口的返回信息
            byte[] rResult;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            byte[] bufferByte = new byte[256];
            int l = -1;
            int downloadSize = 0;
            while ((l = input.read(bufferByte)) > -1) {
                downloadSize += l;
                out.write(bufferByte, 0, l);
                out.flush();
            }
            rResult = out.toByteArray();
            //解析工厂类
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            //解析器
            DocumentBuilder db = dbf.newDocumentBuilder();
            //文档树模型Document     将需要解析的xml文档转化为输入流
            Document d = db.parse(new ByteArrayInputStream(rResult));
            //获取xml返回值中对应标签的值,getElementsByTagName是一种便捷属性允许直接访问文档的文档元素的子节点
            String result = d.getElementsByTagName("Result").item(0).getFirstChild().getNodeValue();
            String outOrderNumber = d.getElementsByTagName("OutOrderNumber").item(0).getFirstChild().getNodeValue();
            resultMap.put("result",result);
            resultMap.put("outOrderNumber",outOrderNumber);

            return resultMap;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (conn != null) {
                conn.disconnect();
            }
        }
        return resultMap;
    }
 
ps. 如有错误或建议欢迎提出指正~

 
//1.在servlet中post一个xml流：
 
import java.io.OutputStreamWriter;
 
import org.jdom.Document;
 
import org.jdom.Document;
 
public void doPost(HttpServletRequest request, HttpServletResponse response)
 
throws ServletException, IOException {
 
//do somthing...
 
response.setContentType("application/xml");
 
Document doc = createDoc();
 
String strdoc = new XMLOutputter().outputString(doc);
 
OutputStreamWriter out = new OutputStreamWriter(response
 
.getOutputStream(), "UTF-8");
 
out.write(strdoc);
 
out.flush();
 
out.close();
 
//do somthing...
 
}
 
/***
 
*将要封装的数据，封装为xml文件的Document格式
 
*/
 
public Document createDoc() {
 
Document doc = null;
 
Element root;
 
Element viewentry;
 
Element entry;
 
List list = getData();
 
try {
 
XMLOutputter docWriter = new XMLOutputter(" ", true);
 
docWriter.setEncoding("UTF-8");
 
root = new Element("your_element_name");
 
doc = new Document(root);
 
root = doc.getRootElement();
 
if (list == null || list.size() == 0) {
 
return doc;
 
}
 
Iterator it = list.iterator();
 
while (it.hasNext()) {
 
Map colMap = (Map) it.next();
 
viewentry = new Element("document");
 
entry = new Element("author");
 
entry.setText(colMap.get("userid").toString());
 
viewentry.addContent(entry);
 
//do other entry in this way
 
root.addContent(viewentry);
 
}
 
} catch (Exception e) {
 
e.printStackTrace();
 
}
 
return doc;
 
}
 
//2.根据接收的url，从其中获取xml流生成xml文件
 
import org.dom4j.Document;
 
import org.dom4j.DocumentException;
 
import org.dom4j.io.SAXReader;
 
import sun.net.www.protocol.http.HttpURLConnection;
 
public static Document getDocument(String url){
 
Document doc = null;
 
HttpURLConnection conn = null;
 
InputStream ins = null;
 
SAXReader reader = null;
 
try{
 
HttpTimeoutHandler hth = new HttpTimeoutHandler(600000);
 
URL conURL = new URL(null,url,hth);
 
conn = (HttpURLConnection)conURL.openConnection();
 
conn.setDoInput(true);
 
conn.setDoOutput(true);
 
conn.setUseCaches(false);
 
ins = conn.getInputStream();
 
reader =new SAXReader();
 
doc= reader.read(ins);
 
ins.close();
 
conn.disconnect();
 
}catch (MalformedURLException e) {
 
e.printStackTrace();
 
} catch (IOException e) {
 
e.printStackTrace();
 
} catch (DocumentException e) {
 
e.printStackTrace();
 
}catch(Exception e){
 
e.printStackTrace();
 
}finally {
 
try {
 
if (ins != null) {
 
ins.close();
 
ins = null;
 
}
 
} catch (IOException e1) {
 
e1.printStackTrace();
 
}
 
try {
 
if (conn != null) {
 
conn.disconnect();
 
conn = null;
 
}
 
} catch (Exception e2) {
 
e2.printStackTrace();
 
}
 
}
 
return doc;
 
}
 
3.//处理url超时限制
 
/***
 
HttpTimeoutHandler.java
 
*/
 
import java.net.*;
 
import java.io.IOException;
 
public class HttpTimeoutHandler extends sun.net.www.protocol.http.Handler {
 
int intTimeoutVal;
 
HttpURLConnectionTimeout fHUCT;
 
public HttpTimeoutHandler(int iT) {
 
intTimeoutVal = iT;
 
}
 
protected java.net.URLConnection openConnection(URL u) throws IOException {
 
return fHUCT = new HttpURLConnectionTimeout(u, this, intTimeoutVal);
 
}
 
String GetProxy() {
 
return proxy;
 
} // breaking encapsulation
 
int GetProxyPort() {
 
return proxyPort;
 
} // breaking encapsulation
 
public void Close() throws Exception {
 
fHUCT.Close();
 
}
 
public Socket GetSocket() {
 
return fHUCT.GetSocket();
 
}
 
}

大家好，这是第一次写博客，跟大家一起学习。 
 在项目中用到了在CS客户端通过http发送xml文件，java后台接受，并返回xml文件，经过查阅资料，流程走通，有效
 
@RequestMapping(value = "login", params = "method=CSlogin")
public void CSLogin(HttpServletRequest request, HttpServletResponse response) {
        Document resDoc = null;
        try {
            // 获取HTTP请求的输入流
            // 已HTTP请求输入流建立一个BufferedReader对象
            BufferedReader br = new BufferedReader(new InputStreamReader(
                    request.getInputStream(), "UTF-8"));

            String buffer = null;
            // 存放请求内容
            StringBuffer xml = new StringBuffer();
            while ((buffer = br.readLine()) != null) {
                // 在页面中显示读取到的请求参数
                xml.append(buffer);
            }
            Document document = null;
            SAXReader reader = new SAXReader();
            ByteArrayInputStream inputStream = new ByteArrayInputStream(xml
                    .toString().getBytes());
            InputStreamReader ir = new InputStreamReader(inputStream);
//document已经获取到xml文件
document = reader.read(ir);
//根据项目需求，解析xml文件
//。。。。略过

} catch (Exception ex) {
    ex.printStackTrace();
    //resDoc为返回的xml文件       
    resDoc = getErrorDocument(accountName, "3", "系统处理出现异常");
} finally {
    OutputFormat format = OutputFormat.createCompactFormat();
    format.setEncoding("UTF-8");
    XMLWriter writer;
try {
    writer = new XMLWriter(response.getOutputStream(), format);
    //resDoc为通过http返回的xml文件
    writer.write(resDoc);
    writer.flush();
    if (null != writer) {
        writer.close();
    }
} catch (Exception e) {
    log.error(e, e);
    e.printStackTrace();
}
}
 
由于经验欠缺，性能优化不是很好，如果大神发现bug了， 恳请指出，谢谢。

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<Request>
<Head>
<TxCode>2818</TxCode>
</Head>
<Body>
<PaymentNo>U0000022019061750506390001</PaymentNo>
<Status>20</Status>
<Amount>400</Amount>
</Body>
</Request>
 
如上，有一段xml数据。要从前端传给后台。接收方式有两种，一种是Http形式，另一种是xml以字符串的形式传进后台。但不管怎么传，最重要的还是传进后台以后怎么去处理xml，怎么得到这里面我们想要的元素信息。这里就涉及到dom4j的使用。json有fastjson来解析，xml自然也有可以解析它的东西。
 
今天就写一下以Http接收的示例，如果是以String接收那就更简单了，大同小异，我就不写了。
 
先上代码解析：
 
 
public String payment(HttpServletRequest request) throws DocumentException, IOException {
        // 获取HTTP请求的输入流
        // 已HTTP请求输入流建立一个BufferedReader对象
        BufferedReader br = new BufferedReader(new InputStreamReader(
                request.getInputStream(), "UTF-8"));
        String buffer = null;
        // 存放请求内容
        StringBuffer xml = new StringBuffer();
        while ((buffer = br.readLine()) != null) {
            // 在页面中显示读取到的请求参数
            xml.append(buffer);
        }

        String callbackMessage = xml.toString();
        if (!ObjectUtils.isEmpty(callbackMessage)) {
            Payment payment= new Payment();
            Document doc = null;
            //1.读取并解析XML文档,SAXReader就是一个管道，用一个流的方式，把xml文件读出来
            // SAXReader reader = new SAXReader();
            // Document document = reader.read(new File("User.hbm.xml")); //User.hbm.xml表示你要解析的xml文档
            //2.将字符串转为XML
            doc = DocumentHelper.parseText(callbackMessage);
            Element rootElt = doc.getRootElement(); // 获取根节点Request
            System.out.println("根节点：" + rootElt.getName()); // 拿到根节点的名称
            Iterator iter = rootElt.elementIterator("Head"); // 获取根节点下的子节点head
            // 遍历head节点
            while (iter.hasNext()) {
                Element recordEless = (Element) iter.next();
       
                String txCode = recordEless.elementTextTrim("TxCode");
                payment.setTxCode(txCode);
                System.out.println("txCode:" + txCode);

            }
            Iterator iterss = rootElt.elementIterator("Body"); ///获取根节点下的子节点body
            // 遍历body节点
            while (iterss.hasNext()) {
                Element recordEless = (Element) iterss.next();
               
                String paymentNo = recordEless.elementTextTrim("PaymentNo");
                payment.setPaymentNo(paymentNo);
                System.out.println("paymentNo:" + paymentNo);
               
                String status = recordEless.elementTextTrim("status");
                payment.setStatus(status);
                System.out.println("status:" + status);
                
                String amount = recordEless.elementTextTrim("Amount");
                payment.setAmount(amount);
                System.out.println("amount:" + amount);
                
               
            }


            ......到此xml解析完毕，后续操作省略
           
        }
 
用到的包
 
 
代码拷进去编辑器应该会有提醒的。