基于SpringBoot + Mybatis实现SpringMVC Web项目

目录

[ 隐藏]

• 1一、热身
• 2二、实践
  • 2.11.预览：
  • 2.22.Maven配置
  • 2.33.主函数
  • 2.44.Controller
  • 2.55.Mybatis
• 3三、总结
• 4四、参阅
• 5附录：

一、热身

一个现实的场景是：当我们开发一个Web工程时，架构师和开发工程师可能更关心项目技术结构上的设计。

而几乎所有结构良好的软件（项目）都使用了分层设计。

分层设计是将项目按技术职能分为几个内聚的部分，从而将技术或接口的实现细节隐藏起来。

从另一个角度上来看，结构上的分层往往也能促进了技术人员的分工，可以使开发人员更专注于某一层业务与功能的实现，

比如：前端工程师只关心页面的展示与交互效果（例如专注于HTML，JS等），

而后端工程师只关心数据和业务逻辑的处理（专注于Java，Mysql等）。两者之间通过标准接口（协议）进行沟通。

在实现分层的过程中我们会使用一些框架，例如SpringMVC。

但利用框架带来了一些使用方面的问题。我们经常要做的工作就是配置各种XML文件，然后还需要搭建配置Tomcat或者Jetty作为容器来运行这个工程。

每次构建一个新项目，都要经历这个流程。

更为不幸的是有时候前端人员为了能在本地调试或测试程序，也需要先配置这些环境，或者需要后端人员先实现一些服务功能。这就和刚才提到的“良好的分层结构”相冲突。

每一种技术和框架都有一定的学习曲线。开发人员需要了解具体细节，才知道如何把项目整合成一个完整的解决方案。

事实上，一个整合良好的项目框架不仅仅能实现技术、业务的分离，还应该关注并满足开发人员的“隔离”。

为了解决此类问题，便产生了Spring Boot这一全新框架。

Spring Boot就是用来简化Spring应用的搭建以及开发过程。

该框架致力于实现免XML配置，提供便捷，独立的运行环境，实现“一键运行”满足快速应用开发的需求。

与此同时，一个完整的Web应用难免少不了数据库的支持。利用JDBC的API需要编写复杂重复且冗余的代码。

而使用O/RM（例如Hibernate）工具需要基于一些假设和规则，例如：最普遍的一个假设就是数据库被恰当的规范了。

这些规范在现实项目中并非能完美实现。由此，诞生了一种混合型解决方案——Mybatis。

Mybatis是一个持久层框架，它从各种数据库访问工具中汲取大量优秀的思想，适用于任何大小和用途的数据库。

根据官方文档的描述：MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。

MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。

MyBatis 可以对配置和原生Map使用简单的 XML 或注解，将接口和 Java 的 POJOs(Plain Old Java Objects，普通的 Java对象)映射成数据库中的记录。

最后，再回到技术结构分层上，目前主流倡导的设计模式为MVC，

即模型(model)－视图(view)－控制器(controller)。实现该设计模式的框架有很多，例如Struts。

而前文提到的SpringMVC是另一个更为优秀，灵活易用的MVC框架。

SpringMVC是一种基于Java的以请求为驱动类型的轻量级Web框架，其目的是将Web层进行解耦，即使用“请求-响应”模型，从工程结构上实现良好的分层，区分职责，简化Web开发。

目前，对于如何把这些技术整合起来形成一个完整的解决方案，并没有相关的最佳实践。

将Spring Boot和Mybatis两者整合使用的资料和案例较少。

因此，本文提供（介绍）一个完整利用SpringBoot和Mybatis来构架Web项目的案例。

该案例基于SpringMVC架构提供完整且简洁的实现Demo，便于开发人员根据不同需求和业务进行拓展。

补充提示，Spring Boot 推荐采用基于 Java 注解的配置方式，而不是传统的 XML。

只需要在主配置 Java 类上添加“@EnableAutoConfiguration”注解就可以启用自动配置。

Spring Boot 的自动配置功能是没有侵入性的，只是作为一种基本的默认实现。

