开发 on Calendar's Blog

苍穹外卖

Thu, 23 Oct 2025 00:00:00 +0000

整体架构

参考：苍穹外卖项目(黑马)学习笔记DAY1_黑马外卖项目-CSDN博客、苍穹外卖——项目搭建_csdn管理端-CSDN博客

企业软件开发流程
- 需求分析（需求规格说明说、产品原型）
- 设计（UI设计、数据库设计、接口设计）
- 编码（项目代码、单元测试）
- 测试
- 上线运维
角色分工
- 项目经理（对项目整体规划安排）
- 产品经理（需求分析）
- UI设计师
- 架构师
- 开发工程师
- 测试工程师
- 运维工程师

NGINX 配置

利用反向代理，实现负载均衡，隐藏内部服务器达到后端安全，以及提高访问速度。

配置信息

global：会影响 Nginx 服务器的整体行为比如运行 Nginx 的用户和用户组
events：配置 Nginx 的事件处理方式，包括连接数限制、事件模型等
http: 配置文件的核心，用于配置 HTTP 服务器的行为。

http {
    include       mime.types;
    default_type  application/octet-stream;
 
    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';
 
    #access_log  logs/access.log  main;
 
    sendfile        on;
    #tcp_nopush     on;
 
    # 设置客户端和 Nginx 服务器之间的 Keep-Alive 连接的超时时间
    keepalive_timeout  65;
 
    #gzip  on;
	
	map $http_upgrade $connection_upgrade{
		default upgrade;
		'' close;
	}
 
	upstream webservers{
	  server 127.0.0.1:8080 weight=90 ;
	  #server 127.0.0.1:8088 weight=10 ;
	}
    # 每个 server 块代表一个特定的域名或端口的配置。
    server {
        listen       80;
        server_name  localhost;
 
        #charset koi8-r;
 
        #access_log  logs/host.access.log  main;
 
        location / {
            root   html/sky;
            index  index.html index.htm;
        }
 
        #error_page  404              /404.html;
 
        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
 
        # 反向代理,处理管理端发送的请求
        location /api/ {
			proxy_pass   http://localhost:8080/admin/;
            #proxy_pass   http://webservers/admin/;
        }
		
		# 反向代理,处理用户端发送的请求
        location /user/ {
        	# 可以设置proxy_pass、proxy_set_header、proxy_redirect
            proxy_pass   http://webservers/user/;
        }
		
		# WebSocket
		location /ws/ {
            proxy_pass   http://webservers/ws/;
			proxy_http_version 1.1;
			proxy_read_timeout 3600s;
			proxy_set_header Upgrade $http_upgrade;
			proxy_set_header Connection "$connection_upgrade";
        }
    }

启动前创建启动目录：

mkdir -p temp/client_body_temp
mkdir -p temp/fastcgi_temp
mkdir -p temp/proxy_temp
mkdir -p temp/scgi_temp
mkdir -p temp/uwsgi_temp

结构分析

sky-takeout
- sky-common
- sky-pojo
- sky-server
  - 配置文件、配置类、拦截器、controller、service、mapper、启动类等

初始化

本地、远程仓库配置

数据库配置（导入数据库设计文档）

docker run -d \
  --name mysql-container \  # 容器名称（自定义）
  -p 3306:3306 \           # 端口映射（主机端口:容器端口）
  -e MYSQL_ROOT_PASSWORD=1234 \  # root 用户密码（必填）
  # -e MYSQL_DATABASE=your_db \             # 初始化时创建的数据库（可选）
  # -e MYSQL_USER=root \               # 初始化时创建的用户（可选）
  # -e MYSQL_PASSWORD=user_password \       # 上述用户的密码（可选）
  -v /root/docker/mysql:/var/lib/mysql \       # 数据持久化（主机目录:容器内数据目录，已补充容器内路径）
  --restart=always \                      # 容器退出时自动重启（可选）
  mysql:5.7                            # MySQL 镜像及版本

登录功能

数据库中的密码应该是加密后的形式，防止数据库泄露后用户密码的暴露。

开发工具

APIFox
- 帮助看文档
Swagger-knief4j
- 调试工具

apifox 是设计阶段使用的工具，管理和维护接口 Swagger 在开发阶段使用的框架，帮助后端开发人员做后端的接口测试

引入依赖：

<dependency>
  <groupId>com.github.xiaoymin</groupId>
  <artifactId>knife4j-spring-boot-starter</artifactId>
</dependency>

配置类：WebMvcConfiguration.java

/**
      * 通过knife4j生成接口文档
      * @return
 */
@Bean
public Docket docket() {
    ApiInfo apiInfo = new ApiInfoBuilder()
    .title("苍穹外卖项目接口文档")
    .version("2.0")
    .description("苍穹外卖项目接口文档")
    .build();
    Docket docket = new Docket(DocumentationType.SWAGGER_2)
    .apiInfo(apiInfo)
    .select()
    .apis(RequestHandlerSelectors.basePackage("com.sky.controller"))
    .paths(PathSelectors.any())
    .build();
    return docket;
}
/**
      * 设置静态资源映射
      * @param registry
 */
protected void addResourceHandlers(ResourceHandlerRegistry registry) {
    registry.addResourceHandler("/doc.html").addResourceLocations("classpath:/META-INF/resources/");
    registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
}

使用说明：

员工、分类管理

产品原型
- 比较直观，便于理解业务。
- 即业务实现的基础页面样式、传递的参数
设计接口
返回数据
表设计

看一下Result类怎么定义：

package com.sky.result;
import lombok.Data;
import java.io.Serializable;
/**
 * 后端统一返回结果
 * @param <T>
 */
@Data
public class Result<T> implements Serializable {
    private Integer code; //编码：1成功，0和其它数字为失败
    private String msg; //错误信息
    private T data; //数据
    public static <T> Result<T> success() {
        Result<T> result = new Result<T>();
        result.code = 1;
        return result;
    }
    public static <T> Result<T> success(T object) {
        Result<T> result = new Result<T>();
        result.data = object;
        result.code = 1;
        return result;
    }
    public static <T> Result<T> error(String msg) {
        Result result = new Result();
        result.msg = msg;
        result.code = 0;
        return result;
    }
}

看一下 Constant 类怎么定义

package com.sky.constant;

/**
 * 公共字段自动填充相关常量
 */
public class AutoFillConstant {
    /**
     * 实体类中的方法名称
     */
    public static final String SET_CREATE_TIME = "setCreateTime";
    public static final String SET_UPDATE_TIME = "setUpdateTime";
    public static final String SET_CREATE_USER = "setCreateUser";
    public static final String SET_UPDATE_USER = "setUpdateUser";
}

员工添加流程

Controller 层中创建方法

    @PostMapping
    @ApiOperation("新增员工")
    public Result save(@RequestBody EmployeeDTO employeeDTO){
        log.info("新增员工：{}",employeeDTO);
        employeeService.save(employeeDTO);//该方法后续步骤会定义
        return Result.success();
    }

Service 层中声明方法

`1`	`void save(EmployeeDTO employeeDTO);`

Impl 具体实现

    public void save(EmployeeDTO employeeDTO) {
        Employee employee = new Employee();

        //对象属性拷贝
        BeanUtils.copyProperties(employeeDTO, employee);

        //设置账号的状态，默认正常状态 1表示正常 0表示锁定
        employee.setStatus(StatusConstant.ENABLE);

        //设置密码，默认密码123456
        employee.setPassword(DigestUtils.md5DigestAsHex(PasswordConstant.DEFAULT_PASSWORD.getBytes()));

        //设置当前记录的创建时间和修改时间
        employee.setCreateTime(LocalDateTime.now());
        employee.setUpdateTime(LocalDateTime.now());

        //设置当前记录创建人id和修改人id
        employee.setCreateUser(10L);//目前写个假数据，后期修改
        employee.setUpdateUser(10L);

        employeeMapper.insert(employee);//后续步骤定义
    }

Mapper 中实现插入

@Insert("insert into employee (name, username, password, phone, sex, id_number, create_time, update_time, create_user, update_user,status) " +
            "values " +
            "(#{name},#{username},#{password},#{phone},#{sex},#{idNumber},#{createTime},#{updateTime},#{createUser},#{updateUser},#{status})")
    void insert(Employee employee);

在application.yml中已开启驼峰命名，故id_number和idNumber可对应。
1
2
3
4
mybatis:
  configuration:
    #开启驼峰命名
    map-underscore-to-camel-case: true

完善

录入用户名冲突时，抛出的异常没处理

通过添加全局处理器

// sky-server/com.sky.hander/GlobalExceptionHander.java	
public class GlobalExceptionHandler{
    ......
/**
     * 处理SQL异常
     * @param ex
     * @return
     */
    @ExceptionHandler
    public 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);
        }
    }
}

新增员工时，创建、修改人 id 为固定值
- 需要动态获取当前用户信息 –> jwt 拦截获取 id ，存入上下文
- 拦截器的书写：

@Component
@Slf4j
public class JwtTokenAdminInterceptor implements HandlerInterceptor {
    @Autowired
    private JwtProperties jwtProperties;
    /**
     * 校验jwt
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断当前拦截到的是Controller的方法还是其他资源
        //识别到 Mapping...，会自动被包装为 HandlerMethod
        if (!(handler instanceof HandlerMethod)) {
            //当前拦截到的不是动态方法，直接放行
            return true;
        }
        //1、从请求头中获取令牌
        String token = request.getHeader(jwtProperties.getAdminTokenName());
        //2、校验令牌
        try {
            log.info("jwt校验:{}", token);
            Claims claims = JwtUtil.parseJWT(jwtProperties.getAdminSecretKey(), token);
            Long empId = Long.valueOf(claims.get(JwtClaimsConstant.EMP_ID).toString());
            log.info("当前员工id：", empId);
            //3、通过，放行
            return true;
        } catch (Exception ex) {
            //4、不通过，响应401状态码
            response.setStatus(401);
            return false;
        }
    }
}

ThreadLocal：

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

常用方法：

public void set(T value) 设置当前线程的线程局部变量的值

public T get() 返回当前线程所对应的线程局部变量的值

public void remove() 移除当前线程的线程局部变量

看一下封装了的 ThreadLocal 工具类

// 在sky-common/com.sky.context
    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();
    }
}

分页查询

封装 EmployeePageQueryDTO 来接收参数

封装 PageResult 对象，来返回分页参数

包含总记录数、当前页数据集合

@Data
@AllArgsConstructor
@NoArgsConstructor
public class PageResult implements Serializable {
    private long total; //总记录数
    private List records; //当前页数据集合
}

后续用 Result<PageResult> 返回

controller 层

	@GetMapping
    @ApiOperation(value = "分页查询")
    public Result<PageResult> pageQuery(@RequestParam EmployeePageQueryDTO employeePageQueryDTO){
        log.info("分页查询{}",employeePageQueryDTO);
        PageResult pageResult = employeeService.pageQuery(employeePageQueryDTO);
        return Result.success(pageResult);
    }

Service 层

关注 PageHelper 的使用

来自：

<dependency>
   <groupId>com.github.pagehelper</groupId>
   <artifactId>pagehelper-spring-boot-starter</artifactId>
   <version>${pagehelper}</version>
</dependency>

public PageResult pageQuery(EmployeePageQueryDTO employeePageQueryDTO) {
    // SQL 语法：select * from employee limit 0,10
    // 传入 startPage，然后查询，用 Page<T> 接收
        PageHelper.startPage(employeePageQueryDTO.getPage(),employeePageQueryDTO.getPageSize());
        Page<Employee> page = employeeMapper.pageQuery(employeePageQueryDTO);
		// 从封装好的 page 对象中取出结果
        long total = page.getTotal();
        List<Employee> records = page.getResult();
        return new PageResult(total,records);
    }

Mapper
- 复杂查询用 .xml

<mapper namespace="com.sky.mapper.EmployeeMapper">
    <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>
</mapper>

完善

日期显示格式有问题
- 方法一：在属性上加注解@JsonFormat(patter = "yyyy-MM-dd HH:mm:ss")
- 方法二：在WebMvcConfiguration中扩展SpringMVC的消息转换器，统一对日期类型进行格式处理

消息转换器：

当后端向前端返回 ResponseBody，或接收前端 RequestBody 时，会自动调用

	/**
     * 扩展Spring MVC框架的消息转化器
     * @param converters
     */
    protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        log.info("扩展消息转换器...");
        //创建一个消息转换器对象
        MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
        //需要为消息转换器设置一个对象转换器，对象转换器可以将Java对象序列化为json数据
        converter.setObjectMapper(new JacksonObjectMapper());
        //将自己的消息转化器加入容器中
        converters.add(0,converter);
    }

Json 对象映射器

package com.sky.json;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

import static com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;

/**
 * 对象映射器:基于jackson将Java对象转为json，或者将json转为Java对象
 * 将JSON解析为Java对象的过程称为 [从JSON反序列化Java对象]
 * 从Java对象生成JSON的过程称为 [序列化Java对象到JSON]
 */
public class JacksonObjectMapper extends ObjectMapper {

    public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
    //public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm";
    public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

    public JacksonObjectMapper() {
        super();
        //收到未知属性时不报异常
        this.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);

        //反序列化时，属性不存在的兼容处理
        this.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

        SimpleModule simpleModule = new SimpleModule()
                .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)))
                .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));

        //注册功能模块 例如，可以添加自定义序列化器和反序列化器
        this.registerModule(simpleModule);
    }
}

启用、禁用

数据层处理：直接用 update 来更新！整合到一起

Controller
- 注意接收路径参数、query 参数

    @PostMapping("/status/{status}")
    @ApiOperation("启用禁用员工账号")
    public Result startOrStop(@PathVariable Integer status,Long id){
        log.info("启用禁用员工账号：{},{}",status,id);
        employeeService.startOrStop(status,id);//后绪步骤定义
        return Result.success();
    }

Service

    public void startOrStop(Integer status, Long id) {
        Employee employee = Employee.builder()
                .status(status)
                .id(id)
                .build();

        employeeMapper.update(employee);
    }

Mapper .xml

<update id="update" parameterType="Employee">
        update employee
        <set>
            <if test="name != null">name = #{name},</if>
            <if test="username != null">username = #{username},</if>
            <if test="password != null">password = #{password},</if>
            <if test="phone != null">phone = #{phone},</if>
            <if test="sex != null">sex = #{sex},</if>
            <if test="idNumber != null">id_Number = #{idNumber},</if>
            <if test="updateTime != null">update_Time = #{updateTime},</if>
            <if test="updateUser != null">update_User = #{updateUser},</if>
            <if test="status != null">status = #{status},</if>
        </set>
        where id = #{id}
    </update>

编辑员工

根据 id 查询员工

Controller

    @GetMapping("/{id}")
    @ApiOperation("根据id查询员工信息")
    public Result<Employee> getById(@PathVariable Long id){
        Employee employee = employeeService.getById(id);
        return Result.success(employee);
    }

Service
- 注意：密码回显前要隐藏！

public Employee getById(Long id) {
        Employee employee = employeeMapper.getById(id);
        employee.setPassword("****");
        return employee;
    }

Mapper

1
2

@Select("select * from employee where id = #{id}")
Employee getById(Long id);

修改员工信息

直接用 update 将原来的覆盖即可

Controller
- 注意方式为 Put！

@PutMapping
@ApiOperation("编辑员工信息")
public Result update(@RequestBody EmployeeDTO employeeDTO){
        log.info("编辑员工信息：{}", employeeDTO);
        employeeService.update(employeeDTO);
        return Result.success();
    }

Service

public void update(EmployeeDTO employeeDTO) {
        Employee employee = new Employee();
        BeanUtils.copyProperties(employeeDTO, employee);

        employee.setUpdateTime(LocalDateTime.now());
        employee.setUpdateUser(BaseContext.getCurrentId());

        employeeMapper.update(employee);
    }

Mapper
- 就是上面的 update

公共字段填充

抽取需要重复赋值的部分，如 setCreateTime(...) 等

使用 AOP 编程！

实现步骤：

自定义注解 AutoFill，用于标识需要进行公共字段自动填充的方法
自定义切面类 AutoFillAspect，统一拦截加入了 AutoFill 注解的方法，通过反射为公共字段赋值
在 Mapper 的方法上加入 AutoFill 注解

