简易的http-client

package com.http;

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;


/**
 * 所有数据默认返回 json
 * 目前不支持文件上传
 * @author vp
 *
 */
public class SimpleHttpClient {
	private Object object;
	
	public SimpleHttpClient(Class clazz){
		object = Proxy.newProxyInstance(clazz.getClassLoader(), 
			     new Class[]{clazz}, 
			     new ProxyHandler( new HttpClient("", PerFormEnum.POSTBODY)));
	}
	
	
	

	static class bulid {
		
	}
}

class HttpClient{
	private static final Map<String,String> defaultRequestProperty = new HashMap<String, String>();
	static{
		defaultRequestProperty.put("User-Agent", "laohu");
		defaultRequestProperty.put("Content-Type", "application/json");
		defaultRequestProperty.put("Accept", "application/json");
	}
	
	
	private Map<String,String> requestProperty = new HashMap<String, String>( defaultRequestProperty );
	
	private HttpRequestSerialization httpRequestSerialization;
	
	private HttpReturnSerialization httpReturnSerialization;
	
	private Perform perform;
	
	private int defaultConnectTimeout = 3000;
	private int defaultReadTimeout    = 3000;
	
	private int connectTimeout = 3000;
	private int readTimeout    = 3000;
	
	private String url;
	
	private PerFormEnum perFormEnum;
	
	private Map<String ,String> parameter;
	
	
	public HttpClient(String url , PerFormEnum perFormEnum){
		this( url , perFormEnum , new HashMap<String, String>());
	}
	
	public HttpClient(String url , PerFormEnum perFormEnum , Map<String ,String> parameter ){
		this( url , perFormEnum , parameter , new DefaultHttpRequestSerialization() , new StringHttpReturnSerialization());
	}
	
	
	public HttpClient(String url , PerFormEnum perFormEnum , Map<String ,String> parameter , HttpRequestSerialization httpRequestSerialization,HttpReturnSerialization httpReturnSerialization){
		if( url == null  || parameter == null){
			throw new NullPointerException();
		}
		this.url = url ;
		this.perFormEnum = perFormEnum;
		this.perform = perFormEnum.getPerform();
		this.perform.setUrl( this.url );
		
		this.parameter = parameter;
		
		if(parameter.containsKey( "connectTimeout")){
			connectTimeout = Integer.getInteger( this.parameter.get("connectTimeout"));
		}else{
			connectTimeout  = defaultConnectTimeout;
		}
		
		if(parameter.containsKey( "readTimeout")){
			readTimeout = Integer.getInteger( this.parameter.get("readTimeout"));
		}else{
			readTimeout = defaultReadTimeout;
		}
		
		
		this.httpRequestSerialization = httpRequestSerialization;
		this.httpReturnSerialization  = httpReturnSerialization;
				
	}
	
	
	public <T>T perform(String uri , Object object) throws Exception{
		String data = null;
		if(object != null){
			data = httpRequestSerialization.serialization( object );
		}
		String url = perform.urlPerform(uri, data);
		HttpURLConnection httpUrlConnection = (HttpURLConnection)new URL(url).openConnection();
		httpUrlConnection.setRequestMethod( perFormEnum.getMethon() );
		setRequestProperty( httpUrlConnection );
		
		perform.perform(httpUrlConnection, data);
		
		
		try{		
			httpUrlConnection.setUseCaches( false );
			
			httpUrlConnection.setReadTimeout( this.readTimeout );
			
			httpUrlConnection.setConnectTimeout( this.connectTimeout );
			
			httpUrlConnection.connect();
		}catch (Exception e) {
			//这里修改代码不
		}
		
		int i = httpUrlConnection.getResponseCode();
		if( i == 200)
			return returnDate( httpUrlConnection );		
		return null;		
	}
	
	
	private void setRequestProperty(HttpURLConnection httpUrlConnection){
		for( Entry<String, String> e : requestProperty.entrySet()){
			httpUrlConnection.setRequestProperty( e.getKey() , e.getValue() );
		}
	}
	
