Tabla de contenido
Nivel 1: base de datos de conexiones JDBC
Cargue el controlador de la base de datos
Ejecutar la declaración SQL escrita
Nivel 2: Operaciones JDBC sobre datos en tablas
Especificar la conexión de la base de datos
Insertar datos en la tabla especificada
Consultar los datos de la tabla.
Elementos Básicos de las Transacciones (ACID)
Nivel 1: base de datos de conexiones JDBC
información relacionada
JDBC API
Se proporcionan las siguientes interfaces y clases:
DriverManager
: Lista de controladores de bases de datos de gestión para esta clase. JDBC
El primer controlador bajo el cual se reconoce y utiliza un subprotocolo para establecer una conexión de base de datos.
Driver
: Esta interfaz maneja la comunicación con el servidor de la base de datos. Rara vez Driver
interactuamos directamente con los objetos. Para conectarse a la base de datos en la programación, primero debe cargar el controlador de la base de datos de un proveedor específico.
Connection
: Esta interfaz tiene todos los métodos para contactar con la base de datos. Connection
El objeto representa el contexto de comunicación, es decir, toda la comunicación con la base de datos pasa únicamente por el objeto de conexión.
Statement
: Un objeto utilizado para ejecutar una SQL
declaración estática y devolver el resultado que genera. Algunas interfaces derivadas también pueden aceptar parámetros, por ejemplo PrepareStatement
, .
ResultSet
: Proporciona métodos para recuperar campos de diferentes tipos. (El objeto de la operación es el resultado después de Statement
ejecutar SQL
la consulta)
SQLException
: esta clase maneja cualquier error que ocurra en la aplicación de la base de datos.
Los pasos utilizados JDBC
son los siguientes:
Cargue el controlador de la base de datos → establezca una conexión con la base de datos ( Connection
) → cree un objeto SQL
para ejecutar la declaración Statement
→ procese el resultado de la ejecución ( ResultSet
) → libere recursos
Para completar esta tarea, debe dominar: 1. Cómo cargar el controlador de la base de datos, 2. Cómo establecer una conexión con la base de datos, 3. Cómo ejecutar la SQL
declaración escrita, 4. Liberar recursos.
Cargue el controlador de la base de datos
El controlador se carga para abrir el canal de comunicación con la base de datos.
Antes de registrar el controlador, debemos cargar el controlador de base de datos específico del proveedor y el mysq-connector-java
paquete importado jar
. El método consiste en crear un directorio en el proyecto lib
y colocar el paquete debajo jar
.
Luego haga clic con el botón derecho jar
en el paquete Build Path
→ importación Add to Build Path
completa jar
del paquete. Después de importar jar
el paquete al proyecto, comenzamos a registrar el controlador:
Java
La carga del controlador de la base de datos generalmente usa Class
el método estático de la clase forName()
y el formato de sintaxis es el siguiente:
Class.forName(String driverManager)
Ejemplo:
try {
Class.forName("com.mysql.jdbc.Driver" );
} catch (ClassNotFoundException e) {
e.printStackT\frace();
}
Si la carga es exitosa, la clase de controlador cargada se registrará con DriverManager
; si la carga falla, ClassNotFoundException
se lanzará una excepción.
establecer conexión
Después de cargar con éxito el controlador de la base de datos, puede establecer una conexión a la base de datos utilizando el DriverManager
método estático getConnection()
para lograrlo. como sigue:
Connection conn = DriverManager.getConnection(url, user, password);
URL
URL
Se utiliza para identificar la ubicación de la base de datos y comunicar la información de conexión del programa a través de la dirección JDBC
.
Si no hay base de datos, solo establezca una conexión, URL
escrita como:
Si hay una base de datos test
, URL
el método de escritura es:
localhost
Se puede reemplazar con IP
una dirección 127.0.0.1
, 3306
que es MySQL
el número de puerto predeterminado de la base de datos, user
y password
el nombre de usuario y la contraseña de la base de datos correspondiente.
Ejecutar la SQL
declaración escrita
Una vez establecida la conexión, puede usar el método Connection
de la interfaz createStatement()
para obtener Statement
el objeto y executeUpdate()
ejecutar SQL
la declaración a través del método.
-
crear
statement
objetotry {
Statement statement = conn.createStatement();
} catch (SQLException e) {
e.printStackT\frace();
}
-
crear base de datos
try {
String sql1="drop database if exists test";
String sql2="create database test";
statement.executeUpdate(sql1);//执行sql语句
statement.executeUpdate(sql2);
} catch (SQLException e) {
e.printStackT\frace();
}
-
crear mesa
try {
statement.executeUpdate("use test");//选择在哪个数据库中操作
String sql = "create table table1(" +
"column1 int not null, " +
"column2 varchar(255)" +
")";
statement.executeUpdate(sql);
} catch (SQLException e) {
e.printStackT\frace();
}
liberar recursos
Jdbc
Después de que el programa se esté ejecutando, recuerde liberar los objetos que el programa creó durante el proceso de ejecución para que interactúen con la base de datos, estos objetos suelen ser y ResultSet
objetos .Statement
Connection
Especialmente Connection
los objetos, que son recursos muy escasos, deben liberarse inmediatamente después de su uso. Si Connection
no se pueden cerrar de manera oportuna y correcta, fácilmente se producirá un tiempo de inactividad del sistema.
Connection
El principio de uso es crear lo más tarde posible y publicar lo antes posible.
Para garantizar que el código de liberación de recursos se pueda ejecutar, el código de liberación de recursos debe colocarse finally
en la declaración.
finally {
try {
if(statement!=null)
statement.close();
if(conn!=null)
conn.close();
} catch (SQLException e) {
e.printStackT\frace();
}
}
requisitos de programación
Complemente el código en el editor de la derecha y complete las siguientes tareas correspondientes:
-
Cargue el controlador de la base de datos; [El usuario ( ) de la conexión de la base de datos de la plataforma
user
esroot
, y la contraseña (password
) es123123
] -
Crear una base de datos
mysql_db
; -
Crear tablas
student
.
student
La estructura de la tabla es:
nombre del campo | tipo | Observación | restricción |
---|---|---|---|
identificación | En t | Identificación del Estudiante | no vacío |
nombre | varchar(20) | nombre del estudiante | ninguno |
sexo | varchar(4) | sexo del estudiante | ninguno |
edad | En t | edad del estudiante | ninguno |
//jdbcConn.java
package jdbc;
import java.sql.*;
public class jdbcConn {
public static void getConn() {
try {
// 1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
/********** End **********/
/********** Begin **********/
Connection conn = null;
Statement statement = null;
try {
// 2.建立连接并创建数据库和表
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/", "root", "123123");
String sql1 = "drop database if exists mysql_db;";
String sql2 = "create database mysql_db;";
statement = conn.createStatement();
statement.execute(sql1);
statement.execute(sql2);
statement.execute("use mysql_db");
String sql3 = "create table student(id int not null,name varchar(20),sex varchar(4),age int)";
statement.execute(sql3);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (statement != null)
statement.close();
if (conn != null)
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
//test1.java
package jdbcTest;
import jdbc.jdbcConn;
import java.sql.*;
public class Test1 {
public static void main(String[] args) throws SQLException {
jdbcConn.getConn();
try {
Class.forName("com.mysql.jdbc.Driver" );
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
String url = "jdbc:mysql://localhost:3306/mysql_db";
Connection conn = DriverManager.getConnection (url,"root","123123" );
PreparedStatement pst = null;
try {
pst = conn.prepareStatement("select * from student");
ResultSetMetaData rsd = pst.executeQuery().getMetaData();
for(int i = 1; i <= rsd.getColumnCount(); i++) {
String columnTypeName = rsd.getColumnTypeName(i);
String columnName = rsd.getColumnName(i);
int columnDisplaySize = rsd.getColumnDisplaySize(i);
System.out.println(columnName+" "+columnTypeName+"("+columnDisplaySize+")");
}
} catch(SQLException e) {
throw new RuntimeException(e);
} finally {
try {
if (pst!=null)
pst.close();
if (conn != null)
conn.close();
} catch(SQLException e) {
throw new RuntimeException(e);
}
}
}
}
Nivel 2: Operaciones JDBC sobre datos en tablas
información relacionada
Especificar la conexión de la base de datos
Cuando ya tenemos una base de datos, podemos especificar la base de datos directamente al conectarnos, de la siguiente manera para establecer test_db
una conexión con la base de datos:
String url = "jdbc:mysql://localhost:3306/test_db";
Connection conn = DriverManager.getConnection (url,"root","123123" );
Cuando se especifica la base de datos al conectarse, no necesitamos escribir SQL
una declaración para seleccionar la base de datos.
Insertar datos en la tabla especificada
sql
Una vez establecida la conexión, escriba una declaración para insertar datos en la tabla y use el método Statement
del objeto executeUpdate()
para ejecutar la sql
declaración para modificar los datos en la tabla (este método es aplicable a las declaraciones de insert
, update
, ). una declaración de consulta, utilice el método:delete
sql
sql
executeQuery()
try {
Statement statement = conn.createStatement();
statement.executeUpdate("insert into table1(column1,column2) values(101,'xxx')");
} catch (SQLException e) {
e.printStackT\frace();
}
Declaración preparada
El uso directo mencionado anteriormente Statement
inserta datos en la tabla, y existe SQL
un riesgo de inyección durante la operación, que se separa de la tabla mencionada anteriormente, como en el siguiente ejemplo:
String id = "5";
String sql = "delete from tablename where id=" + id;
Statement st = conn.createStatement();
st.executeQuery(sql);//查询到表中将无数据
//如果用户传入的id为“5 or 1=1”,那么将删除表中的所有记录
SQL
Para evitar la inyección de esta situación , PreparedStatement
prevenga efectivamente sql
la inyección ( SQL
la declaración ha sido precompilada antes de que se ejecute el programa , y los parámetros se pasan dinámicamente cuando se ejecuta PreprareStatement
, incluso si hay caracteres confidenciales en los parámetros, como or '1=1'
la base de datos, serán utilizado como un atributo de campo del valor de los parámetros a procesar y no como una SQL
instrucción)
PreparedStatement
Utilizar de la siguiente manera:
PreparedStatement statement = conn.prepareStatement("insert into table1(column1,column2) values(?,?)");//使用占位符来先占个位置
statement.setInt(1,101);//占位符顺序从1开始,根据数据库中字段相应的类型存入数据
statement.setString(2, "XXX");//也可以使用setObject
statement.executeUpdate();//每执行一个sql语句就需要执行该方法
Consultar los datos de la tabla.
Jdbc
Se utiliza en un programa ResultSet
para representar Sql
el resultado de la ejecución de una declaración.
Resultset
Al encapsular los resultados de la ejecución, el método es similar a una tablaResultSet
. El objeto mantiene un cursor que apunta a la fila de datos de la tabla. Inicialmente, el cursor está antes de la primera fila. Llame ResultSet.next()
al método para que el cursor apunte a los datos específicos. fila y, a continuación, llame al método Obtener los datos para esta fila.
//编写查询sql语句
PreparedStatement statement = conn.prepareStatement("select * from table1");
ResultSet resultSet = statement.executeQuery();//将执行结果给ResultSet
while (resultSet.next()) {//循环判断表中是否还有数据
int id = resultSet.getInt(1);//通过列的索引查询
String name = resultSet.getString("column2");//通过列名查询
}
requisitos de programación
mysql_db
Complemente el código en el editor de la derecha, inserte datos en la tabla en la base de datos creada en el capítulo anterior student
y genere los datos insertados:
identificación | nombre | sexo | edad |
---|---|---|---|
1 | zhang san | masculino | 19 |
2 | lisi | femenino | 18 |
3 | wangwu | masculino | 20 |
Sugerencia: la clase se ha empaquetado para usted student
, puede verla en la carpeta de la derecha y esta clase se puede usar directamente.
package jdbc;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class jdbcInsert {
public static void insert(){
/********** Begin **********/
try {
//加载驱动
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
/********** End **********/
Connection conn = null;
PreparedStatement statement = null;
/********** Begin **********/
//连接并插入数据
try{
String url = "jdbc:mysql://localhost:3306/mysql_db?useUnicode=true&characterEncoding=utf8";
String user = "root";
String password = "123123";
conn = DriverManager.getConnection(url, user, password);
String sql = "insert into student(id,name,sex,age) values (1,'张三','男',19),(2,'李四','女',18),(3,'王五','男',20)";
statement = conn.prepareStatement(sql);
statement.executeUpdate();
String sql1 = "select * from student";
ResultSet rs = statement.executeQuery(sql1);
Student student = null;
while (rs.next()) {
int id = rs.getInt(1);
String name = rs.getString(2);
String sex = rs.getString(3);
int age = rs.getInt(4);
student = new Student(id, name, sex, age);
System.out.println(
student.getId() + " " + student.getName() + " " + student.getSex() + " " + student.getAge());
}
} catch (SQLException e) {
e.printStackTrace();
}
/********** End **********/
finally {
try {
if (statement != null)
statement.close();
if (conn != null)
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
Nivel 3: Transacciones JDBC
información relacionada
asuntos
Suponiendo un escenario, tenemos un sistema de administración de personal. Si desea eliminar a una persona, debe eliminar no solo la información básica de la persona, sino también la información relacionada con la persona, como buzones, artículos, etc. para que estas declaraciones de operación de la base de datos puedan ser ¡Haga una transacción!
Las transacciones controlan cuándo se confirman y aplican los cambios a la base de datos. Trata una SQL
declaración única o un grupo SQL
de declaraciones como una unidad lógica, y si alguna declaración falla, la transacción completa falla.
Elementos básicos del negocio ( ACID
)
-
Atomicidad (
Atomicity
): un grupo de transacciones, ya sea exitosas o retiradas; -
Consistencia (
Consistency
): antes y después de la transacción, no se violan las restricciones de integridad de la base de datos. Por ejemplo, cuando A transfiere dinero a B, es imposibleA
deducir el dineroB
pero no recibirlo; -
Aislamiento (
Isolation
): Las transacciones se ejecutan de forma independiente. Si el resultado del procesamiento de una transacción afecta a otras transacciones, se retirarán otras transacciones. El aislamiento de transacciones100%
requiere sacrificar la velocidad; -
Persistencia (
Durability
): una vez completada la transacción, todas las actualizaciones realizadas por la transacción en la base de datos se guardarán en la base de datos y no se podrán revertir.
transacción abierta
Abrir una cosa requiere habilitar el soporte de transacciones manuales, en lugar de usar JDBC
el modo de confirmación automática que el controlador usa de forma predeterminada, en el método Connection
del objeto invocable. setAutoCommit()
Si false
se pasa un valor booleano a setAutoCommit()
, la confirmación automática se desactiva , lo que equivale a activar las cosas. También se puede pasar un valor booleano true
para volver a activarlo.
Connection conn = DriverManager.getConnection (url,"root","123123" );
conn.setAutoCommit(false);//关闭自动提交开启事务
comprometer y retroceder
En mysql
la base de datos, el valor predeterminado es sql
enviar automáticamente cada oración. Cuando configuramos el soporte de transacción manual (es decir, la transacción se ha abierto manualmente), podemos enviar manualmente cuando necesitamos enviar:
conn.commit();//提交事务
Cuando se envían varios sql
extractos a la vez, debemos considerar sql
si son legales y, si uno de ellos es ilegal, sql
si los demás aún deben cambiarse; para garantizar los elementos básicos de la transacción, debemos llamar manualmente al reversión de transacciones para controlar sql
la ejecución de:
try{
Connection conn = DriverManager.getConnection (url,"root","123123" );
conn.setAutoCommit(false);//开启事务
PreparedStatement ps = conn.prepareStatement("insert into table1(column1,column2) values(1,'xx1')");
ps.executeUpdate();
ps = conn.prepareStatement("insert in table1(column1,column2) values(1,'xx1')");
ps.executeUpdate();
conn.commit();//提交事务
} catch (SQLException e) {
try {
conn.rollback();//回滚事务 回滚到你开始事务之前
} catch (SQLException e1) {
e1.printStackT\frace();
}
}
Después de ejecutar el código anterior, no se actualizará ningún dato en la base de datos. Debido a que la sintaxis de la segunda insert
declaración es incorrecta, la transacción se retrotrae y la anterior insert
se invalida. Por lo general, las reversiones de transacciones se colocan catch
para capturar.
Después de iniciar la transacción, asegúrese de mantenerse al día commit
o rollback
liberar los datos que puedan estar bloqueados a tiempo.
No rollback()
usarlo tiene rollback()
el mismo efecto que usarlo, pero no usarlo rollback()
puede hacer que los datos bloqueados no se liberen a tiempo (debe esperar a que se liberen las cosas con el tiempo), lo que afectará la próxima operación de transacción.
requisitos de programación
De acuerdo con el indicador, complemente el código en el editor de la derecha, escriba una SQL
declaración nueva y cualquier declaración incorrecta , y envíe la transacción; la primera declaración nueva SQL
debe modificarse en la base de datos y la siguiente SQL
declaración incorrecta no se ejecuta .
Los requisitos específicos para agregar una declaración de inserción son los siguientes: Agregue una nueva entrada en mysql_db
la tabla de la base de datos para , para Zhao Liu, para mujer, para datos.student
id
4
name
sex
age
21
Sugerencia:SQL
las transacciones se pueden comprometer después de cada declaración.
package jdbc;
import java.sql.*;
public class jdbcTransaction {
public static void transaction(){
try {
Class.forName("com.mysql.jdbc.Driver" );
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Connection conn = null;
PreparedStatement ps = null;
/********** Begin **********/
//连接数据库并开启事务
try {
String url = "jdbc:mysql://localhost:3306/mysql_db?useUnicode=true&characterEncoding=utf8";
conn = DriverManager.getConnection(url, "root", "123123");
conn.setAutoCommit(false);
String sql = "insert into student(id,name,sex,age) values(4,'赵六','女',21)";
ps = conn.prepareStatement(sql);
ps.executeUpdate();
conn.commit();
String sql1 = "daj;ljd";
ps = conn.prepareStatement(sql1);
ps.executeUpdate();
conn.commit();
String sql2 = "select * from student";
ResultSet rs = ps.executeQuery(sql2);
Student student = null;
while (rs.next()) {
int id = rs.getInt(1);
String name = rs.getString(2);
String sex = rs.getString(3);
int age = rs.getInt(4);
student = new Student(id, name, sex, age);
System.out.println(
student.getId() + " " + student.getName() + " " + student.getSex() + " " + student.getAge());
}
} catch (SQLException e) {
try {
//回滚
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
}
/********** End **********/
finally {
try {
if(ps!=null)
ps.close();
if (conn != null)
conn.close();
} catch (SQLException e1) {
e1.printStackTrace();
}
}
}
}