stringutil.java

JAVA解析MSNP15协议

package jm.framework.msn.util;

import java.lang.ref.SoftReference;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
import java.util.ArrayList;

/**
 * 系统常量
 * 梦界家园MSNP15
 * @author ISHome
 * @since 0.5.0.1
 * @version 0.1
 */
public final class StringUtil {
	
	public static final Charset CHATSET_UTF8 = Charset.forName("UTF-8");

    /**
     * Default encoding.
     */
    public static final String DEFAULT_ENCODING = "UTF-8";

    /**
     * Line separator.
     */
    public static final String LINE_SEPARATOR = "\r\n";

    /**
     * Fast ssl login. Use the default login url to login.
     */
    public static final boolean FAST_SSL_LOGIN = Integer.getInteger(
            "net.sf.jml.fastSslLogin", 0) == 1;

    /**
     * The MsnMessageChain length.
     */
    public static final int MESSAGE_CHAIN_LENGTH = Integer.getInteger(
            "net.sf.jml.messageChainLength", 20);
    
    private static Object getReference(ThreadLocal threadlocal)
    {
        SoftReference softreference = (SoftReference)threadlocal.get();
        if(softreference != null)
            return softreference.get();
        else
            return null;
    }

    private static void setReference(ThreadLocal threadlocal, Object obj)
    {
        threadlocal.set(new SoftReference(obj));
    }

    public String getCharsetName()
    {
        return CHATSET_UTF8.name();
    }

    private static CharsetEncoder getEncoder()
    {
        CharsetEncoder charsetencoder = (CharsetEncoder)getReference(encoderCache);
        if(charsetencoder == null)
        {
            charsetencoder = CHATSET_UTF8.newEncoder().onMalformedInput(CodingErrorAction.REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE);
            setReference(encoderCache, charsetencoder);
        }
        return charsetencoder;
    }

    private CharsetDecoder getDecoder()
    {
        CharsetDecoder charsetdecoder = (CharsetDecoder)getReference(decoderCache);
        if(charsetdecoder == null)
        {
            charsetdecoder = CHATSET_UTF8.newDecoder().onMalformedInput(CodingErrorAction.REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE);
            setReference(decoderCache, charsetdecoder);
        }
        return charsetdecoder;
    }

    public static ByteBuffer encode(String s)
    {
        return encode(CharBuffer.wrap(s));
    }

    public static ByteBuffer encode(CharBuffer charbuffer)
    {
        CharsetEncoder charsetencoder = getEncoder();
        int i = 0;
        if(charbuffer.remaining() > 0)
        {
            i = (int)((float)charbuffer.remaining() * charsetencoder.averageBytesPerChar());
            if(i == 0)
                i = (int)((float)charbuffer.remaining() * charsetencoder.maxBytesPerChar());
        }
        ByteBuffer bytebuffer = ByteBuffer.allocate(i);
        if(i == 0)
            return bytebuffer;
        charsetencoder.reset();
        do
        {
            CoderResult coderresult = charbuffer.hasRemaining() ? charsetencoder.encode(charbuffer, bytebuffer, true) : charsetencoder.flush(bytebuffer);
            if(coderresult.isUnderflow())
                break;
            if(coderresult.isOverflow())
            {
                i *= 2;
                bytebuffer.flip();
                bytebuffer = ByteBuffer.allocate(i).put(bytebuffer);
            }
        } while(true);
        bytebuffer.flip();
        return bytebuffer;
    }

    public ByteBuffer[] encode(CharBuffer charbuffer, int i)
    {
        CharsetEncoder charsetencoder = getEncoder();
        charsetencoder.reset();
        ArrayList arraylist = new ArrayList();
        do
        {
            ByteBuffer bytebuffer = ByteBuffer.allocate(i);
            CoderResult coderresult = charsetencoder.encode(charbuffer, bytebuffer, true);
            if(coderresult.isUnderflow())
            {
                charsetencoder.flush(bytebuffer);
                bytebuffer.flip();
                arraylist.add(bytebuffer);
                break;
            }
            if(!coderresult.isOverflow())
                continue;
            if(bytebuffer.position() == 0)
                break;
            bytebuffer.flip();
            arraylist.add(bytebuffer);
        } while(true);
        return (ByteBuffer[])(ByteBuffer[])arraylist.toArray(new ByteBuffer[0]);
    }

    public CharBuffer decode(byte abyte0[])
    {
        return decode(ByteBuffer.wrap(abyte0));
    }

    public CharBuffer decode(ByteBuffer bytebuffer)
    {
        CharsetDecoder charsetdecoder = getDecoder();
        int i = 0;
        if(bytebuffer.remaining() > 0)
        {
            i = (int)((float)bytebuffer.remaining() * charsetdecoder.averageCharsPerByte());
            if(i == 0)
                i = (int)((float)bytebuffer.remaining() * charsetdecoder.maxCharsPerByte());
        }
        CharBuffer charbuffer = CharBuffer.allocate(i);
        if(i == 0)
            return charbuffer;
        charsetdecoder.reset();
        do
        {
            CoderResult coderresult = bytebuffer.hasRemaining() ? charsetdecoder.decode(bytebuffer, charbuffer, true) : charsetdecoder.flush(charbuffer);
            if(coderresult.isUnderflow())
                break;
            if(coderresult.isOverflow())
            {
                i *= 2;
                charbuffer.flip();
                charbuffer = CharBuffer.allocate(i).put(charbuffer);
            }
        } while(true);
        charbuffer.flip();
        return charbuffer;
    }

    private static StringUtil getCharsetUtils(String s)
    {
    	StringUtil charsetutils = (StringUtil)getReference(charsetCache);
        if(charsetutils == null || !CHATSET_UTF8.name().equals(s))
        {
            charsetutils = new StringUtil();
            setReference(charsetCache, charsetutils);
        }
        return charsetutils;
    }

    public static ByteBuffer encode(String s, CharBuffer charbuffer)
    {
        return getCharsetUtils(s).encode(charbuffer);
    }

    public static ByteBuffer encode(String s, String s1)
    {
        return getCharsetUtils(s).encode(s1);
    }

    public static CharBuffer decode(String s, ByteBuffer bytebuffer)
    {
        return getCharsetUtils(s).decode(bytebuffer);
    }

//    private Charset charset;
    private static ThreadLocal encoderCache = new ThreadLocal();
    private static ThreadLocal decoderCache = new ThreadLocal();
    private static ThreadLocal charsetCache = new ThreadLocal();

}