--create common service

jfwUtil/src/main/java/org/jfw/util/StringUtil.java

import java.util.UUID;
public final class StringUtil {
	private StringUtil() {
	}
	public static String fromWithUTF8(InputStream in) throws IOException {
		char[] buf = new char[1024];
		Reader r = new BufferedReader(new InputStreamReader(in, ConstData.UTF8));
		int len = 0;
		StringBuilder sb = new StringBuilder();
		while ((len = r.read(buf)) != -1) {
			if (len > 0)
				sb.append(buf, 0, len);
		}
		return sb.toString();
	}
	public static String fromByUTF8AndClose(InputStream in) throws IOException {
		try {
			char[] buf = new char[1024];
			Reader r = new BufferedReader(new InputStreamReader(in, ConstData.UTF8));
			int len = 0;
			StringBuilder sb = new StringBuilder();
			while ((len = r.read(buf)) != -1) {
				if (len > 0)
					sb.append(buf, 0, len);
			}
			return sb.toString();
		} finally {
			try {
				in.close();
			} catch (Exception e) {
			}
		}
	}
	public static Map<String, String[]> decodeURLQueryString(String queryString) throws UnsupportedEncodingException {
		Map<String, String[]> result = new HashMap<String, String[]>();
		if (queryString != null) {
			List<String> list = ListUtil.splitTrimExcludeEmpty(queryString, '&');
			for (String str : list) {
				int index = str.indexOf('=');
				if (index > 0) {
					String key = str.substring(0, index);
					String value = str.substring(index + 1);
					if (value.length() > 0)
						value = java.net.URLDecoder.decode(str.substring(index + 1), "UTF-8");
					String[] values = result.get(key);
					if (values == null) {
						values = new String[] { value };
					} else {
						String[] nv = new String[values.length + 1];
						System.arraycopy(values, 0, nv, 0, values.length);
						nv[values.length] = value;
						values = nv;
					}
					result.put(key, values);
				}
			}
		}
		return result;
	}
	public static String buildUUID() {
		return UUID.randomUUID().toString().replaceAll("-", "").toUpperCase(Locale.US);
	}
	public static String md5(String str) {
		byte[] bytes = str.getBytes(ConstData.UTF8);
		MessageDigest md5 = null;
		try {
			md5 = MessageDigest.getInstance("MD5");
		} catch (NoSuchAlgorithmException e) {
			throw new RuntimeException("jdk unsupported md5???????????", e);
		}
		md5.update(bytes);
		byte[] tmp = md5.digest();
		StringBuilder sb = new StringBuilder();
		for (byte b : tmp) {
			sb.append(digits[(b & 0xf0) >> 4]);
			sb.append(digits[b & 0xf]);
		}
		return sb.toString();
	}
	public static String toHexString(byte b) {
		char[] cs = new char[2];
		cs[1] = digits[b & 0xf];
		cs[0] = digits[(b & 0xf0) >> 4];
		return new String(cs);
	}
	public static String toHexString(int i) {
		char[] cs = new char[4];
		cs[3] = digits[i & 0xf];
		cs[2] = digits[(i & 0xf0) >> 4];
		cs[1] = digits[(i & 0xf00) >> 8];
		cs[0] = digits[(i & 0xf000) >> 12];
		return new String(cs);
	}
	final static char[] digits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
	public static void main(String[] args) {
		System.out.println(toHexString(0x1fff));
	}
    private StringUtil() {
    }
    public static String fromWithUTF8(InputStream in) throws IOException {
        char[] buf = new char[1024];
        Reader r = new BufferedReader(new InputStreamReader(in, ConstData.UTF8));
        int len = 0;
        StringBuilder sb = new StringBuilder();
        while ((len = r.read(buf)) != -1) {
            if (len > 0)
                sb.append(buf, 0, len);
        }
        return sb.toString();
    }
    public static String fromByUTF8AndClose(InputStream in) throws IOException {
        try {
            char[] buf = new char[1024];
            Reader r = new BufferedReader(new InputStreamReader(in, ConstData.UTF8));
            int len = 0;
            StringBuilder sb = new StringBuilder();
            while ((len = r.read(buf)) != -1) {
                if (len > 0)
                    sb.append(buf, 0, len);
            }
            return sb.toString();
        } finally {
            try {
                in.close();
            } catch (Exception e) {
            }
        }
    }
    public static Map<String, String[]> decodeURLQueryString(String queryString) throws UnsupportedEncodingException {
        Map<String, String[]> result = new HashMap<String, String[]>();
        if (queryString != null) {
            List<String> list = ListUtil.splitTrimExcludeEmpty(queryString, '&');
            for (String str : list) {
                int index = str.indexOf('=');
                if (index > 0) {
                    String key = str.substring(0, index);
                    String value = str.substring(index + 1);
                    if (value.length() > 0)
                        value = java.net.URLDecoder.decode(str.substring(index + 1), "UTF-8");
                    String[] values = result.get(key);
                    if (values == null) {
                        values = new String[] { value };
                    } else {
                        String[] nv = new String[values.length + 1];
                        System.arraycopy(values, 0, nv, 0, values.length);
                        nv[values.length] = value;
                        values = nv;
                    }
                    result.put(key, values);
                }
            }
        }
        return result;
    }
    public static String buildUUID() {
        return UUID.randomUUID().toString().replaceAll("-", "").toUpperCase(Locale.US);
    }
    public static String md5(String str) {
        byte[] bytes = str.getBytes(ConstData.UTF8);
        MessageDigest md5 = null;
        try {
            md5 = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("jdk unsupported md5???????????", e);
        }
        md5.update(bytes);
        byte[] tmp = md5.digest();
        StringBuilder sb = new StringBuilder();
        for (byte b : tmp) {
            sb.append(digits[(b & 0xf0) >> 4]);
            sb.append(digits[b & 0xf]);
        }
        return sb.toString();
    }
    public static String toHexString(byte b) {
        char[] cs = new char[2];
        cs[1] = digits[b & 0xf];
        cs[0] = digits[(b & 0xf0) >> 4];
        return new String(cs);
    }
    public static String toHexString(int i) {
        char[] cs = new char[4];
        cs[3] = digits[i & 0xf];
        cs[2] = digits[(i & 0xf0) >> 4];
        cs[1] = digits[(i & 0xf00) >> 8];
        cs[0] = digits[(i & 0xf000) >> 12];
        return new String(cs);
    }
    public static String bytesToStringDesc(byte[] bytes) {
        if (null == bytes)
            return "null";
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        char[] cs = new char[3];
        cs[2]=',';
        for (int i = 0; i < bytes.length; ++i) {
            byte b = bytes[i];
            cs[1] = digits[b & 0xf];
            cs[0] = digits[(b & 0xf0) >> 4];
            sb.append(cs);
        }
        sb.append("]");
        return sb.toString();
    }
    final static char[] digits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    public static void main(String[] args) {
        System.out.println(toHexString(0x1fff));
    }
}

