zoukankan      html  css  js  c++  java

  • JDBC连接数据库的步骤详解

     1 package com.tao.jdbc;
 2 
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.ResultSet;
 6 import java.sql.Statement;
 7 
 8 public class MainTest {
 9 
10     public static void main(String[] args) {
11         Connection conn=null;
12         Statement st=null;
13         ResultSet rs=null;
14         try {
15         //通过接口调用函数，使用多态，实质是调用导入的驱动重写的函数(驱动就是实现了jdbc提供的接口)
16         //这样来适应连接不同数据库的底层实现差异
17             
18         /*1.注册驱动*/
19             //com.mysql.jdbc.Driver实现了java.sql.Driver接口
20             //DriverManager.registerDriver(new com.mysql.jdbc.Driver());//lib下的mysql驱动要buildpath一下
21             //函数参数是java.sql.Driver引用指向com.mysql.jdbc.Driver对象
22             
23             //一般用这句，上面.mysql.jdbc.Driver()在加载类文件的时候注册了一遍，相当于注册了两遍
24             Class.forName("com.mysql.jdbc.Driver");
25             
26         /*2.建立连接*/
27             //getConnection()静态方法返回的是Connection对象实例，由Connection接口类型的引用接收
28             //真正的与数据库的直接的连接交互在厂商的PgConnection类中完成，该类实际实现了Connection接口
29             conn=DriverManager.getConnection("jdbc:mysql://localhost/stu_page", "root", "taotao");
30         /*3.创建statement,使用数据库一定需要这个对象*/
31             //createStatement()调用的应该是mysql重写的那个，因为它是接口中的抽象函数
32             st=conn.createStatement();
33         /*4.执行查询，得到结果集*/
34             //executeQuery()调用的应该是mysql重写的那个，因为它是接口中的抽象函数
35             String sql="select * from user";
36             rs=st.executeQuery(sql);//查询，增删改都用executeUpdate(sql);
37         /*5.遍历查询每条记录*/
38             while(rs.next()){
39                 int id=rs.getInt("id");
40                 String name=rs.getString("user");
41                 String pw=rs.getString("pw");
42                 System.out.println("id="+id+"==name="+name+"pwd="+pw);
43             }
44         } catch (Exception e) {
45             e.printStackTrace();
46         }finally{
47             JDBCUtil.release(conn, st, rs);
48         }
49 
50     }
51 
52 }
     1 package com.tao.jdbc;
 2 
 3 import java.sql.Connection;
 4 import java.sql.ResultSet;
 5 import java.sql.SQLException;
 6 import java.sql.Statement;
 7 
 8 
 9 
