mybatis基础知识-03-C-2020-11-14

日志编号	说明
C-2020-11-14	第一次创建

mybatis缓存

缓存这个概念大家也比较熟悉，现在进行mybatis缓存的讲解。
在mybatis中，缓存分为了三类，分别是一级缓存，二级缓存和第三方缓存。

一级缓存

在mybatis中，一级缓存是默认开启的，它表示sqlSession级别的缓存，每次查询的时候会开启一个会话，此会话相当于一次连接，关闭之后自动失效。
在同一个会话之内，如果执行了多个相同的sql语句，那么除了第一个之外，所有的数据都是从缓存中进行查询的。
在某些情况下，一级缓存可能会失效？

• 在同一个方法中，可能会开启多个会话，此时需要注意，会话跟方法没有关系，不是一个方法就只能由一个会话，所以严格记住,缓存的数据是保存在sqlsession中的。
• 当传递对象的时候，如果对象中的属性值不同，也不会走缓存。
• 在多次查询过程中，如果修改了数据，那么缓存会失效。
• 如果在一个会话过程中，手动清空了缓存，那么缓存也会失效。

二级缓存

二级缓存表示的是全局缓存，必须要等到sqlsession关闭之后才会生效，也就是说，二级缓存的数据，是在一级缓存关闭的时候，把一级缓存的数据刷到二级缓存中。
在使用二级缓存的过程里，需要进行如下配置：

• 修改全局配置文件（mybatis-config.xml），在settings中添加配置：

<setting name="cacheEnabled" value="true"/>

• 指定在哪个映射文件中使用缓存的配置，例如要对UserDao.xml使用二级缓存，需要在UserDao.xml中添加如下的配置：

<cache></cache>

• 对应的java实体类必须要实现序列化的接口，即User类需要实现序列化接口。同时，如果包含了嵌套查询，则嵌套的类也需要实现序列化接口。

通过上面的配置之后，就可以使用mybatis的二级缓存。接着讲解一下配置在mapper中的cache元素的属性。
cache中包含了如下常用属性，每个属性的意义如下：
eviction:表示缓存回收策略，默认是LRU

• LRU：最近最少使用的，移除最长时间不被使用的对象。
• FIFO：先进先出，按照对象进入缓存的顺序来移除。
• SOFT：软引用，移除基于垃圾回收器状态和软引用规则的对象。
• WEAK：弱引用，更积极地移除基于垃圾收集器状态和弱引用规则的对象

flushInternal:刷新间隔，单位毫秒，默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新。

size：引用数目，正整数。代表缓存最多可以存储多少个对象，太大容易导致内存溢出。

readonly：只读，true/false。

• true：只读缓存，会给所有调用这返回缓存对象的相同实例，因此这些对象不能被修改。
• false：读写缓存，会返回缓存对象的拷贝（序列化实现），这种方式比较安全，默认值。

cache元素在不进行属性配置时，起到的作用如下：

• 映射语句文件中的所有 select 语句的结果将会被缓存。
• 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
• 缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
• 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
• 缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
• 缓存会被视为读/写缓存（false），这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

上面是cache中常用的基础属性，除过上面定义当前mapper二级缓存特性的之外，在增删改查的操作中，有一个配合使用的属性：flushCache。
在insert，update，delete这三个元素中，flushCache属性默认是true，也就是上面说的，当调用这三个语句之后，会刷新缓存。
在select元素中也有这个属性。默认是false。
在缓存开启的时候（不论是一级缓存，二级缓存，亦或者第三方缓存），可以通过特定语句上的flushCache属性去配置它对于缓存数据的影响。

第三方缓存

