快速开始

方式一、官网下载

使用在线地址：https://start.spring.io/，配置Spring Boot项目，配置完成后下载到本地使用idea导入项目。

方式二、使用idea快速生成

image.png

项目结构

image.png
image.png

SpringBoot 常用设置

修改端口号

image.png

自定义banner

image.png

原理初探

自动装配原理

pom.xml

  • spring-boot-dependencies：核心依赖在父工程
  • 我在写或者引入一些SpringBoot依赖的时候，不需要指定版本，就因为有这些版本仓库

启动器

  1. <!-- 启动器 -->
  2. <!-- web依赖：tomcat, dispatcherServlet.xml -->
  3. <dependency>
  4.     <groupId>org.springframework.boot</groupId>
  5.   <artifactId>spring-boot-starter-web</artifactId>
  6. </dependency>
  8. <!-- 所有的SpringBoot依赖都是使用这个开头的：spring-boot-starter -->
  • 启动器：说白了就是SpringBoot的启动场景
  • 比如spring-boot-starter-web，它就会帮我们自动导入web环境所有的依赖
  • SpringBoot会将所有的功能场景，都变成一个个的启动器
  • 我们要使用什么功能，就只需要找到对应的启动器就可以了

SpringBoot官方启动器地址：
https://docs.spring.io/spring-boot/docs/2.5.3/reference/html/using.html#using.build-systems.starters

主程序

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. // SpringBoot程序的主入口
  5. // @SpringBootApplication：标注这个类是一个SpringBoot的应用
  6. @SpringBootApplication
  7. public class HelloworldApplication {
  9.     public static void main(String[] args) {
  10.         // 将SpringBoot应用启动
  11.         SpringApplication.run(HelloworldApplication.class, args);
  12.     }
  14. }

@SpringBootApplication

@SpringBootConfiguration：SpringBoot的配置
  • @Configuration：Spring配置类
  • @Component：说明也是一个spring的组件

@EnableAutoConfiguration：自动配置
  • @AutoConfigurationPackage：自动配置包
    • @Import(AutoConfigurationPackages.Registrar.class)：自动配置包注册
  • @Import(AutoConfigurationImportSelector.class)：自动配置导入选择

�

整合JDBC

整合Mybatis

整合Redis

SpringBoot操作数据：spring-data，例如：jpa、jdbc、mongodb、redis
说明：在SpringBoot2.x之后，原来使用的jedis被替换了lettuce

  • jedis：采用直接，多个线程操作的话，是不安全的，如果想避免可使用jedis pool连接池。 更像BIO模式。

  • lettuc：采用netty异步调用，实例可以在多个线程中进行共享，不存在线程不安全的情况，可以减少线程数量。更像Nio模式。

    原理解析

    image.png
    SpringBoot所有配置类，都有一个自动配置类，redis的为：RedisAutoConfiguration。
    自动配置类都会绑定一个properties配置文件，redis的为：RedisProperties。

    RedisProperties配置

    1. public class RedisProperties {
    3.   /**
    4.    * Database index used by the connection factory.
    5.    */
    6.   private int database = 0;
    8.   /**
    9.    * Connection URL. Overrides host, port, and password. User is ignored. Example:
    10.    * redis://user:password@example.com:6379
    11.    */
    12.   private String url;
    14.   /**
    15.    * Redis server host.
    16.    */
    17.   private String host = "localhost";
    19.   /**
    20.    * Login username of the redis server.
    21.    */
    22.   private String username;
    24.   /**
    25.    * Login password of the redis server.
    26.    */
    27.   private String password;
    29.   /**
    30.    * Redis server port.
    31.    */
    32.   private int port = 6379;
    34.   /**
    35.    * Whether to enable SSL support.
    36.    */
    37.   private boolean ssl;
    39.   /**
    40.    * Read timeout.
    41.    */
    42.   private Duration timeout;
    44.   /**
    45.    * Connection timeout.
    46.    */
    47.   private Duration connectTimeout;
    49.   /**
    50.    * Client name to be set on connections with CLIENT SETNAME.
    51.    */
    52.   private String clientName;
    54.   /**
    55.    * Type of client to use. By default, auto-detected according to the classpath.
    56.    */
    57.   private ClientType clientType;
    59.   ...
    60. }

    RedisAutoConfiguration

    ```java @Configuration(proxyBeanMethods = false) @ConditionalOnClass(RedisOperations.class) @EnableConfigurationProperties(RedisProperties.class) @Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class }) public class RedisAutoConfiguration {

    @Bean @ConditionalOnMissingBean(name = “redisTemplate”) // 我们可以自定义redisTemplate来替换这个默认的模板 @ConditionalOnSingleCandidate(RedisConnectionFactory.class) public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {

    1.   /*
    2.       默认的RedisTemplate没有过多的设置，redis对象都是需要序列化
    3.       两个泛型都是<Object，Object>的类型，我们后面使用需要强制转换<String Object>
    4.   */
    5.   RedisTemplate<Object, Object> template = new RedisTemplate<>();
    6.   template.setConnectionFactory(redisConnectionFactory);
    7.   return template;

    }

  1. // 由于String是redis中最常用的类型，所以单独提出来一个bean
  2. @Bean
  3. @ConditionalOnMissingBean
  4. @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
  5. public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
  6.     StringRedisTemplate template = new StringRedisTemplate();
  7.     template.setConnectionFactory(redisConnectionFactory);
  8.     return template;
  9. }

}

  1. <a name="vp9Kw"></a>
  2. ### 整合测试
  3. <a name="szun4"></a>
  4. #### 导入依赖
  5. ```xml
  6. <!-- pom.xml -->
  7. <dependency>
  8.     <groupId>org.springframework.boot</groupId>
  9.      <artifactId>spring-boot-starter-data-redis</artifactId>
  10. </dependency>

