java HttpServer构建http服务器

package com.tdt.server.httpserver;

import java.io.IOException;
import java.net.InetSocketAddress;

import com.sun.net.httpserver.HttpServer;
import com.sun.net.httpserver.spi.HttpServerProvider;
/**
 * 
 * @author chuer
 * @Description: 服务器启动类
 * @date 2014年11月12日 下午3:53:38 
 * @version V1.0
 */
public class MyHttpServer {
    //启动服务，监听来自客户端的请求
	public static void start() throws IOException {
		Context.load();
		
		HttpServerProvider provider = HttpServerProvider.provider();
		HttpServer httpserver =provider.createHttpServer(new InetSocketAddress(8080), 100);//监听端口8080,能同时接 受100个请求
		httpserver.createContext(Context.contextPath, new MyHttpHandler()); 
		httpserver.setExecutor(null);
		httpserver.start();
		System.out.println("server started");
	}
	
	
	public static void main(String[] args) throws IOException {
		start();
	}
}

package com.tdt.server.httpserver;

import java.io.IOException;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.tdt.server.httpserver.core.Handler;
import com.tdt.server.httpserver.core.impl.HttpRequest;
import com.tdt.server.httpserver.core.impl.HttpResponse;

/**
 * @author chuer
 * @Description: 内部消息处理类
 * @date 2014年11月12日 下午3:53:44 
 * @version V1.0
 */
public class MyHttpHandler implements HttpHandler {

	public void handle(HttpExchange httpExchange) throws IOException {
		HttpRequest request = new HttpRequest(httpExchange);
		HttpResponse response = new HttpResponse(httpExchange);
		Handler handler = Context.getHandler(request.getReuestURI().getPath());
		handler.service(request, response);

	}
}

package com.tdt.server.httpserver;

import java.util.HashMap;
import java.util.Map;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

import com.tdt.server.httpserver.core.impl.HttpHandler;
import com.tdt.server.httpserver.utils.XmlUtils;
/**
 * 
 * @author chuer
 * @Description: 上下文 
 * @date 2014年11月12日 下午3:53:48 
 * @version V1.0
 */