jfwUtil/src/main/java/org/jfw/util/cache/CacheService.java

package org.jfw.util.cache;
import java.lang.reflect.Type;
public interface CacheService {
    /**
     * cache a object,non expired
     * @param obj cached object     not null
     * @return  key in cache area
     * @throws JfwCacheException
     */
    String put(Object obj) throws JfwCacheException;
    /**
     * cache object with specified expire time
     * @param obj cached object   not null
     * @param expireTime  unit is millisecond    =0 ||  expireTime > System.currMilliseconds,   0  is non expired   
     *                expireTime  is deadline
     * @return
     * @throws JfwCacheException
     */
    String put(Object obj,long expireTime)throws JfwCacheException;
    
    
    /**
     * cache a object,non expired
     * @param key 
     * @param obj cached object     not null
     * @return  key in cache area
     * @throws JfwCacheException
     */
    void put(String key,Object obj) throws JfwCacheException;
    /**
     * cache object with specified expire time
     * @param key 
     * @param obj cached object   not null
     * @param expireTime  unit is millisecond    =0 ||  expireTime > System.currMilliseconds,   0  is non expired   
     *                expireTime  is deadline
     * @return
     * @throws JfwCacheException
     */
    void put(String key,Object obj,long expireTime)throws JfwCacheException;
    
