jdbc学习-02

3. 详解各类对象

1.Drivermanager :驱动管理对象

1. 注册驱动，告诉程序使用哪一个数据库驱动jar
2. 获取数据库连接对象

static Connection getConnection(String url, String user, String password) 
    

• 参数
  • url：连接路径
    • 语法：jdbc:mysql://ip地址:端口号/数据库名
    • 例子：jdbc:mysql://localhost:3306/stu
    • 细节：如果连接的是本机的服务器，并且端口号默认为3306，则URL=》jdbc:mysql:///数据库名
  • user：用户名
  • password：密码

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    //
    // Register ourselves with the DriverManager
    //
    static {
        try {
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }

2. Connection 对象：获取执行sql语句对象

1. Statement createStatement（）；
2. PreparedStatement  preparedStatement（String sql）;

3. Statement对象：执行sql语句

1. 执行sql

int executeUpdate(String sql)
    //执行insert update delete 语句
    返回值：影响的的行数，返回值大于0，则成功
    
    ResultSet executeQuery(String sql)
执行select 语句
    

4. ResultSet ：结果集对象，封装查询的结果

1. next（）；指向下一个光标
2. getXxx（String colunmName）;获取当前行指定列的值

5.PrepareStatement 对象

1. SQL 注入问题：在拼接字符串的时候，有一些sql的特殊关键字参与字符串拼接，会造成安全问题
   ex：SQL=select * from user where user=user(v) and password=password(v) or ‘a’=‘a’; 则会查询出所有的数据。 where条件问题

2. 解决Sql注入问题，使用PreparedStatement对象来解决。

3. 预编译sql：参数使用？ 作为占位符

4. 步骤

   1. 导入驱动jar包
   2. 注册驱动
   3. 获取数据库连接对象Connection
   4. 定义sql
      sql的参数使用？作为占位符。
   5. 获取执行sql对象PrepareStatement
   6. 给？ 赋值
   7. 执行sql，接受返回结果
   8. 处理结果
   9. 、 释放资源

4. JDBC工具类

获取src目录子目录内的资源的绝对路径 的方法

package com.chenwei.jdbc.utils;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;

public class JDBCUtils {
    private static String url;
    private static String user;
    private static String password;
    private static String driver;

    private static String path;

    private static FileReader fr=null;

    private static Connection conn;
    static{

        Properties pr=new Properties();
        path=JDBCUtils.class.getResource("jdbc.properties").getPath();// **通过类对象获取配置文件的绝对路径**
        try {

            //读取配置文件的数据
             fr=new FileReader(path);
            pr.load(fr);
            url=pr.getProperty("url");
            user=pr.getProperty("user");
            password=pr.getProperty("password");

            driver=pr.getProperty("driver");

            //注册驱动
            Class.forName(driver);


            //获取Connection对象
            conn= DriverManager.getConnection(url,user,password);


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            //释放资源
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 获取连接对象
     * @return 连接对象
     */
    public static Connection getConnection(){
        return  conn;
    }


    public  static void close(Connection conn, Statement smt){
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(smt!=null){
            try {
                smt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void close(Connection conn, Statement smt, ResultSet rs){
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(smt!=null){
            try {
                smt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

5.数据库连接池：JDBC的新连接技术

1. 概念

本质是一个容器（集合），存放数据库连接对象的容器。

当系统初始化后，容器被创建，容器中会申请一些连接对象，当用户访问数据库时，从容器中获取连接对象，访问结束，连接对象归还容器。

好处： 节约资源；访问效率高

2. 实现

1. 标准接口：DataSource，有sun公司提供，数据库驱动厂商去实现
   1. 获取连接Connection对象，getConnection
   2. Connection 对象.close();释放连接对象到连接池中
2. 数据库厂商提供
   1. C3P0
   2. Druid

3. C3P0的使用：不想用~~~

步骤

1. 导入jar包 两个，导入数据库驱动jar包
2. 定义配置文件
   1. 名称 xml
   2. 路径：直接放在src目录下即可
3. 创建核心对象 数据库连接池对象 ComboPooledDataSource
4. 获取连接：getConnection

4. DRUID 连接池

1. 步骤
   1. 导入jar 包 和数据库驱动jar包
   2. 定义配置文件 Properties 形式的放在任意目录下
   3. 加载配置文件
   4. 获取数据库连接池对象
   5. 获取连接对象 getConnection
2. 使用工具类
   1. 获取连接池方法
   2. 获取连接对象 方法

5. JDBC Template Spring框架

1. 步骤

1. 准备DruidDataSource连接池

2. 导入依赖的jar 包

3. 创建JDBCTemplate对象，传入Druid连接池

4. 调用 方法

   1. update（） 执行DML语句。增删改

   2. queryForMap（）；查询结果封装成map集合

   3. queryForList（）；结果封装为list集合

   4. query（）；结果封装为JavaBean 对象

      1. 注意：

         public static void main(String[]args){
                 JdbcTemplate jt=new JdbcTemplate(JDBCUtils.getDataSource());
         
                 String sqlQuery="select * from user";
                 List<User> query = jt.query(sqlQuery, new BeanPropertyRowMapper<User>(User.class));//
             
             //BeanPropertyRowMapper 自动封装成为对象
                 for (User user:query
                      ) {
                     System.out.println(user);
                 }
             }
         

ry, new BeanPropertyRowMapper(User.class));//

         //BeanPropertyRowMapper 自动封装成为对象
             for (User user:query
                  ) {
                 System.out.println(user);
             }
         }
     ~~~

5. queryForObject（）；结果封装为对象

 public Account findById(Integer id) {
        String sqlQuery="select * from account where id=?";


        return  jt.queryForObject(sqlQuery,new BeanPropertyRowMapper<Account>(Account.class),id);
    }