10 public class JDBCUtil {
11     /**
12      * 释放资源
13      * @param conn
14      * @param st
15      * @param rs
16      */
17     public static void release(Connection conn,Statement st,ResultSet rs){
18         closeRs(rs);
19         closeSt(st);
20         closeConn(conn);
21     }
22     private static void closeRs(ResultSet rs){
23         try {
24             if(rs!=null)
25                 rs.close();
26         } catch (SQLException e) {
27             e.printStackTrace();
28         }finally{
29             rs=null;
30         }
31     }
32     
33     private static void closeSt(Statement st){
34         try {
35             if(st!=null)
36                 st.close();
37         } catch (SQLException e) {
38             e.printStackTrace();
39         }finally{
40             st=null;
41         }
42     }
43     private static void closeConn(Connection conn){
44         try {
45             if(conn!=null)
46                 conn.close();
47         } catch (SQLException e) {
48             e.printStackTrace();
49         }finally{
50             conn=null;
51         }
52     }
53 
54 }

     //优化代码

     1 package com.tao.jdbc;
 2 
 3 import java.sql.Connection;
 4 import java.sql.ResultSet;
 5 import java.sql.Statement;
 6 
 7 public class MainTest {
 8 
 9     public static void main(String[] args) {
10         Connection conn=null;
11         Statement st=null;
12         ResultSet rs=null;
13         try {
14         //通过接口调用函数，使用多态，实质是调用导入的驱动重写的函数(驱动就是实现了jdbc提供的接口)
15         //这样来适应连接不同数据库的底层实现差异
16             
17         /*1.注册2.连接*/
18             conn=JDBCUtil.getConn();
19         /*3.创建statement,使用数据库一定需要这个对象*/
20             //createStatement()调用的应该是mysql重写的那个，因为它是接口中的抽象函数
21             st=conn.createStatement();
22         /*4.执行查询，得到结果集*/
23             //executeQuery()调用的应该是mysql重写的那个，因为它是接口中的抽象函数
24             String sql="select * from user";
25             rs=st.executeQuery(sql);
26         /*5.遍历查询每条记录*/
27             while(rs.next()){
28                 int id=rs.getInt("id");
29                 String name=rs.getString("user");
30                 String pw=rs.getString("pw");
31                 System.out.println("id="+id+"==name="+name+"pwd="+pw);
32             }
33         } catch (Exception e) {
34             e.printStackTrace();
35         }finally{
36             JDBCUtil.release(conn, st, rs);
37         }
38 
39     }
40 
41 }
      1 package com.tao.jdbc;
  2 
  3 import java.io.InputStream;
  4 import java.sql.Connection;
  5 import java.sql.DriverManager;
  6 import java.sql.ResultSet;
  7 import java.sql.SQLException;
  8 import java.sql.Statement;
  9 import java.util.Properties;
 10 
 11 
 12 
 13 public class JDBCUtil {
 14     static String driverClass=null;
 15     static String url=null;
 16     static String name=null;
 17     static String password=null;
 18     //使用静态代码块读入配置信息
 19     static{
 20         try {
 21             //创建一个属性配置对象
 22             Properties properties=new Properties();
 23             //properties文件要放在src下，使在bin目录下加载字节码文件的时候加载properties
 24             //使用类加载器加载资源文件
 25             InputStream is=JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");//实现获取在classpath路径下的资源文件的输入流
 26             
 27             properties.load(is);
 28             //读取属性
 29             driverClass=properties.getProperty("driverClass");
 30             url=properties.getProperty("url");
 31             name=properties.getProperty("name");
 32             password=properties.getProperty("password");
 33             
 34             
 35         } catch (Exception e) {
 36             e.printStackTrace();
 37         }
 38     }
 39     public static Connection getConn(){
 40         Connection conn=null;
 41         
 42         
 43         try {
 44             /*1.注册驱动*/
 45                 //com.mysql.jdbc.Driver实现了java.sql.Driver接口
 46                 //DriverManager.registerDriver(new com.mysql.jdbc.Driver());//lib下的mysql驱动要buildpath一下
 47                 //函数参数是java.sql.Driver引用指向com.mysql.jdbc.Driver对象
 48                 
 49                 //一般用这句，上面.mysql.jdbc.Driver()在加载类文件的时候注册了一遍，相当于注册了两遍
 50                 Class.forName(driverClass);
 51                 
 52             /*2.建立连接*/
 53                 //getConnection()静态方法返回的是Connection对象实例，由Connection接口类型的引用接收
 54                 //真正的与数据库的直接的连接交互在厂商的PgConnection类中完成，该类实际实现了Connection接口
 55                 conn=DriverManager.getConnection(url, name, password);
 56         } catch (Exception e) {
 57             // TODO Auto-generated catch block
 58             e.printStackTrace();
 59         } 
 60         return conn;
 61     }
 62     /**
 63      * 释放资源
 64      * @param conn
 65      * @param st
 66      * @param rs
 67      */
 68     public static void release(Connection conn,Statement st,ResultSet rs){
 69         closeRs(rs);
 70         closeSt(st);
 71         closeConn(conn);
 72     }
 73     private static void closeRs(ResultSet rs){
 74         try {
 75             if(rs!=null)
 76                 rs.close();
 77         } catch (SQLException e) {
 78             e.printStackTrace();
 79         }finally{
 80             rs=null;
 81         }
 82     }
 83     
 84     private static void closeSt(Statement st){
 85         try {
 86             if(st!=null)
 87                 st.close();
 88         } catch (SQLException e) {
 89             e.printStackTrace();
 90         }finally{
 91             st=null;
 92         }
 93     }
 94     private static void closeConn(Connection conn){
 95         try {
 96             if(conn!=null)
 97                 conn.close();
 98         } catch (SQLException e) {
 99             e.printStackTrace();
100         }finally{
101             conn=null;
102         }
103     }
104 
105 }

    jdbc.properities文件放在src下

    内容:

    driverClass=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost/stu_page
    name=root
    password=taotao

    //////////////////////////////////////////一个实例

    1 package com.tao.dao;
