MyBatis01

最新推荐文章于 2022-05-02 20:40:29 发布

做个挖井人

最新推荐文章于 2022-05-02 20:40:29 发布

阅读量134

点赞数

分类专栏： MyBatis源码学习文章标签： mybatis

本文链接：https://blog.csdn.net/zj499063104/article/details/102478201

版权

MyBatis源码学习专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

一、传统JDBC弊端
二、ORM框架MyBatis介绍
三、MyBatis快速开始&配置详解
四、MyBatis xml 与 annotation 优缺点
五、Mybatis插件（plugin）
六、逆向工程

一、传统JDBC弊端

jdbc底层没有用连接池、操作数据库需要频繁的创建和关联链接。消耗很大的资源。
写原生的jdbc代码在java中，一旦我们要修改sql的话，java需要整体编译，不利于系统维护。
使用PreparedStatement预编译的话对变量进行设置123数字，这样的序号不利于维护。
返回result结果集也需要硬编码。

二、ORM框架MyBatis介绍

MyBatis is a first class persistence framework with support for custom SQL, stored procedures and advanced mappings. MyBatis eliminates almost all of the JDBC code and manual setting of parameters and retrieval of results. MyBatis can use simple XML or Annotations for configuration and map primitives, Map interfaces and Java POJOs (Plain Old Java Objects) to database records.

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

三、MyBatis快速开始&配置详解

一、MyBatis快速开始

登陆官网

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.4</version>
</dependency>

创建一个test类

@Slf4j
public class MyBatisTest {

    @Test
    public void test() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            User user = session.selectOne("org.mybatis.example.BlogMapper.selectUser", 1);
            log.info("user:{}",user);
        }
    }

创建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/zj_mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF8&amp;serverTimezone=GMT"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mybatis/UserMapper.xml"/>
    </mappers>
</configuration>

test类中添加执行SQL代码

@Slf4j
public class MyBatisTest {

