框架简述 && 带你认识 Mybatis

框架概述

什么是框架

框架是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法；或者定义为应用开发者定制的应用骨架。综上，框架是某种应用的半成品，是一组组件，供开发者选用以完成系统构建。

框架一般处在低层应用平台（如 J2EE）和高层业务逻辑之间的中间层。

软件设计思想

面向对象——三层架构（表现层、业务层、持久层）

区分层次的目的即为了“高内聚，低耦合”的思想

① 持久层：该层所做事务直接操作数据库，针对数据的增添、删除、修改、更新、查找等。采用DAO模式，建立实体类和数据库表映射（ORM映射）。也就是哪个类对应哪个表，哪个属性对应哪个列。持久层的目的就是，完成对象数据和关系数据的转换。即DAO层。///也称数据访问层（DAL）

② 业务层：针对具体问题的操作，也可以说是对数据层的操作，对数据业务逻辑处理。采用事务脚本模式。将一个业务中所有的操作封装成一个方法，同时保证方法中所有的数据库更新操作，即保证同时成功或同时失败。避免部分成功部分失败引起的数据混乱操作。即Service层。///也称业务逻辑层（BLL）

③ 表现层：通俗讲就是展现给用户的界面。

采用MVC模式。

​ M称为模型，也就是实体类。用于数据的封装和数据的传输。

​ V为视图，也就是GUI组件，用于数据的展示。

​ C为控制，也就是事件，用于流程的控制

设计原则：

​ 业务层接口的设计原则：一个实体类一个接口，一次提交一个业务方法。业务方法的参数来自表现层。

​ 持久层接口的设计原则：一个实体类一个接口，一次数据库操作一个持久层方法。

MVC 编程模式（分层思想）

MVC指MVC模式的某种框架，它强制性的使应用程序的输入、处理和输出分开。使用MVC应用程序被分成三个核心部件：模型、视图、控制器。它们各自处理自己的任务。最典型的MVC就是JSP + servlet + javabean的模式。

模型Model：模型是应用程序的主体部分。模型表示业务数据，或者业务逻辑. 实现具体的业务逻辑、状态管理的功能。

视图View：视图是应用程序中用户界面相关的部分，是用户看到并与之交互的界面。 就是与用户实现交互的页面，通常实现数据的输入和输出功能。

控制Controller：控制器工作就是根据用户的输入，控制用户界面数据显示和更新model对象状态。起到控制整个业务流程的作用，实现View层跟Model层的协同工作。

MVC模式与三层架构的区别

MVC是表现模式（Presentation Pattern），三层架构是典型的架构模式（Architecture Pattern），三层架构的分层模式是典型的上下关系，上层依赖于下层。但MVC作为表现模式是不存在上下关系的，而是相互协作关系。

MVC是 Model-View-Controller，严格说这三个加起来以后才是三层架构中的UI层，也就是说，MVC把三层架构中的UI层再度进行了分化，分成了控制器、视图、实体三个部分，控制器完成页面逻辑，通过实体来与界面层完成通话；而C层直接与三层中的BLL进行对话。

MVC与三层架构互为补充，二者之间的关系如下图所示。在三层架构设计中，表示层可由MVC设计模式中的视图和控制器来实现，而业务逻辑层和数据访问层则组成MVC设计模式中的模型的实现。因此，在实际的应用中，都是采用三层架构来搭建系统的框架，而表示层与业务逻辑层和数据访问层的交互则是通过MVC设计模式来实现。

MVC可以是三层中的一个表现层框架，属于表现层。三层和MVC可以共存。

具体可参考;https://www.cnblogs.com/rainbow70626/p/4967478.html

分层开发下的常见框架

持久层框架------Mybatis

mybatis 是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。mybatis 通过 xml 或注解的方式将要执行的各种 statement 配置起来，并通过 java 对象和 statement 中sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并返回。采用 ORM 思想解决了实体和数据库映射的问题，对 jdbc 进行了封装，屏蔽了 jdbc api 底层访问细节，使我们不用与 jdbc api 打交道，就可以完成对数据库的持久化操作。

