原文链接： 

目录
1.摘要
2.JDBC的使用步骤
　　1.注册驱动 只做一次
　　2.建立连接Connection
　　3.创建执行SQL的语句Statement
　　4.处理执行结果ResultSet
　　5.释放资源
3.使用JDBC来实现CRUD的操作
4.Statement中的sql依赖注入的问题
5.JDBC中特殊数据类型的操作问题
　　1.第一个是日期问题
　　2.第二个问题就是大文本数据的问题
6.JDBC中事务的概念
7.JDBC中调用存储过程
8.JDBC来实现批处理功能
9.JDBC中的滚动结果集和分页技术
10.JDBC中的可更新以及对更新敏感的结果集操作
11.元数据的相关知识
　　1.数据库的元数据信息
　　2.查询参数的元数据信息
　　3.结果集中元数据信息
12.JDBC中的数据源
13.JDBC中CRUD的模板模式
14.Spring框架中的JdbcTemplate
　　1.加强版的JdbcTemplate
　　　　1.NamedParameterJdbcTemplate
　　　　2.SimpleJdbcTemplate

今天我们来说一下关于JDBC的相关知识，关于JDBC我想大家都不陌生了，而且我记得早就开始使用它了，记得那是大二的时候做课程设计，但是那时候是为了完成任务，所以遇到问题就google,那时候也没有时间去整理，所以这次就来详细说一下关于JDBC的知识

摘要：

JDBC（Java Data Base Connectivity,java数据库连接），由一些接口和类构成的API。 J2SE的一部分，由java.sql,javax.sql包组成。

应用程序、JDBC API、数据库驱动及数据库之间的关系

JDBC的使用步骤

1.注册驱动 (只做一次)

方式一：Class.forName(“com.mysql.jdbc.Driver”); 推荐这种方式，不会对具体的驱动类产生依赖。 方式二：DriverManager.registerDriver(com.mysql.jdbc.Driver); 会造成DriverManager中产生两个一样的驱动，并会对具体的驱动类产生依赖。 方式三：System.setProperty(“jdbc.drivers”, “driver1:driver2”); 虽然不会对具体的驱动类产生依赖；但注册不太方便，所以很少使用。  驱动类型(四种类型)

2.建立连接(Connection) 

1. Connection conn = DriverManager.getConnection(url, user, password);  

Connection conn = DriverManager.getConnection(url, user, password);

url格式： JDBC:子协议:子名称//主机名:端口/数据库名？属性名=属性值&… User,password可以用“属性名=属性值”方式告诉数据库； 其他参数如：useUnicode=true&characterEncoding=GBK。

3.创建执行SQL的语句(Statement)

1. Statement  
2. Statement st = conn.createStatement();  
3. st.executeQuery(sql);  
4. PreparedStatement  
5. String sql = “select * from table_name where col_name=?”;  
6. PreparedStatement ps = conn.preparedStatement(sql);  
7. ps.setString(1, “col_value”);  
8. ps.executeQuery();  

Statement
Statement st = conn.createStatement();
st.executeQuery(sql);
PreparedStatement
String sql = “select * from table_name where col_name=?”;
PreparedStatement ps = conn.preparedStatement(sql);
ps.setString(1, “col_value”);
ps.executeQuery();

4.处理执行结果(ResultSet)

1. ResultSet rs = statement.executeQuery(sql);  
2. While(rs.next()){  
3. rs.getString(“col_name”);  
4. rs.getInt(“col_name”);  
5. //…  
6. }  

ResultSet rs = statement.executeQuery(sql);
While(rs.next()){
rs.getString(“col_name”);
rs.getInt(“col_name”);
//…
}

5.释放资源

释放ResultSet, Statement,Connection. 数据库连接（Connection）是非常稀有的资源，用完后必须马上释放，如果Connection不能及时正确的关闭将导致系统宕机。Connection的使用原则是尽量晚创建，尽量早的释放。

