1. Use JDBC para agregar lotes
Repaso del punto de conocimiento:
1. Los seis pasos principales de JDBC (importar el paquete jar, cargar la clase de controlador, obtener el objeto de conexión, obtener el ejecutor sql, ejecutar sql y devolver el resultado, cerrar la conexión con la base de datos) 2. Encapsula una clase DBUtil, leyendo
el archivo de propiedades para obtener información básica de conexión.
3. Agregar lotes: se pueden agregar varios registros a la vez y se pueden ejecutar varias declaraciones SQL en la conexión actual.
// 设置部门集合
List<Dept> list = new ArrayList<>();
list.add(new Dept(60,"市场部","武汉市"));
list.add(new Dept(70,"研发部","武汉市"));
list.add(new Dept(80,"教学部","武汉市"));
//通过DBUtil获取数据库连接
Connection conn = DBUtil.getConn();
String sql="insert into dept(deptno,dname,loc) values (?,?,?)";
//获取预编译sql执行器
PreparedStatement ps = conn.prepareStatement(sql);
//批量设置该条sql语句的 参数
for(Dept dept : list){
//设置参数
ps.setInt(1,dept.getDeptno());
ps.setString(2,dept.getDname());
ps.setString(3,dept.getLoc());
// 将设置好的参数 先放入批量添加的容器中
ps.addBatch();
// 对于完整的sql语句 可以用有参的
// ps.addBatch(sql);
}
// 执行sql语句 返回每一行sql语句影响的行数 ,
int [] counts = ps.executeBatch();
System.out.println("结果长度："+ counts.length);
System.out.println("结果："+ Arrays.toString(counts));
//关闭sql语句
DBUtil.closeAll(conn,ps,null);
En segundo lugar, los metadatos del conjunto de resultados:
columnCount El número de columnas en el conjunto de resultados
columnName El nombre de la columna // seleccione columnName como columnLabel...
columnLabel El alias (etiqueta) de la
columna columnClassName El tipo correspondiente de la columna en Java (puede cooperar con Class.forName( String className) para obtener el valor de retorno del tipo de clase)
columnType El tipo de columna en la base de datos (número numérico)
columnTypeName el nombre de tipo de la columna en la base de datos
columnDisplaySize el tamaño de la columna
El conjunto de resultados (ResultSet) y los metadatos del conjunto de resultados (ResultSetMetaData) son interfaces|estándares en el estándar JDBC.
java.sql.ResultSet
java.sql.ResultSetMetaData
Tres, Reflexión de clase
1. ¿Por qué necesita usar la reflexión?
Debido al proceso anterior de creación de un objeto, la clase se conoce y luego la clase se compila, y el objeto solo se puede crear después de que se pasa la compilación. Ahora puede haber " clase desconocida" solo "nombre del paquete + nombre de la clase", saber si la clase existe durante el tiempo de ejecución y crear dinámicamente objetos de esta clase. En este momento, el proceso de creación de un objeto se puede hacer a través de la reflexión.
Definición de mecanismo de reflexión: para cualquier clase, los objetos de esta clase se pueden crear dinámicamente durante el tiempo de ejecución, y las propiedades y métodos del objeto se pueden conocer, y las propiedades y métodos se pueden llamar dinámicamente.Este proceso es el mecanismo de reflexión de Java
Para cualquier clase, hay un tipo de Clase de la clase, cómo obtener el tipo de Clases de la clase
Método 1: Class cls = Class.forName("nombre de clase completo de la clase")
Método 2: clase cls = nombre de clase.clase;
Método 3: Clase cls = nombre de objeto de la clase.getClass()
API comunes
Construir:
cls.getConstructor(int.class, String.class); Obtener el objeto constructor correspondiente a cls según el tipo y número de parámetro
Campo: El tipo correspondiente al atributo
getDeclareFields (): obtenga todos los atributos declarados (incluidos los modificadores, excepto los modificadores privados)
getFields(): Obtener todos los atributos modificados públicos declarados
getDeclareFiled(String name): Obtener el objeto de atributo de acuerdo con el nombre del atributo
getField(String name): Obtenga el objeto de atributo de acuerdo con el nombre del atributo (debe ser compartido)
Método: el tipo correspondiente al método
getDeclaredMethods(): Devuelve los métodos autodeclarados de la clase actual
getMethods(): devuelve todos los métodos (incluida la clase principal)
invoke(obj, valor del parámetro): llame a este método
getMethod("nombre del método", valor del parámetro): devuelve el método según el nombre del método
4. Embalajes reflectantes (adiciones, supresiones, modificaciones, controles)
El papel de la declaración preparada:
1. Pase en sql por adelantado, y no pase en sql al ejecutar.
2. Admite el paso de parámetros en sql
. 3. Resuelva lagunas en la lógica de inyección de sql
. 4. Mejore la eficiencia de ejecución.
Objeto ...params (grupo de parámetros deformable) Función: Al llamar a una función, se puede pasar cualquier número de parámetros de cualquier tipo en
Envoltorio de consulta de encabezado para varias líneas
//查询多行多列
public static <T> List<T> list(String sql,Class<T> c,Object...params){
//创建一个集合，存放所有的对象
List<T> tList=new ArrayList<>();
try {
//1、注册驱动-反射去加载jar包中com.mysql.jdbc.Driver这个类中的 DriverManager.registerDriver(new Driver());
Class.forName("com.mysql.jdbc.Driver");
//2、获取连接对象
var conn = DriverManager.getConnection("jdbc:mysql://localhost:3307/summer-camp2023?characterEncoding=utf8", "root", "admin");
//3、定义sql
//4、需要创建statement
var st = conn.prepareStatement(sql);
for (int i = 0; i < params.length; i++) {
st.setObject(i+1,params[i]);
}
//5、statement 执行sql，返回 结果集
var rs = st.executeQuery();
//结果集rs得到结果集元数据
ResultSetMetaData md=rs.getMetaData();
//获取结果集总列数
var columnCount = md.getColumnCount();
//6、解析rs
while (rs.next()) {
//rs.next 读取结果集的光标向下移动一行，光标默认在哪一行，列名所在的那一行
//根据每一行数据，封装成一个实体对象
T t = c.newInstance();
// 1、取出某一行的每个数据，封装到对象t的属性中
for (int i = 1; i <= columnCount; i++) {
//通过列的序号，获取每一列的值
var value = rs.getObject(i);
if (value!=null){
//通过列的序号，获取每一列的列名
var columnName = md.getColumnName(i);
//因为列名和实体类t中的属性名一致，为每一个属性构造一个反射中的set方法
var f = c.getDeclaredField(columnName);
//赋予私有属性的赋值权限
f.setAccessible(true);
//使用反射，把value给到对象t的属性中
f.set(t,value);//理解为：把value赋值给对象t的ColumName，相当于set方法
}
}
//把对象存入集合中
tList.add(t);
}
//7、关闭资源
st.close();
conn.close();
} catch (Exception e) {
e.printStackTrace();
}
return tList;
}
Consultar el paquete de una fila
//查询一行
public static <T> T selectRow(String sql,Class<T> c,Object...params){
//创建一个集合，存放所有的对象
List<T> tList=new ArrayList<>();
try {
//1、注册驱动-反射去加载jar包中com.mysql.jdbc.Driver这个类中的 DriverManager.registerDriver(new Driver());
Class.forName("com.mysql.jdbc.Driver");
//2、获取连接对象
var conn = DriverManager.getConnection("jdbc:mysql://localhost:3307/summer-camp2023?characterEncoding=utf8", "root", "admin");
//3、定义sql
//4、需要创建statement
var st = conn.prepareStatement(sql);
//执行前给sql传递参数
for (int i = 0; i < params.length; i++) {
st.setObject(i+1,params[i]);
}
//5、statement 执行sql，返回 结果集
var rs = st.executeQuery();
//结果集rs得到结果集元数据
ResultSetMetaData md=rs.getMetaData();
//获取结果集总列数
var columnCount = md.getColumnCount();
//根据每一行数据，封装成一个实体对象
//6、解析rs
T t=null;
if (rs.next()) {
//rs.next 读取结果集的光标向下移动一行，光标默认在哪一行，列名所在的那一行
t = c.newInstance();
// 1、取出某一行的每个数据，封装到对象t的属性中
for (int i = 1; i <= columnCount; i++) {
//通过列的序号，获取每一列的值
var value = rs.getObject(i);
if (value!=null){
//通过列的序号，获取每一列的列名
var columnName = md.getColumnName(i);
//因为列名和实体类t中的属性名一致，为每一个属性构造一个反射中的set方法
var f = c.getDeclaredField(columnName);
//赋予私有属性的赋值权限
f.setAccessible(true);
//使用反射，把value给到对象t的属性中
f.set(t,value);//理解为：把value赋值给对象t的ColumName，相当于set方法
}
}
}
//7、关闭资源
st.close();
conn.close();
return t;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
Consultar el paquete de una columna.
//查询一列
public static <T> List<T> selectColumn(String sql,Class<T> c,Object...params){
//创建一个集合，存放所有的对象
List<T> tList=new ArrayList<>();
try {
//1、注册驱动-反射去加载jar包中com.mysql.jdbc.Driver这个类中的 DriverManager.registerDriver(new Driver());
Class.forName("com.mysql.jdbc.Driver");
//2、获取连接对象
var conn = DriverManager.getConnection("jdbc:mysql://localhost:3307/summer-camp2023?characterEncoding=utf8", "root", "admin");
//3、定义sql
//4、需要创建statement
var st = conn.prepareStatement(sql);
for (int i = 0; i < params.length; i++) {
st.setObject(i+1,params[i]);
}
//5、statement 执行sql，返回 结果集
var rs = st.executeQuery();
//结果集rs得到结果集元数据
ResultSetMetaData md=rs.getMetaData();
//获取结果集总列数
var columnCount = md.getColumnCount();
//6、解析rs
while (rs.next()) {
//rs.next 读取结果集的光标向下移动一行，光标默认在哪一行，列名所在的那一行
//通过列的序号，获取每一列的值
T t = (T) rs.getObject(1);
//把对象存入集合中
tList.add(t);
}
//7、关闭资源
st.close();
conn.close();
} catch (Exception e) {
e.printStackTrace();
}
return tList;
}
Consultar un solo paquete
//查询单个
public static <T> T selectOne(String sql,Class<T> c,Object...params){
try {
//1、注册驱动-反射去加载jar包中com.mysql.jdbc.Driver这个类中的 DriverManager.registerDriver(new Driver());
Class.forName("com.mysql.jdbc.Driver");
//2、获取连接对象
var conn = DriverManager.getConnection("jdbc:mysql://localhost:3307/summer-camp2023?characterEncoding=utf8", "root", "admin");
//3、定义sql
var st = conn.prepareStatement(sql);
for (int i = 0; i < params.length; i++) {
st.setObject(i+1,params[i]);
}
//5、statement 执行sql，返回 结果集
var rs = st.executeQuery();
//结果集rs得到结果集元数据
ResultSetMetaData md=rs.getMetaData();
//获取结果集总列数
var columnCount = md.getColumnCount();
//6、解析rs
T t=null;
if (rs.next()) {
t = (T) rs.getObject(1);
}
//7、关闭资源
st.close();
conn.close();
return t;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
Agregar, eliminar, modificar y empaquetar métodos
//增删改
public static int update(String sql,Object...params){
try {
//1、注册驱动-反射去加载jar包中com.mysql.jdbc.Driver这个类中的 DriverManager.registerDriver(new Driver());
Class.forName("com.mysql.jdbc.Driver");
//2、获取连接对象
var conn = DriverManager.getConnection("jdbc:mysql://localhost:3307/summer-camp2023?characterEncoding=utf8", "root", "admin");
//3、定义sql
//4、需要创建statement
var st = conn.prepareStatement(sql);
for (int i = 0; i < params.length; i++) {
st.setObject(i+1,params[i]);
}
//5、statement 执行sql，返回 结果集
var i = st.executeUpdate();
//7、关闭资源
st.close();
conn.close();
return i;
} catch (Exception e) {
e.printStackTrace();
}
return 0;
}
En general, la encapsulación es solo para hacer que el código sea más conciso y allanar el camino para el desarrollo posterior.