如果您想了解第一个Mybatis程序的相关知识，那么本文是一篇不可错过的文章，我们将对mybatisthen进行全面详尽的解释，并且为您提供关于01_mybatis第一个应用程序、java-mybai

如果您想了解第一个Mybatis程序的相关知识，那么本文是一篇不可错过的文章，我们将对mybatis then进行全面详尽的解释，并且为您提供关于01_mybatis 第一个应用程序、java-mybaits-015-mybatis逆向工程最佳实践【基础mybatis-generator、tk.mybatis、mubatis-plus】、Mybaits 源码解析 （一）----- 搭建一个mybatis框架（MyBatis HelloWorld）、MyBatis 学习之路其一：使用mybatis 创建一个简单的程序的有价值的信息。

• 第一个Mybatis程序（mybatis then）
• 01_mybatis 第一个应用程序
• java-mybaits-015-mybatis逆向工程最佳实践【基础mybatis-generator、tk.mybatis、mubatis-plus】
• Mybaits 源码解析 （一）----- 搭建一个mybatis框架（MyBatis HelloWorld）
• MyBatis 学习之路其一：使用mybatis 创建一个简单的程序

第一个Mybatis程序（mybatis then）

1.第一个Mybatis程序

思路：搭建环境——》导入Mybatis——》编写代码——》测试

1.1搭建环境

搭建数据库

CREATE DATABASE `mybatis`;

USE `mybatis`;

CREATE TABLE `user`(
`id` INT(20) NOT NULL PRIMARY KEY,
`name` VARCHAR(30) DEFAULT NULL,
`pwd` VARCHAR(30) DEFAULT NULL
 )ENGINE=INNODB DEFAULT CHARSET=utf8;
 
 INSERT INTO `user`(`id`,`name`,`pwd`) VALUES
(1,'卷心菜','123456'),
(2,'厉哥','123456'),
(3,'苗姐','123456')

新建项目

创建一个普通的maven项目

检查maven版本是否是自己的

然后删除src

导入jar包【MysqL，mybaits，junit】

<!--导入依赖-->
<dependencies>
<!--    MysqL驱动-->
    <dependency>
        <groupId>MysqL</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.21</version>
    </dependency>
<!--    mybatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
<!--    junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

1.2创建一个模块

其实就是在这个基础上再创建一个子项目，这样子就可以复用父工程的jar包

1.编写mybatis核心配置文件

在resources下创建一个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>
<!--    配置环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.MysqL.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:MysqL://localhost:3306/mybatis?useRSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

2.编写mybatis工具类

/**
 * 第一步:把资源加载进来
 * 第二步:创建一个能够执行sql的对象
 */
public class MybatisUtils {
    public static sqlSessionFactory sqlSessionFactory=null;
    static {
        try {//使用mybatis获取sqlSessionFactory对象[三行必写代码]
            String resource = "mybatis-config.xml";//读取资源文件
            InputStream inputStream = Resources.getResourceAsstream(resource);
            sqlSessionFactory = new sqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printstacktrace();
        }
    }
    //    既然有了sqlSessionFactory，顾名思义，我们就可以从中获得sqlSession实例了
//   sqlSession 完全包含了面向库执行 sql 命令所需的所有方法
    public static sqlSession getsqlSession() {
        sqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
    }
}

1.3编写代码

• 实体类【与数据库一 一对应】

public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    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 getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

• Dao接口【以后可能用Mapp代替，就是换个名字】

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

• 实现接口类【我们利用一个xml文件代替】UserMapper.xml

<?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.Jacob.dao.UserDao">
<!-- namespace与哪个接口绑定 -- !>
<mapper namespace="com.Jacob.dao.UserDao">
<!--    select查询语句
id对应接口的方法名[类似之前需要实现接口]
resultType返回结果集类型[需要通包找]
-->
    <select id="getUserList"  resultType="com.Jacob.pojo.User">
        select * from USER;
    </select>
