JDBC,事务管理，数据库连接池(C3P0、Druid),Spring Template

最新推荐文章于 2022-09-12 16:01:04 发布

小人物大Dream

最新推荐文章于 2022-09-12 16:01:04 发布

阅读量203

点赞数

分类专栏： Java语言学习文章标签：数据库 spring java

本文链接：https://blog.csdn.net/weixin_45762767/article/details/126608457

版权

Java语言学习专栏收录该内容

17 篇文章 0 订阅

订阅专栏

JDBC概念

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

使用JDBC的好处：
1）程序员如果要开发访问数据库的程序,只需要会调用JDBC接口中的方法即可，不用关注类是怎么实现的。
2）使用同一套Java代码，进行少量的修改就可以访问其他JDBC支持的数据库。
在这里插入图片描述
JDBC快速入门：
1）导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
1.复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下
2.右键–>Add As Library
2）注册驱动
3）获取数据库连接对象 Connection
4）定义sql
5）获取执行sql语句的对象 Statement
6）执行sql，接受返回结果
7）处理结果
8）释放资源

    public static void main(String[] args) throws Exception {
        //1.导入驱动jar包
        //2.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //3.获取数据库连接对象
       // Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/seckill", "root", "123456");
        Connection conn = DriverManager.getConnection("jdbc:mysql:///seckill", "root", "123456");
        //4.定义sql语句
        String sql ="update account set name = 'zeng01' where id = 1";
        //5.获取执行sql的对象 Statement
        Statement statement = conn.createStatement();
        //6.执行sql语句
        int i = statement.executeUpdate(sql);
        //7.处理结果
        System.out.println(i>0?true:false);
        //8.释放资源
        statement.close();
        conn.close();

    }

1. DriverManager：驱动管理对象

1）管理和注册驱动
2）创建数据库的连接
注册与给定的驱动程序 DriverManager

static void registerDriver(Driver driver)

通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块

 static {
				        try {
				            java.sql.DriverManager.registerDriver(new Driver());
				        } catch (SQLException E) {
				            throw new RuntimeException("Can't register driver!");
				        }
					}

注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。

2. 获取数据库连接：

方法：static Connection getConnection(String url, String user, String password)
参数：
url：指定连接的路径
语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
例子：jdbc:mysql://localhost:3306/db3
细节：如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称
user：用户名
password：密码

3.Connection：数据库连接对象

获取执行sql 的对象
Statement createStatement()
PreparedStatement prepareStatement(String sql) 推荐使用这个对象
管理事务：
1）开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
2）提交事务：commit()
3）回滚事务：rollback()

4.Statement：执行sql的对象

执行sql
boolean execute(String sql) ：可以执行任意的sql 了解
int executeUpdate(String sql) ：执行DML（insert、update、delete）语句、DDL(create，alter、drop)语句
ResultSet executeQuery(String sql) ：执行DQL（select)语句

