java 常用工具类的使用<四>

一、连接数据库的综合类

package com.itjh.javaUtil;  
  
import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.PreparedStatement;  
import java.sql.ResultSet;  
import java.sql.ResultSetMetaData;  
import java.sql.SQLException;  
import java.util.ArrayList;  
import java.util.Collections;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
  
import org.apache.commons.dbcp.ConnectionFactory;  
import org.apache.commons.dbcp.DriverManagerConnectionFactory;  
import org.apache.commons.dbcp.PoolableConnectionFactory;  
import org.apache.commons.dbcp.PoolingDriver;  
import org.apache.commons.dbutils.DbUtils;  
import org.apache.commons.dbutils.QueryRunner;  
import org.apache.commons.dbutils.handlers.MapListHandler;  
import org.apache.commons.pool.ObjectPool;  
import org.apache.commons.pool.impl.GenericObjectPool;  
  
/** 
 * 连接数据库的综合类。</br> 
 * 依赖jar包：commons.dbcp-1.4，commons.dbutils-1.3，commons.pool-1.5.4包。 
 *  
 * @author 宋立君 
 * @date 2014年07月03日 
 */  
  
public class DBUtil {  
  
    private String dri = null;  
    private String url = null;  
    private String username = null;  
    private String password = null;  
    private String poolName = null; // 连接池名称  
    private ObjectPool connectionPool = null; // 连接池  
    // 对应的定时查询类  
    private QueryThread queryThread = null;  
  
    /** 
     * 功能：构造函数 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param dri 
     *            驱动全类名，例如：com.mysql.jdbc.Driver。 
     * @param url 
     *            数据库url连接，例如： 
     *            "jdbc:mysql://127.0.0.1:3306/test?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8" 
     * @param userName 
     *            数据库用户名，例如：root 
     * @param password 
     *            数据库密码，例如：abc 
     * @param poolName 
     *            创建的数据库连接池的名称，例如mypool，注意一个web容器此名称不能重复。 
     */  
    public DBUtil(String dri, String url, String userName, String password,  
            String poolName) {  
        this.dri = dri;  
        this.url = url;  
        this.username = userName;  
        this.password = password;  
        this.poolName = poolName;  
    }  
  