</mapper>

1.4测试

注意点

org.apache.ibatis.binding.BindingException: Type interface com.Jacob.dao.UserDao is not kNown to the MapperRegistry.

MapperRegistry是什么？

解决方案:在mybatis-config.xml里面记得加上

 <!--    每一个mapper.xml都需要在mybatis核心配置文件中注册-->
<mappers>
        <mapper resource="com/Jacob/dao/UserMapper.xml"/>
    </mappers>

还可能出现UserMapper.xml不存在的异常，所以我们需要在pom.xml加上【保险起见父子工程的pom都加上】以后记得一开始就做

 <!--    在build中配置resources ， 来防止我们资源导出失败的问题-->
<build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

public class UserDaoTest {
    @Test
    public void test(){
        //获得sqlSession对象
        sqlSession sqlSession = MybatisUtils.getsqlSession();
        //执行sql
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
//关闭sqlsession
        sqlSession.close();

    }
}
//结果
User{id=1, name='卷心菜', pwd='123456'}
User{id=2, name='厉哥', pwd='123456'}
User{id=3, name='苗姐', pwd='123456'}

流程

01_mybatis 第一个应用程序

1、mybatis 简介

　　a):MyBatis 本是 apache 的一个开源项目 iBatis, 2010 年这个项目由 apache software foundation 迁移到了 google code，并且改名为 MyBatis 。2013 年 11 月迁移到 Github。

　　c): 每个 MyBatis 应用程序主要都是使用 Sql SessionFactory 实例的，一个 SqlSessionFactory 实例可以通过 SqlSessionFactoryBuilder 获得。SqlSessionFactoryBuilder 可以从一个 xml 配置文件或者一个预定义的配置类的实例获得。

用 xml 文件构建 SqlSessionFactory 实例是非常简单的事情。推荐在这个配置中使用类路径资源（classpath resource)，但你可以使用任何 Reader 实例，包括用文件路径或 file:// 开头的 url 创建的实例。MyBatis 有一个实用类 ----Resources，它有很多方法，可以方便地从类路径及其它位置加载资源。

2、搭建我们的第一个 mybatis 小 demo

　　这里说明下这个搭建步骤根据 mybatis 官方提供的文档示例进行搭建的、下面我贴出这个文档 (此文档打包至下面 mybatis 相关 jar 包里面下载即可) 截图：

　　

 

　　a): 导入 mybatis 相关 jar 包及数据库驱动包

　　　demo 结构图如下:

　　　

 

　 　　b):Building SqlSessionFactory from XML (从 XML 配置文件中构建 SqlSessionFactory)

　　　　既然构建 SqlsessionFactory 的前提是从 xml 文件中那么接下来我们先编写这个 mybatis 的核心配置文件 (mybatis.xml) 及实体类映射文件 (User.mapper.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>
<environments default="development">
<environment id="development">
<!-- 采用jdbc事务管理其 -->
<transactionManager type="JDBC"/>
<!-- 配置数据源 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
<property name="username" value="root"/>
<property name="password" value="111"/>
</dataSource>
</environment>
</environments>
<mappers>
<!-- 引入实体类的映射文件 -->
<mapper resource="edu/aeon/mybatis/entity/User.mapper.xml"/>
</mappers>
</configuration>

实体类映射文件:User.mapper.xml

<?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="edu.aeon.mybatis.entity">
<select id="selectAllUsers" resultType="edu.aeon.mybatis.entity.User">
select * from user
</select>
</mapper>

　　c): 编写 User 实体类：

package edu.aeon.mybatis.entity;
/**
 * user实体类
 * @author QQ1584875179
 */
