JavaSE基础复习巩固

第十一天：JDBC 连接池

1.JDBC（JAVA DATA BASE Connection）：Java数据库连接

为什么会有JDBC的存在？是一种规范标准

1. 概念：Java DataBase Connectivity  Java 数据库连接， Java语言操作数据库

JDBC本质：其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。

以前在DOS窗口可视化工具操作数据库，现在想用JAVA程序去操作数据库。

2.使用JDBC操作数据库步骤：

1.导入依赖Jar包

2.注册驱动

Class.forName("com.mysql.jdbc.Driver")

3.获取数据库连接对象

DriverManager.getConnection()

4.通过数据连接对象获取执行sql语句的对象--获取sql语句执行平台

connection.createStatemen()

5.定义sql语句

String sql=" sql语句";

6.执行sql语句

statement.execute(sql);

7.释放连接资源

con.close();

statement.close()

例子：

  //使用JDBC操作数据库步骤
        /*
        * 1.导入JDBC的相关Jar包（添加依赖关系）
        * 2.加载驱动（注册驱动）因为操作数据库的具体实现类是Driver类，目的是把Driver类加载进内存，加载字节码文件加载进内存
        * 3.建立连接(获取操作数据库的连接对象)----DriverManager 通过DriverManager.getConnection()
        * 4.通过数据库连接对象获取能够操作数据库的对象（获取能够执行sql语句的对象）--获取执行sql语句平台
        * 5.定义sql语句
        * 6。执行sql语句
        * 7.释放资源
        * */
//        1.导入JDBC的相关Jar包（添加依赖关系）
//        2.（注册驱动）
        Class.forName("com.mysql.jdbc.Driver");
//        3.建立连接(获取操作数据库的连接对象)----DriverManager 通过DriverManager.getConnection()
        Connection con = DriverManager.getConnection("Jdbc:mysql://localhost:3306/db5", "root", "root");
        //4.通过数据库连接对象获取能够操作数据库的对象（获取能够执行sql语句的对象）--获取执行sql语句平台
        Statement statement = con.createStatement();
//        5.定义sql语句
//           添加一条数据
        String sql="INSERT INTO `emp1`(`id`,`NAME`) VALUES(NULL,'王五');";//双引号里面不能放双引号，可以放单引号
//        6.执行sql语句
        statement.execute(sql);

优化之后：

