Mybatis框架

Mybatis框架

第一章 框架的概述

1.1 三层架构

1.1.1 mvc（用于web开发）

• m：数据 来自数据库mysql，来自文件或网络

• v：视图 现在使用jsp,html,css,js,显示请求的处理结果，把m中的数据显示出来

• c：控制器 接受请求，调用service对象，显示请求的处理结果。当前使用servlet作为控制器

mvc作用：

1. 实现解耦合
2. 让mvc三个层各负其职
3. 使系统扩展性更好，更容易维护

1.1.2 another三层架构（适用于非web开发）

1. 界面层（视图层）：接受用户请求，调用service，显示请求的处理结果。包括了jsp,html,servlet等对象。对应的包controller
2. 业务逻辑层：处理业务逻辑，使用算法处理数据，把数据返回给界面层。对应的是service包，和包中很多的XXXService类。例如：StudentService,OrderService,ShopService
3. 持久层（数据访问层）：访问数据库，或是读取文件，访问网络。获取数据。对应的包是dao，dao包中很多的StudentDao,OrderDao,ShopDao等等。

1.2 三层架构请求的处理流程

用户发起请求—>界面层---->业务逻辑层—>持久层---->数据库（mysql)

1.3 三层架构模式和框架

每一层对应着一个框架

1. 界面层—SpringMVC框架
2. 业务层—Spring框架
3. 持久层—Mybatis框架

1.4 框架

框架（framework）的定义：

框架就是一个软件，完成了部分的功能。软件的类和类之间的方法调用都已经定好了。通过这些可以完成某些功能。框架看做是模板。

框架是可以升级、改造的，而且是安全的。

框架是对某一个方面有用的，并非全能。

1.5 框架解决的问题

1. 框架能实现技术的整合。
2. 提高开发效率，降低难度

1.6 JDBC访问数据库的优缺点

优点：

​ 1、直观，好理解

缺点：

1. ​ 创建对象较多：Connection、Statement、Resultset
2. ​ 注册驱动
3. ​ 执行sql语句
4. ​ 把ResultSet转为Student , List 集合
5. ​ 关闭资源
6. ​ sql语句和业务逻辑代码混在一起

1.7 MyBatis框架

MyBatis作用：可以操作数据库，执行CRUD，相当于高级的JDBC

MyBatis的特点：

1. 注册驱动
2. 创建JDBC中使用的Connection,Statement ,ResultSet
3. 执行sql语句，得到ResultSet
4. 处理ResultSet，把记录集中的数据转为Java对象，同时还能把Java对象放入到List集合
5. 关闭资源
6. 实现sql语句和Java代码的解耦合

第二章 MyBatis 框架快速入门

2.1 第一个例子

实现步骤：

1. 创建student表（id,name,email,age)

2. 新建maven项目

3. 修改pom.xml

   1）加入依赖 mybatis依赖，mysql驱动,junit

   2）在加入资源插件

4. 创建实体类Student。定义属性，属性名和列名保持一致

5. 创建Dao接口，在接口中定义操作数据库的方法

6. 创建xml文件（mapper文件），写sql语句

   mybatis框架推荐把sql语句和Java代码分开

   mapper文件：定义和dao接口在同一目录，一个表一个mapper文件。

7. 创建mybatis的主配置文件（xml文件）<只一个，放在resources目录下>

   1）定义创建连接实例的数据源（DataSource)对象

   2）指定其他mapper文件的位置

8. 创建测试代码

   使用main方法，测试mybatis访问数据库

   也可以使用junit 访问数据库

2.2 概念

1. 自动提交：当你的sql语句执行完毕后，提交事务。数据库更新操作直接保存到数据库中。
2. 手动（手工）提交事务：在你需要提交事务的位置，执行方法，提交事务或者回滚事务

2.3 MyBatis的一些重要概念

1）Resources: mybatis框架中的对象 一个作用：读取主配置信息

InputStream inputStream = Resources.getResourceAsStream(config);

2)SqlSessionFactoryBulider: 负责创建SqlSessionFactory对象

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);

3）SqlSessionFactory: 重要对象

