MyBatis学习总结（四）——MyBatis缓存与代码生成

 一、mybatis缓存

缓存可以提高系统性能，可以加快访问速度，减轻服务器压力，带来更好的用户体验。缓存用空间换时间，好的缓存是缓存命中率高的且数据量小的。缓存是一种非常重要的技术。

1.0、再次封装sqlsessionfactoryutils

为了配置缓存的学习我们将工具类再次封装。

原sqlsessionfactoryutil工具类如下：

package com.zhangguo.mybatis03.utils;

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;

/**
 * mybatis 会话工具类
 * */
public class sqlsessionfactoryutil {

    /**
     * 获得会话工厂
     *
     * */
    public static sqlsessionfactory getfactory(){
        inputstream inputstream = null;
        sqlsessionfactory sqlsessionfactory=null;
        try{
            //加载conf.xml配置文件，转换成输入流
            inputstream = sqlsessionfactoryutil.class.getclassloader().getresourceasstream("mybatiscfg.xml");

            //根据配置文件的输入流构造一个sql会话工厂
            sqlsessionfactory = new sqlsessionfactorybuilder().build(inputstream);
        }
        finally {
            if(inputstream!=null){
                try {
                    inputstream.close();
                } catch (ioexception e) {
                    e.printstacktrace();
                }
            }
        }
        return sqlsessionfactory;
    }

    /**
     * 获得sql会话，是否自动提交
     * */
    public static sqlsession opensession(boolean isautocommit){
        return getfactory().opensession(isautocommit);
    }

    /**
     * 关闭会话
     * */
    public static void closesession(sqlsession session){
        if(session!=null){
            session.close();
        }
    }

}

view code

上面的代码中当我们每次获取sqlsession时都要实例化sqlsessionfactory，效率不高。可以使用单例改进：

package com.zhangguo.mybatis03.utils;

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;

/**
 * mybatis会话工具类
 * */
public class sqlsessionfactoryutils {

    /**会话工厂*/
    private static sqlsessionfactory factory;

    static {
        try {
            /*获得配置文件的文件流*/
           inputstream inputstream=resources.getresourceasstream("mybatiscfg.xml");
           //初始化工厂
            factory=new sqlsessionfactorybuilder().build(inputstream);
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }

    /**
     * 获得会话对象
     * 指定是否自动提交
     * */
    public static sqlsession opensqlsession(boolean isautocommit){
        return getfactory().opensession(isautocommit);
    }

    public static sqlsessionfactory getfactory() {
        return factory;
    }
    public static void setfactory(sqlsessionfactory factory) {
        sqlsessionfactoryutils.factory = factory;
    }

    /**
     * 关闭会话
     * */
    public static void closesession(sqlsession session){
        if(session!=null){
            session.close();
        }
    }
}

1.1、mybatis缓存概要

在一个系统中查询的频次远远高于增删改，据三方统计不同系统比例在9:1-7:3之间。正如大多数持久层框架一样，mybatis 同样提供了一级缓存和二级缓存的支持

（1）、一级缓存基于perpetualcache 的 hashmap本地缓存，其存储作用域为 session，当 session flush 或 close 之后，该session中的所有 cache 就将清空。

（2）、二级缓存与一级缓存其机制相同，默认也是采用 perpetualcache，hashmap存储，不同在于其存储作用域为 mapper(namespace)，并且可自定义存储源，如 ehcache。

（3）、对于缓存数据更新机制，当某一个作用域(一级缓存session/二级缓存namespaces)的进行了 c/u/d 操作后，默认该作用域下所有 select 中的缓存将被clear。

1.2、默认mybatis的一级缓存是开启的

测试用例：

    /**缓存测试*/
    @test
    public void cachetest(){
        //打开一个会话，不自动提交
        sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
        //获得一个映射器
        studentmapper mapper1 = session1.getmapper(studentmapper.class);
        //查询单个对象通过编号
        student student1 = mapper1.selectstudentbyid(1);
        system.out.println(student1);
        
        student student2 = mapper1.selectstudentbyid(1);
        system.out.println(student2);
        //关闭
        sqlsessionfactoryutils.closesession(session1);
    }

结果：

虽然查询了二次，但只向数据库发送了一次sql请求，因为第二次是在缓存中获得的数据。

1.3、一级缓存仅在同一个会话（sqlsession）中有效

测试用例：

    /**缓存测试*/
    @test
    public void cachetest(){
        //打开一个会话1，不自动提交
        sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
        //获得一个映射器
        studentmapper mapper1 = session1.getmapper(studentmapper.class);
        //查询单个对象通过编号
        student student1 = mapper1.selectstudentbyid(1);
        system.out.println(student1);

        //打开一个会话2，不自动提交
        sqlsession session2 = sqlsessionfactoryutils.opensqlsession(false);
        //获得一个映射器
        studentmapper mapper2 = session2.getmapper(studentmapper.class);
        student student2 = mapper2.selectstudentbyid(1);
        system.out.println(student2);
        //关闭
        sqlsessionfactoryutils.closesession(session1);
    }

结果：

从上图可以看出此时并没有使用缓存，向数据库查询了二次，因为第二次查询使用的是新的会话，而一级缓存必须在同一个会话中。

1.4、清空一级缓存

（1）、当对表执行增删改时缓存将清空

测试用例：