配置连接

  1. # application.yml
  2. spring:
  3.   # 配置redis
  4.   redis:
  5.     host: localhost
  6.     port: 6379
  7.     lettuce:
  8.       pool:
  9.         max-active: 8

测试

  1. @SpringBootTest
  2. class SpringbootRedisApplicationTests {
  4.     @Autowired
  5.     private RedisTemplate redisTemplate;
  7.     @Test
  8.     void contextLoads() {
  9.         /*
  10.             redisTemplate 操作不同的数据类型
  11.             opsForValue 操作字符串 类似String
  12.             opsForList 操作List 类似List
  13.             opsForSet
  14.             opsForHash
  15.             opsForZSet
  16.             opsForGeo
  17.             opsForHyperLogLog
  19.             除了基本的操作，常用的方法都可以直接通过redisTemplate操作，例如事务、基本的CRUD等
  20.         */
  22.         // 获取redis的连接对象，一般很少用
  23.         // RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
  24.         // connection.flushDb();
  25.         // connection.flushAll();
  27.         redisTemplate.opsForValue().set("myKey", "harry中文名字");
  28.         System.out.println(redisTemplate.opsForValue().get("myKey"));
  29.     }
  31. }

通过 redis-cli 连接测试使用 redis 服务

  1. docker exec -it redis-test /bin/bash
  2. redis-cli

image.png

自定义RedisTemplate

  1. package com.kuang.config;
  3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  4. import com.fasterxml.jackson.annotation.PropertyAccessor;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.data.redis.connection.RedisConnectionFactory;
  9. import org.springframework.data.redis.core.RedisTemplate;
  10. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  11. import org.springframework.data.redis.serializer.StringRedisSerializer;
  13. @Configuration
  14. public class RedisConfig {
  15.     // 自定义 redisTemplate
  16.     @Bean
  17.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
  18.         RedisTemplate<String, Object> template = new RedisTemplate<>();
  19.         template.setConnectionFactory(redisConnectionFactory);
  21.         // Json序列化配置
  22.         Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  23.         ObjectMapper om = new ObjectMapper();
  24.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  25.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  26.         jackson2JsonRedisSerializer.setObjectMapper(om);
  28.         // String的序列化
  29.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  31.         // key采用String的序列化方式
  32.         template.setKeySerializer(stringRedisSerializer);
  33.         // hash的key也采用String的序列化方式
  34.         template.setHashKeySerializer(stringRedisSerializer);
  35.         // value序列化方式采用jackson
  36.         template.setValueSerializer(jackson2JsonRedisSerializer);
  37.         // hash的value序列化方式采用jackson
  38.         template.setHashValueSerializer(jackson2JsonRedisSerializer);
  39.         template.afterPropertiesSet();
  41.         return template;
  42.     }
  43. }

SpringSecurity（安全）

在web开发中，安全第一位！过滤器，拦截器~
功能性需求：否
做网站：安全应该在什么时候考虑？设计之初！

shiro、SpringSecurity
认证、授权

权限

  • 功能权限
  • 访问权限
  • 菜单权限
  • … 拦截器，过滤器：大量的原生代码~ 冗余

任务

异步任务

  1. package com.kuang.controller;
  3. import com.kuang.service.AsyncService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  8. @RestController
  9. public class AsyncController {
  10.     @Autowired
  11.     AsyncService asyncService;
  13.     @RequestMapping("/hello")
  14.     public String hello() {
  15.         asyncService.hello();
  16.         return "ok";
  17.     }
  18. }
  1. package com.kuang.service;
  3. import org.springframework.scheduling.annotation.Async;
  4. import org.springframework.stereotype.Service;
  6. @Service
  7. public class AsyncService {
  8.     // 告诉Spring这是一个异步的方法
  9.     @Async
  10.     public void hello() {
  11.         try {
  12.             Thread.sleep(3000);
  13.         } catch (InterruptedException e) {
  14.             e.printStackTrace();
  15.         }
  17.         System.out.println("数据正在处理...");
  18.     }
  19. }

定时任务

  1. package com.kuang.service;
  3. import org.springframework.scheduling.annotation.Scheduled;
  4. import org.springframework.stereotype.Service;
  6. @Service
  7. public class ScheduleService {
  8.     // cron 表达式
  9.     // 秒 分 时 日 月 周几
  10.     @Scheduled(cron = "0 * * * * 0-7")
  11.     public void hello() {
  12.         System.out.println("hello, 被执行了~");
  13.     }
  14. }