下面来看一下完整的Demo:

工具类：JdbcUtils

1. package com.weijia.firstdemo;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.ResultSet;  
6. import java.sql.SQLException;  
7. import java.sql.Statement;  
8.   
9. import javax.sql.DataSource;  
10.   
11. public class JdbcUtils {  
12.       
13.     private static String user = "root";  
14.     private static String password = "123456";  
15.     private static String dbName = "test";  
16.     private static  String url = "jdbc:mysql://localhost:3306/"+dbName+"?user="+user+"&password="+password+"&useUnicode=true&characterEncoding=gb2312";  
17.       
18.     private static DataSource dataSource = null;  
19.       
20.     /** 
21.      * 加载驱动 
22.      */  
23.     static{  
24.         try{  
25.             Class.forName("com.mysql.jdbc.Driver");  
26.         }catch(Exception e){  
27.             System.out.println("Exception:"+e.getMessage()+"");  
28.             throw new ExceptionInInitializerError(e);  
29.         }  
30.     }  
31.       
32.     private JdbcUtils(){  
33.     }  
34.       
35.     /** 
36.      * 获取连接 
37.      * @return 
38.      * @throws SQLException 
39.      */  
40.     public static Connection getConnection() throws SQLException{  
41.         return DriverManager.getConnection(url);  
42.     }  
43.       
44.     public static DataSource getDataSource(){  
45.         return dataSource;  
46.     }  
47.       
48.     /** 
49.      * 释放资源 
50.      * @param rs 
51.      * @param st 
52.      * @param conn 
53.      */  
54.     public static void free(ResultSet rs,Statement st,Connection conn){  
55.         try{  
56.             if(rs != null){  
57.                 rs.close();  
58.             }  
59.         }catch(SQLException e){  
60.             e.printStackTrace();  
61.         }finally{  
62.             try{  
63.                 if(st != null){  
64.                     st.close();  
65.                 }  
66.             }catch(SQLException e){  
67.                 e.printStackTrace();  
68.             }finally{  
69.                 try{  
70.                     if(conn != null){  
71.                         conn.close();  
72.                     }  
73.                 }catch(SQLException e){  
74.                     e.printStackTrace();  
75.                 }  
76.             }  
77.         }  
78.               
79.     }  
80.   
81. }  

package com.weijia.firstdemo;

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

import javax.sql.DataSource;

public class JdbcUtils {
	
	private static String user = "root";
	private static String password = "123456";
	private static String dbName = "test";
	private static  String url = "jdbc:mysql://localhost:3306/"+dbName+"?user="+user+"&password="+password+"&useUnicode=true&characterEncoding=gb2312";
	
	private static DataSource dataSource = null;
	
	/**
	 * 加载驱动
	 */
	static{
		try{
			Class.forName("com.mysql.jdbc.Driver");
		}catch(Exception e){
			System.out.println("Exception:"+e.getMessage()+"");
			throw new ExceptionInInitializerError(e);
		}
	}
	
	private JdbcUtils(){
	}
	
	/**
	 * 获取连接
	 * @return
	 * @throws SQLException
	 */
	public static Connection getConnection() throws SQLException{
		return DriverManager.getConnection(url);
	}
	
	public static DataSource getDataSource(){
		return dataSource;
	}
	
	/**
	 * 释放资源
	 * @param rs
	 * @param st
	 * @param conn
	 */
	public static void free(ResultSet rs,Statement st,Connection conn){
		try{
			if(rs != null){
				rs.close();
			}
		}catch(SQLException e){
			e.printStackTrace();
		}finally{
			try{
				if(st != null){
					st.close();
				}
			}catch(SQLException e){
				e.printStackTrace();
			}finally{
				try{
					if(conn != null){
						conn.close();
					}
				}catch(SQLException e){
					e.printStackTrace();
				}
			}
		}
			
	}

}

测试类：

