乐趣区

关于java:JDBC编程一一jdbc原理和基础编程

JDBC

WHAT IS JDBC

Java Database Connectivity:Java 拜访数据库的解决方案。
JDBC 是 Java 应用程序拜访数据库的里程碑式解决方案。Java 研发者心愿用雷同的形式拜访不同的数据库,以实现与具体数据库无关的 Java 操作界面。
JDBC 定义了一套标准接口,即拜访数据库的通用 API,不同的数据库厂商依据各自数据库的特点去实现这些接口。

JDBC 接口及数据库厂商实现

JDBC 中定义了一些接口:
1、驱动治理:
DriverManager
2、连贯接口
Connection
DatabasemetaData
3、语句对象接口
Statement
PreparedStatement
CallableStatement
4、后果集接口
ResultSet
ResultSetMetaData

JDBC 工作原理

JDBC 只定义接口,具体实现由各个数据库厂商负责。
程序员应用时只须要调用接口,理论调用的是底层数据库厂商的实现局部。

JDBC 拜访数据库的工作过程:
加载驱动,建设连贯
创立语句对象
执行 SQL 语句
处理结果集
敞开连贯

Driver 接口及驱动类加载

要应用 JDBC 接口,须要先将对应数据库的实现局部(驱动)加载进来。
驱动类加载形式(Oracle):

Class.forName("oracle.jdbc.driver.OracleDriver");

这条语句的含意是:装载驱动类,驱动类通过 static 块实现在 DriverManager 中的“主动注册”。

Connection 接口

Connection 接口负责应用程序对数据库的连贯,在加载驱动之后,应用 url、username、password 三个参数,创立到具体数据库的连贯。

Class.forName("oracle.jdbc.OracleDriver")
// 依据 url 连贯参数,找到与之匹配的 Driver 对象,调用其办法获取连贯
Connection conn = DriverManager.getConnection(
"jdbc:oracle:thin:@192.168.0.26:1521:tarena",
"openlab","open123");

须要留神的是:Connection 只是接口,真正的实现是由数据库厂商提供的驱动包实现的。

Statement 接口

Statement 接口用来解决发送到数据库的 SQL 语句对象,通过 Connection 对象创立。次要有三个罕用办法:

Statement stmt=conn.createStatement();
//1.execute 办法,如果执行的 sql 是查问语句且有后果集则返回 true,如果是非查问语句或者没有后果集,返回 false
boolean flag = stmt.execute(sql);
//2. 执行查问语句,返回后果集
ResultSetrs = stmt.executeQuery(sql);
//3. 执行 DML 语句,返回影响的记录数
int flag = stmt.executeUpdate(sql);

ResultSet 接口

执行查问 SQL 语句后返回的后果集,由 ResultSet 接口接管。
罕用解决形式:遍历 / 判断是否有后果(登录)。

