SpringBoot

最新推荐文章于 2024-05-07 20:15:43 发布

不爱跑步的肥狗

最新推荐文章于 2024-05-07 20:15:43 发布

阅读量444

点赞数

本文链接：https://blog.csdn.net/m0_46361249/article/details/118960574

版权

java 学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

springboot

源码笔记
链接：https://pan.baidu.com/s/1fvUolvYDIZZtuIkqJ9v8Aw
提取码：6666

第一个SpringBoot

方法一：spring官网 ->project->SpringBoot->quickstart 下载解压，配置导入

方法二：直接创建
inits 然后可以在里面改端口

原理：
Springboot所有配置都是在启动的时候被扫描和加载，在spring.factories中，所有配置都在里面，不一定生效，会有判断条件，只有对应的start就有对应的启动器，有启动器就会配置成功。
过程
1.启动的时候，在/META-INF/spring.factories获取指定的值
2.把这些自动配置导入容器，自动配置就生效，帮我们自动配置
3.需要自动配置的就自动配置了
4.解决方案和自动配置都在spring-boot-autoconfigure-2.2.0.RELEASE.jar这个包下
5.他会把需要导入的组件以类名的方式返回，这些组件被添加到容器中
6.容器中也会有很多xxxAutoConfiguration的文件(@Bean)，就是需要的组件，然后自动配置这些组件

谈谈对Springboot的理解
1.自动装配
2.run方法

配置
application.yaml 可以代替application.properties
1.application.properties只能保存键值对
2.yaml可以给实体类赋值

在这里插入图片描述
设置默认值

JSR303常用注解

配置文件的目录

指定配置文件
1.在application.propeties里通过profiles来指定

2.直接在yaml文件里面写

在yaml里面配置都存在一个固定的properties对应
#xxxAutoconfiguration: 默认值 xxxProperties 和配置文件绑定可以到对应绑定的文件然后自定义配置
在这里插入图片描述

SpringBoot Web开发

特点：
自动装配
.xxxAutoConfiguration向文件中自动配置组件
.xxxProperties：自动配置类，装配自定义的一些内容
学习过程

1.静态资源

查找源码 ctrl+n 找到WebMvcAutoConfig里面找到WebMvcAutoConfigurationAdapter里面有add资源然后找到 addResourceHandlers

 public void addResourceHandlers(ResourceHandlerRegistry registry) {
            if (!this.resourceProperties.isAddMappings()) {
                logger.debug("Default resource handling disabled");
            } else {
                this.addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
                this.addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {
                    registration.addResourceLocations(this.resourceProperties.getStaticLocations());
                    if (this.servletContext != null) {
                        ServletContextResource resource = new ServletContextResource(this.servletContext, "/");
                        registration.addResourceLocations(new Resource[]{resource});
                    }

                });
            }
        }