1. package com.weijia.firstdemo;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.ResultSet;  
6. import java.sql.SQLException;  
7. import java.sql.Statement;  
8.   
9. public class Demo {  
10.       
11.     public static void main(String[] args) throws Exception{  
12.         //测试代码：  
13.         test();  
14.         //标准规范代码：  
15.         template();  
16.     }  
17.       
18.     //模板代码  
19.     public static void template(){  
20.         Connection conn = null;  
21.         Statement st = null;  
22.         ResultSet rs = null;  
23.         try {  
24.             conn = JdbcUtils.getConnection();  
25.             //创建语句  
26.             st = conn.createStatement();  
27.             //执行语句  
28.             rs = st.executeQuery("select * from user");  
29.             //处理结果  
30.             while(rs.next()){  
31.                 System.out.println(rs.getObject(1) + "\t" + rs.getObject(2) + "\t" + rs.getObject(3) + "\t");  
32.             }  
33.         }catch(SQLException e){  
34.             e.printStackTrace();  
35.         }catch(Exception e){  
36.             e.printStackTrace();  
37.         }finally{  
38.             JdbcUtils.free(rs, st, conn);  
39.         }  
40.     }  
41.       
42.     //测试  
43.     static void test() throws Exception{  
44.         //注册驱动  
45.         DriverManager.registerDriver(new com.mysql.jdbc.Driver());  
46.         //通过系统属性来注册驱动  
47.         System.setProperty("jdbc.drivers","");  
48.         //静态加载驱动  
49.         Class.forName("com.mysql.jdbc.Driver");  
50.           
51.         //建立连接  
52.         String url = "jdbc:mysql://localhost:3306";  
53.         String userName = "root";  
54.         String password = "";  
55.         Connection conn = DriverManager.getConnection(url,userName,password);  
56.           
57.         //创建语句  
58.         Statement st = conn.createStatement();  
59.           
60.         //执行语句  
61.         ResultSet rs = st.executeQuery("select * from user");  
62.           
63.         //处理结果  
64.         while(rs.next()){  
65.             System.out.println(rs.getObject(1) + "\t" + rs.getObject(2) + "\t" + rs.getObject(3) + "\t");  
66.         }  
67.           
68.         //释放资源  
69.         rs.close();  
70.         st.close();  
71.         conn.close();  
72.     }  
73.   
74. }  

package com.weijia.firstdemo;

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

public class Demo {
	
	public static void main(String[] args) throws Exception{
		//测试代码：
		test();
		//标准规范代码：
		template();
	}
	
	//模板代码
	public static void template(){
		Connection conn = null;
		Statement st = null;
		ResultSet rs = null;
		try {
			conn = JdbcUtils.getConnection();
			//创建语句
			st = conn.createStatement();
			//执行语句
			rs = st.executeQuery("select * from user");
			//处理结果
			while(rs.next()){
				System.out.println(rs.getObject(1) + "\t" + rs.getObject(2) + "\t" + rs.getObject(3) + "\t");
			}
		}catch(SQLException e){
			e.printStackTrace();
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			JdbcUtils.free(rs, st, conn);
		}
	}
	
	//测试
	static void test() throws Exception{
		//注册驱动
		DriverManager.registerDriver(new com.mysql.jdbc.Driver());
		//通过系统属性来注册驱动
		System.setProperty("jdbc.drivers","");
		//静态加载驱动
		Class.forName("com.mysql.jdbc.Driver");
		
		//建立连接
		String url = "jdbc:mysql://localhost:3306";
		String userName = "root";
		String password = "";
		Connection conn = DriverManager.getConnection(url,userName,password);
		
		//创建语句
		Statement st = conn.createStatement();
		
		//执行语句
		ResultSet rs = st.executeQuery("select * from user");
		
		//处理结果
		while(rs.next()){
			System.out.println(rs.getObject(1) + "\t" + rs.getObject(2) + "\t" + rs.getObject(3) + "\t");
		}
		
		//释放资源
		rs.close();
		st.close();
		conn.close();
	}

}

