在前面兩篇部落格preparedstatement簡單操作和statement簡單操作中，我們會發現很明顯的一個問題就是，jdbc的Driver，connection的url，mysql的username和password具體的值都寫在了java檔案之中，這樣子是不利於我們維護的，比如說，我們做專案的時候是使用本地的資料庫進行測試，當我們專案做完了，交接的時候自然要用客戶自己的資料庫，難道要讓客戶深入到程式碼去修改上面的值嗎….

最好的做法是將這些需要更改的東西寫進一個配置檔案之中…這樣客戶自己去修改配置檔案就可以的…無需對我們寫的程式碼傷筋動骨的….

我把上述的值都寫進了一個叫jdbc.properties的檔案之中(.properties檔案是配置檔案哦)…
檔案的內容如下：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?characterEncoding=utf-8&useSSL=true
jdbc.username=root
jdbc.password=scott

寫了這個配置檔案之後，我寫了一個工具類來獲取這些值，和封裝了的帶connection和關閉流的方法,
工具類的具體內容如下：

package JDBCUtils;

import java.io.InputStream;
import java.sql.Connection;
import
 
 java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

public class JDBCUtils {

    private static Properties p = new Properties();

    static{
        try {
            InputStream is = Thread.currentThread().
                    getContextClassLoader().getResourceAsStream("jdbc.properties"
 
);
            p.load(is);
            Class.forName(p.getProperty("jdbc.driverClassName"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection(){
        try {
            return DriverManager.getConnection(p.getProperty("jdbc.url"),
            p.getProperty("jdbc.username"),p.getProperty("jdbc.password"));
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void close(Connection conn , PreparedStatement ps , ResultSet rs ){
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }finally{
                if(ps != null){
                    try {
                        ps.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }finally{
                        if(rs != null){
                            try {
                                rs.close();
                            } catch (SQLException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    }
}

下面是重頭戲：
在前面兩篇部落格之中，我們都要很幸苦的一個一個的給preparedstatement的佔位符設定值..
我們就將這些東西封裝好，以後就不用反覆設定了…

我們對資料庫的操作有四種，增刪查改，而粗略的分，只有兩種，就是更新（此處是隻對資料庫的更新）和查詢，所以我封裝了query和update兩個方法
下面是程式碼：

package JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class JDBC_Functions {
    //DML操作....
    public static Integer update(String sql , Object...params){
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = JDBCUtils.getConnection();
            ps = conn.prepareStatement(sql);
            if(params != null){
                for(int i = 0 ; i<params.length ; i++){
                    ps.setObject(i+1, params[i]);
                }
            }
            ps.execute();
            return 1;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }finally{
            JDBCUtils.close(conn, ps, null);
        }
    }

    //DDL操作....
    public static <T> T query(String sql , IResultSetHandler<T> rsh,Object...params){
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtils.getConnection();
            ps = conn.prepareStatement(sql);
            if( params != null){
                for(int i = 0 ; i < params.length ; i++ ){
                    ps.setObject(i+1, params[i]);
                }
            }
            rs = ps.executeQuery();
            return (T) rsh.handler(rs);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }finally{
            JDBCUtils.close(conn, ps, rs);
        }
    }
}

通過上面的程式碼，你會發現，每次進行資料庫操作的時候，只需要將sql語句和佔位符？的值傳進封裝好的query或者update方法裡面就大功告成了….那我們的dao層方法只需要幾行程式碼就可以了…..

看到這裡，你可能會問，query的第二個引數IResultSetHandler rsh是什麼東西呢….
因為我每次將資料從資料庫裡取出來，都會把它們轉化成java的物件，之前通過ResultSet做迴圈取值和設值來轉化，如果在query方法裡面來完成這個轉化，那這個query方法就不是通用的了…

因為有些類具有不一樣的欄位，用一個方法就完成不同類的轉化，這不太可能…所以我寫了一個介面，裡面有一個負責完成從資料庫資料轉化成java物件的方法…..

介面具體程式碼如下：

package JDBCUtils;

import java.sql.ResultSet;

public interface IResultSetHandler<T> {
    T handler(ResultSet rs);
}

所以每有一個類需要這種轉化，我們都需要實現這個介面，實現這個方法，將具體的轉化過程寫在這個實現的方法裡面…這也是介面的意義所在（制定一套規範，在後面實現….）

好了，下面我用User類做師範，實現一下對User的增刪查改，
User的程式碼如下：

package Pojo;

public class User {
    private Integer id;
    private String username;
    private String password;
------------------------------
    getter和setter方法
------------------------------

    public User(Integer id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public User() {
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password=" + password + "]\n";
    }
}

首先要實現一個IResultSetHandler的介面，程式碼如下….

package JDBCUtils;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import Pojo.User;

public class UserResultSetHandler implements IResultSetHandler<List<User>>{

    public List<User> handler(ResultSet rs) {
        List<User> userList = new ArrayList<User>();
        try {
            while(rs.next()){
                int id = rs.getInt("ID");
                String username = rs.getString("USERNAME");
                String password = rs.getString ("PASSWORD");
                User u = new User(id,username,password);
                userList.add(u);
            }
            return userList;
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

}

實現介面之後，我們寫一個UserDao，封裝對User進行增刪查改的四個方法…..
程式碼如下：

package Dao;

import java.util.List;

import JDBCUtils.JDBC_Functions;
import JDBCUtils.UserResultSetHandler;
import Pojo.User;

public class UserDao {
    public void findUsers(){
        String sql = "SELECT * FROM USER";
        List<User> userList = JDBC_Functions.query(sql, new UserResultSetHandler());
        System.out.println(userList);
    }

    public void deleteUser(int id){
        String sql = "DELETE FROM USER WHERE ID = ?";
        JDBC_Functions.update(sql, id);
        System.out.println("刪除成功.....");
    }

    public void addUser(User u){
        String sql = "INSERT INTO USER(ID,USERNAME,PASSWORD) VALUES(?,?,?)";
        JDBC_Functions.update(sql, u.getId(),u.getUsername(),u.getPassword());
        System.out.println("新增成功....");
    }

    public void updateUser(User u ){
        String sql = "UPDATE USER SET USERNAME = ? ,PASSWORD = ? WHERE ID = ?";
        JDBC_Functions.update(sql, u.getUsername(),u.getPassword(),u.getId());
        System.out.println("更新成功....");
    }
}

下面是開始測試了：

package App;

import Dao.UserDao;
import Pojo.User;

public class JDBCTest3 {
    public static void main(String[] args) {

        UserDao ud = new UserDao();

        System.out.println("------增加前--------");
        ud.findUsers();
        User u = new User(7,"white","9999999");
        ud.addUser(u);
        System.out.println("------增加後--------");
        ud.findUsers();

        System.out.println("\n");
        ud.deleteUser(7);
        System.out.println("------刪除後--------");
        ud.findUsers();

        System.out.println("\n");
        u = new User(3,"UZI","666666");
        ud.updateUser(u);
        System.out.println("------更新後--------");
        ud.findUsers();
    }
}

結果如下：