JDBC：java database connectivity

JDBC 本质：

public class JdbcDemo1 {
    public static void main(String[] args) throws Exception {
//        step1:导入驱动jar包
//        step2:注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
//        step3:获取数据库的连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", "root", "111111");
//        执行mysql语句
        String sql="update account set balance=200 where id=1";
        Statement stmt = conn.createStatement();
//        处理结果
        int count = stmt.executeUpdate(sql);
        System.out.println(count);
//        释放资源
        stmt.close();
        conn.close();
    }
}

note:每一信息资源都有统一的且在网上唯一的地址，该地址就叫URL（Uniform Resource Locator,统一资源定位符）

代码详解：


数据库的连接对象：
执行SQL的对象（常用executeUpdate（DDL，DML）executeQuery（DQL））：

SQL注入问题：

JDBC事务管理：

package cn.jdbc;

import util.JdbcUtils;//自己的创建的jabc工具类

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * @Author:XXX
 * @Date:2021-12-03-9:10
 * @Description:cn.jdbc(管理事务，解决异常管理)
 * @version:1.0
 */

public class Jdbc_transaction {
    public static void main(String[] args) {
        Connection conn =null;
        PreparedStatement pstmt1 =null;
        PreparedStatement pstmt2 =null;
        try {
            conn = JdbcUtils.getConnection();
            //开启事务
            conn.setAutoCommit(false);
            String sql1="update account set balance=balance-? where id=?";
            String sql2="update account set balance=balance+? where id=?";
            pstmt1 = conn.prepareStatement(sql1);
            pstmt2 = conn.prepareStatement(sql2);
            pstmt1.setDouble(1,500);
            pstmt1.setInt(2,1);
            pstmt2.setDouble(1,500);
            pstmt2.setInt(2,2);
            pstmt1.executeUpdate();
            int i=1/0;//没有事务管理之前：只执行了sql1,sql2没有执行。事务管理之后：sql1,sql2没有执行
            pstmt2.executeUpdate();
            //没有错误，提交事务
            conn.commit();


        } catch (Exception e) {
            try {
                //有错误回滚事务
                if(conn!=null){
                    conn.rollback();
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }finally {
            JdbcUtils.close(pstmt1,conn);
            JdbcUtils.close(pstmt2,null);
        }
    }

}

数据库连接池：

C3p0的使用

配置文件:

<c3p0-config>

    <!-- c3p0默认配置，下面还可以配置多个数据库 -->
    <default-config>
        <!--  连接参数 -->
        <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db1</property>
        <property name="user">root</property>
        <property name="password">111111</property>

        <!-- 连接池参数 -->
        <!-- 初始化时获取连接数 -->
        <property name="initialPoolSize">6</property>
        <!-- 连接池中保留的最大连接数 -->
        <property name="maxPoolSize">10</property>
        <!-- 最大空闲时间，多少秒内未使用则连接被丢弃。若为0则永不丢弃。默认值: 0 -->
        <property name="checkoutTimeout">1000</property>
    </default-config>

        <named-config name="otherc3p0">
            <!--  连接参数 -->
            <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
            <property name="jdbcUrl">jdbc:mysql://localhost:3306/db1</property>
            <property name="user">root</property>
            <property name="password">111111</property>

            <!-- 连接池参数 -->
            <property name="initialPoolSize">6</property>
            <property name="maxPoolSize">10</property>
            <property name="checkoutTimeout">1000</property>
        </named-config>
</c3p0-config>

数据连接池获取的代码演示：

package cn.DataConnPool.c3p0;

import com.mchange.v2.c3p0.ComboPooledDataSource;

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

/**
 * @Author:xxxx
 * @Date:2021-12-03-10:37
 * @Description:cn.DataConnPool.c3p0(c3p0的配置演示，注意仍然需要在mysql的jar包存在的前提下)
 * @version:1.0
 */

public class C3p0Demo1 {
    public static void main(String[] args) throws SQLException {
        //创建数据库连接池对象
        DataSource ds=new ComboPooledDataSource();
        //获取配置文件中的10个连接对象
        for (int i = 1; i < 11; i++) {
            Connection conn = ds.getConnection();
            //打印
            System.out.println(i+": "+conn);
        }
    }
}

运行结果：

当我们归还连接对象时，可以使用超过datasource最大连接对象数：

druid连接池（alibaba）:

配置文件：

#数据库的连接参数
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql:///db1
username=root
password=111111
#初始化连接池数
initialSize=5
#最大连接数
maxActive=10
#最长等待时间
maxWait=2000

配置项说明

import com.alibaba.druid.pool.DruidDataSourceFactory;

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

/**
 * @Author:xxxx
 * @Date:2021-12-03-11:09
 * @Description:cn.DataConnPool.druid(druid的演示文件)
 * @version:1.0
 */

public class DruidDemo {
    public static void main(String[] args) throws Exception {
        //导入jar包
        //定义配置文件并进行加载
        Properties pro= new Properties();
        InputStream is =   DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);

        //创建数据库连接池pool的对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        //获取连接从pool选一个
        Connection conn = ds.getConnection();
        System.out.println(conn);
    }
}

Spring JDBC(框架：简化JDBC的开发):

需要的jar包：

package cn.DataConnPool.SpringJDBC;

import cn.DataConnPool.util.Jdbc_datasourceUtils;
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * @Author:xxxx
 * @Date:2021-12-03-14:46
 * @Description:cn.DataConnPool.SpringJDBC（这个框架会自动帮我们释放资源与归还连接对象）
 * @version:1.0
 */

public class JDBCtemplateDemo1 {
    public static void main(String[] args) {
        //导入jar包
        //创建JDBCtemplate对象,JdbcTemplate（）方法需要一个数据库连接池作为传输参数
        JdbcTemplate template=new JdbcTemplate(Jdbc_datasourceUtils.getdatasource());//调用druid的工具类获取一个datasource pool
        //调用方法
        String sql="Update account set balance=10 where id=?";
        int count = template.update(sql, 3);
        System.out.println(count);
    }
}

package cn.DataConnPool.SpringJDBC;

import cn.DataConnPool.util.Jdbc_datasourceUtils;
import cn.jdbc.Emp;
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.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

/**
 * @Author:xxxxx
 * @Date:2021-12-03-15:21
 * @Description:cn.DataConnPool.SpringJDBC（junit单元测试可以让方法独立运行，JDBCtemplate中：update进行增删改，queryxxxxx进行查询并封装）
 * @version:1.0
 */

public class JdbcTemplateSQL {

