关于java:Java开发之JDBC学习分享

数据库的操作步骤:

1:导入数据库的驱动jar包—-> 导入实现类

2:加载驱动 —–> 通知他我要连贯哪个数据库

3:取得连贯——>让我和数据库产生关系

4:取得预处理语句对象->让我发送sql指令到数据库

5:执行SQL命令；—>预处理语句对象.execute(“SQL 命令行”);

6:开释资源 ——-> 切断我和数据库的分割

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import org.junit.Test;

public class JDBCTest {

@Test
public void testJDBC() throws Exception {

// 1.加载驱动
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        Class.forName("com.mysql.jdbc.Driver");//间接应用此形式：因为底层曾经实现下面的步骤
// 2:取得连贯----->让java程序和数据库建立联系 . 让程序和数据库产生关系
Connection connection = DriverManager.getConnection("jdbc:mysql://IP地址:端口号（默认3306）/数据库的名字", "root", "root");
// 3:取得预处理语句对象-->让java发送SQL语句到数据库
Statement statement = connection.createStatement();
// 4.执行须要执行的SQL语句
statement.execute("create table girl(id int , name varchar(20),age int);");
// 4:开释资源
statement.close();
connection.close();

}
}

如何找到你要操作的数据集库：

写死 jdbc:不同的数据库的厂商名://ip地址:端口号/数据库的库名

操作mysql形式1：jdbc:mysql://localhost:3306/数据库的库名

操作mysql形式2：jdbc:mysql://127.0.0.1:3306/数据库的库名

如果操作的数据库在本机 ,并且数据库的端口号是 3306

能够简写形式：jdbc:mysql:///数据库的库名

抽取工具类：DAO标准的设计

标准DAO组件的类名以及包名. 域名java培训倒写.模块名.组件名—-> cn.wolfcode.smis

1.定义domain包以及类名(操作DAO都是去操作一张表,表应该对应着一个javabean, 取一个非凡的名字domain)

cn.wolfcode.smis.domain

Student.java

2.定义DAO包以及DAO接口.

cn.wolfcode.smis.dao

IxxxDAO—> XXX示意domain.

IStudentDAO.java

3.定义DAO实现类的包以及实现类

cn.wolfcode.smis.dao.impl

StudentDAOImpl.java

4.测试类

cn.wolfcode.smis.test

StudentDAOImplTest.java

5.工具类

cn.wolfcode.smis.util

JDBCUtil.java

标准的开发步骤—实现保留操作:

1.创立数据库表.

2.依据数据库表创立对应的domain包和类.

留神:表的列的名字和类型与类的属性名和类型要一一匹配.

3.通过domain来创立DAO包以及接口.

4.依据接口生成实现类.

5.依据接口/实现类生成测试类.实现测试的代码.

6.实现一个办法,测试一个办法,测试通过,再写写一个办法.

预编译语句对象-PreparedStatement:

预编译语句对象-PreparedStatement:

PreparedStatement是动态语句对象的子类.所以,父类中的所有的办法都能够调用到.然而个别咱们不会调用.调用本人特有的办法.

预编译语句对象是通过带有占位符的SQL模板来创建对象的.

SQL模板:带有占位符?的SQL.雷同的操作,SQL语句其实是一样的,仅仅是参数不一样而已.

参数确定不了,应用占位符?来示意.

常见API:

获取预编译语句对象.

应用数据库连贯对象:

PreparedStatement prepareStatement(String sql); 传递的是SQL模板,有占位符

2.在执行SQL之前,肯定要给占位符设置值.

void setObject(int parameterIndex,Object x):

parameterIndex: 参数索引,在JDBC中,索引是从1开始的.

3.执行SQL命令:

留神,不要调用父类带有参数的办法.

DQL操作：增删改

在JDK中,把如何解析后果集的操作,封装到了一个对象中.ResultSet.

需要:

1.查问id为10的学生信息

2.查问所有的学生信息.

ResultSet对象:

把如何解析后果集的过程封装成了对象.

boolean next(): 往下挪动一行,如果返回true,示意有数据,否则没有数据.要获取数据,肯定要调用next办法.

Object getObject(int columnIndex): 依据列的地位来取数据.索引从1开始.

Object getObject(String columnLabel): 依据列名来获取数据

优化：

1.连贯数据库四因素反复写很多遍(抽取到公共的地位,只写一遍).

2.Class.forName加载字节码,字节码只会加载一次(应用动态代码块去加载注册驱动).

3.硬编码.(连贯数据库四因素).

4.代码反复(DML操作, DQL操作).