    @Test
    public void test() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            User user = session.selectOne("org.mybatis.example.BlogMapper.selectUser", 1);
            log.info("user:{}",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="org.mybatis.example.BlogMapper">
    <select id="selectUser" resultType="zj.cn.mybatis.pojo.User">
    select * from user where id = #{id}
  </select>
</mapper>

package zj.cn.mybatis.pojo;

import lombok.ToString;
import org.apache.ibatis.type.Alias;

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

@ToString
public class User implements Serializable{

  private Integer id;
  private String name;
  private  Integer age;
  private String phone;
  private Date desc;

  public Integer getId() {
    return id;
  }

  public void setId(Integer id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Integer getAge() {
    return age;
  }

  public void setAge(Integer age) {
    this.age = age;
  }

  public String getPhone() {
    return phone;
  }

  public void setPhone(String phone) {
    this.phone = phone;
  }

  public Date getDesc() {
    return desc;
  }

  public void setDesc(Date desc) {
    this.desc = desc;
  }

}

二、配置详解

配置文件：mybatis-config.xml中

<configuration>
<!--这中间可以有这些属性：properties, settings, typeAliases
, typeHandlers, objectFactory, objectWrapperFactory
, reflectorFactory, plugins, environments, databaseIdProvider, mappers
另外要强调一点，配置顺序也要按照上面的顺序配置，否则报错-->
</configuration>

官网给我们做了一一的介绍
在这里插入图片描述

一、properties

创建config.properties

#需要的数据库驱动
driver=com.mysql.cj.jdbc.Driver
#数据库名路径
url=jdbc:mysql://localhost:3306/zj_mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF8&serverTimezone=GMT
#用户名
username=root
#密码
password=123456

在mybatis-config.xml中添加properties属性

<?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="config.properties">
        <!-- 如果这里定义的属性与config.properties中的属性重复，config.properties优先级大于这里 -->
    	<property name="password" value="root"/>
    </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="mybatis/UserMapper.xml"/>
    </mappers>
</configuration>

二、settings

第三节课讲

三、typeAliases（类型别名）

类路径比较长，用一个别名来代替。
比如UserMapper.xml中resultType="zj.cn.mybatis.pojo.User"太长，用一个别名类代替

<?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="config.properties">
        <!-- 如果这里定义的属性与config.properties中的属性重复，config.properties优先级大于这里 -->
        <property name="password" value="root"/>
    </properties>
    <typeAliases>
        <!-- 用abc作为别名代替resultType类型；如果不写alias="abc"，默认的别名为小写user-->
        <typeAlias type="zj.cn.mybatis.pojo.User" alias="abc"/>
    </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>
        <mapper resource="mybatis/UserMapper.xml"/>
    </mappers>
</configuration>

<?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="org.mybatis.example.BlogMapper">
    <select id="selectUser" resultType="abc">
    select * from user where id = #{id}
  </select>
</mapper>

将整个包路径下的类都做别名处理
首先添加

<typeAliases>
<!--表示这个包下的所有类都可以通过注解标记@Alias做别名处理-->
  <package name="domain.blog"/>
</typeAliases>

然后在domain.blog路径下的类上添加注解标记@Alias(“abc”)，表示它的别名是abc，如果不加这个注解默认的别名为类名小写：author

@Alias("abc")
public class Author {
    ...
}

<?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="config.properties">
        <!-- 如果这里定义的属性与config.properties中的属性重复，config.properties优先级大于这里 -->
        <property name="password" value="root"/>
    </properties>
    <typeAliases>
        <!-- 用abc作为别名代替resultType类型；如果不写alias="abc"，默认的别名为小写user-->
        <!--typeAlias type="zj.cn.mybatis.pojo.User" alias="abc"/-->
        <!-- 表示这个包下的所有类都可以通过注解标记@Alias做别名处理-->
        <package name="zj.cn.mybatis.pojo"/>
    </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>
        <mapper resource="mybatis/UserMapper.xml"/>
    </mappers>
</configuration>

四、typeHandlers

无论是 MyBatis 在预处理语句中设置一个参数，还是从结果集中取出一个值时，类型处理器（Type Handler）被用来将获取的值以合适的方式转换成 Java 类型。下面这个表格描述了默认的类型处理器。
你可以重写类型处理器或创建你自己的类型处理器来处理不支持的或非标准的类型。要这样做的话，简单实现 TypeHandler 接口（org.mybatis.type），然后映射新的类型处理器类到 Java 类型，还有可选的一个 JDBC 类型。例如：将数据库中的VARCHAR类型，转换成java的Date类型

新建 BatTypeHandler 类，实现 TypeHandler 接口

package zj.cn.mybatis.hander;

import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeHandler;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class BatTypeHandler implements TypeHandler<Date> {

   // 设置sql中指定索引的参数，即将javaType转化为jdbcType
   @Override
   public void setParameter(PreparedStatement ps, int i, Date parameter, JdbcType jdbcType) throws SQLException {
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      ps.setString(i, simpleDateFormat.format(parameter));
   }

   // 根据列名称从结果集获取值，并将jdbcType转换成javaType
   @Override
   public Date getResult(ResultSet rs, int columnIndex) throws SQLException {
      String columnValue = rs.getString(columnIndex);
      if (null != columnValue) {
         return new Date(Long.valueOf(columnValue));
      }
      return null;
   }

   // 根据列名称从结果集获取值，并将jdbcType转换成javaType
   @Override
   public Date getResult(ResultSet rs, String columnName) throws SQLException {
      String columnValue = rs.getString(columnName);
      if (null != columnValue) {
         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         try {
            return format.parse(columnValue);
         } catch (ParseException e) {
            return  null;
         }

      }
      return null;
   }

   @Override
   public Date getResult(CallableStatement cs, int columnIndex) throws SQLException {
      String columnValue = cs.getString(columnIndex);
      if (null != columnValue) {
         return new Date(Long.valueOf(columnValue));
      }
      return null;
   }
}

mybatis-config.xml中添加配置：

<typeHandlers>
    <typeHandler handler="zj.cn.mybatis.hander.BatTypeHandler" jdbcType="VARCHAR" javaType="Date"></typeHandler>
</typeHandlers>

五、mappers

mapper加载方式

resource = xxxxMapper.xml 路径；这种使用的是XML（MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO为数据库中的记录）

<!-- Using classpath relative resources -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

这种暂时没讲

<!-- Using url fully qualified paths -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>

class = UserMapper（这是一个接口）路径；这种使用的是注解（MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO为数据库中的记录）

package zj.cn.mybatis.mapper;

import org.apache.ibatis.annotations.Select;
import zj.cn.mybatis.pojo.User;

public interface UserMapper {
 /*  @Results({
           @Result(property ="name",column = "username")
   })*/
   @Select("select id,username as name,age,phone,`desc` from User where id = #{id}")
   public User selectUser(Integer id);
}

<!-- Using mapper interface classes -->
<mappers>
  <mapper class="zj.cn.mybatis.mapper.UserMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

这种暂时没讲

<!-- Register all interfaces in a package as mappers -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

四、MyBatis xml 与 annotation 优缺点

Annotaion方式：

不适合比较复杂的sql 比如关联查询
不方便管理（收集）sql

Xml方式：

增加xml文件的复杂性
对于条件判断的SQL语句（动态SQL语句），不确定最终的查询语句是什么
特殊字符转义（特殊字符特指：<, >）

五、Mybatis插件（plugin）

MyBatis 允许你在某一点拦截已映射语句执行的调用。默认情况下，MyBatis 允许使用插件来拦截方法调用：

Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
ParameterHandler (getParameterObject, setParameters)
ResultSetHandler (handleResultSets, handleOutputParameters)
StatementHandler (prepare, parameterize, batch, update, query)

这些类中方法的详情可以通过查看每个方法的签名来发现，而且它们的源代码存在于MyBatis 的发行包中。你应该理解你所覆盖方法的行为，假设你所做的要比监视调用要多。如果你尝试修改或覆盖一个给定的方法，你可能会打破 MyBatis 的核心。这是低层次的类和方法，要谨慎使用插件。使用插件是它们提供的非常简单的力量。简单实现拦截器接口，要确定你想拦截的指定签名。
例如：在执行SQL的时候增加拦截，打印SQL的执行时间，和具体执行的SQL。
首先，新建实现 Interceptor 接口的 SqlPrintInterceptor 类

package zj.cn.mybatis.plugin;

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.ParameterMode;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.type.TypeHandlerRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Properties;
import java.util.regex.Matcher;

@Intercepts
        ({
                @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
                @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
        })
public class SqlPrintInterceptor implements Interceptor{

    private static final Logger log = LoggerFactory.getLogger(SqlPrintInterceptor.class);

    private static final DateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        Object parameterObject = null;
        if (invocation.getArgs().length > 1) {
            parameterObject = invocation.getArgs()[1];
        }
        long start = System.currentTimeMillis();
        Object result = invocation.proceed();
        String statementId = mappedStatement.getId();
        BoundSql boundSql = mappedStatement.getBoundSql(parameterObject);
        Configuration configuration = mappedStatement.getConfiguration();
        String sql = getSql(boundSql, parameterObject, configuration);
        long end = System.currentTimeMillis();
        long timing = end - start;
        if(log.isInfoEnabled()){
            log.info("执行sql耗时:" + timing + " ms" + " - id:" + statementId + " - Sql:" );
            log.info("   "+sql);
        }
        return result;
    }

    @Override
    public Object plugin(Object target) {
        if (target instanceof Executor) {
            return Plugin.wrap(target, this);
        }
        return target;
    }

    @Override
    public void setProperties(Properties properties) {
    }

    private String getSql(BoundSql boundSql, Object parameterObject, Configuration configuration) {
        String sql = boundSql.getSql().replaceAll("[\\s]+", " ");
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
        if (parameterMappings != null) {
            for (int i = 0; i < parameterMappings.size(); i++) {
                ParameterMapping parameterMapping = parameterMappings.get(i);
                if (parameterMapping.getMode() != ParameterMode.OUT) {
                    Object value;
                    String propertyName = parameterMapping.getProperty();
                    if (boundSql.hasAdditionalParameter(propertyName)) {
                        value = boundSql.getAdditionalParameter(propertyName);
                    } else if (parameterObject == null) {
                        value = null;
                    } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                        value = parameterObject;
                    } else {
                        MetaObject metaObject = configuration.newMetaObject(parameterObject);
                        value = metaObject.getValue(propertyName);
                    }
                    sql = replacePlaceholder(sql, value);
                }
            }
        }
        return sql;
    }

    private String replacePlaceholder(String sql, Object propertyValue) {
        String result;
        if (propertyValue != null) {
            if (propertyValue instanceof String) {
                result = "'" + propertyValue + "'";
            } else if (propertyValue instanceof Date) {
                result = "'" + DATE_FORMAT.format(propertyValue) + "'";
            } else {
                result = propertyValue.toString();
            }
        } else {
            result = "null";
        }
        return sql.replaceFirst("\\?", Matcher.quoteReplacement(result));
    }
}

然后在配置文件 mybatis-config.xml 中添加配置

<plugins>
    <plugin interceptor="zj.cn.mybatis.plugin.SqlPrintInterceptor"></plugin>
</plugins>

六、逆向工程

一、添加配置文件

打开官网：MyBatis Generator
pom.xml 文件中添加配置

