JDBC
1、概念：
Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun Microsystems的商标。我们通常说的JDBC是面向关系型数据库的
即Java语言操作数据库。
2、入门步骤：
前提导入驱动jar包
1、注册驱动
2、获取数据库连接对象 Connection
3\定义sql
4、获取执行sql的语句对象 Statement
5、执行sql语句，接受返回结果
6、处理结果
7、释放资源
public class JdbcDemo {
public static void main(String[] args) {
try {
//1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2\获取数据库连接对象
Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/db2", "root", "root");
//3\定义sql语句
String sql = "update stu set name = 'li' where id = 1";
//4\获取执行sql的对象 statement
Statement statement = connection.createStatement();
//5\执行sql
int count = statement.executeUpdate(sql);
//6\处理结果
System.out.println(count);
//7\释放资源
statement.close();
connection.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
3、详解各个对象
a、DriverManager--驱动管理对象
功能：
1注册驱动
static void registerDriver(Driver driver) 注册与给定的驱动程序 DriverManager 。
写代码使用：Class.forName("com.mysql.jdbc.Driver");
通过查看源代码发现：在com.mysql.jdbc.Driver类中存在静态代码块
try
{
DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}
2获取数据库连接
方法：static Connection getConnection(String url， String user, String password )
参数
url - 形式为 jdbc:subprotocol:subname的数据库网址
语法：jdbc:mysql://ip地址（域名）：端口号/数据库名称
例子：jdbc:mysql://127.0.0.1:3306/db2
user - 正在连接的数据库用户 password - 用户密码
b、Connection--数据库连接对象
1\获取执行sql的对象
Statement createStatement() 创建一个 Statement对象，用于将SQL语句发送到数据库。
PreparedStatement prepareStatement(String sql) 创建一个 PreparedStatement对象，用于将参数化的SQL语句发送到数据库。
2、管理事务：
开启事务：setAutoCommit(boolean autoCommit) --调用该方法设置参数为false,即开启事务。
提交事务：commit()
回滚事务:rollback()
c、Statement--执行sql的对象
1\执行sql
1\boolean execute(String sql) :可以执行任意的sql 了解
2、int executeUpdate(String sql) ：可以执行DML(insert\update\delete)语句、DDL（create\alter\drop）语句
返回值:影响的行数，可以通过这个影响的行数判断DML语句是否执行成功 返回值>0的则成功，反之，则失败。
3、ResultSet executeQuery(String sql) ：执行DQL(select)语句
d、ResultSet--结果集对象
1、next() 游标向下移动一行
2、getxxx(参数)：获取数据
xxx:代表数据类型 如：int getInt(),String getString()
1、int --代表列的编号，从1开始 如：getString(1)
while (rs.next()){
System.out.println(rs.getInt(1)+","+rs.getString(2)+","+rs.getString(3));
}
2、String--代表列名。如：getString("name")
while (rs.next()){ System.out.println(rs.getInt("id")+rs.getString("name")+rs.getString("phone_num"));
public class JdbcDemo01 {
public static void main(String[] args) {
Connection connection = null;
Statement statement = null;
try {
//注册驱动
Class.forName("com.mysql.jdbc.Driver");
//获取数据库连接对象
connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/db2", "root", "root");
//定义sql语句
String sql = "select * from person";
//获取执行sql的statement对象
statement = connection.createStatement();
//执行sql语句
ResultSet rs = statement.executeQuery(sql);
//处理结果集
while (rs.next()){
Person person = new Person();
person.setId(rs.getInt("id"));
person.setName(rs.getString("name"));
person.setAge(rs.getInt("age"));
System.out.println(person);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}catch (SQLException e){
e.printStackTrace();
}
}
}
Jdbc工具类——练习
public class JdbcUtils {
private static String url;
private static String user;
private static String password;
private static String driver;
static {
//1、创建properties集合类
Properties properties = new Properties();
try {
//2、加载文件
//获取src路径下的文件的方式--ClassLoader 类加载器
ClassLoader classLoader = JdbcUtils.class.getClassLoader();
// InputStream resourceAsStream = classLoader.getResourceAsStream("jdbc.properties");//返回用于读取指定资源的输入流。
// properties.load(resourceAsStream);
URL resourceUrl = classLoader.getResource("jdbc.properties");
String urlPath = resourceUrl.getPath();
System.out.println(urlPath);
properties.load(new FileReader(urlPath));
//3、获取配置的数据，赋值
JdbcUtils.url = properties.getProperty("url");
user = properties.getProperty("user");
password = properties.getProperty("password");
driver = properties.getProperty("driver");
//4、加载驱动
Class.forName(driver);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/***
* @Author 俺家笨丫头
* @Description: 获取数据库连接
* @Date: 2020/5/15 23:52
* @Param []
* @throws Exception
* @return java.sql.Connection
*/
public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(url,user,password);
}
/**
* @Author 俺家笨丫头
* @Description: 释放资源
* @Date: 2020/5/15 23:52
* @Param [statement, connection]
* @throws Exception
* @return void
*/
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 class JdbcDemo02 {
public static void main(String[] args) {
List<Person> personList = findAll();
System.out.println(personList);
System.out.println(personList.size());
}
private static List<Person> findAll() {
ArrayList<Person> list = new ArrayList<>();
String sql = "select * from person";
Connection connection = null;
try {
connection = JdbcUtils.getConnection();
Statement statement = connection.createStatement();
ResultSet rs = statement.executeQuery(sql);
while (rs.next()){
Person person = new Person();
person.setId(rs.getInt("id"));
person.setName(rs.getString("name"));
person.setAge(rs.getInt("age"));
list.add(person);
}
} catch (SQLException e) {
e.printStackTrace();
}
return list;
}
}
登录小练习（有bug）sql注入问题
public class Demo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名字：");
String name = scanner.next();
System.out.println("请输入密码:");
String password = scanner.next();
boolean b = logIn(name, password);
if(b){
System.out.println("登录成功");
}else{
System.out.println("用户名或密码错误");
}
}
private static boolean logIn(String name, String password) {
Connection connection = null;
Statement statement = null;
ResultSet rs = null;
if (name == null || password == null){
return false;
}
String sql = "select * from users where name = '" +name+
"' and password = '" + password +
"'";
System.out.println("sql:" + sql);
try {
connection = JdbcUtils.getConnection();
connection.setAutoCommit(true);
statement = connection.createStatement();
rs = statement.executeQuery(sql);
return rs.next();
} catch (SQLException e) {
e.printStackTrace();
}finally {
JdbcUtils.close(rs,statement,connection);
}
return false;
}
}
e、PreparedStatement--执行sql的对象
-
表示预编译的SQL语句的对象。
SQL语句已预编译并存储在
PreparedStatement对象中。 然后可以使用该对象多次有效地执行此语句。1、SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
1、用户随便输入密码：a' or 'a' = 'a'
2、sql:select * from users where name = 'huhu' and password = 'a' or 'a' = 'a'
2、解决sql注入问题：使用PreparedStatement对象来解决
3、预编译的sql：参数使用？作为占位符
4、步骤：
1、导入驱动架包mysql-connector-java-5.1.40-bin.jar
2、注册驱动
3、获取数据库连接对象
4、定义sql
注意sql的参数使用？作为占位符。如 :select * from users where name = ? and password = ?;
5、获取执行sql语句的对象 PreparedStatement Connection.prepareStatement(String sql)
6、给？赋值
方法：setXXX（参数1，参数2）
参数1--？的位置编号 从1开始
参数2--？的值
7、执行sql,接受返回结果
8、处理结果
9、释放资源
public class Demo04 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名字：");
String name = scanner.next();
System.out.println("请输入密码:");
String password = scanner.next();
boolean b = logIn(name, password);
if(b){
System.out.println("登录成功");
}else{
System.out.println("用户名或密码错误");
}
}
private static boolean logIn(String name, String password) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet rs = null;
if (name == null || password == null){
return false;
}
try {
connection = JdbcUtils.getConnection();
connection.setAutoCommit(true);
String sql = "select * from users where name = ? and password = ?";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1,name);
preparedStatement.setString(2,password);
rs = preparedStatement.executeQuery();
return rs.next();
} catch (SQLException e) {
e.printStackTrace();
}finally {
JdbcUtils.close(rs,preparedStatement,connection);
}
return false;
}
}
4、JDBC控制事务：
1、事务：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。
2、操作：开启事务、提交事务、回滚事务。
3、使用connection对象来管理事务
开启事务：setAutoCommit(boolean autoCommit) --调用该方法设置参数为false,即开启事务。
提交事务：commit()
回滚事务:rollback()
默认的话为自动提交， 每执行一个update ,delete或者insert的时候都会自动提交到数据库，无法回滚事务。 设置connection.setautocommit(false);只有程序调用connection.commit()的时候才会将先前执行的语句一起提交到数据库，这样就实现了数据库的事务。
true：sql命令的提交（commit）由驱动程序负责 false：sql命令的提交由应用程序负责，程序必须调用commit或者rollback方法
public class Demo05 {
public static void main(String[] args) {
Connection connection = null;
PreparedStatement preparedStatement = null;
PreparedStatement preparedStatement2 = null;
try {
//获取数据库连接
connection = JdbcUtils.getConnection();
//开启事务
connection.setAutoCommit(false);
//sql语句
String sql1 = "update person a set a.age = a.age - ? where a.id = ?";
String sql2 = "update person a set a.age = a.age + ? where a.id = ?";
//获取执行sql的对象
preparedStatement = connection.prepareStatement(sql1);
preparedStatement2 = connection.prepareStatement(sql1);
//设置参数
preparedStatement.setInt(1,5);
preparedStatement.setInt(2,1);
preparedStatement2.setInt(1,5);
preparedStatement2.setInt(2,5);
//执行sql
preparedStatement.executeUpdate();
int i = 3/0;//制造异常
preparedStatement2.executeUpdate();
//提交事务
connection.commit();
} catch (Exception e) {
if (connection != null){
try {
connection.rollback();//回滚事务
} catch (SQLException e1) {
e1.printStackTrace();
}
}
e.printStackTrace();
}finally {
JdbcUtils.close(preparedStatement,connection);
JdbcUtils.close(preparedStatement2,connection);
}
}
}
5、数据库连接池
A、概念：其实就是一个容器（集合），存放数据库连接的容器。
当系统初始化好之后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从 容器中获取连接对象，用户访问完后，会将连接对象归还给容器。
B、优点：1、节约资源 2、用户访问高效
C、实现：
1、标准接口：DataSource javax.sql包下
方法：
a、获取连接：getConnection()
b、归还连接：如果连接对象Connection是从连接池中获取的，那么调用connection.close()方法，则不会再关闭连接了。而是归还链接。
2、一般我们不去实现它，由数据库厂商来实现
1、C3P0:数据库连接池技术
2、Druid:数据库连接池实现技术，有阿里巴巴提供的
D、C3P0数据库连接池技术
步骤：
1、导入jar包：c3p0-0.9.5.5.jar mchange-commons-java-0.2.19.jar 和数据库的驱动架包
2、定义配置文件：
名称：c3p0.properties.xml 或者 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>
<!-- 数据库的url -->
<property name="jdbcUrl">jdbc:mysql://localhost:3306/db2</property>
<property name="user">root</property>
<property name="password">root</property>
<!-- 连接池参数 -->
<!--初始化时申请获取5个连接，取值应在minPoolSize与maxPoolSize之间。-->
<property name="initialPoolSize">5</property>
<!-- 连接池里允许申请的最大的连接数量 -->
<property name="maxPoolSize">10</property>
<!-- 最小的连接数量 -->
<property name="minPoolSize">4</property>
<!--超时时间 （等待3秒才会报错）-->
<property name="checkoutTimeout">3000</property>
</default-config>
<named-config name="c3p0mysql">
<!-- 连接参数 -->
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/db2</property>
<property name="user">root</property>
<property name="password">root</property>
<!-- 连接池参数 -->
<property name="initialPoolSize">4</property>
<property name="maxPoolSize">8</property>
<!-- 最小的连接数量 -->
<property name="minPoolSize">3</property>
<!--超时时间-->
<property name="checkoutTimeout">1000</property>
</named-config>
<named-config name="c3p0oracle">
<property name="driverClass">oracle.jdbc.driver.OracleDriver</property>
<property name="jdbcUrl">jdbc:oracle:thin:@地址:端口:ORCL</property>
<property name="user">root</property>
<property name="password">root</property>
<!--初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。-->
<property name="initialPoolSize">3</property>
<!--连接池中保留的最大连接数。-->
<property name="maxPoolSize">6</property>
<!--连接池中保留的最小连接数 -->
<property name="minPoolSize">2</property>
<!--超时时间-->
<property name="checkoutTimeout">1000</property>
</named-config>
</c3p0-config>
public class C3p0Demo01 {
public static void main(String[] args) {
//1创建数据库连接池对象
//DataSource dataSource = new ComboPooledDataSource();//默认<default-config>
DataSource dataSource = new ComboPooledDataSource("c3p0mysql");//使用指定的配置
//2获取连接对象
try {
Connection connection = dataSource.getConnection();
//3打印
System.out.println(connection);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public class C3p0Demo02 {
public static void main(String[] args) throws SQLException {
//1创建数据库连接对象
DataSource dataSource = new ComboPooledDataSource();//使用默认<default-config>
//2获取连接
for (int i = 1; i <= 11; i++) {
Connection connection = dataSource.getConnection();
System.out.println(i+":"+connection);
if (i==5){
connection.close();//归还连接到连接池
}
}
}
}
E、Druid:数据库连接池实现技术，有阿里巴巴提供的
1步骤：
1、导入jar包：druid-1.1.21.jar 和数据库的驱动架包
2、定义配置文件：
是properties形式的
可以是任意名称，可以放在任意目录下
3、创建核心对象 数据库连接池对象 DruidDataSourceFactory
4、获取连接：getConnection
2定义工具类
1定义一个JDBCUtils
2提供静态代码块加载配置文件，初始化连接池对象
3提供方法
1获取连接方法：通过数据库连接池获取连接
2释放资源
3获取连接池的方法
JDBCUtils工具类
public class JdbcUtils {
//1定义成员变量
private static DataSource dataSource;
static {
InputStream inputStream = JdbcUtils.class.getClassLoader().getResourceAsStream("druid.properties");
try {
Properties properties = new Properties();
properties.load(inputStream);
dataSource = DruidDataSourceFactory.createDataSource(properties);
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public static Connection getConnetion() throws SQLException {
return dataSource.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 resultSet, Statement statement, Connection connection){
if (resultSet != null){
try {
resultSet.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 dataSource;
}
}
druid.properties文件的配置
# druid.properties文件的配置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db2
username=root
password=root
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大超时时间
maxWait=3000
小练习
public class DruidDemo02 {
public static void main(String[] args) {
Connection connetion = null;
PreparedStatement statement = null;
try {
connetion = JdbcUtils.getConnetion();
connetion.setAutoCommit(false);
String sql = "insert into person values(null,?,?)";
statement = connetion.prepareStatement(sql);
statement.setString(1,"李毅");
statement.setInt(2,26);
int count = statement.executeUpdate();
System.out.println(count);
connetion.commit();
connetion.close();
} catch (SQLException e) {
try {
connetion.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace();
}finally {
JdbcUtils.close(statement,connetion);
}
}
}
6、Spring JDBC
Spring 框架对jdbc的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
步骤：
1、导入架包
2、创建JDBCTemplate对象。依赖于数据源DataSource
JdbcTemplate template = new JdbcTemplate(ds);
3、调用JdbcTemplate的方法来完成CRUD的操作
update():执行DML语句。增删改语句。
queryForMap():查询结果将结果集封装为map集合 //注意这个方法的查询结果集长度只能是1
queryForList():查询结果将结果集封装为list集合
query():查询结果，将结果封装为JavaBean对象//查询返回对象类型的集合
new BeanPropertyRowMapper<类型>(类型.class)
queryForObject():查询结果，将结果封装为对象//一般用来查询聚合函数的
public class JdbcTemplateDemo01 {
public static void main(String[] args) {
//1导jar包
//2创建JdbcTemplate对象
JdbcTemplate template = new JdbcTemplate(JdbcUtils.getDataSource());
//3调用方法
String sql = "insert into person values(?,?,?)";
int count = template.update(sql, null, "千年老妖", 1000);
System.out.println(count);
}
}
public class JdbcTemplateDemo02 {
private JdbcTemplate template = new JdbcTemplate(JdbcUtils.getDataSource());
@Test
public void test1(){
Person person = new Person();
ArrayList<Person> list = new ArrayList<>();
String sql = "update person set age = ? where id = ?";
int update = template.update(sql, 26, 1);
System.out.println(update);
}
@Test
public void test2(){
String sql = "insert into person values (?,?,?)";
int update = template.update(sql, null,"刘飞",28);
System.out.println(update);
}
@Test
public void test3(){
String sql = "delete from person where id = ?";
int update = template.update(sql,4);
System.out.println(update);
}
@Test
public void test4(){
String sql = "select * from person where id = ?";
//注意这个方法的查询结果集长度只能是1
Map<String, Object> stringObjectMap = template.queryForMap(sql, 1);
Set<Map.Entry<String, Object>> entrySet = stringObjectMap.entrySet();
/*for (Map.Entry<String, Object> entry : entrySet) {
System.out.println(entry.getKey()+entry.getValue());
}*/
Iterator<Map.Entry<String, Object>> iterator = entrySet.iterator();
while (iterator.hasNext()){
Map.Entry<String, Object> entry = iterator.next();
System.out.println(entry.getKey()+entry.getValue());
}
}
@Test
public void test5(){
String sql = "select * from person where id = ? or id = ?";
List<Map<String, Object>> maps = template.queryForList(sql,1,2);
//System.out.println(maps);
for (Map<String, Object> map : maps) {
System.out.println(map);
}
}
@Test
public void test6(){
String sql = "select * from person where id = ? or id = ?";
/*List<Person> list = template.query(sql, new RowMapper<Person>() {
@Override
public Person mapRow(ResultSet resultSet, int i) throws SQLException {
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
int age = resultSet.getInt("age");
Person person = new Person(id,name,age);
return person;
}
},1,3);
for (Person person : list) {
System.out.println(person);
}*/
List<Person> list = template.query(sql, new BeanPropertyRowMapper<Person>(Person.class), 1, 3);
System.out.println(list);
}
@Test
public void test7(){
String sql = "select count(1) from person where id = ? or id = ?";
Integer integer = template.queryForObject(sql, Integer.class,1,5);
System.out.println(integer);
}
}