SqlSessionFactory是重量级对象：创建此对象需要使用更多的资源和时间。在项目中有一个就可以了。

SqlSessionFactory接口：作用是SqlSession的工厂，就是创建SqlSession对象。

DefaultSqlSessionFactory实现类

public class DefaultSqlSessionFactory implements SqlSessionFactory { }

SqlSessionFactor接口中的方法

openSession(): 获取一个默认的SqlSession对象，默认是需要手工提交事务的。

openSession(boolean):boolean参数表示是否自动提交事务。

​ true:创建一个自动提交事务的SqlSession

​ false:等同于没有参数的openSession

4）SqlSession对象

SqlSession对象是通过SqlSessionFactory获取的。SqlSession本身是接口

DefaultSqlSession:实现类

public class DefaultSqlSession implements SqlSession { }

SqlSession作用是提供了大量的执行sql语句的方法：

selectOne:执行sql语句，最多得到一行记录，多于1行会报错。
selectList:执行sql语句，返回多行数据
selectMap：执行sql语句，得到一个map结果
insert：执行insert语句
update：执行update语句
delete：执行delete语句
commit：提交事务
rollback：回滚事务

注意SqlSession对象不是线程安全的，使用的步骤：

①：在方法的内部，执行sql语句之前，先获取SqlSession对象

②：调用SqlSession的方法，执行sql语句

③：关闭SqlSession对象，执行SqlSession

2.4 使用工具类和模板

1）创建模板，mapper文件模板和mybatis主配置文件模板

创建模板的步骤：

创建模板文件：

使用已保存的模板来新建文件

第三章 MyBatis的dao代理

3.1dao代理

3.1.1mybatis提供代理：

mybatis创建Dao接口的实现类对象，完成对sql语句的执行。

3.1.2使用mybatis代理要求

1. mapper文件中的namespace一定是dao接口全限定名称
2. mapper文件中标签的id 是dao 接口方法名称

3.1.3mybatis代理方式

使用SqlSession对象的方法 getMapper(dao.class)

例如：现在有StudentDao接口。

SqlSession session = MyBatisutils.getSqlSession();
StudentDao dao = session.getMapper(StudentDao.class);
Student student = dao.selectById(1001);

//以上代码中
StudentDao dao = session.getMapper(StudentDao.class);
等同于
StudentDao dao = new StudentDaoImpl();

3.2理解参数

通过Java程序把数据传入到mapper文件中的sql语句，参数主要是指dao接口方法的形参。

3.2.1 parameterType

parameterType表示参数类型，指定dao方法的形参数据类型。这个形参的数据类型是给mybatis使用。

mybatis在给sql语句的参数赋值时使用。PreparedStatement.setXXX(位置，值)

第一个用法：java类型的全限定类型名称 parameterType = "java.lang.Integer"

第二个用法：mybatis定义的java类型的别名 parameterType = "int"

    parameterType: mybatis通过反射机制可以获取 dao接口方法参数的类型，可以不写
    
      <select id="selectById" parameterType="java.lang.Integer" resultType="com.bjpowernode.domain.Student">
        select id,name,email,age from student where id = #{studentId}
    </select>  

3.2.2 dao接口方法是一个简单类型的参数

// dao接口的方法形参是一个简单类型的
// 简单类型: java基本数据类型和string
Student selectByEmai1(string email);

<!--
	dao接口是一个简单类型的参数
	mapper文件，获取这个参数值，使用#{任意字符}
-->
<select id="selectByEmail" 		resultType="com.bjpowernode.domain.Student">
select id, name ,email,age from student where email=#{studentEmail}
</select>

3.2.3 dao接口方法有多个简单类型的参数

@Param:命名参数，在方法的形参前面使用的，定义参数名。这个名称可以用在mapper文件中。

dao接口，方法的定义

/*
    * 多个简单类型的操作时
    使用@Param命名参数，注解是mybatis提供的
    位置：在形参定义的前面
    属性：value自定义的参数名称
    * */
    List<Student> selectByNameOrAge(@Param("myname") String name, @Param("myage") Integer age);

mapper文件