 <project ...>
     ...
     <build>
       ...
       <plugins>
        ...
        <plugin>
          <groupId>org.mybatis.generator</groupId>
          <artifactId>mybatis-generator-maven-plugin</artifactId>
          <version>1.3.7</version>
        </plugin>
        ...
      </plugins>
      ...
    </build>
    ...
  </project>

除了要增加官方文档
3. 添加配置文件
在这里插入图片描述
注意：打开官方文档：Datebase Specific information for MySql
上面的英文文档翻译过来就是:
如果您使用的是Connector / J的8.x版，您可能会注意到生成器尝试为MySql信息模式（sys，information_schema，performance_schema等）中的表生成代码。这可能不是您想要的！要禁用此行为，请将属性“nullCatalogMeansCurrent = true”添加到JDBC。

 <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://localhost/my_schema"
            userId="my_user" password="my_password">
        <property name="nullCatalogMeansCurrent" value=true" />
    </jdbcConnection>

本人使用的mysql的数据库版本为8，连带使用 mysql-connector-java.version：8.0.12，所以配置文件中需要添加以上那一段。

<?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>
    <context id="mybatisTables" targetRuntime="MyBatis3">
        <!-- 注释 -->
        <commentGenerator>
            <property name="suppressAllComments" value="false"/>
            <!-- 是否取消注释 -->
        </commentGenerator>

