BlogJava-Terry.B.Li 彬-文章分类-java

纯真IP数据库格式详解

礼物 — Sat, 20 Nov 2010 07:15:00 GMT

摘要: 摘要网络上的IP数据库以纯真版的最为流行，LumaQQ也采用了纯真版IP数据库做为IP查询功能的基础。不过关于其格式的文档却非常之少，后来终于在网上找到了一份文档，得以了解其内幕，不过那份文档寥寥数语，也是颇为耐心才读明白。在这里我重写一份，以此做为LumaQQ开发者文档的一部分，我想还是必要的。本文详细介绍了纯真IP数据库的格式，并且给出了一些Demo以供参考。 ... 阅读全文

礼物 2010-11-20 15:15 发表评论

java读取纯真IP数据库QQwry.dat的源代码

礼物 — Sat, 20 Nov 2010 06:23:00 GMT

java读取纯真IP数据库QQwry.dat的源代码,要运行此程序必须有
到网上下载QQwry.da，由于太大，我这里就不提供了。
一、IPEntry.java
/** *
* 一条IP范围记录，不仅包括国家和区域，也包括起始IP和结束IP *

*
* @author 马若劼
*/
public class IPEntry {
    public String beginIp;
    public String endIp;
    public String country;
    public String area;

    /**
     * 构造函数
     */


public IPEntry() {
        beginIp = endIp = country = area = "";
    }

    public String toString(){
       retur        this.area+"  "+this.country+"IP范围:"+this.beginIp+"-"+this.endIp;
    }
   }

二、Utils.java

/*
* Created on 2004-8-4
*
*/

import java.io.UnsupportedEncodingException;

/**
* @author LJ-silver
*/
public class Utils {
    /**
     * 从ip的字符串形式得到字节数组形式
     * @param ip 字符串形式的ip
     * @return 字节数组形式的ip
     */
    public static byte[] getIpByteArrayFromString(String ip) {
        byte[] ret = new byte[4];
        java.util.StringTokenizer st = new java.util.StringTokenizer(ip, ".");
        try {
            ret[0] = (byte)(Integer.parseInt(st.nextToken()) & 0xFF);
            ret[1] = (byte)(Integer.parseInt(st.nextToken()) & 0xFF);
            ret[2] = (byte)(Integer.parseInt(st.nextToken()) & 0xFF);
            ret[3] = (byte)(Integer.parseInt(st.nextToken()) & 0xFF);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return ret;
    }

    public static void main(String args[]){
         byte[] a=getIpByteArrayFromString(args[0]);
          for(int i=0;i< a.length;i++)
                System.out.println(a[i]);
          System.out.println(getIpStringFromBytes(a));
    }
    /**
     * 对原始字符串进行编码转换，如果失败，返回原始的字符串
     * @param s 原始字符串
     * @param srcEncoding 源编码方式
     * @param destEncoding 目标编码方式
     * @return 转换编码后的字符串，失败返回原始字符串
     */
    public static String getString(String s, String srcEncoding, String destEncoding) {
        try {
            return new String(s.getBytes(srcEncoding), destEncoding);
        } catch (UnsupportedEncodingException e) {
            return s;
        }
    }

    /**
     * 根据某种编码方式将字节数组转换成字符串
     * @param b 字节数组
     * @param encoding 编码方式
     * @return 如果encoding不支持，返回一个缺省编码的字符串
     */
    public static String getString(byte[] b, String encoding) {
        try {
            return new String(b, encoding);
        } catch (UnsupportedEncodingException e) {
            return new String(b);
        }
    }

    /**
     * 根据某种编码方式将字节数组转换成字符串
     * @param b 字节数组
     * @param offset 要转换的起始位置
     * @param len 要转换的长度
     * @param encoding 编码方式
     * @return 如果encoding不支持，返回一个缺省编码的字符串
     */
    public static String getString(byte[] b, int offset, int len, String encoding) {
        try {
            return new String(b, offset, len, encoding);
        } catch (UnsupportedEncodingException e) {
            return new String(b, offset, len);
        }
    }

    /**
     * @param ip ip的字节数组形式
     * @return 字符串形式的ip
     */
    public static String getIpStringFromBytes(byte[] ip) {
        StringBuffer sb = new StringBuffer();
        sb.append(ip[0] & 0xFF);
        sb.append('.');
        sb.append(ip[1] & 0xFF);
        sb.append('.');
        sb.append(ip[2] & 0xFF);
        sb.append('.');
        sb.append(ip[3] & 0xFF);
        return sb.toString();
    }

}

三、IPSeeker.java

/*
* LumaQQ - Java QQ Client
*
* Copyright (C) 2004 luma < stubma@163.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteOrder;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;

/**
*  * 用来读取QQwry.dat文件，以根据ip获得好友位置，QQwry.dat的格式是
* 一. 文件头，共8字节
*        1. 第一个起始IP的绝对偏移， 4字节
*     2. 最后一个起始IP的绝对偏移， 4字节
* 二. "结束地址/国家/区域"记录区
*     四字节ip地址后跟的每一条记录分成两个部分
*     1. 国家记录
*     2. 地区记录
*     但是地区记录是不一定有的。而且国家记录和地区记录都有两种形式
*     1. 以0结束的字符串
*     2. 4个字节，一个字节可能为0x1或0x2
*           a. 为0x1时，表示在绝对偏移后还跟着一个区域的记录，注意是绝对偏移之后，而不是这四个字节之后
*        b. 为0x2时，表示在绝对偏移后没有区域记录
*        不管为0x1还是0x2，后三个字节都是实际国家名的文件内绝对偏移
*           如果是地区记录，0x1和0x2的含义不明，但是如果出现这两个字节，也肯定是跟着3个字节偏移，如果不是
*        则为0结尾字符串
* 三. "起始地址/结束地址偏移"记录区
*     1. 每条记录7字节，按照起始地址从小到大排列
*        a. 起始IP地址，4字节
*        b. 结束ip地址的绝对偏移，3字节
*
* 注意，这个文件里的ip地址和所有的偏移量均采用little-endian格式，而java是采用
* big-endian格式的，要注意转换
*
*
* @author 马若劼
*/
public class IPSeeker {
    /**
     *      * 用来封装ip相关信息，目前只有两个字段，ip所在的国家和地区
     *
     *
     * @author 马若劼
     */
    private class IPLocation {
        public String country;
        public String area;

        public IPLocation() {
            country = area = "";
        }

        public IPLocation getCopy() {
            IPLocation ret = new IPLocation();
            ret.country = country;
            ret.area = area;
            return ret;
        }
    }

    private static final String IP_FILE = IPSeeker.class.getResource("/QQWry.dat").toString().substring(5);

    // 一些固定常量，比如记录长度等等
    private static final int IP_RECORD_LENGTH = 7;
    private static final byte AREA_FOLLOWED = 0x01;
    private static final byte NO_AREA = 0x2;

    // 用来做为cache，查询一个ip时首先查看cache，以减少不必要的重复查找
    private Hashtable ipCache;
    // 随机文件访问类
    private RandomAccessFile ipFile;
    // 内存映射文件
    private MappedByteBuffer mbb;
    // 单一模式实例
    private static IPSeeker instance = new IPSeeker();
    // 起始地区的开始和结束的绝对偏移
    private long ipBegin, ipEnd;
    // 为提高效率而采用的临时变量
    private IPLocation loc;
    private byte[] buf;
    private byte[] b4;
    private byte[] b3;

    /**
     * 私有构造函数
     */
    private IPSeeker()  {
        ipCache = new Hashtable();
        loc = new IPLocation();
        buf = new byte[100];
        b4 = new byte[4];
        b3 = new byte[3];
        try {
            ipFile = new RandomAccessFile(IP_FILE, "r");
        } catch (FileNotFoundException e) {
                        System.out.println(IPSeeker.class.getResource("/QQWry.dat").toString());
                        System.out.println(IP_FILE);
            System.out.println("IP地址信息文件没有找到，IP显示功能将无法使用");
            ipFile = null;

        }
        // 如果打开文件成功，读取文件头信息
        if(ipFile != null) {
            try {
                ipBegin = readLong4(0);
                ipEnd = readLong4(4);
                if(ipBegin == -1 || ipEnd == -1) {
                    ipFile.close();
                    ipFile = null;
                }
            } catch (IOException e) {
                System.out.println("IP地址信息文件格式有错误，IP显示功能将无法使用");
                ipFile = null;
            }
        }
    }

    /**
     * @return 单一实例
     */
    public static IPSeeker getInstance() {
        return instance;
    }

    /**
     * 给定一个地点的不完全名字，得到一系列包含s子串的IP范围记录
     * @param s 地点子串
     * @return 包含IPEntry类型的List
     */
    public List getIPEntriesDebug(String s) {
        List ret = new ArrayList();
        long endOffset = ipEnd + 4;
        for(long offset = ipBegin + 4; offset <= endOffset; offset += IP_RECORD_LENGTH) {
            // 读取结束IP偏移
            long temp = readLong3(offset);
            // 如果temp不等于-1，读取IP的地点信息
            if(temp != -1) {
                IPLocation loc = getIPLocation(temp);
                // 判断是否这个地点里面包含了s子串，如果包含了，添加这个记录到List中，如果没有，继续
                if(loc.country.indexOf(s) != -1 || loc.area.indexOf(s) != -1) {
                    IPEntry entry = new IPEntry();
                    entry.country = loc.country;
                    entry.area = loc.area;
                    // 得到起始IP
                    readIP(offset - 4, b4);
                    entry.beginIp = Utils.getIpStringFromBytes(b4);
                    // 得到结束IP
                    readIP(temp, b4);
                    entry.endIp = Utils.getIpStringFromBytes(b4);
                    // 添加该记录
                    ret.add(entry);
                }
            }
        }
        return ret;
    }

