本文详细介绍了如何在SpringBoot项目中利用MyBatis的自动化代码生成工具，包括配置依赖、插件及生成配置文件，适用于MySQL和Oracle数据库，通过具体步骤指导读者快速生成实体类、Mapper接口及XML映射文件。
spring boot 使用mybatis自动生成方法：
首先pom.xml添加依赖:
<dependency>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-core</artifactId>
<version>1.3.5</version>
</dependency>
在build—>plugins下面添加：
<!-- mybatis-generator自动生成代码插件 -->
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.5</version>
</plugin>
接下来是mybatis自动生成的配置文件：
mysql配置：
<?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="mysql" defaultModelType="hierarchical" targetRuntime="MyBatis3Simple">
<!-- 自动识别数据库关键字，默认false，如果设置为true，根据SqlReservedWords中定义的关键字列表； 一般保留默认值，遇到数据库关键字（Java关键字），使用columnOverride覆盖 -->
<property name="autoDelimitKeywords" value="false" />
<!-- 生成的Java文件的编码 -->
<property name="javaFileEncoding" value="UTF-8" />
<!-- beginningDelimiter和endingDelimiter：指明数据库的用于标记数据库对象名的符号，比如ORACLE就是双引号，MYSQL默认是`反引号； -->
<property name="beginningDelimiter" value="`" />
<property name="endingDelimiter" value="`" />
<!-- 注释生成器 -->
<commentGenerator>
<property name="suppressDate" value="true"/>
<property name="suppressAllComments" value="true" />
</commentGenerator>
<!-- 必须要有的，使用这个配置链接数据库 @TODO:是否可以扩展 -->
<jdbcConnection driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://115.159.xx.xx/lingyu-system" userId="root" password="123456">
<!-- 这里面可以设置property属性，每一个property属性都设置到配置的Driver上 -->
</jdbcConnection>
<!-- java模型创建器，是必须要的元素 负责：1，key类（见context的defaultModelType）；2，java类；3，查询类
targetPackage：生成的类要放的包，真实的包受enableSubPackages属性控制； targetProject：目标项目，指定一个存在的目录下，生成的内容会放到指定目录中，如果目录不存在，MBG不会自动建目录 -->
<javaModelGenerator targetPackage="com.xxx.cloud.modules.xx.entity" targetProject="src/main/java">
<!-- for MyBatis3/MyBatis3Simple 自动为每一个生成的类创建一个构造方法，构造方法包含了所有的field；而不是使用setter； -->
<property name="constructorBased" value="false" />
<!-- for MyBatis3 / MyBatis3Simple 是否创建一个不可变的类，如果为true， 那么MBG会创建一个没有setter方法的类，取而代之的是类似constructorBased的类 -->
<property name="immutable" value="false" />
</javaModelGenerator>
<!-- 生成SQL map的XML文件生成器， 注意，在Mybatis3之后，我们可以使用mapper.xml文件+Mapper接口（或者不用mapper接口），
或者只使用Mapper接口+Annotation，所以，如果 javaClientGenerator配置中配置了需要生成XML的话，这个元素就必须配置
targetPackage/targetProject:同javaModelGenerator -->
<sqlMapGenerator targetPackage="mapper/sys"
targetProject="src/main/resources">
<!-- 在targetPackage的基础上，根据数据库的schema再生成一层package，最终生成的类放在这个package下，默认为false -->
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>
<!-- 对于mybatis来说，即生成Mapper接口，注意，如果没有配置该元素，那么默认不会生成Mapper接口 targetPackage/targetProject:同javaModelGenerator
type：选择怎么生成mapper接口（在MyBatis3/MyBatis3Simple下）：
1，ANNOTATEDMAPPER：会生成使用Mapper接口+Annotation的方式创建（SQL生成在annotation中），不会生成对应的XML；
2，MIXEDMAPPER：使用混合配置，会生成Mapper接口，并适当添加合适的Annotation，但是XML会生成在XML中；
3，XMLMAPPER：会生成Mapper接口，接口完全依赖XML；
注意，如果context是MyBatis3Simple：只支持ANNOTATEDMAPPER和XMLMAPPER -->
<javaClientGenerator targetPackage="com.xxx.cloud.modules.xx.dao"
type="XMLMAPPER" targetProject="src/main/java">
<!-- 在targetPackage的基础上，根据数据库的schema再生成一层package，最终生成的类放在这个package下，默认为false -->
<property name="enableSubPackages" value="true" />
<!-- 可以为所有生成的接口添加一个父接口，但是MBG只负责生成，不负责检查 <property name="rootInterface"
value=""/> -->
</javaClientGenerator>
<table tableName="sys_validation" domainObjectName="ValidationEntity" mapperName="ValidationEntityDao">
<!-- 参考 javaModelGenerator 的 constructorBased属性 -->
<property name="constructorBased" value="false" />
<generatedKey column="id" sqlStatement="JDBC" />
</table>
</context>
</generatorConfiguration>
Oracle配置：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
<!-- 指定数据连接驱动jar地址 -->
<classPathEntry location="D:\lib\ojdbc6-11.2.0.1.0.jar" />
<context id="my" defaultModelType="flat" targetRuntime="MyBatis3">
<!-- 自动识别数据库关键字，默认false，如果设置为true，根据SqlReservedWords中定义的关键字列表； 一般保留默认值，遇到数据库关键字（Java关键字），使用columnOverride覆盖 -->
<property name="autoDelimitKeywords" value="false" />
<!-- 生成的Java文件的编码 -->
<property name="javaFileEncoding" value="UTF-8" />
<!-- JavaBean 实现 序列化 接口 -->
<!-- <plugin type="org.mybatis.generator.plugins.SerializablePlugin"/> -->
<!-- genenat entity时,生成toString -->
<plugin type="org.mybatis.generator.plugins.ToStringPlugin" />
<!-- beginningDelimiter和endingDelimiter：指明数据库的用于标记数据库对象名的符号，比如ORACLE就是双引号，MYSQL默认是`反引号； -->
<!-- <property name="beginningDelimiter" value="`" />
<property name="endingDelimiter" value="`" /> -->
<!-- 注释生成器 -->
<commentGenerator>
<property name="suppressAllComments" value="true" /><!-- 是否取消注释 -->
<property name="suppressDate" value="true" /> <!-- 是否生成注释代时间戳 -->
</commentGenerator>
<jdbcConnection driverClass="oracle.jdbc.driver.OracleDriver"
connectionURL="jdbc:oracle:thin:@10.50.xx.xx:1521:Test" userId="wxy"
password="wxy123456" />
<!-- java类型处理器
用于处理DB中的类型到Java中的类型，默认使用JavaTypeResolverDefaultImpl；
注意一点，默认会先尝试使用Integer，Long，Short等来对应DECIMAL和 NUMERIC数据类型；
-->
<!-- <javaTypeResolver type="org.mybatis.generator.internal.types.JavaTypeResolverDefaultImpl">
true：使用BigDecimal对应DECIMAL和 NUMERIC数据类型
false：默认,
scale>0;length>18：使用BigDecimal;
scale=0;length[10,18]：使用Long；
scale=0;length[5,9]：使用Integer；
scale=0;length<5：使用Short；
<property name="forceBigDecimals" value="false"/>
</javaTypeResolver> -->
<javaTypeResolver type="org.mybatis.generator.internal.types.MyJavaTypeResolverDefaultImpl"></javaTypeResolver>
<!-- 生成实体类地址 -->
<javaModelGenerator targetPackage="com.xxx.bean.xx"
targetProject="spring-boot-test/src/main/java">
<property name="enableSubPackages" value="true" />
<property name="trimStrings" value="false" />
</javaModelGenerator>
<!-- 生成mapxml文件 -->
<sqlMapGenerator targetPackage="xxx.mybatis.mapper.xx"
targetProject="spring-boot-test/src/main/resources">
<property name="enableSubPackages" value="false" />
</sqlMapGenerator>
<!-- 生成mapxml对应client，也就是接口dao -->
<javaClientGenerator targetPackage="com.xxx.dao.xx"
targetProject="spring-boot-test/src/main/java" type="XMLMAPPER">
<property name="enableSubPackages" value="false" />
</javaClientGenerator>
<!-- 选择一个table来生成相关文件，可以有一个或多个table，必须要有table元素
tableName（必要）：要生成对象的表名；
可选：
1，schema：数据库的schema；
2，catalog：数据库的catalog；
3，alias：为数据表设置的别名，如果设置了alias，那么生成的所有的SELECT SQL语句中，列名会变成：alias_actualColumnName
4，domainObjectName：生成的domain类的名字，如果不设置，直接使用表名作为domain类的名字；可以设置为somepck.domainName，那么会自动把domainName类再放到somepck包里面；
5，enableInsert（默认true）：指定是否生成insert语句；
6，enableSelectByPrimaryKey（默认true）：指定是否生成按照主键查询对象的语句（就是getById或get）；
7，enableSelectByExample（默认true）：MyBatis3Simple为false，指定是否生成动态查询语句；
8，enableUpdateByPrimaryKey（默认true）：指定是否生成按照主键修改对象的语句（即update)；
9，enableDeleteByPrimaryKey（默认true）：指定是否生成按照主键删除对象的语句（即delete）；
10，enableDeleteByExample（默认true）：MyBatis3Simple为false，指定是否生成动态删除语句；
11，enableCountByExample（默认true）：MyBatis3Simple为false，指定是否生成动态查询总条数语句（用于分页的总条数查询）；
12，enableUpdateByExample（默认true）：MyBatis3Simple为false，指定是否生成动态修改语句（只修改对象中不为空的属性）；
13，modelType：参考context元素的defaultModelType，相当于覆盖；
14，delimitIdentifiers：参考tableName的解释，注意，默认的delimitIdentifiers是双引号，如果类似MYSQL这样的数据库，使用的是`（反引号，那么还需要设置context的beginningDelimiter和endingDelimiter属性）
15，delimitAllColumns：设置是否所有生成的SQL中的列名都使用标识符引起来。默认为false，delimitIdentifiers参考context的属性
注意，table里面很多参数都是对javaModelGenerator，context等元素的默认属性的一个复写；
-->
<table tableName="ORDER_INFO"
domainObjectName="OrderEntity" enableCountByExample="false"
enableUpdateByExample="false" enableDeleteByExample="false"
enableSelectByExample="false" selectByExampleQueryId="false"
>
<!-- <property name="useActualColumnNames" value="true" /> -->
</table>
</context>
</generatorConfiguration>
这是要注意一下，
使用Oracle数据库的时候，需要重写两个类，因为oracle里的nvachar2类型，mybatis无法识别，会转换成object类型；
package org.mybatis.generator.internal.types;
import java.sql.Types;
import org.mybatis.generator.api.dom.java.FullyQualifiedJavaType;
public class MyJavaTypeResolverDefaultImpl extends JavaTypeResolverDefaultImpl{
public MyJavaTypeResolverDefaultImpl() {
super();
//把数据库的 NVARCHAR2 映射成 String
super.typeMap.put(Types.OTHER, new JdbcTypeInformation("NVARCHAR2", new FullyQualifiedJavaType(String.class.getName())));
}
}
第二个是IntrospectedColumn，我这里直接贴源码；
/**
* Copyright 2006-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.mybatis.generator.api;
import java.sql.Types;
import java.util.Properties;
import org.mybatis.generator.api.dom.java.FullyQualifiedJavaType;
import org.mybatis.generator.config.Context;
import org.mybatis.generator.internal.util.StringUtility;
/**
* This class holds information about an introspected column. The class has
* utility methods useful for generating iBATIS objects.
*
* @author Jeff Butler
* update wangxinyang 20190123
*/
public class IntrospectedColumn {
protected String actualColumnName;
protected int jdbcType;
protected String jdbcTypeName;
protected boolean nullable;
protected int length;
protected int scale;
protected boolean identity;
protected boolean isSequenceColumn;
protected String javaProperty;
protected FullyQualifiedJavaType fullyQualifiedJavaType;
protected String tableAlias;
protected String typeHandler;
protected Context context;
protected boolean isColumnNameDelimited;
protected IntrospectedTable introspectedTable;
protected Properties properties;
// any database comment associated with this column. May be null
protected String remarks;
protected String defaultValue;
/**
* true if the JDBC driver reports that this column is auto-increment
*/
protected boolean isAutoIncrement;
/**
* true if the JDBC driver reports that this column is generated
*/
protected boolean isGeneratedColumn;
/**
* True if there is a column override that defines this column as GENERATED ALWAYS
*/
protected boolean isGeneratedAlways;
/**
* Constructs a Column definition. This object holds all the information
* about a column that is required to generate Java objects and SQL maps;
*/
public IntrospectedColumn() {
super();
properties = new Properties();
}
public int getJdbcType() {
return jdbcType;
}
public void setJdbcType(int jdbcType) {
this.jdbcType = jdbcType;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public boolean isNullable() {
return nullable;
}
public void setNullable(boolean nullable) {
this.nullable = nullable;
}
public int getScale() {
return scale;
}
public void setScale(int scale) {
this.scale = scale;
}
/*
* This method is primarily used for debugging, so we don't externalize the
* strings
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("Actual Column Name: "); //$NON-NLS-1$
sb.append(actualColumnName);
sb.append(", JDBC Type: "); //$NON-NLS-1$
sb.append(jdbcType);
sb.append(", Nullable: "); //$NON-NLS-1$
sb.append(nullable);
sb.append(", Length: "); //$NON-NLS-1$
sb.append(length);
sb.append(", Scale: "); //$NON-NLS-1$
sb.append(scale);
sb.append(", Identity: "); //$NON-NLS-1$
sb.append(identity);
return sb.toString();
}
public void setActualColumnName(String actualColumnName) {
this.actualColumnName = actualColumnName;
isColumnNameDelimited = StringUtility
.stringContainsSpace(actualColumnName);
}
/**
* @return Returns the identity.
*/
public boolean isIdentity() {
return identity;
}
/**
* @param identity
* The identity to set.
*/
public void setIdentity(boolean identity) {
this.identity = identity;
}
public boolean isBLOBColumn() {
String typeName = getJdbcTypeName();
return "BINARY".equals(typeName) || "BLOB".equals(typeName) //$NON-NLS-1$ //$NON-NLS-2$
|| "CLOB".equals(typeName) || "LONGNVARCHAR".equals(typeName) //$NON-NLS-1$ //$NON-NLS-2$
|| "LONGVARBINARY".equals(typeName) || "LONGVARCHAR".equals(typeName) //$NON-NLS-1$ //$NON-NLS-2$
|| "NCLOB".equals(typeName) || "VARBINARY".equals(typeName); //$NON-NLS-1$ //$NON-NLS-2$
}
public boolean isStringColumn() {
return fullyQualifiedJavaType.equals(FullyQualifiedJavaType
.getStringInstance());
}
public boolean isJdbcCharacterColumn() {
return jdbcType == Types.CHAR || jdbcType == Types.CLOB
|| jdbcType == Types.LONGVARCHAR || jdbcType == Types.VARCHAR
|| jdbcType == Types.LONGNVARCHAR || jdbcType == Types.NCHAR
|| jdbcType == Types.NCLOB || jdbcType == Types.NVARCHAR;
}
public String getJavaProperty() {
return getJavaProperty(null);
}
public String getJavaProperty(String prefix) {
if (prefix == null) {
return javaProperty;
}
StringBuilder sb = new StringBuilder();
sb.append(prefix);
sb.append(javaProperty);
return sb.toString();
}
public void setJavaProperty(String javaProperty) {
this.javaProperty = javaProperty;
}
public boolean isJDBCDateColumn() {
return fullyQualifiedJavaType.equals(FullyQualifiedJavaType
.getDateInstance())
&& "DATE".equalsIgnoreCase(jdbcTypeName); //$NON-NLS-1$
}
public boolean isJDBCTimeColumn() {
return fullyQualifiedJavaType.equals(FullyQualifiedJavaType
.getDateInstance())
&& "TIME".equalsIgnoreCase(jdbcTypeName); //$NON-NLS-1$
}
public String getTypeHandler() {
return typeHandler;
}
public void setTypeHandler(String typeHandler) {
this.typeHandler = typeHandler;
}
public String getActualColumnName() {
return actualColumnName;
}
public void setColumnNameDelimited(boolean isColumnNameDelimited) {
this.isColumnNameDelimited = isColumnNameDelimited;
}
public boolean isColumnNameDelimited() {
return isColumnNameDelimited;
}
public String getJdbcTypeName() {
if (jdbcTypeName == null || jdbcTypeName.equalsIgnoreCase("NVARCHAR2")) {
return "OTHER"; //$NON-NLS-1$
}
return jdbcTypeName;
}
public void setJdbcTypeName(String jdbcTypeName) {
this.jdbcTypeName = jdbcTypeName;
}
public FullyQualifiedJavaType getFullyQualifiedJavaType() {
return fullyQualifiedJavaType;
}
public void setFullyQualifiedJavaType(
FullyQualifiedJavaType fullyQualifiedJavaType) {
this.fullyQualifiedJavaType = fullyQualifiedJavaType;
}
public String getTableAlias() {
return tableAlias;
}
public void setTableAlias(String tableAlias) {
this.tableAlias = tableAlias;
}
public Context getContext() {
return context;
}
public void setContext(Context context) {
this.context = context;
}
public IntrospectedTable getIntrospectedTable() {
return introspectedTable;
}
public void setIntrospectedTable(IntrospectedTable introspectedTable) {
this.introspectedTable = introspectedTable;
}
public Properties getProperties() {
return properties;
}
public void setProperties(Properties properties) {
this.properties.putAll(properties);
}
public String getRemarks() {
return remarks;
}
public void setRemarks(String remarks) {
this.remarks = remarks;
}
public String getDefaultValue() {
return defaultValue;
}
public void setDefaultValue(String defaultValue) {
this.defaultValue = defaultValue;
}
public boolean isSequenceColumn() {
return isSequenceColumn;
}
public void setSequenceColumn(boolean isSequenceColumn) {
this.isSequenceColumn = isSequenceColumn;
}
public boolean isAutoIncrement() {
return isAutoIncrement;
}
public void setAutoIncrement(boolean isAutoIncrement) {
this.isAutoIncrement = isAutoIncrement;
}
public boolean isGeneratedColumn() {
return isGeneratedColumn;
}
public void setGeneratedColumn(boolean isGeneratedColumn) {
this.isGeneratedColumn = isGeneratedColumn;
}
public boolean isGeneratedAlways() {
return isGeneratedAlways;
}
public void setGeneratedAlways(boolean isGeneratedAlways) {
this.isGeneratedAlways = isGeneratedAlways;
}
}
重写的上面这个类，重点在这里：
到这里配置文件就ok了；
-------------------------------------------------------------
在里面配置好数据源，表名，要生成的类名，然后就可以使用了；
对了，这里eclipse还要安装一个插件：
在eclipse的菜单栏点击 help—>Eclipse Marketplace ...
然后在search选项卡中搜索：mybatis
右下角的install，直接安装就好了。
我这里因为是已经安装过的，所以显示installed;
安装成功之后，在我们的generatorConfig.xml上点击右键：Run As
运行之后，控制台会打印日志，可以查看日志看是否生成成功，成功之后会在上面配置的包下面生成文件。
-------------------------------
还可以使用mybatis-plus的插件，这个配合相应的模版，能生成更多的文件诸如增删改查，从dao到controller都会有相关方法，更加便捷。
有兴趣可以探索一下。
程序员都是懒人，因为懒，所以我们在做一件事情的时候，会去寻找一更优的解决方案。
不将就，the end;
扫一扫
3380
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
