jdk http server test

package com.cyyun.xc.command.util;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetSocketAddress;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
import com.sun.net.httpserver.spi.HttpServerProvider;

/**
 * @project SimpleHttpServer
 * @author sunnylocus
 * @vresion 1.0 2009-9-2
 * @description 自定义的http服务器
 */
public class MyHttpServer {
	// 启动服务，监听来自客户端的请求
	public static void httpserverService() throws IOException {
		HttpServerProvider provider = HttpServerProvider.provider();
		HttpServer httpserver = provider.createHttpServer(
				new InetSocketAddress(6666), 100);// 监听端口6666,能同时接 受100个请求
		httpserver.createContext("/myApp", new MyHttpHandler());
		httpserver.setExecutor(null);
		httpserver.start();
		System.out.println("server started");
	}

	// Http请求处理类
	static class MyHttpHandler implements HttpHandler {
		public void handle(HttpExchange httpExchange) throws IOException {
			String responseMsg = "ok"; // 响应信息
			
			
			System.out.println("httpExchange.getRequestMethod() "+httpExchange.getRequestMethod());
			
			
			System.out.println("httpExchange.getRequestURI() "+httpExchange.getRequestURI());
			
			InputStream in = httpExchange.getRequestBody(); // 获得输入流
			BufferedReader reader = new BufferedReader(
					new InputStreamReader(in));
			String temp = null;
			while ((temp = reader.readLine()) != null) {
				System.out.println("client request:" + temp);
			}
			httpExchange.sendResponseHeaders(200, responseMsg.length()); // 设置响应头属性及响应信息的长度
			OutputStream out = httpExchange.getResponseBody(); // 获得输出流
			out.write(responseMsg.getBytes());
			out.flush();
			httpExchange.close();

		}
	}

	public static void main(String[] args) throws IOException {
		httpserverService();
	}
}

 

package com.cyyun.xc.command.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.KeyStore;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.conn.ssl.X509HostnameVerifier;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;

public class HttpXmlClient {
	private static Logger log = Logger.getLogger(HttpXmlClient.class);

	public static String post(String url, Map<String, String> params) {
		DefaultHttpClient httpclient = new DefaultHttpClient();
		String body = null;

		log.info("create httppost:" + url);
		HttpPost post = postForm(url, params);

		body = invoke(httpclient, post);

		httpclient.getConnectionManager().shutdown();

		return body;
	}

	public static String get(String url) {
		DefaultHttpClient httpclient = new DefaultHttpClient();
		// 请求超时
		httpclient.getParams().setParameter(
				CoreConnectionPNames.CONNECTION_TIMEOUT, 30000);
		// 读取超时
		httpclient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT,
				30000);
		String body = null;

		log.info("create httppost:" + url);
		HttpGet get = new HttpGet(url);
		body = invoke(httpclient, get);

		httpclient.getConnectionManager().shutdown();

