一、JDBC基本概念以及使用
- JDBC基本概念
概念：Jdbc(Java DataBase Connectivity)，java与数据库连接工具使用java语言操作数据库
jdbc本质：是sun公司提供的统一操纵数据库的规则（接口），数据库厂商写自己的驱动去
实现JDBC接口。我们使用对应的驱动去使用JDBC接口进行编程，真正执行代码的式驱动
jar包中的实现类。 - 快速入门
1. 导入jar包
2. 注册驱动
Class.forName(“com.mysql.jdbc.Driver”);
3.获取数据库连接对象
Connection conn = DriverManager.getConnection(“jdbc:mysql://localhost:3306/db3”, “root”, “root”);
4.定义sql
String sql = “update account set balance = 500 where id = 1”;
5.获取执行sql语句statement，使用connection的createStatement方法创建对应的statement对象
Statement stmt = conn.createStatement();
6.执行sql，定义返回结果影响行数
int count = stmt.executeUpdate(sql);
7.处理结果
System.out.println(count);
8.释放资源：包括connection和statement
stmt.close();
conn.close(); - 详解各个对象
- DriverManager：驱动管理对象
- connection:数据连接对象
- statement：执行sql的对象
- ResultSet：执行sql查询语句返回的结果集
- PreparedStatement：执行sql的对象
具体代码演示如下：
public class JDBCDemo3 {
public static void main(String[] args) {
List<Emp> all = new JDBCDemo3().findAll();
System.out.println(all);
}
public List<Emp> findAll(){
//将对象创建提取到try catch域外
Connection connection = null;
Statement statement = null;
ResultSet rs = null;
List<Emp> empList = null;
try {
//注册驱动
Class.forName("com.mysql.jdbc.Driver");
//获取连接
connection = DriverManager.getConnection("jdbc:mysql:///db5?characterEncoding=UTF-8", "root", "root");
//定义sql
String sql = "select *from emp";
//获取执行sql的对象
statement = connection.createStatement();
//执行sql，获取结果集
rs = statement.executeQuery(sql);
//遍历结果集，封装对象，装载集合
Emp emp = null;
empList = new ArrayList<Emp>();
while (rs.next()){
//获取数据
int id = rs.getInt("id");
String ename = rs.getString("ename");
int job_id = rs.getInt("job_id");
int mgr = rs.getInt("mgr");
Date joindate = rs.getDate("joindate");
double salary = rs.getDouble("salary");
double bounds = rs.getDouble("bonus");
int dept_id=rs.getInt("dept_id");
//创建emp对像赋值
emp = new Emp();
emp.setId(id);
emp.setEname(ename);
emp.setJob_id(job_id);
emp.setMgr(mgr);
emp.setJoindate(joindate);
emp.setSalary(salary);
emp.setBounds(bounds);
emp.setDept_id(dept_id);
//装载集合
empList.add(emp);
}
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}finally {
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();
}
}
}
return empList;
}
}
将重复代码提取出来，编写为实体类JDBCUtils，代码如下：
/**
* 所有方法的工具类都是静态的，方便调用
*
* 静态代码块会随着类的加载而加载，只会执行一次
*/
public class JDBCUtils {
/**
* 文件只需要读取一次拿到这些值
* 使用静态代码块完成，静态代码块会随着类的加载执行
* 使用静态代码块读取资源文件
* 将connection的参数作用域提升为成员变量，只要类加载就可以使用参数
* 只有静态的变量才能被静态代码块使用
*/
private static String url;
private static String user;
private static String password;
private static String driver;
static{
//读取资源文件，获取值
try {
//创建properties集合类
Properties properties = new Properties();
//获取src路径下的文件的方式-->Classloader 类加载器
ClassLoader classLoader = JDBCUtils.class.getClassLoader();
URL resource = classLoader.getResource("jdbc.properties");
String path = resource.getPath();
System.out.println(path);
properties.load(new FileReader(path));
//获取数据并赋值
url = properties.getProperty("url");
user = properties.getProperty("user");
password = properties.getProperty("password");
driver = properties.getProperty("driver");
//注册驱动
Class.forName(driver);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 获取连接
* @return 连接对象
* @throws SQLException
*/
public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(url,user,password);
}
/**
* 释放资源，增删改
* @param statement
* @param connection
*/
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();
}
}
}
/**
* 释放资源 查询，资源释放顺序从小到大
* @param rs
* @param statement
* @param connection
*/
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();
}
}
}
}
使用JDBCUtils工具类，执行sql，示例代码如下：
public class JDBCDemo4 {
public static void main(String[] args) {
List<Emp> all = new JDBCDemo4().findAll2();
System.out.println(all);
}
public List<Emp> findAll2(){
Connection connection = null;
Statement statement = null;
ResultSet rs = null;
List<Emp> empList = null;
try {
//调用工具类获取连接
connection=JDBCUtils.getConnection();
//定义sql语句
String sql = "select *from emp";
//创建sql执行对象
statement = connection.createStatement();
//执行sql
rs = statement.executeQuery(sql);
//遍历结果集，封装对象，装载集合
Emp emp = null;
empList = new ArrayList<Emp>();
while (rs.next()){
//获取数据
int id = rs.getInt("id");
String ename = rs.getString("ename");
int job_id = rs.getInt("job_id");
int mgr = rs.getInt("mgr");
Date joindate = rs.getDate("joindate");
double salary = rs.getDouble("salary");
double bounds = rs.getDouble("bonus");
int dept_id=rs.getInt("dept_id");
//创建emp对象赋值
emp = new Emp();
emp.setId(id);
emp.setEname(ename);
emp.setJob_id(job_id);
emp.setMgr(mgr);
emp.setJoindate(joindate);
emp.setSalary(salary);
emp.setBounds(bounds);
emp.setDept_id(dept_id);
//装载集合
empList.add(emp);
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
//调用工具类，释放资源（用了方法重载的机制）
JDBCUtils.close(rs,statement,connection);
}
//返回结果
return empList;
}
}
使用PreparedStatement执行sql对象：
1.SQL注入问题：在拼接sql时，有一些特殊的关键字与字符串的拼接，会造成安全性的问题
输入用户随便，密码为：a’ or ‘a’=‘a
sql: select *from user where username= ’ suibian’ pssword=’ a’ or ‘a’=‘a ’
2.结局sql注入问题：使用PreparedStatement对象来解决
3.预编译的SQL：参数使用？做为占位符
4.步骤
1. 导入jar包
2. 注册驱动
Class.forName(“com.mysql.jdbc.Driver”);
3.获取数据库连接对象
Connection conn = DriverManager.getConnection(“jdbc:mysql://localhost:3306/db3”, “root”, “root”);
4.定义sql–注意sql的占位符为？
select * from user where username=’?’ and password =’?’;
5.获取执行sql语句statement，使用connection的preparedStatement方法创建对应的preparedStatement对象
conn.preparedStatement(String sql);
6.给?赋值
方法：setXxx(参数1，参数2)
参数1的位置编号从1开始
参数2的位置编号从2开始
7.执行sql，定义返回结果影响行数，不需要传递参数语句
8.处理结果
9.释放资源
实例代码如下，以后的代码都是使用PreparedStatement，可以防止依赖注入并且效率更高：
/**
*使用PreparedStatement
*/
public class JDBCDemo7 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名：");
String username = scanner.nextLine();
System.out.println("请输入密码：");
String password = scanner.nextLine();
boolean login = new com.itcast.jdbc.JDBDDemo6().login(username, password);
if (login){
System.out.println("登陆成功！！！");
}else{
System.out.println("登陆失败，用户名或者密码有误，请重新输入");
}
}
public boolean login2(String username, String password){
if (username==null||password==null){
System.out.println("请输入用户名或密码");
return false;
}
Connection connection = null;
PreparedStatement statement = null;
ResultSet resultSet = null;
try {
connection = JDBCUtils.getConnection();
String sql = "select * from user where username =? and password =?";
statement = connection.prepareStatement(sql);
statement.setString(1,username);
statement.setString(2,password);
resultSet = statement.executeQuery();
return resultSet.next();
} catch (SQLException e) {
e.printStackTrace();
}finally {
JDBCUtils.close(resultSet,statement,connection);
}
return false;
}
}
小练习，用户登录操作，示例代码如下：
public class JDBDDemo6 {
/**
* 登录
* 1.调用scanner方法，接受键盘传入的值
* 2.调用本类的login方法，传入参数
* 3.判断，如果用户名密码存在，返回true否则返回false（执行原理，使用sql语句，条件查询
* 将键盘输入的username和password作为参数传入方法，与数据库中的方法进行比对）
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名：");
String username = scanner.nextLine();
System.out.println("请输入密码：");
String password = scanner.nextLine();
boolean login = new JDBDDemo6().login(username, password);
if (login){
System.out.println("登陆成功！！！");
}else{
System.out.println("登陆失败，用户名或者密码有误，请重新输入");
}
}
/**
* 基本思路
*
* 1.创建一个含有两个参数的login方法
* 2.先对键盘传入的参数进行判断，非空的话直接return false
* 3.调用JDBCUtils的getConnection方法连接数据库
* 4.因为是查询语句，将connection、statement、resultset对象，在try catch代码块外创建，方便后面作为参数释放资源
* 5.定义sql语句
* 6.创建sql执行对象statement
* 7.执行sql语句，如果条件查询有结果 直接返回结果集
* 8.释放资源
*
*/
public boolean login(String username, String password){
if (username==null||password==null){
System.out.println("请输入用户名或密码");
return false;
}
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try {
connection = JDBCUtils.getConnection();
String sql = "select * from user where username ='"+username+"'and password ='"+password+"'";
statement = connection.createStatement();
resultSet = statement.executeQuery(sql);
return resultSet.next();
} catch (SQLException e) {
e.printStackTrace();
}finally {
JDBCUtils.close(resultSet,statement,connection);
}
return false;
}
}
- JDBC控制事务
- 事务：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。
- 操作：
- 开启事务
- 提交事务
- 回滚事务
- 使用Connection对象来管理事务
- 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
** 在执行sql之前开启事务 - 提交事务：commit()
** 当所有sql都执行完提交事务 - 回滚事务：rollback()
** 在catch中回滚事务
- 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
- 数据库连接池针对（之前的代码每一次执行都要获取一次连接，执行完成之后释放，极为浪费资源）
1. 基本原理：是一个容器（集合），存放数据库连接对象的容器。
JDBC原始操作是访问一次数据库创建一次连接对象，用完就释放，数据库连接池的作用是将常规释放掉的连接对象回收再连接池中，这时候数据库直接从连接池里面拿连接对象使用，是用完之后，业务结束，在归还连接对象至连接池，避免了大量的资源浪费，让连接对象可以复用。
2. 好处：
1. 节约资源
2.用户访问更高效
3. 实现：
1.标准接口： DataSource javax.sql包下的一个接口
方法：
获取连接：getConnection
规范连接：如果连接对象从连接池中获取，那么connection.close();方法则不会关闭连接而是归还连接对象
２.因为是sun公司提供的接口，都是通过数据库编写驱动去实现的
常用的数据库连接池技术：
C3P0：数据库连接池技术
Druid：阿里巴巴的数据库连接池技术
4. C3P0：数据库连接技术
1. 导入jar包 c3p0-0.9.5.2.jar，mchange-commons-java-0.2.12.jar
2. 定义配置文件
名称为：c3p0.properties or c3p0-config.xml
路径：直接把配置文件放在src目录下即可
3. 创建核心对象 数据库连接池对象 ComboPooledDataSource
4. 获取连接 getConnection
示例代码如下：
配置文件：
<c3p0-config>
<!-- 使用默认的配置读取连接池对象 -->
<default-config>
<!-- 连接参数 -->
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/db5</property>
<property name="user">root</property>
<property name="password">root</property>
<!-- 连接池参数 -->
<property name="initialPoolSize">5</property>
<property name="maxPoolSize">10</property>
<property name="checkoutTimeout">3000</property>
</default-config>
<named-config name="otherc3p0">
<!-- 连接参数 -->
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/db3</property>
<property name="user">root</property>
<property name="password">root</property>
<!-- 连接池参数 -->
<property name="initialPoolSize">5</property>
<property name="maxPoolSize">8</property>
<property name="checkoutTimeout">1000</property>
</named-config>
</c3p0-config>
public class c3 {
public static void main(String[] args) throws SQLException {
DataSource ds = new ComboPooledDataSource();
Connection connection = ds.getConnection();
System.out.println(connection);
}
}
- Druid 数据库连接池技术
1. 导入jar包
2. 定义配置文件
3. 加载配置文件
4. 获取数据库连接对象：通过工厂获取 DruidDatSourceFactory
5. 获取连接 getConnection
示例代码如下：
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db5
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000
- 定义Druid工具类
1. 定义一个JDBCUtils
2.获取静态代码块加载配置文件，初始化连接对象
3. 提供方法
1. 获取连接方法：通过数据库连接池获取连接
2. 释放资源
3. 获取连接池的方法
示例代码如下：
public class Druid2 {
public static void main(String[] args) {
/**
* 添加操作
*/
Connection connection = null;
PreparedStatement preparedStatement=null;
try {
connection = JDBCUtils.getC();
String sql = "insert into account values(null,?,?)";
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1,"san");
preparedStatement.setDouble(2,5000);
int i = preparedStatement.executeUpdate();
System.out.println(i);
} catch (SQLException e) {
e.printStackTrace();
}finally {
JDBCUtils.close(preparedStatement,connection);
}
}
}
##Spring JDBC
spring框架对jdbc的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
步骤：
1. 导入jar包
2.创建JdbcTemplate对象，依赖于数据源DataSource
JdbcTemplate template = new JdbcTemplate(ds);
3.调用JDBCTemplate的方法完成CRUD的操作
update()
queryForMap():将查询结果封装为map集合
(这个方法查询的结果集长度只能为1)
queryForList():将查询结果封装为list集合
(将每一条记录封装为一个Map集合，在封装到List集合中)
query():查询结果封装为javaBean对象
(query的参数为RowMapper，一般使用beanPropertyRowMapper实现类，可
以完成JavaBean的自动封装)
格式：new BeanPropertyRowMapper<类型>(类型.class)
queryForObject:查询结果封装为对象
(一般用于结婚函数的查询)
2542
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
