JDBC技术1（数据库的连接、增删改查、批量插入）

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