<!--
    多个简单类型的参数
    当使用了Param命名后，例如@Param("myname") String name
    在mapper中，使用#{命名的参数} 例如 #{myname}
-->
    <select id="selectByNameOrAge" resultType="com.bjpowernode.domain.Student">
        select id,name,email,age from student where name = #{myname} or age = #{myage}
    </select>

3.2.4 dao接口方法使用一个对象作为参数

方法的形参是一个Java对象。这个Java对象表示多个参数。使用对象的属性值作为参数使用

java对象

public class Student {

    private Integer id;
    private String name;
    private String email;
    private Integer age;
    // 对应的get\set方法
}
或者任何一个其他对象 具有属性和对应的get\set函数即可

dao接口中的方法定义

/*
    * 一个Java对象作为参数(对象有属性 每个属性有get/set方法 )
    * */
 List<Student> selectByObject(Student student);

mapper文件

<!--
    一个Java对象作为方法的参数，使用对象的属性作为参数值使用
    简单的语法：#{属性名}, mybatis调用此属性的getxxx()方法获取属性值
-->
    <select id="selectByObject" resultType="com.bjpowernode.domain.Student">
        select id,name,email,age from student where name = #{name} or age = #{age}
    </select>

3.2.5 dao接口中多个简单类型的参数，使用位置

参数位置： dao接口中方法的形参列表，从左往右，参数位置是0，1，2…

语法格式：#{arg0},#{arg1}…

dao接口的方法

/*
    * 通过位置获取参数
    * */
    List<Student> selectByPosition(String name,Integer age);

<!--
    使用位置获得参数值，dao接口是多个简单类型的参数
    语法：#{arg0},#{arg1}....
-->
    <select id="selectByPosition" resultType="com.bjpowernode.domain.Student">
        select id,name,email,age from student where name = #{arg0} or age= #{arg1}
    </select>

3.2.6 dao接口参数是一个Map

map作为dao接口的参数，使用key获取参考值，mapper文件中，语法格式#{key}

/*
    * 使用Map作为参数
    * */
    List<Student> selectStudentByMap(Map<String,Object> map);

mapper文件

<!--
    使用Map传递参数，
    在mapper文件中，获取map的值，是通过key获取的，语法；#{key}
-->
    <select id="selectStudentByMap" resultType="com.bjpowernode.domain.Student">
        select id,name,email,age from student where name = #{myname} or age = #{myage}
    </select>

测试、调用方法的位置

@Test
    public void testSelectByMap(){
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        StudentDao dao = sqlSession.getMapper(StudentDao.class);
        //使用map传递参数
        Map<String,Object> data = new HashMap<>();
        data.put("myname","一胎十个郑爽");
        data.put("myage",28);
        List<Student> students = dao.selectStudentByMap(data);

        students.forEach(stu-> System.out.println("stu = " + stu));
        sqlSession.close();
    }

3.3 #和$的区别

3.3.1 #占位符

语法： #{字符}

mybais处理#{} 使用jdbc对象是 PreparedStatement对象

<select id="selectById" parameterType="java.lang.Integer" resultType="com.bjpowernode.domain.Student">
        select id,name,email,age from student where id = #{studentId}
</select>

//mybatis创建PreparedStatement对象，执行sql语句
String sql = "select id,name,email,age from student where id=?";
PreparedStatement pst = conn.preparedStatement(sql);
pst.setInt(1,1001);//传递参数


‘ResultSet rs = pst.executeQuery();//执行sql语句

#{}特点：

1. 使用PreparedStatement对象来执行sql语句，效率高。
2. 使用PreparedStatement对象能避免sql注入，sql语句执行更安全
3. #{}常常作为列值使用，位于等号右侧，#{}位置的值和数据类型有关

3.3.2 $占位符

语法： ${字符}

mybatis执行${}占位符的sql语句

    <select id="selectById" parameterType="java.lang.Integer" resultType="com.bjpowernode.domain.Student">
        select id,name,email,age from student where id = ${studentId}
    </select>

${} 表示字符串连接，把 sql语句的其他内容 和 ${}的内容 使用字符串（+）连接方式连在一起
String sql = "select id,name,email,age from student where id ="+"1001";