    /** 
     * 执行sql。 
     *  
     * @param conn 
     *            连接 
     * @param pstm 
     *            PreparedStatement 
     * @return int 执行sql对应的影响行。 
     * @throws SQLException 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public int execute(Connection conn, PreparedStatement pstm)  
            throws SQLException {  
        try {  
            return pstm.executeUpdate();  
        } finally {  
            Close(conn);  
        }  
    }  
  
    /** 
     * 查询sql。 
     *  
     * @param conn 
     *            连接 
     * @param pstm 
     *            PreparedStatement 
     * @return List<Map<String,Object>> 查询的结果集 
     * @throws SQLException 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public List<Map<String, Object>> query(Connection conn,  
            PreparedStatement pstm) throws SQLException {  
        try {  
            return resultSetToList(pstm.executeQuery());  
        } finally {  
            Close(conn);  
        }  
    }  
  
    /** 
     * 功能：ResultSet 转为List<Map<String,Object>> 
     *  
     *  
     * @param rs 
     *            ResultSet 原始数据集 
     * @return List<Map<String,Object>> 
     * @throws java.sql.SQLException 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    private List<Map<String, Object>> resultSetToList(ResultSet rs)  
            throws java.sql.SQLException {  
        if (rs == null)  
            return Collections.EMPTY_LIST;  
  
        ResultSetMetaData md = rs.getMetaData(); // 得到结果集(rs)的结构信息，比如字段数、字段名等  
        int columnCount = md.getColumnCount(); // 返回此 ResultSet 对象中的列数  
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();  
        Map<String, Object> rowData = new HashMap<String, Object>();  
        while (rs.next()) {  
            rowData = new HashMap<String, Object>(columnCount);  
            for (int i = 1; i <= columnCount; i++) {  
                rowData.put(md.getColumnName(i), rs.getObject(i));  
            }  
            list.add(rowData);  
        }  
        return list;  
    }  
  
    /** 
     * 查询sql语句。 
     *  
     * @param sql 
     *            被执行的sql语句 
     * @return List<Map<String,Object>> 
     * @throws SQLException 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public List<Map<String, Object>> query(String sql) throws SQLException {  
        List<Map<String, Object>> results = null;  
        Connection conn = null;  
        try {  
            conn = getConnection();  
            QueryRunner qr = new QueryRunner();  
            results = qr.query(conn, sql, new MapListHandler());  
        } finally {  
            Close(conn);  
        }  
        return results;  
    }  
  
    /** 
     * 根据参数查询sql语句 
     *  
     * @param sql 
     *            sql语句 
     * @param param 
     *            参数 
     * @return List<Map<String,Object>> 
     * @throws SQLException 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public List<Map<String, Object>> query(String sql, Object param)  
            throws SQLException {  
        List<Map<String, Object>> results = null;  
        Connection conn = null;  
        try {  
            conn = getConnection();  
            QueryRunner qr = new QueryRunner();  
            results = (List<Map<String, Object>>) qr.query(conn, sql, param,  
                    new MapListHandler());  
        } catch (SQLException e) {  
            e.printStackTrace();  
        } finally {  
            Close(conn);  
        }  
        return results;  
    }  
  
    /** 
     * 执行sql语句 
     *  
     * @param sql 
     *            被执行的sql语句 
     * @return 受影响的行 
     * @throws Exception 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public int execute(String sql) throws Exception {  
        Connection conn = getConnection();  
        int rows = 0;  
        try {  
            QueryRunner qr = new QueryRunner();  
            rows = qr.update(conn, sql);  
        } finally {  
            Close(conn);  
        }  
        return rows;  
    }  
  
    /** 
     * 执行含参数的sql语句 
     *  
     * @param sql 
     *            被执行的sql语句 
     * @param params 
     *            参数 
     * @return 返回受影响的行 
     * @throws Exception 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public int execute(String sql, Object[] params) throws Exception {  
        Connection conn = getConnection();  
        int rows = 0;  
        try {  
            QueryRunner qr = new QueryRunner();  
            rows = qr.update(conn, sql, params);  
        } finally {  
            Close(conn);  
        }  
        return rows;  
    }  
  
    /** 
     * 关闭连接 
     *  
     * @param conn 
     * @throws SQLException 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public void Close(Connection conn) throws SQLException {  
        if (conn != null) {  
            conn.close();  
        }  
        DbUtils.closeQuietly(conn);  
    }  
  
    /** 
     * 启动连接池 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    private void StartPool() {  
        try {  
            Class.forName(dri);  
        } catch (ClassNotFoundException e1) {  
            e1.printStackTrace();  
        }  
        if (connectionPool != null) {  
            ShutdownPool();  
        }  
        try {  
            connectionPool = new GenericObjectPool(null);  
            ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(  
                    url, username, password);  
            PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(  
                    connectionFactory, connectionPool, null, "SELECT 1", false,  
                    true);  
            Class.forName("org.apache.commons.dbcp.PoolingDriver");  
            PoolingDriver driver = (PoolingDriver) DriverManager  
                    .getDriver("jdbc:apache:commons:dbcp:");  
            driver.registerPool(poolName, poolableConnectionFactory.getPool());  
  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        // 开启查询程序  
        queryThread = new QueryThread(this);  
        queryThread.start();  
    }  
  
    /** 
     * 关闭连接池 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    private void ShutdownPool() {  
        try {  
            PoolingDriver driver = (PoolingDriver) DriverManager  
                    .getDriver("jdbc:apache:commons:dbcp:");  
            driver.closePool(poolName);  
            // 关闭定时查询  
            queryThread.setStartQuery(false);  
        } catch (SQLException e) {  
            e.printStackTrace();  
        }  
    }  
  
    /** 
     * 得到一个连接 
     *  
     * @return 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public synchronized Connection getConnection() {  
        Connection conn = null;  
        try {  
            if (connectionPool == null)  
                StartPool();  
            conn = DriverManager.getConnection("jdbc:apache:commons:dbcp:"  
                    + poolName);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return conn;  
    }  
}  
  
/** 
 * 当连接池启动后会自动定时查询数据库，防止数据库连接超时。 
 *  
 * @author 宋立君 
 * @date 2014年07月03日 
 */  
class QueryThread extends Thread {  
  
    private DBUtil dbUtil = null;  
    // 是否开启查询  
    private boolean startQuery = true;  
  
    /** 
     * 功能：对应的数据库连接。 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param dbUtil 
     *            数据库连接 
     */  
    public QueryThread(DBUtil dbUtil) {  
        this.dbUtil = dbUtil;  
    }  
  