注意，在使用第三方缓存的时候，是通过在Mapper中cache元素的type属性进行定义。
在上面讲解cache属性的时候，还有一个我们会用到的属性没有讲解，就是type。
在某些情况下我们也可以自定义实现缓存，或为其他第三方缓存方案创建适配器，来完全覆盖缓存行为。当要自己实现缓存操作的时候，需要实现cache接口，并且在实现类中提供一个接受 String 参数作为 id 的构造器。当写好这个实现类之后，就可以把这个实现类的完全限定名作为type的值。
除了自己实现，还可以使用第三方工具作为缓存，这里通过ehcache举例。
首先，是引入pom信息。

<!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>3.8.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.2.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.0-alpha1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>2.0.0-alpha1</version>
    <scope>test</scope>
</dependency>

上面引入了ehcache的pom以及mybatis-ehcache。mybatis-ehcache可以在git中mybatis库里去看相应的配置解释。slf4j是ehcache需要用到的日志组件，因此也进行引入。

接下来是创建ehcache的配置文件编写 ehcache.xml：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
 <!-- 磁盘保存路径 -->
 <diskStore path="D:\ehcache" />
 
 <defaultCache 
   maxElementsInMemory="1" 
   maxElementsOnDisk="10000000"
   eternal="false" 
   overflowToDisk="true" 
   timeToIdleSeconds="120"
   timeToLiveSeconds="120" 
   diskExpiryThreadIntervalSeconds="120"
   memoryStoreEvictionPolicy="LRU">
 </defaultCache>
</ehcache>
 
<!-- 
属性说明：
diskStore：指定数据在磁盘中的存储位置。
defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略
 
以下属性是必须的：
maxElementsInMemory - 在内存中缓存的element的最大数目 
maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大
eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
 
以下属性是可选的：
timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
 diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区.
diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）
 -->

上述配置和详细的讲解，欢迎移步ehcache的相关介绍。（后续会把博文链接贴在这里）。

最后，就是在目标mapper中的cache元素上，添加对应的type属性，指明缓存用到的具体的类。

 <cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache>

这样，就完成了mybatis与第三方缓存工具的整合。

再次留意一下，因为这个type是cache的属性，而cache是编写在Mapper中的，也就是说，每个Mapper都可以通过自己的cache去指定自己的二级缓存行为。

ssm整合

在博客中已经写了spring，springmvc和mybatis，这三者构成了一个主流开发框架：SSM。现在说如何把这三个整合到一起。
创建好一个maven空工程之后，首先引入pom信息。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.phl</groupId>
    <artifactId>ssm_second</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

之后写各个组件的配置文件。
编写数据库连接配置和日志配置
db.properties

jdbc.username=XXXX
jdbc.password=XXXX
jdbc.driverName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3307/XXXX?serverTimezone=UTC

web.xml：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:application-context.xml</param-value>
    </context-param>
    <!--springmvc的核心配置类-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!--字符编码过滤器-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!--支持rest风格的过滤器-->
    <filter>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

springmvc配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/page/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
    <context:component-scan base-package="com.phl">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    <mvc:default-servlet-handler></mvc:default-servlet-handler>
    <mvc:annotation-driven></mvc:annotation-driven>
</beans>

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>
</configuration>

spring配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
    <context:component-scan base-package="com.phl">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="driverClassName" value="${jdbc.driverName}"></property>
        <property name="url" value="${jdbc.url}"></property>
    </bean>
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
    <!--mybatis 整合-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
        <property name="mapperLocations" value="classpath:com/phl/dao/impl/*.xml"></property>
    </bean>
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.phl.dao"></property>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>
</beans>

给出对应的Controller：

package com.phl.controller;

import com.phl.bean.User;
import com.phl.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class UserController {
    @Autowired
    private UserDao dao;

    @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
    public String getUser(Model model, @PathVariable("id") Integer id){
        User user = dao.searchUserById(id);
        model.addAttribute("msg",user.toString());
        return "view";
    }
}

上面就是整合SSM的过程。其中需要留意的两个点。

• 在web.xml中配置spring的监听

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:application-context.xml</param-value>
</context-param>