	/**
	 * 可以从请求头里面获得 数据长度，就不用循序了
	 * @param httpUrlConnection
	 * @return
	 * @throws Exception
	 */
	@SuppressWarnings({ "unused", "unchecked" })
	private <T>T returnDate(HttpURLConnection httpUrlConnection ) throws Exception{
		try(BufferedInputStream bais = new BufferedInputStream(httpUrlConnection.getInputStream())){
			ByteArrayOutputStream baos  = new ByteArrayOutputStream();
			byte[] contents = new byte[2024];  
	        int byteRead = 0;  
	        while((byteRead = bais.read(contents)) != -1){  
	        	baos.write( contents );
            }  	        
			return (T)httpReturnSerialization.serialization( baos.toByteArray() );
		}
	}	
}


/**
 * 
 * @author vp
 *
 */




class ProxyHandler implements InvocationHandler {

	private HttpClient httpClient;
	
	public ProxyHandler( HttpClient httpClient ){
		this.httpClient = httpClient;
	}
	
	
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		
		
		return httpClient.perform( method.getName() , args[0] );
	}
	
}


/**
 * 
 * @author vp
 *
 */

interface HttpRequestSerialization {
	
	public String serialization(Object o);
}

class DefaultHttpRequestSerialization implements HttpRequestSerialization{

	public String serialization(Object o) {
		
		return null;
	}

	private String mapSerialization(){
		
		return null;
	}
	
	private String entitySerialization(){
		
		return null;
	}
}

/**
 * 
 * @author vp
 *
 */
interface HttpReturnSerialization {

	
	public Object serialization(byte[] byteArray);
}

class StringHttpReturnSerialization implements HttpReturnSerialization {

	public Object serialization(byte[] byteArray) {
	
		return new String( byteArray );
	}

}


/**
 * 
 * @author vp
 *
 */


interface Perform {
	
	static final byte[] separator = new byte[]{13 , 10};
	
	static final byte[] piecewise = new byte[]{13 , 10 , 13 ,10};
	
	
	public void setUrl(String url );

	public String urlPerform(String url, String data);

	public void perform(HttpURLConnection httpUrlConnection, String data) throws Exception;
}


 enum PerFormEnum{
	
	GET("GET" , new GetPerform()),
	POST("POST" , new PostPerform()),
	POSTBODY("POST" , new PostBodyPerform());
	
	private String methon;
	
	private Perform perform;
	
	
	
	PerFormEnum(String methon , Perform perform ){
		this.methon = methon;
		this.perform = perform;
	}

	
	public String getMethon(){
		return methon;
	}
	
	public Perform getPerform(){
		return perform;
	}
}


abstract class PequestPerForm implements Perform {

	String url;
	
	public void setUrl(String url){
		this.url = url;
	}
	
	public String urlPerform(String url, String data) {
		return this.url + url;
	}

	public void perform(HttpURLConnection httpUrlConnection, String data) throws Exception {
		
	}
}

abstract class PostPequestPerForm extends PequestPerForm{
	
	private OutputStream outputStream;
	
	private HttpURLConnection httpUrlConnection;
	
	private int bodyLenth = 0;
	
	void setHttpURLConnection( HttpURLConnection httpUrlConnection ) throws IOException{
		this.httpUrlConnection = httpUrlConnection;
		httpUrlConnection.setDoOutput(true);
		httpUrlConnection.setDoInput(true);
		httpUrlConnection.setUseCaches(false);	
				
		this.outputStream = httpUrlConnection.getOutputStream();
	}
	
	
	void write(byte[] by , int length ) throws IOException{
		bodyLenth = bodyLenth + by.length;
		outputStream.write( by );
	}
	
	void write(byte[] by) throws IOException{
		write( by , by.length);
	}
	
	
	void length(){
		httpUrlConnection.setRequestProperty("Content-length" , ""+bodyLenth);
	}
}



class GetPerform extends PequestPerForm {
	public String urlPerform(String url, String data) {
		return super.urlPerform(url,data)+"?"+data;
	}
}

class PostPerform  extends PostPequestPerForm {

	public void perform(HttpURLConnection httpUrlConnection, String data) throws Exception{
		setHttpURLConnection( httpUrlConnection );
		write( data.getBytes() );

	}
}


class PostBodyPerform extends PostPequestPerForm {
	
	public void perform(HttpURLConnection httpUrlConnection, String data) throws Exception {
		setHttpURLConnection( httpUrlConnection );
		
		write( piecewise , 0 );
		write(data.getBytes());	
	}
}

 很简单，支持post，get请求，支持流传输，支持对象操作。

目的就是为了，没有依赖。给调用方使用。