注意：这里还要记住引入额外的jar.这个网上很多的，这里使用的是MySql,搜一下MySql驱动的jar就行了。这里我们将一些操作都放到一个工具类中，这种方式是很优雅的。

使用JDBC来实现CRUD的操作

我们这里就采用分层操作：Dao层，Service层

首先看一下domain域中的User实体

1. package com.weijia.domain;  
2.   
3. import java.util.Date;  
4.   
5. public class User {  
6.       
7.     private int id;  
8.     private String name;  
9.     private Date birthday;  
10.     private float money;  
11.       
12.     public User(){  
13.           
14.     }  
15.       
16.     public User(int id,String name,Date birthday,float money){  
17.         this.id = id;  
18.         this.name = name;  
19.         this.birthday = birthday;  
20.         this.money = money;  
21.     }  
22.       
23.     public int getId() {  
24.         return id;  
25.     }  
26.     public void setId(int id) {  
27.         this.id = id;  
28.     }  
29.     public String getName() {  
30.         return name;  
31.     }  
32.     public void setName(String name) {  
33.         this.name = name;  
34.     }  
35.     public Date getBirthday() {  
36.         return birthday;  
37.     }  
38.     public void setBirthday(Date birthday) {  
39.         this.birthday = birthday;  
40.     }  
41.     public float getMoney() {  
42.         return money;  
43.     }  
44.     public void setMoney(float money) {  
45.         this.money = money;  
46.     }  
47.   
48.     @Override  
49.     public String toString(){  
50.         return "[id="+id+",name="+name+",birthday="+birthday+",money="+money+"]";  
51.     }  
52. }  

package com.weijia.domain;

import java.util.Date;

public class User {
	
	private int id;
	private String name;
	private Date birthday;
	private float money;
	
	public User(){
		
	}
	
	public User(int id,String name,Date birthday,float money){
		this.id = id;
		this.name = name;
		this.birthday = birthday;
		this.money = money;
	}
	
	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 Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	public float getMoney() {
		return money;
	}
	public void setMoney(float money) {
		this.money = money;
	}

	@Override
	public String toString(){
		return "[id="+id+",name="+name+",birthday="+birthday+",money="+money+"]";
	}
}

再来看一下Dao层结构：

接口：

1. package com.weijia.domain;  
2.   
3. public interface UserDao {  
4.   
5.     //添加用户  
6.     public void addUser(User user);  
7.     //通过userid查询用户,id是唯一的,所以返回的是一个user  
8.     public User getUserById(int userId);  
9.     //更新用户信息  
10.     public int update(User user);  
11.     //删除用户信息  
12.     public int delete(User user);  
13.       
14. }  

package com.weijia.domain;

public interface UserDao {

	//添加用户
	public void addUser(User user);
	//通过userid查询用户,id是唯一的,所以返回的是一个user
	public User getUserById(int userId);
	//更新用户信息
	public int update(User user);
	//删除用户信息
	public int delete(User user);
	
}

实现类：

