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;
     }
 }

Java反射工具类

package reflection;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.Assert;

/**
 * 反射的Utils函数集合. 提供访问私有变量,获取泛型类型Class,提取集合中元素的属性等Utils函数.
 * 
 * @author lei
 */
public class ReflectionUtils {

	private static Logger logger = LoggerFactory.getLogger(ReflectionUtils.class);

	private ReflectionUtils() {
	}

	/**
	 * 直接读取对象属性值,无视private/protected修饰符,不经过getter函数.
	 */
	public static Object getFieldValue(final Object object, final String fieldName) {
		Field field = getDeclaredField(object, fieldName);

		if (field == null)
			throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

		makeAccessible(field);

		Object result = null;
		try {
			result = field.get(object);
		} catch (IllegalAccessException e) {
			logger.error("不可能抛出的异常{}", e.getMessage());
		}
		return result;
	}

	/**
	 * 直接设置对象属性值,无视private/protected修饰符,不经过setter函数.
	 */
	public static void setFieldValue(final Object object, final String fieldName, final Object value) {
		Field field = getDeclaredField(object, fieldName);

		if (field == null)
			throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");

		makeAccessible(field);

		try {
			field.set(object, value);
		} catch (IllegalAccessException e) {
			logger.error("不可能抛出的异常:{}", e.getMessage());
		}
	}

	/**
	 * 循环向上转型,获取对象的DeclaredField.
	 */
	protected static Field getDeclaredField(final Object object, final String fieldName) {
		Assert.notNull(object, "object不能为空");
		return getDeclaredField(object.getClass(), fieldName);
	}

	/**
	 * 循环向上转型,获取类的DeclaredField.
	 */
	@SuppressWarnings("unchecked")
	protected static Field getDeclaredField(final Class clazz, final String fieldName) {
		Assert.notNull(clazz, "clazz不能为空");
		Assert.hasText(fieldName, "fieldName");
		for (Class superClass = clazz; superClass != Object.class; superClass = superClass.getSuperclass()) {
			try {
				return superClass.getDeclaredField(fieldName);
			} catch (NoSuchFieldException e) {
				// Field不在当前类定义,继续向上转型
			}
		}
		return null;
	}

	/**
	 * 强制转换fileld可访问.
	 */
	protected static void makeAccessible(final Field field) {
		if (!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers())) {
			field.setAccessible(true);
		}
	}

	/**
	 * 通过反射,获得定义Class时声明的父类的泛型参数的类型. 如public UserDao extends HibernateDao<User>
	 * 
	 * @param clazz
	 *            The class to introspect
	 * @return the first generic declaration, or Object.class if cannot be
	 *         determined
	 */
	@SuppressWarnings("unchecked")
	public static Class getSuperClassGenricType(final Class clazz) {
		return getSuperClassGenricType(clazz, 0);
	}

	/**
	 * 通过反射,获得定义Class时声明的父类的泛型参数的类型. 如public UserDao extends
	 * HibernateDao<User,Long>
	 * 
	 * @param clazz
	 *            clazz The class to introspect
	 * @param index
	 *            the Index of the generic ddeclaration,start from 0.
	 * @return the index generic declaration, or Object.class if cannot be
	 *         determined
	 */

	@SuppressWarnings("unchecked")
	public static Class getSuperClassGenricType(final Class clazz, final int index) {

		Type genType = clazz.getGenericSuperclass();

		if (!(genType instanceof ParameterizedType)) {
			logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
			return Object.class;
		}

		Type[] params = ((ParameterizedType) genType).getActualTypeArguments();

		if (index >= params.length || index < 0) {
			logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: " + params.length);
			return Object.class;
		}
		if (!(params[index] instanceof Class)) {
			logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
			return Object.class;
		}
		return (Class) params[index];
	}

	/**
	 * 提取集合中的对象的属性,组合成List.
	 * 
	 * @param collection
	 *            来源集合.
	 * @param propertityName
	 *            要提取的属性名.
	 */
	@SuppressWarnings("unchecked")
	public static List fetchElementPropertyToList(final Collection collection, final String propertyName) throws Exception {

		List list = new ArrayList();

		for (Object obj : collection) {
			list.add(PropertyUtils.getProperty(obj, propertyName));
		}

		return list;
	}

	/**
	 * 提取集合中的对象的属性,组合成由分割符分隔的字符串.
	 * 
	 * @param collection
	 *            来源集合.
	 * @param propertityName
	 *            要提取的属性名.
	 * @param separator
	 *            分隔符.
	 */
	@SuppressWarnings("unchecked")
	public static String fetchElementPropertyToString(final Collection collection, final String propertyName, final String separator) throws Exception {
		List list = fetchElementPropertyToList(collection, propertyName);
		return StringUtils.join(list.toArray(), separator);
	}
}