自定义注解

// sky-server/com.sky.annotation
package com.sky.annotation;
import ...

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

其中，OperationType 在 sky-common 中定义：

package com.sky.enumeration;
/**
 * 数据库操作类型
 */
public enum OperationType {
    UPDATE,
    INSERT
}

自定义切面

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();
            }
        }else if(operationType == OperationType.UPDATE){
            //为2个公共字段赋值
            try {
                Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);

                //通过反射为对象属性赋值
                setUpdateTime.invoke(entity,now);
                setUpdateUser.invoke(entity,currentId);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

菜品管理

文件上传的配置

实现图片的上传、多表操作

文件上传
- 使用阿里云的 OSS

配置 application-dev.yml

sky:
  alioss:
    endpoint: oss-cn-hangzhou.aliyuncs.com
    access-key-id: ...
    access-key-secret: ...
    bucket-name: sky-takeout-calendar

application.yml

spring:
  profiles:
    active: dev    #设置环境
sky:
  alioss:
    endpoint: ${sky.alioss.endpoint}
    access-key-id: ${sky.alioss.access-key-id}
    access-key-secret: ${sky.alioss.access-key-secret}
    bucket-name: ${sky.alioss.bucket-name}

读取配置

// sky-commom/com.sky.properties
package com.sky.properties;

@Component
@ConfigurationProperties(prefix = "sky.alioss")
@Data
public class AliOssProperties {
    private String endpoint;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;
}

配置类，用于生成 OSS 工具类对象

// sky-server/com.sky.config
package com.sky.config;
/**
 * 配置类，用于创建AliOssUtil对象
 */
@Configuration
@Slf4j
public class OssConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public AliOssUtil aliOssUtil(AliOssProperties aliOssProperties){
        log.info("开始创建阿里云文件上传工具类对象：{}",aliOssProperties);
        return new AliOssUtil(aliOssProperties.getEndpoint(),
                aliOssProperties.getAccessKeyId(),
                aliOssProperties.getAccessKeySecret(),
                aliOssProperties.getBucketName());
    }
}

AliOssUtil 在 sky-common 中定义

package com.sky.utils;
@Data
@AllArgsConstructor
@Slf4j
public class AliOssUtil {

    private String endpoint;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;

    /**
     * 文件上传
     */
    public String upload(byte[] bytes, String objectName) {

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);

        try {
            // 创建PutObject请求。
            ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(bytes));
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }

        //文件访问路径规则 https://BucketName.Endpoint/ObjectName
        StringBuilder stringBuilder = new StringBuilder("https://");
        stringBuilder
                .append(bucketName)
                .append(".")
                .append(endpoint)
                .append("/")
                .append(objectName);

        log.info("文件上传到:{}", stringBuilder.toString());

        return stringBuilder.toString();
    }
}

用 putobject 上传，然后捕获异常、回显上传路径

CommonController 接口

package com.sky.controller.admin;

/**
 * 通用接口
 */
@RestController
@RequestMapping("/admin/common")
@Api(tags = "通用接口")
@Slf4j
public class CommonController {

    @Autowired
    private AliOssUtil aliOssUtil;

    /**
     * 文件上传
     * @param file
     * @return
     */
    @PostMapping("/upload")
    @ApiOperation("文件上传")
    public Result<String> upload(MultipartFile file){
        log.info("文件上传：{}",file);
        try {
            //原始文件名
            String originalFilename = file.getOriginalFilename();
            //截取原始文件名的后缀   dfdfdf.png
            String extension = originalFilename.substring(originalFilename.lastIndexOf("."));
            //构造新文件名称
            String objectName = UUID.randomUUID().toString() + extension;
            //文件的请求路径
            String filePath = aliOssUtil.upload(file.getBytes(), objectName);
            return Result.success(filePath);
        } catch (IOException e) {
            log.error("文件上传失败：{}", e);
        }

        return Result.error(MessageConstant.UPLOAD_FAILED);
    }
}

新增菜品

多表操作、批量添加的处理

Controller
- 注意：注入的注解是 @RequiredArgsConstructor，且用 private final

    @PostMapping
    @ApiOperation("新增菜品")
    public Result save(@RequestBody DishDTO dishDTO) {
        log.info("新增菜品：{}", dishDTO);
        dishService.saveWithFlavor(dishDTO);//后绪步骤开发
        return Result.success();
    }
}

Service
- 用事务解决同步性问题

package com.sky.service.impl;
@Service
@Slf4j
public class DishServiceImpl implements DishService {

    @Autowired
    private DishMapper dishMapper;
    @Autowired
    private DishFlavorMapper dishFlavorMapper;

    /**
     * 新增菜品和对应的口味
     *
     * @param dishDTO
     */
    @Transactional
    public void saveWithFlavor(DishDTO dishDTO) {

        Dish dish = new Dish();
        BeanUtils.copyProperties(dishDTO, dish);

        //向菜品表插入1条数据
        dishMapper.insert(dish);//后绪步骤实现

        //获取insert语句生成的主键值
        Long dishId = dish.getId();
        
		// ！！！批量插入数据
        List<DishFlavor> flavors = dishDTO.getFlavors();
        if (flavors != null && flavors.size() > 0) {
            flavors.forEach(dishFlavor -> {
                dishFlavor.setDishId(dishId);
            });
            //向口味表插入n条数据
            dishFlavorMapper.insertBatch(flavors);//后绪步骤实现
        }
    }

}

Mapper
- 主要看 insetBatch，用 foreach 遍历