		return body;
	}

	public static String invoke(DefaultHttpClient httpclient,
			HttpUriRequest httpost) {

		HttpResponse response = sendRequest(httpclient, httpost);
		String body = paseResponse(response);

		return body;
	}

	private static String paseResponse(HttpResponse response) {
		log.info("get response from http server..");
		HttpEntity entity = response.getEntity();

		log.info("response status: " + response.getStatusLine());
		String charset = EntityUtils.getContentCharSet(entity);
		log.info(charset);

		String body = null;
		try {
			body = EntityUtils.toString(entity);
			log.info(body);
		} catch (ParseException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

		return body;
	}
	
	public static void main(String[] args) {
		String url = "http://127.0.0.1:6666/myApp?123123";
		//get(url);
		Map<String,String> params= new LinkedHashMap<String, String>();
		for(int i=0;i<100;i++){
			params.put("name"+i, "1234");
		}
		
		post(url, params);
	}

	public static void setHttps(DefaultHttpClient httpclient, File file) {
		try {
			// 获得密匙库
			KeyStore trustStore = KeyStore.getInstance(KeyStore
					.getDefaultType());
			FileInputStream instream = new FileInputStream(file);
			// 密匙库的密码
			trustStore.load(instream, "1qaz2wsx".toCharArray());
			// 注册密匙库
			SSLSocketFactory socketFactory = new SSLSocketFactory(trustStore);
			// 不校验域名
			socketFactory
					.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
			Scheme sch = new Scheme("https", 443, socketFactory);
			httpclient.getConnectionManager().getSchemeRegistry().register(sch);
		} catch (Exception e) {
			log.error(e);
		}

	}

	public static void setHttps2(DefaultHttpClient httpclient, File file) {
		try {
			X509TrustManager trustManager = new X509TrustManager() {
				@Override
				public void checkClientTrusted(X509Certificate[] chain,
						String authType) throws CertificateException {
				}

				@Override
				public void checkServerTrusted(X509Certificate[] chain,
						String authType) throws CertificateException {
				}

				@Override
				public X509Certificate[] getAcceptedIssuers() {
					return null;
				}
			};
			// 创建HostnameVerifier
			// 用于解决javax.net.ssl.SSLException: hostname in certificate didn't
			// match:
			// <123.125.97.66> != <123.125.97.241>
			X509HostnameVerifier hostnameVerifier = new X509HostnameVerifier() {
				@Override
				public void verify(String host, SSLSocket ssl)
						throws IOException {
				}

				@Override
				public void verify(String host, X509Certificate cert)
						throws SSLException {
				}

				@Override
				public void verify(String host, String[] cns,
						String[] subjectAlts) throws SSLException {
				}

				@Override
				public boolean verify(String arg0, SSLSession arg1) {
					return true;
				}
			};
			// TLS1.0与SSL3.0基本上没有太大的差别,可粗略理解为TLS是SSL的继承者，但它们使用的是相同的SSLContext
			SSLContext sslContext = SSLContext
					.getInstance(SSLSocketFactory.TLS);
			// 使用TrustManager来初始化该上下文,TrustManager只是被SSL的Socket所使用
			sslContext.init(null, new TrustManager[] { trustManager }, null);
			// 创建SSLSocketFactory
			SSLSocketFactory socketFactory = new SSLSocketFactory(sslContext,
					hostnameVerifier);
			// 通过SchemeRegistry将SSLSocketFactory注册到HttpClient上
			httpclient.getConnectionManager().getSchemeRegistry()
					.register(new Scheme("https", 443, socketFactory));
		} catch (Exception e) {
			log.error(e);
		}

	}

	public static HttpResponse sendRequest(DefaultHttpClient httpclient,
			HttpUriRequest httpost) {
		log.info("execute post...");
		HttpResponse response = null;

		try {
			response = httpclient.execute(httpost);
		} catch (ClientProtocolException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
		}
		return response;
	}

	public static HttpPost postForm(String url, Map<String, String> params) {

		HttpPost httpost = new HttpPost(url);
		// httpost.setHeaders(headers);
		List<NameValuePair> nvps = new ArrayList<NameValuePair>();

		Set<String> keySet = params.keySet();
		for (String key : keySet) {
			nvps.add(new BasicNameValuePair(key, params.get(key)));
		}

		try {
			log.info("set utf-8 form entity to httppost");
			httpost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}

		return httpost;
	}

	private static HttpPost postForm(String url, Map<String, String> params,
			HttpPost httpost) {

		// HttpPost httpost = new HttpPost(url);
		try {
			httpost.setURI(new URI(url));
		} catch (URISyntaxException e1) {
			e1.printStackTrace();
		}
		List<NameValuePair> nvps = new ArrayList<NameValuePair>();

		Set<String> keySet = params.keySet();
		for (String key : keySet) {
			nvps.add(new BasicNameValuePair(key, params.get(key)));
		}

		try {
			log.info("set utf-8 form entity to httppost");
			httpost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}

		return httpost;
	}

	public static String checkIp(DefaultHttpClient httpclient, String ip,
			String prot) {
		String rs = null;
		String url = "http://web.chacuo.net/netproxycheck";
		Map<String, String> dataMap = new HashMap<String, String>();
		dataMap.put("data", ip.trim());
		dataMap.put("type", "proxycheck");
		dataMap.put("arg", "p=" + prot.trim() + "_t=1_o=3");
		// log.error("ip  map :" + dataMap);
		try {
			HttpPost httpPost = postForm(url, dataMap);
			rs = invoke(httpclient, httpPost);
			rs = encodingtoStr(rs);
		} catch (Exception e) {
			log.error("检测ip出错", e);
		}
		return rs;
	}

	/**
	 * 汉字转Unicode
	 * 
	 * @param s
	 * @return
	 */
	public static String gbEncoding(final String s) {
		if (StringUtils.isBlank(s)) {
			return null;
		}
		String str = "";
		for (int i = 0; i < s.length(); i++) {
			int ch = (int) s.charAt(i);
			str += "\\u" + Integer.toHexString(ch);
		}
		return str;
	}

	/**
	 * Unicode转汉字
	 * 
	 * @param str
	 * @return
	 */
	public static String encodingtoStr(String str) {
		if (StringUtils.isBlank(str)) {
			return null;
		}
		Pattern pattern = Pattern.compile("(\\\\u(\\p{XDigit}{4}))");
		Matcher matcher = pattern.matcher(str);
		char ch;
		while (matcher.find()) {
			ch = (char) Integer.parseInt(matcher.group(2), 16);
			str = str.replace(matcher.group(1), ch + "");
		}
		return str;
	}

}