纯java http协议通讯

这是纯java的http协议通信，这适合特定的场景，一般用到http协议的时候我们都会用web工程很轻松的实现的各种http协议程式，但是如果我们的主项目并非web工程，而是纯java的应用程式的时候，但是客户端又必须实现通信，此时我们有多重方案可选，如HTTP、TCP的socket、或者UDP,他们各有自己的特点和适用场景，这里不做过多的叙述，实现http协议如下demo如下
1、context是程式的应用上下文，读配置文件环境等都可以在这里实现。

package cn.okline.http;

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

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

public class Context
{
    private static Map<String, HttpHandler> contextMap = new HashMap<String, HttpHandler>();
    public static String contextPath = "";

    public static void load()
    {
        try
        {
            Document doc = XmlUtils.load(Context.class.getResource("/").getPath() +"/cn/okline/http/"+ "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);
    }

}

2、这里是http的帮助类，实现了get和post请求。可以在这里实现这里的逻辑程式。发送报文、数据。

package cn.okline.http;

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

}

3、接口

package cn.okline.http;

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 cn.okline.http;

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 cn.okline.http;
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;  

public class HttpRequest implements Request {  
    private HttpExchange httpExchange;  
    private Map<String, String> paramMap = new HashMap<String, String>();  
    private Map<String, List<String>> headMap = new HashMap<String, List<String>>();  
    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 cn.okline.http;

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

import com.sun.net.httpserver.HttpExchange;  

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 cn.okline.http;

import java.io.IOException;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;

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 cn.okline.http;

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

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

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 cn.okline.http;

import java.net.URI;

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 cn.okline.http;

public interface Response
{
     public void write(String result);  
}

package cn.okline.http;

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:/\+ 
     * <p> 
     * 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:/\+ 
     * <p> 
     * 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:/\+ 
     * <p> 
     * 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<String> list = new LinkedList<String>();
        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 = "";

    /** 
     * 比较两个字符串（大小写敏感）。 
     * <pre> 
     * 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 
     * </pre> 
     * 
     * @param str1 要比较的字符串1 
     * @param str2 要比较的字符串2 
     * 
     * @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code> 
     */
    public static boolean equals(String str1, String str2)
    {
        if (str1 == null)
        {
            return str2 == null;
        }

        return str1.equals(str2);
    }

    /** 
     * 比较两个字符串（大小写不敏感）。 
     * <pre> 
     * 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 
     * </pre> 
     * 
     * @param str1 要比较的字符串1 
     * @param str2 要比较的字符串2 
     * 
     * @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code> 
     */
    public static boolean equalsIgnoreCase(String str1, String str2)
    {
        if (str1 == null)
        {
            return str2 == null;
        }

        return str1.equalsIgnoreCase(str2);
    }

    /** 
     * 检查字符串是否是空白：<code>null</code>、空字符串<code>""</code>或只有空白字符。 
     * <pre> 
     * StringUtil.isBlank(null)      = true 
     * StringUtil.isBlank("")        = true 
     * StringUtil.isBlank(" ")       = true 
     * StringUtil.isBlank("bob")     = false 
     * StringUtil.isBlank("  bob  ") = false 
     * </pre> 
     * 
     * @param str 要检查的字符串 
     * 
     * @return 如果为空白, 则返回<code>true</code> 
     */
    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;
    }

    /** 
     * 检查字符串是否不是空白：<code>null</code>、空字符串<code>""</code>或只有空白字符。 
     * <pre> 
     * StringUtil.isBlank(null)      = false 
     * StringUtil.isBlank("")        = false 
     * StringUtil.isBlank(" ")       = false 
     * StringUtil.isBlank("bob")     = true 
     * StringUtil.isBlank("  bob  ") = true 
     * </pre> 
     * 
     * @param str 要检查的字符串 
     * 
     * @return 如果为空白, 则返回<code>true</code> 
     */
    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;
    }

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

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

    /** 
     * 在字符串中查找指定字符串，并返回第一个匹配的索引值。如果字符串为<code>null</code>或未找到，则返回<code>-1</code>。 
     * <pre> 
     * 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 
     * </pre> 
     * 
     * @param str 要扫描的字符串 
     * @param searchStr 要查找的字符串 
     * 
     * @return 第一个匹配的索引值。如果字符串为<code>null</code>或未找到，则返回<code>-1</code> 
     */
    public static int indexOf(String str, String searchStr)
    {
        if ((str == null) || (searchStr == null))
        {
            return -1;
        }

        return str.indexOf(searchStr);
    }

    /** 
     * 在字符串中查找指定字符串，并返回第一个匹配的索引值。如果字符串为<code>null</code>或未找到，则返回<code>-1</code>。 
     * <pre> 
     * 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 
     * </pre> 
     * 
     * @param str 要扫描的字符串 
     * @param searchStr 要查找的字符串 
     * @param startPos 开始搜索的索引值，如果小于0，则看作0 
     * 
     * @return 第一个匹配的索引值。如果字符串为<code>null</code>或未找到，则返回<code>-1</code> 
     */
    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);
    }

    /** 
     * 取指定字符串的子串。 
     *  
     * <p> 
     * 负的索引代表从尾部开始计算。如果字符串为<code>null</code>，则返回<code>null</code>。 
     * <pre> 
     * 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" 
     * </pre> 
     * </p> 
     * 
     * @param str 字符串 
     * @param start 起始索引，如果为负数，表示从尾部计算 
     * @param end 结束索引（不含），如果为负数，表示从尾部计算 
     * 
     * @return 子串，如果原始串为<code>null</code>，则返回<code>null</code> 
     */
    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);
    }

    /** 
     * 检查字符串中是否包含指定的字符串。如果字符串为<code>null</code>，将返回<code>false</code>。 
     * <pre> 
     * 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 
     * </pre> 
     * 
     * @param str 要扫描的字符串 
     * @param searchStr 要查找的字符串 
     * 
     * @return 如果找到，则返回<code>true</code> 
     */
    public static boolean contains(String str, String searchStr)
    {
        if ((str == null) || (searchStr == null))
        {
            return false;
        }

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

    /** 
     * <p>Checks if the String contains only unicode digits. 
     * A decimal point is not a unicode digit and returns false.</p> 
     * 
     * <p><code>null</code> will return <code>false</code>. 
     * An empty String ("") will return <code>true</code>.</p> 
     * 
     * <pre> 
     * 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 
     * </pre> 
     * 
     * @param str  the String to check, may be null 
     * @return <code>true</code> 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.length; i++)
        {
            ii[i] = getInt(ss[i]);
        }
        return ii;
    }

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

}

package cn.okline.http;

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;

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 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" + 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<Node> list = new LinkedList<Node>();
        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<String, Object> getProperties(Element root)
    {
        Map<String, Object> map = new HashMap<String, Object>();
        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<String, Object> map = getProperties(root);
        Iterator<String> 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;
    }
}

<?xml version="1.0" encoding="UTF-8"?>  
<httpServer context="/myApp">  
    <handler>  
        <handler-class>cn.okline.http.FirstHandler</handler-class>  
        <url-pattern>/firstHandler</url-pattern>  
    </handler>  
</httpServer>

<?xml version="1.0" encoding="UTF-8"?>