<?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.sky.mapper.DishFlavorMapper">
    <insert id="insertBatch">
        insert into dish_flavor (dish_id, name, value) VALUES
        <foreach collection="flavors" item="df" separator=",">
            (#{df.dishId},#{df.name},#{df.value})
        </foreach>
    </insert>
</mapper>

菜品分页查询

类似前面的分页查询，但是新增了多表查询

Controller

@GetMapping("/page")
@ApiOperation(value = "菜品分页查询")
public Result<PageResult> page(DishPageQueryDTO dishPageQueryDTO){
        log.info("菜品分页查询{}",dishPageQueryDTO);
        PageResult pageResult = dishService.page(dishPageQueryDTO);
        return Result.success(pageResult);
    }

Service

    @Override
    public PageResult page(DishPageQueryDTO dishPageQueryDTO) {
        PageHelper.startPage(dishPageQueryDTO.getPage(),dishPageQueryDTO.getPageSize());
        Page<DishVO> records = dishMapper.page(dishPageQueryDTO);
        Long total = records.getTotal();
        List<DishVO> dishVOS = records.getResult();
        PageResult pageResult = new PageResult();
        pageResult.setTotal(total);
        pageResult.setRecords(dishVOS);
        return pageResult;
    }

Mapper
- 注意多表查询

    <select id="pageQuery" resultType="com.sky.vo.DishVO">
        select d.* , c.name as categoryName from dish d left outer join category c on d.category_id = c.id
        <where>
            <if test="name != null">
                and d.name like concat('%',#{name},'%')
            </if>
            <if test="categoryId != null">
                and d.category_id = #{categoryId}
            </if>
            <if test="status != null">
                and d.status = #{status}
            </if>
        </where>
        order by d.create_time desc
    </select>

删除菜品

涉及较复杂的多表关联删除操作

业务规则：

可以一次删除一个菜品，也可以批量删除菜品

起售中的菜品不能删除

被套餐关联的菜品不能删除

删除菜品后，关联的口味数据也需要删除掉

菜品的返回需要包装一个 VO 类

Controller

    @DeleteMapping
    @ApiOperation("菜品批量删除")
    public Result delete(@RequestParam List<Long> ids) {
        log.info("菜品批量删除：{}", ids);
        dishService.deleteBatch(ids);//后绪步骤实现
        return Result.success();
    }

Service
- 注意判断逻辑

@Transactional//事务
    public void deleteBatch(List<Long> ids) {
        //判断当前菜品是否能够删除---是否存在起售中的菜品？？
        for (Long id : ids) {
            Dish dish = dishMapper.getById(id);//后绪步骤实现
            if (dish.getStatus() == StatusConstant.ENABLE) {
                //当前菜品处于起售中，不能删除
                throw new DeletionNotAllowedException(MessageConstant.DISH_ON_SALE);
            }
        }

        //判断当前菜品是否能够删除---是否被套餐关联了？？
        List<Long> setmealIds = setmealDishMapper.getSetmealIdsByDishIds(ids);
        if (setmealIds != null && setmealIds.size() > 0) {
            //当前菜品被套餐关联了，不能删除
            throw new DeletionNotAllowedException(MessageConstant.DISH_BE_RELATED_BY_SETMEAL);
        }

        //删除菜品表中的菜品数据
        for (Long id : ids) {
            dishMapper.deleteById(id);//后绪步骤实现
            //删除菜品关联的口味数据
            dishFlavorMapper.deleteByDishId(id);//后绪步骤实现
        }
    }

Mapper
- 注意删除多个

<?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.sky.mapper.SetmealDishMapper">
    <select id="getSetmealIdsByDishIds" resultType="java.lang.Long">
        select setmeal_id from setmeal_dish where dish_id in
        <foreach collection="dishIds" item="dishId" separator="," open="(" close=")">
            #{dishId}
        </foreach>
    </select>
</mapper>

异常类编写：

package com.sky.exception;
public class DeletionNotAllowedException extends BaseException {

    public DeletionNotAllowedException(String msg) {
        super(msg);
    }
}

修改菜品

查询

需要将 flavor 也添加进去 –> 需要新的 VO 来存储

Controller

@GetMapping("/{id}")
    @ApiOperation("根据id查询菜品")
    public Result<DishVO> getById(@PathVariable Long id) {
        log.info("根据id查询菜品：{}", id);
        DishVO dishVO = dishService.getByIdWithFlavor(id);//后绪步骤实现
        return Result.success(dishVO);
    }

Service

    public DishVO getByIdWithFlavor(Long id) {
        //根据id查询菜品数据
        Dish dish = dishMapper.getById(id);

        //根据菜品id查询口味数据
        List<DishFlavor> dishFlavors = dishFlavorMapper.getByDishId(id);//后绪步骤实现

        //将查询到的数据封装到VO
        DishVO dishVO = new DishVO();
        BeanUtils.copyProperties(dish, dishVO);
        dishVO.setFlavors(dishFlavors);

        return dishVO;
    }

Mapper

1
2

    @Select("select * from dish_flavor where dish_id = #{dishId}")
    List<DishFlavor> getByDishId(Long dishId);

修改

Controller

    @PutMapping
    @ApiOperation("修改菜品")
    public Result update(@RequestBody DishDTO dishDTO) {
        log.info("修改菜品：{}", dishDTO);
        dishService.updateWithFlavor(dishDTO);
        return Result.success();
    }

Service

    public void updateWithFlavor(DishDTO dishDTO) {
        Dish dish = new Dish();
        BeanUtils.copyProperties(dishDTO, dish);

        //修改菜品表基本信息
        dishMapper.update(dish);

        //删除原有的口味数据
        dishFlavorMapper.deleteByDishId(dishDTO.getId());

        //重新插入口味数据
        List<DishFlavor> flavors = dishDTO.getFlavors();
        if (flavors != null && flavors.size() > 0) {
            flavors.forEach(dishFlavor -> {
                dishFlavor.setDishId(dishDTO.getId());
            });
            //向口味表插入n条数据
            dishFlavorMapper.insertBatch(flavors);
        }
    }

Mapper
- 注意更新的编写，if test 标签

<update id="update">
        update dish
        <set>
            <if test="name != null">name = #{name},</if>
            <if test="categoryId != null">category_id = #{categoryId},</if>
            <if test="price != null">price = #{price},</if>
            <if test="image != null">image = #{image},</if>
            <if test="description != null">description = #{description},</if>
            <if test="status != null">status = #{status},</if>
            <if test="updateTime != null">update_time = #{updateTime},</if>
            <if test="updateUser != null">update_user = #{updateUser},</if>
        </set>
        where id = #{id}
</update>

套餐管理

新增套餐

首先需要新增根据套餐类型查询菜品，回显
- 注意返回值！

// DishController
    @GetMapping("/list")
    @ApiOperation(value = "根据分类id查询菜品")
    public Result<List<DishVO>> getByCategoryId(@RequestParam Long categoryId){
        log.info("根据分类id查询菜品{}",categoryId);
        List<DishVO> dishVOS = dishService.getByCategoryId(categoryId);
        return Result.success(dishVOS);
    }

然后正常添加 setmeal 的 insert 即可

套餐分页查询

类似地，多了参数，多写几个 if test 就可以了

注意，Page<Setmeal> records = setmealMapper.pageQuerySetmeal(setmealPageQueryDTO);，返回的不是 page 对象……

删除套餐

sql 不会写：
- 接收参数要用 @RequestParam List<Long> ids
  - 绑定参数、参数可选、数组参数

<delete id="deleteSetmeals">
    delete from setmeal where id in
    <foreach collection="ids" item="id" open="(" close=")" separator=",">
        #{id}
    </foreach>
</delete>

修改套餐

update 语句还不太会写

参数还是要用 @RequestBody 接收

<update id="update">
    update setmeal
    <set>
        <if test="categoryId != null">category_id = #{categoryId},</if>
        <if test="description != null and description != ''">description = #{description},</if>
        <if test="image != null and image != ''">image = #{image},</if>
        <if test="name != null and name != ''">name = #{name},</if>
        <if test="price != null">price = #{price},</if>
        <if test="status != null">status = #{status},</if>
        <if test="updateTime != null">update_time = #{updateTime},</if>
        <if test="updateUser != null">update_user = #{updateUser}</if>
    </set>
    where id = #{id}
</update>

启用、禁用套餐

没什么问题

Redis - 店铺营业状态

docker 部署

docker run -d \
  --name redis-4.0.0 \
  -p 6379:6379 \
  -v /root/docker/redis/data:/data \
  -v /root/docker/redis/conf/redis.conf:/etc/redis/redis.conf \
  redis:4.0.0 \
  redis-server /etc/redis/redis.conf

Spring Data Redis 的使用

配置

导入maven坐标

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

配置 dev.yml,并导入到 application.tml 中

spring:
  profiles:
    active: dev
  redis:
    host: ${sky.redis.host}
    port: ${sky.redis.port}
    password: ${sky.redis.password}
    database: ${sky.redis.database}

配置类

package com.sky.config;
@Configuration
@Slf4j
public class RedisConfiguration {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        log.info("开始创建redis模板对象...");
        RedisTemplate redisTemplate = new RedisTemplate();
        //设置redis的连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置redis key的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

Spring Boot 内置了 RedisAutoConfiguration 自动配置类，会根据 application.yml 中的 spring.redis 前缀配置，自动创建 RedisConnectionFactory 实例

当前配置类不是必须的，因为 Spring Boot 框架会自动装配 RedisTemplate 对象，但是默认的key序列化器为 JdkSerializationRedisSerializer，导致我们存到 Redis 中后的数据和原始数据有差别，故设置为 StringRedisSerializer 序列化器。

通过配置类操作 Redis

字符串型

	/**
     * 操作字符串类型的数据
     */
    public void testString(){
        // set get setex setnx
        redisTemplate.opsForValue().set("name","小明");
        String city = (String) redisTemplate.opsForValue().get("name");
        System.out.println(city);
        redisTemplate.opsForValue().set("code","1234",3, TimeUnit.MINUTES);
        redisTemplate.opsForValue().setIfAbsent("lock","1");
        redisTemplate.opsForValue().setIfAbsent("lock","2");
    }

哈希型

	/**
     * 操作哈希类型的数据
     */
    public void testHash(){
        //hset hget hdel hkeys hvals
        HashOperations hashOperations = redisTemplate.opsForHash();

        hashOperations.put("100","name","tom");
        hashOperations.put("100","age","20");

        String name = (String) hashOperations.get("100", "name");
        System.out.println(name);

        Set keys = hashOperations.keys("100");
        System.out.println(keys);

        List values = hashOperations.values("100");
        System.out.println(values);

        hashOperations.delete("100","age");
    }

列表类型

/**
 * 操作列表类型的数据
 */
public void testList(){
    //lpush lrange rpop llen
    ListOperations listOperations = redisTemplate.opsForList();

    listOperations.leftPushAll("mylist","a","b","c");
    listOperations.leftPush("mylist","d");

    List mylist = listOperations.range("mylist", 0, -1);
    System.out.println(mylist);

    listOperations.rightPop("mylist");

    Long size = listOperations.size("mylist");
    System.out.println(size);
}

集合类型

/**
 * 操作集合类型的数据
 */
@Test
public void testSet(){
    //sadd smembers scard sinter sunion srem
    SetOperations setOperations = redisTemplate.opsForSet();

    setOperations.add("set1","a","b","c","d");
    setOperations.add("set2","a","b","x","y");

    Set members = setOperations.members("set1");
    System.out.println(members);

    Long size = setOperations.size("set1");
    System.out.println(size);

    Set intersect = setOperations.intersect("set1", "set2");
    System.out.println(intersect);

    Set union = setOperations.union("set1", "set2");
    System.out.println(union);

    setOperations.remove("set1","a","b");
}

有序集合类型

/**
 * 操作有序集合类型的数据
 */
@Test
public void testZset(){
    //zadd zrange zincrby zrem
    ZSetOperations zSetOperations = redisTemplate.opsForZSet();

    zSetOperations.add("zset1","a",10);
    zSetOperations.add("zset1","b",12);
    zSetOperations.add("zset1","c",9);

    Set zset1 = zSetOperations.range("zset1", 0, -1);
    System.out.println(zset1);

    zSetOperations.incrementScore("zset1","c",10);

    zSetOperations.remove("zset1","a","b");
}

通用命令

	/**
     * 通用命令操作
     */
    @Test
    public void testCommon(){
        //keys exists type del
        Set keys = redisTemplate.keys("*");
        System.out.println(keys);

        Boolean name = redisTemplate.hasKey("name");
        Boolean set1 = redisTemplate.hasKey("set1");

        for (Object key : keys) {
            DataType type = redisTemplate.type(key);
            System.out.println(type.name());
        }

        redisTemplate.delete("mylist");
    }

店铺营业状态设置

接口设计：

设置营业状态

管理端查询营业状态

用户端查询营业状态

admin - ShopController
- user 类似，重名的 class 要指定 RestController 名称，否则自动装配会分辨不了

package com.sky.controller.admin;

@RestController("adminShopController")
@RequestMapping("/admin/shop")
@Api(tags = "店铺相关接口")
@Slf4j
public class ShopController {

    public static final String KEY = "SHOP_STATUS";

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

用户、管理接口分离

WebConfiguration 中配置扫描

	@Bean
    public Docket docket1(){
        log.info("准备生成接口文档...");
        ApiInfo apiInfo = new ApiInfoBuilder()
                .title("苍穹外卖项目接口文档")
                .version("2.0")
                .description("苍穹外卖项目接口文档")
                .build();

        Docket docket = new Docket(DocumentationType.SWAGGER_2)
                .groupName("管理端接口")
                .apiInfo(apiInfo)
                .select()
                //指定生成接口需要扫描的包
                .apis(RequestHandlerSelectors.basePackage("com.sky.controller.admin"))
                .paths(PathSelectors.any())
                .build();

        return docket;
    }

    @Bean
    public Docket docket2(){
        log.info("准备生成接口文档...");
        ApiInfo apiInfo = new ApiInfoBuilder()
                .title("苍穹外卖项目接口文档")
                .version("2.0")
                .description("苍穹外卖项目接口文档")
                .build();

        Docket docket = new Docket(DocumentationType.SWAGGER_2)
                .groupName("用户端接口")
                .apiInfo(apiInfo)
                .select()
                //指定生成接口需要扫描的包
                .apis(RequestHandlerSelectors.basePackage("com.sky.controller.user"))
                .paths(PathSelectors.any())
                .build();

        return docket;
    }

HttpClient

HttpClient作用：

发送HTTP请求

接收响应数据

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

导入坐标

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

核心 API
- HttpClient：Http客户端对象类型，使用该类型对象可发起Http请求。
- HttpClients：可认为是构建器，可创建HttpClient对象。
- CloseableHttpClient：实现类，实现了HttpClient接口。
- HttpGet：Get方式请求类型。
- HttpPost：Post方式请求类型。
发送请求步骤：
- 创建HttpClient对象
- 创建Http请求对象
- 调用HttpClient的execute方法发送请求

案例

@SpringBootTest
public class HttpClientTest {

    /**
     * 测试通过httpclient发送GET方式的请求
     */
    @Test
    public void testGET() throws Exception{
        //创建httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        //创建请求对象
        HttpGet httpGet = new HttpGet("http://localhost:8080/user/shop/status");

        //发送请求，接受响应结果
        CloseableHttpResponse response = httpClient.execute(httpGet);

        //获取服务端返回的状态码
        int statusCode = response.getStatusLine().getStatusCode();
        System.out.println("服务端返回的状态码为：" + statusCode);

        HttpEntity entity = response.getEntity();
        String body = EntityUtils.toString(entity);
        System.out.println("服务端返回的数据为：" + body);

        //关闭资源
        response.close();
        httpClient.close();
    }
}

post

	/**
     * 测试通过httpclient发送POST方式的请求
     */
    @Test
    public void testPOST() throws Exception{
        // 创建httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        //创建请求对象
        HttpPost httpPost = new HttpPost("http://localhost:8080/admin/employee/login");

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("username","admin");
        jsonObject.put("password","123456");

        StringEntity entity = new StringEntity(jsonObject.toString());
        //指定请求编码方式
        entity.setContentEncoding("utf-8");
        //数据格式
        entity.setContentType("application/json");
        httpPost.setEntity(entity);

        //发送请求
        CloseableHttpResponse response = httpClient.execute(httpPost);

        //解析返回结果
        int statusCode = response.getStatusLine().getStatusCode();
        System.out.println("响应码为：" + statusCode);

        HttpEntity entity1 = response.getEntity();
        String body = EntityUtils.toString(entity1);
        System.out.println("响应数据为：" + body);

        //关闭资源
        response.close();
        httpClient.close();
    }

微信小程序开发

小程序目录结构

小程序包含一个描述整体程序的 app 和多个描述各自页面的 page。一个小程序主体部分由三个文件组成，必须放在项目的根目录，如下：
- **app.js：**必须存在，主要存放小程序的逻辑代码
- **app.json：**必须存在，小程序配置文件，主要存放小程序的公共配置
- app.wxss: 非必须存在，主要存放小程序公共样式表，类似于前端的CSS样式

每个小程序页面主要由四个文件组成：
- **js文件：**必须存在，存放页面业务逻辑代码，编写的js代码。
  
  **wxml文件：**必须存在，存放页面结构，主要是做页面布局，页面效果展示的，类似于HTML页面。
  
  **json文件：**非必须，存放页面相关的配置。
  
  **wxss文件：**非必须，存放页面样式表，相当于CSS文件。

实现微信登录

步骤分析：
1. 小程序端，调用wx.login()获取code，就是授权码。
2. 小程序端，调用wx.request()发送请求并携带code，请求开发者服务器(自己编写的后端服务)。
3. 开发者服务端，通过HttpClient向微信接口服务发送请求，并携带appId+appsecret+code三个参数。
4. 开发者服务端，接收微信接口服务返回的数据，session_key+opendId等。opendId是微信用户的唯一标识。
5. 开发者服务端，自定义登录态，生成令牌(token)和openid等数据返回给小程序端，方便后绪请求身份校验。
6. 小程序端，收到自定义登录态，存储storage。
7. 小程序端，后绪通过wx.request()发起业务请求时，携带token。
8. 开发者服务端，收到请求后，通过携带的token，解析当前登录用户的id。
9. 开发者服务端，身份校验通过后，继续相关的业务逻辑处理，最终返回业务数据。
基于文档描述的所需参数，即可设计出登录接口
- 请求参数：前端像后端传递 code
- 返回数据：后端请求接口，再返回 id、openid、token
设计用户表
Controller

public class UserController {

    @Autowired
    private UserService userService;
    @Autowired
    private JwtProperties jwtProperties;
    
    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    @PostMapping("/login")
    @ApiOperation("微信登录")
    public Result<UserLoginVO> login(@RequestBody UserLoginDTO userLoginDTO){
        log.info("微信用户登录：{}",userLoginDTO.getCode());

        //微信登录
        User user = userService.wxLogin(userLoginDTO);

        //为微信用户生成jwt令牌
        Map<String, Object> claims = new HashMap<>();
        claims.put(JwtClaimsConstant.USER_ID,user.getId());
        String token = JwtUtil.createJWT(jwtProperties.getUserSecretKey(), jwtProperties.getUserTtl(), claims);

        UserLoginVO userLoginVO = UserLoginVO.builder()
                .id(user.getId())
                .openid(user.getOpenid())
                .token(token)
                .build();
        return Result.success(userLoginVO);
    }
}

Service

package com.sky.service.impl;
@Service
@Slf4j
public class UserServiceImpl implements UserService {

    //微信服务接口地址
    public static final String WX_LOGIN = "https://api.weixin.qq.com/sns/jscode2session";

    @Autowired
    private WeChatProperties weChatProperties;
    @Autowired
    private UserMapper userMapper;

    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    public User wxLogin(UserLoginDTO userLoginDTO) {
        String openid = getOpenid(userLoginDTO.getCode());

        //判断openid是否为空，如果为空表示登录失败，抛出业务异常
        if(openid == null){
            throw new LoginFailedException(MessageConstant.LOGIN_FAILED);
        }

        //判断当前用户是否为新用户
        User user = userMapper.getByOpenid(openid);

        //如果是新用户，自动完成注册
        if(user == null){
            user = User.builder()
                    .openid(openid)
                    .createTime(LocalDateTime.now())
                    .build();
            userMapper.insert(user);//后绪步骤实现
        }

        //返回这个用户对象
        return user;
    }

    /**
     * 调用微信接口服务，获取微信用户的openid
     * @param code
     * @return
     */
    private String getOpenid(String code){
        //调用微信接口服务，获得当前微信用户的openid
        Map<String, String> map = new HashMap<>();
        map.put("appid",weChatProperties.getAppid());
        map.put("secret",weChatProperties.getSecret());
        map.put("js_code",code);
        map.put("grant_type","authorization_code");
        String json = HttpClientUtil.doGet(WX_LOGIN, map);

        JSONObject jsonObject = JSON.parseObject(json);
        String openid = jsonObject.getString("openid");
        return openid;
    }
}

配置令牌校验
- 学一下怎么校验
- Claims claims = JwtUtil.parseJWT(jwtProperties.getUserSecretKey(), token);

@Component
@Slf4j
public class JwtTokenUserInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtProperties jwtProperties;

    /**
     * 校验jwt
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断当前拦截到的是Controller的方法还是其他资源
        if (!(handler instanceof HandlerMethod)) {
            //当前拦截到的不是动态方法，直接放行
            return true;
        }

        //1、从请求头中获取令牌
        String token = request.getHeader(jwtProperties.getUserTokenName());

        //2、校验令牌
        try {
            log.info("jwt校验:{}", token);
            Claims claims = JwtUtil.parseJWT(jwtProperties.getUserSecretKey(), token);
            Long userId = Long.valueOf(claims.get(JwtClaimsConstant.USER_ID).toString());
            log.info("当前用户的id：", userId);
            BaseContext.setCurrentId(userId);
            //3、通过，放行
            return true;
        } catch (Exception ex) {
            //4、不通过，响应401状态码
            response.setStatus(401);
            return false;
        }
    }
}

缓存

菜品 - 原始方法

用户端小程序展示的菜品数据都是通过查询数据库获得，如果用户端访问量比较大，数据库访问压力随之增大。

用 Redis 缓存菜品数据，减少数据库操作

缓存逻辑分析：
- 每个分类下的菜品保存一份缓存数据
- 数据库中菜品数据有变更时清理缓存数据
Controller

// 修改 DishController 调用 Mapper 的逻辑
public Result<List<DishVO>> list(Long categoryId) {

        //构造redis中的key，规则：dish_分类id
        String key = "dish_" + categoryId;

        //查询redis中是否存在菜品数据
        List<DishVO> list = (List<DishVO>) redisTemplate.opsForValue().get(key);
        if(list != null && list.size() > 0){
            //如果存在，直接返回，无须查询数据库
            return Result.success(list);
        }
		////////////////////////////////////////////////////////
        Dish dish = new Dish();
        dish.setCategoryId(categoryId);
        dish.setStatus(StatusConstant.ENABLE);//查询起售中的菜品

        //如果不存在，查询数据库，将查询到的数据放入redis中
        list = dishService.listWithFlavor(dish);
        ////////////////////////////////////////////////////////
        redisTemplate.opsForValue().set(key, list);

        return Result.success(list);
    }

为了保证数据库和Redis中的数据保持一致，修改管理端接口 DishController 的相关方法，加入清理缓存逻辑。

Controller
- 再新增、删除、更新等逻辑后面添加
- 支持通配符删除

// 管理端 DishController 中的清理缓存逻辑
    private void cleanCache(String pattern){
        Set keys = redisTemplate.keys(pattern);
        redisTemplate.delete(keys);
    }

套餐 - SpringCache

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

Spring Cache 提供了一层抽象，底层可以切换不同的缓存实现，例如：

EHCache

Caffeine

Redis(常用)
1
2
3
4
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-cache</artifactId>  		            		       	 <version>2.7.3</version> 
</dependency>

常用注解

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

@CachePut(value = “userCache”, key = “#user.id”)

@Cacheable(cacheNames = “userCache”,key="#id")

@CacheEvict(cacheNames = “userCache”,key = “#id”)

启动类中添加 @EnableCaching
用户端 SetmealController 的 list 方法上加入@Cacheable注解

@Cacheable(cacheNames = "setmealCache",key = "#categoryId")

管理端接口SetmealController的 save、delete、update、startOrStop等方法上加入 CacheEvict 注解

@CacheEvict(cacheNames = "setmealCache",allEntries = true)

购物车

新增

关注点
- 只能查询自己购物车的数据：shoppingCart.setUserId(BaseContext.getCurrentId());
- 添加菜品 or 套餐的判断
Controller

package com.sky.service.impl;
@Service
public class ShoppingCartServiceImpl implements ShoppingCartService {

    @Autowired
    private ShoppingCartMapper shoppingCartMapper;
    @Autowired
    private DishMapper dishMapper;
    @Autowired
    private SetmealMapper setmealMapper;

    /**
     * 添加购物车
     *
     * @param shoppingCartDTO
     */
    public void addShoppingCart(ShoppingCartDTO shoppingCartDTO) {
        ShoppingCart shoppingCart = new ShoppingCart();
        BeanUtils.copyProperties(shoppingCartDTO, shoppingCart);
        //只能查询自己的购物车数据
        shoppingCart.setUserId(BaseContext.getCurrentId());

        //判断当前商品是否在购物车中
        List<ShoppingCart> shoppingCartList = shoppingCartMapper.list(shoppingCart);

        if (shoppingCartList != null && shoppingCartList.size() == 1) {
            //如果已经存在，就更新数量，数量加1
            shoppingCart = shoppingCartList.get(0);
            shoppingCart.setNumber(shoppingCart.getNumber() + 1);
            shoppingCartMapper.updateNumberById(shoppingCart);
        } else {
            //如果不存在，插入数据，数量就是1

            //判断当前添加到购物车的是菜品还是套餐
            Long dishId = shoppingCartDTO.getDishId();
            if (dishId != null) {
                //添加到购物车的是菜品
                Dish dish = dishMapper.getById(dishId);
                shoppingCart.setName(dish.getName());
                shoppingCart.setImage(dish.getImage());
                shoppingCart.setAmount(dish.getPrice());
            } else {
                //添加到购物车的是套餐
                Setmeal setmeal = setmealMapper.getById(shoppingCartDTO.getSetmealId());
                shoppingCart.setName(setmeal.getName());
                shoppingCart.setImage(setmeal.getImage());
                shoppingCart.setAmount(setmeal.getPrice());
            }
            shoppingCart.setNumber(1);
            shoppingCart.setCreateTime(LocalDateTime.now());
            shoppingCartMapper.insert(shoppingCart);
        }
    }
}

Service

@Service
public class ShoppingCartServiceImpl implements ShoppingCartService {

    @Autowired
    private ShoppingCartMapper shoppingCartMapper;
    @Autowired
    private DishMapper dishMapper;
    @Autowired
    private SetmealMapper setmealMapper;

    /**
     * 添加购物车
     *
     * @param shoppingCartDTO
     */
    public void addShoppingCart(ShoppingCartDTO shoppingCartDTO) {
        ShoppingCart shoppingCart = new ShoppingCart();
        BeanUtils.copyProperties(shoppingCartDTO, shoppingCart);
        //只能查询自己的购物车数据
        shoppingCart.setUserId(BaseContext.getCurrentId());

        //判断当前商品是否在购物车中
        List<ShoppingCart> shoppingCartList = shoppingCartMapper.list(shoppingCart);

        if (shoppingCartList != null && shoppingCartList.size() == 1) {
            //如果已经存在，就更新数量，数量加1
            shoppingCart = shoppingCartList.get(0);
            shoppingCart.setNumber(shoppingCart.getNumber() + 1);
            shoppingCartMapper.updateNumberById(shoppingCart);
        } else {
            //如果不存在，插入数据，数量就是1

            //判断当前添加到购物车的是菜品还是套餐
            Long dishId = shoppingCartDTO.getDishId();
            if (dishId != null) {
                //添加到购物车的是菜品
                Dish dish = dishMapper.getById(dishId);
                shoppingCart.setName(dish.getName());
                shoppingCart.setImage(dish.getImage());
                shoppingCart.setAmount(dish.getPrice());
            } else {
                //添加到购物车的是套餐
                Setmeal setmeal = setmealMapper.getById(shoppingCartDTO.getSetmealId());
                shoppingCart.setName(setmeal.getName());
                shoppingCart.setImage(setmeal.getImage());
                shoppingCart.setAmount(setmeal.getPrice());
            }
            shoppingCart.setNumber(1);
            shoppingCart.setCreateTime(LocalDateTime.now());
            shoppingCartMapper.insert(shoppingCart);
        }
    }
}

Mapper

package com.sky.mapper;
@Mapper
public interface ShoppingCartMapper {
    /**
     * 条件查询
     *
     * @param shoppingCart
     * @return
     */
    List<ShoppingCart> list(ShoppingCart shoppingCart);

    /**
     * 更新商品数量
     *
     * @param shoppingCart
     */
    @Update("update shopping_cart set number = #{number} where id = #{id}")
    void updateNumberById(ShoppingCart shoppingCart);

    /**
     * 插入购物车数据
     *
     * @param shoppingCart
     */
    @Insert("insert into shopping_cart (name, user_id, dish_id, setmeal_id, dish_flavor, number, amount, image, create_time) " +
            " values (#{name},#{userId},#{dishId},#{setmealId},#{dishFlavor},#{number},#{amount},#{image},#{createTime})")
    void insert(ShoppingCart shoppingCart);
}

注意！User 需要用到 id，故需要设置回填！！

useGeneratedKeys

<insert id="insert" useGeneratedKeys="true" keyProperty="id">
    insert into user (openid, name, phone, sex, id_number, avatar, create_time)
    values (#{openid}, #{name}, #{phone}, #{sex}, #{idNumber}, #{avatar}, #{createTime})
</insert>

注意！定义了 jwt 拦截器以后要在配置类（WebMvcConfuguration）里注册！！

protected void addInterceptors(InterceptorRegistry registry) {
    log.info("开始注册自定义拦截器...");
    registry.addInterceptor(jwtTokenAdminInterceptor)
            .addPathPatterns("/admin/**")
            .excludePathPatterns("/admin/employee/login");
    registry.addInterceptor(jwtTokenUserInterceptor)
            .addPathPatterns("/user/**")
            .excludePathPatterns("/user/user/login");
}

查询

类似，调用动态查询即可

删除

略

地址簿

接口设计：

新增地址

查询登录用户所有地址

查询默认地址

根据id修改地址

根据id删除地址

根据id查询地址

设置默认地址

类似的增删改查

用户下单

根据接口设计 DTO、VO
Controller

package com.sky.controller.user;

/**
 * 订单
 */
@RestController("userOrderController")
@RequestMapping("/user/order")
@Slf4j
@Api(tags = "C端-订单接口")
public class OrderController {

    @Autowired
    private OrderService orderService;
    @PostMapping("/submit")
    @ApiOperation("用户下单")
    public Result<OrderSubmitVO> submit(@RequestBody OrdersSubmitDTO ordersSubmitDTO) {
        log.info("用户下单：{}", ordersSubmitDTO);
        OrderSubmitVO orderSubmitVO = orderService.submitOrder(ordersSubmitDTO);
        return Result.success(orderSubmitVO);
    } 

}

Service
- 异常处理
- 查询购物车数据
- 构造、添加订单表
- 构造、加入订单明细表
- 清空购物车，封装返回结果

package com.sky.service.impl;

/**
 * 订单
 */
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private OrderDetailMapper orderDetailMapper;
    @Autowired
    private ShoppingCartMapper shoppingCartMapper;
    @Autowired
    private AddressBookMapper addressBookMapper;


    /**
     * 用户下单
     *
     * @param ordersSubmitDTO
     * @return
     */
    @Transactional
    public OrderSubmitVO submitOrder(OrdersSubmitDTO ordersSubmitDTO) {
        //异常情况的处理（收货地址为空、超出配送范围、购物车为空）
        AddressBook addressBook = addressBookMapper.getById(ordersSubmitDTO.getAddressBookId());
        if (addressBook == null) {
            throw new AddressBookBusinessException(MessageConstant.ADDRESS_BOOK_IS_NULL);
        }

        Long userId = BaseContext.getCurrentId();
        ShoppingCart shoppingCart = new ShoppingCart();
        shoppingCart.setUserId(userId);

        //查询当前用户的购物车数据
        List<ShoppingCart> shoppingCartList = shoppingCartMapper.list(shoppingCart);
        if (shoppingCartList == null || shoppingCartList.size() == 0) {
            throw new ShoppingCartBusinessException(MessageConstant.SHOPPING_CART_IS_NULL);
        }

        //构造订单数据
        Orders order = new Orders();
        BeanUtils.copyProperties(ordersSubmitDTO,order);
        order.setPhone(addressBook.getPhone());
        order.setAddress(addressBook.getDetail());
        order.setConsignee(addressBook.getConsignee());
        order.setNumber(String.valueOf(System.currentTimeMillis()));
        order.setUserId(userId);
        order.setStatus(Orders.PENDING_PAYMENT);
        order.setPayStatus(Orders.UN_PAID);
        order.setOrderTime(LocalDateTime.now());

        //向订单表插入1条数据
        orderMapper.insert(order);

        //订单明细数据
        List<OrderDetail> orderDetailList = new ArrayList<>();
        for (ShoppingCart cart : shoppingCartList) {
            OrderDetail orderDetail = new OrderDetail();
            BeanUtils.copyProperties(cart, orderDetail);
            orderDetail.setOrderId(order.getId());
            orderDetailList.add(orderDetail);
        }

        //向明细表插入n条数据
        orderDetailMapper.insertBatch(orderDetailList);

        //清理购物车中的数据
        shoppingCartMapper.deleteByUserId(userId);

        //封装返回结果
        OrderSubmitVO orderSubmitVO = OrderSubmitVO.builder()
                .id(order.getId())
                .orderNumber(order.getNumber())
                .orderAmount(order.getAmount())
                .orderTime(order.getOrderTime())
                .build();

        return orderSubmitVO;
    }
    
}

订单支付

参考支付文档：https://pay.weixin.qq.com/static/product/product_index.shtml

流程：
- 关键是新增了微信后台的接口

订单管理

查询历史订单

写代码之前先想清楚用什么实体类、查什么表什么字段、返回什么！
- 订单表、订单明细表不同 –> 需要先查出订单 id，在去订单明细表中查明细
各个功能的接口要看清楚
接收参数不一定要用实体类接……
- 还要注意实体类之间的继承关系

删除订单

业务逻辑、场景要考虑全面

待支付和待接单状态下，用户可直接取消订单

商家已接单状态下，用户取消订单需电话沟通商家

派送中状态下，用户取消订单需电话沟通商家

如果在待接单状态下取消订单，需要给用户退款

取消订单后需要将订单状态修改为“已取消”

参考 Service

	/**
     * 用户取消订单
     *
     * @param id
     */
    public void userCancelById(Long id) throws Exception {
        // 根据id查询订单
        Orders ordersDB = orderMapper.getById(id);

        // 校验订单是否存在
        if (ordersDB == null) {
            throw new OrderBusinessException(MessageConstant.ORDER_NOT_FOUND);
        }

        //订单状态 1待付款 2待接单 3已接单 4派送中 5已完成 6已取消
        if (ordersDB.getStatus() > 2) {
            throw new OrderBusinessException(MessageConstant.ORDER_STATUS_ERROR);
        }

        Orders orders = new Orders();
        orders.setId(ordersDB.getId());

        // 订单处于待接单状态下取消，需要进行退款
        if (ordersDB.getStatus().equals(Orders.TO_BE_CONFIRMED)) {
            //调用微信支付退款接口
            weChatPayUtil.refund(
                    ordersDB.getNumber(), //商户订单号
                    ordersDB.getNumber(), //商户退款单号
                    new BigDecimal(0.01),//退款金额，单位 元
                    new BigDecimal(0.01));//原订单金额

            //支付状态修改为 退款
            orders.setPayStatus(Orders.REFUND);
        }

        // 更新订单状态、取消原因、取消时间
        orders.setStatus(Orders.CANCELLED);
        orders.setCancelReason("用户取消");
        orders.setCancelTime(LocalDateTime.now());
        orderMapper.update(orders);
    }

再来一单

再来一单就是将原订单中的商品重新加入到购物车中

Service
- 注意看对象转换的 stream 流

	/**
     * 再来一单
     *
     * @param id
     */
    public void repetition(Long id) {
        // 查询当前用户id
        Long userId = BaseContext.getCurrentId();

        // 根据订单id查询当前订单详情
        List<OrderDetail> orderDetailList = orderDetailMapper.getByOrderId(id);

        // 将订单详情对象转换为购物车对象
        List<ShoppingCart> shoppingCartList = orderDetailList.stream().map(x -> {
            ShoppingCart shoppingCart = new ShoppingCart();

            // 将原订单详情里面的菜品信息重新复制到购物车对象中
            BeanUtils.copyProperties(x, shoppingCart, "id");
            shoppingCart.setUserId(userId);
            shoppingCart.setCreateTime(LocalDateTime.now());

            return shoppingCart;
        }).collect(Collectors.toList());

        // 将购物车对象批量添加到数据库
        shoppingCartMapper.insertBatch(shoppingCartList);
    }

商家搜索

SQL 中，>= 会和标签混淆，故要用 > 代替

接单、拒单、派送

简化为修改 status 字段，并且要处理退款逻辑
Service

	/**
     * 拒单
     *
     * @param ordersRejectionDTO
     */
    public void rejection(OrdersRejectionDTO ordersRejectionDTO) throws Exception {
        // 根据id查询订单
        Orders ordersDB = orderMapper.getById(ordersRejectionDTO.getId());

        // 订单只有存在且状态为2（待接单）才可以拒单
        if (ordersDB == null || !ordersDB.getStatus().equals(Orders.TO_BE_CONFIRMED)) {
            throw new OrderBusinessException(MessageConstant.ORDER_STATUS_ERROR);
        }

        //支付状态
        Integer payStatus = ordersDB.getPayStatus();
        if (payStatus == Orders.PAID) {
            //用户已支付，需要退款
            String refund = weChatPayUtil.refund(
                    ordersDB.getNumber(),
                    ordersDB.getNumber(),
                    new BigDecimal(0.01),
                    new BigDecimal(0.01));
            log.info("申请退款：{}", refund);
        }

        // 拒单需要退款，根据订单id更新订单状态、拒单原因、取消时间
        Orders orders = new Orders();
        orders.setId(ordersDB.getId());
        orders.setStatus(Orders.CANCELLED);
        orders.setRejectionReason(ordersRejectionDTO.getRejectionReason());
        orders.setCancelTime(LocalDateTime.now());

        orderMapper.update(orders);
    }

距离检测

调用百度地图的接口，读文档即可

设置地址、规划路径、判断

添加到 ServiceImpl

    @Value("${sky.shop.address}")
    private String shopAddress;

    @Value("${sky.baidu.ak}")
    private String ak;

/**
     * 检查客户的收货地址是否超出配送范围
     * @param address
     */
    private void checkOutOfRange(String address) {
        Map map = new HashMap();
        map.put("address",shopAddress);
        map.put("output","json");
        map.put("ak",ak);

        //获取店铺的经纬度坐标
        String shopCoordinate = HttpClientUtil.doGet("https://api.map.baidu.com/geocoding/v3", map);

        JSONObject jsonObject = JSON.parseObject(shopCoordinate);
        if(!jsonObject.getString("status").equals("0")){
            throw new OrderBusinessException("店铺地址解析失败");
        }

        //数据解析
        JSONObject location = jsonObject.getJSONObject("result").getJSONObject("location");
        String lat = location.getString("lat");
        String lng = location.getString("lng");
        //店铺经纬度坐标
        String shopLngLat = lat + "," + lng;

        map.put("address",address);
        //获取用户收货地址的经纬度坐标
        String userCoordinate = HttpClientUtil.doGet("https://api.map.baidu.com/geocoding/v3", map);

        jsonObject = JSON.parseObject(userCoordinate);
        if(!jsonObject.getString("status").equals("0")){
            throw new OrderBusinessException("收货地址解析失败");
        }

        //数据解析
        location = jsonObject.getJSONObject("result").getJSONObject("location");
        lat = location.getString("lat");
        lng = location.getString("lng");
        //用户收货地址经纬度坐标
        String userLngLat = lat + "," + lng;

        map.put("origin",shopLngLat);
        map.put("destination",userLngLat);
        map.put("steps_info","0");

        //路线规划
        String json = HttpClientUtil.doGet("https://api.map.baidu.com/directionlite/v1/driving", map);

        jsonObject = JSON.parseObject(json);
        if(!jsonObject.getString("status").equals("0")){
            throw new OrderBusinessException("配送路线规划失败");
        }

        //数据解析
        JSONObject result = jsonObject.getJSONObject("result");
        JSONArray jsonArray = (JSONArray) result.get("routes");
        Integer distance = (Integer) ((JSONObject) jsonArray.get(0)).get("distance");

        if(distance > 5000){
            //配送距离超过5000米
            throw new OrderBusinessException("超出配送范围");
        }
    }

然后在 OrderServiceImpl 的 submitOrder 方法中调用上面的校验方法即可

SpringTask - 订单计时

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

Cron 表达式

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

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

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

**举例：**2022年10月12日上午9点整对应的cron表达式为：0 0 9 12 10 ? 2022

说明：一般日和周的值不同时设置，其中一个设置，另一个用？表示。

通配符：

* 表示所有值；

? 表示未说明的值，即不关心它为何值；

- 表示一个指定的范围；

, 表示附加一个可能值；

/ 符号前表示开始时间，符号后表示每次递增的值；

使用步骤
1. 导入 maven 坐标，spring-context
2. 启动类添加注解 @EnableScheduling 开启任务调度
3. 自定义定时任务类
定时任务类

package com.sky.task;
@Component
@Slf4j
public class OrderTask {

    @Autowired
    private OrderMapper orderMapper;

    /**
     * 处理支付超时订单
     */
    @Scheduled(cron = "0 * * * * ?")
    public void processTimeoutOrder(){
        log.info("处理支付超时订单：{}", new Date());

        LocalDateTime time = LocalDateTime.now().plusMinutes(-15);

        // select * from orders where status = 1 and order_time < 当前时间-15分钟
        List<Orders> ordersList = orderMapper.getByStatusAndOrdertimeLT(Orders.PENDING_PAYMENT, time);
        if(ordersList != null && ordersList.size() > 0){
            ordersList.forEach(order -> {
                order.setStatus(Orders.CANCELLED);
                order.setCancelReason("支付超时，自动取消");
                order.setCancelTime(LocalDateTime.now());
                orderMapper.update(order);
            });
        }
    }
    /**
     * 处理“派送中”状态的订单
     */
    @Scheduled(cron = "0 0 1 * * ?")
    public void processDeliveryOrder(){
        log.info("处理派送中订单：{}", new Date());
        // select * from orders where status = 4 and order_time < 当前时间-1小时
        LocalDateTime time = LocalDateTime.now().plusMinutes(-60);
        List<Orders> ordersList = orderMapper.getByStatusAndOrdertimeLT(Orders.DELIVERY_IN_PROGRESS, time);

        if(ordersList != null && ordersList.size() > 0){
            ordersList.forEach(order -> {
                order.setStatus(Orders.COMPLETED);
                orderMapper.update(order);
            });
        }
    }
}

Mapper

1
2
3

	//根据状态和下单时间查询订单
    @Select("select * from orders where status = #{status} and order_time < #{orderTime}")
    List<Orders> getByStatusAndOrdertimeLT(Integer status, LocalDateTime orderTime);

Websocket

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

WebSocket缺点：

服务器长期维护长连接需要一定的成本

各个浏览器支持程度不一

WebSocket 是长连接，受网络限制比较大，需要处理好重连

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

maven 坐标

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

服务组件定义

package com.sky.websocket;

/**
 * WebSocket服务
 */
@Component
@ServerEndpoint("/ws/{sid}")
public class WebSocketServer {

    //存放会话对象
    private static Map<String, Session> sessionMap = new HashMap();

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("sid") String sid) {
        System.out.println("客户端：" + sid + "建立连接");
        sessionMap.put(sid, session);
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, @PathParam("sid") String sid) {
        System.out.println("收到来自客户端：" + sid + "的信息:" + message);
    }

    /**
     * 连接关闭调用的方法
     *
     * @param sid
     */
    @OnClose
    public 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 的服务端组件

package com.sky.config;

/**
 * WebSocket配置类，用于注册WebSocket的Bean
 */
@Configuration
@EnableWebsocket
public class WebSocketConfiguration {

    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

}

Impl 里引用

        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));

催单

类似

WebSocket 不知道为什么连不上……

Apache Echarts、数据统计

Apache ECharts 是一款基于 Javascript 的数据可视化图表库，提供直观，生动，可交互，可个性化定制的数据可视化图表。

营业额统计

**注意：**具体返回数据一般由前端来决定，前端展示图表，具体折现图对应数据是什么格式，是有固定的要求的。

Controller
- 注意：@DateTimeFormat(pattern = "yyyy-MM-dd") 指定格式

package com.sky.controller.admin;

/**
 * 报表
 */
@RestController
@RequestMapping("/admin/report")
@Slf4j
@Api(tags = "统计报表相关接口")
public class ReportController {

    @Autowired
    private ReportService reportService;

    /**
     * 营业额数据统计
     */
    @GetMapping("/turnoverStatistics")
    @ApiOperation("营业额数据统计")
    public Result<TurnoverReportVO> turnoverStatistics(
            @DateTimeFormat(pattern = "yyyy-MM-dd")
                    LocalDate begin,
            @DateTimeFormat(pattern = "yyyy-MM-dd")
                    LocalDate end) {
        return Result.success(reportService.getTurnover(begin, end));
    }

}

Service
- 用 map 来传递参数

package com.sky.service.impl;

@Service
@Slf4j
public class ReportServiceImpl implements ReportService {

    @Autowired
    private OrderMapper orderMapper;

    /**
     * 根据时间区间统计营业额
     * @param begin
     * @param end
     * @return
     */
    public TurnoverReportVO getTurnover(LocalDate begin, LocalDate end) {
        List<LocalDate> dateList = new ArrayList<>();
        dateList.add(begin);

        while (!begin.equals(end)){
            begin = begin.plusDays(1);//日期计算，获得指定日期后1天的日期
            dateList.add(begin);
        }

        List<Double> turnoverList = new ArrayList<>();
        for (LocalDate date : dateList) {
            LocalDateTime beginTime = LocalDateTime.of(date, LocalTime.MIN);
            LocalDateTime endTime = LocalDateTime.of(date, LocalTime.MAX);
            Map map = new HashMap();
            map.put("status", Orders.COMPLETED);
            map.put("begin",beginTime);
            map.put("end", endTime);
            Double turnover = orderMapper.sumByMap(map);
            turnover = turnover == null ? 0.0 : turnover;
            turnoverList.add(turnover);
        }

        //数据封装
        return TurnoverReportVO.builder()
                .dateList(StringUtils.join(dateList,","))
                .turnoverList(StringUtils.join(turnoverList,","))
                .build();
    }
}

Mapper
- 接收 map 直接取就可以

    <select id="sumByMap" resultType="java.lang.Double">
        select sum(amount) from orders
        <where>
            <if test="status != null">
                and status = #{status}
            </if>
            <if test="begin != null">
                and order_time &gt;= #{begin}
            </if>
            <if test="end != null">
                and order_time &lt;= #{end}
            </if>
        </where>
    </select>

用户统计

Service
- 自定义方法来计算总数
- 返回的是字符串，还要进行处理

@Override
public UserReportVO getUserStatistics(LocalDate begin, LocalDate end) {
    List<LocalDate> dateList = new ArrayList<>();
    dateList.add(begin);

    while (!begin.equals(end)){
        begin = begin.plusDays(1);
        dateList.add(begin);
    }
    List<Integer> newUserList = new ArrayList<>(); //新增用户数
    List<Integer> totalUserList = new ArrayList<>(); //总用户数

    for (LocalDate date : dateList) {
        LocalDateTime beginTime = LocalDateTime.of(date, LocalTime.MIN);
        LocalDateTime endTime = LocalDateTime.of(date, LocalTime.MAX);
        //新增用户数量 select count(id) from user where create_time > ? and create_time < ?
        Integer newUser = getUserCount(beginTime, endTime);
        //总用户数量 select count(id) from user where  create_time < ?
        Integer totalUser = getUserCount(null, endTime);

        newUserList.add(newUser);
        totalUserList.add(totalUser);
    }

    return UserReportVO.builder()
            .dateList(StringUtils.join(dateList,","))
            .newUserList(StringUtils.join(newUserList,","))
            .totalUserList(StringUtils.join(totalUserList,","))
            .build();
}

/**
 * 根据时间区间统计用户数量
 * @param beginTime
 * @param endTime
 * @return
 */
private Integer getUserCount(LocalDateTime beginTime, LocalDateTime endTime) {
    Map map = new HashMap();
    map.put("begin",beginTime);
    map.put("end", endTime);
    return userMapper.countByMap(map);
}

Mapper

<select id="countByMap" resultType="java.lang.Integer">
        select count(id) from user
        <where>
            <if test="begin != null">
                and create_time &gt;= #{begin}
            </if>
            <if test="end != null">
                and create_time &lt;= #{end}
            </if>
        </where>
</select>

订单统计

类似

销量排行榜

Mapper
- 只返回前十条数据即可，用 limit 限制

<select id="getSalesTop10" resultType="com.sky.dto.GoodsSalesDTO">
    select od.name name,sum(od.number) number from order_detail od ,orders o
    where od.order_id = o.id
    and o.status = 5
    <if test="begin != null">
        and order_time &gt;= #{begin}
    </if>
    <if test="end != null">
        and order_time &lt;= #{end}
    </if>
    group by name
    order by number desc
    limit 0, 10
</select>

Apache POI

Apache POI 是一个处理Miscrosoft Office各种文件格式的开源项目。简单来说就是，我们可以使用 POI 在 Java 程序中对Miscrosoft Office各种文件进行读写操作。一般情况下，POI 都是用于操作 Excel 文件。

坐标

<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>3.16</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>3.16</version>
</dependency>

数据处理演示

package com.sky.test;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class POITest {

    /**
     * 基于POI向Excel文件写入数据
     * @throws Exception
     */
    public static void write() throws Exception{
        //在内存中创建一个Excel文件对象
        XSSFWorkbook excel = new XSSFWorkbook();
        //创建Sheet页
        XSSFSheet sheet = excel.createSheet("itcast");

        //在Sheet页中创建行，0表示第1行
        XSSFRow row1 = sheet.createRow(0);
        //创建单元格并在单元格中设置值，单元格编号也是从0开始，1表示第2个单元格
        row1.createCell(1).setCellValue("姓名");
        row1.createCell(2).setCellValue("城市");

        XSSFRow row2 = sheet.createRow(1);
        row2.createCell(1).setCellValue("张三");
        row2.createCell(2).setCellValue("北京");

        XSSFRow row3 = sheet.createRow(2);
        row3.createCell(1).setCellValue("李四");
        row3.createCell(2).setCellValue("上海");

        FileOutputStream out = new FileOutputStream(new File("D:\\itcast.xlsx"));
        //通过输出流将内存中的Excel文件写入到磁盘上
        excel.write(out);

        //关闭资源
        out.flush();
        out.close();
        excel.close();
    }
    public static void main(String[] args) throws Exception {
        write();
    }
}

数据读取演示

package com.sky.test;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class POITest {
    /**
     * 基于POI读取Excel文件
     * @throws Exception
     */
    public static void read() throws Exception{
        FileInputStream in = new FileInputStream(new File("D:\\itcast.xlsx"));
        //通过输入流读取指定的Excel文件
        XSSFWorkbook excel = new XSSFWorkbook(in);
        //获取Excel文件的第1个Sheet页
        XSSFSheet sheet = excel.getSheetAt(0);

        //获取Sheet页中的最后一行的行号
        int lastRowNum = sheet.getLastRowNum();

        for (int i = 0; i <= lastRowNum; i++) {
            //获取Sheet页中的行
            XSSFRow titleRow = sheet.getRow(i);
            //获取行的第2个单元格
            XSSFCell cell1 = titleRow.getCell(1);
            //获取单元格中的文本内容
            String cellValue1 = cell1.getStringCellValue();
            //获取行的第3个单元格
            XSSFCell cell2 = titleRow.getCell(2);
            //获取单元格中的文本内容
            String cellValue2 = cell2.getStringCellValue();

            System.out.println(cellValue1 + " " +cellValue2);
        }

        //关闭资源
        in.close();
        excel.close();
    }

    public static void main(String[] args) throws Exception {
        read();
    }
}

后续代码类似，要用到的时候再学吧，完结。

Mybatis

Sun, 12 Oct 2025 00:00:00 +0000

Mybatis

介绍

轻量级，性能出色
封装 JDBC
SQL 和 Java 编码分开，功能边界清晰。Java 代码专注业务、SQL 语句专注数据
官网：https://mybatis.org/mybatis-3/zh/#

使用

创建SpringBoot工程、引入Mybatis相关依赖
准备数据库表即对应实体类
配置 Mybatis（在application.properties中数据库连接信息）

编写 Mybatis 程序：编写 Mybatis 的持久层接口，定义 SQL（注解/XML）

@Mapper：应用程序在运行时，会自动的为该接口创建一个实现类对象（代理对象），并且会自动将该实现类对象存入I0C容器

辅助配置

定义注解的语句为 MySQL 语法
IDEA 连接数据库
日志

1
2

#配置mybatis的日志输出
mybatis.configuration.logimpl=org.apache.ibatis.logging.stdout.StdoutImpl

数据库连接池

数据库连接池是个容器，负责分配、管理数据库连接（Connection）
- 资源重用
允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个
- 提升系统响应速度
释放空闲时间超过最大空闲时间的连接，来避免因为没有释放连接而引起的数据库连接遗漏
- 避免数据库连接遗漏

// 引入德鲁伊连接池
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.19</version>
</dependency>

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

底层实现 DataSource 接口

操作

新增

1
2

@Insert("insert insert(username,password,name,age) values (#{username},#{password},#{name},#{age})") // 写的是对象属性名
public void insert(User user2);

删除

1
2
3

@Delete("delete from user where id = #{id}")
public Integer deleteById(Integer id);
// 可以返回影响的行数

修改

1
2

@Update("update user set username=#{username}, password=#{password}, name=#{name}, age=#{age} where id=#{id}")
public void update(User user);

查询

1
2

@Select("select * from user where username=#{username} and password=#{password}")
public User findByUsernameAndPassword(@Param("username") String username, @Param("password") String password);

有多个参数时，需要 @param 注解

XML 映射配置

默认规则：

XML 映射文件的名称与 Mapper 接口名称一致，并且将 XML 映射文件和 Mapper 接口放置在相同包下（ resource 中同包同名）。
XML 映射文件的 namespace 属性为 Mapper 接口全限定名一致。

<mapper namespace="com.itheima.mapper.UserMapper">
    <select id="findAll" resultType="com.itheima.pojo.User">
    	select id，username，password，name，age from user
    </select>
</mapper>

XML 映射文件中 sql 语句的 id 与 Mapper 接口中的方法名一致，并保持返回类型一致。

动态 SQL

IF

<select id="selectAllWebsite" resultMap="myResult">
    select id,name,url from website where 1=1
    <if test="name != null">
        AND name like #{name}
    </if>
    <if test="url!= null">
        AND url like #{url}
    </if>
</select>

choose-when-otherwise

<mapper namespace="net.biancheng.mapper.WebsiteMapper">
    <select id="selectWebsite"
            parameterType="net.biancheng.po.Website"
            resultType="net.biancheng.po.Website">
        SELECT id,name,url,age,country
        FROM website WHERE 1=1
        <choose>
            <when test="name != null and name !=''">
                AND name LIKE CONCAT('%',#{name},'%')
            </when>
            <when test="url != null and url !=''">
                AND url LIKE CONCAT('%',#{url},'%')
            </when>
            <otherwise>
                AND age is not null
            </otherwise>
        </choose>
    </select>
</mapper>

注意：AND 不能省！

WHERE

where 会检索语句，它会将 where 后的第一个 SQL 条件语句的 AND 或者 OR 关键词去掉。

<select id="selectWebsite" resultType="net.biancheng.po.Website">
    select id,name,url from website
    <where>
        <if test="name != null">
            AND name like #{name}
        </if>
        <if test="url!= null">
            AND url like #{url}
        </if>
    </where>
</select>

SET

set 标签可以为 SQL 语句动态的添加 set 关键字，剔除追加到条件末尾多余的逗号

<update id="updateWebsite"
            parameterType="net.biancheng.po.Website">
        UPDATE website
        <set>
            <if test="name!=null">name=#{name}</if>
            <if test="url!=null">url=#{url}</if>
        </set>
        WHERE id=#{id}
   </update>

foreach

foreach 标签用于循环语句，它很好的支持了数据和 List、set 接口的集合，并对此提供遍历的功能

1
2
3

<foreach item="item" index="index" collection="list|array|map key" open="(" separator="," close=")">
    参数值
</foreach>

foreach 标签主要有以下属性，说明如下。

item：表示集合中每一个元素进行迭代时的别名。
index：指定一个名字，表示在迭代过程中每次迭代到的位置。
open：表示该语句以什么开始（既然是 in 条件语句，所以必然以(开始）。
separator：表示在每次进行迭代之间以什么符号作为分隔符（既然是 in 条件语句，所以必然以,作为分隔符）。
close：表示该语句以什么结束（既然是 in 条件语句，所以必然以)开始）。

使用 foreach 标签时，最关键、最容易出错的是 collection 属性，该属性是必选的，但在不同情况下该属性的值是不一样的，主要有以下 3 种情况：

如果传入的是单参数且参数类型是一个 List，collection 属性值为 list。
如果传入的是单参数且参数类型是一个 array 数组，collection 的属性值为 array。
如果传入的参数是多个，需要把它们封装成一个 Map，当然单参数也可以封装成 Map。Map 的 key 是参数名，collection 属性值是传入的 List 或 array 对象在自己封装的 Map 中的 key。

trim

trim 一般用于去除 SQL 语句中多余的 AND 关键字、逗号，或者给 SQL 语句前拼接 where、set 等后缀，可用于选择性插入、更新、删除或者条件查询等操作

1
2
3

<trim prefix="前缀" suffix="后缀" prefixOverrides="忽略前缀字符" suffixOverrides="忽略后缀字符">
    SQL语句
</trim>

bind

bind 标签可以通过 OGNL 表达式自定义一个上下文变量

<select id="selectWebsite" resultType="net.biancheng.po.Website">
    <bind name="pattern" value="'%'+_parameter+'%'" />
    SELECT id,name,url,age,country
    FROM website
    WHERE name like #{pattern}
</select>

实现分页

使用 limit：

<select id="selectWebsite" resultType="net.biancheng.po.Website">
    SELECT id,name,url,age,country
    FROM website
    <trim prefix="where" prefixOverrides="and">
        <if test="site.name != null and site.name !=''">
            AND name LIKE CONCAT ('%',#{site.name},'%')
        </if>
        <if test="site.url!= null and site.url !=''">
            AND url LIKE CONCAT ('%',#{site.url},'%')
        </if>
        ORDER BY id limit #{from},#{pageSize}
    </trim>
</select>

逆向工程

导入依赖：

<dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.4.0</version>
</dependency>

config 文件夹下创建 genertorConfig.xml 文件，用于配置及指定数据库及表等

<?xml version="1.0" encoding="UTF-8"?>
                    <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <context id="DB2Tables" targetRuntime="MyBatis3">
        <commentGenerator>
            <!-- 是否去除自动生成的注释 -->
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!-- Mysql数据库连接的信息：驱动类、连接地址、用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/test" userId="root"
                        password="root" />
        <!-- 默认为false，把JDBC DECIMAL 和NUMERIC类型解析为Integer，为true时 把JDBC DECIMAL 和NUMERIC类型解析为java.math.BigDecimal -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>
        <!-- targetProject：生成POJO类的位置 -->
        <javaModelGenerator
                targetPackage="net.biancheng.pojo" targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- targetProject：mapper映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="net.biancheng.mapper"
                         targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>
        <!-- targetProject：mapper接口生成的的位置 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="net.biancheng.mapper" targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>
        <!-- 指定数据表 -->
        <table tableName="website"></table>
        <table tableName="student"></table>
        <table tableName="studentcard"></table>
        <table tableName="user"></table>
    </context>
</generatorConfiguration>

创建 GeneratorSqlmap 类执行生成代码

public class GeneratorSqlmap {
    public void generator() throws Exception {
        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        // 指定配置文件
        File configFile = new File("./config/generatorConfig.xml");
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
        myBatisGenerator.generate(null);
    }
    // 执行main方法以生成代码
    public static void main(String[] args) {
        try {
            GeneratorSqlmap generatorSqlmap = new GeneratorSqlmap();
            generatorSqlmap.generator();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

SpringBoot

Sun, 12 Oct 2025 00:00:00 +0000

SpringBoot

简介

设计目的：简化Spring应用的初始搭建以及开发过程

Spring 程序缺点

依赖设置繁琐
- 去除 spring-web 和 spring-webmvc 坐标
配置繁琐

SpringBoot 核心功能及优点：

起步依赖（简化依赖配置）
自动配置
辅助功能（内置服务器）

parent 管理版本

由 parent 帮助开发者统一的进行各种技术的版本管理

只控制版本，不负责导入坐标

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.4</version>
</parent>

starter 依赖组合

starter定义了使用某种技术时对于依赖的固定搭配格式，使用starter可以帮助开发者减少依赖配置。

引导类

这个类在SpringBoot程序中是所有功能的入口，称为引导类，最典型的特征就是当前类上方声明了一个注解 @SpringBootApplication。

用于启动程序
创建并初始化 Spring 容器

内嵌 Tomcat

整合到了：

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

基础配置

默认配置文件：application.properties，配置指定属性即可

配置文件间的加载优先级 properties（最高）> yml > yaml（最低）
不同配置文件中相同配置按照加载优先级相互覆盖，不同配置文件中不同配置全部保留

指定SpringBoot配置文件

Setting → Project Structure → Facets
选中对应项目/工程
Customize Spring Boot
选择配置文件

YML 数据读取

使用Spring中的注解

@Value读取单个数据

1
2

@Value("${server.port}")
private int port;

使用默认配置类

SpringBoot 提供了一个对象，能够把所有的数据都封装到这一个对象中，这个对象叫做 Environment，使用自动装配注解可以将所有的yaml数据封装到这个对象中

@Autowired
private Environment env;
...
env.getProperty("...");

使用自定义配置类

SpringBoot 也提供了可以将一组 yaml 对象数据封装一个 Java 对象的操作

enterprise 指定加载某一组 yaml 配置

@Component
@ConfigurationProperties(prefix = "enterprise")
public class Enterprise {
private String name;
private Integer age;
private String[] subject;
}

数据引用

baseDir: /usr/local/fire
center:
    dataDir: ${baseDir}/data
    tmpDir: ${baseDir}/tmp
    logDir: ${baseDir}/log
    msgDir: ${baseDir}/msgDir

SSMP 整合

JUnit

@SpringBootTest(classes = Springboot04JunitApplication.class)
// @ContextConfiguration(classes = Springboot04JunitApplication.class)
class Springboot04JunitApplicationTests {
    //注入你要测试的对象
    @Autowired
    private BookDao bookDao;
    @Test
    void contextLoads() {
        //执行要测试的对象对应的方法
        bookDao.save();
        System.out.println("two...");
    }
}

Mybatis

在配置、引入依赖时已经整合

@Mapper
public interface BookDao {
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);
}

#2.配置相关信息
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=Asia/Shanghai
    username: root
    password: root

Mybatis-plus

需要用阿里云的 url 导入

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

配置所有数据库表名的前缀名：

mybatis-plus:
  global-config:
    db-config:
      table-prefix: tbl_		#设置所有表的通用前缀名称为tbl_

其他

Lombok

简化POJO实体类开发，SpringBoot 目前默认集成了 lombok 技术

可以通过一个注解@Data完成一个实体类对应的getter，setter，toString，equals，hashCode等操作的快速添加

<dependencies>
    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

SpringMVC

Sun, 12 Oct 2025 00:00:00 +0000

Spring MVC

主要覆盖表述层（Controller）

简化接收前端参数、响应前端数据

工作流程

接收数据

路径设置

RequestMapping("path") 注解

GetMapping("...")
……

接收参数

param

参数名和 param 名相同，直接接收
注解接收 RequestParam(value = "...",required = "...")
多字符串，直接用集合接收
- 必须要注解
封装为对象接收
- 属性名必须等于参数名

路径传参

@RequestMapping("{account}/{password}")
public String login(@PathVariable String account,@PathVariable String password){
	return null;
}

Json 参数

定义接收的实体类
用 RequestBody 接收

原生 Java 不支持接收 Json

handlerMapper 中配置 Json 转换器，EnableWebMVC
- 用于给RequestMappingHandLerMapping、RequestMappingHandLerAdapter 添加Json处理器

@CookieValue

存 Cookie：

public String save(HttpServletResponse response){
    Cookie cookie = new Cookie(name:"cookiellame", value:"root");
    response.addCookie(cookie);
    return "ok";
}

请求头

@RequestHeader

原生 API 对象

共享域对象

Session、ServletContext

原生获取

SpringMVC 提供

model modeLMap map modeLAndView

响应数据

前后端不分离

不用 ResponseBody，配置 Jsp 模板地址，返回

return "forward:/jsp/..."

返回 Json

直接 return User，会被自动封装

需要 @ResponseBody 注解，不会走视图转换器
- ResponseBody + Controller = RestController

返回静态资源

需要配置 Config

//开启静态资源查找
//dispatcherServLet->handLerMapping找有没有对应的handLer->【没有->找有没有静态资源】

@Override
public void configurelDefaultServletHandling(DefaultServletHandlerConfigurer configurer）{
    configurer.enable();
}

Restful 风格

规定路径设计方式、参数传递格式、选择请求方式

风格特点

每一个URI代表1种资源；
客户端使用GET、POST、PUT、DELETE4个表示操作方式的动词对服务端资源进行操作：GET用来获取资源，POST用来新建资源（也可以用于更新资源），PUT用来更新资源，DELETE用来删除资源；
资源的表现形式是XML或者JSON；
客户端与服务端之间的交互在请求之间是无状态的，从客户端到服务端的每个请求都必须包含理解请求所必需的信息。

用请求方式 + URI 来表示操作、对象
- 路径传参：对应单一资源，如 id

其他扩展

全局异常处理

异常处理分类

编程式：单独细化处理
声明式：统一处理

//全局异常发生，会走此类写的handLer！
//@ControLLerAdvice//可以返回逻辑视图转发和重定向的！
no usages
@RestControllerAdvice//@ResponseBody直接返回json字符串
public class GlobalExceptionHandler{
    //发生异常->ControLLerAdvice注解的类型->@ExceptionHandLer（指定的异常）->handLer
    no usages
    @ExceptionHandler(ArithmeticException.class)
    public ObjectArithmeticExceptionHandler(ArithmeticException e){
    //自定义处理异常即可handLer
    }

拦截器

HandlerIntercepter

拦截器 Springmvc VS 过滤器 javaWeb:

相似点
- 拦截: 必须先把请求拦住，才能执行后续操作
- 过滤: 拦截器或过滤器存在的意义就是对请求进行统一处理
- 放行: 对请求执行了必要操作后，放请求过去，让它访问原本想要访问的资源
不同点
- 工作平台不同
  - 过滤器工作在 Servlet 容器中
  - 拦截器工作在 SpringMVC 的基础上
- 拦截的范围
  - 过滤器: 能够拦截到的最大范围是整个 Web 应用
  - 拦截器: 能够拦截到的最大范围是整个 SpringMVC 负责的请求
- IOC 容器支持
  - 过滤器: 想得到 IOC 容器需要调用专门的工具方法，是间接的
  - 拦截器: 它自己就在 IOC 容器中，所以可以直接从 IOC 容器中装配组件，也就是可以直接得到 IOC 容器的支持

使用

实现 HandlerInterceptor 接口
修改类配置拦截器 SpringMvcConfig impLements WebMvcConfigurer

// 配置拦截
publicvoid addInterceptors(InterceptorRegistry registry){
    //配置方案1：拦截全部请求
    registry.addInterceptor(new MyInterceptor());
    
    //配置方案2：指定地址拦截.addPathPatterns（"/user/data");；
    //*任意一层字符串**任意多层字符串
    registry.addInterceptor(new MyInterceptor())
    .addPathPatterns("/user/**");
    
    //配置方案3：排除拦截排除的地址应该在拦截地址内部！
    registry.addInterceptor(new MyInterceptor())
    .addPathPatterns("/user/**").excludePathPatterns("/user/data1");
}

参数校验

hybernate 框架实现

非空校验 @Validate

NotNull：包装类型不为 null
NotEmpty：集合类型长度大于 0
NotBlank：字符串不为 null，且不为 ""

通过 BindingResult 绑定错误，不直接返回

Spring

Fri, 10 Oct 2025 00:00:00 +0000

概述

Spring FrameWork 特点

非侵入式
控制反转
面向切面编程
容器化管理
组件化
一站式

IOC 控制反转

概述

Inversion of Control

用容器管理所有 Java 对象的实例化和初始化，控制依赖关系，称为 SpringBean

xml 配置文件
抽象 BeanDefinitionReader 读取
装配，读取信息，利用反射实例化
- BeanFactory、ApplicationContex
用 Context.getBean("...") 来获取

基于 xml 管理

获取 Bean

xml 定义

`1`	`<bean id="helloworldone" class="ccom.atguigu.spring6.bean.He11owor1d"></bean>`

Context.getBean("...") 获取

1
2

//根据类型获取接口对应bean
UserDaouserDao= context.getBean(UserDao.class);

依赖注入

set 注入
- xml 中进行配置
构造器注入
- <constructor-arggname="bnamevalue="java开发"></constructor-arg>

是不是只能注入默认值？

特殊值注入
- 对象中注入其他对象（表示关系）
  - 法一：引入外部/内部类，bean 标签中嵌套 ref
  - 法二：级联赋值，直接嵌套对所注入的对象的属性的赋值
数组类型注入
- 配置中的 <array>标签
List 集合属性注入
- 先定义 Bean，再用 <list> 标签注入
map 集合属性注入
- <map><entry><key> 标签
引用集合类型（？util 整合）
p 命名空间注入
- 防止 7.中的util 的名称冲突

引入外部属性

创建外部属性文件 .property

xml 中配置读取即可

作用域

配置 scope 来指定作用域

singleton 单例
prototype 多例，每次获取时创建

生命周期

FactoryBean 机制

根据接口实现 FactoryBean，自定义 getObjet（）方法返回值，来控制产生的对象

用于整合第三方框架(?)

基于注解注解管理

开启组件扫描

1
2

<!--开启组件扫描功能-->
<context:component-scanbase-package="com.atguigu.spring6"></context:component-scan>

注解说明

@Autowired 注入

set 方法注入

@Autowired
public void setUserService(UserService userService) {
this.userService = userService;
}

构造方法注入
形参上注入
根据名称进行注入（而非接口名）
- 一个接口有多个实现类时 @Qualifier

@Resource 注入

默认根据 name 标签进行注入

全注解开发

无需使用配置文件，写一个配置类替代配置文件

@configuration
//@componentscan({"com.atguigu.spring6.controller"
//"com.atguigu.spring6.service","com.atguigu.spring6.dao"})
@componentscan("com.atguigu.spring6")
public class Spring6config {}

手写 IoC

反射

获取对象：

public void test01(）{
    //1 类名.cLass
    Class clazz1 = Car.class;
    //2 对象.getCLass()
    Class clazz2 =newv Car().getclass();
    //3 CLass.forName（"全路径"）
    Class clazz3 = Class.forName( className: "......");
    //实例化
    Object o = clazz3.getDeclaredConstructor().newInstance();
}

获取方法：

public void test02() throws Exception {
    Classclazz = Car.class;
    1/获取所有构造
    Constructor[]] constructors = clazz.getconstructors();
    for (Constructor c:constructors) {......}
    // 方法名：c.getname() 参数个数(public)：c.getConstructor()
    // 参数个数(所有)：c.getDeclaredConstructor()
}

构造对象：

1
2
3

Constructorc2=（clazz.getDeclaredConstructor(......)
c2.setAccessible(true);
Car car2 = (Car)c2.newInstance( ..initargs: "捷达"， 15,“白色");

获取属性：

Classclazz = Car.class;
//获取所有pubLic属性
Field[] fields = clazz.getFields();
//获取所有属性（包含私有属性）
Field[] fields = clazz.getDeclaredFields();
for (Field field:fields）{
System.out.println(field.getName());
}

操作方法

private方法
Method[] methodsAll = clazz.getDeclaredMethods();
for (Method m:methodsAll) {
//执行方法 runI
if(m.getName().equals("run")) {
    m.setAccessible(true);
    m.invoke(car) ;
}

实现

步骤

创建注解：@Bean创建对象、@Di属性注入
创建bean容器接口：ApplicationContext
定义方法，返回对象
实现bean容器接口：返回对象、根据包规则加载bean

配置

@Bean

@Target(ElementType.TYPE) // 目标
@Retention(RetentionPolicy.RUNTIME) // 运行范围
public @interface Bean
}

@Di

ApplicationCotext 接口

//创建有参数构造，传递包路径，设置包扫描规则
//扫描当前包及其子包，哪个类有@Bean注解，把这个类通过反射实例化
public AnnotationApplicationContext implement ApplicationContext(String basePackage) {
	// 路径转义,点替换为斜杠
    String packagePath = basePackage.replaceAll("\\.","\\\\")
    // 获取绝对路径
    Enumeration<URL> urls = Thread.currentThread().getContextClassLoader()·getResources(packagePath);
    while(urls.hasMoreElements()) {
        URL url = urls.nextElement();
        String filePath= URLDecoder.decode(url.getFile(), "utf-8");
        loadBean(new File(filePath)); // 实现 loadBean 方法
    }
    
    loadDi(); // 实现 loadDi 方法
}

	public static void loadBean(File file){
        // 1.判断当前内容是否是文件夹
        // 2.是，则获取当前文件夹所有内容      
        // 3.文件夹为空，返回空       
        // 4.文件夹不为空，遍历文件夹所有内容      
        // 4.1.遍历每个File对象，继续判断，如果还是文件，递归        
        // 4.2.不是文件夹，是文件        
        // 4.3.得到包文件 + 类名称部分    	
        // 4.4.判断当前文件类型是否.cLass        
        // 4.5.如果是.cLass类型，把路径\替换成。把.cLass去掉        
        // 4.6.判断类上面是否有注解@Bean，如果有实例化过程        
        // 4.7.把对象实例化之后，放到map集合bearFactory
        }
    private void loadDi() {
    	//实例化对象在beanFactory的map集合里面
    	//1遍历beanFactory的map集合
    	//2获取map集合每个对象（vaLue），每个对象属性获取到
    	//3遍历得到每个对象属性数组，得到每个属性
    	//4判断属性上面是否有@Di注解
    	//5如果有@Di注解，把对象进行设置（注入）
    }

AOP 面向切面

引入

问题：

要抽取的代码在方法内部，无法通过抽取到父类解决

代理模式：

在调用目标方法时，不直接调用，而是通过代理类调用
代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法
目标：代理“套用"了非核心逻辑代码的类、对象、方法

优化：

静态代理：再创建一个代理类，实现其他方法，再调用原有类
- 问题：还是僵化，无法动态调整
动态代理：创建动态代理对象 ProxyFactory，用反射统一管理

AOP：通过预编译和动态代理，在不修改程序源码情况下，给程序添加功能

抽取横切关注点
整合横切关注点为通知方法
将各种通知方法整合为切面类

基于注解实现

分类：

JDK：代理对象和目标对象实现相同接口（目标有接口时）
cglib：通过继承目标类
AspectJ：基于静态代理，将代理逻辑植入编译的字节码文件，效果是动态的，Spring借助了其中的注解

@Aspect//切阻尖
@Component //ioc容器
public class LogAspect {
    //设置切入点和通知类型
    //通知类型：
    //前置 @Before(value = "切入点表达式")
    public void beforeMethod(JoinPoint joinPoint) {
        StringmethodName = joinPoint.getSignature().getName();
        Object[] args = jqinPoint.getArgs();
        // 获取连接点的信息
    }
    //返回 @AfterReturning
    //异常 @AfterThrowing
    //后置 @After()
    //环绕 @Around()
}

@Order 控制切面优先级

基于 xml 实现

<context:component-scanbase-package="com.atguigu.aop.xml"></context:component-scan>
<aop:config>
	<!--配置切面类-->
	<aop:aspect ref="loggerAspect">
	<aop:pointcut id="pointcut"
expression="execution(*com.atguigu.aop.xml.calculatorImpl.*(..))"/>
	<aop:before method="beforeMethod"pointcut-ref="pointcut"></aop:before>
	<aop:after method="afterMethod"pointcut-ref="pointcut"></aop:after>
	<aop:after-returning method="afterReturningMethod"returning="result"pointcut-
ref="pointcut"></aop:after-returning>
	<aop:after-throwing method="afterThrowingMethod"throwing="ex"pointcut-
ref="pointcut"></aop:after-throwing>
<aop:around method="aroundMethod"pointcut-ref="pointcut"></aop:around>
	</aop:aspect>
</aop:config>

事务

JDBC Template

增：

//1添加操作
//第一步编写sqL语句
String Sql = "INSERT INTO t_emp VALUES(NULL,?,?,?)";I
//第二步调用jdbcTempLate的方法，传入相关参数
//Object[］ params ={"东方不败"，20，"未知"};
//int rows = jdbcTemplate.update(sql,params);
int rows = jdbcTemplate.update(sql, ..args:"东方不败"，20，"未知");

改：

1
2
3

//2修改操作
String sql ="update t_emp set name=? where id=?";
int rows =jdbcTemplate.update(sql, ..args: "林平之atguigu",3）;

删：

1
2
3

//3删除操作
String sql'deletefromt_empwhere id=?";
introws=jdbcTemplate.update(sql, ..args: 3);

查：

public void testSelectObject() {
    String sql="select*from t_emp
    List<Emp>list = jdbcTemplate.query(sql,
    new BeanPropertyRowMapper<>(Emp.class));
}

基于注解的声明式事务

保证事务的一致性、隔离性、持久性、原子性

Transactional 标签声明事务，可以设置：

只读
超时
回滚策略，哪些异常不回滚
隔离级别
传播行为，事务方法之间调用的处理逻辑

全注解

不用 XML，改用配置类

JavaWeb-Servlet

Thu, 09 Oct 2025 00:00:00 +0000

Tomcat

服务器容器，将服务部署（deploy）到容器内

目录结构：

bin 可执行文件目录
conf 配置文件目录
webapps 项目部署的目录
- 项目内容存放到 webapps-name-WEBINF 文件夹下，即可访问
work 工作目录

Servlet

获取参数

在 web.xml 中定义 servlet-mapping，指定接收 url 请求对应的类
1. 现在支持注解注册 @WebServlet("\...")
定义类，继承 HttpServlet ，实现 doPost 方法
再调用 DAO、DAOImpl 更改数据库

继承关系

Servlet 接口

void init（config）初始化方法
void service(request,response) 服务方法（收到请求自动调用）
void destory() 销毁方法

Servlet 父类、抽象类

genericServlet 抽象类，用于处理子类没有实现的方法（抛错误）
- httpServlet 实现类，具体处理逻辑

生命周期

默认情况下：

第一次接收请求时，这个servlet会进行实例化（调用构造方法）、初始化（调用init())）、然后服务（调用service()）
- 默认只会有一个 Servlet 示例
- 单例的，线程不安全的 –> 尽量不在 Servlet 中定义、修改成员变量
第二次请求开始，每一次都是服务
当容器关闭时，其中的所有的 servlet 实例会被销毁，调用销毁方法

Http 协议

超文本传输协议，是无状态的

请求内容

请求行
- 方式、URL、HTTP版本
请求头
- Host、Referer、Cookie……
请求体

响应内容

响应行
- 协议、状态码（200）、响应状态（ok）
响应消息头
- Server、Content-type……
响应体

Session

会话跟踪技术，解决 http 的无状态问题。

request.getSession，获取、自动分配 Session

session.setAttribute，保存 session 作用域

服务器端内部转发和客户端重定向

内部转发：同一请求、不同服务组件之间转发处理

getdepatcher…

重定向：返回客户端一个新的服务，使其重新请求

redirect…

Thymeleaf 视图模板技术

辅助渲染从 DAO 获取的数据到前端

引入模板
将查询的数据动态显示

th: if... unless... each... text...

保存作用域

request：一次请求有效
session：一次会话范围有效
application：一次应用程序范围内有效（上下文）

小项目

编辑、修改特定信息

变量的获取 url/(fid=${name.fid})
跳转到编辑页面，获取数据

MVC Servlet优化

Servlet 整合

问题：

Servlet 组件过多

优化：

将各种 Servlet 整合到一个 Controller 中，作为方法
用路径区分操作要求
通过 Switch ... case ... 进行跳转，执行 DAO
- 再用反射优化，this.getClass().getDeclaredMethods();

DispatcherServlet 中央控制器

抽取路径、反射代码

拦截、处理指定请求，修改路径再传输到 Controller

将每个 Controller 的反射代码再抽取到父类

注意，这样的 Controller 继承 DispatcherServlet，不能再自动调用 Init（），需要另外处理

解析 xml 配置文件
定位指定 Controller
读取 bean 配置，整合为 map<id,object>，寻找指定方法

抽取重定向

Controller处理后，return 一个字符串，再交给 DispatcherServlet 处理

抽取传入参数

获取参数的过程同一抽取到 DispatcherServlet

jdk 8 新特性，通过反射获取方法参数的方法名
将得到的参数拆包、赋值、类型转换后，再传递给 Controller

初始化

重写 init（）方法，通过注解或 xml，向初始化方法中添加参数

Service

model：模型层
- pojo/vo、DAO（数据访问对象，单精度方法）、BO（业务对象）
- 在 Controller 与 DAO 间添加 Service 层
controller：控制
view：视图

IOC 控制反转

实现 Bean 的自动装配，整理 xml 映射文件

将解析出的实例创建并存放在 beanmap 中，beanmap 存放在 BeanFactory 中，改变示例生命周期（存放到 IOC 容器中），需要时取用即可

1
2
3

Field propertyField = beanClazz.getDeclaredField(propertyName);
propertyField.setAccessible(true);
propertyField.set(beanobj,refobj);

Filter 过滤器

拦截请求、响应

实现 Filter 接口，@WebFilter("...")
改写 doFilter，后放行（执行 Service）filterchain.doFilter(...)
接收到 Service 后，继续执行完 doFilter

过滤器链

执行顺序：根据全类名、xml 配置的顺序

事务管理

一个 Service 需要作为一个整体，操作多个数据库时要保证同时成功或失败

将 try …… catch 放到 Filter 当中处理，统一回滚
用 ThreadLocal 来保证对象、线程（Connection）的同一性

OpenSessionInViewFilter 的实现

事务管理封装为 TransactionManager，实现开启、提交、回滚事务的方法

本来分开的 commit、rollback 等，手动进行管理
注意内部不能 catch 异常，需要都交给 Filter 处理
- 或者 catch 为新的异常抛出

ThreadLocal 的实现源码

public void set(T value)
    Thread t=Thread.currentThread();//获取当前的线程
    ThreadLocalMap map = getMap(t);//每一个线程都维护各自的一个容器(ThreadLocalMap)
    iff (map != null)
    map.set((this)value);//用map，支持多个对象存储
    else
    createMap(t, value) ;
}

Listener 监听器

监听各种对象的创建、销毁；保存作用域的变化；对象在 Session 中的创建与移除、序列化与反序列化

将 IOC 整合到 Listener 中（监听上下文启动），提前初始化，提高响应速度（减慢启动速度）

QQZone 笔记

数据库

设计

先写出功能，再分析：

抽取实体：用户登录信息、用户详情信息、日志、回贴、主人回复
分析其中属性
1. 用户登录信息：账号、密码、头像、昵称
2. 用户详情信息：真实姓名、星座、血型、邮箱、手机号
3. 日志：标题、内容、日期、作者
4. 回复：内容、日期、作者、日志
分析实体之间关系
- 一对一 or 一对多 or 多对多

范式

第一范式：列不可再分（空间尽量小）

第二范式：一张表只表达一层含义

第三范式：表中每一列和逐渐都是直接依赖关系（与多表连接查询权衡）

根据数据库查询频次、量，调整规范性

主键尽量不与业务产生联系

直接用自增组件

实体类 - POJO

定义对应属性，有关系的要对应

1
2

private UserDetail userDetail//1:1
private List<Topic> topiqList//1:N

数据层 - DAO

接口、impl，实现查询

业务层 - Service

接口、impl，整合 DAO 层

ElasticSearch

Sat, 04 Oct 2025 00:00:00 +0000

初识

分布式的开源搜索引擎
提供 Restful 接口，所有语言均可调用

ELK技术栈：

结合 kibana（可视化）、Logstash、Beats
用于日志分析、事实监控等

倒排索引

正向索引：

传统数据库使用，查询需要逐一遍历

倒排索引：

document：文档，每条数据就是一个文档
term：词条，由文档按语义划分，有限且唯一
先搜词条，再根据词条找文档

IK分词器

作为 ES 插件导入

根据现有词典（可拓展）对文档进行划分

基础概念

索引库：

相同类型的文档（Json存储）的集合

映射：

索引库中对文档的约束

mapping 属性

type：字段数据类型
index：是否创建索引
analyzer：分词器
propertis：嵌套的子字段

索引库操作

RESTFUL 规范

不同请求方式对应不同请请求类型

创建索引库和mapping的请求语法如下：

PUT /索引库名称
{
  "mappings": {
    "properties": {
      "字段名1": {
        "type": "text",
        "analyzer": "ik_smart"
      },
      "字段名2": {
        "type": "keyword",
        "index": "false"
      },
      "字段名3": {
        "properties": {
          "子字段": {
            "type": "keyword"
          }
        }
      },
      // …略
    }
  }
}

支持 put、get、delete

文档操作

新增文档：

POST /索引库名/_doc/文档id
{
  "字段1": "值1",
  "字段2": "值2",
  "字段3": {
    "子属性1": "值3",
    "子属性2": "值4"
  },
  // …
}

修改

put 全量修改，先删除再新建
post 增量修改

批处理

POST /_bulk
{ "index" : { "_index" : "索引库名", "_id" : "1" } }
{ "字段1" : "值1", "字段2" : "值2" }
{ "index" : { "_index" : "索引库名", "_id" : "1" } }
{ "字段1" : "值1", "字段2" : "值2" }
{ "index" : { "_index" : "索引库名", "_id" : "1" } }
{ "字段1" : "值1", "字段2" : "值2" }
{ "delete" : { "_index" : "test", "_id" : "2" } }
{ "update" : {"_id" : "1", "_index" : "test"} }
{ "doc" : {"field2" : "value2"} }

DSL 查询

分类：

叶子查询：特定字段查询特定值
复合查询：逻辑方式组合叶子查询

基本语法：

GET /indexName/_search
{
  "query": {
    "查询类型": {
      "查询条件": "条件值"
    }
  }
}

叶子

全文检索：分词
- match 查询
- mult_match 允许同时查询多个字段
精确查询：不分词，直接精确匹配
- term 查询，整体到词条中寻找
- range
地理查询：用于搜索地理位置

复合

基于逻辑运算组合叶子
- bool：子句must、should、must_not、filer
基于算法修改查询时的文档相关性算分，从而改变排名
- function_score
- dis_max

排序和分页

排序：

添加 sort 标签，默认按照 _score 排序

分页：

添加 from 、size

深度分页问题：

es 一般对数据进行分片存储，导致查询数据时需要汇总各个分片的数据

解决方案：

search after，分页时需要排序，每次查询从上一次的排序值开始。但只能向后逐页查询
scrool，将排序数据形成快照，保存在内存
设置上限

高亮显示

在搜索结果中把搜索关键字突出显示

field标签加上pre_tags、post_tags

Java 客户端

JavaRestClient

初始化

1
2
3

RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
       HttpHost.create("http://192.168.150.101:9200")
));

Mapping 映射

结合业务分析所需字段（区分是否需要和是否搜索）

搜索字段
排序字段
展示字段

索引库操作

基于 RestFul格式：

@Test
void testCreateHotelIndex() throws IOException {
    // 1. 创建Request对象
    CreateIndexRequest request = new CreateIndexRequest("items");
    // 2. 请求参数，MAPPING_TEMPLATE是静态常量字符串，内容是JSON格式请求体
    request.source(MAPPING_TEMPLATE, XContentType.JSON);
    // 3. 发起请求
    client.indices().create(request, RequestOptions.DEFAULT);
}

文档操作

新增文档的 API

@Test
void testIndexDocument() throws IOException {
    // 1. 创建request对象
    IndexRequest request = new IndexRequest("indexName").id("1");
    // 2. 准备JSON文档
    request.source("{\"name\": \"Jack\", \"age\": 21}", XContentType.JSON);
    // 3. 发送请求
    client.index(request, RequestOptions.DEFAULT);
}

文档批处理

add 多个 index，然后统一请求即可

完成批量导入数据

void testBulk() throws IOException {
    // 1. 创建Bulk请求
    BulkRequest request = new BulkRequest();
    // 2. 添加要批量提交的请求：这里添加了两个新增文档的请求
    request.add(new IndexRequest("indexName")
            .id("101").source("json source", XContentType.JSON));
    request.add(new IndexRequest("indexName")
            .id("102").source("json source2", XContentType.JSON));
    // 3. 发起bulk请求
    client.bulk(request, RequestOptions.DEFAULT);
}

准备文档数据
准备请求参数
发送请求

RTL 查询

SearchRequest 对象，发请求
解析结果
得到 Hits 属性，结果是数组

复合、排序、分页

用指定对象、设置指定参数即可

boolquery、source

@Test
void testBool() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    // 2.1.准备bool查询
    BoolQueryBuilder bool = QueryBuilders.boolQuery();
    // 2.2.关键字搜索
    bool.must(QueryBuilders.matchQuery("name", "脱脂牛奶"));
    // 2.3.品牌过滤
    bool.filter(QueryBuilders.termQuery("brand", "德亚"));
    // 2.4.价格过滤
    bool.filter(QueryBuilders.rangeQuery("price").lte(30000));
    request.source().query(bool);
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

分页：

@Test
void testPageAndSort() throws IOException {
    int pageNo = 1, pageSize = 5;

    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    // 2.1.搜索条件参数
    request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
    // 2.2.排序参数
    request.source().sort("price", SortOrder.ASC);
    // 2.3.分页参数
    request.source().from((pageNo - 1) * pageSize).size(pageSize);
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

高亮：

@Test
void testHighlight() throws IOException {
    // 1.创建Request
    SearchRequest request = new SearchRequest("items");
    // 2.组织请求参数
    // 2.1.query条件
    request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶"));
    // 2.2.高亮条件
    request.source().highlighter(
            SearchSourceBuilder.highlight()
                    .field("name")
                    .preTags("<em>")
                    .postTags("</em>")
    );
    // 3.发送请求
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 4.解析响应
    handleResponse(response);
}

数据聚合

对文档数据进行统计、分析

桶：对文档做而非女足
度量 Metric：计算某些特定值
管道 Pipeline：以其他聚合的结果为基础做聚合

DSL

aggs 定义聚合

GET /items/_search
{
  "query": {"match_all": {}}, // 可以省略
  "size": 0, // 设置size为0，结果中不包含文档，只包含聚合结果
  "aggs": { // 定义聚合
    "cateAgg": { // 给聚合起个名字
      "terms": { // 聚合的类型，按照品牌值聚合，所以选择term
        "field": "category", // 参与聚合的字段
        "size": 20 // 希望获取的聚合结果数量
      }
    }
  }
}

RestClient 构造聚合

指定名称、类型、字段

request.source().size(0);
request.source().aggregation(
        AggregationBuilders
                .terms("brand_agg")
                .field("brand")
                .size(20)
);

MQ

Thu, 02 Oct 2025 00:00:00 +0000

初识 MQ

服务调用类型

同步调用

服务 A 同时请求多个服务，导致服务种类的不断扩增，服务的等待耗时增加。

缺点：

扩展性差
性能下降
级联失败问题

异步调用

基于消息通知的方式，包含：

消息发送者：即原来的调用者
消息接收者：接收和处理消息的人
消息代理：管理、暂存转发消息

不再同步调用业务关联度第的服务，而是分别发送消息到 Broker

接触耦合，扩展性强
无需等待，性能好
故障隔离
缓存消息，流量削锋填谷

技术选型

RabbitMQ、ActiveMQ、RocketMQ、Kafka

部署

Docker安装即可

整体架构：

publisher：消息发送者
consumer：消息消费者
queue：队列，存储消息
exchange：交换机，负责路由消息
vertual-host：虚拟主机，用于数据隔离

消息发送给交换机，再由交换机分发给对应的 queue，交换机没有消息存贮的能力。

Java客户端

AMQP：无协议传输

封装为 Spring AMQP
再封装为 SpringRabbit，RabbitTemplate包装类

收发消息

发送：

@Autowired
private RabbitTemplate rabbitTemplate;

@Test
public void testSimpleQueue() {
    // 队列名称
    String queueName = "simple.queue";
    // 消息
    String message = "hello, spring amqp!";
    // 发送消息
    rabbitTemplate.convertAndSend(queueName, message);
}

接收：

@Slf4j
@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        log.info("spring 消费者接收到消息: [" + msg + "] ");
    }
}

Work Queues

多个消费者绑定到一个队列

一条消息只能被一个消费者处理
多条消息，默认轮流接收
通过添加消费者来处理超量数据

修改配置

修改 prefetch 来控制消费者预取的消息数量，使性能高的服务器多处理

交换机

Fanout

广播模式，将接收到的消息路由到每一个与其绑定的 queue

Direct

定向路由，根据规则路由到指定的 queue

设置 BindingKey 和 RoutingKey

Topic

基于 RoutingKey，但其通常是多个单词的组合，且以.分割，可以使用通配符# *

声明队列交换机

用代码自动完成队列、交换机的创建

基于Bean声明

在消费者端声明：

@Configuration
public class FanoutConfig {
    // 声明FanoutExchange交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("hmall.fanout");
    }
    // 声明第1个队列
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }
    // 绑定队列和交换机
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }
    // ... 略，以相同方式声明第2个队列，并完成绑定
}

基于注解声明

优化 Bean 声明中绑定 Key 的冗余代码。

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "direct.queue1"),
        exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
        key = {"red", "blue"}
))
public void listenDirectQueue1(String msg){
    System.out.println("消费者1接收到Direct消息: ["+msg+"] ");
}

消息转换器

负责将对象转换为字节格式传输

问题：

默认序列化由安全风险
信息体积变大
可读性差

解决：

用 Jackson 序列转换器
注意收发一致

进阶

改进消息可靠性问题

发送者可靠性

重连

由于网络波动，可能出现发送者连接 MQ 失败。

配置中开启重连机制即可

注意性能损耗
使用合理的重连机制

确认

MQ 接收到消息后，返回 ACK 给发送者。（对性能影响较大）

不同的返回情况、强度
其他情况返回 NACK，告知投递失败

使用：

先开启配置 public confirm type
配置类

@Slf4j
@AllArgsConstructor
@Configuration
public class MqConfig {
    private final RabbitTemplate rabbitTemplate;

    @PostConstruct //只在启动时初始化依次
    public void init(){
        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            @Override
            public void returnedMessage(ReturnedMessage returned) {
                log.error("触发return callback,");
                log.debug("exchange: {}", returned.getExchange());
                log.debug("routingKey: {}", returned.getRoutingKey());
                log.debug("message: {}", returned.getMessage());
                log.debug("replyCode: {}", returned.getReplyCode());
                log.debug("replyText: {}", returned.getReplyText());
            }
        });
    }
}