作为持久层的框架，还有一个封装程度更高的框架就是Hibernate，但这个框架因为各种原因目前在国内的流行程度下降太多，现在公司开发也越来越少使用。目前使用 Spring Data 来实现数据持久化也是一种趋势。

mybatis加载流程

1. spring加载mybatis
2. 加载配置文件到内存
3. 加载mapper文件到内存
4. 生产SqlsessionFactory

mybatis执行流程

1. 从SqlsessionFactory获取Sqlsession
2. 封装请求参数
3. 预编译sql
4. 执行sql
5. 封装返回参数

mybatis的工作流程

1. 读取mybatis配置文件
2. 根据读取到的配置文件生成SqlsessionFactory
3. 创建Sqlsession对象（开启事务）
4. 操作目标数据库
5. 提交事务
6. 关闭Sqlsession

表现层框架（ MVC 框架）------Spring MVC

SpringMVC是一个基于MVC的web框架

在MVC架构中，JSP页面就是视图，用户通过JSP页面发出请求后，Spring MVC会根据请求路径，将请求发给与请求路径对应的Controller类，Controller类调用Service类对请求进行处理，Service类会调用数据持久层MyBatis完成对实体类的存取和查询工作，并将处理结果返回到Controller类，Controller类将处理结果转换ModelAndView对象，JSP接收ModelAndView对象并进行渲染。

解决技术整合问题的框架------Spring

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。

◆目的：解决企业应用开发的复杂性

◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

◆范围：任何Java应用

Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。

Mybatis框架的使用

基于.xml映射文件的使用

(1) 创建maven中java project项目

(2) 在pom.xml中配置mybatis和mysql等所需jar包坐标信息

<dependency>
    <!--mybatis开发包-->
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.1</version>
    <scope>compile</scope><!--默认值-->
</dependency>
<dependency>
     <!--mysql驱动-->
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<dependency>
    <!--日志操作包-->
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.12</version>
</dependency>

(3)编写配置文件mybatisConfig.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="ee12">
        <!-- 配置 mysql 的环境 -->
        <!--可以有多个environment,设置不同的id，比如一个是runner，一个是test，表示一个用于正式运行，一个用于测试-->
        <environment id="ee12">
            <!-- 配置事务的类型 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置连接数据库的信息：用的是数据源(连接池) -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
               <!-- <property name="url" value="jdbc:mysql://localhost:3306/db_01"/>-->
                <property name="url" value="jdbc:mysql:///db_01"/>
                <property name="username" value="root"/>
                <property name="password" value="000"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

(4)拷贝log4j的配置文件到resources下

log4j.properties

log4j.rootLogger=trace,stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

(5)编写实体类

package com.dayu.domain;