    /**缓存测试*/
    @test
    public void cachetest(){
        //打开一个会话1，不自动提交
        sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
        //获得一个映射器
        studentmapper mapper1 = session1.getmapper(studentmapper.class);
        //查询单个对象通过编号
        student student1 = mapper1.selectstudentbyid(1);
        system.out.println(student1);

        //执行更新
        student lili=new student();
        lili.setid(5);
        lili.setsex("girl");
        mapper1.updatestudent(lili);

        student student2 = mapper1.selectstudentbyid(1);
        system.out.println(student2);

        sqlsessionfactoryutils.closesession(session1);
    }

结果：

从日志中可以看出第二次查询也发送了sql到数据库中，并没有使用缓存，是因为执行了更新操作缓存已被清空。

此时数据库中的数据其实并未真的更新，如下所示：

因为没有手动提交，可以设置自动提交

/**缓存测试*/
    @test
    public void cachetest(){
        //打开一个会话1，不自动提交
        sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
        //获得一个映射器
        studentmapper mapper1 = session1.getmapper(studentmapper.class);
        //查询单个对象通过编号
        student student1 = mapper1.selectstudentbyid(1);
        system.out.println(student1);

        //执行更新
        student lili=new student();
        lili.setid(5);
        lili.setsex("girl");
        mapper1.updatestudent(lili);

        student student2 = mapper1.selectstudentbyid(1);
        system.out.println(student2);

        //提交
        session1.commit();
        sqlsessionfactoryutils.closesession(session1);
    }

view code

提交后的结果

（2）、手动清空

测试用例：

   /**缓存测试*/
    @test
    public void cachetest(){
        //打开一个会话1，不自动提交
        sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
        //获得一个映射器
        studentmapper mapper1 = session1.getmapper(studentmapper.class);
        //查询单个对象通过编号
        student student1 = mapper1.selectstudentbyid(1);
        system.out.println(student1);

        //执行手动更新
        session1.clearcache();

        student student2 = mapper1.selectstudentbyid(1);
        system.out.println(student2);

        //提交
        session1.commit();
        sqlsessionfactoryutils.closesession(session1);
    }

结果：

从日志中可以看到第二次查询并未使用缓存因为执行了手动清空缓存，没有缓存可用则再次查询数据库。

小结：当session flush或close之后，该session中的所有 cache 就将清空；执行cud也将会自动清空；手动清空；

1.5、开启二级缓存

默认二级缓存是不开启的，需要手动进行配置：

1.5.1、全局开关

默认是true，如果它配成false，其余各个mapper xml文件配成支持cache也没用。

    <settings>
        <!--设置是否允许缓存-->
        <setting name="cacheenabled" value="true"/>
        <!--设置日志输出的目标-->
        <setting name="logimpl" value="stdout_logging"/>
    </settings>

1.5.2、单个mapper xml映射文件开关

默认mapper xml映射文件是不采用cache。在配置文件加一行就可以支持cache：

<?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">
<mapper namespace="com.zhangguo.mybatis03.dao.studentmapper">

    <cache/>
    
    <select id="selectstudentbyid" resulttype="student">
        select id,name,sex from student where id=#{id}
    </select>
    
</mapper>

可以在开启二级缓存时候，手动配置一些属性

<cache eviction="lru" flushinterval="100000" size="1024" readonly="true"/>

各个属性意义如下：

• eviction：缓存回收策略
  - lru：最少使用原则，移除最长时间不使用的对象
  - fifo：先进先出原则，按照对象进入缓存顺序进行回收
  - soft：软引用，移除基于垃圾回收器状态和软引用规则的对象
  - weak：弱引用，更积极的移除移除基于垃圾回收器状态和弱引用规则的对象
• flushinterval：刷新时间间隔，单位为毫秒，这里配置的100毫秒。如果不配置，那么只有在进行数据库修改操作才会被动刷新缓存区
• size：引用额数目，代表缓存最多可以存储的对象个数
• readonly：是否只读，如果为true，则所有相同的sql语句返回的是同一个对象（有助于提高性能，但并发操作同一条数据时，可能不安全），如果设置为false，则相同的sql，后面访问的是cache的clone副本。

1.5.3、mapper statement开关

mapper xml文件配置支持cache后，文件中所有的mapper statement就支持了。此时要个别对待某条，需要：

<select id="selectstudentbyid" resulttype="student" usecache="false">
    select id,name,sex from student where id=#{id}
</select>

可以在mapper的具体方法下设置对二级缓存的访问意愿：

• usecache配置

  ​ 如果一条语句每次都需要最新的数据，就意味着每次都需要从数据库中查询数据，可以把这个属性设置为false，如：

<select id="selectall" usecache="false">

• 刷新缓存（就是清空缓存）

  ​ 二级缓存默认会在insert、update、delete操作后刷新缓存，可以手动配置不更新缓存，如下：

<update id="updatebyid" flushcache="false" />

1.5.4、实现可序列化接口

 如果未实现可序列化接口，会引发异常。

修改pojo对象，增加实现可序列化接口：

package com.zhangguo.mybatis03.entities;

import java.io.serializable;

/**
 * 学生实体
 */
public class student implements serializable {
    private int id;
    private string name;
    private string sex;

    public int getid() {
        return id;
    }

    public void setid(int id) {
        this.id = id;
    }

    public string getname() {
        return name;
    }