    public void run() {  
        while (true) {  
            try {  
                if (startQuery) {  
                    this.dbUtil.query("select 1");  
                }  
                // System.out.println(startQuery+"   123");  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                try {  
                    Thread.sleep(120000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  
  
    public void setStartQuery(boolean startQuery) {  
        // System.out.println("startQuery shut:"+startQuery);  
        this.startQuery = startQuery;  
    }  
}  

二、DES加密和解密

package com.itjh.javaUtil;  
  
import java.io.UnsupportedEncodingException;  
import java.security.InvalidKeyException;  
import java.security.NoSuchAlgorithmException;  
import java.security.SecureRandom;  
import java.security.spec.InvalidKeySpecException;  
  
import javax.crypto.BadPaddingException;  
import javax.crypto.Cipher;  
import javax.crypto.IllegalBlockSizeException;  
import javax.crypto.KeyGenerator;  
import javax.crypto.NoSuchPaddingException;  
import javax.crypto.SecretKey;  
import javax.crypto.SecretKeyFactory;  
import javax.crypto.spec.DESKeySpec;  
  
/** 
 * DES加密和解密。 
 *  
 * @author 宋立君 
 * @date 2014年07月03日 
 */  
public class DESUtil {  
  
    /** 安全密钥 */  
    private String keyData = "ABCDEFGHIJKLMNOPQRSTWXYZabcdefghijklmnopqrstwxyz0123456789-_.";  
  
    /** 
     * 功能：构造 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public DESUtil() {  
    }  
  
    /** 
     * 功能：构造 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param keyData 
     *            key 
     */  
    public DESUtil(String key) {  
        this.keyData = key;  
    }  
  
    /** 
     * 功能：加密 (UTF-8) 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param source 
     *            源字符串 
     * @param charSet 
     *            编码 
     * @return String 
     * @throws UnsupportedEncodingException 
     *             编码异常 
     */  
    public String encrypt(String source) throws UnsupportedEncodingException {  
        return encrypt(source, "UTF-8");  
    }  
  
    /** 
     *  
     * 功能：解密 (UTF-8) 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param encryptedData 
     *            被加密后的字符串 
     * @return String 
     * @throws UnsupportedEncodingException 
     *             编码异常 
     */  
    public String decrypt(String encryptedData)  
            throws UnsupportedEncodingException {  
        return decrypt(encryptedData, "UTF-8");  
    }  
  
    /** 
     * 功能：加密 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param source 
     *            源字符串 
     * @param charSet 
     *            编码 
     * @return String 
     * @throws UnsupportedEncodingException 
     *             编码异常 
     */  
    public String encrypt(String source, String charSet)  
            throws UnsupportedEncodingException {  
        String encrypt = null;  
        byte[] ret = encrypt(source.getBytes(charSet));  
        encrypt = new String(Base64.encode(ret));  
        return encrypt;  
    }  
  
    /** 
     *  
     * 功能：解密 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param encryptedData 
     *            被加密后的字符串 
     * @param charSet 
     *            编码 
     * @return String 
     * @throws UnsupportedEncodingException 
     *             编码异常 
     */  
    public String decrypt(String encryptedData, String charSet)  
            throws UnsupportedEncodingException {  
        String descryptedData = null;  
        byte[] ret = descrypt(Base64.decode(encryptedData.toCharArray()));  
        descryptedData = new String(ret, charSet);  
        return descryptedData;  
    }  
  
    /** 
     * 加密数据 用生成的密钥加密原始数据 
     *  
     * @param primaryData 
     *            原始数据 
     * @return byte[] 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    private byte[] encrypt(byte[] primaryData) {  
  
        /** 取得安全密钥 */  
        byte rawKeyData[] = getKey();  
  
        /** DES算法要求有一个可信任的随机数源 */  
        SecureRandom sr = new SecureRandom();  
  
        /** 使用原始密钥数据创建DESKeySpec对象 */  
        DESKeySpec dks = null;  
        try {  
            dks = new DESKeySpec(keyData.getBytes());  
        } catch (InvalidKeyException e) {  
            e.printStackTrace();  
        }  
  
        /** 创建一个密钥工厂 */  
        SecretKeyFactory keyFactory = null;  
        try {  
            keyFactory = SecretKeyFactory.getInstance("DES");  
        } catch (NoSuchAlgorithmException e) {  
            e.printStackTrace();  
        }  
  
        /** 用密钥工厂把DESKeySpec转换成一个SecretKey对象 */  
        SecretKey key = null;  
        try {  
            key = keyFactory.generateSecret(dks);  
        } catch (InvalidKeySpecException e) {  
            e.printStackTrace();  
        }  
  
        /** Cipher对象实际完成加密操作 */  
        Cipher cipher = null;  
        try {  
            cipher = Cipher.getInstance("DES");  
        } catch (NoSuchAlgorithmException e) {  
            e.printStackTrace();  
        } catch (NoSuchPaddingException e) {  
            e.printStackTrace();  
        }  
  
        /** 用密钥初始化Cipher对象 */  
        try {  
            cipher.init(Cipher.ENCRYPT_MODE, key, sr);  
        } catch (InvalidKeyException e) {  
            e.printStackTrace();  
        }  
  
        /** 正式执行加密操作 */  
        byte encryptedData[] = null;  
        try {  
            encryptedData = cipher.doFinal(primaryData);  
        } catch (IllegalStateException e) {  
            e.printStackTrace();  
        } catch (IllegalBlockSizeException e) {  
            e.printStackTrace();  
        } catch (BadPaddingException e) {  
            e.printStackTrace();  
        }  
  
        /** 返回加密数据 */  
        return encryptedData;  
    }  
  
    /** 
     * 用密钥解密数据 
     *  
     * @param encryptedData 
     *            加密后的数据 
     * @return byte[] 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    private byte[] descrypt(byte[] encryptedData) {  
  
        /** DES算法要求有一个可信任的随机数源 */  
        SecureRandom sr = new SecureRandom();  
  
        /** 取得安全密钥 */  
        byte rawKeyData[] = getKey();  
  
        /** 使用原始密钥数据创建DESKeySpec对象 */  
        DESKeySpec dks = null;  
        try {  
            dks = new DESKeySpec(keyData.getBytes());  
        } catch (InvalidKeyException e) {  
            e.printStackTrace();  
        }  
  
        /** 创建一个密钥工厂 */  
        SecretKeyFactory keyFactory = null;  
        try {  
            keyFactory = SecretKeyFactory.getInstance("DES");  
        } catch (NoSuchAlgorithmException e) {  
            e.printStackTrace();  
        }  
  
        /** 用密钥工厂把DESKeySpec转换成一个SecretKey对象 */  
        SecretKey key = null;  
        try {  
            key = keyFactory.generateSecret(dks);  
        } catch (InvalidKeySpecException e) {  
            e.printStackTrace();  
        }  
  
        /** Cipher对象实际完成加密操作 */  
        Cipher cipher = null;  
        try {  
            cipher = Cipher.getInstance("DES");  
        } catch (NoSuchAlgorithmException e) {  
            e.printStackTrace();  
        } catch (NoSuchPaddingException e) {  
            e.printStackTrace();  
        }  
  
        /** 用密钥初始化Cipher对象 */  
        try {  
            cipher.init(Cipher.DECRYPT_MODE, key, sr);  
        } catch (InvalidKeyException e) {  
            e.printStackTrace();  
        }  
  
        /** 正式执行解密操作 */  
        byte decryptedData[] = null;  
        try {  
            decryptedData = cipher.doFinal(encryptedData);  
        } catch (IllegalStateException e) {  
            e.printStackTrace();  
        } catch (IllegalBlockSizeException e) {  
            e.printStackTrace();  
        } catch (BadPaddingException e) {  
            e.printStackTrace();  
        }  
  
        return decryptedData;  
    }  
  
    /** 
     * 取得安全密钥 此方法作废,因为每次key生成都不一样导致解密加密用的密钥都不一样， 从而导致Given final block not 
     * properly padded错误. 
     *  
     * @return byte数组 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    private byte[] getKey() {  
  
        /** DES算法要求有一个可信任的随机数源 */  
        SecureRandom sr = new SecureRandom();  
  
        /** 为我们选择的DES算法生成一个密钥生成器对象 */  
        KeyGenerator kg = null;  
        try {  
            kg = KeyGenerator.getInstance("DES");  
        } catch (NoSuchAlgorithmException e) {  
            e.printStackTrace();  
        }  
        kg.init(sr);  
  
        /** 生成密钥工具类 */  
        SecretKey key = kg.generateKey();  
  
        /** 生成密钥byte数组 */  
        byte rawKeyData[] = key.getEncoded();  
  
        return rawKeyData;  
    }  
  
}  

Base64.java

package com.itjh.javaUtil;  
  
import java.io.*;  
  
/** 
 * Base64 编码和解码。 
 *  
 * @author 宋立君 
 * @date 2014年07月03日 
 */  
public class Base64 {  
  