public static void main(String[] args) {
        Statement statement=null;
        Connection conn=null;
        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.定义sql
            String sql ="insert into account values(null,'曾石头',50000)";
            //3.获取Connection对象
            conn = DriverManager.getConnection("jdbc:mysql:///seckill", "root", "123456");
            //4.获取执行sql的对象Statement
            statement = conn.createStatement();
            //5.执行sql
            int i = statement.executeUpdate(sql);
            if (i>0){
                System.out.println("执行成功!");
            }else {
                System.out.println("执行失败！");
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }finally {
            //为了避免空指针异常
            if (statement!=null){
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }

    }

ResultSet：结果集对象,封装查询结果

public static void main(String[] args) {
        Statement statement=null;
        Connection conn=null;
        ResultSet resultSet=null;
        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.定义sql
            String sql ="select * from account";
            //3.获取Connection对象
            conn = DriverManager.getConnection("jdbc:mysql:///seckill", "root", "123456");
            //4.获取执行sql的对象Statement
            statement = conn.createStatement();
            //5.执行sql
            resultSet = statement.executeQuery(sql);
            //让游标向下移动一行 第一行是表头
           // resultSet.next();
            //获取数据   getInt 数据库单元格的第一行的第一个 从1开始计算
           // int i = resultSet.getInt(1);//主键
           // String name = resultSet.getString("name");
           // System.out.println("名字"+name);
            //使用循环遍历
            while (resultSet.next()){
                int i = resultSet.getInt(1);//主键
                String name = resultSet.getString("name");
                System.out.println("名字"+name);
            }

        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }finally {
            //为了避免空指针异常
            if (resultSet!=null){
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (statement!=null){
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }

    }

PreparedStatement：执行sql的对象

public static void main(String[] args) {
        PreparedStatement preparedStatement=null;
        Connection conn=null;
        ResultSet resultSet=null;
        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.定义sql
            String sql ="select * from account where username = ? and password = ?";
            //3.获取Connection对象
            conn = DriverManager.getConnection("jdbc:mysql:///seckill", "root", "123456");
            //4.获取执行sql的对象Statement   prepareStatement
            preparedStatement = conn.prepareStatement(sql);
            //防止sql注入 1表示第一个占位符
            preparedStatement.setString(1,"username");
            preparedStatement.setString(2,"password");
            //5.执行sql
            resultSet = preparedStatement.executeQuery();
            //推荐使用PreparedStatement对象，效率更高，更安全

        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }finally {
            //为了避免空指针异常
            if (resultSet!=null){
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (preparedStatement!=null){
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }

    }

注意：
1）后期都会使用PreparedStatement来完成增删改查的所有操作
2）可以防止SQL注入
3）效率更高

JDBC控制事务

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

使用Connection对象来管理事务

开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
注意：在执行sql之前开启事务
提交事务：commit()
注意：当所有sql都执行完提交事务
回滚事务：rollback()
注意：在catch中回滚事务

 public static void main(String[] args) {
        PreparedStatement preparedStatement_1=null;
        PreparedStatement preparedStatement_2=null;
        Connection conn=null;
        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.定义sql
            String sql_1 ="update account set balance = balance - ? where id =?";
            String sql_2 ="update account set balance = balance + ? where id =?";
            //3.获取Connection对象 获取数据库连接
            conn = DriverManager.getConnection("jdbc:mysql:///seckill", "root", "123456");

            //开启事务  false开启事务
            conn.setAutoCommit(false);

            //4.获取执行sql的对象Statement   prepareStatement
            preparedStatement_1 = conn.prepareStatement(sql_1);
            preparedStatement_2 = conn.prepareStatement(sql_2);
            //防止sql注入 1表示第一个占位符
            //设置参数
            preparedStatement_1.setDouble(1,500);
            preparedStatement_1.setDouble(2,1);

            preparedStatement_2.setDouble(1,500);
            preparedStatement_2.setDouble(2,2);
            //执行
            preparedStatement_1.executeUpdate();

            //制造一个异常
            int i = 0/8;

            preparedStatement_2.executeUpdate();

            //提交事务
            conn.commit();

        } catch (ClassNotFoundException | SQLException e) {

            if (conn!=null){
                try {
                    //出现了异常，回滚
                    conn.rollback();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }

            e.printStackTrace();
        }finally {
            //为了避免空指针异常
            if (preparedStatement_1!=null){
                try {
                    preparedStatement_1.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (preparedStatement_2!=null){
                try {
                    preparedStatement_2.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }

    }

数据库连接池

概念：其实就是一个容器(集合)，存放数据库连接的容器。
当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。
好处：
1. 节约资源
2. 用户访问高效
实现：
标准接口：DataSource javax.sql包下的
方法：
获取连接：getConnection()
归还连接：Connection.close()。如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接
一般我们不去实现它，有数据库厂商来实现
1. C3P0：数据库连接池技术
2. Druid：数据库连接池实现技术，由阿里巴巴提供的

C3P0：数据库连接池技术

快速使用：
1）导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar （不要忘记导入数据库驱动jar包）
2）定义配置文件：
1.名称： c3p0.properties 或者 c3p0-config.xml
2.路径：直接将文件放在src目录下即可。
3）创建核心对象数据库连接池对象 ComboPooledDataSource
4）获取连接： getConnection

 //1.创建数据库连接池对象
        DataSource ds  = new ComboPooledDataSource();
        //2. 获取连接对象
        Connection conn = ds.getConnection();

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

步骤：
1）导入jar包 druid-1.0.9.jar
2）定义配置文件：
是properties形式的
可以叫任意名称，可以放在任意目录下
3）加载配置文件。Properties
4）获取数据库连接池对象：通过工厂来来获取 DruidDataSourceFactory
5）获取连接：getConnection

        //加载配置文件
        Properties pro = new Properties();
        InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);
        //获取连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        //获取连接
        Connection conn = ds.getConnection();

SpringJDBC

Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
步骤：
1）导入jar包
2）创建JdbcTemplate对象。依赖于数据源DataSource

//ds数据源
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：查询结果，将结果封装为对象（一般用于聚合函数的查询）

          //1. 获取JDBCTemplate对象
			    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
			    /**
			     * 1. 修改1号数据的 salary 为 10000
			     */
			    @Test
			    public void test1(){
			
			        //2. 定义sql
			        String sql = "update emp set salary = 10000 where id = 1001";
			        //3. 执行sql
			        int count = template.update(sql);
			        System.out.println(count);
			    }
			    /**
			     * 2. 添加一条记录
			     */
			    @Test
			    public void test2(){
			        String sql = "insert into emp(id,ename,dept_id) values(?,?,?)";
			        int count = template.update(sql, 1015, "郭靖", 10);
			        System.out.println(count);
			
			    }
			    /**
			     * 3.删除刚才添加的记录
			     */
			    @Test
			    public void test3(){
			        String sql = "delete from emp where id = ?";
			        int count = template.update(sql, 1015);
			        System.out.println(count);
			    }
			    /**
			     * 4.查询id为1001的记录，将其封装为Map集合
			     * 注意：这个方法查询的结果集长度只能是1
			     */
			    @Test
			    public void test4(){
			        String sql = "select * from emp where id = ? or id = ?";
			        Map<String, Object> map = template.queryForMap(sql, 1001,1002);
			        System.out.println(map);
			        //{id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20}
			
			    }
			    /**
			     * 5. 查询所有记录，将其封装为List
			     */
			    @Test
			    public void test5(){
			        String sql = "select * from emp";
			        List<Map<String, Object>> list = template.queryForList(sql);
			
			        for (Map<String, Object> stringObjectMap : list) {
			            System.out.println(stringObjectMap);
			        }
			    }
			    /**
			     * 6. 查询所有记录，将其封装为Emp对象的List集合
			     */
			
			    @Test
			    public void test6(){
			        String sql = "select * from emp";
			        List<Emp> list = template.query(sql, new RowMapper<Emp>() {
			            @Override
			            public Emp mapRow(ResultSet rs, int i) throws SQLException {
			                Emp emp = new Emp();
			                int id = rs.getInt("id");
			                String ename = rs.getString("ename");
			                int job_id = rs.getInt("job_id");
			                int mgr = rs.getInt("mgr");
			                Date joindate = rs.getDate("joindate");
			                double salary = rs.getDouble("salary");
			                double bonus = rs.getDouble("bonus");
			                int dept_id = rs.getInt("dept_id");
			                emp.setId(id);
			                emp.setEname(ename);
			                emp.setJob_id(job_id);
			                emp.setMgr(mgr);
			                emp.setJoindate(joindate);
			                emp.setSalary(salary);
			                emp.setBonus(bonus);
			                emp.setDept_id(dept_id);
			                return emp;
			            }
			        });
			        		for (Emp emp : list) {
			            System.out.println(emp);
			        }
			    }
			    
          /**
			     * 6. 查询所有记录，将其封装为Emp对象的List集合
			     */
			    @Test
			    public void test6_2(){
			        String sql = "select * from emp";
			        List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
			        for (Emp emp : list) {
			            System.out.println(emp);
			        }
			    }
			     /**
			     * 7. 查询总记录数
			     */
			    @Test
			    public void test7(){
			        String sql = "select count(id) from emp";
			        Long total = template.queryForObject(sql, Long.class);
			        System.out.println(total);
			    }
			}