public class User {
    //用户id
    private int uid;
    //用户名
    private String uname;
    //用户密码
    private String upw;
    //↓setter/getter
    public int getUid() {
        return uid;
    }
    public void setUid(int uid) {
        this.uid = uid;
    }
    public String getUname() {
        return uname;
    }
    public void setUname(String uname) {
        this.uname = uname;
    }
    public String getUpw() {
        return upw;
    }
    public void setUpw(String upw) {
        this.upw = upw;
    }
    @Override
    public String toString() {
        return uid+"\t"+uname+"\t"+upw;
    }
}

　　因为我们每次操作数据库都要获得 session (和数据库进行会话 / 通信)、所以便于代码的复用我们写一个获得 session 的工具类 (MyBatisUtils.java)：　

package edu.aeon.mybatis.utils;

import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
/**
 * mybatis工具类
 * @author QQ1584875179
 */
public class MyBatisUtils {
    /**
     * @param resource 构建资源来自resource
     * @return 通过构建资源构建的SqlSessionFactory实例
     * @throws IOException 此处采取抛出异常到顶层、然后我们统一去处理
     */
    public static SqlSessionFactory getSqlSessionFactory(String resource) throws IOException{
        InputStream inputStream = Resources.getResourceAsStream(resource);
        return new SqlSessionFactoryBuilder().build(inputStream);
    }
    /**
     * @param resource 构建资源来自resource
     * @return 通过构建资源构建的SqlSessionFactory实例的openSession()方法获得SqlSession实例
     * @throws IOException 此处采取抛出异常到顶层、然后我们统一去处理
     */
    public static SqlSession getSqlSession(String resource) throws IOException{
        return getSqlSessionFactory(resource).openSession();
    }
}

接下来我们写个测试类 (便于测试我们前面的各种配置是否正确):

package edu.aeon.mybatis.test;

import java.io.IOException;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import edu.aeon.mybatis.entity.User;
import edu.aeon.mybatis.utils.MyBatisUtils;

public class Demo01Test {
    public static void main(String[] args) {
        try {
            SqlSession sqlSession = MyBatisUtils.getSqlSession("mybatis/mybatis.xml");
            List<User> userList=sqlSession.selectList("edu.aeon.mybatis.entity.selectAllUsers");
            System.out.println("用户id\t用户名\t用户密码");
            for(User user:userList){
                System.out.println(user);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }
}

　　数据库截图：

　　

　　测试结果 (控制台) 截图:

　　

 

　　可见前面我们所有的配置都是正确的！

　　接下来为了节省你们搭建环境以及插入测试数据、我附上本次我数据库的创建表、以及测试数据

##创建一个mybatis的数据库
create database mybatis;
##切换我们刚才创建的mybatis数据库为当前数据库
use mybatis;
##创建(user)表
create table user(uid int(3) primary key auto_increment,uname varchar(16),upw varchar(16));
##想user表中插入5条测试数据
insert into user(uname,upw) values(''lzj1'',''aeon1'');
insert into user(uname,upw) values(''lzj2'',''aeon2'');
insert into user(uname,upw) values(''lzj3'',''aeon3'');
insert into user(uname,upw) values(''lzj4'',''aeon4'');
insert into user(uname,upw) values(''lzj5'',''aeon5'');

最后我们对配置文件进行一次简化操作:

　　a): 简化 mybatis 的核心配置文件　　

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
 PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<properties resource="database/database_mysql.properties"/>
<typeAliases>
    <!-- 
    目的:简化配置文件的繁琐性、以前由包名+类名的形式均可变成所指定的别名类型、或者通过包名所配置后的类类型
    -->
    <!-- 第一种方式:为type属性中的内容指定引用别名为alias中的内容、指定之后所有关于type中的类型均可由alias内容代替 -->
    <!-- <typeAlias type="edu.aeon.mybatis.entity.User" alias="User"/> -->
    <!-- 第二种方式:通过包名配置、配置后所有该包下的类型均可有类名代替、不需要由以前的包名+类名的形式 -->
    <package name="edu.aeon.mybatis.entity"/>
</typeAliases>
 <environments default="development">
 <environment id="development">
 <transactionManager type="JDBC"/>
 <dataSource type="POOLED">
 <property name="driver" value="${driver}"/>
 <property name="url" value="${url}"/>
 <property name="username" value="${username}"/>
 <property name="password" value="${password}"/>
 </dataSource>
 </environment>
 </environments>
 <mappers>
 <!-- 引入实体类到数据库的sql映射文件 -->
 <mapper resource="edu/aeon/mybatis/entity/User.Mapper.xml"/>
 </mappers>
</configuration>

　　b): 简化实体类到数据库的 sql 映射文件

　　

