数据库-----JDBC技术

曾经终败给现在 2023-09-23 16:14 59阅读 0赞

**目录**

JDBC概述

数据的持久化

什么是 JDBC

什么是数据库驱动程序

Java中访问数据库技术

程序操作数据库流程

JBDC中常用的类与接口

Driver 接口

DriverManager 类

Connection 接口

Statement 接口

PreparedStatement接口

ResultSet 接口

JDBC编写步骤

获取连接

下载数据库驱动

获取数据库连接

Properties文件的使用

properties文件介绍

Properties工具类

Properties工具类中常用方法

properties文件

操作properties文件

优化获取数据库连接

properties文件内容

获取连接

封装JDBC工具类

properties文件

JdbcUtil工具类

Statement的使用

Statement简介

通过Statement添加数据

创建表

添加数据

通过Statement修改数据

通过Statement删除数据

PreparedStatement的使用(重点)

PreparedStatement对象简介

PreparedStatement对象的特点：

PreparedStatement 的预编译能力

通过PreparedStatement添加数据

通过PreparedStatement修改数据

通过PreparedStatement删除数据

ResultSet的使用

ResultSet简介

ResultSet接口的特点

ResultSet特点

ResultSet使用原理

通过ResultSet获取查询结果

ORM编程思想

ORM简介

实体类

实体类特点：

ORM使用

Users实体类

ORM映射

SQL注入

什么是SQL注入

SQL注入案例

解决SQL注入

JDBC批量添加数据

批量添加数据简介

Mysql的URL参数说明

实现数据的批量添加

在url中开启批量添加

实现数据的批量添加方式一

实现数据的批量添加方式二

JDBC事务处理

JDBC中事务处理特点

JDBC事务处理实现

Blob类型的使用

MySql Blob类型简介

Mysql中的Blob类型

插入Blob类型数据

创建表

通过PreparedStatement存储Blob类型数据

解除文件大小限制

文件位置

编辑修改属性

读取Blob类型数据

其他查询方式

模糊查询

实现模糊查询

动态条件查询

动态条件查询实现

分页查询

分页查询简介

分页查询分类：

物理分页：

逻辑分页：

如何在MySql中实现物理分页查询

创建Page模型

Page

实现分页查询

分页实现

数据库连接池

数据库连接池简介

什么是数据库连接池

不使用数据库连接池存在的问题

JDBC数据库连接池的必要性

数据库连接池的优点

常用的数据库连接池

Druid连接池

Druid简介

Druid使用步骤

通过数据库连接池获取连接

通过druid重构JDBCUtils

应用程序分层

应用程序分层简介

三层结构

应用程序分层实现

在分层项目中实现查询业务

封装通用的BaseDao

封装通用的DML操作

封装通用的查询操作

对象的关联关系

关联关系简介

创建对象的关联关系

创建表

对象的关联关系

Users对象

Orders对象

Items对象

--------------------

# JDBC概述 #

## 数据的持久化 ##

> 持久化(persistence)：将内存中的数据保存到可永久保存的存储 设备中（如磁盘）。
> 
> 持久化的主要应用是将内存中的数据存储在关系型数据库中，当 然也可以存储在磁盘文件、XML数据文件中。

![5aa131932ce14062b74c3a4178d090d6.png][]

## 什么是 JDBC ##

> 1、JDBC（Java DataBase Connectivity）java 数据库连接
> 
> 2、是 JavaEE 平台下的技术规范
> 
> 3、定义了在 Java 语言中连接数据库，执行 SQL 语句的标准 API
> 
> 4、可以为多种关系数据库提供统一访问

## 什么是数据库驱动程序 ##

> 1、数据库驱动就是直接操作数据库的一个程序
> 
> 2、不同数据产品的数据库驱动名字有差异
> 
> 3、在程序中需要依赖数据库驱动来完成对数据库的操作

## Java中访问数据库技术 ##

> 1、基于JDBC标准访问数据库
> 
> 2、使用第三方ORM 框架，如Hibernate, Mybatis 等访问数据库

## 程序操作数据库流程 ##

如果没有JDBC，那么Java程序访问数据库时是这样的：

![c9eec2bed559449a8928772038591e2a.png][]

有了JDBC，Java程序访问数据库时是这样的：

![655cb0361d5e4f0090179f6e55351939.png][]

##  **JBDC中常用的类与接口** ##

### Driver 接口 ###

> Driver 接口的作用是来定义数据库驱动对象应该具备的一些能 力。比如与数据库建立连 接的方法的定义，该接口是提供给数据库厂商使用的，所有支持 java 语言连接的数据库都实现了该接口，实现该接口的类我们称 之为数据库驱动类。

### DriverManager 类 ###

DriverManager是驱动程序管理器，是负责管理数据库驱动程序 的。驱动注册以后，会保存在DriverManager中的已注册列表 中。 DriverManager 通过实例化的数据库驱动对象，能够建立 应用程序与数据库之间建立连 接。并返回 Connection 接口类型 的数据库连接对象。

> getConnection(String jdbcUrl, String user, String password) 该方法通过访问数据库的 url、用户以及密码，返回对应的数 据库的 Connection 对象。 JDBC URL 与数据库连接时，用来连接到指定数据库标识符。在 URL 中 包括了该数据库的类型、 地址、端口、库名称等信息。不同 品牌数据库的连接 URL 不同。

**连接 MySql 数据库：**

Connection conn = DriverManager.getConnection
    ("jdbc:mysql://host:port/database", "user","password");

**连接 Oracle 数据库：**

Connection conn = DriverManager.getConnection
    ("jdbc:oracle:thin:@host:port:database","user", "password");

### Connection 接口 ###

Connection 是数据库的连接（会话）对象。对数据库的一切操 作都是在这个连接基础之上进行的，我们可以通过该对象执行 sql 语句并返回结果。

**常用方法**

> 1、createStatement() 创建向数据库发送 sql 的 Statement 接口类型的对象。
> 
> 2、preparedStatement(sql) 创建向数据库发送预编译 sql 的 PrepareSatement 接口类型的对象。
> 
> 3、setAutoCommit(boolean autoCommit) 设置事务是否自动提交。
> 
> 4、commit() 在链接上提交事务。
> 
> 5、rollback() 在此链接上回滚事务。

###  **Statement 接口** ###

用于执行静态 SQL 语句并返回它所生成结果的对象。 由 createStatement 创建，用于发送简单的 SQL 语句（不支持动 态绑定）。

**常用方法**

> 1、execute(String sql) 执行参数中的 SQL，返回是否有结果集。
> 
> 2、executeQuery(String sql) 运行 select 语句，返回 ResultSet 结果集。
> 
> 3、executeUpdate(String sql) 运行 insert/update/delete 操作，返回更新的行数。
> 
> 4、addBatch(String sql) 把多条 sql 语句放到一个批处理中。
> 
> 5、executeBatch() 向数据库发送一批 sql 语句执行。

### PreparedStatement接口 ###

继承自 Statement 接口，由 preparedStatement 创建，用于发 送含有一个或多个参数的 SQL 语句。PreparedStatement 对象 比 Statement 对象的效率更高，由于实现了动态的参数绑定， 所以可以防止 SQL 注入，所以我们一般都使用 PreparedStatement。

**常用方法**

> **1、addBatch()**
> 
> 把当前 sql 语句加入到一个批处理中。
> 
> **2、execute()**
> 
> 执行当前 SQL，返回个 boolean 值
> 
> **3、executeUpdate()**
> 
> 运行 insert/update/delete 操作，返回更新的行数。
> 
> **4、executeQuery()**
> 
> 执行当前的查询，返回一个结果集对象
> 
> **5、setDate(int parameterIndex, Date x)**
> 
> 向当前SQL语句中的指定位置绑定一个java.sql.Date值
> 
> **6、setDouble(int parameterIndex, double x)**
> 
> 向当前 SQL 语句中的指定位置绑定一个 double值
> 
> **7、setFloat(int parameterIndex, float x)**
> 
> 向当前 SQL 语句中的指定位置绑定一个 float 值
> 
> **8、setInt(int parameterIndex, int x)**
> 
> 向当前 SQL 语句中的指定位置绑定一个 int 值
> 
> **9、setString(int parameterIndex, String x)**
> 
> 向当前 SQL 语句中的指定位置绑定一个 String 值

### ResultSet 接口 ###

ResultSet 用来暂时存放数据库查询操作获得结果集。

**常用方法**

> **1、getString(int index)、getString(String columnName)**
> 
> 获得在数据库里是 varchar、char 等类型的数据对象。
> 
> **2、getFloat(int index)、getFloat(String columnName)**
> 
> 获得在数据库里是 Float 类型的数据对象。
> 
> **3、getDate(int index)、getDate(String columnName)**
> 
> 获得在数据库里是 Date 类型的数据。
> 
> **4、getBoolean(int index)、getBoolean(String columnName)**
> 
> 获得在数据库里是 Boolean 类型的数据。
> 
> **5、getObject(int index)、getObject(String columnName)**
> 
> 获取在数据库里任意类型的数据。

## JDBC编写步骤 ##

![ad70bc4540a54453ae0cd39f07d8da76.png][]

> 注：ODBC(Open Database Connectivity，开放式数据库连接)， 是微软在Windows平台下推出的。使用者在程序中只需要调用 ODBC API，由 ODBC 驱动程序将调用转换成为对特定的数据库的 调用请求。

# 获取连接 #

![8a291d3d91264756b0ee435ed0c5e2d3.png][]

## 下载数据库驱动 ##

> [MySQL :: Download MySQL Connector/J (Archived Versions)][MySQL _ Download MySQL Connector_J _Archived Versions]