1. package com.weijia.domain;  
2.   
3. import java.sql.Connection;  
4. import java.sql.Date;  
5. import java.sql.PreparedStatement;  
6. import java.sql.ResultSet;  
7.   
8. import com.weijia.firstdemo.JdbcUtils;  
9.   
10. public class UserDaoImpl implements UserDao{  
11.   
12.     /** 
13.      * 添加用户 
14.      */  
15.     public void addUser(User user) {  
16.         Connection conn = null;  
17.         PreparedStatement st = null;  
18.         try{  
19.             conn = JdbcUtils.getConnection();  
20.             String sql = "insert into user(id,name,birthday,money) values(?,?,?,?)";  
21.             st = conn.prepareStatement(sql);  
22.             st.setInt(1,user.getId());  
23.             st.setString(2,user.getName());  
24.             //日期格式的转换(utils.date转化成sql.date)  
25.             st.setDate(3,new Date(user.getBirthday().getTime()));  
26.             st.setFloat(4, user.getMoney());  
27.             int count = st.executeUpdate();  
28.             System.out.println("添加记录条数:"+count);  
29.         }catch(Exception e){  
30.             throw new DaoException(e.getMessage(),e);  
31.         }finally{  
32.             JdbcUtils.free(null, st, conn);  
33.         }  
34.     }  
35.   
36.     /** 
37.      * 删除用户 
38.      */  
39.     public int delete(User user) {  
40.         Connection conn = null;  
41.         PreparedStatement st = null;  
42.         try{  
43.             conn = JdbcUtils.getConnection();  
44.             String sql = "delete from user where id=?";  
45.             st = conn.prepareStatement(sql);  
46.             st.setInt(1,user.getId());  
47.             int count = -1;  
48.             count = st.executeUpdate();  
49.             System.out.println("删除记录条数:"+count);  
50.             return count;  
51.         }catch(Exception e){  
52.             throw new DaoException(e.getMessage(),e);  
53.         }finally{  
54.             JdbcUtils.free(null, st, conn);  
55.         }  
56.     }  
57.   
58.     /** 
59.      * 通过userId获取用户信息 
60.      */  
61.     public User getUserById(int userId) {  
62.         Connection conn = null;  
63.         PreparedStatement st = null;  
64.         ResultSet rs = null;  
65.         try{  
66.             conn = JdbcUtils.getConnection();  
67.             String sql = "select * from user where id=?";  
68.             st = conn.prepareStatement(sql);  
69.             st.setInt(1,userId);  
70.             rs = st.executeQuery();  
71.             if(rs.next()){  
72.                 User user = new User();  
73.                 user.setId(userId);  
74.                 user.setName(rs.getString("name"));  
75.                 user.setBirthday(rs.getDate("birthday"));  
76.                 user.setMoney(rs.getFloat("money"));  
77.                 return user;  
78.             }  
79.         }catch(Exception e){  
80.             throw new DaoException(e.getMessage(),e);  
81.         }finally{  
82.             JdbcUtils.free(rs, st, conn);  
83.         }  
84.         return null;  
85.     }  
86.   
87.     /** 
88.      * 更新用户信息 
89.      */  
90.     public int update(User user){  
91.         Connection conn = null;  
92.         PreparedStatement st = null;  
93.         try{  
94.             conn = JdbcUtils.getConnection();  
95.             String sql = "update user set name=?,birthday=?,money=? where id=?";  
96.             st = conn.prepareStatement(sql);  
97.             st.setString(1,user.getName());  
98.             st.setDate(2,new Date(user.getBirthday().getTime()));  
99.             st.setFloat(3,user.getMoney());  
100.             st.setInt(3,user.getId());  
101.             int count = 0;  
102.             count = st.executeUpdate();  
103.             System.out.println("更新的记录数:"+count);  
104.             return count;  
105.         }catch(Exception e){  
106.             throw new DaoException(e.getMessage(),e);  
107.         }finally{  
108.             JdbcUtils.free(null, st, conn);  
109.         }  
110.     }  
111.   
112. }  

package com.weijia.domain;

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

import com.weijia.firstdemo.JdbcUtils;

public class UserDaoImpl implements UserDao{

	/**
	 * 添加用户
	 */
	public void addUser(User user) {
		Connection conn = null;
		PreparedStatement st = null;
		try{
			conn = JdbcUtils.getConnection();
			String sql = "insert into user(id,name,birthday,money) values(?,?,?,?)";
			st = conn.prepareStatement(sql);
			st.setInt(1,user.getId());
			st.setString(2,user.getName());
			//日期格式的转换(utils.date转化成sql.date)
			st.setDate(3,new Date(user.getBirthday().getTime()));
			st.setFloat(4, user.getMoney());
			int count = st.executeUpdate();
			System.out.println("添加记录条数:"+count);
		}catch(Exception e){
			throw new DaoException(e.getMessage(),e);
		}finally{
			JdbcUtils.free(null, st, conn);
		}
	}