<?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="edu.aeon.mybatis.entity.UserMapper">
 <insert id="insertUser" useGeneratedKeys="true" parameterType="User">
     insert into user(uname,upw) values(#{uname},#{upw})
 </insert>
 <delete id="deleteUser" parameterType="int">
     delete from user where uid = #{uid}
 </delete>
 <update id="updateUser" parameterType="User">
     update user set uname=#{uname},upw=#{upw} where uid=#{uid}
 </update>
 <select id="selectAllUsers" resultType="User">
     select uid,uname,upw from user
 </select>
 <select id="selectUser" resultType="User">
     select * from user where uid = #{uid}
 </select>
</mapper>

　　c): 附上 database_mysql.properties 配置信息

driver = com.mysql.jdbc.Driver
url = jdbc:mysql://localhost:3306/mybatis
username = root
password = 111 

解决实体类属性名和数据库表字段映射不一致获取不到值的情况：

　　a): 给数据库表字段起别名，别名对应类属性即可

　　b): 类属性和数据库表字段重新映射

　　

<select id="selectAllUsers" resultMap="UserMap">
     select uid,uname,upw from user
 </select>
 <!-- 此处重新映射了实体类属性名和数据库字段 、当然只针对需要重新映射的sql语句 (resultMap="UserMap"__id="UserMap") -->
 <resultMap type="User" id="UserMap">
     <id property="uid" column="uid"/>
     <result property="uname" column="uname"/>
     <result property="upw" column="upw"/>
 </resultMap>

资源整理：　

　　mybatis 相关 jar 包下载链接： https://pan.baidu.com/s/1-GRtDOMYQFx0vvjs_QnJZw　　提取码：3gal

　　mysql 数据库驱动包下载链接： https://pan.baidu.com/s/1L9nFhVmr5ns1Tez2kzmIoA　　提取码：gzgw

　　oracle 数据库驱动包下载链接： https://pan.baidu.com/s/1XTogghptNxNNwM1pP_XY0A&nbsp　　提取码：2y5m

　　demo 下载

链接：https://pan.baidu.com/s/1x2Exj8l2ZGA0ChY6wUgE2w　　

提取码：d9mh

 

　

 

　　mybatis 增删改查:

链接：https://pan.baidu.com/s/1jTB3aiUfyIhhRLvRTra7Vg　　提取码：bve0

 

 

　　

　　　　

java-mybaits-015-mybatis逆向工程最佳实践【基础mybatis-generator、tk.mybatis、mubatis-plus】

一、概述

三款框架的功能对比

　　通用Mapper是对Mybatis-generator的升级改造，解决了使用Mybatis-generator可能需要大量重构的问题，并且在这个基础上加入了一些新的功能。

　　Mybatis-Plus可以看作是在另一个方向上对Mybatis的升级改造，不仅能够根据数据库表快速生成pojo实体类，还封装了大量CRUD方法，使用Wrapper解决了复杂条件构造等问题，更是根据开发中常见的问题给出了一系列解决方案。

　　在拥有Maven和Spring boot的开发框架下，MBG、通用Mapper和MP都可以快速地完成安装，相比于MBG和通用Mapper仅需要执行插件就可以完成基本的开发工作，MP可能需要更多的开发工作量。

