框架-java：Mybatis+mysql入门使用

11:30:27

Mybatis+mysql 入门使用

Mybatis+mysql 配置文件版本入门使用

Mybatis+mysql 注解版本入门使用

一、新建一个java maven项目-Mybatis+mysql 配置文件版本入门使用

groupId：cn.zc.javapro.database
artifactId：SimpleMybatisMysql
version：1.0-SNAPSHOT

，目录结构如下所示：

1、添加依赖

　　a）使用maven管理依赖，以我本次使用的版本为例

<?xml version="1.0" encoding="UTF-8"?>
<!--MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。
框架:Mybatis+mysql入门使用
入门使用 1、添加依赖 a、使用maven管理依赖，以我本次使用的版本为例-->
<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>cn.zc.javapro.database</groupId>
    <artifactId>SimpleMybatisMysql</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.13</version>
            <scope>runtime</scope>
        </dependency>
        <!--druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
        <!--lombok 注解-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

pom.xml

　　b) 也可以使用gradle管理依赖

　　c) 也可以去官网下载，mybatis-3官网地址：http://www.mybatis.org/mybatis-3/

2、初始化数据库和初始数据

　　以数据库db2021和表t_test为例，以下是sql。然后执行sql，经此步骤，数据库中存在数据库db2021和表t_test

-- 2、初始化数据库和初始数据，以数据库moy_mybatis和表t_test为例

-- 创建数据库
CREATE SCHEMA IF NOT EXISTS `db2021` Character Set utf8mb4 COLLATE utf8mb4_unicode_ci;
USE `db2021`;

--  创建一个测试表
CREATE TABLE IF NOT EXISTS `db2021`.`t_test`(
    id INT(11) AUTO_INCREMENT,
    create_time DATE COMMENT '创建时间',
    modify_time DATE COMMENT '修改时间',
    content VARCHAR (50) COMMENT '内容',
    PRIMARY KEY (id)
);

3、新建实体类TestEntity.java

为了接收从表中取出来的值，比如数据库的select语句返回来的值，我们通过实体类对象进行接收。所以需要定义表的实体类。

关键技术点是Mybatis如何实现封装，如何实现表列和实体类对象成员之间的一一映射。

package cn.zc.javapro.database.mybatis.entity;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.io.Serializable;
import java.util.Date;

/**
 * [Project]:
 * [Date]:2021/1/22
 * [Description]: java mybatis mysql maven
 * @author zc
 */
//让它实现序列化接口
@Getter
@Setter
@ToString
public class TestEntity implements Serializable {
    private Integer id;
    private Date createTime;
    private Date modifyTime;
    private String content;
}

TestEntity.java

这里我们可以玩个小花样，再用个实体类QueryVo封装一下TestEntity实体类。

package cn.zc.javapro.database.mybatis.domain;

import cn.zc.javapro.database.mybatis.entity.TestEntity;

public class QueryVo {
    private TestEntity testEntity;

    public TestEntity getTestEntity() {
        return testEntity;
    }

    public void setTestEntity(TestEntity testEntity) {
        this.testEntity = testEntity;
    }
}

QueryVo.java

4、新建接口TestMapper.java

Mybatis通过定义接口，并通过配置文件或者注解，自动实现将该接口中的方法与sql语句一一对应。

当调用该接口的方法，相当于调用了对应的sql语句。

package cn.zc.javapro.database.mybatis.mapper;

import cn.zc.javapro.database.mybatis.domain.QueryVo;
import cn.zc.javapro.database.mybatis.entity.TestEntity;
import org.apache.ibatis.annotations.Param;

import java.io.Serializable;
import java.util.List;

/**
 * [Project]:
 * [Email]:
 * [Date]:2021/1/22
 * [Description]:
 *
 * @author zc
 */
public interface TestMapper {
    List<TestEntity> list();

    TestEntity get(Serializable id);
    //TestEntity get(Integer id);
    //TestEntity get(@Param("id") Integer id);

    int insert(TestEntity TestEntity);

    int update(TestEntity TestEntity);

    int delete(Serializable id);

    int count();

    /**
     * 根据名称模糊查询信息
     */
    List<TestEntity> findByContent(String content);

    /**
     * 根据queryVo中的条件查询用户
     */
    List<TestEntity> findTestByVo(QueryVo vo);
}

TestMapper.java

5、新建实体映射文件Test.xml

这里主要配置 接口类的方法与 sql语句一一对应关系。比如， TestMapper 与 TestEntity、QueryVo等。

这里的namespace就是写TestMapper全类名，否则不能使用动态代理的方式调用接口TestMapper。后面会讲一下parameterType如何配置多个参数。

