本文全面介绍了Web技术，包括HTML、CSS、JavaScript等前端技术，以及Tomcat服务器、Servlet等后端技术。同时深入探讨了JDBC的核心技术，如连接数据库的方法、使用PreparedStatement预防SQL注入等问题。
Web技术总览
浏览器端：
THML （超文本标记语言（Hypertext Markup Language））：负责整个浏览器的骨架（女生）
CSS：页面美化（女生化妆）
JS：负责整个页面行为，让页面动起来、比如注册的时候设置密码、确认密码（让女生动起来）
jQuery：基于JS，将JS的操作封装到jQuery中，更加便利，除此之外还有VUE、React这些技术
Ajax（创建交互式 Web 应用程序而无需牺牲浏览器兼容性的流行方法（Asynchronous JavaScript and XML））：比如说相当于在注册的时候看你名字被占用了没有，这就是用的Ajax，还有就是搜索的时候搜索了一些就会出现很多提示这些都是Ajax实现的
JSON：以前用XML，现在用JSON比说点餐的时候显示多少人点了这个餐，就是JSON 的格式
服务器端：
Tomcat服务器：Tomcat 服务器是一个开源的轻量级Web应用服务器，在中小型系统和并发量小的场合下被普遍使用，是开发和调试Servlet、JSP 程序的首选。
XML（可扩展标示语言（Extensive Markup Language））：跟html的区别，可以自定义标签，主要的作用写配置文件，传统来说xml负责后台（配菜师），而 hmtl 负责显示（服务员），而在移动端xml 就从后端走上前台了
Servlet（组件）：是Tomcat中最重要的组件、作用有三个 获取请求、处理请求（比如登录的时候看你的密码是不是靠谱的）、响应请求（比如说返回登陆失败这些）
Filter(过滤器)：过滤数据
Listener(监听器)：监听用户的一些操作
HTTP: 而浏览器端跟服务器端交互的是需要遵循HTTP协议（在应用层），其中有一些请求和响应的细节
JSP（Java服务端网页（一种建立动态网页的技术，Java Server Page））： JSP是实现动态页面，本质来说也是Servlet ，实现了Servlet接口， JS中又有EL表达式来替换JSP表达式，JSTL来替换JSP中的脚本片段
Cookie和Session： 判断变换页面后还是不是你这个人（比如说你登录了淘宝然后搜索你需要买的东西过后会变换页面，变换页面过后我们就会判断还是不是你这个人，就不需要重新登录）
JDBC核心技术
JDBC概述
JDBC基础
获取数据库连接
要素一：Driver接口实现类
要素二：URL
要素三：用户名
要素四：密码
Driver 接口
加载与注册 JDBC 驱动
建立连接(Connection)
URL
JDBC URL 用于标识一个被注册的驱动程序，驱动程序管理器通过这个 URL 选择正确的驱动程序，从而建立到
数据库的连接。
JDBC URL的标准由三部分组成，各部分间用冒号分隔。
jdbc:子协议:子名称
协议：JDBC URL中的协议总是jdbc
子协议：子协议用于标识一个数据库驱动程序
子名称：一种标识数据库的方法。子名称可以依不同的子协议而变化，用子名称的目的是为了定位数据库
提供足够的信息。包含主机名(对应服务端的ip地址)，端口号，数据库名
几种常用数据库的JDBC URL
导入mysql驱动
//方式一：
@Test
public void testConnection1() throws SQLException {
//获取Dirver实现类对象
Driver driver = new com.mysql.jdbc.Driver();
//url:http://localhost:8080/gmall/keyboard.jpg
//jdbc:mysql:协议
//localhost:ip地址
//3306:默认mysql的端口号
//test:test数据库
String url = "jdbc:mysql://localhost:3306/test";
//将用户名和密码封装在Properties中
Properties info = new Properties();
info.setProperty("user","root");
info.setProperty("password", "7777");
Connection conn = driver.connect(url, info);
System.out.println(conn);
}
//方式二：对方式一的迭代：在如下的程序中不出现第三方的api，使得程序具有更好的可移植性
@Test
public void testConnection2() throws Exception {
//1.获取Dirver实现类对象：使用反射
Class clazz = Class.forName("com.mysql.jdbc.Driver");
Driver driver = (Driver)clazz.newInstance();
//2.提供要链接的数据库
String ur1 = "jdbc:mysql://localhost:3306/test";
//3.提供需要的用户名和密码
Properties info = new Properties();
info.setProperty("user","root");
info.setProperty("password", "7777");
//4.获取连接
Connection conn = driver.connect(ur1,info);
System.out.println(conn);
}
//方式三：使用DriverManager
@Test
public void testConnection3() throws Exception {
//1.获取Driver实现类的对象
Class clazz = Class.forName("com.mysql.jdbc.Driver");
Driver driver = (Driver) clazz.newInstance();
//2.提供三个连接的基本信息
String ur1 = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "7777";
//注册驱动
DriverManager.registerDriver(driver);
//获取连接
Connection conn = DriverManager.getConnection(ur1,user,password);
System.out.println(conn);
}
//方式四：可以指示加载驱动，不用显示的注册驱动过了
@Test
public void testConnection4() throws Exception {
//1.提供三个连接的基本信息
String ur1 = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "7777";
//2.加载Dirver
Class.forName("com.mysql.jdbc.Driver");
//相较于方式三：可以省略如下的操作
// Driver driver = (Driver) clazz.newInstance();
// //注册驱动
// DriverManager.registerDriver(driver);
//为什么可以省略上述操作呢？
/*
* 在mysql的Driver实现类中，声明了如下的操作：
* static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}
*/
//3.获取连接
Connection conn = DriverManager.getConnection(ur1,user,password);
System.out.println(conn);
}
//方式五：将数据库连接需要的四个基本信息声明在配置文件中，通过读取配置文件的方式，获取连接
/*
* 此种方式的好处？
* 1.实现了数据与代码的分离。实现了解耦
* 2.如果需要修改配置文件信息，可以避免程序重新打包。
* */
@Test
public void getConnection5() throws Exception {
//1.读取配置文件中的4个信息
InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
Properties pros = new Properties();
pros.load(is);
String user = pros.getProperty("user");
String password = pros.getProperty("password");
String url = pros.getProperty("url");
String driverClass = pros.getProperty("driverClass");
//2.加载驱动
Class.forName(driverClass);
//3.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
}
使用Statement操作数据表的弊端
SQL注入的问题
// 使用Statement的弊端：需要拼写sql语句，并且存在SQL注入的问题
//如何避免出现sql注入：只要用 PreparedStatement(从Statement扩展而来) 取代 Statement
@Test
public void testLogin() {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入用户名：");
String user = scanner.nextLine();
System.out.print("请输入密码：");
String password = scanner.nextLine();
//SELECT user,password FROM user_table WHERE user = '1' or ' AND password = '=1 or '1' = '1'
String sql = "SELECT user,password FROM user_table WHERE user = '"+ user +"' AND password = '"+ password +"'";
User returnUser = get(sql,User.class);
if(returnUser != null){
System.out.println("登录成功");
}else{
System.out.println("用户名不存在或密码错误");
}
}
ResultSet类
ResultSetMetaData 类
使用PreparedStatement
// 向customers表中添加一条记录
@Test
public void testInsert() {
Connection conn = null;
java.sql.PreparedStatement ps = null;
try {
// 1.读取配置文件中的4个信息
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
Properties pros = new Properties();
pros.load(is);
String user = pros.getProperty("user");
String password = pros.getProperty("password");
String url = pros.getProperty("url");
String driverClass = pros.getProperty("driverClass");
// 2.加载驱动
Class.forName(driverClass);
// 3.获取连接
conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
// 4.预编译sql语句，返回PreparedStatement的实例
String sql = "insert into customers(name,email,birth)values(?,?,?)";
ps = conn.prepareStatement(sql);
// 5.填充占位符
ps.setString(1, "哪吒");
ps.setString(2, "nezha@gmail.com");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
java.util.Date date = sdf.parse("1000-01-01");
ps.setDate(3, new java.sql.Date(date.getTime()));
// 6.执行操作
ps.execute();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 7.资源的关闭
try {
if (ps != null)
ps.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if (conn != null)
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
JDBCUtils 类（工具类）：
public class JDBCUtils {
/**
*
* @Description 获取数据库的连接
* @author acoffee
* @date 2020年11月22日 上午10:29:18
* @return
* @throws Exception
*/
public static Connection getConnection() throws Exception {
// 1.读取配置文件中的4个信息（ ClassLoader.getSystemClassLoader()也能获取系统类加载器 ）
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
Properties pros = new Properties();
pros.load(is);
String user = pros.getProperty("user");
String password = pros.getProperty("password");
String url = pros.getProperty("url");
String driverClass = pros.getProperty("driverClass");
// 2.加载驱动
Class.forName(driverClass);
// 3.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
return conn;
}
/**
*
* @Description 关闭连接和Statement操作
* @author acoffee
* @date 2020年11月22日 上午10:31:41
* @param conn
* @param ps
*/
public static void closeResourse(Connection conn,Statement ps) {
try {
if (ps != null)//避免在 ps = conn.prepareStatement(sql); 这句语句中对象没有创建报空指针异常
ps.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if (conn != null)//避免 在获取连接是如果有异常 报空指针的情况
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
*
* @Description 关闭资源的操作
* @author acoffee
* @date 2020年11月22日 下午4:24:56
* @param conn
* @param ps
* @param rs
*/
//方法的重载
public static void closeResourse(Connection conn,Statement ps,ResultSet rs) {
try {
if (ps != null)
ps.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if (conn != null)
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if (rs != null)
rs.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
修改customers表的一条数据的操作
//修改customers表的一条操作
@Test
public void testUpdate() {
//1.获取数据库的连接
Connection conn = null;
PreparedStatement ps = null;
try {
conn = JDBCUtils.getConnection();
//2.预编译sql语句，返回PreparedStatement的实例
String sql = "update customers set name = ? where id = ?";
ps = (PreparedStatement) conn.prepareStatement(sql);
//3.填充占位符
ps.setObject(1, "莫扎特");//数字代表占位符的位置
ps.setObject(2, 18);
//4.执行
ps.execute();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
//5.资源的关闭
JDBCUtils.closeResourse(conn,ps);
}
通用的增删改操作
//通用的增删改操作
public void update(String sql,Object ...args) {
//1.获取数据库的连接
Connection conn = null;
//2.预编译sql语句，返回PreparedStatement实例
java.sql.PreparedStatement ps = null;
try {
conn = JDBCUtils.getConnection();
ps = conn.prepareStatement(sql);//预编译sql语句，预编译因为有占位符的存在，生成的prepareStatement就知道你要干什么，从而就解决了sql注入问题.
//3.填充占位符
for(int i = 0;i < args.length;i++) {
ps.setObject(i+1, args[i]);
}
//4.执行
ps.execute();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
//5.资源的关闭
JDBCUtils.closeResourse(conn, ps);
}
}
@Test
public void testCommonUpdate() {
// String sql = "delete from customers where id = ?";
// update(sql,3);
String sql = "update `order` set order_name = ? where order_id = ? ";
update(sql,"DD","2");
}
customer表
Customer类
/*
* ORM编程思想（object relational mapping 对象关系映射）
* 一个数据表对应一个java类
* 表中的一条记录对应java类的一个对象
* 表中的一个字段对应java类的一个属性
* */
public class Customer {
private int id;
private String name;
private String email;
private Date birth;
public Customer() {
}
public Customer(int id, String name, String email, Date birth) {
super();
this.id = id;
this.name = name;
this.email = email;
this.birth = birth;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
@Override
public String toString() {
return "Customer [id=" + id + ", name=" + name + ", email=" + email + ", birth=" + birth + "]";
}
}
Customer表的查询(不是通用的，只能使用固定的字段)
@Test
public void testQuery1() {
Connection conn = null;
PreparedStatement ps = null;
ResultSet resultSet = null;
try {
conn = JDBCUtils.getConnection();
String sql = "select id,name,email,birth from customers where id =?";
ps = conn.prepareStatement(sql);
ps.setObject(1, 1);
// 执行，并返回结果集
resultSet = ps.executeQuery();//查询到的结果需要返回，我们是使用resultSet来接受和处理结果集
// 处理结果集
if (resultSet.next()) {// 判断结果集的下一条是否有数据，如果有数据返回true
// 指针下移，如果放回false，则指针不会下移
// 获取当前这条数据的各个字段值
int id = resultSet.getInt(1);
String name = resultSet.getString(2);
String email = resultSet.getString(3);
Date birth = resultSet.getDate(4);
// 方式一：
// Object[] data = new Object[] { id, name, email, birth };
// 方式二：（使用类来封装结果集，因为返回的字段都可以当做类的属性，sql字段的数据类型都能在java中找到对应的数据类型 对应关系如下图，这就是ORM编程思想）
Customer customer = new Customer(id, name, email, birth);
System.out.println(customer);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
//关闭资源
JDBCUtils.closeResourse(conn, ps, resultSet);
}
}
Customers表的通用查询操作
@Test
public void testQueryForCustomer() {
String sql = "select id,name,birth,email from customers where id = ?";
Customer customer = queryForCustomers(sql,13);
System.out.println(customer);
sql = "select name,email from customers where name = ?";
Customer customer1 = queryForCustomers(sql,"周杰伦");
System.out.println(customer1);
}
/**
*
* @Description 针对于customers表的通用的查询操作
* @author acoffee
* @throws Exception
* @date 2020年11月22日 下午4:34:52
*/
public Customer queryForCustomers(String sql,Object...args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = JDBCUtils.getConnection();
ps = conn.prepareStatement(sql);
for(int i = 0;i < args.length;i++) {
ps.setObject(i+1, args[i]);
}
rs = ps.executeQuery();
//获取结果集的元数据：因为我们要去获取结果的列数，而得到结果集的列数的方法 封装在ResultSet 的元数据中.
ResultSetMetaData rsmd = rs.getMetaData();
//通过ResultSetMetaData获取结果集中的列数
int columnCount = rsmd.getColumnCount();
if(rs.next()) { //判断结果集的下一条是否有数据，如果有数据返回true，并指针下移；如果没有数据返回false，指针不下移，直接结束。相当于迭代器 中的hasnext() 和next()一半的功能，只是没有next() 返回值的功能.
Customer cust = new Customer();//将空参构造器创建的对象放在if 外面的话，如果next没有查到数据，我们还去创建对象就有点浪费了.
for(int i = 0;i < columnCount;i++) {
//获取列值
Object columvalue = rs.getObject(i + 1);
//获取每个列的列名：同样是封装在ResultSetMetaData 中（ResultSet 的元数据）
String columnName = rsmd.getColumnName(i+1);
//给cust对象执行的某个属性,赋值为columValue:通过反射
Field field = Customer.class.getDeclaredField(columnName);
field.setAccessible(true);
field.set(cust, columvalue);
}
return cust;
}
} catch (Exception e) {
e.printStackTrace();
}finally {
JDBCUtils.closeResourse(conn, ps, rs);
}
return null;
}
元数据就是修饰数据的数据：比如 String str = name; String 和 str 就是name的元数据
order表
/*
* 针对于表的字段名与类的属性名不相同的情况：
* 1. 必须声明sql时，使用类的属性名来命名字段的别名
* 2.使用ResultSetMetaData时，需要使用getColumnLabel()来替换getColumnName(), 获取列的别名。
* 说明：如果sql中没有给字段其别名，getColumnLabel()获取的就是列名
*
*/
@Test
public void testOrderForQuery() {
String sql = "select order_id orderId,order_name orderName,order_date orderDate from `order` where order_id = ?";
Order order = orderForQuery(sql, 1);
System.out.println(order);
}
public Order orderForQuery(String sql, Object... args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 执行，获取结果集
conn = JDBCUtils.getConnection();
ps = conn.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
// 获取结果集的元数据
ResultSetMetaData rsmd = rs.getMetaData();
// 获取列数(获取列数的方法在元数据中)
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
Order order = new Order();
for (int i = 0; i < columnCount; i++) {
// 获取每个列的列值：通过ResultSet
Object columnValue = rs.getObject(i + 1);
// 获取每个列的列名：通过ResultSetMetaData
// 获取列的列名：getColumnName() 不推荐使用
// 获取列的别名：getColumnLabel() 没有别名的时候直接获取列名
// String columnName = rsmd.getColumnName(i+1);
String getColumnLabel = rsmd.getColumnLabel(i + 1);
// 通过反射，将对象指定名getColumnLabel 的属性赋值为指定的值columnValue
Field field = Order.class.getDeclaredField(getColumnLabel);
field.setAccessible(true);
field.set(order, columnValue);
}
return order;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResourse(conn, ps, rs);
}
return null;
}
图解：
PrepareStatement针对不同表的通用的查询
package com.acoffee3.preparedstatement;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import com.acoffee3.bean.Customer;
import com.acoffee3.bean.Order;
/**
*
* @Description 使用PreparedStatement实现正对于不同表的通用及查询多条数据的查询操作
* @author acoffee Email:763857320qq.com
* @version
* @date 2020年11月22日 下午9:28:46
*
*/
public class preparedStatementTest1 {
@Test
public void testGetForList() {
String sql = "select id,name,email from customers where id < ?";
List<Customer> list = getForList(Customer.class,sql,12);
list.forEach(System.out::println);
String sql1 = "select order_id orderId,order_name orderName from `order` where order_id < ?";
List<Order> list2 = getForList(Order.class, sql1, 5);
list2.forEach(System.out::println);
}
public <T> List<T> getForList(Class<T> clazz, String sql, Object... args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 执行，获取结果集
conn = JDBCUtils.getConnection();
ps = conn.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
// 获取结果集的元数据
ResultSetMetaData rsmd = rs.getMetaData();
// 获取列数
int columnCount = rsmd.getColumnCount();
ArrayList<T> list = new ArrayList<T>();
while (rs.next()) {
T t = clazz.newInstance();
//处理结果集一行数据中的每一个列：给t对象指定的属性赋值
for (int i = 0; i < columnCount; i++) {
// 获取每个列的列值：通过ResultSet
Object columnValue = rs.getObject(i + 1);
// 获取每个列的列名：通过ResultSetMetaData
// 获取列的列名：getColumnName() 不推荐使用
// 获取列的别名：getColumnLabel() 没有别名的时候直接获取列名
// String columnName = rsmd.getColumnName(i+1);
String getColumnLabel = rsmd.getColumnLabel(i + 1);
// 通过反射，将对象指定名ColumnName的属性赋值为指定的值columnValue
Field field = clazz.getDeclaredField(getColumnLabel);
field.setAccessible(true);
field.set(t, columnValue);
}
list.add(t);
}
return list;
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResourse(conn, ps, rs);
}
return null;
}
}
演示使用PreparedStatement替换Statement，解决SQL注入问题
@Test
public void testLogin() {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入用户名：");
String user = scanner.nextLine();
System.out.print("请输入密码：");
String password = scanner.nextLine();
//SELECT user,password FROM user_table WHERE user = '1' or ' AND password = '=1 or '1' = '1'
String sql = "SELECT user,password FROM user_table WHERE user = ? and password = ?";
User returnUser = getInstance(User.class,sql,user,password);
if(returnUser != null){
System.out.println("登录成功");
}else{
System.out.println("用户名不存在或密码错误");
}
}
PreparedStatement为什么他能够解决sql注入问题？
占位符起到了很大的作用，在API中我可以看到有这样一句话，它概括了PreparedStatement的主要特征：预编译SQL语句，我们在生成的，我们在生成PreparedStatement的时候就已经把sql语句已经使用过了，我们就把and的关系固定死了，就是谁且谁的关系，而Statement不靠谱的原因就是没有预编译这个过程，它直接拿sql语句上去操作，所以就出现了sql注入的问题。
练习题：
Student（构造器）类
public class Student {
private int flowID;//流水号
private int type;//考试类型
private String IDCard;//身份证号
private String examCard;//准考证号
private String name;//学生姓名
private String location;//所在城市
private int grade;//成绩
public Student() {
super();
}
public Student(int flowID, int type, String iDCard, String examCard, String name, String location, int grade) {
super();
this.flowID = flowID;
this.type = type;
IDCard = iDCard;
this.examCard = examCard;
this.name = name;
this.location = location;
this.grade = grade;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public String getIDCard() {
return IDCard;
}
public void setIDCard(String iDCard) {
IDCard = iDCard;
}
public String getExamCard() {
return examCard;
}
public void setExamCard(String examCard) {
this.examCard = examCard;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
public int getFlowID() {
return flowID;
}
@Override
public String toString() {
System.out.println("=========查询结果===========");
return info();
}
private String info() {
return "流水号：" + flowID + "\n四级/六级：" + type + "\n身份证号：" + IDCard + "\n准考证号：" + examCard +
"\n学生姓名：" + name + "\n区域：" + location + "\n成绩：" + grade;
}
}
实现类：
//课后练习2
public class Exer2Test {
// 问题1：向examstudent表中添加一条记录
/*
* Type:
IDCard:
ExamCard:
StudentName:
Location:
Grade:
*/
@Test
public void testInsert(){
Scanner scanner = new Scanner(System.in);
System.out.print("四级/六级：");
int type = scanner.nextInt();
System.out.print("身份证号：");
String IDCard = scanner.next();
System.out.print("准考证号：");
String examCard = scanner.next();
System.out.print("学生姓名：");
String studentName = scanner.next();
System.out.print("所在城市：");
String location = scanner.next();
System.out.print("考试成绩：");
int grade = scanner.nextInt();
String sql = "insert into examstudent(type,IDCard,examCard,studentName,location,grade)values(?,?,?,?,?,?)";
int insertCount = update(sql,type,IDCard,examCard,studentName,location,grade);
if(insertCount > 0){
System.out.println("添加成功");
}else{
System.out.println("添加失败");
}
}
// 通用的增删改操作
public int update(String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！
Connection conn = null;
PreparedStatement ps = null;
try {
// 1.获取数据库的连接
conn = JDBCUtils.getConnection();
// 2.预编译sql语句，返回PreparedStatement的实例
ps = conn.prepareStatement(sql);
// 3.填充占位符
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
}
// 4.执行
/*
* ps.execute():
* 如果执行的是查询操作，有返回结果，则此方法返回true;
* 如果执行的是增、删、改操作，没有返回结果，则此方法返回false.
*/
// 方式一：
// return ps.execute();
// 方式二：
return ps.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5.资源的关闭
JDBCUtils.closeResource(conn, ps);
}
return 0;
}
//问题2：根据身份证号或者准考证号查询学生成绩信息
@Test
public void queryWithIDCardOrExamCard(){
System.out.println("请选择您要输入的类型：");
System.out.println("a.准考证号");
System.out.println("b.身份证号");
Scanner scanner = new Scanner(System.in);
String selection = scanner.next();
if("a".equalsIgnoreCase(selection)){//if(selection.equalsIgnoreCase("a")){
System.out.println("请输入准考证号：");
String examCard = scanner.next();
String sql = "select FlowID flowID,Type type,IDCard,ExamCard examCard,StudentName name,Location location,Grade grade from examstudent where examCard = ?";
Student student = getInstance(Student.class,sql,examCard);
if(student != null){
System.out.println(student);
}else{
System.out.println("输入的准考证号有误！");
}
}else if("b".equalsIgnoreCase(selection)){
System.out.println("请输入身份证号：");
String IDCard = scanner.next();
String sql = "select FlowID flowID,Type type,IDCard,ExamCard examCard,StudentName name,Location location,Grade grade from examstudent where IDCard = ?";
Student student = getInstance(Student.class,sql,IDCard);
if(student != null){
System.out.println(student);
}else{
System.out.println("输入的身份证号有误！");
}
}else{
System.out.println("您的输入有误，请重新进入程序。");
}
}
public <T> T getInstance(Class<T> clazz,String sql, Object... args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = JDBCUtils.getConnection();
ps = conn.prepareStatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setObject(i + 1, args[i]);
}
rs = ps.executeQuery();
// 获取结果集的元数据 :ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 通过ResultSetMetaData获取结果集中的列数
int columnCount = rsmd.getColumnCount();
if (rs.next()) {
T t = clazz.newInstance();
// 处理结果集一行数据中的每一个列
for (int i = 0; i < columnCount; i++) {
// 获取列值
Object columValue = rs.getObject(i + 1);
// 获取每个列的列名
// String columnName = rsmd.getColumnName(i + 1);
String columnLabel = rsmd.getColumnLabel(i + 1);
// 给t对象指定的columnName属性，赋值为columValue：通过反射
Field field = clazz.getDeclaredField(columnLabel);
field.setAccessible(true);
field.set(t, columValue);
}
return t;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResource(conn, ps, rs);
}
return null;
}
//问题3：删除指定的学生信息
@Test
public void testDeleteByExamCard(){
System.out.println("请输入学生的考号：");
Scanner scanner = new Scanner(System.in);
String examCard = scanner.next();
//查询指定准考证号的学生
String sql = "select FlowID flowID,Type type,IDCard,ExamCard examCard,StudentName name,Location location,Grade grade from examstudent where examCard = ?";
Student student = getInstance(Student.class,sql,examCard);
if(student == null){
System.out.println("查无此人，请重新输入");
}else{
String sql1 = "delete from examstudent where examCard = ?";
int deleteCount = update(sql1, examCard);
if(deleteCount > 0){
System.out.println("删除成功");
}
}
}
//优化以后的操作：
@Test
public void testDeleteByExamCard1(){
System.out.println("请输入学生的考号：");
Scanner scanner = new Scanner(System.in);
String examCard = scanner.next();
String sql = "delete from examstudent where examCard = ?";
int deleteCount = update(sql, examCard);
if(deleteCount > 0){
System.out.println("删除成功");
}else{
System.out.println("查无此人，请重新输入");
}
}
}
除了解决Statement的拼串、sql问题之外，PreparedStatement还有哪些好处呢？
- 1.PreparedStatement操作Blob的数据，而Statement做不到。
- 2.PreparedStatement可以实现更高效的批量操作。
操作BLOB类型字段
如果在指定了相关的Blob类型以后，还报错：xxx too large，那么在mysql的安装目录下，找my.ini文件加上如下的配置参数： max_allowed_packet=16M（默认的packet是1M）
同时注意：修改了my.ini文件之后，打开直接粘贴到最后，需要重新启动mysql服务。
//向数据表customers中插入Blob类型的字段
@Test
public void testInsert() throws Exception{
Connection conn = JDBCUtils.getConnection();
String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setObject(1,"袁浩");
ps.setObject(2, "yuan@qq.com");
ps.setObject(3,"1992-09-08");
FileInputStream is = new FileInputStream(new File("girl.jpg"));
ps.setBlob(4, is);
ps.execute();
JDBCUtils.closeResource(conn, ps);
}
//查询数据表customers中Blob类型的字段，并将其从数据库上下载到本地
@Test
public void testQuery() {
InputStream is = null;
FileOutputStream fos = null;
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
//1.建立连接
conn = JDBCUtils.getConnection();
String sql = "select id,name,email,birth,photo from customers where id = ?";
//2.预编译sql语句
ps = conn.prepareStatement(sql);
//3.填充站位符
ps.setInt(1, 27);
rs = ps.executeQuery();
if(rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("name");
String email = rs.getString("email");
Date birth = rs.getDate("birth");
Customer cust = new Customer(id,name,email,birth);
System.out.println(cust);
//将Blob类型的字段下载下来，以文件的方式保存在本地
Blob photo = rs.getBlob("photo");
is = photo.getBinaryStream();
fos = new FileOutputStream("frank.jpg");
byte[] buffer = new byte[1024];
int len;
while((len = is.read(buffer)) != -1) {
fos.write(buffer, 0, len);
}
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
try {
if(is != null)
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
if(fos != null)
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
JDBCUtils.closeResourse(conn, ps, rs);
}
}
执行结果：
Customer [id=27, name=frank, email=frank@qq.com, birth=1992-09-08]
使用PreparedStatement实现批量插入
更换jar包的流程
先将jar包复制在lib中，在项目上点击右键如图操作将老的jar包移除，然后在将新的包添加即可。
代码实现：
package com.atguigu5.blob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import org.junit.Test;
import com.atguigu3.util.JDBCUtils;
/*
* 使用PreparedStatement实现批量数据的操作
*
* update、delete本身就具有批量操作的效果。
* 此时的批量操作，主要指的是批量插入。使用PreparedStatement如何实现更高效的批量插入？
*
* 题目：向goods表中插入20000条数据
* CREATE TABLE goods(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(25)
);
* 方式一：使用Statement
* Connection conn = JDBCUtils.getConnection();
* Statement st = conn.createStatement();
* for(int i = 1;i <= 20000;i++){
* String sql = "insert into goods(name)values('name_" + i + "')";
* st.execute(sql);
* }
*
*/
public class InsertTest {
//批量插入的方式二：使用PreparedStatement
@Test
public void testInsert1() {
Connection conn = null;
PreparedStatement ps = null;
try {
long start = System.currentTimeMillis();
conn = JDBCUtils.getConnection();
String sql = "insert into goods(name)values(?)";
ps = conn.prepareStatement(sql);
for(int i = 1;i <= 20000;i++){
ps.setObject(1, "name_" + i);
ps.execute();
}
long end = System.currentTimeMillis();
System.out.println("花费的时间为：" + (end - start));//20000:83065
} catch (Exception e) {
e.printStackTrace();
}finally{
JDBCUtils.closeResource(conn, ps);
}
}
/*
* 批量插入的方式三：
* 1.addBatch()、executeBatch()、clearBatch()
* 2.mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。
* ?rewriteBatchedStatements=true 写在配置文件的url后面
* 3.使用更新的mysql 驱动：mysql-connector-java-5.1.37-bin.jar
*/
@Test
public void testInsert2() {
Connection conn = null;
PreparedStatement ps = null;
try {
long start = System.currentTimeMillis();
conn = JDBCUtils.getConnection();
String sql = "insert into goods(name)values(?)";
ps = conn.prepareStatement(sql);
for(int i = 1;i <= 1000000;i++){
ps.setObject(1, "name_" + i);
//1."攒"sql
ps.addBatch();
if(i % 500 == 0){
//2.执行batch
ps.executeBatch();
//3.清空batch
ps.clearBatch();
}
}
long end = System.currentTimeMillis();
System.out.println("花费的时间为：" + (end - start));//20000:83065 -- 565
} catch (Exception e) { //1000000:16086
e.printStackTrace();
}finally{
JDBCUtils.closeResource(conn, ps);
}
}
//批量插入的方式四：设置连接不允许自动提交数据
@Test
public void testInsert3() {
Connection conn = null;
PreparedStatement ps = null;
try {
long start = System.currentTimeMillis();
conn = JDBCUtils.getConnection();
//设置不允许自动提交数据
conn.setAutoCommit(false);
String sql = "insert into goods(name)values(?)";
ps = conn.prepareStatement(sql);
for(int i = 1;i <= 1000000;i++){
ps.setObject(1, "name_" + i);
//1."攒"sql
ps.addBatch();
if(i % 500 == 0){
//2.执行batch
ps.executeBatch();
//3.清空batch
ps.clearBatch();
}
}
//提交数据
conn.commit();
long end = System.currentTimeMillis();
System.out.println("花费的时间为：" + (end - start));//20000:83065 -- 565
} catch (Exception e) { //1000000:16086 -- 5114
e.printStackTrace();
}finally{
JDBCUtils.closeResource(conn, ps);
}
}
}
PreparedStatement vs Statement
- 代码的可读性和可维护性。
- PreparedStatement 能最大可能提高性能：
DBServer会对预编译语句提供性能优化。因为预编译语句有可能被重复调用，所以语句在被DBServer的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行代码中就会得到执行。
在statement语句中,即使是相同操作但因为数据内容不一样,所以整个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存。这样每执行一次都要对传入的语句编译一次。
(语法检查，语义检查，翻译成二进制命令，缓存)
- PreparedStatement 可以防止 SQL 注入
扫一扫
1173
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