　　最佳实践参看代码：https://github.com/bjlhx15/java_base_architecture.git

二、Mybatis-generator

　　MyBatis Generator（MBG）是MyBatis MyBatis 和iBATIS的代码生成器。它为所有版本的MyBatis以及版本2.2.0之后的iBATIS版本生成代码。它将根据数据库表生成可用于访问表的文件。

　　Mybatis-generator主要完成的工作是依据数据库表创建对应的model、dao、mapping文件，可以通过Maven插件或者mybatis-generator的jar包生成。

　　这里介绍Maven插件使用方法：

　　　　1、在pom.xml文件中加入mybatis-generator系列插件；

　　　　2、创建generatorConfig.xml文件，在配置文件中指定数据库连接地址、生成类的存放地址、生成对应表的类名等信息；

　　　　3、执行mybatis-generator插件，即可生成相应文件；

　　　　4、此外，mybatis-generator自动生成了example类用于构造复杂的筛选条件

　　Mybatis-generator使用较为简单，生成的DAO类及映射文件中包含基本的CRUD操作。

　　需要注意的是，在一次项目中多次执行mybatis-generator，xml文件会追加，会覆盖原本的Model、DAO；可以使用如下方式

　　　　1、每次清理要生成的xml

　　　　2、自动生成的写入auto，

　　　　3、个人扩展的使用上图方式

　　可以参看上述github代码

三、通用Mapper【tk.mybatis】

官网：https://github.com/abel533/Mapper/wiki

　　当数据库字段变化频繁时，使用MBG（mybatis-generator）会带来大量的重构工作，对此，通用Mapper给出的解决办法是：给予开发者一个具备丰富的单表方法并且容易扩展的通用的Mapper。

　　通用Mapper是对单表的CRUD操作进行了较为详细的实现，使得开发人员可以随意的按照自己的需求选择通用的方法，同时允许开发人员便捷地对通用Mapper进行扩展。

1. 在pom.xml中添加插件配置

<!-- 命令：mvn mybatis-generator:generate -->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.6</version>
                <configuration>
                    <!-- 配置实际调用地址-->
                    <configurationFile>src/main/resources/mybatis_generatorConfig/generatorConfig-base.xml
                    </configurationFile>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>5.1.38</version>
                    </dependency>
                    <dependency>
                        <groupId>tk.mybatis</groupId>
                        <artifactId>mapper</artifactId>
                        <version>4.0.0</version>
                    </dependency>
                </dependencies>
            </plugin>

View Code

　　可以看到，通用Mapper的代码生成实际上是使用了MGB，因此通用Mapper的代码生成器只是调用了MGB，然后在这个基础上加入了一些元素来方便开发。

2. 配置文件generatorConfig.xml

<?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>
    <!--导入属性配置，前面我们写的一个配置文件，你也可以直接使用mybatis的jdbc的配置文件 -->
    <properties resource="jdbc.properties"></properties>
    <!-- 数据库驱动，注意，这里必须要修改成你的数据库的驱动地址 -->
    <!--    如果 pom配置这里可以不写-->
    <!--    <classPathEntry  location=".m2/repository/mysql/mysql-connector-java/5.1.8/mysql-connector-java-5.1.8.jar"/>-->

    <context id="Mysql" targetRuntime="MyBatis3Simple" defaultModelType="flat">
        <property name="beginningDelimiter" value="`"/>
        <property name="endingDelimiter" value="`"/>
        <plugin type="tk.mybatis.mapper.generator.MapperPlugin">
            <property name="mappers" value="tk.mybatis.mapper.common.Mapper"/>
            <property name="caseSensitive" value="true"/>
        </plugin>

        <!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
        <jdbcConnection driverClass="${jdbc.driver}"
                        connectionURL="${jdbc.url}"
                        userId="${jdbc.username}" password="${jdbc.password}">
        </jdbcConnection>