邮件发送（邮件任务）

  1. spring:
  2.   mail:
  3.     username: 732150595@qq.com
  4.     password: ******
  5.     host: smtp.qq.com
  6.     properties:
  7.       mail:
  8.         smtp:
  9.           ssl:
  10.             enable: true # 开启加密验证，qq邮箱特有
  1. package com.kuang;
  3. import org.junit.jupiter.api.Test;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.boot.test.context.SpringBootTest;
  6. import org.springframework.mail.SimpleMailMessage;
  7. import org.springframework.mail.javamail.JavaMailSender;
  8. import org.springframework.mail.javamail.JavaMailSenderImpl;
  9. import org.springframework.mail.javamail.MimeMessageHelper;
  11. import javax.mail.MessagingException;
  12. import javax.mail.internet.MimeMessage;
  13. import java.io.File;
  15. @SpringBootTest
  16. class Springboot05MybatisApplicationTests {
  18.     @Autowired
  19.     JavaMailSenderImpl mailSender;
  21.     @Test
  22.     void testSimpleMail() {
  23.         // 一个简单的邮件
  24.         SimpleMailMessage mailMessage = new SimpleMailMessage();
  25.         mailMessage.setSubject("你好啊！我是SpringBoot发的邮件！");
  26.         mailMessage.setText("我正在学习SpringBoot，要一起吗？");
  28.         mailMessage.setFrom("732150595@qq.com");
  29.         mailMessage.setTo("huangxubo23@gmail.com");
  31.         mailSender.send(mailMessage);
  32.     }
  34.     @Test
  35.     void testMimeMail() throws MessagingException {
  36.         // 一个复杂的邮件
  37.         MimeMessage mimeMessage = mailSender.createMimeMessage();
  38.         // 组装
  39.         MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
  41.         helper.setSubject("你好啊！我是SpringBoot发的复杂邮件");
  42.         helper.setText("<h2 style='color:red'>我正在学习SpringBoot，要一起吗？</h2>", true);
  43.         // 附件
  44.         helper.addAttachment("OG-Spring.png", new File("/Users/harryhuang/Downloads/OG-Spring.png"));
  45.         helper.setFrom("732150595@qq.com");
  46.         helper.setTo("huangxubo23@gmail.com");
  48.         mailSender.send(mimeMessage);
  49.     }
  51.     /**
  52.      * 邮件发送发放封装
  53.      * @param html
  54.      * @param subject
  55.      * @param text
  56.      * @throws MessagingException
  57.      */
  58.     public void sendMail(Boolean html, String subject, String text) throws MessagingException {
  59.         // 一个复杂的邮件
  60.         MimeMessage mimeMessage = mailSender.createMimeMessage();
  61.         // 组装
  62.         MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, html);
  64.         helper.setSubject(subject);
  65.         helper.setText(text, html);
  66.         // 附件
  67.         helper.addAttachment("OG-Spring.png", new File("/Users/harryhuang/Downloads/OG-Spring.png"));
  68.         helper.setFrom("732150595@qq.com");
  69.         helper.setTo("huangxubo23@gmail.com");
  71.         mailSender.send(mimeMessage);
  72.     }
  74. }

集成Swagger

  • 了解Swagger的作用和概念
  • 了解前后端分离
  • 在SpringBoot中集成Swagger

背景介绍

前后端分离
后端时代：前端只用管理静态页面；模板引擎 JSP =》后端是主力
前后端分离时代：

  • 后端：后端控制层、服务层、数据访问层
  • 前端：前端控制层、视图层
  • 前后端相对独立，松耦合
  • 前后端可以部署在不同的服务器上

产生一个问题：

  • 前后端集成联调，前端人员和后端人员无法做到“及时协商，尽早解决”，最终导致问题集中爆发

解决方案：

  • 首先指定schema（计划的提纲），实时更新最新API，降低集成的风险
  • 早些年：制定word计划文档
  • 前后端分离：
    • 前端测试后端接口：postman
    • 后端提供接口，需要实时更新最新的消息及改动

Swagger简介

  • 号称世界上最流行的Api框架
  • ResetFul Api文档在线自动生成工具=》Api文档与API定义同步更新
  • 直接运行，可以在线测试API接口
  • 支持多种语言：Java、PHP…

在项目使用Swagger需要springbox

  • swagger2
  • swagger-ui

SpringBoot集成Swagger

  1. 新建一个SpringBoot web项目
  2. 导入Swagger相关依赖 ```xml io.springfox springfox-swagger2 2.10.5

io.springfox springfox-swagger-ui 2.10.5 

  2. 3. 编写一个ResetFul API工程
  3. 3. 配置Swagger=》Config
  4. ```java
  5. package com.kuang.config;
  7. import org.springframework.context.annotation.Configuration;
  8. import springfox.documentation.swagger2.annotations.EnableSwagger2WebFlux;
  10. @Configuration
  11. @EnableSwagger2WebFlux
  12. public class SwaggerConfig {
  14. }
  1. 测试运行

配置Swagger

Swagger的bean示例Docket