发送方：

@Test
void testPublisherConfirm() throws InterruptedException {
    // 1.创建CorrelationData
    CorrelationData cd = new CorrelationData();
    // 2.给Future添加ConfirmCallback
    cd.getFuture().addCallback(new ListenableFutureCallback<CorrelationData.Confirm>() {
        @Override
        public void onFailure(Throwable ex) {
            // 2.1.Future发生异常时的处理逻辑，基本不会触发
            log.error("handle message ack fail", ex);
        }

        @Override
        public void onSuccess(CorrelationData.Confirm result) {
            // 2.2.Future接收到回执的处理逻辑，参数中的result就是回执内容
            if(result.isAck()){ // result.isAck()是boolean类型，true代表ack回执，false代表nack回执
                log.debug("发送消息成功，收到 ack!");
            }else{ // result.getReason()是String类型，返回nack时的异常描述
                log.error("发送消息失败，收到 nack，reason：{}", result.getReason());
            }
        }
    });
    // 3.发送消息
    rabbitTemplate.convertAndSend("hmall.direct", "red1", "hello", cd);
}

若发送失败，则尝试重发

MQ可靠性

问题：

数据丢失
内存空间有限，可能导致消息阻塞、堆积

数据持久化

交换机、队列、消息

消息：内存到上限后，才写出到磁盘，阻塞
- 一直写出到磁盘

