java image流转成file java将流转为文件

转载

mob64ca13fd9f8e 2023-10-23 16:49:09

文章标签 java image流转成file java spring 配置文件 Java 文章分类 Java 后端开发

Java微服务篇1——SpringBoot

1、什么是springboot

1.1、Spring出现的问题

Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需开发重量级的 Enterprise Java Bean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象（Plain Old Java Object，POJO）实现了EJB的功能

虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML 配置。Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML
所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少
除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度

1.2、SpringBoot的诞生

SpringBoot对上述Spring的缺点进行的改善和优化，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期

起步依赖：本质上是一个Maven项目对象模型(Project Object Model，POM)，定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。简单的说，起步依赖就是将具备某种功能的依赖坐标打包到一起，并提供一些默认的功能
自动装配：指的是springboot，会自动将一些配置类的bean注册进ioc容器，我们可以需要的地方使用@autowired或者@resource等注解来使用它。 “自动”的表现形式就是我们只需要引我们想用功能的包，相关的配置我们完全不用管，springboot会自动注入这些配置bean，我们直接使用这些bean即可

2、SpringBoot核心理念

约定大于配置

Build Anything with Spring Boot：Spring Boot is the starting point forbuilding all Spring-based applications. Spring Boot is designed to get you up and running as quickly as possible, with minimal upfront configuration of Spring.

使用Spring Boot构建任何东西：Spring Boot是构建所有基于Spring的应用程序的起点。Spring Boot的设计目的是让您以最少的Spring前端配置尽快启动和运行

3、SpringBoot快速入门

3.1、创建项目

java image流转成file java将流转为文件_java image流转成file

java image流转成file java将流转为文件_java_02

java image流转成file java将流转为文件_配置文件_03

java image流转成file java将流转为文件_配置文件_04

3.2、pom.xml

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--
    所有的springBoot项目都会直接或者间接的继承spring-boot-starter-parent
    1.指定项目的编码格式为UTF-8
    2.指定JDK版本为1.8
    3.对项目依赖的版本进行管理，当前项目再引入其他常用的依赖时就需要再指定版本号，避免版本冲突的问题
    4.默认的资源过滤和插件管理
    -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>cn.winkto</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <!--可以将project打包为一个可以执行的jar-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3.3、启动类

// SpringBoot的启动类通常放在二级包中，SpringBoot项目在做包扫描，会扫描启动类所在的包及其子包下的所有内容。

//标识当前类为SpringBoot项目的启动类
@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

3.4、Controller

@RestController
public class SpringBootController {
    @RequestMapping("/hello")
    public String hello(){
        return "Hello, SpringBoot!";
    }
}

4、SpringBoot单元测试

// 标记为当前类为SpringBoot测试类，加载项目的ApplicationContext上下文环境
@SpringBootTest
class DemoApplicationTests {

    @Autowired
    SpringBootController springBootController;

    @Test
    void contextLoads() {
        System.out.println(springBootController.hello());
    }

}

5、热部署

在开发过程中，通常会对一段业务代码不断地修改测试，在修改之后往往需要重启服务，有些服务需要加载很久才能启动成功，这种不必要的重复操作极大的降低了程序开发效率。为此，Spring Boot框架专门提供了进行热部署的依赖启动器，用于进行项目热部署，而无需手动重启项目。

5.1、导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
</dependency>

5.2、开启Idea的自动编译

java image流转成file java将流转为文件_Java_05

5.3、开启Idea的在项目运行中自动编译

Ctrl+Shift+Alt+/打开Maintenance选项框，勾选compiler.automake.allow.when.app.running

java image流转成file java将流转为文件_spring_06

然后自行测试即可

6、配置文件

配置文件能够对一些默认配置值进行修改，Spring Boot使用一个application.properties或者application.yaml（application.yml）的文件作为全局配置文件，该文件存放在**src/main/resource目录（常用）**或者类路径的/config

实体类

@Component
// @ConfigurationProperties注解用来快速、方便地将配置文件中的自定义属性值批量注入到某个Bean对象的多个对应属性中(@Value仅支持基础类型！)
// 保证配置文件中person.xx与当前Person类的属性名一致
// 保证当前Person中的属性都具有set方法
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private int age;
    private double money;
    private String[] hobbies;
    private List<String> books;
    private Set<String> lotteries;
    private Map<String,String> bankcards;
    private Pet pet;
}

public class Pet {
    private String name;
    private int age;
}

@ConfigurationProperties(prefix = “person”)爆红问题

虽然爆红，但是不影响运行，实在看着不爽，引入一个依赖解决一下

<!--处理@ConfigurationProperties(prefix = "person")爆红-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

6.1、properties配置文件

#tomcat的端口号
server.port=8099

#基础类型
person.name=zhangsan
person.age=20
person.money=123.5
#数组和集合（list，set）种赋值方式可以互换
person.hobbies=basketball,football,volleyball
person.books[0]=book1
person.books[1]=book2
person.books[2]=book3
person.lotteries[0]=book1
person.lotteries[1]=book2
person.lotteries[2]=book3
#map
person.bankcards.ICBC=123456789
person.bankcards.ABC=987654321
#对象
person.pet.name=huahua
person.pet.age=2

6.2、yaml配置文件

YAML文件格式是Spring Boot支持的一种JSON文件格式，相较于传统的Properties配置文件，YAML文件以数据为核心，是一种更为直观且容易被电脑识别的数据序列化格式，application.yaml配置文件的工作原理和application.properties是一样的，yaml格式配置文件看起来更简洁一些

对空格要求极其严格

