第一章 框架概述

软件开发常用结构

三层架构

界面层（User Interface layer）、业务逻辑层（Business Logic Layer）、数据访问层（Data access layer）

• 三层的职责:

1. 界面层（表示层，视图层）：主要功能是接受用户的数据，显示请求的处理结果。使用 web 页面和 用户交互，手机 app 也就是表示层的，用户在 app 中操作，业务逻辑在服务器端处理。
2. 业务逻辑层：接收表示传递过来的数据，检查数据，计算业务逻辑，调用数据访问层获取数据。
3. 数据访问层：与数据库打交道。主要实现对数据的增、删、改、查。将存储在数据库中的数据提交

给业务层，同时将业务层处理的数据保存到数据库

• 三层的处理请求的交互：

用户---> 界面层--->业务逻辑层--->数据访问层--->DB 数据库

• 为什么要使用三层？

  1. 结构清晰、耦合度低, 各层分工明确
  2. 可维护性高，可扩展性高
  3. 有利于标准化
  4. 开发人员可以只关注整个结构中的其中某一层的功能实现
  5. 有利于各层逻辑的复用

常用框架

• 常见的 J2EE 中开发框架：

  MyBatis 框架： MyBatis 是一个优秀的基于 java 的持久层框架，内部封装了 jdbc，开发者只需要关注 sql 语句 本身，而不需要处理加载驱动、创建连接、创建 statement、关闭连接，资源等繁杂的过程。 MyBatis 通过 xml 或注解两种方式将要执行的各种 sql 语句配置起来，并通过 java 对象和 sql 的 动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并返回。

  Spring 框架： Spring 框架为了解决软件开发的复杂性而创建的。Spring 使用的是基本的 JavaBean 来完成以前 非常复杂的企业级开发。Spring 解决了业务对象，功能模块之间的耦合，不仅在 javase,web 中使用， 大部分 Java 应用都可以从 Spring 中受益。 Spring 是一个轻量级控制反转(IoC)和面向切面(AOP)的容器。

  SpringMVC 框架 Spring MVC 属于 SpringFrameWork 3.0 版本加入的一个模块，为 Spring 框架提供了构建 Web 应用程序的能力。现在可以 Spring 框架提供的 SpringMVC 模块实现 web 应用开发，在 web 项目中 可以无缝使用 Spring 和 Spring MVC 框架。

框架是什么

• 框架定义

  框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方 法;另一种认为，框架是可被应用开发者定制的应用骨架、模板。 简单的说，框架其实是半成品软件，就是一组组件，供你使用完成你自己的系统。从另一个角度来 说框架一个舞台，你在舞台上做表演。在框架基础上加入你要完成的功能。 框架安全的，可复用的，不断升级的软件。

• 框架解决的问题

  框架要解决的最重要的一个问题是技术整合，在 J2EE 的 框架中，有着各种各样的技术，不同的应 用，系统使用不同的技术解决问题。需要从 J2EE 中选择不同的技术，而技术自身的复杂性，有导致更 大的风险。企业在开发软件项目时，主要目的是解决业务问题。 即要求企业负责技术本身，又要求解 决业务问题。这是大多数企业不能完成的。框架把相关的技术融合在一起，企业开发可以集中在业务领 域方面。 另一个方面可以提供开发的效率。

JDBC 编程

• 使用 JDBC 编程的回顾

点击查看