    /**
     * 给定一个地点的不完全名字，得到一系列包含s子串的IP范围记录
     * @param s 地点子串
     * @return 包含IPEntry类型的List
     */
    public List getIPEntries(String s) {
        List ret = new ArrayList();
        try {
            // 映射IP信息文件到内存中
            if(mbb == null) {
                FileChannel fc = ipFile.getChannel();
                mbb = fc.map(FileChannel.MapMode.READ_ONLY, 0, ipFile.length());
                mbb.order(ByteOrder.LITTLE_ENDIAN);
            }

            int endOffset = (int)ipEnd;
            for(int offset = (int)ipBegin + 4; offset <= endOffset; offset += IP_RECORD_LENGTH) {
                int temp = readInt3(offset);
                if(temp != -1) {
                    IPLocation loc = getIPLocation(temp);
                    // 判断是否这个地点里面包含了s子串，如果包含了，添加这个记录到List中，如果没有，继续
                    if(loc.country.indexOf(s) != -1 || loc.area.indexOf(s) != -1) {
                        IPEntry entry = new IPEntry();
                        entry.country = loc.country;
                        entry.area = loc.area;
                        // 得到起始IP
                        readIP(offset - 4, b4);
                        entry.beginIp = Utils.getIpStringFromBytes(b4);
                        // 得到结束IP
                        readIP(temp, b4);
                        entry.endIp = Utils.getIpStringFromBytes(b4);
                        // 添加该记录
                        ret.add(entry);
                    }
                }
            }
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
        return ret;
    }

    /**
     * 从内存映射文件的offset位置开始的3个字节读取一个int
     * @param offset
     * @return
     */
    private int readInt3(int offset) {
        mbb.position(offset);
        return mbb.getInt() & 0x00FFFFFF;
    }

    /**
     * 从内存映射文件的当前位置开始的3个字节读取一个int
     * @return
     */
    private int readInt3() {
        return mbb.getInt() & 0x00FFFFFF;
    }

    /**
     * 根据IP得到国家名
     * @param ip ip的字节数组形式
     * @return 国家名字符串
     */
    public String getCountry(byte[] ip) {
        // 检查ip地址文件是否正常
        if(ipFile == null) return "错误的IP数据库文件";
        // 保存ip，转换ip字节数组为字符串形式
        String ipStr = Utils.getIpStringFromBytes(ip);
        // 先检查cache中是否已经包含有这个ip的结果，没有再搜索文件
        if(ipCache.containsKey(ipStr)) {
            IPLocation loc = (IPLocation)ipCache.get(ipStr);
            return loc.country;
        } else {
            IPLocation loc = getIPLocation(ip);
            ipCache.put(ipStr, loc.getCopy());
            return loc.country;
        }
    }

    /**
     * 根据IP得到国家名
     * @param ip IP的字符串形式
     * @return 国家名字符串
     */
    public String getCountry(String ip) {
        return getCountry(Utils.getIpByteArrayFromString(ip));
    }

    /**
     * 根据IP得到地区名
     * @param ip ip的字节数组形式
     * @return 地区名字符串
     */
    public String getArea(byte[] ip) {
        // 检查ip地址文件是否正常
        if(ipFile == null) return "错误的IP数据库文件";
        // 保存ip，转换ip字节数组为字符串形式
        String ipStr = Utils.getIpStringFromBytes(ip);
        // 先检查cache中是否已经包含有这个ip的结果，没有再搜索文件
        if(ipCache.containsKey(ipStr)) {
            IPLocation loc = (IPLocation)ipCache.get(ipStr);
            return loc.area;
        } else {
            IPLocation loc = getIPLocation(ip);
            ipCache.put(ipStr, loc.getCopy());
            return loc.area;
        }
    }

    /**
     * 根据IP得到地区名
     * @param ip IP的字符串形式
     * @return 地区名字符串
     */
    public String getArea(String ip) {
        return getArea(Utils.getIpByteArrayFromString(ip));
    }

    /**
     * 根据ip搜索ip信息文件，得到IPLocation结构，所搜索的ip参数从类成员ip中得到
     * @param ip 要查询的IP
     * @return IPLocation结构
     */
    private IPLocation getIPLocation(byte[] ip) {
        IPLocation info = null;
        long offset = locateIP(ip);
        if(offset != -1)
            info = getIPLocation(offset);
        if(info == null) {
            info = new IPLocation();
            info.country = "未知国家";
            info.area = "未知地区";
        }
        return info;
    }

    /**
     * 从offset位置读取4个字节为一个long，因为java为big-endian格式，所以没办法
     * 用了这么一个函数来做转换
     * @param offset
     * @return 读取的long值，返回-1表示读取文件失败
     */
    private long readLong4(long offset) {
        long ret = 0;
        try {
            ipFile.seek(offset);
            ret |= (ipFile.readByte() & 0xFF);
            ret |= ((ipFile.readByte() << 8) & 0xFF00);
            ret |= ((ipFile.readByte() << 16) & 0xFF0000);
            ret |= ((ipFile.readByte() << 24) & 0xFF000000);
            return ret;
        } catch (IOException e) {
            return -1;
        }
    }

    /**
     * 从offset位置读取3个字节为一个long，因为java为big-endian格式，所以没办法
     * 用了这么一个函数来做转换
     * @param offset
     * @return 读取的long值，返回-1表示读取文件失败
     */
    private long readLong3(long offset) {
        long ret = 0;
        try {
            ipFile.seek(offset);
            ipFile.readFully(b3);
            ret |= (b3[0] & 0xFF);
            ret |= ((b3[1] << 8) & 0xFF00);
            ret |= ((b3[2] << 16) & 0xFF0000);
            return ret;
        } catch (IOException e) {
            return -1;
        }
    }

    /**
     * 从当前位置读取3个字节转换成long
     * @return
     */
    private long readLong3() {
        long ret = 0;
        try {
            ipFile.readFully(b3);
            ret |= (b3[0] & 0xFF);
            ret |= ((b3[1] << 8) & 0xFF00);
            ret |= ((b3[2] << 16) & 0xFF0000);
            return ret;
        } catch (IOException e) {
            return -1;
        }
    }

    /**
     * 从offset位置读取四个字节的ip地址放入ip数组中，读取后的ip为big-endian格式，但是
     * 文件中是little-endian形式，将会进行转换
     * @param offset
     * @param ip
     */
    private void readIP(long offset, byte[] ip) {
        try {
            ipFile.seek(offset);
            ipFile.readFully(ip);
            byte temp = ip[0];
            ip[0] = ip[3];
            ip[3] = temp;
            temp = ip[1];
            ip[1] = ip[2];
            ip[2] = temp;
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    /**
     * 从offset位置读取四个字节的ip地址放入ip数组中，读取后的ip为big-endian格式，但是
     * 文件中是little-endian形式，将会进行转换
     * @param offset
     * @param ip
     */
    private void readIP(int offset, byte[] ip) {
        mbb.position(offset);
        mbb.get(ip);
        byte temp = ip[0];
        ip[0] = ip[3];
        ip[3] = temp;
        temp = ip[1];
        ip[1] = ip[2];
        ip[2] = temp;
    }

    /**
     * 把类成员ip和beginIp比较，注意这个beginIp是big-endian的
     * @param ip 要查询的IP
     * @param beginIp 和被查询IP相比较的IP
     * @return 相等返回0，ip大于beginIp则返回1，小于返回-1。
     */
    private int compareIP(byte[] ip, byte[] beginIp) {
        for(int i = 0; i < 4; i++) {
            int r = compareByte(ip[i], beginIp[i]);
            if(r != 0)
                return r;
        }
        return 0;
    }

    /**
     * 把两个byte当作无符号数进行比较
     * @param b1
     * @param b2
     * @return 若b1大于b2则返回1，相等返回0，小于返回-1
     */
    private int compareByte(byte b1, byte b2) {
        if((b1 & 0xFF) > (b2 & 0xFF)) // 比较是否大于
            return 1;
        else if((b1 ^ b2) == 0)// 判断是否相等
            return 0;
        else
            return -1;
    }

    /**
     * 这个方法将根据ip的内容，定位到包含这个ip国家地区的记录处，返回一个绝对偏移
     * 方法使用二分法查找。
     * @param ip 要查询的IP
     * @return 如果找到了，返回结束IP的偏移，如果没有找到，返回-1
     */
    private long locateIP(byte[] ip) {
        long m = 0;
        int r;
        // 比较第一个ip项
        readIP(ipBegin, b4);
        r = compareIP(ip, b4);
        if(r == 0) return ipBegin;
        else if(r < 0) return -1;
        // 开始二分搜索
        for(long i = ipBegin, j = ipEnd; i < j; ) {
            m = getMiddleOffset(i, j);
            readIP(m, b4);
            r = compareIP(ip, b4);
            // log.debug(Utils.getIpStringFromBytes(b));
            if(r > 0)
                i = m;
            else if(r < 0) {
                if(m == j) {
                    j -= IP_RECORD_LENGTH;
                    m = j;
                } else
                    j = m;
            } else
                return readLong3(m + 4);
        }
        // 如果循环结束了，那么i和j必定是相等的，这个记录为最可能的记录，但是并非
        //     肯定就是，还要检查一下，如果是，就返回结束地址区的绝对偏移
        m = readLong3(m + 4);
        readIP(m, b4);
        r = compareIP(ip, b4);
        if(r <= 0) return m;
        else return -1;
    }

    /**
     * 得到begin偏移和end偏移中间位置记录的偏移
     * @param begin
     * @param end
     * @return
     */
    private long getMiddleOffset(long begin, long end) {
        long records = (end - begin) / IP_RECORD_LENGTH;
        records >>= 1;
        if(records == 0) records = 1;
        return begin + records * IP_RECORD_LENGTH;
    }

    /**
     * 给定一个ip国家地区记录的偏移，返回一个IPLocation结构
     * @param offset
     * @return
     */
    private IPLocation getIPLocation(long offset) {
        try {
            // 跳过4字节ip
            ipFile.seek(offset + 4);
            // 读取第一个字节判断是否标志字节
            byte b = ipFile.readByte();
            if(b == AREA_FOLLOWED) {
                // 读取国家偏移
                long countryOffset = readLong3();
                // 跳转至偏移处
                ipFile.seek(countryOffset);
                // 再检查一次标志字节，因为这个时候这个地方仍然可能是个重定向
                b = ipFile.readByte();
                if(b == NO_AREA) {
                    loc.country = readString(readLong3());
                    ipFile.seek(countryOffset + 4);
                } else
                    loc.country = readString(countryOffset);
                // 读取地区标志
                loc.area = readArea(ipFile.getFilePointer());
            } else if(b == NO_AREA) {
                loc.country = readString(readLong3());
                loc.area = readArea(offset + 8);
            } else {
                loc.country = readString(ipFile.getFilePointer() - 1);
                loc.area = readArea(ipFile.getFilePointer());
            }
            return loc;
        } catch (IOException e) {
            return null;
        }
    }

    /**
     * @param offset
     * @return
     */
    private IPLocation getIPLocation(int offset) {
        // 跳过4字节ip
        mbb.position(offset + 4);
        // 读取第一个字节判断是否标志字节
        byte b = mbb.get();
        if(b == AREA_FOLLOWED) {
            // 读取国家偏移
            int countryOffset = readInt3();
            // 跳转至偏移处
            mbb.position(countryOffset);
            // 再检查一次标志字节，因为这个时候这个地方仍然可能是个重定向
            b = mbb.get();
            if(b == NO_AREA) {
                loc.country = readString(readInt3());
                mbb.position(countryOffset + 4);
            } else
                loc.country = readString(countryOffset);
            // 读取地区标志
            loc.area = readArea(mbb.position());
        } else if(b == NO_AREA) {
            loc.country = readString(readInt3());
            loc.area = readArea(offset + 8);
        } else {
            loc.country = readString(mbb.position() - 1);
            loc.area = readArea(mbb.position());
        }
        return loc;
    }

    /**
     * 从offset偏移开始解析后面的字节，读出一个地区名
     * @param offset
     * @return 地区名字符串
     * @throws IOException
     */
    private String readArea(long offset) throws IOException {
        ipFile.seek(offset);
        byte b = ipFile.readByte();
        if(b == 0x01 || b == 0x02) {
            long areaOffset = readLong3(offset + 1);
            if(areaOffset == 0)
                return "未知地区";
            else
                return readString(areaOffset);
        } else
            return readString(offset);
    }

    /**
     * @param offset
     * @return
     */
    private String readArea(int offset) {
        mbb.position(offset);
        byte b = mbb.get();
        if(b == 0x01 || b == 0x02) {
            int areaOffset = readInt3();
            if(areaOffset == 0)
                return "未知地区";
            else
                return readString(areaOffset);
        } else
            return readString(offset);
    }

    /**
     * 从offset偏移处读取一个以0结束的字符串
     * @param offset
     * @return 读取的字符串，出错返回空字符串
     */
    private String readString(long offset) {
        try {
            ipFile.seek(offset);
            int i;
            for(i = 0, buf[i] = ipFile.readByte(); buf[i] != 0; buf[++i] = ipFile.readByte());
            if(i != 0)
                return Utils.getString(buf, 0, i, "GBK");
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
        return "";
    }

    /**
     * 从内存映射文件的offset位置得到一个0结尾字符串
     * @param offset
     * @return
     */
    private String readString(int offset) {
        try {
            mbb.position(offset);
            int i;
            for(i = 0, buf[i] = mbb.get(); buf[i] != 0; buf[++i] = mbb.get());
            if(i != 0)
                return Utils.getString(buf, 0, i, "GBK");
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
        return "";
    }

    public String getAddress(String ip){
        String country = getCountry(ip).equals(" CZ88.NET")?"":getCountry(ip);
        String area = getArea(ip).equals(" CZ88.NET")?"":getArea(ip);
        String address = country+" "+area;
        return address.trim();
    }
}

礼物 2010-11-20 14:23 发表评论

图片截取和缩略

礼物 — Sat, 20 Nov 2010 04:26:00 GMT

摘要: package com.supben.util; import java.awt.Dimension; ... 阅读全文

礼物 2010-11-20 12:26 发表评论

spring任务调度方法之Quartz

礼物 — Tue, 02 Nov 2010 00:52:00 GMT

摘要: 一、Quartz简介 Quartz是一个开放源码项目，专注于任务调度器，提供了极为广泛的特性如持久化任务，集群和分布式任务等。Spring对Quartz的集成与其对JDK Timer的集成在任务、触发器和调度计划的声明式配置方面等都非常相似。 Quartz的核心由两个接口和两个类组成：Job和Scheduler接口，JobDetail... 阅读全文

礼物 2010-11-02 08:52 发表评论

使用JMeter进行性能测试

礼物 — Thu, 10 Sep 2009 05:51:00 GMT

JMeter 是 Apache 组织的开放源代码项目，它是功能和性能测试的工具，100%的用java实现，最新的版本是1.9.1。本文中作者将向大家介绍如何使用 JMeter 进行测试。

JMeter是Apache组织的开放源代码项目，它是功能和性能测试的工具，100%的用java实现，最新的版本是1.9.1，大家可以到 http://jakarta.apache.org/jmeter/index.html下载源代码和查看相关文档。

JMeter作用领域

JMeter 可以用于测试静态或者动态资源的性能（文件、Servlets、Perl脚本、java对象、数据库和查询、ftp服务器或者其他的资源）。JMeter 用于模拟在服务器、网络或者其他对象上附加高负载以测试他们提供服务的受压能力，或者分析他们提供的服务在不同负载条件下的总性能情况。你可以用 JMeter提供的图形化界面分析性能指标或者在高负载情况下测试服务器/脚本/对象的行为。

回页首

使用JMeter测试Web应用

接下来的章节里，作者将详细的演示如何使用JMeter来测试Web应用的完整过程。

2.1 测试环境

作者使用了Tomcat作为Web服务器进行测试，被测试的内容是一个jsp文件和一个servlet，jsp文件调用JavaBean、打印相关信息，servlet接受用户参数、调用javabean、输出相关信息。详细的内容请参考作者提供的JMeter.war的内容。

2.2 安装启动JMeter

大家可以到通过http://apache.linuxforum.net/dist/jakarta/jmeter/binaries/jakarta- jmeter-1.9.1.zip下载JMeter的release版本，然后将下载的.zip文件解压缩到C:/JMeter（后面的文章中将使用%JMeter%来引用这个目录）目录下。

现在，请使用%JMeter%/bin下面的jmeter.bat批处理文件来启动JMeter的可视化界面，下面的工作都将在这个可视化界面界面上进行操作。下面的图片是JMeter的可视化界面的屏幕截图。

图一： JMeter打开时的屏幕截图

2.3 建立测试计划（Test Plan）

测试计划描述了执行测试过程中JMeter的执行过程和步骤，一个完整的测试计划包括一个或者多个线程组(Thread Groups)、逻辑控制（Logic Controller）、实例产生控制器（Sample Generating Controllers）、侦听器(Listener)、定时器（Timer）、比较（Assertions）、配置元素（Config Elements）。打开JMeter时，它已经建立一个默认的测试计划,一个JMeter应用的实例只能建立或者打开一个测试计划。

现在我们开始填充一个测试计划的内容，这个测试计划向一个jsp文件和一个servlet发出请求，我们需要JMeter模拟五个请求者（也就是五个线程），每个请求者连续请求两次，下面的章节介绍了详细的操作步骤。

2.4 增加负载信息设置

这一步，我们将向测试计划中增加相关负载设置,是Jmeter知道我们需要模拟五个请求者，每个请求者在测试过程中连续请求两次。详细步骤如下：

1. 选中可视化界面中左边树的Test Plan节点，单击右键，选择Add'Thread Group，界面右边将会出现他的设置信息框。

2. Thread Group有三个和负载信息相关的参数：
Number of Threads：设置发送请求的用户数目
Ramp-up period：每个请求发生的总时间间隔，单位是秒。比如你的请求数目是5，而这个参数是10，那么每个请求之间的间隔就是10／5，也就是2秒
Loop Count：请求发生的重复次数，如果选择后面的forever（默认），那么请求将一直继续，如果不选择forever，而在输入框中输入数字，那么请求将重复指定的次数，如果输入0，那么请求将执行一次。

根据我们演示例子的设计，我们应该将Number of Threads设置为5，Ramp-up period设置为0（也就是同时并发请求），不选中forever，在Loop Count后面的输入框中输入2，设置后的屏幕截图如下：

图二：设置好参数的Thread Group。

2.5 增加默认Http属性（可选）

实际的测试工作往往是针对同一个服务器上Web应用展开的,所以Jmeter提供了这样一种设置, 在默认Http属性设置需要被测试服务器的相关属性，以后的http请求设置中就可以忽略这些相同参数的设置,减少设置参数录入的时间。

我们这里将采用这种属性。你可以通过下面的步骤来设置默认http属性：

1. 选中可视化界面中左边树的Test Plan节点，单击右键，选择Add'config element'http request defaults，界面右边将会出现他的设置信息框。

2. 默认http属性的主要参数说明如下：
protocal：发送测试请求时使用的协议
server name or ip：被测试服务器的ip地址或者名字
path：默认的起始位置。比如将path设置为／jmeter，那么所有的http请求的url中都将增加／jmeter路径。
port number：服务器提供服务的端口号

我们的测试计划将针对本机的Web服务器上的Web应用进行测试，所以protocal应该是http，ip使用localhost，因为这个web应用发布的context路径是／jmeter，所以这里的path设置为／jmeter，因为使用Tomcat服务器，所以port number是8080。设置后的屏幕截图如下：

图三：测试计划中使用的默认Http参数

2.6 增加Http请求

现在我们需要增加http请求了，他也是我们测试的内容主体部分。你可以通过下面的步骤来增加性的http请求：

1. 选中可视化界面中左边树的Thread Group节点，单击右键，选择Add'sampler'http request，界面右边将会出现他的设置信息框。

2. 他的参数和2.5中介绍的http属性差不多，增加的属性中有发送http时方法的选择，你可以选择为get或者post。

我们现在增加两个http 请求，因为我们设置了默认的http属性，所以和默认http属性中相同的属性不再重复设置。设置后的屏幕截图如下：

图四：设置好的jsp测试请求

图五：设置好的Servlet测试请求（带参数）

2.7 增加Listener

增加listener是为了记录测试信息并且可以使用Jmeter提供的可视化界面查看测试结果，里面有好几种结果分析方式可供选择，你可以根据自己习惯的分析方式选择不同的结果显示方式，我们这里使用表格的形式来查看和分析测试结果。你可以通过下面的步骤来增加listener：

1. 选中可视化界面中左边树的Test Plan节点，单击右键，选择Add'listener'view result in table，界面右边将会出现他的设置信息和结果显示框。

2. 你可以设置界面上面的filename属性设置将测试结果保存到某个文件中界面下面将使用表格显示测试结果，表格的第一列sampleno显示请求执行的顺序和编号，url显示请求发送的目标，sample－ms列显示这个请求完成耗费的时间，最后的success列显示改请求是否成功执行。

界面的最下面你还可以看到一些统计信息，最关心的应该是Average吧，也就是相应的平均时间。

2.8 开始执行测试计划

现在你可以通过单击菜单栏run -> Start开始执行测试计划了。下面这两个图是作者第一次、第二次执行该测试计划的结果图:

图六：第一次执行后的结果显示

图七：第二次执行的结果显示

大家可以看到第一次执行时的几个大时间值均来自于jsp request，这可以通过下面的理由进行解释：jsp执行前都需要被编译成.class文件。所以第二次的结果才是正常的结果。

回页首

总结

JMeter用于进行供能或者性能测试，通过使用JMeter提供的供能，我们可以可视化的制定测试计划：包括规定使用什么样的负载、测试什么内容、传入的参数，同时，他提供了好多种图形化的测试结果显示方式，使我们能够简单的开始测试工作和分析测试结果。

本文中，作者根据自己的使用经验，详细演示了如何使用JMeter来进行Web测试的全部过程，简单的介绍了JMeter提供测试结果的图形化显示界面中相关参数的含义。希望能够帮助大家学会使用JMeter的基本知识，同时，大家可以参考这个过程和JMeter的帮助文档来实现对java对象、数据库等的测试过程。

礼物 2009-09-10 13:51 发表评论

(原)Proxool 连接池

礼物 — Wed, 09 Sep 2009 09:09:00 GMT

导入jar包：proxool-0.9.1.jar 和 proxool-cglib.jar

一、使用硬编码方式

package com.proxool.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class Test1 {
    private static final Log LOG = LogFactory.getLog(Test1.class);
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Connection connection = null;
         try {
//           Class.forName("com.mysql.jdbc.Driver");
             Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
           try {
//             connection = DriverManager.getConnection("jdbc:mysql://172.16.220.154:3306/sipityprofile?autoReconnect=true&useUnicode=true&characterEncoding=utf8&user=root&password=12345678");
               connection = DriverManager.getConnection("proxool.example:com.mysql.jdbc.Driver:jdbc:mysql://172.16.220.154:3306/sipityprofile?user=root&password=12345678");
//               connection = DriverManager.getConnection("proxool.example");
           } catch (SQLException e) {
             LOG.error("Problem getting connection", e);
           }

          if (connection != null) {
            LOG.info("Got connection :)");
          } else {
            LOG.error("Didn't get connection, which probably means that no Driver accepted the URL");
          }

        } catch (ClassNotFoundException e) {
          LOG.error("Couldn't find driver", e);
        } finally {
          try {
            // Check to see we actually got a connection before we
            // attempt to close it.
            if (connection != null) {
              connection.close();
            }
          } catch (SQLException e) {
            LOG.error("Problem closing connection", e);
          }
        }
    }

}

二、使用 xml 配置文件

package com.proxool.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.ProxoolException;
import org.logicalcobwebs.proxool.configuration.JAXPConfigurator;

public class Test2ByXml {

    private static final Log LOG = LogFactory.getLog(Test2ByXml.class);

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            JAXPConfigurator.configure("src/proxool.xml", false);
            Connection connection = DriverManager.getConnection("proxool.proxool-sipity");
            if (null == connection) {
                LOG.info("connection is null");
            }else {
                LOG.info("connection successfull");
                Statement statement = connection.createStatement();
                ResultSet resultSet = statement.executeQuery("select * from event");
                while (resultSet.next()) {
                    LOG.info(resultSet.getInt(1)+"    "+resultSet.getString(2));
                }
            }
        } catch (ProxoolException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

xml version="1.0" encoding="ISO-8859-1"?>
<something-else-entirely>
    <proxool>
        <alias>proxool-sipityalias>
        <driver-url>jdbc:mysql://172.16.220.154:3306/sipityprofiledriver-url>
        <driver-class>com.mysql.jdbc.Driverdriver-class>
        <driver-properties>
            <property name="user" value="root" />
            <property name="password" value="12345678" />
        driver-properties>
        <maximum-connection-count>10maximum-connection-count>
        <house-keeping-test-sql>select 1house-keeping-test-sql>
    proxool>
something-else-entirely>

三、使用 properties 方式

package com.proxool.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.ProxoolException;
import org.logicalcobwebs.proxool.configuration.PropertyConfigurator;

public class Test3ByProp {
    private static final Log LOG = LogFactory.getLog(Test3ByProp.class);

    static{
        try {
            PropertyConfigurator.configure("src/proxool.properties");
        } catch (ProxoolException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        testConnection();
        testConnection();
    }
    private static void testConnection() {
        Connection connection = null;
        try {

            connection = DriverManager.getConnection("proxool.proxool-sipity");
            if (null == connection) {
                LOG.info("connection is null");
            }else {
                LOG.info("connection successfull");
                Statement statement = connection.createStatement();
                ResultSet resultSet = statement.executeQuery("select * from event");
                while (resultSet.next()) {
                    //LOG.info(resultSet.getInt(1)+"    "+resultSet.getString(2));
                }
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                connection.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

jdbc-0.proxool.alias=proxool-sipity
jdbc-0.proxool.driver-url=jdbc:mysql://172.16.220.154:3306/sipityprofile
jdbc-0.proxool.driver-class=com.mysql.jdbc.Driver
jdbc-0.user=root
jdbc-0.password=12345678
jdbc-0.proxool.maximum-connection-count=10
jdbc-0.proxool.house-keeping-test-sql=select 1

礼物 2009-09-09 17:09 发表评论

（原）Java 类访问 URI

礼物 — Wed, 09 Sep 2009 09:04:00 GMT

import java.io.IOException;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.GetMethod;

public class Test {

     /**
     * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
        GetMethod method = new GetMethod( " http://api.telenav.com/tnapi/services/geoutil/geocode?apiKey=AQAAASNiwsIwf/////////8AAAABAAAAAQEAAAAQF55mB/t8b4u/xsTdcidXpAEAAAAOAwAAAA8AAAAXAAAAAQA=&firstLine=1130%20kifer%20rd,Sunnyvale,ca&country=US " );
        HttpClient httpClient = new HttpClient();
         try {
             int state = httpClient.executeMethod(method);
             if (state == HttpStatus.SC_OK) {
                System.out.println( " OK " );
            } else {
                System.out.println( " Error " );
            }
            String result = method.getResponseBodyAsString();
            System.out.println(result);
        } catch (HttpException e) {
             // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
             // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

Maven 依赖

<dependency>
    <groupId>commons-httpclientgroupId>
    <artifactId>commons-httpclientartifactId>
    <version>3.0.1version>
dependency>

礼物 2009-09-09 17:04 发表评论

(转载)应用架构设计“防火”经验分享

礼物 — Thu, 03 Sep 2009 09:25:00 GMT

应用架构设计“防火”经验分享

Author : 岑文初 ( 淘宝花名：放翁 )

Email: fangweng@taobao.com

Blog: http://blog.csdn.net/cenwenchu79

Date: 2009-08-26

刚从阿软到淘宝不久，现在主要负责TOP平台的技术框架设计，同时要肩负“救火”和“防火”的工作，也需要培养团队的同学能够有“防火”意识，减少“救火”次数，因此今天下午花了一点时间，也没于写任何的PPT，就直接将自己想的起来的一些自己认为应用架构设计“防火”知识做了一下事例分享，这里也想记录下来给更多的同学分享一下，当然很多都是老生常谈的常识，但是有时候不经意就会忘记一些血的教训。

资源是有限的

着火点：

系统设计的时候总是估摸不到会有大数据量从远端传输过来（例如处理Http请求时，对于大附件内容的处理，全部装载到内存，结果资源耗尽。从搜索引擎或者DB或者缓存里面拉数据，没有分页，结果内存被吃尽。Socket无限建立连接，结果linux的文件句柄被耗尽。）

防火点：

对业务场景中资源的分配与申请需要做到上限控制，以及达到上限以后的逻辑处理（排队，丢弃，告警）。可以采取一些滑动窗口设计来将不需要过多处理的内容分段直接送入下一个处理管道中。

依赖是未知的

着火点：

事务中嵌入对于第三方系统的请求（例如在数据库操作时去发送邮件或者缓存获取内容，结果连接池资源被Hold，导致系统不可用）。默认依赖系统会给出结果，如果出现异常就反复重试，结果对方被压垮，自己也牺牲。

防火点：

对于第三方系统的依赖能够异步的就采用异步方式，能够从主流程中剥离的就剥离。同时设计好容错的机制，采用本地时效性缓存减少对对方的压力和依赖。最重要的就是注意系统间的死锁，申请了一套资源处理业务逻辑，结果由于远端系统的不可用，导致本地资源的无法释放，最后击垮自己系统。

线程安全与性能

着火点：

对于线程不安全的对象处理一定要小心，否则业务出现异常的地方其实已经离设计出现问题的地方十万八千里，问题时常成为灵异问题，解决只有靠经验。

防火点：

首先对于自己设计的类和方法需要注释是否是线程安全的。同时明确类的使用场景，对线程安全及高性能作判断，因为采用线程安全的对象一定会有性能损耗。最近给同学写的一个Http消息的Lazy获取参数，就是线程不安全的类，但是这个类只会保存在ThreadLocal中，因此不存在问题。很直观的一点判断是否线程安全，就看看你设计的类里面的成员变量在多线程操作时候是否会有并发问题，例如一个普通的Map，多个线程操作就会导致结果的不可估量性。

资源释放

着火点：

正常逻辑都会将IO流关闭，Socket关闭，但是异常抛出时候，没有走到资源释放的流程中，产生了资源泄露问题。另外，资源中可能会有内嵌资源，当内部资源被外部的对象引用，则释放将不成功，内部资源依然会泄露。一些需要显式回收的资源（例如ThreadLocal），如果不回收，那么下次线程被操作系统重用，则会出现莫名其妙的问题（Java的线程创建和使用依赖于操作系统的实现）。

防火点：

Finally的处理。需要释放的资源要做深度检查。需要显式回收的资源要确保使用完毕以后被回收（异常情况也需要考虑）。

创建与复用

着火点：

在以前设计Cache客户端的时候，有同学给我建议说我对于字节数组利用可以采取复用的方式，这样可以减少对象的申请。但是做了一下测试，这样的重复利用其实效果不像想象的那么好，甚至还不如直接创建。

防火点：

Java的垃圾收集器已经在性能上有了很大的提高，同时对于对象的复用需要考虑对象复用前的初始化或者是内容重置，这些得成本及复杂度可能远远要高于复用带来的优势，因此需要根据具体的业务场景选择复用和创建。当然对于稀缺资源采用池的方式是最好的。

字符串处理，日志级别的选择

着火点：

这两个是小问题，但是会带来大麻烦。首先字符串的累加是老生常谈的问题，但是很多新手不以为然，当你是一个高速运转的系统时，你就会发现1ms的延时在上千万次调用下回被无限放大，10byte的申请，在上千万次的请求下会带来GC多次的操作（带来的短暂处理停滞直接影响系统的可用性）。日志级别的随意性会导致线上环境日志迅速膨胀，出错难以查找，影响系统的效率。（log4j优化的再好也是要写文件的，虽然是异步刷页）

防火点：

谨慎处理字符串拼接，选择线程安全或者不安全的两个StringBuilder和StringBuffer。日志尽量区分清楚，debug和Info，前者纯粹调试，可以有海量信息，Info一般用于系统或者模块的状况报告。Warn通常不建议使用了。Error就把你需要的关键信息都打出来。附带这里说一下对于日期对象的处理，在传输和保存的过程中，建议都还是采用long型，可以很好的提高性能及满足国际化的需求。

原子操作与并发控制

着火点：

对于本地的对象操作通常情况下通过锁机制保证并发的一致性，当在设计一个对于资源访问控制的策略时，例如集群应用处理某人每天发送短信1000条，这时候计数器保存在远端的集中式缓存中，采用get和put方式就会有并发问题，因为在应用获得到999这个计数器值的时候，也许正有10000个请求也获得了这个值，这样原有的控制就失效了。

防火点：

其实就是一个原子操作的支持，本地数据可以通过锁来达到原子操作，远程依赖就需要对方系统提供原子操作接口来实现高并发下的业务处理，例如Memcached Cache提供的incr 和decr。结合黑名单策略，计数器可以发挥很多用途，包括及时监控告警等。

接口实现与松耦合

着火点:

没有接口提供，团队间合作困难，无法Mock，相互之间进度影响很大。同时业务实现的修改直接影响业务调用方，使得双方耦合性很强，系统不稳定性被放大。

防火点：

对外提供的服务，或者模块间交互的服务都需要接口化。框架性代码需要在模块载入时考虑是否需要接口化定义，以便在不同环境可以切换不同实现提供对特殊场景的支持，同时也可以将具体实现延后交给使用者实现，使得框架更加灵活。Jdk对于xml的解析就是最好的范例。

灵活性和性能和可维护性的折中

着火点：

最近看了一些同学的代码，看到大量的使用了反射，拦截器等。但是在线上环境运行过程中就发现对于一些拦截器的配置疏漏导致系统性能大幅度降低。对于几十个spring文件，有谁能够很清楚和直观的了解到这些看似灵活和无侵入性的设计。

防火点：

对于业务逻辑不复杂，同时场景不多变的流程采用简单的实现，不要追求花哨的灵活性，带来的只会是可读性，可维护性，可用性的降低。

要有分布式和并发的观念，但是不要本末倒置

着火点：

有些同学在做设计的时候考虑的很清晰，但是就是没有考虑集群部署的情况，结果系统上线以后出现了无法集群部署的问题。并发情况的设计也一样，仅仅在满足业务需求以后，对于多用户并发操作的考虑缺失，导致系统流程错误。

防火点：

设计的时候需要适度考虑这些问题，但是是在满足现有业务逻辑的前提下，不要为了追求分布式而分布式。

便利性的函数与性能的冲突

着火点：

首先申明的是这点适用范围有限（高速运转的模块）。对于String,Date等对象的便利性函数，例如正则匹配，分割，Format等等其实都会有不少的性能损耗。例如你只是需要判断文件名最后的后缀是否满足需求，采用了正则匹配，结果发现性能在高速运转的情况下大大下降。

防火点：

高速运转的模块尽量采用原始方式或者半原始方式。例如上面说到的文件后缀，就用string的endwith来判断。对于一些字符串的替换，能够用字符串拼接就拼接。对于一些字节流的处理也可以自己根据需求来订制的写。总的一句话，能够满足的就用最低成本的方法。

防止系统设计的完备性成为攻击或者压力的瓶颈

着火点：

在很多设计的时候，对于一些系统设计讲究比较完美。例如对于对象的查询会分本地缓存，集中缓存，DB三个阶段。当对方攻击采用不存在的资源名称时候，这种分阶段的设计反而会增加系统负荷。

防火点：

简化流程的分支和层次，对于消耗性资源的访问尽量减少或者没有（采用黑名单本地缓存或者集中缓存的方式），同时改Pull为Push方式，通过控制数据变更点来通知相关系统，而非轮询获取更新状态。

多级缓存和异步缓解异构系统的瓶颈

着火点：

有时候设计系统时，服务提供方向我们许诺说对方系统如何高效和健壮，但是当频繁访问产生网络风暴的时候，我们发现原来带宽和网络IO本身都会成为瓶颈。

防火点：

对于第三方系统的依赖，要做到松耦合就要从流程的异步化来实现。同时通过缓存的使用来达到，系统的高效性和降低对于第三方系统的依赖程度。这样可以大大降低系统的瓶颈。

运行期白盒化，模块可重置

着火点：

系统运行起来以后就无法在知道内部的状态，也无法对问题组件进行单独处理，造成线上环境的不可知性和无法部分修复。不得不停机重起和看日志。

防火点：

模块设计过程中考虑运行期可观测和可重置，提高系统的模块化程度及健壮性。

站在用户角度设计接口，提升系统可用性

着火点：

总是从自身业务体系和架构去考虑如何设计对外接口，但是发现最后用户使用的很别扭，同时由于需求不能直接被满足，会多次反复调用接口，导致自身系统的压力增大。例如对于一个状态的检查接口，是否提供一个状态变更通知接口就会极大降低轮询的压力

防火点：

需要从客户角度考虑问题，设计接口，防止需求和实现脱节，导致系统压力增加。

懒惰有时候是件好事

着火点:

业务流程中很多耗时的操作在流程编排方面没有考虑清楚，当耗时工作做完以后，发现不符合最基本的交验，这样就会导致系统无谓的增加了开销。对于需要申请的资源，考虑处理流程的阶段，阶段性申请要优于一次申请（不过需要注意死锁）。

防火点:

流程编排需要合理性，尽量将耗时的工作放到合理的位置，同时做好基础的防攻击轻量前端屏障逻辑，提高系统的健壮性。

主流程和副流程隔离

着火点：

SIP早先的日志分析模块中有分析日志，备份，发邮件，更新系统缓存，操作数据库等多种操作，但是一股脑儿都被放到一个流程中，结果当邮件没有发成功导致整个流程的失败。

防火点：

把真正的主流程梳理出来，同时对于一些副流程可以考虑采用后台异步方式完成，提高系统稳定性。

模块间接口交互，控制资源直接操作入口

着火点：

对于数据库中的资源任何模块不区分范围都可以访问，最后导致数据结构变更困难，业务对象管理混乱，模块无法剥离独立。

防火点：

模块化设计的基本思想，模块间通过接口交互获得其他模块管辖的数据，接口方式屏蔽了对于后端实现及业务对象的依赖。

学习份外的事情，配置决定成败

着火点：

没有SA就高不定环境，也无法了解操作系统的配置与Web容器的配置对于应用的影响。没有DBA就无法确定如何写SQL避免一些简单的耗时查询。没有测试同学就无法作压力测试，无法了解当前系统性能。

防火点：

多学多问，多了解一些其他岗位的内容，才能够更加全面的掌握好架构设计。

不要迷信

着火点：

总是看到新技术如何有优点，但是看不到它的成熟度。总是听到很多经验之谈，但是从来没有真的比较过。结果就是别人说什么就是什么，系统地稳定性和可用性基于Google出来的结果。

防火点：

需要听取各种意见和经验，同时用测试结果说明问题的结果，看代码说明结果背后的问题。这样才会走得更加踏实，学的更加实际。其实技术发展来说，真正的基础性内容还是有限的，而且各种技术都是触类旁通。分布式，不论是文件系统，DB，缓存都会遇到分布式的共性问题（负载均摊，容错，数据复制，动态扩容等等），在结合一些文件系统，DB，缓存的自身特质。因此扎扎实实学好基础，了解Http协议，了解七层通信协议，了解文件系统设计，了解MapReduce思路，了解结构化，半结构化（bigmap），非结构化存储的要点，就会不会让自己迷失在技术宣传中。

明天晚上去北京参加系统架构师会议，到时候会和大家分享一下TOP的一些商业和技术上的心得，准备得很仓促，但是个人觉得分享就在于自己将自己知道的说出来，时间不长，45分钟，能讲的也不多，但是如果对于淘宝开放平台有兴趣的同学可以来听一下。这里也算是做个广告，不过不要期望过高，免得失望也大^_^。五年没有来北京了，首都应该也变化不小了。

礼物 2009-09-03 17:25 发表评论

(转载)各种架构图汇总!

礼物 — Thu, 21 May 2009 08:05:00 GMT

http://blog.csdn.net/liuxiaotao008/archive/2008/06/29/2595391.aspx

1.Spring架构图

2.Hibernate架构图

礼物 2009-05-21 16:05 发表评论

正则表达式30分钟入门教程

礼物 — Mon, 02 Feb 2009 00:44:00 GMT

本文目标

30分钟内让你明白正则表达式是什么，并对它有一些基本的了解，让你可以在自己的程序或网页里使用它。

如何使用本教程

最重要的是——请给我30分钟，如果你没有使用正则表达式的经验，请不要试图在30秒内入门——除非你是超人 :)

别被下面那些复杂的表达式吓倒，只要跟着我一步一步来，你会发现正则表达式其实并没有你想像中的那么困难。当然，如果你看完了这篇教程之后，发现自己明白了很多，却又几乎什么都记不得，那也是很正常的——我认为，没接触过正则表达式的人在看完这篇教程后，能把提到过的语法记住80%以上的可能性为零。这里只是让你明白基本的原理，以后你还需要多练习，多使用，才能熟练掌握正则表达式。

除了作为入门教程之外，本文还试图成为可以在日常工作中使用的正则表达式语法参考手册。就作者本人的经历来说，这个目标还是完成得不错的——你看，我自己也没能把所有的东西记下来，不是吗？

清除格式文本格式约定：专业术语元字符/语法格式正则表达式正则表达式中的一部分(用于分析) 对其进行匹配的源字符串对正则表达式或其中一部分的说明

隐藏边注本文右边有一些注释，主要是用来提供一些相关信息，或者给没有程序员背景的读者解释一些基本概念，通常可以忽略。

正则表达式到底是什么东西？

字符是计算机软件处理文字时最基本的单位，可能是字母，数字，标点符号，空格，换行符，汉字等等。字符串是0个或更多个字符的序列。文本也就是文字，字符串。说某个字符串匹配某个正则表达式，通常是指这个字符串里有一部分（或几部分分别）能满足表达式给出的条件。

在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。

很可能你使用过Windows/Dos下用于文件查找的通配符(wildcard)，也就是*和?。如果你想查找某个目录下的所有的Word文档的话，你会搜索*.doc。在这里，*会被解释成任意的字符串。和通配符类似，正则表达式也是用来进行文本匹配的工具，只不过比起通配符，它能更精确地描述你的需求——当然，代价就是更复杂——比如你可以编写一个正则表达式，用来查找所有以0开头，后面跟着2-3个数字，然后是一个连字号“-”，最后是7或8位数字的字符串(像010-12345678或0376-7654321)。

入门

学习正则表达式的最好方法是从例子开始，理解例子之后再自己对例子进行修改，实验。下面给出了不少简单的例子，并对它们作了详细的说明。

假设你在一篇英文小说里查找hi，你可以使用正则表达式hi。

这几乎是最简单的正则表达式了，它可以精确匹配这样的字符串：由两个字符组成，前一个字符是h,后一个是i。通常，处理正则表达式的工具会提供一个忽略大小写的选项，如果选中了这个选项，它可以匹配hi,HI,Hi,hI这四种情况中的任意一种。

不幸的是，很多单词里包含hi这两个连续的字符，比如him,history,high等等。用hi来查找的话，这里边的hi也会被找出来。如果要精确地查找hi这个单词的话，我们应该使用"bhi"b。

"b是正则表达式规定的一个特殊代码（好吧，某些人叫它元字符，metacharacter），代表着单词的开头或结尾，也就是单词的分界处。虽然通常英文的单词是由空格，标点符号或者换行来分隔的，但是"b并不匹配这些单词分隔字符中的任何一个，它只匹配一个位置。

如果需要更精确的说法，"b匹配这样的位置：它的前一个字符和后一个字符不全是(一个是,一个不是或不存在)"w。

假如你要找的是hi后面不远处跟着一个Lucy，你应该用"bhi"b.*"bLucy"b。

这里，.是另一个元字符，匹配除了换行符以外的任意字符。*同样是元字符，不过它代表的不是字符，也不是位置，而是数量——它指定*前边的内容可以连续重复出现任意次以使整个表达式得到匹配。因此，.*连在一起就意味着任意数量的不包含换行的字符。现在"bhi"b.*"bLucy"b的意思就很明显了：先是一个单词hi,然后是任意个任意字符(但不能是换行)，最后是Lucy这个单词。

换行符就是'"n',ASCII编码为10(十六进制0x0A)的字符。

如果同时使用其它元字符，我们就能构造出功能更强大的正则表达式。比如下面这个例子：

0"d"d-"d"d"d"d"d"d"d"d匹配这样的字符串：以0开头，然后是两个数字，然后是一个连字号“-”，最后是8个数字(也就是中国的电话号码。当然，这个例子只能匹配区号为3位的情形)。

这里的"d是个新的元字符，匹配一位数字(0，或1，或2，或……)。-不是元字符，只匹配它本身——连字符或者减号。

为了避免那么多烦人的重复，我们也可以这样写这个表达式：0"d{2}-"d{8}。这里"d后面的{2}({8})的意思是前面"d必须连续重复匹配2次(8次)。

测试正则表达式

其它可用的测试工具:

如果你不觉得正则表达式很难读写的话，要么你是一个天才，要么，你不是地球人。正则表达式的语法很令人头疼，即使对经常使用它的人来说也是如此。由于难于读写，容易出错，所以找一种工具对正则表达式进行测试是很有必要的。

由于在不同的环境下正则表达式的一些细节是不相同的，本教程介绍的是微软 .Net Framework 2.0下正则表达式的行为，所以，我向你介绍一个.Net下的工具Regex Tester。首先你确保已经安装了.Net Framework 2.0，然后下载Regex Tester。这是个绿色软件，下载完后打开压缩包,直接运行RegexTester.exe就可以了。

下面是Regex Tester运行时的截图：

元字符

现在你已经知道几个很有用的元字符了，如"b,.,*，还有"d.正则表达式里还有更多的元字符，比如"s匹配任意的空白符，包括空格，制表符(Tab)，换行符，中文全角空格等。"w匹配字母或数字或下划线或汉字等。

对中文/汉字的特殊处理是由.Net提供的正则表达式引擎支持的，其它环境下的具体情况请查看相关文档。

下面来看看更多的例子：

"ba"w*"b匹配以字母a开头的单词——先是某个单词开始处("b)，然后是字母a,然后是任意数量的字母或数字("w*)，最后是单词结束处("b)。

好吧，现在我们说说正则表达式里的单词是什么意思吧：就是多于一个的连续的"w。不错，这与学习英文时要背的成千上万个同名的东西的确关系不大 :)

"d+匹配1个或更多连续的数字。这里的+是和*类似的元字符，不同的是*匹配重复任意次(可能是0次)，而+则匹配重复1次或更多次。

"b"w{6}"b 匹配刚好6个字母/数字的单词。

表1.常用的元字符
代码	说明
.	匹配除换行符以外的任意字符
"w	匹配字母或数字或下划线或汉字
"s	匹配任意的空白符
"d	匹配数字
"b	匹配单词的开始或结束
^	匹配字符串的开始
$	匹配字符串的结束

元字符^（和数字6在同一个键位上的符号）和$都匹配一个位置，这和"b有点类似。^匹配你要用来查找的字符串的开头，$匹配结尾。这两个代码在验证输入的内容时非常有用，比如一个网站如果要求你填写的QQ号必须为5位到12位数字时，可以使用：^"d{5,12}$。

这里的{5,12}和前面介绍过的{2}是类似的，只不过{2}匹配只能不多不少重复2次，{5,12}则是重复的次数不能少于5次，不能多于12次，否则都不匹配。

因为使用了^和$，所以输入的整个字符串都要用来和"d{5,12}来匹配，也就是说整个输入必须是5到12个数字，因此如果输入的QQ号能匹配这个正则表达式的话，那就符合要求了。

和忽略大小写的选项类似，有些正则表达式处理工具还有一个处理多行的选项。如果选中了这个选项，^和$的意义就变成了匹配行的开始处和结束处。

字符转义

如果你想查找元字符本身的话，比如你查找.,或者*,就出现了问题：你没办法指定它们，因为它们会被解释成别的意思。这时你就得使用"来取消这些字符的特殊意义。因此，你应该使用".和"*。当然，要查找"本身，你也得用"".

例如：unibetter".com匹配unibetter.com，C:""Windows匹配C:"Windows。

重复

你已经看过了前面的*,+,{2},{5,12}这几个匹配重复的方式了。下面是正则表达式中所有的限定符(指定数量的代码，例如*,{5,12}等)：

表2.常用的限定符
代码/语法	说明
*	重复零次或更多次
+	重复一次或更多次
?	重复零次或一次
{n}	重复n次
{n,}	重复n次或更多次
{n,m}	重复n到m次

下面是一些使用重复的例子：

Windows"d+匹配Windows后面跟1个或更多数字

^"w+匹配一行的第一个单词(或整个字符串的第一个单词，具体匹配哪个意思得看选项设置)

字符类

要想查找数字，字母或数字，空白是很简单的，因为已经有了对应这些字符集合的元字符，但是如果你想匹配没有预定义元字符的字符集合(比如元音字母a,e,i,o,u),应该怎么办？

很简单，你只需要在方括号里列出它们就行了，像[aeiou]就匹配任何一个英文元音字母，[.?!]匹配标点符号(.或?或!)。

我们也可以轻松地指定一个字符范围，像[0-9]代表的含意与"d就是完全一致的：一位数字；同理[a-z0-9A-Z_]也完全等同于"w（如果只考虑英文的话）。

下面是一个更复杂的表达式："(?0"d{2}[) -]?"d{8}。

“(”和“)”也是元字符，后面的分组节里会提到，所以在这里需要使用转义。

这个表达式可以匹配几种格式的电话号码，像(010)88886666，或022-22334455，或02912345678等。我们对它进行一些分析吧：首先是一个转义字符"(,它能出现0次或1次(?),然后是一个0，后面跟着2个数字("d{2})，然后是)或-或空格中的一个，它出现1次或不出现(?)，最后是8个数字("d{8})。

分枝条件

不幸的是，刚才那个表达式也能匹配010)12345678或(022-87654321这样的“不正确”的格式。要解决这个问题，我们需要用到分枝条件。正则表达式里的分枝条件指的是有几种规则，如果满足其中任意一种规则都应该当成匹配，具体方法是用|把不同的规则分隔开。听不明白？没关系，看例子：

0"d{2}-"d{8}|0"d{3}-"d{7}这个表达式能匹配两种以连字号分隔的电话号码：一种是三位区号，8位本地号(如010-12345678)，一种是4位区号，7位本地号(0376-2233445)。

"(0"d{2}")[- ]?"d{8}|0"d{2}[- ]?"d{8}这个表达式匹配3位区号的电话号码，其中区号可以用小括号括起来，也可以不用，区号与本地号间可以用连字号或空格间隔，也可以没有间隔。你可以试试用分枝条件把这个表达式扩展成也支持4位区号的。

"d{5}-"d{4}|"d{5}这个表达式用于匹配美国的邮政编码。美国邮编的规则是5位数字，或者用连字号间隔的9位数字。之所以要给出这个例子是因为它能说明一个问题：使用分枝条件时，要注意各个条件的顺序。如果你把它改成"d{5}|"d{5}-"d{4}的话，那么就只会匹配5位的邮编(以及9位邮编的前5位)。原因是匹配分枝条件时，将会从左到右地测试每个条件，如果满足了某个分枝的话，就不会去再管其它的条件了。

分组

我们已经提到了怎么重复单个字符（直接在字符后面加上限定符就行了）；但如果想要重复多个字符又该怎么办？你可以用小括号来指定子表达式(也叫做分组)，然后你就可以指定这个子表达式的重复次数了，你也可以对子表达式进行其它一些操作(后面会有介绍)。

("d{1,3}".){3}"d{1,3}是一个简单的IP地址匹配表达式。要理解这个表达式，请按下列顺序分析它："d{1,3}匹配1到3位的数字，("d{1,3}".){3}匹配三位数字加上一个英文句号(这个整体也就是这个分组)重复3次，最后再加上一个一到三位的数字("d{1,3})。

IP地址中每个数字都不能大于255，大家千万不要被《24》第三季的编剧给忽悠了...

不幸的是，它也将匹配256.300.888.999这种不可能存在的IP地址。如果能使用算术比较的话，或许能简单地解决这个问题，但是正则表达式中并不提供关于数学的任何功能，所以只能使用冗长的分组，选择，字符类来描述一个正确的IP地址：((2[0-4]"d|25[0-5]|[01]?"d"d?)".){3}(2[0-4]"d|25[0-5]|[01]?"d"d?)。

理解这个表达式的关键是理解2[0-4]"d|25[0-5]|[01]?"d"d?，这里我就不细说了，你自己应该能分析得出来它的意义。

反义

有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外，其它任意字符都行的情况，这时需要用到反义：

表3.常用的反义代码
代码/语法	说明
"W	匹配任意不是字母，数字，下划线，汉字的字符
"S	匹配任意不是空白符的字符
"D	匹配任意非数字的字符
"B	匹配不是单词开头或结束的位置
[^x]	匹配除了x以外的任意字符
[^aeiou]	匹配除了aeiou这几个字母以外的任意字符

例子："S+匹配不包含空白符的字符串。

]+>匹配用尖括号括起来的以a开头的字符串。

后向引用

使用小括号指定一个子表达式后，匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下，每个分组会自动拥有一个组号，规则是：从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推。

后向引用用于重复搜索前面某个分组匹配的文本。例如，"1代表分组1匹配的文本。难以理解？请看示例：

"b("w+)"b"s+"1"b可以用来匹配重复的单词，像go go, 或者kitty kitty。这个表达式首先是一个单词，也就是单词开始处和结束处之间的多于一个的字母或数字("b("w+)"b)，这个单词会被捕获到编号为1的分组中，然后是1个或几个空白符("s+)，最后是分组1中捕获的内容（也就是前面匹配的那个单词）("1)。

你也可以自己指定子表达式的组名。要指定一个子表达式的组名，请使用这样的语法：(?"w+)(或者把尖括号换成'也行：(?'Word'"w+)),这样就把"w+的组名指定为Word了。要反向引用这个分组捕获的内容，你可以使用"k,所以上一个例子也可以写成这样："b(?"w+)"b"s+"k"b。

使用小括号的时候，还有很多特定用途的语法。下面列出了最常用的一些：

表4.常用分组语法
分类	代码/语法	说明
捕获	(exp)	匹配exp,并捕获文本到自动命名的组里
	(?exp)	匹配exp,并捕获文本到名称为name的组里，也可以写成(?'name'exp)
	(?:exp)	匹配exp,不捕获匹配的文本，也不给此分组分配组号
零宽断言	(?=exp)	匹配exp前面的位置
	(?<=exp)	匹配exp后面的位置
	(?!exp)	匹配后面跟的不是exp的位置
	(?	匹配前面不是exp的位置
注释	(?#comment)	这种类型的分组不对正则表达式的处理产生任何影响，用于提供注释让人阅读

我们已经讨论了前两种语法。第三个(?:exp)不会改变正则表达式的处理方式，只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面，也不会拥有组号。

零宽断言

地球人，是不是觉得这些术语名称太复杂，太难记了？我也和你一样。知道有这么一种东西就行了，它叫什么，随它去吧！“无名，万物之始...”

接下来的四个用于查找在某些内容(但并不包括这些内容)之前或之后的东西，也就是说它们像"b,^,$那样用于指定一个位置，这个位置应该满足一定的条件(即断言)，因此它们也被称为零宽断言。最好还是拿例子来说明吧：

断言用来声明一个应该为真的事实。正则表达式中只有当断言为真时才会继续进行匹配。

(?=exp)也叫零宽度正预测先行断言，它断言自身出现的位置的后面能匹配表达式exp。比如"b"w+(?=ing"b)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如查找I'm singing while you're dancing.时，它会匹配sing和danc。

(?<=exp)也叫零宽度正回顾后发断言，它断言自身出现的位置的前面能匹配表达式exp。比如(?<="bre)"w+"b会匹配以re开头的单词的后半部分(除了re以外的部分)，例如在查找reading a book时，它匹配ading。

假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了)，你可以这样查找需要在前面和里面添加逗号的部分：((?<="d)"d{3})*"b，用它对1234567890进行查找时结果是234567890。

下面这个例子同时使用了这两种断言：(?<="s)"d+(?="s)匹配以空白符间隔的数字(再次强调，不包括这些空白符)。

负向零宽断言

前面我们提到过怎么查找不是某个字符或不在某个字符类里的字符的方法(反义)。但是如果我们只是想要确保某个字符没有出现，但并不想去匹配它时怎么办？例如，如果我们想查找这样的单词--它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样：

"b"w*q[^u]"w*"b匹配包含后面不是字母u的字母q的单词。但是如果多做测试(或者你思维足够敏锐，直接就观察出来了)，你会发现，如果q出现在单词的结尾的话，像Iraq,Benq，这个表达式就会出错。这是因为[^u]总要匹配一个字符，所以如果q是单词的最后一个字符的话，后面的[^u]将会匹配q后面的单词分隔符(可能是空格，或者是句号或其它的什么)，后面的"w*"b将会匹配下一个单词，于是"b"w*q[^u]"w*"b就能匹配整个Iraq fighting。负向零宽断言能解决这样的问题，因为它只匹配一个位置，并不消费任何字符。现在，我们可以这样来解决这个问题："b"w*q(?!u)"w*"b。

零宽度负预测先行断言(?!exp)，断言此位置的后面不能匹配表达式exp。例如："d{3}(?!"d)匹配三位数字，而且这三位数字的后面不能是数字；"b((?!abc)"w)+"b匹配不包含连续字符串abc的单词。

同理，我们可以用(?

请详细分析表达式(?<=<("w+)>).*(?=<"/"1>)，这个表达式最能表现零宽断言的真正用途。

一个更复杂的例子：(?<=<("w+)>).*(?=<"/"1>)匹配不包含属性的简单HTML标签内里的内容。()指定了这样的前缀：被尖括号括起来的单词(比如可能是)，然后是.*(任意的字符串),最后是一个后缀(?=<"/"1>)。注意后缀里的"/，它用到了前面提过的字符转义；"1则是一个反向引用，引用的正是捕获的第一组，前面的("w+)匹配的内容，这样如果前缀实际上是的话，后缀就是了。整个表达式匹配的是和之间的内容(再次提醒，不包括前缀和后缀本身)。

注释

小括号的另一种用途是通过语法(?#comment)来包含注释。例如：2[0-4]"d(?#200-249)|25[0-5](?#250-255)|[01]?"d"d?(?#0-199)。

要包含注释的话，最好是启用“忽略模式里的空白符”选项，这样在编写表达式时能任意的添加空格，Tab，换行，而实际使用时这些都将被忽略。启用这个选项后，在#后面到这一行结束的所有文本都将被当成注释忽略掉。例如，我们可以前面的一个表达式写成这样：

(?<= # 断言要匹配的文本的前缀
<("w+)> # 查找尖括号括起来的字母或数字(即HTML/XML标签)
) # 前缀结束
.* # 匹配任意文本
(?= # 断言要匹配的文本的后缀
<"/"1> # 查找尖括号括起来的内容：前面是一个"/"，后面是先前捕获的标签
) # 后缀结束

贪婪与懒惰

当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符。考虑这个表达式：a.*b，它将会匹配最长的以a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。这被称为贪婪匹配。

有时，我们更需要懒惰匹配，也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号?。这样.*?就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧：

a.*?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话，它会匹配aab（第一到第三个字符）和ab（第四到第五个字符）。

为什么第一个匹配是aab（第一到第三个字符）而不是ab（第二到第三个字符）？简单地说，因为正则表达式有另一条规则，比懒惰／贪婪规则的优先级更高：最先开始的匹配拥有最高的优先权——The match that begins earliest wins。

表5.懒惰限定符

代码/语法说明

*? 重复任意次，但尽可能少重复

+? 重复1次或更多次，但尽可能少重复

?? 重复0次或1次，但尽可能少重复

{n,m}? 重复n到m次，但尽可能少重复

{n,}? 重复n次以上，但尽可能少重复

处理选项

在C#中，你可以使用Regex(String, RegexOptions)构造函数来设置正则表达式的处理选项。如：Regex regex = new Regex(""ba"w{6}"b", RegexOptions.IgnoreCase);

上面介绍了几个选项如忽略大小写，处理多行等，这些选项能用来改变处理正则表达式的方式。下面是.Net中常用的正则表达式选项：

表6.常用的处理选项

名称说明

IgnoreCase(忽略大小写) 匹配时不区分大小写。

Multiline(多行模式) 更改^和$的含义，使它们分别在任意一行的行首和行尾匹配，而不仅仅在整个字符串的开头和结尾匹配。(在此模式下,$的精确含意是:匹配"n之前的位置以及字符串结束前的位置.)

Singleline(单行模式) 更改.的含义，使它与每一个字符匹配（包括换行符"n）。

IgnorePatternWhitespace(忽略空白) 忽略表达式中的非转义空白并启用由#标记的注释。

RightToLeft(从右向左查找) 匹配从右向左而不是从左向右进行。

ExplicitCapture(显式捕获) 仅捕获已被显式命名的组。

ECMAScript(JavaScript兼容模式) 使表达式的行为与它在JavaScript里的行为一致。

一个经常被问到的问题是：是不是只能同时使用多行模式和单行模式中的一种？答案是：不是。这两个选项之间没有任何关系，除了它们的名字比较相似（以至于让人感到疑惑）以外。

平衡组/递归匹配

这里介绍的平衡组语法是由.Net Framework支持的；其它语言／库不一定支持这种功能，或者支持此功能但需要使用不同的语法。

有时我们需要匹配像( 100 * ( 50 + 15 ) )这样的可嵌套的层次性结构，这时简单地使用"(.+")则只会匹配到最左边的左括号和最右边的右括号之间的内容(这里我们讨论的是贪婪模式，懒惰模式也有下面的问题)。假如原来的字符串里的左括号和右括号出现的次数不相等，比如( 5 / ( 3 + 2 ) ) )，那我们的匹配结果里两者的个数也不会相等。有没有办法在这样的字符串里匹配到最长的，配对的括号之间的内容呢？

为了避免(和"(把你的大脑彻底搞糊涂，我们还是用尖括号代替圆括号吧。现在我们的问题变成了如何把xx aa> yy这样的字符串里，最长的配对的尖括号内的内容捕获出来？

这里需要用到以下的语法构造：

(?'group') 把捕获的内容命名为group,并压入堆栈(Stack)

(?'-group') 从堆栈上弹出最后压入堆栈的名为group的捕获内容，如果堆栈本来为空，则本分组的匹配失败

(?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分

(?!) 零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败

如果你不是一个程序员（或者你自称程序员但是不知道堆栈是什么东西），你就这样理解上面的三种语法吧：第一个就是在黑板上写一个"group"，第二个就是从黑板上擦掉一个"group"，第三个就是看黑板上写的还有没有"group"，如果有就继续匹配yes部分，否则就匹配no部分。

我们需要做的是每碰到了左括号，就在压入一个"Open",每碰到一个右括号，就弹出一个，到了最后就看看堆栈是否为空－－如果不为空那就证明左括号比右括号多，那匹配就应该失败。正则表达式引擎会进行回溯(放弃最前面或最后面的一些字符)，尽量使整个表达式得到匹配。

< #最外层的左括号
[^<>]* #最外层的左括号后面的不是括号的内容
(
(
(?'Open'<) #碰到了左括号，在黑板上写一个"Open"
[^<>]* #匹配左括号后面的不是括号的内容
)+
(
(?'-Open'>) #碰到了右括号，擦掉一个"Open"
[^<>]* #匹配右括号后面不是括号的内容
)+
)*
(?(Open)(?!)) #在遇到最外层的右括号前面，判断黑板上还有没有没擦掉的"Open"；如果还有，则匹配失败
> #最外层的右括号

平衡组的一个最常见的应用就是匹配HTML,下面这个例子可以匹配嵌套的
标签：]*>[^<>]*(((?'Open']*>)[^<>]*)+((?'-Open'
)[^<>]*)+)*(?(Open)(?!)).

还有些什么东西没提到

我已经描述了构造正则表达式的大量元素，还有一些我没有提到的东西。下面是未提到的元素的列表，包含语法和简单的说明。你可以在网上找到更详细的参考资料来学习它们--当你需要用到它们的时候。如果你安装了MSDN Library,你也可以在里面找到关于.net下正则表达式详细的文档。

表7.尚未详细讨论的语法

代码/语法说明

"a 报警字符(打印它的效果是电脑嘀一声)

"b 通常是单词分界位置，但如果在字符类里使用代表退格

"t 制表符，Tab

"r 回车

"v 竖向制表符

"f 换页符

"n 换行符

"e Escape

"0nn ASCII代码中八进制代码为nn的字符

"xnn ASCII代码中十六进制代码为nn的字符

"unnnn Unicode代码中十六进制代码为nnnn的字符

"cN ASCII控制字符。比如"cC代表Ctrl+C

"A 字符串开头(类似^，但不受处理多行选项的影响)

"Z 字符串结尾或行尾(不受处理多行选项的影响)

"z 字符串结尾(类似$，但不受处理多行选项的影响)

"G 当前搜索的开头

"p{name} Unicode中命名为name的字符类，例如"p{IsGreek}

(?>exp) 贪婪子表达式

(?-exp) 平衡组

(?im-nsx:exp) 在子表达式exp中改变处理选项

(?im-nsx) 为表达式后面的部分改变处理选项

(?(exp)yes|no) 把exp当作零宽正向先行断言，如果在这个位置能匹配，使用yes作为此组的表达式；否则使用no

(?(exp)yes) 同上，只是使用空表达式作为no

(?(name)yes|no) 如果命名为name的组捕获到了内容，使用yes作为表达式；否则使用no

(?(name)yes) 同上，只是使用空表达式作为no

礼物 2009-02-02 08:44 发表评论

表5.懒惰限定符
代码/语法	说明
*?	重复任意次，但尽可能少重复
+?	重复1次或更多次，但尽可能少重复
??	重复0次或1次，但尽可能少重复
{n,m}?	重复n到m次，但尽可能少重复
{n,}?	重复n次以上，但尽可能少重复

表6.常用的处理选项
名称	说明
IgnoreCase(忽略大小写)	匹配时不区分大小写。
Multiline(多行模式)	更改^和$的含义，使它们分别在任意一行的行首和行尾匹配，而不仅仅在整个字符串的开头和结尾匹配。(在此模式下,$的精确含意是:匹配"n之前的位置以及字符串结束前的位置.)
Singleline(单行模式)	更改.的含义，使它与每一个字符匹配（包括换行符"n）。
IgnorePatternWhitespace(忽略空白)	忽略表达式中的非转义空白并启用由#标记的注释。
RightToLeft(从右向左查找)	匹配从右向左而不是从左向右进行。
ExplicitCapture(显式捕获)	仅捕获已被显式命名的组。
ECMAScript(JavaScript兼容模式)	使表达式的行为与它在JavaScript里的行为一致。

表7.尚未详细讨论的语法
代码/语法	说明
"a	报警字符(打印它的效果是电脑嘀一声)
"b	通常是单词分界位置，但如果在字符类里使用代表退格
"t	制表符，Tab
"r	回车
"v	竖向制表符
"f	换页符
"n	换行符
"e	Escape
"0nn	ASCII代码中八进制代码为nn的字符
"xnn	ASCII代码中十六进制代码为nn的字符
"unnnn	Unicode代码中十六进制代码为nnnn的字符
"cN	ASCII控制字符。比如"cC代表Ctrl+C
"A	字符串开头(类似^，但不受处理多行选项的影响)
"Z	字符串结尾或行尾(不受处理多行选项的影响)
"z	字符串结尾(类似$，但不受处理多行选项的影响)
"G	当前搜索的开头
"p{name}	Unicode中命名为name的字符类，例如"p{IsGreek}
(?>exp)	贪婪子表达式
(?-exp)	平衡组
(?im-nsx:exp)	在子表达式exp中改变处理选项
(?im-nsx)	为表达式后面的部分改变处理选项
(?(exp)yes\|no)	把exp当作零宽正向先行断言，如果在这个位置能匹配，使用yes作为此组的表达式；否则使用no
(?(exp)yes)	同上，只是使用空表达式作为no
(?(name)yes\|no)	如果命名为name的组捕获到了内容，使用yes作为表达式；否则使用no
(?(name)yes)	同上，只是使用空表达式作为no

将任意格式转换为JSON数据格式的工具类

礼物 — Mon, 05 Jan 2009 15:11:00 GMT
     摘要: package org.sjw.utils; import java.beans.IntrospectionException; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.util.List; im...  阅读全文

礼物 2009-01-05 23:11 发表评论

HTTP/1.1 Cache-Control的理解

礼物 — Mon, 05 Jan 2009 15:06:00 GMT
网页的缓存是由HTTP消息头中的“Cache-control”来控制的，常见的取值有private、no-cache、max-age、must-revalidate等，默认为private。其作用根据不同的重新浏览方式分为以下几种情况：
（1）打开新窗口
如果指定cache-control的值为private、no-cache、must-revalidate，那么打开新窗口访问时都会重新访问服务器。而如果指定了max-age值，那么在此值内的时间里就不会重新访问服务器，例如：
Cache-control: max-age=5
表示当访问此网页后的5秒内再次访问不会去服务器
（2）在地址栏回车
如果值为private或must-revalidate（和网上说的不一样），则只有第一次访问时会访问服务器，以后就不再访问。如果值为no-cache，那么每次都会访问。如果值为max-age，则在过期之前不会重复访问。
（3）按后退按扭
如果值为private、must-revalidate、max-age，则不会重访问，而如果为no-cache，则每次都重复访问
（4）按刷新按扭
无论为何值，都会重复访问

项目中使用过滤器来设置网页的缓存

FilterConfig fc;

    public void doFilter(ServletRequest req, ServletResponse res,
            FilterChain chain) throws IOException, ServletException {
        HttpServletResponse response = (HttpServletResponse) res;
        // set the provided HTTP response parameters
        for (Enumeration e = fc.getInitParameterNames(); e.hasMoreElements();) {
            String headerName = (String) e.nextElement();
            response.addHeader(headerName, fc.getInitParameter(headerName));
        }
        // pass the request/response on
        chain.doFilter(req, response);
    }

配置文件的配置：

<filter>
        <filter-name>NoCachefilter-name>
        <filter-class>filter.CacheFilterfilter-class>
        <init-param>
            <param-name>Cache-Controlparam-name>
            <param-value>no-cache, must-revalidateparam-value>
        init-param>
    filter>
    <filter>
        <filter-name>CacheForWeekfilter-name>
        <filter-class>filter.CacheFilterfilter-class>
        <init-param>
            <param-name>Cache-Controlparam-name>
            <param-value>max-age=604800param-value>
        init-param>
    filter>

    <filter-mapping>
        <filter-name>CacheForWeekfilter-name>
        <url-pattern>*.jsurl-pattern>
    filter-mapping>
    <filter-mapping>
        <filter-name>CacheForWeekfilter-name>
        <url-pattern>*.cssurl-pattern>
    filter-mapping>
    <filter-mapping>
        <filter-name>CacheForWeekfilter-name>
        <url-pattern>*.gifurl-pattern>
    filter-mapping>

上述设置保存了1周的缓存。

礼物 2009-01-05 23:06 发表评论

Tomcat下绑定JMS应用服务器的实例讲解

礼物 — Wed, 31 Dec 2008 10:07:00 GMT

JMS做为J2EE的高级部分一直蒙着一层神秘的面纱，作为JMS的定制者SUN只规定了JMS规范，象很多其他SUN产品一样被多家厂商提供了具体的实现。但是作为tomcat和RESIN（今年初宣布全部支持J2EE规范）。这些面向低端但却被广泛应用的服务器本身并不对JMS提供支持。庆幸的是openjms和activeMQ两家开源软件提供了插件式的支持。

在应用了一些开发框架如spring的项目里如果要使用到JMS，虽然SPRING提供了部分对JMS的支持但经过我一段时间的应用发现，OO的封装在某些地方反而成为开发过程中的障碍。在实现诸如监听之类的代码段里使人非常的懊恼，即使用callback(回调)有些东西仍然不能够很好的被取到。

下面就一些TOMCAT上面JMS的支持既实现做一下整理。

1.很自然的你需要下载JMS实现,如:opnerJMS或者activeMQ .下载地址www.jmsopen.com 或www.activeMQ.com

2.服务器下载以后的具体配置在以上两个网站上都有很详细的说明，就不再列举了。

3.和WEB服务器的整合，首先要配置应用的web.xml这个文件配置如下：

1
2 brokerURI
3 /WEB-INF/activemq.xml
4
5
6
7 org.activemq.web.SpringBrokerContextListener
8

将这一段代码放到web.xml里。注意到activemq.xml文件，是jms服务器的具体配置：

"-//ACTIVEMQ//DTD//EN"
"http://activemq.org/dtd/activemq.dtd">

uri="tcp://localhost:61616"
useAsyncSend="true"
maxOutstandingMessages="50"/>

dataSourceRef="oracle-ds"/>

"org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">

org.apache.derby.jdbc.EmbeddedDriver

jdbc:derby:derbydb;create=true

true

此时，在启动你的TOMCAT的时候会看到JMS服务器已经绑到了上面。

礼物 2008-12-31 18:07 发表评论

(转载)将任意格式转换为JSON数据格式的工具类

礼物 — Tue, 30 Dec 2008 02:57:00 GMT
     摘要: package org.sjw.utils; import java.beans.IntrospectionException; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.util.List; import&nbs...  阅读全文

礼物 2008-12-30 10:57 发表评论

JAVA加密算法简介

礼物 — Thu, 18 Dec 2008 00:52:00 GMT
     摘要: 通常,使用的加密算法比较简便高效,密钥简短，加解密速度快，破译极其困难。本文介绍了 MD5/SHA1，DSA，DESede/DES，Diffie-Hellman的使用。　　第1章基础知识　　1.1. 单钥密码体制　　单钥密码体制是一种传统的加密算法，是指信息的发送方和接收方共同使用同一把密钥进行加解密。　　通常,使用的加密算法比较简便高效,密钥简短，...  阅读全文

礼物 2008-12-18 08:52 发表评论

url加密参数（java版）

礼物 — Thu, 18 Dec 2008 00:51:00 GMT

**

*加密解密类
*
*
*
*/
package com.abacus.common ;
import java.security. *;
import javax.crypto. *;
/**
*加密解密类

*/
public class Eryptogram
{
    private static String Algorithm ="DES";
    //定义加密算法,可用DES,DESede,Blowfish
　　     static boolean debug =false ;
    /**
    *构造子注解.
    */
    public Eryptogram ()
    {
    }
    /**
    *生成密钥
    *@returnbyte[]返回生成的密钥
    *@throwsexception扔出异常.
    */
    public static byte []getSecretKey ()throws Exception
    {
        KeyGenerator keygen =KeyGenerator.getInstance (Algorithm );
        SecretKey deskey =keygen.generateKey ();
        if (debug )System.out.println ("生成密钥:"+byte2hex (deskey.getEncoded ()));
        return deskey.getEncoded ();
    }
    /**
    *将指定的数据根据提供的密钥进行加密
    *@paraminput需要加密的数据
    *@paramkey密钥
    *@returnbyte[]加密后的数据
    *@throwsException
    */
    public static byte []encryptData (byte []input ,byte []key )throws Exception
    {
        SecretKey deskey =new javax.crypto.spec.SecretKeySpec (key ,Algorithm );
        if (debug )
        {
            System.out.println ("加密前的二进串:"+byte2hex (input ));
            System.out.println ("加密前的字符串:"+new String (input ));
        }
        Cipher c1 =Cipher.getInstance (Algorithm );
        c1.init (Cipher.ENCRYPT_MODE ,deskey );
        byte []cipherByte =c1.doFinal (input );
        if (debug )System.out.println ("加密后的二进串:"+byte2hex (cipherByte ));
        return cipherByte ;
    }
    /**
    *将给定的已加密的数据通过指定的密钥进行解密
    *@paraminput待解密的数据
    *@paramkey密钥
    *@returnbyte[]解密后的数据
    *@throwsException
    */
    public static byte []decryptData (byte []input ,byte []key )throws Exception
    {
        SecretKey deskey =new javax.crypto.spec.SecretKeySpec (key ,Algorithm );
        if (debug )System.out.println ("解密前的信息:"+byte2hex (input ));
        Cipher c1 =Cipher.getInstance (Algorithm );
        c1.init (Cipher.DECRYPT_MODE ,deskey );
        byte []clearByte =c1.doFinal (input );
        if (debug )
        {
            System.out.println ("解密后的二进串:"+byte2hex (clearByte ));
            System.out.println ("解密后的字符串:"+(new String (clearByte )));
        }
        return clearByte ;
    }
    /**
    *字节码转换成16进制字符串
    *@parambyte[]b输入要转换的字节码
    *@returnString返回转换后的16进制字符串
    */
    public static String byte2hex (byte []b )
    {
        String hs ="";
        String stmp ="";
        for (int n =0 ;n <b.length ;n ++)
        {
            stmp =(java.lang.Integer.toHexString (b [n ]&0XFF ));
            if (stmp.length ()==1 )hs =hs +"0"+stmp ;
            else hs =hs +stmp ;
            if (n <b.length -1 )hs =hs +":";
        }
        return hs.toUpperCase ();
    }
    public static void main (String []args )
    {
        try
        {
            debug =false ;
            Eryptogram etg =new Eryptogram ();
            byte []key =etg.getSecretKey ();
            System.out.println ("key="+key );
            String aa ="1234567";
            byte []data =aa.getBytes ();
            System.out.println (data );
            byte []en =etg.encryptData (data ,key );
            System.out.println ("encryptData="+new String (en ));
            byte []de =etg.decryptData (en ,key );
            System.out.println ("decryptData="+new String (de ));
        }
        catch (Exception e )
        {
            e.printStackTrace ();
        }
    }
}

礼物 2008-12-18 08:51 发表评论

FreeMarker学习笔记

礼物 — Thu, 11 Dec 2008 06:34:00 GMT
１. 模板＋数据模型＝输出
２. 数据模型
a) 类似目录的变量称为hashes,包含保存下级变量的唯一的查询名字,充当其它对象的容器,每个都关联唯一的查询名字
b) 类似文件的变量称为scalars,保存单值,有两种类型
i. 字符串:用引号括起,单引号or双引号
ii. 数字:不用引号
iii. 日期:可以是日期,时间或日期-时间
iv. 布尔值:true或false,通常在<#if …>标记中使用
v. 对scalars的访问从root开始,各部分用”.”分隔,如 animals.mouse.price
c) 另外一种变量是sequences,和hashes类似,充当其它对象的容器,按次序访问,只是不使用变量名字,而使用数字索引,如animals[0].name,索引值从0开始
d) 通常每个变量具有上述的一种能力,但一个变量可以具有多种上述能力
e) 方法
i. ${avg(3,5,20)} ${avg(student.zhangyaang.age,student.situ.age)}
f) 宏和变换器:用户自定义的指令(FTL标记)
g) 节点:树形结构中的一个节点,常用于xml处理中
３. 模板
a) 文本:直接输出
b) ${…}:称为interpolations,FreeMarker会在输出时用实际值代替,或#{},只用于文本中
c) FTL标记:类似于HTML,为了与HTML区分,用#开始,有的以@开始,不会输出,区分大小写,FTL标记不能位于另一个FTL标记内部
d) 注释:<#--和-->,不会输出
e) 多余的空白字符会在模板输出时移除
f) 指令
i. 使用FTL标记引用指令,有三种FTL标记
1. 开始标记:<#name prarm>
2. 结束标记:
3. 空内容指令标记:<#name param />
ii. 有两种类型的指令:预定义指令和用户定义指令,用户定义指令要用@替换#
iii. FTL标记不能够交叉,应该正确嵌套
iv. 如果使用不存在的指令,FreeMarker会产生错误消息
v. < , g) 表达式
i. 字符串
1. 使用单引号或双引号限定
2. 特殊字符要转义
3. raw字符串,可以认为是文本,其中的$和{等不具有特殊含义,该类字符串在引号前面加r,如${r”${foo}”} ${r”c:"foo"bar”}
ii. 数字
1. 直接输入,不需要引号
2. 精度数字使用”.”分隔,不能使用分组符号
3. 不支持科学计数法
4. 不能省略小数点前面的0
5. 数字8 ,+8 ,08和8.00 都是相同的
iii. 布尔值:true 和 false, 不使用引号
iv. 序列
1. 有逗号分隔的子变量列表,有方括号限定,如:
<#list [“winter”, ”spring”, ”summer”, ”autumn”] as x>
${x}

2. 列表的项目是表达式,如:
[2+2, [1,2,3,4], ”whatnot”]
3. 可以使用数字范围定义数字序列,如:
2..5等同于[2,3,4,5] 注意:数字范围没有方括号如:5..2
4. 散列(hash) 由逗号的键/值列表,有大括号限定,键和值之间用冒号分隔
{“name”:”zhangyang”,”age”:23} 键和值都是表达式,但键必须是字符串
v. 获取变量
1. 顶层变量:${variable}, 变量名只能是字母, 数字, 下划线, $, @ 和# 的组合, 不能以数字开头
2. 从散列中获取数据
a) school.student.name
b) school.[“student”].name
c) school[“student”][“name”]
说明:使用点语法,变量名有顶层变量一样的限制, 方括号语法没有该限制
3. 从序列获(sequences)得数据: 和散列的方括号语法一样, 只是方括号的表达式值必须是数字; 注意: 第一个项目的索引是0
4. 序列片段: 使用[startIndex..endIndex]语法, 从序列中获得片段(也是序列)
5. 特殊变量: FreeMarker内定义的变量, 使用 .variablenae 语法访问
vi. 字符串操作
1. Interpolation(或连接操作)
a) 可以使用${..} 或#{..} 在文本部分插入表达式的值,
如${“Hello ${user}”} 等于 ${“Hello”+user}
b) ${..} 只能用于文本部分, 不用于FTL表达式中
2. 子串
假设user的值为”tom cat”
${user[0]}${user[4]}  tc
${user[1..4]}  om c
vii. 序列操作
连接操作: 和字符串一样, 用”+”
<#list [“joe”,”fred”] + [“julia”,”kate”] as user>
${user}