<!--        <javaTypeResolver>-->
<!--            <property name="forceBigDecimals" value="false"/>-->
<!--        </javaTypeResolver>-->
        <!-- targetProject:生成PO类的位置 -->
        <javaModelGenerator targetPackage="com.github.bjlhx15.mybatis.springboot.base.model.auto"
                            targetProject="../tk-mybatis-springboot-base1/src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false"/>
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>

        <!-- targetProject:mapper xml 映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="autoxml"
                         targetProject="../tk-mybatis-springboot-base1/src/main/resources/mapper/">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false"/>
        </sqlMapGenerator>

        <!--targetPackage：mapper接口生成的位置 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.github.bjlhx15.mybatis.springboot.base.repository.auto"
                             targetProject="../tk-mybatis-springboot-base1/src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false"/>
        </javaClientGenerator>

        <!-- 指定数据库表 -->
        <table tableName="accountbalance" domainObjectName="AccountBalance">
            <generatedKey column="id" sqlStatement="JDBC"/>
        </table>


    </context>
</generatorConfiguration>

View Code

　　与MGB原有的配置文件相比，这里只是多了一个插件的配置，这个插件的作用是：配置生成的Mapper接口都会自动继承这个接口，也就是说，使用通用Mapper生成的mapper接口即使看上去空空如也，但已经具备了大量的对数据库的操作方法。此外，通用 Mapper 专用代码生成器生成的 Model 会在原有基础上增加 @Table,@Id,@Column 等注解，方便自动与数据库字段进行映射。

3. 在 pom.xml 这一级目录的命令行窗口执行 mvn mybatis-generator:generate或者直接在执行mvn插件即可。

4. 通用Mapper同样有Example的设计，与MGB不同的是，MDB会对每一个表生成对应的Example类，而通用Mapper提供了一个统一的Example类，这个类和 MBG 生成的相比，需要自己设置属性名，这个类还额外提供了更多的方法。

　　通用Mapper可以看作是MGB的改进和扩展，一定程度上解决了使用MGB重构的问题。

　　可以参看上述github代码

四、Mybatis-Plus

　　官网地址：https://mp.baomidou.com/guide/generator.html

　　（以下简称MP）是Mybatis的增强工具（MBG和通用Mapper可看成插件），在Mybatis的基础上增加了很多功能，简化开发，提高效率。

在Spring Boot中的引入：

1. 在maven中添加MP启动器

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.1.2</version>
</dependency>

2. 要使用代码生成器还需要添加模板引擎依赖

参看地址：AutoGenerator的使用参考 https://mybatis.plus/guide/generator.html 。

添加 模板引擎 依赖，MyBatis-Plus 支持 Velocity（默认）、Freemarker、Beetl，用户可以选择自己熟悉的模板引擎，如果都不满足您的要求，可以采用自定义模板引擎。

Velocity（默认）：

<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.1</version>
</dependency>

Freemarker：

<dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
    <version>2.3.29</version>
</dependency>

Beetl：

<dependency>
    <groupId>com.ibeetl</groupId>
    <artifactId>beetl</artifactId>
    <version>3.0.11.RELEASE</version>
</dependency>

注意！如果您选择了非默认引擎，需要在 AutoGenerator 中 设置模板引擎。

AutoGenerator generator = new AutoGenerator();

// set freemarker engine
generator.setTemplateEngine(new FreemarkerTemplateEngine());

// set beetl engine
generator.setTemplateEngine(new BeetlTemplateEngine());

// set custom engine (reference class is your custom engine class)
generator.setTemplateEngine(new CustomTemplateEngine());

// other config
...

View Code

3、代码的自动生成。AutoGenerator是MP的代码生成器，通过调用AutoGenerator，进行相应的模板、策略配置可以快速生成Entity、Mapper、Mapper XML、Service、Controller各个模块的代码。

