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直接运行