• 在整合的时候，需要将mybatis的sqlSessionFactory通过SqlSessionFactoryBean注入在spring IOC容器中。

<!--mybatis-->
<bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!--指定dataSource-->
    <property name="dataSource" ref="dataSource"></property>
    <!--指明mybatis配置文件位置-->
    <property name="configLocation" value="classpath:mybatis-config.xml"></property>
    <!--指明Mapper文件位置-->
    <property name="mapperLocations" value="classpath:com/phl/dao/impl/*.xml"></property>
</bean>
<!--扫描接口，并交给spring管理-->
<bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!--指明接口的位置-->
    <property name="basePackage" value="com.phl.dao"></property>
    <!--指明要使用的SQLSessionFactory的名字-->
    <property name="sqlSessionFactoryBeanName" value="sessionFactory"></property>
</bean>

mybatis-generator

mybatis-generator就是经常提到的逆向工程。
在之前的例子中，都是在有了数据表之后，自己创建Bean，Dao，编写对应mapper。逆向工程则是根据数据表，帮我们生成对应的Bean，Dao和mapper。当然，这个是否好用，不做过多评论，对于生成的代码，是否契合我们的需求，也不做过多评论。这里，只是讲解对应的工序。

在mybatis generator的官方文档下有详细的文档说明，这里的操作也是遵照文档中的顺序来进行的。mybatis-generator官方文档.

为了使用mybatis-generator，需要现在pom中引入对应的依赖。目前最新的版本是1.4.0

<!-- https://mvnrepository.com/artifact/org.mybatis.generator/mybatis-generator-core -->
<dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.4.0</version>
</dependency>

引入pom之后，编写mybatis-generator对应的配置文件。配置文件的内容，也可以从上面的官方文档里找到对应的内容，我这里选用的target是MyBatis3对应的模板。

<!DOCTYPE generatorConfiguration PUBLIC
        "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <context id="simple" targetRuntime="MyBatis3Simple">
        <!--注意，模板中是没有password和userId这两项的，需要手动添加-->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3307/panbase?serverTimezone=UTC"
                        password=""
                        userId=""
        />
        <!--生成对应的实体类
        targetPackage：指定生成java文件的目录
        targetProject：放在那个工程的哪个目录下
        -->
        <javaModelGenerator targetPackage="com.phl.ssm.bean" targetProject="src/main/java"/>
        <!--SQL映射文件生成器
        targetPackage：指定生成java文件的目录
        targetProject：放在那个工程的哪个目录下
        -->
        <sqlMapGenerator targetPackage="com.phl.ssm.dao" targetProject="src/main/resources"/>
        <!--dao接口生成器-->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.phl.ssm.dao" targetProject="src/main/java"/>

        <!--指定要逆向生成的数据表
        tableName:表名
        domainObjectName:对象名
        -->
        <table tableName="tbl_user" domainObjectName="User"/>
    </context>
</generatorConfiguration>

编写好这些之后，创建一个Java类，在里面通过main方法进行启动。

package com.phl.ssm.genarator;

import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class Test {

    public static void main(String[] args) throws Exception{
        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        File configFile = new File("mbg.xml");
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
        myBatisGenerator.generate(null);
    }
}

之后运行这个main方法。运行结束后，就能看到mybatis-generator帮我们生成的bean，dao，mapper了。
在使用mybatis-generator的时候，需要注意一下几个内容：

• 记得在pom里引入对应mybatis-generator的依赖。
• 编写generator对应的配置时，根据个人需求，去找需要的模板，并且根据自己的需求，更改里面的属性。

mybatis-plus

快速使用mybatis-plus