	/**
	 * 删除用户
	 */
	public int delete(User user) {
		Connection conn = null;
		PreparedStatement st = null;
		try{
			conn = JdbcUtils.getConnection();
			String sql = "delete from user where id=?";
			st = conn.prepareStatement(sql);
			st.setInt(1,user.getId());
			int count = -1;
			count = st.executeUpdate();
			System.out.println("删除记录条数:"+count);
			return count;
		}catch(Exception e){
			throw new DaoException(e.getMessage(),e);
		}finally{
			JdbcUtils.free(null, st, conn);
		}
	}

	/**
	 * 通过userId获取用户信息
	 */
	public User getUserById(int userId) {
		Connection conn = null;
		PreparedStatement st = null;
		ResultSet rs = null;
		try{
			conn = JdbcUtils.getConnection();
			String sql = "select * from user where id=?";
			st = conn.prepareStatement(sql);
			st.setInt(1,userId);
			rs = st.executeQuery();
			if(rs.next()){
				User user = new User();
				user.setId(userId);
				user.setName(rs.getString("name"));
				user.setBirthday(rs.getDate("birthday"));
				user.setMoney(rs.getFloat("money"));
				return user;
			}
		}catch(Exception e){
			throw new DaoException(e.getMessage(),e);
		}finally{
			JdbcUtils.free(rs, st, conn);
		}
		return null;
	}

	/**
	 * 更新用户信息
	 */
	public int update(User user){
		Connection conn = null;
		PreparedStatement st = null;
		try{
			conn = JdbcUtils.getConnection();
			String sql = "update user set name=?,birthday=?,money=? where id=?";
			st = conn.prepareStatement(sql);
			st.setString(1,user.getName());
			st.setDate(2,new Date(user.getBirthday().getTime()));
			st.setFloat(3,user.getMoney());
			st.setInt(3,user.getId());
			int count = 0;
			count = st.executeUpdate();
			System.out.println("更新的记录数:"+count);
			return count;
		}catch(Exception e){
			throw new DaoException(e.getMessage(),e);
		}finally{
			JdbcUtils.free(null, st, conn);
		}
	}

}

然后是Servic层：

1. package com.weijia.domain;  
2.   
3. public class UserService {  
4.       
5.     private UserDao userDao;  
6.       
7.     public UserService(){  
8.         //通过工厂实例化UserDao对象  
9.         userDao = DaoFactory.getInstance().createUserDao();  
10.         System.out.println("userDao:"+userDao);  
11.     }  
12.       
13.     /** 
14.      * 注册用户 
15.      * @param user 
16.      */  
17.     public void regist(User user){  
18.         if(user == null){  
19.             System.out.println("注册信息无效!!");  
20.         }else{  
21.             userDao.addUser(user);  
22.         }  
23.           
24.     }  
25.       
26.     /** 
27.      * 查询用户 
28.      * @param userId 
29.      * @return 
30.      */  
31.     public User query(int userId){  
32.         User user = userDao.getUserById(userId);  
33.         if(user == null){  
34.             System.out.println("查询结果为空!!");  
35.         }else{  
36.             System.out.println(user.getId()+"\t"+user.getName()+"\t"+user.getBirthday()+"\t"+user.getMoney());  
37.         }  
38.         return userDao.getUserById(userId);  
39.     }  
40.       
41.     /** 
42.      * 更新用户 
43.      * @param user 
44.      */  
45.     public void update(User user){  
46.         if(user.getId()<=0){  
47.             System.out.println("用户id无效,无法更新");  
48.         }else{  
49.             userDao.update(user);  
50.         }  
51.     }  
52.       
53.     /** 
54.      * 删除用户 
55.      * @param user 
56.      */  
57.     public void delete(User user){  
58.         if(user.getId()<=0){  
59.             System.out.println("用户id无效,无法删除!!");  
60.         }else{  
61.             userDao.delete(user);  
62.         }  
63.     }  
64.       
65. }  