<?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">
<!--新建实体映射文件Test.xml，这里的namespace就是写TestMapper全类名，否则不能使用动态代理的方式调用接口TestMapper-->
<mapper namespace="cn.zc.javapro.database.mybatis.mapper.TestMapper">

    <!--配置 查询结果的列明和实体类的属性名的对应关系-->
    <resultMap id="testMap" type="TestEntity">
        <!--主键字段的对应 -->
        <id property="id" javaType="Integer" column="id"></id>
        <!--非主键字段的对应-->
        <result property="createTime" javaType="Date" column="create_time"></result>
        <result property="modifyTime" javaType="Date" column="modify_time"></result>
        <result property="content" javaType="String" column="content"></result>
    </resultMap>

    <!--<select id="list" resultType="TestEntity">
        SELECT * FROM t_test
    </select>-->

    <select id="list" resultMap="testMap">
        SELECT * FROM t_test
    </select>

    <!--<select id="list" resultType="TestEntity">
        SELECT id,create_time as createTime,modify_time as modifyTime ,content
         FROM t_test
    </select>-->

    <select id="count" resultType="int">
        SELECT count(*) FROM t_test
    </select>

    <!-- 如果 mybatis-config.xml 中没有配置实体类对应的包名，则 resultType="cn.zc.javapro.database.mybatis.entity.TestEntity" -->
    <!-- 这里数据库返回值TestEntity的成员变量，肯定需要用到成员变量的set方法，
    要想赋值给对的对象，必须将表的列名和对象的成员变量一一对应起来。
    select可以通过给列名起别名为对象的成员变量名，建立一一对应关系，如下 create_time as createTime，create_time是表的列名，createTime是TestEntity的成员变量
    insert如下所示
    update如下所示
    -->
    <select id="get" parameterType="int" resultType="TestEntity">
        SELECT id,create_time as createTime,modify_time as modifyTime, content
         FROM t_test WHERE id=#{id}
    </select>

    <insert id="insert" parameterType="TestEntity">
        <!--配置插入操作后,获取插入数据的id-->
        <!--<selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        </selectKey>-->
        INSERT INTO t_test (create_time,modify_time,content)
        VALUES (#{createTime},#{modifyTime},#{content})
    </insert>

    <update id="update" parameterType="TestEntity">
        UPDATE t_test SET modify_time=#{modifyTime},content=#{content}
        WHERE id = #{id}
    </update>

    <delete id="delete" parameterType="int">
        DELETE FROM t_test WHERE id = #{id}
    </delete>

    <select id="findByContent" parameterType="string" resultType="TestEntity">
        <!-- 有问题： select * from t_test where content like #{content}; -->
        select id, create_time as createTime, modify_time as modifyTime, content
         from t_test where content like '%${content}%'
    </select>

    <!--根据queryVo的条件查询用户-->
    <select id="findTestByVo" parameterType="cn.zc.javapro.database.mybatis.domain.QueryVo" resultType="TestEntity">
        <!--select * from t_test where id like #{testEntity.id};-->
        select id, create_time as createTime, modify_time as modifyTime, content
         from t_test where id like #{testEntity.id};
    </select>
</mapper>

Test.xml

6、新建mybatis配置信息文件mybatis-config.xml

这里主要配置项目实体类对应的包名，可以扫描实体类。并配置了mysql数据库的连接信息。以及配置了接口类与实体类映射的配置文件（这里例如Test.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">
<!--新建mybatis配置信息文件mybatis-config.xml-->
<!--首先是跟元素-->
<configuration>
    <typeAliases>
        <!--项目实体类对应的包名-->
        <package name="cn.zc.javapro.database.mybatis.entity"/>
    </typeAliases>
    <!--myql数据库连接信息-->
    <!--配置环境 , 选择一个默认的环境mysql-->
    <environments default="development">
        <!--配置mysql的环境-->
        <environment id="development">
            <!--配置事务-->
            <transactionManager type="JDBC"/>
            <!--配置连接池-->
            <!--<dataSource type="cn.zc.javapro.database.mybatis.datasource.MyDataSource">-->
            <dataSource type="POOLED">
                <!--<property name="driver" value="com.mysql.jdbc.Driver"/>-->
                <!--<property name="url" value="jdbc:mysql://127.0.0.1:3306/db2021?useSSL=false"/>-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/db2021?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!--配置实体映射xml路径-->
    <mappers>
        <mapper resource="mapper/Test.xml"></mapper>
    </mappers>
</configuration>

mybatis-config.xml

这里重点说一下，我们可以单独通过XML来配置环境变量。

也可以通过 xml + properties 文件进行配置，

也可以通过 properties + xml文件进行配置，

还可以通过 yml + xml 文件进行配置。

参考： SpringBoot配置Mybatis的两种方式（通过XML配置和通过YML配置文件配置）： https://blog.csdn.net/weixin_43966635/article/details/112342116

比如，xml的配置还有另一种写法，即 xml + properties，下面的只写主要部分：

1.内置连接池

<configuration>
    <environments default="development">
        <environment id="development">
            <!-- 配置事务管理器 -->
            <transactionManager type="JDBC"/>
            <!-- 配置数据源：这里使用 MyBatis 内置连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///mybatisstu"/>
                <property name="username" value="root"/>
                <property name="password" value="123"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

2.引入数据源

<configuration>
    <!--引入数据源-->
    <properties resource="db.properties" />
    <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>

mybatis-config

7、为了方便测试，编写一个获取SqlSession的工具类MybatisTools.java

该类主要通过配置文件（如，mybatis-config.xml）初始化 SqlSession，通过SqlSession 配置注册初始化接口类（如 TestMapper）

package cn.zc.javapro.database.mybatis.tools;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.ExecutorType;
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.Reader;
import java.util.Objects;

/**
 * [Project]:
 * [Email]:
 * [Date]:2021/1/22
 * [Description]:
 * 7、为了方便测试，编写一个获取SqlSession的工具类MybatisTools
 * 该类主要是加载mybatis的配置文件（如：mybatis-config.xml等），然后
 *
 * 使用的时候:
 * 1）先 MybatisTools mt = new MybatisTools(resourceXMLFile)  // 这里的resourceXMLFile是mybatis的配置文件，如"mybatis-config.xml"
 * 2) SqlSession sqlSession = mt.openCurrentSqlSession()  // 按照配置文件打开获取 SqlSession
 * 3) TestMapper testMapper = sqlSession.getMapper(TestMapper.class); // 这里的 TestMapper.class 是实体和数据库的交互接口。
 * 4) testMapper.getAll()  // 调用方法
 * 5) mt.closeCurrentSqlSession() // 关闭 SqlSession
 * @author zc
 */
public class MybatisTools {
    //private String resourceFile;
    private ExecutorType executorType;
    private SqlSessionFactory sqlSessionFactory;
    private ThreadLocal<SqlSession> sessionThread = new ThreadLocal<>();

    /**
     *
     * @param resourceFile 资源文件
     */
    public MybatisTools(String resourceFile) {
        //this.resourceFile = resourceFile;
        this.initSqlSessionFactory(resourceFile);
    }

    /**
     *
     * @param resourceFile
     * @param executorType
     */
    public MybatisTools(String resourceFile, ExecutorType executorType) {
        //this.resourceFile = resourceFile;
        this.initSqlSessionFactory(resourceFile);
        this.executorType = executorType;
    }

    private void initSqlSessionFactory(String resourceFile) {
        try {
            Reader reader = Resources.getResourceAsReader(resourceFile);
            // 构建sqlSession的工厂
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public SqlSession openCurrentSqlSession() {
        SqlSession sqlSession = sessionThread.get();
        if (Objects.isNull(sqlSession)) {
            if(this.executorType == null) {
                sqlSession = sqlSessionFactory.openSession();
            } else {
                // 通过session设置ExecutorType开启批量添加，类似jdbc的addBatch操作
                //sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
                sqlSession = sqlSessionFactory.openSession(this.executorType);
            }

            sessionThread.set(sqlSession);
        }
        return sqlSession;
    }

    public void commitCurrentSqlSession() {
        SqlSession sqlSession = sessionThread.get();
        if (Objects.nonNull(sqlSession)) {
            sqlSession.commit();
        }
    }

    public void closeCurrentSqlSession() {
        SqlSession sqlSession = sessionThread.get();
        if (Objects.nonNull(sqlSession)) {
            /*if (this.executorType != null) {
                sqlSession.commit();
            }*/
            sqlSession.close();
        }
        sessionThread.set(null);
    }
}

MybatisTools.java

执行查询语句的时候不需要commit，但是执行 insert、update等操作时，需要commit。并且如果是大批量的更新插入操作，则每次都打开关闭，会浪费。所以我们直接一次插入。具体看第八节。

8、新建测试类TestMapperTest测试

包括3步：开启SqlSession；执行接口类的方法（如TestMapper的get()方法）；关闭SqlSession。

package cn.zc.javapro.database.mybatis.mapper;

import cn.zc.javapro.database.mybatis.domain.QueryVo;
import cn.zc.javapro.database.mybatis.entity.TestEntity;
import cn.zc.javapro.database.mybatis.tools.MybatisTools;
import cn.zc.javapro.database.mybatis.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.Arrays;
import java.util.Date;
import java.util.List;

public class TestMapperTest {
    MybatisTools mybatisTools;
    SqlSession sqlSession;
    TestMapper testMapper;

    @Before
    public void before() {
        /*sqlSession = MybatisUtils.getCurrentSqlSession();
        testMapper = sqlSession.getMapper(TestMapper.class);*/
        mybatisTools = new MybatisTools("mybatis-config.xml");
        sqlSession = mybatisTools.openCurrentSqlSession();
        testMapper = sqlSession.getMapper(TestMapper.class);
    }

    @After
    public void after() {
        // MybatisUtils.closeCurrentSession();
        mybatisTools.closeCurrentSqlSession();
    }

    @Test
    public void insert() {
        TestEntity entity = new TestEntity();
        entity.setCreateTime(new Date());
        entity.setModifyTime(new Date());
        entity.setContent("我是内容");
        //entity.setaontent("我是内容");
        System.out.println(testMapper.insert(entity));
        sqlSession.commit();
    }

    @Test
    public void count() {
        System.out.println(testMapper.count());
    }

    @Test
    public void list() {
        List<TestEntity> list = testMapper.list();
        //System.out.println(Arrays.toString(list.toArray()));
        for (TestEntity testEntity : list) {
            System.out.println(testEntity);
        }
    }

    @Test
    public void get() {
        System.out.println(testMapper.get(1));
    }

    @Test
    public void update() {
        TestEntity entity = new TestEntity();
        entity.setId(1);
        entity.setModifyTime(new Date());
        entity.setContent("我是修改后内容");
        //entity.setaontent("我是修改后内容");
        testMapper.update(entity);
        sqlSession.commit();
    }

    @Test
    public void delete() {
        testMapper.delete(1);
        sqlSession.commit();
    }

    /**
     * 测试模糊查询操作
     */
    @Test
    public void findByContent(){
        List<TestEntity> testEntityList = testMapper.findByContent("内容");
        for(TestEntity testEntity: testEntityList){
            System.out.println(testEntity);
        }
    }

    /**
     * 测试使用QueryVo作为查询对象
     */
    @Test
    public void testFindByVo(){
        QueryVo vo = new QueryVo();
        TestEntity testEntity = new TestEntity();
        //testEntity.setContent("%内容%");
        testEntity.setId(1);
        vo.setTestEntity(testEntity);
        List<TestEntity> testEntityList = testMapper.findTestByVo(vo);
        for(TestEntity testEntity1 : testEntityList){
            System.out.println(testEntity1);
        }

    }
}

TestMapperTest

我们可以看到，已经可以操作了。下面我们试一下主方法中调用：

9、主方法中调用

包括3步：开启SqlSession；执行接口类的方法（如TestMapper的get()方法）；关闭SqlSession。

package cn.zc.javapro.database.mybatis;

import cn.zc.javapro.database.mybatis.mapper.TestMapper;
import cn.zc.javapro.database.mybatis.tools.MybatisTools;
import cn.zc.javapro.database.mybatis.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

public class SimpleMybatisMysqlApp {
    public static void main(String[] args) {
        test2();
    }

    public static void test2() {
        SqlSession sqlSession;
        TestMapper testMapper;
        //
        MybatisTools mybatisTools = new MybatisTools("mybatis-config.xml");
        sqlSession = mybatisTools.openCurrentSqlSession();
        //得到 TestMapper 接口的实现类对象，TestMapper 接口的实现类对象由 sqlSession.getMapper(TestMapper.class)动态构建出来
        testMapper = sqlSession.getMapper(TestMapper.class);

        //执行查询操作，将查询结果自动封装成 TestEntity 返回
        System.out.println(testMapper.get(1));

        mybatisTools.closeCurrentSqlSession();
    }

    public static void test() {
        SqlSession sqlSession;
        TestMapper testMapper;
        sqlSession = MybatisUtils.getCurrentSqlSession();
        testMapper = sqlSession.getMapper(TestMapper.class);

        //
        System.out.println(testMapper.get(1));

        MybatisUtils.closeCurrentSession();
    }

}

SimpleMybatisMysqlApp.java

可以看出来，依然可以得出结果。到这一步，我们已经可以使用mybatis对数据库进行操作了。

二、Mybatis (ParameterType) 如何传递多个不同类型的参数

偶然碰到一个需要给xml传一个String类型和一个Integer类型的需求，当时心想用map感觉有点太浪费，所以专门研究了下各种方式。

1、方法一：不需要写parameterType参数

public List<XXXBean> getXXXBeanList(String xxId, String xxCode);

<select id="getXXXBeanList" resultType="XXBean">
　　select t.* from tableName where id = #{0} and name = #{1}  
</select>

由于是多参数那么就不能使用parameterType，改用#｛index｝是第几个就用第几个的索引，索引从0开始

2、方法二：基于注解(最简单)

public List<XXXBean> getXXXBeanList(@Param("id")String id, @Param("code")String code);

<select id="getXXXBeanList" resultType="XXBean">
　　select t.* from tableName where id = #{id} and name = #{code}  
</select>

由于是多参数那么就不能使用parameterType，这里用@Param来指定哪一个

3、方法三：Map封装

public List<XXXBean> getXXXBeanList(HashMap map);

<select id="getXXXBeanList" parameterType="hashmap" resultType="XXBean">
　　select 字段... from XXX where id=#{xxId} code = #{xxCode}  
</select>

其中hashmap是mybatis自己配置好的直接使用就行。map中key的名字是那个就在#{}使用那个，map如何封装就不用了我说了吧。

4、方法四：List封装

public List<XXXBean> getXXXBeanList(List<String> list);

<select id="getXXXBeanList" resultType="XXBean">
　　select 字段... from XXX where id in
　　<foreach item="item" index="index" collection="list" open="(" separator="," close=")">  
　　　　#{item}  
　　</foreach>  
</select>

5、总结

传递list和map在资源消耗上肯定远大于方法一和方法二，但是有一些特殊的情形需要传递list，比如你需要传递一个id集合并批量对id进行sql操作然后再返回等等。所以都需要了解。

四、Mybatis (resultType) 返回结果

如何对应实体类的成员变量，之前说过我们实体类的属性名和数据库列名是一致的，那如果是不一致的呢。

因为MySQL数据库不区分大小写，userName和username等同所以能封装进去，而其他的完全不一样，就封装不进去。

这里注意如果是linux系统是严格区分大小写的。

现在我们来解决封装不进去的问题，之所以封装不进去就是名字对不上，我们可以通过起别名的方式解决。

有2种解决办法：都是通过配置 Tese.xml .

1、通过起别名的方式

现在我们来解决封装不进去的问题，之所以封装不进去就是名字对不上，我们可以通过起别名的方式解决。

也就是说mysql执行这条sql语句出来的列名跟实体类是需要匹配的。如下所示：我们只是截取Test.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">
<!--新建实体映射文件Test.xml，这里的namespace就是写TestMapper全类名，否则不能使用动态代理的方式调用接口TestMapper-->
<mapper namespace="cn.zc.javapro.database.mybatis.mapper.TestMapper">
    <!--<select id="list" resultType="TestEntity">
        SELECT * FROM t_test
    </select>-->

    <select id="list" resultType="TestEntity">
        SELECT id,create_time as createTime,modify_time as modifyTime ,content
         FROM t_test
    </select>

    <!-- 如果 mybatis-config.xml 中没有配置实体类对应的包名，则 resultType="cn.zc.javapro.database.mybatis.entity.TestEntity" -->
    <!-- 这里数据库返回值TestEntity的成员变量，肯定需要用到成员变量的set方法，
    要想赋值给对的对象，必须将表的列名和对象的成员变量一一对应起来。
    select可以通过给列名起别名为对象的成员变量名，建立一一对应关系，如下 create_time as createTime，create_time是表的列名，createTime是TestEntity的成员变量
    insert如下所示
    update如下所示
    -->
    <select id="get" parameterType="int" resultType="TestEntity">
        SELECT id,create_time as createTime,modify_time as modifyTime ,content
         FROM t_test WHERE id=#{id}
    </select>

    <insert id="insert" parameterType="TestEntity">
        <!--配置插入操作后,获取插入数据的id-->
        <!--<selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        </selectKey>-->
        INSERT INTO t_test (create_time,modify_time,content)
        VALUES (#{createTime},#{modifyTime},#{content})
    </insert>

    <update id="update" parameterType="TestEntity">
        UPDATE t_test SET modify_time=#{modifyTime},content=#{content}
        WHERE id = #{id}
    </update>

    <delete id="delete" parameterType="int">
        DELETE FROM t_test WHERE id = #{id}
    </delete>
</mapper>

Test.xml片段

我们可以看到select 、insert、update、delete 都是将表列名和实体成员变量名对应起来。

如果我们用了

<select id="list" resultType="TestEntity">
    SELECT * FROM t_test
</select>

就会出现id和content有内容，而 createTime 和 modifyTime为 null。这是因为id和content表列名和对象成员变量一致，而表中create_time ,成员变量createTime ；表中modify_time，成员变量modifyTime名字不一致，Mybatis无法将之对应起来，无法赋值。

同理 insert、update、delete。

2、文档进行一个配置，创建了一个结果集的关系表

创建了一个结果集的关系表，使得java实体类的属性名和数据库的列名一一对应，property是java属性名，column是表的列名。

我们截取了Test.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">
<!--新建实体映射文件Test.xml，这里的namespace就是写TestMapper全类名，否则不能使用动态代理的方式调用接口TestMapper-->
<mapper namespace="cn.zc.javapro.database.mybatis.mapper.TestMapper">

    <!--配置 查询结果的列明和实体类的属性名的对应关系-->
    <resultMap id="testMap" type="TestEntity">
        <!--主键字段的对应 -->
        <id property="id" javaType="Integer" column="id"></id>
        <!--非主键字段的对应-->
        <result property="createTime" javaType="Date" column="create_time"></result>
        <result property="modifyTime" javaType="Date" column="modify_time"></result>
        <result property="content" javaType="String" column="content"></result>
    </resultMap>

    <select id="list" resultMap="testMap">
        SELECT * FROM t_test
    </select>

    <!-- 如果 mybatis-config.xml 中没有配置实体类对应的包名，则 resultType="cn.zc.javapro.database.mybatis.entity.TestEntity" -->
    <!-- 这里数据库返回值TestEntity的成员变量，肯定需要用到成员变量的set方法，
    要想赋值给对的对象，必须将表的列名和对象的成员变量一一对应起来。
    -->
    <select id="get" parameterType="int" resultMap="testMap">
        SELECT * FROM t_test WHERE id=#{id}
    </select>
    
</mapper>

Test.xml

这样就可以将表列名和对象成员变量一一对应起来。

总结

第一种方式是直接在数据库层实现，第二种方式还要多解析个xml，所以第一种的执行效率比第二种的要高，但第二种的开发效率高，因为我们既然定义了这个map，之后有关查询的都可以配置这个map，不用动里面的sql语句，两种方法各有利弊。

五、Mybatis+mysql 注解版本入门使用

只需要简单的修改就可以了，首先注解版本的实现就是用注解代替了Test.xml，所以注解版本不需要Test.xml。

1、修改 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">
<!--新建mybatis配置信息文件mybatis-config.xml-->
<!--首先是跟元素-->
<configuration>
    <!--<settings>
        &lt;!&ndash; #开启mybatis驼峰式命名规则自动转换 &ndash;&gt;
        <setting name="mapUnderscoreToCamelCase" value="true" />
    </settings>-->
    <typeAliases>
       <!-- <typeAlias alias="Integer" type="java.lang.Integer" />
        <typeAlias alias="Long" type="java.lang.Long" />
        <typeAlias alias="HashMap" type="java.util.HashMap" />
        <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
        <typeAlias alias="ArrayList" type="java.util.ArrayList" />
        <typeAlias alias="LinkedList" type="java.util.LinkedList" />-->
        <!--项目实体类对应的包名-->
        <package name="cn.zc.javapro.database.mybatis.entity"/>
    </typeAliases>
    <!--myql数据库连接信息-->
    <!--配置环境 , 选择一个默认的环境mysql-->
    <environments default="development">
        <!--配置mysql的环境-->
        <environment id="development">
            <!--配置事务-->
            <transactionManager type="JDBC"/>
            <!--配置连接池-->
            <dataSource type="cn.zc.javapro.database.mybatis.datasource.MyDataSource">
            <!--<dataSource type="POOLED">-->
                <!--<property name="driver" value="com.mysql.jdbc.Driver"/>-->
                <!--<property name="url" value="jdbc:mysql://127.0.0.1:3306/db2021?useSSL=false"/>-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/db2021?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 映射文件定位 -->
    <!--这个就是说一下，要执行的sql语句的xml文件在哪，这里可以写相对路径也可以写绝对路径，绝对路径就是url，相对路径使用resource-->
    <mappers>
        <!-- <mapper url = "file:Users/zc/MybatisMysqlAnnotation/src/main/resources/mapper/Test.xml" /> -->
        <!--配置实体映射xml路径, 配置文件就用这个-->
        <!--<mapper resource="mapper/Test.xml"></mapper>-->
        <!-- 注册Mapper映射接口，注解就用这个-->
        <mapper class = "cn.zc.javapro.database.mybatis.mapper.TestMapper2" />
    </mappers>
</configuration>

mybatis-config.xml

主要是修改了：

<!-- 映射文件定位 -->
    <!--这个就是说一下，要执行的sql语句的xml文件在哪，这里可以写相对路径也可以写绝对路径，绝对路径就是url，相对路径使用resource-->
    <mappers>
        <!-- <mapper url = "file:Users/zc/MybatisMysqlAnnotation/src/main/resources/mapper/Test.xml" /> -->
        <!--配置实体映射xml路径, 配置文件就用这个-->
        <!--<mapper resource="mapper/Test.xml"></mapper>-->
        <!-- 注册Mapper映射接口，注解就用这个-->
        <mapper class = "cn.zc.javapro.database.mybatis.mapper.TestMapper2" />
    </mappers>

2、添加接口 TestMapper2.java

这里面就是注解的实现。

package cn.zc.javapro.database.mybatis.mapper;

import cn.zc.javapro.database.mybatis.domain.QueryVo;
import cn.zc.javapro.database.mybatis.entity.TestEntity;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.io.Serializable;
import java.util.List;

/**
 * [Project]:
 * [Email]:
 * [Date]:2021/1/22
 * [Description]:
 *
 * @author zc
 */
public interface TestMapper2 {
    @Select("select id, create_time as createTime, modify_time as modifyTime, content from t_test;")
    List<TestEntity> list();

    @Select("select id, create_time as createTime, modify_time as modifyTime, content from t_test where id = #{id};")
    TestEntity get(Serializable id);
    //TestEntity get(Integer id);
    //TestEntity get(@Param("id") Integer id);
    @Insert("INSERT INTO t_test (create_time,modify_time,content)\n" +
            "        VALUES (#{createTime},#{modifyTime},#{content})")
    int insert(TestEntity TestEntity);

    @Update("UPDATE t_test SET modify_time=#{modifyTime},content=#{content}\n" +
            "        WHERE id = #{id}")
    int update(TestEntity TestEntity);

    @Delete("DELETE FROM t_test WHERE id = #{id}")
    int delete(Serializable id);

    @Select("SELECT count(*) FROM t_test")
    int count();

    /**
     * 根据名称模糊查询信息
     */
    @Select("select id, create_time as createTime, modify_time as modifyTime, content\n" +
            "         from t_test where content like '%${content}%'")
    List<TestEntity> findByContent(String content);

    /**
     * 根据queryVo中的条件查询用户
     */
    @Select("select id, create_time as createTime, modify_time as modifyTime, content\n" +
            "         from t_test where id like #{testEntity.id};")
    List<TestEntity> findTestByVo(QueryVo vo);
}

TestMapper2.java

3、修改主类SimpleMybatisMysqlApp，测试一下

package cn.zc.javapro.database.mybatis;

import cn.zc.javapro.database.mybatis.mapper.TestMapper;
import cn.zc.javapro.database.mybatis.mapper.TestMapper2;
import cn.zc.javapro.database.mybatis.tools.MybatisTools;
import cn.zc.javapro.database.mybatis.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

public class SimpleMybatisMysqlApp {
    public static void main(String[] args) {
        test3();
    }

    public static void test3() {
        SqlSession sqlSession;
        TestMapper2 testMapper2;
        //
        MybatisTools mybatisTools = new MybatisTools("mybatis-config.xml");
        sqlSession = mybatisTools.openCurrentSqlSession();
        //得到 TestMapper 接口的实现类对象，TestMapper 接口的实现类对象由 sqlSession.getMapper(TestMapper.class)动态构建出来
        testMapper2 = sqlSession.getMapper(TestMapper2.class);

        //执行查询操作，将查询结果自动封装成 TestEntity 返回
        System.out.println(testMapper2.get(1));

        mybatisTools.closeCurrentSqlSession();
    }

    public static void test2() {
        SqlSession sqlSession;
        TestMapper testMapper;
        //
        MybatisTools mybatisTools = new MybatisTools("mybatis-config.xml");
        sqlSession = mybatisTools.openCurrentSqlSession();
        //得到 TestMapper 接口的实现类对象，TestMapper 接口的实现类对象由 sqlSession.getMapper(TestMapper.class)动态构建出来
        testMapper = sqlSession.getMapper(TestMapper.class);

        //执行查询操作，将查询结果自动封装成 TestEntity 返回
        System.out.println(testMapper.get(1));

        mybatisTools.closeCurrentSqlSession();
    }

    public static void test() {
        SqlSession sqlSession;
        TestMapper testMapper;
        sqlSession = MybatisUtils.getCurrentSqlSession();
        testMapper = sqlSession.getMapper(TestMapper.class);

        //
        System.out.println(testMapper.get(1));

        MybatisUtils.closeCurrentSession();
    }

}

SimpleMybatisMysqlApp.java

六、自定义的数据源

自定义数据源有两种写法；之后需要修改一下 mybatis-config.xml，使得Mybatis识别使用该数据源。

1、我们配置一下自定义的数据源

　　比如我们自定义数据源整合阿里巴巴的druid数据库连接池:

　　方案一：extends DruidDataSourceFactory implements DataSourceFactory

　　方案二：extends UnpooledDataSourceFactory

方案一：MyDataSource.java

package cn.zc.javapro.database.mybatis.datasource;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.apache.ibatis.datasource.DataSourceFactory;

import javax.sql.DataSource;
import java.util.Properties;

public class MyDataSource extends DruidDataSourceFactory implements DataSourceFactory {
    protected Properties properties;

    @Override
    public void setProperties(Properties properties) {
        this.properties= properties;
    }

    @Override
    public DataSource getDataSource() {
        try {
            return createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

MyDataSource.java

方案二：MyDataSource2.java

package cn.zc.javapro.database.mybatis.datasource;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.datasource.unpooled.UnpooledDataSourceFactory;

import javax.sql.DataSource;

public class MyDataSource2 extends UnpooledDataSourceFactory {
    protected DataSource dataSource;

    public MyDataSource2() {
        this.dataSource = new DruidDataSource();

    }
}

MyDataSource2.java

2、修改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">
<!--新建mybatis配置信息文件mybatis-config.xml-->
<!--首先是跟元素-->
<configuration>
    <typeAliases>
        <!--项目实体类对应的包名-->
        <package name="cn.zc.javapro.database.mybatis.entity"/>
    </typeAliases>
    <!--myql数据库连接信息-->
    <!--配置环境 , 选择一个默认的环境mysql-->
    <environments default="development">
        <!--配置mysql的环境-->
        <environment id="development">
            <!--配置事务-->
            <transactionManager type="JDBC"/>
            <!--配置连接池-->
            <dataSource type="cn.zc.javapro.database.mybatis.datasource.MyDataSource">
            <!--<dataSource type="POOLED">-->
                <!--<property name="driver" value="com.mysql.jdbc.Driver"/>-->
                <!--<property name="url" value="jdbc:mysql://127.0.0.1:3306/db2021?useSSL=false"/>-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/db2021?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!--配置实体映射xml路径-->
    <mappers>
        <mapper resource="mapper/Test.xml"></mapper>
    </mappers>
</configuration>

mybatis-config.xml

3、编写测试方法TestDruidDemo.java

package cn.zc.javapro.database.mybatis;

import com.alibaba.druid.pool.DruidDataSourceFactory;
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.Reader;

public class TestDruidDemo {
    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        // 使用类加载器加载mybatis的配置文件（它也加载关联的映射文件）
        Reader reader = Resources.getResourceAsReader(resource);

        // 构建sqlSession的工厂
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder()
                .build(reader,"development");

        SqlSession session = sessionFactory.openSession();

        System.out.println(session);

        session = sessionFactory.openSession();

        System.out.println(session);

        DruidDataSourceFactory f;
    }
}

TestDruidDemo.java

七、配置多数据源

配置多数据源（此数据源非比数据源，此处更偏向于数据库，或者数据的来源），就是通过不同的配置从不同的数据源中获取数据。比如MySQL的主库和从库（或者读库和写库），不是一个库，需要配置两个数据源。甚至是不同数据库的数据源，有的来自MySQL、有的来自Oracle等，都需要配置多数据源。

具体如下，我们还是在之前的基础上进行修改。

比如，我现在要从另一个数据库获取数据，这是我就要重新配置一个新的mybatis-mysql-config.xml，他和mybatis-config.xml同一级别，知识不同的配置。

1、配置一个新的mybatis-mysql-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">
<!--新建mybatis配置信息文件mybatis-mysql-config.xml-->
<!--首先是跟元素-->
<configuration>
    <settings>
        <!-- #开启mybatis驼峰式命名规则自动转换 -->
        <setting name="mapUnderscoreToCamelCase" value="true" />
    </settings>
    <typeAliases>
        <typeAlias alias="Integer" type="java.lang.Integer" />
        <typeAlias alias="Long" type="java.lang.Long" />
        <typeAlias alias="HashMap" type="java.util.HashMap" />
        <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
        <typeAlias alias="ArrayList" type="java.util.ArrayList" />
        <typeAlias alias="LinkedList" type="java.util.LinkedList" />
        <!--项目实体类对应的包名-->
        <package name="cn.zc.javapro.database.mybatis.entity"/>
    </typeAliases>
    <!--myql数据库连接信息-->
    <!--配置环境 , 选择一个默认的环境mysql-->
    <environments default="development">
        <!--配置mysql的环境-->
        <environment id="development">
            <!--配置事务-->
            <transactionManager type="JDBC"/>
            <!--配置连接池-->
            <dataSource type="cn.zc.javapro.database.mybatis.datasource.MyDataSource">
            <!--<dataSource type="POOLED">-->
                <!--<property name="driver" value="com.mysql.jdbc.Driver"/>-->
                <!--<property name="url" value="jdbc:mysql://127.0.0.1:3306/db2021?useSSL=false"/>-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 映射文件定位 -->
    <!--这个就是说一下，要执行的sql语句的xml文件在哪，这里可以写相对路径也可以写绝对路径，绝对路径就是url，相对路径使用resource-->
    <mappers>
        <!-- <mapper url = "file:Users/zc/MybatisMysqlAnnotation/src/main/resources/mapper/Test.xml" /> -->
        <!--配置实体映射xml路径, 配置文件就用这个-->
        <mapper resource="mapper/User.xml"></mapper>
        <!-- 注册Mapper映射接口，注解就用这个-->
        <!--<mapper class = "cn.zc.javapro.database.mybatis.mapper.UserMapper" />-->
    </mappers>
</configuration>

mybatis-mysql-config.xml

2、添加一个新的实体类UserEntity.java

package cn.zc.javapro.database.mybatis.entity;

import lombok.Data;

import java.io.Serializable;

@Data
public class UserEntity implements Serializable {
    private int id;
    // 邮箱
    private String email;
    // 昵称
    private String nickName;
    // 密码
    private String passWord;
    // 注册时间
    private String regTime;
    // 用户名
    private String userName;
}

UserEntity.java

3、添加一个新的Mapper，UserMapper.java

package cn.zc.javapro.database.mybatis.mapper;

import cn.zc.javapro.database.mybatis.entity.UserEntity;

import java.util.List;

public interface UserMapper {

    List<UserEntity> list();
}

UserMapper.java

4、添加一个新的配置文件，User.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">
<!--新建实体映射文件 User.xml，这里的namespace就是写 UserMapper 全类名，否则不能使用动态代理的方式调用接口 UserMapper-->
<mapper namespace="cn.zc.javapro.database.mybatis.mapper.UserMapper">

    <!--配置 查询结果的列明和实体类的属性名的对应关系-->
    <resultMap id="userMap" type="UserEntity">
        <!--主键字段的对应 -->
        <id property="id" javaType="Integer" column="id"></id>
        <!--非主键字段的对应-->
        <result property="email" javaType="String" column="email"></result>
        <result property="nickName" javaType="String" column="nick_name"></result>
        <result property="passWord" javaType="String" column="pass_word"></result>
        <result property="regTime" javaType="String" column="reg_time"></result>
        <result property="userName" javaType="String" column="user_name"></result>
    </resultMap>

    <select id="list" resultMap="userMap">
        SELECT * FROM user
    </select>

    <!--<select id="list" resultType="TestEntity">
        SELECT * FROM t_test
    </select>-->

    <!--<select id="list" resultType="TestEntity">
        SELECT id,create_time as createTime,modify_time as modifyTime ,content
         FROM t_test
    </select>-->
</mapper>

User.xml

5、修改主类，进行测试

package cn.zc.javapro.database.mybatis;

import cn.zc.javapro.database.mybatis.entity.UserEntity;
import cn.zc.javapro.database.mybatis.mapper.TestMapper;
import cn.zc.javapro.database.mybatis.mapper.TestMapper2;
import cn.zc.javapro.database.mybatis.mapper.UserMapper;
import cn.zc.javapro.database.mybatis.tools.MybatisTools;
import cn.zc.javapro.database.mybatis.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

public class SimpleMybatisMysqlApp {
    public static void main(String[] args) {
        System.out.println("------------test3--------------");
        test3();
        System.out.println("------------test4--------------");
        test4();
    }

    public static void test4() {
        SqlSession sqlSession;
        UserMapper userMapper;
        //
        MybatisTools mybatisTools = new MybatisTools("mybatis-mysql-config.xml");
        sqlSession = mybatisTools.openCurrentSqlSession();
        //得到 UserMapper 接口的实现类对象，UserMapper 接口的实现类对象由 sqlSession.getMapper(UserMapper.class)动态构建出来
        userMapper = sqlSession.getMapper(UserMapper.class);

        //执行查询操作，将查询结果自动封装成 UserEntity 返回
        for(UserEntity userEntity: userMapper.list()) {
            System.out.println(userEntity);
        }

        mybatisTools.closeCurrentSqlSession();
    }

    public static void test3() {
        SqlSession sqlSession;
        TestMapper2 testMapper2;
        //
        MybatisTools mybatisTools = new MybatisTools("mybatis-config.xml");
        sqlSession = mybatisTools.openCurrentSqlSession();
        //得到 TestMapper 接口的实现类对象，TestMapper 接口的实现类对象由 sqlSession.getMapper(TestMapper.class)动态构建出来
        testMapper2 = sqlSession.getMapper(TestMapper2.class);

        //执行查询操作，将查询结果自动封装成 TestEntity 返回
        System.out.println(testMapper2.get(1));

        mybatisTools.closeCurrentSqlSession();
    }

    public static void test2() {
        SqlSession sqlSession;
        TestMapper testMapper;
        //
        MybatisTools mybatisTools = new MybatisTools("mybatis-config.xml");
        sqlSession = mybatisTools.openCurrentSqlSession();
        //得到 TestMapper 接口的实现类对象，TestMapper 接口的实现类对象由 sqlSession.getMapper(TestMapper.class)动态构建出来
        testMapper = sqlSession.getMapper(TestMapper.class);

        //执行查询操作，将查询结果自动封装成 TestEntity 返回
        System.out.println(testMapper.get(1));

        mybatisTools.closeCurrentSqlSession();
    }

    public static void test() {
        SqlSession sqlSession;
        TestMapper testMapper;
        sqlSession = MybatisUtils.getCurrentSqlSession();
        testMapper = sqlSession.getMapper(TestMapper.class);

        //
        System.out.println(testMapper.get(1));

        MybatisUtils.closeCurrentSession();
    }

}

SimpleMybatisMysqlApp.java

结果如下：

八、批量插入Insert与批量更新Update

待补充

https://www.cnblogs.com/zhangchao0515/p/14333262.html

参考：

Mybatis中进行批量更新（updateBatch）：https://www.cnblogs.com/eternityz/p/12284760.html

Mybatis批量新增和修改：https://blog.csdn.net/lan_qinger/article/details/84138216

MyBatis批量新增数据：https://www.cnblogs.com/shouyaya/p/12797984.html

总结：

1） Mybatis是在 JDBC基础上进行进一步封装

2）Mybatis用到了很多设计模式，包括但不限于工厂模式，建造者模式，代理模式，适配模式（比如MySQL、Oracle等）；还用到反射等。

3）Mybatis隐藏了细节，最终肯定要把实体类的成员变量和表的列名一一对应起来。其中实体类的成员变量通过get方法获取值，通过set方法设置值。

posted @ 2021-01-23 11:33 秦时明月0515 阅读(1498) 评论(0) 编辑收藏举报

刷新页面返回顶部

秦时明月0515

一步两步三步。。。 知其然且知其所以然。

框架-java：Mybatis+mysql入门使用

Mybatis+mysql 入门使用

一、新建一个java maven项目-Mybatis+mysql 配置文件版本入门使用

1、添加依赖

2、初始化数据库和初始数据

3、新建实体类TestEntity.java

4、新建接口TestMapper.java

5、 新建实体映射文件Test.xml

6、新建mybatis配置信息文件mybatis-config.xml

这里重点说一下，我们可以单独通过XML来配置环境变量。

也可以通过 xml + properties 文件进行配置，

也可以通过 properties + xml文件进行配置，

还可以通过 yml + xml 文件进行配置。

比如，xml的配置还有另一种写法，即 xml + properties，下面的只写主要部分：

7、为了方便测试，编写一个获取SqlSession的工具类MybatisTools.java

8、 新建测试类TestMapperTest测试

9、主方法中调用

二、Mybatis (ParameterType) 如何传递多个不同类型的参数

1、 方法一：不需要写parameterType参数

2、方法二：基于注解(最简单)

3、方法三：Map封装

4、方法四：List封装

5、总结

四、Mybatis (resultType) 返回结果

1、通过起别名的方式

2、文档进行一个配置，创建了一个结果集的关系表

总结

五、Mybatis+mysql 注解版本入门使用

1、修改 mybatis-config.xml

2、添加接口 TestMapper2.java

3、修改主类SimpleMybatisMysqlApp，测试一下

六、自定义的数据源

1、我们配置一下自定义的数据源

2、修改mybatis-config.xml，如下所示：

3、编写测试方法TestDruidDemo.java

七、配置多数据源

1、配置一个新的mybatis-mysql-config.xml，因为来自不同的库。

2、添加一个新的实体类UserEntity.java

3、添加一个新的Mapper，UserMapper.java

4、添加一个新的配置文件，User.xml

5、修改主类，进行测试

八、批量插入Insert与批量更新Update

总结：

公告

一步两步三步。。。知其然且知其所以然。

5、新建实体映射文件Test.xml

8、新建测试类TestMapperTest测试

1、方法一：不需要写parameterType参数