## 获取数据库连接 ##

/**
    * 获取数据库连接测试类
    */
    public class JdbcTest {
         public static void main(String[] args) throws ClassNotFoundException, SQLException
          {
            //连接Mysql数据库的URL
            String url = "jdbc:mysql://localhost:3306/itjdbc";
            //连接数据库的用户名
            String name = "root";
            //连接数据库的密码  
            String pwd01 = "";
            //通过反射实现数据库驱动的加载与注册
            Class.forName("com.mysql.jdbc.Driver");
            //通过DriverManager对象获取数据库的连接对象
            Connection connection = DriverManager.getConnection(url, name, pwd);
            System.out.println(connection);
         }
    }

> 在加载com.mysql.jdbc.Driver类信息时，会执行静态块中的代码。 在静态块中 ，数据库驱动会实例化自己并通过DriverManager的 registerDriver方法，将自己注册DriverManager驱动管理器中。

![00b117b3852243f4951d977e315b4ed4.png][]

## Properties文件的使用 ##

![fb627e643b7748139aa3d9da5f274c29.png][]

## properties文件介绍 ##

> 后缀properties的文件是一种属性文件。这种文件以key=value格式 存储内容。Java中可以使用Properties工具类来读取这个文件。项 目中会将一些配置信息放到properties文件中，所以properties文 件经常作为配置文件来使用。

## Properties工具类 ##

> Properties工具类，位于java.util包中，该工具类继承自 Hashtable。通过Properties工具类可以读 取.properties类型的配置文件。

## Properties工具类中常用方法 ##

> load(InputStream is) 通过给定的输入流对象读取properties文件并解析
> 
> getProperty(String key) 根据key获取对应的value
> 
> 注意： 如果properties文件中含有中文那么需要对idea进行设置。

![e6ad2d11cdba4a758806aa0d84a32907.png][]

## properties文件 ##

#我是中国人
    key1=ITBZ
    key2=BJSXT
    key3=我是中国人

## 操作properties文件 ##

/**
    * 读取properties配置文件的测试类
    */
    public class PropertiesTest {
        public static void main(String[] args) throws IOException {
            //实例化Properties对象
            Properties prop = new Properties();
            //获取读取properties文件的输入流对象
            InputStream is = PropertiesTest.class.getClassLoader().getResourceAsStream("test.properties");
           //通过给定的输入流对象读取properties文件并解析。
            prop.load(is);
            //获取properties文件中的内容
            String value1 =prop.getProperty("key1");
            String value2 =prop.getProperty("key2");
            String value3 =prop.getProperty("key3");
            System.out.println(value1+""+value2+" "+value3);
       }
    }

## **优化获取数据库连接** ##

将连接数据库时所需要的信息存放到properties文件中，可以解决 硬编码的问题。

## properties文件内容 ##

#连接Mysql数据库的URL
    url=jdbc:mysql://localhost:3306/itjdbc
    #连接数据库的用户名
    username=root
    #连接数据库的密码
    pwd= XXXX
    #数据库驱动名称
    driver=com.mysql.jdbc.Driver

## 获取连接 ##

/**
    * 优化获取数据库连接
    */
    public class JdbcTest2 {
        public static void main(String[] args) throws IOException, ClassNotFoundException,
    SQLException {
            //实例化Properties对象
            Properties prop = new Properties();
            //获取读取properties文件的字节输入流对象
            InputStream is = JdbcTest2.class.getClassLoader().getResourceAsStream("jdbc.properties");
            //读取properties文件并解析
            prop.load(is);
            //获取连接数据库的url
            String url = prop.getProperty("url");
            //获取连接数据库的用户名
            String name = prop.getProperty("username");
            //获取连接数据库的密码
            String pwd = prop.getProperty("pwd");
            //获取数据库驱动全名
            String drivername = prop.getProperty("driver");
            //加载并注册驱动
            Class.forName(drivername);
            //通过驱动管理器对象获取连接对象
            Connection connection = DriverManager.getConnection(url, name, pwd);
            System.out.println(connection);
       }
    }

## 封装JDBC工具类 ##

![ccdc3dd0955148bc8f78bcab829758c4.png][]

## properties文件 ##

## JdbcUtil工具类 ##

/**
    * Jdbc工具类
    */
    public class JdbcUtils {
        private static String url;
        private static String name;
        private static String pwd;
        static {
            try{
                //实例化Properties对象
                Properties prop = new Properties();
                //获取读取properties文件的字节输入流 对象
                InputStream is = JdbcTest2.class.getClassLoader().getResourceAsStream("jdbc.properties");
                //读取properties文件并解析
                prop.load(is);
                //获取连接数据库的url
                url = prop.getProperty("url");
                //获取连接数据库的用户名
                name = prop.getProperty("username");
                //获取连接数据库的密码
                pwd = prop.getProperty("pwd");
                //获取数据库驱动全名
                String drivername = prop.getProperty("driver");
                //加载并注册驱动
                Class.forName(drivername);  }catch(Exception e){
                e.printStackTrace();
           }
       }
        //获取数据库连接对象
        public static Connection getConnection()
          {
              Connection connection = null;
              try {
               connection = DriverManager.getConnection(url,name,pwd);
           } catch (SQLException throwables) {
                throwables.printStackTrace();
           }
            return connection;
       }
        //关闭连接对象
        public static void closeConnection(Connection connection){
            try {
                connection.close();
           } catch (SQLException throwables) {
                throwables.printStackTrace();
           }
       }
        //提交事务
        public static void commit(Connection connection){
            try {
                connection.commit();
           } catch (SQLException throwables) { throwables.printStackTrace();
           }
       }
        //事务回滚
        public static void rollback(Connection connection){
            try {
                connection.rollback();
           } catch (SQLException throwables) {
                throwables.printStackTrace();
           }
       }
        //关闭Statement对象
        public static void closeStatement(Statement statement){
            try {
                statement.close();
           } catch (SQLException throwables) {
                throwables.printStackTrace();
           }
       }
        //关闭ResultSet
        public static void closeResultSet(ResultSet resultSet) {
            try {
                resultSet.close();
           } catch (SQLException throwables) {
                throwables.printStackTrace();
           }
       }
        //DML操作时关闭资源
        public static void closeResource(Statement statement,Connection connection){
            //先关闭Statement对象
            closeStatement(statement);
            //在关闭Connection对象
            closeConnection(connection);
           }
        //查询时关闭资源
        public static void closeResource(ResultSet resultSet,Statement statement,Connection connection){
            //先关闭ResultSet
            closeResultSet(resultSet);
            //在闭Statement对象
            closeStatement(statement);
            //最后关闭Connection对象
            closeConnection(connection);
       }
    }

## Statement的使用 ##

![12f26f6e2a444418ba92c32197a86553.png][]

## Statement简介 ##

**Statement接口特点**

> 用于执行静态 SQL 语句并返回它所生成结果的对象。 由 createStatement 创建，用于发送简单的 SQL 语句（不支持动态绑 定）。
> 
> 注意： 由于Statement对象是一个执行静态SQL语句的对象，所以该对 象存在SQL注入风险。

**JDBC中三种Statement对象**

> Statement：用于执行静态 SQL 语句。
> 
> PreparedStatement：用于执行预编译SQL语句。
> 
> CallableStatement：用于执行数据库存储过程。

![840c3184319149ea881abf91230a346d.png][]

## 通过Statement添加数据 ##

### 创建表 ###