viii. 散列操作
连接操作: 和字符串一样, 用”+”, 如果有相同的key, 右边的值替换左边的值(后面的替换前面的), 如
<#assign ages = {“joe”:23,”fred”:25} + {“joe”:30,”julia”:23}>
结果: joe的值为30
ix. 算术运算
1. +, -- , *, /, %
${x / 2}
2. 操作符两边必须是数字
3. 使用 “+” 操作符时,如果一边是数字, 一边是字符串, 就会自动将数字转换为字符串, 如: ${3+”4”} 结果 34
4. 使用内建的 int 获得整数部分
${1.1?int} 1
${1.999?int} 1
${(5/2)?int} 2
5. 比较操作符
a) 使用=(或==,完全相等)测试两个值是否相等, 使用!=测试两个值是否不相等
b) = 和!= 两边必须是相同类型的值
c) FreeMarker是精确比较,”x”,”x “和”x”是不等的
d) 对数字和日期可以使用<, <=, >, 和>=, 但不用用于字符串
e) 由于FreeMarker 会将>解释成FTL标记的结束字符, 所以对于>和>=可以使用括号来避免这种情况, 如<#if (x > y)>
f) e)的一种替代方法, 使用lt, lte, gt 和gte来替代
6. 逻辑操作符
a) &&(and), ||(or), !(not), 只能用于布尔值
<#if x < 13 && color = “green”>
…

