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 注入