CREATE TABLE `users` (
      `userid` int(11) NOT NULL AUTO_INCREMENT,
      `username` varchar(30) DEFAULT NULL,
      `userage` int(11) DEFAULT NULL,
      PRIMARY KEY (`userid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

### 添加数据 ###

/**
    * Statement对象的使用
    */
    public class StatementTest {
        /**
         * 添加用户
         */
        public void insertUsers(String username,int userage){
            Connection connection = null;
            Statement statement = null;
            try{
                //获取Connection对象。
                connection = JdbcUtils.getConnection();
                //获取Statement对象
                statement = connection.createStatement();
                //定义需要执行的SQL语句
                String sql = "insert into users values(default,'"+username+"',"+userage+")";
                //执行SQL,返回boolean值，如果sql有结果集返回，那么返回值为true，如果没有结果集返回，则返回false。
                boolean execute = statement.execute(sql);
                System.out.println(execute);
           }catch(Exception e){
                e.printStackTrace();
           }finally{
              JdbcUtils.closeResource(statement,connection);
           }
       }
    }

### 通过Statement修改数据 ###

/**
         * 修改用户信息
         */
        public void updateUsers(int userid,String username,int userage){
            Connection connection = null;
            Statement statement  = null;
            try{
                    //获取连接对象
                   connection = JdbcUtils.getConnection();
                   //获取Statement对象
                   statement = connection.createStatement();
                   //定义sql语句
                   String sql ="update users set username='"+username+"',userage="+userage+"
    where userid="+userid;
                   //执行sql语句
                   int i = statement.executeUpdate(sql);
                   System.out.println(i);
               }catch(Exception e){
                    e.printStackTrace();
               }finally{
                  JdbcUtils.closeResource(statement,connection);
               }
       }

### 通过Statement删除数据 ###

/**
         * 根据用户ID删除用户
         */
        public void deleteUsersById(int userid){
            Connection connection =null;
            Statement statement = null;
            try{
                //获取数据库连接
                connection = JdbcUtils.getConnection();
                //获取Statement对象
                statement = connection.createStatement();
                //定义执行删除语句
                String sql = "delete from users where userid="+userid;
                //执行sql
                int i = statement.executeUpdate(sql);
                System.out.println(i);
           }catch(Exception e){
                e.printStackTrace();
           }finally{
               JdbcUtils.closeResource(statement,connection);
           }
       }

# PreparedStatement的使用(重点) #

![240e6700286e4ad6b995787872624a44.png][]

## PreparedStatement对象简介 ##

继承自 Statement 接口，由 preparedStatement方法创建。 PreparedStatement具有预编译SQL语句能力，所以 PreparedStatement 对象比 Statement 对象的效率更高，由于实 现了动态的参数绑定，所以可以防止 SQL 注入，所以我们一般都使 用 PreparedStatement。

### PreparedStatement对象的特点： ###

> PreparedStatement 接口继承 Statement 接口
> 
> PreparedStatement 效率高于 Statement
> 
> PreparedStatement 支持动态绑定参数
> 
> PreparedStatement 具备 SQL 语句预编译能力 使用
> 
> PreparedStatement 可防止出现 SQL 注入问题

## PreparedStatement 的预编译能力 ##

**语句的执行步骤**

> 1、语法和语义解析
> 
> 2、优化 sql 语句，制定执行计划
> 
> 3、执行并返回结果

> 但是很多情况，我们的一条 sql 语句可能会反复执行，或者每次执 行的时候只有个别的值不同（比如 select 的 where 子句值不同， update 的 set 子句值不同,insert 的 values 值不同）。 如果每次都 需要经过上面的词法语义解析、语句优化、制定执行计划等，则效 率就明显不行 了。所谓预编译语句就是将这类语句中的值用占位符 替代，可以视为将 sql 语句模板化或者说参数化预编译语句的优势 在于：一次编译、多次运行，省去了解析优化等过程；此外预编译 语 句能防止 sql 注入

## 通过PreparedStatement添加数据 ##

/**
    * PreparedStatement使用的测试类
    */
    public class PreparedStatementTest {
        /**
         * 添加用户
         */
        public void insertUsers(String username,int userage){
            Connection connection = null;
            PreparedStatement ps = null;
            try{
                //获取数据库连接
                connection = JdbcUtils.getConnection();
                //定义Sql。?是PreparedStatement对象中的绑定参数的占位符。问号的位置是从1开始计数的
                String sql = "insert into users values(default,?,?)";
                //创建PreparedStatement对象
                ps = connection.prepareStatement(sql);
                //完成参数的绑定
                ps.setString(1,username);
                ps.setInt(2,userage);
                int i = ps.executeUpdate();
                System.out.println(i);
           }catch(Exception e){
                e.printStackTrace();
           }finally{
                JdbcUtils.closeResource(ps,connection);
           }
       }
    }

## 通过PreparedStatement修改数据 ##

/**
         * 根据用户ID修改用户姓名与年龄
         */
        public void updateUsersById(int userid,String username,int userage){
                Connection connection = null;
                PreparedStatement ps = null;
               try{
                   //获取数据库连接对象
                   connection = JdbcUtils.getConnection();
                   //创建PreparedStatement对象
                   ps = connection.prepareStatement("update users set username = ?,userage=? where userid = ?");
                   //参数绑定
                   ps.setString(1,username);
                   ps.setInt(2,userage);
                   ps.setInt(3,userid);
                   int i = ps.executeUpdate();
                   System.out.println(i);
               }catch(Exception e){
                   e.printStackTrace();
               }finally{
                   JdbcUtils.closeResource(ps,connection);
               }
       }

## 通过PreparedStatement删除数据 ##

/**
         * 根据用户ID删除指定用户
         */
        public void deleteUsersById(int userid){
                Connection conn = null;
                PreparedStatement ps = null;
            try{
                //获取数据库连接对象
                conn = JdbcUtils.getConnection();
                //创建PreparedStatement对象
                ps = conn.prepareStatement("delete from users where userid = ? ");
                //绑定参数
                ps.setInt(1,userid);
                int i = ps.executeUpdate();
                System.out.println(i);
           }catch (Exception e){
                e.printStackTrace();
           }finally{
                JdbcUtils.closeResource(ps,conn);
           }
       }

# ResultSet的使用 #

![acf8cd0d2e6e4f46809f8e974b0537c6.png][]

## ResultSet简介 ##

### ResultSet接口的特点 ###

ResultSet用来存放数据库查询操作获得结果集，通过对ResultSet 的操作可以获取查询到的结果集数据。

> 注意： ResultSet 对象中存放的并不是我们查询到的所有的结果集。它 采用分块加载的方式来载入结果集数据

### ResultSet特点 ###

> 1、ResultSet 对象具有指向其当前数据行的指针。最初，指针被置于第一行之前。next 方法将指针移 动到下一行；因为该方法在 ResultSet 对象中没有下一行时返回 false，所以可以在 while 循环中使 用它来迭代结果集。
> 
> 2、默认的 ResultSet 对象仅有一个向前移动的指针。因此，只能迭代它一次，并且只能按从第一行到 最后一行的顺序进行。
> 
> 3、ResultSet 接口提供用于获取当前行检索列值的获取方法（getBoolean、getLong 等）。可以使用 列的索引位置或列的名称检索值。

### ResultSet使用原理 ###

![6cff0007cb93418b92cc37dc14d9c97d.png][]

## 通过ResultSet获取查询结果 ##

/**
    * 获取结果集测试类
    */
    public class ResultSetTest {
        /**
         * 查询所用用户
         */
        public void selectUsersAll(){
            Connection connection = null;
            PreparedStatement ps = null;
            ResultSet resultSet = null;
            try{
                //获取数据库连接
                connection = JdbcUtils.getConnection();
                //创建PreparedStatement对象
                ps = connection.prepareStatement("select * from users");
                //执行查询
                resultSet = ps.executeQuery();
                //操作ResultSet对象获取查询的结果集
                while(resultSet.next()){
                    //获取列中的数据
                    int userid = resultSet.getInt("userid");
                    String username = resultSet.getString("username");
                    int userage = resultSet.getInt("USERAGE");
                    System.out.println(userid+" "+username+" "+userage);
               }
           }catch(Exception e){
                e.printStackTrace();
           }finally{
              JdbcUtils.closeResource(resultSet,ps,connection);
           }
       }
    }

# ORM编程思想 #

![e1cbde5442404fe2b1b29829a1d2ea3f.png][]

## ORM简介 ##

对象关系映射（英语：Object Relational Mapping，简称ORM，或 O/R mapping）是一种为了解决面向对象语言与关系数据库存在的 互不匹配的现象。

![ac88ea7fc2004cf3afed043152222e44.png][]

### 实体类 ###

实体类就是一个定义了属性，拥有getter、setter、无参构造方法 （基本必备）的一个类。实体类可以在数据传输过程中对数据进行 封装，相当于一个“工具”、“容器”、“载体”，能存储、传输数据，能 管理数据。

### 实体类特点： ###

> 1 实体类名，尽量和数据库中的表名一一对应
> 
> 2 实体类中的属性对应数据库表中的字段，相关的命名最好也一一对应
> 
> 3 实体类内方法主要有，getter、setter方法，用于设置、获取数据
> 
> 4 实体类属性一般为private类型，方法为public类型
> 
> 5 实体类应该有，无参、有参构造方法

## ORM使用 ##

### Users实体类 ###

/**
    * 实体类，存放Users表中的数据
    */
    public class Users {
        private int userid;
        private String username;
        private int userage;
        public int getUserid() {
            return userid;
       }
        
    public void setUserid(int userid) {
            this.userid = userid;
       }
        
    public String getUsername() {
            return username;
       }
        
    public void setUsername(String username)
      {
            this.username = username;
       }
        
    public int getUserage() {
            return userage;
       }
        
    public void setUserage(int userage) {
            this.userage = userage;
       }
    }

### ORM映射 ###

/**
         * 查询所用用户
    */
        public List<Users> selectUsersAll(){
            Connection connection = null;
            PreparedStatement ps = null;
            ResultSet resultSet = null;
            List<Users> list = new ArrayList<>();
            try{
                //获取数据库连接
                connection = JdbcUtils.getConnection();
                //创建PreparedStatement对象
                ps = connection.prepareStatement("select * from users");
                //执行查询
                resultSet = ps.executeQuery();
                //操作ResultSet对象获取查询的结果集
                while(resultSet.next()){
                    //获取列中的数据
                    int userid = resultSet.getInt("userid");
                    String username = resultSet.getString("username");
                    int userage = resultSet.getInt("USERAGE");
                    //System.out.println(userid+" "+username+" "+userage);
                    //ORM映射处理
                    Users users = new Users();
                    users.setUserid(userid); 
                    users.setUsername(username);
                    users.setUserage(userage);
                    list.add(users);
               }
           }catch(Exception e){
                e.printStackTrace();
           }finally{
              JdbcUtils.closeResource(resultSet,ps,connection);
           }
            return list;
       }

# SQL注入 #

![fb54d5345729457eb422b82b849d156e.png][]

## 什么是SQL注入 ##

所谓 SQL 注入，就是通过把含有 SQL 语句片段的参数插入到需要 执行的 SQL 语句中， 最终达到欺骗数据库服务器执行恶意操作的 SQL 命令。

### SQL注入案例 ###

/**
    * SQL注入测试类
    */
    public class SqlInjectTest {
        /**
         * 体现sql注入
         */
        public void sqlInject(String username,int userage){
            Connection connection =null;
            Statement statement =null;
            ResultSet resultSet =null;
            try{
                //获取连接
                connection = JdbcUtils.getConnection();
                //创建Statement对象
                statement = connection.createStatement();
                //定义sql语句
                String sql ="select * from users where username ='"+username+"' and userage = "+userage;
                System.out.println(sql);
                //执行sql语句
                resultSet = statement.executeQuery(sql);
                //处理结果集
                while(resultSet.next()){
                    int userid = resultSet.getInt("userid");
                    String name = resultSet.getString("username");
                    int age = resultSet.getInt("userage");
                    System.out.println(userid+" "+name+" "+age);
               }
           }catch(Exception e){
                e.printStackTrace();
           }finally{
               JdbcUtils.closeResource(resultSet,statement,connection);
           }
       }
        public static void main(String[] args) {
            SqlInjectTest sit = new SqlInjectTest();
            sit.sqlInject("oldlu' or 1=1 --",28);
       }
    }

### 解决SQL注入 ###

public void noSqlInject(String username,int userage){
                Connection connection = null;
                PreparedStatement ps =null;
                ResultSet resultSet = null;
               try{
                    //获取连接
                   connection = JdbcUtils.getConnection();
                   //创建PreparedStatement对象
                   ps = connection.prepareStatement("select * from users where username = ? and userage = ?");
                   //绑定参数
                   ps.setString(1,username);
                   ps.setInt(2,userage);
                   //执行sql
                   resultSet = ps.executeQuery();
                   //处理结果集
                   while(resultSet.next()){
                       int userid = resultSet.getInt("userid");
                       String name = resultSet.getString("username");
                       int age = resultSet.getInt("userage");
                       System.out.println(userid+" "+name+" "+age);
                   }
               }catch(Exception e){
                   e.printStackTrace();
               }finally{
                   JdbcUtils.closeResource(resultSet,ps,connection);
               }
       }

# JDBC批量添加数据 #

## 批量添加数据简介 ##

在JDBC中通过PreparedStatement的对象的addBatch()和 executeBatch()方法进行数据的批量插入。

> addBatch()把若干SQL语句装载到一起，然后一次性传送到数据库执行，即是批量处理sql数据的。
> 
> executeBatch()会将装载到一起的SQL语句执行。

> 注意： MySql默认情况下是不开启批处理的。 数据库驱动从5.1.13开始添加了一个对rewriteBatchStatement 的参数的处理，该参数能够让MySql开启批处理。在url中添加 该参数：rewriteBatchedStatements=true

## Mysql的URL参数说明 ##

![1daaa63363d746f1abadcbf655e4a70c.png][]

## 实现数据的批量添加 ##

### 在url中开启批量添加 ###

rewriteBatchedStatements=true

### **实现数据的批量添加方式一** ###

/**
         * 批量添加数据方式一
         */
        public void addBatch1(){
            Connection conn = null;
            PreparedStatement ps =null;
            try{
                //创建连接
                conn = JdbcUtils.getConnection();
                //创建PreparedStatement
                ps = conn.prepareStatement("insert into users  values(default ,?,?)");
                //参数绑定
                for(int i=0;i<1000;i++){
                    //绑定username
                    ps.setString(1,"ITBZ"+i);
                    //绑定userage
                    ps.setInt(2,20);
                    //缓存sql
                    ps.addBatch();
               }
                //执行sql
                ps.executeBatch();
           }catch(Exception e){
                e.printStackTrace();
           }finally{
              JdbcUtils.closeResource(ps,conn);
           }
       }

### 实现数据的批量添加方式二 ###

/**
         * 批量添加数据方式二
         */
        public void addBatch2(){
            Connection conn = null;
            PreparedStatement ps =null;
            try{
                //创建连接
                conn = JdbcUtils.getConnection();
                //创建PreparedStatement
                ps = conn.prepareStatement("insert into users  values(default ,?,?)");
                //参数绑定
                for(int i=1;i<=1000;i++){
                    //绑定username
                    ps.setString(1,"ITBZ"+i);
                    //绑定userage
                    ps.setInt(2,20);
                    //缓存sql
                    ps.addBatch();
                    if(i%500 == 0){
                        //执行sql
                        ps.executeBatch();
                        //清除缓存
                        ps.clearBatch();
                   }
               }
           }catch(Exception e){
                e.printStackTrace();
           }finally{
               JdbcUtils.closeResource(ps,conn);
           }
       }

# JDBC事务处理 #

![6b56d0eb56f047f3bd9170735f31f026.png][]

**事务简介**

**事务：**

事务是指作为单个逻辑工作单元执行的一系列操作，要么完全地 执行，要么完全地不执行。

**事务操作流程：**

**1、**开启事务

2、提交事务

3、回滚事务

## JDBC中事务处理特点 ##

> 在JDBC中，使用Connection对象来管理事务，默认为自动提交事 务。可以通过setAutoCommit(boolean autoCommit)方法设置事 务是否自动提交，参数为boolean类型，默认值为true，表示自动 提交事务，如果值为false则表示不自动提交事务，需要通过 commit方法手动提交事务或者通过rollback方法回滚事务。

### JDBC事务处理实现 ###

/**
         * 批量添加数据方式二
         * 支持事务处理
    */
        public void addBatch2(){
            Connection conn = null;
            PreparedStatement ps =null;
            try{
                //创建连接
                conn = JdbcUtils.getConnection();
                //设置事务的提交方式，将自动提交修改为手动提交
               conn.setAutoCommit(false);
                //创建PreparedStatement
                ps = conn.prepareStatement("insert into users values(default ,?,?)");
                //参数绑定
                for(int i=1;i<=1000;i++){
                    //绑定username
                    ps.setString(1,"ITBZ"+i);
                    //绑定userage
                    ps.setInt(2,20);
                    //缓存sql
                    ps.addBatch();
                    if(i%500 == 0){
                        //执行sql
                        ps.executeBatch();
                        //清除缓存
                        ps.clearBatch();
                    }
                    if(i==501){
                        String str = null;
                        str.length();
                   }
               }
                //提交事务
               JdbcUtils.commit(conn);
           }catch(Exception e){
                e.printStackTrace();
                JdbcUtils.rollback(conn);
           }finally{
              JdbcUtils.closeResource(ps,conn);
           }
       }

# Blob类型的使用 #

![99bbada732b247489033738407a78844.png][]

## MySql Blob类型简介 ##

> Blob(全称：Binary Large Object 二进制大对象)。在MySql中， Blob是一个二进制的用来存储图片，文件等数据的数据类型。操作 Blob类型的数据必须使用PreparedStatement，因为Blob类型的数 据无法使用字符串拼接。大多数情况，并不推荐直接把文件存放在 MySQL 数据库中，但如果应用场景是文件与数据高度耦合，或者对 文件安全性要求较高的，那么将文件与数据存放在一起，即安全， 又方便备份和迁移。

### Mysql中的Blob类型 ###

MySql中有四种Blob类型，它们除了在存储的最大容量上不同，其 他是一致的。

![013cd3f07e2a440e8a7fecb3a19d90c3.png][]

**Blob类型使用的注意事项**

> 1、实际使用中根据需要存入的数据大小定义不同的Blob类型。
> 
> 2、如果存储的文件过大，数据库的性能会下降。

# 插入Blob类型数据 #

## 创建表 ##

CREATE TABLE `movie` (
      `movieid` int(11) NOT NULL AUTO_INCREMENT,
      `moviename` varchar(30) DEFAULT NULL,
      `poster` mediumblob,
      PRIMARY KEY (`movieid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

## 通过PreparedStatement存储Blob类型数据 ##

/**
    * Blob类型操作测试类
    */
    public class BlobTest {
        /**
         * 向Movie表中插入数据
         */
        public void insertMovie(String moviename, InputStream is){
            Connection conn =null;
            PreparedStatement ps =null;
            try{
                //获取连接
                conn = JdbcUtils.getConnection();
                //创建PreparedStatement对象
                ps = conn.prepareStatement("insert into movie values(default,?,?)");
                //绑定参数
                ps.setString(1,moviename);
                ps.setBlob(2,is);
                ps.executeUpdate();
           }catch(Exception e){
                e.printStackTrace();
           }finally{
               JdbcUtils.closeResource(ps,conn);
           }
       }
        public static void main(String[] args) throws FileNotFoundException {
            BlobTest bt = new BlobTest();
            //创建读取文件的IO流
            InputStream is = new FileInputStream(new File("d:/1.jpg"));
            bt.insertMovie("战狼",is);
       }
    }

### 解除文件大小限制 ###

> 虽然MediumBlob允许保存最大值为16M，但MySql中默认支持的 容量为4194304即4M。我们可以通过修改Mysql的my.ini文件中 max\_allowed\_packet属性扩大支持的容量，修改完毕后需要重启 MySql服务。

### 文件位置 ###

### ![13cfcd06f061415e8f8735099cc8cfe4.png][]修改属性 ###

![dae0d54c29b249e78685cc78bec19b93.png][]

## 读取Blob类型数据 ##

/**
         * 根据影片ID查询影片信息
         * @param movieid
         */
        public void selectMovieById(int movieid)
          {
             Connection conn =null;
             PreparedStatement ps = null;
             ResultSet rs = null;
             try{
                //获取连接
                 conn =JdbcUtils.getConnection();
                 //创建PreparedStatement对象
                 ps = conn.prepareStatement("select * from movie where movieid = ?");
                 //绑定参数
                 ps.setInt(1,movieid);
                 //执行sql
                 rs = ps.executeQuery();
                 while(rs.next()){
                     int id = rs.getInt("movieid");
                     String name = rs.getString("moviename");
                     System.out.println(id+" "+name);
                     //获取blob类型的数据
                     Blob blob = rs.getBlob("poster");
                     //获取能够从Blob类型的列中读取数 据的IO流
                     InputStream is = blob.getBinaryStream();
                     //创建文件输出字节流对象
                     OutputStream os = new FileOutputStream(id+"_"+name+".jpg");
                     //操作流完成文件的输出处理
                     byte[] buff = new byte[1024];
                     int len;
                     while((len = is.read(buff)) != -1){
                         os.write(buff,0,len);
                     }
                     os.flush();
                     is.close();
                     os.close();
                 }
             }catch(Exception e){
                 e.printStackTrace();
             }finally{
                JdbcUtils.closeResource(rs,ps,conn);
             }
    }

# 其他查询方式 #

## 模糊查询 ##

![44c5febf9ebc4917b3475219725266fa.png][]

### 实现模糊查询 ###

/**
    * 模糊查询测试类
    */
    public class FuzzyQueryTest {
        /**
         * 根据用户名称模糊查找用户信息
         */
        public List<Users> fuzzyQuery(String username){
            List<Users> list= new ArrayList<>();
            Connection conn =null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            try{
                //获取数据库连接
                conn = JdbcUtils.getConnection();
                //创建PreparedStatement对象
                ps = conn.prepareStatement("select * from users where username like ?");
                //参数绑定
                ps.setString(1,username);
                //执行sql语句
                rs = ps.executeQuery();
                while(rs.next()){
                    Users user = new Users();
                  user.setUserid(rs.getInt("userid"));
                  user.setUsername(rs.getString("username"));
                  user.setUserage(rs.getInt("userage"));
                    list.add(user);
               }
           }catch(Exception e){
                e.printStackTrace();
           }finally{
              JdbcUtils.closeResource(rs,ps,conn);
           }
              return list;
       }
        public static void main(String[] args) {
            FuzzyQueryTest ft = new FuzzyQueryTest();
            List<Users> users = ft.fuzzyQuery("%d%");
            for(Users user1:users){
              System.out.println(user1.getUserid()+""+user1.getUsername()+" "+user1.getUserage());
           }
       }
    }

### 动态条件查询 ###

![7df8b5a3e5e141c386b49fdcbe9c94f9.png][]

### 动态条件查询实现 ###

/**
    * 动态条件查询测试类
    */
    public class DynamicConditionQueryTest {
        /**
         * 动态条件查询Users
         */
        public List<Users> queryUsers(Users users){
            List<Users> list= new ArrayList<>();
            Connection conn =null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            try{
                //获取数据库连接
                conn = JdbcUtils.getConnection();
                //拼接查询SQL语句
                String sql = this.generateSql(users);
                System.out.println(sql);
                //创建PreparedStatement对象
                ps = conn.prepareStatement(sql);
                //执行sql语句
                rs = ps.executeQuery();
                while(rs.next()){
                    Users user = new Users();
                  user.setUserid(rs.getInt("userid"));
                  user.setUsername(rs.getString("username"));
                  user.setUserage(rs.getInt("userage"));
                    list.add(user);
               }
           }catch(Exception e){
                e.printStackTrace();
           }finally{
              JdbcUtils.closeResource(rs,ps,conn);
           }
            return list;
       }
      /**
         * 生成动态条件查询sql
         */
        private String generateSql(Users users){
            StringBuffer sb = new StringBuffer("select * from users where 1=1");
            if(users.getUserid() > 0){
                sb.append(" and userid = ").append(users.getUserid());
           }
            if(users.getUsername() !=null &&users.getUsername().length() > 0){
                sb.append(" and username = '").append(users.getUsername()).append("'");
           }
            if(users.getUserage() > 0){
                sb.append(" and userage = ").append(users.getUserage());
           }
            return sb.toString();
       }
        public static void main(String[] args) {
            DynamicConditionQueryTest dt = new DynamicConditionQueryTest();
            Users users = new Users();
            users.setUsername("Oldlu");
            users.setUserage(20);
            List<Users> list = dt.queryUsers(users);
            for(Users user1:list){
              System.out.println(user1.getUserid()+""+user1.getUsername()+" "+user1.getUserage());
           }
       }
    }

# 分页查询 #

![d95d347ac1fe4c17a0023f71d695b70d.png][]

## 分页查询简介 ##

当一个操作数据库进行查询的语句返回的结果集内容如果过多，那 么内存极有可能溢出，所以在查询中含有大数据的情况下分页是必 须的。

## 分页查询分类： ##

### 物理分页： ###

> 在数据库执行查询时（实现分页查询），查询需要的数据—依赖数据库的SQL语句
> 
> 在SQL查询时，从数据库只检索分页需要的数据
> 
> 通常不同的数据库有着不同的物理分页语句
> 
> MySql物理分页采用limit关键字

### 逻辑分页： ###

在sql查询时，先从数据库检索出所有数据的结果集，在程序内，通过逻辑语句获得分页需要的数 据

### 如何在MySql中实现物理分页查询 ###

> 使用limit方式。

**limit的使用**

select * from tableName limit m,n

其中m与n为数字。n代表需要获取多少行的数据项，而m代表从哪 开始(以0为起始)。

例如我们想从users表中先获取前两条数据SQL为：

select * from users limit 0,2;

那么如果要继续看下两条的数据则为：

select * from users limit 2,2;

以此类推 分页公式：(当前页-1)\*每页大小

## 创建Page模型 ##

![68d9251d5dd440f5bfe4ada140fcb13c.png][]

### Page ###

/**
    * 分页查询实体类
    */
    public class Page<T> {
        //当前页
        private int currentPage;
        //每页显示的条数
        private int pageSize;
        //总条数
        private int totalCount;
        //总页数
        private int totalPage;
        //结果集
        private List<T> result;
        public int getCurrentPage() {
            return currentPage;
       }
        
       public void setCurrentPage(int currentPage) {
            this.currentPage = currentPage;
       }
        
       public int getPageSize() {
            return pageSize;
       }
        
       public void setPageSize(int pageSize) {
            this.pageSize = pageSize;
       }
        
       public int getTotalCount() {
            return totalCount;
       }
        
       public void setTotalCount(int totalCount) {
            this.totalCount = totalCount;
       }
        
       public int getTotalPage() {
            return totalPage;
       }
      
       public void setTotalPage(int totalPage){
            this.totalPage = totalPage;
       }
        
       public List<T> getResult() {
            return result;
       }
        
       public void setResult(List<T> result) {
            this.result = result;
       }
    }

## 实现分页查询 ##

### 分页实现 ###

/**
    * 分页查询测试类
    */
    public class PageTest {
        /**
         * 分页查询Users
         */
        public Page<Users> selectPage(Page page)
         {
            Connection conn =null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            List<Users> list = new ArrayList<>();
            try{
                //获取连接对象
                conn = JdbcUtils.getConnection();
                //创建PrepareStatement对象
                ps = conn.prepareStatement("select * from users limit ?,?");
                //绑定m参数 m的值 = (当前页-1)*每页显示的条数
                ps.setInt(1, (page.getCurrentPage()-1)*page.getPageSize());
                //绑定n参数 n的值为每页显示的条数
                ps.setInt(2,page.getPageSize());
                //执行查询
                rs = ps.executeQuery();
                //处理结果集
                while(rs.next()){
                    //完成ORM映射
                    Users  users = new Users();
                  users.setUserid(rs.getInt("userid"));
                  users.setUsername(rs.getString("username"));
                  users.setUserage(rs.getInt("userage"));
                    list.add(users);
               }
                //讲结果集存放到Page对象中。
                page.setResult(list);
                //查询总条数
                ps =conn.prepareStatement("select count(*) from users");
                //执行查询
                rs = ps.executeQuery();
                while(rs.next()){
                    //总条数
                  int count =  rs.getInt(1);
                   //保存总条数
                    page.setTotalCount(count);
                    //换算总页数 = 总条数 / 每页显示的条数 向上取整
                   int totalPage = (int)Math.ceil(1.0*count/page.getPageSize());
                   //保存总页数
                  page.setTotalPage(totalPage);
               }
           }catch(Exception e){
                e.printStackTrace();
           }finally{
              JdbcUtils.closeResource(rs,ps,conn);
           }
            return page;
       }
     public static void main(String[] args) {
            PageTest pt = new PageTest();
            Page page = new Page();
            page.setCurrentPage(2);
            page.setPageSize(2);
            Page page1 = pt.selectPage(page);
            System.out.println("总条数："+page1.getTotalCount());
            System.out.println("总页数："+page1.getTotalPage());
            System.out.println("当前页："+page1.getCurrentPage());
            System.out.println("每页显示的条数："+page1.getPageSize());
            List<Users> list =page1.getResult();
            for(Users user:list){
              System.out.println(user.getUserid()+ " "+user.getUsername()+" "+user.getUserage());
           }
       }
    }

# 数据库连接池 #

![7d7564ba042d435581bd993b93195327.png][]

## 数据库连接池简介 ##

### 什么是数据库连接池 ###

数据库连接池（Connection pooling）是程序启动时建立足够的数 据库连接，并将这些连接组成一个连接池，由程序动态地对池中的 连接进行申请，使用，释放。 它允许应用程序重复使用一个现有的数据库连接，而不是再重新建 立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为 没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提 高对数据库操作的性能。

### 不使用数据库连接池存在的问题 ###

> 1、普通的JDBC数据库连接使用 DriverManager 来获取，每次向数 据库建立连接的时候都要将 Connection加载到内存中，再验证 用户名和密码，所以整个过程比较耗时。
> 
> 2、需要数据库连接的时候，就向数据库要求一个，执行完成后再断 开连接。这样的方式将会消耗大量的资源和时间。数据库的连接 资源并没有得到很好的重复利用。若同时有几百人甚至几千人在 线，频繁的进行数据库连接操作将占用很多的系统资源，严重的甚至会造成服务器的崩溃。
> 
> 3、对于每一次数据库连接，使用完后都得断开。否则，如果程序出 现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将 导致重启数据库。

### JDBC数据库连接池的必要性 ###

> **数据库连接池的基本思想**：为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连 接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。
> 
> **数据库连接池**负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连 接，而不是重新建立一个。
> 
> **数据库连接池在初始化时**将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由 最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么 多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序 向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。

![07a2bd55c3164e72b375b2fa11e9a9ac.png][]

## 数据库连接池的优点 ##

> 1、**资源重用**：由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系 统消耗的基础上，另一方面也增加了系统运行环境的平稳性。
> 
> 2、**更快的系统反应速度**：数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池 中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接避免了 数据库连接初始化和释放过程的时间开销，从而减少了系统的响应时间。
> 
> 3、**新的资源分配手段**：对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置 实现某一应用最大可用数据库连接数的限制避免某一应用独占所有的数据库资源。
> 
> 4、**统一的连接管理**：避免数据库连接泄露在较为完善的数据库连接池实现中，可根据预先的占用超时 设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露。

## 常用的数据库连接池 ##

> **c3p0**：是一个开源组织提供的数据库连接池，速度相对较慢，稳定性还可以。
> 
> **DBCP**：是Apache提供的数据库连接池。速度相对c3p0较快，但自身存在bug。
> 
> **Druid**：是阿里提供的数据库连接池，据说是集DBCP、c3p0优点于一身的数据库连接池，目前经 常使用。

## Druid连接池 ##

![0d27956b9ec94b5bbcbee93f46e0d015.png][]

### Druid简介 ###

Druid是阿里提供的数据库连接池，它结合了C3P0、DBCP等DB池 的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的 执行情况。

### Druid使用步骤 ###

> 1 导入druid-1.2.8.jar包到lib目录下，并引入到项目中
> 
> 2 在src下创建一个druid.properties类型的文件，并写入
> 
> 3 加载配置文件
> 
> 4 获取连接池对象
> 
> 5 通过连接池对象获取连接

url=jdbc:mysql://localhost:3306/itbz
    driverClassName=com.mysql.jdbc.Driver
    username=root
    password=。。。。
    initialSize=10
    maxActive=20

**druid配置信息：**

![bd00789b65b54c0881aeb594d4982f94.png][]

### 通过数据库连接池获取连接 ###

/**
    * Druid连接池测试类
    */
    public class DruidTest {
        public static void main(String[] args) throws Exception {
            //获取读取druid配置的字节输入流
            InputStream is = DruidTest.class.getClassLoader().getResourceAsStream("druid.properties");
            //创建Properties对象
            Properties pos = new Properties();
            //加载配置文件
            pos.load(is);
            //获取连接池对象
            DataSource ds = DruidDataSourceFactory.createDataSource(pos);
            //获取连接
            Connection connection = ds.getConnection();
            System.out.println(connection);
       }
    }

**封装工具类**

/**
    * 基于Druid连接池获取数据库连接工具类
    */
    public class JdbcDruidUtil {
         //数据库连接池对象
         private static DataSource dataSource;
         static{
             try {
                 //获取读取配置文件的字节输入流对象
                 InputStream is = JdbcDruidUtil.class.getClassLoader().getResourceAsStream("druid.properties");
                 //创建Properties对象
                 Properties pop = new Properties();
                 //加载配置文件
                 pop.load(is);
                 //创建连接池对象
                 dataSource = DruidDataSourceFactory.createDataSource(pop);
             }catch(Exception e){
                 e.printStackTrace();
             }
         }
        //获取数据库连接对象
        public static Connection getConnection()
         {
            Connection connection = null;
            try {
                connection = dataSource.getConnection();
           } catch (SQLException throwables) {
                throwables.printStackTrace();
           }
            return connection;
       }
        //关闭连接对象
        public static void closeConnection(Connection connection){
            try {
                  connection.close();
           } catch (SQLException throwables) {
                throwables.printStackTrace();
           }
       }
        //提交事务
        public static void commit(Connection connection){
            try {
                connection.commit();
           } catch (SQLException throwables) {
                throwables.printStackTrace();
           }
       }
        //事务回滚
        public static void rollback(Connection connection){
            try {
                connection.rollback();
           } catch (SQLException throwables) {
                throwables.printStackTrace();
           }
       }
        //关闭Statement对象
        public static void closeStatement(Statement statement){
            try {
                statement.close();
           } catch (SQLException throwables) {
                throwables.printStackTrace();
           }
       }
     //关闭ResultSet
        public static void closeResultSet(ResultSet resultSet) {
            try {
                resultSet.close();
           } catch (SQLException throwables) {
                throwables.printStackTrace();
           }
       }
        //DML操作时关闭资源
        public static void closeResource(Statement statement,Connection connection){
            //先关闭Statement对象
            closeStatement(statement);
            //在关闭Connection对象
            closeConnection(connection);
       }
        //查询时关闭资源
        public static void closeResource(ResultSet resultSet,Statement statement,Connection connection){
            //先关闭ResultSet
            closeResultSet(resultSet);
            //在闭Statement对象
            closeStatement(statement);
            //最后关闭Connection对象
            closeConnection(connection);
       }
    }

### 通过druid重构JDBCUtils ###

> 1 创建JDBCUtilsDruid类
> 
> 2 使用静态块初始化连接池

public class JDBCUtilsDruid {
        private static DataSource ds = null;
        static{
            try {
                InputStream is = JDBCUtilsDruid.class.getClassLoader().getResourceAsStream("druid.properties");
                Properties properties = new Properties();
                pros.load(is);
                ds = DruidDataSourceFactory.createDataSource(properties);
           } catch (Exception e) {
                e.printStackTrace();
           }
       }

> 3 获取数据库连接方法

public static Connection getConnection() throws Exception {
            Connection conn = null;
            conn = ds.getConnection();
            return conn;
    }

> 4 释放数据库连接方法

public static void close(Connection conn,Statement statement) throws Exception
       {
          try {
               if (statement!=null) {
                     statement.close();
                   }
               } catch (SQLException e) {
                    e.printStackTrace();
               }finally {
                if (conn!=null) {
                  try {
                      conn.close();
                      } catch (SQLException e) {
                         e.printStackTrace();
                   }
               }
           }

# 应用程序分层 #

![1c70f5a86ac140efb9a669c1f4bbc1cc.png][]

## 应用程序分层简介 ##

> 应用程序分层是指通过创建不同的包来实现项目的分层，将项目中 的代码根据功能做具体划分，并存放在不同的包下。

## 三层结构 ##

> 三层结构就是将整个业务应用划分为：表述层、业务逻辑层 、数据访问层。区分层次的目的即为了“高内 聚低耦合”的思想。在软件体 系架构设计中，分层式结构是最常见，也是最重要的一种结构。

![6787f1887f8d4ba0933e0bc3e330f603.png][]

**分层优点**

> 1 分层结构将应用系统划分为若干层，每一层只解决问题的一部 分，通过各层的协作提供整体解决方案。大的问题被分解为一系 列相对独立的子问题，局部化在每一层中，这样就有效的降低了 单个问题的规模和复杂度，实现了复杂系统的第一步也是最为关 键的一步分解。
> 
> 2 分层结构具有良好的可扩展性，为应用系统的演化增长提供了一 个灵活的支持，具有良好的可扩展性。增加新的功能时，无须对 现有的代码做修改，业务逻辑可以得到最大限度的重用。
> 
> 3 分层结构易于维护。在对系统进行分解后，不同的功能被封装在 不同的层中，层与层之间的耦合显著降低。因此在修改某个层的 代码时，只要不涉及层与层之间的接口，就不会对其他层造成严 重影响。

**分层命名**

> **表述层**：web或controller
> 
> **业务层**：service
> 
> **数据访问层**：dao (Data Access Object)

## 应用程序分层实现 ##

![5e180041968a46efa70e164943750b31.png][]

### 在分层项目中实现查询业务 ###

**UserDao接口**

public interface UsersDao {
        /**
         * 根据用户ID查询用户
         *
         */
        Users selectUsersById(int userid);
    }

**UserDaoImpl接口实现类**

public class UsersDaoImpl implements UsersDao {
        /**
         * 根据用户ID查询用户
         * @param userid
         * @return
         */
        @Override
        public Users selectUsersById(int userid)
          {
            Connection conn =null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            Users users = null;
            try{
                conn = JdbcDruidUtil.getConnection();
                ps = conn.prepareStatement("select * from users where userid = ?");
                ps.setInt(1,userid); 
                rs = ps.executeQuery();
                while(rs.next()){
                    //手动orm映射
                    users = new Users();
                  users.setUserid(rs.getInt("userid"));
                  users.setUsername(rs.getString("username"));
                  users.setUserage(rs.getInt("userage"));
               }
           }catch(Exception e){
                e.printStackTrace();
                //通过自定义异常解决异常耦合问题
                throw new ApplicationException(e.getMessage());
           }finally{
              JdbcDruidUtil.closeResource(rs,ps,conn);
           }
            return users;
       }
    }

**UserService接口**

public interface UsersService {
        Users findUsersById(int userid);
    }

**UserServiceImpl接口实现类**

public class UsersServiceImpl implements UsersService {
        /**
         * 根据用户ID查询用户业务
         * @param userid
         * @return
         */
        @Override
        public Users findUsersById(int userid) {
            UsersDao ud = new UsersDaoImpl();
            return ud.selectUsersById(userid);
       }
    }

**web**

public class Test {
        public static void main(String[] args) {
            UsersService us = new UsersServiceImpl();
            Users u = us.findUsersById(1);
            System.out.println(u);
       }
    }

# 封装通用的BaseDao #

## 封装通用的DML操作 ##

**BaseDao接口**

/**
    * 通用接口
    */
    public interface BaseDao {
        /**
         * 通用的DML操作方法
         */
        int executeUpdate(String sql,Object[] param);
    }

**BaseDaoImpl接口实现类**

**UsersDao接口**

public interface UsersDao extends BaseDao {
        /**
         * 根据用户ID查询用户
         *
         */
        Users selectUsersById(int userid);
        /**
         * 修改用户信息
         */
        int updateUsersById(Users users);
    }

**UsersDaoImpl接口实现类**

public class UsersDaoImpl extends BaseDaoImpl implements UsersDao {
        /**
         * 根据用户ID查询用户
         * @param userid
         * @return
         */
        @Override
        public Users selectUsersById(int userid)
         {
            Connection conn =null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            Users users = null;
            try{
             conn = JdbcDruidUtil.getConnection();
                ps = conn.prepareStatement("select * from users where userid = ?");
                ps.setInt(1,userid);
                rs = ps.executeQuery();
                while(rs.next()){
                    //手动orm映射
                    users = new Users();
                  users.setUserid(rs.getInt("userid"));
                  users.setUsername(rs.getString("username"));
                  users.setUserage(rs.getInt("userage"));
               }
           }catch(Exception e){
                e.printStackTrace();
                //通过自定义异常解决异常耦合问题
                throw new ApplicationException(e.getMessage());
           }finally{
              JdbcDruidUtil.closeResource(rs,ps,conn);
           }
            return users;
       }
        /**
         * 修改用户信息
         */
     @Override
        public int updateUsersById(Users users)
         {
            String sql = "update users set userage = ? where userid = ? ";
            Object[] param = new Object[] {users.getUserage(),users.getUserid()};
            return this.executeUpdate(sql,param);
       }
    }

## 封装通用的查询操作 ##

**BaseDao接口**

/**
    * 通用接口
    */
    public interface BaseDao {
        /**
         * 通用的DML操作方法
         */
        int executeUpdate(String sql,Object[] param);
        /**
         * 通用查询方法
         * 要求：实体类的属性名必须要与表的列名相同。
         */
        <T> List<T> select(String sql,Object[] param,Class<T> clazz);
    }

**BaseDaoImpl接口实现类**

/**
    * 通用接口实现类
    */
    public class BaseDaoImpl implements BaseDao
    {
        /**
         * 通用的DML操作方法
         */
        @Override
        public int executeUpdate(String sql, Object[] param) {
            Connection conn = null;
            PreparedStatement ps = null;
            int row;
            try{
                conn = JdbcDruidUtil.getConnection();
                ps = conn.prepareStatement(sql);
                //得到参数的个数
                ParameterMetaData pd = ps.getParameterMetaData();
                for(int i =0;i<pd.getParameterCount();i++){
                    ps.setObject(i+1,param[i]);
               }
                   row = ps.executeUpdate();
           }catch (Exception e){
                e.printStackTrace();
                //通过自定义异常解决异常耦合问题
                throw new ApplicationException(e.getMessage());
           }finally{
              JdbcDruidUtil.closeResource(ps,conn);
           }
            return row;
       }
        /**
         * 通用查询方法
         */
        @Override
        public <T> List<T> select(String sql, Object[] param, Class<T> clazz) {
            Connection conn = null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            List<T> list = new ArrayList<>();
            try{
                conn = JdbcDruidUtil.getConnection();
                ps = conn.prepareStatement(sql);
                //得到参数的个数
                ParameterMetaData pd = ps.getParameterMetaData();
                for(int i =0;i<pd.getParameterCount();i++){
                     ps.setObject(i+1,param[i]);
               }
                rs = ps.executeQuery();
                //获取结果集信息
                ResultSetMetaData rm = rs.getMetaData();
                while(rs.next()){
                    //OMR映射
                    //通过反射实例化实体类对象
                  T bean = clazz.newInstance();
                  //实体类的属性名必须要和表的列名相同。
                    for(int i=0;i<rm.getColumnCount();i++){
                        //得到列名
                        String columnName = rm.getColumnName(i+1);
                        //获取列的值
                        Object value = rs.getObject(columnName);
                        //通过BeanUtil工具类讲值映射到对象中
                      BeanUtils.setProperty(bean,columnName,value);
                   }
                    list.add(bean);
               }
           }catch (Exception e){
                e.printStackTrace();
                //通过自定义异常解决异常耦合问题 
                throw new ApplicationException(e.getMessage());
           }finally{
              JdbcDruidUtil.closeResource(rs,ps,conn);
           }
            return list;
       }
    }

**UsersDao接口**

public interface UsersDao extends BaseDao {
        /**
         * 根据用户ID查询用户
         *
         */
        Users selectUsersById(int userid);
        /**
         * 修改用户信息
         */
        int updateUsersById(Users users);
        /**
         * 根据用户姓名模糊查询
         */
        List<Users> selectUsersByLikeName(String username);
    }

**UsersDaoImpl接口实现类**

public class UsersDaoImpl extends
    BaseDaoImpl implements UsersDao {
        /**
         * 根据用户ID查询用户
         * @param userid
         * @return
         */
        @Override
        public Users selectUsersById(int userid){
            Connection conn =null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            Users users = null;
            try{
                conn = JdbcDruidUtil.getConnection();
                ps = conn.prepareStatement("select * from users where userid = ?");
                ps.setInt(1,userid);
                rs = ps.executeQuery();
                while(rs.next()){
                    //手动orm映射
                    users = new Users();
                  users.setUserid(rs.getInt("userid"));
                  users.setUsername(rs.getString("username"));
                  users.setUserage(rs.getInt("userage"));
               }
           }catch(Exception e){
                e.printStackTrace();
                //通过自定义异常解决异常耦合问题
                throw new ApplicationException(e.getMessage());
           }finally{
              JdbcDruidUtil.closeResource(rs,ps,conn);
           }
            return users;
       }
        /**
         * 修改用户信息
         */
        @Override
        public int updateUsersById(Users users){
            String sql = "update users set userage = ? where userid = ? ";
            Object[] param = new Object[] {users.getUserage(),users.getUserid()};
            return this.executeUpdate(sql,param);
       }
        @Override
        public List<Users> selectUsersByLikeName(String username) {
            String sql = "select * from users where username like ?";
            Object[] param = new Object[] {"%"+username+"%"};
            return this.select(sql,param,Users.class);
       }
    }

# 对象的关联关系 #

## 关联关系简介 ##

> 关联关系(Association)，是一种拥有的关系，它使一个对象知道另 一个对象的属性和方法。关联可以是双向的，也可以是单向的。在 Java语言中，关联关系一般使用成员变量来实现。

![bce32703730e46178bf8905b39693d89.png][]

**对象的关联关系解决了什么问题**

在多表查询时，使用对象关联关系能够更合理的存放查询到的结果集数据。

**关联关系的方向性**

> **单向** 只在一侧关联了对方。
> 
> **双向** 两侧相互关联了对方。

## 创建对象的关联关系 ##

### 创建表 ###

**orders表**

CREATE TABLE `orders` (
      `orderid` int(11) NOT NULL AUTO_INCREMENT,
      `orderprice` float(11,2) DEFAULT NULL,
      `user_id` int(11) DEFAULT NULL,
      PRIMARY KEY (`orderid`),
      KEY `orders_fk` (`user_id`),
      CONSTRAINT `orders_fk` FOREIGN KEY
    (`user_id`) REFERENCES `users` (`userid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

**items表**

CREATE TABLE `items` (
      `itemid` int(11) NOT NULL,
      `itemname` varchar(30) DEFAULT NULL,
      `itemprice` float(11,2) DEFAULT NULL,
      `itemnum` int(11) DEFAULT NULL,
      PRIMARY KEY (`itemid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

**orders\_itmes表**

CREATE TABLE `orders_items` (
      `order_id` int(11) NOT NULL,
      `item_id` int(11) NOT NULL,
      PRIMARY KEY (`order_id`,`item_id`),
      KEY `orders_items_fk2` (`item_id`),
      CONSTRAINT `orders_items_fk` FOREIGN KEY
    (`order_id`) REFERENCES `orders` (`orderid`),
      CONSTRAINT `orders_items_fk2` FOREIGN KEY
    (`item_id`) REFERENCES `items` (`itemid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

## 对象的关联关系 ##

### Users对象 ###

public class Users {
        private int userid;
        private String username;
        private int userage;
        //创建与Orders的关联关系
        private List<Orders> orders = new ArrayList<>();
        public List<Orders> getOrders() {
            return orders;
       }
        public void setOrders(List<Orders> orders) {
            this.orders = orders;
       }
      @Override
        public String toString() {
            return "Users{" +
                    "userid=" + userid +
                    ", username='" + username +'\'' +
                    ", userage=" + userage +
                    '}';
       }
        public int getUserid() {
            return userid;
       }
        public void setUserid(int userid) {
            this.userid = userid;
       }
        public String getUsername() {
            return username;
       }
        public void setUsername(String username)
       {
            this.username = username;
       }
        public int getUserage() {
            return userage;
       }
       public void setUserage(int userage) {
            this.userage = userage;
       }
    }

### Orders对象 ###

public class Orders {
        private int orderid;
        private double orderprice;
        //关联Users
        private Users users;
        //关联Items
        private List<Items> items =new ArrayList<>();
        public int getOrderid() {
            return orderid;
       }
        public void setOrderid(int orderid) {
            this.orderid = orderid;
       }
        public double getOrderprice() {
            return orderprice;
       }
        public void setOrderprice(double orderprice) {
            this.orderprice = orderprice;
     }
        public Users getUsers() {
            return users;
       }
        public void setUsers(Users users) {
            this.users = users;
       }
        public List<Items> getItems() {
            return items;
       }
        public void setItems(List<Items> items)
       {
            this.items = items;
       }
    }

### Items对象 ###

public class Items {
        private int itemid;
        private String itemname;
        private double itemprice;
        private int itemnum;
        //关联Orders
        private List<Orders> orders = new ArrayList<>();
        public int getItemid() {
            return itemid;
       }
        public void setItemid(int itemid) {
            this.itemid = itemid;
       }
        public String getItemname() {
            return itemname;
       }
        public void setItemname(String itemname)
       {
            this.itemname = itemname;
       }
        public double getItemprice() {
            return itemprice;
       }
        public void setItemprice(double itemprice) {
            this.itemprice = itemprice;
       }
        public int getItemnum() {
            return itemnum;
       }
        public void setItemnum(int itemnum) {
            this.itemnum = itemnum;
       }
        public List<Orders> getOrders() {
            return orders;
       }
        public void setOrders(List<Orders> orders) {
            this.orders = orders;
       }
    }

**使用对象关联关系存放查询数据**

需求：查询用户ID为1的用户信息他的订单信息，以及订单中所包含 的商品信息。

**SQL语句**

select * from users u,orders o, orders_items oi, items i WHERE u.userid = o.user_id and o.orderid = oi.order_id and oi.item_id = i.itemid and u.userid =1

**UserDao接口**

/**
         * 查询用户ID为1的用户信息他的订单信息，
         * 以及订单中所包含的商品信息。
         */
        Users selectUsers(int userid);

**UsersDaoImpl接口实现类**

/**
         * 查询用户ID为1的用户信息他的订单信息，
         * 以及订单中所包含的商品信息。
         */
        @Override
        public Users selectUsers(int userid) {
            Connection conn = null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            Users users =new Users();
            try{
                conn = JdbcDruidUtil.getConnection();
                ps = conn.prepareStatement("select * from users u,orders o, orders_items oi, items i WHERE\n" + "u.userid = o.user_id and o.orderid = oi.order_id and oi.item_id = i.itemid \n" + "and u.userid =?");
                ps.setInt(1,userid);
                rs = ps.executeQuery();
            while(rs.next()){
                    //Users对象的ORM映射
                  users.setUserid(rs.getInt("userid"));
                  users.setUsername(rs.getString("username"));
                  users.setUserage(rs.getInt("userage"));
                    //Orders对象的ORM映射
                    Orders orders = new Orders();
                    orders.setOrderid(rs.getInt("orderid"));
                    orders.setOrderprice(rs.getDouble("orderprice"));
                    users.getOrders().add(orders);
                    //Items对象的ORM映射
                    Items items = new Items();
                    items.setItemid(rs.getInt("itemid"));
                    items.setItemname(rs.getString("itemname"));
                    items.setItemprice(rs.getDouble("itemprice"));
                    items.setItemnum(rs.getInt("itemnum"));
                    orders.getItems().add(items);
               }
           }catch (Exception e){
                e.printStackTrace();
                //通过自定义异常解决异常耦合问题
                throw new ApplicationException(e.getMessage());
           }finally{
               JdbcDruidUtil.closeResource(rs,ps,conn);
           }
            return users;
       }

**UsersService接口**

Users findUsers(int userid);

**UsersService接口实现类**

@Override
        public Users findUsers(int userid) {
            UsersDao ud = new UsersDaoImpl();
            return ud.selectUsers(userid);
       }

[5aa131932ce14062b74c3a4178d090d6.png]: https://img-blog.csdnimg.cn/5aa131932ce14062b74c3a4178d090d6.png
[c9eec2bed559449a8928772038591e2a.png]: https://img-blog.csdnimg.cn/c9eec2bed559449a8928772038591e2a.png
[655cb0361d5e4f0090179f6e55351939.png]: https://img-blog.csdnimg.cn/655cb0361d5e4f0090179f6e55351939.png
[ad70bc4540a54453ae0cd39f07d8da76.png]: https://img-blog.csdnimg.cn/ad70bc4540a54453ae0cd39f07d8da76.png
[8a291d3d91264756b0ee435ed0c5e2d3.png]: https://img-blog.csdnimg.cn/8a291d3d91264756b0ee435ed0c5e2d3.png
[MySQL _ Download MySQL Connector_J _Archived Versions]: https://downloads.mysql.com/archives/c-j/
[00b117b3852243f4951d977e315b4ed4.png]: https://img-blog.csdnimg.cn/00b117b3852243f4951d977e315b4ed4.png
[fb627e643b7748139aa3d9da5f274c29.png]: https://img-blog.csdnimg.cn/fb627e643b7748139aa3d9da5f274c29.png
[e6ad2d11cdba4a758806aa0d84a32907.png]: https://img-blog.csdnimg.cn/e6ad2d11cdba4a758806aa0d84a32907.png
[ccdc3dd0955148bc8f78bcab829758c4.png]: https://img-blog.csdnimg.cn/ccdc3dd0955148bc8f78bcab829758c4.png
[12f26f6e2a444418ba92c32197a86553.png]: https://img-blog.csdnimg.cn/12f26f6e2a444418ba92c32197a86553.png
[840c3184319149ea881abf91230a346d.png]: https://img-blog.csdnimg.cn/840c3184319149ea881abf91230a346d.png
[240e6700286e4ad6b995787872624a44.png]: https://img-blog.csdnimg.cn/240e6700286e4ad6b995787872624a44.png
[acf8cd0d2e6e4f46809f8e974b0537c6.png]: https://img-blog.csdnimg.cn/acf8cd0d2e6e4f46809f8e974b0537c6.png
[6cff0007cb93418b92cc37dc14d9c97d.png]: https://img-blog.csdnimg.cn/6cff0007cb93418b92cc37dc14d9c97d.png
[e1cbde5442404fe2b1b29829a1d2ea3f.png]: https://img-blog.csdnimg.cn/e1cbde5442404fe2b1b29829a1d2ea3f.png
[ac88ea7fc2004cf3afed043152222e44.png]: https://img-blog.csdnimg.cn/ac88ea7fc2004cf3afed043152222e44.png
[fb54d5345729457eb422b82b849d156e.png]: https://img-blog.csdnimg.cn/fb54d5345729457eb422b82b849d156e.png
[1daaa63363d746f1abadcbf655e4a70c.png]: https://img-blog.csdnimg.cn/1daaa63363d746f1abadcbf655e4a70c.png
[6b56d0eb56f047f3bd9170735f31f026.png]: https://img-blog.csdnimg.cn/6b56d0eb56f047f3bd9170735f31f026.png
[99bbada732b247489033738407a78844.png]: https://img-blog.csdnimg.cn/99bbada732b247489033738407a78844.png
[013cd3f07e2a440e8a7fecb3a19d90c3.png]: https://img-blog.csdnimg.cn/013cd3f07e2a440e8a7fecb3a19d90c3.png
[13cfcd06f061415e8f8735099cc8cfe4.png]: https://img-blog.csdnimg.cn/13cfcd06f061415e8f8735099cc8cfe4.png
[dae0d54c29b249e78685cc78bec19b93.png]: https://img-blog.csdnimg.cn/dae0d54c29b249e78685cc78bec19b93.png
[44c5febf9ebc4917b3475219725266fa.png]: https://img-blog.csdnimg.cn/44c5febf9ebc4917b3475219725266fa.png
[7df8b5a3e5e141c386b49fdcbe9c94f9.png]: https://img-blog.csdnimg.cn/7df8b5a3e5e141c386b49fdcbe9c94f9.png
[d95d347ac1fe4c17a0023f71d695b70d.png]: https://img-blog.csdnimg.cn/d95d347ac1fe4c17a0023f71d695b70d.png
[68d9251d5dd440f5bfe4ada140fcb13c.png]: https://img-blog.csdnimg.cn/68d9251d5dd440f5bfe4ada140fcb13c.png
[7d7564ba042d435581bd993b93195327.png]: https://img-blog.csdnimg.cn/7d7564ba042d435581bd993b93195327.png
[07a2bd55c3164e72b375b2fa11e9a9ac.png]: https://img-blog.csdnimg.cn/07a2bd55c3164e72b375b2fa11e9a9ac.png
[0d27956b9ec94b5bbcbee93f46e0d015.png]: https://img-blog.csdnimg.cn/0d27956b9ec94b5bbcbee93f46e0d015.png
[bd00789b65b54c0881aeb594d4982f94.png]: https://img-blog.csdnimg.cn/bd00789b65b54c0881aeb594d4982f94.png
[1c70f5a86ac140efb9a669c1f4bbc1cc.png]: https://img-blog.csdnimg.cn/1c70f5a86ac140efb9a669c1f4bbc1cc.png
[6787f1887f8d4ba0933e0bc3e330f603.png]: https://img-blog.csdnimg.cn/6787f1887f8d4ba0933e0bc3e330f603.png
[5e180041968a46efa70e164943750b31.png]: https://img-blog.csdnimg.cn/5e180041968a46efa70e164943750b31.png
[bce32703730e46178bf8905b39693d89.png]: https://img-blog.csdnimg.cn/bce32703730e46178bf8905b39693d89.png