基于SpringBoot+Springmvc+mybatis+mybatis-generator代码自动生成的框架。

当我们在开发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/htmlspring.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=rootpassword=

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放在资源文件中。在下面的实现数据源的配置要特别注意。

通过上面的操作就配置好了自动生成代码的操作。

最后运行程序生成好代码：点击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结果。