Java小农养成记第二十九天

最新推荐文章于 2022-06-30 11:55:28 发布
最新推荐文章于 2022-06-30 11:55:28 发布
阅读量99 收藏
点赞数
分类专栏： Java学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45265623/article/details/122815144
版权

java 数据库 mysql

day29

今日内容

  1. 数据库连接池
  2. Spring JDBC ：JDBC Template

数据库连接池

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

C3P0：数据库连接池技术

步骤：
	1. 导入jar包（两个）c3p0-0.9.5.2.jar  mchange-commons-java-0.2.12.jar
		* 注意：不要忘记导入数据库驱动jar包 mysql-connector-java-5.1.37-bin.jar
	2. 定义配置文件：
		* 名称：c3p0.properties或者c3p0-config.xml
		* 路径：直接将文件放在class目录下即可（class目录下就是src目录下）
	3. 创建核心对象 数据库连接池对象 ComboPooledDataSource
	4. 获取连接：getConnection

<c3p0-config>
  <!-- 使用默认的配置读取连接池对象 -->
  <default-config>
  	<!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db4</property>
    <property name="user">root</property>
    <property name="password">root</property>
    
    <!-- 连接池参数 -->
    <!-- 初始化申请的连接数量 -->
    <property name="initialPoolSize">5</property>
    <!--最大的连接数量-->
    <property name="maxPoolSize">10</property>
    <!--超时时间-->
    <property name="checkoutTimeout">3000</property>
  </default-config>

  <named-config name="otherc3p0"> 
    <!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db3</property>
    <property name="user">root</property>
    <property name="password">root</property>
    
    <!-- 连接池参数 -->
    <property name="initialPoolSize">5</property>
    <property name="maxPoolSize">8</property>
    <property name="checkoutTimeout">1000</property>
  </named-config>
</c3p0-config>

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

/*
c3p0演示
 */
public class C3P0Demo02 {
    public static void main(String[] args) throws SQLException {
       /* //1. 获取DataSource，没有参数使用默认配置default-config
        DataSource ds = new ComboPooledDataSource();
        //2. 获取连接
        for (int i = 0; i <= 10 ; i++) {
            Connection conn = ds.getConnection();
            System.out.println(i + ":" + conn);
            if (i == 5){
                conn.close();
            }
        }*/
       testNameConfig();
    }
    public static void testNameConfig() throws SQLException {
        //1. 获取DataSource,使用指定名称配置
        DataSource ds = new ComboPooledDataSource("otherc3p0");
        //2. 获取连接
        for (int i = 0; i <= 10 ; i++) {
            Connection conn = ds.getConnection();
            System.out.println(i + ":" + conn);
            if (i == 5){
                conn.close();
            }
        }
    }
}

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

步骤：
    1. 导入jar包 druid-1.0.9.jar
		* 注意：不要忘记导入数据库驱动jar包 mysql-connector-java-5.1.37-bin.jar
	2. 定义配置文件：
		* 是properties形式的
		* 可以叫任意名称，可以放在任意目录下
	3. 加载配置文件Properties
	4. 获取数据库连接池对象：通过工厂类来获取 DruidDataSourceFactory
	5. 获取连接：getConnection

# 配置文件druid.properties
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db3
username=root
password=root
# 初始化连接数量
initialSize=5
# 最大连接数量
maxActive=10
# 最大等待时间
maxWait=3000

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;

/*
Druid演示
 */
public class DruidDemo01 {
    public static void main(String[] args) throws Exception {
        //1.导入jar包
        //2.定义配置文件
        //3.加载配置文件
        Properties properties = new Properties();
        InputStream is = DruidDemo01.class.getClassLoader().getResourceAsStream("druid.properties");
        properties.load(is);
        //4.获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
        //5.获取连接
        Connection conn = dataSource.getConnection();
        System.out.println(conn);
    }
}

定义工具类

1. 定义一个类 JDBCUtils
2. 提供静态代码块加载配置文件，初始化连接池对象
3. 提供文件
	1. 获取连接方法：通过数据库连接池获取连接
	2. 释放资源
	3. 获取连接池的方法：也可以自己手动获取连接