    /**
     * modify expire time with a cache object ,
     * @param key  key with cache object
     * @param newExprieTime new exprie time unit is millisecond    =0 ||  expireTime > System.currMilliseconds,   0  is non expired   
     *                expireTime  is deadline
     * @return  old exprie time , -1 is not exists 
     * @throws JfwCacheException
     */
    long expire(String key,long newExprieTime) throws JfwCacheException;
    /**
     * 
     * @param key
     * @return exprie time , -1 is not exists
     * @throws JfwCacheException
     */
    long getExprieTime(String key) throws JfwCacheException;
    /**
     * 
     * @param key
     * @return
     * @throws JfwCacheException
     */
    <T> T get(String key,Class<T> clazz)throws JfwCacheException;
    <T> T get(String key,Type typeOfT) throws JfwCacheException;
    Object get(String key)throws JfwCacheException;
    
    String put(int i)throws JfwCacheException;
    String put(byte b)throws JfwCacheException;
    String put(short s)throws JfwCacheException;
    String put(long l)throws JfwCacheException;
    String put(float f)throws JfwCacheException;
    String put(double d)throws JfwCacheException;
    String put(boolean b)throws JfwCacheException;
    String put(String s)throws JfwCacheException;
    String put(String key,int i)throws JfwCacheException;
    String put(String key,byte b)throws JfwCacheException;
    String put(String ket,short s)throws JfwCacheException;
    String put(String key,long l)throws JfwCacheException;
    String put(String key,float f)throws JfwCacheException;
    String put(String key,double d)throws JfwCacheException;
    String put(String key,boolean b)throws JfwCacheException;
    String put(String key,String s)throws JfwCacheException;
    
    int get(String key,int defaultValue)throws JfwCacheException;   
    byte get(String key,byte defaultValue)throws JfwCacheException;   
    short get(String key,short defaultValue)throws JfwCacheException;  
    long get(String key,long defaultValue)throws JfwCacheException;   
    float get(String key,float defaultValue)throws JfwCacheException;  
    double get(String key,double defaultValue)throws JfwCacheException; 
    boolean get(String key,boolean defaultValue)throws JfwCacheException;
    
    
    /**
     * remove a cached object 
     * @param key
     * @return true exists , false not exists 
     * @throws JfwCacheException
     */
    boolean remove(String key)throws JfwCacheException;
    
    
    
    
}

jfwUtil/src/main/java/org/jfw/util/cache/JfwCacheException.java

package org.jfw.util.cache;
import org.jfw.util.exception.JfwBaseException;
//TODO : define exception 
public class JfwCacheException extends JfwBaseException{
    private static final long serialVersionUID = -4683352043487231658L;
}

jfwUtil/src/main/java/org/jfw/util/codec/Base64CodecService.java

