简易 DBUtil 封装

Dao包结构图：

1.首先连接数据库

 package com.util.db;

 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.ResourceBundle;

 import javax.management.loading.PrivateClassLoader;

 import org.omg.CORBA.PRIVATE_MEMBER;

 /**
  * 连接数据库
  * @author Administrator
  *
  */
 public class DBConn {
 public static String URL;
 public static String USERNAME;
 public static String PASSWORD;
 public static String DRIVER;
 private static  ResourceBundle resourceBundle = ResourceBundle.getBundle("com.util.db.db_config");
 private DBConn() {}
 /**
  *为连接数据库变量赋值
  *加载jdbc驱动
  */
 static{
     URL = resourceBundle.getString("jdbc.url");
     USERNAME = resourceBundle.getString("jdbc.username");
     PASSWORD = resourceBundle.getString("jdbc.password");
     DRIVER = resourceBundle.getString("jdbc.driver");
     try {
         Class.forName(DRIVER);
     } catch (ClassNotFoundException e) {
         e.printStackTrace();
     }
 }
 /**
  * 连接数据库，若连接失败则返回空
  * @return
  */
 public static Connection getConnection() {
     Connection conn = null;
     try {
         conn = DriverManager.getConnection(URL, USERNAME,PASSWORD);
         System.out.println("连接成功！");
     } catch (SQLException e) {
         e.printStackTrace();
         System.out.println("连接失败");
     }
     return conn;
 }
 /**
  * 关闭数据库连接
  * @param rs
  * @param st
  * @param conn
  */
 public static void close(ResultSet rs,Statement st,Connection conn){
     try {
         if (rs != null) {rs.close();}
         if (st != null) {st.close();}
         if (conn !=null) {conn.close();}
     } catch (SQLException e) {
         e.printStackTrace();
     }

 }
 public static void main(String[] args) {
     System.out.println(URL);
     System.out.println(USERNAME);
     System.out.println(PASSWORD);
     System.out.println(DRIVER);

 }
 }

连接所需配置文件如下：

jdbc.url = jdbc\:mysql\://localhost\:3306/test?characterEncoding\=utf8
jdbc.username = root
jdbc.password = 000000
jdbc.driver =com.mysql.jdbc.Driver

2.对增删该查基本操作做定义  使用不定参数 来解决增删改的参数不同

 package com.util.db;

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

 /**
  * 为数据库操作提供方法模板
  * @author Administrator
  *
  */
 public class JdbcTemplete {
     /**
      * 更新操作
      * 返回 int 类型的操作行数 用作判断操作成功与否
      * 若操作异常  则返回 -1
      * @param sql
      * @param args
      * @return
      */
 public int update(String sql,Object...args){
     Connection conn = null;
     PreparedStatement ps =  null;
     conn = DBConn.getConnection();
     try {
         ps = conn.prepareStatement(sql);
         if(args!=null){
             for(int i = 0; i< args.length; i++){
             ps.setObject(i+1, args[i]);
             }
         }

         int rs =  ps.executeUpdate();
         System.out.println("操作成功！");
         return rs;
     } catch (SQLException e) {
         e.printStackTrace();
 //        try {
 //            //事务回滚
 //            conn.rollback();
 //        } catch (SQLException e1) {e1.printStackTrace();}
         System.out.println("更新异常");
         return -1;
     }finally{
         DBConn.close(null, ps, conn);
     }
 }
 /**
  *  查询操作 不做结果处理
  *  结果处理放在  ResultSetHandler
  *  由调用时编写匿名类  采用策略模式  使用户采用不同策略 处理不同对象
  * @param sql
  * @param handler
  * @param args
  * @return
  */
 public Object query(String sql, ResultSetHandler handler, Object...args) {
     Connection conn = null;
     PreparedStatement ps = null;
     ResultSet rs = null;
     try {
         conn = DBConn.getConnection();
         ps = conn.prepareStatement(sql);
         if (args != null) {
             for (int i = 0; i < args.length; i++) {
                 ps.setObject(i+1, args[i]);
             }
         }
         rs = ps.executeQuery();
         return handler.doHandler(rs);
     } catch (SQLException e) {
         e.printStackTrace();
         return null;
     }finally{
         DBConn.close(rs, ps, conn);
     }
 }
 }

