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);