server:
  port: 8099
person:
  name: zhangsan
  age: 20
  money: 123.5
  hobbies: baskball,football,volleyball
  books:
    - book1
    - book2
    - book3
  lotteries: [lottery1,lottery2,lottery3]
  bankcards: {ICBC: 123456789,ABC: 987654321}
  pet:
    name: huahua
    age: 2

6.3、测试

@SpringBootTest
class DemoApplicationTests {

    @Autowired
    Person person;

    @Test
    void contextLoads() {
        System.out.println(person.toString());
    }

}

6.4、配置文件优先级

spring-boot-starter-parent-2.5.3.pom中出现这个的配置文件加载顺序，那么文件的优先级yml<yaml<properties

<includes>
  <include>**/application*.yml</include>
  <include>**/application*.yaml</include>
  <include>**/application*.properties</include>
</includes>

6.5、自定义配置文件

有时候我们需要一些额外的配置文件，比如secretkey.properties，但是SpringBoot并不知道我们要加载这个配置文件，此时我们需要使用@PropertySource加载自定义配置文件（@PropertySource只对properties文件可以进行加载，对于yml或者yaml不能支持，需要自行实现）

@Component
@PropertySource("classpath:secretkey.properties")
@ConfigurationProperties(prefix = "secretkey")
public class SecretKey {
    private int num;
    private String secretkey;

    public SecretKey() {
    }

    public SecretKey(int num, String secretkey) {
        this.num = num;
        this.secretkey = secretkey;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getSecretkey() {
        return secretkey;
    }

    public void setSecretkey(String secretkey) {
        this.secretkey = secretkey;
    }

    @Override
    public String toString() {
        return "SecretKey{" +
                "num=" + num +
                ", secretkey='" + secretkey + '\'' +
                '}';
    }
}

secretkey.num=22
secretkey.secretkey=abcdefg

// 标记为当前类为SpringBoot测试类，加载项目的ApplicationContext上下文环境
@SpringBootTest
class DemoApplicationTests {

    @Autowired
    SecretKey secretKey;

    @Test
    void contextLoads() {
        System.out.println(secretKey.toString());
    }

}

6.6、自定义配置类（推荐使用）

在Spring Boot框架中，通常使用@Configuration注解定义一个配置类，Spring Boot会自动扫描和识别配置类，从而替换传统Spring框架中的XML配置文件

// 标识该类是一个配置类
@Configuration
public class WinktoConfig {
    // 将返回值对象作为组件添加到Spring容器中，该组件id默认为方法名
    @Bean
    public ObjectMapper objectMapper(){
        return new ObjectMapper();
    }
}

@SpringBootTest
class DemoApplicationTests {

    @Autowired
    SecretKey secretKey;

    @Autowired
    ObjectMapper objectMapper;