    public Base64() {  
    }  
  
    /** 
     * 功能：编码字符串 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param data 
     *            源字符串 
     * @return String 
     */  
    public static String encode(String data) {  
        return new String(encode(data.getBytes()));  
    }  
  
    /** 
     * 功能：解码字符串 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param data 
     *            源字符串 
     * @return String 
     */  
    public static String decode(String data) {  
        return new String(decode(data.toCharArray()));  
    }  
  
    /** 
     * 功能：编码byte[] 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param data 
     *            源 
     * @return char[] 
     */  
    public static char[] encode(byte[] data) {  
        char[] out = new char[((data.length + 2) / 3) * 4];  
        for (int i = 0, index = 0; i < data.length; i += 3, index += 4) {  
            boolean quad = false;  
            boolean trip = false;  
  
            int val = (0xFF & (int) data[i]);  
            val <<= 8;  
            if ((i + 1) < data.length) {  
                val |= (0xFF & (int) data[i + 1]);  
                trip = true;  
            }  
            val <<= 8;  
            if ((i + 2) < data.length) {  
                val |= (0xFF & (int) data[i + 2]);  
                quad = true;  
            }  
            out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)];  
            val >>= 6;  
            out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)];  
            val >>= 6;  
            out[index + 1] = alphabet[val & 0x3F];  
            val >>= 6;  
            out[index + 0] = alphabet[val & 0x3F];  
        }  
        return out;  
    }  
  
    /** 
     * 功能：解码 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param data 
     *            编码后的字符数组 
     * @return byte[] 
     */  
    public static byte[] decode(char[] data) {  
  
        int tempLen = data.length;  
        for (int ix = 0; ix < data.length; ix++) {  
            if ((data[ix] > 255) || codes[data[ix]] < 0) {  
                --tempLen; // ignore non-valid chars and padding  
            }  
        }  
        // calculate required length:  
        // -- 3 bytes for every 4 valid base64 chars  
        // -- plus 2 bytes if there are 3 extra base64 chars,  
        // or plus 1 byte if there are 2 extra.  
  
        int len = (tempLen / 4) * 3;  
        if ((tempLen % 4) == 3) {  
            len += 2;  
        }  
        if ((tempLen % 4) == 2) {  
            len += 1;  
  
        }  
        byte[] out = new byte[len];  
  
        int shift = 0; // # of excess bits stored in accum  
        int accum = 0; // excess bits  
        int index = 0;  
  
        // we now go through the entire array (NOT using the 'tempLen' value)  
        for (int ix = 0; ix < data.length; ix++) {  
            int value = (data[ix] > 255) ? -1 : codes[data[ix]];  
  
            if (value >= 0) { // skip over non-code  
                accum <<= 6; // bits shift up by 6 each time thru  
                shift += 6; // loop, with new bits being put in  
                accum |= value; // at the bottom.  
                if (shift >= 8) { // whenever there are 8 or more shifted in,  
                    shift -= 8; // write them out (from the top, leaving any  
                    out[index++] = // excess at the bottom for next iteration.  
                    (byte) ((accum >> shift) & 0xff);  
                }  
            }  
        }  
  
        // if there is STILL something wrong we just have to throw up now!  
        if (index != out.length) {  
            throw new Error("Miscalculated data length (wrote " + index  
                    + " instead of " + out.length + ")");  
        }  
  
        return out;  
    }  
  
    /** 
     * 功能：编码文件 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param file 
     *            源文件 
     */  
    public static void encode(File file) throws IOException {  
        if (!file.exists()) {  
            System.exit(0);  
        }  
  
        else {  
            byte[] decoded = readBytes(file);  
            char[] encoded = encode(decoded);  
            writeChars(file, encoded);  
        }  
        file = null;  
    }  
  
    /** 
     * 功能：解码文件。 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param file 
     *            源文件 
     * @throws IOException 
     */  
    public static void decode(File file) throws IOException {  
        if (!file.exists()) {  
            System.exit(0);  
        } else {  
            char[] encoded = readChars(file);  
            byte[] decoded = decode(encoded);  
            writeBytes(file, decoded);  
        }  
        file = null;  
    }  
  
    //  
    // code characters for values 0..63  
    //  
    private static char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="  
            .toCharArray();  
  
    //  
    // lookup table for converting base64 characters to value in range 0..63  
    //  
    private static byte[] codes = new byte[256];  
    static {  
        for (int i = 0; i < 256; i++) {  
            codes[i] = -1;  
            // LoggerUtil.debug(i + "&" + codes[i] + " ");  
        }  
        for (int i = 'A'; i <= 'Z'; i++) {  
            codes[i] = (byte) (i - 'A');  
            // LoggerUtil.debug(i + "&" + codes[i] + " ");  
        }  
  
        for (int i = 'a'; i <= 'z'; i++) {  
            codes[i] = (byte) (26 + i - 'a');  
            // LoggerUtil.debug(i + "&" + codes[i] + " ");  
        }  
        for (int i = '0'; i <= '9'; i++) {  
            codes[i] = (byte) (52 + i - '0');  
            // LoggerUtil.debug(i + "&" + codes[i] + " ");  
        }  
        codes['+'] = 62;  
        codes['/'] = 63;  
    }  
  
    private static byte[] readBytes(File file) throws IOException {  
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  
        byte[] b = null;  
        InputStream fis = null;  
        InputStream is = null;  
        try {  
            fis = new FileInputStream(file);  
            is = new BufferedInputStream(fis);  
            int count = 0;  
            byte[] buf = new byte[16384];  
            while ((count = is.read(buf)) != -1) {  
                if (count > 0) {  
                    baos.write(buf, 0, count);  
                }  
            }  
            b = baos.toByteArray();  
  
        } finally {  
            try {  
                if (fis != null)  
                    fis.close();  
                if (is != null)  
                    is.close();  
                if (baos != null)  
                    baos.close();  
            } catch (Exception e) {  
                System.out.println(e);  
            }  
        }  
  
        return b;  
    }  
  
    private static char[] readChars(File file) throws IOException {  
        CharArrayWriter caw = new CharArrayWriter();  
        Reader fr = null;  
        Reader in = null;  
        try {  
            fr = new FileReader(file);  
            in = new BufferedReader(fr);  
            int count = 0;  
            char[] buf = new char[16384];  
            while ((count = in.read(buf)) != -1) {  
                if (count > 0) {  
                    caw.write(buf, 0, count);  
                }  
            }  
  
        } finally {  
            try {  
                if (caw != null)  
                    caw.close();  
                if (in != null)  
                    in.close();  
                if (fr != null)  
                    fr.close();  
            } catch (Exception e) {  
                System.out.println(e);  
            }  
        }  
  
        return caw.toCharArray();  
    }  
  
    private static void writeBytes(File file, byte[] data) throws IOException {  
        OutputStream fos = null;  
        OutputStream os = null;  
        try {  
            fos = new FileOutputStream(file);  
            os = new BufferedOutputStream(fos);  
            os.write(data);  
  
        } finally {  
            try {  
                if (os != null)  
                    os.close();  
                if (fos != null)  
                    fos.close();  
            } catch (Exception e) {  
                System.out.println(e);  
            }  
        }  
    }  
  
    private static void writeChars(File file, char[] data) throws IOException {  
        Writer fos = null;  
        Writer os = null;  
        try {  
            fos = new FileWriter(file);  
            os = new BufferedWriter(fos);  
            os.write(data);  
  
        } finally {  
            try {  
                if (os != null)  
                    os.close();  
                if (fos != null)  
                    fos.close();  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
    // /////////////////////////////////////////////////  
    // end of test code.  
    // /////////////////////////////////////////////////  
  
}  

三、ExcelUtil工具类

package com.itjh.javaUtil;  
  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.OutputStream;  
import java.text.DecimalFormat;  
import java.util.LinkedList;  
import java.util.List;  
  
import javax.servlet.http.HttpServletResponse;  
  
import org.apache.poi.hssf.usermodel.HSSFCell;  
import org.apache.poi.hssf.usermodel.HSSFRichTextString;  
import org.apache.poi.hssf.usermodel.HSSFRow;  
import org.apache.poi.hssf.usermodel.HSSFSheet;  
import org.apache.poi.hssf.usermodel.HSSFWorkbook;  
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;  
import org.apache.poi.ss.usermodel.Cell;  
import org.apache.poi.ss.usermodel.DateUtil;  
import org.apache.poi.ss.usermodel.Row;  
import org.apache.poi.ss.usermodel.Sheet;  
import org.apache.poi.ss.usermodel.Workbook;  
import org.apache.poi.ss.usermodel.WorkbookFactory;  
  
/** 
 * 封装对excel的操作，包括本地读写excel和流中输出excel,支持office 2007。<br/> 
 * 依赖于poi-3.9-20121203.jar,poi-ooxml-3.9-20121203.jar,poi-ooxml-schemas-3.9- 
 * 20121203.jar,dom4j-1.6.1.jar<br/> 
 * 有参构造函数参数为excel的全路径<br/> 
 *  
 * @author 宋立君 
 * @date 2014年07月03日 
 */  
public class ExcelUtil {  
  
    // excel文件路径  
    private String path = "";  
  
    // 写入excel时，是否自动扩展列宽度来符合内容。  
    private boolean autoColumnWidth = false;  
  
    /** 
     * 无参构造函数 默认 
     */  
    public ExcelUtil() {  
    }  
  
    /** 
     * 有参构造函数 
     *  
     * @param path 
     *            excel路径 
     */  
    public ExcelUtil(String path) {  
        this.path = path;  
    }  
  
    /** 
     * 读取某个工作簿上的所有单元格的值。 
     *  
     * @param sheetOrder 
     *            工作簿序号，从0开始。 
     * @return List<Object[]> 所有单元格的值。 
     * @throws IOException 
     *             加载excel文件IO异常。 
     * @throws FileNotFoundException 
     *             excel文件没有找到异常。 
     * @throws InvalidFormatException 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public List<Object[]> read(int sheetOrder) throws FileNotFoundException,  
            IOException, InvalidFormatException {  
        FileInputStream fis = new FileInputStream(path);  
        Workbook workbook = WorkbookFactory.create(fis);  
        if (fis != null) {  
            fis.close();  
        }  
        Sheet sheet = workbook.getSheetAt(sheetOrder);  
        // 用来记录excel值  
        List<Object[]> valueList = new LinkedList<Object[]>();  
        // 循环遍历每一行、每一列。  
        for (Row row : sheet) {  
            // 每一行  
            Object[] rowObject = null;  
            for (Cell cell : row) {  
                // cell.getCellType是获得cell里面保存的值的type  
                switch (cell.getCellType()) {  
                case Cell.CELL_TYPE_BOOLEAN:  
                    // 得到Boolean对象的方法  
                    rowObject = CollectionUtil.addObjectToArray(rowObject,  
                            cell.getBooleanCellValue());  
                    break;  
                case Cell.CELL_TYPE_NUMERIC:  
                    // 先看是否是日期格式  
                    if (DateUtil.isCellDateFormatted(cell)) {  
                        // 读取日期格式  
                        rowObject = CollectionUtil.addObjectToArray(rowObject,  
                                cell.getDateCellValue());  
                    } else {  
                        DecimalFormat df = new DecimalFormat();  
                        // 单元格的值,替换掉,  
                        String value = df.format(cell.getNumericCellValue())  
                                .replace(",", "");  
                        // 读取数字  
                        rowObject = CollectionUtil.addObjectToArray(rowObject,  
                                value);  
                    }  
                    break;  
                case Cell.CELL_TYPE_FORMULA:  
                    // 读取公式  
                    rowObject = CollectionUtil.addObjectToArray(rowObject,  
                            cell.getCellFormula());  
                    break;  
                case Cell.CELL_TYPE_STRING:  
                    // 读取String  
                    rowObject = CollectionUtil.addObjectToArray(rowObject, cell  
                            .getRichStringCellValue().toString());  
                    break;  
                }  
            }  
            // 将这行添加到list。  
            valueList.add(rowObject);  
        }  
        return valueList;  
    }  
  
    /** 
     * 读取某个工作簿上的某个单元格的值。 
     *  
     * @param sheetOrder 
     *            工作簿序号,从0开始。 
     * @param colum 
     *            列数 从1开始 
     * @param row 
     *            行数 从1开始 
     * @return 单元格的值。 
     * @throws Exception 
     *             加载excel异常。 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public String read(int sheetOrder, int colum, int row) throws Exception {  
        FileInputStream fis = new FileInputStream(path);  
        Workbook workbook = WorkbookFactory.create(fis);  
        if (fis != null) {  
            fis.close();  
        }  
        Sheet sheet = workbook.getSheetAt(sheetOrder);  
        Row rows = sheet.getRow(row - 1);  
        Cell cell = rows.getCell(colum - 1);  
        String content = cell.getStringCellValue();  
        return content;  
    }  
  
    /** 
     * 在指定的工作簿、行、列书写值。 
     *  
     * @param sheetOrder 
     *            工作簿序号，基于0. 
     * @param colum 
     *            列 基于1 
     * @param row 
     *            行 基于1 
     * @param content 
     *            将要被书写的内容。 
     * @throws Exception 
     *             书写后保存异常。 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public void write(int sheetOrder, int colum, int row, String content)  
            throws Exception {  
        FileInputStream fis = new FileInputStream(path);  
        Workbook workbook = WorkbookFactory.create(fis);  
        if (fis != null) {  
            fis.close();  
        }  
        Sheet sheet = workbook.getSheetAt(sheetOrder);  
        Row rows = sheet.createRow(row - 1);  
        Cell cell = rows.createCell(colum - 1);  
        cell.setCellValue(content);  
        FileOutputStream fileOut = new FileOutputStream(path);  
        workbook.write(fileOut);  
        fileOut.close();  
  
    }  
  
    /** 
     * 得到一个工作区最后一条记录的序号，相当于这个工作簿共多少行数据。 
     *  
     * @param sheetOrder 
     *            工作区序号 
     * @return int 序号。 
     * @throws IOException 
     *             根据excel路径加载excel异常。 
     * @throws InvalidFormatException 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public int getSheetLastRowNum(int sheetOrder) throws IOException,  
            InvalidFormatException {  
        FileInputStream fis = new FileInputStream(path);  
        Workbook workbook = WorkbookFactory.create(fis);  
        if (fis != null) {  
            fis.close();  
        }  
        Sheet sheet = workbook.getSheetAt(sheetOrder);  
        return sheet.getLastRowNum();  
    }  
  
    /** 
     * 在磁盘生成一个含有内容的excel,路径为path属性 
     *  
     * @param sheetName 
     *            导出的sheet名称 
     * @param fieldName 
     *            列名数组 
     * @param data 
     *            数据组 
     * @throws IOException 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public void makeExcel(String sheetName, String[] fieldName,  
            List<Object[]> data) throws IOException {  
        // 在内存中生成工作薄  
        HSSFWorkbook workbook = makeWorkBook(sheetName, fieldName, data);  
        // 截取文件夹路径  
        String filePath = path.substring(0, path.lastIndexOf("\"));  
        // 如果路径不存在，创建路径  
        File file = new File(filePath);  
        // System.out.println(path+"-----------"+file.exists());  
        if (!file.exists())  
            file.mkdirs();  
        FileOutputStream fileOut = new FileOutputStream(path);  
        workbook.write(fileOut);  
        fileOut.close();  
    }  
  
    /** 
     * 在输出流中导出excel。 
     *  
     * @param excelName 
     *            导出的excel名称 包括扩展名 
     * @param sheetName 
     *            导出的sheet名称 
     * @param fieldName 
     *            列名数组 
     * @param data 
     *            数据组 
     * @param response 
     *            response 
     * @throws IOException 
     *             转换流时IO错误 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    public void makeStreamExcel(String excelName, String sheetName,  
            String[] fieldName, List<Object[]> data,  
            HttpServletResponse response) throws IOException {  
        OutputStream os = null;  
        response.reset(); // 清空输出流  
        os = response.getOutputStream(); // 取得输出流  
        response.setHeader("Content-disposition", "attachment; filename="  
                + new String(excelName.getBytes(), "ISO-8859-1")); // 设定输出文件头  
        response.setContentType("application/msexcel"); // 定义输出类型  
        // 在内存中生成工作薄  
        HSSFWorkbook workbook = makeWorkBook(sheetName, fieldName, data);  
        os.flush();  
        workbook.write(os);  
    }  
  
    /** 
     * 根据条件，生成工作薄对象到内存。 
     *  
     * @param sheetName 
     *            工作表对象名称 
     * @param fieldName 
     *            首列列名称 
     * @param data 
     *            数据 
     * @return HSSFWorkbook 
     * @author 宋立君 
     * @date 2014年07月03日 
     */  
    private HSSFWorkbook makeWorkBook(String sheetName, String[] fieldName,  
            List<Object[]> data) {  
        // 用来记录最大列宽,自动调整列宽。  
        Integer collength[] = new Integer[fieldName.length];  
  
        // 产生工作薄对象  
        HSSFWorkbook workbook = new HSSFWorkbook();  
        // 产生工作表对象  
        HSSFSheet sheet = workbook.createSheet();  
        // 为了工作表能支持中文,设置字符集为UTF_16  
        workbook.setSheetName(0, sheetName);  
        // 产生一行  
        HSSFRow row = sheet.createRow(0);  
        // 产生单元格  
        HSSFCell cell;  
        // 写入各个字段的名称  
        for (int i = 0; i < fieldName.length; i++) {  
            // 创建第一行各个字段名称的单元格  
            cell = row.createCell((short) i);  
            // 设置单元格内容为字符串型  
            cell.setCellType(HSSFCell.CELL_TYPE_STRING);  
            // 为了能在单元格中输入中文,设置字符集为UTF_16  
            // cell.setEncoding(HSSFCell.ENCODING_UTF_16);  
            // 给单元格内容赋值  
            cell.setCellValue(new HSSFRichTextString(fieldName[i]));  
            // 初始化列宽  
            collength[i] = fieldName[i].getBytes().length;  
        }  
        // 临时单元格内容  
        String tempCellContent = "";  
        // 写入各条记录,每条记录对应excel表中的一行  
        for (int i = 0; i < data.size(); i++) {  
            Object[] tmp = data.get(i);  
            // 生成一行  
            row = sheet.createRow(i + 1);  
            for (int j = 0; j < tmp.length; j++) {  
                cell = row.createCell((short) j);  
                // 设置单元格字符类型为String  
                cell.setCellType(HSSFCell.CELL_TYPE_STRING);  
                tempCellContent = (tmp[j] == null) ? "" : tmp[j].toString();  
                cell.setCellValue(new HSSFRichTextString(tempCellContent));  
  
                // 如果自动调整列宽度。  
                if (autoColumnWidth) {  
                    if (j >= collength.length) { // 标题列数小于数据列数时。  
                        collength = CollectionUtil.addObjectToArray(collength,  
                                tempCellContent.getBytes().length);  
                    } else {  
                        // 如果这个内容的宽度大于之前最大的，就按照这个设置宽度。  
                        if (collength[j] < tempCellContent.getBytes().length) {  
                            collength[j] = tempCellContent.getBytes().length;  
                        }  
                    }  
                }  
            }  
        }  
  
        // 自动调整列宽度。  
        if (autoColumnWidth) {  
            // 调整列为这列文字对应的最大宽度。  
            for (int i = 0; i < fieldName.length; i++) {  
                sheet.setColumnWidth(i, collength[i] * 2 * 256);  
            }  
        }  
        return workbook;  
    }  
  
    /** 
     * 功能：设置写入excel时，是否自动扩展列宽度来符合内容，默认为false。 
     *  
     * @author 宋立君 
     * @date 2014年07月03日 
     * @param autoColumnWidth 
     *            true或者false 
     */  
    public void setAutoColumnWidth(boolean autoColumnWidth) {  
        this.autoColumnWidth = autoColumnWidth;  
    }  
}