package org.jfw.util.codec;
import java.nio.charset.Charset;
import org.jfw.util.ConstData;
public class Base64CodecService implements CodecService {
    public static final String CODEC_TYPE="BASE64";
    @Override
    public byte[] encode(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return bytes;
        }
        return (new Base64(false)).encode(bytes);
    }
    @Override
    public byte[] decode(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return bytes;
        }
        return (new Base64(false)).decode(bytes);
    }
    @Override
    public byte[] encode(byte[] bytes, byte[] key) {
       return this.encode(bytes);
    }
    @Override
    public byte[] decode(byte[] bytes, byte[] key) {
       return this.decode(bytes);
    }
    @Override
    public String encode(String s) {
        return new String(this.encode(s.getBytes(ConstData.UTF8)),ConstData.UTF8);
    }
    @Override
    public String decode(String s) {
        return new String(this.decode(s.getBytes(ConstData.UTF8)),ConstData.UTF8);
    }
    @Override
    public String encode(String s, byte[] key) {
        return this.encode(s);
    }
    @Override
    public String decode(String s, byte[] key) {
      return this.decode(s);
    }
    @Override
    public String encode(String s, String enc) {
        Charset c = Charset.forName(enc);
        return new String(this.encode(s.getBytes(c)),c);
    }
    @Override
    public String decode(String s, String enc) {
        Charset c = Charset.forName(enc);
        return new String(this.decode(s.getBytes(c)),c);
    }
    @Override
    public String encode(String s, byte[] key, String enc) {
      return this.encode(s, enc);
    }
    @Override
    public String decode(String s, byte[] key, String enc) {
        return this.decode(s, enc);
    }
}

jfwUtil/src/main/java/org/jfw/util/codec/CodecService.java

package org.jfw.util.codec;
public interface CodecService {
    /**
     * Encodes a byte array  using default key
     * @param bytes  byte array to be encoded.
     * @return the encoded byte array
     */
    byte[] encode(byte[] bytes)throws JfwCodecException;
    /**
     * Decodes a byte array  using default key
     * @param bytes  byte array to be Decoded.
     * @return the decoded byte array
     */
    byte[] decode(byte[] bytes)throws JfwCodecException;
    /**
     * Encodes a byte array  using specified key
     * @param bytes  byte array to be encoded.
     * @return the encoded byte array
     * @throws JfwCodecKeyException 
     */
    byte[] encode(byte[] bytes,byte[] key)throws JfwCodecException;
    /**
     * Decodes a byte array  using specified key
     * @param bytes  byte array to be decoded.
     * @return the decoded byte array
     */
    byte[] decode(byte[] bytes,byte[] key)throws JfwCodecException;
    /**
     * Encode a string  by UTF-8  using default key
     * @param s String to be encoded.
     * @return the encoded String
     */
    String encode(String s)throws JfwCodecException;
    /**
     * Decodes a String by UTF-8  using default key
     * @param s  a String to be decoded.
     * @return the decoded String
     */  
    String decode(String s)throws JfwCodecException;
    /**
     * Encodes a String by UTF-8  using specified key
     * @param s  a String  to be encoded.
     * @return the encoded byte array
     */
    String encode(String s,byte[] key)throws JfwCodecException;
    /**
     * Decodes a String by UTF-8  using specified key
     * @param s  a String to be decoded.
     * @return the decoded String
     */ 
    String decode(String s,byte[] key)throws JfwCodecException;
    /**
     * Encode a string  by specified charset  using default key
     * @param s String to be encoded.
     * @return the encoded String
     */
    String encode(String s,String enc)throws JfwCodecException;
    /**
     * Decodes a String by specified  using default key
     * @param s  a String to be decoded.
     * @return the decoded String
     */  
    String decode(String s,String enc)throws JfwCodecException;
    /**
     * Encode a string  by specified charset  using specified key
     * @param s String to be encoded.
     * @return the encoded String
     */
    String encode(String s,byte[] key,String enc)throws JfwCodecException;
    /**
     * Decodes a String by specified  using specified key
     * @param s  a String to be decoded.
     * @return the decoded String
     */  
    String decode(String s,byte[] key,String enc)throws JfwCodecException;   
}

jfwUtil/src/main/java/org/jfw/util/codec/DesCodecService.java

package org.jfw.util.codec;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.util.Random;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import org.jfw.util.StringUtil;
public class DesCodecService implements CodecService {
    public static final byte[] DEFAULT_KEY_BYTES = new byte[] { 65, 66, 67, 68, 69, 70, 71, 72 };
    public static final String CODEC_TYPE="DES";
    
