当前位置：首页 > news >正文

《初入苍穹：大一新手的编程成长之旅》

news 来源：原创 2025/5/21 12:29:54

前言：个人完成了整个苍穹外卖项目的开发，这篇文章会将一些重要的知识点细节全部展示出来，让刚开始入手苍穹外卖的你们更容易了解这个项目，提高对应项目的认知。

以下是我的个人感受与技术总结（结合Javaweb+AI教程和黑马点评的redis教程）

项目特点：

代码规范：苍穹外卖项目在代码规范性上表现十分出色，遵循清晰的命名规范、整齐的代码格式、详细的注释说明以及良好的代码复用性，有助于新手养成良好的编程习惯。

逻辑清晰：业务逻辑清晰，涵盖用户、商家、订单管理和支付结算等模块，各环节衔接紧密，流程顺畅，易于理解和操作。

难度适中：技术要求和业务复杂度平衡得当，对于我来说，既能提供实践机会，又不会显得过于复杂，是一个非常适合新手入门的项目，能够有效提升开发者对项目开发的认知和理解。

1.项目介绍

本项目（苍穹外卖）是专门为餐饮企业（餐厅、饭店）定制的一款软件产品，包括 系统管理后台 和 小程序端应用 两部分。

系统管理后台:主要提供给餐饮企业内部员工使用，可以对餐厅的分类、菜品、套餐、订单、员工等进行管理维护，对餐厅的各类数据进行统计，同时也可进行来单语音播报功能。

小程序端:主要提供给消费者使用，可以在线浏览菜品、添加购物车、下单、支付、催单等。

2.技术选型

3.Day1 技术总结

3.1 Nginx反向代理

nginx反向代理介绍

nginx反向代理的好处

提高访问速度

因为nginx本身可以进行缓存，如果访问的同一接口，并且做了数据缓存，nginx就直接可把数据返回，不需要真正地访问服务端，从而提高访问速度。
进行负载均衡

所谓负载均衡,就是把大量的请求按照我们指定的方式均衡的分配给集群中的每台服务器。
保证后端服务安全

因为一般后台服务地址不会暴露，所以使用浏览器不能直接访问，可以把nginx作为请求访问的入口，请求到达nginx后转发到具体的服务中，从而保证后端服务的安全。

配置方式

proxy_pass：该指令是用来设置代理服务器的地址，可以是主机名称，IP地址加端口号等形式。

如上代码的含义是：监听80端口号，然后当我们访问 http://localhost:80/api/../..这样的接口的时候，它会通过 location /api/ {} 这样的反向代理到 http://localhost:8080/admin/上来。

负载均衡策略

3.2 MD5加密

//密码进行md5加密后，然后再进行比对
password = DigestUtils.md5DigestAsHex(password.getBytes());

3.3 Swagger,knife4j与Apifox

Swagger是一种基于OpenAPI规范的工具，用于设计、生成和文档化RESTful API

knife4j的使用

常用注解

通过注解可以控制生成的接口文档，使接口文档拥有更好的可读性，常用注解如下：

注解	说明
@Api	用在类上，例如Controller，表示对类的说明
@ApiModel	用在类上，例如entity、DTO、VO
@ApiModelProperty	用在属性上，描述属性信息
@ApiOperation	用在方法上，例如Controller的方法，说明方法的用途、作用

注解使用示例

@Data
@ApiModel(description = "员工登录时传递的数据模型")
public class EmployeeLoginDTO implements Serializable {@ApiModelProperty("用户名")private String username;@ApiModelProperty("密码")private String password;}