2 
3 public interface UserDao {
4     public boolean queryUserByNameAndPassword(String name,String password);
5 }
     1 package com.tao.daoImpy;
 2 
 3 import java.sql.Connection;
 4 import java.sql.PreparedStatement;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 import java.sql.Statement;
 8 
 9 import com.tao.dao.UserDao;
10 import com.tao.util.JDBCUtil;
11 
12 public class UserDaoImply implements UserDao{
13     @Override
14     public boolean queryUserByNameAndPassword(String name, String password) {
15         Connection conn=null;
16 //        Statement st=null;
17         PreparedStatement pst=null;
18         ResultSet result=null;
19         boolean flag=false;
20         try {
21             //注册连接
22             conn=JDBCUtil.getConn();
23             
24 //            //通过连接获取statement(这种方式会导致sql注入)
25 //            st=conn.createStatement();
26 //            //查找内容
27 //            String sql="select * from user where username='"+name+"' and password='"+password+"';";
28 //            result=st.executeQuery(sql);
29             String sql="select * from user where username=? and password=?;";
30             pst=conn.prepareStatement(sql);
31             pst.setString(1, name);
32             pst.setString(2, password);
33             result= pst.executeQuery();
34             if(result.next()){
35                 flag=true;
36             }
37         } catch (SQLException e) {
38             e.printStackTrace();
39         }finally{
40             JDBCUtil.release(conn, pst);//JDBCUtil.release()有实现重载，且Statement是PrepareStatament的父亲，有多态
41         }
42         return flag;
43         
44     }
45     
46     
47 
48 }
     1 package com.tao.test;
 2 
 3 import org.junit.Test;
 4 
 5 import com.tao.dao.UserDao;
 6 import com.tao.daoImpy.UserDaoImply;
 7 
 8 public class TestUser {
 9     @Test
10     public void testLogin(){
11         UserDao user=new UserDaoImply();
12 //        boolean flag=user.queryUserByNameAndPassword("小涛涛", "124 ' or '1=1");//sql注入
13         boolean flag=user.queryUserByNameAndPassword("小涛涛", "124");
14         if(flag){
15             System.out.println("登录成功");
16         }else{
17             System.out.println("登录失败");
18         }
19     }
20 
21 }

    相比较以前的Statement,PrepareStatement预先处理给定的sql语句，对其进行语法检查，在
    sql语句中使用?占位符，来代替后面传进来的变量，后面传进来的变量会被看成字符串，不会产生任何关键字

    // Java Database Connectivity，简称JDBC。
// 是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口
// 不同的数据库提供商去实现底层的访问规则

Ctrl+O
查看一个类的纲要，列出其方法和成员变量。
提示：再多按一次Ctrl+O，可以列出该类继承的方法和变量。
助记："O"--->"Outline"--->"纲要"

Ctrl+T
查看一个类的继承关系树，是自顶向下的，再多按一次Ctrl+T, 会换成自底向上的显示结构。
提示：选中一个方法名，按Ctrl+T，可以查看到有这个同名方法的父类、子类、接口。
助记："T"------->"Tree"----->"层次树"

添加单元测试，项目右键，buildpath,add libraries,jUnit,然后在测试单元上加@Test
使用时在函数上右键（或outline视图中）
单元测试绿条代表代码逻辑没问题，但结果不一定


Dao模式：Data Access Object数据访问对象
  • 相关阅读:
    poj 2584 T-Shirt Gumbo (二分匹配)
    hdu 1757 A Simple Math Problem (乘法矩阵)
    矩阵之矩阵乘法(转载)
    poj 2239 Selecting Courses (二分匹配)
    hdu 3661 Assignments (贪心)
    hdu 1348 Wall (凸包)
    poj 2060 Taxi Cab Scheme (二分匹配)
    hdu 2202 最大三角形 (凸包)
    hdu 1577 WisKey的眼神 (数学几何)
    poj 1719 Shooting Contest (二分匹配)
  • 原文地址：https://www.cnblogs.com/abtious/p/13494652.html
Copyright © 2011-2022 走看看