Spring Boot入门（连接MySQL, Redis 输出JSP）

本文主要介绍一下如何搭建一个基本的Spring-Boot项目，Spring-Boot也是Spring众多项目中的一个，主要用于快速的搭建项目。通常构建一个java web的maven项目，需要引入不少jar包，写不少xml配置（如果用注解就当我没说），有了Spring-Boot这些繁琐的事情可以简化很多，构建项目的效率可以大大提升，另外它内置web容器，你可以不要tomcat就运行一个web项目。

可以Google一下Spring-Boot了解更详细的信息，或者通过下面这个项目了解一下它的简便。本人使用Spring-Boot时间也不长，感触不多。

通过一个简单的查询数据库信息并展示的项目来感受一下：

1. 新建maven项目

2. pom.xml如下：

Spring-Boot的maven依赖包含了很多常用的jar，比如spring相关的，log相关的，所以第一次下来这些依赖的时候会比较久。

<?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>com.francis</groupId>
<artifactId>springboot-framework</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>

<!--官方推荐配置这个parent，主要是parent包含了很多jar，这样一来就不用自己写很多。-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.3.0.RELEASE</version>
</parent>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!--DB -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>

<!--Redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>

<!--JSP-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>

<!-- apache common -->
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.3</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.0.1</version>
</dependency>

<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>
</dependencies>

<properties>
<java.version>1.8</java.version>
<main.basedir>${basedir}/../..</main.basedir>
<m2eclipse.wtp.contextRoot>/</m2eclipse.wtp.contextRoot>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<encoding>UTF-8</encoding>
</configuration>
</plugin>

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<argLine>-Dfile.encoding=UTF-8</argLine>
<useSystemClassLoader>false</useSystemClassLoader>
</configuration>
</plugin>

</plugins>
</build>
</project>

3. application.yml

这个是Spring-Boot的配置文件，可以配置很多项，具体的需要查看官方文档。

该文件放置在resources目录下（似乎只要是在classpath下面都行，通常是在resources下面）。

下面给出的这些是配置mysql连接和redis连接所需要的，根据文件中的配置和依赖的jar，Spring-Boot会自动创建DataSource对象，而你需要做的只是在配置文件中写清楚并引入相应的jar。（是不是很方便？）

spring:
#配置数据源
datasource:
url: jdbc:mysql://localhost:3306/test
username: root
password: abc123_
driverClassName: com.mysql.jdbc.Driver
max-wait: 10000
max-active: 50
test-on-borrow: false
#配置持久层框架
jpa:
database: MYSQL
show-sql: true
hibernate:
ddl-auto: update
dialect: org.hibernate.dialect.MySQL5Dialect
#SpringMVC视图解析配置
mvc:
view:
prefix: /WEB-INF/jsp/
suffix: .jsp
#配置redis信息
redis:
database: 0
host: localhost
password:
port: 6379
pool:
max-idle: 8
min-idle: 0
max-active: 10
max-wait: -1
server:
sessionTimeout: 30

4. config

代码中有用到Spring的@Cacheable注解，RedisConfig中主要是讲RedisCacheManager配置成Spring全局的缓存管理器，这样在代码中使用@Cacheable注解的时候，默认都会使用Redis作为缓存的实现。同时还配置了一个keyGenerator。

在Spring-Boot中推荐使用注解的方式来配置对象，使用xml也行的，看个人喜好吧。

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

@Bean
public KeyGenerator biliKeyGenerator(){
return new KeyGenerator() {
@Override
public Object generate(Object target, Method method, Object... params) {
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName());
sb.append(method.getName());
for (Object obj : params) {
sb.append(obj.toString());
}
return sb.toString();
}
};

}

@Bean
public CacheManager cacheManager(@SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {
return new RedisCacheManager(redisTemplate);
}

@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
StringRedisTemplate template = new StringRedisTemplate(factory);
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
template.setValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}

5. model

很简单的一个User对象

@Entity
public class User implements Serializable {
private static final long serialVersionUID = 1L;

@Id
private Integer id;

private String name;

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}

6. repository

JPA你值得拥有，就这么两行代码，基本的CRUD和分页都有了。

public interface UserDao extends PagingAndSortingRepository<User, Integer> {
}

7. service

service层逻辑很简单，也就不写接口了，直接一个实现。

@Cacheable注解会通过keyGenerator生成key，将方法的返回值作为value，存储到缓存管理器中，配置中的value这个字段，个人理解是相当于将缓存分成不同的块，每个块都有唯一的名字，通过value的值表明想要把这个方法的结果缓存到那一块中。比较像Redis中database的概念，不过没那么重。具体可以看一下这个annotation的注释。

@CacheEvict可用来刷新缓存

需要注意一点，如果被Cacheable注解的方法同时还有AOP，那么Cacheable会先于APO执行。

@Service
public class UserService {
@Autowired
private UserDao userDao;

@Cacheable(value = "user_info", keyGenerator = "demoKeyGenerator")
public User getById(Integer id) {
System.out.println("从数据库中查询的");
User user = userDao.findOne(id);
return userDao.findOne(id);
}

@CacheEvict(value = "user_info", allEntries = true)
public void update() {
System.out.println("清除缓存");
}
}

8. controller

@Controller
public class MainController {
@Autowired
private UserService userService;

@RequestMapping(value = "/")
public ModelAndView index() {
//从数据库查询
System.out.println(userService.getById(1).getName());

//从缓存获取
System.out.println(userService.getById(1).getName());

//刷新缓存
userService.update();

//从数据库获取
User user = userService.getById(1);
System.out.println(user.getName());
return new ModelAndView("index", "user", user);
}
}

9. jsp

Hello， ${Your}！

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@page import="com.francis.boot.model.User" %>
<html>
<head>
</head>
<body>
Hello, ${user.name}!
</body>
</html>

10. 程序入口

上面的逻辑代码跟其他的web项目也没什么区别，只是少写了一些xml配置，Spring-Boot如何自动映射这些配置，并根据配置和依赖的jar生成DataSource等对象呢？ 主要是下面的代码在起作用。

Application（程序入口类，只是一个class的名字，而非只整个应用）这个class需要放到package的根目录下，主要是默认情况下Spring-Boot会扫描跟Application同级，以及级别比它低的目录里面的class。

//@Configuration
//@EnableAutoConfiguration（这个注解告诉Spring Boot根据添加的jar依赖猜测你想如何配置Spring。）
//@ComponentScan（如果被注解的类在类的根目录下，则可以不用指定basePackage）
//上面这三个注解通常都需要被放到main class，然后下面这个SpringBootApplication可以代替上面三个的功能
@SpringBootApplication
public class Application extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(Application.class);
}

public static void main(String[] args) {
ConfigurableApplicationContext configurableApplicationContext = SpringApplication.run(Application.class);
}
}

至此，大功告成。

文件结构如下：

11. 其他

日志默认使用logback

内置容器对JSP的支持有一些限制。

a. tomcat只支持war的打包方式，不支持可执行的jar。

b. 内嵌的Jetty目前不支持JSPs。

c. Undertow不支持JSPs

如果只有接口，那么可以将程序打包成一个jar直接运行