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);
    }

}

 

xml version="1.0" encoding="UTF-8"?>
<httpServer context="/myApp">
    <handler>
        <handler-class>com.tdt.server.httpserver.sample.FirstHandlerhandler-class>
        <url-pattern>/firstHandlerurl-pattern>
    handler>


httpServer>

 

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文件的，没有放到这里.

 

重定向代码实例：

class="java" name="code">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
            ii[i] = getInt(ss[i]);
        }
        return ii;
    }

    public static int getInt(String input) {
        return getInt(input, true, 0);
    }


}