mybatis 创建Statement对象，执行sql语句
Statement stmt = conn.createStatement(sql);
ResultSet rs = stmt.executeQuery();

${}的特点

1. 使用Statement对象执行sql需要先编译，效率低
2. ${}占位符的值使用的是字符串链接呢的方式，有sql注入的风险，代码有安全问题
3. ${}数据是原样使用的，不会区分数据类型
4. ${}常用作 表名or列名，前提是能保证数据安全

3.4封装MyBatis输出结果

封装输出结果：MyBatis执行sql语句，得到ResultSet，转为Java对象。

3.4.1 resultType

resultType属性：在执行select时使用，作为标签的属性出现。

resultType表示结果类型：即mysql执行sql语句后，所得到的Java对象的类型。

它的值有两类：

• Java类型的全限定名称

• 使用别名

1）resultType：表示Java自定义对象

Student selectById(Integer id);

<select id="selectById" parameterType="java.lang.Integer" resultType="com.bjpowernode.domain.Student">
        select id,name,email,age from student where id = #{studentId}
    </select>
    
resultType:此处使用Java类型的全限定名称。目的是在mybatis执行sql后，把ResultSet中的数据转为Student类的对象；其中包含以下操作：
1.调用com.bjpowernode.domain.Student的无参构造方法，创建对象。
	Student student = new Student()；//使用反射创建对象
2.同名的列值赋给同名的属性
	student.setId(rs.getInt("id"));
	student.setName(rs.getString("name"));
3.得到Java对象，如果dao接口返回值是List集合，mybatis把student对象放入到List集合。

所以才能执行Student mystudent = dao.selectById(1001);得到 数据库中 id=1001 的该行数据；而这行数据的列值，赋给了mystudent对象的属性。
因此得到mystudent对象，就相当于得到id=1001的整行数据。

2）resultType表示简单类型

dao方法

long.countStudent();

mapper文件

<!--
执行sq1语句，得到是一个值(一行一列)
-->
<select id="countStudent" 			resultType="java.lang.Long">
select count(*) from student
</select>

3）resultType：表示一个map结构

//查询结果返回是一个Map
Map<object,object> selectMap(@Param("stuid") Integer id);

<!--
执行sq1得到一个Map结构数据，mybatis执行sq1，把Resultset转为mapsq1执行结果，列名做map的key ,列值作为value
sq1执行得到是一行记录,转为map结构是正确的。
dao接口返回是一个map， sq1语句最多能获取一行记录，多余一行是错误
-->
<select id="selectMap" resultType="java.util.HashMap ">
select id,name,email from student where id != #{stuid}</select>

3.4.2 resultMap

resultMap:结果映射。自定义列名和Java对象属性的对应关系。常用在列名和属性名不同的情况。

用法：

先定义resultMap标签，指定列名和属性名对应关系

在select标签使用resultMap属性，指定上面定义的resultMap的id值

<!--使用resultMap定义列和属性的关系-->
<! --定义resultMap
	id:给resultMap的映射关系起个名称，唯一值
	type :java类型的全限定名称
-->
<resultMap id="customMap" type="com. bjpowernode.vo.CustomObject">
<!--定义列名和属性名的对应-->
<!--主键类型使用id标签-->
<id column="id" property="cid"/>
<!--非主键类型使用result标签-->
<result column="name" property="cname”/>
<! --列名和属性名相同不用定义-->
<result column="email" property="emai7"/><result column="age" property="age"/></resultMap>
<! --使用resultMap属性，指定映射关系的id
resultMap和resultType 不能同时使用，二选一。
-->
<select id="selectById2" resultMap="customMap">
select id,name,email,age from student where id=#{stuid}</select>

3.5 自定义别名

mybatis提供的对Java类型定义简短，记好名称。

自定义别名的步骤：

1. 在mybatis主配置文件，使用typeAliases标签声明别名
2. 在mapper文件中，把别名赋值给resultType，即resultType=“别名”

声明别名(mybatis主配置文件)

