一.JDBC的基本操作
1.1 JDBC的概述
什么是JDBC
-
JDBC(Java Date Base Connectivity , Java数据库连接) 是一种用于执行SQL语句的Java API,为多种关系数据库提供统一访问 它由一组java语言编写的类和接口组成 有了JDBC,程序员只需要JDBC API写一个程序,就可以访问所有数据库 SUN公司是规定的制定者,制定了规范JDBC(连接数据库规范) DriverManager类 作用:管理各种不同的JDBC驱动 Connection接口 建立与数据库的连接 Statement接口 和其子接口PreparedStatement接口 : 发送SQL语句的工具 ResultSet接口 : 如果是查询语句的话,查询的结果会封装成结果集 数据库厂商微软,甲骨文等分别提供了实现JDBC接口的驱动jar包 程序员学习JDBC规范来应用这些jar包里的类
JDBC访问数据库的步骤:
- 1.加载一个Driver驱动 (–> 首先得加载一个jar包,访问不同的数据库,不同的jar包)
- 2.创建数据库连接(Connectior)
- 3.创建SQL命令发送器Statement
- 4.通过Statement发送SQL命令并得到结果(eg: 添加,删除,修改…的结果无非就是成功或失败,返回的是有几行数据收到影响 ; 查询 的结果就是返回一个结果集)
- 5.处理结果(select语句)
- 6.关闭数据库资源 close()
- ResultSet
- Statement
- Connection
1.2 使用JDBC完成添加操作
package JDBC;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class TestInsert {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
String driver = "com.mysql.jdbc.Driver";
String url = "jdbc:mysql://localhost:3306/test2";
String user = "root";
String password = "123";
//1.加载驱动,导入jar包
Class.forName(driver);
//2.与数据库建立连接
Connection conn = DriverManager.getConnection(url, user, password);
// System.out.println(conn);
//3.创建SQL命令的Statement发送器
Statement st = conn.createStatement();
//4.准备一个SQL命令,并使用SQL命令发送器发送SQL语句,并返回结果
String sql = "insert into account values(6,'章三',9999)";
int result = st.executeUpdate(sql); // insert update delete -->DML
//5.处理结果
if (result>0){
System.out.println("添加成功");
}else{
System.out.println("添加失败");
}
//6.关闭资源
st.close();
conn.close();
}
}
1.3 使用JDBC完成修改操作
package JDBC;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class TestUptate {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
//1.加载驱动,导入jar包
Class.forName("com.mysql.jdbc.Driver");
//2.建立与数据库的连接
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test2","root","123");
//3.创建Statement发射器
Statement st = conn.createStatement();
//4.编写SQL语句,使用statement发射器发送SQL语句,并返回结果
String sql = "update account set money=1000 where name='章三'";
int result = st.executeUpdate(sql);
//5.处理结果集
if (result>0){
System.out.println("修改成功");
}else{
System.out.println("修改失败");
}
//6.关闭资源
st.close();
conn.close();
}
}
1.4 使用JDBC完成删除操作
package JDBC;
import java.sql.*;
public class TestDelete {
public static void main(String[] args) {
Connection conn = null;
Statement st = null;
try{
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2.创建于数据库的连接
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test2", "root", "123");
//3.创建发射器
st = conn.createStatement();
//4.编写SQL语句,并发射SQL语句,并返回结果
String sql = "delete from account where name='章三'";
int result = st.executeUpdate(sql);
//5.处理结果
if (result>0){
System.out.println("删除成功");
}else{
System.out.println("删除失败");
}
}catch (Exception e){
e.printStackTrace();
}finally{
//6.关闭资源
try {
if (st != null) {
st.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if (conn != null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
1.5 使用JDBC完成查询操作
package JDBC;
import java.sql.*;
public class TestSelect {
public static void main(String[] args) {
Connection conn=null;
Statement st = null;
ResultSet rs = null;
try{
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2.连接数据库
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test2", "root", "123");
//3.建立Statement发射器
st = conn.createStatement();
//4.编写SQL语句,发射SQL语句,并返回结果
String sql = "select * from account";
rs = st.executeQuery(sql);
//5.处理结果集
while (rs.next()){
int id = rs.getInt("id");
String name = rs.getString("name");
double money = rs.getDouble("money");
System.out.println("id:"+id+"\tname:"+name+"\tmoney"+money);
}
}catch (Exception e){
e.printStackTrace();
}finally{
//关闭资源
try {
if (rs!=null) {
rs.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if (st!=null) {
st.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if (conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
注意:
-
ResultSet里的数据一行一行排列,每行有多个字段,且有一个记录指针,指针所指的数据叫做当前数据行,我们只能来操作当前的数据行.我们如果想要取得某一条记录,就要使用ResultSet的next()方法,如果我们想要得到ResultSet里的所有记录,就应该使用while循环.
-
ResultSet对象自动维护指向当前数据行的游标.每调用一次next(),游标向下移动一行
-
初始状态下记录指针指向第一条记录的前面,通过next()指向第一条记录.循环完毕后指向最好一条记录的后面.
方法:
- boolean next() 将光标从当前位置向下移动一行
- boolean previous() 游标从当前位置向上移动一行
- void close() 关闭资源
- int getInt(int colIndex) 以int形式获取结果集当前行指定列号值
- int getInt(int colLabel) 以int形式获取结果集当前行指定列名值
…
package JDBC;
import entity.Account;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class TestSelect2 {
/**
* 前台
*
* 返回结果到前台集不可取
* 1.Operation not allowed after ResultSet closed
* 在后台关闭了结果集后,在前台已经不可取结果集了
* 2.最关键的是: 不要将JDBC的API直接传到前台,会导致前台后台耦合在一起,
* 如果以后不使用JDBC,前台也要修改
* @param args
*/
public static void main(String[] args) throws SQLException {
//调用后台,并获取结果
List<Account> list = findAll();
//输出结果
for (Account acc : list){
System.out.println("id:"+acc.getId()+"\tname:"+acc.getName()+"\tmoney"+acc.getMoney());
}
}
/**
* 后台
*/
public static List<Account> findAll(){
Connection conn=null;
Statement st = null;
ResultSet rs = null;
List<Account> list = new ArrayList<>();
try{
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2.连接数据库
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test2", "root", "123");
//3.建立Statement发射器
st = conn.createStatement();
//4.编写SQL语句,发射SQL语句,并返回结果
String sql = "select * from account";
rs = st.executeQuery(sql);
//5.处理结果 >>将ResultSet的数据封装到一个List中,再将List返回
while(rs.next()){
//获取当前行各个字段的值
int id = rs.getInt("id");
String name = rs.getString("name");
double money = rs.getDouble("money");
//将当前行各个字段的值封装到一个Account对象中
Account account = new Account(id,name,money);
//将Account对象添加到集合中
list.add(account);
}
}catch (Exception e){
e.printStackTrace();
}finally{
//关闭资源
try {
if (rs!=null) {
rs.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if (st!=null) {
st.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if (conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
return list;
}
}
二. JDBC高级操作
2.1 PreparedStatement
是Statement的子接口
案例: 模拟淘宝登录功能.在前台输入用户名和密码,后台判断是否正确,并给出前台的反馈信息,前台输出反馈信息.
其具体实现步骤是:
- 创建数据库表user
- 创建实体类User
- 开发前台代码
TestLogin :
package JDBC2;
import entity.User;
import jdbc1.JDBCUtil;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
import java.util.Scanner;
/**
* 模拟淘宝登录功能
*/
public class TestLogin {
/**
* 前台
* @param args
*/
public static void main(String[] args) throws SQLException {
//1.输入用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的用户名..");
String userid = sc.next();
System.out.println("请输入您的密码..");
String password = sc.next();
//2.调用后台,判断登录是否成功,并返回结果给前台
User user =login(userid,password);
//3.在前台输入结果
if (user == null){
System.out.println("登录失败!");
}else{
System.out.println("登录成功,欢迎您"+user.getRealname());
}
}
public static User login(String userid,String password) throws SQLException {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
User user = null;
//1.加载驱动并获取连接
conn = JDBCUtil.getConnection();
//2.创建发射器
st = conn.createStatement();
//3.编写Sql语句,并发射返回结果'
String sql = "select * from user where userId= '"+userid+"' and password='"+password+"'";
rs = st.executeQuery(sql);
//4.处理结果集
if (rs.next()){ //因为加了查询条件,使得查询结果只有一条,故 用if足够
//获得当前字段的值
String id = rs.getString("userId");
String rname = rs.getString("realname");
String paw = rs.getString("password");
double money = rs.getDouble("money");
//创建user对象
user = new User(id,rname,paw,money); // >> 有编译错误 : 因为user在这里是局部变量,所以应把user放在全局中
}
return user;
}
}
TestLogin2 :
package JDBC2;
import entity.User;
import jdbc1.JDBCUtil;
import java.sql.*;
import java.util.Scanner;
/**
* 模拟淘宝登录功能
* preparedStatement
*
* 关系 : public interface PreparedStatement extends Statement
* preparedStatement的优点:
* 1.安全性高 避免SQL注入 因为不是基于字符串拼接的
* 2.代码不繁琐,可读性高. 不用进行复杂的字符串拼接
* 3.
*
*/
public class TestLogin2 {
/**
* 前台
* @param args
*/
public static void main(String[] args) throws SQLException {
//1.输入用户名和密码
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的用户名..");
String userid = sc.next();
System.out.println("请输入您的密码..");
String password = sc.next();
//2.调用后台,判断登录是否成功,并返回结果给前台
User user =login(userid,password);
//3.在前台输入结果
if (user == null){
System.out.println("登录失败!");
}else{
System.out.println("登录成功,欢迎您"+user.getRealname());
}
}
public static User login(String userid,String password) throws SQLException {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
User user = null;
//1.加载驱动并获取连接
conn = JDBCUtil.getConnection();
//2.创建发射器并发送SQL
String sql = "select * from user where userId= ? and password= ? ";
ps = conn.prepareStatement(sql);
ps.setString(1,userid); // 从1开始
ps.setString(2,password);
rs = ps.executeQuery();
//4.处理结果集
if (rs.next()){ //因为加了查询条件,使得查询结果只有一条,故 用if足够
//获得当前字段的值
String id = rs.getString("userId");
String rname = rs.getString("realname");
String paw = rs.getString("password");
double money = rs.getDouble("money");
//创建user对象
user = new User(id,rname,paw,money); // >> 有编译错误 : 因为user在这里是局部变量,所以应把user放在全局中
}
return user;
}
}
TestLogin3 :
package JDBC2;
import entity.User;
import jdbc1.JDBCUtil;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* 登录
*/
public class TestLogin3 {
/**
* 前台
* @param args
*/
public static void main(String[] args) throws SQLException {
//1.在前台输入登录用户ID和用户密码
String userid = "1010";
String password = "555";
//2.调用后台,判断是否登录成功并返回结果
User user = login(userid, password);
//3.在前台输出结果
if (user ==null){
System.out.println("登录失败");
}else{
System.out.println("欢迎登录 : "+user.getRealname() );
}
}
public static User login(String userid,String password) throws SQLException {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
User user = null;
//1.加载驱动并获取连接
conn = JDBCUtil.getConnection();
//2.创建发射器并发送SQL
String sql = "select * from user where userId= ? and password= ? ";
ps = conn.prepareStatement(sql);
ps.setString(1,userid); // 从1开始
ps.setString(2,password);
rs = ps.executeQuery();
//4.处理结果集
if (rs.next()){ //因为加了查询条件,使得查询结果只有一条,故 用if足够
//获得当前字段的值
String id = rs.getString("userId");
String rname = rs.getString("realname");
String paw = rs.getString("password");
double money = rs.getDouble("money");
//创建user对象
user = new User(id,rname,paw,money); // >> 有编译错误 : 因为user在这里是局部变量,所以应把user放在全局中
}
return user;
}
}
User:
package entity;
/**
* 用户类
*/
public class User {
private String userId;
private String realname;
private String password;
private double money;
public User() {
}
public User(String userId, String realname, String password, double money) {
this.userId = userId;
this.realname = realname;
this.password = password;
this.money = money;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getRealname() {
return realname;
}
public void setRealname(String realname) {
this.realname = realname;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
@Override
public String toString() {
return "User{" +
"userId='" + userId + '\'' +
", realname='" + realname + '\'' +
", password='" + password + '\'' +
", money=" + money +
'}';
}
}
jdbc.properties :
url=jdbc:mysql://localhost:3306/homework
user=root
password=123
driver=com.mysql.jdbc.Driver
JDBCUtil :
package jdbc1;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class JDBCUtil {
private static String url;
private static String username;
private static String password;
private static String driver;
//文件的读取,只需读取1次,便可拿到相应的值,使用静态代码块
static{
try{
//读取资源文件,获取数据库访问信息
Properties pro = new Properties();
//获取src路径下的文件的方式--ClassLoader类加载器 >>加载配置文件信息
InputStream is = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
pro.load(is);
//获取数据,并赋值
url = pro.getProperty("url");
username = pro.getProperty("user");
password = pro.getProperty("password");
driver = pro.getProperty("driver");
//加载驱动
Class.forName(driver);
}catch (Exception e){
e.printStackTrace();
}
}
/**
* 获取连接
* @return
* @throws SQLException
*/
public static Connection getConnection() throws SQLException {
Connection conn = DriverManager.getConnection(url, username, password);
return conn;
}
/**
* 关闭资源
* @param st 关闭发射器
* @param conn 关闭与数据库的连接
*/
public static void getClose(Statement st,Connection conn){
try {
if (st!=null){
st.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if (conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 资源关闭 >> 重载
* @param rs 结果集的关闭
* @param st 发射器的关闭
* @param conn 数据库连接的关闭
*/
public static void getClose(ResultSet rs, Statement st, Connection conn){
try {
if (rs!=null) {
rs.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if (st!=null){
st.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if (conn!=null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
2.2 JDBC中使用事务
- 在JDBC中,事务操作是自动提交
- 一条对数据库的DML(insert , update , delete)代表一向事务操作
- 操作成功后,系统将自动调用commit()提交,否则自动调用rollback()回滚
- 在JDBC中,事务操作方法都位于接口java.sql.Connect
- 可以通过调用setAutoCommit(false)来禁止自动提交.
- 之后就可以把多个数据库操作的表达式作为一个事物,在操作完成后调用commit()来进行整体提交
- 倘若其中一个表达式操作失败,都不会执行到commit(),并且将产生相应异常
- 此时就可以在异常捕获时调用rollback()进行回滚,回复至数据初始状态
- 事务开始的边界则不是那么明显了,他会开始于组成当前事务的所有statement中的第一个被执行的时候
- 事务结束的边界是commit或者rollback方法的调用
案例 : 银行转账
package JDBC2;
import jdbc1.JDBCUtil;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
/**
* 银行转账
*/
public class TestTransaction {
public static void main(String[] args) throws SQLException {
Connection conn=null;
Statement st=null;
try {
conn = JDBCUtil.getConnection();
st = conn.createStatement();
String sql1 = "update user set money=money-1000 where userId = 1010";
String sql2 = "update user set money=money+1000 where userId = 7777";
// 因为JDBC中事物会自动提交,所以要取消自动提交
conn.setAutoCommit(false); // 在JDBC中,事务操作方法都位于接口java.sql.Connection中
st.executeUpdate(sql1);
st.executeUpdate(sql2);
//提交事务,开始事务
conn.commit();
} catch (SQLException e) {
e.printStackTrace();
conn.rollback(); //出错直接回滚,结束事务
}finally{
//关闭资源
st.close();
conn.close();
}
}
}
三. 数据库连接池
3.1 概述
数据库连接池就是一个容器[集合],存放数据库连接的容器.
当系统初始化好后,容器会被创建,容器中会申请一些连接对象,当用户来访问数据库时,从容器中获取连接对象,用户访问完之后归还给容器.
好处:
- 节约资源
- 用户访问高效
实现:
1.标准接口: DataSource javax.sql包下
方法:
获取连接: getConnection()
归还连接: 如果连接对象Connection试是从连接池中获取,那么调用Connection.close()
2.一般我们不去实现它,有数据库厂商来实现
C3P0: 数据库连接池技术
Druid(德鲁伊):数据库连接池技术,由阿里巴巴提供的
3.2 C3P0数据库连接池技术
3.2.1 基本使用步骤
1.导入jar包 : c3p0-xx.xx.xx.jar,不要忘记数据库驱动jar
2.定义配置文件
名称为: c3p0.properties 或 c3p0-config.xml
记得要加载配置文件
3.创建核心对象 : 数据库连接池对象
new ConboPooledDateSource()
4.获取连接
getConnection()
3.3 Druid连接池
Druid是阿里巴巴开源平台上一个数据库连接池实现，它它结合了C3P0、DBCP、等DB池的优点，同时加入日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池，说是目前最好的连接池之一
3.3.1 基本使用步骤
1.导入jar包，druid-x-x-x.jar ,不要忘记数据库驱动jar
2.定义配置文件
是properties形式的 (可以任意取名,放在任意位置,但是配置文件的加载形式不一样)
3.获取数据库连接池对象，通过工厂类来获取
DruidDataSourceFactory
4.获取连接：getConnection
四. Spring JDBC
4.1 概述
Spring框架对JDBC的简单封装，提供了一个JdbcTemplate对象简化JDBC开发
4.1.1 基本使用步骤
1.导入jar包
2.创建JDBCtemplate对象，依赖于数据源DataSource
new JdbcTemplate(ds);
3.调用JdbcTemplate的方法来完成CRUD的操作
update():执行DML语句，增删改操作
queryForMap():查询结果将结果集封装为map集合，该方法查询的结果集长度只能是1
queryForList():查询结果将结果集封装为List集合
每条记录封装为一个Map集合，再将Map集合装载到List集合中
query():查询结果，将结果封装为JavaBean对象
参数：RowMapper,一般使用BeanPropertyMapper实现类，可以完成数据到JavaBean的自动封装
new BeanPropertyRowMapper<>(Account.class)
queryForObject():查询结果，将结果封装为对象，一般用于聚合函数的查询
扫一扫
820
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