public class Context {
	private static Map contextMap = new HashMap();
	public static String contextPath = "";
	public static void load(){
		try{
			Document doc = XmlUtils.load(Context.class.getResource("/").getPath()+"context.xml");
			Element root = doc.getDocumentElement();
			
			contextPath = XmlUtils.getAttribute(root,"context");
			Element[] handlers = XmlUtils.getChildrenByName(root, "handler");
			for(Element ele : handlers){
				String handle_class = XmlUtils.getChildText(ele, "handler-class");
				String url_pattern = XmlUtils.getChildText(ele, "url-pattern");
				
				Class cls = Class.forName(handle_class);
				Object newInstance = cls.newInstance();
				if(newInstance instanceof HttpHandler){
					contextMap.put(contextPath+url_pattern, (HttpHandler)newInstance);
				}
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	
	/**
	 * 
	 * @param key
	 * @return
	 */
	public static HttpHandler getHandler(String key){
		return contextMap.get(key);
	}
	
}

	
		com.tdt.server.httpserver.sample.FirstHandler
		/firstHandler
	
	
	

package com.tdt.server.httpserver.core;
/**
 * 
 * @author chuer
 * @Description: 相应类接口
 * @date 2014年11月12日 下午3:54:02 
 * @version V1.0
 */
public interface Response {
	
	public void write(String result);
	
}

package com.tdt.server.httpserver.core;

import java.net.URI;
/**
 * @author chuer
 * @Description: 请求接口
 * @date 2014年11月12日 下午3:54:58 
 * @version V1.0
 */
public interface Request {
	public final static String GET = "GET";
	public final static String POST = "POST";

	public String getParamter(String param);

	public String getMethod();

	public URI getReuestURI();

	public void initRequestHeader();
	
	public void initRequestParam();

	public void initRequestBody();

	public String getRequestBody();
}

package com.tdt.server.httpserver.core;
/**
 * @author chuer
 * @Description: 消息处理接口
 * @date 2014年11月12日 下午3:55:10 
 * @version V1.0
 */
public interface Handler {
	public void service(Request request, Response response);

	public void doGet(Request request, Response response);

	public void doPost(Request request, Response response);

}

package com.tdt.server.httpserver.core.impl;

import com.tdt.server.httpserver.core.Handler;
import com.tdt.server.httpserver.core.Request;
import com.tdt.server.httpserver.core.Response;

public abstract class HttpHandler implements Handler {

	@Override
	public void service(Request request, Response response) {
		request.initRequestHeader();
		request.initRequestParam();
		if(request.getMethod().equals(Request.GET)){
			doGet(request,response);
		}else if(request.getMethod().equals(Request.POST)){
			request.initRequestBody();
			doPost(request,response);
		}
	}

	@Override
	public abstract void doGet(Request request, Response response);

	@Override
	public abstract void doPost(Request request, Response response);

	
}

package com.tdt.server.httpserver.core.impl;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URI;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.sun.net.httpserver.HttpExchange;
import com.tdt.server.httpserver.core.Request;

public class HttpRequest implements Request {
	private HttpExchange httpExchange;
	private Map paramMap = new HashMap();
	private Map> headMap = new HashMap>();
	private String requestBody = "";

	public HttpRequest(HttpExchange httpExchange) {
		this.httpExchange = httpExchange;
	}

	@Override
	public String getParamter(String param) {
		return paramMap.get(param);
	}

	@Override
	public String getMethod() {
		return httpExchange.getRequestMethod().trim().toUpperCase();
	}

	@Override
	public URI getReuestURI() {
		return httpExchange.getRequestURI();
	}

	@Override
	public void initRequestParam() {
		String query = getReuestURI().getQuery();
		String [] arrayStr = query.split("&");
		for(String str : arrayStr){
			paramMap.put(str.split("=")[0], str.split("=")[1]);
		}
		
	}

	@Override
	public void initRequestHeader() {
		for(String s : httpExchange.getRequestHeaders().keySet()){
			headMap.put(s, httpExchange.getRequestHeaders().get(s));
		}
	}

	@Override
	public void initRequestBody() {
		InputStream in = httpExchange.getRequestBody(); // 获得输入流
		BufferedReader reader = new BufferedReader(new InputStreamReader(in));
		String temp = null;
		try {
			while ((temp = reader.readLine()) != null) {
				requestBody += temp;
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@Override
	public String getRequestBody() {
		return requestBody;
	}
	
	public static void main(String[] args) {
		
		String query = "aaa=aaa&bbb=bbb";
		String [] a = query.split("&");
		for(String s : a){
			System.out.print(s.split("=")[0]+"=");
			System.out.println(s.split("=")[1]);
			
		}
		
		
		
	}

}

package com.tdt.server.httpserver.core.impl;

import java.io.IOException;
import java.io.OutputStream;

import com.sun.net.httpserver.HttpExchange;
import com.tdt.server.httpserver.core.Response;

public class HttpResponse implements Response{
	private HttpExchange httpExchange;
	public HttpResponse(HttpExchange httpExchange){
		this.httpExchange = httpExchange;
	}
	
	
	@Override
	public void write(String result) {
		try {
			httpExchange.sendResponseHeaders(200, result.length());// 设置响应头属性及响应信息的长度
			OutputStream out = httpExchange.getResponseBody(); // 获得输出流
			out.write(result.getBytes());
			out.flush();
			httpExchange.close();
		} catch (IOException e) {
			e.printStackTrace();
		} 
		
	}

	
}

package com.tdt.server.httpserver.sample;

import com.tdt.server.httpserver.core.Request;
import com.tdt.server.httpserver.core.Response;
import com.tdt.server.httpserver.core.impl.HttpHandler;

public class FirstHandler extends HttpHandler{

	@Override
	public void doGet(Request request, Response response) {
		System.out.println("doGet");
		
		System.out.println(request.getParamter("aaa"));
		System.out.println(request.getParamter("bbb"));
		
		response.write("helloWorld.....");
	}

	
	@Override
	public void doPost(Request request, Response response) {
		System.out.println("doPost");
		System.out.println(request.getRequestBody());
		
		response.write("helloWorld.....");
	}

	
}

启动服务器类，浏览器输出http://localhost:8080/myApp/firstHandler?aaa=aaa&bbb=bbb

显示hello world....

 

XmlUtils类是用来解析xml文件的，没有放到这里.

 

重定向代码实例：

Headers responseHeaders = httpExchange.getResponseHeaders();
			responseHeaders.add("location", "http://www.baidu.com");
			httpExchange.sendResponseHeaders(302, 0);
			httpExchange.close();
			OutputStream out = httpExchange.getResponseBody(); 
			out.write(result.getBytes());
			out.flush();
 
  
 
 
  
 
 
  
工具类：
 
  
package com.tdt.server.httpserver.utils;

import java.io.CharArrayReader;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;

/**
 * 

 * Title: XmlUtils
 * 
 * 

 * Description: XML文件处理工具
 * 
 * 

 * Copyright: Copyright (c) 2008
 * 
 * 

 * Company: Ocean Blue Mobile Tech.
 * 
 * 
 * @author chur
 * @version 1.0
 */
public class XmlUtils {
	public static final String BR = System.getProperty("line.separator");

	/**
	 * load a xml file from OS file system and interpret it into a Document no
	 * charset limited
	 * 
	 * @param xmlfile
	 *            String 文件路径名
	 * @return Document
	 * @throws Exception
	 */
	public static Document load(String xmlfile) throws Exception {
		javax.xml.parsers.DocumentBuilderFactory factory =

		javax.xml.parsers.DocumentBuilderFactory.newInstance();
		factory.setIgnoringComments(false);
		factory.setIgnoringElementContentWhitespace(false);
		factory.setValidating(false);
		factory.setCoalescing(false);
		DocumentBuilder builder = factory.newDocumentBuilder();

		return builder.parse(xmlfile);
	}

	/**
	 * load a xml file from OS file system and interpret it into a Document no
	 * charset limited
	 * 
	 * @param xmlfile
	 *            String 文件路径名
	 * @return Document
	 * @throws Exception
	 */
	public static Document load(File xmlfile) throws Exception {
		javax.xml.parsers.DocumentBuilderFactory factory =

		javax.xml.parsers.DocumentBuilderFactory.newInstance();
		factory.setIgnoringComments(false);
		factory.setIgnoringElementContentWhitespace(false);
		factory.setValidating(false);
		factory.setCoalescing(false);
		DocumentBuilder builder = factory.newDocumentBuilder();

		return builder.parse(xmlfile);
	}

	/**
	 * 取得文件名
	 * 
	 * @param filePath
	 *            String
	 * @return String
	 */
	public static String getFileName(String filePath) {
		Pattern p = Pattern.compile("[^\\" + File.separator + "]+.xml");
		Matcher m = p.matcher(filePath);
		if (m.find()) {
			return m.group().substring(0, m.group().length() - 4);
		}
		return "";
	}

	/**
	 * 验证文件名是否合法
	 * 
	 * @param filePath
	 *            String
	 * @return String
	 */
	public static boolean checkValidity(String filePath) {
		String[] array = filePath.split(".");
		if (array[array.length - 1].equals("xml")) {
			return true;
		} else {
			return false;
		}
	}

	public static boolean isXml(String file) {
		if (file.toLowerCase().endsWith("xml")) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * load a String without the title tag of xml into a Document
	 * 
	 * @param domContent
	 *            String 没有head的XML内容
	 * @return Document
	 * @throws Exception
	 */
	public static Document loadStringWithoutTitle(String domContent)
			throws Exception {
		domContent = "" + BR
				+ domContent;
		return XmlUtils.loadString(domContent);
	}

	/**
	 * load a String with a title tag of xml into a Document
	 * 
	 * @param domContent
	 *            String XML内容
	 * @return Document
	 * @throws Exception
	 */
	public static Document loadString(String domContent) throws Exception {
		javax.xml.parsers.DocumentBuilderFactory factory = javax.xml.parsers.DocumentBuilderFactory.newInstance();
		factory.setIgnoringComments(false);
		factory.setIgnoringElementContentWhitespace(false);
		factory.setValidating(false);
		factory.setCoalescing(false);
		DocumentBuilder builder = factory.newDocumentBuilder();

		char[] chars = new char[domContent.length()];
		domContent.getChars(0, domContent.length(), chars, 0);
		InputSource is = new InputSource(new CharArrayReader(chars));
		return (builder.parse(is));
	}

	/**
	 * 根据完整路径得到整个文档的一个子节点的文字
	 * 
	 * @param doc
	 *            Document 文档
	 * @param fullname
	 *            String 子节点完整路径
	 * @return String
	 */
	public static String getTextByFullName(Document doc, String fullname) {
		String path[] = StringUtils.toStringArray(fullname, ".");
		Element e = doc.getDocumentElement();
		for (int i = 1; i < path.length; i++) {
			e = getChildByName(e, path[i]);
		}
		return getText(e);
	}

	/**
	 * 根据完整路径得到某个节点的一个子节点的文字
	 * 
	 * @param parent
	 *            Element 父节点
	 * @param fullname
	 *            String 子节点完整路径
	 * @return String
	 */
	public static String getTextByFullName(Element parent, String fullname) {
		String path[] = StringUtils.toStringArray(fullname, ".");
		Element e = parent;
		for (int i = 0; i < path.length; i++) {
			e = getChildByName(e, path[i]);
		}
		return getText(e);
	}

	/**
	 * 根据一个document对象获取某节点下的property的内容
	 * @param parent
	 *            Element
	 * @param name
	 *            String
	 * @return String
	 */
	public static String getChildText(Element parent, String name) {
		Element e = getChildByName(parent, name);
		if (e == null) {
			return "";
		}
		return getText(e);
	}

	/**
	 * 根据名称得到一个父节点下所有的子节点
	 * 
	 * @param e
	 *            Element
	 * @param name
	 *            String
	 * @return Element[]
	 */
	public static Element[] getChildrenByName(Element e, String name) {
		NodeList nl = e.getChildNodes();
		int max = nl.getLength();
		LinkedList list = new LinkedList();
		for (int i = 0; i < max; i++) {
			Node n = nl.item(i);
			if (n.getNodeType() == Node.ELEMENT_NODE
					&& n.getNodeName().equals(name)) {
				list.add(n);
			}
		}
		return list.toArray(new Element[list.size()]);
	}

	/**
	 * 根据名字查找某个节点下的符合该名字的节点
	 * 
	 * @param e
	 *            Element 父节点
	 * @param name
	 *            String 子节点名称
	 * @return Element
	 */
	public static Element getChildByName(Element e, String name) {
		Element[] list = getChildrenByName(e, name);
		if (list.length == 0) {
			return null;
		}
		if (list.length > 1) {
			throw new IllegalStateException("Too many (" + list.length + ") '"
					+ name + "' elements found!");
		}
		return list[0];
	}

	/**
	 * 得到一个节点的文字
	 * 
	 * @param e
	 *            Element
	 * @return String
	 */
	public static String getText(Element e) {
		NodeList nl = e.getChildNodes();
		int max = nl.getLength();
		for (int i = 0; i < max; i++) {
			Node n = nl.item(i);
			if (n.getNodeType() == Node.TEXT_NODE) {
				return n.getNodeValue();
			}
		}
		return "";
	}

	public static String getAttribute(Element e, String name) {
		return e.getAttribute(name);
	}

	/**
	 * get Int value
	 * 
	 * @param player
	 * @param name
	 * @return
	 */
	public static int getIntValue(Element e) {
		return Integer.valueOf(getText(e));
	}

	/**
	 * get byte value
	 * 
	 * @param player
	 * @param name
	 * @return
	 */
	public static byte getByteValue(Element e) {
		return Byte.valueOf(getText(e));
	}

	/**
	 * 获取Properties格式的xml数据
	 * 
	 * @param root
	 * @return
	 */
	public static Map getProperties(Element root) {
		Map map = new HashMap();
		Element[] list = getChildrenByName(root, "property");
		for (int i = 0; i < list.length; i++) {
			String name = list[i].getAttribute("name");
			String type = list[i].getAttribute("type");
			String valueString = getText(list[i]);
			try {
				Class cls = Class.forName(type);
				Constructor con = cls.getConstructor(new Class[] { String.class

				});
				Object value = con.newInstance(new Object[] { valueString

				});
				map.put(name, value);
			} catch (Exception e) {
				System.err.println("Unable to parse property '" + name +

				"'='" + valueString + "': " + e.toString());
			}
		}
		return map;
	}

	/**
	 * 将dom中的内容存入xmlfile所指的文件中。 dom==null时，xml文件也是空的。
	 * 
	 * @param xmlfile
	 *            java.lang.String 保存的文件名
	 * @param doc
	 *            ort.w3c.dom.Document 需要保存的DOM
	 * @throws Exception
	 *             任何异常
	 */
	public static void save(String xmlfile, Document doc) throws Exception {
		// 首先创建一个DOMSource对象,该构造函数的参数可以是一个Document对象
		// doc代表更改后的DOM Tree。
		DOMSource doms = new DOMSource(doc);

		// 创建一个File对象,代表DOM Tree所包含的数据的输出介质,这是一个XML文件。
		File f = new File(xmlfile);
		File dir = f.getParentFile();
		dir.mkdirs();
		// 创建一个StreamResult对象,该构造函数的参数可以取为File对象。
		StreamResult sr = new StreamResult(f);

		// 下面调用JAXP中的XSLT引擎来实现输出DOM Tree中的数据到XML文件中的功能。
		// XSLT引擎的输入为DOMSource对象,输出为StreamResut对象。
		try {
			// 首先创建一个TransformerFactory对象,再由此创建Transformer对象。Transformer
			// 类相当于一个XSLT引擎。通常我们使用它来处理XSL文件,但是在这里我们使
			// 用它来输出XML文档。
			TransformerFactory tf = TransformerFactory.newInstance();
			Transformer t = tf.newTransformer();
			// 设置新的输出属性:输出字符编码为UTF-8,XSLT引擎所输出
			// 的XML文档如果包含了中文字符,可以正常显示,不会出现所谓的"汉字问题"。
			// 请留意OutputKeys类的字符串常数OutputKeys.ENCODING。
			Properties properties = t.getOutputProperties();
			properties.setProperty(OutputKeys.ENCODING, "UTF-8");
			properties.setProperty(OutputKeys.INDENT, "yes");
			// 更新XSLT引擎的输出属性。
			t.setOutputProperties(properties);
			// 关键的一步, 调用Transformer对象 (XSLT引擎)的transform()方法,该方法的第一
			// 个参数是DOMSource对象,第二个参数是StreamResult对象。
			t.transform(doms, sr);

		} catch (TransformerConfigurationException tce) {
			tce.printStackTrace();
		} catch (TransformerException te) {
			te.printStackTrace();
		}

	}

	/**
	 * create a blank Document.
	 * 
	 * @param rootElementName
	 *            String
	 * @return Document
	 * @throws Exception
	 */
	public static Document blankDocument(String rootElementName)
			throws Exception {
		javax.xml.parsers.DocumentBuilderFactory factory =

		javax.xml.parsers.DocumentBuilderFactory.newInstance();
		factory.setIgnoringComments(false);
		factory.setIgnoringElementContentWhitespace(false);
		factory.setValidating(false);
		factory.setCoalescing(false);
		DocumentBuilder builder = factory.newDocumentBuilder();
		Document doc = builder.newDocument();
		Element root = doc.createElement(rootElementName);
		doc.appendChild(root);
		return doc;
	}

	public static Element createChild(Document doc, Element root, String name) {
		Element elem = doc.createElement(name);
		root.appendChild(elem);
		return elem;
	}

	public static void createChildText(Document doc, Element elem, String name,
			String value) {
		Element child = doc.createElement(name);
		child.appendChild(doc.createTextNode(value == null ? "" : value));
		elem.appendChild(child);
	}

	/**
	 * 创建一个带注释的子节点
	 * 
	 * @param doc
	 *            Document
	 * @param elem
	 *            Element
	 * @param name
	 *            String
	 * @param value
	 *            String
	 * @param comment
	 *            String
	 */
	public static void createChildTextWithComment(Document doc, Element elem,
			String name, String value, String comment) {
		Element child = doc.createElement(name);
		child.appendChild(doc.createTextNode(value == null ? "" : value));
		Comment c = doc.createComment(comment);
		elem.appendChild(c);
		elem.appendChild(child);

	}

	/**
	 * 创建一段注释
	 * 
	 * @param doc
	 *            Document
	 * @param comment
	 *            String
	 */
	public static void createComment(Document doc, String comment) {
		Comment c = doc.createComment(comment);
		doc.getDocumentElement().appendChild(c);
	}

	public static void createOptionalChildText(Document doc, Element elem,
			String name, String value) {
		if (value == null || value.length() == 0) {
			return;
		}
		Element child = doc.createElement(name);
		child.appendChild(doc.createTextNode(value));
		elem.appendChild(child);
	}

	public static void applyProperties(Object o, Element root) {
		Map map = getProperties(root);
		Iterator it = map.keySet().iterator();
		Field[] fields = o.getClass().getFields();
		Method[] methods = o.getClass().getMethods();
		while (it.hasNext()) {
			String name = (String) it.next();
			Object value = map.get(name);
			try {
				for (int i = 0; i < fields.length; i++) {
					if (fields[i].getName().equalsIgnoreCase(name) && isTypeMatch(fields[i].getType(),
						value.getClass())) {
						fields[i].set(o, value);
						System.err.println("Set field " + fields

						[i].getName() + "=" + value);
						break;
					}
				}
				for (int i = 0; i < methods.length; i++) {
					if (methods[i].getName().equalsIgnoreCase("set" + name) && methods[i].getParameterTypes

					().length == 1 && isTypeMatch(methods

					[i].getParameterTypes()[0], value.getClass())) {
						methods[i].invoke(o, new Object[] { value

						});
						System.err.println("Set method " + methods

						[i].getName() + "=" + value);
						break;
					}
				}
			} catch (Exception e) {
				System.err.println("Unable to apply property '" + name + "': " + e.toString());
			}
		}
	}

	private static boolean isTypeMatch(Class one, Class two) {
		if (one.equals(two)) {
			return true;
		}
		if (one.isPrimitive()) {
			if (one.getName().equals("int") && two.getName().equals("java.lang.Integer")) {
				return true;
			}
			if (one.getName().equals("long") && two.getName().equals("java.lang.Long")) {
				return true;
			}
			if (one.getName().equals("float") && two.getName().equals("java.lang.Float")) {
				return true;
			}
			if (one.getName().equals("double") && two.getName().equals("java.lang.Double")) {
				return true;
			}
			if (one.getName().equals("char") && two.getName().equals("java.lang.Character")) {
				return true;
			}
			if (one.getName().equals("byte") && two.getName().equals("java.lang.Byte")) {
				return true;
			}
			if (one.getName().equals("short") && two.getName().equals("java.lang.Short")) {
				return true;
			}
			if (one.getName().equals("boolean") && two.getName().equals("java.lang.Boolean")) {
				return true;
			}
		}
		return false;
	}
}
 
  

  
 
  
package com.tdt.server.httpserver.utils;

import java.util.LinkedList;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringUtils {
	/**
	 * Converts a line of text into an array of lower case words. Words are
	 * delimited by the following characters: , .\r\n:/\+
	 * 

	 * In the future, this method should be changed to use a
	 * BreakIterator.wordInstance(). That class offers much more fexibility.
	 * 
	 * @param text
	 *            a String of text to convert into an array of words
	 * @return text broken up into an array of words.
	 */
	public static final String[] toLowerCaseWordArray(String text) {
		if (text == null || text.length() == 0) {
			return new String[0];
		}
		StringTokenizer tokens = new StringTokenizer(text, " ,\r\n.:/\\+");
		String[] words = new String[tokens.countTokens()];
		for (int i = 0; i < words.length; i++) {
			words[i] = tokens.nextToken().toLowerCase();
		}
		return words;
	}

	/**
	 * Converts a line of text into an array of lower case words. Words are
	 * delimited by the following characters: , .\r\n:/\+
	 * 

	 * In the future, this method should be changed to use a
	 * BreakIterator.wordInstance(). That class offers much more fexibility.
	 * 
	 * @param text
	 *            a String of text to convert into an array of words
	 * @return text broken up into an array of words.
	 */
	public static final String[] toStringArray(String text) {
		if (text == null || text.length() == 0) {
			return new String[0];
		}
		StringTokenizer tokens = new StringTokenizer(text, ",\r\n/\\");
		String[] words = new String[tokens.countTokens()];
		for (int i = 0; i < words.length; i++) {
			words[i] = tokens.nextToken();
		}
		return words;
	}

	/**
	 * * Converts a line of text into an array of lower case words. Words are
	 * delimited by the following characters: , .\r\n:/\+
	 * 

	 * In the future, this method should be changed to use a
	 * BreakIterator.wordInstance(). That class offers much more fexibility.
	 * 
	 * @param text
	 *            a String of text to convert into an array of words
	 * @param token
	 *            String
	 * @return String[]broken up into an array of words.
	 */
	public static final String[] toStringArray(String text, String token) {
		if (text == null || text.length() == 0) {
			return new String[0];
		}
		StringTokenizer tokens = new StringTokenizer(text, token);
		String[] words = new String[tokens.countTokens()];
		for (int i = 0; i < words.length; i++) {
			words[i] = tokens.nextToken();
		}
		return words;
	}

	/**
	 * 
	 * @param source
	 * @return
	 */
	public static String[] splitOnWhitespace(String source) {
		int pos = -1;
		LinkedList list = new LinkedList();
		int max = source.length();
		for (int i = 0; i < max; i++) {
			char c = source.charAt(i);
			if (Character.isWhitespace(c)) {
				if (i - pos > 1) {
					list.add(source.substring(pos + 1, i));
				}
				pos = i;
			}
		}
		return list.toArray(new String[list.size()]);
	}

	/**
	 * Replayer str
	 * 
	 * @param str
	 * @param key
	 * @param replacement
	 * @return
	 */
	public static final String replaceAll(String str, String key,
			String replacement) {
		if (str != null && key != null && replacement != null
				&& !str.equals("") && !key.equals("")) {
			StringBuilder strbuf = new StringBuilder();
			int begin = 0;
			int slen = str.length();
			int npos = 0;
			int klen = key.length();
			for (; begin < slen && (npos = str.indexOf(key, begin)) >= begin; begin = npos
					+ klen) {
				strbuf.append(str.substring(begin, npos)).append(replacement);
			}

			if (begin == 0) {
				return str;
			}
			if (begin < slen) {
				strbuf.append(str.substring(begin));
			}
			return strbuf.toString();
		} else {
			return str;
		}
	}
	
	
	public static String UnicodeToString(String str) {    
		Pattern pattern = Pattern.compile("(\\\\u(\\p{XDigit}{4}))");    
		Matcher matcher = pattern.matcher(str);    
		char ch;   
		boolean hasU = false;
		while (matcher.find()) {   
			hasU = true;
			ch = (char) Integer.parseInt(matcher.group(2), 16);     
			str = str.replace(matcher.group(1), ch + "");    
		} 
		String s = str;
		try{
			if(!hasU){
				int i = 0;
				String rstr = "";
				while(i+4<=str.length()){
					ch = (char) Integer.parseInt(str.substring(i,i=i+4), 16); 
					rstr = rstr+ch;
				}
				str = rstr;
			}
		}catch(Exception ex){
			str = s;
			ex.printStackTrace();
		}
		return str;   
	} 
    /** 空字符串。 */
    public static final String EMPTY_STRING = "";

    /**
     * 比较两个字符串（大小写敏感）。
     * 
     * StringUtil.equals(null, null)   = true
     * StringUtil.equals(null, "abc")  = false
     * StringUtil.equals("abc", null)  = false
     * StringUtil.equals("abc", "abc") = true
     * StringUtil.equals("abc", "ABC") = false
     * 
     *
     * @param str1 要比较的字符串1
     * @param str2 要比较的字符串2
     *
     * @return 如果两个字符串相同，或者都是null，则返回true
     */
    public static boolean equals(String str1, String str2) {
        if (str1 == null) {
            return str2 == null;
        }

        return str1.equals(str2);
    }

    /**
     * 比较两个字符串（大小写不敏感）。
     * 
     * StringUtil.equalsIgnoreCase(null, null)   = true
     * StringUtil.equalsIgnoreCase(null, "abc")  = false
     * StringUtil.equalsIgnoreCase("abc", null)  = false
     * StringUtil.equalsIgnoreCase("abc", "abc") = true
     * StringUtil.equalsIgnoreCase("abc", "ABC") = true
     * 
     *
     * @param str1 要比较的字符串1
     * @param str2 要比较的字符串2
     *
     * @return 如果两个字符串相同，或者都是null，则返回true
     */
    public static boolean equalsIgnoreCase(String str1, String str2) {
        if (str1 == null) {
            return str2 == null;
        }

        return str1.equalsIgnoreCase(str2);
    }

    /**
     * 检查字符串是否是空白：null、空字符串""或只有空白字符。
     * 
     * StringUtil.isBlank(null)      = true
     * StringUtil.isBlank("")        = true
     * StringUtil.isBlank(" ")       = true
     * StringUtil.isBlank("bob")     = false
     * StringUtil.isBlank("  bob  ") = false
     * 
     *
     * @param str 要检查的字符串
     *
     * @return 如果为空白, 则返回true
     */
    public static boolean isBlank(String str) {
        int length;

        if ((str == null) || ((length = str.length()) == 0)) {
            return true;
        }

        for (int i = 0; i < length; i++) {
            if (!Character.isWhitespace(str.charAt(i))) {
                return false;
            }
        }

        return true;
    }

    /**
     * 检查字符串是否不是空白：null、空字符串""或只有空白字符。
     * 
     * StringUtil.isBlank(null)      = false
     * StringUtil.isBlank("")        = false
     * StringUtil.isBlank(" ")       = false
     * StringUtil.isBlank("bob")     = true
     * StringUtil.isBlank("  bob  ") = true
     * 
     *
     * @param str 要检查的字符串
     *
     * @return 如果为空白, 则返回true
     */
    public static boolean isNotBlank(String str) {
        int length;

        if ((str == null) || ((length = str.length()) == 0)) {
            return false;
        }

        for (int i = 0; i < length; i++) {
            if (!Character.isWhitespace(str.charAt(i))) {
                return true;
            }
        }

        return false;
    }

    /**
     * 检查字符串是否为null或空字符串""。
     * 
     * StringUtil.isEmpty(null)      = true
     * StringUtil.isEmpty("")        = true
     * StringUtil.isEmpty(" ")       = false
     * StringUtil.isEmpty("bob")     = false
     * StringUtil.isEmpty("  bob  ") = false
     * 
     *
     * @param str 要检查的字符串
     *
     * @return 如果为空, 则返回true
     */
    public static boolean isEmpty(String str) {
        return ((str == null) || (str.length() == 0));
    }

    /**
     * 检查字符串是否不是null和空字符串""。
     * 
     * StringUtil.isEmpty(null)      = false
     * StringUtil.isEmpty("")        = false
     * StringUtil.isEmpty(" ")       = true
     * StringUtil.isEmpty("bob")     = true
     * StringUtil.isEmpty("  bob  ") = true
     * 
     *
     * @param str 要检查的字符串
     *
     * @return 如果不为空, 则返回true
     */
    public static boolean isNotEmpty(String str) {
        return ((str != null) && (str.length() > 0));
    }

    /**
     * 在字符串中查找指定字符串，并返回第一个匹配的索引值。如果字符串为null或未找到，则返回-1。
     * 
     * StringUtil.indexOf(null, *)          = -1
     * StringUtil.indexOf(*, null)          = -1
     * StringUtil.indexOf("", "")           = 0
     * StringUtil.indexOf("aabaabaa", "a")  = 0
     * StringUtil.indexOf("aabaabaa", "b")  = 2
     * StringUtil.indexOf("aabaabaa", "ab") = 1
     * StringUtil.indexOf("aabaabaa", "")   = 0
     * 
     *
     * @param str 要扫描的字符串
     * @param searchStr 要查找的字符串
     *
     * @return 第一个匹配的索引值。如果字符串为null或未找到，则返回-1
     */
    public static int indexOf(String str, String searchStr) {
        if ((str == null) || (searchStr == null)) {
            return -1;
        }

        return str.indexOf(searchStr);
    }

    /**
     * 在字符串中查找指定字符串，并返回第一个匹配的索引值。如果字符串为null或未找到，则返回-1。
     * 
     * StringUtil.indexOf(null, *, *)          = -1
     * StringUtil.indexOf(*, null, *)          = -1
     * StringUtil.indexOf("", "", 0)           = 0
     * StringUtil.indexOf("aabaabaa", "a", 0)  = 0
     * StringUtil.indexOf("aabaabaa", "b", 0)  = 2
     * StringUtil.indexOf("aabaabaa", "ab", 0) = 1
     * StringUtil.indexOf("aabaabaa", "b", 3)  = 5
     * StringUtil.indexOf("aabaabaa", "b", 9)  = -1
     * StringUtil.indexOf("aabaabaa", "b", -1) = 2
     * StringUtil.indexOf("aabaabaa", "", 2)   = 2
     * StringUtil.indexOf("abc", "", 9)        = 3
     * 
     *
     * @param str 要扫描的字符串
     * @param searchStr 要查找的字符串
     * @param startPos 开始搜索的索引值，如果小于0，则看作0
     *
     * @return 第一个匹配的索引值。如果字符串为null或未找到，则返回-1
     */
    public static int indexOf(String str, String searchStr, int startPos) {
        if ((str == null) || (searchStr == null)) {
            return -1;
        }

        // JDK1.3及以下版本的bug：不能正确处理下面的情况
        if ((searchStr.length() == 0) && (startPos >= str.length())) {
            return str.length();
        }

        return str.indexOf(searchStr, startPos);
    }

    /**
     * 取指定字符串的子串。
     * 
     * 

     * 负的索引代表从尾部开始计算。如果字符串为null，则返回null。
     * 
     * StringUtil.substring(null, *, *)    = null
     * StringUtil.substring("", * ,  *)    = "";
     * StringUtil.substring("abc", 0, 2)   = "ab"
     * StringUtil.substring("abc", 2, 0)   = ""
     * StringUtil.substring("abc", 2, 4)   = "c"
     * StringUtil.substring("abc", 4, 6)   = ""
     * StringUtil.substring("abc", 2, 2)   = ""
     * StringUtil.substring("abc", -2, -1) = "b"
     * StringUtil.substring("abc", -4, 2)  = "ab"
     * 
     * 

     *
     * @param str 字符串
     * @param start 起始索引，如果为负数，表示从尾部计算
     * @param end 结束索引（不含），如果为负数，表示从尾部计算
     *
     * @return 子串，如果原始串为null，则返回null
     */
    public static String substring(String str, int start, int end) {
        if (str == null) {
            return null;
        }

        if (end < 0) {
            end = str.length() + end;
        }

        if (start < 0) {
            start = str.length() + start;
        }

        if (end > str.length()) {
            end = str.length();
        }

        if (start > end) {
            return EMPTY_STRING;
        }

        if (start < 0) {
            start = 0;
        }

        if (end < 0) {
            end = 0;
        }

        return str.substring(start, end);
    }

    /**
     * 检查字符串中是否包含指定的字符串。如果字符串为null，将返回false。
     * 
     * StringUtil.contains(null, *)     = false
     * StringUtil.contains(*, null)     = false
     * StringUtil.contains("", "")      = true
     * StringUtil.contains("abc", "")   = true
     * StringUtil.contains("abc", "a")  = true
     * StringUtil.contains("abc", "z")  = false
     * 
     *
     * @param str 要扫描的字符串
     * @param searchStr 要查找的字符串
     *
     * @return 如果找到，则返回true
     */
    public static boolean contains(String str, String searchStr) {
        if ((str == null) || (searchStr == null)) {
            return false;
        }

        return str.indexOf(searchStr) >= 0;
    }

    /**
     * 
Checks if the String contains only unicode digits.
     * A decimal point is not a unicode digit and returns false.
     *
     * 
null will return false.
     * An empty String ("") will return true.
     *
     * 
     * StringUtils.isNumeric(null)   = false
     * StringUtils.isNumeric("")     = true
     * StringUtils.isNumeric("  ")   = false
     * StringUtils.isNumeric("123")  = true
     * StringUtils.isNumeric("12 3") = false
     * StringUtils.isNumeric("ab2c") = false
     * StringUtils.isNumeric("12-3") = false
     * StringUtils.isNumeric("12.3") = false
     * 
     *
     * @param str  the String to check, may be null
     * @return true if only contains digits, and is non-null
     */
    public static boolean isNumeric(String str) {
        if (str == null) {
            return false;
        }
        int sz = str.length();
        for (int i = 0; i < sz; i++) {
            if (Character.isDigit(str.charAt(i)) == false) {
                return false;
            }
        }
        return true;
    }

	/**
	 * 字符串拼接
	 * @param object
	 * @return
	 */
	public static String assemble(char sep,Object... object){
		if(object == null)return null;
		StringBuilder sb = new StringBuilder();
		for(Object obj:object){
			if(obj == null)obj="";
			sb.append(obj.toString()).append(sep);
		}
		String str = "";
		if(sb.length()>0){
			str = sb.substring(0, sb.length()-1);
		}
		return str;
	}

	// 6-16个字母和数字组成
	private static String regex = "^[A-Za-z0-9]$";
	/**
	 * 检测字符串是否符合规则（6-16个字母和数字组成，大小写不敏感）
	 * @param user
	 * @return
	 */
	public static boolean checkStringLegal(String user) {
		boolean isMatch = true;
		char[] userChars = user.toCharArray();
		for(char c : userChars){
			isMatch = String.valueOf(c).matches(regex);
			if(!isMatch){
				break;
			}
		}
		return isMatch;
	}
	

	public static String getString(String input) {
		return getString(input, true, "");
	}

	public static String getString(String input, boolean btrim, String dval) {
		if (input == null)
			return dval;
		try {
			if (btrim)
				return trim(input);
			else
				return input;
		} catch (Exception e) {
			return "";
		}
	}

	public static String Trim(String str) {
		return trim(str);
	}

	public static String[] Trim(String[] s) {
		return trim(s);
	}

	public static String trim(String str) {
		if (str == null)
			return "";
		else
			return str.trim();
	}

	public static String[] trim(String[] s) {
		if (s == null || s.length <= 0)
			return s;
		for (int i = 0; i < s.length; i++)
			s[i] = trim(s[i]);
		return s;
	}

	public static int getInt(String input, boolean btrim, int dval) {
		if (input == null)
			return dval;
		int val;
		try {
			String str = new String(input);
			if (btrim)
				str = trim(str);
			val = Integer.parseInt(str);
		} catch (Exception e) {
			val = dval;
		}
		return val;
	}
	
	public static int[] getInts(String input) {
		return getInts(input, ",");
	}

	public static int[] getInts(String input, String split) {
		if (input == null) {
			return null;
		}
		
		String[] ss = input.split(split);
		int[] ii = new int[ss.length];
		for (int i=0;i