传智播客李勇Jdbc视频笔记.docx
《传智播客李勇Jdbc视频笔记.docx》由会员分享，可在线阅读，更多相关《传智播客李勇Jdbc视频笔记.docx（84页珍藏版）》请在冰点文库上搜索。
传智播客李勇Jdbc视频笔记
1、jdbc的理论概述：
JDBC（JavaDataBaseConnectivity,java数据库连接），由一些接口和类构成的API。
J2SE的一部分，由java.sql,javax.sql包组成
2、编写简单的jdbc的例子
3、分析jdbc程序的编写步骤和原理：
代码示例：
Java代码
1.static void test（） throws SQLException, ClassNotFoundException {
2. // 1.注册驱动
3. DriverManager.registerDriver（new com.mysql.jdbc.Driver（））;
4. System.setProperty（"jdbc.drivers", "com.mysql.jdbc.Driver"）;
5. Class.forName（"com.mysql.jdbc.Driver"）;// 推荐方式
6.
7. // 2.建立连接
8. String url = "jdbc:
mysql:
//localhost:
3306/jdbc";
9. String user = "root";
10. String password = "";
11. Connection conn = DriverManager.getConnection（url, user, password）;
12.
13. // 3.创建语句
14. Statement st = conn.createStatement（）;
15.
16. // 4.执行语句
17. ResultSet rs = st.executeQuery（"select * from user"）;
18.
19. // 5.处理结果
20. while （rs.next（）） {
21. System.out.println（rs.getObject
（1） + "\t" + rs.getObject
（2） + "\t"
22. + rs.getObject（3） + "\t" + rs.getObject（4））;
23. }
24.
25. // 6.释放资源
26. rs.close（）;
27. st.close（）;
28. conn.close（）;
29. }
staticvoidtest（）throwsSQLException,ClassNotFoundException{
//1.注册驱动
DriverManager.registerDriver（newcom.mysql.jdbc.Driver（））;
System.setProperty（"jdbc.drivers","com.mysql.jdbc.Driver"）;
Class.forName（"com.mysql.jdbc.Driver"）;//推荐方式
//2.建立连接
Stringurl="jdbc:
mysql:
//localhost:
3306/jdbc";
Stringuser="root";
Stringpassword="";
Connectionconn=DriverManager.getConnection（url,user,password）;
//3.创建语句
Statementst=conn.createStatement（）;
//4.执行语句
ResultSetrs=st.executeQuery（"select*fromuser"）;
//5.处理结果
while（rs.next（））{
System.out.println（rs.getObject
（1）+"\t"+rs.getObject
（2）+"\t"
+rs.getObject（3）+"\t"+rs.getObject（4））;
}
//6.释放资源
rs.close（）;
st.close（）;
conn.close（）;
}
注册驱动的三种方式：
Java代码
1.Class.forName（“com.mysql.jdbc.Driver”）;
2. 推荐这种方式，不会对具体的驱动类产生依赖。
3. DriverManager.registerDriver（com.mysql.jdbc.Driver）;
4. 会造成DriverManager中产生两个一样的驱动，并会对具体的驱动类产生依赖。
5. //可以注册多个驱动用冒号分隔
6. System.setProperty（“jdbc.drivers”, “driver1:
driver2”）;
7. 虽然不会对具体的驱动类产生依赖；但注册不太方便，所以很少使用。
Class.forName（“com.mysql.jdbc.Driver”）;
推荐这种方式，不会对具体的驱动类产生依赖。
DriverManager.registerDriver（com.mysql.jdbc.Driver）;
会造成DriverManager中产生两个一样的驱动，并会对具体的驱动类产生依赖。
//可以注册多个驱动用冒号分隔
System.setProperty（“jdbc.drivers”,“driver1:
driver2”）;
虽然不会对具体的驱动类产生依赖；但注册不太方便，所以很少使用。
4、jdbc代码的规范和封装：
//封装成Jdbc工具类
Java代码
1.public final class JdbcUtils {
2. private static String url = "jdbc:
mysql:
//localhost:
3306/jdbc";
3. private static String user = "root";
4. private static String password = "";
5.
6. private JdbcUtils（） {
7. }
8.
9. //用静态语句块来注册驱动，只注册一次。
10. static {
11. try {
12. Class.forName（"com.mysql.jdbc.Driver"）;
13. } catch （ClassNotFoundException e） {
14. throw new ExceptionInInitializerError（e）;
15. }
16. }
17.
18. //得到链接
19. public static Connection getConnection（） throws SQLException {
20. return DriverManager.getConnection（url, user, password）;
21. }
22.
23. //释放链接
24. public static void free（ResultSet rs, Statement st, Connection conn） {
25. try {
26. if （rs !
= null）
27. rs.close（）;
28. } catch （SQLException e） {
29. e.printStackTrace（）;
30. } finally {
31. try {
32. if （st !
= null）
33. st.close（）;
34. } catch （SQLException e） {
35. e.printStackTrace（）;
36. } finally {
37. if （conn !
= null）
38. try {
39. conn.close（）;
40. } catch （SQLException e） {
41. e.printStackTrace（）;
42. }
43. }
44. }
45. }
46. }
47.
48. //在main函数的调用封装
49. static void template（） throws Exception {
50. Connection conn = null;
51. Statement st = null;
52. ResultSet rs = null;
53. try {
54. // 2.建立连接
55. conn = JdbcUtils.getConnection（）;
56. // conn = JdbcUtilsSing.getInstance（）.getConnection（）;
57. // 3.创建语句
58. st = conn.createStatement（）;
59.
60. // 4.执行语句
61. rs = st.executeQuery（"select * from user"）;
62.
63. // 5.处理结果
64. while （rs.next（）） {
65. // 参数中的1,2,3,4是指sql中的列索引
66. System.out.println（rs.getObject
（1） + "\t" + rs.getObject
（2）
67. + "\t" + rs.getObject（3） + "\t" + rs.getObject（4））;
68. }
69. } finally {
70. JdbcUtils.free（rs, st, conn）;
71. }
72.
73. }
publicfinalclassJdbcUtils{
privatestaticStringurl="jdbc:
mysql:
//localhost:
3306/jdbc";
privatestaticStringuser="root";
privatestaticStringpassword="";
privateJdbcUtils（）{
}
//用静态语句块来注册驱动，只注册一次。
static{
try{
Class.forName（"com.mysql.jdbc.Driver"）;
}catch（ClassNotFoundExceptione）{
thrownewExceptionInInitializerError（e）;
}
}
//得到链接
publicstaticConnectiongetConnection（）throwsSQLException{
returnDriverManager.getConnection（url,user,password）;
}
//释放链接
publicstaticvoidfree（ResultSetrs,Statementst,Connectionconn）{
try{
if（rs!
=null）
rs.close（）;
}catch（SQLExceptione）{
e.printStackTrace（）;
}finally{
try{
if（st!
=null）
st.close（）;
}catch（SQLExceptione）{
e.printStackTrace（）;
}finally{
if（conn!
=null）
try{
conn.close（）;
}catch（SQLExceptione）{
e.printStackTrace（）;
}
}
}
}
}
//在main函数的调用封装
staticvoidtemplate（）throwsException{
Connectionconn=null;
Statementst=null;
ResultSetrs=null;
try{
//2.建立连接
conn=JdbcUtils.getConnection（）;
//conn=JdbcUtilsSing.getInstance（）.getConnection（）;
//3.创建语句
st=conn.createStatement（）;
//4.执行语句
rs=st.executeQuery（"select*fromuser"）;
//5.处理结果
while（rs.next（））{
//参数中的1,2,3,4是指sql中的列索引
System.out.println（rs.getObject
（1）+"\t"+rs.getObject
（2）
+"\t"+rs.getObject（3）+"\t"+rs.getObject（4））;
}
}finally{
JdbcUtils.free（rs,st,conn）;
}
}
总结：
释放ResultSet,Statement,Connection.
数据库连接（Connection）是非常稀有的资源，用完后必须马上释放，如果Connection不能及时正确的关闭将导致
系统宕机。
Connection的使用原则是尽量晚创建，尽量早的释放
5、采用单例的方式完成上面的JdbcUtils类：
首先把上面类中的static方法都改成不是静态的，然后
对外提供一个获得对象的方法：
Java代码
1.// private static JdbcUtilsSing instance = new JdbcUtilsSing（）;
2.private static JdbcUtilsSing instance = null;
3.
4.private JdbcUtilsSing（） {
5.}
6.
7.public static JdbcUtilsSing getInstance（） {
8. //延迟加载：
等要调用我这个方法的时候才new一个对象，否则在static时候创建了一个对象，
9. //有可能会用不到。
10. if （instance == null） {
11. //解决多线程访问的问题，把这个同步如果加到方法上，那么我们每次的调用都会进行同步 会影响性能 如果我们按照下面的方法
12. //将同步缩小了范围之后只是会同步一次，下一次有对象了之后instance ！
= null 同步方法就不会执行
13. //为什么要判断两次instance == null:
假设有两个线程同时访问这个方法，同时判断到第一个instance == null,然后其中一个线程会
14. //先拿到锁，我们假设没有第二个判断，那么这个时候创建完对象之后，返回对象，而第二个线程有会创建一个实例 但此时instance已经
15. //不是null了，所以我们要进行第二次的判断。
16. synchronized （JdbcUtilsSing.class） {
17. if （instance == null） {
18. instance = new JdbcUtilsSing（）;
19. }
20. }
21. }
22. return instance;
23.}
//privatestaticJdbcUtilsSinginstance=newJdbcUtilsSing（）;
privatestaticJdbcUtilsSinginstance=null;
privateJdbcUtilsSing（）{
}
publicstaticJdbcUtilsSinggetInstance（）{
//延迟加载：
等要调用我这个方法的时候才new一个对象，否则在static时候创建了一个对象，
//有可能会用不到。
if（instance==null）{
//解决多线程访问的问题，把这个同步如果加到方法上，那么我们每次的调用都会进行同步会影响性能如果我们按照下面的方法
//将同步缩小了范围之后只是会同步一次，下一次有对象了之后instance！
=null同步方法就不会执行
//为什么要判断两次instance==null:
假设有两个线程同时访问这个方法，同时判断到第一个instance==null,然后其中一个线程会
//先拿到锁，我们假设没有第二个判断，那么这个时候创建完对象之后，返回对象，而第二个线程有会创建一个实例但此时instance已经
//不是null了，所以我们要进行第二次的判断。
synchronized（JdbcUtilsSing.class）{
if（instance==null）{
instance=newJdbcUtilsSing（）;
}
}
}
returninstance;
}
6、理解sql注入：
//根据我传递的name名称来确定查询哪个字段。
Java代码
1.public void read（String name） {
2. ......
3. String sql = "select * from xxx where name = '" + name "'";
4. ......
5. ..
6. }
publicvoidread（Stringname）{
......
Stringsql="select*fromxxxwherename='"+name"'";
......
..
}
在上面这种情况下，如果我的name传值为"'or1'"那
sql=select*fromxxxwherename=''or1;因为or是数据库中的关键字，而在
数据库中1其实表示true，所以会把所有的数据都会给查询上来。
这叫做sqlInjection（sql注入）
7、PerparedStatement的应用：
在上面的例子中，我们看到了在构造sql语句的时候使用拼串的方式会有sql注入的问题，这个时候我们可以用
PreparedStatement来解决这个问题
Java代码
1.public void read（String name） {
2. ......
3. PreparedStatement ps = null;
4. String sql = "select * from xxx where name = ?
";
5. ps = conn.prepareStatement（sql）;
6. ps.setString（1, name）;
7. rs = ps.executeQuery（）;
8. ..
升级会员 