String sql = "select * from emp";
ResultSetrs = stmt.executeQuery(sql);
while (rs.next()) {System.out.println(rs.getInt("empno")+",“+rs.getString("ename") );
}

查问的后果寄存在 ResultSet 对象的一系列行中,指针的最后地位在行首,应用 next()办法用来在行间挪动,getXXX()办法用来获得字段的内容。

处理结果集 ResultSet

ResultSet 代表 DQL 查问后果, 是 2 维后果. 其外部保护了一个读取数据的游标, 默认状况在, 游标在第一行数据之前, 当调用 next() 办法时候, 游标会向下挪动, 并将返回后果集中是否蕴含数据, 如果蕴含数据就返回 true. 后果集还提供了很好 getXXX 办法用于获取后果集游标指向以后行数据.

原理:

案例:

/**
 * 执行 DQL 语句 
 */
public class Demo03 {public static void main(String[] args) 
        throws Exception{
        // 注册驱动
        String driver="oracle.jdbc.OracleDriver";;
        Class.forName(driver);
        // 连贯数据库
        String url="jdbc:oracle:thin:@192.168.201.227:1521:orcl";
        String user="openlab";
        String pwd="open123";
        Connection conn=DriverManager.getConnection(url, user, pwd);
        // 创立 Statement
        Statement st=conn.createStatement();
        // 执行 SQL(dql)
        String sql="select id, name"
                + "from robin_demo";
        ResultSet rs=st.executeQuery(sql);
        // 处理结果 ...
        //rs 后果集中蕴含一个游标, 游标默认在后果集
        // 的第一行之前
        //rs.next(): 挪动后果集游标到下一行
        // 查看是否有数据, 如果有返回 true, 否则 false
        while(rs.next()){//getXXX(列名): 返回后果集以后行中
            // 指定列名的数据.
            int id = rs.getInt("id");
            String name=rs.getString("name");
            // 输入查问后果
            System.out.println(id+","+name);
        }
        // 敞开连贯
        conn.close();}
}

应用 Properties 读取配置文件

Properties 是 Java 中专门用于读取配置文件的 API.

  1. 其底层就是文本文件 IO
  2. Properties 自身 实现 Map 接口, 外部是散列表
  3. Properties 限定了 key 和 Value 都是 String 类型.

Properties 罕用 API 办法:

  • load(流) 读取一个配置文件
  • String getProperty(key) 读取一个属性值

应用步骤:

  1. 创立 Properties 对象
  2. 利用 load 办法读取配置文件
  3. 利用 getProperty 查问属性文件的内容

案例, 读取配置文件:

在 resource 文件夹中增加配置文件 db.properties:

# db.properties
jdbc.driver=oracle.jdbc.OracleDriver
jdbc.url=jdbc:oracle:thin:@192.168.201.227:1521:orcl
jdbc.username=openlab
jdbc.password=open123

应用 Properties 读取配置文件内容:

public class Demo05 {public static void main(String[] args)
        throws IOException{
        // Properties 就是为了读取
        // *.properties 文件而设计的 API
        // 其底层就是文本文件 IO
        // Properties 自身 实现 Map 接口
        // 外部是散列表, 限定了 key 和 Value 都是
        // String 类型.

        // 办法: load(流) 将文件就读取为散列表
        //String getProperty(key) 查问 value

        // 应用步骤
        //1 创立 Properties 对象
        Properties cfg = new Properties();
        System.out.println(cfg);
        System.out.println(cfg.size());
        System.out.println(cfg.isEmpty());
        //2\. 利用 load 办法读取文件
        InputStream in=
            Demo05.class.getClassLoader()
            .getResourceAsStream("db.properties");
        // 执行当前, 将文件内容读取到散列表中了
        cfg.load(in); 
        System.out.println(cfg);
        System.out.println(cfg.size());

        //3\. 查找文件内容, 就是读取文件内容
        String s=
            cfg.getProperty("jdbc.driver");
        System.out.println(s); 
    }
}

利用配置文件能够将程序中的参数保留到配置文件中, 批改程序参数只须要批改配置文件即可.

治理数据库连贯

在软件中数据库连贯应用十分频繁, 如果每次都创立连贯, 就会造成代码的大量冗余, 惯例的做法是建设数据库连贯工具类, 封装数据库连贯过程, 对立数据库连贯过程, 应用时候就能够简化代码.

实现步骤:

  1. 创立数据库连贯参数文件 db.properties
  2. 创立 DbUtils.java 封装数据库连贯办法

    • 利用 Properties 读取配置文件夹中的数据库连贯参数
    • 创立办法 getConnection 封装数据库连贯过程
  3. 应用 getConnection 办法

创立配置文件 db.properties

# db.properties
jdbc.driver=oracle.jdbc.OracleDriver
jdbc.url=jdbc:oracle:thin:@192.168.201.227:1521:orcl
jdbc.username=openlab
jdbc.password=open123

创立 DbUtils.java

public class DbUtils {
    static String driver;
    static String url;
    static String username;
    static String password;

    // 读取文件中的数据库连贯参数
    static{
        // 初始化动态属性
        //1\. 利用 Properties 读取配置文件
        //2\. 从配置文件中查找 相应参数值
        try{Properties cfg=new Properties();
            InputStream in=
                DbUtils.class.getClassLoader()
                .getResourceAsStream("db.properties");
            cfg.load(in);
            System.out.println(cfg); 
            // 初始化 连贯参数 
            driver=cfg.getProperty("jdbc.driver");
            url=cfg.getProperty("jdbc.url");
            username=cfg.getProperty("jdbc.username");
            password=cfg.getProperty("jdbc.password");
            in.close();}catch(Exception e){e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 封装创立数据库连贯的过程
     * 简化数据库连贯
     */
    public static Connection getConnection(){
        try{Class.forName(driver);
            Connection conn=
                DriverManager.getConnection(url, username, password);
            return conn;
        }catch(Exception e){e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    //DbUtils.java
    /*
     * 敞开数据库的连贯办法, 封装简单的敞开过程
     */
    public static void close(Connection conn){if(conn!=null){
            try {conn.close();
            } catch (Exception e) {e.printStackTrace(); 
            }
        }
    }
}

阐明:

  1. driver url username password 是 4 个数据库连贯参数, 因为只须要一份, 则定义为动态变量.
  2. 动态代码块的目标是从配置文件中读取 4 个数据库连贯参数的值.
  3. getConnection 办法封装了数据库连贯过程
  4. close 办法封装了数据库连贯敞开的过程

DbUtils 的应用:

public class Demo06 {public static void main(String[] args) {
        Connection conn=null;
        try{conn=DbUtils.getConnection();
            Statement st=conn.createStatement();
            String sql="select * from robin_demo";
            ResultSet rs=st.executeQuery(sql);
            while(rs.next()){int id=rs.getInt("id");
                String name=rs.getString("name");
                System.out.println(id+","+name);
            }
            rs.close();// 开释查问后果
            st.close();// 开释语句对象}catch(Exception e){e.printStackTrace();
        }finally {DbUtils.close(conn);
        }
    }
}

显然: 应用 DbUtils 能够简化 JDBC 代码的书写.
这个代码中在 finally 中敞开数据库连贯, 其益处是牢靠敞开连贯.

最初,如果大家对这些内容感兴趣的话能够继续关注我,每天都有更新喔~
当然,须要以往的内容也能够找我浏览哦,我这里都整合起来了不便大家浏览,详情点击这里!!!

退出移动版