JDBC(Java DataBase Connectivity)

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

步骤：1.导入驱动jar包 mysql-connector-java

           2.注册驱动

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

　　　4.定义sql

　　　5.获取执行sql语句的对象 Statement

　　　6.执行sql,接收返回结果

　　　7.处理结果

　　　8.释放资源

 

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

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

　　　　2.sql:select * from user where username = 'hfhfa' and password = 'a' or 'a' = 'a'

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

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

4.步骤：

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

           2.注册驱动

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

　　　4.定义sql

　　　　*注意：sql的参数使用？作为占位符。如：select * from user where username = ？and password = ？；

　　　5.获取执行sql语句的对象 PreparedStatement    Connection.PerpareStatement(String sql)

　　　6.给？赋值

　　　　*方法;setXXX(参数1，参数2)

　　　　　　参数1：？的位置编号 从1开始

　　　　　　参数2：？的值

　　　7.执行sql,接收返回结果，不需要传递sql语句

　　　8.处理结果

　　　8.释放资源

JDBC管理事务

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

2.操作：

　　　　*开启事务

　　　　*提交事务

　　　　*回滚事务

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

　　　　*开启事物：setAutoCommit（boolean autoCommit）:调用该方法设置参数为false，即开启事物

　　　　　　-----执行sql之前开启事务

　　　　*提交事物:commit()

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

　　　　*回滚事物：roolback()

　　　　　　-----在catch中回滚事务

 C3P0数据库连接池技术

步骤：1.导入jar包

　　　　*导入jar包（两个）c3p0-0.9.5.2.jar mchange-commoms-java-0.12.jar,不要忘记导入数据库驱动jar包

　　　2.定义配置文件

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

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

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

　　　4.获取连接：getConnection

c3p0-config.xml 配置文件

<?xml version="1.0" encoding="utf-8"?>
<c3p0-config>
  <default-config>
    <!--    连接参数-->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/itcast</property>
    <property name="user">root</property>
    <property name="password">123456</property>

    <!--    连接池参数-->
    <!--    初始申请连接数量-->
    <property name="initialPoolSize">5</property>
    <!--    最大连接数量-->
    <property name="maxPoolSize">10</property>
    <!--    超时时间-->
    <property name="checkoutTimeout">3000</property>

  </default-config>

  <named-config name="otherc3p0"> //可以指定配置选项
  </named-config>
</c3p0-config>

测试1：

package c3p0;

import com.mchange.v2.c3p0.ComboPooledDataSource;

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

/*
c3p0数据库连接池演示
 */
public class c3p0demo {
    public static void main(String[] args) throws SQLException {
        //1.创建数据库连接池对象
        DataSource ds = new ComboPooledDataSource();
        //2.获取连接对象
        Connection conn = ds.getConnection();
        //3.打印
        System.out.println(conn);
    }
}

结果：
com.mchange.v2.c3p0.impl.NewProxyConnection@2a18f23c [wrapping: com.mysql.jdbc.JDBC4Connection@d7b1517]

测试2：

package c3p0;

import com.mchange.v2.c3p0.ComboPooledDataSource;

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

/*

c3p0配置文件参数演示
 */
public class c3p0demo2 {
    public static void main(String[] args) throws SQLException {
        //1.获取DataSource
        DataSource ds = new ComboPooledDataSource();//可以指定配置文件名称，调用对应的配置文件
        //2.获取连接
        for (int i = 1;i <= 11; i++){
            Connection conn = ds.getConnection();
            System.out.println(i+":"+conn);
            if (i == 5){
                conn.close();//归还连接到连接池中
            }
        }
    }
}

结果：

1:com.mchange.v2.c3p0.impl.NewProxyConnection@2a18f23c [wrapping: com.mysql.jdbc.JDBC4Connection@d7b1517]
2:com.mchange.v2.c3p0.impl.NewProxyConnection@23223dd8 [wrapping: com.mysql.jdbc.JDBC4Connection@4ec6a292]
3:com.mchange.v2.c3p0.impl.NewProxyConnection@ea4a92b [wrapping: com.mysql.jdbc.JDBC4Connection@3c5a99da]
4:com.mchange.v2.c3p0.impl.NewProxyConnection@5a01ccaa [wrapping: com.mysql.jdbc.JDBC4Connection@71c7db30]
5:com.mchange.v2.c3p0.impl.NewProxyConnection@4563e9ab [wrapping: com.mysql.jdbc.JDBC4Connection@11531931]
6:com.mchange.v2.c3p0.impl.NewProxyConnection@4cdbe50f [wrapping: com.mysql.jdbc.JDBC4Connection@11531931]
7:com.mchange.v2.c3p0.impl.NewProxyConnection@7cf10a6f [wrapping: com.mysql.jdbc.JDBC4Connection@7e0babb1]
8:com.mchange.v2.c3p0.impl.NewProxyConnection@5ba23b66 [wrapping: com.mysql.jdbc.JDBC4Connection@2ff4f00f]
9:com.mchange.v2.c3p0.impl.NewProxyConnection@3f0ee7cb [wrapping: com.mysql.jdbc.JDBC4Connection@75bd9247]
10:com.mchange.v2.c3p0.impl.NewProxyConnection@7dc36524 [wrapping: com.mysql.jdbc.JDBC4Connection@35bbe5e8]
11:com.mchange.v2.c3p0.impl.NewProxyConnection@5a39699c [wrapping: com.mysql.jdbc.JDBC4Connection@3cb5cdba]

Druid数据库连接池

步骤：1.导入jar包 druid-1.0.9.jar