上面讲到了mybatis-generator，估计大家也试着用了一下。好不好用，结果是否友善不做过多评说，这里提出一个比mybatis-generator更好用的一个工具：mybatis-plus。不说别的，就冲着mybatis-plus是中国人写的，官网是中文，就已经比generator友善了一大截子了。mybatis-plus官网.
官网中有一个对mybatis-plus很契合的说明：
这里希望大家留意的一点，既然是1P，2P。那么不论mybatis-plus在具体编码中与mybatis有多大的差异，都是在对mybatis进行扩充和支持。他完全不影响我们按照习惯的mybatis操作去进行编码。
另外一点，因为我的博客还没写到springboot，所以即使mybatis-plus在官网的解释大多都是用springboot进行举例，我这里还是用ssm整合的形式进行讲解。
老规矩，在使用之前，永远都是先引入对应的pom信息。

<!-- https://mvnrepository.com/artifact/com.baomidou/mybatis-plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>3.4.1</version>
</dependency>

由于原本的项目是整合了SSM，此处为了使用mybatis-plus，最简单的一个更改就是这里，将原本引入的org.mybatis.spring.SqlSessionFactoryBean

<!--mybatis-->
<bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	<property name="dataSource" ref="dataSource"></property>
    <!--指明mybatis配置文件位置-->
    <property name="configLocation" value="mybatis-config.xml"></property>
    <!--指明Mapper文件位置-->
    <property name="mapperLocations" value="classpath:com/phl/ssm/dao/impl/*.xml"></property>
</bean>

更改为com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean：

<bean id="sessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
	<property name="dataSource" ref="dataSource"></property>
    <!--指明mybatis配置文件位置，如果没有，这个就省略了-->
    <property name="configLocation" value="mybatis-config.xml"></property>
    <!--指明Mapper文件位置，如果没有，这个就省略-->
    <property name="mapperLocations" value="classpath:com/phl/ssm/dao/impl/*.xml"></property>
</bean>

其实也很好理解，在之前单独使用mybatis的例子里，测试类中都会需要new一个sqlSessionFactory对象，在使用了spring之后，就是把他对应的Bean（这个是在pom中引用mybatis-spring）放置在IOC容器中进行管理。现在既然换成了mybatis-plus，则需要把对应的sqlSessionFactoryBean换成mybatis-plus里面的MybatisSqlSessionFactoryBean，感觉上就是切换了一个总体的入口，其他配置都没有什么更改，就可以使用mybatis-plus了。

有了配置之后，就可以进行使用了，这里给大家贴出来两个图。图一，是之前为了做SSM整合的时候，自己写的UserDao，图二是使用了mybatis-plus之后，写的UserPlusDao。
图二：
通过两个图的比对很容易发现其中的差距。
使用mybatis本身的时候，需要自己去写对应的接口，对应的Mapper。但是使用了mybatis-plus的话，定义好了接口之后，需要继承BaseMapper接口，并且制定好对应的泛型，然后我们就能看到很多基础方法继承自了BaseMapper。不需要再进行其他与dao相关的开发，就可以进行使用。
有人说了，如果使用了mybatis-generator会比这样更方便，不需要写bean，dao和mapper，但是对于mybatis-plus而言，他也有自己的代码生成器，并且不光是上面提到的三种，它还可以帮着生成service和controller等。

因为mybatis-plus是一个辅助工具，并且他的官网是中文的，这里不再做其他讲解。如果大家在使用中遇到了什么问题，可以留言。同时也非常推荐去看mybatis-plus的官网。因为这个是中国人做的，中国人写的，它的一切一切，都是那么符合中国人的习惯。牛逼。

最后提一句，在mybatis-plus一开始就提到的，1P，2P的比喻，不仅仅是比喻。上面我们只是说道了mybatis-plus给我们提供的便利，但是这种便利是有局限性的。比如说，关联查询，自定义结果集之类的。此时，你只需要按照原来使用mybatis的方式去使用mybatis-plus就行。类似这个UserPlusDao，虽然实现了接口BaseMapper，但是并不阻碍在他内部定义自己的方法，并且去写对应的Mapper，一切都是那么自然。