<#if ! man>
woman

7. 内建函数
a) 内建函数的用法类似访问散列的子变量, 只是用”?”|替代”,”
b) 用于字符串
i. html: 对字符串进行html编码
ii. cap_first: 将字符串转换成第一个字母大写
iii. lower_case: 小写
iv. upper_case: 大写
v. trim: 去掉字符串前后的空白字符
c) 用于序列
i. size: 获得序列中元素的数目
d) 用于数字
i. int: 取得数字的整数部分
e) 例子:
test = “tom & jerry”
${test?html}  tom & jerry
${test?upper_case?html}  TOM & JERRY
8. 操作符优先顺序
h) Interpolation(只用于文本部分)
i. Interpolation有两种类型
1. 通用Interpolation: ${expr}
a) 插入字符串值: 直接输出表达式结果
b) 插入数字值: 根据缺省格式(由#setting指令设置)将表达式转换成文本输出; 可以使用内建函数string格式化单个Interpolation
c) 例子
<#setting number_format=”currency”/> 金额
<#assign answer=43/>
${answer}  $43.00
${answer?string} $43.00
${answer?string.number} 43
${answer?string.currency} $43.00
${answer?string.percent} 4,300%
2. 数字Interpolation: ${expr} 或#{expr ; format}
3. 插入日期: 根据缺省格式(#setting) 将表达式结果转换成文本输出; 可以使用内建的函数string 格式化单个Interpolation, 例子:
${update?string(“yyyy-MM-dd HH:mm:ss zzzz”)}
4. 插入布尔值: 说明同上
<#assign foo = true/>
${foo?string(“yes”,”no”)} yes
5. 数字Interpolation的#{expr ; format}形式可以用来格式化数字, format可以是
a) mX: 小数部分最小X位
b) MX: 小数部分最大X位
c) 例子
<#assign x=2.364/>
<#assign y=4/>
#{x; M2} 2.36
#{y; M2} 4
#{x; m1} 2.4
#{y; m1} 4.0
i) 例子
i. if指令
<#if zhangyang.age < situ.age>
Situ is order
<#else>
Zhangyang is order