5.每次获取数据库连贯对象,用完间接就敞开了.节约.

代码：

配置文件：

符号javaBean的Student类：

DAO接口的定义：

接口的测试类：

JDBC的工具类：

package cn.wolfcode.smis.util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

//工具类
public class MyJDBCUtil {
// 私有化结构器
private MyJDBCUtil() {
}

static Properties p = new Properties();
// 动态代码块
static {

try {
  // 加载配置文件
  p.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("pd.properties"));
  // 加载驱动器
  Class.forName(p.getProperty("driverClassName"));
} catch (Exception e) {
  e.printStackTrace();
}

}

// 取得连贯对象
public static Connection getConnection() {

Connection connection = null;
try {
  connection = DriverManager.getConnection(p.getProperty("url"), p.getProperty("username"),
      p.getProperty("password"));
} catch (Exception e) {
  e.printStackTrace();
}
return connection;

}

// 敞开资源
public static void close(Connection connection, Statement statement) {

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

}

// 重载敞开资源
public static void close(Connection connection, Statement statement, ResultSet resultSet) {

try {
  if (statement != null) {
    statement.close();
  }
} catch (SQLException e) {
  e.printStackTrace();
}
try {
  if (connection != null) {
    connection.close();
  }
} catch (SQLException e) {
  e.printStackTrace();
}
try {
  if (resultSet != null) {
    resultSet.close();
  }
} catch (SQLException e) {
  e.printStackTrace();
}

}

接口的实现类：

package cn.wolfcode.smis.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import cn.wolfcode.smis.dao.IStudentDAO;
import cn.wolfcode.smis.domain.Student;
import cn.wolfcode.smis.util.MyJDBCUtil;