    public static DESKeySpec createKey(byte[] key) throws JfwCodecException{
        try {
            return  new DESKeySpec(key);
        } catch (InvalidKeyException e) {
            throw new JfwInvalidCodecKeyException(CODEC_TYPE, key, e);
        }
    }
    @Override
    public byte[] encode(byte[] bytes) throws JfwCodecException {
        return this.encode(bytes,DEFAULT_KEY_BYTES);
    }
    @Override
    public byte[] decode(byte[] bytes) throws JfwCodecException {
       return this.decode(bytes,DEFAULT_KEY_BYTES);
    }
    @Override
    public byte[] encode(byte[] bytes, byte[] key) throws JfwCodecException {
        SecureRandom random = new SecureRandom();
        DESKeySpec desKey = createKey(key);
        SecretKeyFactory keyFactory;
        try {
            keyFactory = SecretKeyFactory.getInstance("DES");
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
        SecretKey securekey;
        try {
            securekey = keyFactory.generateSecret(desKey);
        } catch (InvalidKeySpecException e) {
            throw new JfwInvalidCodecKeyException(CODEC_TYPE, key, e);
        }
        Cipher cipher;
        try {
            cipher = Cipher.getInstance("DES");
        } catch (Exception e) {
            throw new RuntimeException(e);
        } 
        try {
            cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
        } catch (InvalidKeyException e) {
            throw new JfwInvalidCodecKeyException(CODEC_TYPE, key, e);
        }
        try {
            return cipher.doFinal(bytes);
        } catch (Exception e) {
            throw new JfwCodecException(CODEC_TYPE, 402, "encode error", e);
        } 
    }
    @Override
    public byte[] decode(byte[] bytes, byte[] key) throws JfwCodecException {
        SecureRandom random = new SecureRandom();
        DESKeySpec desKey = createKey(key);
        SecretKeyFactory keyFactory;
        try {
            keyFactory = SecretKeyFactory.getInstance("DES");
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
        SecretKey securekey;
        try {
            securekey = keyFactory.generateSecret(desKey);
        } catch (InvalidKeySpecException e) {
            throw new JfwInvalidCodecKeyException(CODEC_TYPE, key, e);
        }
        Cipher cipher;
        try {
            cipher = Cipher.getInstance("DES");
        } catch (Exception e) {
            throw new RuntimeException(e);
        } 
        try {
            cipher.init(Cipher.DECRYPT_MODE, securekey, random);
        } catch (InvalidKeyException e) {
            throw new JfwInvalidCodecKeyException(CODEC_TYPE, key, e);
        }
        try {
            return cipher.doFinal(bytes);
        } catch (Exception e) {
            throw new JfwCodecException(CODEC_TYPE, 403, "decode error", e);
        } 
    }
    @Override
    public String encode(String s) throws JfwCodecException {
        throw new UnsupportedOperationException();
    }
    @Override
    public String decode(String s) throws JfwCodecException {
        throw new UnsupportedOperationException();
    }
    @Override
    public String encode(String s, byte[] key) throws JfwCodecException {
        throw new UnsupportedOperationException();
    }
    @Override
    public String decode(String s, byte[] key) throws JfwCodecException {
        throw new UnsupportedOperationException();
    }
    @Override
    public String encode(String s, String enc) throws JfwCodecException {
        throw new UnsupportedOperationException();
    }
    @Override
    public String decode(String s, String enc) throws JfwCodecException {
        throw new UnsupportedOperationException();
    }
    @Override
    public String encode(String s, byte[] key, String enc) throws JfwCodecException {
        throw new UnsupportedOperationException();
    }
    @Override
    public String decode(String s, byte[] key, String enc) throws JfwCodecException {
        throw new UnsupportedOperationException();
    }
   
    
    public static void main(String[] args)throws Exception{
        Random ra =new Random();
        CodecService cs = new DesCodecService();
        int len = 256;
        byte[] source = new byte[len];
        for(int i = 0 ; i < len;++i){
            source[i] =(byte)(ra.nextInt(255)-128);
        }
      byte[] key= new byte[]{1,2,3,4,5,6,7,8};
        System.out.println(StringUtil.bytesToStringDesc(source));
        byte[] dest = cs.encode(source,key);
        System.out.println(""+dest.length+StringUtil.bytesToStringDesc(dest));
        
        byte[] es = cs.decode(dest,key);
        
        System.out.println(""+es.length+StringUtil.bytesToStringDesc(es));
    }
}

jfwUtil/src/main/java/org/jfw/util/codec/JfwCodecException.java

package org.jfw.util.codec;
import org.jfw.util.exception.JfwBaseException;
public class JfwCodecException extends JfwBaseException {
    private static final long serialVersionUID = 6032614432891886439L;
    private String codecType;
    public JfwCodecException(String codecType) {
        super();
        this.codecType = codecType;
    }
    public JfwCodecException(String codecType, int code, String message, Throwable cause) {
        super(code, message, cause);
        this.codecType = codecType;
    }
    public JfwCodecException(String codecType, int code, String message) {
        super(code, message);
        this.codecType = codecType;
    }
    public JfwCodecException(String codecType, int code, Throwable cause) {
        super(code, cause);
        this.codecType = codecType;
    }
    public JfwCodecException(String codecType, int code) {
        super(code);
        this.codecType = codecType;
    }
    public JfwCodecException(String codecType, String message, Throwable cause) {
        super(message, cause);
        this.codecType = codecType;
    }
    public JfwCodecException(String codecType, String message) {
        super(message);
        this.codecType = codecType;
    }
    public JfwCodecException(String codecType, Throwable cause) {
        super(cause);
        this.codecType = codecType;
    }
    public String getCodecType() {
        return codecType;
    }
    public void setCodecType(String codecType) {
        this.codecType = codecType;
    }
    
}

jfwUtil/src/main/java/org/jfw/util/codec/JfwInvalidCodecKeyException.java

package org.jfw.util.codec;
import org.jfw.util.StringUtil;
public class JfwInvalidCodecKeyException extends JfwCodecException {
    private static final long serialVersionUID = 2397737655762171304L;
    private byte[] key;
    public byte[] getKey() {
        return key;
    }
    public void setKey(byte[] key) {
        this.key = key;
    }
    public JfwInvalidCodecKeyException(String codecType,byte[] key,Throwable cause ) {
        super(codecType,401,"Invalid codec key:"+StringUtil.bytesToStringDesc(key),cause);
        this.key = key;
    }
}

jfwUtil/src/main/java/org/jfw/util/codec/UrlSafeBase64CodecService.java

package org.jfw.util.codec;
public class UrlSafeBase64CodecService extends Base64CodecService {
    public static final String CODEC_TYPE="BASE64_URLSAFE";
    @Override
    public byte[] encode(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return bytes;
        }
        return (new Base64(true)).encode(bytes);
    }
    @Override
    public byte[] decode(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return bytes;
        }
        return (new Base64(true)).decode(bytes);
    }
    
}

