Spring Boot 整合 JDBC 详解
Spring Boot 是一个基于 Spring 框架的开源框架，它简化了 Spring 应用程序的配置和开发。整合 JDBC 可以让我们更方便地与数据库进行交互。以下是 Spring Boot 整合 JDBC 的详细步骤。
1. 创建 Spring Boot 项目
可以使用 Spring Initializr 创建一个新的 Spring Boot 项目。在项目中选择以下依赖：
Spring Web
postgreSql
2. 配置数据源
在 application.yml 中配置数据库连接信息。
示例 application.yml
spring:
datasource:
url: jdbc:h2:mem:testdb
driver-class-name: org.h2.Driver
username: sa
password: ''
h2:
console:
enabled: true
3. 创建数据模型
创建一个简单的实体类，例如 User。
package com.example.demo.model;
import javax.persistence.Entity;
import javax.persistence.Id;
public class User {
private Long id;
private String name;
// Getters and Setters
}
4. 创建 JDBC Repository
可以使用 JdbcTemplate 进行数据库操作。创建一个 UserRepository 类。
package com.example.demo.repository;
import com.example.demo.model.User;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public class UserRepository {
private final JdbcTemplate jdbcTemplate;
public UserRepository(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
public void save(User user) {
String sql = "INSERT INTO user (id, name) VALUES (?, ?)";
jdbcTemplate.update(sql, user.getId(), user.getName());
}
public List<User> findAll() {
String sql = "SELECT * FROM user";
return jdbcTemplate.query(sql, (rs, rowNum) -> {
User user = new User();
user.setId(rs.getLong("id"));
user.setName(rs.getString("name"));
return user;
});
}
}
5. 创建控制器
创建一个简单的控制器以处理 HTTP 请求。
package com.example.demo.controller;
import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/users")
public class UserController {
private final UserRepository userRepository;
public UserController(UserRepository userRepository) {
this.userRepository = userRepository;
}
@PostMapping
public void addUser(@RequestBody User user) {
userRepository.save(user);
}
@GetMapping
public List<User> getAllUsers() {
return userRepository.findAll();
}
}
6. 启动应用
确保在项目的主类中添加 @SpringBootApplication 注解并运行应用。
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
集成 Druid 数据源
Druid 是一个高性能的开源数据库连接池，它提供了监控和扩展功能，可以作为 Spring Boot 项目的数据源。以下是集成 Druid 数据源的详细步骤。
1. 添加 Druid 依赖
在 pom.xml 文件中添加 Druid 的 Maven 依赖：
<!--Druid数据库连接池依赖-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.14</version>
</dependency>
2. 配置 Druid 数据源
在 application.yml 中配置 Druid 数据源信息，包括 URL、用户名、密码等。
示例 application.yml
spring:
datasource:
url: jdbc:druid://localhost:3306/mydb
username: root
password: root
driver-class-name: com.mysql.cj.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource
# druid 数据源专有配置
# 不是druid-spring-boot-starter依赖，SpringBoot默认是不注入druid数据源专有属性值的，需要自己绑定
initialSize: 5
minIdle: 5
maxActive: 20
maxWait: 60000
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: SELECT 1 FROM DUAL
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 20
useGlobalDataSourceStat: true
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计。stat:监控统计 log4:日志记录 wall:防御sql注入
# 如果运行时报错：ClassNotFoundException:orgapache.log4j.Priority，则导入log4j依赖即可
filters: stat,wall,log4j
# 自动往数据库建表
#schema:
#- classpath:department.sql
3. 配置 Druid 监控页面
在 Spring Boot 项目中配置 Druid 的监控页面，可以通过以下步骤实现：
创建配置类
package com.example.demo.config;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class DruidConfig {
@ConfigurationProperties(prefix = "spring.datasource")
@Bean
@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "com.alibaba.druid.pool.DruidDataSource")
public DataSource dataSource() {
return new DruidDataSource();
}
@Bean
public ServletRegistrationBean<StatViewServlet> druidServlet() {
ServletRegistrationBean<StatViewServlet> servletRegistrationBean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
servletRegistrationBean.addInitParameter("loginUsername", "admin");
servletRegistrationBean.addInitParameter("loginPassword", "admin");
return servletRegistrationBean;
}
@Bean
public FilterRegistrationBean<WebStatFilter> filterRegistrationBean() {
FilterRegistrationBean<WebStatFilter> filterRegistrationBean = new FilterRegistrationBean<>(new WebStatFilter());
filterRegistrationBean.addUrlPatterns("/*");
filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
return filterRegistrationBean;
}
}
4. 启动应用
在项目的主类中添加 @SpringBootApplication 注解并运行应用，Druid 数据源将会被成功集成到 Spring Boot 项目中。
通过以上步骤，你可以成功地将 Druid 数据源集成到 Spring Boot 项目中，实现对数据库连接池的监控和管理。
整合MyBatis框架
整合 MyBatis 框架可以让我们更方便地进行数据库操作。以下是整合 MyBatis 的详细步骤。
1. 添加 MyBatis 依赖
在 pom.xml 文件中添加 MyBatis 的 Maven 依赖：
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.4</version>
</dependency>
2. 配置数据源
在 application.yml 中配置数据库连接信息，与之前整合 JDBC 时的配置相同。
3. 创建数据模型和映射文件
创建一个数据模型类，例如 User，并在 resources 目录下创建一个与数据模型类对应的映射文件 UserMapper.xml。
示例 User.java
package com.example.demo.model;
public class User {
private Long id;
private String name;
// Getters and Setters
}
示例 UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.UserMapper">
<resultMap id="BaseResultMap" type="com.example.demo.model.User">
<id column="id" property="id" />
<result column="name" property="name" />
</resultMap>
<select id="findAll" resultMap="BaseResultMap">
SELECT * FROM user
</select>
<insert id="save" parameterType="com.example.demo.model.User">
INSERT INTO user (id, name) VALUES (#{id}, #{name})
</insert>
</mapper>
4. 创建 Mapper 接口
创建一个 Mapper 接口，例如 UserMapper，用于定义数据库操作的方法。
示例 UserMapper.java
package com.example.demo.mapper;
import com.example.demo.model.User;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;
@Mapper
public interface UserMapper {
@Select("SELECT * FROM user")
List<User> findAll();
@Insert("INSERT INTO user (id, name) VALUES (#{id}, #{name})")
void save(User user);
}
5. 创建 Service 类
创建一个 Service 类，例如 UserService，用于调用 Mapper 接口中的方法进行数据库操作。
示例 UserService.java
package com.example.demo.service;
import com.example.demo.mapper.UserMapper;
import com.example.demo.model.User;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserService {
private final UserMapper userMapper;
public UserService(UserMapper userMapper) {
this.userMapper = userMapper;
}
public List<User> getAllUsers() {
return userMapper.findAll();
}
public void addUser(User user) {
userMapper.save(user);
}
}
6. 创建控制器
创建一个控制器类，例如 UserController，用于处理 HTTP 请求。
示例 UserController.java
package com.example.demo.controller;
import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/users")
public class UserController {
private final UserService userService;
public UserController(UserService userService) {
this.userService = userService;
}
@GetMapping
public List<User> getAllUsers() {
return userService.getAllUsers();
}
@PostMapping
public void addUser(@RequestBody User user) {
userService.addUser(user);
}
}
7. 启动应用
在项目的主类中添加 @SpringBootApplication 注解并运行应用，MyBatis 框架将会被成功集成到 Spring Boot 项目中。
通过以上步骤，你可以成功地将 MyBatis 框架集成到 Spring Boot 项目中，实现对数据库的操作。
Spring Security 详解
一般Web应用的需要进行认证和授权。
认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户
授权：经过认证后判断当前用户是否有权限进行某个操作
而认证和授权也是SpringSecurity作为安全框架的核心功能。
核心概念
身份验证 (Authentication)
身份验证是确认用户身份的过程。Spring Security 提供了多种身份验证机制，如表单登录、HTTP Basic、OAuth2 等。
AuthenticationManager：用于管理认证过程的核心接口，通常通过ProviderManager 实现。
Authentication：表示认证请求或认证结果的接口，通常包含用户名和密码等信息。
UserDetailsService：用于从数据库或其他源加载用户特定数据的接口，返回 UserDetails 对象。
UserDetails：存储用户信息的核心接口，通常包含用户名、密码、是否启用、账户是否过期、凭证是否过期、账户是否锁定等信息。
1.2 授权 (Authorization)
授权是控制用户访问资源的过程。Spring Security 使用基于角色的访问控制 (RBAC) 和权限来实现授权。
AccessDecisionManager：用于做出访问决策的核心接口，通常通过 AffirmativeBased 实现。
AccessDecisionVoter：投票决定是否允许访问，ROLE、Scope 和 IP 是常见的投票者类型。
GrantedAuthority：表示授予用户的权限（例如角色）的接口，通常通过 SimpleGrantedAuthority 实现。
1.3 过滤器链 (Filter Chain)
Spring Security 使用一系列过滤器（Filter Chain）来处理安全相关的操作。每个过滤器在请求到达控制器之前进行特定的安全检查。
SecurityFilterChain：包含一个或多个过滤器的链，按顺序处理 HTTP 请求。
登陆校验流程
SpringSecurity完整流程
SpringSecurity的原理其实就是一个过滤器链，内部包含了提供各种功能的过滤器。
UsernamePasswordAuthenticationFilter:负责处理我们在登陆页面填写了用户名密码后的登陆请求。
ExceptionTranslationFilter： 处理过滤器链中抛出的任何AccessDeniedException和AuthenticationException 。
FilterSecurityInterceptor： 负责权限校验的过滤器。
认证流程详解
Authentication接口: 它的实现类，表示当前访问系统的用户，封装了用户相关信息。
AuthenticationManager接口：定义了认证Authentication的方法
UserDetailsService接口：加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法。
UserDetails接口：提供核心用户信息。通过UserDetailsService根据用户名获取处理的用户信息要封装成UserDetails对象返回。然后将这些信息封装到Authentication对象中。
核心组件
2.1 SecurityContext
用于保存当前已认证用户的安全上下文信息，通常通过 SecurityContextHolder 来访问。
SecurityContextHolder：持有当前应用程序的安全上下文信息，允许获取当前用户的身份信息。
SecurityContext context = SecurityContextHolder.getContext();
Authentication authentication = context.getAuthentication();
String username = authentication.getName();
2.2 HttpSecurity
用于配置基于 HTTP 的安全保护，包括设置哪些 URL 需要保护、使用哪种认证方式等。
http
.authorizeRequests()
.antMatchers("/public/**").permitAll()
.anyRequest().authenticated()
.and()
.formLogin()
.loginPage("/login")
.permitAll()
.and()
.logout()
.permitAll();
2.3 WebSecurityConfigurerAdapter
一个配置类，用于自定义 Spring Security 的配置，通常通过重写 configure 方法来设置各种安全选项。
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/public/**").permitAll()
.anyRequest().authenticated()
.and()
.formLogin()
.loginPage("/login")
.permitAll()
.and()
.logout()
.permitAll();
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth
.inMemoryAuthentication()
.withUser("user").password("{noop}password").roles("USER")
.and()
.withUser("admin").password("{noop}admin").roles("ADMIN");
}
}
3. 认证机制
3.1 基于表单的认证 (Form-Based Authentication)
用户通过登录表单提交用户名和密码进行认证。
http
.formLogin()
.loginPage("/login")
.loginProcessingUrl("/perform_login")
.defaultSuccessUrl("/homepage.html", true)
.failureUrl("/login.html?error=true")
.and()
.logout()
.logoutUrl("/perform_logout")
.deleteCookies("JSESSIONID");
3.2 HTTP Basic 认证
使用 HTTP Basic 头信息进行认证。
http
.authorizeRequests()
.anyRequest().authenticated()
.and()
.httpBasic();
3.3 Token-Based 认证 (如 JWT)
使用令牌（如 JWT）在客户端和服务器端之间传递身份认证信息。
public class JWTAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
private AuthenticationManager authenticationManager;
public JWTAuthenticationFilter(AuthenticationManager authenticationManager) {
this.authenticationManager = authenticationManager;
}
@Override
public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
// 从请求中提取用户名和密码
}
@Override
protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
// 生成 JWT 并在响应中返回
}
}
4. 授权机制
4.1 基于 URL 的授权
通过配置哪些 URL 需要哪些角色或权限来进行授权。
http
.authorizeRequests()
.antMatchers("/admin/**").hasRole("ADMIN")
.antMatchers("/user/**").hasAnyRole("USER", "ADMIN")
.anyRequest().authenticated();
4.2 基于方法的授权
通过注解方式，在方法级别上进行授权。
@PreAuthorize("hasRole('ROLE_USER')")
public void someMethod() {
// Method implementation
}
5. 防护措施
5.1 CSRF (Cross-Site Request Forgery)
Spring Security 默认启用 CSRF 防护，保护应用免受 CSRF 攻击。
http
.csrf().disable(); // 禁用 CSRF 防护（不推荐）
5.2 CORS (Cross-Origin Resource Sharing)
配置跨域资源共享策略，允许或限制跨域请求。
http
.cors().configurationSource(corsConfigurationSource());
@Bean
public CorsConfigurationSource corsConfigurationSource() {
CorsConfiguration configuration = new CorsConfiguration();
configuration.setAllowedOrigins(Arrays.asList("http://localhost:3000"));
configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE"));
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", configuration);
return source;
}
6. 集成 OAuth2
Spring Security 提供了对 OAuth2 和 OpenID Connect 的支持，可以轻松集成第三方身份提供者（如 Google、Facebook）。
@EnableWebSecurity
public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests(a -> a
.anyRequest().authenticated()
)
.oauth2Login();
}
}
7. 自定义扩展
7.1 自定义 UserDetailsService
通过实现 UserDetailsService 接口来自定义用户数据的加载逻辑。
@Service
public class CustomUserDetailsService implements UserDetailsService {
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
// 自定义用户加载逻辑
return new User(username, password, authorities);
}
}
7.2 自定义认证过滤器
通过扩展 UsernamePasswordAuthenticationFilter 来实现自定义的认证逻辑。
public class CustomAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
@Override
public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) {
// 自定义认证逻辑
}
}
8. 配置示例
以下是一个完整的 Spring Security 配置示例，结合了以上讲述的各个方面：
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private CustomUserDetailsService userDetailsService;
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/public/**").permitAll()
.antMatchers("/admin/**").hasRole("ADMIN")
.anyRequest().authenticated()
.and()
.formLogin()
.loginPage("/login")
.loginProcessingUrl("/perform_login")
.defaultSuccessUrl("/homepage.html", true)
.failureUrl("/login.html?error=true")
.permitAll()
.and()
.logout()
.logoutUrl("/perform_logout")
.deleteCookies("JSESSIONID")
.permitAll()
.and()
.csrf().disable()
.cors().configurationSource(corsConfigurationSource());
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userDetailsService)
.passwordEncoder(passwordEncoder());
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Bean
public CorsConfigurationSource corsConfigurationSource() {
CorsConfiguration configuration = new CorsConfiguration();
configuration.setAllowedOrigins(Arrays.asList("http://localhost:3000"));
configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE"));
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", configuration);
return source;
}
}
密码加密存储
实际项目中我们不会把密码明文存储在数据库中。
默认使用的PasswordEncoder要求数据库中的密码格式为：{id}password 。它会根据id去判断密码的加密方式。但是我们一般不会采用这种方式。所以就需要替换PasswordEncoder。
我们一般使用SpringSecurity为我们提供的BCryptPasswordEncoder。
我们只需要使用把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验。
我们可以定义一个SpringSecurity的配置类，SpringSecurity要求这个配置类要继承WebSecurityConfigurerAdapter。
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
}任务
1. 异步任务
异步任务可以在后台线程中执行，避免阻塞主线程。使用 @Async 注解来定义异步方法。
示例：
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service
public class AsyncService {
@Async
public void asyncMethod() {
// 任务逻辑
}
}
配置：
在主类或配置类上添加 @EnableAsync 注解以启用异步支持。
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
@SpringBootApplication
@EnableAsync
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
2. 定时任务
定时任务用于按照特定时间间隔执行任务。使用 @Scheduled 注解来定义定时方法。
示例：
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
@Service
public class ScheduledService {
@Scheduled(fixedRate = 5000) // 每5秒执行一次
public void scheduledMethod() {
// 任务逻辑
}
}
配置：
同样需要在主类或配置类上添加 @EnableScheduling 注解以启用定时任务。
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
@SpringBootApplication
@EnableScheduling
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
通过以上配置和示例，你可以轻松实现 Spring Boot 中的异步任务和定时任务，提升应用程序的效率和响应能力。想要深入探讨某个特定方面吗？
Spring Boot 邮件任务
Spring Boot 提供了简单而强大的邮件发送功能，可以用于发送文本邮件、HTML 邮件、附件邮件等。以下是使用 Spring Boot 发送邮件的详细步骤。
1. 添加依赖
首先，在 pom.xml 文件中添加 Spring Boot 邮件依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>
2. 配置邮件发送参数
在 application.yml 中配置邮件发送参数，包括邮件服务器地址、端口、用户名、密码等。
示例 application.yml
spring:
mail:
host: smtp.example.com
port: 587
username: your-email@example.com
password: your-email-password
properties:
mail:
smtp:
auth: true
starttls:
enable: true
3. 创建邮件服务类
创建一个邮件服务类，用于发送邮件。
示例邮件服务类
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Service;
@Service
public class EmailService {
@Autowired
private JavaMailSender emailSender;
public void sendSimpleEmail(String to, String subject, String text) {
SimpleMailMessage message = new SimpleMailMessage();
message.setTo(to);
message.setSubject(subject);
message.setText(text);
emailSender.send(message);
}
}
4. 发送邮件
在需要发送邮件的地方调用邮件服务类的方法发送邮件。
示例发送邮件
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class EmailController {
@Autowired
private EmailService emailService;
@PostMapping("/sendEmail")
public void sendEmail(@RequestBody EmailRequest request) {
emailService.sendSimpleEmail(request.getTo(), request.getSubject(), request.getText());
}
}
通过以上步骤，你可以成功地在 Spring Boot 项目中集成邮件发送功能，实现发送文本邮件的功能。如果需要发送 HTML 邮件或带附件的邮件，可以进一步扩展邮件服务类和控制器来实现。
详解定时规则设置
在 Spring Boot 中，使用 @Scheduled 注解来定义定时任务方法，并通过 cron 属性来设置定时规则。下面是对定时规则设置的详细解释：
cron 表达式
cron 表达式是一个字符串，用于定义定时任务的执行规则。它由6个字段组成，分别表示秒、分钟、小时、日期、月份和星期几。每个字段可以是一个具体的值，一个范围，一个通配符或者一个逗号分隔的列表。
例子
0 0 12 * * ?：每天中午12点触发0 15 10 ? * *：每天上午10:15触发0 15 10 * * ?：每天上午10:15触发0 15 10 * * ? *：每天上午10:15触发0 15 10 * * ? 2005：2005年的每天上午10:15触发0 * 14 * * ?：每天下午2点到2点59分每分钟触发0 0/5 14 * * ?：每天下午2点到2点59分每5秒触发0 0/5 14,18 * * ?：每天下午2点到2点59分和下午6点到6点59分每5秒触发0 0-5 14 * * ?：每天下午2点到2点5分每分钟触发
字段含义
秒：0-59分钟：0-59小时：0-23日期：1-31月份：1-12 或者 JAN-DEC星期：1-7 或者 SUN-SAT
特殊字符
*：通配符，表示任意值?：非确定的值，用于日期和星期字段-：范围，表示一个范围内的值,：列表分隔符，表示一个列表的值/：增量，表示一个起始值和增量
示例
@Scheduled(cron = "0 0 12 * * ?") // 每天中午12点触发
public void scheduledMethod() {
// 任务逻辑
}
SpringBoot基础（二）
https://blog.mykele.asia/archives/springbootji-chu-er
Comments