开发人员可以通过定义其他 bean 来替代自动配置所提供的功能，例如在配置本案例数据源（DataSource）时，可以体会到该用法。

 

二、实践

一些说明：

项目IDE采用Intellij（主要原因在于Intellij颜值完爆Eclipse，谁叫这是一个看脸的时代）

工程依赖管理采用个人比较熟悉的Maven（事实上SpringBoot与Groovy才是天生一对）

1.预览：

（1）github地址

https://github.com/djmpink/springboot-mybatis

git :  https://github.com/djmpink/springboot-mybatis.git

（2）完整项目结构

（3）数据库

数据库名：test 

【user.sql】

[html] view plain copy

1. SET FOREIGN_KEY_CHECKS=0;  
2. -- ----------------------------  
3. -- Table structure for user  
4. -- ----------------------------  
5. DROP TABLE IF EXISTS `user`;  
6. CREATE TABLE `user` (  
7.   `id` int(11) NOT NULL,  
8.   `name` varchar(255) DEFAULT NULL,  
9.   `age` int(11) DEFAULT NULL,  
10.   `password` varchar(255) DEFAULT NULL,  
11.   PRIMARY KEY (`id`)  
12. ) ENGINE=InnoDB DEFAULT CHARSET=latin1;  
13. -- ----------------------------  
14. -- Records of user  
15. -- ----------------------------  
16. INSERT INTO `user` VALUES ('1', '7player', '18', '123456');  

2.Maven配置

完整的【pom.xml】配置如下：

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <project xmlns="http://maven.apache.org/POM/4.0.0"  
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
5.     <modelVersion>4.0.0</modelVersion>  
6.     <groupId>cn.7player.framework</groupId>  
7.     <artifactId>springboot-mybatis</artifactId>  
8.     <version>1.0-SNAPSHOT</version>  
9.     <parent>  
10.         <groupId>org.springframework.boot</groupId>  
11.         <artifactId>spring-boot-starter-parent</artifactId>  
12.         <version>1.2.5.RELEASE</version>  
13.     </parent>  
14.     <properties>  
15.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
16.         <java.version>1.7</java.version>  
17.     </properties>  
18.     <dependencies>  
19.         <!--Spring Boot-->  
20.             <!--支持 Web 应用开发，包含 Tomcat 和 spring-mvc。 -->  
21.         <dependency>  
22.             <groupId>org.springframework.boot</groupId>  
23.             <artifactId>spring-boot-starter-web</artifactId>  
24.         </dependency>  
25.         <!--模板引擎-->  
26.         <dependency>  
27.             <groupId>org.springframework.boot</groupId>  
28.             <artifactId>spring-boot-starter-thymeleaf</artifactId>  
29.         </dependency>  
30.         <!--支持使用 JDBC 访问数据库-->  
31.         <dependency>  
32.             <groupId>org.springframework.boot</groupId>  
33.             <artifactId>spring-boot-starter-jdbc</artifactId>  
34.         </dependency>  
35.         <!--添加适用于生产环境的功能，如性能指标和监测等功能。 -->  
36.         <dependency>  
37.             <groupId>org.springframework.boot</groupId>  
38.             <artifactId>spring-boot-starter-actuator</artifactId>  
39.         </dependency>  
40.         <!--Mybatis-->  
41.         <dependency>  
42.             <groupId>org.mybatis</groupId>  
43.             <artifactId>mybatis-spring</artifactId>  
44.             <version>1.2.2</version>  
45.         </dependency>  
46.         <dependency>  
47.             <groupId>org.mybatis</groupId>  
48.             <artifactId>mybatis</artifactId>  
49.             <version>3.2.8</version>  
50.         </dependency>  
51.         <!--Mysql / DataSource-->  
52.         <dependency>  
53.             <groupId>org.apache.tomcat</groupId>  
54.             <artifactId>tomcat-jdbc</artifactId>  
55.         </dependency>  
56.         <dependency>  
57.             <groupId>mysql</groupId>  
58.             <artifactId>mysql-connector-java</artifactId>  
59.         </dependency>  
60.         <!--Json Support-->  
61.         <dependency>  
62.             <groupId>com.alibaba</groupId>  
63.             <artifactId>fastjson</artifactId>  
64.             <version>1.1.43</version>  
65.         </dependency>  
66.         <!--Swagger support-->  
67.         <dependency>  
68.             <groupId>com.mangofactory</groupId>  
69.             <artifactId>swagger-springmvc</artifactId>  
70.             <version>0.9.5</version>  
71.         </dependency>  
72.     </dependencies>  
73.     <build>  
74.         <plugins>  
75.             <plugin>  
76.                 <groupId>org.springframework.boot</groupId>  
77.                 <artifactId>spring-boot-maven-plugin</artifactId>  
78.             </plugin>  
79.         </plugins>  
80.     </build>  
81.     <repositories>  
82.         <repository>  
83.             <id>spring-milestone</id>  
84.             <url>https://repo.spring.io/libs-release</url>  
85.         </repository>  
86.     </repositories>  
87.     <pluginRepositories>  
88.         <pluginRepository>  
89.             <id>spring-milestone</id>  
90.             <url>https://repo.spring.io/libs-release</url>  
91.         </pluginRepository>  
92.     </pluginRepositories>  
93. </project>  