代码：

   ArrayList<Stu> stu = getStu();
        for (Stu stu1 : stu) {
            System.out.println(stu1);
        }
    }

    private static ArrayList<Stu> getStu() {
        //把stu对象放到ArrayList集合中去
        ArrayList<Stu> stus = new ArrayList<>();
        Connection con=null;
        Statement stat=null;
        ResultSet resultSet=null;
        try {
//            1.获取数据连接
             con = JDBCUtilDemo1.getConnection();
//            2.获取执行sql语句的平台（对象）
            stat = con.createStatement();
            //3定义sql语句
            String sql="SELECT * FROM stu1;";
            //4.执行sql语句  返回的是结果集 查询数据中的数据返回成一个结果集
        resultSet = stat.executeQuery(sql);
           //判断是否有下一个数据
//            boolean next = resultSet.next(); 当next为true时证明有下一条数据
            //得到下一个数据
            while(resultSet.next()) {
                int id = resultSet.getInt("id");//得到id字段
                String name = resultSet.getString("name");
                System.out.println(id+" "+name);
                //创建对象
                Stu stu = new Stu();
                stu.setId(id);
                stu.setName(name);
                //把对象添加到集合中去
                stus.add(stu);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtilDemo1.close(con,stat,resultSet);
        }
        return stus;
    }

JDBC的工具类：

代码：

public class JDBCUtilDemo1 {
    //提供一个获取连接对象的方法
    public static Connection getConnection() throws Exception {
        Class.forName("com.mysql.jdbc.Driver");
        Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
        return con;
    }

    //关闭资源---有结果集（查询）
    public static  void close(Connection con, Statement stat, ResultSet res) {
        //释放资源
        if(con!=null){
            try {
                con.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if(stat!=null) {
            try {
                stat.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if(res!=null){
            try {
                res.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }
    //关闭资源---没有结果集（增删改）
    public static void close(Connection con, Statement stat) {
        //释放资源
        if (con != null) {
            try {
                con.close();
                con=null;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (stat != null) {
            try {
                stat.close();
                stat=null;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

结合实体类使用JDBC：

代码：

   public static void main(String[] args) {
        ArrayList<Student> student = getStudent();
        //遍历集合
        for (Student student1 : student) {
            System.out.println(student);
        }
    }

    private static ArrayList<Student> getStudent() {
        ArrayList<Student> students = new ArrayList<>();
        try {
            Connection con = JDBCUtilDemo1.getConnection();
            Statement stat = con.createStatement();
            String sql="SELECT * FROM student WHERE NAME LIKE'%三%';";
            ResultSet resultSet = stat.executeQuery(sql);
            while (resultSet.next()){
                //得到数据表中的每一个字段
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                int age = resultSet.getInt("age");
                int math = resultSet.getInt("math");
                int english = resultSet.getInt("english");
                Student student = new Student();
                student.setId(id);
                student.setName(name);
                student.setAge(age);
                student.setMath(math);
                student.setEnglish(english);
                //把对象添加到集合中去
                students.add(student);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return students;
    }

细节:

static:静态的 被这个关键字修饰的会随着类的加载而加载

sql注入产生原因:

因为sql语句中存在字符串的拼接，只要给予特定的sql语句，会导致用户名与密码失效，这样的问题我们称之为sql注入

如何解决这个问题？

不使用字符串拼接，而是使用占位符 ？ 进行赋值

占位符----占用位置

PreparedStatement：执行sql的对象

1. SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题

1. 输入用户随便，输入密码：a' or 'a' = 'a

2. sql：select * from user where username = 'fhdsjkf' and password = 'a' or 'a' = 'a'

2. 解决sql注入问题：使用PreparedStatement对象来解决

3. 预编译的SQL：参数使用?作为占位符

4. 步骤：

1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar

2. 注册驱动

3. 获取数据库连接对象 Connection

4. 定义sql

代码如下：

public static void main(String[] args)  {

         /*提供一个用户表  user
         * 登录案列
         *     键盘录入用户名与密码与数据中已存在的用户名与密码进行校验
         *     如果输入的用户名与密码存在，提示“登录成功”
         *     否则 提示  “登录失败”
         *
         * */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入 用户名:");
        String username=sc.nextLine();
        System.out.println("请输入密码:");
        String password=sc.nextLine();

        boolean flag = login(username, password);
             if(flag)
                 System.out.println("登录成功");
             else
                 System.out.println("登录失败");

    }

    /**
     * 登录验证的方法

     * @return
     */
    public  static   boolean  login(String username,String password){

        try {
            //获取数据库连接对象
            Connection con = JDBCUtil.getConnection();

               //获取执行sql语句对象
//            Statement stat = con.createStatement();
            //定义sql语句
//            String sql="select * from user where username='"+username+"' and password='"+password+"'";
            /*sql注入产生原因:
            *   因为sql语句中存在字符串的拼接，只要给予特定的sql语句，会导致用户名与密码失效，这样的问题我们称之为sql注入
            *   如何解决这个问题？
            *      不使用字符串拼接，而是使用占位符 ？  进行赋值
            *          占位符----占用位置
            * */
//            String sql="select * from user where username='"+username+"' and password='88' or '1'='1'";
            String sql="select * from user where username=? and password=? ";
            System.out.println(2);
            //获取预编译对象  ---预编译sql语句，并对占位符进行赋值
            // 预编译---把sql语句执行一次，让sql不能再随意更改（防止字符串拼接）
            PreparedStatement pst =con.prepareStatement(sql);
            System.out.println(1);
            //给占位符赋值
              pst.setString(1,username);
              pst.setString(2,password);
            System.out.println(3);
               //再次真正执行sql
            ResultSet resultSet = pst.executeQuery();
            //执行sql语句
//            ResultSet resultSet = stat.executeQuery(sql);
               //进行判断 如果存在下一个元素，证明我们输入的用户名与密码与数据库中用户名和密码匹配
            //  resultSet.next()的返回值是boolean,如果  resultSet.next()结果为true,
            // 代表存在下一个元素，意味着我们输入的用户名与密码与数据库中用户名和密码匹配
            if(resultSet.next()){
                return true;
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

JDBC控制事务：

1. 事务：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。

2. 操作：

1. 开启事务

2. 提交事务

3. 回滚事务

3. 使用Connection对象来管理事务

* 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务

* 在执行sql之前开启事务

* 提交事务：commit()

* 当所有sql都执行完提交事务

* 回滚事务：rollback()

* 在catch中回滚事务

2.连接池：是一个容器，用来存放数据库连接的容器

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

为什么要学连接池？

连接池的好处（作用）是？

1. 节约资源

2. 用户访问高效（提高用户访问效率）

常见的连接池有：c3p0 Druid dbcp

实现：

1. 标准接口：DataSource   javax.sql包下的

1. 方法：

* 获取连接：getConnection()

* 归还连接：Connection.close()。如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接

2. 一般我们不去实现它，有数据库厂商来实现

1. C3P0：数据库连接池技术

2. Druid：数据库连接池实现技术，由阿里巴巴提供的

c3p0的使用：

1.导入依赖Jar包

2.导入配置文件（建议放在src下面）

3.创建连接对象（DateSource）

C3P0：数据库连接池技术

* 步骤：

1. 导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar ，

* 不要忘记导入数据库驱动jar包

2. 定义配置文件：

* 名称： c3p0.properties 或者 c3p0-config.xml

* 路径：直接将文件放在src目录下即可。

3. 创建核心对象 数据库连接池对象 ComboPooledDataSource

4. 获取连接： getConnection

* 代码：

 //1.创建数据库连接池对象

        DataSource ds  = new ComboPooledDataSource();

        //2. 获取连接对象

        Connection conn = ds.getConnection();

例子：

 /*使用c3p0连接池操作数据库的步骤:
        *    1.要导入连接池jar包
        *      注意:使用连接池技术操作数据库也需要jdbc的jar
        *    2.导入配置文件
        *       配置文件要放在src下面（会自动加载配置文件中的内容）
        *
        *    3.创建连接池对象
        *       DateSource(接口)----ComboPooledDataSource
        *
        *    4.获取连接对象
        *
        * */
        //默认使用配置文件中的   <default-config>
        DataSource  ds=new ComboPooledDataSource();
        //获取连接对象
        Connection con = ds.getConnection();
        //操作数据库
        //定义sql语句
        String sql="select * from account where id=? or id=?";
        PreparedStatement pst = con.prepareStatement(sql);
               pst.setInt(1,1);
               pst.setInt(2,2);
        ResultSet res = pst.executeQuery();
             //遍历结果集
          while(res.next()){
              int id = res.getInt("id");
              String name = res.getString("name");
              double balance = res.getDouble("balance");
              System.out.println(id+"\t"+name+"\t"+balance);
          }

 Druid：数据库连接池实现技术，由阿里巴巴提供的

1. 步骤：

1. 导入jar包

2. 定义配置文件：

* 是properties形式的

* 可以叫任意名称，可以放在任意目录下

3. 加载配置文件。Properties

4. 获取数据库连接池对象：通过工厂来来获取  DruidDataSourceFactory

5. 获取连接：getConnection

例子：

/*使用Druid连接池操作数据库步骤
             1.导入jar包
             2.导入配置文件（可以放在项目的任意位置，但是建议放在src下面）
             3.创建连接池对象
               使用DataSource的工厂类   DruidDataSourceFactory
                   调用createDataSource创建连接池对象

               4.获取连接对象
        *
        *
        * */
        //创建流对象
      /*  InputStream  is=new FileInputStream
                ("druid.properties");*/
        InputStream is = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");

        //创建Properties对象
        Properties  pt=new Properties();
        //加载配置文件
        pt.load(is);
//        3.创建连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pt);
//        4.获取连接对象
        Connection con = ds.getConnection();
        System.out.println(con);

        //执行sql语句


    }

Spring JDBC

* Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发

* 步骤：

1. 导入jar包

2. 创建JdbcTemplate对象。依赖于数据源DataSource

* JdbcTemplate template = new JdbcTemplate(ds);

3. 调用JdbcTemplate的方法来完成CRUD的操作

* update():执行DML语句。增、删、改语句

* queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合

* 注意：这个方法查询的结果集长度只能是1

* queryForList():查询结果将结果集封装为list集合

* 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中

* query():查询结果，将结果封装为JavaBean对象

* query的参数：RowMapper

* 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装

* new BeanPropertyRowMapper<类型>(类型.class)

* queryForObject：查询结果，将结果封装为对象

* 一般用于聚合函数的查询

代码：

public static void main(String[] args) {
        /*JDBCTemplate：
        *    Spring对jdbc的一个封装，Spring为操作JDBC提供的一个小的框架
        *    目的:简化执行sql语句的代码书写。
        *    框架是什么？相当于一个半成品软件。
        *         Spring1框架----用来做数据库的添加操作---小的软件
        *         对数据库做 具体的添加操作时，基于 前面已经封装好的一个小的软件进行二次开发。
        *         使用JDBCTemplate的步骤:
        *               1.导入jar包。
        *               2.创建JDBCTemplate对象  ，依赖于连接池
        *           JDBCTemplate提供了很多方法，用来简化执行sql语句的书写
        *           update()----执行增删改语句
        *           Query()---将查询的结果封装成实体类（JAVABean）对象
        *           QueryForMap()---将查询的结果封装成map集合（只能查询一条数据）
        *           QueryForList()---将查询的结果封装成list集合（查询一条数据或多条数据）
        *           QueryForObject()----一般用于聚合函数的查询
        * */
        //先要获取连接池对象
        DataSource ds = DruidUtil.getDs();
//        2.创建JDBCTemplate对象  ，依赖于连接池

        JdbcTemplate jdbcTemplate = new JdbcTemplate(ds);
        String sql="insert into account values(?,?,?)";
        //  操作sql语句
        jdbcTemplate.update(sql,3,"老王",9000);

        //使用JDBCTemplate 往account 表中添加一条数据

    }

今日学习感受：学习java的路上虽然很长，但是累并快乐着，学习的东西虽然很多，但是大部分只要自己认真去学，还是可以学好的，希望自己继续坚持下去。最后一句话：生于忧患，死于安乐.