@Api(tags = "员工相关接口")
public class EmployeeController {@PostMapping("/login")@ApiOperation(value = "员工登录")public Result<EmployeeLoginVO> login(@RequestBody EmployeeLoginDTO employeeLoginDTO) {}

测试文档生成页面

启动服务：访问http://localhost:8080/doc.html

Apifox：
Apifox是一款集API设计、调试、Mock、自动化测试与文档管理于一体的综合平台。它支持多种协议，提供可视化界面，可自动生成API文档和Mock数据，方便前后端开发。

4.Day2 技术总结

4.1 DTO,VO和POJO

sky-pojo: 模块中存放的是一些 entity、DTO、VO

名称	说明
Entity	实体，通常和数据库中的表对应
DTO	数据传输对象，通常用于程序中各层之间传递数据
VO	视图对象，为前端展示数据提供的对象
POJO	普通Java对象，只有属性和对应的getter和setter

POJO:一种简单的Java实体类，不包含业务逻辑

DTO,VO 是一个简单的 Java 对象，用于封装一组数据。

DTO通常包含字段和相应的 getter 和 setter 方法，但不包含业务逻辑或行为。

在 RESTful API 中，使用 DTO 封装返回的数据，确保只返回必要的信息

VO是前端需要展示的数据，由后端查询数据库，返回对应数据

注意：当前端提交的数据和实体类中对应的属性差别比较大时，建议使用DTO来封装数据

4.2 全局异常处理器

全局异常处理器是一种用于集中处理应用程序中所有异常的机制。

在Spring框架中，可以通过@ExceptionHandler注解来定义一个全局异常处理器方法。当程序运行时抛出异常时，Spring会自动调用该方法来处理异常，而不是直接抛出到客户端。

