这个项目我已经传到CSDN资源上面了，大家如果需要，可以点击下载：
地址是：《spring-boot-mybatis-mysql-demo》 https://download.csdn.net/download/ibliplus/10668805
使用mybatis-generator逆向生成dao,entity,mapper文件，在我之前的博客中有专门的介绍，
博客：《Mybatis-Generator反向自动生成Dao、Entitys、mapping》
链接：https://blog.csdn.net/IBLiplus/article/details/82193114
首先创建springboot+mybatis+mysql项目需要的应用：
1、jdk1.8
2、maven3_5_3
3、mysql
4、STS
下面我们介绍创建springboot整合mybatis+mysql的项目详细步骤：
首先下载STS之后需要将本地的jdk和maven引入到编辑器中，tomcat这里不用引入，因为springboot框架内部集成了一个简易的tomcat容器，所以这里我们不再需要引入了。
首先引入本地的jdk，这里编辑器默认引入的是jre，我们点击jre-->remove ,然后点击Add，导入你本地安装的jdk路径，引入后，点击选择框选中，点击apply。
然后引入本地的maven：切记选中前面的单选框，然后点击apply
引入maven之后还需要引入maven的配置文件，指定maven本地仓库的路径：
创建项目所需要的环境我们已经设置好了，接下来就是使用编辑器创建项目了：
首先Service URL一般都是默认的，这里不需要改动，Name是项目的名称，Group，Artifact，Version是maven项目的坐标及版本，package是默认加载类所在包，然后点击next，选择项目创建时，默认添加到pom.xml文件的依赖。
这些依赖的选择是看自己项目的需要，点击next：
点击finish，一个简易的项目就配置完成了。接下来就是我们配置项目和创建实现类和接口了，首先要创建如下目录：
接下来提供项目源码：
首先是默认加载类：Run.java：
package org.hsweb.demo;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Configuration
@EnableAutoConfiguration
@ComponentScan("org.hsweb.demo")
@MapperScan("org.hsweb.demo.dao")
@Controller
public class Run {
public static void main(String[] args) {
SpringApplication.run(Run.class, args);
}
@RequestMapping({"/", "/index.html"})
public ModelAndView index() {
return new ModelAndView("index");
}
}
UserController.java 代码：
package org.hsweb.demo.controller;
import org.hsweb.demo.po.User;
import org.hsweb.demo.service.UserService;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
@RestController
public class UserController {
@Resource
UserService userService;
@RequestMapping(value = "/users", method = RequestMethod.GET)
public List<User> getAll() {
return userService.selectAll();
}
@RequestMapping(value = "/user/{id}", method = RequestMethod.GET)
public User getById(@PathVariable("id") String id) {
return userService.selectById(id);
}
@RequestMapping(value = "/user", method = RequestMethod.POST)
public User add(@RequestBody User user) {
userService.insert(user);
return user;
}
@RequestMapping(value = "/user/{id}", method = RequestMethod.PUT)
public User update(@PathVariable String id, @RequestBody User user) {
user.setId(id);
userService.update(user);
return user;
}
@RequestMapping(value = "/user/{id}", method = RequestMethod.DELETE)
public boolean delete(@PathVariable String id) {
return userService.delete(id);
}
}
UserDao.java 代码：
package org.hsweb.demo.dao;
import org.hsweb.demo.po.User;
import java.util.List;
public interface UserDao {
User selectById(String id);
List<User> selectAll();
User selectByUserName(String username);
void insert(User user);
int update(User user);
int deleteById(String id);
}
User.java 实体类
package org.hsweb.demo.po;
import java.io.Serializable;
public class User implements Serializable {
private String id;
private String username;
private String password;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
UserMapper.xml代码：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.hsweb.demo.dao.UserDao">
<resultMap id="UserResultMap" type="org.hsweb.demo.po.User">
<id property="id" column="u_id" javaType="string" jdbcType="VARCHAR"/>
<result property="username" column="username" javaType="String" jdbcType="VARCHAR"/>
<result property="password" column="password" javaType="String" jdbcType="VARCHAR"/>
</resultMap>
<insert id="insert" parameterType="org.hsweb.demo.po.User">
insert into t_user (id,username,password) values(#{id},#{username},#{password})
</insert>
<delete id="deleteById" parameterType="org.hsweb.demo.po.User">
delete from t_user where id=#{id}
</delete>
<update id="update" parameterType="org.hsweb.demo.po.User">
update t_user set password = #{password} where id=#{id}
</update>
<select id="selectById" parameterType="string" resultMap="UserResultMap">
select * from t_user where id=#{id}
</select>
<select id="selectByUserName" parameterType="string" resultMap="UserResultMap">
select * from t_user where username=#{username}
</select>
<select id="selectAll" resultMap="UserResultMap">
select * from t_user
</select>
</mapper>
UserService.java 代码：
package org.hsweb.demo.service;
import org.hsweb.demo.po.User;
import java.util.List;
public interface UserService {
User selectById(String id);
User selectByUserName(String username);
List<User> selectAll();
String insert(User user);
boolean update(User user);
boolean delete(String id);
}
SimpleUserService.java代码：
package org.hsweb.demo.service.impl;
import org.hsweb.demo.dao.UserDao;
import org.hsweb.demo.po.User;
import org.hsweb.demo.service.UserService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.List;
import java.util.UUID;
@Service("userService")
@Transactional(rollbackFor = Throwable.class)
public class SimpleUserService implements UserService {
@Resource
private UserDao userDao;
@Override
@Transactional(readOnly = true)
public User selectById(String id) {
return userDao.selectById(id);
}
@Override
@Transactional(readOnly = true)
public User selectByUserName(String username) {
return userDao.selectByUserName(username);
}
@Override
@Transactional(readOnly = true)
public List<User> selectAll() {
return userDao.selectAll();
}
@Override
public String insert(User user) {
user.setId(UUID.randomUUID().toString());
userDao.insert(user);
return user.getId();
}
@Override
public boolean update(User user) {
return userDao.update(user) == 1;
}
@Override
public boolean delete(String id) {
return userDao.deleteById(id) == 1;
}
}
index.ftl 代码：
hello,spring-boot
${.now}
<br/>
GET: /users<br/>
POST: /user<br/>
PUT: /user/{id}<br/>
DELETE: /user/{id}<br/>db.sql 文档代码：
DROP TABLE IF EXISTS t_user;
CREATE TABLE t_user (
id VARCHAR(64) PRIMARY KEY,
username VARCHAR(128) NOT NULL,
password VARCHAR(256) NOT NULL
);logback.xml文档代码：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<conversionRule conversionWord="cl" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
<!-- 控制台输出日志 -->
<appender name="Console" class="ch.qos.logback.core.ConsoleAppender"> <!---->
<encoder>
<pattern>%cl(%d{HH:mm:ss.SSS}){blue} > %highlight(%-5level %logger{35}) - %cl(%m%n){green}</pattern>
</encoder>
<withJansi>true</withJansi>
</appender>
<logger name="org.springframework" level="ERROR"/>
<logger name="org.springframework.web" level="ERROR"/>
<logger name="org.apache.tomcat" level="ERROR"/>
<logger name="org.eclipse" level="ERROR"/>
<logger name="org.hsweb" level="DEBUG"/>
<logger name="freemarker.cache" level="ERROR"/>
<logger name="jndi" level="ERROR"/>
<logger name="org.apache.commons.beanutils" level="ERROR"/>
<logger name="com.atomikos" level="ERROR" />
<logger name="com.atomikos.jdbc.AtomikosConnectionProxy" level="ERROR"/>
<root level="DEBUG">
<appender-ref ref="Console"/>
</root>
</configuration>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>
<!-- 配置mybatis的缓存，延迟加载等等一系列属性 -->
<settings>
<!-- 全局映射器启用缓存 -->
<setting name="cacheEnabled" value="false"/>
<!-- 查询时，关闭关联对象即时加载以提高性能 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 对于未知的SQL查询，允许返回不同的结果集以达到通用的效果 -->
<setting name="multipleResultSetsEnabled" value="true"/>
<!-- 允许使用列标签代替列名 -->
<setting name="useColumnLabel" value="true"/>
<!-- 不允许使用自定义的主键值(比如由程序生成的UUID 32位编码作为键值)，数据表的PK生成策略将被覆盖 -->
<setting name="useGeneratedKeys" value="false"/>
<!-- 给予被嵌套的resultMap以字段-属性的映射支持 FULL,PARTIAL -->
<setting name="autoMappingBehavior" value="PARTIAL"/>
<!-- 对于批量更新操作缓存SQL以提高性能 BATCH,SIMPLE -->
<!-- <setting name="defaultExecutorType" value="BATCH" /> -->
<!-- 数据库超过25000秒仍未响应则超时 -->
<!-- <setting name="defaultStatementTimeout" value="25000" /> -->
<!-- Allows using RowBounds on nested statements -->
<setting name="safeRowBoundsEnabled" value="false"/>
<!-- Enables automatic mapping from classic database column names A_COLUMN to camel case classic Java property names aColumn. -->
<setting name="mapUnderscoreToCamelCase" value="true"/>
<!-- MyBatis uses local cache to prevent circular references and speed up repeated nested queries. By default (SESSION) all queries executed during a session are cached. If localCacheScope=STATEMENT
local session will be used just for statement execution, no data will be shared between two different calls to the same SqlSession. -->
<setting name="localCacheScope" value="SESSION"/>
<!-- Specifies the JDBC type for null values when no specific JDBC type was provided for the parameter. Some drivers require specifying the column JDBC type but others work with generic values
like NULL, VARCHAR or OTHER. -->
<setting name="jdbcTypeForNull" value="OTHER"/>
<!-- Specifies which Object's methods trigger a lazy load -->
<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
<!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指 定)，不会加载关联表的所有字段，以提高性能 -->
<setting name="aggressiveLazyLoading" value="false"/>
<!--<setting name="proxyFactory" value="CGLIB"/>-->
</settings>
</configuration>
pom.xml文档代码：
<?xml version="1.0" encoding="UTF-8"?>
<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>org.hsweb</groupId>
<artifactId>spring-boot-mybatis-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.build.locales>zh_CN</project.build.locales>
<java.version>1.8</java.version>
<javassist.version>3.20.0-GA</javassist.version>
<project.build.jdk>${java.version}</project.build.jdk>
<spring.boot.version>1.3.7.RELEASE</spring.boot.version>
<freemarker.version>2.3.23</freemarker.version>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring.boot.version}</version>
<configuration>
<mainClass>org.hsweb.demo.Run</mainClass>
<layout>ZIP</layout>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>${project.build.jdk}</source>
<target>${project.build.jdk}</target>
<encoding>${project.build.sourceEncoding}</encoding>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.20</version>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</dependency>
<!--新版本freemarker无法下载-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
<exclusions>
<exclusion>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>${freemarker.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</dependency>
<!-- mybatis start-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.0.2</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib-nodep</artifactId>
<version>3.2.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring.boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
</project>以上是整个项目的代码，下面是项目的格式展示：
## spring-boot+mybatis+freemarker 简单演示
##运行
```bash
$ mvn spring-boot:run
```
或者直接运行 org.hsweb.demo.Run.java 默认端口8080
## 目录说明
```bash
------- src/main/java
-------------|-----------controller #视图控制器
-------------|-----------dao #DAO接口
-------------|-----------po #PO实体类
-------------|-----------service #Service接口和实现类
-------------|-----------Run.java #程序入口
----------resources
-------------|-----------o.g.d.d.mybatis #mybatis mapper配置文件
-------------|----------templates # freemarker 模板文件
-------------|----------application.yml #项目配置文件
-------------|----------db.sql #初始数据文件
-------------|----------logback.xml #loback日志配置文件
-------------|----------mybatis-config.xml #mybatis基础配置文件
```
##注意
程序每次启动都会执行db.sql
可在application.yml 取消配置
```yml
spring:
datasource:
schema: classpath:db.sql
```
运行项目启动类：run.java然后在本地浏览器中输入localhost:8080