4. MP将通用的CRUD操作封装进BaseMapper接口，而自动生成的Mapper接口便自动继承了BaseMapper接口。复杂的Sql操作，则可以使用QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper)进行动态Sql拼接。

5、此外，MP还支持分页、逻辑删除、通用枚举、Sql注入等功能，在:https://mp.baomidou.com/guide/generator.html

　　还有性能分析插件：https://mp.baomidou.com/guide/performance-analysis-plugin.html

与MBG不同，使用Mybatis-Plus自动生成代码需要编写代码，通过调用AutoAutoGenerator类实现代码生成，从这方面来说不如使用插件方便。但是它丰富的功能以及只是相对复杂的配置还是使它领先于MBG以及通用Mapper。

双方都

Mybaits 源码解析 （一）----- 搭建一个mybatis框架（MyBatis HelloWorld）

源码分析之前先搭一个mybatis的demo，这个在看源码的时候能起到了很大的作用，因为在看源码的时候，会恍然大悟，为什么要这么配置，为什么要这么写。（老鸟可以跳过这篇）

开发环境的准备

创建maven项目

pom.xml

<?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.mybatis.chenhao</groupId>
    <artifactId>mybatisDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <!-- mybatis版本号 -->
        <mybatis.version>3.4.2</mybatis.version>
    </properties>
    <dependencies>

        <!--mybatis依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
        <!-- mysql驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
        </dependency>

    </dependencies>

</project>

创建mybatis的配置文件

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="db.properties"></properties>
    <environments default="default">
        <environment id="default">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper class="mapper.DemoMapper"></mapper>
    </mappers>
</configuration>

db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf8
jdbc.username=chenhao
jdbc.password=123456

entity和mapper

Employee

package entity;

/***
 *
 *@Author ChenHao
 *@Description:
 *@Date: Created in 14:58 2019/10/26
 *@Modified By:
 *
 */
public class Employee {
    int id;
    String name;

    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;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name=''" + name + ''\'''' +
                ''}'';
    }
}

EmployeeMapper

package mapper;

import entity.Employee;
import java.util.List;

/***
 *
 *@Author ChenHao
 *@Description:
 *@Date: Created in 14:58 2019/10/26
 *@Modified By:
 *
 */
public interface EmployeeMapper {
    List<Employee> getAll();
}

EmployeeMapper.xml

<?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="mapper.EmployeeMapper">

    <resultMap id="baseMap" type="entity.Employee">
        <result property="id" column="id" jdbcType="INTEGER"></result>
        <result property="name" column="name" jdbcType="VARCHAR"></result>

    </resultMap>
    <select id="getAll" resultMap="baseMap">
        select * from employee
    </select>
</mapper>

测试

public static void main(String[] args) throws IOException {
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    try {
         EmployeeMapper employeeMapper = sqlSession.getMapper(EmployeeMapper.class);
         List<Employee> all = employeeMapper.getAll();
         for (Employee item : all)
            System.out.println(item);
    } finally {
        sqlSession.close();
    }
}

测试结果：

Employee{id=1, name=''name1''}
Employee{id=2, name=''name2''}
Employee{id=3, name=''name3''}

好了，MyBatis HelloWorld我们已经搭建完了，后面的源码分析文章我们将以这个为基础来分析

原文出处：https://www.cnblogs.com/java-chen-hao/p/11743516.html

MyBatis 学习之路其一：使用mybatis 创建一个简单的程序

 1 package mybatisTest.model;
 2 
 3 public class Role {
 4 
 5     private Long id;
 6     private String roleName;
 7     private int age;
 8     public Long getId() {
 9         return id;
10     }
11     public void setId(Long id) {
12         this.id = id;
13     }
14     public String getRoleName() {
15         return roleName;
16     }
17     public void setRoleName(String roleName) {
18         this.roleName = roleName;
19     }
20     public int getAge() {
21         return age;
22     }
23     public void setAge(int age) {
24         this.age = age;
25     }
26     
27 }