<typeAliases>
<! --第一种语法格式
	type :java类型的全限定名称（自定义类型)
	alias :自定义别名
-->
<typeAlias type="com.bjpowernode.domain.Student" alias="stu"/>

</typeAliases>

mapper文件中使用

resultType="别名"
<select id="selectById" parameterType="integer" resultType="stu">
select id,name,email,age from student where id=#{studentId}</select>

3.6 列名和Java对象属性名称不一致 的解决方式

1. 使用resultMap：自定义列名和属性名称对应方式

   代码见前面部分

2. 使用resultType：使用列别名，让别名和Java对象属性名称

   <!--
   使用列别名，解决列名和属性名不同的问题(其中as可省略)
   -->
   <select id="selectById3" resultType="com. bjpowernode . vo.Customobject">
   select id as cid, name as cname,email,age from student where id=#{stuid}
   </select>
   

3.7 like的使用

第一种方式：在Java程序中，把like的相关内容组装好。把这个内容传入到sql语句

/ /like第一种方式
List<student> selectLikeone(@P aram( "name") string name);

mapper

<! --like第一种方式 -->
<select id="selectLikeone" resultType="com.bjpowernode.domain.student">
select * from student where name like #{name}
</select>

执行like

@Test
public void testLikeone(){
sq1session sqlsession = MyBatisutil.getsqlsession() ;
studentDao dao = sq1session. getMapper(studentDao.class);

String name="%李%";
List<Student> students = dao.selectLikeone(name);

sq1Session.close();
    
students.forEach( stu-> System.out.print1n(stu) );
}

第二种方式：在sql语句中，组织like的内容

sql语句like的格式：where name like “%“空格#{}空格”%”

/ /like第二种方式
List<student> selectLikeTwo(@Param("name") String name);

<! --like第二种方式-->
<select id="selectLikeTwo" resultType="com.bjpowernode.domain.student">
select * from student where name like "%" #{name}  "%"
</select>

@Test
public void testLikeTwo(){
Sqlsession sq1session = MyBatisutil.getSqlsession() ;
StudentDao dao = sq1session. getMapper(StudentDao.c1ass);

String name="李”;
List<Student> students = dao.selectLikeTwo(name);

sq1session.close();

students.forEach(stu-> System.out.print1n(stu));

第四章 动态sql

动态sql定义： 同一个dao的方法，根据不同的条件可以表示不同的sql语句，主要是where部分有变化

使用mybatis提供的标签，实现动态sql的能力，主要记录 if，where，foreach，sql。

使用动态sql时，dao方法的形参使用Java对象。

4.1 if标签

语法：

<if test="boolean判断结果">
	sql 代码
</if>
多个if可并列放置 没有else之类的其他标签

mapper文件中

<select id="selectStudent" resultType="com.bjpwoernode.domain.Student">
	select * from student
	<if test="条件">
	sql语句
	</if>
	<if test="条件">
	sql语句
	</if>
</select>

例子：

List<Student> selectIf(Student student) ;

<! --if
	test:使用对象的属性值作为条件
-->
<select id="selectIf" resultType="com.bjpowernode.domain.student">
	select * from student
	where id=-1
<if test="name !=nu11 and name! ='"'">
	orname = #{name}
</if>
<if test="age >0">
	or age &lt; #{age}
</if>
</select>

4.2 where标签

作用：使用if标签时，容易由于多if连接导致sql语法错误。使用where标签可以解决。

用法：where里有一个或多个if标签，当有一个if标签判断条件为true，where标签加到sql语句后面。如果if没有一个条件为true，忽略where和里面的if

语法:
<where>
<if test="条件1">sql语句1</if>
<if test="条件2">sq1语句2</if>
</where>

/ / where
List<Student> selectwher e(student student);

<! --where-->
<select id="selectwhere" resultType="com.bjpowernode.domain.student">
	select i from student
	<where>
		<if test="name !=nu11 and name ! ='" ">
			or name = #{name}
		</if>
		<if test="age >0">
			or age &lt; #{age}</if>
	</where>
	
</select>

4.3 foreach循环

使用foreach可以循环数组，list集合，一般使用在in语句中。

语法:

<foreach collection="集合类型" open="开始的字符" close="结束的字符"
item="集合中的成员" separator="集合成员之间的分隔符">
#{item的值}
</foreach>


标签属性:

collection:表示循环的对象是数组、或1ist集合；
如果dao接口方法的形参是数组，collection="array”；
如果dao接口形参是List，collection="list"

open:循环开始时的字符。 sql.append("(");

close:循环结束时字符。sql.append(")");

item:集合成员，自定义的变量。 Integer item = idlist.get(i);// item是集合成员
separator:集合成员之间的分隔符。sql.append(", ");//
集合成员之间的分隔符
#{item的值}:获取集合成员的值。

4.4 sql标签

sql标签标示一段sql代码，可以是表名，几个字段，where条件；

可以在其他地方复用sql标签的内容

使用方式：

1) 在mapper文件中定义 sq1代码片段<sql id="唯一字符串">部分sq1语句</sq1>
2）在其他的位置，使用include标签引用某个代码片段