public class User {
    private Integer uid;
    private String username;
    private String password;

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

(6)编写持久层（dao）接口（可以写成 UserDao 或者 UserMapper）

package com.dayu.dao;

import com.ujiuye.domain.User;

import java.util.List;

public interface UserDao {
    List<User> findAllUsers();
}

(7)编写持久层接口的映射文件UserDao.xml

1、映射文件的目录要和dao接口的包一致；

2、映射文件的名字和dao接口类名一致

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dayu.dao.UserDao">
    <select id="findAllUsers" resultType="com.dayu.domain.User">
        select uid,username,password from t_users
    </select>
</mapper>

注意：

a、基于接口代理方式开发

采用mybatis基于接口代理方式实现持久层的开发，这种方式是现在企业的主流

基于接口代理方式开发只需要编写DAO接口，mybatis框架为我们动态生成实现类(代理对象)

使用这种方式开发需要遵循以下规则：

1. 、sql映射文件中的namespace与DAO接口的全限定名相同

2. 、DAO接口中方法名和sql映射文件定义的每个映射语句（select,insert,delete,update）中的id名称相同

3. 、DAO接口方法的输入参数类型和sql映射文件定义的每个映射语句的parameterType类型相同(省略)

4. 、DAO接口方法的输出参数类型和sql映射文件定义的每个映射语句resultType类型相同

b、解决实体类属性名和对应数据库表中字段不相同

实体类中属性名和对应数据库表中字段名不相同，当执行查询地，就会返回数据为null，原因就是数据库字段给属性赋值根据名称匹配查找，解决此问题方法如下：

1. 、在sql语句中给字段取别名

2. 、采用resultMap标签建立属性和字段一一关联映射

(8)注册映射文件

在mybatis-config.xml中注册映射文件

<!-- 告知 mybatis 映射配置的位置 -->
<mappers>
    <mapper resource="com/dayu/dao/UserDao.xml"/>
</mappers>

(9)执行测试

编写一个测试工具类

package com.dayu.util;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MyBatisUtil {
    private static SqlSessionFactory sqlSessionFactory;
    static {
       try {
           //读取主配置文件，创建sqlSessionFactory
           InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
           sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
           inputStream.close();
        } catch (IOException e) {
            throw new RuntimeException("初始化mybatis失败，请检查您的配置文件");
        }
    }
    //创建SqlSession的方法
    public static SqlSession openSession(){
        return sqlSessionFactory.openSession();
    }
   //关闭SqlSession的方法
    public static void release(SqlSession sqlSession){
        if(sqlSession!=null)
            sqlSession.close();
    }
}

单元测试

package com.dayu.dao;

import com.dayu.domain.User;
import com.dayu.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void testFindAllUsers(){
        SqlSession sqlSession = MyBatisUtil.openSession();
        //利用反射机制生成代理对象
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> allUsers = userDao.findAllUsers();
        for(User user:allUsers)
            System.out.println(user);
        MyBatisUtil.release(sqlSession);
    }
}

基于注解的 mybatis 使用

注意：使用注解时，就不需要映射配置文件了。

@Insert:实现新增

@Update:实现更新

@Delete:实现删除

@Select:实现查询

@Result:实现结果集封装

@Results:可以与@Result 一起使用，封装多个结果集

@ResultMap:实现引用@Results 定义的封装

@One:实现一对一结果集封装

@Many:实现一对多结果集封装

@SelectProvider: 实现动态 SQL 映射

@CacheNamespace:实现注解二级缓存的使用

(1)修改mybatis-config.xml

直接指定dao所在的包进行扫描，或者告知具体映射的接口位置

	<mappers>
        <!--扫描指定包中的所有接口--><!--推荐使用，因为有多个接口时可以全部囊括在内-->
        <package name="com.ujiuye.dao"/>
    </mappers>
<!--或者-->
	<!-- 告知 mybatis 映射配置的位置 -->
	<mappers> 
        <mapper class="com.itheima.dao.IUserDao"/>
	</mappers>

(2)在持久层接口中添加注解

增删改查：

@Select @Update @Insert @Delete

package com.dayu.dao;

import com.dayu.domain.User;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

public interface UserDao {
    @Insert("insert into t_users values(null,#{username},#{password})")
    void insertUser(User user);

    @Update("update t_users set username=#{username},password=#{password} where uid=#{uid}")
    void updateUser(User user);

    @Delete("delete from t_users where uid=#{uid}")
    void deleteUser(Integer uid);

    @Select("select * from t_users where uid=#{uid}")
    User findUserByUid(Integer uid);
}