jfwUtil/src/main/java/org/jfw/util/pojo/BuildTimeObj.java

package org.jfw.util.pojo;
public class BuildTimeObj<T> {
    protected long buildTime;
    protected T value;
    public BuildTimeObj() {
        this.buildTime = System.currentTimeMillis();
    }
    public BuildTimeObj(T obj) {
       
        this.buildTime = System.currentTimeMillis();
        this.value = obj;
    }
    public long getBuildTime() {
        return buildTime;
    }
    public void setBuildTime(long buildTime) {
        if (buildTime >= 0)
            this.buildTime = buildTime;
    }
    public T getValue() {
        return value;
    }
    public void setValue(T value) {
        this.value = value;
    }
}

jfwUtil/src/main/java/org/jfw/util/pojo/Entity.java

package org.jfw.util.pojo;
public class Entity<K,V> {
    protected K key;
    protected V value;
    
    public Entity(){}
    public Entity(K key,V value){
        this.key = key;
        this.value = value;
    }
    public K getKey() {
        return key;
    }
    public void setKey(K key) {
        this.key = key;
    }
    public V getValue() {
        return value;
    }
    public void setValue(V value) {
        this.value = value;
    }
}

jfwUtil/src/main/java/org/jfw/util/pojo/ExpireObj.java