3.主函数

【Application.java】包含main函数，像普通java程序启动即可。

此外，该类中还包含和数据库相关的DataSource，SqlSeesion配置内容。

注：@MapperScan(“cn.no7player.mapper”) 表示Mybatis的映射路径（package路径）

[java] view plain copy

1. package cn.no7player;  
2.    
3. import org.apache.ibatis.session.SqlSessionFactory;  
4. import org.apache.log4j.Logger;  
5. import org.mybatis.spring.SqlSessionFactoryBean;  
6. import org.mybatis.spring.annotation.MapperScan;  
7. import org.springframework.boot.SpringApplication;  
8. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;  
9. import org.springframework.boot.autoconfigure.SpringBootApplication;  
10. import org.springframework.boot.context.properties.ConfigurationProperties;  
11. import org.springframework.context.annotation.Bean;  
12. import org.springframework.context.annotation.ComponentScan;  
13. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;  
14. import org.springframework.jdbc.datasource.DataSourceTransactionManager;  
15. import org.springframework.transaction.PlatformTransactionManager;  
16.    
17. import javax.sql.DataSource;  
18.    
19. @EnableAutoConfiguration  
20. @SpringBootApplication  
21. @ComponentScan  
22. @MapperScan("cn.no7player.mapper")  
23. public class Application {  
24.     private static Logger logger = Logger.getLogger(Application.class);  
25.    
26.     //DataSource配置  
27.     @Bean  
28.     @ConfigurationProperties(prefix="spring.datasource")  
29.     public DataSource dataSource() {  
30.         return new org.apache.tomcat.jdbc.pool.DataSource();  
31.     }  
32.    
33.     //提供SqlSeesion  
34.     @Bean  
35.     public SqlSessionFactory sqlSessionFactoryBean() throws Exception {  
36.    
37.         SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();  
38.         sqlSessionFactoryBean.setDataSource(dataSource());  
39.    
40.         PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();  
41.    
42.         sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:/mybatis/*.xml"));  
43.    
44.         return sqlSessionFactoryBean.getObject();  
45.     }  
46.    
47.     @Bean  
48.     public PlatformTransactionManager transactionManager() {  
49.         return new DataSourceTransactionManager(dataSource());  
50.     }  
51.    
52.     /**  
53.      * Main Start  
54.      */  
55.     public static void main(String[] args) {  
56.         SpringApplication.run(Application.class, args);  
57.         logger.info("============= SpringBoot Start Success =============");  
58.     }  
59.    
60. }  

4.Controller

请求入口Controller部分提供三种接口样例：视图模板，Json，restful风格

（1）视图模板

返回结果为视图文件路径。视图相关文件默认放置在路径 resource/templates下：

[java] view plain copy

1. package cn.no7player.controller;  
2.    
3. import org.apache.log4j.Logger;  
4. import org.springframework.stereotype.Controller;  
5. import org.springframework.ui.Model;  
6. import org.springframework.web.bind.annotation.RequestMapping;  
7. import org.springframework.web.bind.annotation.RequestParam;  
8.    
9. @Controller  
10. public class HelloController {  
11.    
12.     private Logger logger = Logger.getLogger(HelloController.class);  
13.    
14.     /* 
15.     *   http://localhost:8080/hello?name=cn.7player 
16.      */  
17.    
18.     @RequestMapping("/hello")  
19.     public String greeting(@RequestParam(value="name", required=false, defaultValue="World") String name, Model model) {  
20.         logger.info("hello");  
21.         model.addAttribute("name", name);  
22.         return "hello";  
23.     }  
24.       
25. }  

（2）Json

返回Json格式数据，多用于Ajax请求。

[java] view plain copy

1. package cn.no7player.controller;  
2.    
3. import cn.no7player.model.User;  
4. import cn.no7player.service.UserService;  
5. import org.apache.log4j.Logger;  
6. import org.springframework.beans.factory.annotation.Autowired;  
7. import org.springframework.stereotype.Controller;  
8. import org.springframework.web.bind.annotation.RequestMapping;  
9. import org.springframework.web.bind.annotation.ResponseBody;  
10.    
11. @Controller  
12. public class UserController {  
13.    
14.     private Logger logger = Logger.getLogger(UserController.class);  
15.    
16.     @Autowired  
17.     private UserService userService;  
18.    
19.     /* 
20.      *  http://localhost:8080/getUserInfo 
21.      */  
22.    
23.     @RequestMapping("/getUserInfo")  
24.     @ResponseBody  
25.     public User getUserInfo() {  
26.         User user = userService.getUserInfo();  
27.         if(user!=null){  
28.             System.out.println("user.getName():"+user.getName());  
29.             logger.info("user.getAge():"+user.getAge());  
30.         }  
31.         return user;  
32.     }  
33. }  

（3）restful

REST 指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是 RESTful。

此外，有一款RESTFUL接口的文档在线自动生成+功能测试功能软件——Swagger UI，具体配置过程可移步《Spring Boot 利用 Swagger 实现restful测试》

[java] view plain copy

1. package cn.no7player.controller;  
2.    
3. import cn.no7player.model.User;  
4. import com.wordnik.swagger.annotations.ApiOperation;  
5. import org.springframework.web.bind.annotation.PathVariable;  
6. import org.springframework.web.bind.annotation.RequestMapping;  
7. import org.springframework.web.bind.annotation.RequestMethod;  
8. import org.springframework.web.bind.annotation.RestController;  
9.    
10. import java.util.ArrayList;  
11. import java.util.List;  
12.    
13. @RestController  
14. @RequestMapping(value="/users")  
15. public class SwaggerController {  
16.       
17.     /* 
18.      *  http://localhost:8080/swagger/index.html 
19.      */  
20.    
21.     @ApiOperation(value="Get all users",notes="requires noting")  
22.     @RequestMapping(method=RequestMethod.GET)  
23.     public List<User> getUsers(){  
24.         List<User> list=new ArrayList<User>();  
25.    
26.         User user=new User();  
27.         user.setName("hello");  
28.         list.add(user);  
29.    
30.         User user2=new User();  
31.         user.setName("world");  
32.         list.add(user2);  
33.         return list;  
34.     }  
35.    
36.     @ApiOperation(value="Get user with id",notes="requires the id of user")  
37.     @RequestMapping(value="/{name}",method=RequestMethod.GET)  
38.     public User getUserById(@PathVariable String name){  
39.         User user=new User();  
40.         user.setName("hello world");  
41.         return user;  
42.     }  
43. }  

5.Mybatis

配置相关代码在Application.java中体现。

（1）【application.properties】

[html] view plain copy

1. spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=gbk&zeroDateTimeBehavior=convertToNull  
2. spring.datasource.username=root  
3. spring.datasource.password=123456  
4. spring.datasource.driver-class-name=com.mysql.jdbc.Driver  

注意，在Application.java代码中，配置DataSource时的注解

@ConfigurationProperties(prefix=“spring.datasource”) 

表示将根据前缀“spring.datasource”从application.properties中匹配相关属性值。

（2）【UserMapper.xml】

Mybatis的sql映射文件。Mybatis同样支持注解方式，在此不予举例了。

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
3. <mapper namespace="cn.no7player.mapper.UserMapper">  
4.    
5.   <select id="findUserInfo" resultType="cn.no7player.model.User">  
6.     select name, age,password from user;  
7.   </select>  
8.    
9. </mapper>  

（3）接口UserMapper

[java] view plain copy

1. package cn.no7player.mapper;  
2.    
3. import cn.no7player.model.User;  
4.    
5. public interface UserMapper {  
6.     public User findUserInfo();  
7. }  

三、总结

（1）运行 Application.java

（2）控制台输出：

…..（略过无数内容）

（3）访问：

针对三种控制器的访问分别为：

视图：

http://localhost:8080/hello?name=7player

Json：

http://localhost:8080/getUserInfo

Restful（使用了swagger）：

http://localhost:8080/swagger/index.html

 

四、参阅

《Spring Boot – Quick Start》

http://projects.spring.io/spring-boot/#quick-start

《mybatis》

http://mybatis.github.io/mybatis-3/

《使用 Spring Boot 快速构建 Spring 框架应用》

http://www.ibm.com/developerworks/cn/java/j-lo-spring-boot/

《Using @ConfigurationProperties in Spring Boot》

http://www.javacodegeeks.com/2014/09/using-configurationproperties-in-spring-boot.html?utm_source=tuicool

《Springboot-Mybatis-Mysample》

https://github.com/mizukyf/springboot-mybatis-mysample

《Serving Web Content with Spring MVC》

http://spring.io/guides/gs/serving-web-content/

《理解RESTful架构》

http://www.ruanyifeng.com/blog/2011/09/restful

 

附录：

Spring Boot 推荐的基础 POM 文件

名称	说明
spring-boot-starter	核心 POM，包含自动配置支持、日志库和对 YAML 配置文件的支持。
spring-boot-starter-amqp	通过 spring-rabbit 支持 AMQP。
spring-boot-starter-aop	包含 spring-aop 和 AspectJ 来支持面向切面编程（AOP）。
spring-boot-starter-batch	支持 Spring Batch，包含 HSQLDB。
spring-boot-starter-data-jpa	包含 spring-data-jpa、spring-orm 和 Hibernate 来支持 JPA。
spring-boot-starter-data-mongodb	包含 spring-data-mongodb 来支持 MongoDB。
spring-boot-starter-data-rest	通过 spring-data-rest-webmvc 支持以 REST 方式暴露 Spring Data 仓库。
spring-boot-starter-jdbc	支持使用 JDBC 访问数据库。
spring-boot-starter-security	包含 spring-security。
spring-boot-starter-test	包含常用的测试所需的依赖，如 JUnit、Hamcrest、Mockito 和 spring-test 等。
spring-boot-starter-velocity	支持使用 Velocity 作为模板引擎。
spring-boot-starter-web	支持 Web 应用开发，包含 Tomcat 和 spring-mvc。
spring-boot-starter-websocket	支持使用 Tomcat 开发 WebSocket 应用。
spring-boot-starter-ws	支持 Spring Web Services。
spring-boot-starter-actuator	添加适用于生产环境的功能，如性能指标和监测等功能。
spring-boot-starter-remote-shell	添加远程 SSH 支持。
spring-boot-starter-jetty	使用 Jetty 而不是默认的 Tomcat 作为应用服务器。
spring-boot-starter-log4j	添加 Log4j 的支持。
spring-boot-starter-logging	使用 Spring Boot 默认的日志框架 Logback。
spring-boot-starter-tomcat	使用 Spring Boot 默认的 Tomcat 作为应用服务器。