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;

/**
 * 连接数据库的综合类。
 * 依赖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> 查询的结果集
     * @throws SQLException
     * @author 宋立君
     * @date 2014年07月03日
     */
    public List> query(Connection conn,
            PreparedStatement pstm) throws SQLException {
        try {
            return resultSetToList(pstm.executeQuery());
        } finally {
            Close(conn);
        }
    }

    /**
     * 功能：ResultSet 转为List>
     *
     *
     * @param rs
     *            ResultSet 原始数据集
     * @return List>
     * @throws java.sql.SQLException
     * @author 宋立君
     * @date 2014年07月03日
     */
    private List> 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> list = new ArrayList>();
        Map rowData = new HashMap();
        while (rs.next()) {
            rowData = new HashMap(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>
     * @throws SQLException
     * @author 宋立君
     * @date 2014年07月03日
     */
    public List> query(String sql) throws SQLException {
        List> 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>
     * @throws SQLException
     * @author 宋立君
     * @date 2014年07月03日
     */
    public List> query(String sql, Object param)
            throws SQLException {
        List> results = null;
        Connection conn = null;
        try {
            conn = getConnection();
            QueryRunner qr = new QueryRunner();
            results = (List>) 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。
 * 依赖于poi-3.9-20121203.jar,poi-ooxml-3.9-20121203.jar,poi-ooxml-schemas-3.9-
 * 20121203.jar,dom4j-1.6.1.jar
 * 有参构造函数参数为excel的全路径
 *
 * @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 所有单元格的值。
     * @throws IOException
     *             加载excel文件IO异常。
     * @throws FileNotFoundException
     *             excel文件没有找到异常。
     * @throws InvalidFormatException
     * @author 宋立君
     * @date 2014年07月03日
     */
    public List 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 valueList = new LinkedList();
        // 循环遍历每一行、每一列。
        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 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 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 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;
    }
}