<select id="selectIf" resultType="com.bjpowernode. domain.Student ">
    <include refid="selectStudent"/>
	where id=-1
	<if test="name !=null and name!='" ">
		or name = #{name}
	</if>
	<if test="age >0">
		or age &lt; #{age}
	</if>
</select>

<! --where-->
<select id="selectwhere" resultType="com.bjpowernode.domain.student">
	select <include refid="studentFie1dList"from student
	<where>
		<if test="name !=nu1l and name!=''">
			orname = #{name}
		</if>
		<if test="age >0">
			or age &lt; #{age}
		</if>
	</where>
	
</select>

第五章 MyBatis配置文件

mybatis配置文件分为两大类：

1. mybatis主配置文件：提供mybatis全局设置。内容包含日志，数据源,mapper文件位置。
2. mapper文件:写sql语句。一个表一个mapper文件。

5.1 settings部分

settings是mybatis的全局设置，影响整个mybatis的运行。这个设置一般用默认值就可以了。

<settings>
	<setting name="cacheEnab1ed" value="true" />
	<setting name="7azyLoadingEnab1ed" value="true" />
	<setting name="multipleResultsetsEnab1ed" value="true"/>
	<setting name="usecolumnL abel" value="true" />
	<setting name="useGeneratedKeys" value="false" />
	<setting name="autoMappingBehavior" value="PARTIAL"/>
	<setting name="autoMappingUnknowncolumnBehavior" value="wARNING"/>
	<setting name="defaultExecutorType" value="SIMPLE"/>
	<setting name="defaultstatementTimeout" value="25"/>
	<setting name="defaultFetchsize" value="100" />
	<setting name="safeRowBoundsEnab1ed" value="false" />
	<setting name="mapUnderscoreToCamelcase" value="false" />
	<setting name="localcachescope" value="SESSION"/>
	<setting name="jdbcTypeForNu17" value="OTHER" />
	<setting name="7azyLoadTriggerMethods" 
value="equals , clone, hashCode,toString"/>

</settings>

5.2 typeAliase别名

设置别名

<typeAliases>
	<!--第一种语法格式
		type : java类型的全限定名称（自定义类型)
		alias :自定义别名
		优点:别名可以自定义
		缺点:每个类型必须单独定义
	-->
<typeAlias type="com.bjpowernode . domain.student" alias="stu"/>
<typeAlias type="com.bjpowernode.vo.QueryParam" alias="qp"/>

	<!--第二种方式
		name:包名，mybatis会把这个包中所有类名作为别名（不用区分大小写)
		优点:使用方便，一次给多个类定义别名
		缺点:别名不能自定义,必须是类名。-->
	<package name="com.bjpowernode.domain"/>
	<package name="com.bjpowernode.vo”/>

</typeAliases>

5.3 配置环境

environments:环境标签,在他里面可以配置多个environmentenvironment :表示一个数据库的连接信息。
	属性:id自定义的环境的标识。唯一值。
	transactionManager :事务管理器
	属性: type 表示事务管理器的类型。
	属性值:
	1）JDBC:使用connection对象，由mybatis自己完成事务的处理。
	2)MANAGED:管理，表示把事务的处理交给容器实现（由其他软件完成事务的提交，回滚)