package com.weijia.domain;

public class UserService {
	
	private UserDao userDao;
	
	public UserService(){
		//通过工厂实例化UserDao对象
		userDao = DaoFactory.getInstance().createUserDao();
		System.out.println("userDao:"+userDao);
	}
	
	/**
	 * 注册用户
	 * @param user
	 */
	public void regist(User user){
		if(user == null){
			System.out.println("注册信息无效!!");
		}else{
			userDao.addUser(user);
		}
		
	}
	
	/**
	 * 查询用户
	 * @param userId
	 * @return
	 */
	public User query(int userId){
		User user = userDao.getUserById(userId);
		if(user == null){
			System.out.println("查询结果为空!!");
		}else{
			System.out.println(user.getId()+"\t"+user.getName()+"\t"+user.getBirthday()+"\t"+user.getMoney());
		}
		return userDao.getUserById(userId);
	}
	
	/**
	 * 更新用户
	 * @param user
	 */
	public void update(User user){
		if(user.getId()<=0){
			System.out.println("用户id无效,无法更新");
		}else{
			userDao.update(user);
		}
	}
	
	/**
	 * 删除用户
	 * @param user
	 */
	public void delete(User user){
		if(user.getId()<=0){
			System.out.println("用户id无效,无法删除!!");
		}else{
			userDao.delete(user);
		}
	}
	
}

这里我们还需要额外的两个类：

一个是异常类，因为我们需要自定义我们自己的一个异常，这样方便进行捕获：

1. package com.weijia.domain;  
2.   
3. public class DaoException extends RuntimeException{  
4.   
5.     private static final long serialVersionUID = 1L;  
6.       
7.     public DaoException(){  
8.           
9.     }  
10.       
11.     public DaoException(Exception e){  
12.         super(e);  
13.     }  
14.       
15.     public DaoException(String msg){  
16.         super(msg);  
17.     }  
18.       
19.     public DaoException(String msg,Exception e){  
20.         super(msg,e);  
21.     }  
22.   
23. }  

package com.weijia.domain;

public class DaoException extends RuntimeException{

	private static final long serialVersionUID = 1L;
	
	public DaoException(){
		
	}
	
	public DaoException(Exception e){
		super(e);
	}
	
	public DaoException(String msg){
		super(msg);
	}
	
	public DaoException(String msg,Exception e){
		super(msg,e);
	}

}

同时，我们这里面采用工厂模式进行实例化UserDao对象：

1. package com.weijia.domain;  
2.   
3. import java.io.FileInputStream;  
4. import java.util.Properties;  
5.   
6. public class DaoFactory {  
7.     /** 
8.      * 单例模式 
9.      */  
10.     private static UserDao userDao = null;  
11.     private static DaoFactory instance = new DaoFactory();  
12.       
13.     private DaoFactory(){  
14.         /** 
15.          * 通过读取属性文件来动态的加载Dao层类 
16.          */  
17.         Properties prop = new Properties();  
18.         try{  
19.             FileInputStream fis = new FileInputStream("src/com/weijia/domain/daoconfig.properties");  
20.             prop.load(fis);  
21.             String className = prop.getProperty("userDaoClass");  
22.             Class<?> clazz = Class.forName(className);  
23.             userDao = (UserDao)clazz.newInstance();  
24.             fis.close();  
25.         }catch(Throwable e){  
26.             throw new ExceptionInInitializerError(e);  
27.         }  
28.     }  
29.       
30.     public static DaoFactory getInstance(){  
31.         return instance;  
32.     }  
33.       
34.     public UserDao createUserDao(){  
35.         return userDao;  
36.     }  
37.   
38. }  

package com.weijia.domain;

