1.application.properties 文件的基本配置

除了我们之前配置mysql数据库的相关参数,还能进行如下配置,配置端口号,配置context-path路径(未添加context-path路径前为:http://localhost:8080/dog, 添加如下context-path后为http://localhost:8080/avalanching/dog)

# 默认端口号是8080
server.port=9090
# 配置context-path 默认的context-path
server.context-path = /avalanching # 多为工程名

# 指定服务器的地址
server.address = #bind to a specific NIC

# 指定服务器请求的超时时间
server.session-timeout = # session timeout in second

# 此项原为*.do
server.servlet-path = # the server path defaults to '/'

2.spring-boot的定时任务

1.几种常见的定时任务

(1) java自带的java.util.Timer类, Timer允许开发者按照某一个频率去执行,但不能指定具体的运行时间。（类似于iOS中的NSTimer）
(2)使用Quartz，这是个功能比较强大的调度器，可以让开发者的程序在指定时间执行，也可以按照某个频度执行，配置起来相对比较麻烦。
(3)spring3.0以后自带了task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz更简单

2.spring task

@Configuration
@EnableScheduling
cron定时任务表达式
指定:秒，分钟，小时，日期，月份，星期，年(option)
@Scheduled(cron="0/10 * * * * *")

注意:
spring task: 在计算时间的时候，是根据当前服务器的系统时间进行计算的；
如果每十秒执行一次，那么它从系统时间的0，10，20秒进行计算；
如果每一分钟执行一次，那么它是从系统时间1分钟，2分钟，进行计算。

_ 区间
* 通配符
? 你不想设置那个字段

e.g:

cronExpression配置说明和cron例子

1.创建一个新程序
2.pom文件添加依赖
3.编写启动类
4.编写scheduler

1.创建一个新程序

新建一个Maven Project工程，创建方法不再赘述。

2.pom文件添加依赖

添加Spring的常规依赖
代码如下，可以直接拷贝之前工程pom.xml

<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.avalanching</groupId>
    <artifactId>spring-task</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>spring-task</name>
    <url>http://maven.apache.org</url>

    <!-- 配置parent maven 自动选择最合适的版本 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
    </parent>


    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- 指定一下jdk的版本 ，这里我们使用jdk 1.8 ,默认是1.6 -->
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!-- spring-boot-starter-web: MVC,AOP的依赖包.... -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!-- <version></version> 由于我们在上面指定了 parent(spring boot) -->
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

3.编写启动类

package com.avalanching.spring_task;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Hello world!
 *
 */
@SpringBootApplication
public class App 
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
        SpringApplication.run(App.class, args);
    }
}

4.编写scheduler

package com.avalanching.spring_task.custom;

import java.util.Date;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

@Configuration
@EnableScheduling
public class Scheduler {

    @Scheduled(cron="0/10 * * * * *")
    public void testTask1() {
        System.out.println("我是每十秒执行一次的方法，当前时间是:" + new Date());
    }
    
    @Scheduled(cron="0 0/1 * * * *")
    public void testTask2() {
        System.out.println("我是每分钟执行一次的方法，当前时间是:" + new Date());
    }
}

运行代码，查看打印即可

动态传入具体时间配置

使用@EnableScheduling注释实现于SchedulingConfigurer接口的类

1.新建一个实现于SchedulingConfigurer的类

2.重新public void configureTasks(SchedulingTaskRegistrar taskRegistrar)

3.为了方便测试将这个类设置为一个controller，通过接口穿过来表达式，改变执行方式

package com.avalanching.spring_task.custom;

import java.util.Date;

import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@EnableScheduling
public class ApplicationScheduler implements SchedulingConfigurer {

    // 每五秒执行一下定时任务
    private String expression = "0/5 * * * * *" ;
    
    @RequestMapping("/changetime")
    public String changeExprssion(String expression) {
        if (expression == null) {
            return "handle falure";
        }
        this.expression = expression;
        return "handle success";
    }
    
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        Runnable task = new Runnable() {
            
            public void run() {
                
                System.out.println("configureTask.run, " + new Date());
            }
        };
        
        Trigger trigger = new Trigger() {
            
            public Date nextExecutionTime(TriggerContext triggerContext) {
                CronTrigger cronTrigger = new CronTrigger(expression);
                return cronTrigger.nextExecutionTime(triggerContext);
            }
        };
        taskRegistrar.addTriggerTask(task, trigger);
    }
    
}

注意：

public interface Runnable
是java的一个多线程操作的接口，这里仅仅是一个接口，我们要写一个它实现类才可以使用它，做为iOS的开发者，我们可以简单将它理解成一个NSOperation，现实run方法，如同为实现了NSOperation的main方法，在java中实现Runnable的类，就如同iOS中自定义的NSOperation的子类，两者用法相似。