3.对操作查询结果作出接口声明  使用策略模式  对于不同的javaBean有不同的处理

package com.util.db;

import java.sql.ResultSet;
import java.sql.SQLException;
/**
 * 操作连接数据库的结果集
 * 声明接口可以对具体的实体做不同处理
 * @author Administrator
 *
 */
public interface ResultSetHandler {
public Object doHandler(ResultSet rs) throws SQLException;
}

4.定义javaBean

 package com.domain;

 public class Person {
 private int id;
 private String name;
 private int age;
 private String description;
 public Person() {
     super();
 }
 public Person(String name, int age, String description) {
     super();
     this.name = name;
     this.age = age;
     this.description = description;
 }
 public Person(int id, String name, int age, String description) {
     super();
     this.id = id;
     this.name = name;
     this.age = age;
     this.description = description;
 }
 public int getId() {
     return id;
 }
 public void setId(int id) {
     this.id = id;
 }
 public String getName() {
     return name;
 }
 public void setName(String name) {
     this.name = name;
 }
 public int getAge() {
     return age;
 }
 public void setAge(int age) {
     this.age = age;
 }
 public String getDescription() {
     return description;
 }
 public void setDescription(String description) {
     this.description = description;
 }
 @Override
 public String toString() {
     return "Person [id=" + id + ", name=" + name + ", age=" + age
             + ", description=" + description + "]";
 }

 }

5. 定义Dao  对具体操作  声明接口

 package com.dao;

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

 import com.domain.Person;

 /**
  * 用户功能接口
  * @author Administrator
  *
  */
 public interface PersonDao {
 public void add(Person person)throws SQLException;
 public void update(Person person)throws SQLException;
 public void delete (int id)throws SQLException;
 public Person findById(int id)throws SQLException;
 public List findAll()throws SQLException;

 } 

6.对用户的操作进行实现

 package com.dao.impl;

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

 import javax.management.j2ee.statistics.JDBCConnectionPoolStats;

 import com.dao.PersonDao;
 import com.domain.Person;
 import com.util.db.JdbcTemplete;
 import com.util.db.ResultSetHandler;

 public class PersonDaoImpl implements PersonDao {
 private JdbcTemplete jdbcTemplete;
 public PersonDaoImpl(){
     jdbcTemplete = new JdbcTemplete();
 }
     /**
      * 添加
      */
     @Override
     public void add(Person person) throws SQLException {
        String sql = "insert into person(name,age,description)value(?,?,?)";
        jdbcTemplete.update(sql, person.getName(),person.getAge(),person.getDescription());

     }
     /**
      * 更新操作
      */
     @Override
     public void update(Person person) throws SQLException {
            String sql ="update person set name=?,age=?,description=? where id=?";
            jdbcTemplete.update(sql, person.getName(),person.getAge(),person.getDescription(),person.getId());
     }

     @Override
     public void delete(int id) throws SQLException {
         String sql = "delete from person where id = ?";
         jdbcTemplete.update(sql,id);
     }

     @Override
     public Person findById(final int id) throws SQLException {
         String sql = "select name,age,description from person where id =?";
           return (Person) jdbcTemplete.query(sql, new ResultSetHandler() {
             @Override
             public Object doHandler(ResultSet rs) throws SQLException {
                 Person person = null;
                 if (rs.next()) {
                     person = new Person();
                     person.setId(rs.getInt(id));
                     person.setName(rs.getString(1));
                     person.setAge(rs.getInt(2));
                     person.setDescription(rs.getString(3));
                 }
                 return person;
             }
         },id );

     }

     @Override
     public List findAll() throws SQLException {
         String sql = "select id,name,age,description from person";
         return (List) jdbcTemplete.query(sql,new ResultSetHandler() {
             @Override
             public Object doHandler(ResultSet rs) throws SQLException {
                 List<Person> personList = new ArrayList<>();
                 Person person =null;
                 while (rs.next()) {
                     person = new Person();
                     person.setId(rs.getInt(1));
                     person.setName(rs.getString(2));
                     person.setAge(rs.getInt(3));
                     person.setDescription(rs.getString(4));
                     personList.add(person);
                 }
                 return personList;
             }
         });

     }

 }