Lazy Queue

惰性队列

接到消息不再写到内存，直接存入磁盘
消费消息时，从磁盘中读取并加载到内存

消费者可靠性

确认

消费者处理消息结束后，向 MQ 发送回执，告知消息处理状态

ack：成功处理
- 配置`acknowledge-mode
- none 接到后直接返回。不安全
- manual 手动编写返回逻辑
- auto
nack：处理失败，需要重发
reject：处理失败并拒绝，MQ 从队列中删除该消息

失败重试

问题：消费者反复调用 MQ 导致性能损耗

解决：消费者出现异常时利用本地调试机制，无需调用 queue

重试耗尽后的策略

直接 reject（默认）
返回 nack，重新入队
将失败消息投递到指定的交换机

业务幂等

程序开发时，同一个业务执行一次和多次对业务状态的影响是一致的。用于确保消息不被多次执行。

解决方案：

给每个消息设置唯一 id ，配置SetMessageId，然后将 id 写入数据库
业务判断：基于业务本身
- 保证服务间一致性

延迟消息

实现一致性的兜底方案。

发送者发送消息时指定时间，消费者在指定时间后才收到消息

如支付超时取消

死信交换机

死信：

requeue = false
消息无人消费、过期 –> 用于实现延迟消息
消息堆积满了，最早的消息成为死信

死信交换机：

接收死信

消息延迟插件

RabbitMQ的插件，docker部署

计时需要占用 CPU，产生资源消耗
尽可能延时缩短

网关及配置中心

Wed, 01 Oct 2025 00:00:00 +0000

网关

介绍

网络的关口，负责请求的路由、转发、身份检验。分为阻塞式、响应式。微服务将服务注册到注册中心，网关进行服务拉取返回给前端。

使用

创建新模块
引入网关依赖
编写启动类
配置路由

spring:
  cloud:
    gateway:
      routes:
        - id: item # 路由规则id，自定义，唯一
          uri: lb://item-service # 路由目标微服务，lb代表负载均衡
          predicates: # 路由断言，判断请求是否符合规则，符合则路由到目标
            - Path=/items/** # 以请求路径做判断，以/items开头则符合
        - id: xx
          uri: lb://xx-service
          predicates:
            - Path=/xx/**

另有各种路由种类、路由过滤器。

登录校验

需要在网关转发之前进行校验，即添加过滤器。

网关底层流程：

HandlerMapping 路由映射器
WebHandler 请求处理器，即过滤器处理器
PRE（在这里实现） + POST 阶段

Q: 网关如何将用户信息传递给微服务？

Http 传送 –> 用请求头

Q: 微服务之间如何传递用户信息？

自定义过滤器

GatewayFilter：指定路由生效
GlobalFilter：全局过滤器，作用于所有路由

@Component
public class MyGlobalFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1.获取请求
        ServerHttpRequest request = exchange.getRequest();
        // 2.过滤器业务处理
        System.out.println("GlobalFilter pre阶段 执行了。");
        // 3.放行
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        // 过滤器执行顺序，值越小，优先级越高
        return 0;
    }
}

网关拦截逻辑：

获取 request
根据 URL 判断是否需要拦截
获取 Token，解析校验

网关传递服务

用 ServerWebExchange 类下的 API 来给请求头添加鉴权信息，再发送给后续服务。
将登录检验封装为工具模块（配置类），统一扫描调用。
配置类的配置：@ConditionalOnClass(DispatcherServlet.class) 只拦截到后端 SpringMVC 的请求（否则其他模块扫描不到），绕过网关。

微服务间传递信息

利用 OpenFeign 的 RequestTemplate 类更改请求头传递，保存请求头。

配置管理中心

问题：

微服务重复配置过多，维护成本高
更改配置不方便，需要重启服务、网关

解决：

通过配置管理实现热更新、配置共享

配置管理

NACOS 可视化编辑共享配置

包含：

数据库
日志
Swagger
……

微服务拉取共享配置

流程：

启动，加载 bootstrap 引导类
拉取 Nacos 配置
初始化 ApplicationContext上下文
加载 application.yml ，拉取共享配置，合并配置

配置热更新

前提条件

nacos 中要有于微服务名有关的配置文件
微服务中要以特定方式读取需要热更新的配置属性

动态路由

要求：

监听 Nacos 配置变更信息

private final NacosConfigManager nacosConfigManager;

public void initRouteConfigListener() throws NacosException {
    // 1.注册监听器并首次拉取配置
    String configInfo = nacosConfigManager.getConfigService()
            .getConfigAndSignListener(dataId, group, 5000, new Listener() {
                @Override
                public Executor getExecutor() {
                    return null;
                }

                @Override
                public void receiveConfigInfo(String configInfo) {
                    // TODO 监听到配置变更，更新一次配置
                }
            });
    // TODO 2.首次启动时，更新一次配置
}
再定义 UpdateConfigInfo(),删除旧的路由、重新读取新路由

微服务拆分

Wed, 01 Oct 2025 00:00:00 +0000

为什么需要拆分？

单体架构不适合于用户量大、开发人员多的项目访问资源难以分配，无法分解并发压力 –> 把单体架构拆分为多个独立项目

颗粒度小，团队自治，服务自治，数据隔离

服务拆分

前置知识

首先熟悉项目、模块，看流程。

拆分时机

创业型项目先采用单体结构，随规模扩增

拆分原则

高内聚（关联度、完整度高），低耦合（减少对其他服务依赖）
纵向：按业务模块
横向：抽取公共服务，提高复用性

拆分类型

独立 project：适用于大型项目
Maven 聚合，分开打包：较小型项目

注册中心

整合服务调用、服务提供者
提供负载均衡，心跳续约、推送变更（防失效）

Nacos

需要提供数据库，配置服务注册

服务发现 -> 挑选示例（负载均衡） -> 调用

OpenFeign

声明式http客户端，简化http请求书写

使用步骤：导入 client 模块 -> 打开开关 -> 写接口
接口的作用是转发 http 请求，作为各个服务间请求数据的中介
连接池：底层请求用的是 Client，效率较低，用连接池优化
最佳实践：1. 将查询接口放到服务提供方 2 . 封装为统一的api模块（耦合度较高）
日志记录：定义类、定义日志级别，声明到注解

拆分步骤

先按模块分析，将实体类区分开
选择拆分类型，建立模块或项目，改依赖
导入并修改启动类、配置类、各种实体类，根据报错再修改
导入service、impl、controller、mapper
重建数据库、配置启动项进行测试

注意

若 service 中还需要注入其他模块的 service，就要配置注册中心。接入 feign 的 api 接口来调用指定服务。在拆分的同时不断完善 feign 的接口（从目标服务的 controller 中抽取）。

微服务保护及分布式事务

Mon, 08 Sep 2025 00:00:00 +0000

微服务保护

问题：

雪崩问题：某个服务故障，导致整个链路失效
- 微服务相互调用
- 没有做好异常处理
- 所有服务级联失败

解决思路：

尽量避免服务故障、阻塞
做好异常的后备方案

方案：

请求限流
线程隔离：控制业务可用线程数量
服务熔断：将异常比例过高的接口断开，直接走 fallback
失败处理：定义 fallback 处理逻辑

Sentinel

整合到微服务中，配置控制台

簇点链路：默认情况下，Sentinel 拦截的只是 Controller 的请求路径，故需要配置其拦截请求方法。

请求限流

设置 QPS，每秒最多请求线程数

Jmeter

请求模拟工具，用于测试压力

线程隔离

服务 B 出现阻塞或故障时，调用服务 B 的服务 A 的资源也可能因此被耗尽，故必须限制服务 A 中调用服务B的线程数。保护服务 A 中其他接口。

Fallback

将 FeignClient 添加到服务，若超限，则调用其中的 FallFactory 的接口。

服务熔断

解决雪崩问题的重要手段。有断路器统计服务调用的异常比例、慢请求比例，若超出阈值则熔断改服务。

分布式事务

分布式系统中，一个业务需要多个服务共同完成，则这多个服务需要同时成功或失败。

解决思路：

各个子事务之间能感知到彼此的状态

Seata

Seata架构

TC：事务协调者，协调全局事务提交或回滚

TM：事务管理器，定义全局事务的范围，开始提交或回滚（入口）

RM：资源管理器，与 TC 交谈以注册事务状态

部署 TC 服务

seata 用 docker 部署，然后注册到 Nacos 上

微服务集成 Seata

在 application.yml 中添加配置，让微服务找到 TC 地址

抽取共享配置到 nacos、划分事务组

seata:
  registry: # TC服务注册中心的配置，微服务根据这些信息去注册中心获取tc服务地址
    type: nacos # 注册中心类型 nacos
    nacos:
      server-addr: 192.168.150.101:8848 # nacos地址
      namespace: "" # namespace，默认为空
      group: DEFAULT_GROUP # 分组，默认是DEFAULT_GROUP
      application: seata-server # seata服务名称
      username: nacos
      password: nacos
  tx-service-group: hmall # 事务组名称
  service:
    vgroup-mapping: # 事务组与tc集群的映射关系
      hmall: "default"

XA 模式

步骤：

RM 注册分支事务到 TC
RM 执行 sql 但不提交
RM 报告执行状态到 TC
TC 检查各分支执行状态，RM 等待 TC 指令

问题：

需要锁定数据库资源，需要等待，性能较差

AT 模式

弥补 XA 模式中资源锁定周期过长的缺陷

步骤：

注册分支事务
记录数据快照
执行 sql 并提交
报告事务状态
删除快照 / 根据快照恢复数据

问题：

短暂的数据不一致

使用：

对每个服务创建一个 undo_log 表