ii. list指令 <#list students[0..5] as s_list>取list的前5条记录

<#list students as s_list>

name age ${s_list.name} ${s_list.age}

iii. include指令
<#include “/all/header.html”>
…
<#include “/all/footer.html”>
iv. 应用

<#list students as s_list>

<#if s_list.sex =”man”>
<#else>

${s_list.name}
${s_list.age}

４. 用户自定义指令
a) 宏和变换器
b) 模板中定义变量
c) 名字空间(命名空间)
５. 应用
a) List
i. 例子1
List scalarList = new ArrayList();
scalarList.add("red");
scalarList.add("green");
scalarList.add("blue");
scalarList.add("yellow");
root.put("scList", scalarList);

<#list scList as the_value>
Scalar List值:${the_value}

ii. 例子2
public class User {
private String userId;
private String userName;
}

User u1 = new User();
u1.setUserId("100");
u1.setUserName("郜司徒");

User u2 = new User();
u2.setUserId("200");
u2.setUserName("张宇伟");

User u3 = new User();
u3.setUserId("300");
u3.setUserName("冯钰凯");

User u4 = new User();
u4.setUserId("400");
u4.setUserName("苗先杰");

SimpleSequence userList = new SimpleSequence(ObjectWrapper.BEANS_WRAPPER);
userList.add(u1);
userList.add(u2);
userList.add(u3);
userList.add(u4);

root.put("userList", userList);

<#list userList as list>
List对象user的值:${list.userId}
List的value:${list.userName}

b) Map
i. 例子1
SimpleHash scalarMap = new SimpleHash(ObjectWrapper.BEANS_WRAPPER);
scalarMap.put("anotherString", "aaaaaaaa");
scalarMap.put("anotherNumber", new Double(2.5555));

root.put("scMap", scalarMap);

<#list scMap?keys as myKey>
Map key is:${myKey}
map value is:${scMap[myKey]}

ii. 例子2
SimpleHash userMap = new SimpleHash(ObjectWrapper.BEANS_WRAPPER);
userMap.put("1", u1);
userMap.put("2", u2);
userMap.put("3", u3);
userMap.put("4", u4);
root.put("user", userMap);

<#list user?keys as key1>
${key1}
${user[key1].userId}
${user[key1].userName}

<#assign u = "${user[key1]}">
User is :${u}

c) List和Map
SimpleHash root = new SimpleHash(/*ObjectWrapper.BEANS_WRAPPER*/);
// Map my_map = new HashMap();
SimpleHash my_map = new SimpleHash();
my_map.put("1", "ehow");
my_map.put("2", "laomiao");
my_map.put("3", "yukai");
my_map.put("zt", "北京中天诺士达");

SimpleHash my_map2 = new SimpleHash();
my_map2.put("1", "ehow2");
my_map2.put("2", "laomiao2");
my_map2.put("3", "yukai2");
my_map2.put("zt", "北京中天诺士达2");

SimpleHash my_map3 = new SimpleHash();
my_map3.put("1", "ehow3");
my_map3.put("2", "laomiao3");
my_map3.put("3", "yukai3");
my_map3.put("zt", "北京中天诺士达3");

SimpleHash my_map4 = new SimpleHash();
my_map4.put("1", "ehow4");
my_map4.put("2", "laomiao4");
my_map4.put("3", "yukai4");
my_map4.put("zt", "北京中天诺士达4");

// List userList = new ArrayList();

SimpleSequence userList=new SimpleSequence(/*ObjectWrapper.BEANS_WRAPPER*/);
userList.add(my_map);
userList.add(my_map2);
userList.add(my_map3);

SimpleSequence userList2 = new SimpleSequence();
userList2.add(my_map4);
userList2.add(my_map4);
userList2.add(my_map4);

root.put("the_list", userList);
root.put("other_list", userList2);







    <#list the_list as list>







    <#list other_list as list2>








代号代号2 代号3 明细

${list["1"]} ${list["2"]} ${list["3"]} ${list.zt}

${list2["1"]} ${list2["2"]} ${list2["3"]} ${list2["zt"]}

d) 与Hibernate结合
DAO
String hql = "select new map(s.s_name as s_n,s.s_addr as s_a,h.h_addr as h_a,u.u_name as u_n) from User_school as s,User_home as h,User_info as u where u.id=h.id and h.id=s.id";
// String hql = "select new map(s.s_name as s_n,s.s_addr as s_a) from User_school as s";
List my = session.createQuery(hql).list();
Hello hello = new Hello();
hello.sayHello(my);

通用方法
public void sayHello(List info){
...
root.put("from_db", info);
...
}

FTL
<#list from_db as db>
${db.s_n}
${db.s_a}
${db.h_a}
${db.u_n}

e) 我们的项目
<#assign n = list5?size /> //定义n的值为list5的大小
<#if n gt 6> //如果n大于6,页面中可能要求只显示6条
<#assign n = 6 /> //把n重定义为6

<#if n!=0> //防止n的值为0,也可以写成<#if n gt 0 >
<#list 0..(n-1) as i> //把前 n 条记录赋值给 i,如果i=3,则[0,1,2]
<#assign ls5 = list5[i] /> //把list5的第i个元素赋值给ls5
<#assign isNew = list5Istrue[i] />

.
<#if ls5.CTitle?length lt 15> //如果Ctitle的长度小于15,就
${ls5.CTitle} //就正常显示该标题
<#else> //如果大于15
${ls5.CTitle[0..15]}... //就截取前15个,并加上…

<#if isNew="true">

FreeMarker学习笔记.rar (212.9 KB)

描述: 这是格式良好的pdf

下载次数: 67

礼物 2008-12-11 14:34 发表评论

压缩/解压缩zip包处理

礼物 — Sun, 07 Dec 2008 03:03:00 GMT
     摘要: package com.newegg.lab.util; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; imp...  阅读全文

礼物 2008-12-07 11:03 发表评论

UUIDGenerator 主键产生器

礼物 — Wed, 17 Sep 2008 10:34:00 GMT

package com.newegg.lib;

import org.safehaus.uuid.UUIDGenerator;

public class UUIDImpl {
    private UUIDGenerator _uuidGenerator = UUIDGenerator.getInstance();

    public String generate() {
        return _uuidGenerator.generateRandomBasedUUID().toString();
    }