7.编写测试类

 package com.test;

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

 import com.dao.PersonDao;
 import com.dao.impl.PersonDaoImpl;
 import com.domain.Person;

 public class Test {
     /**
      *
      * @param args
      */
 public static void main(String[] args) {
     PersonDao personDao = new PersonDaoImpl();

     try {

 //        personDao.add(new Person("CCC", 13, "CCC"));

         personDao.delete(3);
 //
 //        personDao.update(new Person(3, "DDD", 10, "DDD"));
 //
 //
 //        Person p4 = personDao.findById(2);
 //        System.out.println(p4.toString());
 //
 //
 //        List<Person> personList = personDao.findAll();
 //        for (Person p : personList) {
 //            System.out.println(p.toString());
 //        }

     } catch (SQLException e) {
         e.printStackTrace();
     }
 }
 }

1.Statement、PreparedStatement和CallableStatement都是接口(interface)。  
2.Statement继承自Wrapper、PreparedStatement继承自Statement、CallableStatement继承自PreparedStatement。 
3.  
　a.Statement:  
　　　　普通的不带参的查询SQL；支持批量更新,批量删除;  
　b.PreparedStatement:  
　　　　可变参数的SQL,支持占位符，每个占位符可占一个位，

　　　　 编译一次,执行多次,效率高;  
　　　　安全性好，有效防止Sql注入等问题;  
　　　　支持批量更新,批量删除;  
　c.CallableStatement:  
　　　　继承自PreparedStatement,支持带参数的SQL操作;  
　　　　支持调用存储过程,提供了对输出和输入/输出参数(INOUT)的支持; 

PreparedStatement是预编译的，使用PreparedStatement有几个好处  
1. 在执行可变参数的一条SQL时，PreparedStatement比Statement的效率高，因为DBMS预编译一条SQL当然会比多次编译一条SQL的效率要高。 
2. 安全性好，有效防止Sql注入等问题。  
3.  对于多次重复执行的语句，使用PreparedStament效率会更高一点，并且在这种情况下也比较适合使用batch；  
4.  代码的可读性和可维护性。

如何防止注入攻击：

如果你是做Java web应用开发的，那么必须熟悉那声名狼藉的SQL注入式攻击。去年Sony就遭受了SQL注入攻击，被盗用了一些Sony play station（PS机）用户的数据。在SQL注入攻击里，恶意用户通过SQL元数据绑定输入，比如：某个网站的登录验证SQL查询代码为：

strSQL = "SELECT * FROM users WHERE name = '" + userName + "' and pw = '"+ passWord +"';"

恶意填入：

userName = "1' OR '1'='1";
passWord = "1' OR '1'='1"

那么最终SQL语句变成了：

strSQL = "SELECT * FROM users WHERE name = '1' OR '1'='1' and pw = '1' OR '1'='1';"

因为WHERE条件恒为真，这就相当于执行：

strSQL = "SELECT * FROM users;"

因此可以达到无账号密码亦可登录网站。如果恶意用户要是更坏一点，再在后面加一句  ：

drop  table users；

SQL语句变成了：

strSQL = "SELECT * FROM users;drop  table users；

这样一来，虽然没有登录，但是数据表都被删除了。

　　然而使用PreparedStatement的参数化的查询可以阻止大部分的SQL注入。在使用参数化查询的情况下，数据库系统（eg:MySQL）不会将参数的内容视为SQL指令的一部分来处理，而是在数据库完成SQL指令的编译后，才套用参数运行，参数只是用作参数，而不会作为指令拼成SQL语句，因此就算参数中含有破坏性的指令，也不会被数据库所运行。
补充：避免SQL注入的第二种方式：
在组合SQL字符串的时候，先对所传入的参数做字符取代（将单引号字符取代为连续2个单引号字符，因为连续2个单引号字符在SQL数据库中会视为字符中的一个单引号字符，譬如：

strSQL = "SELECT * FROM users WHERE name = '" + userName + "';"

传入字符串：

userName  = " 1' OR 1=1 "