public class StudentDAOImpl implements IStudentDAO {

@Override
public void insert(Student student) {

// 取得连贯对象
Connection connection = MyJDBCUtil.getConnection();
// 取得预编译对象
PreparedStatement statement = null;
try {
  statement = connection.prepareStatement("insert into student(id,name,age)  values(?,?,?)");
  // 设置站位符
  statement.setObject(1, student.getId());
  statement.setObject(2, student.getName());
  statement.setObject(3, student.getAge());
  // 执行
  statement.execute();
} catch (Exception e) {
  e.printStackTrace();
} finally {
  // 敞开资源
  MyJDBCUtil.close(connection, statement);
}

}

@Override
public void delete(Long id) {

// 取得连贯对象
Connection connection = MyJDBCUtil.getConnection();
// 取得预编译对象
PreparedStatement statement = null;
try {
  statement = connection.prepareStatement("delete from student where id = ?");
  // 设置站位符
  statement.setObject(1, id);
  // 执行
  statement.execute();
} catch (Exception e) {
  e.printStackTrace();
} finally {
  // 敞开资源
  MyJDBCUtil.close(connection, statement);
}

}

@Override
public void update(Student student) {

// 取得连贯对象
Connection connection = MyJDBCUtil.getConnection();
// 取得预编译对象
PreparedStatement statement = null;
try {
  statement = connection.prepareStatement("update student set name = ? ,age = ? where id = ?");
  // 设置站位符
  statement.setObject(1, student.getName());
  statement.setObject(2, student.getAge());
  statement.setObject(3, student.getId());
  // 执行更新办法
  statement.executeUpdate();
} catch (Exception e) {
  e.printStackTrace();
} finally {
  // 敞开资源
  MyJDBCUtil.close(connection, statement);
}

}

@Override
public Student selectOne(Long id) {

// 取得连贯对象
Connection connection = MyJDBCUtil.getConnection();
// 取得预编译对象
PreparedStatement statement = null;
Student student = null;
try {
  statement = connection.prepareStatement("select * from student where id = ?");
  // 设置站位符
  statement.setObject(1, id);
  // 执行查问，返回后果集
  ResultSet resultSet = statement.executeQuery();
  if (resultSet.next()) {// 后果集中有元素
    // 失去后果集中的元素---->后果集中是一个个字段对应的值，听过字段名取得值，而后创立个对象返回
    Object name = resultSet.getObject("name");
    Object age = resultSet.getObject("age");
    // 创建对象
    student = new Student(id, (String) name, (Integer) age);
  }
} catch (Exception e) {
  e.printStackTrace();
} finally {
  // 敞开资源
  MyJDBCUtil.close(connection, statement);
}
return student;

}

@Override
public List<Student> selectAll() {

// 创立List
List<Student> list = new ArrayList<>();
// 取得连贯对象
Connection connection = MyJDBCUtil.getConnection();
// 取得预编译对象
PreparedStatement statement = null;
try {
  statement = connection.prepareStatement("select * from student");
  // 执行查问，返回后果集
  ResultSet resultSet = statement.executeQuery();
  // if (resultSet.next()) {// 后果集中有元素
  // 用while循环将后果集中所有的元素取出来
  while (resultSet.next()) {
    // 失去后果集中的元素---->后果集中是一个个字段对应的值，听过字段名取得值，而后创立个对象返回
    Object id = resultSet.getObject("id");
    Object name = resultSet.getObject("name");
    Object age = resultSet.getObject("age");
    // 创建对象并将对象增加进list中
    list.add(new Student((Long) id, (String) name, (Integer) age));
  }
} catch (Exception e) {
  e.printStackTrace();
} finally {
  // 敞开资源
  MyJDBCUtil.close(connection, statement);
}
return list;

}

上述代码仍然有反复：应用模板办法可再进行优化。

注入问题：经典案例登录平安问题；

@Test
public void testLogin() throws Exception {

// 模仿账户的登录,了解 statement和preparestatement的区别
String username = "will";
// String password = "123456";
// 注入问题
String password = "' or '1'='1";
// loginByStatement(username, password);
// loginByPrepareStatement(username, password);
loginByPrepareStatement1(username, password);

}

// 没有应用预处理语句对象:不平安 String password = “‘ or ‘1’=’1”;时能够屏蔽SQL语句的语义。导致胜利登录
private void loginByStatement(String username, String password) throws Exception {

// 验证 username 和 password 在数据库中的表 是否存在这一条数据
Connection connection = JDBCUtil.getConnection();
Statement statement = connection.createStatement();
String sql = "select * from user where username = '" + username + "' and password = '" + password + "'";
ResultSet resultSet = statement.executeQuery(sql);
if (resultSet.next()) {
  System.out.println("登录胜利");
} else {
  System.out.println("账户或者明码谬误,登录失败");
}
JDBCUtil.close(connection, statement, resultSet);

}

// 模仿登录案例—>应用预处理对象：平安
private void loginByPrepareStatement1(String username, String password) throws Exception {

// 把参数和数据库中的客户信息比照，雷同能力登录胜利
// 1连贯数据库
Connection connection = JDBCUtil.getConnection();
// 2取得预处理语句对象
PreparedStatement statement = connection
    .prepareStatement("select * from user where username = ? and password = ?");
// 2.1设置占位符
statement.setObject(1, username);
statement.setObject(2, password);
// 3查问后果
ResultSet resultSet = statement.executeQuery();
// 判断数据库中是否有这条用户数据
if (resultSet.next()) {
  System.out.println("登录胜利！");
} else {
  System.out.println("账户不存在！登录失败！！");
}
// 敞开资源
JDBCUtil.close(connection, statement, resultSet);

}

事务：经典案例，转账平安问题。

冀望后果:如果转账胜利,那么数据发生变化.如果转账失败,那么账户余额不应该扭转,应该还是转账之前的状态.

下面这种操作,就是数据库中的事务操作.

事务(Transaction,简写为tx):

在数据库中,所谓事务是指一组逻辑操作单元,使数据从一种状态变换到另一种状态。

为确保数据库中数据的一致性,数据的操纵该当是离散的成组的逻辑单元:

当每个逻辑操作单元全副实现时,数据的一致性能够放弃,

而当这个单元中的一部分操作失败,整个事务应全副视为谬误,所有从起始点当前的操作应全副回退到开始状态。

事务的操作:

先定义开始一个事务,而后对数据作批改操作,这时如果提交(commit),这些批改就永恒地保留下来,如果回退(rollback),数据库管理系统将放弃您所作的所有批改而回到开始事务时的状态。

事务：指形成单个逻辑工作单元的操作汇合

事务处理：保障所有事务都作为一个工作单元来执行，即便呈现了故障，都不能扭转这种执行形式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，要么整个事务回滚(rollback)到最后状态

说白了:

1.须要把多个操作放在一起作为一个整体.

2.全副胜利,才叫胜利,否则一个失败,全副都失败.

事务的ACID属性:

原子性（Atomicity）:原子在化学中,是最小单位,不能够再宰割了.

原子性是指事务是一个不可分割的工作单位，事务中的操作要么都产生，要么都不产生。

一致性（Consistency):保证数据的完整性.

事务必须使数据库从一个一致性状态变换到另外一个一致性状态。(数据不被毁坏)

隔离性（Isolation）:

事务的隔离性是指一个事务的执行不能被其余事务烦扰，即一个事务外部的操作及应用的数据对并发的其余事务是隔离的，并发执行的各个事务之间不能相互烦扰。

持久性（Durability）:

持久性是指一个事务一旦被提交，它对数据库中数据的扭转就是永久性的，接下来的其余操作和数据库故障不应该对其有任何影响

事务相干的细节:

1):默认状况下,事务在执行完DML操作就主动提交.

2):查问操作,其实是不须要事务的.然而,个别的,咱们在开发中都把查问放入事务中.

3):开发中,代码完全正确,没有异样,然而就是数据库中数据不变.

意识:可能没有提交事务.

4):在MySQL中,只有InnoDB存储引擎反对事务,反对外键,MyISAM不反对事务.

5):当前事务咱们不应该在DAO层解决,应该在service层管制(提出).

6):事务在解说框架和我的项目的时候都会再讲.

事务操作,在一次连贯中进行屡次操作.须要将多个操作放在一个整体中,就须要应用事务.

操作模板:

try{
// 手动开启一个事务
conn.setAutoCommit(false);
操作1…
操作2…
操作N…
// 全副胜利,提交事务
conn.commit();
} catch(Exception e){
// 异样代码解决
// 如果失败,须要回滚
conn.rollback();
} finally{
// 敞开资源
}

留神:

只有在调用了commit办法之后,数据库才会真正的发生变化.全副胜利,调用commit办法.如果失败了肯定要调用rollback办法.

起因:在开启事务的时候,就有一个事务锁的存在.必须要调用commit或者rollback才能够开释.

@Test
public void testTransaction() {

// 模仿转账的成果 西门吹雪 转账给 菠萝吹雪 1000钱。如果转账过程中出现异常，则金额不应该产生扭转。// 1:先判断 西门吹雪 有没有钱
Connection connection = JDBCUtil.getConnection();
PreparedStatement statement = null;
ResultSet resultSet = null;
try {
  // 勾销主动提交，让残缺的事物执行完后再进行收动提交
  connection.setAutoCommit(false);
  statement = connection.prepareStatement("select * from account where name = '西门吹雪' and balance >= 1000");
  resultSet = statement.executeQuery();
  // 只有金额足够能力转账
  if (resultSet.next()) {
    System.out.println("开始转账");
    // 西门吹雪的 钱 缩小1000
    statement.executeUpdate("update account set balance = balance - 1000 where name = '西门吹雪'");
    // int ret = 10 / 0;//制作异样---->如果转账过程中出现异常，则金额不应该产生扭转。// 菠萝吹雪金莲的钱 减少 1000
    statement.executeUpdate("update account set balance = balance + 1000 where name = '菠萝吹雪'");


    // 手动提交事务
    connection.commit();
  } else {
    System.out.println("没钱!!!,我的二叔是公安局长");
  }
} catch (Exception e) {
  System.out.println("转账异常中断！");
  e.printStackTrace();
  // 回退：出现异常时，将事务回退到最开始的状态。---->只有呈现异常中断时才须要回退，所以放到catch语句中
  try {
    connection.rollback();
  } catch (SQLException e1) {
    e1.printStackTrace();
  }
} finally {
  // 敞开资源：无论如何最初都要敞开资源
  JDBCUtil.close(connection, statement, resultSet);
}

}

取得主动生成的主键：取得注册后信息

1.设置一个标记,给数据库说,我要主动生成的主键.

在获取预编译语句对象的时候,传递要获取的标记.

Statement.RETURN_GENERATED_KEYS .

2.获取主动生成的主键.

// 模仿注册后显示id和注册时的信息
@Test
public void testInsert() throws Exception {

// 注册时的输出的信息
String username = "天河首富";
String password = "lh0030";
// 取得连贯对象
Connection connection = JDBCUtil.getConnection();
String sql = "insert into user (username,password) values(?,?)";
// 取得预处理语句对象
PreparedStatement statement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);// 取得主动生成的主键
// 设置占位符的值
statement.setObject(1, username);
statement.setObject(2, password);
// 执行更新操作
statement.executeUpdate();
// 把主动生成的主键放到了一个后果集对象中
ResultSet keys = statement.getGeneratedKeys();
// 如果插入胜利就返回主键和插入的信息
if (keys.next()) {
  // 获取主动生成的主键
  long id = (long) keys.getObject(1);
  System.out.println(id + "  " + username + "  " + password);
}
// 敞开资源
JDBCUtil.close(connection, statement, keys);

}

数据库连接池：

目前咱们操作数据库的形式:

1.获取数据库连贯对象.

2.执行SQL命令

3.解析后果集.

4.敞开资源(后果集对象,预编译语句对象,数据库连贯对象)

执行完了一个SQL命令之后,就会敞开数据库连贯对象.问题就出在这里.

为什么必须应用数据库连接池:

一般的JDBC数据库连贯(Connection对象)应用 DriverManager 来获取，每次向数据库建设连贯的时候都要将 Connection 加载到内存中，再验证用户名和明码(得破费0.05s～1s的工夫),数据库的连贯是比拟低廉的(创立的老本比拟大)。

须要数据库连贯的时候，就向数据库要求一个，执行实现后再断开连接。这样的形式将会耗费大量的资源和工夫。

数据库的连贯资源并没有失去很好的反复利用.若同时有几百人甚至几千人在线，频繁的进行数据库连贯操作将占用很多的系统资源，重大的甚至会造成服务器的解体。

对于每一次数据库连贯，应用完后都得断开。否则，如果程序出现异常而未能敞开，将会导致数据库系统中的内存透露，最终将导致重启数据库。

这种开发不能管制被创立的连贯对象数，系统资源会被毫无顾及的调配进来，如连贯过多，也可能导致内存透露，服务器解体.

说白了:

以后的操作数据库的形式是,破费了大量的资源和工夫创立的十分低廉的数据库连贯对象,应用一次之后就敞开了.次要存在的问题是,没有充沛应用到数据库连贯对象.应用连接池来解决这个问题.

池化技术:治理资源对象,达到最高的效率.

池化技术可能缩小资源对象的创立次数，进步程序的性能，特地是在高并发下这种进步更加显著。应用池化技术缓存的资源对象有如下独特特点：

1，对象创立工夫长；

2，对象创立须要大量资源；3，对象创立后可被重复使用。比方thread，connection等对象都具备下面的几个独特特点。

在Java中,连接池应用javax.sql.DataSource接口来示意连接池.

DataSource(数据源)和连接池(Connection Pool)是同一个.

留神:DataSource仅仅只是一个接口,由各大服务器厂商来实现(Tomcat,JBoss).

罕用的DataSource的实现:

DBCP: Spring框架举荐的

druid: 阿里巴巴的连接池(号称Java语言中性能最好的连接池)德鲁伊.

==============================================================

应用连接池和不应用连接池的区别在哪里?

如何获取Connection对象:

未应用连接池:

Connection conn = DriverManager.getConnection(url,username,password);

应用了连接池:

datasource对象.getConnection();// 返回的连贯对象曾经是一个性能加强的连贯对象了.

只有获取了Connection对象,接下来的操作和以前是截然不同的.

关键在于:如何创立DataSource对象.

如何开释Connection对象(Connection对象.close()):

未应用连接池: 是和数据库服务器断开.

应用了连接池: 还给连接池.

应用数据库连接池创立JDBC的工具类：

形式1：

import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

//JDBC工具类
public class JDBCUtil {
// 私有化结构器
private JDBCUtil() {
}

static Properties p = new Properties();
static {

try {
  p.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
  Class.forName(p.getProperty("driverClassName"));


} catch (IOException e) {
  System.err.println("你的配置文件加载不到");
  e.printStackTrace();
} catch (ClassNotFoundException e) {
  e.printStackTrace();
}

}

// 取得数据库的连贯对象
public static Connection getConnection() {

// 取得 资源文件夹中的db.properties文件中数据库连贯信息
Connection connection = null;
try {
  connection = DriverManager.getConnection(p.getProperty("url"), p.getProperty("username"),
      p.getProperty("password"));
} catch (SQLException e) {
  e.printStackTrace();
}
return connection;

}
}

形式2：

import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import javax.sql.DataSource;

import com.alibaba.druid.pool.DruidDataSourceFactory;//德鲁伊的jar包

//JDBC工具类
public class JDBCUtil {
// 私有化结构器
private JDBCUtil() {
}

static DataSource source = null;
static {

try {
  Properties p = new Properties();
  p.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
  //这种形式创建对象
  source = DruidDataSourceFactory.createDataSource(p);
} catch (IOException e) {
  e.printStackTrace();
} catch (Exception e) {
  e.printStackTrace();
}

}

// 取得数据库的连贯对象
public static Connection getConnection() {

Connection connection = null;
try {
  connection = source.getConnection();
} catch (SQLException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
}
return connection;

}
//省略关流操作，关流没变
}

关于java:Java开发之JDBC学习分享

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于java:Java开发之JDBC学习分享

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复