设置静态资源
查找源码 WebMvcAutoConfig里面找到WebMvcProperties里面的配置
找到静态资源配置 this.staticPathPattern = “/**”;
然后在yaml里面配置
设置静态资源的方式：
1.webjars localhost/webjars/
2.public, static, /* * , resource localhost:8080/
3.优先级 resource>static>public
在这里插入图片描述
2.首页
还是WebMvcconfig里面的 getWelcomepage() ,welcome
3.模板引擎
Template类似jsp

1.导入Template坐标也就是thymeleaf
导入thymeleaf坐标

        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
        </dependency>
        <dependency>
            <groupId>org.thymeleaf.extras</groupId>
            <artifactId>thymeleaf-extras-java8time</artifactId>
        </dependency>

2.在html里面加上命名空间

<html lang="en" xmlns:th="http://www.thymeleaf.org">

3.在配置里面添加视图解析器

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
        registry.addViewController("/index.html").setViewName("index");
    }
}

4.页面放在templates里面
就可以直接使用controller层使用
5.关闭模板引擎缓存
spring:
thymeleaf:
cache: false
6.根据thymeleaf的各种样式，来接管html的各种标签

4.装配springmvc
spring首先就会去看这些组件有没有配置，如果有用户配置的就用用户配置，没有就用默认的在WebMvcProperties
有些组件会存在多个，那么就会组合使用，就比如视图解析器，选区最优的解析器
5.增删改查
首页的配置都要用thymeleaf接管
1.提取公共页面
2.把公共页面放到公共资源里面然后每次别的页面调用就可以直接调用里面的

<!--   顶部导航栏   -->
	<div th:replace="~{commons/commons::topbar}"></div>
<!--   顶部导航栏   -->
<div th:replace="~{commons/commons::sidebar(active='list.html')}"></div>

6.拦截器
1.在config里添加拦截器配置拦截器类实现HandlerInterceptor接口

package com.springboot.config;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LoginHandlerInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        //登陆成功 就有用户session
        Object  loginUser=request.getSession().getAttribute("loginUser");

        if (loginUser==null)
        {
            //不放行
            request.setAttribute("msg","没有权限，请先登陆");
            request.getRequestDispatcher("/index.html").forward(request,response);
            return false;
        }
    else
        {
            return true;
        }
    }

}

2.在mvcconfig里注入拦截器，让拦截器有一些不拦截

   //拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginHandlerInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/index.html","/","/user/login","/css/**","/js/**","/img/**");
    }

3.controller层的时候让他每次登陆成功就给一个session,
拦截器每次判断session就可以判断有没有

7.国际化
在这里插入图片描述

Springboot整合数据库

   直接去网盘看我的笔记

Springboot整合数据库jdbc
Springboot整合数据库druid
Springboot整合数据库mybatis
目录结构
在这里插入图片描述
1.导包

   <!-- 引入 myBatis，这是 MyBatis官方提供的适配 Spring Boot 的，而不是Spring Boot自己的-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

<resources>
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/*.xml</include>
        </includes>
        <filtering>true</filtering>
    </resource>
</resources>

2.配置数据库连接信息

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

3.用默认的数据源去测试是否成功！

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootDemoMybatisApplicationTests {

    @Autowired
    DataSource dataSource;

    @Test
    public void contextLoads() throws SQLException {

        System.out.println("数据源>>>>>>" + dataSource.getClass());
        Connection connection = dataSource.getConnection();
        System.out.println("连接>>>>>>>>>" + connection);
        System.out.println("连接地址>>>>>" + connection.getMetaData().getURL());
        connection.close();
    }
}

4.配置实体类

package com.kuang.mybatis.pojo;

public class User {

    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }

}

5.配置Mapper接口

package com.kuang.mybatis.pojo.mapper;

import com.kuang.mybatis.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

//@Mapper : 表示本类是一个 MyBatis 的 Mapper，等价于以前 Spring 整合 MyBatis 时的 Mapper 接口
@Mapper
@Repository
public interface UserMapper {

    //选择全部用户
    List<User> selectUser();
    //根据id选择用户
    User selectUserById(int id);
    //添加一个用户
    int addUser(User user);
    //修改一个用户
    int updateUser(User user);
    //根据id删除用户
    int deleteUser(int id);

}

6.创建对应的mapper 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.kuang.mybatis.pojo.mapper.UserMapper">

    <select id="selectUser" resultType="User">
    select * from user
  </select>

    <select id="selectUserById" resultType="User">
    select * from user where id = #{id}
</select>

    <insert id="addUser" parameterType="User">
    insert into user (id,name,pwd) values (#{id},#{name},#{pwd})
</insert>

    <update id="updateUser" parameterType="User">
    update user set name=#{name},pwd=#{pwd} where id = #{id}
</update>

    <delete id="deleteUser" parameterType="int">
    delete from user where id = #{id}
</delete>
</mapper>

7.SpringBoot 整合！

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

#指定myBatis的核心配置文件与Mapper映射文件
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml
# 注意：对应实体类的路径
mybatis.type-aliases-package=com.kuang.mybatis.pojo

8.写控制类测试

package com.kuang.mybatis.controller;

import com.kuang.mybatis.pojo.User;
import com.kuang.mybatis.pojo.mapper.UserMapper;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {

    @Autowired
    private UserMapper userMapper;

    //选择全部用户
    @GetMapping("/selectUser")
    public String selectUser(){
        List<User> users = userMapper.selectUser();
        for (User user : users) {
            System.out.println(user);
        }

        return "ok";
    }
    //根据id选择用户
    @GetMapping("/selectUserById")
    public String selectUserById(){
        User user = userMapper.selectUserById(1);
        System.out.println(user);
        return "ok";
    }
    //添加一个用户
    @GetMapping("/addUser")
    public String addUser(){
        userMapper.addUser(new User(5,"阿毛","456789"));
        return "ok";
    }
    //修改一个用户
    @GetMapping("/updateUser")
    public String updateUser(){
        userMapper.updateUser(new User(5,"阿毛","421319"));
        return "ok";
    }
    //根据id删除用户
    @GetMapping("/deleteUser")
    public String deleteUser(){
        userMapper.deleteUser(5);
        return "ok";
    }

}

SpringSecurity(安全框架）

在这里插入图片描述

web开发完全第一过滤器，拦截器
Spring Security针对Spring的安全框架，只需要导入spring-boot-starter-security就可以实现安全管理
1.认证
2.授权
Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。它实际上是保护基于spring的应用程序的标准。
Spring Security是一个框架，侧重于为Java应用程序提供身份验证和授权。与所有Spring项目一样，Spring安全性的真正强大之处在于它可以轻松地扩展以满足定制需求。一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分。用户认证指的是验证某个用户是否为系统中的合法主体，也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码。系统通过校验用户名和密码来完成认证过程。用户授权指的是验证某个用户是否有权限执行某个操作。在一个系统中，不同用户所具有的权限是不同的。比如对一个文件来说，有的用户只能进行读取，而有的用户可以进行修改。一般来说，系统会为不同的用户分配不同的角色，而每个角色则对应一系列的权限。
1.导包

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

2、在启动类上加上相应的注解以及配置

并且加入开启的注解

package com.it;

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

@SpringBootApplication
public class SpringbootSecurityApplication {

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

}

3.配置SpringSecurity

package com.kuang.config;

import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@EnableWebSecurity  // 开启WebSecurity模式
public class SecurityConfig extends WebSecurityConfigurerAdapter {

   //定制请求的授权规则
   @Override
   protected void configure(HttpSecurity http) throws Exception {

       http.authorizeRequests().antMatchers("/").permitAll()
      .antMatchers("/level1/**").hasRole("vip1")
      .antMatchers("/level2/**").hasRole("vip2")
      .antMatchers("/level3/**").hasRole("vip3");


       //开启自动配置的登录功能：如果没有权限，就会跳转到登录页面！
           // /login 请求来到登录页
           // /login?error 重定向到这里表示登录失败
       http.formLogin()
          .usernameParameter("username")
          .passwordParameter("password")
          .loginPage("/toLogin")
          .loginProcessingUrl("/login"); // 登陆表单提交请求

       //开启自动配置的注销的功能
           // /logout 注销请求
           // .logoutSuccessUrl("/"); 注销成功来到首页

       http.csrf().disable();//关闭csrf功能:跨站请求伪造,默认只能通过post方式提交logout请求
       http.logout().logoutSuccessUrl("/");

       //记住我
       http.rememberMe().rememberMeParameter("remember");
  }

   //定义认证规则
   @Override
   protected void configure(AuthenticationManagerBuilder auth) throws Exception {
       //在内存中定义，也可以在jdbc中去拿....
       //Spring security 5.0中新增了多种加密方式，也改变了密码的格式。
       //要想我们的项目还能够正常登陆，需要修改一下configure中的代码。我们要将前端传过来的密码进行某种方式加密
       //spring security 官方推荐的是使用bcrypt加密方式。

       auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder())
              .withUser("kuangshen").password(new BCryptPasswordEncoder().encode("123456")).roles("vip2","vip3")
              .and()
              .withUser("root").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2","vip3")
              .and()
              .withUser("guest").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2");
  }
}

Shiro(安全框架）

是一款 Java 安全框架，不依赖任何容器，可以运行在 Java SE 和 Java EE 项目中，它的主要作用是用来做身份认证、授权、会话管理和加密等操作。

shiro的核心组件
1、UsernamePasswordToken，Shiro 用来封装用户登录信息，使用用户的登录信息创建令牌 Token，登录的过程即 Shiro 验证令牌是否具有合法身份以及相关权限。

2、 SecurityManager，Shiro 的核心部分，负责安全认证与授权。
3、Subject，Shiro 的一个抽象概念，包含了用户信息。

4、Realm，开发者自定义的模块，根据项目的需求，验证和授权的逻辑在 Realm 中实现。

5、AuthenticationInfo，用户的角色信息集合，认证时使用。

6、AuthorizationInfo，角色的权限信息集合，授权时使用。

7、DefaultWebSecurityManager，安全管理器，开发者自定义的 Realm 需要注入到 DefaultWebSecurityManager 进行管理才能生效。

8、ShiroFilterFactoryBean，过滤器工厂，Shiro 的基本运行机制是开发者定制规则，Shiro 去执行，具体的执行操作就是由 ShiroFilterFactoryBean 创建一个个 Filter 对象来完成。

在这里插入图片描述
1.导包

<!-- Shiro整合Spring -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.5.3</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.20</version>
</dependency>

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.1.tmp</version>
</dependency>

2.创建实体类 Account

Data
public class Account {
    private Integer id;
    private String username;
    private String password;
    private String perms;
    private String role;
}

3.创建 AccountMapper 接口
4.创建 application.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Drive
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

5.启动类添加 @MapperScan 注解扫描 Mapper 接口

@SpringBootApplication
@MapperScan("com.southwind.springbootshirodemo.mapper")
public class SpringbootshirodemoApplication {

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

6.首先通过单元测试调试 AccoutMapper 接口

@SpringBootTest
class AccountMapperTest {

    @Autowired
    private AccountMapper accountMapper;

    @Test
    void test(){
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.eq("username","user");
        Account account = accountMapper.selectOne(wrapper);
        System.out.println(account);
    }
}

7.测试成功就开始写service层和实现类

public interface AccountService {
    public Account findByUsername(String username);
}

service层实现类

public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountMapper accountMapper;

    @Override
    public Account findByUsername(String username) {
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.eq("username",username);
        return accountMapper.selectOne(wrapper);
    }
}

8.写 Shiro 完成用户认证，在 MyRealm 中完成代码的编写。

public class MyRealm extends AuthorizingRealm {

    @Autowired
    private AccountService accountService;

    /**
     * 授权
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    /**
     * 认证
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        Account account = accountService.findByUsername(token.getUsername());
        if(account != null){
            return new SimpleAuthenticationInfo(account,account.getPassword(),getName());
        }
        return null;
    }
}

客户端传来的 username 和 password 会自动封装到 token，先根据 username 进行查询，如果返回 null，则表示用户名错误，直接 return null 即可，Shiro 会自动抛出 UnknownAccountException 异常。

如果返回不为 null，则表示用户名正确，再验证密码，直接返回 SimpleAuthenticationInfo 对象即可，如果密码验证成功，Shiro 认证通过，否则返回 IncorrectCredentialsException 异常。

9.配置shiroConfig
自定义过滤器创建完成之后，需要进行配置才能生效，在 Spring Boot 应用中，不需要任何的 XML 配置，直接通过配置类进行装配，代码如下所示。

比如，我们创建三个页面，main.html、manage.html、administrator.html，要求如下：

1、必须是登录状态才可以访问 main.html。
2、用户必须拥有 manage 授权才可以访问 manage.html。
3、用户必须拥有 administrator 角色才能访问 administrator.html。

@Configuration
public class ShiroConfig {

    @Bean
    public ShiroFilterFactoryBean filterFactoryBean(@Qualifier("manager") DefaultWebSecurityManager manager){
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        factoryBean.setSecurityManager(manager);
        return factoryBean;
    }


    @Bean
    public DefaultWebSecurityManager manager(@Qualifier("myRealm") MyRealm myRealm){
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
        manager.setRealm(myRealm);
        return manager;
    }

    @Bean
    public MyRealm myRealm(){
        return new MyRealm();
    }
}

这个配置类中一共自动装配了 3 个 bean 实例，第一个是自定义过滤器 MyRealm，我们的业务逻辑全部定义在这个 bean 中。

然后需要创建第二个 bean 示例 DefaultWebSecurityManager，并且将 MyRealm 注入到 DefaultWebSecurityManager bean 中，完成注册。

最终需要装配第三个 bean ShiroFilterFactoryBean，这是 Shiro 自带的一个 Filter 工厂实例，所有的认证和授权判断都是由这个 bean 生成的 Filter 对象来完成的，这就是 Shiro 框架的运行机制，开发者只需要定义规则，进行配置，具体的执行者全部由 Shiro 自己创建的 Filter 来完成。
10.写controller层

@Controlle
public class MyController {

    @GetMapping("/{url}")
    public String redirect(@PathVariable("url") String url){
        return url;
    }

    @PostMapping("/login")
    public String login(String username, String password, Model model){
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken(username,password);
        try {
            subject.login(token);
            return "index";
        } catch (UnknownAccountException e) {
            model.addAttribute("msg","用户名错误");
            return "login";
        } catch (IncorrectCredentialsException e) {
            model.addAttribute("msg", "密码错误");
            return "login";
        }
    }

    @RequestMapping("/unauth")
    @ResponseBody
    public String unauth(){
        return "未授权没有访问权限";
    }
}

11.授权
只需要登录就可以访问 main.html，但是无法访问 manage.html，这是因为没有授权，接下来我们完成授权操作，回到 MyRealm，代码如下所示。

@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    //获取当前登录对象
    Subject subject = SecurityUtils.getSubject();
    Account account = (Account) subject.getPrincipal();

    //设置角色
    Set<String> roles = new HashSet<>();
    roles.add(account.getRole());
    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(roles);

    //设置权限
    info.addStringPermission(account.getPerms());
    return info;
}

12.测试
数据库
zs 没有权限和角色，所以登录之后只能访问 main.html。

ls 拥有 manage 权限，没有角色，所以登录之后可以访问 main.html、manage.html。

ww 拥有 manage 权限和 administrator 角色，所以登录之后可以访问 main.html、manage.html、administrator.html。

Swagger

前后端分离
vue + Springboot
后端：控制层，服务层，数据访问层
前端：前端控制器，视图层，伪造后端数据 json

前后端交互

解决方案：指定schema[计划]，实时更新最新API,降低集成风险；

最流行的Api的框架-----api文档自动生成

在项目中使用Swaggerspringbox

1.创建springboot添加 spring-web
2.改端口，编写一个hello程序
3.导包

 <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

配置SwaggerConfig

测试访问： http://localhost:8088/swagger-ui.html

配置Docket

Swagger配置扫描接口
Docket
.select()
.apis()
.build()

异步处理
1.配置好基本配置
2.写延迟，在延迟方法上加上异步注解

  @Async  //异步注解
    public void hello()
    {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("异步任务处理完成");
    }

3.开启异步支持
在控制层加上自动开启异步的注解


@RestController
@EnableAsync  //自动开启异步
public class AsyncController {

    @Autowired
    AsyncService asyncService;


    @RequestMapping("/hello")
    public String hello()
    {
        asyncService.hello();
        return "异步处理完成";
    }
}

邮件处理

1.导包

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

2.在properties里面配置

server.port=8088
spring.mail.username=1723767677@qq.com
spring.mail.password=ouyangsong333
spring.mail.host=smtp.qq.com

#开启加密验证
spring.mail.properties.mail.smtp.ssl.enable=true

3.直接测试

@Autowired
JavaMailSenderImpl mailSender;

@Test
void contextLoads() {
    SimpleMailMessage mailMessage=new SimpleMailMessage();
    mailMessage.setSubject("测试邮件");
    mailMessage.setText("松哥大帅b");
    mailMessage.setTo("1723767677@qq.com");
    mailMessage.setFrom("1723767677@qq.com");
    mailSender.send(mailMessage);
}
     //复杂的邮件
    @Test
    void contextLoads2() throws MessagingException {
       //复杂的邮件
        MimeMessage mimeMessage=mailSender.createMimeMessage();
        //组装
        MimeMessageHelper helper=new MimeMessageHelper(mimeMessage,true);
        //附件
        helper.addAttachment("1.jpg",new File("图片的绝对地址"));
        helper.addAttachment("2.jpg",new File("图片的绝对地址"));
        helper.setTo("1723767677@qq.com");
        helper.setFrom("1723767677@qq.com");
        mailSender.send(mimeMessage);
    }

定时任务

TaskScheduler 任务调度
TaskExecutor 任务执行
@EnableScheduling //开启定时功能注解
@Scheeduled什么时候执行

1.在spring启动类上加注解

@EnableAsync //异步注解
@EnableScheduling //开启定时功能注解
@SpringBootApplication

在对应的service层写方法让其定时完成

   //cron执行
    //秒 分 时 日 月 周几
    @Scheduled(cron = "* 32 12 * * 0-7") //在特定的时间执行
    public  void hello()
    {
        System.out.println("特定的时间执行");
    }