    @Test
    void contextLoads() throws JsonProcessingException {
        System.out.println(objectMapper.writeValueAsString(secretKey));
    }

}

6.7、多配置文件

application.yaml可以放在以下位置

file:./config/
file:./
classpath:/config/
classpath:/

java image流转成file java将流转为文件_spring_07

可自行设置端口号进行测试，上述给出的顺序就是优先级从高到低的顺序

6.8、多环境

application-prod.yaml

server:
  port: 8099

application-dev.yaml

server:
  port: 8080

application.yaml

spring:
  profiles:
    active: prod

java image流转成file java将流转为文件_Java_08

上述三个文档也可以写在一个文档里

application.yaml

spring:
  profiles:
    active: prod
---
server:
  port: 8081
spring:
  profiles: dev
---
server:
  port: 8099
spring:
  profiles: prod

7、SpringBoot整合持久层

数据库准备

CREATE TABLE person(
	pid INT PRIMARY,
	pname VARCHAR(20),
	ppassword VARCHAR(20)
)

实体类

public class Person {
    private int pid;
    private String pname;
    private String ppassword;
}

7.1、JDBC

7.1.1、导入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <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>
    </dependency>
</dependencies>

7.1.2、application.yaml

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: blingbling123.
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai

7.1.3、controller

这里我就不在分层，直接写在controller里

@RestController
public class SpringBootController {
    @Autowired
    JdbcTemplate jdbcTemplate;
    @RequestMapping("/select")
    public List<Map<String, Object>> select(){
        List<Map<String, Object>> list = jdbcTemplate.queryForList("select * from person");
        return list;
    }
    @RequestMapping("/insert")
    public List<Map<String,Object>> insert(){
        jdbcTemplate.update("insert into person values (10,'小明','xiaoming')");
        List<Map<String, Object>> list = select();
        return list;
    }
    @RequestMapping("/update")
    public List<Map<String,Object>> update(){
        jdbcTemplate.update("update person set pname='小小明',ppassword='123456' where pid=10");
        List<Map<String, Object>> list = select();
        return list;
    }
    @RequestMapping("/delete")
    public List<Map<String,Object>> delList(){
        jdbcTemplate.update("delete from person where pid=10");
        List<Map<String, Object>> list = select();
        return list;
    }
}

7.2、Mybaits

7.2.1、导入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>
    <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>
    </dependency>
</dependencies>

7.2.2、mybatis书写

7.2.2.1、注解方式

mapper

@Repository
public interface PersonMapper {
    @Select("select * from person")
    public List<Person> selectPerson();
}

修改启动类

//标识当前类为SpringBoot项目的启动类
@SpringBootApplication
//指定扫描的mapper路径
@MapperScan("cn.winkto.mapper")
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

7.2.2.2、配置文件方式

mapper

@Repository
public interface PersonMapper {
    public List<Person> selectPerson();
}

映射文件

<?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="cn.winkto.mapper.PersonMapper">
    <select id="selectPerson" resultType="Person">
        select * from person
    </select>
</mapper>

application.yaml配置映射文件地址及别名

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: blingbling123.
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
mybatis:
  #配置MyBatis的xml配置文件路径
  mapper-locations: classpath:mapper/*.xml
  #配置XML映射文件中指定的实体类别名路径
  type-aliases-package: cn.winkto.bean

修改启动类

//标识当前类为SpringBoot项目的启动类
@SpringBootApplication
//指定扫描的mapper路径
@MapperScan("cn.winkto.mapper")
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

7.2.3、测试

// 标记为当前类为SpringBoot测试类，加载项目的ApplicationContext上下文环境
@SpringBootTest
class DemoApplicationTests {

    @Autowired
    PersonMapper personMapper;

    @Test
    void contextLoads() throws JsonProcessingException {
        System.out.println(personMapper.selectPerson());
    }

}

7.3、Redis

7.3.1、导入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <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>
    </dependency>
</dependencies>

7.3.2、application.yaml

需要注意的是，springboot2.x中spring-boot-starter-data-redis使用的不再是jedis，而是lettuce，所以如果设置连接池，需要选择lettuce下的连接池

spring:
  redis:
    host: 132.232.82.49

7.3.3、测试

// 标记为当前类为SpringBoot测试类，加载项目的ApplicationContext上下文环境
@SpringBootTest
class DemoApplicationTests {

    @Autowired
    RedisTemplate redisTemplate;

    @Test
    void contextLoads() throws JsonProcessingException {
        // 操作字符串：redisTemplate.opsForValue()
        // 操作list集合：redisTemplate.opsForList()
        // 操作set集合：redisTemplate.opsForSet();
        // 操作hash：redisTemplate.opsForHash();
        // 操作zset集合：redisTemplate.opsForZSet();
        // 操作地图数据：redisTemplate.opsForGeo();
        // 操作HyperLogLog：redisTemplate.opsForHyperLogLog();
        // 除了公用，常用操作被提取出来了，其他的操作如同jedis
        redisTemplate.opsForValue().set("k1","v1");
        System.out.println(redisTemplate.opsForValue().get("k1"));
    }

}

8、SpringBoot视图层

前端模板引擎技术的出现，使前端开发人员无需关注后端业务的具体实现，只关注自己页面的呈现效果即可，并且解决了前端代码错综复杂的问题、实现了前后端分离开发

Spring Boot框架对很多常用的模板引擎技术（如：FreeMarker、Thymeleaf、Mustache等）提供了整合支持

8.1、静态资源目录

#webjars
classpath:/NETA-INF/resources/
#上传文件
classpath:/resources/
#图片等
classpath:/static/
#css、js等
classpath:/public/

注意优先级，从上到下从高到低

resources/templates相当于之前的WEB-INF目录，下面的页面只能通过controller进行访问，并且需要模板引擎

自定义页面图标：起名为favicon.icon，放入resources

8.2、Thymeleaf

8.2.1、Thymeleaf快速入门

th标签	说明
th:utext	取值，并按照html格式进行解析
th:text	仅取值

Thymeleaf内置对象

#ctx：上下文对象，可以从中获取所有的thymeleaf内置对象
#arrays：数组操作的工具
#aggregates：操作数组或集合的工具
#bools：判断boolean类型的工具
#calendars：类似于#dates，但是是java.util.Calendar类的方法
#dates：日期格式化内置对象，具体方法可以参照java.util.Date
#numbers： 数字格式化；#strings：字符串格式化，具体方法可以参照java.lang.String，如startsWith、contains等；#objects：参照java.lang.Object
#lists：列表操作的工具，参照java.util.List
#sets：Set操作工具，参照java.util.Set；#maps：Map操作工具，参照java.util.Map
#messages：操作消息的工具

导入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <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>
    </dependency>
</dependencies>

controller

@Controller
public class SpringBootController {
    @RequestMapping("/hello")
    public String hello(Model model){
        model.addAttribute("text","<h1>Hello, Thymeleaf!</h1>");
        return "hello";
    }
}

页面

# thymeleaf约束
xmlns:th="http://www.thymeleaf.org"

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<p th:utext="${text}"></p>
<p th:text="${text}"></p>
</body>
</html>

8.2.2、th:href和th:src

th标签	说明
th:href	用于html页面link标签引入css（需使用@{}表达式）
th:src	用于html页面script标签引入js（需使用@{}表达式）

目录结构

java image流转成file java将流转为文件_配置文件_09

controller

@Controller
public class SpringBootController {
    @RequestMapping("/path")
    public String path(){
        return "path";
    }
}

css

.card{
    width: 50px;
    height: 50px;
    background-color: skyblue;
}

window.onload=function () {
    let cards = document.getElementsByClassName("card")
    for (let i = 0; i < cards.length; i++) {
        cards[i].onclick=f;
    }
    function f() {
        alert("我被点击了！")
    }
}

页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <!--对于th:href和th:src而言，静态资源目录可以省略-->
    <link rel="stylesheet" th:href="@{/card.css}">
</head>
<body>
    <div class="card">1</div>
    <div class="card">2</div>
</body>
<!--对于th:href和th:src而言，静态资源目录可以省略-->
<script th:src="@{/tap.js}"></script>
</html>

8.2.3、th:if和th:unless

th标签	说明
th:if	如果为真，则显示
th:unless	如果为假，则显示

controller

@Controller
public class SpringBootController {
    @RequestMapping("/condition")
    public String condition(Model model){
        model.addAttribute("flagif",true);
        model.addAttribute("flagunless",false);
        return "condition";
    }
}

页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<p th:if="${flagif}">th:if</p>
<p th:unless="${flagunless}">th:unless</p>
</body>
</html>

8.2.4、th:each

th标签	说明
th:each	for循环，例如：

controller

@Controller
public class SpringBootController {
    @RequestMapping("/each")
    public String each(Model model){
        model.addAttribute("list", Arrays.asList("book","code","music","dance"));
        return "each";
    }
}

页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div>
    <ul>
        <li th:each="item:${list}" th:text="${item}"></li>
    </ul>
</div>
</body>
</html>

8.2.5、th:switch和th:case

th标签	说明
th:switch	如果为真，则显示
th:case	如果为假，则显示

controller

@Controller
public class SpringBootController {
    @RequestMapping("/switch")
    public String switch1(Model model){
        model.addAttribute("gender", 1);
        return "switch";
    }
}

页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<p>性别</p>
<div th:switch="${gender}">
    <p th:case=1>男</p>
    <p th:case=0>女</p>
    <p th:case=*>未知</p>
</div>
</body>
</html>

8.2.6、th:insert和th:replace

th标签	说明
th:insert	在原有标签内插入指定内容，例如：th:insert="~{public::header}"
th:replace	用指定内容替换原有标签，例如：th:replace="~{public::header}"

controller

@Controller
public class SpringBootController {
    @RequestMapping("/contain")
    public String contain(Model model){
        return "contain";
    }
}

页面（public.html）

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
<nav th:fragment="header">
    <a href="#">首页</a>
    <a href="#">分类</a>
</nav>
</body>
</html>

页面（contain.html）

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        div{
            background-color: skyblue;
        }
    </style>
</head>
<body>
<div th:insert="~{public::header}">
</div>
<div th:replace="~{public::header}">
</div>
</body>
</html>

html页面源码

java image流转成file java将流转为文件_spring_10

8.2.7、th:class

controller

@Controller
public class SpringBootController {
    @RequestMapping("/class")
    public String classes(Model model){
        model.addAttribute("classes", "red");
        return "class";
    }
}

页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        .red{
            background-color: red;
        }
        .blue{
            background-color: blue;
        }
    </style>
</head>
<body>
<div th:class="${classes=='red'}?'red':'blue'">
    动态class
</div>
</body>
</html>

8.3、错误处理

在templates下建error文件夹，然后在下面放xxx.html即可，例如：404.html，500.html

8.4、页面国际化

application.yaml

spring:
  messages:
    basename: i18n.login

国际化文件

java image流转成file java将流转为文件_Java_11

# login.properties
login.btn=登录
login.username=用户名
login.password=密码
login.passwordPlaceholder=请输入密码
login.usernamePlaceholder=请输入用户名

# login_zh_CN.properties
login.btn=登录
login.username=用户名
login.password=密码
login.passwordPlaceholder=请输入密码
login.usernamePlaceholder=请输入用户名

# login_en_US.properties
login.btn=login
login.username=username
login.password=password
login.passwordPlaceholder=Please input your password
login.usernamePlaceholder=Please enter your user name

覆盖默认WebMvcConfigurer中的LocaleResolver

public class WinktoLocaleResolver implements LocaleResolver {
    @Override
    public Locale resolveLocale(HttpServletRequest httpServletRequest) {
        // 接收语言的参数 - 传进来的就是形如'zh_CN'这样的参数
        String lang = httpServletRequest.getParameter("lang");
        System.out.println(lang);
        // 使用默认的语言 - 在文中就是login.properties文件里配置的
        Locale locale = Locale.getDefault();
        // 判断接收的参数是否为空，不为空就设置为该语言
        if(!StringUtils.isEmpty(lang)){
            // 将参数分隔 - 假设传进来的是'zh_CN'
            String[] s = lang.split("_");
            // 语言编码:zh   地区编码:CN
            locale = new Locale(s[0],s[1]);
        }
        return locale;
    }

    @Override
    public void setLocale(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Locale locale) {

    }
}

@Configuration
public class WinktoWebMvcConfig implements WebMvcConfigurer {
    @Bean
    public LocaleResolver localeResolver(){
        return new WinktoLocaleResolver();
    }
}

页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form>
    <label for="username" th:text="#{login.username}">username</label>
    <input type="text" id="username" name="username" th:placeholder="#{login.usernamePlaceholder}">
    <label for="password" th:text="#{login.password}">password</label>
    <input type="password" id="password" name="password" th:placeholder="#{login.passwordPlaceholder}">
    <input type="submit" th:value="#{login.btn}">
    <br>
    <a th:href="@{/login(lang='zh_CN')}">中文</a>
    <a th:href="@{/login(lang='en_US')}">英文</a>
</form>
</body>
</html>

9、安全与授权

Spring Security 是针对Spring项目的安全框架，也是Spring Boot底层安全模块默认的技术选型，可以实现强大的Web安全控制

用户认证：系统认为用户是否能登录
用户授权：通俗点讲就是系统判断用户是否有权限去做某些事情

9.1、快速入门

导入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

页面（index.html）

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<a th:href="@{/v/1}">v1</a>
<a th:href="@{/v/2}">v2</a>
<a th:href="@{/v/3}">v3</a>
</body>
</html>

页面（v1.html,v2.html,v3.html）

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
v1
</body>
</html>

页面（403.html）

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>权限不足哦！</h1>
</body>
</html>

访问http://localhost:8080/发现跟我们预料的不一样

java image流转成file java将流转为文件_java image流转成file_12

需要输入用户名密码，其实这是因为引入spring-boot-starter-security的原因，默认有用户名为user，密码在控制台已经打印出来了

java image流转成file java将流转为文件_java image流转成file_13

9.2、认证（账号密码来源）

9.2.1、默认

上述就是默认的账号密码

9.2.2、application.properties（application.yaml）

spring.security.user.name=della
spring.security.user.password=della

9.2.3、配置类

需要覆盖WebSecurityConfigurerAdapter中的configure(AuthenticationManagerBuilder auth)方法，在内存中处理账号密码

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter{
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder())
                .withUser("della").password(new BCryptPasswordEncoder().encode("123456")).roles("v2","v3")
                .and()
                .withUser("author").password(new BCryptPasswordEncoder().encode("123456")).roles("v1");
    }
}

9.2.4、自定义认证接口

实现UserDetailsService接口，定义认证逻辑

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    PasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        if (s==null){
            return null;
        }
        System.out.println("自定义处理逻辑");
        // 假装自己查了数据库，密码为123456
        return new User(s,passwordEncoder.encode("123456"), AuthorityUtils.commaSeparatedStringToAuthorityList("v2,v3"));
    }
}

覆盖默认认证逻辑

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter{

    @Autowired
    UserDetailsServiceImpl userDetailsService;

    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }
    
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }
}

9.3、自定义登录页（走）

目录结构

java image流转成file java将流转为文件_java_14

SecurityConfig

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter{

    @Autowired
    UserDetailsServiceImpl userDetailsService;

    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                // 放行静态资源下的文件，如果不放行，会卡死在登录页！！！（AuthenticationFailureHandler和AuthenticationSuccessHandler都不会触发，甚至是自定义的UserDetailsService都不会触发）
                .antMatchers("/static/**").permitAll()
                // 所有的请求必须登录后才能访问，除了上面定义的（注意anyRequest必须是页面拦截的最后一个）
                .anyRequest().authenticated()
                .and()
                // 自定义登录逻辑，并放行登陆相关页面
                .formLogin().loginPage("/login.html")
                // 登陆处理逻辑接口（可以自定义为其他接口，这样无需实现UserDetailsService）
                .loginProcessingUrl("/login")
                // 成功跳转页面
                .successForwardUrl("/")
                // 失败跳转页面
                .failureForwardUrl("/login.html")
                // 自定义接受参数
                .usernameParameter("username")
                .passwordParameter("password")
                .permitAll()
                .and()
                // 关闭csrf防护，不关闭也会导致卡死在登录页
                .csrf().disable();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }
}

页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="/login" method="post">
    <label for="username">username</label>
    <input type="text" id="username" name="username" placeholder="usernamePlaceholder">
    <label for="password">password</label>
    <input type="password" id="password" name="password" placeholder="passwordPlaceholder">
    <input type="submit" value="login">
</form>
</body>
</html>

9.4、授权

9.4.1、antMatchers

?：匹配一个字符
*：匹配0个或多个字符
**：匹配一个或多个目录

9.4.2、hasAuthority

与UserDetailsServiceImpl中的AuthorityUtils对应，并且严格区分大小写

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter{

    @Autowired
    UserDetailsServiceImpl userDetailsService;

    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                // 放行静态资源下的文件，如果不放行，会卡死在登录页！！！（AuthenticationFailureHandler和AuthenticationSuccessHandler都不会触发，甚至是自定义的UserDetailsService都不会触发）
                .antMatchers("/static/**").permitAll()
                // 角色判断
                .antMatchers("/v/1").hasAuthority("v1")
                .antMatchers("/v/2").hasAuthority("v2")
                .antMatchers("/v/3").hasAuthority("v3")
                // 所有的请求必须登录后才能访问，除了上面定义的（注意anyRequest必须是页面拦截的最后一个）
                .anyRequest().authenticated()
                .and()
                // 自定义登录逻辑，并放行登陆相关页面
                .formLogin().loginPage("/login.html")
                // 登陆处理逻辑接口
                .loginProcessingUrl("/login")
                // 成功跳转页面
                .successForwardUrl("/")
                // 失败跳转页面
                .failureForwardUrl("/login.html")
                // 自定义接受参数
                .usernameParameter("username")
                .passwordParameter("password")
                .permitAll()
                .and()
                // 关闭csrf防护，不关闭也会导致卡死在登录页
                .csrf().disable();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }
}

9.4.3、hasRole

角色必须以ROLE_开头（大小写也必须一致）

UserDetailsServiceImpl

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    PasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        System.out.println(s);
        if (s==null){
            return null;
        }
        System.out.println("自定义处理逻辑");
        // 假装自己查了数据库，密码为123456
        return new User(s,passwordEncoder.encode("123456"), AuthorityUtils.commaSeparatedStringToAuthorityList("ROLE_v1,v2,v3"));
    }
}

SecurityConfig

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter{

    @Autowired
    UserDetailsServiceImpl userDetailsService;

    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                // 放行静态资源下的文件，如果不放行，会卡死在登录页！！！（AuthenticationFailureHandler和AuthenticationSuccessHandler都不会触发，甚至是自定义的UserDetailsService都不会触发）
                .antMatchers("/static/**").permitAll()
                // 角色判断
                .antMatchers("/v/1").hasRole("v1")
                .antMatchers("/v/2").hasAuthority("v2")
                .antMatchers("/v/3").hasAuthority("v3")
                // 所有的请求必须登录后才能访问，除了上面定义的（注意anyRequest必须是页面拦截的最后一个）
                .anyRequest().authenticated()
                .and()
                // 自定义登录逻辑，并放行登陆相关页面
                .formLogin().loginPage("/login.html")
                // 登陆处理逻辑接口
                .loginProcessingUrl("/login")
                // 成功跳转页面
                .successForwardUrl("/")
                // 失败跳转页面
                .failureForwardUrl("/login.html")
                // 自定义接受参数
                .usernameParameter("username")
                .passwordParameter("password")
                .permitAll()
                .and()
                // 关闭csrf防护，不关闭也会导致卡死在登录页
                .csrf().disable();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }
}

9.5、基于注解的访问控制

注解功能默认关闭，需要手动开启

9.5.1、@Secured（用于角色）

取消代码权限控制

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter{

    @Autowired
    UserDetailsServiceImpl userDetailsService;

    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                // 放行静态资源下的文件，如果不放行，会卡死在登录页！！！（AuthenticationFailureHandler和AuthenticationSuccessHandler都不会触发，甚至是自定义的UserDetailsService都不会触发）
                .antMatchers("/static/**").permitAll()
                // 角色判断
                //.antMatchers("/v/1").hasRole("v1")
                //.antMatchers("/v/2").hasAuthority("v2")
                //.antMatchers("/v/3").hasAuthority("v3")
                // 所有的请求必须登录后才能访问，除了上面定义的（注意anyRequest必须是页面拦截的最后一个）
                .anyRequest().authenticated()
                .and()
                // 自定义登录逻辑，并放行登陆相关页面
                .formLogin().loginPage("/login.html")
                // 登陆处理逻辑接口
                .loginProcessingUrl("/login")
                // 成功跳转页面
                .successForwardUrl("/")
                // 失败跳转页面
                .failureForwardUrl("/login.html")
                // 自定义接受参数
                .usernameParameter("username")
                .passwordParameter("password")
                .permitAll()
                .and()
                // 关闭csrf防护，不关闭也会导致卡死在登录页
                .csrf().disable();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }
}

修改启动类

@SpringBootApplication
@EnableGlobalMethodSecurity(securedEnabled = true)
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

接口上书写注解

@Controller
public class WinktoController {
    @RequestMapping("/")
    public String index(){
        return "index";
    }
    @RequestMapping("/v/{id}")
    @Secured("ROLE_v1")
    public String v(@PathVariable int id){
        System.out.println(id);
        return "v"+id;
    }
}

9.5.2、@PreAuthorize和@PostAuthorize

这两个注解都是使用access表达式

java image流转成file java将流转为文件_配置文件_15

修改启动类

@SpringBootApplication
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

接口上书写注解

@Controller
public class WinktoController {
    @RequestMapping("/")
    public String index(){
        return "index";
    }
    @RequestMapping("/v/{id}")
    // 方法执行前判断
    @PreAuthorize("hasAuthority('v2')")
    //方法执行后判断
    // @PostAuthorize()
    public String v(@PathVariable int id){
        System.out.println(id);
        return "v"+id;
    }
}

9.6、退出登录

SecurityConfig

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter{

    @Autowired
    UserDetailsServiceImpl userDetailsService;

    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                // 放行静态资源下的文件，如果不放行，会卡死在登录页！！！（AuthenticationFailureHandler和AuthenticationSuccessHandler都不会触发，甚至是自定义的UserDetailsService都不会触发）
                .antMatchers("/static/**").permitAll()
                // 角色判断
                //.antMatchers("/v/1").hasRole("v1")
                //.antMatchers("/v/2").hasAuthority("v2")
                //.antMatchers("/v/3").hasAuthority("v3")
                // 所有的请求必须登录后才能访问，除了上面定义的（注意anyRequest必须是页面拦截的最后一个）
                .anyRequest().authenticated()
                .and()
                // 自定义登录逻辑，并放行登陆相关页面
                .formLogin().loginPage("/login.html")
                // 登陆处理逻辑接口
                .loginProcessingUrl("/login")
                // 成功跳转页面
                .successForwardUrl("/")
                // 失败跳转页面
                .failureForwardUrl("/login.html")
                // 自定义接受参数
                .usernameParameter("username")
                .passwordParameter("password")
                .permitAll()
                .and()
                .logout()
                .permitAll()
                .and()
                // 关闭csrf防护，不关闭也会导致卡死在登录页
                .csrf().disable();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService);
    }
}

页面（index.html）

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/extras/spring-security">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<a th:href="@{/v/1}">v1</a>
<a th:href="@{/v/2}">v2</a>
<a th:href="@{/v/3}">v3</a>
<br>
<a href="/logout">退出登录</a>
</body>
</html>

9.7、Thymeleaf整合Spring Security

导入依赖

<dependency>
    <groupId>org.thymeleaf.extras</groupId>
    <artifactId>thymeleaf-extras-springsecurity5</artifactId>
    <version>3.0.4.RELEASE</version>
</dependency>

引入约束

xmlns:sec="http://www.thymeleaf.org/extras/spring-security"（注意是这个）
xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5"（这个跟最新版本不匹配）

页面（index.html）

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/extras/spring-security">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<a th:href="@{/v/1}">v1</a>
<a th:href="@{/v/2}">v2</a>
<a th:href="@{/v/3}">v3</a>
<br>
账号 <p sec:authentication="name"></p>
密码 <p sec:authentication="principal.username"></p>
凭证 <p sec:authentication="credentials"></p>
权限 <p sec:authentication="authorities"></p>
地址<p sec:authentication="details.remoteAddress"></p>
session<p sec:authentication="details.sessionId"></p>
<br>
v1 <p sec:authorize="hasRole('v1')"></p>
v2 <p sec:authorize="hasAuthority('v2')"></p>
v3 <p sec:authorize="hasAuthority('v3')"></p>
</body>
</html>

10、任务

10.1、异步任务

导入依赖

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

任务

@Component
public class WinktoTask {
    public void sync() throws InterruptedException {
        Thread.sleep(5000);
        System.out.println("邮件发送成功！");
    }
    // 标记为异步任务
    @Async
    public void async() throws InterruptedException {
        Thread.sleep(5000);
        System.out.println("邮件发送成功！");
    }
}

接口

@RestController
public class WinktoController {
    @Autowired
    WinktoTask winktoTask;
    @RequestMapping("/sync")
    public String sync() throws InterruptedException {
        winktoTask.sync();
        return "ok";
    }
    @RequestMapping("/async")
    public String async() throws InterruptedException {
        winktoTask.async();
        return "ok";
    }
}

启动类

@SpringBootApplication
// 开启异步任务功能
@EnableAsync
public class TaskApplication {

    public static void main(String[] args) {
        SpringApplication.run(TaskApplication.class, args);
    }

}

10.2、定时任务

10.2.1、cron表达式

Seconds Minutes Hours DayofMonth Month DayofWeek Year
Seconds Minutes Hours DayofMonth Month DayofWeek

字段	允许值	允许的特殊字符
秒（Seconds）	0~59的整数	, - * / 四个字符
分（Minutes）	0~59的整数	, - * / 四个字符
小时（Hours）	0~23的整数	, - * / 四个字符
日期（DayofMonth）	1~31的整数（但是你需要考虑你月的天数）	,- * ? / L W C 八个字符
月份（Month）	1~12的整数或者 JAN-DEC	, - * / 四个字符
星期（DayofWeek）	1~7的整数或者 SUN-SAT （1=SUN）	, - * ? / L C # 八个字符
年(可选，留空)（Year）	1970~2099	, - * / 四个字符

*表示匹配该域的任意值。假如在Minutes域使用, 即表示每分钟都会触发事件。
?：只能用在DayofMonth和DayofWeek两个域。它也匹配域的任意值，但实际不会。因为DayofMonth和DayofWeek会相互影响。例如想在每月的20日触发调度，不管20日到底是星期几，则只能使用如下写法： 13 13 15 20 * ?, 其中最后一位只能用？，而不能使用*，如果使用*表示不管星期几都会触发，实际上并不是这样。
-：表示范围。例如在Minutes域使用5-20，表示从5分到20分钟每分钟触发一次
/：表示起始时间开始触发，然后每隔固定时间触发一次。例如在Minutes域使用5/20,则意味着5分钟触发一次，而25，45等分别触发一次.
,：表示列出枚举值。例如：在Minutes域使用5,20，则意味着在5和20分每分钟触发一次。
L：表示最后，只能出现在DayofWeek和DayofMonth域。如果在DayofWeek域使用5L,意味着在最后的一个星期四触发。
W:表示有效工作日(周一到周五),只能出现在DayofMonth域，系统将在离指定日期的最近的有效工作日触发事件。例如：在 DayofMonth使用5W，如果5日是星期六，则将在最近的工作日：星期五，即4日触发。如果5日是星期天，则在6日(周一)触发；如果5日在星期一到星期五中的一天，则就在5日触发。另外一点，W的最近寻找不会跨过月份。
LW:这两个字符可以连用，表示在某个月最后一个工作日，即最后一个星期五。
#:用于确定每个月第几个星期几，只能出现在DayofMonth域。例如在4#2，表示某月的第二个星期三。

实例

0 0 2 1 * ? *   表示在每月的1日的凌晨2点调整任务

0 15 10 ? * MON-FRI   表示周一到周五每天上午10:15执行作业

0 15 10 ? 6L 2002-2006   表示2002-2006年的每个月的最后一个星期五上午10:15执行作

0 0 10,14,16 * * ?   每天上午10点，下午2点，4点 

0 0/30 9-17 * * ?   朝九晚五工作时间内每半小时 

0 0 12 ? * WED    表示每个星期三中午12点 

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期间的每1分钟触发 

0 0/5 14 * * ?    在每天下午2点到下午2:55期间的每5分钟触发 

0 0/5 14,18 * * ?     在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发 

0 0-5 14 * * ?    在每天下午2点到下午2:05期间的每1分钟触发 

0 10,44 14 ? 3 WED    每年三月的星期三的下午2:10和2:44触发 

0 15 10 ? * MON-FRI    周一至周五的上午10:15触发 

0 15 10 15 * ?    每月15日上午10:15触发 

0 15 10 L * ?    每月最后一日的上午10:15触发 

0 15 10 ? * 6L    每月的最后一个星期五上午10:15触发 

0 15 10 ? * 6L 2002-2005   2002年至2005年的每月的最后一个星期五上午10:15触发 

0 15 10 ? * 6#3   每月的第三个星期五上午10:15触发

10.2.2、案例

导入依赖

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

任务

@Component
public class WinktoTask {
	//每分钟的0秒执行
    //秒 时 分 日 月 周
    @Scheduled(cron = "0 * * * * ?")
    public void helloScheduled(){
        System.out.println(new Date()+"我执行啦！");
    }
}

启动器

@SpringBootApplication
// 开启定时任务功能
@EnableScheduling
public class TaskApplication {

    public static void main(String[] args) {
        SpringApplication.run(TaskApplication.class, args);
    }

}

java image流转成file java将流转为文件_java_16

11、邮件

开启qq邮箱pop3/mtp服务

java image流转成file java将流转为文件_spring_17

11.1、依赖

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

11.2、application.yaml

spring:
  mail:
    username: 2750955630@qq.com
    # 填写上你自己的密钥
    password: zpcp********dfbg
    host: smtp.qq.com
    properties:
      mail:
        smtp:
          ssl:
            enable: true
    port: 465
    default-encoding: UTF-8

11.3、任务

@Component
public class WinktoTask {
    @Autowired
    JavaMailSenderImpl javaMailSender;
    @Async
    public void simpleMail() {
        //简单邮件
        SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
        simpleMailMessage.setFrom("2750955630@qq.com");
        simpleMailMessage.setTo("winkto@126.com");
        simpleMailMessage.setSubject("通知");
        simpleMailMessage.setText("很高兴你能加入我们！");

        javaMailSender.send(simpleMailMessage);
    }
    @Async
    public void mimeMessage() throws MessagingException, URISyntaxException {
        //复杂邮件
        MimeMessage mimeMessage=javaMailSender.createMimeMessage();

        MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage,true,"UTF-8");
        mimeMessageHelper.setFrom("2750955630@qq.com");
        mimeMessageHelper.setTo("winkto@126.com");
        mimeMessageHelper.setSubject("我是兰蔻");
        mimeMessageHelper.setText("欢迎你加入我们！");
        ClassLoader classLoader=ClassLoader.getSystemClassLoader();
        // 目录以resources为基目录
        URL resource = classLoader.getResource("1.txt");
        //断言
        assert resource != null;
        //添加附件
        mimeMessageHelper.addAttachment("1.txt", new File(resource.getFile()));
        javaMailSender.send(mimeMessage);
    }
}

11.4、controller

@RestController
public class WinktoController {
    @Autowired
    WinktoTask winktoTask;
    @RequestMapping("simpleMail")
    public String simpleMail(){
        winktoTask.simpleMail();
        return "邮件发送成功！";
    }
    @RequestMapping("mimeMessage")
    public String mimeMessage() throws MessagingException, URISyntaxException {
        winktoTask.mimeMessage();
        return "邮件发送成功！";
    }
}

11.5、启动类

@SpringBootApplication
@EnableAsync
public class TaskApplication {

    public static void main(String[] args) {
        SpringApplication.run(TaskApplication.class, args);
    }

}

11.5、效果

简单邮件

java image流转成file java将流转为文件_java_18

带附件的邮件

java image流转成file java将流转为文件_配置文件_19

12、Swagger

12.1、依赖

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

    <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-starter-web</artifactId>
        <version>2.4.0</version>
    </dependency>

    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-boot-starter</artifactId>
        <version>3.0.0</version>
    </dependency>
</dependencies>

12.2、Swagger配置类

@Configuration
public class SwaggerConfig {
    Boolean swaggerEnabled=true;
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.OAS_30).apiInfo(apiInfo())
                // 是否开启
                .enable(swaggerEnabled).select()
                // 扫描的路径包
                .apis(RequestHandlerSelectors.basePackage("cn.winkto.vueserver"))
                // 指定路径处理PathSelectors.any()代表所有的路径
                .paths(PathSelectors.any()).build().pathMapping("/");
    }
 
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("Vue3 axios封装测试")
                .description("springboot | swagger")
                // 作者信息
                .contact(new Contact("wenley", "www.baidu.com", "wenley.yu@qq.com"))
                .version("1.0.0")
                .build();
    }
}

12.3、controller

@RestController
@CrossOrigin
@Api(tags = "HelloController!")
public class HelloController {

    @ApiOperation("get测试")
    @GetMapping("/get")
    public String get(@ApiParam("get参数") @RequestParam String str, @ApiParam("get参数1") @RequestParam String str1) {
        return "hello " + str + ' ' + str1;
    }

    @ApiOperation("post测试")
    @PostMapping("/post")
    public String post(@ApiParam("get参数") @RequestBody String str) {
        return "hello " + str;
    }

    @ApiOperation("file测试")
    @PostMapping("/file")
    public String file(@ApiParam("文件") @RequestBody String str) {
        return "hello" + str;
    }
}

12.4、效果

java image流转成file java将流转为文件_spring_20

12.5、注意事项

springboot超过2.6.0，需在application.properties添加

spring.mvc.pathmatch.matching-strategy= ANT_PATH_MATCHER

13、文件上传下载

13.1、依赖

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

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-boot-starter</artifactId>
        <version>3.0.0</version>
    </dependency>

    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.4</version>
    </dependency>

    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.4</version>
    </dependency>
</dependencies>

13.2、配置

spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=30MB

13.3、上传

@PostMapping("/file")
public String file(@RequestParam(value = "file", required = true) MultipartFile file) throws IOException {
    String upload = "D:\\upload";
    File file1 = new File(upload);
    if (!file1.exists()) {
        file1.mkdir();
    }
    String path = upload + File.separator + file.getOriginalFilename();

    File destination = new File(path);
    if (!destination.getParentFile().exists()) {
        //使用commons-io的工具类
        FileUtils.forceMkdirParent(destination);
    }
    file.transferTo(destination);
    return "success:" + path;
}

13.4、前端

<form action="http://localhost:8099/file" method="post" enctype="multipart/form-data">
  <input type="file" name="file"/>
  <input type="submit" value="上传"/>
</form>

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。