<environments default="development">
	<environment id="development">
		<transactionManager type="3DBC"/>
		<!--配置数据源:创建connection对象。-->
	<datasource type="POOLED">
		<! --driver:驱动的内容-->
		<property name="driver " value="com.mysq1.jdbc. Driver" />
		<! --连接数据库的ur1-->
		<property name="ur 7"
value="jdbc : mysql: / / localhost : 3306/springdb" />
		<!--用户名-->
		<property name="username" value="root" /><!--密码-->
		<property name="password" value="123"/>		</dataSource>
	</environment>
</environments>

5.4使用数据库属性配置文件

需要把数据库的配置信息放到一个单独文件中，独立管理。这个文件扩展名是properties

在这个文件中，使用自定义的key=value的格式表示数据

使用步骤:

1. 在resources目录中，创建xxxx.properties
2. 在文件中，使用key=value的格式定义数据。
   例如jdbc.url=jdbc:mysql://localhost:3306/springdb
3. 在mybatis主配置文件，使用properties标签引用外部的属性配置文件
4. 在使用值的位置，使用${key}获取key对应的value(等号右侧的值)

例子:

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysq1://localhost:3306/springdb?useUnicode=true& characterEncoding=utf-8
jdbc.username=root
jdbc.password=123

mybatis主配置文件：

<! --使用外部属性配置文件
	resource:指定类路径下的某个属性配置文件
-->
<properties resource="jdbc.properties"/>

<environments default="development">
	<environment id="development">
		<tr ansactionManager type="JDBC"/>
		<!--配置数据源:创建Connection对象。-->				<dataSource type="POOLED">
			<!--driver:驱动的内容-->
			<property name="driver " value="${jdbc.driver}"/>
			<!--连接数据库的ur1-->
			<property name="ur7" value="${jdbc.ur 1}"/>
			<!--用户名-->
			<property name="username" value="${jdbc.username}"/>
			<!--密码-->
			<property name="password" value="${jdbc.password}" />
		</dataSource>
	</environment>
</environments>

5.5 mapper文件

使用mapper指定其他mapper文件的位置，

mapper标签有两个常用的格式。

<mappers>
	<!--
		第一种方式,resources="mapper文件的路径"
		优点:文件清晰。加载的文件是明确的。
			文件的位置比较灵活。
		缺点:文件比较多，代码量会比较大，管理难度大
	-->
<mapper resource="com/bjpowernode/dao/studentDao.xml" /><mapper resource="com/bjpowernode/dao/or derDao.xml" />
	<!--
		第二种方式，使用<package>
		name:包名，mapper文件所在的包名。
		特点:把这个包中的所有mapper文件，一次加载。	
		
		使用要求:
		1. mapper文件和dao接口在同一目录
		2. mapper文件和dao接口名称完全一样
	-->
	<package name="com.bjpowernode.dao"/>
	<package name="com.bjpowernode.dao1"/>
</mappers>

第六章 PageHelper

PageHelper做数据分页。在你的select语句后面加入 分页的sql内容，如果你使用的是sql数据库，它就是在select语句后添加 limit语句

使用步骤：

1. 加入依赖pagehelper依赖

<dependency>
<groupId>com.github.pagehelper</groupId><artifactId>pagehelper</artifactId>
<version>5.1.10</version>
</dependency>

2. 在mybatis主配置文件，加入plugin声明

//在<environments>之前加入

<plugins>
	<plugin interceptor ="com.github.pagehelper.PageInterceptor"/>
</plugins>

3. 在select语句之前，调用PageHelper.startPage(页码，每页大小)

//调用PageHelper的方法
PageHelper.startPage( pageNum: 2, pageSize: 4);

对比：

• 没有使用PageHelper
  select * from student order by id

• 使用PageHelper
  select * from student order by id LlMIT ?

    优点:文件清晰。加载的文件是明确的。
    	文件的位置比较灵活。
    缺点:文件比较多，代码量会比较大，管理难度大