SpringBoot集成JSP、Quartz框架

一、SpringBoot静态资源目录

1.1介绍

在web开发中，静态资源的访问是必不可少的，如：图片、js、css等资源的访问，SpringBoot对静态资源访问提供了很好的支持，基本使用默认配置就能满足开发需求。

1.2 位置和命名

在传统的web项目中，静态资源放在项目的WebRootWEB-INF目录下，SpringBoot框架默认提供静态资源目录，在classpath（src/main/resources）下，目录名需要符合如下规则：

/static

/public

/resources

/META-INF/resources

1.3使用

这四个目录可以在项目中任意创建一个即可，如只创建一个static文件夹存放静态资源，它们的功能都是一样的，需要注意的是：这几个目录的名称不能写错，使用时，在地址栏中输入资源的名称就可以了，如：在static中放入my.js文件，在地址栏输入：http//localhost:8080/my.js，即可直接访问到该资源了。

 

二、SpringBoot集成JSP

2.1 介绍

由于JSP这种技术本身有很多缺陷，所以SpringBoot默认是不支持JSP的，但是如果我们要使用JSP,那需要SpringBoot整合JSP,在整合JSP的时候，需要注意与原来的操作有所不同，项目需要打成war包，因此在创建项目的时候需要注意。

jsp本质是一个Servlet，纯java代码，不利于维护，也不便于继承

jar包和war包的区别？

2.2 集成JSP的步骤

1.在创建Maven项目

 

 

 

 

2.导入Pom依赖

在项目的pom.xml文件中导入常规依赖之外，需要额外添加JSP和JSTL两个依赖。

<!-- SpringBoot支持JSP的依赖，默认自带的tomact不支持JSP,所以引入这个依赖 -->
<dependency>
　　<groupId>org.apache.tomcat.embed</groupId>
　　<artifactId>tomcat-embed-jasper</artifactId>
　　<scope>provided</scope>
</dependency> 
<!-- JSP页面使用JSTL标签 --> 
<dependency> 
　　<groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> 
</dependency>

完整pom.xml

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <!-- 项目设置:编码格式UTF-8 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
    <!--单元测试依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <!-- Spring Boot SpringMVC框架依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Spring Boot 测试依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- 热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
            <!-- optional=true,依赖不会传递，该项目依赖devtools；之后依赖myboot项目的项目如果想要使用
            devtools，需要重新引入 -->
            <scope>true</scope><!-- 热部署 -->
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- SpringBoot支持JSP的依赖 -->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- JSP页面使用JSTL标签 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>
  </dependencies>
  <build>
      <plugins>
        <!-- SpringBoot插件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
      <!-- SpringBoot项目打包jar名称 -->
    <finalName>sp3-jsp</finalName>
  </build>

 

3.配置视图解析

出于安全考虑，SpringBoot推荐将JSP页面放入到项目的webapp/WEB-INF/view目录下，需要在application.properties配置文件中加入如下内容：

#视图前缀
spring.mvc.view.prefix=/WEB-INF/view/
#视图后缀
spring.mvc.view.suffix=.jsp

　　WEB-INF对于用户是不可见的，让js页面对用户不可见。

4.案例测试

4.1 新建控制器类（UserController.java）处理请求，内容如下：

package com.sqy.start.controller;
 
import java.util.ArrayList;
import java.util.List;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
 
@Controller
public class UserController {
 @RequestMapping("/getUser")
 public ModelAndView getUser(ModelAndView view,String name) {
 List<String> list = new ArrayList<String>();
 list.add(name);
 list.add("张三");
 list.add("李四");
 view.addObject("list",list);
 view.setViewName("user");
 return view;
 }
}

4.2 在webapp/WEB-INF/下新建view目录，然后新建一个user.jsp文件，内容如下：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
 <head>
 <base href="<%=basePath%>">
 
 <title>My JSP 'MyJsp.jsp' starting page</title>
 
 <meta http-equiv="pragma" content="no-cache">
 <meta http-equiv="cache-control" content="no-cache">
 <meta http-equiv="expires" content="0"> 
 <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 <meta http-equiv="description" content="This is my page">
 <!--
 <link rel="stylesheet" type="text/css" href="styles.css">
 -->
 
 </head>
 
 <body>
 <c:if test="${not empty list }">
 <c:forEach items="${list }" var="str" varStatus="sta">
 ${sta.count }-------->${str }<br/>
 </c:forEach>
 </c:if>
 <c:if test="${empty msg }">
 <h5>page,request,session,application四个对象属性中msg都为null</h5>
 </c:if>
 </body>
</html>

4.3定义主模板，启动类

package com.sqy.start;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class Start {
 public static void main(String[] args) {
 SpringApplication.run(Start.class, args);
 }
}

4.4启动项目，在浏览器中输入http://localhost:8080/getUser?name=Tom，运行效果如下：

打war包发布项目

1.修改主程序的入口函数，打成war包需要继承org.springframework.boot.context.web.SpringBootServletInitializer类,覆盖config(SpringApplicationBuilder)方法。

