Jfinal 获取post请求中的body内容(流的形式获取),Java 发送post 流

发布时间:2018-06-01作者:laosun阅读(2958)

Jfinal HttpKit 有封装http请求类。内含get、post请求。以及post 流的发送方式。另外提供流的获取方式。 Jfinal目前用于客户端android、ios提供接口服务器比较常见,下边博主来说一下如何发送请求、如何接收请求

    下边我来先贴一下Jfinal HttpKit的封装类:

    package com.jfinal.kit;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.UnsupportedEncodingException;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.net.URLEncoder;
    import java.security.KeyManagementException;
    import java.security.NoSuchAlgorithmException;
    import java.security.NoSuchProviderException;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    import java.util.Map;
    import java.util.Map.Entry;
    import javax.net.ssl.HostnameVerifier;
    import javax.net.ssl.HttpsURLConnection;
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.SSLSession;
    import javax.net.ssl.SSLSocketFactory;
    import javax.net.ssl.TrustManager;
    import javax.net.ssl.X509TrustManager;
    import javax.servlet.http.HttpServletRequest;
    
    /**
     * HttpKit
     */
    public class HttpKit {
    	
    	private HttpKit() {}
    	
    	/**
    	 * https 域名校验
    	 */
    	private static class TrustAnyHostnameVerifier implements HostnameVerifier {
    		public boolean verify(String hostname, SSLSession session) {
    			return true;
    		}
    	}
    	
    	/**
    	 * https 证书管理
    	 */
    	private static class TrustAnyTrustManager implements X509TrustManager {
    		public X509Certificate[] getAcceptedIssuers() {
    			return null;  
    		}
    		public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    		}
    		public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    		}
    	}
    	
    	private static final String GET  = "GET";
    	private static final String POST = "POST";
    	private static String CHARSET = "UTF-8";
    	
    	private static final SSLSocketFactory sslSocketFactory = initSSLSocketFactory();
    	private static final TrustAnyHostnameVerifier trustAnyHostnameVerifier = new HttpKit.TrustAnyHostnameVerifier();
    	
    	private static SSLSocketFactory initSSLSocketFactory() {
    		try {
    			TrustManager[] tm = {new HttpKit.TrustAnyTrustManager() };
    			SSLContext sslContext = SSLContext.getInstance("TLS");	// ("TLS", "SunJSSE");
    			sslContext.init(null, tm, new java.security.SecureRandom());
    			return sslContext.getSocketFactory();
    		}
    		catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    	}
    	
    	public static void setCharSet(String charSet) {
    		if (StrKit.isBlank(charSet)) {
    			throw new IllegalArgumentException("charSet can not be blank.");
    		}
    		HttpKit.CHARSET = charSet;
    	}
    	
    	private static HttpURLConnection getHttpConnection(String url, String method, Map<String, String> headers) throws IOException, NoSuchAlgorithmException, NoSuchProviderException, KeyManagementException {
    		URL _url = new URL(url);
    		HttpURLConnection conn = (HttpURLConnection)_url.openConnection();
    		if (conn instanceof HttpsURLConnection) {
    			((HttpsURLConnection)conn).setSSLSocketFactory(sslSocketFactory);
    			((HttpsURLConnection)conn).setHostnameVerifier(trustAnyHostnameVerifier);
    		}
    		
    		conn.setRequestMethod(method);
    		conn.setDoOutput(true);
    		conn.setDoInput(true);
    		
    		conn.setConnectTimeout(19000);
    		conn.setReadTimeout(19000);
    		
    		conn.setRequestProperty("Content-Type","application/x-www-form-urlencoded");
    		conn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36");
    		
    		if (headers != null && !headers.isEmpty()) {
    			for (Entry<String, String> entry : headers.entrySet()) {
    				conn.setRequestProperty(entry.getKey(), entry.getValue());
    			}
    		}
    		
    		return conn;
    	}
    	
    	/**
    	 * Send GET request
    	 */
    	public static String get(String url, Map<String, String> queryParas, Map<String, String> headers) {
    		HttpURLConnection conn = null;
    		try {
    			conn = getHttpConnection(buildUrlWithQueryString(url, queryParas), GET, headers);
    			conn.connect();
    			return readResponseString(conn);
    		}
    		catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    		finally {
    			if (conn != null) {
    				conn.disconnect();
    			}
    		}
    	}
    	
    	public static String get(String url, Map<String, String> queryParas) {
    		return get(url, queryParas, null);
    	}
    	
    	public static String get(String url) {
    		return get(url, null, null);
    	}
    	
    	/**
    	 * Send POST request
    	 */
    	public static String post(String url, Map<String, String> queryParas, String data, Map<String, String> headers) {
    		HttpURLConnection conn = null;
    		try {
    			conn = getHttpConnection(buildUrlWithQueryString(url, queryParas), POST, headers);
    			conn.connect();
    			
    			if (data != null) {
    				OutputStream out = conn.getOutputStream();
    				out.write(data.getBytes(CHARSET));
    				out.flush();
    				out.close();
    			}
    			
    			return readResponseString(conn);
    		}
    		catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    		finally {
    			if (conn != null) {
    				conn.disconnect();
    			}
    		}
    	}
    	
    	public static String post(String url, Map<String, String> queryParas, String data) {
    		return post(url, queryParas, data, null);
    	}
    	
    	public static String post(String url, String data, Map<String, String> headers) {
    		return post(url, null, data, headers);
    	}
    	
    	public static String post(String url, String data) {
    		return post(url, null, data, null);
    	}
    	
    	private static String readResponseString(HttpURLConnection conn) {
    		BufferedReader reader = null;
    		try {
    			StringBuilder ret;
    			reader = new BufferedReader(new InputStreamReader(conn.getInputStream(), CHARSET));
    			String line = reader.readLine();
    			if (line != null) {
    				ret = new StringBuilder();
    				ret.append(line);
    			} else {
    				return "";
    			}
    			
    			while ((line = reader.readLine()) != null) {
    				ret.append('\n').append(line);
    			}
    			return ret.toString();
    		}
    		catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    		finally {
    			if (reader != null) {
    				try {
    					reader.close();
    				} catch (IOException e) {
    					LogKit.error(e.getMessage(), e);
    				}
    			}
    		}
    	}
    	
    	/**
    	 * Build queryString of the url
    	 */
    	private static String buildUrlWithQueryString(String url, Map<String, String> queryParas) {
    		if (queryParas == null || queryParas.isEmpty()) {
    			return url;
    		}
    		
    		StringBuilder sb = new StringBuilder(url);
    		boolean isFirst;
    		if (url.indexOf('?') == -1) {
    			isFirst = true;
    			sb.append('?');
    		}
    		else {
    			isFirst = false;
    		}
    		
    		for (Entry<String, String> entry : queryParas.entrySet()) {
    			if (isFirst) {
    				isFirst = false;
    			} else {
    				sb.append('&');
    			}
    			
    			String key = entry.getKey();
    			String value = entry.getValue();
    			if (StrKit.notBlank(value)) {
    				try {value = URLEncoder.encode(value, CHARSET);} catch (UnsupportedEncodingException e) {throw new RuntimeException(e);}
    			}
    			sb.append(key).append('=').append(value);
    		}
    		return sb.toString();
    	}
    	
    	public static String readData(HttpServletRequest request) {
    		BufferedReader br = null;
    		try {
    			StringBuilder ret;
    			br = request.getReader();
    			
    			String line = br.readLine();
    			if (line != null) {
    				ret = new StringBuilder();
    				ret.append(line);
    			} else {
    				return "";
    			}
    			
    			while ((line = br.readLine()) != null) {
    				ret.append('\n').append(line);
    			}
    			
    			return ret.toString();
    		} catch (IOException e) {
    			throw new RuntimeException(e);
    		}
    		finally {
    			if (br != null) {
    				try {br.close();} catch (IOException e) {LogKit.error(e.getMessage(), e);}
    			}
    		}
    	}
    	
    	@Deprecated
    	public static String readIncommingRequestData(HttpServletRequest request) {
    		return readData(request);
    	}
    }

    从上边这个类我们可以看出HttpKit提供的方法有如下几种

    image.png

    看图中介绍,就可以得出,get方法涉及三种形式。满足多参数、多headers的请求方式

    post方法也满足了多参数、多header的请求方式,另外还有个参数data,这个data就是以流的形式进行发送的。

    打个比方来说: 

    如果你想向某个服务端发送超大json数据,这个json数据你放入queryParas中肯定是不行的。那么就需要以流的形式发送过去。

    举例说明:

    public static void main(String[] args) {
    		String url = "https://xxxx.com/upload";
    		Map<String, String> queryParas = new HashMap<String, String>();
    		queryParas.put("key", "123");
    		queryParas.put("version", "1.2.1");
    		String jsonData = "超大json数据";
    		String result = HttpKit.post(url, queryParas, jsonData);
    		System.out.println("请求结果:"+result);
    	}

    那么在服务端进行获取的时候就要用到上边的readData方法了。但是使用这个方法相信很多人遇到了麻烦,为什么获取不到呢?

    其实获取body参数,需要在request.getParameter()方法之前调用(如果有需要取QueryString参数的话),因为一旦调用了getParameter()方法之后,再通过IO流的方式获取body参数就失效了

    也就是说,我们必须先获取body流数据,然后再获取参数才可。

    举例说明(按照以下顺序获取):

    String json = HttpKit.readData(getRequest());
    		String key = getPara("key"); 
    		String version = getPara("version");

    好了,这个请求类可以拿出来做个封装,android端也是可以用的,都是java,出自一个地方。

3 +1

版权声明

 Java  源码

 请文明留言

2 条评论