public void findStudent() {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
		
        try {
			//注册 mysql 驱动 MySQL8.0 连接(com.mysql.cj.jdbc.Driver)
			Class.forName("com.mysql.jdbc.Driver");
			
			//连接数据的基本信息 url ，username，password
			String url = "jdbc:mysql://localhost:3306/springdb";//MySQL8.0 需要加上  ?useSSL=false&serverTimezone=UTC
			String username = "root";
			String password = "123456";
			
			//创建连接对象
			conn = DriverManager.getConnection(url, username, password);
			
			//保存查询结果
			List<Student> stuList = new ArrayList<>();
			
			//创建 Statement, 用来执行 sql 语句
			stmt = conn.createStatement();
			
			//执行查询，创建记录集，
			rs = stmt.executeQuery("select * from student");
			while (rs.next()) {
				Student stu = new Student();
				stu.setId(rs.getInt("id"));
				stu.setName(rs.getString("name"));
				stu.setAge(rs.getInt("age"));
			
				//从数据库取出数据转为 Student 对象，封装到 List 集合
				stuList.add(stu);
			}
		
		} catch (Exception e) {
			e.printStackTrace();
        } finally {
			try {
				//关闭资源
				if (rs != null) ;
				{
					rs.close();
				}
				if (stmt != null) {
					stmt.close();
				}
				if (conn != null) {
					conn.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
        } 
}

• 使用 JDBC 的缺陷

  1. 代码比较多，开发效率低
  2. 需要关注 Connection ,Statement, ResultSet 对象创建和销毁
  3. 对 ResultSet 查询的结果，需要自己封装为 List
  4. 重复的代码比较多些
  5. 业务代码和数据库的操作混在一起

MyBatis 框架概述

MyBatis 框架： MyBatis 本是 apache 的一个开源项目 iBatis, 2010 年这个项目由 apache software foundation 迁 移到了 google code，并且改名为 MyBatis 。2013 年 11 月迁移到 Github。 iBATIS 一词来源于“internet”和“abatis”的组合，是一个基于 Java 的持久层框架。iBATIS 提供的 持久层框架包括 SQL Maps 和 Data Access Objects（DAOs） 当前，最新版本是 MyBatis 3.5.1 ，其发布时间是 2019 年 4 月 8 日。

• MyBatis 解决的主要问题
  • 减轻使用 JDBC 的复杂性，不用编写重复的创建 Connetion , Statement ;
  • 不用编写关闭资源代码。直接使用 java 对象，表示结果数据。让开发者专注 SQL 的处理。 其他分心的工作由 MyBatis 代劳。

第二章 MyBatis 框架快速入门

入门案例

使用 Mybatis 准备

下载 mybatis https://github.com/mybatis/mybatis-3/releases

搭建 MyBatis 开发环境

1. 创建 mysql 数据库和相关的表

CREATE TABLE `student` (
 `id` int(11) NOT NULL ,
 `name` varchar(255) DEFAULT NULL,
 `email` varchar(255) DEFAULT NULL,
 `age` int(11) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2. 创建 maven 工程

   

3. 加入依赖和插件

pom

   <dependencies>
    <!--单元测试-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
     </dependency>
    <!--mybatis-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>
     <!--mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.9</version>
    </dependency>

   <dependencies>
  <build>
      <!--
      对于MAVEN项目，Eclipse会自动把项目src\main\java\目录下的配置文件（.xml）和
      资源文件(.properties)搬运到target目录下，而intellij idea默认是不会帮我们做这件事的,
      所以需要加以下配置
      -->
      <resources>
          <resource>
              <directory>src/main/java</directory><!--所在的目录-->
              <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
                  <include>**/*.properties</include>
                  <include>**/*.xml</include>
              </includes>
              <filtering>false</filtering>
          </resource>
          <resource>
              <directory>src/main/resources</directory>
              <includes>
                  <include>**/*.properties</include>
                  <include>**/*.xml</include>
              </includes>
          </resource>
      </resources>

      <!--编译时跳过单元测试-->
      <plugins>
          <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-surefire-plugin</artifactId>
              <configuration>
                  <skipTests>true</skipTests>
              </configuration>
          </plugin>

          <plugin>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.1</version>
              <configuration>
                  <source>11</source>
                  <target>11</target>
              </configuration>
          </plugin>
      </plugins>
  </build>

4. 编写 Student 实体类 在domain/entity包下创建

   public class Student {
     //属性名和列名一样 
     private Integer id;
     private String name;
     private String email;
     private Integer age;
     // set ,get , toString
   }
   

5. 编写 Dao 接口 StudentDao 在dao/mapper包下创建

   public interface StudentDao {
     /*查询所有数据*/
     List<Student> selectStudents();
   }
   

6. 编写 Dao 接口 Mapper 映射文件 StudentDao.xml

   要求：

   1. 在 dao 包中创建文件 StudentDao.xml
   2. 要 StudentDao.xml 文件名称和接口 StudentDao 一样，区分大小写

点击查看

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        <!--
             namespace：必须有值，自定义的唯一字符串 
             推荐使用：dao 接口的全限定名称 
        --> 
    <mapper namespace="com.test.dao.StudentDao">
        <!--
            <select>: 查询数据， 标签中必须是 select 语句
            id: sql 语句的自定义名称，推荐使用 dao 接口中方法名称， 
            使用名称表示要执行的 sql 语句
            resultType: 查询语句的返回结果数据类型，使用全限定类名 
        -->
        <select id="selectStudents" resultType="com.test.domain.Student">
            <!--要执行的 sql 语句-->
            select id,name,email,age from student
        </select>
    </mapper>

7. 创建 MyBatis 主配置文件

   项目 src/main 下创建 resources 目录，设置 resources 目录为 resources root

   创建主配置文件：名称为 mybatis.xml

   说明：主配置文件名称是自定义的，内容如下：

点击查看

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--配置 mybatis 环境-->
    <environments default="development">
        <!--id:数据源的名称-->
        <environment id="development">
            <!--配置事务类型：使用 JDBC 事务（使用 Connection 的提交和回滚）-->
            <transactionManager type="JDBC"/>
            <!--数据源 dataSource：创建数据库 Connection 对象
                type: POOLED 使用数据库的连接池 
            -->
            <dataSource type="POOLED">
                <!--连接数据库的四个要素-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mydbtest?useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=GMT"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!--告诉 mybatis 要执行的 sql 语句的位置-->
        <mapper resource="com\test\mapper\StudentMapper.xml"/>
    </mappers>
</configuration>      

8. 创建测试类

MyBatisTest

  @Test
  public void testStart() throws IOException {

       String config = "mybatis-config.xml";//1.mybatis 主配置文件 

       InputStream in = Resources.getResourceAsStream(config); //2.读取配置文件 

       SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);//3.创建 SqlSessionFactory 对象,目的是获取 SqlSession 

       SqlSession session = factory.openSession(); //4.获取 SqlSession,SqlSession 能执行 sql 语句

       List<Student> studentList =session.selectList("com.test.dao.StudentDao.selectStudents");//5.执行 SqlSession 的 selectList("namespace.id")

       studentList.forEach( student -> System.out.println(student)); //6.循环输出查询结果 

       session.close();//7.关闭 SqlSession，释放资源
  }

9. 配置日志功能

   mybatis.xml 文件加入日志配置，可以在控制台输出执行的 sql 语句和参数

       <settings>
            <setting name="logImpl" value="STDOUT_LOGGING" />
      </settings>
   

基本的 CURD

insert ,update ,delete , selectOne（查询一个）

insert

1. StudentDao 接口中增加方法

   int insertStudent(Student student);

2. StudentDao.xml 加入 sql 语句

   <insert id="insertStudent">
   insert into student(id,name,email,age) values(#{id},#{name},#{email},#{age})
   </insert>
   

3. 增加测试方法

   点击查看

   @Test
           public void testInsert() throws IOException {
               
                String config = "mybatis-config.xml";
                InputStream in =Resources.getResourceAsStream(config);
                SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
                SqlSession session = factory.openSession();
   
                Student student = new Student();
                student.setId(1005);
           	student.setName("张三");
           	student.setEmail("zhangsan@163.com");
                student.setAge(20);
                //执行插入 insert
               int rows =session.insert("com.test.dao.StudentDao.insertStudent",student);
                //MyBatis默认情况下是手动提交事务
                session.commit();
                System.out.println("增加记录的行数:"+rows);
                //8.关闭 SqlSession
                session.close();
   }
   

删改查操作类似，只需要在mapper文件中写sql语句就可以了

主要类的介绍

1. Resources： mybatis中的一个类， 负责读取主配置文件

   InputStream in = Resources.getResourceAsStream("mybatis.xml");

2. SqlSessionFactoryBuilder: 创建SqlSessionFactory对象

   SqlSessionFactoryBuilder builder  = new SqlSessionFactoryBuilder();//创建SqlSessionFactory对象 
   SqlSessionFactory factory = builder.build(in); 
   

3. SqlSessionFactory ：重量级对象，程序创建一个对象耗时比较长，使用资源 比较多。在整个项目中，有一个就够用了。

   SqlSessionFactory 接口实现类：DefaultSqlSessionFactory

SqlSessionFactory作用： 获取SqlSession对象, SqlSession sqlSession = factory.openSession()

openSession()方法说明：

1. openSession()：无参数的，获取是非自动提交事务的SqlSession对象

2. openSession(boolean): openSession(true) 获取自动提交事务的SqlSession. openSession(false) 非自动提交事务的SqlSession对象

3. SqlSession:

   SqlSession接口 ：定义了操作数据的方法 例如 selectOne() ,selectList() ,insert(),update(), delete(), commit(), rollback()

SqlSession接口的实现类DefaultSqlSession。

使用要求： SqlSession对象不是线程安全的，需要在方法内部使用， 在执行sql语句之前，使用openSession()获取SqlSession对象。
在执行完sql语句后，需要关闭它，执行SqlSession.close(). 这样能保证他的使用是线程安全的。

传统 Dao 开发方式的分析

Dao 的实现类其实并没有干什么实质性的工作，它仅仅就是通过 SqlSession 的相关 API 定位到映射文件 mapper 中相应 id 的 SQL 语句，真正对 DB 进行操作的工作其实是由框架通过 mapper 中的 SQL 完成的。

所以，MyBatis 框架就抛开了 Dao 的实现类，直接定位到映射文件 mapper 中的相应 SQL 语句，对DB 进行操作。这种对 Dao 的实现方式称为 Mapper 的动态代理方式。

Mapper 动态代理方式无需程序员实现 Dao 接口。接口是由 MyBatis 结合映射文件自动生成的动态代 理实现的。

第3章 MyBatis 框架 Dao 代理

动态代理

• 使用SqlSession.getMapper(dao接口.class) 获取这个dao接口的对象

  SqlSession session = factory.openSession();

  StudentDao dao = session.getMapper(StudentDao.class);

  得到的是MapperProxy 对象（具体看源码）

传入参数(了解)

从java代码中把数据传入到mapper文件的sql语句中。

1. parameterType ： 写在mapper文件中的 一个属性。 表示dao接口中方法的参数的数据类型。

   • mapper文件中 parameterType一般省略不写，mybatis能自动识别。

       <!--
            <select>中parameterType可以不写
                      resultType必须有
            <insert><update><delete>中通常只写 id 属性
    -->
    <select id="selectById" parameterType="java.lang.String" resultType="com.test.domain.Student">
        select * from t_student where id = #{id}
    </select>
   

2. 一个简单类型的参数：

   简单类型： mybatis把java的基本数据类型和String都叫简单类型。 在mapper文件获取简单类型的一个参数的值，使用 #{任意字符}

   接口：public Student selectStudentById(Integer id) mapper:select id,name, email,age from student where id=#{studentId}

3. 多个参数，使用java对象

   vo: value object , 放一些存储数据的类。比如说 提交请求参数， name ,age 现在想把name ,age 传给一个service 类。

   vo: view object , 从servlet把数据返回给浏览器使用的类，表示显示结果的类。

   pojo: 普通的有set， get方法的java类。 普通的java对象Servlet --- StudentService( addStudent( MyParam param) )

   entity（domain域）: 实体类， 和数据库中的表对应的类

   • 语法 #{对象中的属性名}

   • 接口方法： List<Student> find(Student s)

   • mapper 文件：

     <select id="addStu" >
      select id,name,email,age from student where name=#{sname} or age = #{sage} 
     </select>`
     

4. 多个参数，使用Map

   Map 集合可以存储多个值，使用Map向 mapper 文件一次传入多个参数。Map 集合使用 String的 key， Object 类型的值存储参数。 mapper 文件使用 ## { key } 引用参数值。

   例如：

   Map<String,Object> data = new HashMap<String,Object>();
   data.put(“myname”,”李力”);
   data.put(“myage”,20);
   

   • 接口方法： List<Student> selectMultiMap(Map<String,Object> map);

   • mapper 文件：

     <select id="selectMultiMap" resultType="com.test.domain.Student">
     select id,name,email,age from student where name=#{myname} or age =#{myage}
     </select>
     

5. #{}和${}区别

   • # 使用 ？在sql语句中做占位的， 使用PreparedStatement执行sql，效率高

     select id , name, email , age from student where id = #{studentId}
     // #{} 的结果： select id , name, email , age from student where id = ? 
     

   • # 能够避免sql注入，更安全。

   • $ 不使用占位符，是字符串连接方式，使用Statement对象执行sql，效率低

   • $ 有sql注入的风险，缺乏安全性。

   • $ 可以替换表名或者列名

   select id , name, email , age from student where id = $ {studentId}
   ${} 的结果：
   select id , name , email , age from student where id =1001
   相当于：
   String sql="select id ,name , email ,age from student where id=" + "1001";
   

   $:可以替换表名或者列名， 你能确定数据是安全的。可以使用$

mybatis的输出结果

• mybatis执行了sql语句，得到的java对象。

resultType

1. 指sql语句执行完毕后,数据转为的java对象,java类型是任意的。 resultType结果类型的它值

   (1) 类型的全限定名称

   (2) 类型的别名， 例如 java.lang.Integer别名是int

   处理方式：

2. mybatis执行sql语句， 然后mybatis调用类的无参数构造方法，创建对象。

   mybatis把ResultSet指定列值付给同名的属性。

   <select id="selectMultiPosition" resultType="com.bjpowernode.domain.Student">
   select id,name, email,age from student
   </select>
   

   对等的jdbc:

   ResultSet rs = executeQuery(" select id,name, email,age from student" )
   	while(rs.next()){
           Student  student = new Student();
   		student.setId(rs.getInt("id"));
   		student.setName(rs.getString("name"))
   }
   

3. 定义自定义类型的别名

4. 在mybatis主配置文件中定义，使<typeAlias>定义别名

5. 可以在resultType中使用自定义别名

<!--为mapper映射文件中的domain起别名-->
<typeAliases>
    <!--<typeAlias type="com.test.domain.Student" alias="stu" />-->
    <!--package 批量起别名 系统取好了，别名为类名（区分大小写）-->
    <package name="com.test.domain"/>
</typeAliases>

resultMap:

• 结果映射， 指定列名和java对象的属性对应关系。

1. 你自定义列值赋值给哪个属性

2. 当你的列名和属性名不一样时，一定使用resultMap

   <!-- 
   数据库表不变，现在有一个类属性名和字段对应不上的情况
   type：指定一个类型，与数据库表一一对应，建立起表字段和类属性的名字一一匹配的关系
   -->
   <resultMap id="stuMap" type="Student">
   	<!--
   	id:定义主键
   	property:类中的属性名
   	column: 表中的字段名
   	-->
   	<id property="sid" column="id"/>
   	<result property="sname" column="name"/>
   	<result property="sage" column="age"/>
   	</resultMap>
   
   <select id="selectAll2" resultMap="stuMap">
   	select * from t_student
   </select>
   

• resultMap和resultType不要一起用，二选一

第4章 MyBatis 框架动态 SQL

动态sql

sql的内容是变化的，可以根据条件获取到不同的sql语句。主要是where部分发生变化。

动态sql的实现: 使用mybatis提供的标签，<if> ,<where>,<foreach>

1. <if>是判断条件的，语法

   <if test="判断java对象的属性值">
           部分sql语句
   </if> 
   

2. <where>用来包含 多个<if>的,当多个if有一个成立的,<where>会自动增加一个where关键字,并去掉 if中多余的 and ,or等。

<select id="find" resultType="student">
     select * from t_student
     <!--
         where搭配if标签使用  通过if标签来判断
         如果查询条件不匹配 则不在sql中加where关键字

         where 忽略第一个and
     -->
     <where>
         <if test="name!=null and name!=''">
             <!--'%'中间加空格-->
             and name like '%' #{name} '%'
         </if>
         <if test="address!=null and address!=''">
             and address like '%' #{address} '%'
         </if>
     </where>

 </select>

3. <foreach> 循环java中的数组，list集合的。 主要用在sql的in语句中。

   语法：

   <foreach collection="" item="" open="" close="" separator=""> #{xxx} </foreach>

   collection:表示接口中的方法参数的类型， 如果是数组使用array , 如果是list集合使用list item:自定义的，表示数组和集合成员的变量 open:循环开始时的字符 close:循环结束时的字符 separator:集合成员之间的分隔符

   例如：学生id是 1001,1002,1003的三个学生 select * from student where id in (1001,1002,1003)

	 public List<Student> selectByidS(List<Integer> idlist)

	 List<Integer> list = new ...
	 list.add(1001);
	 list.add(1002);
	 list.add(1003);

	 dao.selectByids(list)
	 
	 <select id="selectByIds" resultType="student">
        select * from t_student
        where id in

        <foreach collection="array" item="id" open="(" close=")" separator=",">
            #{id}
        </foreach>
    </select>

4. sql代码片段,就是复用一些语法,代替重复性高，且复杂的子查询

   步骤 1.先定义 <sql id="自定义名称唯一"> sql语句， 表名，字段等 </sql> 2.再使用，<include refid="id的值" />

   <sql id="selectAll" >
   select * from t_student
   </sql>
   <select id="selectById3" resultType="student">
   <include refid="selectAll" /> where id=#{id}
   </select>
   

• 一般不用 会减低代码可读性

5. ...

第5章 MyBatis 配置文件（掌握）

MyBatis 配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
		
<configuration>
    <!--使用配置文件加载数据库连接属性-->
    <properties resource="db.properties"></properties>

<!--
    <settings>
        <setting name="" value=""/>
    </settings>
    设置与数据库交互环境
        例如可以在此处配置二级缓存，配置查询延迟加载策略等等。。
            配置的目的是为了更有效的查询表中的记录
            实际开发中基本没用 效果不明显 现在有其他策略
            基础操作
                对于常用的查询条件的字段，设置索引
            高级操作
                使用nosql数据库，redis
            专业操作
                Elasticsearch与Solr 针对于电商行业
-->

<!--为mapper映射文件中的domain起别名-->
    <typeAliases>
        <!--<typeAlias type="com.test.domain.Student" alias="stu" />-->
        <!--package 批量起别名 系统取好了，别名为类名（区分大小写）-->
        <package name="com.test.domain"/>
    </typeAliases>
    <!--配置 mybatis 环境-->
      <environments default="development">
          <!--id:数据源的名称-->
          <environment id="development">
              <!--配置事务类型：使用 JDBC 事务（使用 Connection 的提交和回滚）-->
              <transactionManager type="JDBC"/>
              <!--数据源 dataSource：创建数据库 Connection 对象
                  type: POOLED 使用数据库的连接池 
              -->
              <dataSource type="POOLED">
                  <!--使用`${}`读取配置文件，连接数据库的四个要素-->
                  <property name="driver" value="${jdbc.driver}"/>
                  <property name="url" value="${jdbc.url}"/>
                  <property name="username" value="${jdbc.username}"/>
                  <property name="password" value="${jdbc.password}"/>
              </dataSource>
          </environment>
      </environments>
    <mappers>
        <!--<mapper resource="com\test\dao\StudentDao.xml"/>-->
        <!--<mapper class="com.test.dao.StudentDao" />-->
        <!--该包下的mapper映射文件自动注册-->
        <package name="com.test.dao"/>
    </mappers>
</configuration>