package org.jfw.util.pojo;
public class ExpireObj<T> extends BuildTimeObj<T> {
    protected long expireTime;
    public ExpireObj(){
        super();
        this.expireTime = Long.MAX_VALUE;
    }
    public ExpireObj(T obj){
        super(obj);
        this.expireTime = Long.MAX_VALUE;
    }
    public long getExpireTime() {
        return expireTime;
    }
    public void setExpireTime(long expireTime) {
        this.expireTime = expireTime;
    }
    public void setSurvivalTime(long time){
        long max = Long.MAX_VALUE - this.getBuildTime();
        if(max>= time) this.expireTime = this.buildTime+time;
    }
    public boolean isExpired(){
        return this.expireTime < System.currentTimeMillis();
    }
}

jfwUtil/src/main/java/org/jfw/util/secure/DefaultSecureService.java

package org.jfw.util.secure;
import java.lang.reflect.Type;
import org.jfw.util.ConstData;
import org.jfw.util.codec.CodecService;
import org.jfw.util.codec.DesCodecService;
import org.jfw.util.codec.UrlSafeBase64CodecService;
import org.jfw.util.exception.JfwBaseException;
import org.jfw.util.serializer.DefaultJsonSerializeService;
import org.jfw.util.serializer.SerializeService;
public class DefaultSecureService implements SecureService {
    private CodecService base64Codec  = new UrlSafeBase64CodecService();
    private CodecService secureCodec = new DesCodecService();
    private SerializeService serializeService = new DefaultJsonSerializeService();
    
    public SerializeService getSerializeService() {
        return serializeService;
    }
    public void setSerializeService(SerializeService serializeService) {
        this.serializeService = serializeService;
    }
    public CodecService getBase64Codec() {
        return base64Codec;
    }
    public void setBase64Codec(CodecService base64Codec) {
        this.base64Codec = base64Codec;
    }
    public CodecService getSecureCodec() {
        return secureCodec;
    }
    public void setSecureCodec(CodecService secureCodec) {
        this.secureCodec = secureCodec;
    }
    @Override
    public byte[] serialize(Object obj) throws JfwBaseException {
       return this.secureCodec.encode(this.serializeService.serialize(obj));
    }
    @Override
    public <T> T deSerialize(byte[] bytes, Class<T> clazz) throws JfwBaseException {
        return this.serializeService.deSerialize(this.secureCodec.decode(bytes), clazz);
    }
    @Override
    public <T> T deSerialize(byte[] bytes, Type type) throws JfwBaseException {
        return this.serializeService.deSerialize(this.secureCodec.decode(bytes), type);
    }
    @Override
    public String serializeToString(Object obj) throws JfwBaseException {
       return new String(this.base64Codec.encode(this.serialize(obj)),ConstData.UTF8);
    }
    @Override
    public <T> T deSerialize(String s, Class<T> clazz) throws JfwBaseException {
       return this.deSerialize(s.getBytes(ConstData.UTF8), clazz);
    }
    @Override
    public <T> T deSerialize(String s, Type type) throws JfwBaseException {
        return this.deSerialize(s.getBytes(ConstData.UTF8), type);
    }
}