　　　2.定义配置文件

　　　　*是properties形式的

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

　　　3.加载配置文件

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

　　　5.获取连接：getConnection

druid.properties 配置文件

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/itcast?useSSL=false
useSSL=true
username=root
password=123456

#初始化连接数量
initialSize=5

#最大连接数
maxActive=10

#最大等待时间
maxWait=3000
minIdle=3

测试1：

package druid;

import com.alibaba.druid.pool.DruidDataSourceFactory;

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

public class Druiddemo {
    public static void main(String[] args) throws Exception {
        //1.导入jar包
        //2.定义配置文件
        //3.加载配置文件
        Properties pro = new Properties();
        InputStream is = Druiddemo.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is);
        //4.获取连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);

        //5.获取连接
        Connection conn = ds.getConnection();
        System.out.println(conn);

    }
}

定义工具类

1.定义一个JDBCUtils

2.提供静态代码块加载配置文件，初始化连接池对象

3.提供方法

　　*获取连接对象：通过数据库连接池获取连接

　　*释放资源

　　*获取连接池的方法

Druid 连接池的工具类

package util;

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.定义成员变量
    private static DataSource ds;

    static {
        //1.加载配置文件
        Properties pro = new Properties();

        try {
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));

            //2.获取datasource
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //2.获取连接
    public static  Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    //3.释放资源
    public static void close(Statement stmt,Connection conn){
        close(null,stmt,conn);
    }

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

        if(conn != null){
            try {
                conn.close();//归还连接
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    //4.获取连接池
    public static DataSource getDataSource(){

        return ds;
    }

}

 工具类测试代码：

package druid;

import util.JDBCUtils;

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

/*
使用新的工具类
 */
public class DruidDemo2 {

    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            //1.获取连接
             conn = JDBCUtils.getConnection();
            //2.定义sql
            String sql = "insert into student values(null,?,?)";
            //3.获取pstm对象
            pstmt = conn.prepareStatement(sql);
            //4.给？赋值
            pstmt.setString(1,"王五");
            pstmt.setDouble(2,3000);
            //4.执行sql
            int count = pstmt.executeUpdate();
            System.out.println(count);


        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.close(pstmt,conn);
        }
    }
}

Spring JDBC

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

步骤：1.导入jar包

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

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

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

　　　　*******queryForMap() 查询结果,将结果集封装为map集合，(将列名作为key，将值作为value，将这条记录封装为一个map集合)这个方法查询的结果只能是1个结果

　　　　*******queryForList() 查询结果,将结果集封装为list集合，(将每一条记录封装为map集合，再将map集合装载到list集合中)

　　　　*******query() 查询结果，将结果封装为JavaBean对象，（一般我们使用BeanPropertyRowMapper实现类，可以完成数据到JavaBean的自动封装）BeanPropertyRowMapper<类型>(类型.class)

　　　　*******queryForObject() 查询结果，将结果封装为对象，(一般用于聚合函数的查询)

 druid.properties配置文件

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/itcast?useSSL=false  更改红色数据库
useSSL=true
username=root
password=123456
initialSize=5
maxActive=10
maxWait=3000
minIdle=3

JDBCUtils工具类

package util;

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;

public class JDBCUtils {

    //1.定义成员变量
    private  static DataSource ds;

    static {
        //1。加载配置文件
        Properties pro = new Properties();

        try {
            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 stmt,Connection conn){
        close(null,stmt,conn);
    }

    public static void close(ResultSet rs ,Statement stmt, Connection conn){

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

        if(conn != null){
            try {
                conn.close();//归还连接
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    //获取连接池

    public static DataSource getDataSource(){
        return ds;
    }


}

JdbcTemplateDemo1 测试

package jdbctemplate;

import com.alibaba.druid.util.JdbcUtils;
import org.springframework.jdbc.core.JdbcTemplate;
import util.JDBCUtils;

public class JdbcTemplateDemo1 {
    public static void main(String[] args) {
        //1.导入驱动jar包
        //2.创建JdbcTemplate对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //3.调用方法
        String sql = "update student set balance = 2000 where id = ?";
        int count = template.update(sql, 3);
        System.out.println(count);
    }

}

练习：数据库名称为emp

//创建jdbctemplate对象
JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

1.修改1号数据的 salary 为 10000

//3.调用方法
String sql = "update emp set salary = 10000 where id = 1";
int count = template.update(sql);
System.out.println(count);

2.添加一条记录

//3.调用方法
String sql = "insert into emp(id,name,dept_id) values(?,?,?) ";
int count = template.update(sql,1015,"郭靖",10);
System.out.println(count);

3.删除刚才添加的记录

//3.调用方法
String sql = "delete from emp where id = ?";
int count = template.update(sql,1015);
System.out.println(count);

4.查询id为1的记录，将其封装为Map集合 (将列名作为key，将值作为value，将这条记录封装为一个map集合)这个方法查询的结果只能是1个结果

//3.调用方法
String sql = "select * from emp where id = ?";
Map<String, Object> map = template.queryForMap(sql, 1);
System.out.println(map);

5.查询所有记录，将其封装为list(将每一条记录封装为map集合，再将map集合装载到list集合中)

//3.调用方法
String sql = "select * from emp";
List<Map<String, Object>> list = template.queryForList(sql);
for (Map<String, Object> map : list) {
    System.out.println(map);
}

6.查询所有记录，将其封装为Emp对象的list集合

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.查询总记录数

//3.调用方法
String sql = "select * from emp";
Long total = template.queryForObject(sql, Long.class);
System.out.println(total);