package cn.itcast.datasource.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/*
Druid连接池的工具类
 */
public class JDBCUtils {
    //1. 定义成员变量 DataSource
    private static DataSource ds;
    static {
        try {
            //1. 加载配置文件
            Properties pro = new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            //2. 获取DataSource
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /*
    获取连接
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    /*
    释放资源
     */
    public static void close(Statement statement, Connection connection){
        if (statement != null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void close(ResultSet rs, Statement statement, Connection connection){
        if (rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (statement != null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    /*
    获取连接池方法
     */
    public static DataSource getDataSource(){
        return ds;
    }
}

import cn.itcast.datasource.utils.JDBCUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/*
使用新的工具类
 */
public class DruidDemo02 {
    public static void main(String[] args) {
        /*
        完成添加操作：给account表添加一条记录
         */
        Connection connection = null;
        PreparedStatement preparedStatement =null;
        try {
            //1.获取连接
            connection = JDBCUtils.getConnection();
            //2.定义sql
            String sql = "insert into account values(null, ?, ?)";
            //3.获取pstm对象
            preparedStatement = connection.prepareStatement(sql);
            //4.给?赋值
            preparedStatement.setString(1, "王五");
            preparedStatement.setDouble(2, 3000);
            //5.执行sql
            int count = preparedStatement.executeUpdate();
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(preparedStatement,connection);
        }
    }
}

Spring JDBC

  • Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象，简化JDBC的开发。
步骤：
1. 导入Jar包
    commons-logging-1.2.jar
    spring-beans-5.0.0.RELEASE.jar
    spring-core-5.0.0.RELEASE.jar
    spring-jdbc-5.0.0.RELEASE.jar
    spring-tx-5.0.0.RELEASE.jar
    * 注意：不要忘记导入数据库驱动jar包 mysql-connector-java-5.1.37-bin.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 class JdbcTemplateDemo01 {
    public static void main(String[] args) {
        //1. 导入Jar包
        //2. 创建JdbcTemplate对象，依赖于数据源的DataSource
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //3. 调用JdbcTemplate的方法来完成CRUD的操作
        String sql = "update account set balance = 5000 where id = ? ";
        //int 	update(String sql, Object... args)args对应着?,第一个args对应第一个?,第二个args对应第二个?
        int count = template.update(sql, 4);
        System.out.println(count);
    }
}

练习：

需求：
	1. 修改1号数据的salary为10000
	2. 添加一条记录
	3. 删除刚才添加的记录
	4. 查询id为1的记录，将其封装为Map集合
	5. 查询所有记录，将其封装为List集合
	6. 查询所有记录，将其封装为Emp对象的List集合
	7. 查询总记录数

import cn.itcast.datasource.domain.Emp;
import cn.itcast.datasource.utils.JDBCUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

public class JdbcTemplateDemo02 {
    //Junit单元测试，可以让方法独立执行
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
    /**
     * 1. 修改1001号数据的salary为10000
     */
    @Test
    public void test1(){
        String sql = "update emp set salary = 10000 where id = 1001";
        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为1的记录，将其封装为Map集合
        * 注意: 这个方法查询的结果集长度只能是1
     */
    @Test
    public void test4(){
        String sql = "select * from emp where id = ?";
        Map<String, Object> map = template.queryForMap(sql, 1001);
        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>> maps = template.queryForList(sql);
        System.out.println(maps);
    }
    /**
     * 6. 查询所有记录，将其封装为Emp对象的List集合
     */
    @Test
    public void test6(){
        String sql = "select * from emp";
        List<Emp> query = template.query(sql, new RowMapper<Emp>() {

            @Override
            public Emp mapRow(ResultSet resultSet, int i) throws SQLException {
                int id = resultSet.getInt("id");
                String ename = resultSet.getString("ename");
                int job_id = resultSet.getInt("job_id");
                int mgr = resultSet.getInt("mgr");
                Date joindate = resultSet.getDate("joindate");
                double salary = resultSet.getDouble("salary");
                double bonus = resultSet.getDouble("bonus");
                int dept_id = resultSet.getInt("dept_id");
                Emp emp = new Emp(id, ename, job_id, mgr, joindate, salary, bonus, dept_id);
                return emp;
            }
        });
        for (Emp emp : query){
            System.out.println(emp);
        }
    }
    @Test
    public void test6_1(){
        String sql = "select * from emp";
        List<Emp> query = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
        for (Emp emp : query){
            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);
    }
}
舍得..
关注
专栏目录
JDBC连接池&JDBCTemplate课堂笔记
qq_38313060的博客
08-13 2128
今日内容 1. 数据库连接池 2. Spring JDBC : JDBC Template 数据库连接池 1. 概念：其实就是一个容器(集合)，存放数据库连接的容器。 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。 2. 好处： 1. 节约资源 2. 用户访...
JDBC连接池&&JdbcTemplate
今晚打老虎的博客
09-25 417
数据库连接池 概念：其实就是一个容器(集合)，存放数据库连接的容器。 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。 好处： 节约资源 用户访问高效 实现： 标准接口：DataSource javax.sql包下的 方法： 获取连接：getConnection() 归还连接：Conne...
day30_JDBC连接池&JDBCTemplate
IT学院
03-27 173
今日内容 1. 数据库连接池 ​ 2. Spring JDBC : JDBC Template 数据库连接池 1. 概念：其实就是一个容器(集合)，存放数据库连接的容器。 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。 ​ 2. 好处： 1. 节约资源 2. 用户...
JdbcTemplate造成数据库连接数过多
Neviller_Ma的博客
06-30 1197
JdbcTemplate造成数据库连接数过多
Jdbc,数据库连接池,jdbcTemplate
qq_43144059的博客
05-31 180
Jdbc,数据库连接池,jdbcTemplate jdbc 思维导图 代码 public static void main(String[] args) throws ClassNotFoundException, SQLException { //1.注册驱动 Class.forName("com.mysql.jdbc.Driver"); //2.获取数据库连接对象 Connection con=DriverManager.getConnection("
小农signcode算法测试源码
11-03
【小农Signcode算法测试源码详解】 小农Signcode算法是一种用于软件签名的技术，它旨在确保代码的完整性和来源的可信性。在Windows平台上，软件签名是验证可执行文件和驱动程序的重要手段，可以防止恶意软件篡改并...
小农sign code算法源码分享，欢迎一起学习交流
11-04
【小农Sign Code算法源码解析】 在信息技术领域，Sign Code通常是指用于软件签名的一类算法，它确保了代码的完整性和来源的可信性。在本文中，我们将深入探讨小农Sign Code算法，这是一种用于软件安全性的特定实现...
水利工程竣工验收书(含决算表)(小农水)_工程竣工验收报告模板装饰装修建设施工完工监理评估验收记录报告.doc
07-31
**区的水利工程竣工验收书是针对关口村小型农田水利工程的一项重要文档，由**市水务局制定，于2020年11月20日完成。这份报告详细记录了工程的相关信息，包括项目的审批、建设、竣工、投资及验收情况。...
小农与市场化.ppt
11-29
2. 农业生产方式转型：从数量扩张转向质量提升，实现第二次农业现代化。 总结，小农与市场化的关系是相互作用的，小农需要通过不断调整策略和模式，以适应日益激烈的市场竞争，同时政府也需要提供相应的政策支持，...
关于旅游农产品电商销售模式改革研究——以“俩小农”电商企业销售改革模式为例.pdf
07-10
文章通过对“俩小农”电商企业销售模式改革的研究，为中小型农产品电商企业在当前竞争激烈的市场环境中，提供了一种可行的发展策略，旨在推动企业实现经济效益和持续发展。同时，该研究也为旅游农产品电商行业的发展...
JdbcTemplate基于XML的连接池获取
飓风2060
03-28 187
1、创建c3p0.properties连接池配置文件用于配置连接池属性 driverClassName = com.mysql.cj.jdbc.Driver jdbcUrl=jdbc:mysql://localhost:3306/syx1 user=root password=123456 initialSize = 5 maxActive = 10 maxWait = 3000 2、创建名为applicationContext.xml的spring配置文件 加载c3p0.properties连接池配置
十六 JdbcTemplate一
记忆碎片
04-16 358
为了使 JDBC 更加易于使用, Spring 在 JDBC API 上定义了一个抽象层, 以此建立一个 JDBC 存取框架. 作为 Spring JDBC 框架的核心, JDBC 模板的设计目的是为不同类型的 JDBC 操作提供模板方法. 每个模板方法都能控制整个过程, 并允许覆盖过程中的特定任务. 通过这种方式, 可以在尽可能保留灵活性的情况下, 将数据库存取的工作量降到最低.
JDBC连接池从0到1
Backpace_的博客
12-06 291
数据库连接池： 概念：是一个存放数据库连接的容器，当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户去访问数据库是，直接从容器里获取连接对象，[不能再去建立连接],用户访问完之后，会将连接对象归还给对象，[不用去关闭连接] 优点：用户访问高效而且节约资源。 标准接口：DataSource,javax.sql包下的 方法： 获取连接：getConnection() 归还连接[不是关...
JDBC连接池&JDBCTemplate
SYJ_1835_LPM的博客
03-20 3606
JDBC连接池数据源（DataSource）数据库连接池DBCP简介DBCP使用的基本步骤：1. 导入相关jar包2. 创建配置文件 *.properties3. 编写相应的代码C3P0Druid 首先介绍一下数据源和数据库连接池的概念和区别： 数据源（DataSource） 所谓数据源也就是数据的来源。它存储了所有建立数据库连接需要的信息。算是对数据库的一个抽象映射，即一个数据源对于一个数据...
连接池和JdbcTemplate
不愿透露姓名的小官同学
04-10 1744
连接池和JdbcTemplate 回顾 核心API的功能： 类名 作用 DriverManager实现类 注册驱动,创建建连接 Connection接口 表示数据库的连接 Statement接口 小货车,执行SQL语句的对象 ResultSet接口 数据库返回的结果集 Connection接口中的方法： Connection接口中的方法 方法名 得到...
Spring（四）------spring的jdbcTemplate操作、配置连接池
wangdongli_1993的博客
08-20 2860
spring是一站式框架，就是在javaee三层中，每一层都有解决技术 而jdbcTemplate技术用在dao层 jdbcTemplate实现crud操作 增加  首先导入数据库操作所需的jar包   创建类，测试用JdbcTemplate技术操作数据库 （1）设置数据库信息，相当于配置连接池 （2）创建JdbcTemplate对象，把配置好的数据库信息传到JdbcTem...
连接池JDBCTemplate最完美模式
风一般的男子·小亮仔
04-15 3152
数据库元数据: jdbcTemplate: 1.概述： 1.1元数据的基本概述 元数据：数据库，表，列的定义信息. 图表解释： 1.2ParameterMetaData ParameterMetaData 可用于获取有关 PreparedStatement 对象中每个参数标记的类型和属性。 select * from user where name=? and passwor...
spring boot中使用spring JdbcTemplate（一）——连接池创建多个连接
archer的技术故事
05-05 8938
本文参考了网上一些文章，最后整理实践得出。1、创建一个springboot的demo程序，可以参考我的文章：创建springboot demo程序2、看一下目录结构：3、首先需要在pom文件中引入依赖：&lt;!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java --&gt; &lt;dependency...
spring jdbcTemplate中获取jdbc Connection并执行操作
weixin_33923762的博客
09-14 5115
实际应用例子在项目中需要获取数据库中元数据相关信息，比如表名，字段名，长度等jdbcTemplate 可以通过SqlRowSetMetaData 可以获取到部分元数据，但是不能获取备注信息（comment中的内容） 已经有jdbcTemplate对象，只需要通过jdbcTemplate获取jdbc Connection即可获取全部信息 代...
小农耕作可持续性模型
最新发布
10-07
小农耕作可持续性模型是一种为了解决全球饥饿问题而提出的农业模型。该模型通过提高农民的产出效率和农田的生产潜力，以确保农民能够养活更多的人口，同时保护土壤和环境资源。小农耕作可持续性模型的关键在于精确的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值