import java.io.FileInputStream;
import java.util.Properties;

public class DaoFactory {
	/**
	 * 单例模式
	 */
	private static UserDao userDao = null;
	private static DaoFactory instance = new DaoFactory();
	
	private DaoFactory(){
		/**
		 * 通过读取属性文件来动态的加载Dao层类
		 */
		Properties prop = new Properties();
		try{
			FileInputStream fis = new FileInputStream("src/com/weijia/domain/daoconfig.properties");
			prop.load(fis);
			String className = prop.getProperty("userDaoClass");
			Class<?> clazz = Class.forName(className);
			userDao = (UserDao)clazz.newInstance();
			fis.close();
		}catch(Throwable e){
			throw new ExceptionInInitializerError(e);
		}
	}
	
	public static DaoFactory getInstance(){
		return instance;
	}
	
	public UserDao createUserDao(){
		return userDao;
	}

}

这里面是读取properties文件，然后去读取类名进行加载，这种方式是很灵活的

测试：

1. package com.weijia.domain;  
2.   
3. import java.util.Date;  
4.   
5. public class TestDemo {  
6.       
7.     public static void main(String[] args) throws Exception{  
8.         UserService userService = new UserService();  
9.         System.out.println("添加用户:");  
10.         userService.regist(new User(1,"jiangwei",new Date(System.currentTimeMillis()),300));  
11.     }  
12.   
13. }  

package com.weijia.domain;

import java.util.Date;

public class TestDemo {
	
	public static void main(String[] args) throws Exception{
		UserService userService = new UserService();
		System.out.println("添加用户:");
		userService.regist(new User(1,"jiangwei",new Date(System.currentTimeMillis()),300));
	}

}

这里我们看到其实这些操作真的很简单，就是按照那样的几个步骤来操作即可，同时我们还需要将结构进行分层，以便管理，我们这里面测试的时候，撇开了创建数据库的一个环节，至于那个环节，也是不难的，可以从网上搜索一下即可。

Statement中的sql依赖注入的问题

接着来看一下关于我们上面的例子中使用了Statement进行操作的，其实这里面是存在一个问题的，就是会有sql注入的问题，我们先来看一下这个问题：

查询学生信息：

1. /** 
2.      * 使用Statement读取数据 
3.      * @param name 
4.      * @throws SQLException 
5.      */  
6.     static void read(String name) throws SQLException{  
7.         Connection conn = null;  
8.         Statement st = null;  
9.         ResultSet rs = null;  
10.         try {  
11.             conn = JdbcUtils.getConnection();  
12.             //创建语句  
13.             st = conn.createStatement();  
14.             //执行语句(不建议使用*)  
15.             String sql = "select id,name from user where name=‘"+name+"‘";  
16.             rs = st.executeQuery(sql);  
17.             //根据列名取数据  
18.             while(rs.next()){  
19.                 System.out.println(rs.getObject("id") + "\t" + rs.getObject("name") + "\t");  
20.             }  
21.         }catch(SQLException e){  
22.             e.printStackTrace();  
23.         }catch(Exception e){  
24.             e.printStackTrace();  
25.         }finally{  
26.             JdbcUtils.free(rs, st, conn);  
27.         }  
28.     }  

/**
	 * 使用Statement读取数据
	 * @param name
	 * @throws SQLException
	 */
	static void read(String name) throws SQLException{
		Connection conn = null;
		Statement st = null;
		ResultSet rs = null;
		try {
			conn = JdbcUtils.getConnection();
			//创建语句
			st = conn.createStatement();
			//执行语句(不建议使用*)
			String sql = "select id,name from user where name=‘"+name+"‘";
			rs = st.executeQuery(sql);
			//根据列名取数据
			while(rs.next()){
				System.out.println(rs.getObject("id") + "\t" + rs.getObject("name") + "\t");
			}
		}catch(SQLException e){
			e.printStackTrace();
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			JdbcUtils.f