把userName做字符替换后变成：

userName = " 1'' OR 1=1"

最后生成的SQL查询语句为：

strSQL = "SELECT * FROM users WHERE name = '1'' OR 1=1'

这样数据库就会去系统查找name为“   　　1′ OR 1=1 　　  ”的记录，而避免了SQL注入。

CallableStatement使用：

　　

public class Conn {
    public static String URL;
    public static String USERNAME;
    public static String PASSWORD;
    public static String DRIVER;
    private static  ResourceBundle resourceBundle = ResourceBundle.getBundle("com.util.db.db_config");
    private void Conn() {}
    static{
        URL = resourceBundle.getString("jdbc.url");
        USERNAME = resourceBundle.getString("jdbc.username");
        PASSWORD = resourceBundle.getString("jdbc.password");
        DRIVER = resourceBundle.getString("jdbc.driver");
        try {
            Class.forName(DRIVER);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    /**
     * 连接数据库，若连接失败则返回空
     * @return
     */
    public static Connection getConnection() {
        Connection conn = null;
        try {
            conn = DriverManager.getConnection(URL, USERNAME,PASSWORD);
            System.out.println("连接成功！");
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("连接失败");
        }
        return conn;
    }
    /**
     * 关闭数据库连接
     * @param rs
     * @param st
     * @param conn
     */
    public static void close(ResultSet rs,CallableStatement cstmt,Connection conn){
        try {
            if (rs != null) {rs.close();}
            if (cstmt != null) {cstmt.close();}
            if (conn !=null) {conn.close();}
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

/**
 * 1、执行不带参数但有返回值的存储过程
 */
static public  int getUserCount() {
    Connection conn = Conn.getConnection();
    CallableStatement  cstmt = null;
    int rowsCount = 0;
    try {
        String sql = "{call getUserCount(?)}";
        //创建CallableStatement 对象
        cstmt = conn.prepareCall(sql);
        //注册输出参数
        cstmt.registerOutParameter(1,Types.INTEGER);
        //执行存储过程
        cstmt.execute();

        rowsCount = cstmt.getInt(1);
    } catch (SQLException e) {
        System.out.println("执行失败！");
        e.printStackTrace();
    }finally {
        Conn.close(null,cstmt, conn);
        return rowsCount;
    }
}
/**
 *     2、执行带参数带返回值的存储过程
 */
static public int getUserCountCondit(String username) {
    Connection conn = Conn.getConnection();
    CallableStatement  cstmt = null;
    int rowsCount = 0;
    try {
        String sql = "{call proc_getUserCountCondit(?,?)}";
        //创建CallableStatement 对象
        cstmt = conn.prepareCall(sql);
        //输入参数赋值
        cstmt.setString(1,username);
        //注册输出参数
        cstmt.registerOutParameter(1,Types.INTEGER);
        //执行存储过程
        cstmt.execute();

        rowsCount = cstmt.getInt(1);
    } catch (SQLException e) {
        System.out.println("执行失败！");
        e.printStackTrace();
    }finally {
        Conn.close(null,cstmt, conn);
        return rowsCount;
    }
}
/**
 * 3、执行返回值为游标的存储过程
 */
static public List<User> getUserListByProc(){
    Connection conn = Conn.getConnection();
    CallableStatement  cstmt = null;
    ResultSet rs = null;
    List<User> userList = new ArrayList();
    try {
        String sql = "{? = call FUNC_GETUSERNAME(?)}";
        //创建CallableStatement 对象
        cstmt = conn.prepareCall(sql);
        //注册输出参数
        cstmt.registerOutParameter(1,Types.REF_CURSOR);
        //执行存储过程
        cstmt.execute();
        rs = cstmt.getResultSet();

        while (rs.next()) {
            String username = rs.getString("username");
            String password = rs.getString("password");
            userList.add(new User(username, password));
        }
    } catch (SQLException e) {
        System.out.println("执行失败！");
        e.printStackTrace();
    }finally {
        Conn.close(rs,cstmt, conn);
        return userList;
    }
}
public static void main(String[] args) {

}

static class User{
    String username = null;
    String password = null;

    public User(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }

}
}