1 package mybatisTest.mapper;
2 
3 import mybatisTest.model.Role;
4 
5 public interface RoleMapper {
6     public Role getRole(int id);
7 }

mysql -h localhost -u root - p

use mysql
select host,user from user;

+----------------+------------------+
| host           | user             |
+----------------+------------------+
| %              | holmes           |
| %              | root             |
| 192.168.52.128 | holmes           |
| localhost      | mysql.infoschema |
| localhost      | mysql.session    |
| localhost      | mysql.sys        |
+----------------+------------------+

update user set host = ''%'' where user = ''root'';

quit

ip add

mysql -h 192.168.52.128 -u root -p

create database javatest;

create database javatest;

create table Role(
   id INT NOT NULL,
   name VARCHAR(100) ,
   age INT NOT NULL,
   PRIMARY KEY (id )
);

insert into Role(id,name,age) values(1,''zhangsan'',23);
insert into Role(id,name,age) values(2,''lisi'',21);
insert into Role(id,name,age) values(3,''wuwu'',29);

firewall-cmd --list-ports

3306/tcp 80/tcp

firewall-cmd --zone=public --add-port=3306/tcp --permanent
firewall-cmd --reload

<?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>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  </mappers>
</configuration>

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE configuration
 3   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4   "http://mybatis.org/dtd/mybatis-3-config.dtd">
 5 <configuration>
 6 <!-- environment 描述的数据库 -->
 7   <environments default="development">
 8     <environment id="development">
 9     <!-- 表示事务管理器采用的事 mybatis 的 jdbc 管理器方式 -->
10       <transactionManager type="JDBC"/>
11       <dataSource type="POOLED">
12         <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
13         <property name="url" value="jdbc:mysql://192.168.52.128:3306/javatest?serverTimezone=UTC"/>
14         <property name="username" value="root"/>
15         <property name="password" value="Root123#"/>
16       </dataSource>
17     </environment>
18   </environments>
19   <mappers>
20     <mapper resource="mybatisTest/mapper/RoleMapper.xml"/>
21   </mappers>
22 </configuration>

The server time zone value ''PDT'' is unrecognized or represents more than one time zone. 
You must configure either the server or JDBC driver (via the serverTimezone configuration property) 
to use a more specifc time zone value if you want to utilize time zone support.

<?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="mybatisTest.mapper.RoleMapper">
  <select id="getRole" resultType="mybatisTest.model.Role">
    select age from Role where id = #{id}
  </select>
</mapper>

 1 package mybatisTest;
 2 
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 
 6 import org.apache.ibatis.io.Resources;
 7 import org.apache.ibatis.session.SqlSession;
 8 import org.apache.ibatis.session.SqlSessionFactory;
 9 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
10 
11 import mybatisTest.model.Role;
12 
13 public class SqlSessionTest {
14 
15     public static void main(String[] args) {
16         SqlSessionFactory sqlSessionFactory = null;
17         String resource = "mybatis-config.xml";
18         InputStream inputStream;
19         try {
20             inputStream = Resources.getResourceAsStream(resource);
21             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
22         }catch(IOException e) {
23             e.printStackTrace();
24         }
25         SqlSession sqlSession = sqlSessionFactory.openSession();
26         Role role = (Role)sqlSession.selectOne("mybatisTest.mapper.RoleMapper.getRole",1);
27         System.out.println(role.getAge());
28     }
29 
30 }

关于第一个Mybatis程序和mybatis then的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于01_mybatis 第一个应用程序、java-mybaits-015-mybatis逆向工程最佳实践【基础mybatis-generator、tk.mybatis、mubatis-plus】、Mybaits 源码解析 （一）----- 搭建一个mybatis框架（MyBatis HelloWorld）、MyBatis 学习之路其一：使用mybatis 创建一个简单的程序等相关知识的信息别忘了在本站进行查找喔。