    public void setname(string name) {
        this.name = name;
    }

    public string getsex() {
        return sex;
    }

    public void setsex(string sex) {
        this.sex = sex;
    }

    @override
    public string tostring() {
        return "student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

view code

1.5.5、注意事项

1、如果readonly为false，此时要结果集对象是可序列化的。

<cache readonly="false"/>

2、在sqlsession未关闭之前，如果对于同样条件进行重复查询，此时采用的是local session cache，而不是上面说的这些cache。

3、mybatis缓存查询到的结果集对象，而非结果集数据，是将映射的pojo对象集合缓存起来。

4、面对一定规模的数据量，内置的cache方式就派不上用场了;

5、对查询结果集做缓存并不是mybatis框架擅长的，它专心做的应该是sql mapper。采用此框架的application去构建缓存更合理，比如采用redis、ehcache、oscache、memcached等

当我们的配置文件配置了cacheenabled=true时，就会开启二级缓存，二级缓存是mapper级别的，也就说不同的sqlsession使用同一个mapper查询是，查询到的数据可能是另一个sqlsession做相同操作留下的缓存。

查询数据的顺序为：二级缓存 -> 一级缓存 -> 数据库

1.6、二级缓存测试

默认情况下一级缓存只在同一个会话中有效：

用例：

    /**缓存测试*/
    @test
    public void cachetest(){
        //打开一个会话1，不自动提交
        sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
        //获得一个映射器1
        studentmapper mapper1 = session1.getmapper(studentmapper.class);
        //查询单个对象通过编号
        student student1 = mapper1.selectstudentbyid(1);
        system.out.println(student1);
        
        //打开一个会话2，不自动提交
        sqlsession session2 = sqlsessionfactoryutils.opensqlsession(false);
        //获得一个映射器2
        studentmapper mapper2 = session2.getmapper(studentmapper.class);
        //查询单个对象通过编号
        student student2 = mapper2.selectstudentbyid(1);
        system.out.println(student2);

        sqlsessionfactoryutils.closesession(session1);
        sqlsessionfactoryutils.closesession(session2);
    }

结果：

如果需要将范围扩大到同一个namespace中有效可以使用二级缓存：

用例：

    /**缓存测试*/
    @test
    public void cachetest(){
        //打开一个会话1，不自动提交
        sqlsession session1 = sqlsessionfactoryutils.opensqlsession(false);
        //获得一个映射器1
        studentmapper mapper1 = session1.getmapper(studentmapper.class);
        //查询单个对象通过编号
        student student1 = mapper1.selectstudentbyid(1);
        system.out.println(student1);

        //必须手动提交，否则无效
        session1.commit();

        //打开一个会话2，不自动提交
        sqlsession session2 = sqlsessionfactoryutils.opensqlsession(false);
        //获得一个映射器2
        studentmapper mapper2 = session2.getmapper(studentmapper.class);
        //查询单个对象通过编号
        student student2 = mapper2.selectstudentbyid(1);
        system.out.println(student2);

        sqlsessionfactoryutils.closesession(session1);
        sqlsessionfactoryutils.closesession(session2);
    }

结果：

 

如果不手动提交查询结果也不会缓存成功。

使用两个不同的sqlsession对象去执行相同查询条件的查询，第二次查询时不会再发送sql语句，而是直接从缓存中取出数据

1.7、二级缓存小结

　　1. 映射语句文件中的所有select语句将会被缓存。

　　2. 映射语句文件中的所有insert，update和delete语句会刷新缓存。

　　3. 缓存会使用least recently used（lru，最近最少使用的）算法来收回。

　　4. 缓存会根据指定的时间间隔来刷新。

　　5. 缓存会存储1024个对象

cache标签常用属性：

<cache 
eviction="fifo"  <!--回收策略为先进先出-->
flushinterval="60000" <!--自动刷新时间60s-->
size="512" <!--最多缓存512个引用对象-->
readonly="true"/> <!--只读-->

二、mybatis-generator代码生成

2.1、在intellij idea创建maven项目

这里创建了一个maven项目，未使用骨架。

2.2、添加依赖

在maven项目的pom.xml 添加mybatis-generator-maven-plugin 插件

<?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.zhangguo.mybatis06</groupid>
    <artifactid>mybatis06</artifactid>
    <version>1.0-snapshot</version>

    <dependencies>
        <!--mybatis -->
        <dependency>
            <groupid>org.mybatis</groupid>
            <artifactid>mybatis</artifactid>
            <version>3.4.6</version>
        </dependency>
        <!--mysql数据库驱动 -->
        <dependency>
            <groupid>mysql</groupid>
            <artifactid>mysql-connector-java</artifactid>
            <version>5.1.38</version>
        </dependency>
        <!-- junit单元测试工具 -->
        <dependency>
            <groupid>junit</groupid>
            <artifactid>junit</artifactid>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!-- mybatis-generator-core 反向生成java代码-->
        <dependency>
            <groupid>org.mybatis.generator</groupid>
            <artifactid>mybatis-generator-core</artifactid>
            <version>1.3.5</version>
        </dependency>
    </dependencies>


    <!--mybatis 代码生成插件-->
    <build>
        <finalname>mybatis06</finalname>
        <plugins>
            <plugin>
                <groupid>org.mybatis.generator</groupid>
                <artifactid>mybatis-generator-maven-plugin</artifactid>
                <version>1.3.2</version>
                <configuration>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2.3、配置生成参数

在maven项目下的src/main/resources 目录下建立名为 generatorconfig.xml的配置文件，作为mybatis-generator-maven-plugin 插件的执行目标：

<?xml version="1.0" encoding="utf-8"?>
<!doctype generatorconfiguration
        public "-//mybatis.org//dtd mybatis generator configuration 1.0//en"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorconfiguration>

    <!--导入属性配置 -->
    <properties resource="db.properties"></properties>

    <!--指定特定数据库的jdbc驱动jar包的位置 -->
    <classpathentry location="${mysql.driverlocation}"/>

    <context id="default" targetruntime="mybatis3">

        <!-- optional，旨在创建class时，对注释进行控制 -->
        <commentgenerator>
            <property name="suppressdate" value="true" />
        </commentgenerator>

        <!--jdbc的数据库连接 -->
        <jdbcconnection driverclass="${mysql.driver}" connectionurl="${mysql.url}" userid="${mysql.username}" password="${mysql.password}">
        </jdbcconnection>

        <!-- 非必需，类型处理器，在数据库类型和java类型之间的转换控制-->
        <javatyperesolver >
            <property name="forcebigdecimals" value="false" />
        </javatyperesolver>

        <!-- model模型生成器,用来生成含有主键key的类，记录类 以及查询example类
            targetpackage     指定生成的model生成所在的包名
            targetproject     指定在该项目下所在的路径
        -->
        <javamodelgenerator targetpackage="com.zhangguo.mybatis06.entities" targetproject="src/main/java">
            <!-- 是否对model添加 构造函数 -->
            <property name="constructorbased" value="true"/>

            <!-- 是否允许子包，即targetpackage.schemaname.tablename -->
            <property name="enablesubpackages" value="false"/>

            <!-- 建立的model对象是否 不可改变  即生成的model对象不会有 setter方法，只有构造方法 -->
            <property name="immutable" value="true"/>

            <!-- 给model添加一个父类 -->
            <property name="rootclass" value="com.zhangguo.mybatis06.entities.baseentity"/>

            <!-- 是否对类char类型的列的数据进行trim操作 -->
            <property name="trimstrings" value="true"/>
        </javamodelgenerator>

        <!--mapper映射文件生成所在的目录 为每一个数据库的表生成对应的sqlmap文件 -->
        <sqlmapgenerator targetpackage="com.zhangguo.mybatis06.mapper" targetproject="src/main/resources">
            <property name="enablesubpackages" value="false"/>
        </sqlmapgenerator>


        <!-- 客户端代码，生成易于使用的针对model对象和xml配置文件 的代码
                type="annotatedmapper",生成java model 和基于注解的mapper对象
                type="mixedmapper",生成基于注解的java model 和相应的mapper对象
                type="xmlmapper",生成sqlmap xml文件和独立的mapper接口
        -->
        <javaclientgenerator targetpackage="com.zhangguo.mybatis06.dao" targetproject="src/main/java" type="mixedmapper">
            <property name="enablesubpackages" value=""/>
            <!--
                    定义maper.java 源代码中的byexample() 方法的可视性，可选的值有：
                    public;
                    private;
                    protected;
                    default
                    注意：如果 targetruntime="mybatis3",此参数被忽略
             -->
            <property name="examplemethodvisibility" value=""/>
            <!--
               方法名计数器
              important note: this property is ignored if the target runtime is mybatis3.
             -->
            <property name="methodnamecalculator" value=""/>

            <!--
              为生成的接口添加父接口
             -->
            <property name="rootinterface" value=""/>
        </javaclientgenerator>



        <table tablename="student" schema="nfmall"></table>
        <table tablename="category" schema="nfmall"></table>
        <table tablename="goods" schema="nfmall"></table>
    </context>
</generatorconfiguration>

这里的属性资源文件与mybatis共用db.propities文件

##mysql连接字符串
#驱动
mysql.driver=com.mysql.jdbc.driver
#地址
mysql.url=jdbc:mysql://127.0.0.1:3306/nfmall?useunicode=true&characterencoding=utf-8
#用户名
mysql.username=root
#密码
mysql.password=uchr@123
#驱动位置
mysql.driverlocation=e:\\nf\\java\\jdbc\\mysql-connector-java-5.1.47\\mysql-connector-java-5.1.47.jar

参数配置文件一：

<?xml version="1.0" encoding="utf-8" ?>
<!doctype generatorconfiguration public
        "-//mybatis.org//dtd mybatis generator configuration 1.0//en"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >
<generatorconfiguration>

    <!-- 本地数据库驱动程序jar包的全路径 -->
    <classpathentry location=""/>

    <context id="context" targetruntime="mybatis3">
        <commentgenerator>
            <property name="suppressallcomments" value="false"/>
            <property name="suppressdate" value="true"/>
        </commentgenerator>

        <!-- 数据库的相关配置 -->
        <jdbcconnection driverclass="" connectionurl="" userid="" password=""/>

        <javatyperesolver>
            <property name="forcebigdecimals" value="false"/>
        </javatyperesolver>

        <!-- 实体类生成的位置 -->
        <javamodelgenerator targetpackage="目标包" targetproject="目标项目classpath">
            <property name="enablesubpackages" value="false"/>
            <property name="trimstrings" value="true"/>
        </javamodelgenerator>

        <!-- *mapper.xml 文件的位置 -->
        <sqlmapgenerator targetpackage="目标包" targetproject="目标项目classpath">
            <property name="enablesubpackages" value="false"/>
        </sqlmapgenerator>

        <!-- mapper 接口文件的位置 -->
        <javaclientgenerator targetpackage="目标包" targetproject="目标项目classpath" type="xmlmapper">
            <property name="enablesubpackages" value="false"/>
        </javaclientgenerator>

        <!-- 相关表的配置 -->
        <table tablename="表名" enablecountbyexample="false" enabledeletebyexample="false" enableselectbyexample="false"
               enableupdatebyexample="false"/>
    </context>
</generatorconfiguration>

view code

参考配置文件二：

<?xml version="1.0" encoding="utf-8"?>  
<!doctype generatorconfiguration  
        public "-//mybatis.org//dtd mybatis generator configuration 1.0//en"  
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">  
<generatorconfiguration>  
    <!--导入属性配置 -->  
    <properties resource="generator.properties"></properties>  
  
    <!--指定特定数据库的jdbc驱动jar包的位置 -->  
    <classpathentry location="${jdbc.driverlocation}"/>  
  
    <context id="default" targetruntime="mybatis3">  
  
  
        <!-- optional，旨在创建class时，对注释进行控制 -->  
        <commentgenerator>  
            <property name="suppressdate" value="true" />  
        </commentgenerator>  
  
  
        <!--jdbc的数据库连接 -->  
        <jdbcconnection driverclass="${jdbc.driverclass}" connectionurl="${jdbc.connectionurl}" userid="${jdbc.userid}" password="${jdbc.password}">  
        </jdbcconnection>  
  
  
  
        <!-- 非必需，类型处理器，在数据库类型和java类型之间的转换控制-->  
        <javatyperesolver >  
            <property name="forcebigdecimals" value="false" />  
        </javatyperesolver>  
  
        <!-- model模型生成器,用来生成含有主键key的类，记录类 以及查询example类  
            targetpackage     指定生成的model生成所在的包名  
            targetproject     指定在该项目下所在的路径  
        -->  
        <javamodelgenerator targetpackage="org.louis.hometutor.po" targetproject="src/main/java">  
            <!-- 是否对model添加 构造函数 -->  
            <property name="constructorbased" value="true"/>  
  
            <!-- 是否允许子包，即targetpackage.schemaname.tablename -->  
            <property name="enablesubpackages" value="false"/>  
  
            <!-- 建立的model对象是否 不可改变  即生成的model对象不会有 setter方法，只有构造方法 -->  
            <property name="immutable" value="true"/>  
  
            <!-- 给model添加一个父类 -->  
            <property name="rootclass" value="com.foo.louis.hello"/>  
  
            <!-- 是否对类char类型的列的数据进行trim操作 -->  
            <property name="trimstrings" value="true"/>  
        </javamodelgenerator>  
  
        <!--mapper映射文件生成所在的目录 为每一个数据库的表生成对应的sqlmap文件 -->  
        <sqlmapgenerator targetpackage="org.louis.hometutor.domain" targetproject="src/main/java">  
            <property name="enablesubpackages" value="false"/>  
        </sqlmapgenerator>  
  
  
        <!-- 客户端代码，生成易于使用的针对model对象和xml配置文件 的代码  
                type="annotatedmapper",生成java model 和基于注解的mapper对象  
                type="mixedmapper",生成基于注解的java model 和相应的mapper对象  
                type="xmlmapper",生成sqlmap xml文件和独立的mapper接口  
        -->  
        <javaclientgenerator targetpackage="com.foo.tourist.dao" targetproject="src/main/java" type="mixedmapper">  
            <property name="enablesubpackages" value=""/>  
            <!--  
                    定义maper.java 源代码中的byexample() 方法的可视性，可选的值有：  
                    public;  
                    private;  
                    protected;  
                    default  
                    注意：如果 targetruntime="mybatis3",此参数被忽略  
             -->  
            <property name="examplemethodvisibility" value=""/>  
            <!--  
                                           方法名计数器  
              important note: this property is ignored if the target runtime is mybatis3.  
             -->  
            <property name="methodnamecalculator" value=""/>  
  
            <!-- 
                                                为生成的接口添加父接口 
             -->  
            <property name="rootinterface" value=""/>  
  
        </javaclientgenerator>  
  
  
  
        <table tablename="lession" schema="louis">  
  
            <!-- optional   , only for mybatis3 runtime  
                 自动生成的键值（identity,或者序列值）  
               如果指定此元素，mbg将会生成<selectkey>元素，然后将此元素插入到sql map的<insert> 元素之中  
               sqlstatement 的语句将会返回新的值  
               如果是一个自增主键的话，你可以使用预定义的语句,或者添加自定义的sql语句. 预定义的值如下:  
                  cloudscape    this will translate to: values identity_val_local()  
                  db2:      values identity_val_local()  
                  db2_mf:       select identity_val_local() from sysibm.sysdummy1  
                  derby:        values identity_val_local()  
                  hsqldb:   call identity()  
                  informix:     select dbinfo('sqlca.sqlerrd1') from systables where tabid=1  
                  mysql:        select last_insert_id()  
                  sqlserver:    select scope_identity()  
                  sybase:   select @@identity  
                  jdbc:     this will configure mbg to generate code for mybatis3 suport of jdbc standard generated keys. 
this is a database independent method of obtaining the value from identity columns.  
                  identity: 自增主键  if true, then the column is flagged as an identity column and the generated <selectkey> 
element will be placed after the insert (for an identity column). if false, then the generated <selectkey> will be placed before
 the insert (typically for a sequence).  
  
            -->  
            <generatedkey column="" sqlstatement="" identity="" type=""/>  
  
  
            <!-- optional.  
                    列的命名规则：  
                    mbg使用 <columnrenamingrule> 元素在计算列名的对应 名称之前，先对列名进行重命名，  
                    作用：一般需要对busi_client_no 前的busi_进行过滤  
                    支持正在表达式  
                     searchstring 表示要被换掉的字符串  
                     replacestring 则是要换成的字符串，默认情况下为空字符串，可选  
            -->  
            <columnrenamingrule searchstring="" replacestring=""/>  
  
  
  
            <!-- optional.告诉 mbg 忽略某一列  
                    column，需要忽略的列  
                    delimitedcolumnname:true ,匹配column的值和数据库列的名称 大小写完全匹配，false 忽略大小写匹配  
                    是否限定表的列名，即固定表列在model中的名称  
            -->  
            <ignorecolumn column="plan_id"  delimitedcolumnname="true" />  
  
  
            <!--optional.覆盖mbg对model 的生成规则  
                 column: 数据库的列名  
                 javatype: 对应的java数据类型的完全限定名  
                 在必要的时候可以覆盖由javatyperesolver计算得到的java数据类型. for some databases, this is necessary to handle "odd" 
database types (e.g. mysql's unsigned bigint type should be mapped to java.lang.object).  
                 jdbctype:该列的jdbc数据类型(integer, decimal, numeric, varchar, etc.)，该列可以覆盖由javatyperesolver计算得到的jdbc类型，
对某些数据库而言，对于处理特定的jdbc 驱动癖好 很有必要(e.g. db2's longvarchar type should be mapped to varchar for ibatis).  
                 typehandler:  
  
            -->  
            <columnoverride column="" javatype=""    jdbctype="" typehandler=""  delimitedcolumnname="" />  
  
        </table>  
    </context>  
</generatorconfiguration>  

view code

属性资源文件：

jdbc.driverlocation=e:\\nf\\java\\jdbc\\mysql-connector-java-5.1.47\\mysql-connector-java-5.1.47.jar
jdbc.driverclass=com.mysql.jdbc.driver
jdbc.connectionurl=jdbc:mysql://127.0.0.1:3306/nfmall?useunicode=true&characterencoding=utf-8
jdbc.userid=root
jdbc.password=uchr@123

view code

这里使用了外置的配置文件generator.properties，可以将一下属性配置到properties文件之中，增加配置的灵活性：

项目目录如下：

2.4、执行生成

在maven projects中找到plugins->mybatis-generator->mybatis-generator:generate

点击运行，然后不出意外的话，会在控制台输出：

[info] scanning for projects...
[info]                                                                         
[info] ------------------------------------------------------------------------
[info] building mybatis06 1.0-snapshot
[info] ------------------------------------------------------------------------
[info] 
[info] --- mybatis-generator-maven-plugin:1.3.2:generate (default-cli) @ mybatis06 ---
[info] connecting to the database
[info] introspecting table nfmall.student
log4j:warn no appenders could be found for logger (org.mybatis.generator.internal.db.databaseintrospector).
log4j:warn please initialize the log4j system properly.
log4j:warn see http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
[info] introspecting table nfmall.category
[info] introspecting table nfmall.goods
[info] generating example class for table student
[info] generating record class for table student
[info] generating mapper interface for table student
[info] generating sql map for table student
[info] generating example class for table category
[info] generating record class for table category
[info] generating mapper interface for table category
[info] generating sql map for table category
[info] generating example class for table goods
[info] generating record class for table goods
[info] generating mapper interface for table goods
[info] generating sql map for table goods
[info] saving file studentmapper.xml
[info] saving file categorymapper.xml
[info] saving file goodsmapper.xml
[info] saving file studentexample.java
[info] saving file student.java
[info] saving file studentmapper.java
[info] saving file categoryexample.java
[info] saving file category.java
[info] saving file categorymapper.java
[info] saving file goodsexample.java
[info] saving file goods.java
[info] saving file goodsmapper.java
[warning] root class com.zhangguo.mybatis06.entities.baseentity cannot be loaded, checking for member overrides is disabled for this class 
[info] ------------------------------------------------------------------------
[info] build success
[info] ------------------------------------------------------------------------
[info] total time: 1.845 s
[info] finished at: 2018-10-10t09:51:45+08:00
[info] final memory: 11m/162m
[info] ------------------------------------------------------------------------

view code

看到build success，则大功告成，如果有错误的话，由于添加了-e 选项，会把具体的详细错误信息打印出来的，根据错误信息修改即可。

生成结果：

2.5、使用生成的代码

1、mybatis会话工具类

package com.zhangguo.mybatis06.utils;

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;

/**
 * mybatis会话工具类
 * */
public class sqlsessionfactoryutils {

    /**会话工厂*/
    private static sqlsessionfactory factory;

    static {
        try {
            /*获得配置文件的文件流*/
           inputstream inputstream=resources.getresourceasstream("mybatiscfg.xml");
           //初始化工厂
            factory=new sqlsessionfactorybuilder().build(inputstream);
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }

    /**
     * 获得会话对象
     * 指定是否自动提交
     * */
    public static sqlsession opensqlsession(boolean isautocommit){
        return getfactory().opensession(isautocommit);
    }

    public static sqlsessionfactory getfactory() {
        return factory;
    }
    public static void setfactory(sqlsessionfactory factory) {
        sqlsessionfactoryutils.factory = factory;
    }

    /**
     * 关闭会话
     * */
    public static void closesession(sqlsession session){
        if(session!=null){
            session.close();
        }
    }
}

view code

2、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>
    <!--导入db.properties文件中的所有key-value数据-->
    <!--外部引入的内容将覆盖内部定义的-->
    <properties resource="db.properties">
        <!--定义一个名称为driver，值为com.mysql.jdbc.driver的属性-->
        <property name="mysql.driver" value="com.mysql.jdbc.driver"></property>
    </properties>

    <settings>
        <!--设置是否允许缓存-->
        <setting name="cacheenabled" value="true"/>
        <!--设置日志输出的目标-->
        <setting name="logimpl" value="stdout_logging"/>
    </settings>

    <!--别名-->
    <typealiases>
        <!--定义单个别名，指定名称为student，对应的类型为com.zhangguo.mybatis02.entities.student-->
        <!--<typealias type="com.zhangguo.mybatis02.entities.student" alias="student"></typealias>-->
        <!--指定包名下所有的类被自动扫描并定义默认别名，
        mybatis会自动扫描包中的pojo类，自动定义别名，别名就是类名(首字母大写或小写都可以)-->
        <package name="com.zhangguo.mybatis03.entities"></package>
    </typealiases>

    <!--注册自定义的类型处理器-->
    <typehandlers>
        <!--<typehandler handler="" javatype="" jdbctype=""></typehandler>-->
    </typehandlers>

    <!--环境配置，default为默认选择的环境-->
    <environments default="development">
        <!--开发-->
        <environment id="development">
            <!--事务管理-->
            <transactionmanager type="jdbc"/>
            <!--连接池-->
            <datasource type="pooled">
                <!--引用属性${mysql.driver}-->
                <property name="driver" value="${mysql.driver}"/>
                <property name="url" value="${mysql.url}"/>
                <property name="username" value="${mysql.username}"/>
                <property name="password" value="${mysql.password}"/>
            </datasource>
        </environment>
        <!--运行-->
        <environment id="work">
            <transactionmanager type="jdbc"/>
            <datasource type="pooled">
                <property name="driver" value="${driver}"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/nfmall?useunicode=true&amp;characterencoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="uchr@123"/>
            </datasource>
        </environment>
    </environments>

    <mappers>
        <!--根据路径注册一个基于xml的映射器-->
        <mapper resource="com/zhangguo/mybatis06/mapper/studentmapper.xml"/>

    </mappers>

</configuration>

view code

3、测试用例

package test;

import com.zhangguo.mybatis06.dao.studentmapper;
import com.zhangguo.mybatis06.entities.student;
import com.zhangguo.mybatis06.entities.studentexample;
import com.zhangguo.mybatis06.utils.sqlsessionfactoryutils;
import org.apache.ibatis.session.sqlsession;
import org.junit.test;

import java.util.list;

public class studenttest {
    /***
     * list<student> selectbyexample(studentexample example);
     */
    @test
    public void testselectbyexample(){

        list<student> entities = null;
        //打开一个会话
        sqlsession session = sqlsessionfactoryutils.opensqlsession(true);

        //获得一个映射器
        studentmapper mapper = session.getmapper(studentmapper.class);

        studentexample studentexample=new studentexample();
        //查询名字中含a
        studentexample.createcriteria().andnamelike("%a%");

        //查询多个对象，指定参数
        entities = mapper.selectbyexample(studentexample);
        //关闭
        sqlsessionfactoryutils.closesession(session);

    }

}

测试结果：

三、mybatis-gui代码生成器mybatis-generator-gui

3.1、概要

源码地址：

mybatis-generator-gui是基于开发一款界面工具, 本工具可以使你非常容易及快速生成mybatis的java pojo文件及数据库mapping文件。

3.2、核心特性

• 按照界面步骤轻松生成代码，省去xml繁琐的学习与配置过程
• 保存数据库连接与generator配置，每次代码生成轻松搞定
• 内置常用插件，比如分页插件
• 把数据库中表列的注释生成为java实体的注释，生成的实体清晰明了
• 可选的去除掉对版本管理不友好的注释，这样新增或删除字段重新生成的文件比较过来清楚
• 目前已经支持mysql、mysql8、oracle、postgresql与sql server，暂不对其他非主流数据库提供支持。

3.3、要求

本工具由于使用了java 8的众多特性，所以要求jdk 1.8.0.60以上版本，另外jdk 1.9暂时还不支持。

3.4、下载

你可以从本链接下载本工具: 

3.5、启动本软件

• 方法一: 自助构建（注意项目名称需要根据实例情况修改）

    git clone https://github.com/astarring/mybatis-generator-gui
    cd mybatis-generator-gui
    mvn jfx:jar
    cd target/jfx/app/
    java -jar mybatis-generator-gui.jar

 

• 方法二: ide中运行

eclipse or intellij idea中启动, 找到com.zzg.mybatis.generator.mainui类并运行就可以了

• 方法三：打包为本地原生应用，双击快捷方式即可启动，方便快捷

  如果不想打包后的安装包logo为java的灰色的茶杯，需要在pom文件里将对应操作系统平台的图标注释放开

    #<icon>${project.basedir}/package/windows/mybatis-generator-gui.ico</icon>为windows
    #<icon>${project.basedir}/package/macosx/mybatis-generator-gui.icns</icon>为mac
    mvn jfx:native

 

​ 另外需要注意，windows系统打包成exe的话需要安装wixtoolset3+的环境；由于打包后会把jre打入安装包，两个平台均100m左右，体积较大请自行打包；打包后的安装包在target/jfx/native目录下

3.6、注意事项

• 本自动生成代码工具只适合生成单表的增删改查，对于需要做数据库联合查询的，请自行写新的xml与mapper；
• 部分系统在中文输入方法时输入框中无法输入文字，请切换成英文输入法；
• 如果不明白对应字段或选项是什么意思的时候，把光标放在对应字段或label上停留一会然后如果有解释会出现解释；

3.7、文档

更多详细文档请参考本库的wiki

• usage

3.8、代码生成示例

3.8.1、创建一个maven项目

3.8.2、下载源代码并使用idea打开

下载地址：

解压后引入到idea中

找到mainui类

3.8.3、运行程序

3.8.4、连接到数据

 

3.8.5、生成代码

3.8.6、使用生成的代码

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.zhangguo.mybatis05</groupid>
    <artifactid>mybatis05</artifactid>
    <version>1.0-snapshot</version>

    <dependencies>
        <!--mybatis -->
        <dependency>
            <groupid>org.mybatis</groupid>
            <artifactid>mybatis</artifactid>
            <version>3.4.6</version>
        </dependency>
        <!--mysql数据库驱动 -->
        <dependency>
            <groupid>mysql</groupid>
            <artifactid>mysql-connector-java</artifactid>
            <version>5.1.38</version>
        </dependency>
        <!-- junit单元测试工具 -->
        <dependency>
            <groupid>junit</groupid>
            <artifactid>junit</artifactid>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

工具类：

package com.zhangguo.mybatis05.utils;

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;

/**
 * mybatis会话工具类
 * */
public class sqlsessionfactoryutils {

    /**会话工厂*/
    private static sqlsessionfactory factory;

    static {
        try {
            /*获得配置文件的文件流*/
           inputstream inputstream=resources.getresourceasstream("mybatiscfg.xml");
           //初始化工厂
            factory=new sqlsessionfactorybuilder().build(inputstream);
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }

    /**
     * 获得会话对象
     * 指定是否自动提交
     * */
    public static sqlsession opensqlsession(boolean isautocommit){
        return getfactory().opensession(isautocommit);
    }

    public static sqlsessionfactory getfactory() {
        return factory;
    }
    public static void setfactory(sqlsessionfactory factory) {
        sqlsessionfactoryutils.factory = factory;
    }

    /**
     * 关闭会话
     * */
    public static void closesession(sqlsession session){
        if(session!=null){
            session.close();
        }
    }
}

核心配置文件：

<?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>
    <!--导入db.properties文件中的所有key-value数据-->
    <!--外部引入的内容将覆盖内部定义的-->
    <properties resource="db.properties">
        <!--定义一个名称为driver，值为com.mysql.jdbc.driver的属性-->
        <property name="mysql.driver" value="com.mysql.jdbc.driver"></property>
    </properties>

    <settings>
        <!--设置是否允许缓存-->
        <setting name="cacheenabled" value="true"/

                    
                

赞 (0)

打赏 微信扫一扫

相关文章:

• 

  configSections必须是根节点下第一个节点

  对webconfig文档进行配置，添加了一个节点configSectionS，添加时，我自个想，按节点的名称以字母排序，就放在appSettings... [阅读全文]
• 

  c/c++ llinux epoll系列4 利用epoll_wait实现非阻塞的connect

  llinux epoll系列4 利用epoll_wait实现非阻塞的connect connect函数是阻塞的，而且不能设置connect函数的ti... [阅读全文]
• 

  WordCount统计文档字符数，单词数，行数

  一、项目简介 源码地址：https://gitee.com/jie140367/WordCount2 作业地址：https://edu.cnblog... [阅读全文]
• 

  cf1072B. Curiosity Has No Limits(枚举)

  题意 "题目链接" 给出两个序列$a, b$，求出一个序列$t$，满足 $$a_i = t_i | t_{i + 1}$$ $$b_i = t_i ... [阅读全文]
• 

  液冷散热? 新一代黑鲨游戏手机强悍配置曝光

  液冷散热? 新一代黑鲨游戏手机强悍配置曝光　　新酷产品第一时间免费试玩，还有众多优质达人分享独到生活经验，快来新浪众测，体验各领域最前沿、最有... [阅读全文]

版权声明：本文内容由互联网用户贡献，该文观点仅代表作者本人。本站仅提供信息存储服务，不拥有所有权，不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 [e-mail] 举报，一经查实将立刻删除。

发表评论

验证码：