	/*** 处理SQL异常* @param ex* @return*/@ExceptionHandlerpublic Result exceptionHandler(SQLIntegrityConstraintViolationException ex){//Duplicate entry 'zhangsan' for key 'employee.idx_username'String message = ex.getMessage();if(message.contains("Duplicate entry")){String[] split = message.split(" ");String username = split[2];String msg = username + MessageConstant.ALREADY_EXISTS;return Result.error(msg);}else{return Result.error(MessageConstant.UNKNOWN_ERROR);}}

4.3 ThreadLocal

ThreadLocal 并不是一个Thread，而是Thread的局部变量。

ThreadLocal为每个线程提供单独一份存储空间，具有线程隔离的效果，只有在线程内才能获取到对应的值，线程外则不能访问。

常用方法：

方法	作用
public void set(T value)	设置当前线程的线程局部变量的值
public T get()	返回当前线程所对应的线程局部变量的值
public void remove()	移除当前线程的线程局部变量

解决办法：将当前所解析出来的id存入到一个由ThreadLocal为每个线程提供单独一份存储空间中，需要时在线程内获取到对应的值，达到保存并随时访问该空间中数据的目的

ThreadLocal 操作的工具类

public class BaseContext {public static ThreadLocal<Long> threadLocal = new ThreadLocal<>();public static void setCurrentId(Long id) {threadLocal.set(id);}public static Long getCurrentId() {return threadLocal.get();}public static void removeCurrentId() {threadLocal.remove();}}

在拦截器(登录)中解析出当前登录员工id，并放入线程局部变量中：

package com.sky.interceptor;/*** jwt令牌校验的拦截器*/
@Component
public class JwtTokenAdminInterceptor implements HandlerInterceptor {@Autowiredprivate JwtProperties jwtProperties;public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {//校验令牌Claims claims = JwtUtil.parseJWT(jwtProperties.getAdminSecretKey(), token);Long empId = Long.valueOf(claims.get(JwtClaimsConstant.EMP_ID).toString());/将用户id存储到ThreadLocalBaseContext.setCurrentId(empId);//3、通过，放行return true;}
}

使用时，在Service中获取线程局部变量中的值：

	/*** 新增员工** @param employeeDTO*/public void save(EmployeeDTO employeeDTO) {//设置当前记录创建人id和修改人idemployee.setCreateUser(BaseContext.getCurrentId());employee.setUpdateUser(BaseContext.getCurrentId());employeeMapper.insert(employee);}

4.4 PageHelper

PageHelper 是一个适用于 MyBatis 框架的分页插件，能够简化分页查询的操作。

引入依赖：

<dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper-spring-boot-starter</artifactId><version>1.2.10</version>
</dependency>

在执行查询之前调用 PageHelper.startPage 方法，即可自动对查询结果进行分页处理

原理

PageHelper 的核心原理是通过 MyBatis 的拦截器机制实现分页。

它在执行 SQL 查询之前，通过 ThreadLocal 保存分页参数，并在拦截器中对 SQL 语句进行分页处理（例如添加 LIMIT 子句）。查询结束后，分页信息会封装在 PageInfo 对象中，便于获取总记录数、总页数等信息。

使用示例：

controller层

@GetMapping("/page")public Result<PageResult> page(EmployeePageQueryDTO employeePageQueryDTO){log.info("员工分页查询，参数为：{}", employeePageQueryDTO);PageResult pageResult = employeeService.pageQuery(employeePageQueryDTO);//后续定义return Result.success(pageResult);}

service层

//在EmployeeService接口中声明pageQuery方法：
PageResult pageQuery(EmployeePageQueryDTO employeePageQueryDTO);

        ServiceImpl层public PageResult pageQuery(EmployeePageQueryDTO employeePageQueryDTO) {// select * from employee limit 0,10//开始分页查询PageHelper.startPage(employeePageQueryDTO.getPage(),                         employeePageQueryDTO.getPageSize());Page<Employee> page = employeeMapper.pageQuery(employeePageQueryDTO);//后续定义long total = page.getTotal();List<Employee> records = page.getResult();return new PageResult(total, records);}

employeeQueryDTO为前端传过来的指定数据，包括总共多少页，每页展示数

Mapper层

Page<Employee> pageQuery(EmployeePageQueryDTO employeePageQueryDTO);

Mapper.xml文件

<select id="pageQuery" resultType="com.sky.entity.Employee">select * from employee<where><if test="name != null and name != ''">and name like concat('%',#{name},'%')</if></where>order by create_time desc</select>

在执行查询语句时，会在后面自动拼接limit语句

5.Day3 技术总结

5.1 AOP思想

AOP简介：

AOP是一种编程范式，旨在通过分离横切关注点（如日志记录、事务管理、安全检查等）来提高代码的模块化和可维护性。它将这些横切逻辑从业务逻辑中分离出来，集中管理，从而减少代码冗余和提高代码清晰度。

作用：在程序运行期间在不修改源代码的基础上对已有方法进行增强（无侵入性: 解耦）

5.1.1 AOP核心概念

Spring的AOP底层是基于动态代理技术来实现的，也就是说在程序运行的时候，会自动的基于动态代理技术为目标对象生成一个对应的代理对象，在代理对象当中就会对目标对象当中的原始方法进行功能的增强，故而对原代码无侵入性

5.1.2 通知类型

5.1.3 通知执行顺序

5.1.4 切入点表达式

5.2 使用AOP解决公共字段填充

5.2.1 自定义注解 AutoFill

进入到sky-server模块，创建com.sky.annotation包

/*** 自定义注解，用于标识某个方法需要进行功能字段自动填充处理*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoFill {//数据库操作类型：UPDATE INSERTOperationType value();
}

OperationType注解

/*** 数据库操作类型*/
public enum OperationType {/*更新操作*/UPDATE,/*插入操作*/INSERT
}

5.2.2 自定义切面类

在sky-server模块，创建com.sky.aspect包

/*** 自定义切面，实现公共字段自动填充处理逻辑*/
@Aspect
@Component
@Slf4j
public class AutoFillAspect {/*** 切入点*/@Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")public void autoFillPointCut(){}/*** 前置通知，在通知中进行公共字段的赋值*/@Before("autoFillPointCut()")public void autoFill(JoinPoint joinPoint){/重要//可先进行调试，是否能进入该方法 提前在mapper方法添加AutoFill注解log.info("开始进行公共字段自动填充...");}
}

完善自定义切面 AutoFillAspect 的 autoFill 方法

@Aspect
@Component
@Slf4j
public class AutoFillAspect {/*** 切入点*/@Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")public void autoFillPointCut(){}/*** 前置通知，在通知中进行公共字段的赋值*/@Before("autoFillPointCut()")public void autoFill(JoinPoint joinPoint){log.info("开始进行公共字段自动填充...");//获取到当前被拦截的方法上的数据库操作类型MethodSignature signature = (MethodSignature) joinPoint.getSignature();//方法签名对象AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class);//获得方法上的注解对象OperationType operationType = autoFill.value();//获得数据库操作类型//获取到当前被拦截的方法的参数--实体对象Object[] args = joinPoint.getArgs();if(args == null || args.length == 0){return;}Object entity = args[0];//准备赋值的数据LocalDateTime now = LocalDateTime.now();Long currentId = BaseContext.getCurrentId();//根据当前不同的操作类型，为对应的属性通过反射来赋值if(operationType == OperationType.INSERT){//为4个公共字段赋值try {Method setCreateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_TIME,LocalDateTime.class;Method setCreateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_USER, Long.class);Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);//通过反射为对象属性赋值setCreateTime.invoke(entity,now);setCreateUser.invoke(entity,currentId);setUpdateTime.invoke(entity,now);setUpdateUser.invoke(entity,currentId);} catch (Exception e) {e.printStackTrace();}}
}

5.2.3 在Mapper方法上加注解

以CategoryMapper为例，分别在新增和修改方法添加@AutoFill()注解

@Mapper
public interface CategoryMapper {/*** 插入数据* @param category*///...@AutoFill(value = OperationType.INSERT)void insert(Category category);/*** 根据id修改分类* @param category*/@AutoFill(value = OperationType.UPDATE)void update(Category category);}

day4为作业部分，无新技术点，故而跳过

6.Day5 技术总结

6.1 Redis介绍

Redis是一种键值型的NoSql数据库，这里有两个关键字：

键值型
NoSql

其中键值型，是指Redis中存储的数据都是以key、value对的形式存储，而value的形式多种多样，可以是字符串、数值、甚至json：

6.2 认识NoSQL

NoSql可以翻译做Not Only Sql（不仅仅是SQL），或者是No Sql（非Sql的）数据库。是相对于传统关系型数据库而言，有很大差异的一种特殊的数据库，因此也称之为非关系型数据库。

6.1.1 结构化与非结构化

传统关系型数据库是结构化数据，每一张表都有严格的约束信息：字段名、字段数据类型、字段约束等等信息，插入的数据必须遵守这些约束：

而NoSql则对数据库格式没有严格约束，往往形式松散，自由。

可以是键值型，文档型，图格式：

6.1.2 关联和非关联

传统数据库的表与表之间往往存在关联，例如外键：

而非关系型数据库不存在关联关系，要维护关系要么靠代码中的业务逻辑，要么靠数据之间耦合：

{id: 1,name: "张三",orders: [{id: 1,item: {id: 10, title: "荣耀6", price: 4999}},{id: 2,item: {id: 20, title: "小米11", price: 3999}}]
}

6.1.3 查询方式

传统关系型数据库会基于Sql语句做查询，语法有统一标准；

而不同的非关系数据库查询语法差异极大，五花八门各种各样。

1.1.4.事务

传统关系型数据库能满足事务ACID的原则。

而非关系型数据库往往不支持事务，或者不能严格保证ACID的特性，只能实现基本的一致性。

6.1.5 总结

除了上述四点以外，在存储方式、扩展性、查询性能上关系型与非关系型也都有着显著差异，总结如下：

存储方式
- 关系型数据库基于磁盘进行存储，会有大量的磁盘IO，对性能有一定影响
- 非关系型数据库，他们的操作更多的是依赖于内存来操作，内存的读写速度会非常快，性能自然会好一些

扩展性
- 关系型数据库集群模式一般是主从，主从数据一致，起到数据备份的作用，称为垂直扩展。
- 非关系型数据库可以将数据拆分，存储在不同机器上，可以保存海量数据，解决内存大小有限的问题。称为水平扩展。
- 关系型数据库因为表之间存在关联关系，如果做水平扩展会给数据查询带来很多麻烦

6.3 Redis通用命令

通用指令是部分数据类型的，都可以使用的指令，常见的有：

KEYS：查看符合模板的所有key
DEL：删除一个指定的key
EXISTS：判断key是否存在
EXPIRE：给一个key设置有效期，有效期到期时该key会被自动删除
TTL：查看一个KEY的剩余有效期

6.4 String的常见命令

Redis 中字符串类型常用命令：

SET key value 设置指定key的值

GET key 获取指定key的值

SETEX key seconds value 设置指定key的值，并将 key 的过期时间设为 seconds 秒

SETNX key value 只有在 key 不存在时设置 key 的值

6.5 Hash类型

Redis hash 是一个string类型的 field 和 value 的映射表，hash特别适合用于存储对象，常用命令：

HSET key field value 将哈希表 key 中的字段 field 的值设为 value

HGET key field 获取存储在哈希表中指定字段的值

HDEL key field 删除存储在哈希表中的指定字段

HKEYS key 获取哈希表中所有字段

HVALS key 获取哈希表中所有值

6.6 List类型

Redis中的List类型与Java中的LinkedList类似，可以看做是一个双向链表结构。既可以支持正向检索和也可以支持反向检索。

特征：

有序
元素可以重复
插入和删除快
查询速度一般

Redis 列表是简单的字符串列表，按照插入顺序排序，常用命令：

LPUSH key value1 [value2] 将一个或多个值插入到列表头部

LRANGE key start stop 获取列表指定范围内的元素

RPOP key 移除并获取列表最后一个元素(R:right)

LPOP key 移除并获取列表第一个元素(L:left)

LLEN key 获取列表长度

BRPOP key1 [key2 ] timeout 移出并获取列表的最后一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止

6.7 Set类型

Redis set 是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据，常用命令：

SADD key member1 [member2] 向集合添加一个或多个成员

SMEMBERS key 返回集合中的所有成员

SCARD key 获取集合的成员数

SINTER key1 [key2] 返回给定所有集合的交集

SUNION key1 [key2] 返回所有给定集合的并集

SREM key member1 [member2] 移除集合中一个或多个成员

6.8 SortedSet类型

Redis的SortedSet是一个可排序的set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表（SkipList）加 hash表。

SortedSet具备下列特性：

可排序
元素不重复
查询速度快

因为SortedSet的可排序特性，经常被用来实现排行榜这样的功能。

常用命令：

ZADD key score1 member1 [score2 member2] 向有序集合添加一个或多个成员

ZRANGE key start stop [WITHSCORES] 通过索引区间返回有序集合中指定区间内的成员

ZINCRBY key increment member 有序集合中对指定成员的分数加上增量 increment

ZREM key member [member ...] 移除有序集合中的一个或多个成员

6.9 Redis解决营业状态问题

6.9.1 设置营业状态

controller层

@RestController("adminShopController")
@RequestMapping("/admin/shop")
@Api(tags = "店铺相关接口")
@Slf4j
public class ShopController {public static final String KEY = "SHOP_STATUS";@Autowiredprivate RedisTemplate redisTemplate;/*** 设置店铺的营业状态* @param status* @return*/@PutMapping("/{status}")@ApiOperation("设置店铺的营业状态")public Result setStatus(@PathVariable Integer status){log.info("设置店铺的营业状态为：{}",status == 1 ? "营业中" : "打烊中");redisTemplate.opsForValue().set(KEY,status);return Result.success();}
}

6.9.2 管理端查询营业状态

	/*** 获取店铺的营业状态* @return*/@GetMapping("/status")@ApiOperation("获取店铺的营业状态")public Result<Integer> getStatus(){Integer status = (Integer) redisTemplate.opsForValue().get(KEY);log.info("获取到店铺的营业状态为：{}",status == 1 ? "营业中" : "打烊中");return Result.success(status);}

6.9.3 用户端查询营业状态

@RestController("userShopController")
@RequestMapping("/user/shop")
@Api(tags = "店铺相关接口")
@Slf4j
public class ShopController {public static final String KEY = "SHOP_STATUS";@Autowiredprivate RedisTemplate redisTemplate;/*** 获取店铺的营业状态* @return*/@GetMapping("/status")@ApiOperation("获取店铺的营业状态")public Result<Integer> getStatus(){Integer status = (Integer) redisTemplate.opsForValue().get(KEY);log.info("获取到店铺的营业状态为：{}",status == 1 ? "营业中" : "打烊中");return Result.success(status);}
}

7.Day6 技术总结

7.1 HttpClient

HttpClient 是Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。

HttpClient作用：

发送HTTP请求
接收响应数据

HttpClient应用场景：

当我们在使用扫描支付、查看地图、获取验证码、查看天气等功能时

其实，应用程序本身并未实现这些功能，都是在应用程序里访问提供这些功能的服务，访问这些服务需要发送HTTP请求，并且接收响应数据，可通过HttpClient来实现。

HttpClient的maven坐标：

<dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpclient</artifactId><version>4.5.13</version>
</dependency>

HttpClient的核心API：

HttpClient：Http客户端对象类型，使用该类型对象可发起Http请求。
HttpClients：可认为是构建器，可创建HttpClient对象。
CloseableHttpClient：实现类，实现了HttpClient接口。
HttpGet：Get方式请求类型。
HttpPost：Post方式请求类型。

HttpClient发送请求步骤：

创建HttpClient对象
创建Http请求对象
调用HttpClient的execute方法发送请求

7.2 微信小程序登录流程

步骤分析：

小程序端，调用wx.login()获取code，就是授权码。
小程序端，调用wx.request()发送请求并携带code，请求开发者服务器。
开发者服务端，通过HttpClient向微信接口服务发送请求，并携带对应参数。
开发者服务端，接收微信接口服务返回的数据。opendId是微信用户的唯一标识。
开发者服务端，自定义登录态，生成令牌(token)和openid等数据返回给小程序端。
小程序端，收到自定义登录态，存储storage。
小程序端，后绪通过wx.request()发起业务请求时，携带token。
开发者服务端，收到请求后，通过携带的token，解析当前登录用户的id。
开发者服务端，身份校验通过后，继续相关的业务逻辑处理，最终返回业务数据。

8.Day7 技术总结

8.1 SpringCache

8.1.1 介绍

Spring Cache 是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能。

起步依赖：

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId>  		            		       	 <version>2.7.3</version> 
</dependency>

8.1.2 常用注解

在SpringCache中提供了很多缓存操作的注解，常见的是以下的几个：

注解	说明
@EnableCaching	开启缓存注解功能，通常加在启动类上
@Cacheable	在方法执行前先查询缓存中是否有数据，如果有数据，则直接返回缓存数据；如果没有缓存数据，调用方法并将方法返回值放到缓存中
@CachePut	将方法的返回值放到缓存中
@CacheEvict	将一条或多条数据从缓存中删除

在spring boot项目中，使用缓存技术只需在项目中导入相关缓存技术的依赖包，并在启动类上使用@EnableCaching开启缓存支持即可。

例如，使用Redis作为缓存技术，只需要导入Spring data Redis的maven坐标即可。

8.1.3 使用案例

引导类上加@EnableCaching:（开启缓存注解功能）

package com.itheima;import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;@Slf4j
@SpringBootApplication
@EnableCaching//开启缓存注解功能
public class CacheDemoApplication {public static void main(String[] args) {SpringApplication.run(CacheDemoApplication.class,args);log.info("项目启动成功...");}
}

在save方法上加注解@CachePut

当前UserController的save方法是用来保存用户信息的，我们希望在该用户信息保存到数据库的同时，也往Redis中缓存一份数据

	/*** CachePut：将方法返回值放入缓存* value：缓存的名称，每个缓存名称下面可以有多个key* key：缓存的key*/@PostMapping@CachePut(value = "userCache", key = "#user.id")//key的生成：userCache::1public User save(@RequestBody User user){userMapper.insert(user);return user;}

在getById上加注解@Cacheable

/*** Cacheable：在方法执行前spring先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；若没有数据，	  *调用方法并将方法返回值放到缓存中* value：缓存的名称，每个缓存名称下面可以有多个key* key：缓存的key*/@GetMapping@Cacheable(cacheNames = "userCache",key="#id")public User getById(Long id){User user = userMapper.getById(id);return user;}

在 delete 方法上加注解@CacheEvict

	@DeleteMapping@CacheEvict(cacheNames = "userCache",key = "#id")//删除某个key对应的缓存数据public void deleteById(Long id){userMapper.deleteById(id);}@DeleteMapping("/delAll")@CacheEvict(cacheNames = "userCache",allEntries = true)//删除userCache下所有的缓存数据public void deleteAll(){userMapper.deleteAll();}

9.Day10 技术总结

9.1 Spring Task

9.1.1 介绍

Spring Task 是Spring框架提供的任务调度工具，可以按照约定的时间自动执行某个代码逻辑。

定位：定时任务框架

作用：定时自动执行某段Java代码

强调：只要是需要定时处理的场景都可以使用Spring Task

9.1.2 cron表达式

cron表达式其实就是一个字符串，通过cron表达式可以定义任务触发的时间

构成规则：分为6或7个域，由空格分隔开，每个域代表一个含义

每个域的含义分别为：秒、分钟、小时、日、月、周、年(可选)

通配符：

符号	含义
*	表示所有值
?	表示未说明的值，即不关心它为何值
-	表示一个指定的范围
,	表示附加一个可能值
/	符号前表示开始时间，符号后表示每次递增的值

9.2. WebSocket

9.2.1 介绍

WebSocket 是基于 TCP 的一种新的网络协议。它实现了浏览器与服务器全双工通信——浏览器和服务器只需要完成一次握手，两者之间就可以创建持久性的连接，并进行双向数据传输。

HTTP协议和WebSocket协议对比：

HTTP是短连接
WebSocket是长连接
HTTP通信是单向的，基于请求响应模式
WebSocket支持双向通信
HTTP和WebSocket底层都是TCP连接

思考：既然WebSocket支持双向通信，功能看似比HTTP强大，那么我们是不是可以基于WebSocket开发所有的业务功能？

WebSocket缺点：

服务器长期维护长连接需要一定的成本
各个浏览器支持程度不一
WebSocket 是长连接，受网络限制比较大，需要处理好重连

结论：WebSocket并不能完全取代HTTP，它只适合在特定的场景下使用

WebSocket应用场景：

视频弹幕

9.2.2 实现来单提醒与用户催单功能

定义WebSocket服务端组件

/*** WebSocket服务*/
@Component
@ServerEndpoint("/ws/{sid}")
public class WebSocketServer {//存放会话对象private static Map<String, Session> sessionMap = new HashMap();/*** 连接建立成功调用的方法*/@OnOpenpublic void onOpen(Session session, @PathParam("sid") String sid) {System.out.println("客户端：" + sid + "建立连接");sessionMap.put(sid, session);}/*** 收到客户端消息后调用的方法** @param message 客户端发送过来的消息*/@OnMessagepublic void onMessage(String message, @PathParam("sid") String sid) {System.out.println("收到来自客户端：" + sid + "的信息:" + message);}/*** 连接关闭调用的方法** @param sid*/@OnClosepublic void onClose(@PathParam("sid") String sid) {System.out.println("连接断开:" + sid);sessionMap.remove(sid);}/*** 群发** @param message*/public void sendToAllClient(String message) {Collection<Session> sessions = sessionMap.values();for (Session session : sessions) {try {//服务器向客户端发送消息session.getBasicRemote().sendText(message);} catch (Exception e) {e.printStackTrace();}}}}

定义配置类，注册WebSocket的服务端组件

/*** WebSocket配置类，用于注册WebSocket的Bean*/
@Configuration
public class WebSocketConfiguration {@Beanpublic ServerEndpointExporter serverEndpointExporter() {return new ServerEndpointExporter();}}

以上两步代码固定，可直接当工具类使用

定义定时任务类，定时向客户端推送数据

@Component
public class WebSocketTask {@Autowiredprivate WebSocketServer webSocketServer;/*** 通过WebSocket每隔5秒向客户端发送消息*/public void sendMessageToClient() {webSocketServer.sendToAllClient("这是来自服务端的消息：" + DateTimeFormatter.ofPattern("HH:mm:ss").format(LocalDateTime.now()));}
}

来单提醒

@Autowiredprivate WebSocketServer webSocketServer;/*** 支付成功，修改订单状态** @param outTradeNo*/public void paySuccess(String outTradeNo) {// 当前登录用户idLong userId = BaseContext.getCurrentId();// 根据订单号查询当前用户的订单Orders ordersDB = orderMapper.getByNumberAndUserId(outTradeNo, userId);// 根据订单id更新订单的状态、支付方式、支付状态、结账时间Orders orders = Orders.builder().id(ordersDB.getId()).status(Orders.TO_BE_CONFIRMED).payStatus(Orders.PAID).checkoutTime(LocalDateTime.now()).build();orderMapper.update(orders);Map map = new HashMap();map.put("type", 1);//消息类型，1表示来单提醒map.put("orderId", orders.getId());map.put("content", "订单号：" + outTradeNo);//通过WebSocket实现来单提醒，向客户端浏览器推送消息webSocketServer.sendToAllClient(JSON.toJSONString(map));}

客户催单

/*** 用户催单** @param id*/public void reminder(Long id) {// 查询订单是否存在Orders orders = orderMapper.getById(id);if (orders == null) {throw new OrderBusinessException(MessageConstant.ORDER_NOT_FOUND);}//基于WebSocket实现催单Map map = new HashMap();map.put("type", 2);//2代表用户催单map.put("orderId", id);map.put("content", "订单号：" + orders.getNumber());webSocketServer.sendToAllClient(JSON.toJSONString(map));}