ph6vsnc9i
/
master_mall
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: ph6vsnc9i:main
Branches Tags
ph6vsnc9i:main
ph6vsnc9i:develop
ph6vsnc9i:tangchuanxing_branch
ph6vsnc9i:LiiuZeYu_branch
ph6vsnc9i:FangJianJun_branch
ph6vsnc9i:wangjinhao_branch
ph6vsnc9i:master
..
compare: ph6vsnc9i:wangjinhao_branch
Branches Tags
ph6vsnc9i:main
ph6vsnc9i:develop
ph6vsnc9i:tangchuanxing_branch
ph6vsnc9i:LiiuZeYu_branch
ph6vsnc9i:FangJianJun_branch
ph6vsnc9i:wangjinhao_branch
ph6vsnc9i:master

No commits in common. 'main' and 'wangjinhao_branch' have entirely different histories.
main ... wangjinhao

122 changed files with 0 additions and 8410 deletions
Show Stats

1
FangJianJun_branch
Unescape View File

@ -1 +0,0 @@
undefined

1
LiiuZeYu_branch
Unescape View File

@ -1 +0,0 @@
undefined

1
develop
Unescape View File

@ -1 +0,0 @@
undefined

BIN
screenshot/login.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 119 KiB

1
tangchuanxing_branch
Unescape View File

@ -1 +0,0 @@
undefined

75
yami-shop-bean/src/main/java/com/yami/shop/bean/app/dto/BasketItemDto.java
Unescape View File

@ -1,75 +0,0 @@
package com.yami.shop.bean.model;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* Basket类用于表示购物车相关的实体信息。
* 它对应数据库中的"tz_basket"表，通过MyBatis Plus的注解来映射表结构与实体类的关系。
* 此类实现了Serializable接口，方便进行对象的序列化操作，例如在网络传输或持久化存储时使用。
*
* @author lanhai
*/
@Data
@TableName("tz_basket")
public class Basket implements Serializable {
/**
* 主键，用于唯一标识购物车中的每一条记录。
* 在数据库表"tz_basket"中对应的字段为主键字段，通常由数据库自动生成或者按照特定规则赋值。
*/
@TableId
private Long basketId;
/**
* 店铺ID，用于标识商品所属的店铺。
* 通过该ID可以关联到对应的店铺信息，比如查询店铺的名称、地址等其他相关属性。
*/
private Long shopId;
/**
* 产品ID，用于确定购物车中具体是哪个产品。
* 可以依据此ID去获取产品的详细信息，如产品名称、价格、描述等内容。
*/
private Long prodId;
/**
* SkuID，代表具体的库存保有单位（Stock Keeping Unit）的编号。
* 不同的Sku可能对应产品的不同规格、颜色、尺寸等变体，通过该ID能准确区分同一产品下的不同库存单元。
*/
private Long skuId;
/**
* 用户ID，用于标识该购物车记录所属的用户。
* 可以通过该ID关联到用户的其他信息，比如用户名、联系方式等，以确定是哪位用户添加的商品到购物车。
* 这里是用字符串类型，可能是根据具体业务系统中用户ID的格式设定（比如可能包含字母等复杂格式）。
*/
private String userId;
/**
* 购物车产品个数，记录了当前购物车中对应商品的数量。
* 用于在计算购物车总价、库存校验等业务场景中发挥作用。
*/
private Integer basketCount;
/**
* 购物时间，记录了用户将商品添加到购物车的具体时间。
* 可以用于分析用户行为，例如统计不同时间段的购物车添加频率等业务需求。
*/
private Date basketDate;
/**
* 满减活动ID，用于关联对应的满减活动。
* 如果商品参与了某个满减活动，通过该ID可以获取活动的详细规则，如满多少金额减多少等信息，以在结算等环节应用相应优惠。
*/
private Long discountId;
/**
* 分销推广人卡号，用于标识在分销业务场景下，将该商品推荐给用户的推广人员的卡号信息。
* 通过这个卡号可以进行分销相关的业绩统计、佣金计算等操作。
*/
private String distributionCardNo;
}

82
yami-shop-bean/src/main/java/com/yami/shop/bean/app/dto/CategoryDto.java
Unescape View File

@ -1,82 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.dto;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.yami.shop.common.serializer.json.ImgJsonSerializer;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* `CategoryDto`类是一个数据传输对象（DTO），用于在应用层不同组件或模块之间传递商品分类相关的信息。
* 它的主要作用是将与商品分类有关的数据进行整合封装，使得在接口调用、页面展示等业务场景下，
* 数据的传递更加清晰、规范且符合业务需求，避免了直接传递复杂的底层实体对象或者分散的单个数据，
* 提高了代码的可读性以及不同模块间交互的便利性。
*
* @author lanhai
*/
@Data
public class CategoryDto {
/**
* 此属性代表商品分类的唯一标识符，用于在整个系统中精确地指代某一个具体的商品分类。
* 无论是在数据库查询操作中，还是在不同业务逻辑模块间传递分类相关信息时，
* 都通过这个 `categoryId` 来准确地定位对应的分类实体。例如，当需要获取某个分类下的商品列表，
* 或者查找该分类的详细属性（如分类描述、关联的其他数据等）时，都会依赖这个唯一标识进行操作。
*
* 在接口交互方面，通过 `@Schema` 注解明确标记该属性在 API 文档生成（例如使用 Swagger 等工具时）
* 中的描述信息为“分类id”，并且表明它是接口调用时必须提供的参数（`required = true`），
* 以此告知接口使用者该参数的重要性及必要性。
*/
@Schema(description = "分类id", required = true)
private Long categoryId;
/**
* `parentId` 属性用于记录当前商品分类的父级分类的唯一标识符，它构建了商品分类之间的层级关系。
* 在电商系统或者其他存在分类层级结构的业务场景中，通过这个属性可以追溯到该分类所属的上级分类，
* 进而形成一个类似树状的分类体系。比如，在电商的商品分类里，“智能手机”分类可能隶属于“数码产品”分类，
* 那么“数码产品”分类的 `id` 就会存储在此处作为 `parentId`。
*
* 同样，借助 `@Schema` 注解，在 API 文档中明确该属性的描述为“分类父id”，且为必填项，
* 方便接口调用者理解其含义以及在传递数据时按要求提供相应的值，有助于系统准确构建和展示分类层级结构。
*/
@Schema(description = "分类父id", required = true)
private Long parentId;
/**
* `categoryName` 是用于直观展示给用户或者在系统内部区分不同商品分类的名称属性。
* 它以字符串的形式呈现了商品分类的具体称谓，例如“服装”“电子产品”“食品”等常见的分类名称，
* 是用户在前端界面看到的用于识别不同分类的文字标识，也是在业务逻辑处理中进行分类筛选、
* 统计等操作时便于理解和操作的重要信息。
*
* 通过 `@Schema` 注解，为该属性在 API 文档里添加“分类名称”的描述，并标记为必填项，
* 确保接口返回的数据包含清晰准确的分类名称信息，同时要求调用方在传递分类相关数据时必须提供有效的名称。
*/
@Schema(description = "分类名称", required = true)
private String categoryName;
/**
* `pic` 属性用于存放商品分类对应的图片资源相关信息，通常可能是图片在系统中的存储路径、
* 唯一标识名称或者完整的 URL 地址等形式，具体取决于系统的图片存储和管理方式。
* 其目的是在前端界面展示分类时能够配上相应的图片，增强视觉效果，帮助用户更直观地识别不同分类，
* 比如在展示“服装”分类时，可以显示一张服装展示图片，让用户更快速地定位到感兴趣的分类。
*
* 这里使用了 `@JsonSerialize(using = ImgJsonSerializer.class)` 注解组合，
* 意味着在将该 `CategoryDto` 对象转换为 JSON 格式数据（例如在接口返回数据给前端时），
* 会使用自定义的 `ImgJsonSerializer` 序列化器对这个 `pic` 属性进行特殊处理，
* 可能是对图片路径进行格式调整、添加域名等操作，使其符合前端展示或者与其他系统交互时的要求，
* 保证图片资源信息能够被正确解析和使用。同时，通过 `@Schema` 注解标记该属性描述为“分类图片”且为必填项，
* 确保分类图片信息的完整性和准确性，以便在前端展示等业务场景中正常使用。
*/
@Schema(description = "分类图片", required = true)
@JsonSerialize(using = ImgJsonSerializer.class)
private String pic;
}

75
yami-shop-bean/src/main/java/com/yami/shop/bean/app/dto/ChooseDiscountItemDto.java
Unescape View File

@ -1,75 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.dto;
import lombok.Data;
import java.io.Serializable;
/**
* `ChooseDiscountItemDto`类是一个数据传输对象（DTO），用于封装购物车中被选中的满减活动项相关信息，
* 在电商系统的业务逻辑处理中，起着在不同组件或模块之间传递相关数据的重要作用。
* 当用户在购物车页面选择参与某些满减活动时，每个被选中的满减活动项具体细节都会被整理并封装到此类的实例对象中，
* 以便后续进行如计算优惠金额、展示活动详情给用户、更新购物车总价等一系列业务操作时使用，
* 确保了数据传递的规范性和完整性，避免了在各业务层之间直接传递零散且复杂的数据结构。
* @author lanhai
*/
@Data
public class ChooseDiscountItemDto implements Serializable {
/**
* 满减活动项的唯一标识符，用于在整个系统中精确地定位该满减活动项对应的详细信息。
* 例如，在数据库中可以通过这个 `discountItemId` 去查询该项活动的具体规则（如满多少金额减多少金额、
* 满减的条件限制等）、活动的有效期限、适用的商品范围以及与其他业务模块相关联的信息等，
* 为后续围绕该满减活动项进行准确的业务逻辑处理（如判断是否满足满减条件、计算优惠额度等）提供关键依据。
*/
private Long discountItemId;
/**
* 关联的满减活动的整体唯一标识符，即 `discountActivityId`，它指向整个满减活动的总体定义信息。
* 通常一个满减活动可能会包含多个不同的活动项，通过这个ID能够获取到该满减活动的通用属性，
* 比如活动的名称、活动发起方（是平台发起还是店铺发起等）、活动覆盖的商品分类范围等基础信息，
* 有助于从整体上把握该满减活动的全貌，并且在涉及多个活动项协同处理或者统计分析整个满减活动相关数据时发挥作用。
*/
private Long discountActivityId;
/**
* 该满减活动项在当前购物车选中场景下能够为用户减免的具体金额数值，即 `discountAmount`。
* 它明确了选择这个满减活动项后，用户可以实际节省多少钱，是计算购物车最终总价、
* 向用户清晰展示优惠明细等操作中不可或缺的数据要素，在涉及金额计算和展示优惠情况的业务逻辑中会频繁被使用。
*/
private Double discountAmount;
/**
* 用于标识该满减活动项当前是否已经生效的布尔类型属性，例如可以用 `isActive` 来表示。
* 其取值通常为 `true` 或 `false`，当满足了该活动项预先设定的生效条件（比如购物车商品总价达到规定金额、
* 所选商品符合活动要求的品类等）时，这个标识会被设置为 `true`，意味着此活动项开始生效，相应的优惠金额可以进行扣除等操作；
* 反之，若不满足条件则为 `false`，通过这个属性方便在业务逻辑中准确判断活动项的执行状态，
* 确保优惠计算的准确性以及整个购物流程中满减活动应用的正确性。
*/
private boolean isActive;
/**
* 满减活动项适用的商品集合相关信息，可以用合适的数据结构来存储（例如 `List<Long>` 类型的列表，
* 里面存放符合该活动项的商品ID等，具体根据业务实际情况确定），用 `applicableProdIds` 表示。
* 它明确了该满减活动项具体适用于哪些商品，在判断购物车中的商品是否能参与此满减活动、
* 以及在计算优惠金额时分摊到各个商品上的情况等业务逻辑中会起到关键作用，有助于更精细地处理满减优惠与商品的关联关系。
*/
private Object applicableProdIds;
/**
* 满减活动项剩余的可使用次数，用 `remainingUseTimes` 表示，通常可以是整数类型。
* 在一些有限次使用的满减活动场景中，这个属性用于记录该活动项还能被使用的次数，
* 例如，某个满减活动项规定用户总共可以使用3次，每使用一次就会相应地减少该次数，
* 通过这个属性可以在业务逻辑中控制活动项的使用频率，避免超次数使用，确保活动规则的正确执行。
*/
private Integer remainingUseTimes;
}

66
yami-shop-bean/src/main/java/com/yami/shop/bean/app/dto/CouponOrderDto.java
Unescape View File

@ -1,66 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.dto;
import lombok.Data;
import java.io.Serializable;
/**
* `CouponOrderDto`类是一个数据传输对象（DTO），用于在电商系统应用层的不同组件或模块之间传递与优惠券和订单相关的信息。
* 其主要目的是将涉及优惠券在订单场景下的相关数据进行整合封装，方便在诸如订单创建、订单金额计算（包含优惠券优惠计算）、
* 订单详情展示等业务操作中进行数据传递，使得数据交互更加清晰、规范，避免直接传递复杂或分散的底层数据结构，
* 提高不同业务层之间协作的效率以及代码的整体可读性。
* @author lanhai
*/
@Data
public class CouponOrderDto implements Serializable {
/**
* 优惠券的唯一标识符，用于在系统中精准定位某一张具体的优惠券。
* 通过这个 `couponId`，可以关联到优惠券的详细信息，例如优惠券的名称、类型（满减券、折扣券等）、
* 优惠金额或折扣比例、使用条件（如满多少金额可用、适用的商品范围等）以及有效期等关键属性，
* 在订单处理过程中，判断该优惠券是否可用于当前订单以及计算具体优惠金额时，都需要依赖这个唯一标识来获取相应信息。
*/
private Long couponId;
/**
* 关联的订单的唯一标识符，即 `orderId`，用于明确该优惠券是应用于哪一个具体的订单上。
* 在电商系统中，一个优惠券可能可以在多个订单中使用（前提是满足使用条件），同样，一个订单也可能会使用多张优惠券，
* 通过这个 `orderId` 能够清晰地建立起优惠券与订单之间的对应关系，便于后续业务逻辑围绕该订单进行优惠券相关的处理，
* 比如统计该订单使用了哪些优惠券、计算因优惠券使用而减免的总金额等操作。
*/
private Long orderId;
/**
* 该优惠券在当前订单中实际减免的金额数值，用 `discountAmount` 表示。
* 在订单处理流程中，当确定某张优惠券可应用于当前订单后，需要根据优惠券的规则（如满减券的满减金额设定等）
* 来计算出它在这个订单里具体能减免多少钱，这个属性就用于记录该实际减免的金额，
* 是计算订单最终应付金额、展示订单优惠明细等操作中重要的数据依据，能直观体现优惠券给订单带来的优惠效果。
*/
private Double discountAmount;
/**
* 表示优惠券在当前订单中的使用状态的标识，例如可以用布尔类型的 `isUsed` 属性来表示（`true` 表示已使用，`false` 表示未使用）。
* 在整个订单生命周期内，优惠券的使用状态可能会发生变化，例如用户最初选择使用某张优惠券，但后续又取消了选择，
* 或者由于某些条件不满足导致优惠券无法使用等情况，通过这个属性可以清晰地反映出优惠券当前是否已在该订单中被实际应用，
* 方便在业务逻辑中进行相应的判断和处理，确保订单与优惠券之间的关联状态准确无误。
*/
private boolean isUsed;
/**
* 优惠券的剩余可用次数（如果优惠券有使用次数限制的话），用 `remainingUseTimes` 表示，通常为整数类型。
* 对于一些有限次使用的优惠券，每次在订单中成功使用后，剩余可用次数会相应减少，
* 这个属性用于记录当前优惠券针对后续订单还能被使用的次数，在判断优惠券是否还能继续在其他订单中使用等业务逻辑中起着关键作用，
* 有助于合理控制优惠券的使用频率，遵循其预先设定的使用规则。
*/
private Integer remainingUseTimes;
}

110
yami-shop-bean/src/main/java/com/yami/shop/bean/app/dto/DeliveryDto.java
Unescape View File

@ -1,110 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.util.List;
/**
* @author lanhai
*//*
* * Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
* *
* * https://www.mall4j.com/
* *
* * 未经允许，不可做商业用途！
* *
* * 版权所有，侵权必究！
* */
*
*package com.yami.shop.bean.app.dto;
*
*import io.swagger.v3.oas.annotations.media.Schema;
*import lombok.Data;
*import java.util.List;
*
* /**
* * `DeliveryDto`类是一个数据传输对象（DTO），主要用于在电商系统应用层不同组件或模块之间传递与物流配送相关的综合信息。
* * 它将涉及物流公司、物流订单以及对应的详细物流信息等多方面的数据进行整合封装，以便在诸如订单物流查询结果展示、
* * 向用户反馈物流状态等业务场景下进行规范、清晰的数据传递，使得各业务环节能基于这些完整的物流数据进行相应操作，
* * 提升用户体验以及保障物流相关业务流程的顺畅进行。
*
* * @author lanhai
* */
*@Data
*
public class DeliveryDto {
*
* /**
* * `companyName`属性用于存储物流公司的名称，它明确指出了负责当前物流配送的公司具体称谓，
* * 例如“顺丰速运”“申通快递”“京东物流”等常见的物流公司名称。在向用户展示物流信息或者在系统内部区分不同物流服务提供商时，
* * 这个属性起着关键的标识作用，并且通过 `@Schema` 注解标记其描述为“物流公司名称”且为必填项（`required = true`），
* * 确保在数据传递过程中该重要信息不会缺失，保证物流信息展示的完整性和准确性。
* */
*
@Schema(description = "物流公司名称", required = true)
*
private String companyName;
*
* /**
* * `companyHomeUrl`属性存放的是物流公司的官方网站网址，即用户可以通过访问这个网址获取该物流公司更详细全面的信息，
* * 比如公司的服务介绍、业务范围、客服联系方式以及快递查询入口等内容。在电商系统中，有时候可能会为用户提供链接跳转功能，
* * 方便用户直接从订单物流界面跳转到物流公司官网进一步了解相关情况，通过 `@Schema` 注解将其描述为“物流公司官网”且设为必填项，
* * 保证了在传递物流相关数据时该网址信息的完整性，有助于完善物流信息服务。
* */
*
@Schema(description = "物流公司官网", required = true)
*
private String companyHomeUrl;
*
* /**
* * `dvyFlowId`属性代表物流订单号，它是每个物流包裹在相应物流公司系统中的唯一标识符，
* * 通过这个订单号，物流公司可以准确查询到该包裹的具体运输情况、轨迹信息等，在电商系统中，
* * 用户查询自己订单的物流状态时，就是依靠这个订单号向物流公司的查询接口发起请求来获取物流详情的，
* * 借助 `@Schema` 注解标记其为“物流订单号”并设为必填项，确保在物流数据传递及后续查询操作中有准确的订单号依据。
* */
*
@Schema(description = "物流订单号", required = true)
*
private String dvyFlowId;
*
* /**
* * `data`属性是一个列表类型，其中的元素为 `DeliveryInfoDto` 类型，用于存放查询出的详细物流信息。
* * 它包含了诸如快递包裹的当前状态（已揽收、运输中、派送中、已签收等）、所在区域、更新时间等具体的物流动态数据，
* * 通过将这些详细信息整合在一个列表中，可以完整地展示物流的整个过程以及当前状态，方便用户全面了解自己包裹的运输情况。
* * 利用 `@Schema` 注解将其描述为“查询出的物流信息”并设为必填项，保证了在向用户或其他业务模块传递物流数据时，
* * 有完整且准确的详细物流内容可供使用，提升物流信息展示的质量和实用性。
* */
*
@Schema(description = "查询出的物流信息", required = true)
*
private List<DeliveryInfoDto> data;
*
}
@Data
public class DeliveryDto {
@Schema(description = "物流公司名称" ,required=true)
private String companyName;
@Schema(description = "物流公司官网" ,required=true)
private String companyHomeUrl;
@Schema(description = "物流订单号" ,required=true)
private String dvyFlowId;
@Schema(description = "查询出的物流信息" ,required=true)
private List<DeliveryInfoDto> data;
}

68
yami-shop-bean/src/main/java/com/yami/shop/bean/app/dto/DeliveryInfoDto.java
Unescape View File

@ -1,68 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* `DeliveryInfoDto`类是一个数据传输对象（DTO），在电商系统的物流相关业务场景中发挥着重要作用，
* 主要用于在不同的业务组件或模块之间传递快递物流过程中的具体信息，以便实现诸如向用户展示物流详情、
* 系统内部记录物流轨迹等功能，确保物流信息的传递清晰、规范且完整。
* @author lanhai
*/
@Data
public class DeliveryInfoDto {
/**
* `context`属性用于承载快递物流的详细描述信息，这是一个非常关键的属性，涵盖了包裹运输过程中的诸多重要情况。
* 例如，它可能包含包裹当前所处的具体状态，像“已揽收”表示快递员已经接收了包裹开始运输流程，“运输中”说明包裹正在运往目的地的途中，
* “派送中”意味着快递即将送到收件人手中，“已签收”则代表收件人已成功接收包裹等；同时还可能包含一些额外的详细说明，
* 比如“因恶劣天气原因，派送可能延迟”或者“包裹在中转站点进行分拣”之类的特殊情况备注。无论是在前端页面展示给用户查看，
* 还是在系统后台用于记录和分析物流状态，这个属性都提供了最为核心的文字描述内容。
* 通过 `@Schema` 注解明确其描述为“详细信息”且标记为必填项（`required = true`），以此确保在物流信息传递过程中，
* 该关键的详细情况能够完整无误地传达，使得各方都能准确知晓快递的具体进展和相关特殊情况。
*/
@Schema(description = "详细信息", required = true)
private String context;
/**
* `ftime`属性用于存放快递预计送达时间相关的信息，其具体的表现形式和含义通常会依据系统的业务设定有所不同。
* 它有可能是一个遵循特定日期时间格式（比如常见的 `yyyy-MM-dd HH:mm:ss`）的精确时间，表示预计包裹将会在这个时间点送达收件人处；
* 也可能是一种相对模糊但通俗易懂的时间范围描述，例如“明天上午”“后天下午”等，目的是为用户提供一个大致的心理预期，
* 方便用户提前安排好接收包裹的相关事宜。不过，与其他必填属性不同，该属性并非强制要求每次都必须提供具体值，
* 因为在某些情况下，物流信息可能暂时无法准确预估送达时间，所以可根据实际掌握的物流数据完整性来决定是否填充该属性内容。
*/
private String ftime;
/**
* `location`属性主要记录快递包裹当前所在的区域信息，这对于用户追踪包裹位置以及了解其运输路线具有重要意义。
* 具体而言，它可以精确到城市、区县等地理范围，比如“北京市朝阳区”“上海市浦东新区”；也有可能进一步细化到具体的快递站点名称，
* 像“XX快递XX街道营业点”，或者是更宽泛一点的配送区域划分，例如“XX小区配送范围”等。通过明确快递所在的区域，
* 用户能够对包裹的大致地理位置有较为直观清晰的了解，从而更好地预估包裹到达自己手中的时间等情况。
* 借助 `@Schema` 注解将其描述为“快递所在区域”并设定为必填项，确保在物流数据传递过程中，
* 始终能准确传达包裹的所在位置信息，方便展示给用户知晓其运输轨迹。
*/
@Schema(description = "快递所在区域", required = true)
private String location;
/**
* `time`属性用于记录物流信息的更新时间，通常采用标准的日期时间格式（如 `yyyy-MM-dd HH:mm:ss`）来准确表示。
* 这个时间点明确了当前这条物流信息是在何时被记录或者更新的，其重要性体现在多个方面。对于用户来说，
* 可以依据更新时间判断所看到的物流信息是否是最新的，从而了解包裹运输状态的时效性；而在系统内部，
* 开发人员可以基于更新时间对物流数据进行排序、筛选等操作，以便更有序地管理和展示物流信息，或者进行数据分析等工作。
* 通过 `@Schema` 注解标记为“物流更新时间”且设为必填项，保证了物流数据的及时性和准确性能够在各个业务环节得以准确体现，
* 维持整个物流信息管理的有序性和可靠性。
*/
@Schema(description = "物流更新时间", required = true)
private String time;
}

67
yami-shop-bean/src/main/java/com/yami/shop/bean/app/dto/DiscountDto.java
Unescape View File

@ -1,67 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.dto;
import lombok.Data;
import java.io.Serializable;
/**
* `DiscountDto`类是一个数据传输对象（DTO），用于在电商系统应用层的不同组件或模块之间传递与折扣（优惠）相关的信息。
* 其主要目的是将涉及商品折扣、满减等优惠活动的各项数据进行整合封装，方便在诸如订单创建、订单金额计算（包含优惠金额计算）、
* 优惠活动展示等业务操作中进行数据传递，使得数据交互更加清晰、规范，避免直接传递复杂或分散的底层数据结构，
* 提高不同业务层之间协作的效率以及代码的整体可读性。
* @author lanhai
*/
@Data
public class DiscountDto implements Serializable {
/**
* 优惠活动的唯一标识符，用于在系统中精准定位某一个具体的优惠活动。
* 通过这个 `discountId`，可以关联到优惠活动的详细信息，例如优惠活动的名称（如“满200减50”“8折优惠”等）、
* 优惠活动的类型（是满减活动、折扣活动还是其他类型）、适用的商品范围（哪些商品可以参与该优惠）、
* 活动的有效期限（开始时间和结束时间）以及其他相关的规则设定等关键属性，
* 在订单处理过程中，判断该优惠活动是否可用于当前订单以及计算具体优惠金额时，都需要依赖这个唯一标识来获取相应信息。
*/
private Long discountId;
/**
* 关联的订单的唯一标识符，即 `orderId`，用于明确该优惠活动是应用于哪一个具体的订单上。
* 在电商系统中，一个优惠活动可能可以在多个订单中使用（前提是满足活动使用条件），同样，一个订单也可能会使用多个优惠活动，
* 通过这个 `orderId` 能够清晰地建立起优惠活动与订单之间的对应关系，便于后续业务逻辑围绕该订单进行优惠相关的处理，
* 比如统计该订单使用了哪些优惠活动、计算因优惠活动使用而减免的总金额等操作。
*/
private Long orderId;
/**
* 该优惠活动在当前订单中实际减免的金额数值，用 `discountAmount` 表示。
* 在订单处理流程中，当确定某优惠活动可应用于当前订单后，需要根据活动的规则（如满减活动的满减金额设定、折扣活动的折扣比例等）
* 来计算出它在这个订单里具体能减免多少钱，这个属性就用于记录该实际减免的金额，
* 是计算订单最终应付金额、展示订单优惠明细等操作中重要的数据依据，能直观体现优惠活动给订单带来的优惠效果。
*/
private Double discountAmount;
/**
* 表示优惠活动在当前订单中的使用状态的标识，例如可以用布尔类型的 `isUsed` 属性来表示（`true` 表示已使用，`false` 表示未使用）。
* 在整个订单生命周期内，优惠活动的使用状态可能会发生变化，例如用户最初选择参与某优惠活动，但后续又取消了选择，
* 或者由于某些条件不满足导致优惠活动无法使用等情况，通过这个属性可以清晰地反映出优惠活动当前是否已在该订单中被实际应用，
* 方便在业务逻辑中进行相应的判断和处理，确保订单与优惠活动之间的关联状态准确无误。
*/
private boolean isUsed;
/**
* 优惠活动的剩余可用次数（如果优惠活动有使用次数限制的话），用 `remainingUseTimes` 表示，通常为整数类型。
* 对于一些有限次使用的优惠活动，每次在订单中成功使用后，剩余可用次数会相应减少，
* 这个属性用于记录当前优惠活动针对后续订单还能被使用的次数，在判断优惠活动是否还能继续在其他订单中使用等业务逻辑中起着关键作用，
* 有助于合理控制优惠活动的使用频率，遵循其预先设定的使用规则。
*/
private Integer remainingUseTimes;
}

81
yami-shop-bean/src/main/java/com/yami/shop/bean/app/dto/IndexImgDto.java
Unescape View File

@ -1,81 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.dto;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.yami.shop.common.serializer.json.ImgJsonSerializer;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.util.Date;
/**
* `IndexImgDto`类是一个数据传输对象（DTO），主要用于在电商系统应用层不同组件或模块之间传递首页图片相关的信息。
* 其作用是将首页图片的关键数据进行整合封装，使得在诸如首页图片展示配置、图片数据获取与传递等业务场景下，
* 数据的交互更加清晰、规范且符合业务需求，便于不同业务部分基于这些信息进行相应的操作，例如按照指定顺序展示图片、
* 根据类型筛选图片、依据关联ID查找相关联的其他业务对象等。
* @author lanhai
*/
@Schema(description = "首页图片对象")
@Data
public class IndexImgDto {
/**
* `imgUrl`属性用于存放首页图片的网络地址或者在系统中的存储路径等信息，具体取决于系统的图片存储和访问方式。
* 例如在使用云存储服务时，可能是该图片在云存储中的完整URL地址；若是本地存储，则可能是相对系统根目录的文件路径。
* 这个属性是展示首页图片的关键数据，前端页面通过获取该 `imgUrl` 来准确显示对应的图片内容。
* 同时，借助 `@JsonSerialize(using = ImgJsonSerializer.class)` 注解，在将该类对象转换为JSON格式数据（如接口返回数据给前端时），
* 会使用自定义的序列化器对这个属性进行特殊处理，可能是对图片路径进行格式调整、添加域名等操作，使其符合前端展示或者与其他系统交互的要求。
* 通过 `@Schema` 注解明确其描述为“图片Url”且标记为必填项（`required = true`），确保在数据传递过程中该图片地址信息的完整性，
* 以便顺利实现图片展示功能。
*/
@JsonSerialize(using = ImgJsonSerializer.class)
@Schema(description = "图片Url", required = true)
private String imgUrl;
/**
* `seq`属性代表首页图片的展示顺序，通常为整数类型，用于确定在首页展示图片时各个图片的先后排列次序。
* 可以按照业务需求设定相应的排序规则，比如较小的数值在前、较大的数值在后等，通过调整不同图片的 `seq` 值，
* 能够灵活地改变首页图片的展示顺序，实现对首页展示效果的个性化定制和优化。
* 通过 `@Schema` 注解将其描述为“图片顺序”并设定为必填项，保证在传递首页图片相关数据时，展示顺序信息不会缺失，
* 便于前端或其他业务模块按照正确的顺序展示图片。
*/
@Schema(description = "图片顺序", required = true)
private Integer seq;
/**
* `uploadTime`属性记录的是首页图片的上传时间，以 `Date` 类型存储，格式一般遵循系统默认的时间格式（例如 `yyyy-MM-dd HH:mm:ss`）。
* 它在业务中有多方面的作用，比如可以用于数据的溯源，方便查看不同时间段内首页图片的更新情况；也能用于统计分析，
* 了解图片的上传频率等信息。通过 `@Schema` 注解标记其描述为“上传时间”且设为必填项，确保在图片数据传递过程中，
* 上传时间信息能够准确传达，有助于进行相关的数据管理和业务操作。
*/
@Schema(description = "上传时间", required = true)
private Date uploadTime;
/**
* `type`属性用于区分首页图片的类型，一般通过不同的整数值来对应不同的图片分类。
* 例如，可以设定 `1` 表示商品推荐图片，`2` 表示活动宣传图片，`3` 表示店铺形象展示图片等。
* 通过这种分类方式，在业务逻辑中能够针对不同类型的图片进行差异化的处理和展示，比如不同类型图片展示在首页的不同位置、
* 采用不同的展示样式等，也便于进行分类管理和统计分析等操作。
* 通过 `@Schema` 注解明确其描述为“类型”且设为必填项，保证传递图片数据时类型信息的完整性，便于后续根据类型进行相应的业务处理。
*/
@Schema(description = "类型", required = true)
private int type;
/**
* `relation`属性用于存放与首页图片相关联的其他数据的唯一标识符，比如可能关联到某个商品的 `id`、某个活动的 `id` 等，
* 其具体含义取决于业务场景中图片与其他实体的关联关系设定。通过这个属性可以建立起图片与其他业务对象之间的联系，
* 在进行相关业务操作时，例如根据图片查找关联商品、获取关联活动详情等，就可以依据这个 `relation` 值来获取对应的关联数据。
* 通过 `@Schema` 注解将其描述为“关联id”并设为必填项，确保在传递图片信息时，关联ID信息准确无误，方便后续基于关联关系开展业务操作。
*/
@Schema(description = "关联id", required = true)
private Long relation;
}

67
yami-shop-bean/src/main/java/com/yami/shop/bean/app/dto/MyOrderDto.java
Unescape View File

@ -1,67 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.util.List;
/**
* `MyOrderDto`类是一个数据传输对象（DTO），主要用于在电商系统应用层不同组件或模块之间传递与用户“我的订单”相关的综合信息。
* 其作用是将订单中关键的数据进行整合封装，方便在诸如订单查询、订单列表展示、订单详情查看等业务场景下进行数据传递，
* 使得数据交互更加清晰、规范，便于不同业务部分基于这些信息进行相应操作，例如向用户展示订单概览、统计订单相关数据等。
* @author lanhai
*/
@Data
@Schema(description = "我的订单")
public class MyOrderDto {
/**
* `orderItemDtos`属性是一个列表类型，其中元素为 `MyOrderItemDto` 类型，用于存放该订单下的各个订单项信息。
* 在一个订单中，通常会包含多个购买的商品项，每个商品项都有其独立的详细信息，比如商品的具体规格（通过对应的SKU信息体现）、
* 商品单价、购买数量等，这个列表就完整地记录了所有订单项的这些详细数据，方便在后续业务逻辑中，
* 例如查看订单商品明细、计算每个商品的实际金额、进行商品退换货操作等时使用，确保订单中商品相关信息的完整性和准确性。
* 通过 `@Schema` 注解明确其描述为“订单项”且标记为必填项（`required = true`），保证在传递“我的订单”相关数据时，
* 订单项信息不会缺失，便于准确展示订单的具体商品构成情况。
*/
@Schema(description = "订单项", required = true)
private List<MyOrderItemDto> orderItemDtos;
/**
* `orderNumber`属性用于存储订单的唯一编号，也就是订单号，它是在整个电商系统中用于精确标识每个订单的字符串。
* 通过这个订单号，后端系统可以精准地关联到该订单对应的所有详细信息，包括用户信息、下单时间、支付信息等诸多方面，
* 在业务操作中，用户查询特定订单、进行订单相关的各种处理（如确认收货、申请退款等）都是依靠这个订单号来定位目标订单的。
* 通过 `@Schema` 注解将其描述为“订单号”并设定为必填项，确保在数据传递过程中订单号信息的完整性，便于后续围绕准确的订单开展业务。
*/
@Schema(description = "订单号", required = true)
private String orderNumber;
/**
* `actualTotal`属性代表订单的总价，即用户实际需要支付的金额总数，其数据类型为 `Double`，通常以货币形式体现。
* 这个总价是经过一系列计算得出的，比如考虑了商品原价、优惠活动减免金额（如满减、优惠券使用等）、运费（如果有）等因素后的最终金额，
* 在向用户展示订单信息时，总价是一个非常关键的数据，用户可以直观地了解到此次订单需要花费多少钱，
* 同时在订单统计、财务相关业务操作中也起着重要作用。通过 `@Schema` 注解标记其描述为“总价”且设为必填项，
* 保证在传递订单数据时总价信息准确无误，方便各方基于该金额进行相应的处理和判断。
*/
@Schema(description = "总价", required = true)
private Double actualTotal;
/**
* `status`属性用于表示订单当前所处的状态，一般为整数类型，不同的整数值对应不同的订单状态，例如：
* `0` 可以表示订单已提交但未支付，`1` 表示订单已支付等待发货，`2` 表示订单已发货在运输中，`3` 表示订单已签收等，
* 具体的状态值和含义通常会根据电商系统的业务规则来设定。通过这个属性，系统可以清晰地知晓订单目前处于哪个环节，
* 进而根据不同状态执行相应的业务逻辑，比如对于已支付的订单安排发货，对于已签收的订单进行后续评价等操作。
* 通过 `@Schema` 注解明确其描述为“订单状态”并设为必填项，确保在传递订单数据时状态信息完整，便于准确把握订单的进展情况。
*/
@Schema(description = "订单状态", required = true)
private Integer status;
}

76
yami-shop-bean/src/main/java/com/yami/shop/bean/app/dto/MyOrderItemDto.java
Unescape View File

@ -1,76 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.dto;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.yami.shop.common.serializer.json.ImgJsonSerializer;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* `MyOrderItemDto`类是一个数据传输对象（DTO），在电商系统应用层用于传递“我的订单”中具体订单项的相关信息，
* 它将单个商品在订单中的关键数据进行整合封装，方便在诸如订单详情展示、订单商品明细查询等业务场景下进行数据传递，
* 使得各业务环节能基于这些详细且规范的数据来进行相应操作，例如向用户清晰呈现所购买商品的各项属性、进行商品金额计算等。
* @author lanhai
*/
@Schema(description = "我的订单-订单项")
@Data
public class MyOrderItemDto {
/**
* `pic`属性用于存放商品图片相关信息，它可以是图片的网络地址或者在系统中的存储路径等，具体取决于系统的图片存储和访问方式。
* 例如在使用云存储服务时，可能是该商品图片在云存储中的完整URL地址；若是本地存储，则可能是相对系统根目录的文件路径。
* 这个属性是展示商品外观等信息的关键数据，前端页面通过获取该 `pic` 来准确显示对应的商品图片内容，让用户直观地知晓所购买商品的样子。
* 同时，借助 `@JsonSerialize(using = ImgJsonSerializer.class)` 注解，在将该类对象转换为JSON格式数据（如接口返回数据给前端时），
* 会使用自定义的序列化器对这个属性进行特殊处理，可能是对图片路径进行格式调整、添加域名等操作，使其符合前端展示或者与其他系统交互的要求。
* 通过 `@Schema` 注解明确其描述为“商品图片”并标记为必填项（`required = true`），确保在传递订单项数据时该商品图片信息的完整性，
* 以便顺利实现商品图片展示功能，提升用户体验。
*/
@Schema(description = "商品图片", required = true)
@JsonSerialize(using = ImgJsonSerializer.class)
private String pic;
/**
* `prodName`属性用于存储商品的名称，它是一个能够清晰标识商品具体是什么的字符串，例如“华为P50手机”“耐克运动鞋”等。
* 在订单相关业务中，商品名称是用户快速识别所购买商品的重要依据，无论是在订单详情页面展示给用户查看，
* 还是在进行商品数据统计、查询等操作时，都需要准确的商品名称信息，通过 `@Schema` 注解将其描述为“商品名称”并设为必填项，
* 保证在数据传递过程中商品名称不会缺失，便于各方基于该名称进行相应的业务处理。
*/
@Schema(description = "商品名称", required = true)
private String prodName;
/**
* `prodCount`属性代表商品的数量，即用户在该订单中购买此商品的具体个数，其数据类型为整数类型。
* 这个数量信息对于计算商品的总价（通过与商品价格相乘）、库存管理（确认销售后相应扣减库存）以及后续可能的退换货等业务操作都至关重要，
* 通过 `@Schema` 注解明确其描述为“商品数量”并标记为必填项，确保在传递订单项数据时商品数量信息准确无误，便于准确开展相关业务逻辑。
*/
@Schema(description = "商品数量", required = true)
private Integer prodCount;
/**
* `price`属性存放的是商品的价格信息，通常以货币形式体现，数据类型为 `Double`，它代表了该商品在本次订单中的单价。
* 在订单金额计算（单个商品金额为价格乘以数量，进而汇总得到订单总价）、优惠活动应用（基于商品单价来计算优惠后的价格）等业务场景中，
* 商品价格是关键的基础数据，通过 `@Schema` 注解将其描述为“商品价格”并设为必填项，保证在数据传递过程中价格信息的完整性，
* 便于准确进行与商品价格相关的各种业务操作。
*/
@Schema(description = "商品价格", required = true)
private Double price;
/**
* `skuName`属性用于表示商品的规格名称，也就是常说的SKU（Stock Keeping Unit）名称，它具体描述了商品的特定规格组合情况，
* 例如对于一款手机，SKU名称可能是“8GB内存 + 256GB存储 + 黑色”，清晰地体现了该商品在颜色、内存容量、存储容量等方面的具体规格配置。
* 在订单中，SKU名称有助于更精准地确定用户购买的是该商品的哪一种具体规格，方便进行商品管理、库存管理以及向用户展示详细商品规格信息等操作，
* 通过 `@Schema` 注解明确其描述为“skuName”并设为必填项，确保在传递订单项数据时规格名称信息完整，便于准确把握商品的具体规格情况。
*/
@Schema(description = "skuName", required = true)
private String skuName;
}

71
yami-shop-bean/src/main/java/com/yami/shop/bean/app/dto/NoticeDto.java
Unescape View File

@ -1,71 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.util.Date;
/**
* `NoticeDto`类是一个数据传输对象（DTO），主要用于在电商系统应用层不同组件或模块之间传递公告相关的信息。
* 其作用是将公告的关键数据进行整合封装，方便在诸如公告发布、公告查询、公告展示等业务场景下进行数据传递，
* 使得数据交互更加清晰、规范且符合业务需求，便于不同业务部分基于这些信息进行相应的操作，例如向用户展示具体公告内容、
* 后台管理系统对公告进行分类管理等。
* @author lanhai
*/
@Schema(description = "公告对象")
@Data
public class NoticeDto {
/**
* `id`属性用于存放公告的唯一标识符，也就是公告在系统中的ID值，通常为一个Long类型的数字。
* 这个ID能够在整个系统中精准地定位到某一条具体的公告记录，方便进行数据的管理操作，比如对公告进行更新、删除、
* 查询其详细属性等操作时，都依赖这个唯一标识来确保操作的准确性和针对性。通过 `@Schema` 注解明确其描述为“公告id”，
* 虽然它在当前设定下并非必填项，但在系统数据管理以及后续可能的功能扩展中，这个ID有着重要的标识作用，
* 有助于区分不同的公告内容，保证数据的唯一性和可追溯性。
*/
@Schema(description = "公告id")
private Long id;
/**
* `shopId`属性用于标识该公告所属的店铺ID，在多店铺的电商平台模式下，不同店铺可能会发布各自的公告信息，
* 通过这个属性可以明确公告是与哪个店铺相关联，进而在展示公告时能够按照店铺进行区分和筛选，
* 同时在涉及店铺相关的公告管理操作（如店铺自行发布、修改、删除自己的公告等）时，也依靠这个ID来确定操作对象。
*/
@Schema(description = "店铺id")
private Long shopId;
/**
* `title`属性代表公告的标题，通常是一个简短且能够直观体现公告主题的字符串。
* 例如在电商系统中，可能是“店铺周年庆活动公告”“商品上新通知”等类似的文字表述，它是用户在查看公告列表或者页面展示公告时，
* 首先看到的关键内容，用于吸引用户的注意力，让用户快速了解公告大致的主题，进而决定是否进一步查看公告的详细内容。
*/
@Schema(description = "标题")
private String title;
/**
* `content`属性用于存储公告的具体内容信息，它包含了要传达给用户或者相关人员的详细文字描述，
* 比如对于“店铺周年庆活动公告”这个标题，内容里可能会详细介绍活动的时间、参与方式、优惠内容等具体情况；
* 对于“商品上新通知”的公告，内容中则可能会列出上新的商品名称、特点、价格等信息，是公告的核心组成部分，
* 承载着实际要传递的消息，方便用户全面了解公告所涉及的相关事宜。
*/
@Schema(description = "公告内容")
private String content;
/**
* `publishTime`属性记录的是公告的发布时间，以 `Date` 类型存储，格式一般遵循系统默认的时间格式（例如 `yyyy-MM-dd HH:mm:ss`）。
* 它可以用于数据的溯源、统计分析等操作，比如查看不同时间段内店铺发布了哪些公告、了解公告的发布频率等业务场景中会用到该时间信息，
* 同时也能让用户知晓公告的时效性，判断公告内容是否还在有效期内或者是否是最新发布的内容等。
*/
@Schema(description = "公告发布时间")
private Date publishTime;
}

189
yami-shop-bean/src/main/java/com/yami/shop/bean/app/param/AddrParam.java
Unescape View File

@ -1,189 +0,0 @@
package com.yami.shop.bean.app.param;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull;
/**
* AddrParam类用于封装与地址相关的参数信息，在应用层（app）传递地址相关的数据时使用。
* 此类中的各个属性对应地址的不同组成部分，并且通过相关注解进行了验证约束和描述说明，方便数据的校验与接口文档生成。
*
* @author lanhai
*/
@Schema(description = "地址参数")
public class AddrParam {
/**
* 地址的唯一标识符，用于在系统中区分不同的地址记录。
* 通过 @Schema 注解描述该属性在接口文档中的相关信息，设置为必填项（required=true）。
*/
@Schema(description = "地址ID", required = true)
private Long addrId;
/**
* 收货人的姓名，是地址信息中重要的一部分，不能为空，通过 @NotNull 注解进行验证约束，
* 同时使用 @Schema 注解在接口文档中进行相应描述，且设置为必填项。
*/
@NotNull(message = "收货人不能为空")
@Schema(description = "收货人", required = true)
private String receiver;
/**
* 详细的地址内容，例如街道名称、门牌号等具体的收货地址信息，不能为空，
* 利用 @NotNull 约束验证，通过 @Schema 注解在接口文档中说明，设置为必填项。
*/
@NotNull(message = "地址不能为空")
@Schema(description = "地址", required = true)
private String addr;
/**
* 地址对应的邮编信息，该属性为可选填项（required=false），通过 @Schema 注解在接口文档中体现其属性描述。
*/
@Schema(description = "邮编", required = false)
private String postCode;
/**
* 收货人联系用的手机号码，是确保能联系到收货人的关键信息，不能为空，
* 使用 @NotNull 进行约束，借助 @Schema 注解在接口文档里标记为必填项并描述。
*/
@NotNull(message = "手机不能为空")
@Schema(description = "手机", required = true)
private String mobile;
/**
* 省份的唯一标识符，用于关联对应的省份信息，不能为空，
* 以 @NotNull 做验证，通过 @Schema 注解在接口文档中表明为必填项并描述其用途。
*/
@NotNull(message = "省ID不能为空")
@Schema(description = "省ID", required = true)
private Long provinceId;
/**
* 城市的唯一标识符，用于准确关联到具体的城市信息，不能为空，
* 借助 @NotNull 约束验证，利用 @Schema 注解在接口文档里设置为必填项并描述相关情况。
*/
@NotNull(message = "城市ID不能为空")
@Schema(description = "城市ID", required = true)
private Long cityId;
/**
* 区（县等）的唯一标识符，用于精确到具体的区（县等）级别的地域信息，不能为空，
* 通过 @NotNull 进行验证，使用 @Schema 注解在接口文档中标记为必填项并给出相应说明。
*/
@NotNull(message = "区ID不能为空")
@Schema(description = "区ID", required = true)
private Long areaId;
/**
* 省份的名称，以字符串形式表示具体的省份，不能为空，
* 通过 @NotNull 约束，配合 @Schema 注解在接口文档里设置为必填项并描述其含义。
*/
@NotNull(message = "省不能为空")
@Schema(description = "省", required = true)
private String province;
/**
* 城市的名称，用于明确具体的城市称呼，不能为空，
* 以 @NotNull 进行验证，通过 @Schema 注解在接口文档中设置为必填项并说明情况。
*/
@NotNull(message = "城市不能为空")
@Schema(description = "城市", required = true)
private String city;
/**
* 区（县等）的名称，具体指出所在的区（县等）的名称，不能为空，
* 通过 @NotNull 约束验证，利用 @Schema 注解在接口文档里标记为必填项并加以说明。
*/
@NotNull(message = "区不能为空")
@Schema(description = "区", required = true)
private String area;
// 以下是各个属性的Getter和Setter方法，用于获取和设置对应属性的值
public Long getAddrId() {
return addrId;
}
public void setAddrId(Long addrId) {
this.addrId = addrId;
}
public String getReceiver() {
return receiver;
}
public void setReceiver(String receiver) {
this.receiver = receiver;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
public String getPostCode() {
return postCode;
}
public void setPostCode(String postCode) {
this.postCode = postCode;
}
public String getMobile() {
return mobile;
}
public void setMobile(String mobile) {
this.mobile = mobile;
}
public Long getProvinceId() {
return provinceId;
}
public void setProvinceId(Long provinceId) {
this.provinceId = provinceId;
}
public Long getCityId() {
return cityId;
}
public void setCityId(Long cityId) {
this.cityId = cityId;
}
public Long getAreaId() {
return areaId;
}
public void setAreaId(Long areaId) {
this.areaId = areaId;
}
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getArea() {
return area;
}
public void setArea(String area) {
this.area = area;
}
}

97
yami-shop-bean/src/main/java/com/yami/shop/bean/app/param/ChangeShopCartParam.java
Unescape View File

@ -1,97 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.param;
import jakarta.validation.constraints.NotNull;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* `ChangeShopCartParam`类是一个用于接收修改购物车相关操作参数的数据对象，在电商应用的业务逻辑处理中起着关键作用。
* 它主要用于在前端与后端进行交互时，承载用户发起的修改购物车操作所需的各项数据信息，以便后端能够依据这些参数准确地执行相应的业务逻辑，
* 比如更新购物车中商品的数量、更换商品的规格、处理与分销相关的业务逻辑等操作。
* @author LGH
*/
@Data
public class ChangeShopCartParam {
/**
* `basketId`属性代表购物车中某条商品记录的唯一标识符，也就是购物车ID。
* 在购物车的业务场景中，购物车可以包含多条不同的商品记录，每条记录都有其独立的 `basketId`，
* 通过这个ID，后端服务能够精准地定位到用户想要修改的具体是哪一项商品记录，
* 无论是对商品数量进行调整、删除该商品，还是进行其他与该商品在购物车中相关的操作，都依赖这个唯一标识来确定操作对象。
* 同时，通过 `@Schema` 注解，在生成API文档（例如使用Swagger等工具时）时，为该属性添加“购物车ID”的描述信息，
* 并明确标记其为必填项（`required = true`），告知接口调用者在发起修改购物车操作时必须提供这个参数值，
* 以此保证后端接收到的数据完整性，便于准确执行后续业务逻辑。
*/
@Schema(description = "购物车ID", required = true)
private Long basketId;
/**
* `prodId`属性是商品的唯一标识符，即商品ID。
* 在整个电商系统中，每个商品都被赋予了一个唯一的 `prodId`，用于精确地指代该商品，
* 通过这个ID，后端可以关联到商品的详细信息，如商品名称、价格、规格详情、库存信息等，
* 进而在修改购物车操作中，准确知晓当前操作涉及的是哪个具体商品。
* 这里使用了 `@NotNull` 注解，并设置了相应的提示消息“商品ID不能为空”，
* 用于在数据校验阶段确保前端传递过来的参数中该商品ID不能为空值，若为空则会触发验证错误提示，
* 同时通过 `@Schema` 注解在API文档中表明其描述为“商品ID”且为必填项，确保接口调用时数据的规范性和完整性。
*/
@NotNull(message = "商品ID不能为空")
@Schema(description = "商品ID", required = true)
private Long prodId;
/**
* `skuId`属性表示商品库存保有单位（Stock Keeping Unit，简称SKU）的ID，即具体商品规格的唯一标识符。
* 在电商业务中，同一款商品往往会有多种不同的规格组合，例如一款手机可能有不同的颜色、内存容量等配置，
* 每个不同的规格组合就对应一个独特的SKU，通过这个 `skuId`，能够精准地定位到具体是哪一种规格的商品，
* 以便在修改购物车操作中准确处理与该商品规格相关的业务逻辑，比如更新对应规格商品的数量等。
* 同样，借助 `@NotNull` 注解保证该参数不能为空，若为空会给出“skuId不能为空”的错误提示，
* 且通过 `@Schema` 注解在API文档里明确其描述为“skuId”并标记为必填项，便于接口调用者正确传递参数。
*/
@NotNull(message = "skuId不能为空")
@Schema(description = "skuId", required = true)
private Long skuId;
/**
* `shopId`属性为店铺的唯一标识符，也就是店铺ID。
* 在多店铺的电商平台模式下，不同店铺可能会售卖相同的商品，但商品的库存数量、价格、优惠活动等信息可能各不相同，
* 所以需要通过这个 `shopId` 来明确当前修改购物车操作所涉及商品所属的具体店铺，
* 确保后端能够依据准确的店铺信息来处理诸如库存扣减、价格计算、店铺相关优惠应用等业务逻辑。
* 利用 `@NotNull` 注解强制要求该参数必须提供有效的店铺ID值，若缺失会触发验证错误，
* 并且通过 `@Schema` 注解在API文档中展示其描述为“店铺ID”以及必填属性，保证接口调用的准确性。
*/
@NotNull(message = "店铺ID不能为空")
@Schema(description = "店铺ID", required = true)
private Long shopId;
/**
* `count`属性代表商品的数量，即用户期望在购物车中设置的该商品的个数。
* 在修改购物车操作里，用户常常会调整商品的购买数量，比如从原来购买1个增加到购买2个等情况，
* 这个属性就用于记录用户想要修改后的商品数量值，后端依据该值来更新购物车中对应商品的数量信息，
* 并进一步基于新的数量进行诸如总价重新计算、库存更新等相关业务逻辑处理。
* 通过 `@NotNull` 注解确保该参数不能为空，必须传递有效的数量数值，
* 同时借助 `@Schema` 注解在API文档中明确其描述为“商品个数”且为必填项，方便接口调用者知晓参数要求并正确传递数据。
*/
@NotNull(message = "商品个数不能为空")
@Schema(description = "商品个数", required = true)
private Integer count;
/**
* `distributionCardNo`属性用于存放分销推广人卡号相关信息。
* 在电商平台的分销业务模式下，当用户通过某个分销推广人的链接进入购物并产生购买行为时，
* 这个卡号可以用于追踪该商品销售与推广人的关联关系，以便后续进行相应的分销收益计算、记录等业务操作。
* 该属性并非必填项，其描述信息通过 `@Schema` 注解在API文档中体现为“分销推广人卡号”，
* 告知接口调用者该参数的含义以及在有分销相关业务场景时可以选择性地提供相应卡号信息。
*/
@Schema(description = "分销推广人卡号")
private String distributionCardNo;
}

104
yami-shop-bean/src/main/java/com/yami/shop/bean/app/param/LoginParam.java
Unescape View File

@ -1,104 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.param;
import io.swagger.v3.oas.annotations.media.Schema;
/**
* `LoginParam`类是一个用于接收用户登录相关操作参数的数据对象，在电商系统用户登录的业务逻辑处理中起着关键作用。
* 它主要用于在前端与后端进行交互时，承载用户发起登录操作时所需的各项必要数据信息，以便后端能够依据这些参数准确地执行相应的业务逻辑，
* 比如验证登录信息的合法性、根据不同的登录方式（小程序登录或账号密码登录）进行对应的身份验证等操作。
* @author lanhai
*/
@Schema(description = "登陆参数")
public class LoginParam {
/**
* `code`属性用于存储小程序登录时返回的 `code` 值。在小程序登录的流程中，用户授权登录后，小程序会向微信等平台获取一个临时的 `code`，
* 这个 `code` 会被传递到后端服务器，后端再凭借该 `code` 向对应的平台（如微信开放平台）发起请求，换取用户的相关信息（如唯一标识等），
* 进而完成登录验证操作。通过 `@Schema` 注解明确其描述为“小程序登陆时返回的 `code`（使用 `code` 登陆必填）”，
* 并标记为必填项（`required = true`），以此确保在用户选择小程序登录方式时，前端必须传递这个关键的 `code` 参数给后端，
* 保证登录流程能够顺利进行，避免因缺少必要参数而导致登录失败。
*/
@Schema(description = "小程序登陆时返回的code(使用code登陆必填)", required = true)
private String code;
/**
* `mobile`属性用于存放用户登录时的用户名信息，在采用账号密码登录方式时，这里通常指的是用户的手机号码。
* 手机号码作为常见的账号形式，方便用户记忆且具有唯一性，后端系统会依据这个手机号码去数据库等存储介质中查找对应的用户记录，
* 并与后续传入的密码进行匹配验证，以确认用户身份的合法性。通过 `@Schema` 注解将其描述为“登陆时的用户名（账号密码登陆必填）”，
* 同时设为必填项，告知接口调用者在使用账号密码登录时必须提供有效的手机号码作为用户名，保障登录验证过程有准确的账号依据。
*/
@Schema(description = "登陆时的用户名(账号密码登陆必填)", required = true)
private String mobile;
/**
* `password`属性用于存储用户登录时输入的密码信息，在账号密码登录模式下，它与前面的 `mobile` 属性一同作为验证用户身份的关键要素。
* 用户输入的密码会与后端存储的已加密的密码（出于安全考虑，通常会对密码进行加密存储）进行比对，只有两者匹配时，
* 才会认定用户登录成功。借助 `@Schema` 注解明确其描述为“登陆时的密码（账号密码登陆必填）”，并标记为必填项，
* 强制要求接口调用者在使用账号密码登录方式时必须提供正确的密码，确保登录操作的安全性和准确性。
*/
@Schema(description = "登陆时的密码(账号密码登陆必填)", required = true)
private String password;
/**
* `getCode`方法是一个标准的JavaBean风格的访问器方法（Getter方法），用于获取 `code` 属性的值。
* 在其他类需要访问本类中存储的小程序登录 `code` 参数信息时，可以通过调用这个方法来获取相应的值，遵循了面向对象编程中封装的原则，
* 对属性的访问进行了一定的控制，保证数据获取的规范性和安全性。
*/
public String getCode() {
return code;
}
/**
* `setCode`方法是与 `getCode` 对应的修改器方法（Setter方法），用于设置 `code` 属性的值。
* 当外部需要更新本类中存储的小程序登录 `code` 信息时，可以通过调用这个方法并传入新的字符串值来实现属性值的修改，
* 同样也是遵循JavaBean规范，方便对属性进行赋值操作，同时在方法内部可以添加一些额外的逻辑（如数据验证等）来保障数据的合法性。
*/
public void setCode(String code) {
this.code = code;
}
/**
* `getMobile`方法是用于获取 `mobile` 属性值的Getter方法，其作用与 `getCode` 类似，
* 为外部类提供了获取用户名（手机号码）信息的途径，使得其他部分的代码可以按照规范的方式获取该属性存储的内容，便于后续基于用户名进行相关操作。
*/
public String getMobile() {
return mobile;
}
/**
* `setMobile`方法是对应 `getMobile` 的Setter方法，用于设置 `mobile` 属性的值，
* 当需要更新用户名（手机号码）信息时，外部代码可以调用这个方法传入新的字符串值来改变属性的存储内容，
* 并且可以在方法内部根据业务需求添加必要的数据校验等逻辑，确保设置的手机号码符合要求。
*/
public void setMobile(String mobile) {
this.mobile = mobile;
}
/**
* `getPassword`方法是获取 `password` 属性值的Getter方法，通过调用它，
* 其他类能够获取到本类中存储的密码信息，方便在后续的业务逻辑中，例如密码验证等操作中使用该密码作为关键的比对依据，
* 确保业务操作围绕准确的登录密码展开。
*/
public String getPassword() {
return password;
}
/**
* `setPassword`方法是用于设置 `password` 属性值的Setter方法，当需要更新密码信息时（例如用户修改密码等情况），
* 外部代码可以调用这个方法传入新的字符串值来改变其存储内容，同样也可以在方法内部添加适当的数据验证逻辑，保障密码的合法性和安全性。
*/
public void setPassword(String password) {
this.password = password;
}
}

57
yami-shop-bean/src/main/java/com/yami/shop/bean/dto/HotSearchDto.java
Unescape View File

@ -1,57 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serializable;
/**
* `HotSearchDto`类是一个数据传输对象（DTO），主要用于在电商系统应用层不同组件或模块之间传递热搜相关的数据信息。
* 其作用是将与热搜有关的关键数据进行整合封装，方便在诸如搜索功能模块、页面展示等业务场景下进行数据传递，
* 使得数据的交互更加清晰、规范且符合业务需求，便于不同业务部分基于这些信息进行相应的操作，例如展示热门搜索词条、
* 根据热搜进行相关商品推荐等。
* @author lanhai
*/
@Schema(description = "热搜数据")
@Data
public class HotSearchDto implements Serializable {
/**
* `hotSearchId`属性用于存放热搜的唯一标识符，也就是热搜在系统中的ID值，通常为一个Long类型的数字。
* 这个ID能够在整个系统中精准地定位到某一条具体的热搜记录，方便进行数据的管理操作，比如对热搜词条进行更新、删除、
* 查询其详细属性等操作时，都依赖这个唯一标识来确保操作的准确性和针对性。通过 `@Schema` 注解明确其描述为“热搜id”，
* 虽然它在当前设定下并非必填项，但在系统数据管理以及后续可能的功能扩展中，这个ID有着重要的标识作用，
* 有助于区分不同的热搜内容，保证数据的唯一性和可追溯性。
*/
@Schema(description = "热搜id")
private Long hotSearchId;
/**
* `title`属性代表热搜的标题，通常是一个简短且能够直观体现用户搜索意图或者热门搜索主题的字符串。
* 例如在电商系统中，可能是“夏季连衣裙”“智能手机推荐”等类似的文字表述，它是用户在搜索界面看到的热搜词条的主要展示内容，
* 用于吸引用户点击并进行相应的搜索操作，进而查看与该标题相关的商品、内容等信息。通过 `@Schema` 注解将其描述为“标题”，
* 方便在API文档（如使用Swagger等工具生成时）或者代码注释中清晰地表明该属性的含义，便于开发人员理解和使用。
*/
@Schema(description = "标题")
private String title;
/**
* `content`属性用于存储与热搜相关的具体内容信息，其具体形式和含义可以根据业务场景有所不同。
* 在一些情况下，它可能是对热搜标题更详细的补充说明，比如对于“夏季连衣裙”这个热搜标题，内容里可能会包含一些流行款式、
* 热门颜色等相关介绍；也有可能是关联到该热搜词条下的一些关键商品信息、推荐理由等内容，方便在用户点击热搜词条后，
* 展示更丰富、有价值的信息供用户参考。通过 `@Schema` 注解标记其为“内容”，明确该属性在整个 `HotSearchDto` 类中所承载的数据含义，
* 便于在不同业务环节准确运用该属性所存储的信息。
*/
@Schema(description = "内容")
private String content;
}

85
yami-shop-bean/src/main/java/com/yami/shop/bean/enums/AreaLevelEnum.java
Unescape View File

@ -1,85 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.enums;
/**
* AreaLevelEnum 是一个枚举类，用于定义地区层级相关的常量值，方便在系统中统一表示和区分不同层级的地区，
* 例如省级、市级、区（县）级等不同层级可以对应此枚举中的不同常量，使得代码在处理地区层级相关逻辑时更加清晰和规范。
*
* @author cl
*/
public enum AreaLevelEnum {
/**
* FIRST_LEVEL 代表地区层级中的第一层，通常可以用于表示最高层级的地区，比如省级地区，
* 其对应的整数值为 1，在数据库存储或者业务逻辑判断地区层级时可以依据此值进行相关操作。
*/
FIRST_LEVEL(1),
/**
* SECOND_LEVEL 表示地区层级中的第二层，一般可以对应市级地区，
* 其整数值为 2，方便在构建地区层级关系以及相关业务处理中识别和区分该层级的地区。
*/
SECOND_LEVEL(2),
/**
* THIRD_LEVEL 指代地区层级中的第三层，常见用于表示区（县）级等更细化的地区层级，
* 对应的数值是 3，有助于在涉及地区层级相关的查询、展示等功能中准确判断和处理相应层级的地区信息。
*/
THIRD_LEVEL(3)
;
/**
* 用于存储每个枚举常量对应的整数值，该值可以用于在业务逻辑中与数据库中的地区层级字段值进行对比等操作，
* 以此来确定地区所处的具体层级情况。
*/
private Integer num;
/**
* 获取当前枚举常量对应的整数值的方法，外部代码可以通过调用此方法获取具体的数值，
* 便于在各种业务场景下（如数据存储、层级判断等）使用该数值进行后续操作。
*
* @return 当前枚举常量对应的整数值
*/
public Integer value() {
return num;
}
/**
* 枚举类的构造方法，用于初始化每个枚举常量对应的整数值，在定义枚举常量时传入相应的整数值进行赋值，
* 确保每个枚举常量都有与之对应的表示地区层级的数值。
*
* @param num 用于表示地区层级的整数值
*/
AreaLevelEnum(Integer num) {
this.num = num;
}
/**
* 根据传入的整数值查找对应的 AreaLevelEnum 枚举常量的静态方法，
* 在业务逻辑中如果已知地区层级的数值表示，可通过调用此方法获取对应的枚举常量，
* 方便进行基于枚举的后续操作，比如根据层级进行不同的业务处理逻辑分支等。
* 如果传入的数值没有对应的枚举常量匹配，则返回 null。
*
* @param value 表示地区层级的整数值
* @return 对应的 AreaLevelEnum 枚举常量，如果不存在匹配则返回 null
*/
public static AreaLevelEnum instance(Integer value) {
AreaLevelEnum[] enums = values();
for (AreaLevelEnum statusEnum : enums) {
if (statusEnum.value().equals(value)) {
return statusEnum;
}
}
return null;
}
}

62
yami-shop-bean/src/main/java/com/yami/shop/bean/enums/MessageStatus.java
Unescape View File

@ -1,62 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.enums;
/**
* `MessageStatus`枚举类用于定义消息状态相关的常量值，在电商系统或者其他涉及消息处理的业务场景中，
* 可以通过这些明确的枚举值来清晰地表示消息所处的不同状态，方便在业务逻辑中进行判断、处理以及数据存储等操作，
* 使得代码对于消息状态的处理更加规范、易读且不容易出现歧义。
* @author lanhai
*/
public enum MessageStatus {
/**
* `CANCEL`枚举值表示消息被取消的状态，对应的整数值为 `0`。
* 在实际业务场景中，例如用户手动取消了某个消息提醒，或者系统根据一定规则判定某个消息不再需要展示、处理时，
* 可以将消息的状态设置为 `CANCEL`，通过这个枚举值来清晰地传达消息已经处于取消状态这一信息，
* 方便后续业务逻辑根据此状态进行相应的操作，比如不再推送该消息、在消息列表中隐藏该条消息等。
*/
CANCEL(0),
/**
* `RELEASE`枚举值代表消息已发布的状态，其对应整数值为 `1`。
* 当一条消息经过相关流程创建完成并且可以对外展示、推送或者供用户查看时，
* 其状态就可以设置为 `RELEASE`，意味着该消息处于正常有效的发布状态，在业务逻辑里，
* 例如消息推送服务会根据这个状态来决定是否将消息发送给对应的用户，前端页面也会依据此状态来展示相应的消息内容等。
*/
RELEASE(1);
/**
* `num`属性用于存储每个枚举值对应的整数值，通过这种方式建立起枚举值与具体数值的映射关系，
* 在需要将枚举值转换为对应的数字进行存储（比如存储到数据库中）或者在不同模块间传递以数字形式表示的状态信息时会用到，
* 使得可以用统一的数字规则来表示不同的消息状态，便于系统进行数据处理和交互。
*/
private Integer num;
/**
* `value`方法用于获取当前枚举值对应的整数值，它提供了一种外部访问 `num` 属性的途径，
* 在其他类需要知晓某个 `MessageStatus` 枚举值具体对应的数字时，可以通过调用这个方法来获取相应的值，
* 遵循了面向对象编程中对数据访问进行封装控制的原则，保证了数据获取的规范性和安全性。
*/
public Integer value() {
return num;
}
/**
* 构造方法用于初始化每个枚举值对应的整数值，在定义枚举常量（如 `CANCEL(0)` 和 `RELEASE(1)`）时会调用此构造方法，
* 将传入的整数值赋给 `num` 属性，建立起枚举常量和对应数值之间的关联，确保每个枚举值都有正确的数值与之对应，
* 以便后续通过 `value` 方法等进行准确的数值获取操作。
*/
MessageStatus(Integer num) {
this.num = num;
}
}

42
yami-shop-bean/src/main/java/com/yami/shop/bean/event/CancelOrderEvent.java
Unescape View File

@ -1,42 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 包声明，表明该类所在的包名，这里定义在com.yami.shop.bean.event包下，
// 按照Java的包结构规范，通常用于对相关类进行组织和分类管理，方便代码的模块化开发和维护。
package com.yami.shop.bean.event;
// 导入Order类，因为在本类中会使用到Order类型的变量，通过导入对应的类，
// 才能在代码中正确地引用和操作该类型，此处表示从com.yami.shop.bean.model包中引入Order类。
import com.yami.shop.bean.model.Order;
// Lombok注解，用于自动生成包含所有参数的构造函数，
// 这样在创建CancelOrderEvent类的实例时，可以方便地通过传入相应参数来初始化对象。
import lombok.AllArgsConstructor;
// Lombok注解，用于自动生成类的getter、setter方法以及其他一些常用的方法（如toString等），
// 减少了手动编写这些重复代码的工作量，提高代码的简洁性和开发效率。
import lombok.Data;
// 类的文档注释，简要描述了该类的作用，即表示取消订单的事件。
// 这种注释有助于其他开发人员快速理解该类在整个业务逻辑中的用途。
/**
* 取消订单的事件
* @author
*/
// 使用@Data注解，让Lombok自动为该类生成相关的方法，如getter、setter等。
// 使用@AllArgsConstructor注解，让Lombok自动生成包含所有参数的构造函数。
@Data
@AllArgsConstructor
// 定义CancelOrderEvent类，用于表示取消订单这一业务事件相关的信息，
// 通常在基于事件驱动的架构中，此类可以作为事件对象在不同组件之间传递相关的业务数据。
public class CancelOrderEvent {
// 定义一个私有成员变量order，类型为Order，用于存储被取消的订单相关的详细信息，
// 比如订单编号、下单用户、商品明细、订单金额等内容，方便在事件传递过程中获取和处理订单相关的数据。
private Order order;
}

62
yami-shop-bean/src/main/java/com/yami/shop/bean/event/ConfirmOrderEvent.java
Unescape View File

@ -1,62 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.event;
import com.yami.shop.bean.app.dto.ShopCartDto;
import com.yami.shop.bean.app.dto.ShopCartItemDto;
import com.yami.shop.bean.app.dto.ShopCartOrderDto;
import com.yami.shop.bean.app.dto.ShopCartOrderMergerDto;
import com.yami.shop.bean.app.param.OrderParam;
import lombok.AllArgsConstructor;
import lombok.Data;
import java.util.List;
/**
* `ConfirmOrderEvent`类是一个用于封装确认订单相关业务信息的事件类，它遵循领域驱动设计（DDD）中领域事件的概念，
* 在电商系统等涉及订单处理的业务场景中发挥着重要作用。当用户进行确认订单操作时，会触发该事件，
* 该类的实例对象会承载确认订单这一时刻所涉及的关键数据信息，并在不同的业务组件或模块之间传递，
* 使得其他关注确认订单事件的部分能够基于这些数据进行相应的业务逻辑处理，比如订单金额计算、库存扣减、
* 订单记录保存等后续操作，确保整个订单确认流程的准确与完整。
* @author LGH
*/
@Data
@AllArgsConstructor
public class ConfirmOrderEvent {
/**
* `shopCartOrderDto`属性用于存放购物车已经组装好的店铺订单信息。
* 在电商购物流程中，用户将商品加入购物车后，当准备确认订单时，系统会根据购物车中的商品、店铺等信息，
* 按照一定规则（例如按照不同店铺进行订单拆分、合并等）组装出每个店铺对应的订单信息，
* 这个 `ShopCartOrderDto` 对象就包含了诸如店铺的基本信息（店铺名称、店铺ID等）、
* 该店铺下所有商品的汇总信息（商品总价、商品总数量等）以及其他与店铺订单相关的必要数据，
* 方便后续在确认订单阶段基于店铺维度进行进一步的业务处理，比如计算店铺优惠、生成店铺订单详情等操作。
*/
private ShopCartOrderDto shopCartOrderDto;
/**
* `orderParam`属性承载了下单请求的各项参数信息。
* 这些参数通常是由用户在前端界面填写或者系统根据默认规则生成的，例如用户的收货地址、联系人姓名、
* 联系电话、选择的支付方式等关键信息，它们对于生成完整准确的订单记录至关重要，
* 后续的订单创建、保存以及与第三方支付平台交互（如果涉及）等业务逻辑都会依赖这些参数进行相应操作，
* 确保订单能够按照用户期望的方式被处理和执行。
*/
private OrderParam orderParam;
/**
* `shopCartItems`属性是一个列表，用于存储店铺中的所有商品项信息，每个元素是 `ShopCartItemDto` 类型。
* 在确认订单阶段，需要详细了解购物车中每个具体商品的详细情况，包括商品的具体规格（通过对应的SKU信息体现）、
* 商品单价、购买数量以及商品在购物车中的唯一标识等信息，这个列表就完整地记录了这些商品项的详细数据，
* 方便在后续业务逻辑中，例如计算每个商品的实际金额、更新商品库存、生成订单商品明细等操作时使用，
* 确保订单中商品相关信息的准确性和完整性。
*/
private List<ShopCartItemDto> shopCartItems;
}

69
yami-shop-bean/src/main/java/com/yami/shop/bean/model/Area.java
Unescape View File

@ -1,69 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.model;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.io.Serializable;
import java.util.List;
/**
* Area类用于表示地区相关的实体信息，对应数据库中的"tz_area"表结构，
* 通过使用MyBatis Plus的相关注解来映射数据库表字段，同时利用Lombok的 @Data 注解简化了实体类的Getter、Setter等方法的编写。
* 此类主要用于在系统中传递、操作和存储地区相关的数据，比如地区的基本信息以及其下级地区列表等情况。
*
* @author lanhai
*/
@Data
@TableName("tz_area") // 表明该实体类对应的数据库表名称为"tz_area"，方便MyBatis Plus进行数据库操作时的表关联映射
public class Area implements Serializable {
private static final long serialVersionUID = -6013320537436191451L;
/**
* 地区的唯一标识符，通过 @TableId 注解标记其为数据库表中的主键字段，
* 利用 @Schema 注解描述该属性在接口文档中的相关信息，设置为必填项（required=true），用于在系统中唯一标识一个地区记录。
*/
@TableId
@Schema(description = "地区id", required = true)
private Long areaId;
/**
* 地区的名称，用于直观展示地区的称呼，通过 @Schema 注解在接口文档中进行相应描述，且设置为必填项，
* 比如可以是省份名称、城市名称或者区（县）名称等具体的地区称谓。
*/
@Schema(description = "地区名称", required = true)
private String areaName;
/**
* 地区的上级地区的唯一标识符，用于构建地区之间的层级关系，即指明当前地区隶属于哪个上级地区，
* 通过 @Schema 注解在接口文档中表明其为必填项，方便在查询地区层级结构等操作时进行关联查找。
*/
@Schema(description = "地区上级id", required = true)
private Long parentId;
/**
* 地区所处的层级，例如省级可以是1级，市级可以是2级，区（县）级可以是3级等，
* 通过 @Schema 注解在接口文档里设置为必填项并描述其用途，用于清晰地体现地区在整个地域层级体系中的位置。
*/
@Schema(description = "地区层级", required = true)
private Integer level;
/**
* 该字段用于存储当前地区的下级地区列表，通过 @TableField(exist=false) 注解表示此属性并非数据库表中的实际字段，
* 而是在业务逻辑处理过程中，用于临时存放其下级地区信息，比如在构建地区树形结构等操作时会使用到，方便进行层级关联展示等功能。
*/
@TableField(exist = false)
private List<Area> areas;
}

84
yami-shop-bean/src/main/java/com/yami/shop/bean/model/AttachFile.java
Unescape View File

@ -1,84 +0,0 @@
/*
* Copyright (c) 2018 - 2999 广州市蓝海创新科技有限公司 All rights reserved.
* 版权声明部分，表明该代码文件的版权归属为广州市蓝海创新科技有限公司，版权有效期从2018年至2999年。
*
* https://www.mall4j.com/
* 给出了公司相关的网址，可能用于更多信息查询等用途。
*
* 未经允许，不可做商业用途！
* 强调此代码未经公司许可，不能用于商业方面的使用场景，旨在保护版权所有者的权益。
*
* 版权所有，侵权必究！
* 明确声明若存在侵犯该代码版权的行为，公司将依法追究责任。
*/
package com.yami.shop.bean.model;
// 声明该类所属的包名，用于在项目的代码组织结构中对类进行分类管理，方便代码的组织、查找以及不同模块间的引用。
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
// 引入MyBatis Plus相关注解和Lombok的Data注解，用于简化代码编写以及实现实体类与数据库表的映射等功能。
import java.io.Serializable;
import java.util.Date;
// 引入Java标准库中的接口和类，Serializable接口用于标记该类对象可以被序列化，方便在网络传输、存储等场景下进行对象状态的保存和恢复；Date类用于处理日期相关的数据。
/**
* @author lanhai
* 类的作者信息，此处表明该类是由名为lanhai的开发者编写。
*/
@Data
// Lombok的@Data注解，它会自动为类生成常用的方法，包括所有成员变量的getter和setter方法、toString方法、equals方法以及hashCode方法等，极大地减少了手动编写这些重复代码的工作量，使代码更加简洁。
@TableName("tz_attach_file")
// MyBatis Plus的@TableName注解，用于将当前的实体类与数据库中的具体表进行映射关联，这里表明AttachFile类对应数据库中的"tz_attach_file"表，方便后续进行数据库操作时框架能够准确地知道操作的数据来源和目标表。
public class AttachFile implements Serializable {
// 定义一个名为AttachFile的公共类，它实现了Serializable接口，意味着该类的实例对象能够进行序列化操作，比如可以保存到文件、在网络间传输等场景中使用。
@TableId
// MyBatis Plus的@TableId注解，用于标识该成员变量对应的是数据库表中的主键字段，在数据库操作（如查询、更新、删除等）中，主键是用于唯一标识每条记录的关键属性。
private Long fileId;
// 定义一个名为fileId的私有成员变量，类型为Long，用于存储文件在系统中的唯一标识符，通常对应数据库表中主键列的值，通过它可以准确地定位和操作某一条具体的文件相关记录。
/**
* 文件路径
* 对成员变量filePath的功能描述，说明该变量用于存储文件在存储系统中的具体路径信息，例如在文件系统中的绝对路径或者相对路径等，通过这个路径可以找到对应的物理文件进行读取、写入等操作。
*/
private String filePath;
// 定义一个名为filePath的私有成员变量，类型为String，用于记录文件的存储路径。
/**
* 文件类型
* 此注释说明该成员变量fileType的用途是保存文件的类型信息，常见的文件类型如"txt"（文本文件）、"jpg"（图片文件）、"pdf"（PDF文档）等，通过该变量可以方便地识别文件的格式，进而进行相应格式特定的处理操作。
*/
private String fileType;
// 定义一个名为fileType的私有成员变量，类型为String，用于存储文件的类型标识。
/**
* 文件大小
* 表明fileSize变量用于记录文件所占用的字节数大小，在文件管理场景中，比如判断文件是否超出存储限制、统计存储资源使用情况等方面，该变量起着重要作用。
*/
private Integer fileSize;
// 定义一个名为fileSize的私有成员变量，类型为Integer，用于存储文件的大小数值，通常以字节为单位来衡量。
/**
* 上传时间
* 解释uploadTime变量的作用是记录文件被上传到当前系统的具体时间，可用于文件操作历史记录、按照时间顺序对文件进行排序、统计不同时间段内的文件上传情况等功能实现。
*/
private Date uploadTime;
// 定义一个名为uploadTime的私有成员变量，类型为Date，用于保存文件上传的时间信息。
/**
* 文件关联的表主键id
* 说明fileJoinId变量的功能是存储与该文件相关联的其他数据表中记录的主键标识符，通过这个关联主键，可以建立起文件与其他业务数据表之间的联系，实现数据的关联查询、整合等操作。
*/
private Long fileJoinId;
// 定义一个名为fileJoinId的私有成员变量，类型为Long，用于记录与文件相关联的其他表的主键值。
/**
* 文件关联表类型：1 商品表 @see FileJoinType
* 对fileJoinType变量的详细说明，它用于表示文件所关联的表的类型，当前示例中值为1时表示关联的是商品表（更完整的关联类型可能通过FileJoinType枚举类等方式进一步定义规范，通过@see注解提示查看相关定义），通过该变量可以区分文件在不同业务场景下与不同数据表之间的关联关系。
*/
private Integer fileJoinType;
// 定义一个名为fileJoinType的私有成员变量，类型为Integer，用于标识文件关联表的类型信息。
}

75
yami-shop-bean/src/main/java/com/yami/shop/bean/model/Basket.java
Unescape View File

@ -1,75 +0,0 @@
package com.yami.shop.bean.model;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* Basket类用于表示购物车相关的实体信息。
* 它对应数据库中的"tz_basket"表，通过MyBatis Plus的注解来映射表结构与实体类的关系。
* 此类实现了Serializable接口，方便进行对象的序列化操作，例如在网络传输或持久化存储时使用。
*
* @author lanhai
*/
@Data
@TableName("tz_basket")
public class Basket implements Serializable {
/**
* 主键，用于唯一标识购物车中的每一条记录。
* 在数据库表"tz_basket"中对应的字段为主键字段，通常由数据库自动生成或者按照特定规则赋值。
*/
@TableId
private Long basketId;
/**
* 店铺ID，用于标识商品所属的店铺。
* 通过该ID可以关联到对应的店铺信息，比如查询店铺的名称、地址等其他相关属性。
*/
private Long shopId;
/**
* 产品ID，用于确定购物车中具体是哪个产品。
* 可以依据此ID去获取产品的详细信息，如产品名称、价格、描述等内容。
*/
private Long prodId;
/**
* SkuID，代表具体的库存保有单位（Stock Keeping Unit）的编号。
* 不同的Sku可能对应产品的不同规格、颜色、尺寸等变体，通过该ID能准确区分同一产品下的不同库存单元。
*/
private Long skuId;
/**
* 用户ID，用于标识该购物车记录所属的用户。
* 可以通过该ID关联到用户的其他信息，比如用户名、联系方式等，以确定是哪位用户添加的商品到购物车。
* 这里是用字符串类型，可能是根据具体业务系统中用户ID的格式设定（比如可能包含字母等复杂格式）。
*/
private String userId;
/**
* 购物车产品个数，记录了当前购物车中对应商品的数量。
* 用于在计算购物车总价、库存校验等业务场景中发挥作用。
*/
private Integer basketCount;
/**
* 购物时间，记录了用户将商品添加到购物车的具体时间。
* 可以用于分析用户行为，例如统计不同时间段的购物车添加频率等业务需求。
*/
private Date basketDate;
/**
* 满减活动ID，用于关联对应的满减活动。
* 如果商品参与了某个满减活动，通过该ID可以获取活动的详细规则，如满多少金额减多少等信息，以在结算等环节应用相应优惠。
*/
private Long discountId;
/**
* 分销推广人卡号，用于标识在分销业务场景下，将该商品推荐给用户的推广人员的卡号信息。
* 通过这个卡号可以进行分销相关的业绩统计、佣金计算等操作。
*/
private String distributionCardNo;
}

96
yami-shop-bean/src/main/java/com/yami/shop/bean/model/Brand.java
Unescape View File

@ -1,96 +0,0 @@
package com.yami.shop.bean.model;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* Brand类用于表示品牌相关的实体信息，对应数据库中的"tz_brand"表，
* 通过MyBatis Plus的注解（如@TableName）来建立实体类与数据库表之间的映射关系，
* 同时实现了Serializable接口，便于对象在诸如网络传输、持久化存储等场景下进行序列化操作。
*
* @author lanhai
*/
@Data
@TableName("tz_brand")
public class Brand implements Serializable {
/**
* 主键，用于在数据库中唯一标识每一个品牌记录。
* 在数据库表"tz_brand"中对应的字段是主键字段，是区分不同品牌实体的关键标识，
* 通常在数据插入等操作时由数据库按照一定规则（如自增）来生成或者进行合理赋值。
*/
@TableId
private Long brandId;
/**
* 品牌名称，用于展示给用户或者在业务逻辑中区分不同品牌的关键属性。
* 例如在前端界面的品牌列表展示、商品筛选等场景中，都会依据这个名称来呈现品牌相关信息。
*/
private String brandName;
/**
* 图片路径，指向存储品牌相关图片的具体位置。
* 可以是本地文件系统的路径，也可能是网络存储的URL等形式，通过这个路径能够获取品牌对应的展示图片，
* 比如在品牌详情页面展示品牌logo或者宣传图片等场景会用到该图片。
*/
private String brandPic;
/**
* 用户ID，用于标识与该品牌相关操作的用户主体。
* 例如可能是创建这个品牌的用户、最后更新品牌信息的用户等，通过该ID可以关联到用户的详细信息，
* 像用户名、所属部门等，方便进行权限管理、操作记录追溯等业务处理。
*/
private String userId;
/**
* 备注，用于记录一些关于品牌的额外说明信息。
* 比如品牌的特殊背景、历史沿革、适用场景等补充性的描述内容，便于内部人员更好地了解品牌相关情况。
*/
private String memo;
/**
* 顺序，用于定义品牌在某些特定展示或排序场景下的先后次序。
* 例如在品牌列表页面按照一定规则排序展示时，依据这个顺序字段来排列品牌的先后顺序，方便用户查看。
*/
private Integer seq;
/**
* 默认是1，表示正常状态，0为下线状态，用于标记品牌当前所处的业务状态。
* 在业务流程中，根据品牌是否还在正常运营、是否需要对外展示等情况来设置该状态值，
* 比如对已停止合作的品牌可以将其状态设为0使其下线，不再出现在常规的品牌展示列表中。
*/
private Integer status;
/**
* 简要描述，提供品牌的一个简短概括性的介绍内容。
* 相比于备注信息可能更精炼，常用于在一些列表页面等有限空间内快速展示品牌的关键特点或定位等信息。
*/
private String brief;
/**
* 记录时间，记录品牌相关信息首次被创建或者录入系统的时间点。
* 可用于数据统计分析，比如统计不同时间段新品牌的创建数量等业务需求，也有助于了解品牌数据的历史情况。
*/
private Date recTime;
/**
* 更新时间，标记品牌信息最后一次被修改的时间。
* 有助于判断数据的时效性，以及在一些需要基于更新时间来进行同步、版本控制等业务场景中发挥作用。
*/
private Date updateTime;
/**
* 品牌首字母，通常用于一些快速索引、分类筛选的场景。
* 比如在按照首字母排序的品牌导航栏中，依据这个首字母来对品牌进行归类展示，方便用户查找特定品牌。
*/
private String firstChar;
/**
* 内容，可用于存储更详细、更丰富的关于品牌的文本描述内容。
* 可以包含品牌故事、品牌文化、产品特色等综合性的信息，具体的使用场景和格式可根据业务实际需求确定。
*/
private String content;
}

170
yami-shop-bean/src/main/java/com/yami/shop/bean/model/Category.java
Unescape View File

@ -1,170 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 声明该类所在的包名，按照Java的包结构组织方式，将相关的类放在同一个包下方便管理和区分不同功能模块的代码，
// 这里表示该类属于com.yami.shop.bean.model包。
package com.yami.shop.bean.model;
// 导入MyBatis Plus的注解TableField，用于定义实体类中字段与数据库表字段之间的一些额外映射关系，
// 比如指定字段是否在数据库表中有对应列等情况。
import com.baomidou.mybatisplus.annotation.TableField;
// 导入MyBatis Plus的注解TableId，用于标记实体类中的主键字段，使得MyBatis Plus能正确识别与数据库表主键的对应关系。
import com.baomidou.mybatisplus.annotation.TableId;
// 导入MyBatis Plus的注解TableName，用于将实体类与数据库中的具体表进行映射，表明该实体类对应哪个数据库表。
import com.baomidou.myatisplus.annotation.TableName;
// 导入Jackson的注解JsonSerialize，用于指定在将对象转换为JSON格式时，对特定字段使用自定义的序列化方式。
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
// 导入自定义的ImgJsonSerializer类，它应该是用于处理图片相关字段序列化的类，
// 在这里配合@JsonSerialize注解来对特定的图片字段进行定制化的JSON序列化操作。
import com.yami.shop.common.serializer.json.ImgJsonSerializer;
// 导入Lombok的Data注解，使用该注解后，Lombok会自动为类生成常用的方法，比如getter、setter、toString等方法，
// 减少了手动编写这些重复代码的工作量，提高代码的简洁性和开发效率。
import lombok.Data;
// 导入Java的相关接口和类，用于实现对象的序列化功能（Serializable接口）以及处理日期相关操作（Date类），
// 还有用于操作列表数据结构（List接口），使得该类能更好地满足常见的业务需求，比如数据存储、传输等场景。
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* 该类的文档注释，简单说明了类的作者信息，这里作者是lanhai，
* 一般可以在此处更详细地描述类的功能和用途，方便其他开发人员快速理解该类在整个项目中的角色。
* @author lanhai
*/
// 使用@Data注解，让Lombok自动生成类的getter、setter等常用方法，简化代码编写。
// 使用@TableName注解，将该Category类与数据库中的"tz_category"表进行映射关联，意味着该类的实例可以与数据库表中的记录相互转换操作。
@Data
@TableName("tz_category")
public class Category implements Serializable {
/**
* 类目ID的成员变量声明及注释，用于唯一标识每个类目，
* 在数据库表"tz_category"中对应的是主键字段，是区分不同类目记录的关键标识，
* 其值的生成方式可能由数据库按照既定规则（如自增等）来确定，以保证每条类目记录都有唯一的ID。
*/
@TableId
private Long categoryId;
/**
* 店铺id的成员变量声明及注释，用于关联对应的店铺信息，
* 通过该店铺id可以获取店铺的详细情况，例如店铺名称、主营类目等，明确该类目是属于哪个具体店铺的，
* 有助于在多店铺的应用场景下进行类目数据的分类管理和相关业务操作。
*/
private Long shopId;
/**
* 父节点的成员变量声明及注释，用于表示当前类目的上级类目ID，
* 这里默认初始化为0L，表示如果没有明确的父类目（比如顶级类目）时的默认值，
* 通过这个字段可以构建类目之间的层级关系，方便进行类目树的展示、查询等操作。
*/
private Long parentId = 0L;
/**
* 产品类目名称的成员变量声明及注释，用于展示给用户或者在业务逻辑中区分不同类目的关键属性，
* 例如在前端界面的类目列表展示、商品筛选等场景中，都会依据这个名称来呈现类目相关信息，帮助用户快速定位和选择感兴趣的商品类目。
*/
private String categoryName;
/**
* 类目图标的成员变量声明及注释，用于指向存储类目相关图标文件的具体位置，
* 可以是本地文件系统的路径，也可能是网络存储的URL等形式，通过这个路径能够获取类目对应的图标，
* 比如在前端界面展示类目时，使用该图标来直观地表示类目，提升用户体验。
*/
private String icon;
/**
* 类目的显示图片的成员变量声明及注释，通过@JsonSerialize注解指定使用ImgJsonSerializer自定义类来进行序列化，
* 意味着在将该类的对象转换为JSON格式（比如用于接口返回数据等场景）时，对这个图片字段会按照自定义的序列化逻辑进行处理，
* 可能涉及到图片路径格式的调整、图片加载相关逻辑等，方便前端正确获取和展示类目对应的显示图片。
*/
@JsonSerialize(using = ImgJsonSerializer.class)
private String pic;
/**
* 排序的成员变量声明及注释，用于定义类目在某些特定展示或排序场景下的先后次序，
* 例如在类目列表页面按照一定规则排序展示时，依据这个顺序字段来排列类目的先后顺序，方便用户查看，
* 也有助于在后台管理类目时按照期望的顺序进行管理操作。
*/
private Integer seq;
/**
* 默认是1，表示正常状态，0为下线状态的成员变量声明及注释，用于标记类目当前所处的业务状态，
* 在业务流程中，根据类目是否还在正常使用、是否需要对外展示等情况来设置该状态值，
* 比如对已停止运营或不再需要展示的类目可以将其状态设为0使其下线，不再出现在常规的类目展示列表中。
*/
private Integer status;
/**
* 记录时间的成员变量声明及注释，用于记录类目相关信息首次被创建或者录入系统的时间点，
* 可用于数据统计分析，比如统计不同时间段新类目的创建数量等业务需求，也有助于了解类目数据的历史情况。
*/
private Date recTime;
/**
* 分类层级的成员变量声明及注释，用于表示当前类目所处的层级深度，
* 通过该字段可以更清晰地构建和了解类目树的结构，例如一级类目层级值可能为1，二级类目层级值为2等，方便进行层级相关的业务操作和查询。
*/
private Integer grade;
/**
* 更新时间的成员变量声明及注释，用于标记类目信息最后一次被修改的时间，
* 有助于判断数据的时效性，以及在一些需要基于更新时间来进行同步、版本控制等业务场景中发挥作用，
* 比如在缓存类目数据时，根据更新时间来判断是否需要重新获取最新的类目数据。
*/
private Date updateTime;
/**
* 品牌id的成员变量声明及注释，使用@TableField(exist=false)注解表示该字段在数据库表"tz_category"中不存在对应列，
* 它用于存储与该类目关联的品牌的ID列表，方便在业务逻辑中查询和处理与该类目相关的品牌信息，比如获取该类目下有哪些品牌的商品等。
*/
@TableField(exist=false)
private List<Long> brandIds;
/**
* 参数id的成员变量声明及注释，同样使用@TableField(exist=false)注解表明在数据库表中无对应列，
* 用于存储与该类目相关的参数的ID列表，在业务中可以依据这些参数来进一步描述类目下商品的特性、属性等信息，
* 例如商品的尺寸、颜色等参数与类目进行关联管理。
*/
@TableField(exist=false)
private List<Long> attributeIds;
/**
* 品牌列表的成员变量声明及注释，通过@TableField(exist=false)注解说明在数据库表中没有对应物理列，
* 用于存储与该类目相关的具体品牌对象列表，相比于只存储品牌ID，这里可以更方便地获取和操作品牌的详细信息，
* 比如品牌名称、品牌图片等，在涉及类目与品牌关联展示、查询等业务场景中使用。
*/
@TableField(exist=false)
private List<Brand> brands;
/**
* 参数列表的成员变量声明及注释，借助@TableField(exist=false)注解指出在数据库表中不存在相应列，
* 用于存放与该类目相关的具体参数对象列表，方便在业务逻辑中详细了解类目下商品所涉及的各种属性参数情况，
* 比如对商品进行筛选、展示详细规格等操作时会用到这些参数对象。
*/
@TableField(exist=false)
private List<ProdProp> prodProps;
/**
* 商品列表的成员变量声明及注释，使用@TableField(exist=false)注解表明其不在数据库表中有对应列，
* 用于存储属于该类目的商品对象列表，便于在业务操作中查询和获取该类目下包含哪些具体的商品，
* 比如在类目详情页面展示类目下的商品列表、进行类目商品统计等场景会用到该列表。
*/
@TableField(exist=false)
private List<Product> products;
/**
* 类目列表的成员变量声明及注释，通过@TableField(exist=false)注解说明在数据库表中没有对应的列，
* 用于存储当前类目下的子类目对象列表，通过这个字段可以构建和遍历类目树结构，方便进行类目层级相关的展示、查询等业务操作，
* 例如展示类目树的展开和收起效果时需要用到子类目列表信息。
*/
@TableField(exist=false)
private List<Category> categories;
}

59
yami-shop-bean/src/main/java/com/yami/shop/bean/model/CategoryBrand.java
Unescape View File

@ -1,59 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.dto;
import lombok.Data;
import java.io.Serializable;
/**
* 该类用于封装购物车中被选中的满减活动项的相关信息，作为数据传输对象（DTO）在应用层各组件或模块间传递相应数据。
* 在电商系统等涉及购物车与促销活动交互的业务场景中，当用户在购物车页面选择参与某些满减活动时，
* 每个被选中的满减活动项具体信息就会被整理封装到此类的实例对象中，以便后续进行诸如计算优惠金额、
* 展示活动详情、更新购物车总价等业务操作时使用，同时保证了数据传递的规范性和完整性，
* 避免了直接传递零散、复杂的数据结构，方便不同业务层之间进行交互协作。
*
* @author lanhai
*/
@Data
public class ChooseDiscountItemDto implements Serializable {
// 此处可根据实际业务需求添加相应的属性及对应的注释，以下为示例，可按需调整替换
/**
* 满减活动项的唯一标识符，用于在系统中精准定位该满减活动项的详细信息。
* 例如在数据库中可以通过该ID查询到活动项对应的满减规则（如满多少金额减多少金额等具体规则）、
* 活动的有效期限、适用的商品范围等相关内容，方便后续业务逻辑围绕该活动项进行准确处理。
*/
private Long discountItemId;
/**
* 关联的满减活动的ID，指向整个满减活动的总体定义信息。
* 一个满减活动可能包含多个不同的活动项，通过这个ID可以获取到该满减活动的通用属性，
* 像活动名称、活动发起方（是平台发起还是店铺发起等）等基础信息，便于从整体上把握该满减活动的全貌。
*/
private Long discountActivityId;
/**
* 该满减活动项在本次购物车选中场景下可减免的金额数值。
* 用于明确当前所选的这个满减活动项具体能为用户节省多少钱，是计算购物车最终总价、
* 展示优惠明细等操作中重要的数据依据，在向用户展示优惠情况或者进行金额相关业务逻辑处理时会频繁用到。
*/
private Double discountAmount;
/**
* 表示该满减活动项是否已经生效的标识，通常可以用布尔类型（true或false）来表示。
* 例如当满足了活动项设定的前置条件（如购物车商品总价达到规定金额等）时，该标识会被设置为true，
* 意味着此活动项开始生效，相应的优惠金额可以进行扣除等操作；反之则为false，
* 方便在业务逻辑中判断活动项的执行状态，确保优惠计算的准确性。
*/
private boolean isActive;
}

53
yami-shop-bean/src/main/java/com/yami/shop/bean/model/CategoryProp.java
Unescape View File

@ -1,53 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.model;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.io.Serializable;
/**
* `CategoryProp`类是一个实体类，用于表示商品分类与商品属性之间的关联关系，在电商系统等业务场景中有着重要作用。
* 它主要负责在数据库层面记录每个商品分类下具体关联了哪些商品属性，方便后续基于分类进行商品属性相关的操作，
* 例如在展示商品详情、进行商品筛选以及查询符合特定属性要求的商品时，依据这种关联关系获取相应的数据。
*
* @author lanhai
*/
@Data
@TableName("tz_category_prop")
public class CategoryProp implements Serializable {
/**
* `id`属性作为该类的主键，是每条分类与属性关联记录在数据库中的唯一标识符。
* 它具有唯一性，通过这个 `id`，系统能够在数据库中精准地定位、操作某一条具体的分类属性关联记录，
* 比如在更新、删除特定的关联关系或者根据关联记录查询相关信息时，都要依赖这个唯一标识来确保操作的准确性和针对性，
* 是整个关联关系数据管理中的关键标识字段。
*/
@TableId
private Long id;
/**
* `categoryId`属性用于标识关联的商品分类的ID，它与系统中定义的商品分类体系相连接。
* 通过这个ID可以明确当前这条关联记录所属的具体商品分类，例如在电商系统中，它可能对应着诸如“服装”分类、
* “数码产品”分类等具体分类的唯一标识，借助该ID还能进一步获取该分类的其他详细信息，
* 像分类名称、分类的层级结构以及与之关联的其他相关数据等，为基于分类的各种业务逻辑处理提供基础依据。
*/
private Long categoryId;
/**
* `propId`属性代表商品属性的ID，它对应着系统中另外一个用于定义商品属性的相关数据表（如 `tz_prod_prop` 表）里的 `prop_id` 字段。
* 此属性的作用是确定具体是哪个商品属性与当前分类进行了关联，例如在“数码产品”分类下，
* 这个 `propId` 可能指向“屏幕尺寸”这个具体属性的标识，通过该ID可以获取到该属性更详细的内容，
* 比如属性的名称、可选的值范围等信息，从而在商品展示、筛选等业务操作中准确地呈现相应的属性详情，
* 方便用户根据属性来挑选商品。
*/
private Long propId;
}

73
yami-shop-bean/src/main/java/com/yami/shop/bean/model/Delivery.java
Unescape View File

@ -1,73 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.model;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* `Delivery`类是一个实体类，用于表示物流公司相关的信息，在电商系统等业务场景中有着重要的作用，
* 主要负责在数据库层面记录物流公司的各项关键数据，方便后续进行与物流相关的业务操作，
* 例如查询物流信息、展示可用的物流公司列表、根据物流公司配置进行快递单号查询等操作。
* @author lanhai
*/
@Data
@TableName("tz_delivery")
public class Delivery implements Serializable {
/**
* `dvyId`属性作为该类的主键，是每条物流公司记录在数据库中的唯一标识符。
* 它具有唯一性，通过这个 `dvyId`，系统能够在数据库中精准地定位、操作某一条具体的物流公司相关记录，
* 比如在更新、删除特定物流公司信息或者根据该ID查询其详细属性时，都要依赖这个唯一标识来确保操作的准确性和针对性，
* 是整个物流公司数据管理中的关键标识字段。
*/
@TableId
private Long dvyId;
/**
* `dvyName`属性用于存储物流公司的名称，例如“顺丰速运”“中通快递”“圆通速递”等常见的物流公司称谓。
* 在电商系统中，用户在选择快递配送方式或者查看订单物流信息时，会看到这个名称展示出来，
* 便于直观地识别是哪家物流公司负责包裹的运输，同时也是关联到具体物流服务的重要标识信息。
*/
private String dvyName;
/**
* `companyHomeUrl`属性存放物流公司的公司主页网址，即用户可以通过访问这个网址了解该物流公司的更多详细信息，
* 比如公司的服务范围、业务介绍、客服联系方式等内容，在电商系统中，可能会为用户提供链接跳转功能，
* 使其能够方便地访问物流公司官网获取相关资讯，不过该属性也可能存在部分物流公司未提供网址而为空值的情况。
*/
private String companyHomeUrl;
/**
* `recTime`属性代表物流公司相关信息的建立时间，通常记录的是这条物流公司记录首次被创建并录入系统的日期和时间，
* 以 `Date` 类型存储，格式一般遵循系统默认的时间格式（例如 `yyyy-MM-dd HH:mm:ss`），
* 它可以用于数据的溯源、统计分析等操作，比如查看不同时间段内新增了哪些物流公司等业务场景中会用到该时间信息。
*/
private Date recTime;
/**
* `modifyTime`属性用于记录物流公司信息的最后修改时间，同样是以 `Date` 类型呈现具体的时间点，
* 每次对该物流公司的相关属性（如名称、网址、物流查询接口等）进行更新操作后，这个时间会随之更新，
* 方便在数据管理中知晓该条记录最近一次的变动情况，也有助于进行数据版本控制、审计等相关业务处理。
*/
private Date modifyTime;
/**
* `queryUrl`属性存放的是物流公司的物流查询接口网址，在电商系统需要获取某个订单的物流实时状态时，
* 可以通过调用该网址对应的接口（按照接口规定的请求参数、方式等）来获取相应的物流信息，
* 例如快递包裹的当前位置、运输状态等关键数据，是实现物流信息查询功能的重要配置信息。
*/
private String queryUrl;
}

68
yami-shop-bean/src/main/java/com/yami/shop/bean/model/HotSearch.java
Unescape View File

@ -1,68 +0,0 @@
package com.yami.shop.bean.model;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.util.Date;
/**
* HotSearch类用于表示热门搜索相关的实体信息，对应数据库中的"tz_hot_search"表。
* 通过MyBatis Plus的相关注解（如@TableName）来建立实体类与数据库表之间的映射关系，
* 同时实现了Serializable接口，便于在需要的场景（如网络传输、持久化存储等）下对该对象进行序列化操作。
*
* @author lanhai
*/
@Data
@TableName("tz_hot_search")
public class HotSearch implements Serializable {
/**
* 主键，用于在数据库中唯一标识每一条热门搜索记录。
* 在"tz_hot_search"表中，此主键字段是区分不同热门搜索项的关键标识，
* 其值的生成方式可能由数据库按照既定规则（比如自增等）来确定，以保证每条记录都有唯一的标识。
*/
@TableId
private Long hotSearchId;
/**
* 店铺id，用于关联对应的店铺信息。
* 通过该店铺id可以获取店铺的详细情况，例如店铺名称、主营类目等，明确该热门搜索内容是属于哪个具体店铺的，
* 有助于在多店铺的应用场景下进行针对性的搜索展示和管理。
*/
private Long shopId;
/**
* 标题，作为热门搜索项呈现给用户的主要文字描述内容。
* 它通常简洁明了地概括了用户可能感兴趣的搜索主题，比如商品类别名称、热门促销活动主题等，方便用户快速识别和点击搜索。
*/
private String title;
/**
* 内容，用于进一步详细阐述热门搜索项相关的信息。
* 相较于标题更为详细，可能包含具体的商品推荐、活动详情、搜索关键词的具体解释等内容，辅助用户更好地理解搜索项所涉及的内容。
*/
private String content;
/**
* 录入时间，记录该热门搜索项被添加到系统中的具体时间点。
* 可以用于数据统计分析，比如统计不同时间段新增的热门搜索项数量，也有助于按照时间顺序对搜索项进行展示或管理等操作。
* 此处通过@DateTimeFormat注解指定了日期时间的格式化模式为"yyyy-MM-dd HH:mm:ss"，方便在数据绑定等操作时进行正确的格式转换。
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date recDate;
/**
* 顺序，用于确定热门搜索项在展示列表中的先后排列次序。
* 在前端页面展示热门搜索列表时，可依据这个顺序字段来合理安排各项的展示顺序，使得重要或热门程度高的搜索项优先展示给用户，提升用户体验。
*/
private Integer seq;
/**
* 状态，默认是1，表示正常状态，0为下线状态，用于标记热门搜索项当前所处的业务状态。
* 在实际业务中，根据搜索项是否还符合当前业务需求、是否需要继续展示给用户等情况来设置该状态值，
* 例如某些季节性的搜索主题结束后，可将其状态设为0使其下线，不在热门搜索列表中呈现给用户了。
*/
private Integer status;
}

129
yami-shop-bean/src/main/java/com/yami/shop/bean/model/IndexImg.java
Unescape View File

@ -1,129 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.model;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.yami.shop.common.serializer.json.ImgJsonSerializer;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* `IndexImg`类是一个实体类，用于表示电商系统首页图片相关的信息，在首页展示、图片管理等业务场景中有着重要作用，
* 它主要负责在数据库层面记录首页图片的各项关键数据，方便后续进行诸如图片展示顺序调整、图片关联商品设置、
* 图片状态管理等操作。
* @author lanhai
*/
@Data
@TableName("tz_index_img")
public class IndexImg implements Serializable {
private static final long serialVersionUID = -3468251351681518798L;
/**
* `imgId`属性作为该类的主键，是每条首页图片记录在数据库中的唯一标识符。
* 它具有唯一性，通过这个 `imgId`，系统能够在数据库中精准地定位、操作某一条具体的首页图片相关记录，
* 比如在更新、删除特定首页图片信息或者根据该ID查询其详细属性时，都要依赖这个唯一标识来确保操作的准确性和针对性，
* 是整个首页图片数据管理中的关键标识字段。
*/
@TableId
private Long imgId;
/**
* `shopId`属性用于标识该图片所属的店铺ID，在多店铺的电商平台模式下，不同店铺可能有各自独立的首页图片展示需求，
* 通过这个属性可以明确图片是与哪个店铺相关联，进而在展示首页图片时能够按照店铺进行区分和筛选，
* 同时在涉及店铺相关的图片管理操作（如店铺自行上传、修改、删除自己的首页图片等）时，也依靠这个ID来确定操作对象。
*/
private Long shopId;
/**
* `imgUrl`属性存放的是图片的网络地址或者在系统中的存储路径等信息，具体取决于系统的图片存储和访问方式。
* 例如在使用云存储服务时，可能是该图片在云存储中的完整URL地址；若是本地存储，则可能是相对系统根目录的文件路径，
* 这个属性用于在前端页面展示首页图片时，准确获取并显示对应的图片内容，是实现图片展示功能的关键数据之一。
*/
private String imgUrl;
/**
* `des`属性用于存储图片的说明文字或者描述信息，它可以对图片展示的内容、目的等进行简要介绍，
* 比如对于一张展示某款商品的图片，这里的描述可能是“新款夏季连衣裙，时尚优雅”之类的文字，帮助用户更好地理解图片所传达的信息，
* 同时在一些图片管理操作或者页面排版时，也可以参考这些描述来进行合理的布局和安排。
*/
private String des;
/**
* `title`属性代表图片的标题，通常是一个简洁且能概括图片核心内容的字符串，
* 例如“热门商品推荐”“限时优惠活动”等，在前端展示图片时，标题可能会以一定的样式显示在图片上方或附近位置，
* 起到突出主题、吸引用户关注的作用，也是图片相关信息展示的重要组成部分。
*/
private String title;
/**
* `link`属性存放的是图片所关联的链接地址，当用户点击首页图片时，会跳转到这个链接指向的页面，
* 链接的目标页面可以是商品详情页、活动专题页、店铺主页等不同类型的页面，具体根据业务需求和图片的用途来设定，
* 以此实现通过图片引导用户进行相应的浏览和操作，提升用户在平台内的交互体验。
*/
private String link;
/**
* `status`属性用于表示图片的状态，一般用整数类型来表示不同的状态值，例如可以设定 `0` 表示图片未启用（暂不展示），
* `1` 表示图片已启用（正常展示）等状态定义，通过这个属性可以方便地对首页图片进行展示与否的控制，
* 比如在后台管理系统中，管理员可以根据业务情况随时更改图片的状态，从而调整首页图片的展示效果。
*/
private Integer status;
/**
* `seq`属性代表图片的展示顺序，同样是整数类型，用于确定在首页展示图片时各个图片的先后排列次序，
* 可以按照业务需求设定较小的数值在前、较大的数值在后等排序规则，通过调整不同图片的 `seq` 值，
* 能够灵活地改变首页图片的展示顺序，实现对首页展示效果的个性化定制和优化。
*/
private Integer seq;
/**
* `uploadTime`属性记录的是图片的上传时间，以 `Date` 类型存储，格式一般遵循系统默认的时间格式（例如 `yyyy-MM-dd HH:mm:ss`），
* 它可以用于数据的溯源、统计分析等操作，比如查看不同时间段内店铺上传了哪些首页图片、了解图片的更新频率等业务场景中会用到该时间信息。
*/
private Date uploadTime;
/**
* `type`属性用于区分图片的类型，不同的整数值可以对应不同的图片分类，例如 `1` 表示商品推荐图片，`2` 表示活动宣传图片，
* `3` 表示店铺形象展示图片等，通过这种分类方式，可以在业务逻辑中针对不同类型的图片进行差异化的处理和展示，
* 也便于进行分类管理和统计分析等操作。
*/
private int type;
/**
* `relation`属性用于存放与图片相关联的其他数据的唯一标识符，比如可能关联到某个商品的 `id`、某个活动的 `id` 等，
* 其具体含义取决于业务场景中图片与其他实体的关联关系设定，通过这个属性可以建立起图片与其他业务对象之间的联系，
* 方便在进行相关业务操作时（如根据图片查找关联商品、获取关联活动详情等）获取对应的关联数据。
*/
private Long relation;
/**
* `pic`属性用于存放商品图片相关信息，它与数据库表字段的映射有所不同，通过 `@TableField(exist = false)` 注解表明该属性
* 在数据库表中并不实际存在对应的字段，但在业务逻辑处理或者数据传输过程中可能会用到。同时使用 `@JsonSerialize(using = ImgJsonSerializer.class)`
* 注解意味着在将该类对象转换为JSON格式（例如在接口返回数据给前端时）会使用自定义的序列化器对这个属性进行特殊处理，
* 可能是对图片路径进行格式调整、添加域名等操作，使其符合前端展示或者与其他系统交互的要求，便于展示商品图片的相关信息。
*/
@TableField(exist = false)
@JsonSerialize(using = ImgJsonSerializer.class)
private String pic;
/**
* `prodName`属性用于存储商品名称，同样是通过 `@TableField(exist = false)` 注解表示其在数据库表中无对应字段，
* 但在涉及与商品相关的业务逻辑以及数据展示时会用到该属性，比如在首页图片关联商品展示时，除了显示图片本身，
* 还可以同时展示对应的商品名称，让用户更直观地了解图片所涉及的商品信息，提升用户体验。
*/
@TableField(exist = false)
private String prodName;
}

104
yami-shop-bean/src/main/java/com/yami/shop/bean/model/Message.java
Unescape View File

@ -1,104 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.app.param;
import io.swagger.v3.oas.annotations.media.Schema;
/**
* `LoginParam`类是一个用于接收用户登录相关操作参数的数据对象，在电商系统用户登录的业务逻辑处理中起着关键作用。
* 它主要用于在前端与后端进行交互时，承载用户发起登录操作时所需的各项必要数据信息，以便后端能够依据这些参数准确地执行相应的业务逻辑，
* 比如验证登录信息的合法性、根据不同的登录方式（小程序登录或账号密码登录）进行对应的身份验证等操作。
* @author lanhai
*/
@Schema(description = "登陆参数")
public class LoginParam {
/**
* `code`属性用于存储小程序登录时返回的 `code` 值。在小程序登录的流程中，用户授权登录后，小程序会向微信等平台获取一个临时的 `code`，
* 这个 `code` 会被传递到后端服务器，后端再凭借该 `code` 向对应的平台（如微信开放平台）发起请求，换取用户的相关信息（如唯一标识等），
* 进而完成登录验证操作。通过 `@Schema` 注解明确其描述为“小程序登陆时返回的 `code`（使用 `code` 登陆必填）”，
* 并标记为必填项（`required = true`），以此确保在用户选择小程序登录方式时，前端必须传递这个关键的 `code` 参数给后端，
* 保证登录流程能够顺利进行，避免因缺少必要参数而导致登录失败。
*/
@Schema(description = "小程序登陆时返回的code(使用code登陆必填)", required = true)
private String code;
/**
* `mobile`属性用于存放用户登录时的用户名信息，在采用账号密码登录方式时，这里通常指的是用户的手机号码。
* 手机号码作为常见的账号形式，方便用户记忆且具有唯一性，后端系统会依据这个手机号码去数据库等存储介质中查找对应的用户记录，
* 并与后续传入的密码进行匹配验证，以确认用户身份的合法性。通过 `@Schema` 注解将其描述为“登陆时的用户名（账号密码登陆必填）”，
* 同时设为必填项，告知接口调用者在使用账号密码登录时必须提供有效的手机号码作为用户名，保障登录验证过程有准确的账号依据。
*/
@Schema(description = "登陆时的用户名(账号密码登陆必填)", required = true)
private String mobile;
/**
* `password`属性用于存储用户登录时输入的密码信息，在账号密码登录模式下，它与前面的 `mobile` 属性一同作为验证用户身份的关键要素。
* 用户输入的密码会与后端存储的已加密的密码（出于安全考虑，通常会对密码进行加密存储）进行比对，只有两者匹配时，
* 才会认定用户登录成功。借助 `@Schema` 注解明确其描述为“登陆时的密码（账号密码登陆必填）”，并标记为必填项，
* 强制要求接口调用者在使用账号密码登录方式时必须提供正确的密码，确保登录操作的安全性和准确性。
*/
@Schema(description = "登陆时的密码(账号密码登陆必填)", required = true)
private String password;
/**
* `getCode`方法是一个标准的JavaBean风格的访问器方法（Getter方法），用于获取 `code` 属性的值。
* 在其他类需要访问本类中存储的小程序登录 `code` 参数信息时，可以通过调用这个方法来获取相应的值，遵循了面向对象编程中封装的原则，
* 对属性的访问进行了一定的控制，保证数据获取的规范性和安全性。
*/
public String getCode() {
return code;
}
/**
* `setCode`方法是与 `getCode` 对应的修改器方法（Setter方法），用于设置 `code` 属性的值。
* 当外部需要更新本类中存储的小程序登录 `code` 信息时，可以通过调用这个方法并传入新的字符串值来实现属性值的修改，
* 同样也是遵循JavaBean规范，方便对属性进行赋值操作，同时在方法内部可以添加一些额外的逻辑（如数据验证等）来保障数据的合法性。
*/
public void setCode(String code) {
this.code = code;
}
/**
* `getMobile`方法是用于获取 `mobile` 属性值的Getter方法，其作用与 `getCode` 类似，
* 为外部类提供了获取用户名（手机号码）信息的途径，使得其他部分的代码可以按照规范的方式获取该属性存储的内容，便于后续基于用户名进行相关操作。
*/
public String getMobile() {
return mobile;
}
/**
* `setMobile`方法是对应 `getMobile` 的Setter方法，用于设置 `mobile` 属性的值，
* 当需要更新用户名（手机号码）信息时，外部代码可以调用这个方法传入新的字符串值来改变属性的存储内容，
* 并且可以在方法内部根据业务需求添加必要的数据校验等逻辑，确保设置的手机号码符合要求。
*/
public void setMobile(String mobile) {
this.mobile = mobile;
}
/**
* `getPassword`方法是获取 `password` 属性值的Getter方法，通过调用它，
* 其他类能够获取到本类中存储的密码信息，方便在后续的业务逻辑中，例如密码验证等操作中使用该密码作为关键的比对依据，
* 确保业务操作围绕准确的登录密码展开。
*/
public String getPassword() {
return password;
}
/**
* `setPassword`方法是用于设置 `password` 属性值的Setter方法，当需要更新密码信息时（例如用户修改密码等情况），
* 外部代码可以调用这个方法传入新的字符串值来改变其存储内容，同样也可以在方法内部添加适当的数据验证逻辑，保障密码的合法性和安全性。
*/
public void setPassword(String password) {
this.password = password;
}
}

76
yami-shop-bean/src/main/java/com/yami/shop/bean/model/Notice.java
Unescape View File

@ -1,76 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.model;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.util.Date;
/**
* 公告管理
*
* @author hzm
* @date 2019-04-18 21:21:40
*/
@Data
@TableName("tz_notice")
public class Notice implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 公告id
*/
@TableId
private Long id;
/**
* 店铺id
*/
private Long shopId;
/**
* 公告标题
*/
private String title;
/**
* 公告内容
*/
private String content;
/**
* 状态(1:公布 0:撤回)
*/
private Integer status;
/**
* 是否置顶（1:是 0：否）
*/
private Integer isTop;
/**
* 发布时间
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date publishTime;
/**
* 更新时间
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
}

217
yami-shop-bean/src/main/java/com/yami/shop/bean/model/Order.java
Unescape View File

@ -1,217 +0,0 @@
package com.yami.shop.bean.model;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* @author lanhai
* @description Order类用于表示电商系统中的订单信息实体，它涵盖了从订单创建到完结整个过程涉及的各类关键数据，
* 并且通过相关注解与数据库表进行映射以及方便地生成常用方法，便于在各业务层对订单数据进行操作处理。
*/
@Data
// 使用@TableName注解指定该实体类对应的数据库表名为"tz_order"，用于MyBatis Plus框架建立实体与表的映射关系
@TableName("tz_order")
public class Order implements Serializable {
private static final long serialVersionUID = 6222259729062826852L;
/**
* @description 订单ID，是订单在系统中的唯一标识符，使用@TableId注解表明在数据库表"tz_order"中此字段为表的主键。
*/
@TableId
private Long orderId;
/**
* @description 店铺id，用于标识该订单所属的店铺，通过此id可以关联查询店铺的其他相关信息，如店铺名称、店铺配置等。
*/
private Long shopId;
/**
* @description 产品名称，当订单包含多个产品时，多个产品名称将会以逗号隔开。
* 这种方式可以简单呈现订单内商品情况，但对于复杂产品信息处理不够灵活，如需详细产品信息可能需关联其他表。
*/
private String prodName;
/**
* @description 订购用户ID，唯一标识下此订单的用户，借助该字段可以关联到用户的各种信息，例如用户基本资料、历史订单等，
* 方便从用户角度对订单进行诸如查询、统计等操作。
*/
private String userId;
/**
* @description 订购流水号，一般具有唯一性，常用于在业务系统中作为订单的外部标识，
* 在与外部系统对接（如支付回调、物流查询等场景）或者在内部业务流程中通过流水号快速定位和查询具体订单时会用到。
*/
private String orderNumber;
/**
* @description 总值，代表订单中商品在未考虑优惠、运费等因素之前的总价值，是统计订单商品价值的基础数据项。
*/
private Double total;
/**
* @description 实际总值，是订单经过各种优惠、折扣以及加上运费等调整之后，用户实际需要支付的总金额，
* 反映了订单最终真实的消费金额情况，对于财务统计等业务操作十分重要。
*/
private Double actualTotal;
/**
* @description 支付方式，通过约定的整数值来区分不同支付渠道，例如：1 表示微信支付，2 表示支付宝支付。
* 方便后续根据支付方式进行支付相关的统计、对账以及不同支付方式下对应的业务逻辑处理（如退款逻辑差异等）。
*/
private Integer payType;
/**
* @description 订单备注，是一个文本字段，用于用户或者业务操作人员填写关于订单的一些特殊说明或者备注信息，
* 比如对商品的特殊要求、对配送时间的额外说明等，方便在查看订单详情时了解额外情况。
*/
private String remarks;
/**
* @description 订单状态，通过定义的整数值来标识订单目前所处的业务流程阶段，具体含义如下：
* - -1：已取消，表示订单已被取消，可能需要进行相关资源释放、数据清理等操作；
* - 0：待付款，对应订单创建后等待用户付款的阶段，可设置定时提醒用户付款等功能；
* - 1：待发货，意味着订单已付款，等待商家发货，此时可通知仓库进行发货操作；
* - 2：待收货，代表商品已发货，等待用户收货确认；
* - 3：已完成，标志着订单整个业务流程全部结束，例如用户确认收货或者系统自动确认收货等情况后所处的状态。
* 不同状态用于驱动不同的业务流程流转以及相应的业务逻辑处理。
*/
private Integer status;
/**
* @description 配送类型，用于记录订单的配送类型相关信息，不过目前代码中未明确具体约定的取值内容，
* 常见的可能如快递、自提等不同的配送分类方式，方便后续根据配送类型来安排具体的物流配送环节以及在前端展示给用户相应的配送信息提示。
*/
private String dvyType;
/**
* @description 配送方式ID，关联具体配送方式的唯一标识，可能对应数据库中存储配送方式详细信息（如快递的具体快递公司、自提的具体门店等信息）的表的主键，
* 通过这个字段可以进一步获取详细的配送相关细节内容。
*/
private Long dvyId;
/**
* @description 物流单号，当订单进入发货阶段，物流单号用于跟踪物流运输的进度，用户可以通过这个单号在对应的物流查询平台查询包裹的实时位置等信息，
* 同时系统内部也可以通过对接物流接口，利用物流单号来获取物流状态更新到订单信息中，方便用户查看。
*/
private String dvyFlowId;
/**
* @description 订单运费，记录该订单产生的运费金额，如果订单有包邮规则或者运费计算逻辑，这个字段会记录最终计算得出的需要用户支付或者商家承担的运费数值，
* 对于统计订单成本、用户实际支付金额等方面是一个重要的数据项。
*/
private Double freightAmount;
/**
* @description 用户订单地址Id，关联用户订单地址的唯一标识，通过这个字段可以从数据库中查询到订单对应的收货地址或者发货地址（如果有不同的地址需求场景）的详细信息，
* 比如地址、联系人、联系电话等，确保货物能准确地送达指定地点。
*/
private Long addrOrderId;
/**
* @description 订单商品总数，用于统计该订单中包含的商品总数量，便于快速了解订单的规模大小，
* 也可以在一些业务逻辑中，比如根据商品数量判断是否满足某些优惠条件、统计商品销售总量等方面起到作用。
*/
private Integer productNums;
/**
* @description 订购时间，使用@DateTimeFormat注解指定日期格式为"yyyy-MM-dd HH:mm:ss"，用于记录订单创建的时间点，
* 在业务中可以根据创建时间进行订单的排序、查询某个时间段内的订单等操作，例如查询当天的新订单、统计每月新增订单数量等都依赖于这个时间字段。
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* @description 订单更新时间，同样使用@DateTimeFormat注解指定日期格式，记录订单信息最后一次更新的时间，
* 比如订单状态改变、地址修改、备注添加等任何对订单数据有修改操作时，都会更新这个时间字段，方便跟踪订单数据的变更历史以及在一些业务场景中判断数据的时效性等。
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
/**
* @description 付款时间，使用@DateTimeFormat注解指定日期格式，当用户完成订单支付后，会记录支付操作完成的具体时间，
* 这个时间对于统计支付成功率、分析支付时间段的分布等支付相关的业务分析以及后续涉及到退款等业务逻辑判断支付是否已完成等方面都有重要作用。
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date payTime;
/**
* @description 发货时间，使用@DateTimeFormat注解指定日期格式，记录订单商品实际发货的时间，
* 通过这个时间可以计算物流运输时长、统计发货效率等，同时也可以作为判断订单状态是否准确（比如是否应该从待发货变为待收货等状态）的依据之一。
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date dvyTime;
/**
* @description 完成时间，使用@DateTimeFormat注解指定日期格式，表示订单整个业务流程全部结束（例如用户确认收货或者系统自动确认收货等情况）后记录的时间，
* 标志着订单的最终完结，对于统计订单完成率、分析订单平均完成时长等业务指标有帮助。
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date finallyTime;
/**
* @description 取消时间，使用@DateTimeFormat注解指定日期格式，当订单被取消时，会记录取消操作发生的时间，
* 对于后续分析订单取消原因、统计取消订单的时间分布等情况提供数据支持，也有助于确保业务数据的完整性和可追溯性。
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date cancelTime;
/**
* @description 是否已经支付，通过整数值来表示，1表示已经支付过，0表示没有支付过。
* 在很多业务逻辑中，比如判断是否可以发货、是否可以进行退款等都需要先判断这个支付状态，避免出现业务流程上的错误。
*/
private Integer isPayed;
/**
* @description 用户订单删除状态，通过整数值来区分不同的删除程度，具体含义如下：
* - 0：没有删除，表示订单正常存在于系统中，未进行删除操作；
* - 1：回收站，意味着订单已被标记为删除，进入回收站状态，此时可能还可以恢复；
* - 2：永久删除，代表订单已被彻底删除，无法再恢复了。
* 方便对订单数据的管理和数据存储空间的合理利用，同时也符合一般系统中数据删除的逻辑设计习惯。
*/
private Integer deleteStatus;
/**
* @description 退款状态，用于记录订单退款相关的状态，具体含义如下：
* - 0：默认，表示退款相关操作未开始或者初始状态；
* - 1：在处理，代表用户发起退款申请后，退款流程正在进行中，例如处于审核等阶段；
* - 2：处理完成，说明退款操作经过相应流程后已完成，便于跟踪退款业务的进展情况以及在不同阶段进行相应的业务处理和提醒等操作。
*/
private Integer refundSts;
/**
* @description 优惠总额，记录该订单享受到的各种优惠（如优惠券、满减活动、折扣等）累计的金额总数，
* 通过这个字段可以清晰地了解到用户在该订单上节省了多少钱，同时对于商家统计营销活动成本、分析优惠策略效果等方面也是重要的数据依据。
*/
private Double reduceAmount;
/**
* @description 店铺名称，使用@TableField(exist = false)注解表明此字段并不对应数据库表"tz_order"中的实际列，
* 它可能是在业务逻辑处理或者数据查询展示过程中，通过关联查询等方式获取到店铺名称后，临时存储在这个实体类对象中的一个属性，
* 方便在前端展示或者其他业务场景中直接获取店铺名称信息，而不用再次去查询数据库。
*/
@TableField(exist = false)
private String shopName;
/**
* @description 订单商品明细列表，使用@TableField(exist = false)注解说明这个字段不对应数据库表中的列，
* 它一般用于存储订单中包含的具体商品明细信息（每个OrderItem可以表示一个商品项的详细情况，如商品ID、商品数量、商品单价等），
* 通常是在查询订单详情等场景下，通过关联查询或者其他业务逻辑组装好商品明细列表后赋值给这个字段，方便一次性获取订单的完整商品信息。
*/
@TableField(exist = false)
private List<OrderItem> orderItems;
/**
* @description 用户订单地址信息对象，使用@TableField(exist = false)注解表示该字段不对应数据库表列，
* 它用于存储与该订单关联的用户地址详细信息对象（UserAddrOrder类应该包含地址相关的各种详细内容，如地址、联系人、联系电话等），
* 方便在获取订单信息时能同时获取到对应的完整地址信息，减少额外查询数据库获取地址的操作。
*/
@TableField(exist = false)
private UserAddrOrder userAddrOrder;
}

54
yami-shop-bean/src/main/java/com/yami/shop/bean/order/ConfirmOrderOrder.java
Unescape View File

@ -1,54 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.order;
/**
* `ConfirmOrderOrder`接口用于定义提交订单事件先后顺序相关的常量，在电商系统的订单处理业务流程中，
* 特别是涉及多种优惠活动、业务规则应用于订单的场景下，起到明确各环节执行顺序的重要作用。
* 通过定义这些顺序常量，系统可以清晰地知晓在提交订单时，不同优惠、业务逻辑处理的先后顺序，
* 确保订单金额计算、优惠叠加等操作按照合理且符合业务要求的顺序进行，避免出现逻辑混乱或计算错误的情况。
* @author LGH
*/
public interface ConfirmOrderOrder {
/**
* `DEFAULT`常量表示在没有任何活动参与时的默认顺序，其值为0。
* 当订单不存在如满减、优惠券、分销等特殊优惠活动或业务逻辑时，
* 系统按照这个默认顺序来处理订单相关的基础操作，例如计算商品原价总和、
* 确定基本的运费（如果有）等，它作为一个基准顺序，其他涉及活动的顺序都基于此进行相对排序。
*/
int DEFAULT = 0;
/**
* `DISCOUNT`常量代表满减活动在整个订单处理顺序中的位置，其值为100，排在 `DEFAULT` 后面。
* 在电商系统中，满减活动是常见的优惠方式之一，当订单满足满减活动的条件（如购物车商品总价达到一定金额可减免部分金额）时，
* 系统会按照这个顺序来处理满减优惠的计算和应用，确保在完成基础的订单金额计算（即 `DEFAULT` 顺序对应的操作）之后，
* 再进行满减金额的扣除等相关操作，保证优惠计算的准确性和顺序性。
*/
int DISCOUNT = 100;
/**
* `COUPON`常量用于表示优惠券相关业务在订单处理顺序中的位置，其值为200，排在 `DISCOUNT` 后面。
* 当用户在下单过程中使用了优惠券来进一步降低订单金额时，系统会依据这个顺序，
* 在完成满减优惠计算（按照 `DISCOUNT` 顺序操作）之后，再进行优惠券优惠金额的扣除等处理，
* 以此来合理叠加不同的优惠方式，使得最终订单金额的计算符合业务设定的先后逻辑顺序。
*/
int COUPON = 200;
/**
* `DISTRIBUTION`常量定义了分销相关业务在订单处理顺序中的位置，其值为300，排在 `COUPON` 后面。
* 在电商的分销模式下，涉及到根据订单情况计算分销收益、记录分销相关信息等业务操作，
* 系统按照这个顺序，在完成优惠券优惠应用（按照 `COUPON` 顺序）之后，再处理分销相关的逻辑，
* 确保整个订单处理流程中各业务环节有序进行，避免优惠计算和业务逻辑执行出现冲突或错误。
*/
int DISTRIBUTION = 300;
}

129
yami-shop-bean/src/main/java/com/yami/shop/bean/param/DeliveryOrderParam.java
Unescape View File

@ -1,129 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.bean.param;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
/**
* `DeliveryOrderParam`类是作为一个参数对象，用于接收在电商系统中与物流订单操作相关的输入参数。
* 其主要目的是在前端与后端进行交互时，承载那些对于处理物流订单必不可少的数据，以便后端能够依据这些准确的数据来执行对应的业务逻辑，
* 例如在物流单号绑定订单、查询物流状态等具体业务操作场景下，为后端服务提供必要的信息支撑。
* @author lanhai
*/
public class DeliveryOrderParam {
/**
* `orderNumber`属性用于存放具体的订单号信息，它在整个电商系统里是唯一标识每个订单的关键字符串。
* 每一个订单从生成之时起，就会被赋予这样一个独一无二的订单号，通过这个订单号，后端系统能够精确地关联到该订单对应的所有详细信息，
* 比如下单用户的信息、所购买商品的详情、订单的金额以及其他各种与该订单相关的附属数据等。
* 在涉及物流相关操作时，这个订单号尤为重要，它能让系统知晓当前的物流业务是针对哪一个具体订单展开的，例如将获取到的物流信息准确匹配到对应的订单上。
*
* 此处使用了 `@NotBlank` 注解，同时搭配了提示消息“订单号不能为空”，这样在进行数据校验时（例如前端向后端传递参数时），
* 如果该属性值为空字符串，就会触发相应的验证错误提示，以此来保证传递过来的订单号是有效的、非空的。
* 并且，通过 `@Schema` 注解，在生成 API 文档（像使用 Swagger 等工具展示接口信息时），会为该属性添加明确的“订单号”描述，
* 同时标记其为必填项（`required = true`），清晰地告知接口调用者在发起涉及物流订单的相关操作时，必须提供这个关键的订单号参数，
* 从而确保后端接收到完整且有效的数据，以保障后续业务逻辑能够顺利执行。
*/
@NotBlank(message = "订单号不能为空")
@Schema(description = "订单号", required = true)
private String orderNumber;
/**
* `dvyId`属性代表的是快递公司在系统中的唯一标识符，也就是快递公司的 ID，其数据类型通常为 `Long`。
* 在电商平台运营过程中，会事先录入众多合作的快递公司信息到系统中，并为每家快递公司分配一个独一无二的 ID，
* 通过这个 ID，系统可以进一步获取该快递公司的各种详细信息，例如公司的名称、官方网站地址、对应的物流查询接口等关键数据。
* 在物流订单相关的业务操作里，明确是由哪家快递公司负责运输当前订单的商品，就完全依赖这个 `dvyId` 参数来确定。
*
* 同样地，借助 `@NotBlank` 注解来确保该参数不能为空，若为空的话，就会出现“快递公司 id 不能为空”的错误提示，
* 以此来强制要求接口调用者必须提供有效的快递公司 ID 值。并且，通过 `@Schema` 注解在 API 文档中为其添加“快递公司”的描述，
* 同时将其设定为必填项，方便接口调用者清楚知晓该参数的含义以及在调用接口时需要正确传递相应的值，
* 进而保证物流相关业务能够准确关联到对应的快递公司，保障整个物流流程的准确执行。
*/
@NotBlank(message = "快递公司id不能为空")
@Schema(description = "快递公司", required = true)
private Long dvyId;
/**
* `dvyFlowId`属性用于存储具体的物流单号，它是快递公司为每一个快递包裹分配的唯一识别编号，一般是一串特定格式的字符串。
* 在物流业务流程中，无论是用户查询包裹的实时物流状态，还是系统内部跟踪包裹的运输轨迹等操作，都需要依靠这个物流单号来向对应的快递公司查询接口发起请求，
* 进而获取到包裹的详细物流信息，比如包裹当前处于运输的哪个阶段、在哪个城市的哪个站点等情况，所以它是物流查询操作中至关重要的一个参数。
*
* 通过使用 `@NotBlank` 注解，规定该参数不能为空，若前端传递过来的这个属性值为空字符串，就会触发“物流单号不能为空”的错误提示，
* 以此来保证传递的物流单号是有效的、真实存在的。同时，借助 `@Schema` 注解在 API 文档里为其添加“物流单号”的描述，
* 并将其标记为必填项，告知接口调用者在进行物流相关操作时必须提供准确的物流单号，确保物流查询等业务能够顺利开展。
*/
@NotBlank(message = "物流单号不能为空")
@Schema(description = "物流单号", required = true)
private String dvyFlowId;
/**
* `getDvyId`方法是遵循 JavaBean 规范的访问器方法（Getter 方法），其作用是对外提供获取 `dvyId` 属性值的途径。
* 在其他类需要获取当前 `DeliveryOrderParam` 对象中存储的快递公司 ID 信息时，就可以通过调用这个方法来得到相应的值，
* 这符合面向对象编程中对数据封装和访问控制的原则，通过这种规范的方法调用，能够保证数据获取过程的安全性和规范性，
* 避免外部类直接访问属性可能带来的一些不合理操作，同时也使得代码结构更加清晰、易于维护。
*/
public Long getDvyId() {
return dvyId;
}
/**
* `setDvyId`方法是与 `getDvyId` 方法相对应的修改器方法（Setter 方法），它用于为 `dvyId` 属性设置新的值。
* 当在业务逻辑中需要更新当前对象所存储的快递公司 ID 信息时（虽然在实际情况中这种更新可能相对较少出现），
* 外部代码可以通过调用这个方法，并传入一个新的 `Long` 类型的值，来实现对 `dvyId` 属性值的修改操作。
* 在这个方法内部，还可以根据具体的业务需求添加一些额外的数据验证逻辑，例如验证传入的 ID 是否符合系统中已有的快递公司 ID 规则等，
* 以此来进一步保障数据的合法性和准确性，确保设置的快递公司 ID 是有效的、符合业务要求的。
*/
public void setDvyId(Long dvyId) {
this.dvyId = dvyId;
}
/**
* `getDvyFlowId`方法同样是一个 Getter 方法，它的功能是对外提供获取 `dvyFlowId` 属性值的渠道。
* 在涉及物流业务操作的其他代码部分，如果需要知晓当前对象中存储的物流单号具体是什么，就可以调用这个方法来获取相应的字符串值，
* 遵循了 JavaBean 的规范，使得对属性的访问更加有序、可控，方便不同模块之间基于统一的方式来获取和使用这个重要的物流单号数据。
*/
public String getDvyFlowId() {
return dvyFlowId;
}
/**
* `setDvyFlowId`方法作为 `getDvyFlowId` 的对应 Setter 方法，用于对 `dvyFlowId` 属性进行赋值操作。
* 当需要更新物流单号信息时（例如可能由于物流单号录入错误需要重新修改等情况），外部代码可以调用这个方法，
* 传入一个新的符合物流单号格式要求的字符串值，来改变 `DeliveryOrderParam` 对象中存储的物流单号内容。
* 并且，在方法内部也可以根据实际业务情况添加必要的数据校验逻辑，例如检查新传入的物流单号是否符合对应快递公司的单号格式规范等，
* 从而保证设置的物流单号是正确且有效的，避免因错误的物流单号导致后续物流查询等业务出现问题。
*/
public void setDvyFlowId(String dvyFlowId) {
this.dvyFlowId = dvyFlowId;
}
/**
* `getOrderNumber`方法是用于获取 `orderNumber` 属性值的 Getter 方法，其作用与前面介绍的其他 Getter 方法类似。
* 它为外部代码提供了获取当前对象中存储的订单号信息的途径，在后续的业务逻辑中，例如根据订单号去查询订单详情、
* 将物流信息与对应的订单进行关联匹配等操作时，都需要通过调用这个方法来获取准确的订单号数据，
* 以保证整个业务流程能够围绕正确的订单来展开，同时也遵循了 JavaBean 规范，使得代码在数据访问方面更加清晰、规范。
*/
public String getOrderNumber() {
return orderNumber;
}
/**
* `setOrderNumber`方法是对应 `getOrderNumber` 的 Setter 方法，用于对 `orderNumber` 属性进行赋值操作。
* 尽管在正常的电商业务流程中，订单号一旦生成通常是不允许随意更改的，但在某些特殊情况下（如数据修正等极个别场景），
* 如果确实需要更新订单号信息，外部代码可以调用这个方法，并传入一个新的符合订单号生成规则的字符串值，来改变该属性的存储内容。
* 同样，在方法内部也可以添加适当的数据验证逻辑，例如检查新的订单号是否满足唯一性等要求，以保障订单号的合法性和整个系统的数据一致性。
*/
public void setOrderNumber(String orderNumber) {
this.orderNumber = orderNumber;
}
}

34
yami-shop-common/src/main/java/com/yami/shop/common/bean/AliDaYu.java
Unescape View File

@ -1,34 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.bean;
// 导入lombok的Data注解，使用该注解可以自动生成类的一些常规方法，比如getter、setter、toString等方法，简化代码编写
import lombok.Data;
/**
* 阿里大鱼配置信息
* 这个类用于存放与阿里大鱼相关的配置信息，比如访问密钥ID、访问密钥密码以及签名名称等。
* 通过这个类可以方便地对阿里大鱼相关配置进行统一管理和传递。
* @author LGH
*/
@Data
// 定义名为AliDaYu的公共类，用于封装阿里大鱼配置相关的属性
public class AliDaYu {
// 以下是类的私有属性，用于存储具体的配置信息
// 用于存储阿里大鱼的访问密钥ID，通过该ID来标识访问阿里大鱼服务的身份凭证之一
private String accessKeyId;
// 用于存储阿里大鱼的访问密钥密码，与访问密钥ID配合使用，用于进行安全验证等操作，确保对阿里大鱼服务的合法访问
private String accessKeySecret;
// 用于存储阿里大鱼的签名名称，在涉及到一些需要签名验证的业务场景中会用到该名称
private String signName;
}

44
yami-shop-common/src/main/java/com/yami/shop/common/bean/ImgUpload.java
Unescape View File

@ -1,44 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.bean;
// 引入Lombok的Data注解，通过该注解，编译器会自动帮我们生成类的常用方法，
// 比如各属性的Getter、Setter方法，以及toString、equals、hashCode方法等，简化代码编写
import lombok.Data;
/**
* ImgUpload类用于封装本地存储相关的配置信息，主要包含了本地文件上传过程中涉及到的关键配置项，
* 方便在项目中统一管理和获取这些配置，以根据不同的配置情况来执行相应的文件上传逻辑，例如选择本地上传还是使用七牛云等外部存储服务上传。
*
* @author lgh
*/
@Data
public class ImgUpload {
/**
* 用于指定本地文件上传时，文件存储的文件夹路径，
* 通过设置该属性，可以明确文件上传后在本地服务器存储的具体位置，便于后续的文件管理和访问操作。
*/
private String imagePath;
/**
* 用于标识文件上传的方式，是一个整数类型的枚举值（这里虽然没用枚举类严格定义，但约定了取值的含义），
* 取值为1时表示采用本地文件上传方式，也就是将文件存储到由imagePath指定的本地文件夹中；
* 取值为2时表示使用七牛云存储服务进行文件上传，此时会结合其他相关配置与七牛云进行交互来完成上传操作。
*/
private Integer uploadType;
/**
* 用于指定网站相关资源的访问URL，在文件上传的场景下，可能用于构建完整的文件访问链接，
* 比如当通过某种方式获取到文件在本地或者云端存储的相对路径后，结合该resourceUrl就能生成完整的可访问的文件URL，提供给前端等进行访问展示。
*/
private String resourceUrl;
}

133
yami-shop-common/src/main/java/com/yami/shop/common/config/DefaultExceptionHandlerConfig.java
Unescape View File

@ -1,133 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.config;
// 导入相关的自定义异常类、响应相关的枚举、响应实体类等
import com.yami.shop.common.exception.YamiShopBindException;
import com.yami.shop.common.response.ResponseEnum;
import com.yami.shop.common.response.ServerResponseEntity;
// 导入日志相关的Lombok注解，用于简化日志记录代码
import lombok.extern.slf4j.Slf4j;
// 导入Spring的HTTP状态码相关枚举类
import org.springframework.http.HttpStatus;
// 导入Spring用于构建HTTP响应实体的类
import org.springframework.http.ResponseEntity;
// 导入Spring用于标记控制器类的注解（此处结合异常处理相关特性使用）
import org.springframework.stereotype.Controller;
// 导入Spring在数据校验场景下的异常类以及表示字段错误的类
import org.springframework.validation.BindException;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
// 导入Spring用于定义异常处理方法的注解以及标记全局异常处理类的注解
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
// 导入Spring用于处理资源未找到异常的类
import org.springframework.web.servlet.resource.NoResourceFoundException;
import java.util.ArrayList;
import java.util.List;
/**
* 自定义错误处理器，用于统一处理项目中的各类异常情况，
* 并将异常信息按照一定格式封装到响应实体中返回给客户端。
* @author LGH
*/
@Slf4j
@Controller
@RestControllerAdvice
public class DefaultExceptionHandlerConfig {
/**
* 处理MethodArgumentNotValidException和BindException这两种参数校验相关异常的方法。
* 当在Spring的参数校验过程中出现这两种异常时，会进入此方法进行处理，
* 将异常中的字段错误信息提取出来，封装到响应实体中返回给客户端。
*
* @param e 捕获到的异常对象，可能是MethodArgumentNotValidException或者BindException类型
* @return ResponseEntity<ServerResponseEntity<List<String>>> 包含了处理后的响应实体的HTTP响应实体，
* 响应实体中包含了参数校验失败的具体字段错误信息列表（如果有）以及对应的响应状态等信息。
*/
@ExceptionHandler({ MethodArgumentNotValidException.class, BindException.class })
public ResponseEntity<ServerResponseEntity<List<String>>> methodArgumentNotValidExceptionHandler(Exception e) {
// 记录异常信息，方便后续查看出现异常的具体情况，用于调试和问题排查
log.error("methodArgumentNotValidExceptionHandler", e);
List<FieldError> fieldErrors = null;
// 判断异常类型是否是MethodArgumentNotValidException，如果是则获取对应的字段错误列表
if (e instanceof MethodArgumentNotValidException) {
fieldErrors = ((MethodArgumentNotValidException) e).getBindingResult().getFieldErrors();
}
// 判断异常类型是否是BindException，如果是则获取对应的字段错误列表
if (e instanceof BindException) {
fieldErrors = ((BindException) e).getBindingResult().getFieldErrors();
}
// 如果没有获取到字段错误列表（可能出现不符合预期的异常情况等）
if (fieldErrors == null) {
// 返回一个包含特定失败响应枚举（表示参数校验不通过）的响应实体，没有具体字段错误信息
return ResponseEntity.status(HttpStatus.OK)
.body(ServerResponseEntity.fail(ResponseEnum.METHOD_ARGUMENT_NOT_VALID));
}
// 用于存放每个字段的错误信息字符串（格式为：字段名:默认错误消息）
List<String> defaultMessages = new ArrayList<>(fieldErrors.size());
// 遍历字段错误列表，拼接每个字段的错误信息字符串并添加到defaultMessages列表中
for (FieldError fieldError : fieldErrors) {
defaultMessages.add(fieldError.getField() + ":" + fieldError.getDefaultMessage());
}
// 返回一个包含具体字段错误信息列表的失败响应实体，使用参数校验不通过的响应枚举标识
return ResponseEntity.status(HttpStatus.OK)
.body(ServerResponseEntity.fail(ResponseEnum.METHOD_ARGUMENT_NOT_VALID, defaultMessages));
}
/**
* 处理YamiShopBindException这种自定义异常的方法。
* 当项目中抛出YamiShopBindException异常时，会进入此方法进行处理，
* 根据异常中封装的响应实体（如果有）或者异常本身的错误码和错误消息构建响应实体返回给客户端。
*
* @param e 捕获到的YamiShopBindException异常对象
* @return ResponseEntity<ServerResponseEntity<?>> 包含了处理后的响应实体的HTTP响应实体，
* 响应实体中包含了对应业务逻辑异常的相关信息以及响应状态等。
*/
@ExceptionHandler(YamiShopBindException.class)
public ResponseEntity<ServerResponseEntity<?>> unauthorizedExceptionHandler(YamiShopBindException e){
// 记录异常信息，方便后续排查问题，了解异常出现的具体情况
log.error("mall4jExceptionHandler", e);
ServerResponseEntity<?> serverResponseEntity = e.getServerResponseEntity();
// 如果异常中已经封装好了响应实体（在抛出异常时可能已经构建好了特定的响应内容）
if (serverResponseEntity!=null) {
// 直接将其作为响应内容返回给客户端，设置状态码为OK
return ResponseEntity.status(HttpStatus.OK).body(serverResponseEntity);
}
// 失败返回消息，状态码固定为直接显示消息的状态码，根据异常的错误码和错误消息构建失败响应实体并返回
return ResponseEntity.status(HttpStatus.OK).body(ServerResponseEntity.fail(e.getCode(),e.getMessage()));
}
/**
* 兜底的异常处理方法，处理所有未被其他异常处理方法处理的Exception类型异常。
* 对于不同类型的通用异常进行相应处理，如资源未找到异常返回特定消息的响应实体，
* 其他异常则返回默认的异常响应实体告知客户端出现了未预期的异常情况。
*
* @param e 捕获到的异常对象，是Exception类型
* @return ResponseEntity<ServerResponseEntity<Object>> 包含了处理后的响应实体的HTTP响应实体，
* 响应实体中包含了对应异常的相关信息以及响应状态等。
*/
@ExceptionHandler(Exception.class)
public ResponseEntity<ServerResponseEntity<Object>> exceptionHandler(Exception e){
// 判断异常是否是资源未找到异常类型
if (e instanceof NoResourceFoundException) {
// 如果是，则返回一个包含异常消息的失败响应实体，告知客户端资源未找到相关错误信息，状态码设为OK
return ResponseEntity.status(HttpStatus.OK).body(ServerResponseEntity.showFailMsg(e.getMessage()));
}
// 记录异常信息，方便后续排查问题，知道出现异常的具体情况
log.error("exceptionHandler", e);
// 返回一个使用默认的异常响应枚举构建的失败响应实体，告知客户端出现了未预期的通用异常情况
return ResponseEntity.status(HttpStatus.OK).body(ServerResponseEntity.fail(ResponseEnum.EXCEPTION));
}
}

112
yami-shop-common/src/main/java/com/yami/shop/common/config/FileUploadConfig.java
Unescape View File

@ -1,112 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.config;
// 导入相关的自定义类，可能用于存储图片上传相关的配置、枚举等信息
import com.yami.shop.common.bean.ImgUpload;
import com.yami.shop.common.enums.QiniuZone;
// 导入Spring的注解相关类，用于实现依赖注入和配置相关功能
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
// 导入七牛云相关的类，用于与七牛云存储服务进行交互，涉及区域、上传管理、认证等功能
import com.qiniu.common.Zone;
import com.qiniu.storage.BucketManager;
import com.qiniu.storage.UploadManager;
import com.qiniu.util.Auth;
import com.yami.shop.common.bean.Qiniu;
import java.util.Objects;
/**
* 文件上传配置类，主要用于整合七牛云存储相关的配置与实例创建，
* 通过依赖注入获取配置信息，并根据配置来构建七牛云存储操作所需的各种实例，
* 如存储配置、上传管理实例、认证实例以及空间管理实例等，方便在项目中进行文件上传等操作。
* @author lgh
*/
@Configuration
public class FileUploadConfig {
// 通过Spring的依赖注入，获取Qiniu类型的配置对象，该对象应该包含了七牛云相关的配置信息，如密钥、机房区域等
@Autowired
private Qiniu qiniu;
/**
* 根据配置文件选择机房，创建七牛云存储的配置实例（com.qiniu.storage.Configuration）。
* 会根据注入的Qiniu对象中的机房区域配置（QiniuZone枚举类型）来确定对应的七牛云机房区域（Zone），
* 并以此构建七牛云存储配置实例，该实例后续会被其他七牛云相关操作的实例所使用。
*
* @return com.qiniu.storage.Configuration 返回构建好的七牛云存储配置实例，包含了指定的机房区域信息。
*/
@Bean
public com.qiniu.storage.Configuration qiniuConfig() {
Zone zone = null;
// 判断配置中的机房区域是否为华北区，如果是则设置对应的七牛云机房区域为华北区（Zone.huabei()）
if (Objects.equals(qiniu.getZone(), QiniuZone.HUA_BEI)) {
zone = Zone.huabei();
}
// 判断是否为华东区，若是则设置对应的七牛云机房区域为华东区（Zone.huadong()）
else if (Objects.equals(qiniu.getZone(), QiniuZone.HUA_DONG)) {
zone = Zone.huadong();
}
// 判断是否为华南区，若是则设置对应的七牛云机房区域为华南区（Zone.huanan()）
else if (Objects.equals(qiniu.getZone(), QiniuZone.HUA_NAN)) {
zone = Zone.huanan();
}
// 判断是否为北美区，若是则设置对应的七牛云机房区域为北美区（Zone.beimei()）
else if (Objects.equals(qiniu.getZone(), QiniuZone.BEI_MEI)) {
zone = Zone.beimei();
}
// 判断是否为新加坡区，若是则设置对应的七牛云机房区域为新加坡区（Zone.xinjiapo()）
else if (Objects.equals(qiniu.getZone(), QiniuZone.XIN_JIA_PO)) {
zone = Zone.xinjiapo();
}
// 使用确定好的机房区域（zone）构建七牛云存储配置实例并返回
return new com.qiniu.storage.Configuration(zone);
}
/**
* 构建一个七牛上传工具实例（UploadManager），
* 该实例依赖于前面创建的七牛云存储配置实例（qiniuConfig方法创建的com.qiniu.storage.Configuration实例），
* 用于在项目中执行文件上传到七牛云存储的操作。
*
* @return UploadManager 返回构建好的七牛上传工具实例，可用于文件上传操作。
*/
@Bean
public UploadManager uploadManager() {
return new UploadManager(qiniuConfig());
}
/**
* 构建七牛云认证信息实例（Auth），
* 通过获取注入的Qiniu对象中的访问密钥（accessKey）和秘密密钥（secretKey）来创建认证实例，
* 该认证实例在后续与七牛云服务进行交互时（如上传、管理空间等操作）用于验证身份，确保操作的合法性。
*
* @return Auth 返回构建好的七牛云认证信息实例，包含了访问密钥和秘密密钥信息用于认证。
*/
@Bean
public Auth auth() {
return Auth.create(qiniu.getAccessKey(), qiniu.getSecretKey());
}
/**
* 构建七牛空间管理实例（BucketManager），
* 该实例依赖于前面创建的认证信息实例（auth方法创建的Auth实例）和七牛云存储配置实例（qiniuConfig方法创建的实例），
* 用于在七牛云存储中进行空间相关的管理操作，比如查看、删除、移动文件等操作。
*
* @return BucketManager 返回构建好的七牛空间管理实例，可用于七牛云存储空间的管理操作。
*/
@Bean
public BucketManager bucketManager() {
return new BucketManager(auth(), qiniuConfig());
}
}

26
yami-shop-common/src/main/java/com/yami/shop/common/constants/Constant.java
Unescape View File

@ -1,26 +0,0 @@
package com.yami.shop.common.constants;
/**
* Constant类用于集中定义项目中常用的一些常量。
* 将常量统一放在此类中进行管理，有助于提高代码的可维护性和可读性，
* 方便在项目的不同地方引用这些常量，避免了硬编码具体的值，
* 当需要修改常量的值时，只需在此类中进行更改即可，减少了代码改动的范围。
*
* @author TRACK
*/
public class Constant {
/**
* PERIOD常量用于表示句号（英文符号）。
* 在需要使用英文句号的场景中（例如文件路径的拼接、字符串格式的规范等情况），
* 可以直接引用此常量，确保整个项目中对于英文句号的使用保持一致性。
*/
public static final String PERIOD = ".";
/**
* COMMA常量用于表示逗号。
* 常用于在构造需要以逗号分隔的字符串（比如CSV格式的数据组装、多个元素的列举表示等场景），
* 或者在解析以逗号分隔的字符串时作为分隔标识等操作中，方便统一使用逗号的表示形式。
*/
public static final String COMMA = ",";
}

131
yami-shop-common/src/main/java/com/yami/shop/common/handler/HttpHandler.java
Unescape View File

@ -1,131 +0,0 @@
package com.yami.shop.common.handler;
// 导入 Hutool 工具库中处理字符集相关的工具类，用于设置响应的字符编码
import cn.hutool.core.util.CharsetUtil;
// 导入 Jackson 库中用于将对象转换为 JSON 字符串以及反序列化等操作的核心类
import com.fasterxml.jackson.databind.ObjectMapper;
// 导入自定义的业务异常类，可能在项目中用于处理特定业务逻辑出错的情况
import com.yami.shop.common.exception.YamiShopBindException;
// 导入自定义的用于封装服务器响应信息的实体类，包含响应状态码、消息、数据等内容
import com.yami.shop.common.response.ServerResponseEntity;
// 导入 Slf4j 框架的日志记录相关类，用于创建日志记录器来记录不同情况的日志信息
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// 导入 Spring 框架用于实现依赖注入的注解，表明某个属性需要由 Spring 容器进行注入
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring 框架中定义媒体类型的枚举类，用于设置响应的内容类型为 JSON 格式
import org.springframework.http.MediaType;
// 导入 Spring 框架用于将类标记为组件的注解，表明该类是一个 Spring 管理的组件，可被自动扫描并注入到其他需要的地方
import org.springframework.stereotype.Component;
// 导入 Spring 框架中用于获取请求上下文相关信息的类和接口
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
// 导入 Servlet 相关的用于操作 HTTP 响应的类，用于设置响应的各种属性以及向客户端输出内容
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Objects;
/**
* HttpHandler 类主要用于处理将服务器响应信息输出到 Web 端（客户端）的相关操作，
* 它能够根据不同的输入参数（如服务器响应实体或特定业务异常），将对应的响应信息以 JSON 格式正确地写入到 HTTP 响应中，
* 同时进行了必要的日志记录以及异常处理，确保响应输出过程的可靠性和稳定性。
*
* @author 菠萝凤梨
* @date 2022/3/28 14:15
*/
@Component
public class HttpHandler {
// 创建一个日志记录器，用于记录该类中不同操作阶段的日志信息，方便后续进行问题排查和调试
private static final Logger logger = LoggerFactory.getLogger(HttpHandler.class);
// 通过 Spring 的依赖注入机制，注入一个 ObjectMapper 对象，用于将对象转换为 JSON 字符串以便输出到客户端
@Autowired
private ObjectMapper objectMapper;
/**
* 将服务器响应实体（ServerResponseEntity）的内容以 JSON 格式输出到 Web 端（客户端）的 HTTP 响应中。
* 如果传入的服务器响应实体为 null，则仅记录相应日志并直接返回，不进行实际的输出操作。
* 同时会进行一系列的有效性检查，确保能够获取到正确的 HTTP 响应对象，并设置响应的字符编码和内容类型等属性，
* 若在输出过程中出现 I/O 异常，则抛出自定义的业务异常（YamiShopBindException）。
*
* @param serverResponseEntity 要输出到客户端的服务器响应实体，包含了响应的各种信息，如状态码、消息、数据等
* @param <T> 泛型参数，用于表示服务器响应实体中携带的数据的具体类型，具有通用性，可以适应不同类型的数据返回情况
*/
public <T> void printServerResponseToWeb(ServerResponseEntity<T> serverResponseEntity) {
// 如果传入的服务器响应实体为 null，记录日志提示信息，并直接返回，不进行后续操作
if (serverResponseEntity == null) {
logger.info("print obj is null");
return;
}
// 从 Spring 的请求上下文中获取 ServletRequestAttributes 对象，它包含了与当前请求相关的信息，如请求和响应对象等
ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder
.getRequestAttributes();
// 如果获取到的 ServletRequestAttributes 对象为 null，说明无法获取到请求上下文相关信息，记录错误日志并返回，无法进行响应输出操作
if (requestAttributes == null) {
logger.error("requestAttributes is null, can not print to web");
return;
}
// 从 ServletRequestAttributes 对象中获取 HttpServletResponse 对象，用于后续设置响应属性和向客户端输出内容
HttpServletResponse response = requestAttributes.getResponse();
// 如果获取到的 HttpServletResponse 对象为 null，说明无法获取到有效的 HTTP 响应对象，记录错误日志并返回，无法进行响应输出操作
if (response == null) {
logger.error("httpServletResponse is null, can not print to web");
return;
}
// 记录响应的错误消息（这里假设 getMsg 方法获取的是错误相关信息，实际情况可能根据 ServerResponseEntity 的具体实现而定）到日志中，方便排查问题
logger.error("response error: " + serverResponseEntity.getMsg());
// 设置 HTTP 响应的字符编码为 UTF-8，确保输出的内容能够正确地被客户端解析，尤其是包含中文等多字节字符的情况
response.setCharacterEncoding(CharsetUtil.UTF_8);
// 设置 HTTP 响应的内容类型为 application/json，表明响应的内容是 JSON 格式的数据，让客户端能够正确识别并解析
response.setContentType(MediaType.APPLICATION_JSON_VALUE);
// 用于向 HTTP 响应中写入字符数据的对象，初始化为 null，后续通过获取响应的输出流来实例化
PrintWriter printWriter = null;
try {
// 获取 HttpServletResponse 的输出流对象，用于向客户端写入响应内容（这里是将服务器响应实体转换后的 JSON 字符串写入）
printWriter = response.getWriter();
// 使用注入的 ObjectMapper 对象将服务器响应实体转换为 JSON 字符串，并写入到 HTTP 响应的输出流中，从而输出到客户端
printWriter.write(objectMapper.writeValueAsString(serverResponseEntity));
} catch (IOException e) {
// 如果在写入过程中出现 I/O 异常，抛出自定义的业务异常（YamiShopBindException），并将原始的 I/O 异常作为原因传递，方便上层进行统一的异常处理和日志记录
throw new YamiShopBindException("io 异常", e);
}
}
/**
* 针对 YamiShopBindException 类型的异常进行处理，将其相关的响应信息以 JSON 格式输出到 Web 端（客户端）的 HTTP 响应中。
* 如果传入的异常对象为 null，则仅记录相应日志并直接返回，不进行实际的输出操作。
* 如果异常对象中已经包含了服务器响应实体（ServerResponseEntity），则调用 printServerResponseToWeb 方法直接输出该实体内容。
* 否则，会根据异常对象中的错误码和错误消息构建一个新的服务器响应实体，并调用 printServerResponseToWeb 方法输出到客户端。
*
* @param yamiShopBindException 要处理并输出响应信息的 YamiShopBindException 异常对象，包含了业务异常相关的错误码、消息等信息
* @param <T> 泛型参数，用于表示服务器响应实体中携带的数据的具体类型（虽然此处构建新实体时可能没有实际数据，但保持与其他方法的通用性）
*/
public <T> void printServerResponseToWeb(YamiShopBindException yamiShopBindException) {
// 如果传入的 YamiShopBindException 异常对象为 null，记录日志提示信息，并直接返回，不进行后续操作
if (yamiShopBindException == null) {
logger.info("print obj is null");
return;
}
// 判断异常对象中是否包含了服务器响应实体（ServerResponseEntity），如果包含则直接调用 printServerResponseToWeb 方法输出该实体内容到客户端
if (Objects.nonNull(yamiShopBindException.getServerResponseEntity())) {
printServerResponseToWeb(yamiShopBindException.getServerResponseEntity());
return;
}
// 如果异常对象中没有包含服务器响应实体，则创建一个新的 ServerResponseEntity 对象，用于封装异常中的错误码和错误消息等信息
ServerResponseEntity<T> serverResponseEntity = new ServerResponseEntity<>();
serverResponseEntity.setCode(yamiShopBindException.getCode());
serverResponseEntity.setMsg(yamiShopBindException.getMessage());
// 调用 printServerResponseToWeb 方法将构建好的服务器响应实体输出到客户端，完成响应信息的输出操作
printServerResponseToWeb(serverResponseEntity);
}
}

104
yami-shop-common/src/main/java/com/yami/shop/common/serializer/json/ImgJsonSerializer.java
Unescape View File

@ -1,104 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.serializer.json;
// 导入Hutool工具库中用于字符串操作的工具类，例如判断字符串是否为空、处理字符串拼接等操作
import cn.hutool.core.util.StrUtil;
// 导入Jackson库中用于自定义JSON序列化相关的核心类，用于定义如何将Java对象序列化为JSON格式
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
// 导入自定义的类，Qiniu类可能包含了七牛云相关的配置信息，如资源访问地址等
import com.yami.shop.common.bean.Qiniu;
// 导入自定义的图片上传工具类，可能用于获取图片上传相关的配置信息，比如上传类型、资源地址等
import com.yami.shop.common.util.ImgUploadUtil;
// 导入Spring框架用于实现依赖注入的注解以及将类标记为组件的注解，表明该类是受Spring管理的组件，可被自动注入到需要的地方
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* ImgJsonSerializer类是一个自定义的JSON序列化器，用于处理将特定格式的字符串（可能是图片相关的路径字符串）序列化为JSON格式时的逻辑定制。
* 它主要根据图片上传的类型以及图片路径本身的格式（是否以http或https开头），来对图片路径进行处理，添加相应的资源访问地址前缀，
* 最终将处理后的图片路径以合适的格式序列化为JSON字符串输出，适用于在将包含图片路径信息的对象转换为JSON时进行特定的路径格式调整需求。
*
* @author lanhai
*/
@Component
public class ImgJsonSerializer extends JsonSerializer<String> {
// 通过Spring的依赖注入机制，注入一个Qiniu对象，该对象可能包含了七牛云存储相关的配置信息，比如七牛云资源的访问地址等
@Autowired
private Qiniu qiniu;
// 注入一个ImgUploadUtil对象，用于获取图片上传相关的配置信息，例如图片上传类型等，辅助对图片路径进行处理
@Autowired
private ImgUploadUtil imgUploadUtil;
/**
* 重写了Jackson库中的serialize方法，用于定义具体的序列化逻辑，也就是将传入的字符串（此处假设与图片路径相关）按照特定规则转换为JSON格式的字符串输出。
*
* @param value 要进行序列化的字符串，在这里可能表示图片的路径信息，可能是单个图片路径或者多个图片路径用逗号分隔的形式
* @param gen Jackson库中的JsonGenerator对象，用于生成JSON输出内容，通过它可以将处理后的字符串写入到最终的JSON输出中
* @param serializers Jackson库中的SerializerProvider对象，提供了序列化相关的上下文信息，比如配置等，但在这个方法中通常不需要直接操作它
* @throws IOException 如果在向JsonGenerator写入内容过程中出现I/O异常，会抛出此异常，需要上层调用者进行相应处理
*/
@Override
public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
// 判断传入的要序列化的字符串是否为空（空白字符串，包括null、空字符串以及只包含空格等不可见字符的字符串）
if (StrUtil.isBlank(value)) {
// 如果为空，则向JsonGenerator写入一个空字符串，保持JSON格式的一致性，然后直接返回，不再进行后续处理
gen.writeString(StrUtil.EMPTY);
return;
}
// 将传入的字符串按照逗号进行分割，得到一个字符串数组，假设这里的字符串表示多个图片路径，以逗号分隔开，每个元素就是一个单独的图片路径
String[] imgs = value.split(StrUtil.COMMA);
// 创建一个可变的字符串构建器，用于拼接处理后的图片路径，方便后续构建最终的序列化字符串
StringBuilder sb = new StringBuilder();
// 用于存储资源访问地址，根据不同的上传类型来确定具体的值，后续会将其添加到图片路径前面（如果图片路径本身不符合要求的话）
String resourceUrl = "";
// 定义一个正则表达式字符串，用于匹配以"http"或"https"开头的字符串，目的是判断图片路径是否已经是完整的网络访问地址形式
String rule = "^((http[s]{0,1})://)";
// 使用定义好的正则表达式创建一个Pattern对象，用于后续进行正则匹配操作
Pattern pattern = Pattern.compile(rule);
// 根据ImgUploadUtil对象获取的上传类型来确定资源访问地址（resourceUrl）的值
if (Objects.equals(imgUploadUtil.getUploadType(), 2)) {
// 如果上传类型为2，从注入的Qiniu对象中获取资源访问地址，可能是七牛云存储资源的访问地址，用于构建完整的图片访问路径
resourceUrl = qiniu.getResourcesUrl();
} else if (Objects.equals(imgUploadUtil.getUploadType(), 1)) {
// 如果上传类型为1，从ImgUploadUtil对象中获取资源访问地址，可能是其他存储方式对应的资源访问地址
resourceUrl = imgUploadUtil.getResourceUrl();
}
// 遍历分割后的每个图片路径字符串
for (String img : imgs) {
// 使用创建的Pattern对象对当前图片路径字符串进行正则匹配，得到一个Matcher对象，用于查看是否匹配成功
Matcher matcher = pattern.matcher(img);
// 如果匹配成功，说明图片路径已经是以"http"或"https"开头的完整网络访问地址形式，直接将其添加到字符串构建器中，并添加逗号（保持与传入格式的一致性，后续会处理末尾多余的逗号）
if (matcher.find()) {
sb.append(img).append(StrUtil.COMMA);
} else {
// 如果图片路径不是完整的网络访问地址形式，则将前面确定的资源访问地址（resourceUrl）、当前图片路径以及逗号依次添加到字符串构建器中，构建完整的图片访问路径格式
sb.append(resourceUrl).append(img).append(StrUtil.COMMA);
}
}
// 删除字符串构建器中最后一个字符（末尾多余的逗号），得到最终处理好的图片路径字符串
sb.deleteCharAt(sb.length() - 1);
// 将处理好的图片路径字符串通过JsonGenerator写入到最终的JSON输出中，完成序列化操作
gen.writeString(sb.toString());
}
}

168
yami-shop-common/src/main/java/com/yami/shop/common/util/Arith.java
Unescape View File

@ -1,168 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.util;
import java.math.BigDecimal;
import java.math.RoundingMode;
/**
* 算术运算工具类，用于提供精确的数值计算功能，避免浮点数计算时因精度问题产生误差。
* 该类主要针对double类型以及BigDecimal类型的数值进行加、减、乘、除和四舍五入等常见算术运算操作。
* @author lanhai
*/
public class Arith {
/**
* 默认除法运算精度，即当调用无指定精度的div方法时，除法运算结果将精确到小数点后2位，
* 后续的数字按照相应的舍入规则进行处理（此处为HALF_EVEN舍入模式）。
*/
private static final int DEF_DIV_SCALE = 2;
/**
* 将构造函数私有化，防止外部实例化该类，因为这个类的设计目的是作为工具类，提供静态方法供调用，
* 不需要创建类的实例对象，所以禁止外部实例化它。
*/
private Arith() {
}
/**
* 提供精确的加法运算。
* 该方法接收两个double类型的参数，将它们转换为BigDecimal类型后进行精确加法运算，
* 最后返回计算结果的double值，这样可以避免直接使用double进行加法运算时可能出现的精度丢失问题。
*
* @param v1 被加数，即参与加法运算的第一个数值。
* @param v2 加数，即参与加法运算的第二个数值。
* @return 两个参数的和，以double类型返回精确计算后的结果。
*/
public static double add(double v1, double v2) {
// 必须转换成String，因为BigDecimal的构造函数建议使用基于字符串的构造方式来避免精度问题，
// 如果直接使用double类型传入构造函数，在某些情况下可能会出现精度丢失。
String s1 = Double.toString(v1);
String s2 = Double.toString(v2);
BigDecimal b1 = new BigDecimal(s1);
BigDecimal b2 = new BigDecimal(s2);
return b1.add(b2).doubleValue();
}
/**
* 提供精确的减法运算。
* 与加法运算类似，接收两个double类型的参数，先转换为BigDecimal类型，再进行精确的减法操作，
* 最后返回结果的double值，确保减法运算的精度准确性。
*
* @param v1 被减数，参与减法运算的第一个数值，从中减去另一个数值。
* @param v2 减数，参与减法运算的第二个数值，用于从被减数中减去。
* @return 两个参数的差，以double类型返回精确计算后的结果。
*/
public static double sub(double v1, double v2) {
String s1 = Double.toString(v1);
String s2 = Double.toString(v2);
BigDecimal b1 = new BigDecimal(s1);
BigDecimal b2 = new BigDecimal(s2);
return b1.subtract(b2).doubleValue();
}
/**
* 提供精确的乘法运算。
* 同样，把传入的两个double类型参数转换为BigDecimal类型后进行乘法运算，
* 以保证乘法计算结果的精度符合预期，最后返回double类型的结果值。
*
* @param v1 被乘数，参与乘法运算的第一个数值，与另一个数值相乘。
* @param v2 乘数，参与乘法运算的第二个数值，用于和被乘数相乘。
* @return 两个参数的积，以double类型返回精确计算后的结果。
*/
public static double mul(double v1, double v2) {
String s1 = Double.toString(v1);
String s2 = Double.toString(v2);
BigDecimal b1 = new BigDecimal(s1);
BigDecimal b2 = new BigDecimal(s2);
return b1.multiply(b2).doubleValue();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到小数点以后10位，以后的数字四舍五入。
* 这里实际调用了另一个带有精度参数的div方法，并传入默认的精度值（DEF_DIV_SCALE），
* 以实现默认精度下的除法运算功能。
*
* @param v1 被除数，参与除法运算的第一个数值，作为被除的对象。
* @param v2 除数，参与除法运算的第二个数值，用于除被除数。
* @return 两个参数的商，以double类型返回按照默认精度进行四舍五入后的结果。
*/
public static double div(double v1, double v2) {
return div(v1, v2, DEF_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指定精度，以后的数字四舍五入。
* 首先会对传入的参数进行合法性校验，如果指定的精度scale小于0，则抛出异常，
* 因为精度应该是正整数或者0，表示小数点后的保留位数。然后将传入的double类型参数转换为BigDecimal类型，
* 使用指定的精度和HALF_EVEN舍入模式进行除法运算，最后返回double类型的商。
*
* @param v1 被除数，参与除法运算的第一个数值，作为被除的对象。
* @param v2 除数，参与除法运算的第二个数值，用于除被除数。
* @param scale 表示需要精确到小数点以后几位，用于指定除法运算结果的精度。
* @return 两个参数的商，以double类型返回按照指定精度进行四舍五入后的结果。
*/
public static double div(double v1, double v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
String s1 = Double.toString(v1);
String s2 = Double.toString(v2);
BigDecimal b1 = new BigDecimal(s1);
BigDecimal b2 = new BigDecimal(s2);
return b1.divide(b2, scale, RoundingMode.HALF_EVEN).doubleValue();
}
/**
* 提供精确的小数位四舍五入处理。
* 先对传入的参数进行合法性校验，要求scale（小数点后保留位数）不能小于0，
* 然后将需要四舍五入的数字转换为BigDecimal类型，再通过与表示数值1的BigDecimal对象进行除法运算，
* 按照指定的scale和HALF_EVEN舍入模式进行四舍五入，最后返回处理后的double类型结果。
*
* @param v 需要四舍五入的数字，以double类型传入。
* @param scale 小数点后保留几位，用于指定四舍五入的精度要求。
* @return 四舍五入后的结果，以double类型返回经过处理后的数值。
*/
public static double round(double v, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
String s = Double.toString(v);
BigDecimal b = new BigDecimal(s);
BigDecimal one = new BigDecimal("1");
return b.divide(one, scale, RoundingMode.HALF_EVEN).doubleValue();
}
/**
* 重载的加法运算方法，用于对三个BigDecimal类型的数值进行相加操作，
* 最后返回相加结果的double值，方便在需要对多个BigDecimal数值求和时使用。
*
* @param bigDecimal 参与加法运算的第一个BigDecimal数值。
* @param bigDecimal2 参与加法运算的第二个BigDecimal数值。
* @param bigDecimal3 参与加法运算的第三个BigDecimal数值。
* @return 三个参数的和，以double类型返回精确计算后的结果。
*/
public static double add(BigDecimal bigDecimal, BigDecimal bigDecimal2, BigDecimal bigDecimal3) {
return bigDecimal.add(bigDecimal2).add(bigDecimal3).doubleValue();
}
/**
* 另一个重载的加法运算方法，用于对两个BigDecimal类型的数值进行相加操作，
* 并返回相加结果的double值，满足不同场景下对两个BigDecimal数值求和的需求。
*
* @param preDepositPrice 参与加法运算的第一个BigDecimal数值，通常可以理解为预存金额之类的数值（具体含义取决于业务场景）。
* @param finalPrice 参与加法运算的第二个BigDecimal数值，通常可以理解为最终金额之类的数值（具体含义取决于业务场景）。
* @return 两个参数的和，以double类型返回精确计算后的结果。
*/
public static double add(BigDecimal preDepositPrice, BigDecimal finalPrice) {
return preDepositPrice.add(finalPrice).doubleValue();
}
}

87
yami-shop-common/src/main/java/com/yami/shop/common/util/CacheManagerUtil.java
Unescape View File

@ -1,87 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.util;
import lombok.AllArgsConstructor;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.stereotype.Component;
/**
* CacheManagerUtil类用于方便地操作Spring的缓存机制。
* 它依赖于Spring的CacheManager来获取、设置和清除缓存中的数据，
* 提供了对缓存数据进行增删查操作的便捷方法。
* 该类被声明为Spring的一个组件（@Component注解），可以被自动注入到其他需要使用缓存操作功能的类中。
*
* @author lanhai
*/
@Component
@AllArgsConstructor
public class CacheManagerUtil {
// Spring的缓存管理器，用于获取具体的缓存对象等操作，通过构造注入的方式获取
private CacheManager cacheManager;
/**
* 从指定名称的缓存中根据给定的键获取缓存值。
*
* @param <T> 泛型参数，表示期望获取的缓存值的类型。
* @param cacheName 缓存的名称，用于通过CacheManager定位到具体的缓存对象。
* @param key 缓存中数据对应的键，用于在具体缓存对象里查找对应的值。
* @return 如果缓存中存在对应键的值，则返回该值（转换为指定的泛型类型T），若缓存不存在或者对应键的值不存在，则返回null。
*/
@SuppressWarnings({"unchecked"})
public <T> T getCache(String cacheName, String key) {
// 通过缓存管理器获取指定名称的缓存对象
Cache cache = cacheManager.getCache(cacheName);
if (cache == null) {
return null;
}
// 从缓存对象中尝试获取对应键的值的包装对象
Cache.ValueWrapper valueWrapper = cache.get(key);
if (valueWrapper == null) {
return null;
}
// 从包装对象中获取实际的值，并转换为指定的泛型类型T返回
return (T) valueWrapper.get();
}
/**
* 将给定的值存入指定名称的缓存中，对应给定的键。
*
* @param cacheName 缓存的名称，用于通过CacheManager定位到要操作的具体缓存对象。
* @param key 缓存中数据对应的键，用于标识存入的值在缓存中的位置。
* @param value 要存入缓存的值，其类型可以是任意符合缓存要求的Java对象。
*/
public void putCache(String cacheName, String key, Object value) {
// 通过缓存管理器获取指定名称的缓存对象
Cache cache = cacheManager.getCache(cacheName);
if (cache!= null) {
// 如果缓存对象存在，则将键值对存入该缓存对象中
cache.put(key, value);
}
}
/**
* 从指定名称的缓存中清除对应给定键的缓存数据。
*
* @param cacheName 缓存的名称，用于通过CacheManager定位到要操作的具体缓存对象。
* @param key 缓存中数据对应的键，用于确定要清除的缓存数据。
*/
public void evictCache(String cacheName, String key) {
// 通过缓存管理器获取指定名称的缓存对象
Cache cache = cacheManager.getCache(cacheName);
if (cache!= null) {
// 如果缓存对象存在，则清除对应键的缓存数据
cache.evict(key);
}
}
}

66
yami-shop-common/src/main/java/com/yami/shop/common/util/HttpContextUtils.java
Unescape View File

@ -1,66 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.util;
// 导入Spring相关的类，用于获取请求相关的上下文信息，基于请求上下文来获取HttpServletRequest对象
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
// 导入Servlet相关的类，用于操作HTTP请求，这里主要是HttpServletRequest，它包含了请求相关的各种信息
import jakarta.servlet.http.HttpServletRequest;
/**
* HttpContextUtils工具类，主要提供了一些与HTTP请求上下文相关的便捷获取方法，
* 通过Spring的请求上下文机制来获取HttpServletRequest对象，并基于该对象进一步获取如请求域名、请求来源等相关信息，
* 方便在项目的其他地方使用这些信息进行业务逻辑处理，例如跨域处理、链接构建等场景。
*
* @author lanhai
*/
public class HttpContextUtils {
/**
* 获取当前线程绑定的HttpServletRequest对象。
* 通过Spring的RequestContextHolder从请求上下文中获取ServletRequestAttributes对象，
* 再从中提取出HttpServletRequest对象。该方法是后续获取其他请求相关信息的基础。
*
* @return HttpServletRequest 返回当前请求对应的HttpServletRequest对象，
* 如果不存在绑定的请求上下文则会抛出异常（运行时异常），调用者需要进行相应处理。
*/
public static HttpServletRequest getHttpServletRequest() {
return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
}
/**
* 获取当前请求的域名信息。
* 首先调用getHttpServletRequest方法获取当前的HttpServletRequest对象，
* 然后通过该对象的getRequestURL方法获取完整的请求URL（包含协议、域名、端口、路径等），
* 再利用getRequestURI方法获取请求的路径部分，通过删除URL中路径及后面的部分来得到域名相关信息（包含协议、域名、端口）。
*
* @return String 返回当前请求的域名信息（格式类似：http://example.com:8080，具体取决于实际请求情况）。
*/
public static String getDomain() {
HttpServletRequest request = getHttpServletRequest();
StringBuffer url = request.getRequestURL();
return url.delete(url.length() - request.getRequestURI().length(), url.length()).toString();
}
/**
* 获取当前请求的来源（Origin）信息，通常用于处理跨域相关场景。
* 先获取当前的HttpServletRequest对象，然后通过该对象的getHeader方法获取名为"Origin"的请求头信息，
* 该请求头一般由浏览器自动添加，标识了请求的来源域名等信息，在跨域请求等场景中有重要作用。
*
* @return String 返回当前请求的Origin信息（格式类似：http://example.com，如果有Origin请求头的话，否则返回null等情况）。
*/
public static String getOrigin() {
HttpServletRequest request = getHttpServletRequest();
return request.getHeader("Origin");
}
}

127
yami-shop-common/src/main/java/com/yami/shop/common/util/IdUtil.java
Unescape View File

@ -1,127 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.util;
// 导入 Hutool 库中用于生成分布式唯一ID的 Snowflake 类，通常基于雪花算法实现
import cn.hutool.core.lang.Snowflake;
// 导入 Spring 框架用于实现依赖注入的注解以及将类标记为组件的注解，表明该类是受 Spring 管理的组件
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;
/**
* IdUtil 是一个进制转换相关的工具类，主要提供了以下功能：
* 1. 支持在十进制和基于特定字符集（DICT）定义的进制之间进行转换，最大支持十进制和 DICT.length() 进制的相互转换操作。
* 2. 能够根据从数据库中获取的记录 ID（通常是较大范围的数值）生成对应的短网址编码，便于在一些场景下使用更简短的编码来表示较长的 ID。
* 3. 可以依据给定的短网址编码解析出其在数据库中对应的原始记录 ID，实现编码与原始 ID 的相互转换。
* 4. 借助注入的 Snowflake 实例，还能生成下一个短 ID（基于雪花算法生成唯一 ID 并转换为短网址编码形式）。
*
* @author xuliugen
* @date 2018/04/23
*/
@Component
public class IdUtil {
// 通过 Spring 的依赖注入机制，注入一个 Snowflake 实例，用于生成分布式唯一 ID（可能用于生成短 ID 的基础）
@Autowired
private Snowflake snowflake;
// 定义了一个包含数字和大小写字母（去除了容易混淆的部分字母）的字符串，作为自定义进制的字符集，用于进制转换操作
private static final String DICT = "0123456789abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ";
// 计算出基于 DICT 字符集的进制数，即字符集的长度，用于进制转换过程中的计算
private static final int SEED = DICT.length();
// 定义了短网址编码的最小长度，用于在生成短网址编码时，如果长度不足则进行补位操作，保证编码长度符合一定要求
private static final int ID_MIN_LENGTH = 6;
/**
* 将 DICT 字符串转换为字符数组，方便在进制转换过程中通过索引快速获取对应字符，用于数字到字符的映射操作。
*/
private static final char[] CHARS = DICT.toCharArray();
/**
* 创建一个字符到数字的映射关系的 Map，用于在解析短网址编码时，根据字符快速获取对应的数字（在自定义进制下的数字表示），实现字符到数字的转换操作。
*/
private static final Map<Character, Integer> NUMBERS = new HashMap<>();
// 静态代码块，用于初始化 NUMBERS 这个字符到数字的映射 Map，遍历 CHARS 字符数组，将每个字符与其对应的索引（在自定义进制下的数字）存入 Map 中
static {
int len = CHARS.length;
for (int i = 0; i < len; i++) {
NUMBERS.put(CHARS[i], i);
}
}
/**
* 将给定的十进制数字（通常是较大范围的数值，如数据库记录 ID）转换为基于自定义进制（由 DICT 定义）的短网址编码字符串。
* 转换过程采用除基取余法，不断将十进制数除以自定义进制数（SEED），取余数作为对应字符在 DICT 中的索引，构建短网址编码字符串，
* 并且如果生成的编码长度小于最小长度要求（ID_MIN_LENGTH），会在前面补位（添加 DICT 中的第一个字符）以达到最小长度。
*
* @param id 要转换的十进制数字，通常表示数据库中记录的 ID，范围大致在 (1 - 56.8 billion)，不过实际范围取决于具体业务场景
* @return 转换后的基于自定义进制的短网址编码字符串，例如可能返回类似 "RwTji8"、"GijT7Y" 等形式的字符串
*/
public static String encode(long id) {
// 创建一个可变的字符串构建器，用于逐步构建短网址编码字符串
StringBuilder shortUrl = new StringBuilder();
// 当传入的十进制数字大于 0 时，进行进制转换操作，采用除基取余法
while (id > 0) {
// 计算当前十进制数除以自定义进制数（SEED）的余数，将其转换为整数类型，该余数将作为在 DICT 中查找对应字符的索引
int r = (int) (id % SEED);
// 将根据余数获取到的对应字符插入到短网址编码字符串的开头（逆序构建编码字符串）
shortUrl.insert(0, CHARS[r]);
// 更新十进制数，将其除以自定义进制数，得到下一轮循环要处理的数字
id = id / SEED;
}
// 获取当前已经构建好的短网址编码字符串的长度
int len = shortUrl.length();
// 如果长度小于最小长度要求（ID_MIN_LENGTH），进行补位操作
while (len < ID_MIN_LENGTH) {
// 在短网址编码字符串的开头插入 DICT 中的第一个字符（通常是 '0'）进行补位
shortUrl.insert(0, CHARS[0]);
// 更新长度
len++;
}
// 返回最终构建好的短网址编码字符串
return shortUrl.toString();
}
/**
* 根据给定的短网址编码字符串（基于自定义进制）解析出其对应的十进制数字，该十进制数字通常对应数据库中的记录 ID。
* 解析过程是将短网址编码中的每个字符按照其在自定义进制下的权重（通过幂运算计算）转换为十进制数，再累加起来得到最终的十进制结果。
*
* @param key 要解析的短网址编码字符串，例如 "RwTji8"、"GijT7Y" 等形式的字符串，每个字符都代表自定义进制下的一位数字
* @return 解析出的十进制数字，对应数据库中记录的 ID
*/
public static long decode(String key) {
// 将传入的短网址编码字符串转换为字符数组，方便逐个字符进行处理
char[] shorts = key.toCharArray();
// 获取字符数组的长度，即短网址编码的长度
int len = shorts.length;
// 初始化用于累加计算的十进制数字为 0
long id = 0L;
// 遍历短网址编码的每个字符，从左到右（按照权重从高到低）进行解析计算
for (int i = 0; i < len; i++) {
// 根据当前字符在 NUMBERS 映射 Map 中获取其对应的数字（在自定义进制下的数字表示），并乘以当前位置对应的权重（SEED 的幂次方），然后累加到结果中
id = id + (long) (NUMBERS.get(shorts[i]) * Math.pow(SEED, len - i - 1));
}
// 返回解析得到的十进制数字（数据库记录 ID）
return id;
}
/**
* 借助注入的 Snowflake 实例生成一个分布式唯一 ID（基于雪花算法），然后将该唯一 ID 转换为基于自定义进制的短网址编码形式，
* 作为下一个短 ID 返回，可用于在业务中生成具有唯一性且简短的标识符，例如用于短链接、短编号等场景。
*
* @return 基于雪花算法生成唯一 ID 并转换后的短网址编码字符串，作为下一个短 ID
*/
public String nextShortId() {
return encode(snowflake.nextId());
}
}

127
yami-shop-common/src/main/java/com/yami/shop/common/util/ImgUploadUtil.java
Unescape View File

@ -1,127 +0,0 @@
package com.yami.shop.common.util;
// 导入Hutool工具库中用于字符串操作的工具类，可用于判断字符串是否为空等操作
import cn.hutool.core.util.StrUtil;
// 导入自定义的用于封装图片上传相关配置信息的类，包含存储路径、上传类型、资源访问URL等属性
import com.yami.shop.common.bean.ImgUpload;
// 导入自定义的业务异常类，用于在特定业务逻辑出现问题时抛出相应的异常信息，方便统一处理
import com.yami.shop.common.exception.YamiShopBindException;
// 导入Spring框架用于实现依赖注入的注解以及将类标记为组件的注解，表明该类是受Spring管理的组件，可在项目中被自动注入和使用
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
// 导入Spring用于处理文件上传的核心类，代表上传的文件对象，包含文件内容、文件名等信息
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import java.io.IOException;
import java.util.Objects;
/**
* ImgUploadUtil类是一个工具类，主要提供了本地文件上传与删除相关的功能方法，同时也能获取与文件上传配置相关的一些关键信息，
* 例如上传类型、上传路径、资源访问URL等，并且在配置信息不完整或者文件操作出现异常等情况下会抛出相应的业务异常，
* 便于在项目中进行统一的异常处理以及基于配置进行可靠的本地文件管理操作。
*
* @author TRACK
*/
@Component
public class ImgUploadUtil {
// 通过Spring的依赖注入机制，注入一个ImgUpload对象，该对象包含了本地文件上传相关的配置信息，如存储路径、上传方式等
@Autowired
private ImgUpload imgUpload;
/**
* 获取文件上传类型的方法，从注入的ImgUpload对象中获取上传类型属性值。
* 如果获取到的值为null，说明没有配置图片存储方式，此时会抛出自定义的业务异常（YamiShopBindException），
* 提醒调用者需要进行相应的配置，否则返回获取到的上传类型值。
*
* @return Integer 返回表示文件上传类型的整数值，1通常表示本地文件上传，2可能表示使用其他云存储等方式（具体由业务定义）
*/
public Integer getUploadType() {
Integer uploadType = imgUpload.getUploadType();
if (Objects.isNull(uploadType)) {
throw new YamiShopBindException("请配置图片存储方式");
}
return uploadType;
}
/**
* 获取文件上传路径的方法，从注入的ImgUpload对象中获取图片存储的路径属性值（imagePath）。
* 如果获取到的值为null或者是空字符串，说明没有配置图片存储路径，此时会抛出自定义的业务异常（YamiShopBindException），
* 提醒调用者需要进行相应的配置，否则返回获取到的图片存储路径字符串。
*
* @return String 返回表示本地文件上传存储路径的字符串，用于确定文件上传后在本地服务器存储的具体位置
*/
public String getUploadPath() {
String imagePath = imgUpload.getImagePath();
if (Objects.isNull(imagePath) || StrUtil.isBlank(imagePath)) {
throw new YamiShopBindException("请配置图片存储路径");
}
return imagePath;
}
/**
* 获取图片资源访问URL的方法，从注入的ImgUpload对象中获取资源访问URL属性值（resourceUrl）。
* 如果获取到的值为null或者是空字符串，说明没有配置图片路径相关的资源访问URL，此时会抛出自定义的业务异常（YamiShopBindException），
* 提醒调用者需要进行相应的配置，否则返回获取到的资源访问URL字符串，该URL可用于构建完整的图片访问链接等场景。
*
* @return String 返回表示图片资源访问URL的字符串，用于生成可对外访问的图片链接
*/
public String getResourceUrl() {
String resourceUrl = imgUpload.getResourceUrl();
if (Objects.isNull(resourceUrl) || StrUtil.isBlank(resourceUrl)) {
throw new YamiShopBindException("请配置图片路径");
}
return resourceUrl;
}
/**
* 执行本地文件上传的方法，将传入的MultipartFile类型的文件（代表上传的文件对象）保存到本地指定的路径下。
* 首先获取配置的本地文件上传路径，然后根据传入的文件名构建目标文件对象，若目标文件所在目录不存在，则尝试创建目录，
* 如果目录创建失败会抛出自定义的业务异常；接着将上传的文件内容转移到目标文件中，如果出现I/O异常则同样抛出自定义的业务异常，
* 若文件上传成功则返回上传后的文件名。
*
* @param img 代表要上传的文件对象，包含了文件的内容、原始文件名等信息，是Spring在处理文件上传时封装的对象
* @param fileName 要保存的文件名，通常可以是基于一定规则生成或者获取自上传文件的原始文件名等情况
* @return String 返回上传后的文件名，可用于后续的业务逻辑中，比如记录文件上传情况、构建文件访问链接等
*/
public String upload(MultipartFile img, String fileName) {
// 获取配置的本地文件上传路径（存储文件夹路径）
String filePath = imgUpload.getImagePath();
// 根据文件上传路径和传入的文件名构建一个File对象，代表要保存的目标文件
File file = new File(filePath + fileName);
// 判断目标文件所在的目录是否存在，如果不存在则尝试创建目录
if (!file.exists()) {
boolean result = file.mkdirs();
// 如果目录创建失败（返回false），抛出自定义的业务异常，提示创建目录失败的具体路径信息
if (!result) {
throw new YamiShopBindException("创建目录：" + filePath + "失败");
}
}
try {
// 将上传的文件内容转移到目标文件中，即将MultipartFile中的文件数据写入到本地创建好的目标文件里
img.transferTo(file);
} catch (IOException e) {
// 如果在文件转移（写入）过程中出现I/O异常，抛出自定义的业务异常，提示图片上传失败
throw new YamiShopBindException("图片上传失败");
}
// 文件上传成功后，返回上传后的文件名，方便后续业务使用
return fileName;
}
/**
* 执行本地文件删除的方法，根据传入的文件名尝试删除本地指定路径下对应的文件。
* 通过获取配置的本地文件上传路径和传入的文件名构建目标文件对象，然后调用其deleteOnExit方法标记文件在JVM退出时删除，
* 不过要注意这种删除方式只是标记，实际的删除操作可能会在JVM正常退出时执行。
*
* @param fileName 要删除的文件名，需对应本地文件上传路径下实际存在的文件
*/
public void delete(String fileName) {
// 获取配置的本地文件上传路径（存储文件夹路径）
String filePath = imgUpload.getImagePath();
// 根据文件上传路径和传入的文件名构建一个File对象，代表要删除的目标文件
File file = new File(filePath + fileName);
// 标记文件在JVM退出时删除，注意这并不一定会立即删除文件，而是在JVM正常退出时执行删除操作（如果文件存在且可删除的话）
file.deleteOnExit();
}
}

67
yami-shop-common/src/main/java/com/yami/shop/common/util/IpHelper.java
Unescape View File

@ -1,67 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.util;
// 导入Servlet相关的用于操作HTTP请求的类，后续用于获取请求头以及客户端IP地址等信息
import jakarta.servlet.http.HttpServletRequest;
/**
* IpHelper类是一个工具类，主要用于获取客户端（用户）的真实IP地址。
* 在网络环境中，由于可能存在代理服务器等情况，获取IP地址的方式会有所不同，
* 该类通过依次检查不同的请求头信息以及直接获取远程地址的方式来尝试获取客户端真实IP地址，
* 并且如果获取到多个IP地址（例如经过多层代理的情况），则取第一个作为客户端的真实IP地址返回。
*
* @author lanhai
*/
public class IpHelper {
// 定义一个表示未知IP地址的常量字符串，用于后续判断请求头中获取到的IP地址是否有效
private static final String UNKNOWN = "unknown";
/**
* 获取用户真实IP地址的方法，按照一定的顺序检查不同的请求头以及直接获取远程地址来确定客户端的IP地址。
* 首先尝试从"x-forwarded-for"请求头获取IP地址，因为在经过代理服务器转发时，该请求头可能包含了客户端的真实IP地址；
* 如果该请求头获取到的IP地址为空、长度为0或者是表示未知的字符串（"unknown"），则接着尝试从"Proxy-Client-IP"请求头获取；
* 若还是不符合要求，再尝试从"WL-Proxy-Client-IP"请求头获取；
* 若以上请求头都无法获取到有效IP地址，则直接获取请求的远程地址（RemoteAddr）作为IP地址；
* 最后，如果获取到的IP地址字符串包含多个IP（以逗号分隔，可能经过多层代理的情况），则取第一个IP作为最终的客户端真实IP地址返回。
*
* @return String 返回获取到的客户端真实IP地址，如果由于各种原因无法获取到（例如没有有效的请求上下文等）则返回null
*/
public static String getIpAddr() {
// 通过HttpContextUtils工具类获取当前线程绑定的HttpServletRequest对象，该对象包含了请求相关的各种信息
HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
// 如果获取到的HttpServletRequest对象为null，说明无法获取到请求上下文相关信息，直接返回null，无法获取IP地址
if (request == null) {
return null;
}
// 首先尝试从"x-forwarded-for"请求头获取IP地址，该请求头在经过代理服务器转发时可能包含客户端真实IP
String ip = request.getHeader("x-forwarded-for");
// 如果获取到的IP地址为空、长度为0或者等于表示未知的字符串（不区分大小写比较），则继续尝试从其他请求头获取
if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
// 如果从"Proxy-Client-IP"请求头获取到的IP地址仍不符合要求（为空、长度为0或者是未知字符串），则再尝试从"WL-Proxy-Client-IP"请求头获取
if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
// 如果经过前面的尝试还是没有获取到有效IP地址，则直接获取请求的远程地址（RemoteAddr）作为IP地址，这是最基本的获取客户端IP的方式
if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
// 将获取到的IP地址字符串按照逗号进行分割，因为可能存在经过多层代理，IP地址有多个的情况（以逗号分隔）
String[] ips = ip.split(",");
// 返回分割后的第一个IP地址（去除两端的空白字符）作为客户端的真实IP地址，如果只有一个IP则就是该IP本身
return ips[0].trim();
}
}

148
yami-shop-common/src/main/java/com/yami/shop/common/util/Json.java
Unescape View File

@ -1,148 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.util;
// 导入Jackson相关的注解和类，用于配置JSON序列化和反序列化过程中的一些行为，比如包含哪些属性、如何处理未知属性等
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.json.JsonWriteFeature;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
// 导入Lombok的日志记录相关注解，用于简化日志记录代码，自动生成名为log的日志记录对象
import lombok.extern.slf4j.Slf4j;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* Json工具类，主要基于Jackson库提供了一系列便捷的JSON处理方法，
* 包括将Java对象转换为JSON字符串、将JSON字符串反序列化为Java对象（单个对象、对象数组、JSON节点等多种形式），
* 同时在类初始化时对Jackson的ObjectMapper进行了一些常用的配置，以满足特定的JSON处理需求，例如处理空值、未知属性、日期格式等情况。
*
* @author lanhai
*/
@Slf4j
public class Json {
// 创建一个静态的ObjectMapper实例，ObjectMapper是Jackson库中用于进行JSON序列化和反序列化的核心类，后续所有的JSON操作都基于它来实现
private static ObjectMapper objectMapper = new ObjectMapper();
// 静态代码块，用于对ObjectMapper实例进行一系列的配置，这些配置会影响JSON序列化和反序列化的行为。
static {
// 设置序列化时的包含规则，这里配置为JsonInclude.Include.NON_EMPTY，表示如果属性值为空（比如null、空字符串、空集合等）则不输出该属性到JSON字符串中，减少不必要的JSON数据量。
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
// 配置在序列化时，对于空的Java对象（没有任何属性值的对象）转JSON的时候不抛出错误，而是正常返回一个空的JSON对象（如 {}），增强程序的健壮性，避免因空对象序列化失败导致整个操作中断。
objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
// 禁用将日期类型属性序列化为时间戳的功能，这样在处理日期类型数据时可以按照更符合业务需求的日期格式（比如特定的字符串格式）进行序列化，而不是默认的时间戳形式。
objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
// 禁用在反序列化时遇到未知属性（即JSON字符串中的属性在对应的Java类中不存在定义）抛出异常的功能，这样即使JSON数据有额外的属性，也能尽量解析出已知的属性值，避免因未知属性导致整个反序列化失败。
objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
// 取消对非ASCII字符的转码操作，使得JSON字符串中可以直接包含如中文等非ASCII字符，而不需要进行转义编码，方便查看和处理，更符合实际业务场景中对中文等字符的使用需求。
objectMapper.configure(JsonWriteFeature.ESCAPE_NON_ASCII.mappedFeature(), false);
}
/**
* 将给定的Java对象转换为JSON字符串的方法。
* 通过调用ObjectMapper的writeValueAsString方法来实现转换，如果在转换过程中出现JSON处理异常（如对象的属性类型不支持序列化等情况），
* 则会记录错误日志，并返回null，由调用者根据实际情况进行后续处理。
*
* @param object 要转换为JSON字符串的Java对象，可以是任意符合Jackson序列化规则的对象，如POJO、集合、基本数据类型包装类等。
* @return String 返回转换后的JSON字符串，如果转换过程出现异常则返回null。
*/
public static String toJsonString(Object object) {
try {
return objectMapper.writeValueAsString(object);
} catch (JsonProcessingException e) {
// 记录对象转JSON时出现的错误日志，方便后续排查问题，这里记录了异常的详细信息（通过传入e作为参数）
log.error("对象转json错误：", e);
}
return null;
}
/**
* 将给定的JSON字符串反序列化为指定类型的Java对象的方法。
* 通过调用ObjectMapper的readValue方法，按照传入的目标类类型（clazz）信息将JSON字符串解析为对应的Java对象，
* 如果在反序列化过程中出现异常（如JSON格式不符合要求、属性类型不匹配等情况），则会记录错误日志，并返回null，
* 由调用者根据实际情况进行后续处理。
*
* @param json 要反序列化的JSON字符串，需要符合对应Java类的结构和Jackson的解析规则。
* @param clazz 目标Java类的类型，用于告诉ObjectMapper将JSON字符串解析成什么类型的对象，必须是具体的类类型，不能是接口或抽象类等无法实例化的类型。
* @return <T> 返回反序列化后的Java对象，类型与传入的clazz参数指定的类型一致，如果反序列化过程出现异常则返回null。
*/
public static <T> T parseObject(String json, Class<T> clazz) {
T result = null;
try {
result = objectMapper.readValue(json, clazz);
} catch (Exception e) {
// 记录JSON转对象时出现的错误日志，方便后续排查问题，这里记录了异常的详细信息（通过传入e作为参数）
log.error("对象转json错误：", e);
}
return result;
}
/**
* 获取配置好的ObjectMapper实例的方法，外部代码可以通过获取该实例来进行更复杂、自定义的JSON序列化和反序列化操作，
* 利用已有的配置来满足一些特殊的JSON处理需求，比如使用不同的JSON格式、自定义序列化器和反序列化器等情况。
*
* @return ObjectMapper 返回配置好的ObjectMapper实例，供外部调用进行JSON相关操作。
*/
public static ObjectMapper getObjectMapper() {
return objectMapper;
}
/**
* 将给定的JSON字符串反序列化为指定类型的Java对象数组，并将其转换为对应的List集合的方法。
* 先通过ObjectMapper的readValue方法将JSON字符串按照传入的对象数组类型（clazz）解析为对象数组，
* 如果解析成功，则将对象数组转换为List集合返回；如果解析过程出现异常或者解析结果为null，则返回一个空的List集合，
* 保证方法的返回结果具有一定的稳定性，方便调用者进行后续操作而不用担心空指针等问题。
* 此方法相较于使用TypeReference来处理数组反序列化，在特定情况下（如文档中提到的，最多可快10倍）性能更好。
*
* @param json 要反序列化的JSON字符串，其结构需要符合对应Java对象数组的格式要求，即包含多个符合指定类型的JSON对象表示。
* @param clazz 目标Java对象数组的类型，用于告诉ObjectMapper将JSON字符串解析成什么类型的对象数组，必须是具体的类数组类型，如MyClass[].class。
* @return <T> 返回反序列化后的Java对象列表，类型与传入的clazz参数指定的对象数组中的元素类型一致，如果反序列化出现异常则返回空的List集合。
*/
public static <T> List<T> parseArray(String json, Class<T[]> clazz) {
T[] result = null;
try {
result = objectMapper.readValue(json, clazz);
} catch (Exception e) {
// 记录JSON转换时出现的错误日志，方便后续排查问题，这里记录了异常的详细信息（通过传入e作为参数）
log.error("Json转换错误：", e);
}
if (result == null) {
return Collections.emptyList();
}
return Arrays.asList(result);
}
/**
* 将给定的JSON字符串转换为JsonNode对象的方法，JsonNode类似于JSON数据的树形结构表示，可以方便地对JSON数据进行灵活的遍历、查询和操作，
* 相当于将JSON字符串解析为一个通用的、可以灵活处理的JSON节点对象（类似Map结构，可以按节点层次获取属性值等）。
* 如果在转换过程中出现异常，则会记录错误日志，并返回null，由调用者根据实际情况进行后续处理。
*
* @param jsonStr 要转换为JsonNode对象的JSON字符串，格式需符合JSON语法规范。
* @return JsonNode 返回解析后的JsonNode对象，如果转换过程出现异常则返回null，通过该对象可以进一步操作JSON数据的各个节点和属性。
*/
public static JsonNode parseJson(String jsonStr) {
JsonNode jsonNode = null;
try {
jsonNode = objectMapper.readTree(jsonStr);
} catch (Exception e) {
// 记录JSON转换时出现的错误日志，方便后续排查问题，这里记录了异常的详细信息（通过传入e作为参数）
log.error("Json转换错误：", e);
}
return jsonNode;
}
}

51
yami-shop-common/src/main/java/com/yami/shop/common/util/PageAdapter.java
Unescape View File

@ -1,51 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.util;
// 导入Hutool工具库中用于分页相关操作的工具类，这里主要用于将页码、每页数量等信息转换为数据库查询中起始位置和结束位置的相关操作
import cn.hutool.core.util.PageUtil;
// 导入MyBatis Plus框架中用于表示分页信息的核心类，包含了当前页码、每页显示数量等分页相关的属性和方法
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 引入Lombok的Data注解，通过该注解，编译器会自动帮我们生成类的常用方法，比如各属性的Getter、Setter方法，以及toString、equals、hashCode方法等，简化代码编写
import lombok.Data;
/**
* PageAdapter类主要起到了一个适配的作用，用于将MyBatis Plus框架中的分页对象（Page）的相关信息，
* 转换为适用于其他分页逻辑或者数据库查询中分页参数的表示形式，
* 具体是将基于页码和每页数量的分页信息转换为起始位置（begin）和每页数量（size）的形式，方便后续在数据库查询等场景中使用，
* 借助Hutool工具库的分页相关功能来实现这种转换操作。
*
* @author lh
*/
@Data
public class PageAdapter {
// 用于表示分页查询时的起始位置（通常对应数据库查询中的偏移量，从第几条记录开始查询）
private int begin;
// 用于表示分页查询时每页的记录数量，即每页显示多少条数据
private int size;
/**
* 构造方法，接收一个MyBatis Plus框架中的Page对象作为参数，
* 通过调用Hutool工具库的PageUtil工具类的transToStartEnd方法，
* 将Page对象中的当前页码和每页数量信息转换为对应的起始位置和每页数量信息，分别赋值给类中的begin和size属性，完成适配转换操作。
*
* @param page MyBatis Plus框架中的Page对象，包含了当前页码、每页显示数量等分页相关的属性信息，通过这些信息来计算出合适的begin和size值
*/
public PageAdapter(Page page) {
// 调用Hutool的PageUtil工具类的transToStartEnd方法，将当前页码（需要减1，因为数据库查询中页码通常从0开始计数）和每页数量转换为起始位置和结束位置的数组，这里取数组的第一个元素作为起始位置（begin）
int[] startEnd = PageUtil.transToStartEnd((int) page.getCurrent() - 1, (int) page.getSize());
this.begin = startEnd[0];
// 将传入的Page对象中的每页数量赋值给size属性，作为每页的记录数量
this.size = (int) page.getSize();
}
}

213
yami-shop-common/src/main/java/com/yami/shop/common/util/PageParam.java
Unescape View File

@ -1,213 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.common.util;
// 导入MyBatis Plus框架中用于表示分页信息的核心类，包含了分页相关的属性（如当前页、每页大小等）以及操作方法（如获取记录列表、设置总数等）
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入Jackson相关的注解，用于在JSON序列化和反序列化过程中忽略指定的属性，这里用于标记某些属性在转换为JSON时不进行处理
import com.fasterxml.jackson.annotation.JsonIgnore;
// 导入Swagger相关的注解，用于在生成API文档时隐藏某些属性，使得这些属性不在文档中展示出来，一般用于内部使用或不需要对外暴露的属性
import io.swagger.v3.oas.annotations.Hidden;
// 导入Swagger相关的注解，用于在生成API文档时为类、属性等添加描述信息，方便前端开发人员等查看其含义和作用
import io.swagger.v3.oas.annotations.media.Schema;
// 导入SpringDoc相关的注解，用于标记该类作为参数对象，在生成API文档以及进行参数校验等场景下可以被识别和处理
import org.springdoc.core.annotations.ParameterObject;
import java.util.List;
/**
* PageParam类是一个泛型类，继承自MyBatis Plus的Page类，主要用于扩展和定制分页相关的功能及属性。
* 它在原有Page类的基础上，重新定义了一些分页属性（如每页显示条数、当前页等）的默认值，并对部分属性添加了文档注释以及JSON序列化相关的控制，
* 同时重写了Page类中的一些获取和设置属性的方法，以满足特定业务场景下对分页参数更灵活的控制和处理需求，
* 例如限制每页最大显示条数、根据总数情况判断是否进行count查询等功能。
*
* @author lanhai
*/
@Schema
@ParameterObject
public class PageParam<T> extends Page<T> {
/**
* 每页显示条数属性，用于指定每页展示的数据记录数量，默认值设置为10。
* 通过@Schema注解添加了描述信息，在生成API文档时可以展示该属性的含义，方便使用者了解其作用。
*/
@Schema(description = "每页大小，默认10")
private long size = 10;
/**
* 当前页属性，用于表示当前所处的页码，默认值设置为1，同样通过@Schema注解添加了描述信息以便在API文档中展示其含义。
*/
@Schema(description = "当前页，默认1")
private long current = 1;
/**
* 用于存储查询到的数据记录列表，通过@Hidden注解标记该属性在生成API文档时隐藏起来，因为该属性通常是内部使用，不需要对外展示具体的数据内容。
*/
@Hidden
private List<T> records;
/**
* 用于记录符合查询条件的数据总条数，通过@Hidden注解在生成API文档时隐藏该属性，它主要在内部用于分页相关的计算和判断等操作。
*/
@Hidden
private long total = 0;
/**
* 是否进行count查询的标志属性，用于控制在分页查询时是否需要统计符合条件的数据总条数，默认值为true，表示默认进行count查询。
* 通过@JsonIgnore注解标记该属性，在将对象转换为JSON时忽略该属性，因为它通常不需要在对外传输的数据中体现。
*/
@JsonIgnore
private boolean isSearchCount = true;
/**
* 一个用于特定场景的属性（具体功能可能根据业务而定），通过@JsonIgnore注解标记在JSON序列化时忽略该属性，一般是内部使用的标识信息等情况。
*/
@JsonIgnore
private String countId;
/**
* 用于限制每页最大显示条数的属性（具体值在这里设置为100），通过@JsonIgnore注解在JSON序列化时忽略它，主要在内部用于对每页大小进行限制调整。
*/
@JsonIgnore
private Long maxLimit;
/**
* 用于优化count查询SQL语句相关的属性（具体优化逻辑取决于具体业务实现），通过@JsonIgnore注解在JSON序列化时忽略它，也是内部使用的一个标识属性。
*/
@JsonIgnore
private boolean optimizeCountSql;
/**
* 重写了父类Page中获取记录列表的方法，返回当前对象中存储的记录列表（records属性），用于在业务逻辑中获取查询到的数据内容。
*
* @return List<T> 返回存储的数据记录列表，类型与泛型参数T一致，包含了符合查询条件的具体数据记录。
*/
@Override
public List<T> getRecords() {
return this.records;
}
/**
* 重写了父类Page中设置记录列表的方法，将传入的记录列表赋值给当前对象的records属性，并返回当前对象（this），方便进行链式调用，
* 用于在查询到数据后更新对象中的记录列表信息，以便后续进行分页相关的处理和展示等操作。
*
* @param records 要设置的数据记录列表，类型与泛型参数T一致，通常是从数据库查询得到的符合条件的数据集合。
* @return Page<T> 返回当前对象本身，可用于链式调用，例如继续调用其他设置属性的方法等操作。
*/
@Override
public Page<T> setRecords(List<T> records) {
this.records = records;
return this;
}
/**
* 重写了父类Page中获取数据总条数的方法，返回当前对象中存储的总条数（total属性），用于在分页相关的计算（如计算总页数等）以及业务判断中使用。
*
* @return long 返回符合查询条件的数据总条数，用于后续的分页逻辑处理。
*/
@Override
public long getTotal() {
return this.total;
}
/**
* 重写了父类Page中设置数据总条数的方法，将传入的总条数赋值给当前对象的total属性，并返回当前对象（this），方便进行链式调用，
* 用于在获取到准确的总条数后更新对象中的相关信息，例如在执行完count查询后更新总条数用于后续的分页展示等操作。
*
* @param total 要设置的数据总条数，通过数据库查询或其他方式统计得到的符合条件的数据记录总数。
* @return Page<T> 返回当前对象本身，可用于链式调用，例如继续调用其他设置属性的方法等操作。
*/
@Override
public Page<T> setTotal(long total) {
this.total = total;
return this;
}
/**
* 获取是否进行count查询的方法，在原有的isSearchCount属性基础上进行了额外的判断逻辑。
* 如果数据总条数（total属性）小于0，则返回false，表示不进行count查询（可能是因为数据不符合要求等情况）；
* 否则返回isSearchCount属性的值，即按照默认或之前设置的值来确定是否进行count查询，用于在分页查询前根据实际情况灵活决定是否需要统计总数。
*
* @return boolean 返回是否进行count查询的结果，true表示进行count查询，false表示不进行，根据具体情况判断。
*/
@JsonIgnore
public boolean getSearchCount() {
if (total < 0) {
return false;
}
return isSearchCount;
}
/**
* 重写了父类Page中设置是否进行count查询的方法，将传入的布尔值赋值给当前对象的isSearchCount属性，并返回当前对象（this），方便进行链式调用，
* 用于在业务逻辑中根据不同需求动态设置是否需要进行count查询操作，例如在某些特定条件下不需要统计总数时可以通过该方法进行设置。
*
* @param isSearchCount 要设置的是否进行count查询的布尔值，true表示进行，false表示不进行。
* @return Page<T> 返回当前对象本身，可用于链式调用，例如继续调用其他设置属性的方法等操作。
*/
@Override
public Page<T> setSearchCount(boolean isSearchCount) {
this.isSearchCount = isSearchCount;
return this;
}
/**
* 重写了父类Page中获取每页显示条数的方法，返回当前对象中存储的每页显示条数（size属性），用于在分页相关的计算（如计算偏移量等）以及业务判断中使用。
*
* @return long 返回每页显示的数据记录数量，按照默认值或之前设置的值来确定，可用于后续的分页逻辑处理。
*/
@Override
public long getSize() {
return this.size;
}
/**
* 重写了父类Page中设置每页显示条数的方法，对传入的每页显示条数进行了限制处理。
* 如果传入的每页显示条数（size参数）大于预先设定的最大限制值（这里设置为100），则将当前对象的size属性设置为最大限制值（100），避免每页显示过多数据；
* 否则将传入的size值赋值给当前对象的size属性，用于在业务逻辑中根据实际需求动态设置每页显示的合理数量，然后返回当前对象（this）方便进行链式调用。
*
* @param size 要设置的每页显示条数，通过前端传入或业务逻辑指定的每页希望展示的数据记录数量。
* @return Page<T> 返回当前对象本身，可用于链式调用，例如继续调用其他设置属性的方法等操作。
*/
@Override
public Page<T> setSize(long size) {
int maxSize = 100;
if (size > maxSize) {
this.size = maxSize;
} else {
this.size = size;
}
return this;
}
/**
* 重写了父类Page中获取当前页的方法，返回当前对象中存储的当前页（current属性），用于在分页相关的计算（如计算偏移量等）以及业务判断中使用。
*
* @return long 返回当前所处的页码，按照默认值或之前设置的值来确定，可用于后续的分页逻辑处理。
*/
@Override
public long getCurrent() {
return this.current;
}
/**
* 重写了父类Page中设置当前页的方法，将传入的当前页数值赋值给当前对象的current属性，并返回当前对象（this），方便进行链式调用，
* 用于在业务逻辑中根据实际需求动态设置当前所处的页码，例如响应前端传入的页码切换请求等操作。
*
* @param current 要设置的当前页数值，通过前端传入或业务逻辑指定的当前希望展示的页码。
* @return Page<T> 返回当前对象本身，可用于链式调用，例如继续调用其他设置属性的方法等操作。
*/
@Override
public Page<T> setCurrent(long current) {
this.current = current;
return this;
}
}

27
yami-shop-security/yami-shop-security-admin/src/main/java/com/yami/shop/security/admin/dto/CaptchaAuthenticationDTO.java
Unescape View File

@ -1,27 +0,0 @@
package com.yami.shop.security.admin.dto;
import com.yami.shop.security.common.dto.AuthenticationDTO;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
/**
* CaptchaAuthenticationDTO类用于表示验证码登录相关的数据传输对象（DTO）。
* 它继承自AuthenticationDTO类，意味着会继承其原有的一些与认证相关的通用属性和方法等。
* 此类专门用于在涉及验证码登录的场景中，传递包含验证码信息在内的登录相关数据，
* 比如从前端接收用户输入的验证码以及其他必要的认证信息，再传递到后端进行相应的登录验证处理等操作。
*
* @author 菠萝凤梨
* @date 2022/3/28 14:57
*/
@Data
public class CaptchaAuthenticationDTO extends AuthenticationDTO {
/**
* captchaVerification属性用于存储用户输入的验证码信息。
* 通过@Schema注解对该属性在Swagger文档中的展示进行了描述说明，
* 指明此属性的描述为“验证码”，并且在相关的请求等场景中是必须提供的（required = true），
* 以便后端服务可以获取该验证码并与系统生成的验证码进行比对等验证操作。
*/
@Schema(description = "验证码", required = true)
private String captchaVerification;
}

136
yami-shop-security/yami-shop-security-api/src/main/java/com/yami/shop/security/api/controller/LoginController.java
Unescape View File

@ -1,136 +0,0 @@
package com.yami.shop.security.api.controller;
// 导入MyBatis Plus框架中用于构建条件查询的核心类，方便编写数据库查询条件，此处用于查询用户信息
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
// 导入项目中自定义的用户实体类，代表数据库中存储的用户相关信息，包含各种用户属性，如用户名、手机号、密码等
import com.yami.shop.bean.model.User;
// 导入项目自定义的业务异常类，用于在业务逻辑出现特定错误情况时抛出异常，方便统一处理和向客户端返回错误信息
import com.yami.shop.common.exception.YamiShopBindException;
// 导入项目自定义的工具类，可能包含一些通用的业务逻辑处理方法，此处具体功能需看其内部实现（从名字推测和主体逻辑相关）
import com.yami.shop.common.util.PrincipalUtil;
// 导入项目中定义的用于操作数据库中用户表的Mapper接口，通过它可以调用数据库相关的查询、插入等操作方法（由MyBatis框架生成实现类来具体执行SQL操作）
import com.yami.shop.dao.UserMapper;
// 导入与安全相关的业务对象类，用于封装在Token中存储的用户信息，方便在不同模块间传递和使用用户相关数据
import com.yami.shop.security.common.bo.UserInfoInTokenBO;
// 导入与安全相关的用于接收登录认证信息的数据传输对象（DTO）类，包含用户名、密码以及用户所属系统类型等信息，用于接收前端传入的登录数据
import com.yami.shop.security.common.dto.AuthenticationDTO;
// 导入与安全相关的枚举类，用于区分不同的系统类型，此处有个普通用户类型（ORDINARY），可能还有其他类型用于不同业务场景下的用户分类
import com.yami.shop.security.common.enums.SysTypeEnum;
// 导入与安全相关的用于密码检查的管理类，可能包含验证密码是否符合规则、检查密码错误次数等逻辑，保障登录密码的安全性
import com.yami.shop.security.common.manager.PasswordCheckManager;
// 导入与安全相关的用于密码管理的类，可能包含密码加密、解密等相关操作方法，确保密码在存储和传输过程中的安全性
import com.yami.shop.security.common.manager.PasswordManager;
// 导入与安全相关的用于管理Token存储和操作的类，负责生成、存储Token以及基于用户信息获取相应的Token相关信息等功能
import com.yami.shop.security.common.manager.TokenStore;
// 导入与安全相关的用于返回给前端包含Token信息的视图对象（VO）类，将后端处理后的Token相关数据以合适的格式返回给前端展示和后续使用
import com.yami.shop.security.common.vo.TokenInfoVO;
// 导入Swagger相关的注解，用于生成API文档，@Tag注解用于给接口分类添加标签，方便文档中进行分组展示和说明
import io.swagger.v3.oas.annotations.tags.Tag;
// 导入Swagger相关的注解，用于在API文档中描述接口的功能摘要和详细信息，方便前端开发人员等查看接口的作用和使用方式
import io.swagger.v3.oas.annotations.Operation;
// 导入Spring框架用于实现依赖注入的注解，表明后续的属性需要由Spring容器进行注入实例化
import org.springframework.beans.factory.annotation.Autowired;
// 导入项目自定义的用于封装服务器响应信息的实体类，包含响应状态码、消息、数据等内容，用于统一向客户端返回响应结果
import com.yami.shop.common.response.ServerResponseEntity;
// 导入Spring框架用于定义处理POST请求的注解，将下面的方法映射为一个接收POST请求的接口，处理对应的业务逻辑
import org.springframework.web.bind.annotation.PostMapping;
// 导入Spring框架用于接收请求体数据并将其绑定到方法参数的注解，确保前端传入的JSON等格式的数据能正确映射到对应的参数对象上
import org.springframework.web.bind.annotation.RequestBody;
// 导入Spring框架用于将类标记为RESTful风格的控制器的注解，表明该类中的方法主要用于处理HTTP请求并返回JSON等格式的响应数据
import org.springframework.web.bind.annotation.RestController;
// 导入Jakarta验证相关的注解，用于对传入的参数对象进行数据校验，确保参数符合一定的规则，比如非空等要求
import jakarta.validation.Valid;
/**
* LoginController类是一个Spring RESTful风格的控制器类，主要负责处理用户登录相关的业务逻辑，
* 通过接收前端传入的登录认证信息（用户名、密码以及用户所属系统类型等），验证用户信息的合法性，
* 包括检查用户是否存在、密码是否正确以及密码错误次数是否超限等情况，若验证通过则生成并返回对应的Token信息给前端，
* 方便后续的用户鉴权以及其他需要身份验证的业务操作，同时使用Swagger注解生成相关的API文档，便于接口的查看和使用说明。
*
* @author 菠萝凤梨
* @date 2022/3/28 15:20
*/
@RestController
@Tag(name = "登录")
public class LoginController {
// 通过Spring的依赖注入机制，注入一个TokenStore实例，用于管理Token的存储、生成以及获取相关信息等操作
@Autowired
private TokenStore tokenStore;
// 注入一个UserMapper实例，用于调用数据库中用户表相关的查询、操作方法，以便获取用户信息进行登录验证等操作
@Autowired
private UserMapper userMapper;
// 注入一个PasswordCheckManager实例，用于对用户输入的密码进行各种检查，如密码错误次数限制等安全相关的验证操作
@Autowired
private PasswordCheckManager passwordCheckManager;
// 注入一个PasswordManager实例，用于对密码进行加密、解密等管理操作，此处主要用于解密前端传入的密码进行后续验证
@Autowired
private PasswordManager passwordManager;
/**
* 处理用户登录请求的接口方法，接收前端传入的经过验证的登录认证信息（通过@Valid注解确保数据格式符合要求），
* 首先根据传入的用户名（可能是手机号或者用户名）查找对应的用户信息，然后解密前端传入的密码，
* 接着检查密码是否正确以及是否达到密码错误次数限制，若一切验证通过，则构建用户在Token中存储的信息对象，
* 通过TokenStore生成并存储Token，获取相应的Token信息视图对象（TokenInfoVO）返回给前端，告知登录成功以及返回Token相关信息。
*
* @param authenticationDTO 经过验证的登录认证信息对象，包含用户名、密码以及用户所属系统类型等信息，由前端传入，通过请求体（@RequestBody）接收并绑定到该参数上
* @return ServerResponseEntity<TokenInfoVO> 返回一个包含Token信息视图对象（TokenInfoVO）的服务器响应实体，若登录成功则状态码为成功状态，包含有效的Token信息返回给前端；若出现异常则返回相应的错误状态和提示信息
*/
@PostMapping("/login")
@Operation(summary = "账号密码(用于前端登录)", description = "通过账号/手机号/用户名密码登录，还要携带用户的类型，也就是用户所在的系统")
public ServerResponseEntity<TokenInfoVO> login(
@Valid @RequestBody AuthenticationDTO authenticationDTO) {
// 从登录认证信息对象中获取用户名（可能是手机号或者普通用户名形式），用于后续查找用户信息
String mobileOrUserName = authenticationDTO.getUserName();
// 根据获取到的用户名查找对应的用户信息，若找不到则会抛出异常告知账号或密码不正确
User user = getUser(mobileOrUserName);
// 通过PasswordManager对前端传入的密码进行解密操作，获取解密后的密码，以便后续和数据库中存储的密码进行比对验证
String decryptPassword = passwordManager.decryptPassword(authenticationDTO.getPassWord());
// 通过PasswordCheckManager检查密码是否正确以及是否达到密码错误次数限制（半小时内密码输入错误十次，已限制登录30分钟），若不符合要求会抛出相应异常进行处理
passwordCheckManager.checkPassword(SysTypeEnum.ORDINARY, authenticationDTO.getUserName(), decryptPassword, user.getLoginPassword());
// 创建一个用于在Token中存储用户信息的业务对象，将用户的ID、所属系统类型以及是否启用等信息设置进去，用于后续生成Token以及存储相关用户标识信息
UserInfoInTokenBO userInfoInToken = new UserInfoInTokenBO();
userInfoInToken.setUserId(user.getUserId());
userInfoInToken.setSysType(SysTypeEnum.ORDINARY.value());
userInfoInToken.setEnabled(user.getStatus() == 1);
// 通过TokenStore存储用户信息并生成Token，同时获取包含Token相关信息的视图对象（TokenInfoVO），用于返回给前端告知登录成功以及提供后续鉴权等所需的Token信息
TokenInfoVO tokenInfoVO = tokenStore.storeAndGetVo(userInfoInToken);
return ServerResponseEntity.success(tokenInfoVO);
}
/**
* 根据传入的用户名（可能是手机号或者用户名）查找对应的用户信息的私有方法，
* 首先判断传入的用户名是否符合手机号格式，如果是则通过手机号在数据库中查找用户信息；
* 如果通过手机号没找到用户，则再尝试通过用户名在数据库中查找用户；
* 如果最终还是没找到对应的用户，则抛出自定义的业务异常（YamiShopBindException）告知账号或密码不正确。
*
* @param mobileOrUserName 要查找用户信息对应的用户名，可能是手机号或者普通用户名形式
* @return User 返回查找到的用户信息对象，如果没找到则抛出异常，不会返回null
*/
private User getUser(String mobileOrUserName) {
User user = null;
// 通过PrincipalUtil工具类判断传入的用户名是否符合手机号格式，如果是则进行下一步操作（通过手机号查找用户）
if (PrincipalUtil.isMobile(mobileOrUserName)) {
// 使用MyBatis Plus构建的条件查询对象（LambdaQueryWrapper），根据手机号在数据库中查找对应的用户信息，通过UserMapper调用数据库查询方法
user = userMapper.selectOne(new LambdaQueryWrapper<User>().eq(User::getUserMobile, mobileOrUserName));
}
// 如果通过手机号没找到用户（即user为null），则尝试通过用户名在数据库中查找用户
if (user == null) {
user = userMapper.selectOneByUserName(mobileOrUserName);
}
// 如果最终还是没找到对应的用户，则抛出自定义的业务异常，告知账号或密码不正确
if (user == null) {
throw new YamiShopBindException("账号或密码不正确");
}
return user;
}
}

37
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/adapter/AuthConfigAdapter.java
Unescape View File

@ -1,37 +0,0 @@
package com.yami.shop.security.common.adapter;
import java.util.List;
/**
* 该接口用于配置授权相关的路径信息，实现此接口后，能够方便地修改需要授权登录的路径以及不需要授权登录的路径。
* 它为应用的权限控制中关于路径的授权配置提供了一种规范和扩展点，使得不同的应用场景可以根据自身需求灵活定义哪些路径需要授权，哪些不需要。
*
* @author 菠萝凤梨
* @date 2022/3/25 17:31
*/
public interface AuthConfigAdapter {
/**
* 定义了一个字符串常量，表示可能需要登录才可用的URL的路径匹配模式。
* 这里的 "/**/ma/**" 是一种通配符形式的路径表达式，意味着以任意多级目录开始，中间包含 "ma" 子目录的路径都可能需要登录才能访问。
* 实际应用中可根据具体的业务逻辑和权限控制需求对该通配符表达式进行调整或替换。
*/
String MAYBE_AUTH_URI = "/**/ma/**";
/**
* 获取需要授权登录的路径列表。
* 实现该接口的类需要通过具体的逻辑来确定并返回哪些路径是要求用户必须进行授权登录后才能访问的。
* 例如，可能会根据业务模块、功能权限等因素来收集相应的路径集合。
*
* @return 需要授权登陆的路径列表，列表中的每个元素为一个具体的路径表达式（通常采用类似通配符等格式来表示一批路径）
*/
List<String> pathPatterns();
/**
* 获取不需要授权登录的路径列表。
* 同样，实现此接口的类要依据业务规则来明确哪些路径是无需用户授权登录就能直接访问的，比如一些公开的页面（如登录页面、注册页面、网站首页等常规对外公开的资源路径）。
*
* @return 不需要授权登陆的路径列表，列表中的元素为具体的不需要授权的路径表达式
*/
List<String> excludePathPatterns();
}

79
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/adapter/CaptchaCacheServiceRedisImpl.java
Unescape View File

@ -1,79 +0,0 @@
package com.yami.shop.security.common.adapter;
import com.anji.captcha.service.CaptchaCacheService;
import com.yami.shop.common.util.RedisUtil;
/**
* CaptchaCacheServiceRedisImpl类的主要作用是将验证码相关的数据存储适配到Redis中。
* 它实现了CaptchaCacheService接口，意味着需要按照该接口定义的方法规范来实现具体的功能，
* 从而为验证码服务提供基于Redis的缓存操作功能，例如存储验证码、判断验证码是否存在、删除验证码以及获取验证码等操作，
* 使得验证码相关的数据可以在Redis中进行有效的管理和操作。
*
* @author 菠萝凤梨
* @date 2022/3/25 17:33
*/
public class CaptchaCacheServiceRedisImpl implements CaptchaCacheService {
/**
* 此方法用于将指定的键值对存储到Redis中，并设置过期时间（以秒为单位）。
* 它调用了RedisUtil工具类中的set方法来实际执行向Redis存储数据的操作，
* 将传入的键（key）、值（value）以及过期时间（expiresInSeconds）传递给RedisUtil的对应方法进行处理。
*
* @param key 要存储到Redis中的键，用于唯一标识验证码相关的数据。
* @param value 要存储到Redis中的值，通常为验证码的具体内容等相关信息。
* @param expiresInSeconds 数据在Redis中的过期时间，单位为秒，超过这个时间后数据将自动从Redis中删除。
*/
@Override
public void set(String key, String value, long expiresInSeconds) {
RedisUtil.set(key, value, expiresInSeconds);
}
/**
* 此方法用于判断在Redis中是否存在指定的键对应的验证码数据。
* 通过调用RedisUtil工具类中的hasKey方法来实现判断逻辑，
* 如果Redis中存在该键，则表示对应的验证码数据存在，返回true；否则返回false。
*
* @param key 要检查其是否存在的键，对应着可能存储在Redis中的验证码相关数据的标识。
* @return 如果Redis中存在该键对应的验证码数据，则返回true；否则返回false。
*/
@Override
public boolean exists(String key) {
return RedisUtil.hasKey(key);
}
/**
* 此方法用于从Redis中删除指定键对应的验证码数据。
* 调用RedisUtil工具类中的del方法来执行从Redis中删除数据的实际操作，
* 使得对应的验证码相关信息在Redis中被移除，不再占用存储空间。
*
* @param key 要从Redis中删除其对应数据的键，即要删除的验证码相关数据在Redis中的标识。
*/
@Override
public void delete(String key) {
RedisUtil.del(key);
}
/**
* 此方法用于从Redis中获取指定键对应的验证码数据的值（通常就是验证码的具体内容）。
* 借助RedisUtil工具类中的get方法来实现从Redis中查找并返回对应值的功能，
* 如果键存在，则返回对应的验证码数据的值；如果不存在，则返回相应的默认值（根据RedisUtil的实现来确定）。
*
* @param key 要从Redis中获取其对应值的键，即要获取的验证码相关数据在Redis中的标识。
* @return 从Redis中获取到的指定键对应的验证码数据的值，如果键不存在则返回相应结果（由RedisUtil决定）。
*/
@Override
public String get(String key) {
return RedisUtil.get(key);
}
/**
* 此方法用于返回当前缓存服务所使用的存储类型，在这里明确返回“redis”，
* 表明本实现类是将验证码相关数据存储在Redis中的，方便外部代码知晓和区分不同的缓存存储实现方式。
*
* @return 始终返回“redis”，表示该缓存服务基于Redis进行数据存储。
*/
@Override
public String type() {
return "redis";
}
}

53
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/adapter/DefaultAuthConfigAdapter.java
Unescape View File

@ -1,53 +0,0 @@
package com.yami.shop.security.common.adapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Collections;
import java.util.List;
/**
* DefaultAuthConfigAdapter类实现了AuthConfigAdapter接口，主要用于配置认证相关的路径规则。
* 它定义了哪些路径需要进行认证（通过pathPatterns方法）以及哪些路径不需要进行认证（通过excludePathPatterns方法），
* 在整个应用的安全认证体系中起着路径筛选和配置的作用。
*
* @author 菠萝凤梨
* @date 2022/3/25 17:33
*/
public class DefaultAuthConfigAdapter implements AuthConfigAdapter {
// 创建一个日志记录器，用于记录与该类相关的日志信息，方便在运行时排查问题、了解类的执行情况等，这里记录器的名称为DefaultAuthConfigAdapter类的全限定名
private static final Logger logger = LoggerFactory.getLogger(DefaultAuthConfigAdapter.class);
/**
* 构造方法，在实例化DefaultAuthConfigAdapter对象时会被调用。
* 此构造方法中主要通过日志记录器输出一条信息，提示没有实现其他的AuthConfigAdapter，当前使用的是DefaultAuthConfigAdapter，
* 并且表示所有的URL都需要进行认证（这是基于当前默认实现的规则设定，具体可能根据业务需求在子类中进行重写来改变）。
*/
public DefaultAuthConfigAdapter() {
logger.info("not implement other AuthConfigAdapter, use DefaultAuthConfigAdapter... all url need auth...");
}
/**
* pathPatterns方法实现了AuthConfigAdapter接口中定义的方法，用于返回需要进行认证的路径模式列表。
* 在当前的默认实现中，返回一个包含通配符“/*”的列表，表示所有的路径都需要进行认证，
* 当然，具体的业务场景下如果有更精细的认证路径需求，可以通过继承该类并重写此方法来实现不同的路径配置。
*
* @return 返回一个List<String>类型的列表，其中元素为需要进行认证的路径模式，当前默认返回包含“/*”的列表，表示所有路径。
*/
@Override
public List<String> pathPatterns() {
return Collections.singletonList("/*");
}
/**
* excludePathPatterns方法同样是实现AuthConfigAdapter接口定义的方法，用于返回不需要进行认证的路径模式列表。
* 在当前默认实现中，返回一个空的列表，表示没有任何路径被排除在认证之外，即所有路径都按照pathPatterns方法定义的规则进行认证，
* 同样，可根据实际业务需求在子类中重写此方法来指定特定的不需要认证的路径。
*
* @return 返回一个List<String>类型的列表，其中元素为不需要进行认证的路径模式，当前默认返回空列表，表示无排除路径。
*/
@Override
public List<String> excludePathPatterns() {
return Collections.emptyList();
}
}

59
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/adapter/MallWebSecurityConfigurerAdapter.java
Unescape View File

@ -1,59 +0,0 @@
package com.yami.shop.security.common.adapter;
// 导入Spring框架中用于将方法标记为创建Bean的注解，通过该注解定义的方法返回的对象会被Spring容器管理，可在其他地方进行注入使用
import org.springframework.context.annotation.Bean;
// 导入Spring Security框架中用于配置基于Web的安全相关设置的类，通过链式调用的方式可以配置如认证、授权、跨域、会话管理等多个方面的安全策略
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
// 导入Spring Security框架中用于启用Web安全功能的注解，表明在当前应用中要开启Spring Security相关的Web安全配置机制
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
// 导入Spring Security框架中用于定义会话创建策略的枚举类，此处配置为无状态（STATELESS）会话策略，适用于基于Token的认证方式
import org.springframework.security.config.http.SessionCreationPolicy;
// 导入Spring Security框架中用于构建安全过滤链的核心接口，配置好的安全规则最终会形成这样一个过滤链来处理进入应用的请求，进行安全相关的检查和过滤操作
import org.springframework.security.web.SecurityFilterChain;
// 导入Spring框架中用于将类标记为组件的注解，表明该类是一个Spring管理的组件，会被自动扫描并实例化，可在其他地方进行依赖注入使用
import org.springframework.stereotype.Component;
// 导入Spring框架中用于处理跨域相关的工具类，此处用于判断请求是否是跨域预检请求（OPTIONS请求），以便对不同类型请求做不同的授权处理
import org.springframework.web.cors.CorsUtils;
/**
* MallWebSecurityConfigurerAdapter类主要用于配置Spring Security在Web应用中的安全策略，
* 其特点是利用了Spring Security的防火墙等安全相关功能，但并不使用Spring Security自带的认证授权登录机制，
* 而是自行处理认证授权逻辑（可能通过其他自定义方式，比如基于Token的方式等），在这个类中重点配置了如跨域、会话管理以及请求的授权规则等方面的内容，
* 通过定义SecurityFilterChain来构建整个安全过滤链，使得进入应用的请求按照设定的规则进行相应的安全处理。
*
* @author 菠萝凤梨
* @date 2022/3/25 17:33
*/
@Component
@EnableWebSecurity
public class MallWebSecurityConfigurerAdapter {
/**
* 定义一个名为filterChain的方法，并通过@Bean注解将其返回的SecurityFilterChain对象交由Spring容器管理，成为一个可被注入使用的Bean。
* 这个方法用于构建安全过滤链，配置了一系列的安全相关规则，具体如下：
*
* @param http HttpSecurity对象，用于以链式调用的方式配置基于HTTP请求的安全策略，如认证、授权、跨域、会话管理等各个方面
* @return SecurityFilterChain 返回配置好的安全过滤链对象，该过滤链会应用到整个Web应用中，对进入的请求进行安全相关的处理和过滤
* @throws Exception 如果在配置HttpSecurity过程中出现异常（比如配置的规则不符合要求等情况），则会抛出异常，需要进行相应的处理
*/
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
// 关闭跨站请求伪造（CSRF）防护功能，因为基于Token的认证方式下通常不需要CSRF防护，Token本身就用于身份验证，可避免此类安全风险
return http.csrf().disable().cors()
// 配置跨域相关设置，启用跨域支持（后续可能还需要配置更具体的跨域规则等，这里只是开启了基本的支持），
// 接着配置会话管理相关内容，将会话创建策略设置为无状态（STATELESS），意味着服务器不会为客户端创建和维护会话状态，
// 适用于基于Token的认证场景，每次请求都通过携带Token来验证身份，服务器不依赖会话来识别客户端
.and().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
// 配置请求授权相关规则，对于跨域预检请求（OPTIONS请求，通过CorsUtils::isPreFlightRequest判断），允许所有的此类请求通过，
// 因为跨域预检请求主要是浏览器在正式发起跨域请求前进行的一种询问服务器是否允许跨域的请求，通常需要放行
.and().authorizeRequests().requestMatchers(CorsUtils::isPreFlightRequest).permitAll()
// 继续配置请求授权规则，对于所有其他请求（通过"/**"表示任意路径的请求），也都允许通过，这意味着在这个配置下，没有进行严格的基于Spring Security自带认证授权的访问限制，
// 可能后续会通过其他自定义的中间件或者业务逻辑来对请求进行更细致的权限判断等操作，此处只是简单放开了所有请求的访问权限
.and().authorizeRequests().requestMatchers(
"/**").permitAll().and().build();
}
}

84
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/config/AuthConfig.java
Unescape View File

@ -1,84 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.security.common.config;
import cn.hutool.core.util.ArrayUtil;
// 导入自定义的授权配置适配器类，用于适配不同的授权配置相关逻辑，可根据具体业务需求进行扩展或定制
import com.yami.shop.security.common.adapter.AuthConfigAdapter;
// 导入默认的授权配置适配器实现类，当没有自定义的授权配置适配器时，会使用这个默认的实现类来处理相关逻辑
import com.yami.shop.security.common.adapter.DefaultAuthConfigAdapter;
// 导入自定义的授权过滤器类，用于对请求进行授权相关的过滤操作，比如验证用户权限等
import com.yami.shop.security.common.filter.AuthFilter;
import jakarta.servlet.DispatcherType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
/**
* 授权配置类，主要用于在Spring应用中配置授权相关的组件和规则。
* 这个类负责创建授权配置适配器以及注册授权过滤器等操作，以确保应用的授权功能能够正常工作。
*
* @author 菠萝凤梨
* @date 2022/3/25 17:33
*/
@Configuration
// 启用方法级别的安全配置，允许在方法上使用诸如 @PreAuthorize、@PostAuthorize 等注解来进行权限控制
@EnableMethodSecurity
public class AuthConfig {
// 通过自动注入获取授权过滤器实例，该过滤器将在后续的配置中被注册到Servlet容器中，用于对请求进行过滤处理
@Autowired
private AuthFilter authFilter;
/**
* 创建授权配置适配器的Bean。
* 如果在Spring容器中没有找到自定义的AuthConfigAdapter类型的Bean，
* 则会创建并返回一个默认的授权配置适配器实例（DefaultAuthConfigAdapter），
* 这样可以方便地进行默认授权配置或者允许用户自定义授权配置来替换默认配置。
*
* @return AuthConfigAdapter实例，用于适配授权配置相关逻辑
*/
@Bean
@ConditionalOnMissingBean
public AuthConfigAdapter authConfigAdapter() {
return new DefaultAuthConfigAdapter();
}
/**
* 创建并注册授权过滤器的FilterRegistrationBean。
* 这个方法会创建一个FilterRegistrationBean对象，用于将授权过滤器（AuthFilter）注册到Servlet容器中，
* 并配置相关的属性，比如过滤路径、过滤器名称、优先级以及处理的请求类型等。
* 这里使用了 @Lazy 注解，表示该Bean会延迟初始化，只有在第一次使用时才会真正创建实例，避免不必要的资源消耗。
*
* @param authConfigAdapter 授权配置适配器实例，用于获取过滤路径等配置信息
* @return FilterRegistrationBean<AuthFilter>对象，用于将授权过滤器注册到Servlet容器
*/
@Bean
@Lazy
public FilterRegistrationBean<AuthFilter> filterRegistration(AuthConfigAdapter authConfigAdapter) {
FilterRegistrationBean<AuthFilter> registration = new FilterRegistrationBean<>();
// 将之前注入的授权过滤器添加到FilterRegistrationBean中，这样Servlet容器就能识别并使用该过滤器来处理请求了
registration.setFilter(authFilter);
// 设置过滤路径，通过授权配置适配器获取需要过滤的路径列表，并转换为字符串数组格式。
// 这里使用ArrayUtil工具类将获取到的路径列表转换为String数组，以便设置给FilterRegistrationBean，
// 表示该过滤器将会对这些指定的路径下的请求进行过滤处理，此处的 /* 表示所有路径，具体路径配置通常由授权配置适配器决定
registration.addUrlPatterns(ArrayUtil.toArray(authConfigAdapter.pathPatterns(), String.class));
registration.setName("authFilter");
// 设置过滤器的优先级，数值越小优先级越高，这里设置为0，表示较高的优先级，在多个过滤器存在的情况下会先执行该过滤器
registration.setOrder(0);
registration.setDispatcherTypes(DispatcherType.REQUEST);
return registration;
}
}

116
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/config/CaptchaConfig.java
Unescape View File

@ -1,116 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.security.common.config;
import com.anji.captcha.model.common.CaptchaTypeEnum;
import com.anji.captcha.model.common.Const;
import com.anji.captcha.service.CaptchaService;
import com.anji.captcha.service.impl.CaptchaServiceFactory;
import com.anji.captcha.util.ImageUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.util.Base64Utils;
import org.springframework.util.FileCopyUtils;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
* CaptchaConfig类是一个Spring的配置类（通过@Configuration注解标识），
* 主要用于配置验证码相关的服务以及处理验证码底图在Redis中的存储等相关操作。
* 如果出现获取验证码失败的情况，并且提示找管理员查看时，可重点检查Redis中验证码相关数据的存储情况，
* 因为此配置类涉及将验证码底图存入Redis的相关逻辑。
*
* @author 菠萝凤梨
* @date 2022/3/25 17:33
*/
@Configuration
public class CaptchaConfig {
/**
* captchaService方法是一个Spring的Bean定义方法（通过@Bean注解标识），
* 用于创建并配置一个CaptchaService实例，该实例在验证码的生成、验证等流程中起着核心作用。
* 在这里，通过创建一个Properties对象来配置CaptchaService所需的各项参数，
* 然后使用这些配置参数通过CaptchaServiceFactory获取具体的CaptchaService实例。
*
* @return 返回配置好的CaptchaService实例，供Spring容器管理并在需要验证码服务的地方注入使用。
*/
@Bean
public CaptchaService captchaService() {
Properties config = new Properties();
// 设置验证码的缓存类型为Redis，意味着验证码相关的数据（如底图等）将存储在Redis中
config.put(Const.CAPTCHA_CACHETYPE, "redis");
// 设置验证码的水印为空字符串，即不添加水印（具体根据验证码实现逻辑来定是否生效）
config.put(Const.CAPTCHA_WATER_MARK, "");
// 设置验证码的类型为滑动验证，这里使用了CaptchaTypeEnum枚举中BLOCKPUZZLE对应的代码值来指定
config.put(Const.CAPTCHA_TYPE, CaptchaTypeEnum.BLOCKPUZZLE.getCodeValue());
// 设置初始化原始图片相关的标志为true，具体含义取决于验证码服务内部对该参数的使用逻辑
config.put(Const.CAPTCHA_INIT_ORIGINAL, "true");
// 调用initializeBaseMap方法进行一些初始化操作，可能与验证码底图相关（比如预加载等）
initializeBaseMap();
return CaptchaServiceFactory.getInstance(config);
}
/**
* initializeBaseMap方法用于执行与验证码底图初始化相关的操作。
* 它调用了ImageUtils类的cacheBootImage方法，传递从指定路径获取的原始图片资源和滑动块图片资源，
* 以及一个空的Map（可能后续会根据业务逻辑在方法内部填充相关数据），
* 目的是将这些图片资源进行缓存处理（比如转换格式、存入特定缓存等，具体取决于ImageUtils的实现），
* 以便后续验证码生成等操作可以方便地使用这些底图资源。
*/
private static void initializeBaseMap() {
ImageUtils.cacheBootImage(getResourcesImagesFile("classpath:captcha" + "/original/*.png"),
getResourcesImagesFile("classpath:captcha" + "/slidingBlock/*.png"),
Collections.emptyMap());
}
/**
* getResourcesImagesFile方法用于从指定的类路径下获取图片资源，并将其转换为Base64编码的字符串格式存储在一个Map中。
* 这个Map的键是图片的文件名，值是对应的Base64编码后的字符串，方便后续在内存中对图片资源进行管理和使用，
* 例如传递给其他方法用于验证码底图相关的处理等操作。
*
* @param path 表示要获取图片资源的类路径表达式，例如"classpath:captcha" + "/original/*.png"用于获取指定目录下的所有png格式的原始图片资源。
* @return 返回一个Map，其中包含了从指定路径获取到的图片文件名及其对应的Base64编码后的字符串表示形式。
*/
public static Map<String, String> getResourcesImagesFile(String path) {
Map<String, String> imgMap = new HashMap<>(16);
// 创建一个PathMatchingResourcePatternResolver实例，用于解析类路径下的资源模式，能够匹配符合指定模式的多个资源文件
PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
try {
// 根据传入的路径表达式获取对应的资源数组，即匹配该模式的所有图片资源文件
Resource[] resources = resolver.getResources(path);
// 遍历获取到的所有资源文件
Resource[] var4 = resources;
int var5 = resources.length;
for (int var6 = 0; var6 < var5; ++var6) {
Resource resource = var4[var6];
// 将资源文件的内容读取为字节数组，以便后续进行Base64编码操作
byte[] bytes = FileCopyUtils.copyToByteArray(resource.getInputStream());
// 将字节数组转换为Base64编码的字符串，使得图片数据可以以文本形式方便地在内存中存储和传输等
String string = Base64Utils.encodeToString(bytes);
// 获取资源文件的文件名，用于作为Map中的键来标识对应的Base64编码后的图片数据
String filename = resource.getFilename();
imgMap.put(filename, string);
}
} catch (Exception var11) {
// 如果在获取资源文件或处理过程中出现异常，打印异常堆栈信息，方便排查问题
var11.printStackTrace();
}
return imgMap;
}
}

61
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/config/CorsConfig.java
Unescape View File

@ -1,61 +0,0 @@
package com.yami.shop.security.common.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
/**
* CorsConfig类是一个Spring的配置类（通过@Configuration注解标识），
* 其主要作用是配置跨域资源共享（CORS）相关的设置，以便在前后端分离的项目中，
* 解决浏览器的同源策略限制，使得不同域名（或端口等不同源情况）下的前端应用能够安全地访问后端接口。
*
* @author yami
*/
@Configuration
public class CorsConfig {
/**
* corsConfigurationSource方法是一个Spring的Bean定义方法（通过@Bean注解标识），
* 用于创建并配置一个CorsConfigurationSource对象，该对象作为Spring Web中CORS配置的数据源，
* 定义了哪些来源（origins）的请求可以访问本应用的接口、允许的HTTP方法、请求头以及其他相关的跨域设置等信息。
*
* 注意事项：
* - 对于生产环境，建议将配置中的通配符（*）修改为实际需要允许跨域访问的具体域名，
* 虽然通配符可以方便开发测试阶段允许所有来源访问，但在生产环境出于安全考虑，应精确配置。
* - 可以通过多次调用addAllowedOrigin等方法配置多个允许跨域访问的域名，例如：
* configuration.addAllowedOrigin("http://localhost:8080");
* configuration.addAllowedOrigin("http://192.168.1.6:8080");
*
* @return 返回配置好的CorsConfigurationSource对象，供Spring Web在处理跨域请求时使用其配置信息。
*/
@Bean
public CorsConfigurationSource corsConfigurationSource() {
// 创建一个CorsConfiguration对象，用于配置跨域相关的各种规则
CorsConfiguration configuration = new CorsConfiguration();
// 使用addAllowedOriginPattern方法添加允许跨域访问的来源模式，这里使用通配符（*）表示允许所有来源访问，
// 但需注意在生产环境应按实际情况修改为具体域名，可参考上面的注释说明。
configuration.addAllowedOriginPattern("*");
// 修改为添加（add）而不是设置（set）允许的HTTP方法，使用通配符（*）表示允许所有的HTTP方法（如GET、POST、PUT等），
// 这样前端可以使用各种类型的HTTP请求来访问后端接口。
configuration.addAllowedMethod("*");
// 这里配置允许的请求头，同样使用通配符（*）表示允许所有的请求头信息，
// 特别重要的是起码需要允许 Access-Control-Allow-Origin这个请求头，它与跨域访问的合法性验证密切相关。
configuration.addAllowedHeader("*");
// 设置是否允许发送Cookie等凭证信息，设置为true表示允许，
// 若前后端交互需要携带用户认证等相关凭证（如Cookie中的登录信息），则需要开启此项。
configuration.setAllowCredentials(true);
// 设置预检请求（OPTIONS请求）的缓存时间，单位为秒，这里设置为一天（3600 * 24秒），
// 在缓存有效期内，对于相同来源、方法和请求头的请求，浏览器不会再次发送预检请求，提高性能。
configuration.setMaxAge(3600 * 24L);
// 创建一个基于URL的CorsConfigurationSource对象，它可以根据不同的URL路径应用不同的CorsConfiguration配置。
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
// 将上面配置好的CorsConfiguration应用到所有路径（/**表示匹配所有的请求路径），
// 意味着所有的接口请求都会按照这个配置来处理跨域相关的规则。
source.registerCorsConfiguration("/**", configuration);
return source;
}
}

79
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/controller/CaptchaController.java
Unescape View File

@ -1,79 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.security.common.controller;
import com.anji.captcha.model.common.RepCodeEnum;
import com.anji.captcha.model.common.ResponseModel;
import com.anji.captcha.model.vo.CaptchaVO;
import com.anji.captcha.service.CaptchaService;
import io.swagger.v3.oas.annotations.tags.Tag;
import com.yami.shop.common.response.ServerResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* CaptchaController类是一个Spring RESTful风格的控制器类（通过@RestController注解标识），
* 主要负责处理与验证码相关的HTTP请求，如获取验证码、验证验证码等操作。
* 它被映射到"/captcha"路径下（通过@RequestMapping注解配置），并且在Swagger文档中被标记为"验证码"相关的接口（通过@Tag注解定义），方便接口文档的展示和查看。
*
* @author 菠萝凤梨
* @date 2022/3/25 17:33
*/
@RestController
@RequestMapping("/captcha")
@Tag(name = "验证码")
public class CaptchaController {
// 通过构造函数注入的方式引入CaptchaService，用于后续调用验证码相关的业务逻辑方法，比如生成验证码、验证验证码有效性等操作
private final CaptchaService captchaService;
public CaptchaController(CaptchaService captchaService) {
this.captchaService = captchaService;
}
/**
* get方法是一个处理HTTP POST请求的方法，用于获取验证码信息。
* 它接收一个CaptchaVO类型的请求体参数（通过@RequestBody注解标识），该参数包含了获取验证码时可能需要的一些配置信息或参数（具体取决于CaptchaVO的定义）。
* 方法内部调用captchaService的get方法来实际获取验证码相关的数据，并将获取到的结果包装在ServerResponseEntity中返回给客户端，
* 表示操作成功以及返回对应的验证码相关信息（如果成功获取的话）。
*
* @param captchaVO 包含获取验证码相关配置或参数的请求体对象。
* @return 返回一个ServerResponseEntity，其中包装了验证码服务获取到的ResponseModel类型的结果，向客户端表示操作成功并传递验证码相关数据。
*/
@PostMapping({ "/get" })
public ServerResponseEntity<ResponseModel> get(@RequestBody CaptchaVO captchaVO) {
return ServerResponseEntity.success(captchaService.get(captchaVO));
}
/**
* check方法同样是一个处理HTTP POST请求的方法，用于验证客户端提交的验证码是否正确。
* 它也接收一个CaptchaVO类型的请求体参数，该参数包含了待验证的验证码以及可能相关的验证辅助信息（同样取决于CaptchaVO的定义）。
* 方法内部首先尝试调用captchaService的check方法来验证验证码，如果验证过程中没有出现异常，则将验证结果包装在ServerResponseEntity中返回给客户端，
* 表示验证操作成功以及返回对应的验证结果（如验证码是否正确等信息）。
* 如果在验证过程中出现异常，会捕获该异常，并返回一个表示验证码坐标错误的默认错误响应（通过ResponseModel.errorMsg方法构建对应错误消息的ResponseModel对象），
* 同样包装在ServerResponseEntity中返回给客户端，提示客户端验证码验证出现问题。
*
* @param captchaVO 包含待验证验证码及相关信息的请求体对象。
* @return 返回一个ServerResponseEntity，其中包装了验证码服务验证后的ResponseModel类型的结果，向客户端反馈验证操作的成功与否及相应信息。
*/
@PostMapping({ "/check" })
public ServerResponseEntity<ResponseModel> check(@RequestBody CaptchaVO captchaVO) {
ResponseModel responseModel;
try {
responseModel = captchaService.check(captchaVO);
} catch (Exception e) {
return ServerResponseEntity.success(ResponseModel.errorMsg(RepCodeEnum.API_CAPTCHA_COORDINATE_ERROR));
}
return ServerResponseEntity.success(responseModel);
}
}

71
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/controller/LogoutController.java
Unescape View File

@ -1,71 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.security.common.controller;
// 导入Hutool工具库中用于字符串操作的工具类，此处用于判断字符串是否为空（空白字符串），方便进行逻辑判断
import cn.hutool.core.util.StrUtil;
// 导入项目自定义的用于封装服务器响应信息的实体类，包含响应状态码、消息、数据等内容，用于统一向客户端返回响应结果，此处响应数据为Void表示无具体数据返回
import com.yami.shop.common.response.ServerResponseEntity;
// 导入与安全相关的用于管理Token存储和操作的类，负责对Token进行删除等相关管理操作，此处用于删除用户的登录Token
import com.yami.shop.security.common.manager.TokenStore;
// 导入Swagger相关的注解，用于生成API文档，@Operation注解用于描述接口的功能摘要和详细信息，方便前端开发人员等查看接口的作用和使用方式
import io.swagger.v3.oas.annotations.Operation;
// 导入Swagger相关的注解，用于给接口分类添加标签，方便文档中进行分组展示和说明，此处标记为"注销"类别
import io.swagger.v3.oas.annotations.tags.Tag;
// 导入Spring框架用于实现依赖注入的注解，表明后续的属性需要由Spring容器进行注入实例化，此处用于注入TokenStore实例
import org.springframework.beans.factory.annotation.Autowired;
// 导入Spring框架用于定义处理POST请求的注解，将下面的方法映射为一个接收POST请求的接口，处理对应的业务逻辑，即处理用户退出登录的请求
import org.springframework.web.bind.annotation.PostMapping;
// 导入Spring框架用于将类标记为RESTful风格的控制器的注解，表明该类中的方法主要用于处理HTTP请求并返回JSON等格式的响应数据
import org.springframework.web.bind.annotation.RestController;
// 导入Servlet相关的用于操作HTTP请求的类，用于获取请求头中的信息，此处主要用于获取包含Token的"Authorization"请求头内容
import jakarta.servlet.http.HttpServletRequest;
/**
* LogoutController类是一个Spring RESTful风格的控制器类，主要负责处理用户退出登录相关的业务逻辑，
* 通过接收客户端发送的退出登录请求，获取请求头中的Token信息（如果存在），然后调用相关的Token管理组件（TokenStore）删除对应的Token，
* 实现清除用户登录状态以及可能相关的缓存（如菜单缓存等，具体依赖于业务实现）的功能，同时使用Swagger注解生成相关的API文档，便于接口的查看和使用说明。
*
* @author 菠萝凤梨
* @date 2022/3/25 17:33
*/
@RestController
@Tag(name = "注销")
public class LogoutController {
// 通过Spring的依赖注入机制，注入一个TokenStore实例，用于管理Token的删除等相关操作，以实现清除用户登录Token的功能
@Autowired
private TokenStore tokenStore;
/**
* 处理用户退出登录请求的接口方法，接收客户端发送的HTTP请求（通过HttpServletRequest对象获取请求相关信息），
* 首先尝试从请求头中获取名为"Authorization"的Token信息，如果获取到的Token信息为空（空白字符串），
* 则直接返回成功的服务器响应实体，表示可以直接视为已退出登录（可能本身就没有有效的登录状态）；
* 如果获取到了Token信息，则调用TokenStore的方法删除该用户对应的当前Token，然后返回成功的服务器响应实体，告知客户端已成功退出登录。
*
* @param request 包含客户端发送的退出登录请求相关信息的HttpServletRequest对象，用于获取请求头中的Token信息等操作
* @return ServerResponseEntity<Void> 返回一个服务器响应实体，响应数据类型为Void表示无具体数据返回，若成功退出登录则状态码为成功状态；若出现异常等情况，相关的异常处理机制会在更上层进行处理并返回合适的错误响应
*/
@PostMapping("/logOut")
@Operation(summary = "退出登陆", description = "点击退出登陆，清除token，清除菜单缓存")
public ServerResponseEntity<Void> logOut(HttpServletRequest request) {
// 从请求头中获取名为"Authorization"的Token信息，通常在登录成功后，客户端会在后续请求的这个请求头中携带Token用于身份验证等操作
String accessToken = request.getHeader("Authorization");
// 通过Hutool工具类判断获取到的Token信息是否为空（空白字符串），如果为空则直接返回成功的服务器响应实体，表示可视为已退出登录（可能本身就没登录）
if (StrUtil.isBlank(accessToken)) {
return ServerResponseEntity.success();
}
// 如果获取到了有效的Token信息，则调用注入的TokenStore实例的方法，删除该用户在当前系统对应的Token，实现清除登录状态的功能
tokenStore.deleteCurrentToken(accessToken);
return ServerResponseEntity.success();
}
}

47
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/dto/AuthenticationDTO.java
Unescape View File

@ -1,47 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.security.common.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import jakarta.validation.constraints.NotBlank;
/**
* 这个类是数据传输对象（DTO），主要用于在登录操作时传递账号和密码相关的信息。
* 它在系统的安全模块中扮演着重要角色，作为客户端与服务端之间传递登录凭证的载体，方便对登录信息进行统一的校验、处理和传递。
*
* @author 菠萝凤梨
* @date 2022/3/25 17:33
*/
@Data
public class AuthenticationDTO {
/**
* 用于存储用户登录时输入的用户名信息。
* 这里的用户名可以是实际的用户名，也可以是用户注册时关联的邮箱地址或者手机号等能够唯一标识用户身份的信息，具体取决于系统的业务逻辑和认证规则。
* 并且通过 @NotBlank 注解进行了校验约束，要求该字段不能为空，若为空则会根据注解中配置的提示信息（"userName不能为空"）给出相应的错误提示。
* 同时使用 @Schema 注解在 API 文档相关的生成（如 Swagger 等工具生成 API 文档时）中描述该字段，表明它代表用户名/邮箱/手机号，且是必填项。
*/
@NotBlank(message = "userName不能为空")
@Schema(description = "用户名/邮箱/手机号", required = true)
protected String userName;
/**
* 用于存储用户登录时输入的密码信息。
* 此密码是用户在注册账号或者设置安全凭证时设定的，用于验证用户身份合法性的关键信息之一。
* 同样受到 @NotBlank 注解的约束，不能为空，若为空会提示 "passWord不能为空" 的错误信息。
* @Schema 注解用于在 API 文档生成时描述该字段，表示一般用作密码，且是必填项。
*/
@NotBlank(message = "passWord不能为空")
@Schema(description = "一般用作密码", required = true)
protected String passWord;
}

163
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/filter/AuthFilter.java
Unescape View File

@ -1,163 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.security.common.filter;
import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.yami.shop.common.exception.YamiShopBindException;
import com.yami.shop.common.handler.HttpHandler;
import com.yami.shop.common.response.ResponseEnum;
import com.yami.shop.common.response.ServerResponseEntity;
import com.yami.shop.security.common.adapter.AuthConfigAdapter;
import com.yami.shop.security.common.bo.UserInfoInTokenBO;
import com.yami.shop.security.common.manager.TokenStore;
import com.yami.shop.security.common.util.AuthUserContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.FilterConfig;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
/**
* 授权过滤类，主要负责对请求进行授权相关的校验过滤操作。
* 只要实现AuthConfigAdapter接口，添加对应路径即可实现灵活的授权路径配置，以此来控制哪些请求需要授权，哪些不需要授权访问。
* 它在整个系统的安全机制中处于关键位置，是保障系统资源按权限访问的重要防线。
*
* @author 菠萝凤梨
* @date 2022/3/25 17:33
*/
@Component
public class AuthFilter implements Filter {
// 用于记录日志，方便在运行过程中输出相关的调试、错误等信息，便于排查问题
private static final Logger logger = LoggerFactory.getLogger(AuthFilter.class);
// 注入AuthConfigAdapter接口的实现类，通过它可以获取到配置的需要授权和不需要授权的路径信息
@Autowired
private AuthConfigAdapter authConfigAdapter;
// 注入HttpHandler，用于处理向Web端输出响应相关的操作，比如将服务器响应信息正确地返回给前端页面
@Autowired
private HttpHandler httpHandler;
// 注入TokenStore，主要用于管理和操作与令牌（Token）相关的存储及查询等功能，例如从存储中获取用户信息等
@Autowired
private TokenStore tokenStore;
// 通过配置文件注入令牌名称，用于后续从请求头中获取对应的令牌信息
@Value("${sa-token.token-name}")
private String tokenName;
@Override
public void init(FilterConfig filterConfig) throws ServletException {
Filter.super.init(filterConfig);
}
/**
* 核心的过滤方法，对每个经过该过滤器的请求进行处理，判断是否需要授权等操作。
*
* @param request 当前的Servlet请求对象，在这里被转换为HttpServletRequest以获取更多HTTP相关的请求信息
* @param response 当前的Servlet响应对象，在这里被转换为HttpServletResponse用于后续向客户端返回响应
* @param chain 过滤器链，用于将请求传递给下一个过滤器或者最终的目标资源（如Servlet、JSP页面等）
* @throws IOException 如果在处理请求或响应的输入输出流时出现错误则抛出此异常
* @throws ServletException 如果在Servlet处理过程中出现其他异常则抛出此异常
*/
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
// 将ServletRequest转换为HttpServletRequest，方便获取HTTP请求相关的属性和信息，比如请求路径、请求头信息等
HttpServletRequest req = (HttpServletRequest) request;
// 将ServletResponse转换为HttpServletResponse，便于后续进行HTTP响应相关的操作，比如设置响应状态码、响应头、输出响应内容等
HttpServletResponse resp = (HttpServletResponse) response;
// 获取当前请求的URI（统一资源标识符），用于后续与配置的授权路径进行匹配判断
String requestUri = req.getRequestURI();
// 通过AuthConfigAdapter获取不需要授权的路径列表，用于判断当前请求是否命中这些无需授权的路径
List<String> excludePathPatterns = authConfigAdapter.excludePathPatterns();
// 创建AntPathMatcher对象，用于进行路径的匹配操作，它支持通配符等方式来灵活匹配路径
AntPathMatcher pathMatcher = new AntPathMatcher();
// 如果不需要授权的路径列表不为空，就遍历这些路径，检查当前请求的URI是否匹配其中某个无需授权的路径模式
if (CollectionUtil.isNotEmpty(excludePathPatterns)) {
for (String excludePathPattern : excludePathPatterns) {
// 使用AntPathMatcher进行路径匹配，如果匹配成功，说明当前请求是不需要授权的，直接将请求传递给下一个过滤器或目标资源
if (pathMatcher.match(excludePathPattern, requestUri)) {
chain.doFilter(req, resp);
return;
}
}
}
// 从请求头中获取名为tokenName的令牌信息，这个令牌通常用于验证用户的登录状态和权限等
String accessToken = req.getHeader(tokenName);
// 判断当前请求的URI是否匹配可能需要登录但不登录也能用的路径模式（通过AuthConfigAdapter中定义的常量路径进行匹配）
boolean mayAuth = pathMatcher.match(AuthConfigAdapter.MAYBE_AUTH_URI, requestUri);
// 用于存储从令牌中解析出来的用户信息，如果后续成功获取到用户信息则会赋值
UserInfoInTokenBO userInfoInToken = null;
try {
// 如果获取到的令牌信息不为空（即存在令牌），说明用户可能已经登录，需要进一步验证并获取用户信息
if (StrUtil.isNotBlank(accessToken)) {
// 使用StpUtil工具类来校验用户是否已经登录，若登录验证失败会抛出异常，在这里捕获异常并进行相应处理
try {
StpUtil.checkLogin();
} catch (Exception e) {
// 如果登录校验失败，通过HttpHandler将表示未授权的服务器响应信息输出到Web端（通常是返回给前端页面显示相应的错误提示）
httpHandler.printServerResponseToWeb(ServerResponseEntity.fail(ResponseEnum.UNAUTHORIZED));
return;
}
// 如果登录校验通过，从TokenStore中根据令牌获取对应的用户信息（从缓存等存储中查询并解析用户信息）
userInfoInToken = tokenStore.getUserInfoByAccessToken(accessToken, true);
} else if (!mayAuth) {
// 如果没有令牌且当前请求也不属于可能不需要登录就能访问的路径，那么说明该请求需要授权但未提供有效令牌，返回表示未授权的响应给前端
httpHandler.printServerResponseToWeb(ServerResponseEntity.fail(ResponseEnum.UNAUTHORIZED));
return;
}
// 将获取到的用户信息保存到AuthUserContext中，方便在后续的请求处理过程中（比如在其他地方需要获取当前登录用户信息时）可以直接获取
AuthUserContext.set(userInfoInToken);
// 如果前面的授权校验等操作都通过了，将请求传递给下一个过滤器或者最终的目标资源（如业务处理的Servlet等）继续处理
chain.doFilter(req, resp);
} catch (Exception e) {
// 手动捕获非controller层抛出的异常，进行统一处理
if (e instanceof YamiShopBindException) {
// 如果是YamiShopBindException类型的异常，通过HttpHandler将该异常对应的响应信息输出到Web端
httpHandler.printServerResponseToWeb((YamiShopBindException) e);
} else {
// 如果是其他类型的异常，直接抛出，让上层的异常处理机制（比如容器的异常处理）去进一步处理
throw e;
}
} finally {
// 无论请求处理过程是否出现异常，最终都要清理AuthUserContext中的用户信息，避免数据残留影响下一次请求处理
AuthUserContext.clean();
}
}
@Override
public void destroy() {
Filter.super.destroy();
}
}

52
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/manager/PasswordManager.java
Unescape View File

@ -1,52 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.security.common.manager;
import cn.hutool.crypto.symmetric.AES;
import com.yami.shop.common.exception.YamiShopBindException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.nio.charset.StandardCharsets;
/**
* @author 菠萝凤梨
* @date 2022/1/19 16:02
*/
@Component
public class PasswordManager {
private static final Logger logger = LoggerFactory.getLogger(PasswordManager.class);
/**
* 用于aes签名的key，16位
*/
@Value("${auth.password.signKey:-mall4j-password}")
public String passwordSignKey;
public String decryptPassword(String data) {
// 在使用oracle的JDK时，JAR包必须签署特殊的证书才能使用。
// 解决方案 1.使用openJDK或者非oracle的JDK（建议） 2.添加证书
// hutool的aes报错可以打开下面那段代码
// SecureUtil.disableBouncyCastle();
AES aes = new AES(passwordSignKey.getBytes(StandardCharsets.UTF_8));
String decryptStr;
String decryptPassword;
try {
decryptStr = aes.decryptStr(data);
decryptPassword = decryptStr.substring(13);
} catch (Exception e) {
logger.error("Exception:", e);
throw new YamiShopBindException("AES解密错误", e);
}
return decryptPassword;
}
}

63
yami-shop-security/yami-shop-security-common/src/main/java/com/yami/shop/security/common/util/AuthUserContext.java
Unescape View File

@ -1,63 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.security.common.util;
import com.alibaba.ttl.TransmittableThreadLocal;
import com.yami.shop.security.common.bo.UserInfoInTokenBO;
/**
* 这个类主要用于管理当前用户在整个线程上下文中的相关信息（具体是存储从令牌中解析出来的用户信息）。
* 它利用了 `TransmittableThreadLocal` 来实现线程间的数据传递，方便在不同的代码位置都能获取到当前登录用户的相关信息，
* 在整个系统的权限验证及业务处理流程中起着传递用户上下文信息的重要作用。
*
* @author FrozenWatermelon
* @date 2020/7/16
*/
public class AuthUserContext {
// 使用 `TransmittableThreadLocal` 来创建一个线程本地变量，用于存储 `UserInfoInTokenBO` 类型的用户信息对象。
// `TransmittableThreadLocal` 相较于普通的 `ThreadLocal` 具有能在线程间传递数据的优势，
// 适合在多线程环境下（比如异步调用、线程池场景等）保证用户信息的正确传递和共享。
private static final ThreadLocal<UserInfoInTokenBO> USER_INFO_IN_TOKEN_HOLDER = new TransmittableThreadLocal<>();
/**
* 获取存储在当前线程上下文中的用户信息对象（从令牌中解析出的用户信息）。
* 通过调用 `USER_INFO_IN_TOKEN_HOLDER` 的 `get` 方法来获取对应的 `UserInfoInTokenBO` 对象，
* 如果当前线程上下文中没有设置该信息，则会返回 `null`。
*
* @return 当前线程上下文中存储的 `UserInfoInTokenBO` 对象，代表从令牌中解析出的用户信息，可能为 `null`。
*/
public static UserInfoInTokenBO get() {
return USER_INFO_IN_TOKEN_HOLDER.get();
}
/**
* 设置当前线程上下文中的用户信息对象（将从令牌中解析出的用户信息存入线程本地变量中）。
* 调用 `USER_INFO_IN_TOKEN_HOLDER` 的 `set` 方法来保存传入的 `UserInfoInTokenBO` 对象，
* 这样在当前线程后续的执行过程中，其他地方可以通过 `get` 方法获取到这个设置好的用户信息。
*
* @param userInfoInTokenBo 要设置的 `UserInfoInTokenBO` 对象，即从令牌中解析出的用户信息。
*/
public static void set(UserInfoInTokenBO userInfoInTokenBo) {
USER_INFO_IN_TOKEN_HOLDER.set(userInfoInTokenBo);
}
/**
* 清理当前线程上下文中存储的用户信息对象（从线程本地变量中移除用户信息）。
* 首先判断当前线程上下文中是否已经设置了用户信息（即 `USER_INFO_IN_TOKEN_HOLDER.get()` 是否不为 `null`），
* 如果不为 `null`，则调用 `USER_INFO_IN_TOKEN_HOLDER` 的 `remove` 方法将其移除，
* 确保线程本地变量不会残留上一次的用户信息，避免对后续请求处理产生干扰。
*/
public static void clean() {
if (USER_INFO_IN_TOKEN_HOLDER.get()!= null) {
USER_INFO_IN_TOKEN_HOLDER.remove();
}
}
}

BIN
yami-shop-security/yami-shop-security-common/src/main/resources/captcha/original/2.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 43 KiB

BIN
yami-shop-security/yami-shop-security-common/src/main/resources/captcha/slidingBlock/1.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 22 KiB

BIN
yami-shop-security/yami-shop-security-common/src/main/resources/captcha/slidingBlock/2.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 21 KiB

26
yami-shop-service/src/main/java/com/yami/shop/dao/AreaMapper.java
Unescape View File

@ -1,26 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 定义了一个名为com.yami.shop.dao的包，用于组织代码
package com.yami.shop.dao;
// 导入了MyBatis Plus框架中的BaseMapper接口，用于提供基础的CRUD操作
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
// 导入了Area实体类，这个类代表了数据库中的一个表
import com.yami.shop.bean.model.Area;
/**
* 这是一个Mapper接口，用于定义与Area实体相关的数据库操作。
*
* @author lanhai 表示这个接口的作者是lanhai
*/
public interface AreaMapper extends BaseMapper<Area> {
// 这个接口继承了BaseMapper接口，因此已经包含了基础的CRUD操作，不需要额外定义方法
}

26
yami-shop-service/src/main/java/com/yami/shop/dao/AttachFileMapper.java
Unescape View File

@ -1,26 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 定义了一个名为com.yami.shop.dao的包，用于组织代码
package com.yami.shop.dao;
// 导入了MyBatis Plus框架中的BaseMapper接口，用于提供基础的CRUD操作
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
// 导入了AttachFile实体类，这个类代表了数据库中的一个表
import com.yami.shop.bean.model.AttachFile;
/**
* 这是一个Mapper接口，用于定义与AttachFile实体相关的数据库操作。
*
* @author lanhai 表示这个接口的作者是lanhai。
*/
public interface AttachFileMapper extends BaseMapper<AttachFile> {
// 这个接口继承了BaseMapper接口，因此已经包含了基础的CRUD操作，不需要额外定义方法
}

88
yami-shop-service/src/main/java/com/yami/shop/dao/BasketMapper.java
Unescape View File

@ -1,88 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 定义了一个名为com.yami.shop.dao的包，用于组织代码
package com.yami.shop.dao;
// 导入了MyBatis Plus框架中的BaseMapper接口，用于提供基础的CRUD操作
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
// 导入了项目中定义的DTO和参数类
import com.yami.shop.bean.app.dto.ShopCartItemDto;
import com.yami.shop.bean.app.param.ShopCartParam;
// 导入了项目中的实体类
import com.yami.shop.bean.model.Basket;
// 导入了MyBatis的@Param注解，用于在XML或注解中传递参数
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
/**
* 这是一个Mapper接口，用于定义与Basket实体（购物车）相关的数据库操作。
*
* @author lanhai 表示这个接口的作者是lanhai。
*/
public interface BasketMapper extends BaseMapper<Basket> {
/**
* 获取用户的购物项列表。
*
* @param userId 用户id
* @return 返回一个包含用户购物项的DTO列表
*/
List<ShopCartItemDto> getShopCartItems(@Param("userId") String userId);
/**
* 根据购物车id列表和用户id删除购物车项。
*
* @param userId 用户id
* @param basketIds 购物车id列表
*/
void deleteShopCartItemsByBasketIds(@Param("userId") String userId, @Param("basketIds") List<Long> basketIds);
/**
* 删除用户的所有购物车项。
*
* @param userId 用户id
*/
void deleteAllShopCartItems(@Param("userId") String userId);
/**
* 获取失效的购物项列表。
*
* @param userId 用户id
* @return 返回一个包含失效购物项的DTO列表
*/
List<ShopCartItemDto> getShopCartExpiryItems(@Param("userId") String userId);
/**
* 删除失效的购物项。
*
* @param userId 用户id
*/
void cleanExpiryProdList(@Param("userId") String userId);
/**
* 更新购物车的满减活动id。
*
* @param userId 用户id
* @param basketIdShopCartParamMap 购物项id与满减活动参数的映射
*/
void updateDiscountItemId(@Param("userId")String userId, @Param("basketIdShopCartParamMap") Map<Long, ShopCartParam> basketIdShopCartParamMap);
/**
* 根据商品id获取包含该商品的用户id列表。
*
* @param prodId 商品id
* @return 返回一个包含用户id的列表
*/
List<String> listUserIdByProdId(@Param("prodId")Long prodId);
}

37
yami-shop-service/src/main/java/com/yami/shop/dao/BrandMapper.java
Unescape View File

@ -1,37 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yami.shop.bean.model.Brand;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @author lanhai
*/
public interface BrandMapper extends BaseMapper<Brand> {
/**
* 根据品牌名称获取品牌
* @param brandName 品牌名称
* @return 品牌信息
*/
Brand getByBrandName(String brandName);
/**
* 根据分类id获取品牌列表
* @param categoryId 分类id
* @return 品牌列表
*/
List<Brand> listByCategoryId(@Param("categoryId")Long categoryId);
}

44
yami-shop-service/src/main/java/com/yami/shop/dao/CategoryBrandMapper.java
Unescape View File

@ -1,44 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yami.shop.bean.model.CategoryBrand;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 分类品牌Mapper接口，定义了与分类品牌相关的数据库操作
*
* @author lanhai
*/
public interface CategoryBrandMapper extends BaseMapper<CategoryBrand> {
/**
* 批量插入分类品牌关系
* @param categoryId 分类ID
* @param brandIds 品牌ID列表
*/
void insertCategoryBrand(@Param("categoryId") Long categoryId, @Param("brandIds") List<Long> brandIds);
/**
* 根据分类ID删除分类品牌关系
* @param categoryId 分类ID
*/
void deleteByCategoryId(Long categoryId);
/**
* 根据品牌ID删除分类品牌关系
* @param brandId 品牌ID
*/
void deleteByBrandId(Long brandId);
}

37
yami-shop-service/src/main/java/com/yami/shop/dao/CategoryMapper.java
Unescape View File

@ -1,37 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yami.shop.bean.model.Category;
import java.util.List;
/**
* 分类Mapper接口，定义了与分类相关的数据库操作
*
* @author lanhai
*/
public interface CategoryMapper extends BaseMapper<Category> {
/**
* 根据父级ID查询分类列表
* @param parentId 父级ID
* @return 分类列表
*/
List<Category> listByParentId(Long parentId);
/**
* 根据店铺ID查询分类列表
* @param shopId 店铺ID
* @return 分类列表
*/
List<Category> tableCategory(Long shopId);
}

44
yami-shop-service/src/main/java/com/yami/shop/dao/CategoryPropMapper.java
Unescape View File

@ -1,44 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yami.shop.bean.model.CategoryProp;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 分类属性Mapper接口，定义了与分类属性相关的数据库操作
*
* @author lanhai
*/
public interface CategoryPropMapper extends BaseMapper<CategoryProp> {
/**
* 批量插入分类属性关系
* @param categoryId 分类ID
* @param propIds 属性ID列表
*/
void insertCategoryProp(@Param("categoryId") Long categoryId, @Param("propIds") List<Long> propIds);
/**
* 根据分类ID删除分类属性关系
* @param categoryId 分类ID
*/
void deleteByCategoryId(Long categoryId);
/**
* 根据属性ID删除分类属性关系
* @param propId 属性ID
*/
void deleteByPropId(Long propId);
}

29
yami-shop-service/src/main/java/com/yami/shop/dao/DeliveryMapper.java
Unescape View File

@ -1,29 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 定义包名
package com.yami.shop.dao;
// 导入所需的类
import com.yami.shop.bean.model.Delivery;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* DeliveryMapper 接口的文档注释
* 这里可以描述这个接口的作用，比如它是用于数据库操作的Mapper接口
*
* @author lanhai 表示这个类的作者是lanhai
*/
public interface DeliveryMapper extends BaseMapper<Delivery> {
// 这个接口继承了BaseMapper接口，泛型参数为Delivery，表示这个Mapper与Delivery实体类相关联
// 在这个接口中，可以定义与Delivery表相关的数据库操作方法
// 由于继承了BaseMapper，已经包含了很多基础的数据库操作方法，如增删改查
// 如果需要额外的自定义方法，可以在这个接口中声明，然后在对应的XML文件或使用MyBatis Plus的注解方式实现
}

37
yami-shop-service/src/main/java/com/yami/shop/dao/HotSearchMapper.java
Unescape View File

@ -1,37 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yami.shop.bean.dto.HotSearchDto;
import com.yami.shop.bean.model.HotSearch;
import java.util.List;
/**
* HotSearchMapper 是一个数据访问层接口，继承自MyBatis-Plus提供的BaseMapper，
* 提供对HotSearch实体的基本CRUD操作方法。
* 此外，它还定义了一个特定的方法用于根据店铺ID获取热搜列表。
*
* @author lanhai
*/
public interface HotSearchMapper extends BaseMapper<HotSearch> {
/**
* getHotSearchDtoByShopId 方法用于根据给定的店铺ID获取该店铺的热搜列表。
* 它返回的是一个HotSearchDto对象的列表，而不是直接返回数据库中的HotSearch实体对象。
* 这样做通常是为了能够在不改变数据库表结构的情况下调整API输出格式，或者为了减少不必要的数据传输。
*
* @param shopId 店铺的唯一标识符，用于确定要查询的热搜信息所属的店铺。
* @return 返回一个包含指定店铺热搜信息的HotSearchDto对象列表。
*/
List<HotSearchDto> getHotSearchDtoByShopId(Long shopId);
}

37
yami-shop-service/src/main/java/com/yami/shop/dao/IndexImgMapper.java
Unescape View File

@ -1,37 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yami.shop.bean.model.IndexImg;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* IndexImgMapper 是一个数据访问层接口，用于定义对IndexImg实体进行数据库操作的方法。
* 它继承自MyBatis-Plus提供的BaseMapper，从而获得了一系列默认的CRUD方法。
* @author lanhai
*/
public interface IndexImgMapper extends BaseMapper<IndexImg> {
/**
* deleteIndexImgByIds 方法用于根据给定的ID列表批量删除图片记录。
* @param ids 一个或多个要删除的图片记录的ID数组。
*/
void deleteIndexImgByIds(@Param("ids") Long[] ids);
/**
* listIndexImg 方法用于获取所有的图片记录列表。
* @return 返回一个包含所有IndexImg对象的列表。
*/
List<IndexImg> listIndexImg();
}

26
yami-shop-service/src/main/java/com/yami/shop/dao/MessageMapper.java
Unescape View File

@ -1,26 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.dao;
import com.yami.shop.bean.model.Message;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* MessageMapper 是一个数据访问层接口，用于定义针对Message实体的操作方法。
* 它继承自MyBatis-Plus提供的BaseMapper，因此默认实现了对Message表的基本CRUD功能。
*
* 如果需要额外的数据库查询或修改操作，可以在本接口中添加相应的方法，并在对应的XML映射文件或使用@Select等注解实现这些方法。
*
* @author lanhai
*/
public interface MessageMapper extends BaseMapper<Message> {
// 本接口当前没有定义额外的方法，所有操作都依赖于BaseMapper提供的默认方法。
}

45
yami-shop-service/src/main/java/com/yami/shop/service/AreaService.java
Unescape View File

@ -1,45 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 定义了一个名为com.yami.shop.service的包，用于组织代码
package com.yami.shop.service;
// 导入了MyBatis Plus框架中的分页插件Page类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入了MyBatis Plus框架中的IService接口，用于提供基础的CRUD操作
import com.baomidou.mybatisplus.extension.service.IService;
// 导入了Area实体类，这个类代表了数据库中的一个表
import com.yami.shop.bean.model.Area;
import java.util.List;
import java.util.Map;
/**
* 这是一个服务接口，用于定义与Area实体相关的业务操作。
*
* @author lgh on 2018/10/26 表示这个接口的作者是lgh，创建时间为2018年10月26日。
*/
public interface AreaService extends IService<Area> {
/**
* 这是一个通过父id查找地址的方法。
*
* @param pid 父id，用于指定要查找的地址的父级地址
* @return 返回一个Area对象的列表，包含了所有父id为pid的地址信息
*/
List<Area> listByPid(Long pid);
/**
* 这是一个通过父id清除地址缓存的方法。
*
* @param pid 父id，用于指定要清除缓存的地址的父级地址
*/
void removeAreaCacheByParentId(Long pid);
}

46
yami-shop-service/src/main/java/com/yami/shop/service/AttachFileService.java
Unescape View File

@ -1,46 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 定义了一个名为com.yami.shop.service的包，用于组织代码
package com.yami.shop.service;
// 导入了MyBatis Plus框架中的IService接口，用于提供基础的CRUD操作
import com.baomidou.mybatisplus.extension.service.IService;
// 导入了AttachFile实体类，这个类代表了数据库中的一个表
import com.yami.shop.bean.model.AttachFile;
// 导入了Spring框架中的MultipartFile类，用于处理上传的文件
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
/**
* 这是一个服务接口，用于定义与AttachFile实体相关的业务操作。
*
* @author lanhai 表示这个接口的作者是lanhai。
* Created by lgh on 2018/07/27 表示这个接口是由lgh创建的，创建时间为2018年7月27日。
*/
public interface AttachFileService extends IService<AttachFile> {
/**
* 上传文件到本地的方法。
*
* @param file 要上传的文件对象，类型为MultipartFile
* @throws IOException 如果上传过程中发生I/O错误，会抛出IOException异常
* @return 返回一个字符串，通常是上传文件后的一些信息，比如文件路径或者文件ID
*/
String uploadFile(MultipartFile file) throws IOException;
/**
* 删除文件的方法。
*
* @param fileName 要删除的文件名称
*/
void deleteFile(String fileName);
}

111
yami-shop-service/src/main/java/com/yami/shop/service/BasketService.java
Unescape View File

@ -1,111 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yami.shop.bean.app.dto.ShopCartDto;
import com.yami.shop.bean.app.dto.ShopCartItemDto;
import com.yami.shop.bean.app.param.ChangeShopCartParam;
import com.yami.shop.bean.app.param.OrderItemParam;
import com.yami.shop.bean.app.param.ShopCartParam;
import com.yami.shop.bean.model.Basket;
import java.util.List;
import java.util.Map;
/**
* @author lgh on 2018/10/18.
*/
public interface BasketService extends IService<Basket> {
/**
* 根据购物车id列表删除购物项
* @param userId 用户id
* @param basketIds 购物车id列表
*/
void deleteShopCartItemsByBasketIds(String userId, List<Long> basketIds);
/**
* 添加购物车
* @param param
* @param userId
*/
void addShopCartItem(ChangeShopCartParam param, String userId);
/**
* 更新购物车
* @param basket
*/
void updateShopCartItem(Basket basket);
/**
* 删除所有购物车
* @param userId
*/
void deleteAllShopCartItems(String userId);
/**
* 根据用户id获取购物车列表
* @param userId 用户id
* @return 购物车列表
*/
List<ShopCartItemDto> getShopCartItems(String userId);
/**
* 获取购物车失效列表
* @param userId 用户id
* @return 失效商品
*/
List<ShopCartItemDto> getShopCartExpiryItems(String userId);
/**
* 清除失效的购物项
* @param userId 用户id
*/
void cleanExpiryProdList(String userId);
/**
* 更新满减活动id
* @param userId 用户id
* @param basketIdShopCartParamMap 购物车map
*/
void updateBasketByShopCartParam(String userId, Map<Long, ShopCartParam> basketIdShopCartParamMap);
/**
* 删除购物车缓存
* @param userId
*/
void removeShopCartItemsCacheByUserId(String userId);
/**
* 获取购物车中拥有某件商品的用户，用于清除该用户购物车的缓存
* @param prodId 商品id
* @return 用户id
*/
List<String> listUserIdByProdId(Long prodId);
/**
* 根据店铺组装购车中的商品信息，返回每个店铺中的购物车商品信息
* @param shopCartItems 指定的购物项目
* @return 每个店铺的购物车信息
*/
List<ShopCartDto> getShopCarts(List<ShopCartItemDto> shopCartItems);
/**
* 组装获取用户提交的购物车商品项
* @param orderItem 提交订单时携带的商品信息
* @param userId 当前用户的用户id
* @param basketId 购物车id
* @return 所有的商品购物项
*/
List<ShopCartItemDto> getShopCartItemsByOrderItems(List<Long> basketId, OrderItemParam orderItem,String userId);
}

43
yami-shop-service/src/main/java/com/yami/shop/service/BrandService.java
Unescape View File

@ -1,43 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yami.shop.bean.model.Brand;
import java.util.List;
/**
* @author lanhai
*/
public interface BrandService extends IService<Brand> {
/**
* 根据品牌名称获取该品牌
* @param brandName
* @return
*/
Brand getByBrandName(String brandName);
/**
* 删除品牌，同时删除品牌与分类之间的关联关系
* @param brandId
*/
void deleteByBrand(Long brandId);
/**
* 根据分类id获取品牌列表
* @param categoryId 分类id
* @return
*/
List<Brand> listByCategoryId(Long categoryId);
}

24
yami-shop-service/src/main/java/com/yami/shop/service/CategoryBrandService.java
Unescape View File

@ -1,24 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yami.shop.bean.model.CategoryBrand;
/**
* 分类品牌服务接口，继承了MyBatis Plus的IService接口，提供分类品牌相关的业务操作
*
* @author lanhai
*/
public interface CategoryBrandService extends IService<CategoryBrand> {
// 该接口目前为空，继承了IService接口的所有方法，可以添加自定义的方法
}

24
yami-shop-service/src/main/java/com/yami/shop/service/CategoryPropService.java
Unescape View File

@ -1,24 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yami.shop.bean.model.CategoryProp;
/**
* 分类属性服务接口，继承了MyBatis Plus的IService接口，提供分类属性相关的业务操作
*
* @author lanhai
*/
public interface CategoryPropService extends IService<CategoryProp> {
// 该接口目前为空，继承了IService接口的所有方法，可以添加自定义的方法
}

64
yami-shop-service/src/main/java/com/yami/shop/service/CategoryService.java
Unescape View File

@ -1,64 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yami.shop.bean.model.Category;
import java.util.List;
/**
* 商品分类服务接口，继承了MyBatis Plus的IService接口，并扩展了分类相关的业务操作
*
* @author lanhai
*/
public interface CategoryService extends IService<Category> {
/**
* 根据父级ID查询分类列表，用于获取一级分类时传入0
* @param parentId 父级ID，0表示查询一级分类
* @return 分类列表
*/
List<Category> listByParentId(Long parentId);
/**
* 根据店铺ID查询分类列表，并根据seq排序，用于页面表单展示
* @param shopId 店铺ID
* @return 分类列表
*/
List<Category> tableCategory(Long shopId);
/**
* 保存分类信息，包括品牌和参数
* @param category 分类对象
*/
void saveCategory(Category category);
/**
* 更新分类信息，包括品牌和参数
* @param category 分类对象
*/
void updateCategory(Category category);
/**
* 删除分类信息，包括品牌、参数以及分类对应的图片
* @param categoryId 分类ID
*/
void deleteCategory(Long categoryId);
/**
* 根据店铺ID和层级获取商品分类树，用于构建分类树结构
* @param shopId 店铺ID
* @param grade 分类层级
* @return 分类树列表
*/
List<Category> treeSelect(Long shopId, int grade);
}

30
yami-shop-service/src/main/java/com/yami/shop/service/DeliveryService.java
Unescape View File

@ -1,30 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 定义包名，表示这个类属于com.yami.shop.service包
package com.yami.shop.service;
// 导入MyBatis Plus框架中的IService接口，这个接口提供了基本的CRUD操作
import com.baomidou.mybatisplus.extension.service.IService;
// 导入项目中定义的Delivery实体类
import com.yami.shop.bean.model.Delivery;
/**
* DeliveryService接口的文档注释
* 这个接口是用于定义与Delivery实体类相关的业务操作
*
* @author lgh on 2018/11/26 表示这个接口是由lgh在2018年11月26日创建的
*/
public interface DeliveryService extends IService<Delivery> {
// 这个接口继承了IService接口，泛型参数为Delivery，表示这个服务接口与Delivery实体类相关联
// 在这个接口中，可以定义与Delivery实体类相关的额外业务操作方法
// 由于继承了IService，已经包含了很多基础的CRUD操作，如增删改查
}

47
yami-shop-service/src/main/java/com/yami/shop/service/HotSearchService.java
Unescape View File

@ -1,47 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 定义包名，表示这个接口属于com.yami.shop.service包
package com.yami.shop.service;
// 导入MyBatis Plus框架中的IService接口，提供基础的CRUD操作
import com.baomidou.mybatisplus.extension.service.IService;
// 导入项目中定义的HotSearchDto数据传输对象
import com.yami.shop.bean.dto.HotSearchDto;
// 导入项目中定义的HotSearch实体类
import com.yami.shop.bean.model.HotSearch;
// 导入Java.util.List接口，用于返回列表类型的数据
import java.util.List;
/**
* HotSearchService接口的文档注释
* 这个接口是用于定义与HotSearch实体类相关的业务操作
*
* @author lgh on 2019/03/27 表示这个接口是由lgh在2019年3月27日创建的
*/
public interface HotSearchService extends IService<HotSearch> {
/**
* 根据店铺ID获取热搜列表的方法
* 这个方法允许传入一个Long类型的店铺ID，返回一个包含热搜数据的HotSearchDto列表
*
* @param shopId 店铺ID
* @return 根据店铺ID获取的热搜列表
*/
List<HotSearchDto> getHotSearchDtoByShopId(Long shopId);
/**
* 根据店铺ID删除热搜缓存的方法
* 这个方法允许传入一个Long类型的店铺ID，用于清除与该店铺ID相关的热搜缓存
*
* @param shopId 店铺ID
*/
void removeHotSearchDtoCacheByShopId(Long shopId);
}

50
yami-shop-service/src/main/java/com/yami/shop/service/IndexImgService.java
Unescape View File

@ -1,50 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 定义包名，表示这个类属于com.yami.shop.service包
package com.yami.shop.service;
// 导入MyBatis Plus框架中的IService接口，提供基础的CRUD操作
import com.baomidou.mybatisplus.extension.service.IService;
// 导入项目中定义的IndexImg实体类
import com.yami.shop.bean.model.IndexImg;
// 导入Java.util.List接口，用于返回列表类型的数据
import java.util.List;
/**
* IndexImgService接口的文档注释
* 这个接口是用于定义与IndexImg实体类相关的业务操作
*
* @author lgh on 2018/11/26 表示这个接口是由lgh在2018年11月26日创建的
*/
public interface IndexImgService extends IService<IndexImg> {
/**
* 根据id列表删除图片的方法
* 这个方法允许传入一个Long类型的数组，表示要删除的图片的ID列表
*
* @param ids 要删除的图片ID数组
*/
void deleteIndexImgByIds(Long[] ids);
/**
* 获取全部图片列表的方法
* 这个方法返回一个List<IndexImg>类型的数据，包含了所有的图片实体
*
* @return 包含所有图片的列表
*/
List<IndexImg> listIndexImg();
/**
* 删除图片缓存的方法
* 这个方法用于清除与图片相关的缓存，以确保数据的一致性
*/
void removeIndexImgCache();
}

29
yami-shop-service/src/main/java/com/yami/shop/service/MessageService.java
Unescape View File

@ -1,29 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yami.shop.bean.model.Message;
/**
* MessageService 是一个服务层接口，用于定义针对Message实体的业务逻辑方法。
* 它继承自MyBatis-Plus提供的IService，因此默认实现了对Message表的基本CRUD功能。
*
* 通过实现此接口，开发者可以在相应的ServiceImpl类中添加额外的业务逻辑，
* 或者重写已有的方法以满足特定需求。
*
* @author lgh on 2018/10/15.
*/
public interface MessageService extends IService<Message> {
// 本接口当前没有定义额外的方法，所有操作都依赖于IService提供的默认方法。
// 如果需要增加特定的业务逻辑方法，可以在本接口中添加相应的方法签名。
}

40
yami-shop-service/src/main/java/com/yami/shop/service/MyOrderService.java
Unescape View File

@ -1,40 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yami.shop.bean.app.dto.MyOrderDto;
import com.yami.shop.bean.model.Order;
/**
* MyOrderService 是一个服务层接口，用于定义针对用户订单（Order）的业务逻辑方法。
* 它继承自MyBatis-Plus提供的IService，因此默认实现了对Order表的基本CRUD功能。
* 此外，它还提供了一个特定的方法来根据用户ID和订单状态分页获取订单信息。
*
* @author lgh
*/
public interface MyOrderService extends IService<Order> {
/**
* pageMyOrderByUserIdAndStatus 方法用于根据用户ID和订单状态分页查询订单信息。
*
* @param page 分页参数，包含了当前页码、每页显示记录数等信息。
* 该参数也作为返回结果的一部分，用来封装分页后的数据。
* @param userId 用户唯一标识符，用于确定要查询哪个用户的订单。
* @param status 订单的状态码，用于过滤符合条件的订单。
* 如果为null，则表示不根据订单状态进行过滤。
* @return 返回一个IPage<MyOrderDto>对象，其中包含分页后的订单信息列表，
* 以及与分页相关的元数据（如总记录数、总页数等）。
*/
IPage<MyOrderDto> pageMyOrderByUserIdAndStatus(Page<MyOrderDto> page, String userId, Integer status);
}

73
yami-shop-service/src/main/java/com/yami/shop/service/NoticeService.java
Unescape View File

@ -1,73 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 定义包名，表示这个接口属于com.yami.shop.service包
package com.yami.shop.service;
// 导入MyBatis Plus框架中的分页插件的Page类
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
// 导入MyBatis Plus框架中的IService接口，提供基础的CRUD操作
import com.baomidou.mybatisplus.extension.service.IService;
// 导入项目中定义的NoticeDto数据传输对象
import com.yami.shop.bean.app.dto.NoticeDto;
// 导入项目中定义的Notice实体类
import com.yami.shop.bean.model.Notice;
// 导入Java.util.List接口，用于返回列表类型的数据
import java.util.List;
/**
* NoticeService接口的文档注释
* 这个接口是用于定义与Notice实体类相关的业务操作，主要用于公告管理
*
* @author hzm 表示这个接口是由hzm创建的
* @date 2019-04-18 21:21:40 表示这个接口是在2019年4月18日创建的
*/
public interface NoticeService extends IService<Notice> {
/**
* 获取公告列表的方法
* 这个方法返回一个List<Notice>类型的数据，包含了所有的公告实体
*
* @return 包含所有公告的列表
*/
List<Notice> listNotice();
/**
* 删除公告缓存的方法
* 这个方法用于清除与公告相关的缓存，以确保数据的一致性
*/
void removeNoticeList();
/**
* 分页获取公布的公告的方法
* 这个方法接受一个Page<NoticeDto>类型的参数，返回一个分页的NoticeDto列表
*
* @param page 分页参数
* @return 分页的公告DTO列表
*/
Page<NoticeDto> pageNotice(Page<NoticeDto> page);
/**
* 根据公告id获取公告的方法
* 这个方法接受一个Long类型的公告ID，返回对应的Notice实体
*
* @param noticeId 公告ID
* @return 对应的公告实体
*/
Notice getNoticeById(Long noticeId);
/**
* 根据公告id删除公告的方法
* 这个方法接受一个Long类型的公告ID，用于删除对应的公告实体
*
* @param noticeId 公告ID
*/
void removeNoticeById(Long noticeId);
}

73
yami-shop-service/src/main/java/com/yami/shop/service/impl/AreaServiceImpl.java
Unescape View File

@ -1,73 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 定义了一个名为com.yami.shop.service.impl的包，用于组织代码
package com.yami.shop.service.impl;
// 导入了MyBatis Plus框架中的LambdaQueryWrapper类，用于构建条件查询
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
// 导入了MyBatis Plus框架中的ServiceImpl类，用于提供基础的CRUD操作实现
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
// 导入了Area实体类，这个类代表了数据库中的一个表
import com.yami.shop.bean.model.Area;
// 导入了AreaMapper接口，用于数据库操作
import com.yami.shop.dao.AreaMapper;
// 导入了AreaService接口，用于定义业务操作
import com.yami.shop.service.AreaService;
// 导入了Spring框架的注解，用于注入依赖和定义服务
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* 这是一个服务实现类，用于实现AreaService接口中定义的业务操作。
*
* @author lgh on 2018/10/26 表示这个类的作者是lgh，创建时间为2018年10月26日。
*/
@Service
public class AreaServiceImpl extends ServiceImpl<AreaMapper, Area> implements AreaService {
// 使用Spring的@Autowired注解自动注入AreaMapper
@Autowired
private AreaMapper areaMapper;
/**
* 通过父id查找地址列表的方法实现。
* 使用了MyBatis Plus的LambdaQueryWrapper来构建查询条件，查询父id为pid的地址。
* 使用了Spring的@Cacheable注解，表示这个方法的结果会被缓存，缓存名称为"area"，键为方法参数pid。
*
* @param pid 父id，用于指定要查找的地址的父级地址
* @return 返回一个Area对象的列表，包含了所有父id为pid的地址信息
*/
@Override
@Cacheable(cacheNames = "area", key = "#pid")
public List<Area> listByPid(Long pid) {
return areaMapper.selectList(new LambdaQueryWrapper<Area>().eq(Area::getParentId, pid));
}
/**
* 通过父id清除地址缓存的方法实现。
* 使用了Spring的@CacheEvict注解，表示这个方法会清除缓存，缓存名称为"area"，键为方法参数pid。
*
* @param pid 父id，用于指定要清除缓存的地址的父级地址
*/
@Override
@CacheEvict(cacheNames = "area", key = "#pid")
public void removeAreaCacheByParentId(Long pid) {
// 方法体为空，清除缓存的逻辑由Spring Cache自动处理
}
}

134
yami-shop-service/src/main/java/com/yami/shop/service/impl/AttachFileServiceImpl.java
Unescape View File

@ -1,134 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
// 定义了一个名为com.yami.shop.service.impl的包，用于组织代码
package com.yami.shop.service.impl;
// 导入了Hutool工具类，用于日期、文件和ID操作
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.IdUtil;
// 导入了MyBatis Plus框架中的LambdaQueryWrapper类，用于构建条件查询
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
// 导入了MyBatis Plus框架中的ServiceImpl类，用于提供基础的CRUD操作实现
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
// 导入了七牛云存储相关类
import com.qiniu.common.QiniuException;
import com.qiniu.http.Response;
import com.qiniu.storage.BucketManager;
import com.qiniu.storage.UploadManager;
import com.qiniu.storage.model.DefaultPutRet;
import com.qiniu.util.Auth;
// 导入了项目中的枚举、模型、工具类和配置类
import com.yami.shop.bean.enums.UploadType;
import com.yami.shop.bean.model.AttachFile;
import com.yami.shop.common.bean.Qiniu;
import com.yami.shop.common.util.ImgUploadUtil;
import com.yami.shop.common.util.Json;
import com.yami.shop.dao.AttachFileMapper;
import com.yami.shop.service.AttachFileService;
// 导入了Spring框架的注解，用于注入依赖和定义服务
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
// 导入了Spring框架的MultipartFile类，用于处理上传的文件
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.util.Date;
import java.util.Objects;
/**
* 这是一个服务实现类，用于实现AttachFileService接口中定义的业务操作。
*
* @author lanhai 表示这个类的作者是lanhai。
*/
@Service
public class AttachFileServiceImpl extends ServiceImpl<AttachFileMapper, AttachFile> implements AttachFileService {
// 使用Spring的@Autowired注解自动注入AttachFileMapper
@Autowired
private AttachFileMapper attachFileMapper;
// 使用Spring的@Autowired注解自动注入七牛云的UploadManager
@Autowired
private UploadManager uploadManager;
// 使用Spring的@Autowired注解自动注入七牛云的BucketManager
@Autowired
private BucketManager bucketManager;
// 使用Spring的@Autowired注解自动注入七牛云的配置信息
@Autowired
private Qiniu qiniu;
// 使用Spring的@Autowired注解自动注入七牛云的认证工具
@Autowired
private Auth auth;
// 使用Spring的@Autowired注解自动注入图片上传工具类
@Autowired
private ImgUploadUtil imgUploadUtil;
// 定义了一个常量，用于格式化文件名
public final static String NORM_MONTH_PATTERN = "yyyy/MM/";
/**
* 上传文件的方法实现。
* 使用了Spring的@Transactional注解，表示这个方法是一个事务性操作，如果发生异常则回滚。
*
* @param file 要上传的文件对象，类型为MultipartFile
* @throws IOException 如果上传过程中发生I/O错误，会抛出IOException异常
* @return 返回一个字符串，通常是上传文件后的一些信息，比如文件路径或者文件ID
*/
@Override
@Transactional(rollbackFor = Exception.class)
public String uploadFile(MultipartFile file) throws IOException {
// 获取文件扩展名
String extName = FileUtil.extName(file.getOriginalFilename());
// 格式化文件名，包含日期和UUID
String fileName = DateUtil.format(new Date(), NORM_MONTH_PATTERN) + IdUtil.simpleUUID() + "." + extName;
// 创建AttachFile对象，并设置属性
AttachFile attachFile = new AttachFile();
attachFile.setFilePath(fileName);
attachFile.setFileSize(file.getBytes().length);
attachFile.setFileType(extName);
attachFile.setUploadTime(new Date());
// 判断上传类型，如果是本地上传，则保存文件信息到数据库，并上传文件到本地
if (Objects.equals(imgUploadUtil.getUploadType(), 1)) {
attachFileMapper.insert(attachFile);
return imgUploadUtil.upload(file, fileName);
} else {
// 如果是七牛云上传，则获取上传凭证，并上传文件到七牛云
String upToken = auth.uploadToken(qiniu.getBucket(), fileName);
Response response = uploadManager.put(file.getBytes(), fileName, upToken);
// 解析上传响应
Json.parseObject(response.bodyString(), DefaultPutRet.class);
return fileName;
}
}
/**
* 删除文件的方法实现。
*
* @param fileName 要删除的文件名称
*/
@Override
public void deleteFile(String fileName){
// 根据文件名删除数据库中的记录
attachFileMapper.delete(new LambdaQueryWrapper<AttachFile>().eq(AttachFile::getFilePath, fileName));
try {
// 判断上传类型，如果是本地上传，则删除本地文件
if (Objects.equals(imgUploadUtil.getUploadType(), UploadType.LOCAL.value())) {
imgUploadUtil.delete(fileName);
} else if (Objects.equals(imgUploadUtil.getUploadType(), UploadType.QINIU.value())) {
// 如果是七牛云上传，则删除七牛云上的文件
bucketManager.delete(qiniu.getBucket(), fileName);
}
} catch (QiniuException e) {
// 如果删除失败，抛出运行时异常
throw new RuntimeException(e);
}
}
}

246
yami-shop-service/src/main/java/com/yami/shop/service/impl/BasketServiceImpl.java
Unescape View File

@ -1,246 +0,0 @@
/*
* Copyright (c) 2018-2999 广州市蓝海创新科技有限公司 All rights reserved.
*
* https://www.mall4j.com/
*
* 未经允许，不可做商业用途！
*
* 版权所有，侵权必究！
*/
package com.yami.shop.service.impl;
// 导入所需的类和包
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Lists;
import com.yami.shop.bean.app.dto.*;
import com.yami.shop.bean.app.param.ChangeShopCartParam;
import com.yami.shop.bean.app.param.OrderItemParam;
import com.yami.shop.bean.app.param.ShopCartParam;
import com.yami.shop.bean.event.ShopCartEvent;
import com.yami.shop.bean.model.Basket;
import com.yami.shop.bean.model.Product;
import com.yami.shop.bean.model.ShopDetail;
import com.yami.shop.bean.model.Sku;
import com.yami.shop.common.util.Arith;
import com.yami.shop.common.util.CacheManagerUtil;
import com.yami.shop.dao.BasketMapper;
import com.yami.shop.service.BasketService;
import com.yami.shop.service.ProductService;
import com.yami.shop.service.ShopDetailService;
import com.yami.shop.service.SkuService;
import lombok.AllArgsConstructor;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
/**
* 购物车服务实现类
*
* @author lgh on 2018/10/18.
*/
@Service
@AllArgsConstructor
public class BasketServiceImpl extends ServiceImpl<BasketMapper, Basket> implements BasketService {
// 注入的组件
private final BasketMapper basketMapper;
private final CacheManagerUtil cacheManagerUtil;
private final ApplicationContext applicationContext;
private final SkuService skuService;
private final ShopDetailService shopDetailService;
private final ProductService productService;
/**
* 根据购物车ID删除购物车商品
* @param userId 用户ID
* @param basketIds 购物车ID列表
*/
@Override
@CacheEvict(cacheNames = "ShopCartItems", key = "#userId")
public void deleteShopCartItemsByBasketIds(String userId, List<Long> basketIds) {
basketMapper.deleteShopCartItemsByBasketIds(userId, basketIds);
}
/**
* 添加购物车商品
* @param param 购物车参数
* @param userId 用户ID
*/
@Override
@CacheEvict(cacheNames = "ShopCartItems", key = "#userId")
public void addShopCartItem(ChangeShopCartParam param, String userId) {
Basket basket = new Basket();
basket.setBasketCount(param.getCount());
basket.setBasketDate(new Date());
basket.setProdId(param.getProdId());
basket.setShopId(param.getShopId());
basket.setUserId(userId);
basket.setSkuId(param.getSkuId());
basket.setDistributionCardNo(param.getDistributionCardNo());
basketMapper.insert(basket);
}
/**
* 更新购物车商品
* @param basket 购物车对象
*/
@Override
@CacheEvict(cacheNames = "ShopCartItems", key = "#basket.userId")
public void updateShopCartItem(Basket basket) {
basketMapper.updateById(basket);
}
/**
* 删除用户所有购物车商品
* @param userId 用户ID
*/
@Override
@CacheEvict(cacheNames = "ShopCartItems", key = "#userId")
public void deleteAllShopCartItems(String userId) {
basketMapper.deleteAllShopCartItems(userId);
}
/**
* 获取用户购物车商品列表
* @param userId 用户ID
* @return 购物车商品列表
*/
@Override
public List<ShopCartItemDto> getShopCartItems(String userId) {
// 从缓存中获取购物车商品列表，如果缓存中没有则从数据库中获取
List<ShopCartItemDto> shopCartItemDtoList = cacheManagerUtil.getCache("ShopCartItems", userId);
if (shopCartItemDtoList != null) {
return shopCartItemDtoList;
}
shopCartItemDtoList = basketMapper.getShopCartItems(userId);
for (ShopCartItemDto shopCartItemDto : shopCartItemDtoList) {
shopCartItemDto.setProductTotalAmount(Arith.mul(shopCartItemDto.getProdCount(), shopCartItemDto.getPrice()));
}
cacheManagerUtil.putCache("ShopCartItems", userId, shopCartItemDtoList);
return shopCartItemDtoList;
}
/**
* 获取过期的购物车商品列表
* @param userId 用户ID
* @return 过期的购物车商品列表
*/
@Override
public List<ShopCartItemDto> getShopCartExpiryItems(String userId) {
return basketMapper.getShopCartExpiryItems(userId);
}
/**
* 清除过期商品列表
* @param userId 用户ID
*/
@Override
@CacheEvict(cacheNames = "ShopCartItems", key = "#userId")
public void cleanExpiryProdList(String userId) {
basketMapper.cleanExpiryProdList(userId);
}
/**
* 根据购物车参数更新购物车
* @param userId 用户ID
* @param basketIdShopCartParamMap 购物车ID和参数的映射
*/
@Override
@CacheEvict(cacheNames = "ShopCartItems", key = "#userId")
public void updateBasketByShopCartParam(String userId, Map<Long, ShopCartParam> basketIdShopCartParamMap) {
basketMapper.updateDiscountItemId(userId, basketIdShopCartParamMap);
}
/**
* 根据用户ID移除购物车缓存
* @param userId 用户ID
*/
@Override
@CacheEvict(cacheNames = "ShopCartItems", key = "#userId")
public void removeShopCartItemsCacheByUserId(String userId) {
// 该方法体为空，可能是待实现的方法
}
/**
* 根据商品ID列出所有用户的ID
* @param prodId 商品ID
* @return 用户ID列表
*/
@Override
public List<String> listUserIdByProdId(Long prodId) {
return basketMapper.listUserIdByProdId(prodId);
}
/**
* 根据购物车商品项获取购物车信息
* @param shopCartItems 购物车商品项列表
* @return 购物车信息列表
*/
@Override
public List<ShopCartDto> getShopCarts(List<ShopCartItemDto> shopCartItems) {
// 根据店铺ID分组购物车商品项
Map<Long, List<ShopCartItemDto>> shopCartMap = shopCartItems.stream().collect(Collectors.groupingBy(ShopCartItemDto::getShopId));
// 构建购物车信息列表
List<ShopCartDto> shopCartDtos = Lists.newArrayList();
for (Long shopId : shopCartMap.keySet()) {
// 获取店铺的所有商品项
List<ShopCartItemDto> shopCartItemDtoList = shopCartMap.get(shopId);
// 构建每个店铺的购物车信息
ShopCartDto shopCart = new ShopCartDto();
shopCart.setShopId(shopId);
shopCart.setShopName(shopCartItemDtoList.get(0).getShopName());
// 发布购物车事件
applicationContext.publishEvent(new ShopCartEvent(shopCart, shopCartItemDtoList));
shopCartDtos.add(shopCart);
}
return shopCartDtos;
}
/**
* 根据订单项和用户ID获取购物车商品项
* @param basketId 购物车ID列表
* @param orderItem 订单项参数
* @param userId 用户ID
* @return 购物车商品项列表
*/
@Override
public List<ShopCartItemDto> getShopCartItemsByOrderItems(List<Long> basketId, OrderItemParam orderItem, String userId) {
if (orderItem == null && CollectionUtil.isEmpty(basketId)) {
return Collections.emptyList();
}
// 当立即购买时，没有提交的订单是没有购物车信息的
if (CollectionUtil.isEmpty(basketId) && orderItem != null) {
Sku sku = skuService.getSkuBySkuId(orderItem.getSkuId());
if (sku == null) {
throw new RuntimeException("订单包含无法识别的商品");
}
Product prod = productService.getProductByProdId(orderItem.getProdId());
if (prod == null) {
throw new RuntimeException("订单包含无法识别的商品");
}
// 构建购物车商品项
ShopCartItemDto shopCartItemDto = new ShopCartItemDto();
shopCartItemDto.setBasketId(-1L);
shopCartItemDto.setSkuId(orderItem.getSkuId());
shopCartItemDto.setProdCount(orderItem.getProdCount());
shopCartItemDto.setProdId(orderItem.getProdId());
shopCartItemDto.setSkuName(sku.getSkuName());
shopCartItemDto.setPic(StrUtil.isBlank(sku.getPic()) ? prod.getPic() : sku.getPic());
shopCartItemDto.setProdName(sku.getProdName());
shopCartItemDto.set
}

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save