2. 程式人生 > >基於SpringBoot+Springmvc+mybatis+mybatis-generator程式碼自動生成的框架。

基於SpringBoot+Springmvc+mybatis+mybatis-generator程式碼自動生成的框架。

阿新 • • 發佈：2019-01-23

當我們在開發java程式的時候，經常會遇到快速開發，因此我們用spring Boot。spring Boot的牛逼之處就是快。

一：開發環境配置

開發環境：eclipse

java版本：1.8

maven:maven3.2.8

二：maven專案生成

首先在eclipse中點選New->maven->Maven Project 然後出現下圖點選next


接著繼續點選next.如下圖，點選finish


三：配置自動生成程式碼

1：在pom中引入需要的jar包。

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.3.6.RELEASE</version>
    </parent>


    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <start-class>com.practice.App</start-class>
        <java.version>1.7</java.version>
        <lombok.version>1.14.8</lombok.version>
        <log4jdbc.log4j2.version>1.16</log4jdbc.log4j2.version>
        <rest.assured.version>2.3.3</rest.assured.version>
    </properties>


    <dependencies>
        <!--MG依賴-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.2.8</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.3</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.3.3</version>
            <scope>test</scope>
        </dependency>
        <!--druid資料庫連線池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.26</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
        <!--springboot依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.bgee.log4jdbc-log4j2</groupId>
            <artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
            <version>${log4jdbc.log4j2.version}</version>
        </dependency>
        <!--springboottest依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- Springboot 熱部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <version>1.3.6.RELEASE</version>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.jayway.restassured</groupId>
            <artifactId>rest-assured</artifactId>
            <version>${rest.assured.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.2.7.RELEASE</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.21</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>1.3.6.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.1</version>
        </dependency>


        <!-- mybatis 分頁外掛 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>4.1.6</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!--MG的外掛-->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.3</version>
                <configuration>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
                <dependencies>
                    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java
            配置這個依賴主要是為了等下在配置MG的時候可以不用配置classPathEntry這樣的一個屬性，避免
            程式碼的耦合度太高 -->
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>5.1.38</version>
                    </dependency>
                </dependencies>
            </plugin>
            <!--springboot的外掛-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <dependencies>
                    <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>springloaded</artifactId>
                        <version>${spring-loaded.version}</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>

    </build>

2：準備相應的配置檔案

首先：在src/main/resources/下準備相應的properties檔案

(1):準備application.properties檔案。內容如下：

spring.thymeleaf.cache=false
logging.level.jdbc=OFF
logging.level.jdbc.sqltiming=error
logging.level.jdbc.resultsettable=error
#申明使用哪個配置檔案

spring.profiles.active=dev

(2):準備application-dev.properties檔案。準備這個檔案是英文有spring.profiles.active=dev決定，如果spring.profiles.active=test。這個時候就需要application-test.properties檔案了。

內容如下:

#資料庫配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test
spring.datasource.username=root
spring.datasource.password=
# 下面為連線池的補充設定，應用到上面所有資料來源中# 初始化大小，最小，最大
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
# 配置獲取連線等待超時的時間
spring.datasource.maxWait=60000
# 配置間隔多久才進行一次檢測，檢測需要關閉的空閒連線，單位是毫秒
spring.datasource.timeBetweenEvictionRunsMillis=60000
# 配置一個連線在池中最小生存的時間，單位是毫秒
spring.datasource.minEvictableIdleTimeMillis=300000
spring.datasource.validationQuery=SELECT 1 FROM DUAL
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
# 開啟PSCache，並且指定每個連線上PSCache的大小
spring.datasource.poolPreparedStatements=true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
# 配置監控統計攔截的filters，去掉後監控介面sql無法統計，'wall'用於防火牆
spring.datasource.filters=stat,wall,log4j
# 通過connectProperties屬性來開啟mergeSql功能；慢SQL記錄
spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
# 合併多個DruidDataSource的監控資料
#spring.datasource.useGlobalDataSourceStat=true


#檢視模型
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
spring.thymeleaf.cache=false
spring.thymeleaf.mode=HTML5
spring.thymeleaf.encoding=UTF-8
spring.thymeleaf.content-type=text/html

spring.thymeleaf.check-template-location=true

(3):準備自動生成程式碼xml檔案（generatorConfig.xml）以及xml檔案中配置檔案(generatorConfig.properties)

generatorConfig.properties內容如下：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/test
username=root

password=

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>
    <properties resource="generatorConfig.properties"/>


    <context id="ssm" targetRuntime="MyBatis3">
        <plugin type="org.mybatis.generator.plugins.EqualsHashCodePlugin" />
        <plugin type="org.mybatis.generator.plugins.SerializablePlugin" />
        <plugin type="org.mybatis.generator.plugins.CaseInsensitiveLikePlugin" />
        <!-- <plugin type="org.mybatis.generator.plugins.ToStringPlugin"></plugin> -->
        <commentGenerator>
            <property name="suppressDate" value="true" />
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!--
        <jdbcConnection driverClass="oracle.jdbc.driver.OracleDriver" connectionURL="jdbc:oracle:thin:@10.100.1.20:1521:db1"
          userId="rams_test" password="bangsun">
        </jdbcConnection>
        -->
        <jdbcConnection driverClass="${driver}"
                        connectionURL="${url}" userId="${username}" password="${password}">
        </jdbcConnection>


        <javaTypeResolver>
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!-- 生成javabean ,其中targetPackage是自動生成javabean的地址。 -->
        <javaModelGenerator targetPackage="com.zhm.SpringBootTest.pojo" targetProject="src/main/java">
            <property name="constructorBased" value="true" />
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>

 <!-- 生成sqlmap ,其中targetPackage是自動生成sqlMap的地址。 -->
        <sqlMapGenerator targetPackage="com.zhm.SpringBootTest.sqlmap" targetProject="src/main/resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
<!-- 生成sqlmap ,其中targetPackage是自動生成dao的地址。 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.zhm.SpringBootTest.mapper"
                             targetProject="src/main/java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>
        <table schema="mybatis" tableName="user" domainObjectName="User">
            <property name="constructorBased" value="true" />
            <property name="useActualColumnNames" value="false" />
            <property name="ignoreQualifiersAtRuntime" value="true" />
        </table>
    </context>

</generatorConfiguration>

其中紅色處特別注意，這是將sqlMapper放在資原始檔中。在下面的實現資料來源的配置要特別注意。

想了解更多generator.xml的知識可以參考如下：http://blog.csdn.net/wszhm123/article/details/76152663

通過上面的操作就配置好了自動生成程式碼的操作。

最後執行程式生成好程式碼：點選pom.xml右鍵 Run->Maven Build輸入mybatis-generator:generate點選執行，如下圖，就會生成好基礎程式碼和xml了。


四：實現基本功能。

1：實現資料來源的配置。準備如DruidDataSourceConfig的java。如下程式碼：



import com.alibaba.druid.pool.DruidDataSource;
import com.github.pagehelper.PageHelper;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.bind.RelaxedPropertyResolver;
import org.springframework.context.ApplicationContextException;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.util.StringUtils;


import java.sql.SQLException;
import java.util.Arrays;
import java.util.Properties;


/**
 * @author: YeJunwei  Date: 2016/12/2 Time: 15:07
 */
@Configuration
@EnableTransactionManagement

//掃描dao檔案地址
@MapperScan(value = "com.zhm.SpringBootTest.mapper")
public class DruidDataSourceConfig implements EnvironmentAware {


    private Environment environment;
    private RelaxedPropertyResolver propertyResolver;


    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
        this.propertyResolver = new RelaxedPropertyResolver(environment, "spring.datasource.");
    }


    //註冊dataSource
    @Bean(initMethod = "init", destroyMethod = "close")
    public DruidDataSource dataSource() throws SQLException {
        if (StringUtils.isEmpty(propertyResolver.getProperty("url"))) {
            System.out.println("Your database connection pool configuration is incorrect!"
                    + " Please check your Spring profile, current profiles are:"
                    + Arrays.toString(environment.getActiveProfiles()));
            throw new ApplicationContextException(
                    "Database connection pool is not configured correctly");
        }
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(propertyResolver.getProperty("driver-class-name"));
        druidDataSource.setUrl(propertyResolver.getProperty("url"));
        druidDataSource.setUsername(propertyResolver.getProperty("username"));
        druidDataSource.setPassword(propertyResolver.getProperty("password"));
        druidDataSource.setInitialSize(Integer.parseInt(propertyResolver.getProperty("initialSize")));
        druidDataSource.setMinIdle(Integer.parseInt(propertyResolver.getProperty("minIdle")));
        druidDataSource.setMaxActive(Integer.parseInt(propertyResolver.getProperty("maxActive")));
        druidDataSource.setMaxWait(Integer.parseInt(propertyResolver.getProperty("maxWait")));
        druidDataSource.setTimeBetweenEvictionRunsMillis(Long.parseLong(propertyResolver.getProperty("timeBetweenEvictionRunsMillis")));
        druidDataSource.setMinEvictableIdleTimeMillis(Long.parseLong(propertyResolver.getProperty("minEvictableIdleTimeMillis")));
        druidDataSource.setValidationQuery(propertyResolver.getProperty("validationQuery"));
        druidDataSource.setTestWhileIdle(Boolean.parseBoolean(propertyResolver.getProperty("testWhileIdle")));
        druidDataSource.setTestOnBorrow(Boolean.parseBoolean(propertyResolver.getProperty("testOnBorrow")));
        druidDataSource.setTestOnReturn(Boolean.parseBoolean(propertyResolver.getProperty("testOnReturn")));
        druidDataSource.setPoolPreparedStatements(Boolean.parseBoolean(propertyResolver.getProperty("poolPreparedStatements")));
        druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(Integer.parseInt(propertyResolver.getProperty("maxPoolPreparedStatementPerConnectionSize")));
        druidDataSource.setFilters(propertyResolver.getProperty("filters"));
        return druidDataSource;
    }


    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource());
        //mybatis分頁
        PageHelper pageHelper = new PageHelper();
        Properties props = new Properties();
        props.setProperty("dialect", "mysql");
        props.setProperty("reasonable", "true");
        props.setProperty("supportMethodsArguments", "true");
        props.setProperty("returnPageInfo", "check");
        props.setProperty("params", "count=countSql");
        pageHelper.setProperties(props); //新增外掛
        sqlSessionFactoryBean.setPlugins(new Interceptor[]{pageHelper});
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();

   //掃描xml檔案地址
        sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:com/zhm/SpringBootTest/sqlmap/*.xml"));
        return sqlSessionFactoryBean.getObject();
    }


    @Bean
    public PlatformTransactionManager transactionManager() throws SQLException {
        return new DataSourceTransactionManager(dataSource());
    }
}

2：準備相應的service 和Serviceimpl

如IUserService ,程式碼如下：

public interface IUserService {
User getUserById(String id);

}

如UserServiceImpl，程式碼如下：

@Component
public class UserServiceImpl implements IUserService{
  @Autowired
   private UserMapper userMapper;
  

@Override
public User getUserById(String id) {
// TODO Auto-generated method stub
return userMapper.selectByPrimaryKey(id);
}

}

3：準備controller，如UserController程式碼如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


import com.zhm.SpringBootTest.service.IUserService;


@RestController
public class UserController {


@Autowired
private IUserService userService;
@RequestMapping(value="/user/{id}")
public Object getUser(@PathVariable String id){
return userService.getUserById(id);
}

}

這樣基本功能就開發好了，接下來準備啟動java如下：

@SpringBootApplication
public class App 
{
    public static void main( String[] args )
    {
     SpringApplication.run(App.class, args);
    }

}

然後啟動App.java這樣服務就啟動了。完整的專案結構如下圖：


在頁面中輸入http://localhost:8080/user/1就會看到返回的json結果。

參考地址：http://blog.csdn.net/yezhuanxu/article/details/53483130

相關推薦

基於SpringBoot+Springmvc+mybatis+mybatis-generator程式碼自動生成的框架。

當我們在開發java程式的時候，經常會遇到快速開發，因此我們用spring Boot。spring Boot的牛逼之處就是快。 一：開發環境配置 開發環境：eclipse java版本：1.8 maven:maven3.2.8 二：maven專案生成 首先在eclipse中

Eclipse外掛：MyBatis Generator程式碼自動生成工具

MyBatis Generator是一款優秀的工具，可以幫助我們自動生成java實體類，mapper介面和xml，極大得簡化了開發流程，今天，就記錄下在eclipse中使用eclipse外掛整合MyBatis Generator的步驟； 【1：外掛安裝】Help--Eclipser Market

Mybatis generator 程式碼 自動生成外掛

前言：使用IDEA搭建springboot+mybatis框架，自動生成基礎檔案和mapping.xml 第一步： 在pom檔案中： <build> <plugins> <plugin>

springboot+mybatis配置generator.xml自動生成實體，xml檔案

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1

mybatis mybatis-generator 程式碼自動生成工具

一、簡介 mybatis generator是很好用的mybatis自動程式碼生成工具。最近公司使用maven和mybatis開發專案，手動寫入一個個實體類和mapper還有xml配置檔案感覺會很麻煩，使用mybatis generator只需要簡單的配置就能

maven專案自動生成程式碼（mybatis-generator 程式碼自動生成）

1.本地安裝maven，配置好環境變數 2.在專案下的jdbc檔案中引用相關mapper外掛：（拷貝以下程式碼，修改相關路徑） jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/test?

SpringBoot+mybatis plus的程式碼自動生成

在我們開發的時候，特別希望一些簡單的程式碼可以自動生成，我們只需要開發一些比較核心的業務邏輯的內容就可以了。mybatis plus就完成了這方面的內容。下面我們將如何來實現自動程式碼生成。一：引入相應的jar包（核心的jar）。<!-- 阿里巴巴druid資料庫連線池

spring boot 整合 mybatis（含程式碼自動生成）

環境簡介：Idea ，JDK8，MAVEN 開工： 第一步建立專案 第二步選擇maven依賴 第三步，補充自己需要用到的maven依賴（通過工具沒法自動完成的） <?xml version="1.0" encoding="UTF-8"?> <project xmlns="

Mybatis最入門---程式碼自動生成（generatorConfig.xml配置）

第一種方式：通過Main方法執行配置檔案。 -------------------------------------------------------------------------------------------------------------------------------------

【MyBatis Generator】程式碼自動生成工具 generatorConfig.xml配置檔案詳解

MyBatis Generator官網地址：http://www.mybatis.org/generator/index.html MyBaris Generator中文地址：http://mbg.cndocs.ml/ 在MBG中，最主要也最重要的，就是generatorConfig.xml

利用Mybatis-generator工具自動生成程式碼

配置JAVA環境變數； 執行生成程式碼之前，我們須要做的準備工作。  1、新建一個資料夾，作為我們的工作空間，例如： D:\generator 注意：這裡的路徑不要帶有中文字元，這是規範，即使帶有中文字元不會出什麼問題。 2、在 generator 這路徑下 （1）放置 m

mybatis-generator-程式碼自動生成器

前言 Mybatis屬於半自動ORM，在使用這個框架中，工作量最大的就是書寫Mapping的對映檔案，由於手動書寫很容易出錯，我們可以利用Mybatis-Generator來幫我們自動生成檔案。 怎麼操作呢？ 1.命令方式 2.maven外掛方式 1

eclipse/idea 使用maven generator 外掛自動生成mybatis程式碼

eclipse使用maven generator 外掛自動生成mybatis程式碼1、在maven專案的pom.xml檔案中新增“mybatis generator自動程式碼生成外掛”如果已經存在在<build><plugins>節點，則直接在<

mybatis-generator-mysql程式碼自動生成工具

流程：    1、匯入MybatisGenerator專案，在build path中修改jar包位置（mybatis-generator-core-1.3.2和mysql-jdbc）    2、修改generator.xml檔案        a.修改資料庫連線資訊<!

Mybatis -程式碼自動生成（generatorConfig.xml）配置資訊詳解

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1

02 使用Mybatis的逆向工程自動生成程式碼

1、逆向工程的作用 Mybatis 官方提供了逆向工程，可以針對資料庫表自動生成Mybatis執行所需要的程式碼（包括mapper.xml、Mapper.java、pojo）。 2、逆向工程的使用方法 逆向工程需要的jar包如下圖所示： 下載下來的專案目錄如下圖： 從上圖中看

MyBatis逆向工程——Java程式碼自動生成

關於程式碼自動生成，網上呢有很多工具，也有不同的方法，MyBatis是我接觸到的第一款程式碼自動生成器，比較簡單，程式碼量也比較少，也比較好理解，好了廢話不多說，下面就給大家說一下實現方法及程式碼解釋： 我們新建一個普通的Java專案，這裡我使用的工具是idea，是一款很強大的程式碼編寫工具。 首先是要實

MyBatis-Plus程式碼自動生成工具

簡介 官方文件：苞米豆 MyBatis-Plus（簡稱MP）是一個 MyBatis 的增強工具，在 Mybatis 的基礎上只做增強不做改變，為簡化開發、提高效率而生。 特性 無侵入：Mybatis-Plus 在 Mybatis 的基礎上進行擴充套件，只做增強不做改變，引

Mybatis------程式碼自動生成

程式碼自動生成 利用MyBatis生成器自動生成實體類、DAO介面和Mapping對映檔案。這樣可以大大節約開發時間，將生成的程式碼copy到專案工程中即可。 要想實現程式碼的自動生成，首先要下載一個工具：http://download.csdn.net/detail/u010608

Spring Boot （七）MyBatis程式碼自動生成和輔助外掛

一、簡介 1.1 MyBatis Generator介紹 MyBatis Generator 是MyBatis 官方出品的一款，用來自動生成MyBatis的 mapper、dao、entity 的框架，讓我們省去規律性最強的一部分最基礎的程式碼編寫。 1.2 MyBatis Generator使用 MyBat