util.java

java写的qq代码实现qq的部分功能

     */
    public static String getString(byte[] b) {
        return getString(b, QQ.QQ_CHARSET_DEFAULT);
    }
    
    /**
     * 根据某种编码方式将字节数组转换成字符串
     * @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 b 字节数组
     * @param offset 要转换的起始位置
     * @param len 要转换的长度
     * @return
     */
    public static String getString(byte[] b, int offset, int len) {
        return getString(b, offset, len, QQ.QQ_CHARSET_DEFAULT);
    }
    
    /**
     * 把字符串转换成int
     * @param s 字符串
     * @param faultValue 如果转换失败，返回这个值
     * @return 如果转换失败，返回faultValue，成功返回转换后的值
     */
    public static int getInt(String s, int faultValue) {
        try {
            return Integer.parseInt(s);
        } catch (NumberFormatException e) {
            return faultValue;
        }
    }
    
    /**
     * 把字符串转换成long
     * @param s 字符串
     * @param faultValue 如果转换失败，返回这个值
     * @return 如果转换失败，返回faultValue，成功返回转换后的值
     */
    public static long getLong(String s, int radix, long faultValue) {
        try {
            return Long.parseLong(s, radix);
        } catch (NumberFormatException e) {
            return faultValue;
        }
    }
    
    /**
     * 把字符串转换成int
     * @param s 字符串
     * @param radix
     * 		基数
     * @param faultValue 如果转换失败，返回这个值
     * @return 如果转换失败，返回faultValue，成功返回转换后的值
     */
    public static int getInt(String s, int radix, int faultValue) {
        try {
            return Integer.parseInt(s, radix);
        } catch (NumberFormatException e) {
            return faultValue;
        }
    }
    
    /**
     * 检查字符串是否是整数格式
     * 
     * @param s
     * 		字符串
     * @return
     * 		true表示可以解析成整数
     */
    public static boolean isInt(String s) {
        try {
            Integer.parseInt(s);
            return true;
        } catch(NumberFormatException e) {
            return false;
        }
    }
    
    /**
     * 把字符串转换成Integer
     * @param s 字符串
     * @param faultValue 如果转换失败，返回等于这个值的Integer对象
     * @return 如果转换失败，返回faultValue，成功返回转换后的值
     */
    public static Integer getInteger(String s, int faultValue) {
        try {
            return new Integer(s);
        } catch (NumberFormatException e) {
            return new Integer(faultValue);
        }
    }
    
    /**
     * 把字符串转换成Integer
     * @param s 字符串
     * @param faultValue 如果转换失败，返回这个Integer对象
     * @return 如果转换失败，返回faultValue，成功返回转换后的值
     */
    public static Integer getInteger(String s, Integer faultValue) {
        try {
            return new Integer(s);
        } catch (NumberFormatException e) {
            return faultValue;
        }
    }
    
    /**
     * 把字符串转换成char类型的无符号数
     * @param s 字符串
     * @param faultValue 如果转换失败，返回这个值
     * @return 如果转换失败，返回faultValue，成功返回转换后的值
     */
    public static char getChar(String s, int faultValue) {
        return (char)(getInt(s, faultValue) & 0xFFFF);
    }
    
    /**
     * 把字符串转换成byte
     * @param s 字符串
     * @param faultValue 如果转换失败，返回这个值
     * @return 如果转换失败，返回faultValue，成功返回转换后的值
     */
    public static byte getByte(String s, int faultValue) {
        return (byte)(getInt(s, faultValue) & 0xFF);
    }
    
    /**
     * @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();
    }
    
    /**
     * 从ip的字符串形式得到字节数组形式
     * @param ip 字符串形式的ip
     * @return 字节数组形式的ip
     */
    public static byte[] getIpByteArrayFromString(String ip) {
        byte[] ret = new byte[4];
        StringTokenizer st = new 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) {
            log.error(e.getMessage());
        }
        return ret;
    }
    
    /**
     * 判断IP是否相等
     * @param ip1 IP的字节数组形式
     * @param ip2 IP的字节数组形式
     * @return true如果两个IP相等
     */
    public static boolean isIpEquals(byte[] ip1, byte[] ip2) {
        return (ip1[0] == ip2[0] && ip1[1] == ip2[1] && ip1[2] == ip2[2] && ip1[3] == ip2[3]);
    }
    
    /**
     * @param cmd 命令类型
     * @return 命令的字符串形式，用于调试
     */
    public static String getCommandString(char cmd) {
        switch (cmd) {
            case QQ.QQ_CMD_REQUEST_LOGIN_TOKEN:
                return "QQ_CMD_REQUEST_LOGIN_TOKEN";
	        case QQ.QQ_CMD_LOGOUT:
	            return "QQ.QQ_CMD_LOGOUT";
	        case QQ.QQ_CMD_KEEP_ALIVE:
	            return "QQ.QQ_CMD_KEEP_ALIVE";
	        case QQ.QQ_CMD_MODIFY_INFO:
	            return "QQ.QQ_CMD_MODIFY_INFO";
	        case QQ.QQ_CMD_SEARCH_USER:
	            return "QQ.QQ_CMD_SEARCH_USER";
	        case QQ.QQ_CMD_GET_USER_INFO:
	            return "QQ.QQ_CMD_GET_USER_INFO";
	        case QQ.QQ_CMD_ADD_FRIEND:
	            return "QQ.QQ_CMD_ADD_FRIEND";
	        case QQ.QQ_CMD_DELETE_FRIEND:
	            return "QQ.QQ_CMD_DELETE_FRIEND";
	        case QQ.QQ_CMD_ADD_FRIEND_AUTH:
	            return "QQ.QQ_CMD_ADD_FRIEND_AUTH";
	        case QQ.QQ_CMD_CHANGE_STATUS:
	            return "QQ.QQ_CMD_CHANGE_STATUS";
	        case QQ.QQ_CMD_ACK_SYS_MSG:
	            return "QQ.QQ_CMD_ACK_SYS_MSG";
	        case QQ.QQ_CMD_SEND_IM:
	            return "QQ.QQ_CMD_SEND_IM";
	        case QQ.QQ_CMD_RECV_IM:
	            return "QQ.QQ_CMD_RECV_IM";
	        case QQ.QQ_CMD_REMOVE_SELF:
	            return "QQ.QQ_CMD_REMOVE_SELF";
	        case QQ.QQ_CMD_LOGIN:
	            return "QQ.QQ_CMD_LOGIN";
	        case QQ.QQ_CMD_GET_FRIEND_LIST:
	            return "QQ.QQ_CMD_GET_FRIEND_LIST";
	        case QQ.QQ_CMD_GET_FRIEND_ONLINE:
	            return "QQ.QQ_CMD_GET_FRIEND_ONLINE";
	        case QQ.QQ_CMD_CLUSTER_CMD:
	            return "QQ.QQ_CMD_CLUSTER_CMD";
	        case QQ.QQ_CMD_RECV_MSG_SYS:
	            return "QQ.QQ_CMD_RECV_MSG_SYS";
	        case QQ.QQ_CMD_RECV_MSG_FRIEND_CHANGE_STATUS:
	            return "QQ.QQ_CMD_RECV_MSG_FRIEND_CHANGE_STATUS";
	        case QQ.QQ_CMD_REQUEST_KEY:
	            return "QQ_CMD_REQUEST_KEY";
	        case QQ.QQ_CMD_GROUP_DATA_OP:
	        	return "QQ_CMD_GROUP_NAME_OP";
	        case QQ.QQ_CMD_UPLOAD_GROUP_FRIEND:
	        	return "QQ_CMD_UPLOAD_GROUP_FRIEND";
	        case QQ.QQ_CMD_DOWNLOAD_GROUP_FRIEND:
	        	return "QQ_CMD_DOWNLOAD_GROUP_FRIEND";
	        case QQ.QQ_CMD_FRIEND_DATA_OP:
	        	return "QQ_CMD_FRIEND_DATA_OP";
	        case QQ.QQ_CMD_SEND_SMS:
	            return "QQ_CMD_SEND_SMS";
	        case QQ.QQ_CMD_ADVANCED_SEARCH:
	            return "QQ_CMD_ADVANCED_SEARCH";
	        case QQ.QQ_CMD_CLUSTER_DATA_OP:
	            return "QQ_CMD_GET_TEMP_CLUSTER_ONLINE_MEMBER";
	        default:
	            return "UNKNOWN_TYPE " + (int)cmd;
        }
    }
    
    /**
     * 得到群操作的字符串形式，仅用于调试
     * @param cmd
     * @return
     */
    public static String getClusterCommandString(byte cmd) {
    	  switch (cmd) {
    	    case QQ.QQ_CLUSTER_CMD_CREATE_CLUSTER:
    	    	return "QQ_CLUSTER_CMD_CREATE_CLUSTER";
    	    case QQ.QQ_CLUSTER_CMD_MODIFY_MEMBER:
    	    	return "QQ_CLUSTER_CMD_MODIFY_MEMBER";
    	    case QQ.QQ_CLUSTER_CMD_MODIFY_CLUSTER_INFO:
    	    	return "QQ_CLUSTER_CMD_MODIFY_CLUSTER_INFO";
    	    case QQ.QQ_CLUSTER_CMD_GET_CLUSTER_INFO:   
    	    	return "QQ_CLUSTER_CMD_GET_CLUSTER_INFO";
    	    case QQ.QQ_CLUSTER_CMD_ACTIVATE_CLUSTER:    
    	    	return "QQ_CLUSTER_CMD_ACTIVATE_CLUSTER";
    	    case QQ.QQ_CLUSTER_CMD_SEARCH_CLUSTER:     
    	    	return "QQ_CLUSTER_CMD_SEARCH_CLUSTER";
    	    case QQ.QQ_CLUSTER_CMD_JOIN_CLUSTER:        
    	    	return "QQ_CLUSTER_CMD_JOIN_CLUSTER";
    	    case QQ.QQ_CLUSTER_CMD_JOIN_CLUSTER_AUTH:   
    	    	return "QQ_CLUSTER_CMD_JOIN_CLUSTER_AUTH";
    	    case QQ.QQ_CLUSTER_CMD_EXIT_CLUSTER:        
    	    	return "QQ_CLUSTER_CMD_EXIT_CLUSTER";
    	    case QQ.QQ_CLUSTER_CMD_SEND_IM:          
    	    	return "QQ_CLUSTER_CMD_SEND_IM";
    	    case QQ.QQ_CLUSTER_CMD_GET_ONLINE_MEMBER: 
    	    	return "QQ_CLUSTER_CMD_GET_ONLINE_MEMBER";
    	    case QQ.QQ_CLUSTER_CMD_GET_MEMBER_INFO:  
    	    	return "QQ_CLUSTER_CMD_GET_MEMBER_INFO";
    	    default:                             
    	    	return "Unknown QQ Cluster Command";
    	  }
    }
    
    /**
     * 返回文件命令的字符串形式，仅用作调试
     * @param command
     * @return
     */
    public static String getFileCommandString(char command) {
    	switch(command) {
    	    case QQ.QQ_FILE_CMD_HEART_BEAT:
    	        return "QQ_FILE_CMD_HEART_BEAT";
    	    case QQ.QQ_FILE_CMD_HEART_BEAT_ACK:
    	        return "QQ_FILE_CMD_HEART_BEAT_ACK";
    	    case QQ.QQ_FILE_CMD_TRANSFER_FINISHED:
    	        return "QQ_FILE_CMD_TRANSFER_FINISHED";
    	    case QQ.QQ_FILE_CMD_FILE_OP:
    	        return "QQ_FILE_CMD_FILE_OP";
    	    case QQ.QQ_FILE_CMD_FILE_OP_ACK:
    	        return "QQ_FILE_CMD_FILE_OP_ACK";
    		case QQ.QQ_FILE_CMD_SENDER_SAY_HELLO:
    			return "QQ_FILE_CMD_SENDER_SAY_HELLO";    	
    		case QQ.QQ_FILE_CMD_SENDER_SAY_HELLO_ACK:
    		    return "QQ_FILE_CMD_SENDER_SAY_HELLO_ACK";
    		case QQ.QQ_FILE_CMD_RECEIVER_SAY_HELLO:
    			return "QQ_FILE_CMD_RECEIVER_SAY_HELLO";    		
    		case QQ.QQ_FILE_CMD_RECEIVER_SAY_HELLO_ACK:
    			return "QQ_FILE_CMD_RECEIVER_SAY_HELLO_ACK";    		
    		case QQ.QQ_FILE_CMD_NOTIFY_IP_ACK:
    			return "QQ_FILE_CMD_NOTIFY_IP_ACK";    		
    		case QQ.QQ_FILE_CMD_PING:
    			return "QQ_FILE_CMD_PING";    		
    		case QQ.QQ_FILE_CMD_PONG:
    			return "QQ_FILE_CMD_PONG";    		
    		case QQ.QQ_FILE_CMD_YES_I_AM_BEHIND_FIREWALL:
    			return "QQ_FILE_CMD_YES_I_AM_BEHIND_FIREWALL";    			
    		default:
    			return "UNKNOWN TYPE " + (int)command;
    	}
    }
    
    /**
     * 得到状态的字符串表示
     * @param status 状态码
     * @return 字符串形式的状态码
     */
    public static String getStatusString(byte status) {
    	switch(status) {
    		case QQ.QQ_FRIEND_STATUS_ONLINE:
    			return IQQNode.VALUE_ONLINE;
    		case QQ.QQ_FRIEND_STATUS_OFFLINE:
    			return IQQNode.VALUE_OFFLINE;
    		case QQ.QQ_FRIEND_STATUS_AWAY:
    			return IQQNode.VALUE_AWAY;
    		case QQ.QQ_FRIEND_STATUS_HIDDEN:
    			return IQQNode.VALUE_HIDDEN;
    		default:
    			return "Unknown Status";
    	}
    }
    
    /**
     * 这个不是用于调试的，真正要用的方法
     * @param encoding 编码方式
     * @return 编码方式的字符串表示形式
     */
    public static String getEncodingString(char encoding) {
        switch(encoding) {
        	case QQ.QQ_IM_ENCODING_GB:
        	    return "GBK";
        	case QQ.QQ_IM_ENCODING_EN:
        	    return "ISO-8859-1";
        	case QQ.QQ_IM_ENCODING_BIG5:
        	    return "BIG5";
        	default:
        	    return "GBK";
        }
    }
    
    /**
     * 用于调试
     * @param type 收到的消息类型
     * @return 消息类型的字符串表示
     */
    public static String getIMTypeString(char type) {
        switch (type) {
	        case QQ.QQ_RECV_IM_FROM_FRIEND:
	            return "QQ_RECV_IM_TO_BUDDY";
	        case QQ.QQ_RECV_IM_FROM_STRANGER:
	            return "QQ_RECV_IM_TO_UNKNOWN";
	        case QQ.QQ_RECV_IM_CLUSTER_IM:
	            return "QQ_RECV_IM_CLUSTER_IM";
	        case QQ.QQ_RECV_IM_ADDED_TO_CLUSTER:
	            return "QQ_RECV_IM_ADDED_TO_CLUSTER";
	        case QQ.QQ_RECV_IM_DELETED_FROM_CLUSTER:
	            return "QQ_RECV_IM_DEL_FROM_CLUSTER";
	        case QQ.QQ_RECV_IM_REQUEST_JOIN_CLUSTER:
	            return "QQ_RECV_IM_REQUEST_JOIN_CLUSTER";
	        case QQ.QQ_RECV_IM_CREATE_CLUSTER:
	            return "QQ_RECV_IM_CREATE_CLUSTER";
	        case QQ.QQ_RECV_IM_SYS_MESSAGE:
	            return "QQ_RECV_IM_SYS_MESSAGE";
	        case QQ.QQ_RECV_IM_APPROVE_JOIN_CLUSTER:
	            return "QQ_RECV_IM_APPROVE_JOIN_CLUSTER";
	        case QQ.QQ_RECV_IM_REJECT_JOIN_CLUSTER:
	            return "QQ_RECV_IM_REJECT_JOIN_CLUSTER";
	        default:
	            return "QQ_RECV_IM_UNKNOWN";
        }
    }
    
    /**
     * 返回普通消息中的类型，仅用作调试
     * @param type
     * @return
     */
    public static String getNormalIMTypeString(char type) {
        switch(type) {
            case QQ.QQ_IM_NORMAL_TEXT:
                return "QQ_IM_NORMAL_TEXT";
            case QQ.QQ_IM_TCP_REQUEST:
                return "QQ_IM_TCP_REQUEST";
            case QQ.QQ_IM_ACCEPT_TCP_REQUEST:
                return "QQ_IM_ACCEPT_TCP_REQUEST";
            case QQ.QQ_IM_REJECT_TCP_REQUEST:
                return "QQ_IM_REJECT_TCP_REQUEST";
            case QQ.QQ_IM_UDP_REQUEST:
                return "QQ_IM_UDP_REQUEST";
            case QQ.QQ_IM_ACCEPT_UDP_REQUEST:
                return "QQ_IM_ACCEPT_UDP_REQUEST";
            case QQ.QQ_IM_REJECT_UDP_REQUEST:
                return "QQ_IM_REJECT_UDP_REQUEST";
            case QQ.QQ_IM_NOTIFY_IP:
                return "QQ_IM_NOTIFY_IP";
            case QQ.QQ_IM_ARE_YOU_BEHIND_FIREWALL:
                return "QQ_IM_ARE_YOU_BEHIND_FIREWALL";
            case QQ.QQ_IM_ARE_YOU_BEHIND_PROXY:
                return "QQ_IM_ARE_YOU_BEHIND_PROXY";
            case QQ.QQ_IM_YES_I_AM_BEHIND_PROXY:
                return "QQ_IM_YES_I_AM_BEHIND_PROXY";
            case QQ.QQ_IM_REQUEST_CANCELED:
                return "QQ_IM_REQUEST_CANCELED";
            default:
                return String.valueOf((int)type);
        }
    }
    
    /**
     * 返回字符串形式的回复类型，仅用于调试
     * @param type 回复类型
     * @return 字符串形式的回复类型
     */
    public static String getIMReplyType(byte type) {
        switch(type) {
        	case QQ.QQ_IM_NORMAL_REPLY:
        	    return "QQ_IM_TEXT";
        	case QQ.QQ_IM_AUTO_REPLY:
        	    return "QQ_IM_AUTO_REPLY";