        <!-- jdbc连接 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/zj_mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF8&amp;serverTimezone=GMT"
                        userId="root"
                        password="123456">
            <!-- mysql版本8，需要加上这一段，低版本不需要-->
            <property name="nullCatalogMeansCurrent" value="true"/>
        </jdbcConnection>
        <!-- 类型转换 -->
        <javaTypeResolver>
            <!-- 是否使用bigDecimal， false可自动转化以下类型（Long, Integer, Short, etc.） -->
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>
        <!-- 生成实体类的包名和位置 注意targetProject的值为实体类放在工程中具体位置的相对路径，-->
        <javaModelGenerator targetPackage="zj.cn.generator.pojo" targetProject="${user.dir}\src\main\java">
            <property name="enableSubPackages" value="true"/>
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>
        <!-- 生成的SQLMapper映射文件包名和位置 -->
        <sqlMapGenerator targetPackage="mybatis" targetProject="${user.dir}\src\main\resources">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>
        <!-- 生成DAO的包名和位置，这里配置将生成的dao类放在me.gacl.dao这个包下 -->
        <javaClientGenerator type="ANNOTATEDMAPPER" targetPackage="zj.cn.generator.mapper"
                             targetProject="${user.dir}\src\main\java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>
        <!-- 配置表信息 -->
        <!-- schema即为数据库名 tableName为对应的数据库表 domainObjectName是要生成的实体类 enable*ByExample
             是否生成 example类   -->
        <!-- 更改tableName和domainObjectName就可以 -->
        <table schema="zj_mybatis" tableName="user" domainObjectName="User">
            <property name="useActualColumnNames" value="true"/>
            <generatedKey column="ID" sqlStatement="Mysql" identity="true"/>
            <columnOverride column="DATE_FIELD" property="startDate"/>
            <ignoreColumn column="FRED"/>
            <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR"/>
        </table>
    </context>
</generatorConfiguration>

二、执行命令：mvn mybatis-generator:generate

执行命令生成 Mapper 和 POJO
打开官方文档，执行：mvn mybatis-generator:generate

最终生成的代码如下图：

这里介绍三种方法执行，

第一种方法：
第二种方法：
第三种方法：

三、javaClientGenerator

以上配置文件会生成注解形式（MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO 为数据库中的记录）的 Mapper 和 POJO
打开官方文档javaClientGenerator，介绍了几种方式，如下图：
在这里插入图片描述

将以下这段配置，

<!-- 生成DAO的包名和位置，这里配置将生成的dao类放在me.gacl.dao这个包下 -->
        <javaClientGenerator type="ANNOTATEDMAPPER" targetPackage="zj.cn.generator.mapper"
                             targetProject="${user.dir}\src\main\java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>

改成一下形式，就会生成xml形式 Mapper 和 POJO

<!-- 生成DAO的包名和位置，这里配置将生成的dao类放在me.gacl.dao这个包下 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="zj.cn.generator.mapper"
                             targetProject="${user.dir}\src\main\java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>

在这里插入图片描述

四、测试

测试生成的mapper 和pojo时需要注意，字段desc是关键字，所以在测试时需要修改生成的sql语句，加上键盘左上角Esc下面的那个字符 ` ，例如：

select id, username, age, phone, `desc` from user where id = 1;

以下为本人的源码：
链接: https://pan.baidu.com/s/1hMaUf20F65pyuWBxt0cfNA 提取码: 85xv 复制这段内容后打开百度网盘手机App，操作更方便哦

做个挖井人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MyBatis01

文章目录一、传统JDBC弊端二、ORM框架MyBatis介绍三、MyBatis快速开始&配置详解一、传统JDBC弊端jdbc底层没有用连接池、操作数据库需要频繁的创建和关联链接。消耗很大的资源。写原生的jdbc代码在java中，一旦我们要修改sql的话，java需要整体编译，不利于系统维护。使用PreparedStatement预编译的话对变量进行设置123数字，这样的序号不利于...
复制链接

扫一扫