package com.sqy.start;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
 
@SpringBootApplication
public class Start extends SpringBootServletInitializer {
 public static void main(String[] args) {
 SpringApplication application = new SpringApplication(Start.class);
 application.setAddCommandLineProperties(false);
 application.run(args);
 }
 /**
 * 需要把web项目打成war包运行时需要重新此方法
 */
 @Override
 protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
 return builder.sources(Start.class);
 }
}

2.打包：右键项目 --> Run as --> Maven build... 输入clean package命令

本阶段需要注意的时，需修改pom.xml中项目的打包的方式为war，即

<packaging>war</packaging>

3. 运行

在放置war包的目录下，右键点击空白处+按shift键，选择：在命令窗口打开，输入java -jar 包名.war即可。

win10:右键点击空白处+按shift键，选择：在此处打开Powershell窗口，输入java -jar 包名.war即可。

三、SpringBoot集成Quartz框架

3.1介绍

Quartz是一个任务调度框架，它的使用场景是：

想每个月10号，信用卡自动还款

想每隔一个小时，备份自己的学习笔记到云盘

这些问题总结下来就是：在某一个有规律的事件做某件事情，并且事件的触发条件可以非常复杂，例如每月最后一个工作日的17:50，复杂到需要一个专门的框架来做这个事情，而Quartz就是做这个的，给它一个触发条件的定义，它会负责到了时间点触发相应的工作。

3.2 SpringBoot整合Quartz的步骤：

1.引入Quartz依赖：

<!-- pom文件 Spring Quartz依赖 -->
<dependency>
<groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId>
<version>2.2.1</version>
<exclusions>
<exclusion>
<artifactId>slf4j-api</artifactId> <groupId>org.slf4j</groupId>
</exclusion>
</exclusions>
</dependency>

　　2.使用注解@Configuration定义一个配置类

package com.sqy.start.tools;
 
import java.text.SimpleDateFormat;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class ConfigMyTools {
 @Bean("dateFormat")
 public SimpleDateFormat dateFormat() {
 return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 }
}
 

　@Configuration,@Bean这两个注解代替xml配置，@Configuration相当于xml中的标签，@Bean相当于标签，通常两者结合使用。

@Configuration类上加，代表此类变成了配置类，相当于xml

@Bean方法上加入bean会把本方法生bean并放到Spring容器中

3.为了方便看清楚任务调度的次数，我们声明一个辅助类：

package com.sqy.start.tools;
 
import org.springframework.stereotype.Component;
 
@Component
public class MyTask {
 private int count = 0;
 public void say() {
 System.out.println("SpringBoot任务调度次数："+count++);
 }
}

　　4.创建一个任务调度类

package com.sqy.start.tools;
 
import java.text.SimpleDateFormat;
import java.util.Date;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
 
@Component
@EnableScheduling
public class SimpleTask {
 @Autowired
 private MyTask myTask;
 @Autowired
 private SimpleDateFormat dateFormat;
 
 @Scheduled(fixedRate=3000)
 public void reportCurrentTime() {
 myTask.say();
 System.out.println("每隔3秒任务调度一次，现在时间："+dateFormat.format(new Date()));
 }
}

启动项目（入口函数），控制台输出：

SpringBoot任务调度次数：0

每隔3秒任务调度一次，现在时间：2018-11-26 11:06:40

2018-11-26 11:06:40.090 INFO 3728 --- [ restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080 (http) with context path ''

2018-11-26 11:06:40.090 INFO 3728 --- [ restartedMain] com.sqy.start.Start : Started Start in 0.402 seconds (JVM running for 882.928)

2018-11-26 11:06:40.100 INFO 3728 --- [ restartedMain] .ConditionEvaluationDeltaLoggingListener : Condition evaluation unchanged

SpringBoot任务调度次数：1

每隔3秒任务调度一次，现在时间：2018-11-26 11:06:43

SpringBoot任务调度次数：2

每隔3秒任务调度一次，现在时间：2018-11-26 11:06:46

SpringBoot任务调度次数：3

每隔3秒任务调度一次，现在时间：2018-11-26 11:06:49

.......

使用cron表达式,在任务调度类中添加：

@Scheduled(cron="*/5 * * * * ?")
 public void reportCurrentByCron() {
 System.out.println("每隔5秒任务调度一次，现在时间："+dateFormat.format(new Date()));
 }

启动项目（入口函数），控制台输出：

每隔5秒任务调度一次，现在时间：2018-11-26 11:11:30

每隔5秒任务调度一次，现在时间：2018-11-26 11:11:35

每隔5秒任务调度一次，现在时间：2018-11-26 11:11:40

........

说明：cron="*/5 * * * *?",表达式表示秒分时日(每月的第几日)月星期（），*/5表示每隔5秒， @EnableScheduling:放在类前，标注启动定时任务，@Scheduled(表达式):放在方法前，定义某个定时任务

fixedDelay每次任务结束后才开始计算

fixedRate每次任务开始时的瞬间直接计算