(单元测试

package com.dayu.test;

import com.ujiuye.util.MyBatisUtil;
import com.dayu.dao.UserDao;
import com.dayu.domain.User;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;

public class UserDaoTest {

    protected SqlSession sqlSession;

    @Before //带有该注解的方法，测试方法执行前会先执行
    public void initSqlSession(){
        sqlSession = MyBatisUtil.openSession();
    }
    @After//带有该注解的方法，测试方法执行后会执行
    public void destroySqlSession(){
        MyBatisUtil.release(sqlSession);
    }
    
    //注意：增删改时需要手动提交事务  sqlSession.commit();
    @Test
    public void insertUser() {
        User user = new User();
        user.setUsername("user3");
        user.setPassword("1234");

        UserDao userDao = sqlSession.getMapper(UserDao.class);
        userDao.insertUser(user);
        sqlSession.commit();
    }

    @Test
    public void updateUser() {
        User user = new User();
        user.setUid(3);
        user.setUsername("user33");
        user.setPassword("12345");

        UserDao userDao = sqlSession.getMapper(UserDao.class);
        userDao.updateUser(user);
        sqlSession.commit();
    }

    @Test
    public void deleteUser() {
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        userDao.deleteUser(3);
        sqlSession.commit();
    }

    @Test
    public void findUserByUid() {
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        User user = userDao.findUserByUid(1);
        System.out.println(user);
    }
}

嵌套查询

根据少（多）查多

使用.xml文件

查询用户的同时查询其账户信息

step1、建表语句—用户表（少）和账户表（多）

create table t_users(
	uid int primary key auto_increment,
    username varchar(100),
    password varchar(100)
);
insert into t_users values(null,'user1','1234');
insert into t_users values(null,'user2','1234');

create table t_accounts(
	aid int primary key auto_increment,
    number varchar(100),
    balance float(10,2),
    uid int,
    constraint uid_fk foreign key(uid) references t_users(uid)
);
insert into t_accounts values(null,'5555',1000,1);
insert into t_accounts values(null,'6666',1000,1);
insert into t_accounts values(null,'7777',1000,2);

step2、编写实体类

用户的实体类

package com.dayu.domain;

public class User {
    private Integer uid;
    private String username;
    private String password;
    private List<Account> accounts;
    
    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

账户的实体类

package com.dayu.domain;

public class Account {
    private Integer aid;
    private String number;
    private Float balance;

    public Integer getAid() {
        return aid;
    }

    public void setAid(Integer aid) {
        this.aid = aid;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public Float getBalance() {
        return balance;
    }

    public void setBalance(Float balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "Account{" +
                "aid=" + aid +
                ", number='" + number + '\'' +
                ", balance=" + balance +
                '}';
    }
}

step3、编写UserDao

package com.dayu.dao;

import com.dayu.domain.User;
import java.util.List;

public interface UserDao {
    List<User> findAllUsersWithAccounts();
}

step4、编写UserDao映射文件

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dayu.dao.UserDao">
<resultMap id="userBaseMap" type="com.dayu.domain.User">
        <id column="uid" property="uid"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
    </resultMap>
    <resultMap   id="userAcount" extends="userBaseMap" type="com.dayu.domain.User">
        <collection fetchType="lazy" property="accounts" ofType="com.dayu.domain.Account"
               select="com.dayu.dao.AccountDao.findAccountsByuid" column="uid"/>
    </resultMap>
    <select id="findAllUsersWithAccounts" resultMap="userAcount">
        select * from t_users
    </select>
</mapper>

step5、编写AccountDao

package com.dayu.dao;

import com.ujiuye.domain.Account;
import java.util.List;

public interface AccountDao {
    List<Account> findAccountsByUid(Integer uid);
}

step6、编写AccountDao映射文件

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dayu.dao.AccountDao">
    <select id="findAccountsByUid" resultType="com.dayu.domain.Account">
        select aid,number,balance,uid from t_accounts where uid=#{uid}
    </select>
</mapper>

step7、在mybayisConfig.xml中注册映射文件

<mappers>
       <mapper resource="com/dayu/dao/UserDao.xml" />
       <mapper resource="com/dayu/dao/AccountDao.xml" />
        <!--或者<package name="com.dayu.dao"/>-->
    </mappers>

step8、测试

@Test
    public void testFindAllUsers1(){
        SqlSession sqlSession = MyBatisUtil.openSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> allUsers = mapper.findAllUsersWithAccounts();
        for(User user:allUsers)
            System.out.println(user);
        MyBatisUtil.release(sqlSession);
    }

使用注解

主要改变就是省去映射文件，直接在接口中使用注解。

UserDao接口中

 @Results({
            @Result(column = "uid",property = "uid",id = true),
            @Result(column = "username",property = "username"),
            @Result(column = "password",property = "password"),
            @Result(column = "uid",property = "accounts",many = @Many(
                    select = "com.dayu.dao.AccountDao.findAccountsByUid",fetchType = FetchType.EAGER)
            )
    })
    @Select("select uid,username,password from t_users")
    List<User> findAllUsersWithAccounts();

AccountDao接口中

 @Select("select * from t_accounts where uid=#{uid}")
    List<Account> findAccountsByUid(Integer uid);

根据多查少（多）

查询所有账户的同时查询对应的用户信息

使用.xml文件

step1、在账户表中建立账户和用户的关联关系

 private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

step2、修改AccountDao

List<Account> findAccountsWithUser();

step3、修改AccountDao映射文件

<resultMap id="accountBaseMap" type="com.ujiuye.domain.Account">
        <id column="aid" property="aid"/>
        <result column="number" property="number"/>
        <result column="balance" property="balance"/>
    </resultMap>
    <resultMap id="accountUser" type="com.ujiuye.domain.Account" extends="accountBaseMap">
        <association property="user" column="uid" javaType="com.ujiuye.domain.User"
                     select="com.ujiuye.dao.UserDao.findUserByUid"/>
    </resultMap>
    <select id="findAccountsWithUser" resultMap="accountUser">
        select aid,number,balance,uid from t_accounts
    </select>

step4、修改UserDao

User findUserByUid(Integer uid);

step5、修改UserDao映射文件

<select id="findUserByUid" resultMap="userBaseMap">

step6、测试

 @Test
    public void testFindAccountWithUser(){
        SqlSession sqlSession = MyBatisUtil.openSession();
        AccountDao mapper = sqlSession.getMapper(AccountDao.class);
        List<Account> accounts = mapper.findAccountsWithUser();
        for(Account account:accounts){
            System.out.println("Account:"+account);
            System.out.println("User:"+account.getUser());
            System.out.println("---------------------------");
        }
        MyBatisUtil.release(sqlSession);
    }

使用注解的方式

step1、修改AccountDao接口

 @Results({
            @Result(column = "aid",property = "aid",id = true),
            @Result(column = "number",property = "number"),
            @Result(column = "balance",property = "balance"),
            @Result(column = "uid",property = "user",one = @One(
                    select = "com.ujiuye.dao.UserDao.findUserByUid",fetchType = FetchType.EAGER
            ))
    })
    @Select("select aid,number,balance,uid from t_accounts")
    List<Account> findAllAccountsWithUser();

step2、修改UserDao接口

  @Select("select * from t_users where uid=#{uid}")
    User findUserByuid(Integer uid);

MyBatis框架多个输入参数执行查询

说明:在sql映射文件如果有查询条件，默认情况下只支持一个参数作为查询条件，否则就报错

org.apach.ibatis.exception.PersistenceException:

(1) 采用索引获取输入参数

说明:3.4.1版本之后默认不支持使用索引，如果需要使用，需要在mybatis-config.xml文件中配置，配置信息如下

DAO接口方法

sql映射文件

测试方法

(2) 采用注解获取输入参数

DAO接口方法

sql映射文件

测试方法

(3) 采用map对象传入参数

DAO接口方法

sql映射文件

测试方法

(4) 使用实体类传入参数

DAO接口方法

sql映射文件

测试方法

说明：为了方便跟踪sql语句，将sql语句打印日志中，需要在mybatis-config.xml配置，具体配置如下:

MyBatis配置文件深入

映射文件注册配置

<mappers>
        <!--方式一：单独注册某个映射文件
        <mapper resource="com/ujiuye/dao/UserDao.xml"/>
        -->
        <!--方式二：通过注册Dao接口的方式.
            注意：映射文件包名必须和Dao接口一致；映射文件名必须和Dao接口名一致
        <mapper class="com.ujiuye.dao.UserDao"/>
         -->
        <!--方式三：扫描指定包中的所有接口。推荐的
            注意：映射文件包名必须和Dao接口一致；映射文件名必须和Dao接口名一致
        -->
        <package name="com.ujiuye.dao"/>
    </mappers>

mybatisConfig.xml中设置 别名、加载策略、二级缓存

step1、修改mybatisConfig.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>
    <settings>
        <!--全局加载策略-延迟加载lazy-->
        <setting name="lazyLoadingEnabled" value="true"/>
         <!--覆盖触发立即加载的默认方法-->
        <setting name="lazyLoadTriggerMethods" value=""/>
          <!--全局开启二级缓存-->
     <!--注意事项：实体类要实现java.io.Serializables接口。因为二级缓存用到了序列化来保存缓存数据。-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
   
    <typeAliases>
        <!--方式一：给指定类取别名
  		<typeAlias type="com.ujiuye.domain.User" alias="user"/>
        -->
        <!--方式二：批量设置别名。包中的所有类都会采用名称简写。比如其中的User类别名：user、User、USER，不区分大小写-->
        <package name="com.dayu.domain"/>
    </typeAliases>

    <environments default="dayu">
        <environment id="dayu">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///java03"/>
                <property name="username" value="root"/>
                <property name="password" value="000"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
       <!-- <mapper resource="com/dayu/dao/UserDao.xml" />
        <mapper resource="com/dayu/dao/AccountDao.xml" />-->
        <package name="com.dayu.dao"/>
    </mappers>
</configuration>

step2、映射文件中

<cache/><!--当前配置文件中的所有select都会使用二级缓存-->

step3、对于不需要使用二级缓存的select，可以单独使用 useCache=“false” 关闭。

    <cache/>
    <select id="findAllUsers" resultType="user" useCache="false">
        select * from t_users
    </select>

引入外部的配置文件

step1、在resources目录下定义一个属性配置文件jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/数据库名，按实际情况填写
jdbc.username=root---用户名，按实际情况填写
jdbc.password=000---密码，按实际情况填写

step2、修改mybatis-config.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>
    <!--引入外部配置文件-->
    <properties resource="jdbc.properties"/>
    <environments default="dayu">
        <environment id="dayu">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                 <!--对应配置文件中的key-->
                <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>
   
    <settings>
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="lazyLoadTriggerMethods" value=""/>
        <setting name="cacheEnabled" value="true"/>
    </settings>
    
    <mappers>
        <package name="com.dayu.dao"/>
    </mappers>
</configuration>

在mybatis框架提供分页技术

(1)在pom.xml配置分页坐标信息

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

(2)在mybatis-config.xml文件配置分页插件

<configuration>	
    ...
<!-- 配置分页插件 -->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <!-- 分页参数合理化 -->
            <property name="reasonable" value="true" />
        </plugin>
    </plugins>
    ...
</configuration>

<settings>
    <setting name="lazyLoadingEnabled" value="true"/>
    <setting name="lazyLoadTriggerMethods" value=""/>
    <setting name="cacheEnabled" value="true"/>
</settings>

<mappers>
    <package name="com.dayu.dao"/>
</mappers>

```

在mybatis框架提供分页技术

(1)在pom.xml配置分页坐标信息

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

(2)在mybatis-config.xml文件配置分页插件

<configuration>	
    ...
<!-- 配置分页插件 -->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <!-- 分页参数合理化 -->
            <property name="reasonable" value="true" />
        </plugin>
    </plugins>
    ...
</configuration>