    /** *//**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        UUIDImpl impl = new UUIDImpl();
        for (int i = 0; i < 10; i++) {
            System.out.println(impl.generate());
        }

    }

}

依赖：

      org.safehaus.jug
      jug
      2.0.0


礼物 2008-09-17 18:34 发表评论

JBOSS只能用localhost或127.0.0.1访问的解决办法

礼物 — Sat, 28 Jun 2008 12:28:00 GMT
今天配置了一下新版本的JBOSS，启动后发现只能使用localhost访问了，ip访问不到，查找了一下发现，4.2以上的版本不对所有本机ip进行监听了，解决办法是增加启动参数-b 192.168.x.x或-b 0.0.0.0，或者增加Djboss.bind.address=0.0.0.0参数，或者修改jboss\server\default\deploy\jboss-web.deployer\server.xml里的Connector 下面的address，把变量改成对应的IP或者0.0.0.0。

礼物 2008-06-28 20:28 发表评论

Jboss 和 JMS

礼物 — Sat, 28 Jun 2008 12:22:00 GMT
1、介绍
本章介绍在Jboss中使用Java Messageing Service (JMS). 不是JMS指南，而是JBoss和JMS如何一起使用，如果你想看JMS的介绍，请参考 JMS Specification 或 JMS turorial.
最近随着JBoss版本不断更新，对JMS支持越来越成熟，也造成JBoss各个版本之间的不同。在这里我主要介绍JBoss3.0.X版本。
本章给出的例子比较简单，并指出了如何使用JMS的原理。所有的例子可以通过ant build file 来建立。
为了能建立和运行此例子。我们使用两种方式来进行：一是使用Ant命令，二是使用JAR和JAVA基本命令。必须有下面的环境变量：
w JAVA_HOME 安装JDK1.4的目录。
w JBOSS_DIST 安装JBoss的目录。
你必须安装JDK, 如果使用Ant必须安装 Ant。可以参考我前面文档的介绍。
2、概述
1）什么是JMS
JMS是Java API, 允许应用程序来建立、接收和读取消息。程序依靠这些API, 在运行时需要一个JMS实现接口，来提供管理和控制，这被称为JMS provider, 现在有几种不同的JMS Provider; 在JBoss中的叫做JbossMQ。
2） JMS 和J2EE
JMS是在EJB和J2EE框架开发之前进行开发的，所以在JMS说明书中没有涉及到EJB或J2EE。
EJB 和J2EE第一代版本中也没有涉及到JMS，一直到EJB1.1，在生成一个可用Beand的容器provider中JMS也不是必须的API。在J2EE1.2中JMS接口是必需的情况，但并不是非得要包含一个JMS Provider；在EJB2.0和J2EE1.3中又进行改变，应用服务器包含了一个JMS Provider，自从J2EE1。3需要EJB2.0，增加了以下两个JMS特性：
w 一种新Bean类型定义，也就是消息驱动Beam (MDB), 这种bean做为JMS消息监听者，可以异步地处理JMS消息。
w JMS处理作为资源，来自一个Bean 的JMD 发布（发送）必须能和其他bean的全局事务环境共享。这个需要把JMS认为是一个容器管理资源，象JDBC的连接。
3） JMS 和JBoss
JBoss从2.0版本以后都支持JMS。在2.1中增加了MDB，从2.4版本开始JMS作为一个事务资源。
JBoss中JMS的体系结构如下：
w JMS Provider, 叫做JbossMQ 。是JBoss实现JMS 1.0.2规范的一部分，包括可选部分，象ASF（Application Service Facvility）。 JbossMQ处理和普遍JMS一样：建立 queues (队列)或topic(标题)，持久性等。
w MDB (Message Driven Beans),
w 资源适配器。

3、JMS Provider
JBoss有它自己的JMS Provider 叫做JbossMQ。适合与JMS 1.0.2 的JMS Provider，并且能用在所有平常的JMS程序中。为了清楚在JBoss中JMS是如何工作的，首先要清楚在JMS中涉及到的概念和术语，最好的办法是阅读JMS规范，下面给出了简单的JMS介绍。
1) JMS的简单介绍
当你发送一个消息，你不能直接发送到对此消息感兴趣的接受者。而是你发送到一个目的地。对此消息感兴趣的接受者必须连接到目的地，得到此消息或在目的地设置订阅。
在JMS中有两种域：topics 和queues 。
w 一个消息发送到一个topics ，可以有多个客户端。用topic发布允许一对多，或多对多通讯通道。消息的产生者被叫做publisher, 消息接受者叫做subscriber。
w queue 是另外一种方式，仅仅允许一个消息传送给一个客户。一个发送者将消息放在消息队列中，接受者从队列中抽取并得到消息，消息就会在队列中消失。第一个接受者抽取并得到消息后，其他人就不能在得到它。
为了能发送和接收消息，必须得到一个JMS连接。该连接是使用JMS Provider得到连接的，在得到连接之后，建立一个会话(Session)。然后再建立publisher/sender 来发送消息或subscriber/receiver来接收消息。
运行时，如果使用topic 那么publisher 或subscriber 通过一个topic来关联，如果使用queue ，则sender 或receiver通过queue来关联起来。
通常，在JMS框架中运转的方法如下：
(1) 得到一个JNDI初始化上下文(Context)；
(2) 根据上下文来查找一个连接工厂TopicConnectFactory/ QueueConnectionFactory (有两种连接工厂，根据是topic/queue来使用相应的类型)；
(3) 从连接工厂得到一个连接(Connect 有两种[TopicConnection/ QueueConnection]);
(4) 通过连接来建立一个会话(Session);
(5) 查找目的地(Topic/ Queue);
(6) 根据会话以及目的地来建立消息制造者(TopicPublisher/QueueSender)和消费者(TopicSubscriber/ QueueReceiver).
为了得到一个连接和得到一个目的地（用来关联publisher/sender 或subscriber/receiver），必须用provider-specific参数。
通过JNDI来查找相应的连接工厂或目的地，JNDI适合于任何JMS Provider。但是查找用的名字是provider使用的。因此，在你使用的JMS Provider（其中包括JBossMQ），必须学会如何进行指定。JMS Provider中的任何设置，象连接特性，用到目的地等，在用到的Provider都有明确描述。
2) 配置
当使用一个JMS Provider时，有三个Provider-specific因素：
w 得到一个JNDI初始化上下文
w 用到的连接工厂的名字。
w 对目的地的管理和命名协定。
JBoss同它的JNDI一起执行。为了简单的JMS client，配置和查找初始化上下文，同实现其他J2EE客户端一样。
JMS-specific 来约束JBoss 的JMS provider (JBossMQ)。JbossMQ是通过xml 文件jbossmq-service.xml进行配置的，该文件放在在serverdefaultdeploy下。
在xml文件中最基本的三件事情：
w 增加一个新的目的地
w 配置用户
w 获得可用连接工厂的名字。
(1) 增加新的目的地
w 在目的地的xml文件在jboss 3.x中是jbossmq-destinations-service.xml（server/../deploy）。在文件中已经存在几个缺省的目的地，所以你比较容易明白怎样增加到文件中。在例子中你需要一个topic目的地 spool，所以增加下面的语句到jbossmq-destinations-service.xml中。这种方式是长久存在的，不随着JBoss服务器关闭而消失。
name="jboss.mq.destination:service=Topic,name=spool">
jboss.mq:service=DestinationManager

w 另外一种方法是可以通过JMX HTML管理界面。通过http://localhost:8080/jmx-console 来访问。在jboss.mq 下查找service=DestinationManager 的连接。然后在createTopic()或createQueue()来建立，这种方法建立的目的地是临时性的，随着服务器开始存在，当当JBoss 服务器重新启动时，动态建立的目的地将会不存在。在JbossMQ中所有目的地都有一个目的地类型的前缀。对于topic前缀是topic ,对于queues前缀是queue。例如查找一个testTopic目的地，需要查找名字为“topic/testTopic”。
在此种方法中有createTopic()或createQueue()分别有两种方法：一是有两个参数，二是有一个参数的。两个参数分别是：建立的目的地名称和JNDI名称。一个参数的只是目的地名称，对于JNDI名称默认是：[目的地类型(topic/queue) ]/目的地名称。
在这里我们使用的是第一种方法。直接修改jbossmq-destinations-service.xml文件。
(2) 管理用户
在JMS中可能关联一个连接和一个用户，不幸的是没有明确的方法来限制访问JbossMQ或访问特殊的目的地到一个给定的用户。为了给大部分角色，在JbossMQ中不需要建立用户，除非想有一个持久topic订阅者。在这个例子中，用户是必须的。
用户可以直接在文件jbossmq-state.xml（server/../conf）中添加。同样也可以使用JMX HTML管理界面来增加（jboss.mq->service=StateManager->addUser()）。

jacky
jacky
DurableSubscriberExample
>

(3) 连接工厂
JBossMQ 包括为topic和queue几个不同的连接工厂，每个连接工厂有自己特性。当通过JNDI来查找一个连接工厂时，需要知道此连接工厂的名称。所有可用连接工厂和它们的属性，名称都会在文件jbossmq-service.xml中。
有三种类型连接工厂，依赖的通讯协议如下：
OIL
快速双向scoket通讯协议。它是缺省的。
UIL
超过一个socket协议，可以使用在通过防火墙访问，或者当客户端不能正确的查找到服务器的IP地址。
RMI
最早的协议，是稳定的，但是比较慢。
JVM
在JBoss 2.4之后增加的一个新的连接工厂类型。不需要用socket，当客户端和JbossMQ使用同样虚拟机时，可以使用。
在JBoss2.4.1以后版本中，对于topic- 和 queue-目的地，连接工厂使用同样的名字。下表列出了在JBoss中JMS连接工厂：
目的地类型 JNDI名字连接工厂类型
Topic/Queue java:/ConnectionFactory JVM
Topic/Queue java:/XAConnectionFactory JVM支持XA事务
Topic/Queue RMIConnectionFactory RMI
Topic/Queue RMIXAConnectionFactory RMI支持XA事务
Topic/Queue ConnectionFactory OIL
Topic/Queue XAConnectionFactory OIL支持XA事务
Topic/Queue UILConnectionFactory UIL
Topic/Queue UILXAConnectionFactory UIL支持XA事务

3） JBoss中高级JMS配置
在上边段落主要描述了和JbossMQ一起实行的基本配置工作。在本段来描述JMS其他配置。
(1) JMS持久性管理
JMS持久性管理(PM)负责存储消息，并且将消息标记为持久，如果服务器发生故障时，能保证消息不会丢失，并允许恢复持久性消息。持久性JMS消息可以使用不同的方法来完成。每个方法有自己优点和缺陷：
PM 名字优点缺点
File 比较稳定速度慢
Rollinglogged 速度比较快此方法比较新，有些地方需要完善
JDBC 对于稳定性和可量测性比较好必须有JDBC
Logged 速度快 Log files grow without bound, memory management problems during recovery
在JBoss中缺省的持久性消息管理是File持久性管理。可以改变它，但必须对于一个JMS
Server有且仅有一个持久性管理配置。所以你在JBoss管理界面的jboss.mq ? >
service=PersistenceManager 只是看到一个。
持久性管理的配置文件是jbossmq-service.xml。在server..deploy下。
为了让大家了解持久性管理的各种方法，我下面来逐个介绍如何配置。
w File持久性管理
File持久性管理的概念就是为每一个持久性消息建立一个文件。消息持久性方法不是全部都能使用，但它是比较稳定的。
File持久性管理在JBoss发布时，作为一个缺省的持久性管理。如果你打开jbossmq-service.xml文件，你会看到下面的XML：
name="jboss.mq:service=PersistenceManager">
db/jbossmq/file
jboss.mq:service=MessageCache

当设置Mbean配置时，File持久性管理允许你指定下面的属性：
DataDircetory 是存放持久性消息的路径，会把生成的数据文件放在此目录下。

w 设置Rollinglogged持久性管理
Rollinglogged持久性管理是比较新的一种持久性消息管理方法，因为它使用日志文件来持续多个消息，所以当建立一个文件时，不需要许多的I/O。
定义Rollinglogged持久性管理：
name="jboss.mq:service=PersistenceManager">
db/jbossmq/file
jboss.mq:service=MessageCache

Rollinglogged持久性管理中DataDirctory 存放持久性消息的路径，会把生成的数据文件放在此目录下。

w 设置JDBC持久性管理
JDBC持久性管理使用数据库表来存储消息。需要一个JBoss配置的数据源来访问数据库。具体内容参考jbossmq-service.xml文件中的内容。
w 设置Logged持久性管理
Logged持久性管理是比较早的一个，在JBoss2.4.1以后版本中不在建议使用。现在有其他更好的办法。
4、举例说明
当我们清楚了以后内容后，现在我们来用JBoss实现一个例子来加深对JBoss和JMS的了解。
在上面叙述中，我们知道明确使用JMS provider有三个基本的事情要做：配置JNDI初始化上下文，连接工厂的名字和使用目的地的名字。
当编写产品的最好的事情是不受provider-specific 影响，使代码能在不同的JMS provider之间容易移植。在此这个例子没有聚焦在开发产品上，而是解释如何使用JbossMQ来工作。
1) 初始化上下文
w 配置JNDI的一个方法是通过属性文件jndi.properties。在这个文件中使用正确的值，并且把它所在的路径包含到classpath中，它比较容获得正确初始化上下文。
jndi.properties文件的内容如下：
java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.provider.url=localhost:1099
java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces
把该文件放置的路径成为你的classpath的一部分。如果你使用这种方法，在初始化上下文时，代码比较简单: Context context = new IntialContext();1
w 在某些情景下，可能需要手工配置JNDI；例如当运行的类文件中环境已经配置了一个初始化上下文，但不是你想用的上下文时，需要手工来配置一个上下文。设置在哈希表中的几个属性值，并且使用此哈希表来实例化一个上下文。定义语法：
Hashtable props = new Hashtable();
props.put(Context.INITIAL_CONTEXT_FACTORY,
"org.jnp.interfaces.NamingContextFactory");
props.put(Context.PROVIDER_URL, "localhost:1099");
props.put("java.naming.rmi.security.manager", "yes");
props.put(Context.URL_PKG_PREFIXES, "org.jboss.naming");

2) 查找连接工厂
自有了上下文后，需要查找一个连接工厂。为了查找它，使用一个可用的名字。查找连接工厂的代码如下：
对于一个topic目的地
TopicConnectionFactory topicFactory = (TopicConnectionFactory) context.lookup (“ConnectionFactory”)
Queue 目的地：
QueueConnectionFactory queueFactory = (QueueConnectionFactory ) context.lookup (“ConnectionFactory”)
3) 建立连接和会话
在我们有了连接工厂后，建立一个连接，在此连接中建立一个会话。
对于topic代码如下：
//建立一个连接
topicConnection = topicFactory.createTopicConnection();
//建立一个会话
topicSession = topicConnection.createTopicSession(false, //不需要事务
Session.AUTO_ACKNOLEDGE //自动接收消息的收条。
);
对于queue代码如下：
//建立一个连接
queueConnection = queueFactory.createQueueConnection();
//建立一个会话
queueSession = queueConnection .createQueueSession(false, //不需要事务
Session.AUTO_ACKNOLEDGE //自动接收消息的收条。
);
一个会话建立时，配置是否调用事务
在事务Session中，当事务被提交后，自动接收，如果事务回滚，所有的被消费的消息将会被重新发送。
在非事务Session中，如果没有调用事务处理，消息传递的方式有三种：
Session.AUTO_ACKNOWLEDGE :当客户机调用的receive方法成功返回，或当MessageListenser 成功处理了消息，session将会自动接收消息的收条。
Session.CLIENT_ACKNOWLEDGE ：客户机通过调用消息的acknowledge方法来接收消息。接收发生在session层。接收到一个被消费的消息时，将自动接收该session已经消费的所有消息。例如：如果消息的消费者消费了10条消息，然后接收15个被传递的消息，则前面的10个消息的收据都会在这15个消息中被接收。
Session.DUPS_ACKNOWLEDGE ：指示session缓慢接收消息。

4) 查找目的地
现在我们来介绍建立publishes/sends 或subscribles/receives消息。
下面的代码列出来查找一个目的地：
对于topic 查找一个testTopic目的地
Topic topic = (Topic) context.lookup(“topic/testTopic”);

对于queue 查找一个testQueue目的地
Queue queue= (Queue) context.lookup(“queue/testQueue”);
注意：JbossM的前缀topic/ (queue/)通常被放在topic (queue)名字前面。
在JMS中，当客户机扮演每种角色，象对于topic来将的publisher ,subscriber 或对于queue来将的sender, receiver，都有自己不同类继承和不同函数。
5) 建立一个消息制造者Message Producer (topic publisher/ queue sender)
消息制造者是一个由session创建的对象，主要工作是发送消息到目的地。
对于一个topic，需要通过TopicSession来创建一个TopicPublisher。代码如下：
TopicPublisher topicPublisher = TopicSession.createPublisher(topic);

对于一个queue，需要通过QueueSession来创建一个QueueSender。代码如下：
QueuePublisher queuePublisher = queueSession.createSender(queue);
6) 消息发送
建立一个TestMessage并且publish 它，代码：
TextMessage message = topicSession.createTestMessage();
message.setText(msg);
topicPublishe.publish(topic, message);
建立一个TestMessage并且send它，代码：
TextMessage message = queueSession.createTestMessage();
message.setText(msg);
queueSender.send(queue, message);

7) 下面是一个完成的topic publisher 代码，文件名HelloPublisher.java ：
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicConnection;
import javax.jms.TopicSession;
import javax.jms.TopicPublisher;
import javax.jms.Topic;
import javax.jms.TextMessage;
import javax.jms.Session;
import javax.jms.JMSException;
import java.util.Hashtable;
public class HelloPublisher {

TopicConnection topicConnection;
TopicSession topicSession;
TopicPublisher topicPublisher;
Topic topic;

public HelloPublisher(String factoryJNDI, String topicJNDI)
throws JMSException, NamingException {
Hashtable props=new Hashtable();
props.put(Context.INITIAL_CONTEXT_FACTORY,"org.jnp.interfaces.NamingContextFactory");
props.put(Context.PROVIDER_URL, "localhost:1099");
props.put("java.naming.rmi.security.manager", "yes");
props.put(Context.URL_PKG_PREFIXES, "org.jboss.naming");
Context context = new InitialContext(props);
TopicConnectionFactory topicFactory =
(TopicConnectionFactory)context.lookup(factoryJNDI);
topicConnection = topicFactory.createTopicConnection();
topicSession = topicConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);

topic = (Topic)context.lookup(topicJNDI);

topicPublisher = topicSession.createPublisher(topic);

}

public void publish(String msg) throws JMSException {

TextMessage message = topicSession.createTextMessage();
message.setText(msg);
topicPublisher.publish(topic, message);
}

public void close() throws JMSException {
topicSession.close();
topicConnection.close();
}

public static void main(String[] args) {
try {
HelloPublisher publisher = new HelloPublisher(
"ConnectionFactory", "topic/testTopic");
for (int i = 1; i < 11; i++) {
String msg = "Hello World no. " + i;
System.out.println("Publishing message: " + msg);
publisher.publish(msg);
}
publisher.close();
} catch(Exception ex) {
System.err.println(
"An exception occurred while testing HelloPublisher25: " + ex);
ex.printStackTrace();
}
}
}
我们知道，使用JMS不仅能发送（send）/发布（publish）消息，也能获得（send）/发布（publish）的消息。在时间方式有良种方法来做：
w 同步（Synchronously）：需要手工的去得到消息，为了得到一个消息客户机调用方法得到消息，直到消息到达或在规定的时间内没有到达而超时。我们在例子中没有说明这部分，大家可以实验一下。
w 异步（Asynchronously）：你需要定义一个消息监听器(MessageListener),实现该接口。当消息达到时，JMS provider通过调用该对象的 onMessage方法来传递消息。
从原则来将，topic和queue都是异步的，但是在这两种目的地中有不同的类和方法。首先，必须定义一个MessageListener接口。
8) 建立一个MessageListener
在建立了你需要的subscriber/receiver，并且登记了监听器后。就可以调用连接的start方法得到JMS provider 发送到的消息了。如果在登记监听器之前调用start方法，很可能会丢失消息。
public void onMessage(Message m) {
try {
String msg = ((TextMessage)m).getText();
System.out.println("HelloSubscriber got message: " + msg);
} catch(JMSException ex) {
System.err.println("Could not get text message: " + ex);
ex.printStackTrace();
}
}
9) 建立消息消费者
对于topic来将：
//建立一个订阅者
topicSubscriber = topicSession.createSubscriber(topic);
//设置消息监听器，
topicSubscriber.setMessageListener(this)
//连接开始
topicConnection.start();
对于queue来将：
//建立一个订阅者
queueReceiver = queueSession.createReceiver(queue);
//设置消息监听器，
queueReceiver .setMessageListener(this)
//连接开始
queueConnection.start();
10) 完整的代码，放在文件HelloSubscriber.java中，如下：
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import javax.jms.TopicConnectionFactory;
import javax.jms.TopicConnection;
import javax.jms.TopicSession;
import javax.jms.TopicSubscriber;
import javax.jms.Topic;
import javax.jms.Message;
import javax.jms.TextMessage;
import javax.jms.Session;
import javax.jms.MessageListener;
import javax.jms.JMSException;

public class HelloSubscriber implements MessageListener {
TopicConnection topicConnection;
TopicSession topicSession;
TopicSubscriber topicSubscriber;
Topic topic;
public HelloSubscriber(String factoryJNDI, String topicJNDI)
throws JMSException, NamingException
{
Context context = new InitialContext();
TopicConnectionFactory topicFactory =
(TopicConnectionFactory)context.lookup(factoryJNDI);
topicConnection = topicFactory.createTopicConnection();
topicSession = topicConnection.createTopicSession(
false, Session.AUTO_ACKNOWLEDGE);
topic = (Topic)context.lookup(topicJNDI);
topicSubscriber = topicSession.createSubscriber(topic);
topicSubscriber.setMessageListener(this);
System.out.println(
"HelloSubscriber subscribed to topic: " + topicJNDI);
topicConnection.start();
}
public void onMessage(Message m) {
try {
String msg = ((TextMessage)m).getText();
System.out.println("HelloSubscriber got message: " + msg);
} catch(JMSException ex) {
System.err.println("Could not get text message: " + ex);
ex.printStackTrace();
}
}
public void close() throws JMSException {
topicSession.close();
topicConnection.close();
}
public static void main(String[] args) {
try {
HelloSubscriber subscriber = new HelloSubscriber(
"TopicConnectionFactory",
"topic/testTopic");
} catch(Exception ex) {
System.err.println(
"An exception occurred while testing HelloSubscriber: " + ex);
ex.printStackTrace();
}
}
}

11) 编辑、运行程序
直接使用命令（java）
w 开启命令操作符。设置classpath :
set classpath=C:jboss-3.0.6_tomcat-4.1.18clientjbossall-client.jar;C:jboss-3.0.6_tomcat-4.1.18clientjboss-j2ee.jar;C:jboss-3.0.6_tomcat-4.1.18clientjnp-client.jar;C:jboss-3.0.6_tomcat-4.1.18clientlog4j.jar;.
w 首先运行订阅消息端：java HelloSubscriber
w 再开启另外一个命令窗口设置classpath :
set classpath=C:jboss-3.0.6_tomcat-4.1.18clientjbossall-client.jar;C:jboss-3.0.6_tomcat-4.1.18clientjboss-j2ee.jar;C:jboss-3.0.6_tomcat-4.1.18clientjnp-client.jar;C:jboss-3.0.6_tomcat-4.1.18clientlog4j.jar;.
w 运行发布消息端：java HelloPublisher
5、补充
在最后我们解释JBoss-specific特性：如何用代码来管理目的地。JBoss各个版本可能不同，但是差别不大。我使用的是jboss3.0.6。
实现这个目的有两种不同的方法，依赖于是否代码是在和JBoss同样的虚拟机还是独立独立的。它们都包括调用一个通过service=DestinationManager 登记的JMX Bean。这个Mbean 有四个方法来管理目的地：createTopic()，createQueue()，destroyTopic()，destroyQueue()。
在代码中实现管理目的地在影射怎样调用MBean有不同的地方。如果程序虚拟机和Mbean服务器一样，可以直接调用。
建立一个topic 目的地的代码如下：
MBeanServer server = (MBeanServer)
MBeanServerFactory.findMBeanServer(null).iterator().next();
server.invoke(new ObjectName("JBossMQ", "service", "DestinationManager"),
method,
new Object[] { “myTopic” },
new String[] { "java.lang.String" });

如果程序和Mbean服务器的虚拟机不同，需要通过一个JMX adapter。一个JMX adapter是一个HTML GUI。用程序通过URL来调用Mbean。代码如下：
import java.io.InputStream;
import java.net.URL;
import java.net.HttpURLConnection;
import javax.management.MBeanServerFactory;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.jms.Topic;
import javax.jms.Queue;
public class DestinationHelper {
static final String HOST = "localhost";
static final int PORT = 8080;
static final String BASE_URL_ARG = "/jmx-console/HtmlAdaptor?";
public static void createDestination(Class type, String name)
throws Exception
{
String method = null;
if (type == Topic.class) { method = "createTopic"; }
else if (type == Queue.class) { method = "createQueue";}
invoke(method, name);
}

public static void destroyDestination(Class type, String name)
throws Exception
{
String method = null;
if (type == Topic.class) { method = "destroyTopic"; }
else if (type == Queue.class) { method = "destroyQueue";}
invoke(method, name);
}

protected static void invoke(String method, String destName)
throws Exception
{
try {
MBeanServer server = (MBeanServer) MBeanServerFactory.findMBeanServer(null).iterator().next();
invokeViaMBean(method, destName);
}catch(Exception ex) { invokeViaUrl(method, destName);}
}
protected static void invokeViaUrl(String method, String destName)
throws Exception
{
String action = "action=invokeOp&methodIndex=6&name=jboss.mq%3Aservice%3DDestinationManager&arg0=" + destName;
String arg = BASE_URL_ARG + action;
URL url = new URL("http", HOST, PORT, arg);
HttpURLConnection con = (HttpURLConnection)url.openConnection();
con.connect();

InputStream is = con.getInputStream();
java.io.ByteArrayOutputStream os = new java.io.ByteArrayOutputStream();
byte[] buff = new byte[1024];
for(;;) {
int size = is.read( buff );
if (size == -1 ) { break; }
os.write(buff, 0, size);
}
os.flush();

if (con.getResponseCode() != HttpURLConnection.HTTP_OK ) {
throw new Exception ("Could not invoke url: " + con.getResponseMessage() );
} else {
System.out.println("Invoked URL: " + method + " for destination " + destName + "got resonse: " + os.toString());
}
}
protected static void invokeViaMBean(String method, String destName)
throws Exception
{
MBeanServer server = (MBeanServer)MBeanServerFactory.findMBeanServer(null).iterator().next();
server.invoke(new ObjectName("JBossMQ", "service", "DestinationManager"),
method,
new Object[] { destName },
new String[] { "java.lang.String" });
}
public static void main(String[] args) {
try {
if (args.length >0){
destroyDestination(Topic.class,"myCreated");
}else {
createDestination(Topic.class,"myCreated");
}
}catch(Exception ex) {
System.out.println("Error in administering destination: " + ex);
ex.printStackTrace();
}
}

}
编辑命令：
javac -classpath C:jboss-3.0.6_tomcat-4.1.18clientjbossall-client.jar;C:jboss-3.0.6_tomcat-4.1.18libjboss-jmx.jar;. DestinationHelper.java
运行命令
java -classpath C:jboss-3.0.6_tomcat-4.1.18clientjbossall-client.jar;C:jboss-3.0.6_tomcat-4.1.18libjboss-jmx.jar;. DestinationHelper
当运行完后查看http://localhost:8080/jmx-console下面的jboss.mq.destination中有name=myCreated,service=Topic
表明你建立成功。当JBoss关闭重新启动时。该目的地不会在存在

礼物 2008-06-28 20:22 发表评论

Jboss 作为window的服务

礼物 — Wed, 25 Jun 2008 07:57:00 GMT

首先下载 javaservice

http://multiplan.co.uk/software/javaservice/downloads.html

-- install windows service
JavaService.exe -install JBossEM %JAVA_HOME%\jre\bin\server\jvm.dll -Djava.class.path=%JAVA_HOME%\lib\tools.jar;%JBOSS_HOME%\bin\run.jar -start org.jboss.Main -stop org.jboss.Main -method systemExit -current %JBOSS_HOME%\bin -auto -overwrite

-- -uninstall jboss service
javaservice -uninstall JBossEM

-- JBossEM is service name

礼物 2008-06-25 15:57 发表评论

java 国际化-资源文件的使用 (i18n)

礼物 — Sat, 14 Jun 2008 03:01:00 GMT

Java国际化——资源包的使用

本文是由JR主持写作的《J2SE进阶》一书的部分章节整理而成，《J2SE进阶》正在写作、完善阶段。您阅读后，有任何建议、批评，请和我联系，或在http://www.javaresearch.org/forum/thread.jsp?column=376&thread=7576' target='_blank' class='l2'>这儿留言。《J2SE进阶》写作项目组感谢您阅读本文。

在当今这个信息社会，尤其是随着互联网的出现和普及，人们之间的距离比以往任何时候都更加接近，同时交往也更加频繁，时下最时髦的概念就是地球村，而我小时候只知道我出生的那个小乡村。距离近，交往频繁，人们就不得不考虑如何去与各个不同种族、不同区域的人们打交道。对人如此，对我们的软件亦是如此，你需要考虑如何让处于世界不同地方的使用者都能够很好地使用你的软件。于是，在每个软件开始之前，编写者都可能需要考虑这样一个问题——国际化。

我们知道，在Java中可以通过java.util.Locale类来唯一地确定特定语言和国家的组合，即抽象最终用户的使用环境。同时将用户相关的一些信息置于资源包中，通过资源包来动态地获得最终的用户显示。资源包可以由资源文件或者资源子类来具体实现。

注意：本文只打算讨论国际化过程中资源包的使用技巧，更多更精彩的内容，请期待《J2SE进阶》一书。

资源包

在编写应用程序的时候，需要面对的一个问题是如何来处理与locale相关的一些信息。比如，页面上的一些静态文本就希望能够以用户习惯的语言显示。最原始的做法是将这些信息硬编码到程序中（可能是一大串判断语句），但是这样就将程序代码和易变的locale信息捆绑在一起，以后如果需要修改locale信息或者添加其它的locale信息，你就不得不重新修改代码。而资源包可以帮助你解决这个问题，它通过将可变的locale信息放入资源包中来达到两者分离的目的。应用程序可以自动地通过当前的locale设置到相应的资源包中取得所要的信息。资源包的概念类似于Windows编程人员使用的资源文件（rc文件）。

一般来说，资源包需要完成两个功能：和具体的locale进行绑定以及读取locale相关信息。

ResourceBundle类

你可以把资源包看作为一个由许多成员（子类）组成的大家庭，其中每个成员关联到不同的locale对象，那它是如何完成关联功能的呢？

资源包中的每个成员共享一个被称作基名（base name）的名称，然后在此基础上根据一定的命名规范进行扩展。下面就列出了一些成员的名称：
    LabelResources
         LabelResources_de
         LabelResources_de_CH
         LabelResources_de_CH_UNIX
可见这些子类依据这样的命名规范：baseName_language_country_variant，其中language等几个变量就是你在构造Locale类时所使用的。而资源包正是通过这个符合命名规范的名称来和locale进行关联的，比如LabelResource_de_CH就对应于由德语（de）和瑞士（CH）组成的locale对象。

当你的应用程序需要查找特定locale对象关联的资源包时，它可以调用ResourceBundle的getBundle方法，并将locale对象作为参数传入。

Locale currentLocale = new Locale("de", "CH", "UNIX");
ResourceBundle myResources =
      ResourceBundle.getBundle("LabelResources", currentLocale);

如果该locale对象匹配的资源包子类找不到，getBundle将试着查找最匹配的一个子类。具体的查找策略是这样的：getBundle使用基名，locale对象和缺省的locale来生成一个候选资源包名称序列。如果特定locale对象的语言代码、国家代码和可选变量都是空值，则基名是唯一的候选资源包名称。否则的话，具体locale对象（language1，country1和variant1）和缺省locale（language2，country2和variant2）将产生如下的序列：

baseName + "_" + language1 + "_" + country1 + "_" + variant1

baseName + "_" + language1 + "_" + country1

baseName + "_" + language1

baseName + "_" + language2 + "_" + country2 + "_" + variant2

baseName + "_" + language2 + "_" + country2

baseName + "_" + language2

baseName

然后，getBundle方法按照产生的序列依次查找匹配的资源包子类并对结果子类初始化。首先，它将寻找类名匹配候选资源包名称的类，如果找到将创建该类的一个实例，我们称之为结果资源包。否则，getBundle方法将寻找对应的资源文件，它通过候选资源包名称来获得资源文件的完整路径（将其中的“.”替换为“/”，并加上“.properties”后缀），如果找到匹配文件，getBundle方法将利用该资源文件来创建一个PropertyResourceBundle实例，也就是最终的结果资源包。与此同时，getBundle方法会将这些资源包实例缓存起来供以后使用。

如果没有找到结果资源包，该方法将抛出MissingResourceException异常。所以为了防止异常的抛出，一般来说都需要至少实现一个基名资源包子类。

注意：基名参数必须是一个完整的类名称（比如LabelResources，resource.LabelResources等），就相当于你引用一个类时需要指定完整的类路径。但是，为了和以前的版本保持兼容，在使用PropertyResourceBundles时也允许使用“/”来代替“.”表示路径。

比如你有以下这些资源类和资源文件：MyResources.class， MyResources_fr_CH.properties， MyResources_fr_CH.class， MyResources_fr.properties， MyResources_en.properties， MyResources_es_ES.class。你利用以下的locale设置来调用getBundle方法，你将会得到不同的结果资源包（假设缺省locale为Locale(“en”, “UK”)），请参考表13.4。
       表13.4 locale设置与结果资源包
locale设置        结果资源包
Locale("fr", "CH")    MyResources_fr_CH.class
Locale("fr", "FR")        MyResources_fr.properties
Locale("de", "DE")        MyResources_en.properties
Locale("en", "US")        MyResources_en.properties
Locale("es", "ES")        MyResources_es_ES.class

创建了具体的资源包子类实例以后，就需要获得具体的信息。信息在资源包中是以键值对的方式存储的，表13.5列出的是LabelResources.properties文件的内容。

表13.5 LabelResources.properties

# This is LabelResources.properties file
greetings = 您好！
farewell = 再见。
inquiry = 您好吗？

其中等号左边的字符串表示主键，它们是唯一的。为了获得主键对应的值，你可以调用ResourceBundle类的getString方法，并将主键作为参数。此外，文件中以“#”号开头的行表示注释行。

ListResourceBundle和PropertyResourceBundle子类

抽象类ResourceBundle具有两个子类：ListResourceBundle和PropertyResourceBundle，它们表示资源包子类两种不同的实现方式。

PropertyResourceBundle是和资源文件配对使用的，一个属性文件就是一个普通的文本文件，你只需要为不同的locale设置编写不同名称的资源文件。但是，在资源文件中只能包含字符串，如果需要存储其它类型对象，你可以使用ListResourceBundle。

ListResourceBundle是将键值对信息保存在类中的列表中，而且你必须实现ListResourceBundle的具体子类。

如果ListResourceBundle和PropertyResourceBundle不能够满足你的需要，你可以实现自己的ResourceBundle子类，你的子类必须覆盖两个方法：handleGetObject和getKeys。

使用资源文件

使用资源包最简单的方法就是利用资源文件，利用资源文件一般需要以下几个步骤：
1、创建一个缺省的资源文件
为了防止找不到资源文件，你最好实现一个缺省的资源文件，该文件的名称为资源包的基名加上.properties后缀。
2、创建所需的资源文件
为你准备支持的locale设置编写对应的资源文件。
3、设置locale
你必须在程序中的某个地方提供locale的设置或者切换功能，或者将其放入配置文件中。
4、根据locale设置创建资源包
ResourceBundle resource =
        ResourceBundle.getBundle("LabelBundle",currentLocale);
5、通过资源包获取locale相关信息
String value = resource.getString("welcome");

注意：在使用基名的时候，特别要注意给出完整的类名（或者路径名），比如你的应用程序所在的类包为org.javaresearch.j2seimproved.i18n，而你的资源文件在你的应用程序下的resource子目录中，那你的基名就应该是org.javaresearch.j2seimproved.i18n.resource.LabelBundleBundle而不是resource.LabelBundleBundle。

使用ListResourceBundle

使用ListResourceBundle和使用资源文件的步骤基本上一样，只不过你需要用ListResourceBundle子类来替换相应的资源文件。比如你的应用程序的基名是LabelBundle，而且准备支持Locale("en","US")和Locale("zh","CN")，那你需要提供以下几个Java文件，注意类名和locale的对应关系。
LabelBundle_en_US.java
LabelBundle_zh_CN.java
LabelBundle.java（缺省类）

代码13.3列出的是LabelBundle_zh_CN.java的源代码，相对于资源文件中“key = value”的写法，在此文件中你首先利用键值对来初始化一个二维数组，并在getContents方法中返回该数组。

代码13.3：LabelBundle_zh_CN.java

package org.javaresearch.j2seimproved.i18n;import

java.util.ListResourceBundle;

public class LabelBundle_zh_CN extends ListResourceBundle {
  public Object[][] getContents() {
    return contents;
  }

  private Object[][] contents = {
    {"title", "称谓"},
    {"surname", "姓"},
    {"firstname", "名"},
  };
}

创建完资源类以后，同样需要设置locale以及根据locale来创建资源包。在通过资源包获取具体值的时候，你不能再使用getString方法，而应该调用getObject方法，而且由于getObject方法返回一个Object对象，你还需要进行正确的类型转换。其实，为了你的程序通用性，我们建议在使用资源文件的时候你也应该调用getObject方法，而不是getString方法。

    String title = (String)resource.getObject("title");

关于ListResourceBundle的详细使用，可以参考本书所附代码中国际化一节的ListResourceBundleSample.java程序。

MessageFormat类

上面我们讲到利用资源文件来分离代码和可变的信息。但是在实际过程中，有些信息并不能够完全事先定义好，其中可能会用到运行时的一些结果，最典型例子的就是错误提示代码，比如提示某个输入必须在一定范围内。利用上面所讲的资源文件并不能够很好地解决这个问题，所以Java中引入了MessageFormat类。

MessageFormat提供一种语言无关的方式来组装消息，它允许你在运行时刻用指定的参数来替换掉消息字符串中的一部分。你可以为MessageFormat定义一个模式，在其中你可以用占位符来表示变化的部分，比如你有这样一句话：

您好，peachpi！欢迎来到Java研究组织网站！当前时间是：2003-8-1 16:43:12。

其中斜体带下划线的部分为可变化的，你需要根据当前时间和不同的登录用户来决定最终的显示。我们用占位符来表示这些变化的部分，可以得到下面这个模式：

您好，{0}！欢迎来到Java研究组织网站！当前时间是：{1,date} {1,time}。

占位符的格式为{ ArgumentIndex , FormatType , FormatStyle }，详细说明可以参考MessageFormat的API说明文档。这里我们定义了两个占位符，其中的数字对应于传入的参数数组中的索引，{0}占位符被第一个参数替换，{1}占位符被第二个参数替换，依此类推。
最多可以设置10个占位符，而且每个占位符可以重复出现多次，而且格式可以不同，比如{1,date}和{1,time}。而通过将这些模式定义放到不同的资源文件中，就能够根据不同的locale设置，得到不同的模式定义，并用参数动态替换占位符。

下面我们就以MessageFormatSample.java程序（源文件见本书所附代码）为例，来详细说明其中的每个步骤。
1、找出可变的部分，并据此定义模式，将模式放入不同的资源文件中。
比如针对上面的模式，定义了下面两个资源文件：
MessagesBundle_en_US.properties
Welcome = Hi, {0}! Welcome to Java Research Organization!
MessagesBundle_zh_CN.properties
Welcome = 您好，{0}！欢迎来到Java研究组织网站！

2、创建MessageFormat对象，并设置其locale属性。

      MessageFormat formatter = new MessageFormat("");
      formatter.setLocale(currentLocale);

3、从资源包中得到模式定义，以及设置参数。

messages =     ResourceBundle.getBundle(
  "org.javaresearch.j2seimproved.i18n.resource.MessagesBundle",currentLocale);
Object[] testArgs = {"peachpi",new Date()};

4、利用模式定义和参数进行格式化。

      System.out.println(formatter.format(messages.getString("welcome"),testArgs));

关于资源包的组织

一般来说，你是按照资源的用途来组织资源包的，比如会把所有的页面按钮的信息放入一个名为ButtonResources的资源包中。在实际的应用过程中，以下几个原则可以帮你决定如何组织资源包：
1、要易于维护。
2、最好不要将所有的信息都放入一个资源包中，因为这样资源包载入内存时将会很耗时。
3、最好将一个大的资源包分为几个小的资源包，这样可以在使用的时候才导入必须的资源，减少内存消耗。

礼物 2008-06-14 11:01 发表评论

提升JSP页面响应速度的七大秘籍绝招

礼物 — Sun, 13 Apr 2008 01:02:00 GMT
你时常被客户抱怨JSP页面响应速度很慢吗？你想过当客户访问次数剧增时，你的WEB应用能承受日益增加的访问量吗？本文讲述了调整JSP和 servlet的一些非常实用的方法，它可使你的servlet和JSP页面响应更快，扩展性更强。而且在用户数增加的情况下，系统负载会呈现出平滑上长的趋势。在本文中，我将通过一些实际例子和配置方法使得你的应用程序的性能有出人意料的提升。

其中，某些调优技术是在你的编程工作中实现的。而另一些技术是与应用服务器的配置相关的。在本文中，我们将详细地描述怎样通过调整servlet和JSP页面，来提高你的应用程序的总体性能。在阅读本文之前，假设你有基本的servlet和JSP的知识。

方法一：在servlet的init()方法中缓存数据

当应用服务器初始化servlet实例之后，为客户端请求提供服务之前，它会调用这个servlet的init()方法。在一个servlet的生命周期中，init()方法只会被调用一次。通过在init()方法中缓存一些静态的数据或完成一些只需要执行一次的、耗时的操作，就可大大地提高系统性能。

例如，通过在init()方法中建立一个JDBC连接池是一个最佳例子，假设我们是用jdbc2.0的DataSource接口来取得数据库连接，在通常的情况下，我们需要通过JNDI来取得具体的数据源。我们可以想象在一个具体的应用中，如果每次SQL请求都要执行一次JNDI查询的话，那系统性能将会急剧下降。解决方法是如下代码，它通过缓存DataSource，使得下一次SQL调用时仍然可以继续利用它：

public class ControllerServlet extends HttpServlet

{

private javax.sql.DataSource testDS = null;

public void init(ServletConfig config) throws ServletException

{

super.init(config);

Context ctx = null;

try

{

ctx = new InitialContext();

testDS = (javax.sql.DataSource)ctx.lookup("jdbc/testDS");

}

catch(NamingException ne)

{

ne.printStackTrace();

}

catch(Exception e)

{

e.printStackTrace();

}

}

public javax.sql.DataSource getTestDS()

{

return testDS;

}

...

...

}

　　方法 2:禁止servlet和JSP 自动重载(auto-reloading)

Servlet/JSP提供了一个实用的技术，即自动重载技术，它为开发人员提供了一个好的开发环境，当你改变servlet和JSP页面后而不必重启应用服务器。然而，这种技术在产品运行阶段对系统的资源是一个极大的损耗，因为它会给JSP引擎的类装载器(classloader)带来极大的负担。因此关闭自动重载功能对系统性能的提升是一个极大的帮助。

　　方法 3: 不要滥用HttpSession

在很多应用中，我们的程序需要保持客户端的状态，以便页面之间可以相互联系。但不幸的是由于HTTP具有天生无状态性，从而无法保存客户端的状态。因此一般的应用服务器都提供了session 来保存客户的状态。在JSP应用服务器中，是通过HttpSession对像来实现session的功能的，但在方便的同时，它也给系统带来了不小的负担。因为每当你获得或更新session时，系统者要对它进行费时的序列化操作。你可以通过对HttpSession的以下几种处理方式来提升系统的性能。

如果没有必要，就应该关闭JSP页面中对HttpSession的缺省设置。如果你没有明确指定的话，每个JSP页面都会缺省地创建一个HttpSession。如果你的JSP中不需要使用session的话，那可以通过如下的JSP页面指示符来禁止它：

＜%@ page session="false"%＞

　　不要在HttpSession中存放大的数据对像：如果你在HttpSession中存放大的数据对像的话，每当对它进行读写时，应用服务器都将对其进行序列化，从而增加了系统的额外负担。你在HttpSession中存放的数据对像越大，那系统的性能就下降得越快。

当你不需要HttpSession时，尽快地释放它：当你不再需要session时，你可以通过调用HttpSession.invalidate()方法来释放它。尽量将session的超时时间设得短一点：在JSP应用服务器中，有一个缺省的session的超时时间。当客户在这个时间之后没有进行任何操作的话，系统会将相关的session自动从内存中释放。超时时间设得越大，系统的性能就会越低，因此最好的方法就是尽量使得它的值保持在一个较低的水平。

方法 4: 将页面输出进行压缩

压缩是解决数据冗余的一个好的方法，特别是在网络带宽不够发达的今天。有的浏览器支持gzip(GNU zip)进行来对HTML文件进行压缩，这种方法可以戏剧性地减少HTML文件的下载时间。因此，如果你将servlet或JSP页面生成的HTML页面进行压缩的话，那用户就会觉得页面浏览速度会非常快。但不幸的是，不是所有的浏览器都支持gzip压缩，但你可以通过在你的程序中检查客户的浏览器是否支持它。下面就是关于这种方法实现的一个代码片段：

public void doGet(HttpServletRequest request,

HttpServletResponse response)

throws IOException, ServletException

{

OutputStream out = null

String encoding = request.getHeader("Accept-Encoding");

if (encoding != null && encoding.indexOf("gzip") != -1)

{

request.setHeader("Content-Encoding" , "gzip");

out = new GZIPOutputStream(request.getOutputStream());

}

else if (encoding != null && encoding.indexOf("compress") != -1)

{

request.setHeader("Content-Encoding" , "compress");

out = new ZIPOutputStream(request.getOutputStream());

}

else

{

out = request.getOutputStream();

}

...

...

}

礼物 2008-04-13 09:02 发表评论

对ibatis分页功能的改进

礼物 — Sun, 13 Apr 2008 00:51:00 GMT
     摘要: 今天无意间看到了一篇关于这方面的文章，觉得是网上改进ibatis分页方面比较好的文章，这里转摘一下，希望能让更多的人用的到，也希望别人能把更好的解决方案贡献出来！ function StorePage(){d=document;t=d.selection?(d.selection.type!='None'?d.selection.createRange().text:''):(d.g...  阅读全文

礼物 2008-04-13 08:51 发表评论

jsp 70 问答

礼物 — Sun, 04 Nov 2007 04:59:00 GMT
jsp问答７０问：
1. 问：在JAVA与JSP中要调用一个LINUX上的脚本程序,或WINDOWS上的脚本程序,该怎么写？
答：System.getRuntime().exec("bash < aaa.sh");

2. 问：java中用什么表示双引号
答："""

3. 问：如何在JSP程序里另起一个线程？
答：
JSP本身就是独立线程运行而不象CGI都是独立进程.
一般:
Thread t = new Thread("你的对象");
t.start();就可以了.
要求你这个对象要实现runnable接口或继承thread.

4. 问：jsp如何获得客户端的IP地址？
答：
request.getRemoteAddr()
看看各个webserver的API文档说明，一般都有自带的，resin和tomcat都有

5. 问：程序终止与输出终止
答：
程序中止:return;
输出中止out.close();这一句相当于ASP的response.end

6. 问：jsp中如何得到上页的URL？
答：request.getHeader("referer");

7. 问：提交网页的网页过期功能是怎么做的？
答：response.setHader("Expires","0");

8. 问：在JSP网页中如何知道自已打开的页面的名称
答：
request.getRequestURI() ;//文件名
request.getRequestURL() ;//全部ＵＲＬ

9. 问：提交表单后验证没有通过，返回提交页面，如何使原提交页面中的数据保留？
答：javascript的go(-1)可以把上页的表单内容重新显示出来,但password域没有

10. 问：如何取得http的头信息？
答：request.getHader(headerName);

11. 问：&&和&的区别？
答：
&&是短路的与操作，也就是当地一个条件是false的时候，第二个条件不用执行
&相反，两个条件总是执行。

12. 问：将*以正弦曲线的一个周期显示出来
答：
public void paint(Graphics g)
{
for(int i=0;i<200;i++)
g.drawString("*",i,(int)(Math.sin(i)*20)+50);
}
}

13. 问：浮点数相乘后结果不精确如100.0 * 0.6 结果等于 60.0004
答：
这不叫错误,float和double是这样实现的.如果要精确计算，java提供了一个strictfp,它的计算遵循IEEE 754标准.而普通的float和double是

由地平台浮点格式或硬件提供的额外精度或表示范围。

14. 问：如何获得当前用的cursors的位置？
答：
int row = rs.getRow()就是当前指针行数,还有isFrist();isBeforeFist();isLast();isAfterLast();可以测试是不是在方法名所说的位置

15. 问：表单成功提交了，点后退显示网页过期
答：
在里面加以下代码

或者在表单页中加上
<%
response.setHeader("Pragma","no-cache");
response.setHeader("Cache-Control","no-cache");
response.setDateHeader("Expires",0);
%>

16. 问：接口的简单理解
答：接口为了规范,比如我在接口中定义了一个方法:
getData()
这是用来从不同的数据库中取数据的,就是JDBC的实现对于用户,我不要知道每种数据库是如何做的,但我知道如何它们要实现这个接口就一定有

这个方法可以供我调用.这样SUN就把这个接口给各个数据库开发商,让他们自己实现. 但为什么不用继承而用接口哩,因为继承只能从一个你类

继承,而接口可以实现多个,就是说我实现的子类有多个规定好的接口中的功能. 这只是简单的理解,等你深入理解抽象的时候就知道抽象到抽象

类时为什么还要再抽象到接口.

17. 问：怎样编写一个取消按钮（怎样返回上一个页面，象工具栏的后退按钮）？
答：
javascript把每次浏览过的location都压到了一个栈中,这个栈就是history,然后你如果要回到第几个页面它就做几次POP操作,把最后POP出来

的那个LOCATION给你. 这就是JAVASCRIPT在实现history.go(-x)的原理.

18. 问：什么是回调？
答：
简单说,回调用不是让你去监听谁做完了什么事,而是谁做完了什么事就报告给你. 这就是回调用的思想.例子太多了,AWT的事件,SWING事件模型

都是这样有. 还有多线程中,如果要控制线程数,不能总是查询每个线程是否结束,要在每个线程结束时让线程自己告诉主线程我结束了,你可以

开新的线程了.

19. 问：简要介绍一下compareTo方法
答：
compareTo方法是Comparable 接口必需实现的方法,只要实现Comparable

就可以用Arrays.srot()排序就象实现Runnable接口的run就能Thread()一样.

20. 问：如何可以从别的Web服务器检索页, 然后把检索到的网页的HTML代码储存在一个变量中返回过来
答：这是一个简单的WEB ROBOT实现,用URL类实现从网页中抓内容,然后自己写一个分析程序从中找出新的URL,不断递归下去就行了.

21. 问：applet中如何获得键盘的输入
答：application的System.in是当前系统的标准输入,applet因为安全的原因不可能读取当前系统(客户端)的标准输入,只能从它的ROOT组件的

事件中,比如键盘事件中取得键值.

22. 问：怎样计算代码执行所花费的时间？
答：
代码开始取时间，结束后取时间，相减
long t1 = System.currentTimeMillis();
///////////////// your code
long t2 = System.currentTimeMillis() ;
long time = t2-t1;

23. 问：如何获在程序中获得一个文件的ContentType？
答：
URL u = new URL("file:///aaa.txt");
URLConnection uc = u.openConnection();
String s = uc.getContentType();

24. 问：连接池的使用是建立很多连接池，还是一个连接池里用多个连接？
答：
只有在对象源不同的情况下才会发生多个池化,如果你只连一结一个数据源,永远不要用多个连结池. 所以连结池的初始化一定要做成静态的,而

且应该在构造对象之前,也就是只有在类LOAD的时候,别的时候不应该有任何生成新的连结池的时候。

25. 问：JavaMail要怎么安装？
答：下载两个包，一个是javamail包，另一个是jaf包。下载完直接把这两个包不解压加到CLASSPATH。

26. 问：怎样把地址栏里的地址锁定？
答：把你的服务器的可访问目录索引选项关闭就行了,任何服务器都有一个conf文件,里面都有这个选项。

27. 问：在JAVA中怎么取得环境变量啊。比如： TEMP = C：TEMP ？
答：String sss = System.getProperty(key)

28. 问：怎样实现四舍五入，保留小数点后两位小数？
答：
import java.text.*;
...
NumberFormat nf=NumberFormat.getNumberInstance();
nf.setMaximumFractionDigits(2);
nf.setMinimumFractionDigits(2);
nf.format(numb);

29. 问：Applet和form如何通信？
答：
取得的参数传到param里面
<%
String xxx = request.getParameter("xxx");
%>

30. 问：java-plug-in是什么？
答：Java Runtime Environment的插件。用来运行java程序。不需要什么特别的设置。等于你的机器里面有了jvm。

31. 问：WEB上面怎么样连接上一个EXCEL表格？
答：
定义页面得contentType="application/vnd.ms-excel"，让页面以excel得形式打开。同样也可以以word得形式打开：application/msword。

32. 问：怎样才能避免textarea字数限制？
答：是使用了FORM的默认方法的缘故,如果什么也不写默认是GET改用Post即可，在Form中定义mothod="post"。

33. 问：为什么加了<%@page contentType="text/html;charset=gb2312" %>插入数据库的中文，依然是乱码？
答：
这要从环境看,能显示说明你的JSP引擎没有问题,但写入数据库时你的JDBC能不能处理中文,同一公司不同版本的JDBC都有支持中文和不支持中

文的情况,RESIN自带的MYSQL JDBC就不支持,MM的就支持,还有你的数据库类型是否支持中文?CHAR的一般支持,但是否用binary存储双字节码

34. 问：对于JFrame，hide()，show()与setVisibel()有什么区别吗？
答：
setVisible()从Component继承过来，而hide(),show()从Window里面继承过来。
Makes the Window visible. If the Window and/or its owner are not yet displa yable, both are made displayable. The Window will

be validated prior to being made visible. If t he Window is already visible, this will bring the Window to the front. 区别在

这。
36. 问：sendRedirect为什么不可以转到mms协议的地址的？response.sendRedirect("mms://missiah.adsldns.org:9394");
答：java平台目前实现的protocol中并没有mms,你可以取系统属性java.protocol.handler.pkgs看看它的值中有没有mms,所以如果要想重定向

到mms://host这样和URL,只有生成客户端的JAVASCRIPT让它来重定向

37. 问：JTable中怎样定义各个Columns和Width和怎样设置表格的内容靠做靠右或居中？
答：
TableColumn tc = table.getColumn("Name");//取得列名为"Name"的列Handle
int currentWidth = tc.getPreferredWidth(); //取得该列当前的宽度
tc.setPreferredWidth(200); //设置当前列宽
tc.setMaxWidth(200); //设置该列最大宽度
tc.setMinWidth(50); //设置该列最小宽度

38. 问：批操作是否可用于select语句？
答：批操作其实是指成批理更新的操作,绝对不可能用于select操作。

39. 问：为什么jsp路径太深文件名太长就无法读取文件？
答：path不能超过255长度,不然就找不到了.这是作业系统的事。

40. 问：如何让页面不保留缓存？
答：
<%
response.setHeader("Pragma","No-cache");
response.setHeader("Cache-Control","no-cache");
response.setDateHeader("Expires", 0);
%>

41. 问：我的applet code 中用到jbutton 时就出错是否由于ie不支持swing package 请问应怎么办？
答：JBUTTON是SWING基本包啊,只要把jdk/jre/lib/rt.jar放在classpath就行了.不要加载任何别的库。

42. 问：不知道java是否支持midi格式，如果支持，应该怎么把wave格式转换成midi格式？
答：目前还不行,可以看一下JMF三个版中对MIDI的格式支持是read only,而WAVE是read/write,MIDI只能播放,不能生成。

43. 问：在jsp里面防止用户直接输入url进去页面，应该怎么做呢？
答：
一是从web服务器控制,对某一目录的所有访问要通过验证.
二是在要访问的页面中加入控制.这个一般用session,也可以用请求状态码实现

44. 问：
例如后台有一计算应用程序（此程序运算起来很慢，可持续几分钟到几小时，这不管，主要是能激活它），客户机讲任务提交后，服务器对任

务进行检测无误后将向服务器后台程序发送信息，并将其激活。要求如下：
1）首先将后台程序激活，让它执行此任务（比如，前台将计算的C代码提交上后，后台程序程序能马上调用，并将其运行）
2）要在前台JSP页面中显示运行过程信息（由于运行时间长，希望让客户看到运行过程中产生的信息）如何完成？

答：
活是可以的,运行一个shell让它去运行后台就行,但不可能取出运行信息,因为HTTP的超时限制不可能永远等你后台运行的,而且信息如果要动态

实时推出来就得用SERVER PUSH技术。

45. 问：数据库是datetime 型，插入当前时间到数据库？
答：
java.sql.Date sqlDate = new java.sql.Date();
PreparedStatement pstmt = conn.prepareStatement("insert into foo(time) values(?)");
pstmt.setDate(1,sqlDate);
pstmt.executeUpdate();

46. 问：怎样去掉字符串前后的空格。
答：String.trim()

47. 问：session怎样存取int类型的变量？
答：
session.setAttribute("int", i+"");
int i = Integer.parseInt(session.getAttribute("int"));

48. 问：在javascript中如何使输出的float类型的数据保留两位小数。
答：Math.round(aaaaa*100)/100。

49. 问：在bean种如何调用session
答：
你可把session对象作为一个参数传给bean
在BEAN中定义HttpServletRequest request;HttpSession session;
然后
session = request.getSession(false);
false为如果session为空,不建立新的session
将session作为参数传入.其实只要将request传入就可以

50. 问：如何把txt或word文件按原格式显示在jsp页面或servlet上？
答：
其实一个非常简单的解决方法就是在服务器的MIME中指点定TEXT和WORD的解释方式,然后用JSP或SERVLET生成它就行了,客户端就会自动调用相

应程序打开你的文档。
如果是希望按原格式的显示在页面上，而不是调用其他程序打开那么你可以试试用WEBDEV协议,可以说这是MS的一个亮点.它是在WEB方式下打开

文档,和共享一样.完全符合的要求。

51. 问：object的clone方法为什么不能直接调用？
答：
这个方法在object中是protected
为什么要把这个方法定义为protected,这是一个折中,它的目的是想知道你这个方法在Object里只是一个标记,而不是一个实现,比如

public class Object
{
.............
protected Object clone()
{}
}

所以直接继承的clone()方法并不能做任何时,你要使用这个方法就要重载这个方法并放宽访问权限为public,或实现cloneable接口. 但它没法

这样告诉你它没有真的实现,只好用protected 方法加以警示

52. 问：一个页面中如何刷新另外一个页面？
答：
要求是这些面页必须有关联,一是它们都有一个共同的顶层帧,也就是说是一个帧内的分级页面,当然可以是任意级,帧内再分帧也可以,另一个可

能是当前窗口弹出的窗口,如果没有联系,那就不可能用一个页面刷新另一个页面. 帧内只要一级一级引用就行了.

比如在左帧中一个页面中写top.right.location.reload();那么名为right的右帧中的页面就会刷新. 弹出的一样,用open时的名称刷新子窗口,

子窗口用opener刷新主窗口

53. 问：如何在jsp中怎么样向客户端写cookies？
答：
Cookie coo = new Cookie(name, value);
HttpServletResponse.addCookie(name);

54. 问：为什么jTextField1.setText("aaabbb");jTextField2.setText("AAABBB"); 得到的字体宽度不一样？
答：就是说如果不是指定为等宽字体,每个字体的宽度都是不一样的.因此JAVA中用FontMetrics 类来取字符宽度。

55. 问：String kk=application/octet-stream; name="G:/SMBCrack.exe";如何得到SMBCrack.exe？
答：
这应该是解析上传时候的二进制流得到的这一行里面格式是固定的，取到name="后面的字符串，然后把";去掉。然后取最后一个/后面的所有字

符组成一个新字符串就行了。

56. 问：如何传值并不刷新页面？
答：
弹出一个页面进行值的选择或者输入，ok后使用将值传给原窗口，使用javascript关闭打开的窗口即可：
window.close();opener.focus();

57. 问：有一个字符串："EF0C114EA4"，如何变为a[0] = 0xEF a[1] = 0x0C a[2] = 0x11 a[3] = 0x4E a[4] = 0xA4？
答：
String str="EF0C114EA4F";
out.print(str+"
");
int l=str.length()/2+str.length()%2,j=0,k=0;
String[] a=new String[l];
for(int i=0;i if(str.length()-j==1)
k=str.length();
else
k=j+2;
a="0x"+str.substring(j,k);
out.print("a["+Integer.toString(i)+"]="+a+"
");
j+=2;
}

58. 问：怎样将一个int转换成一个四字节的byte数组？
答：
int x = 1234567;
byte[] b = new byte[4];
for(int i=0;i {
b = (x >>( i*8)) & 0xFF;
}

59. 问：indexOf()的使用需要注意什么？
答：参数是指从第几位（1，2，3，...）开始搜索，而返回值是指搜索到的位置（0，1，2，3.......）注意是从零算起的。

60. 问：在Java应用程序中如何动态的添加一个按钮？
答：
这里涉及一个组件重绘的问题,组件要先于panel被显示之处存在,如果一panel已经显示了,那么加在上面你能看到吗?但如果在同一个panel上,

先有button A,假如按下它加了butt on B,这时你如果使整个panel重给,那么A本身要重绘,它的事件监听就没有了,当然也就加不成B了,所以如

果要先有另一个panel,当按A时把B加在这个panel上并重绘这个paenl,其实更好的方法是先把B加在panel中,同一个也行.把它setVisiable(flas

e),按A时设为 true。

61. 问：book mybook=new book(bookid);book是servlet,出错。
答：
book是servlet,能book mybook=new book(bookid);
说明自己实现了servlet容器?不然,servlet能让你自己去调用? servlet如果调用其实和EJB连1%的区别都没有,它们都是自己继承或实现一些接

口,在这些父类或接口中实现了如果和容器"打交道"的方法,然后容器调用这些方法来管理它,让它生成实例,池化,钝化,销毁,再生等.所以这样

写是错误的。

62. 问：给定一个字符串5*(5+9)/7怎样计算出结果？
答：
可有两种方法
1。用堆栈完成
2。最简单的方法，不用编程，如果有任何一个数据库的化，用select (5*(5+9)/7) from oneTable

63. 问：如何实现递交表单内容的加密解密？
答：
如果你用IE目前只能用SSL协议,这一层不要你考虑,否则只你用你自己的工具加密传输,接收后再解密友,至于如何加解,如果要和公认的系统结

合,就用通用的MD5,RAS等公开算法,如果你只是自己传自己解,你随便按你的想法把数据加上一些东西,取回来按规则减掉这些东西,我敢保证除

你自己没有任何人能知道解密方法.

64. 问：为什么Integer.parseInt("+1");会抛出NumberFormatException的异常？
答：因为"+"运行算在JAVA中被重载.系统无法确定你用的是算术加还是字符+。
这一点可以在JAVASCRIPT中更好地理解:

var a = document.t.s.value+1;
这时a = 12345,因为document.t.s.value作为字符串.但var a = document.t.s.value-1;
a 就是1233,因为系统知道-运算肯定是算术运行.所以把document.t.s.value转换成数字.

65. 问：hashCode() 有什么用为什么有时候需要覆盖Object里的hashcode()方法？
答：这就是这个对象的身份证啊,要不如何区分哪个对象。

66. 问：怎样在tomcat中实现一个定时执行的东东？
答：
在应用程序启动时自动运行。servlet2.3中定义了ServletListener,监听Servlet Con text的启动或则关闭（可在配置文件中配置），启动时

触发一个守护程序的运行(可以实现java.util.Timer或则 javax.swing.Timer).

67. 问：程序可以输出自己吗？
答：孔德悖论这个非常有名的法则.就是说任何程序都不可能输出自己.

68. 问：能够把字符转化成ASCII码？比如将 A 转化成 65？
答：
int a='A';
out.println(a);

69. 问：如何区分输入的文字中的全角与半角？
答：由于不能分辨出全角和半角字符的值有什么规律,只好把全角符号牧举出来了.

70. 问：用户注册后的自动发信程序该怎么做？
答：
这种发信程序不考虑性能,因为不可能1秒就有一个人注册,我们说的考虑性能的发信程序是指上百万封信在队列里要不停发送的那种,象你这个

随便怎么写一个程序都行,没有必要用JAVAMAIL.只要指定一个发信的服务器然后用cocket连它的25口就行了.自己用SOCKET连SMTP的25口发一封

信就好象两个邻居之间送一样东西,直接递过去得了,用JAVAMAIL,消息机制就是你把这个东西从邮局寄给你的邻居了.

礼物 2007-11-04 12:59 发表评论

JAVA的代理模式

礼物 — Sat, 22 Sep 2007 13:20:00 GMT

关键字: 设计模式

代理模式：为其他对象提供一种代理以控制对这个对象的访问．说白了就是，在一些情况下客户不想或不能直接引一个对象，而代理对象可以在客户和目标对象之间起到中介作用．去掉客户不能看到的内容和服务或都增添客户需要的额外服务．
给大家举个比较简单的例子：
假如你买台IBM的笔记本，IBM产家是不提供鼠标的．但是我们如果从代理商的手里买就有鼠标和送．
很简单的例子，写几个类来实现一下吧．
首先设计一个购买的接口代码如下：（ComputerInterface.java）
package test.lyx;
publicinterface ComputerInterface {
publicvoid buy();
}
建一个电脑类实现购买的接口代码如下：（Computer.java）
package test.lyx;
publicclass Computer implements ComputerInterface{
private String pcName="IBMT60";
privateintpcPrice=17800;
public String getPcName() {
returnpcName;
}
publicvoid setPcName(String pcName) {
this.pcName = pcName;
}
publicint getPcPrice() {
returnpcPrice;
}
publicvoid setPcPrice(int pcPrice) {
this.pcPrice = pcPrice;
}
publicvoid buy() {
System.out.print("获得笔记本电脑："+pcName+"一台");
}
}
再建设一个代理商的类：用来完成买电脑和赠送鼠标：（ComputerProxy.java）
package test.lyx;
publicclass ComputerProxy {
private ComputerInterface pci;
public ComputerInterface getPci() {
returnpci;
}
publicvoid setPci(ComputerInterface pci) {
this.pci = pci;
}
publicvoid buy(){
pci.buy();
System.out.println("赠送鼠标一个");
}
}
建一个主函数测试一下吧：（TestDemo.java）
package test.lyx;
publicclass TestDemo {
publicstaticvoid main(String[] args) {
ComputerProxy c1=new ComputerProxy();
c1.setPci(new Computer());
c1.buy();
}
}
运行结果如下：
获得笔记本电脑：IBMT60一台获得鼠标一个
以上就是代理功能的实现，由代理商销售笔记本，并赠送鼠标．但是这样的程序只适合是销售ＩＢＭ笔记本．那么如果要是其它品牌呢．所以我们来更改一个代理类．来实现动态的代理．
建立一个类代码如下：（ComputerProxy2．java）
package test.lyx;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
publicclass ComputerProxy2 implements InvocationHandler{
private Object delegate;
//描述是谁的代理，也就是与那个类有关系
public Object bind(Object delegate){
this.delegate=delegate;
return Proxy.newProxyInstance(delegate.getClass().getClassLoader(), delegate.getClass().getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("赠送鼠标一个！");
Object result=method.invoke(delegate, args);
return result;
}
}
然后在主函数中加上：
ComputerProxy2 c2=new ComputerProxy2();
ComputerInterface ci2=(ComputerInterface)c2.bind(new Computer());
ci2.buy();
就可以实现动态代理了．
[b][/b]

最后更新：2007-07-06 19:12
14:46  |   永久链接  |   浏览 (7023)  |   评论 (20)  |    收藏  |   java  |   进入论坛  |

永久链接

http://lyx.javaeye.com/blog/53795

评论    共 20 条发表评论

rubin     2007-02-11 21:32

能否说下动态代理的原理？比如，ci2.buy(); 为什么就能执行，而ComputerProxy2 并没有这个函数？

lyx_2709     2007-02-12 16:09

动态代理一定要实现这个InvocationHandle接口．接口里面有两个方法．一个bind描述代理那个类，也就是与那个类有关系，主函数里我调用bind方法时给出Computer．也就是代理的Computer类．还有一个方法invoke就是代理与要执行的方法．

rubin     2007-02-14 18:57

哦，我看错了，现在明白了，多谢！

lyx_2709     2007-02-14 21:07

呵呵，客气什么．互相学习吧．

weiqingfei     2007-02-20 09:47

按照代理模式的定义
代理类和被代理类都要实现统一的一个接口，
也就是说Computer，和ComputerProxy都应该实现ComputerInterface，
既然这样，你的第一个实现里，厂商和代理上应该是可以随便组合的，怎么就只适合“IBM笔记本”了？

你为什么有搞一个动态代理呢？有什么优点儿？

lyx_2709     2007-02-20 17:11

对啊，ＩＢＭ的本只送鼠标．如果现在ＳＯＮＹ的本送鼠标和包，静态的代理就实现不了了．只有改程序了．使用动态代理，我们只关注买的是什么品牌的本．送的是什么东西．

weiqingfei     2007-02-21 08:27

lyx_2709 写道

对啊，ＩＢＭ的本只送鼠标．如果现在ＳＯＮＹ的本送鼠标和包，静态的代理就实现不了了．只有改程序了．使用动态代理，我们只关注买的是什么品牌的本．送的是什么东西．

好，如果你让你这个动态代理去卖SONY的本子，他怎么送包？你还不是要修改invoke方法么？

动态代理的好处并不是要动态处理不同的任务，而是动态处理不同的类型，我所说的类型，指的是接口类型。
如果说你的IBM本和sony本继承的同样的接口，用动态代理一点儿意义都没有了。因为它和静态代理一样，只能完成一件附加任务。

lyx_2709     2007-02-23 14:51

嗯，也有道理，
为其他对象提供一种代理以控制对这个对象的访问，说白了就是，在一些情况下客户不想或都不能直接引用一个对象，而代理对象可以在客户和目标对象之间起到中介作用，去掉客户不能看到的内容和服务或都增添客户需要的额外服务．
无论是什么代理商本是肯定的卖的，我们就要实现ComputerInterface这个接口，而不同的代理商优惠的条件不同，在这里也就是说赠的东西不同，我们代理的目的，和现时一样，本本卖的基础上，各个代理商送的东西不同．invoke这个方法在这里就描述了我们送的是什么东西．
我是这样认为的．

weiqingfei     2007-02-23 21:23

lyx_2709 写道

嗯，也有道理，
为其他对象提供一种代理以控制对这个对象的访问，说白了就是，在一些情况下客户不想或都不能直接引用一个对象，而代理对象可以在客户和目标对象之间起到中介作用，去掉客户不能看到的内容和服务或都增添客户需要的额外服务．
无论是什么代理商本是肯定的卖的，我们就要实现ComputerInterface这个接口，而不同的代理商优惠的条件不同，在这里也就是说赠的东西不同，我们代理的目的，和现时一样，本本卖的基础上，各个代理商送的东西不同．invoke这个方法在这里就描述了我们送的是什么东西．
我是这样认为的．

可能我们想的都一样，只是描述的不是很清楚吧。

动态代理和静态代理的主要区别是，静态代理已经知道自己要代理什么类型的东西了，而动态代理却不知道。
比如说，静态代理已经明确是代理买还是卖，还是修理。

但是动态代理不知道，它可以代理一切，只要是有可代理的东西。

但是在代理商自己的附加动作上，两种代理方式应该都是确定了的。
如果一个代理商要送鼠标，那他只能送鼠标，不管他是卖什么东西。
如果想送鼠标又要送键盘，那就得再找一个代理商，不管是静态的还是动态的。

qinysong     2007-03-24 12:58

lyx_2709 写道

代理模式：为其他对象提供一种代理以控制对这个对象的访问．说白了就是，在一些情况下客户不想或不能直接引一个对象，而代理对象可以在客户和目标对象之间起到中介作用．去掉客户不能看到的内容和服务或都增添客户需要的额外服务．
给大家举个比较简单的例子：
假如你买台IBM的笔记本，IBM产家是不提供鼠标的．但是我们如果从代理商的手里买就有鼠标和送．
很简单的例子，写几个类来实现一下吧．
首先设计一个购买的接口代码如下：（ComputerInterface.java）
package test.lyx;
publicinterface ComputerInterface {
publicvoid buy();
}
建一个电脑类实现购买的接口代码如下：（Computer.java）
package test.lyx;
publicclass Computer implements ComputerInterface{
private String pcName="IBMT60";
privateintpcPrice=17800;
public String getPcName() {
returnpcName;
}
publicvoid setPcName(String pcName) {
this.pcName = pcName;
}
publicint getPcPrice() {
returnpcPrice;
}
publicvoid setPcPrice(int pcPrice) {
this.pcPrice = pcPrice;
}
publicvoid buy() {
System.out.print("获得笔记本电脑："+pcName+"一台");
}
}
再建设一个代理商的类：用来完成买电脑和赠送鼠标：（ComputerProxy.java）
package test.lyx;
publicclass ComputerProxy {
private ComputerInterface pci;
public ComputerInterface getPci() {
returnpci;
}
publicvoid setPci(ComputerInterface pci) {
this.pci = pci;
}
publicvoid buy(){
pci.buy();
System.out.println("赠送鼠标一个");
}
}
建一个主函数测试一下吧：（TestDemo.java）
package test.lyx;
publicclass TestDemo {
publicstaticvoid main(String[] args) {
ComputerProxy c1=new ComputerProxy();
c1.setPci(new Computer());
c1.buy();
}
}
运行结果如下：
获得笔记本电脑：IBMT60一台获得鼠标一个
以上就是代理功能的实现，由代理商销售笔记本，并赠送鼠标．但是这样的程序只适合是销售ＩＢＭ笔记本．

对于这个代理的例子，我觉得有两个问题：

第一，这个例子所表现的不是代理Proxy模式，而是装饰器Decorator模式，Decorator模式正是这个例子所表现的为对象动态的添加一些额外的功能或职责；

第二，无论是Proxy模式还是Decorator模式，他们有一个相同的一点是他们与被代理和被装饰的对象具有相同的接口，以便为客户提供透明性，而这点上面的例子没有实现。

对于Proxy和Decorator的比较，可以看看这篇帖子http://www.javaeye.com/topic/39053
以上只是个人看法，共同探讨

礼物 2007-09-22 21:20 发表评论

webwork视频目录

礼物 — Sat, 22 Sep 2007 13:06:00 GMT

webwork原创视频

类型名称下载地址

webwork webwork初体验 http://lyx.javaeye.com/blog/56547　

webwork Model-Driven（模型驱动）、配置表单验证 http://lyx.javaeye.com/blog/55986

webwork junit测试 http://lyx.javaeye.com/blog/57037

webwork 国际化 http://lyx.javaeye.com/blog/57838

webwork webwork集成spring   http://lyx.javaeye.com/blog/58242

webwork webwork上传下载地址

礼物 2007-09-22 21:06 发表评论

Model-Driven（模型驱动）、配置表单验证

礼物 — Sat, 22 Sep 2007 13:03:00 GMT
用登陆演示Model-Driven（模型驱动）、配置表单验证
本文主要在上一个视频（webwork初体验）的基本进行改动，所以在看本文之前，请先浏览上一个视频。

在webwork中Action根据Form的不同可分为二类：

一种是Field-Driven（字段驱动）Action；就是 Action用自己的字段来充当Form的角色，上一个视频给大家演示的例子就是采用了这种方式。本人感觉有点像struts中的动态Form。

当然这只是我自己的一些看法。还有一种是Model-Driven（模型驱动）Action。它很像Struts的Form,但在struts中Form必须继承org.apache.struts.action.ActionForm;或是org.apache.struts.validator包下的几个Form.在WebWork中有所不同，只要普通JavaBean就可以充当模型部分。只要我们在Action中实现com.opensymphony.xwork. ModelDriven接口就可以了，它有一个方法：Object getModel();，这个方法用于返回模型对象。

我们改动上个视频的LoginAction类。代码如下：
java 代码

package com.lyx.web.action;
import com.lyx.bo.User;
import com.opensymphony.xwork.Action;
import com.opensymphony.xwork.ActionSupport;
import com.opensymphony.xwork.ModelDriven;
public class LoginAction implements Action,ModelDriven {
//注意这里的User一定要初始化
    private User user=new User();

    public User getUser() {
        return user;
    }
    public String execute() throws Exception {
        if(user.getUserName().equals("lyx")){
            return this.SUCCESS;
        }else{
            return this.ERROR;
        }
    }
    public Object getModel() {
        // TODO Auto-generated method stub
        return user;
    }

}

红色字体部是我们后加部分。

然后我们就可以将index.jsp页面的代码修改如下：

<form action="login.action">

username:<input type="text" name="userName"/>

password:<input type="password" name="userPwd"/>

<input type="submit" value="login"/>

form>

也就是我们去掉了原有的表达式语言。

然后我们修改xwork.xml配置文件如下：
xml 代码

>
<xwork>
    <include file="webwork-default.xml" />
    <package name="default" extends="webwork-default">
        <action name="login" class="com.lyx.web.action.LoginAction">

            <result name="success" type="dispatcher">
                <param name="location">/success.jspparam>
            result>

            <result name="error" type="dispatcher">
                <param name="location">/error.jspparam>
            result>
            <interceptor-ref name="model-driven"/>
            <interceptor-ref name="params"/>
        action>
    package>
xwork>

也就是在原有的基础上加了一行模型驱动的拦截器。作用就是将模型对象保存到值堆栈中。

就样就ＯＫ了。这里要注意，model-driven拦截器要在params的上面。可以测试一下看看。

整过过程，非常像struts中，Action与ActionForm的关系。

通过测试，功能和以前的一样。很简单吧。就不在多述了。

第二个重点我们来配置一个表单的验证：

在 src 目录下新建 validators.xml 文件，文件内容如下：
xml 代码

<validators>
    <validator name="required" class="com.opensymphony.xwork.validator.validators.RequiredFieldValidator"/>
    <validator name="requiredstring" class="com.opensymphony.xwork.validator.validators.RequiredStringValidator"/>
    <validator name="int" class="com.opensymphony.xwork.validator.validators.IntRangeFieldValidator"/>
    <validator name="date" class="com.opensymphony.xwork.validator.validators.DateRangeFieldValidator"/>
    <validator name="expression" class="com.opensymphony.xwork.validator.validators.ExpressionValidator"/>
    <validator name="fieldexpression" class="com.opensymphony.xwork.validator.validators.FieldExpressionValidator"/>
    <validator name="email" class="com.opensymphony.xwork.validator.validators.EmailValidator"/>
    <validator name="url" class="com.opensymphony.xwork.validator.validators.URLValidator"/>
    <validator name="visitor" class="com.opensymphony.xwork.validator.validators.VisitorFieldValidator"/>
    <validator name="conversion" class="com.opensymphony.xwork.validator.validators.ConversionErrorFieldValidator"/>
    <validator name="stringlength" class="com.opensymphony.xwork.validator.validators.StringLengthFieldValidator"/>
validators>

这个文件可以在网上下得到。也可以在webwork的源码中得到。不是不想起了struts中有个valiator-rules.xml文件。这个文件在struts中是描述着验证的规则，里面有好多已经写好了的验证，我们可以很方便的调用。这里的这个文件功能和struts中的类似。

   要启动表单验证，需要增加一个拦截器，还有就是我们在struts的struts-config.xml配置文件中Action的配置有个input属性，它是用来当验证失败时所在跳到的页，在这里如果登陆失败我们应该跳到index页，显示失败的原因，重新登陆。在webwork中我们也用input来描述这个功能。在一个result.

对xwork.xml 文件进行修改，增加<interceptor-ref name="validationWorkflowStack" />

修改后xwork.xml代码如下：
xml 代码

<include file="webwork-default.xml" />
    <package name="default" extends="webwork-default">
        <action name="login" class="com.lyx.web.action.LoginAction">

            <result name="success" type="dispatcher">
                <param name="location">/success.jspparam>
            result>

            <result name="error" type="dispatcher">
                <param name="location">/error.jspparam>
            result>
            <result name="input" type="dispatcher">
                <param name="location">/index.jspparam>
            result>

            <interceptor-ref name="model-driven"/>
            <interceptor-ref name="params"/>
            <interceptor-ref name="validationWorkflowStack" />
        action>
    package>

我们已经用到了success，他指成功所要跳到的页。Error是错误所要跳到的页。Input是指失败时所要返回来登陆的页。在webwork中还有几个。以后我们会看得到，用到的时候在详细讲解。

   建立验证规则

      对 LoginAction 进行验证规则的配置，需要新建一个配置文件，文件名起名是以Action 的名称开头以validation结尾，中间用”-”隔开.xml并保存到 LoginAction.java 文件所在的目录中



   代码如下： LoginAction-validation.xml

xml 代码

>
<validators>
    <field name="userName">
        <field-validator type="requiredstring">
            <message>username is required!message>
        field-validator>
    field>
    <field name="userPwd">
        <field-validator type="requiredstring">
            <message> password is required!message>
        field-validator>
    field>
validators>

这个文件很像struts中的validation.xml。功能和他是一样的。配置表单的验证。这里我们只验证也用户名和密码为必须填写。注意：这个name的属性一定要和User类中的对应。规则是和struts中一样的。对应才能有交的验证。

为了能显示验证的信息再次修改index页面如下：

<ww:form action="login.action" method="POST">

         username:   <ww:textfield label="Username" name="userName" required="true"/>

          password: <ww:password label="Password" name="userPwd" required="true"/>

            <ww:submit value="Submit"/>

     ww:form>

这几行很简单，从字面上就可以看出，就不在多述了。

基本代码就这些，测试一下，看看吧。

哦，没有验证，还忘了一步，回头看看

除了上述的配置外，我们的Action还要继承ActionSupport类，这个类存放着错误的信息，并能将错误的状态返回到页面

在改一下，试试

ＯＫ了。好用了。呵呵，刚是太急用了，忘了最关键的一步。大家在开发当中可以细心点啊。

因为，录这个视频是在公司，不能有声音讲解给大家听。请大家谅解。这段时间比较忙，过了这段时间，给大家录个有声音的。呵呵。

我的联系方式：

ＭＳＮ；Lyx_2709@hotmail.com

Email:Lyx_happy@163.com

就到这里吧。希望大家能多提宝贵意见！

webwork模型驱动与表单验证.part1.rar

描述: 第一部分视频
下载

文件名: webwork模型驱动与表单验证.part1.rar

文件大小: 3 M

下载过的: 文件被下载或查看 1277 次

webwork模型驱动与表单验证.part2.rar

描述: 第二部分视频
下载

文件名: webwork模型驱动与表单验证.part2.rar

文件大小: 3 M

下载过的: 文件被下载或查看 1101 次

webworkfirst.rar

描述: 程序源码
下载

文件名: webworkfirst.rar

文件大小: 8 KB

下载过的: 文件被下载或查看 350 次

礼物 2007-09-22 21:03 发表评论

eclipse 属性文件，自动转为Unicode编码

礼物 — Thu, 20 Sep 2007 09:21:00 GMT
[ INSTALLATION ]

Please choose from the screen of Eclipse with "Help" ->"Software Updates" -> "Update Manager". An 'Update Manager' opens.

In the "Feature Updates" view at the lower left of an 'Update Manager', please carry out the right click of the "Sites to Visit", and create a site bookmark by "New" -> "Site Bookmark...".
- The bookmark to create should input the following "URL" and should push an "Finish" button.
Name: Arbitrary input
URL : http://propedit.sourceforge.jp/eclipse/updates/
Bookmark type: Eclipse update site

If a site bookmark is created, the bookmark created at the bottom of "Feature Updates" will appear.
A click of "jp.gr.java_conf.ussiy.app.propedit.eclipse.feature.PropertiesEditorFeature x.x.x" displays a preview on a right window. Since the button "Install Now" is in around the lower right, please click.

Since an installation wizard starts, please click a "Next" button rapidly.

"You will need to restart the workbench for the changes to take effect. Would you like to restart now?" is displayed. Please reboot Eclipse according to a dialog.

礼物 2007-09-20 17:21 发表评论

代号	代号2	代号3	明细
${list["1"]}	${list["2"]}	${list["3"]}	${list.zt}
${list2["1"]}	${list2["2"]}	${list2["3"]}	${list2["zt"]}

类型	名称	下载地址
webwork	webwork初体验	http://lyx.javaeye.com/blog/56547
webwork	Model-Driven（模型驱动）、配置表单验证	http://lyx.javaeye.com/blog/55986
webwork	junit测试	http://lyx.javaeye.com/blog/57037
webwork	国际化	http://lyx.javaeye.com/blog/57838
webwork	webwork集成spring	http://lyx.javaeye.com/blog/58242
webwork	webwork上传	下载地址

webwork模型驱动与表单验证.part1.rar
描述:	第一部分视频	下载
文件名:	webwork模型驱动与表单验证.part1.rar
文件大小:	3 M
下载过的:	文件被下载或查看 1277 次

webwork模型驱动与表单验证.part2.rar
描述:	第二部分视频	下载
文件名:	webwork模型驱动与表单验证.part2.rar
文件大小:	3 M
下载过的:	文件被下载或查看 1101 次

webworkfirst.rar
描述:	程序源码	下载
文件名:	webworkfirst.rar
文件大小:	8 KB
下载过的:	文件被下载或查看 350 次

BlogJava-Terry.B.Li 彬-文章分类-java

纯真IP数据库格式详解

java读取纯真IP数据库QQwry.dat的源代码

图片截取和缩略

spring任务调度方法之Quartz

使用JMeter进行性能测试

(原)Proxool 连接池

（原）Java 类访问 URI

(转载)应用架构设计“防火”经验分享

(转载)各种架构图汇总!

正则表达式30分钟入门教程

本文目标

如何使用本教程

正则表达式到底是什么东西？

入门

测试正则表达式

元字符

字符转义

重复

字符类

分枝条件

分组

反义

后向引用

零宽断言

负向零宽断言

注释

贪婪与懒惰

处理选项

平衡组/递归匹配

还有些什么东西没提到

将任意格式转换为JSON数据格式的工具类

HTTP/1.1 Cache-Control的理解

Tomcat下绑定JMS应用服务器的实例讲解

(转载)将任意格式转换为JSON数据格式的工具类

JAVA加密算法简介

url加密参数 （java版）

FreeMarker学习笔记

压缩/解压缩zip包处理

UUIDGenerator 主键产生器

JBOSS只能用localhost或127.0.0.1访问的解决办法

Jboss 和 JMS

Jboss 作为window的服务

java 国际化-资源文件的使用 (i18n)

Java国际化——资源包的使用

资源包

ResourceBundle类

ListResourceBundle和PropertyResourceBundle子类

使用资源文件

使用ListResourceBundle

MessageFormat类

关于资源包的组织

提升JSP页面响应速度的七大秘籍绝招

对ibatis分页功能的改进

jsp 70 问答

JAVA的代理模式

webwork视频目录

Model-Driven（模型驱动）、配置表单验证

eclipse 属性文件，自动转为Unicode编码

url加密参数（java版）