jfwUtil/src/main/java/org/jfw/util/secure/SecureService.java

package org.jfw.util.secure;
import java.lang.reflect.Type;
import org.jfw.util.exception.JfwBaseException;
public interface SecureService {
    byte[] serialize(Object obj) throws JfwBaseException;
    <T> T deSerialize(byte[] bytes,Class<T> clazz) throws JfwBaseException;
    <T> T deSerialize(byte[] bytes,Type type)throws JfwBaseException;
    String serializeToString(Object obj) throws JfwBaseException;
    <T> T deSerialize(String s,Class<T> clazz) throws JfwBaseException;
    <T> T deSerialize(String s,Type type)throws JfwBaseException;    
}

jfwUtil/src/main/java/org/jfw/util/serializer/DefaultJsonSerializeService.java

package org.jfw.util.serializer;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.lang.reflect.Type;
import org.jfw.util.ConstData;
import org.jfw.util.exception.JfwBaseException;
import com.google.gson.Gson;
import com.google.gson.JsonIOException;
import com.google.gson.JsonSyntaxException;
public class DefaultJsonSerializeService implements SerializeService{
    private final static Gson gson = new Gson();;
    @Override
    public byte[] serialize(Object obj) {
       if(obj==null) throw new NullPointerException();
       return gson.toJson(obj).getBytes(ConstData.UTF8);
    }
    @Override
    public SerializeService serialize(Object obj, OutputStream out) throws JfwBaseException {
      try {
        gson.toJson(obj, new OutputStreamWriter(out, ConstData.UTF8));
    } catch (JsonIOException e) {
        //TODO:  define JfwSerializeException
        throw new JfwBaseException(e);    }
      return this;
    }
    @Override
    public <T> T deSerialize(byte[] bytes, Class<T> clazz) throws JfwBaseException {
        try {
            return gson.fromJson(new String(bytes,ConstData.UTF8), clazz);
        } catch (JsonSyntaxException e) {
            //TODO:  define JfwSerializeException
            throw new JfwBaseException(e);    
        }
    }
    @Override
    public <T> T deSerialize(byte[] bytes, Type type) throws JfwBaseException {
        try {
            return gson.fromJson(new String(bytes,ConstData.UTF8), type);
        } catch (JsonSyntaxException e) {
            //TODO:  define JfwSerializeException
            throw new JfwBaseException(e);    
        }
    }
    @Override
    public <T> T deSerialize(InputStream in, Class<T> clazz) throws JfwBaseException {
        try {
            return gson.fromJson(new InputStreamReader(in,ConstData.UTF8), clazz);
        } catch (JsonSyntaxException e) {
            //TODO:  define JfwSerializeException
            throw new JfwBaseException(e);    
        }
    }
    @Override
    public <T> T deSerialize(InputStream in, Type type) throws JfwBaseException {
        try {
            return gson.fromJson(new InputStreamReader(in,ConstData.UTF8), type);
        } catch (JsonSyntaxException e) {
            //TODO:  define JfwSerializeException
            throw new JfwBaseException(e);    
        }
    }
}

jfwUtil/src/main/java/org/jfw/util/serializer/SerializeService.java

package org.jfw.util.serializer;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Type;
import org.jfw.util.exception.JfwBaseException;
//TODO:  define JfwSerializeException
public interface SerializeService {
    /**
     * serialize a object
     * 
     * @param obj
     *            is not null
     * @return
     */
    byte[] serialize(Object obj);
    SerializeService serialize(Object obj, OutputStream out) throws JfwBaseException;
    <T> T deSerialize(byte[] bytes, Class<T> clazz) throws JfwBaseException;
    <T> T deSerialize(byte[] bytes, Type type) throws JfwBaseException;
    <T> T deSerialize(InputStream in, Class<T> clazz) throws JfwBaseException;
    <T> T deSerialize(InputStream in, Type type) throws JfwBaseException;
}