    private JdbcTemplate template = new JdbcTemplate(Jdbc_datasourceUtils.getdatasource());//上升为成员变量

    //对account中的Id=1的用户的balance置位30
    @Test
    public void test01(){
        String sql="Update account set balance=30 where id=?";
        int count = template.update(sql, 1);
        System.out.println(count);
    }

    //增加一条记录
    @Test
    public void test02(){
        String sql="insert into account values(null,?,?)";
        int count=template.update(sql,"王峰",3000);
        System.out.println(count);

    }

    //查询id=1的记录并封装到map集合,queryForMap()这个方法的查询结果集的只能长度为1（表中的一条记录）
    //将列表名设置为key,数据设置为value
    @Test
    public void test03(){
        String sql="select* from account where id=?";
        Map<String, Object> map = template.queryForMap(sql, 1);
        System.out.println(map);//输出结果：{id=1, name=张华, balance=1000.0}

    }


    //查询所有的记录封装到list集合(每一条记录作为map集合再装入list集合集合)
    @Test
    public void test04(){
        String sql="select* from account";
        List<Map<String, Object>> maps = template.queryForList(sql);
        System.out.println(maps);
        for (Map<String, Object> map:maps) {
            System.out.println(map);
        }
    }


    //查询所有的记录封装为Emp的Javabean对象再装入到list集合
    @Test
    public void test05(){
        String sql="select* from employee";

        //使用匿名内部类来创建一个RowMapper<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 name = rs.getString("name");
                int age = rs.getInt("age");
                int dep_id = rs.getInt("dep_id");
                emp.setId(id);
                emp.setName(name);
                emp.setAge(age);
                emp.setDep_id(dep_id);
                return emp;

            }
        });
        for (Emp e:list) {
            System.out.println(e);
        }
    }


    //对上一个方法使用Spring框架的已有东西来书写
    @Test
    public void test06(){
        String sql="select* from employee";
        List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));//来自于封装为Javabean时调用Spring已有的框架
        for (Emp e:list) {
            System.out.println(e);
        }
    }

    //查询总记录数
    @Test
    public void test07(){
        String sql="select count(id) from employee";
        Long l= template.queryForObject(sql, long.class);//将结果封装为long对象
        System.out.println("查询到的总记录数为： "+l);
    }

}