连接mysql
    uesr：root
    password：root

    1. package com.exzample.jdbc1;
    3. import java.io.IOException;
    4. import java.io.InputStream;
    5. import java.sql.Connection;
    6. import java.sql.Driver;
    7. import java.sql.DriverManager;
    8. import java.sql.SQLException;
    9. import java.util.Properties;
    11. import org.junit.Test;
    13. public class ConnectionTest {
    15.     // 方式一：
    16.     @Test
    17.     public void testConnection1() throws SQLException {
    18.         // 获取Driver实现类对象
    19.         Driver driver = new com.mysql.cj.jdbc.Driver();
    21.         // url:http://localhost:8080/gmall/keyboard.jpg
    22.         // jdbc:mysql:协议
    23.         // localhost:ip地址
    24.         // 3306：默认mysql的端口号
    25.         // test:test数据库
    26.         String url = "jdbc:mysql://localhost:3306/test";
    27.         // 将用户名和密码封装在Properties中
    28.         Properties info = new Properties();
    29.         info.setProperty("user", "root");
    30.         info.setProperty("password", "root");
    32.         Connection conn = driver.connect(url, info);
    34.         System.out.println(conn);
    35.     }
    37.     // 方式二：对方式一的迭代:在如下的程序中不出现第三方的api,使得程序具有更好的可移植性
    38.     @Test
    39.     public void testConnection2() throws Exception {
    40.         // 1.获取Driver实现类对象：使用反射
    41.         Class clazz = Class.forName("com.mysql.cj.jdbc.Driver");
    42.         Driver driver = (Driver) clazz.newInstance();
    44.         // 2.提供要连接的数据库
    45.         String url = "jdbc:mysql://localhost:3306/test";
    47.         // 3.提供连接需要的用户名和密码
    48.         Properties info = new Properties();
    49.         info.setProperty("user", "root");
    50.         info.setProperty("password", "root");
    52.         // 4.获取连接
    53.         Connection conn = driver.connect(url, info);
    54.         System.out.println(conn);
    56.     }
    58.     // 方式三：使用DriverManager替换Driver
    59.     @Test
    60.     public void testConnection3() throws Exception {
    61.         // 1.获取Driver实现类的对象
    62.         Class clazz = Class.forName("com.mysql.cj.jdbc.Driver");
    63.         Driver driver = (Driver) clazz.newInstance();
    65.         // 2.提供另外三个连接的基本信息：
    66.         String url = "jdbc:mysql://localhost:3306/test";
    67.         String user = "root";
    68.         String password = "root";
    70.         // 注册驱动
    71.         DriverManager.registerDriver(driver);
    73.         // 获取连接
    74.         Connection conn = DriverManager.getConnection(url, user, password);
    75.         System.out.println(conn);
    76.     }
    78.     // 方式四：可以只是加载驱动，不用显示的注册驱动过了。
    79.     @Test
    80.     public void testConnection4() throws Exception {
    81.         // 1.提供三个连接的基本信息：
    82.         String url = "jdbc:mysql://localhost:3306/test";
    83.         String user = "root";
    84.         String password = "root";
    86.         // 2.加载Driver
    87.         Class.forName("com.mysql.cj.jdbc.Driver");
    88.         //相较于方式三，可以省略如下的操作：
    89. //        Driver driver = (Driver) clazz.newInstance();
    90. //        // 注册驱动
    91. //        DriverManager.registerDriver(driver);
    92.         //为什么可以省略上述操作呢？
    93.         /*
    94.          * 在mysql的Driver实现类中，声明了如下的操作：
    95.          * static {
    96.                 try {
    97.                     java.sql.DriverManager.registerDriver(new Driver());
    98.                 } catch (SQLException E) {
    99.                     throw new RuntimeException("Can't register driver!");
    100.                 }
    101.             }
    102.          */
    104.         // 3.获取连接
    105.         Connection conn = DriverManager.getConnection(url, user, password);
    106.         System.out.println(conn);
    107.     }
    108.     //方式五(final版)：将数据库连接需要的4个基本信息声明在配置文件中，通过读取配置文件的方式，获取连接
    109.     /*
    110.      * 此种方式的好处？
    111.      * 1.实现了数据与代码的分离。实现了解耦
    112.      * 2.如果需要修改配置文件信息，可以避免程序重新打包。
    113.      */
    114.     @Test
    115.     public void getConnection5() throws Exception{
    117.         //1.读取配置文件中的4个基本信息
    118.         InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
    120.         Properties pros = new Properties();
    121.         pros.load(is);
    123.         String user = pros.getProperty("user");
    124.         String password = pros.getProperty("password");
    125.         String url = pros.getProperty("url");
    126.         String driverClass = pros.getProperty("driverClass");
    128.         //2.加载驱动
    129.         Class.forName(driverClass);
    131.         //3.获取连接
    132.         Connection conn = DriverManager.getConnection(url, user, password);
    133.         System.out.println(conn);
    134.     }
    135. }

    配置文件

    1. user=root
    2. password=root
    3. url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true
    4. driverClass=com.mysql.cj.jdbc.Driver

    PreparedStatement
    概念：
    3.3 PreparedStatement的使用
    3.3.1 PreparedStatement介绍
    可以通过调用 Connection 对象的 preparedStatement(String sql) 方法获取 PreparedStatement 对象
    PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句
    PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的
    setXxx() 方法来设置这些参数. setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1
    开始)，第二个是设置的 SQL 语句中的参数的值
    3.3.2 PreparedStatement vs Statement
    代码的可读性和可维护性。
    PreparedStatement 能最大可能提高性能：
    DBServer会对预编译语句提供性能优化。因为预编译语句有可能被重复调用，所以语句在被DBServer的
    编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参
    数直接传入编译过的语句执行代码中就会得到执行。
    在statement语句中,即使是相同操作但因为数据内容不一样,所以整个语句本身不能匹配,没有缓存语句的意
    义.事实是没有数据库会对普通语句编译后的执行代码缓存。这样每执行一次都要对传入的语句编译一次。
    (语法检查，语义检查，翻译成二进制命令，缓存)
    PreparedStatement 可以防止 SQL 注入
    3.4 ResultSet与ResultSetMetaData
    3.4.1 ResultSet
    查询需要调用PreparedStatement 的 executeQuery() 方法，查询结果是一个ResultSet 对象
    ResultSet 对象以逻辑表格的形式封装了执行数据库操作的结果集，ResultSet 接口由数据库厂商提供实现
    ResultSet 返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面。
    ResultSet 对象维护了一个指向当前数据行的游标，初始的时候，游标在第一行之前，可以通过 ResultSet 对象
    的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效，该方法返回 true，且指针下移。
    相当于Iterator对象的 hasNext() 和 next() 方法的结合体。
    当指针指向一行时, 可以通过调用 getXxx(int index) 或 getXxx(int columnName) 获取每一列的值。
    例如: getInt(1), getString(“name”)
    注意：Java与数据库交互涉及到的相关Java API中的索引都从1开始。
    ResultSet 接口的常用方法：
    boolean next()
    getString()
    …
    image.png
    3.4.2 ResultSetMetaData
    可用于获取关于 ResultSet 对象中列的类型和属性信息的对象
    ResultSetMetaData meta = rs.getMetaData();
    getColumnName(int column)：获取指定列的名称
    getColumnLabel(int column)：获取指定列的别名
    getColumnCount()：返回当前 ResultSet 对象中的列数。
    getColumnTypeName(int column)：检索指定列的数据库特定的类型名称。
    getColumnDisplaySize(int column)：指示指定列的最大标准宽度，以字符为单位。
    isNullable(int column)：指示指定列中的值是否可以为 null。
    isAutoIncrement(int column)：指示是否自动为指定列进行编号，这样这些列仍然是只读的
    image.png
    3.5 资源的释放
    释放ResultSet, Statement,Connection。
    数据库连接（Connection）是非常稀有的资源，用完后必须马上释放，如果Connection不能及时正确的关闭将
    导致系统宕机。Connection的使用原则是尽量晚创建，尽量早的释放。
    可以在finally中关闭，保证及时其他代码出现异常，资源也一定能被关闭。
    3.6 JDBC API小结
    两种思想
    面向接口编程的思想
    ORM思想(object relational mapping)
    一个数据表对应一个java类
    表中的一条记录对应java类的一个对象
    表中的一个字段对应java类的一个属性
    sql是需要结合列名和表的属性名来写。注意起别名。
    两种技术
    JDBC结果集的元数据：ResultSetMetaData
    获取列数：getColumnCount()
    获取列的别名：getColumnLabel()
    通过反射，创建指定类的对象，获取指定的属性并赋值
    throws

    1. package com.exzample.jdbc1;
    3. import java.io.InputStream;
    4. import java.sql.Connection;
    5. import java.sql.DriverManager;
    6. import java.text.SimpleDateFormat;
    7. import java.util.Date;
    8. import java.util.Properties;
    9. import java.util.logging.SimpleFormatter;
    11. public class PreparedStatement {
    12.     public void update() throws Exception{
    13.         //1.读取配置文件中的4个基本信息
    14.         InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
    16.         Properties pros = new Properties();
    17.         pros.load(is);
    19.         String user = pros.getProperty("user");
    20.         String password = pros.getProperty("password");
    21.         String url = pros.getProperty("url");
    22.         String driverClass = pros.getProperty("driverClass");
    24.         //2.加载驱动
    25.         Class.forName(driverClass);
    27.         //3.获取连接
    28.         Connection conn = DriverManager.getConnection(url, user, password);
    29.         System.out.println(conn);
    30.         //4.预编译sql语句，返回PreparedStatement实例
    31.         String sql = "insert into customers(name,email,birth)value(?,?,?)";
    32.         java.sql.PreparedStatement ps = conn.prepareStatement(sql);
    33.         //5.填充占位符（？）
    34.         ps.setString(1,"娜美");
    35.         ps.setString(2,"134@qq.com");
    36.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    37.         Date date = simpleDateFormat.parse("1234-02-03");
    38.         ps.setDate(3,new java.sql.Date(date.getTime()));
    39.         //6.执行操作
    40.         ps.execute();
    41.         //7.关闭连接
    42.         ps.close();
    43.         conn.close();
    44.     }
    45.     }

    try-catch
    快捷键ctrl-alt-t

    1. package com.exzample.jdbc1;
    3. import java.io.IOException;
    4. import java.io.InputStream;
    5. import java.sql.Connection;
    6. import java.sql.DriverManager;
    7. import java.sql.SQLException;
    8. import java.text.ParseException;
    9. import java.text.SimpleDateFormat;
    10. import java.util.Date;
    11. import java.util.Properties;
    12. import java.util.logging.SimpleFormatter;
    14. public class PreparedStatement {
    15.     public void update(){
    16.         Connection conn = null;
    17.         java.sql.PreparedStatement ps = null;
    18.         try {
    19.             //1.读取配置文件中的4个基本信息
    20.             InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
    22.             Properties pros = new Properties();
    23.             pros.load(is);
    25.             String user = pros.getProperty("user");
    26.             String password = pros.getProperty("password");
    27.             String url = pros.getProperty("url");
    28.             String driverClass = pros.getProperty("driverClass");
    30.             //2.加载驱动
    31.             Class.forName(driverClass);
    33.             //3.获取连接
    34.             conn = DriverManager.getConnection(url, user, password);
    35. //            System.out.println(conn);
    36.             //4.预编译sql语句，返回PreparedStatement实例
    37.             String sql = "insert into customers(name,email,birth)value(?,?,?)";
    38.             ps = conn.prepareStatement(sql);
    39.             //5.填充占位符（？）
    40.             ps.setString(1,"娜美");
    41.             ps.setString(2,"134@qq.com");
    42.             SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    43.             Date date = simpleDateFormat.parse("1234-02-03");
    44.             ps.setDate(3,new java.sql.Date(date.getTime()));
    45.             //6.执行操作
    46.             ps.execute();
    47.         } catch (IOException e) {
    48.             e.printStackTrace();
    49.         } catch (ClassNotFoundException e) {
    50.             e.printStackTrace();
    51.         } catch (SQLException throwables) {
    52.             throwables.printStackTrace();
    53.         } catch (ParseException e) {
    54.             e.printStackTrace();
    55.         }finally {
    56.             //7.关闭连接
    57.             try {
    58.                 if (ps!=null)
    59.                 ps.close();
    60.             } catch (SQLException throwables) {
    61.                 throwables.printStackTrace();
    62.             }
    63.             try {
    64.                 if (conn!=null)
    65.                 conn.close();
    66.             } catch (SQLException throwables) {
    67.                 throwables.printStackTrace();
    68.             }
    69.         }
    70.     }
    71.     }

    JDBCutil工具类

    1. package com.exzample.jdbc1;
    3. import java.io.InputStream;
    4. import java.sql.Connection;
    5. import java.sql.DriverManager;
    6. import java.sql.PreparedStatement;
    7. import java.sql.SQLException;
    8. import java.util.Properties;
    10. /*
    11. JDBC工具类
    12.  */
    13. public class JDBCUtil {
    14.     public static Connection getConnetion()throws Exception{
    15.         //1.读取配置文件中的4个基本信息
    16.         InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");//类加载器
    18.         Properties pros = new Properties();
    19.         pros.load(is);
    21.         String user = pros.getProperty("user");
    22.         String password = pros.getProperty("password");
    23.         String url = pros.getProperty("url");
    24.         String driverClass = pros.getProperty("driverClass");
    26.         //2.加载驱动
    27.         Class.forName(driverClass);
    29.         //3.获取连接
    30.         Connection conn = DriverManager.getConnection(url, user, password);
    31.         return conn;
    32.     }
    33.     public static void closeConnection(Connection conn, PreparedStatement ps){
    34.         try {
    35.             if (ps!=null)
    36.                 ps.close();
    37.         } catch (SQLException throwables) {
    38.             throwables.printStackTrace();
    39.         }
    40.         try {
    41.             if (conn!=null)
    42.                 conn.close();
    43.         } catch (SQLException throwables) {
    44.             throwables.printStackTrace();
    45.         }
    46.     }
    47. }

    image.png
    使用PreparedStatement实现增删改通用代码

    1. //通用的增、删、改操作（体现一：增、删、改 ； 体现二：针对于不同的表） 
    2. public void update(String sql,Object ... args){
    3.     Connection conn = null; 
    4.     PreparedStatement ps = null; 
    5.     try {
    6.         //1.获取数据库的连接 
    7.         conn = JDBCUtils.getConnection(); 
    8.         //2.获取PreparedStatement的实例 (或：预编译sql语句) 
    9.         ps = conn.prepareStatement(sql); 
    10.         //3.填充占位符 
    11.         for(int i = 0;i < args.length;i++){ 
    12.             ps.setObject(i + 1, args[i]); 
    13.         }
    14.         //4.执行sql语句 
    15.         ps.execute(); 
    16.     } catch (Exception e) { 
    17.         e.printStackTrace(); 
    18.     }finally{ 
    19.         //5.关闭资源 
    20.         JDBCUtils.closeResource(conn, ps);
    21.     } 
    22. }

    image.png
    使用PreparedStatement实现查询功能
    image.png
    ORM编程思想
    image.png
    CustomerBeen：
    image.png
    OrderBeen：

    1. package com.exzample;
    3. //
    4. // Source code recreated from a .class file by IntelliJ IDEA
    5. // (powered by FernFlower decompiler)
    6. //
    8. import java.sql.Date;
    10. public class Order {
    11.     private int orderId;
    12.     private String orderName;
    13.     private Date orderDate;
    15.     public Order() {
    16.     }
    18.     public Order(int orderId, String orderName, Date orderDate) {
    19.         this.orderId = orderId;
    20.         this.orderName = orderName;
    21.         this.orderDate = orderDate;
    22.     }
    24.     public int getOrderId() {
    25.         return this.orderId;
    26.     }
    28.     public void setOrderId(int orderId) {
    29.         this.orderId = orderId;
    30.     }
    32.     public String getOrderName() {
    33.         return this.orderName;
    34.     }
    36.     public void setOrderName(String orderName) {
    37.         this.orderName = orderName;
    38.     }
    40.     public Date getOrderDate() {
    41.         return this.orderDate;
    42.     }
    44.     public void setOrderDate(Date orderDate) {
    45.         this.orderDate = orderDate;
    46.     }
    48.     public String toString() {
    49.         return "Order [orderId=" + this.orderId + ", orderName=" + this.orderName + ", orderDate=" + this.orderDate + "]";
    50.     }
    51. }

    queryForCustomers or Order通用代码：

    1. package com.exzample.jdbc1;
    3. import com.exzample.Customer;
    4. import org.junit.Test;
    6. import java.lang.reflect.Field;
    7. import java.sql.Connection;
    8. import java.sql.PreparedStatement;
    9. import java.sql.ResultSet;
    10. import java.sql.ResultSetMetaData;
    12. public class SelectORM {
    13.     @Test
    14.     public void testqueryForCustomers(){
    15.         String sql = "select id,name,birth,email from customers where id = ?";
    16.         Customer customer = queryForCustomers(sql, 1);
    17.         System.out.println(customer);
    18.     }
    19.     public Customer queryForCustomers(String sql, Object...args){
    20.         Connection conn = null;
    21.         PreparedStatement ps = null;
    22.         ResultSet resultSet = null;
    23.         try {
    24.             // 1.获取数据库连接
    25.             conn = JDBCUtil.getConnetion();
    26.             // 2.预编译sql语句，得到PreparedStatement对象
    27.             ps = conn.prepareStatement(sql);
    28.             // 3.填充占位符
    29.             for (int i = 0;i<args.length;i++){
    30.                 ps.setObject(i+1,args[i]);
    31.             }
    32.             // 4.执行executeQuery(),得到结果集：ResultSet
    33.             resultSet = ps.executeQuery();
    34.             // 5.得到结果集的元数据：ResultSetMetaData
    35.             ResultSetMetaData rsmd = resultSet.getMetaData();
    36.             // 6.1通过ResultSetMetaData得到columnCount,columnLabel；通过ResultSet得到列值
    37.             int columnCount = rsmd.getColumnCount();
    38.             if (resultSet.next()){
    39.                 Customer customer = new Customer();
    40.                 for (int i = 0;i<columnCount;i++){// 遍历每一个列
    41.                     // 获取列值
    42.                     Object columValue = resultSet.getObject(i + 1);
    43.                     //获取每个列的列名
    44.                     String columnName = rsmd.getColumnName(i + 1);
    45.                     //给customer对象指定的某个属性，赋值为value,赋值为columValue
    46.                     Field field = Customer.class.getDeclaredField(columnName);
    47.                     field.setAccessible(true);
    48.                     field.set(customer,columValue);
    49.                 }
    50.                 return customer;
    51.             }
    52.         } catch (Exception e) {
    53.             e.printStackTrace();
    54.         } finally {
    55.             JDBCUtil.closeConnection(conn,ps,resultSet);
    56.         }
    57.         return null;
    58.     }
    59.     @Test
    60.     public void testOrderForQuery() {
    61.         String sql = "select order_id orderId,order_name orderName,order_date orderDate from `order` where order_id = ?";
    62.         Order order = this.orderForQuery(sql, 1);
    63.         System.out.println(order);
    64.     }
    66.     public Order orderForQuery(String sql, Object... args) {
    67.         Connection conn = null;
    68.         PreparedStatement ps = null;
    69.         ResultSet rs = null;
    71.         try {
    72.             conn = JDBCUtil.getConnetion();
    73.             ps = conn.prepareStatement(sql);
    75.             for(int i = 0; i < args.length; ++i) {
    76.                 ps.setObject(i + 1, args[i]);
    77.             }
    79.             rs = ps.executeQuery();
    80.             ResultSetMetaData rsmd = rs.getMetaData();
    81.             int columnCount = rsmd.getColumnCount();
    82.             if (rs.next()) {
    83.                 Order order = new Order();
    85.                 for(int i = 0; i < columnCount; ++i) {
    86.                     Object columnValue = rs.getObject(i + 1);
    87.                     String columnLabel = rsmd.getColumnLabel(i + 1);
    88.                     Field field = Order.class.getDeclaredField(columnLabel);
    89.                     field.setAccessible(true);
    90.                     field.set(order, columnValue);
    91.                 }
    92.                 return order;
    93.             }
    94.         } catch (Exception var17) {
    95.             var17.printStackTrace();
    96.         } finally {
    97.             JDBCUtil.closeConnection(conn, ps, rs);
    98.         }
    100.         return null;
    101.     }
    102. }

    Test结果：
    image.png
    image.png
    拓展：PreparedStatement针对不同表的的通用查询（返回一条记录or多条记录）

    1. package com.atguigu3.preparedstatement.crud;
    3. import com.atguigu3.bean.Customer;
    4. import com.atguigu3.bean.Order;
    5. import com.atguigu3.util.JDBCUtils;
    6. import java.lang.reflect.Field;
    7. import java.sql.Connection;
    8. import java.sql.PreparedStatement;
    9. import java.sql.ResultSet;
    10. import java.sql.ResultSetMetaData;
    11. import java.util.ArrayList;
    12. import java.util.List;
    13. import org.junit.Test;
    15. public class PreparedStatementQueryTest {
    16.     public PreparedStatementQueryTest() {
    17.     }
    19.     @Test
    20.     public void testGetForList() {
    21.         String sql = "select id,name,email from customers where id < ?";
    22.         List<Customer> list = this.getForList(Customer.class, sql, 12);
    23.         list.forEach(System.out::println);
    24.         String sql1 = "select order_id orderId,order_name orderName from `order`";
    25.         List<Order> orderList = this.getForList(Order.class, sql1);
    26.         orderList.forEach(System.out::println);
    27.     }
    29.     public <T> List<T> getForList(Class<T> clazz, String sql, Object... args) {
    30.         Connection conn = null;
    31.         PreparedStatement ps = null;
    32.         ResultSet rs = null;
    34.         try {
    35.             conn = JDBCUtils.getConnection();
    36.             ps = conn.prepareStatement(sql);
    38.             for(int i = 0; i < args.length; ++i) {
    39.                 ps.setObject(i + 1, args[i]);
    40.             }
    42.             rs = ps.executeQuery();
    43.             ResultSetMetaData rsmd = rs.getMetaData();
    44.             int columnCount = rsmd.getColumnCount();
    45.             ArrayList list = new ArrayList();
    47.             while(rs.next()) {
    48.                 T t = clazz.newInstance();
    50.                 for(int i = 0; i < columnCount; ++i) {
    51.                     Object columValue = rs.getObject(i + 1);
    52.                     String columnLabel = rsmd.getColumnLabel(i + 1);
    53.                     Field field = clazz.getDeclaredField(columnLabel);
    54.                     field.setAccessible(true);
    55.                     field.set(t, columValue);
    56.                 }
    58.                 list.add(t);
    59.             }
    60.             return list;
    61.         } catch (Exception e) {
    62.             e.printStackTrace();
    63.         } finally {
    64.             JDBCUtils.closeResource(conn, ps, rs);
    65.         }
    67.         return null;
    68.     }
    70.     @Test
    71.     public void testGetInstance() {
    72.         String sql = "select id,name,email from customers where id = ?";
    73.         Customer customer = (Customer)this.getInstance(Customer.class, sql, 12);
    74.         System.out.println(customer);
    75.         String sql1 = "select order_id orderId,order_name orderName from `order` where order_id = ?";
    76.         Order order = (Order)this.getInstance(Order.class, sql1, 1);
    77.         System.out.println(order);
    78.     }
    80.     public <T> T getInstance(Class<T> clazz, String sql, Object... args) {
    81.         Connection conn = null;
    82.         PreparedStatement ps = null;
    83.         ResultSet rs = null;
    85.         try {
    86.             conn = JDBCUtils.getConnection();
    87.             ps = conn.prepareStatement(sql);
    89.             for(int i = 0; i < args.length; ++i) {
    90.                 ps.setObject(i + 1, args[i]);
    91.             }
    93.             rs = ps.executeQuery();
    94.             ResultSetMetaData rsmd = rs.getMetaData();
    95.             int columnCount = rsmd.getColumnCount();
    96.             if (rs.next()) {
    97.                 T t = clazz.newInstance();
    99.                 for(int i = 0; i < columnCount; ++i) {
    100.                     Object columValue = rs.getObject(i + 1);
    101.                     String columnLabel = rsmd.getColumnLabel(i + 1);
    102.                     Field field = clazz.getDeclaredField(columnLabel);
    103.                     field.setAccessible(true);
    104.                     field.set(t, columValue);
    105.                 }
    106.                 return t;
    107.             }
    108.         } catch (Exception e) {
    109.             e.printStackTrace();
    110.         } finally {
    111.             JDBCUtils.closeResource(conn, ps, rs);
    112.         }
    114.         return null;
    115.     }
    116. }

    PreparedStatement解决sql注入问题：

    1. package com.atguigu2.statement.crud;
    3. import com.atguigu3.util.JDBCUtils;
    4. import java.lang.reflect.Field;
    5. import java.sql.Connection;
    6. import java.sql.PreparedStatement;
    7. import java.sql.ResultSet;
    8. import java.sql.ResultSetMetaData;
    9. import java.util.Scanner;
    10. import org.junit.Test;
    12. public class PreparedStatementTest {
    13.     public PreparedStatementTest() {
    14.     }
    16.     @Test
    17.     public void testLogin() {
    18.         Scanner scanner = new Scanner(System.in);
    19.         System.out.print("请输入用户名：");
    20.         String user = scanner.nextLine();
    21.         System.out.print("请输入密码：");
    22.         String password = scanner.nextLine();
    23.         String sql = "SELECT user,password FROM user_table WHERE user = ? and password = ?";
    24.         User returnUser = (User)this.getInstance(User.class, sql, user, password);
    25.         if (returnUser != null) {
    26.             System.out.println("登录成功");
    27.         } else {
    28.             System.out.println("用户名不存在或密码错误");
    29.         }
    31.     }
    33.     public <T> T getInstance(Class<T> clazz, String sql, Object... args) {
    34.         Connection conn = null;
    35.         PreparedStatement ps = null;
    36.         ResultSet rs = null;
    38.         try {
    39.             conn = JDBCUtils.getConnection();
    40.             ps = conn.prepareStatement(sql);
    42.             for(int i = 0; i < args.length; ++i) {
    43.                 ps.setObject(i + 1, args[i]);
    44.             }
    46.             rs = ps.executeQuery();
    47.             ResultSetMetaData rsmd = rs.getMetaData();
    48.             int columnCount = rsmd.getColumnCount();
    49.             if (rs.next()) {
    50.                 T t = clazz.newInstance();
    52.                 for(int i = 0; i < columnCount; ++i) {
    53.                     Object columValue = rs.getObject(i + 1);
    54.                     String columnLabel = rsmd.getColumnLabel(i + 1);
    55.                     Field field = clazz.getDeclaredField(columnLabel);
    56.                     field.setAccessible(true);
    57.                     field.set(t, columValue);
    58.                 }
    59.                 return t;
    60.             }
    61.         } catch (Exception e) {
    62.             e.printStackTrace();
    63.         } finally {
    64.             JDBCUtils.closeResource(conn, ps, rs);
    65.         }
    67.         return null;
    68.     }
    69. }

    exer1

    1. public class Exer1Test {
    3.     @Test
    4.     public void testInsert(){
    5.         Scanner scanner = new Scanner(System.in);
    6.         System.out.print("请输入用户名：");
    7.         String name = scanner.next();
    8.         System.out.print("请输入邮箱：");
    9.         String email = scanner.next();
    10.         System.out.print("请输入生日：");
    11.         String birthday = scanner.next();//'1992-09-08'
    13.         String sql = "insert into customers(name,email,birth)values(?,?,?)";
    14.         int insertCount = update(sql,name,email,birthday);
    15.         if(insertCount > 0){
    16.             System.out.println("添加成功");
    18.         }else{
    19.             System.out.println("添加失败");
    20.         }
    22.     }
    25.     // 通用的增删改操作
    26.     public int update(String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！
    27.         Connection conn = null;
    28.         PreparedStatement ps = null;
    29.         try {
    30.             // 1.获取数据库的连接
    31.             conn = JDBCUtils.getConnection();
    32.             // 2.预编译sql语句，返回PreparedStatement的实例
    33.             ps = conn.prepareStatement(sql);
    34.             // 3.填充占位符
    35.             for (int i = 0; i < args.length; i++) {
    36.                 ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
    37.             }
    38.             // 4.执行
    39.             /*
    40.              * ps.execute():
    41.              * 如果执行的是查询操作，有返回结果，则此方法返回true;
    42.              * 如果执行的是增、删、改操作，没有返回结果，则此方法返回false.
    43.              */
    44.             //方式一：
    45. //            return ps.execute();
    46.             //方式二：
    47.             return ps.executeUpdate();
    48.         } catch (Exception e) {
    49.             e.printStackTrace();
    50.         } finally {
    51.             // 5.资源的关闭
    52.             JDBCUtils.closeResource(conn, ps);
    54.         }
    55.         return 0;
    56.     }
    58. }

    exer2

    1. public class Exer2Test {
    2.     public Exer2Test() {
    3.     }
    5.     @Test
    6.     public void testInsert() {
    7.         Scanner scanner = new Scanner(System.in);
    8.         System.out.print("四级/六级：");
    9.         int type = scanner.nextInt();
    10.         System.out.print("身份证号：");
    11.         String IDCard = scanner.next();
    12.         System.out.print("准考证号：");
    13.         String examCard = scanner.next();
    14.         System.out.print("学生姓名：");
    15.         String studentName = scanner.next();
    16.         System.out.print("所在城市：");
    17.         String location = scanner.next();
    18.         System.out.print("考试成绩：");
    19.         int grade = scanner.nextInt();
    20.         String sql = "insert into examstudent(type,IDCard,examCard,studentName,location,grade)values(?,?,?,?,?,?)";
    21.         int insertCount = this.update(sql, type, IDCard, examCard, studentName, location, grade);
    22.         if (insertCount > 0) {
    23.             System.out.println("添加成功");
    24.         } else {
    25.             System.out.println("添加失败");
    26.         }
    28.     }
    30.     public int update(String sql, Object... args) {
    31.         Connection conn = null;
    32.         PreparedStatement ps = null;
    34.         try {
    35.             conn = JDBCUtils.getConnection();
    36.             ps = conn.prepareStatement(sql);
    38.             for(int i = 0; i < args.length; ++i) {
    39.                 ps.setObject(i + 1, args[i]);
    40.             }
    42.             int var7 = ps.executeUpdate();
    43.             return var7;
    44.         } catch (Exception var10) {
    45.             var10.printStackTrace();
    46.         } finally {
    47.             JDBCUtils.closeResource(conn, ps);
    48.         }
    50.         return 0;
    51.     }
    53.     @Test
    54.     public void queryWithIDCardOrExamCard() {
    55.         System.out.println("请选择您要输入的类型：");
    56.         System.out.println("a.准考证号");
    57.         System.out.println("b.身份证号");
    58.         Scanner scanner = new Scanner(System.in);
    59.         String selection = scanner.next();
    60.         String IDCard;
    61.         String sql;
    62.         Student student;
    63.         if ("a".equalsIgnoreCase(selection)) {
    64.             System.out.println("请输入准考证号：");
    65.             IDCard = scanner.next();
    66.             sql = "select FlowID flowID,Type type,IDCard,ExamCard examCard,StudentName name,Location location,Grade grade from examstudent where examCard = ?";
    67.             student = (Student)this.getInstance(Student.class, sql, IDCard);
    68.             if (student != null) {
    69.                 System.out.println(student);
    70.             } else {
    71.                 System.out.println("输入的准考证号有误！");
    72.             }
    73.         } else if ("b".equalsIgnoreCase(selection)) {
    74.             System.out.println("请输入身份证号：");
    75.             IDCard = scanner.next();
    76.             sql = "select FlowID flowID,Type type,IDCard,ExamCard examCard,StudentName name,Location location,Grade grade from examstudent where IDCard = ?";
    77.             student = (Student)this.getInstance(Student.class, sql, IDCard);
    78.             if (student != null) {
    79.                 System.out.println(student);
    80.             } else {
    81.                 System.out.println("输入的身份证号有误！");
    82.             }
    83.         } else {
    84.             System.out.println("您的输入有误，请重新进入程序。");
    85.         }
    87.     }
    89.     public <T> T getInstance(Class<T> clazz, String sql, Object... args) {
    90.         Connection conn = null;
    91.         PreparedStatement ps = null;
    92.         ResultSet rs = null;
    94.         try {
    95.             conn = JDBCUtils.getConnection();
    96.             ps = conn.prepareStatement(sql);
    98.             for(int i = 0; i < args.length; ++i) {
    99.                 ps.setObject(i + 1, args[i]);
    100.             }
    102.             rs = ps.executeQuery();
    103.             ResultSetMetaData rsmd = rs.getMetaData();
    104.             int columnCount = rsmd.getColumnCount();
    105.             if (rs.next()) {
    106.                 T t = clazz.newInstance();
    108.                 for(int i = 0; i < columnCount; ++i) {
    109.                     Object columValue = rs.getObject(i + 1);
    110.                     String columnLabel = rsmd.getColumnLabel(i + 1);
    111.                     Field field = clazz.getDeclaredField(columnLabel);
    112.                     field.setAccessible(true);
    113.                     field.set(t, columValue);
    114.                 }
    115.                 return t;
    116.             }
    117.         } catch (Exception var18) {
    118.             var18.printStackTrace();
    119.         } finally {
    120.             JDBCUtils.closeResource(conn, ps, rs);
    121.         }
    123.         return null;
    124.     }
    126.     @Test
    127.     public void testDeleteByExamCard() {
    128.         System.out.println("请输入学生的考号：");
    129.         Scanner scanner = new Scanner(System.in);
    130.         String examCard = scanner.next();
    131.         String sql = "select FlowID flowID,Type type,IDCard,ExamCard examCard,StudentName name,Location location,Grade grade from examstudent where examCard = ?";
    132.         Student student = (Student)this.getInstance(Student.class, sql, examCard);
    133.         if (student == null) {
    134.             System.out.println("查无此人，请重新输入");
    135.         } else {
    136.             String sql1 = "delete from examstudent where examCard = ?";
    137.             int deleteCount = this.update(sql1, examCard);
    138.             if (deleteCount > 0) {
    139.                 System.out.println("删除成功");
    140.             }
    141.         }
    143.     }
    145.     @Test
    146.     public void testDeleteByExamCard1() {
    147.         System.out.println("请输入学生的考号：");
    148.         Scanner scanner = new Scanner(System.in);
    149.         String examCard = scanner.next();
    150.         String sql = "delete from examstudent where examCard = ?";
    151.         int deleteCount = this.update(sql, examCard);
    152.         if (deleteCount > 0) {
    153.             System.out.println("删除成功");
    154.         } else {
    155.             System.out.println("查无此人，请重新输入");
    156.         }
    158.     }
    159. }

    PreparedStatement vs Statement两大优点体现：
    4.1 MySQL BLOB类型
    MySQL中，BLOB是一个二进制大型对象，是一个可以存储大量数据的容器，它能容纳不同大小的数据。
    插入BLOB类型的数据必须使用PreparedStatement，因为BLOB类型的数据无法使用字符串拼接写的。
    MySQL的四种BLOB类型(除了在存储的最大信息量上不同外，他们是等同的)
    image.png
    实际使用中根据需要存入的数据大小定义不同的BLOB类型。
    需要注意的是：如果存储的文件过大，数据库的性能会下降。如果在指定了相关的Blob类型以后，还报错：xxx too large，那么在mysql的安装目录下，找my.ini文件加上如
    下的配置参数： max_allowed_packet=16M。同时注意：修改了my.ini文件之后，需要重新启动mysql服务。

    1. /**
    2.  * 
    3.  * @Description 测试使用PreparedStatement操作Blob类型的数据
    4.  * @author shkstart  Email:shkstart@126.com
    5.  * @version 
    6.  * @date 下午4:08:58
    7.  *
    8.  */
    9. public class BlobTest {
    11.     //向数据表customers中插入Blob类型的字段
    12.     @Test
    13.     public void testInsert() throws Exception{
    14.         Connection conn = JDBCUtils.getConnection();
    15.         String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
    17.         PreparedStatement ps = conn.prepareStatement(sql);
    19.         ps.setObject(1,"袁浩");
    20.         ps.setObject(2, "yuan@qq.com");
    21.         ps.setObject(3,"1992-09-08");
    22.         FileInputStream is = new FileInputStream(new File("girl.jpg"));
    23.         ps.setBlob(4, is);
    25.         ps.execute();
    27.         JDBCUtils.closeResource(conn, ps);
    29.     }
    31.     //查询数据表customers中Blob类型的字段
    32.     @Test
    33.     public void testQuery(){
    34.         Connection conn = null;
    35.         PreparedStatement ps = null;
    36.         InputStream is = null;
    37.         FileOutputStream fos = null;
    38.         ResultSet rs = null;
    39.         try {
    40.             conn = JDBCUtils.getConnection();
    41.             String sql = "select id,name,email,birth,photo from customers where id = ?";
    42.             ps = conn.prepareStatement(sql);
    43.             ps.setInt(1, 21);
    44.             rs = ps.executeQuery();
    45.             if(rs.next()){
    46.     //            方式一：
    47.     //            int id = rs.getInt(1);
    48.     //            String name = rs.getString(2);
    49.     //            String email = rs.getString(3);
    50.     //            Date birth = rs.getDate(4);
    51.                 //方式二：
    52.                 int id = rs.getInt("id");
    53.                 String name = rs.getString("name");
    54.                 String email = rs.getString("email");
    55.                 Date birth = rs.getDate("birth");
    57.                 Customer cust = new Customer(id, name, email, birth);
    58.                 System.out.println(cust);
    60.                 //将Blob类型的字段下载下来，以文件的方式保存在本地
    61.                 Blob photo = rs.getBlob("photo");
    62.                 is = photo.getBinaryStream();
    63.                 fos = new FileOutputStream("zhangyuhao.jpg");
    64.                 byte[] buffer = new byte[1024];
    65.                 int len;
    66.                 while((len = is.read(buffer)) != -1){
    67.                     fos.write(buffer, 0, len);
    68.                 }
    70.             }
    71.         } catch (Exception e) {
    72.             e.printStackTrace();
    73.         }finally{
    75.             try {
    76.                 if(is != null)
    77.                     is.close();
    78.             } catch (IOException e) {
    79.                 e.printStackTrace();
    80.             }
    82.             try {
    83.                 if(fos != null)
    84.                     fos.close();
    85.             } catch (IOException e) {
    86.                 e.printStackTrace();
    87.             }
    89.             JDBCUtils.closeResource(conn, ps, rs);
    90.         }
    93.     }
    95. }

    5.1 批量执行SQL语句
    当需要成批插入或者更新记录时，可以采用Java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处
    理。通常情况下比单独提交处理更有效率
    JDBC的批量处理语句包括下面三个方法：
    addBatch(String)：添加需要批量处理的SQL语句或是参数；
    executeBatch()：执行批量处理语句；
    clearBatch():清空缓存的数据
    通常我们会遇到两种批量执行SQL语句的情况：
    多条SQL语句的批量处理；
    一个SQL语句的批量传参；

    1. /*
    2.  * 使用PreparedStatement实现批量数据的操作
    3.  * 
    4.  * update、delete本身就具有批量操作的效果。
    5.  * 此时的批量操作，主要指的是批量插入。使用PreparedStatement如何实现更高效的批量插入？
    6.  * 
    7.  * 题目：向goods表中插入20000条数据
    8.  * CREATE TABLE goods(
    9.     id INT PRIMARY KEY AUTO_INCREMENT,
    10.     NAME VARCHAR(25)
    11.    );
    12.  * 方式一：使用Statement
    13.  * Connection conn = JDBCUtils.getConnection();
    14.  * Statement st = conn.createStatement();
    15.  * for(int i = 1;i <= 20000;i++){
    16.  *         String sql = "insert into goods(name)values('name_" + i + "')";
    17.  *         st.execute(sql);
    18.  * }
    19.  * 
    20.  */
    21. public class InsertTest {
    22.     //批量插入的方式二：使用PreparedStatement
    23.     @Test
    24.     public void testInsert1() {
    25.         Connection conn = null;
    26.         PreparedStatement ps = null;
    27.         try {
    29.             long start = System.currentTimeMillis();
    31.             conn = JDBCUtils.getConnection();
    32.             String sql = "insert into goods(name)values(?)";
    33.             ps = conn.prepareStatement(sql);
    34.             for(int i = 1;i <= 20000;i++){
    35.                 ps.setObject(1, "name_" + i);
    37.                 ps.execute();
    38.             }
    40.             long end = System.currentTimeMillis();
    42.             System.out.println("花费的时间为：" + (end - start));//20000:83065
    43.         } catch (Exception e) {
    44.             e.printStackTrace();
    45.         }finally{
    46.             JDBCUtils.closeResource(conn, ps);
    48.         }
    50.     }
    52.     /*
    53.      * 批量插入的方式三：
    54.      * 1.addBatch()、executeBatch()、clearBatch()
    55.      * 2.mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。
    56.      *          ?rewriteBatchedStatements=true 写在配置文件的url后面
    57.      * 3.使用更新的mysql 驱动：mysql-connector-java-5.1.37-bin.jar
    58.      */
    59.     @Test
    60.     public void testInsert2() {
    61.         Connection conn = null;
    62.         PreparedStatement ps = null;
    63.         try {
    65.             long start = System.currentTimeMillis();
    67.             conn = JDBCUtils.getConnection();
    68.             String sql = "insert into goods(name)values(?)";
    69.             ps = conn.prepareStatement(sql);
    70.             for(int i = 1;i <= 1000000;i++){
    71.                 ps.setObject(1, "name_" + i);
    73.                 //1."攒"sql
    74.                 ps.addBatch();
    76.                 if(i % 500 == 0){
    77.                     //2.执行batch
    78.                     ps.executeBatch();
    80.                     //3.清空batch
    81.                     ps.clearBatch();
    82.                 }
    84.             }
    86.             long end = System.currentTimeMillis();
    88.             System.out.println("花费的时间为：" + (end - start));//20000:83065 -- 565
    89.         } catch (Exception e) {                                //1000000:16086
    90.             e.printStackTrace();
    91.         }finally{
    92.             JDBCUtils.closeResource(conn, ps);
    94.         }
    96.     }
    98.     //批量插入的方式四：设置连接不允许自动提交数据
    99.     @Test
    100.     public void testInsert3() {
    101.         Connection conn = null;
    102.         PreparedStatement ps = null;
    103.         try {
    105.             long start = System.currentTimeMillis();
    107.             conn = JDBCUtils.getConnection();
    109.             //设置不允许自动提交数据
    110.             conn.setAutoCommit(false);
    112.             String sql = "insert into goods(name)values(?)";
    113.             ps = conn.prepareStatement(sql);
    114.             for(int i = 1;i <= 1000000;i++){
    115.                 ps.setObject(1, "name_" + i);
    117.                 //1."攒"sql
    118.                 ps.addBatch();
    120.                 if(i % 500 == 0){
    121.                     //2.执行batch
    122.                     ps.executeBatch();
    124.                     //3.清空batch
    125.                     ps.clearBatch();
    126.                 }
    128.             }
    130.             //提交数据
    131.             conn.commit();
    133.             long end = System.currentTimeMillis();
    135.             System.out.println("花费的时间为：" + (end - start));//20000:83065 -- 565
    136.         } catch (Exception e) {                                //1000000:16086 -- 5114
    137.             e.printStackTrace();
    138.         }finally{
    139.             JDBCUtils.closeResource(conn, ps);
    141.         }
    143.     }
    144. }