B2C电商项目
钢铁小宝宝
已于 2023-03-08 13:41:00 修改
阅读量303
收藏
点赞数
已于 2023-03-08 13:41:00 修改
阅读量303
收藏
点赞数
于 2023-03-07 21:57:51 首次发布
首页多类别热门商品接口
外界发起请求先到的位置是商品服务，商品服务调用类别服务，类别服务查询到数据后返回商品服务，商品服务再进行数据库的查询，封装结果后返回给前端。前端传过来的是categoryName：[数组]数组里边装的是类别名称。类别名称到商品服务后要调用对应的类别服务。类别服务：/category/hots，数组就没办法路径传参了，用请求体传类别的集合，这个集合装的是类别的名称，通过类别集合到类别服务要进行数据库的查询，之后返回封装。之前的是返回封装的类别对象，但是封装的类别对象也会转成LinkedHashMap。我们希望返回R，但R的data中装类别的id，也就是类别名称对应的类别集合。到商品服务就：1、判断类别查询效果，2、根据类别的id进行商品的查询（只查询热门商品，并且7条），最后结果封装返回就可以。
开发步骤：
1、编写param（编写一个接集合的，上次的是单个值）
2、先完成类别的一套业务（根据类别的集合，怎么查到对应的值）
3、定义feign客户端（在原来的里边加方法就可以了），商品服务通过客户端调用类别服务
4、编写商品的一套业务
1、
package com.qqhru.param;
import lombok.Data;
import javax.validation.constraints.NotEmpty;
import java.util.List;
/**
* 热门商品参数接收对象
*/
@Data
public class ProductHotParam {
@NotEmpty//集合不能为空，集合是NotEmpty
private List<String> categoryName;
}
2、
/**
* 热门类别id查询
* @return
*/
@PostMapping("/hots")
public R hots(@RequestBody @Validated ProductHotParam productHotParam, BindingResult result){
if (result.hasErrors()){
return R.fail("类别集合查询失败！");
}
return categoryService.hotsCategory(productHotParam);
}
/**
* 根据传入的热门类别名称集合，返回类别对应的id集合
* @param productHotParam
* @return
*/
R hotsCategory(ProductHotParam productHotParam);
3、
/**
* 根据传入的热门类别名称集合，返回类别对应的id集合
* @param productHotParam
* @return
*/
@Override
public R hotsCategory(ProductHotParam productHotParam) {
//1、封装查询类别名称
QueryWrapper<Category> categoryQueryWrapper = new QueryWrapper<>();
//eq是单个值，in是集合
categoryQueryWrapper.in("category_name",productHotParam.getCategoryName());//哪一列：category_name 值：productHotParam.getCategoryName()
//如果不指定列，默认查询表中的和类别名称有关的所有列
categoryQueryWrapper.select("category_id");//查询指定类别（查询指定列）
//查询数据库
List<Object> ids = categoryMapper.selectObjs(categoryQueryWrapper);//类别id的集合
/*将类别集合封装返回*/
R ok = R.ok("类别集合查询成功", ids);
log.info("CategoryServiceImpl.hotsCategory业务结束，结果：{}",ok);
return ok;
}
/**
* 类别的调用接口
*/
@FeignClient("category-service")//客户端调用的服务名称
public interface CategoryClient {
//根据类别集合查询类别id的方法
/*调用类别里边根据类别集合查询类别id的方法*/
/*注意：写全路径，根据路径配上服务去注册中心找服务的对应地址，最终向服务发起请求*/
@PostMapping("/category/hots")
R hots(@RequestBody ProductPromoParam productPromoParam);
}
@PostMapping("/hots")
public R hots(@RequestBody @Validated ProductPromoParam productPromoParam,BindingResult result){
if (result.hasErrors()){
return R.fail("数据查询失败！");
}
return productService.hots(productPromoParam);
}
/**
* 多类别热门商品查询，根据类别名称集合！最多查询7条
* 1、调用类别服务
* 2、类别集合id查询商品
* 3、结果集封装即可
* @param productPromoParam 类别名称集合
* @return
*/
R hots(ProductPromoParam productPromoParam);
/**
* 多类别热门商品查询，根据类别名称集合！最多查询7条
* 1、调用类别服务
* 2、类别集合id查询商品
* 3、结果集封装即可
* @param productPromoParam 类别名称集合
* @return
*/
@Override
public R hots(ProductPromoParam productPromoParam) {
R r = categoryClient.hots(productPromoParam);
if (r.getCode().equals(R.FAIL_CODE)){
log.info("ProductServiceImpl.hots业务结束，结果：{}",r.getMsg());
return r;
}
//
List<Object> ids = (List<Object>) r.getData();
//进行商品数据查询
QueryWrapper<Product> productQueryWrapper = new QueryWrapper<>();
productQueryWrapper.in("category_id",ids);//商品表中的category_id等于ids
productQueryWrapper.orderByDesc("product_sales");//热门商品要倒叙，根据商品价格倒叙
//封装分页参数
IPage<Product> page = new Page<>();
page = productMapper.selectPage(page,productQueryWrapper);
List<Product> records = page.getRecords();
R ok = R.ok("多类别热门商品查询成功");
return ok;
}
商品类别信息接口
@GetMapping("/list")
public R list(){
return categoryService.list();
}
/**
* 查询类别数据，进行返回
* @return
*/
R list();
@GetMapping("/category/list")
R list();
@PostMapping("/category/list")
public R clist(){
return productService.clist();
}
/**
* 查询类别商品集合
* @return
*/
R clist();
/**
* 查询类别商品集合
* @return
*/
@Override
public R clist() {
R r = categoryClient.list();// R ok = R.ok("类别集合全部数据查询成功！", categoryList);
log.info("ProductServiceImpl.clist业务结束，结果：{}",r);
return r;
}
/**
* 类别实体类
* 如果有天改了category，需要在ProductService修改获取category_id的key
*/
@Data
@TableName("category")
public class Category {
@JsonProperty("category_id")//json格式化，显示在前端
@TableId(type = IdType.AUTO)
private Integer categoryId;
@JsonProperty("category_name")
private String categoryName;
}
指定类别商品和全部商品接口
1、定义接收参数的param
2、controller、service、mapper
1、
/*单类别（指定类别）商品展示*/
@Data
public class ProductIdsParam extends PageParam{
//可以为空的集合，但是不能传空的值
@NotNull
private List<Integer> categoryID;
private int currentPage = 1;
private int pageSize = 15;//默认值
}
2、
@PostMapping("/bycategory")
public R byCategory(@RequestBody @Validated ProductIdsParam productIdsParam,BindingResult result){
if (result.hasErrors()){
return R.fail("类别商品查询失败！");
}
return productService.byCategory(productIdsParam);
}
3、
/**
* 通用性的业务
* 如果传入了类别型的id，根据id查询并且分页
* 如果没有传入类别的id，查询全部！
* @param productIdsParam
* @return
*/
R byCategory(ProductIdsParam productIdsParam);
4、
@Override
public R byCategory(ProductIdsParam productIdsParam) {
List<Integer> categoryID = productIdsParam.getCategoryID();
/*封装参数*/
QueryWrapper<Product> queryWrapper = new QueryWrapper<>();
if (!categoryID.isEmpty()) {
queryWrapper.in("category_id",categoryID);
}
/*分页*/
IPage<Product> page = new Page<>(productIdsParam.getCurrentPage(),productIdsParam.getPageSize());
/*查询：在当页显示的商品。如果queryWrapper为空，就查询全部*/
page = productMapper.selectPage(page,queryWrapper);
/*结果集封装时候封装一个对应的total*/
R ok = R.ok("查询成功", page.getRecords(), page.getTotal());
log.info("ProductServiceImpl.byCategory业务结束，结果：{}",ok);
return ok;
}
5、
@PostMapping("/all")
public R all(@RequestBody @Validated ProductIdsParam productIdsParam,BindingResult result){
if (result.hasErrors()){
return R.fail("类别商品查询失败！");
}
return productService.byCategory(productIdsParam);
}
商品详情（单个商品）
/*商品id参数接收*/
import lombok.Data;
import javax.validation.constraints.NotNull;
@Data
public class ProductIdParam {
@NotNull
private Integer productID;
}
@PostMapping("/detail")
public R detail(@RequestBody @Validated ProductIdParam productIdParam, BindingResult result){
if (result.hasErrors()){
return R.fail("商品详情查询失败！");
}
return productService.detail(productIdParam.getProductID());
}
/**
* 根据商品id查询商品详情信息
* @param productID
* @return
*/
R detail(Integer productID);
@Override
public R detail(Integer productID) {
Product product = productMapper.selectById(productID);
/*查到数据封装*/
R ok = R.ok(product);
log.info("ProductServiceImpl.detail业务结束，结果：{}",ok);
return ok;
}
图片详情接口
商品图片返回的是一个新的表，还要声明一个对应的实体类，实体类在声明的时候需不需要json格式化
/**
* 商品图片实体类
*/
@TableName("product_picture")
public class Picture {
@TableId(type = IdType.AUTO)
private Integer id;
@TableField("product_id")//数据库表中字段，不声明也没事，会自动改成驼峰式，显示声明效率会更高
@JsonProperty("product_id")//前台测试结果中显示成的JSON格式
private Integer productId;
@TableField("product_picture")
@JsonProperty("product_picture")
private String productPicture;
private String intro;
}
@PostMapping("/pictures")
public R pictures(@RequestBody @Validated ProductIdParam productIdParam, BindingResult result){
if (result.hasErrors()){
return R.fail("商品图片详情查询失败！");
}
return productService.pictures(productIdParam.getProductID());
}
/**
* 查询商品对应的图片详情集合
* @param productID
* @return
*/
R pictures(Integer productID);
//现在不能用productMapper了，因为返回结果已经指定是product_pictures表了
public interface PictureMapper extends BaseMapper<Picture> {
}
/**
* 查询商品对应的图片详情集合
* @param productID
* @return
*/
@Override
public R pictures(Integer productID) {
QueryWrapper<Picture> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("product_id",productID);
List<Picture> pictureList = pictureMapper.selectList(queryWrapper);
R ok = R.ok(pictureList);
log.info("ProductServiceImpl.pictures业务结束，结果：{}",ok);
return ok;
}
缓存设计之缓存介绍和缓存配置引入
每一次点击（商品）都要进行mysql的数据库的查询，每一次查询都会消耗一定的性能，而缓存是把它存储到运行内存中，用更高效的数据库给缓存起来，最后在查询的时候就不用走mysql了，提升查询的性能和提高用户体验度。
缓存本身利用的是redis缓存，所以要连接配置redis的地址和激活缓存配置
如何把配置类应用到每个服务中？把配置类放到通用模块，哪个模块想要使用配置类，只需要声明配置类去继承它。配置文件也放到通用模块，只要下边任何服务需要，只需要激活它就可以了。
缓存配置类
/*缓存配置类，被其他子类继承*/
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import java.time.Duration;
/**
* description: 缓存配置类 放置配置的方法,子模板继承和复用
*/
public class CacheConfiguration {
//配置缓存manager
@Bean
@Primary //同类型,多个bean,默认生效! 默认缓存时间1小时! 可以选择!
public RedisCacheManager cacheManagerHour(RedisConnectionFactory redisConnectionFactory){
RedisCacheConfiguration instanceConfig = instanceConfig(1 * 3600L);//缓存时间1小时
//构建缓存对象
return RedisCacheManager.builder(redisConnectionFactory)
.cacheDefaults(instanceConfig)
.transactionAware()
.build();
}
//缓存一天配置
@Bean
public RedisCacheManager cacheManagerDay(RedisConnectionFactory redisConnectionFactory){
RedisCacheConfiguration instanceConfig = instanceConfig(24 * 3600L);//缓存时间1小时
//构建缓存对象
return RedisCacheManager.builder(redisConnectionFactory)
.cacheDefaults(instanceConfig)
.transactionAware()
.build();
}
/**
* 实例化具体的缓存配置!
* 设置缓存方式JSON
* 设置缓存时间 单位秒
* @param ttl
* @return
*/
private RedisCacheConfiguration instanceConfig(Long ttl){
//设置jackson序列化工具
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer
= new Jackson2JsonRedisSerializer<Object>(Object.class);
//常见jackson的对象映射器,并设置一些基本属性
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
objectMapper.registerModule(new JavaTimeModule());
objectMapper.configure(MapperFeature.USE_ANNOTATIONS,false);
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
return RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofSeconds(ttl)) //设置缓存时间
.disableCachingNullValues()
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer));
}
}
spring:
cache:
type: redis
redis:
host: 192.168.23.140
port: 6379
jedis: # 设置Redis连接池
pool:
max-wait: 2000ms
min-idle: 2
max-idle: 8
max-active: 10
/*商品模块配置类：哪个想要哪个继承CacheConfiguration就可以了*/
@Configuration
public class ProductConfiguration extends CacheConfiguration {
}
激活缓存：
profiles:
active: cache
让缓存生效需要在启动类上加@EnableCaching//开启缓存，让缓存生效
缓存设计之商品服务缓存设计考量
怎么看一个接口适不适合缓存？要看接口的使用率以及接口的更新率。
商品搜索是不宜添加缓存的，因为每次搜索的关键字（key）是不一样的，很少两次搜索相同的数据。缓存时候有key和事件
单类别热门商品缓存时间不宜过长，因为它会受销售的影响，所以设置为1小时
缓存一般在业务层
收藏服务值收藏添加接口
什么时候创建param？只有param和实体类完全不符或者局部属性的时候就要声明param，但这次不要求数据库store_collect的collect表中时间和id不是前端传的，前端就穿两个东西，刚好和实体类的属性相等，所以不用创建param，所以直接使用实体类接值就可以了。第二收藏数据用mybatisplus进行插入，用BaseMapper的insert方法，insert方法里边要的是数据库对应的实体类，所以不创建param。
/*收藏实体类*/
@Data
@TableName("collect")
public class Collect implements Serializable {
public static final Long serialVersionUID = 1L;
@TableId(type = IdType.AUTO)
private Integer id;
@JsonProperty("user_id")
@TableField("user_id")//对应数据库的属性名
private Integer userId;
@TableId("product_id")
@JsonProperty("product_id")
private Integer productId;
@JsonProperty("collect_time")
@TableField("collect_time")
private Long collectTime;
}
@RestController
@RequestMapping("/collect")
public class CollectionController {
@Autowired
private CollectService collectService;
@PostMapping("/save")
public R save(@RequestBody Collect collect){
return collectService.save(collect);
}
}
public interface CollectService {
/**
* 收藏添加的方法
* @param collect
* @return 001 004
*/
R save(Collect collect);
}
/*收藏实现类*/
@Service
@Slf4j
public class CollectServiceImpl implements CollectService {
@Autowired
private CollectMapper collectMapper;
/**
* 收藏添加的方法
* @param collect
* @return 001 004
*/
@Override
public R save(Collect collect) {
//1.先判断（查询）数据是否存在，
QueryWrapper<Collect> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("user_id",collect.getUserId());
queryWrapper.eq("product_id",collect.getProductId());
//查询有几条
Long count = collectMapper.selectCount(queryWrapper);
if (count > 0){//有
//说明已经添加了，不能再添加
return R.fail("该商品已经添加收藏，请到我的收藏查看");
}
//2.如果不存在，则添加,在添加之前补充时间值，因为前端不传时间
collect.setCollectTime(System.currentTimeMillis());
int rows = collectMapper.insert(collect);//影响行数
log.info("CollectServiceImpl.save业务结束，结果：{}",rows);
return R.ok("添加收藏成功");
}
}
/*数据库接口*/
public interface CollectMapper extends BaseMapper<Collect> {
}
收藏展示接口
根据user_id去收藏表中去查出用户对应有哪些商品，结果返回的是商品的详情，还需要把当前用户对应的商品集合，最终完成信息的查询和返回。
1、在收藏服务中根据user_id去查询对应的product_id集合
2、调用商品服务，传入id集合，完成数据查询
3、结果返回即可
收藏服务要调用商品服务，要传入商品id集合。商品服务中根据传入的商品id集合进行数据库的查询，返回数据库信息封装的R
购物车添加接口
创建vo就是用来返回结果的，实体类需要实现Serializable接口。
购物车展示接口
ProductCollectParam可以复用，里边装的是product的id集合
/**
* mq序列化方式，选择json！
* @return
*/
@Bean
public MessageConverter messageConverter(){
return new Jackson2JsonMessageConverter();
}
商品模块值之商品删除
使用阿里云OSS
导入依赖
<!-- 阿里云OSS文件上传开始 -->
<!-- 阿里云 OSS -->
<dependency>
<groupId>com.aliyun.oss</groupId>
<artifactId>aliyun-sdk-oss</artifactId>
<version>3.14.1</version>
</dependency>
<!--日期时间工具-->
<dependency>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
<version>2.10.14</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>
</dependencies>
声明配置
#OSS配置
aliyun:
oss:
file:
# 控制台 - oss - 点击对应桶 - 概览 - 地域节点
endpoint: 你的地域节点
keyid: 你的accesskey
keysecret: 你的accesssecret
bucketname: 你的桶名
导入工具类
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.model.GetObjectRequest;
import com.aliyun.oss.model.ObjectMetadata;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.util.Date;
/**
* projectName: b2c-cloud-store
*
* @author: hwf
* description:
*/
@Component
@Data
@ConfigurationProperties(prefix = "aliyun.oss.file")
public class AliyunOSSUtils {
//基本属性 读取配置文件
private String endPoint;
private String keyId;
private String keySecret;
private String bucketName;
/**
* byte数组格式上传文件并返回上传后的URL地址
* @param objectName 完整文件名, 例如abc/efg/123.jpg
* @param content 文件内容, byte数组格式
* @param contentType 文件类型 image/png image/jpeg
* @param hours 过期时间 单位小时
* @Author hwf
*/
public String uploadImage(String objectName,
byte[] content,String contentType,int hours) throws Exception {
// 创建OSSClient实例。
OSS ossClient = new OSSClientBuilder().build(endPoint, keyId, keySecret);
// 创建上传文件的元信息，可以通过文件元信息设置HTTP header(设置了才能通过返回的链接直接访问)。
ObjectMetadata objectMetadata = new ObjectMetadata();
objectMetadata.setContentType(contentType);
// 文件上传
ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(content), objectMetadata);
// 设置URL过期时间为hours小时。
Date expiration = new Date(System.currentTimeMillis() + 3600 * 1000 * 300 * hours);
//返回url地址
String url = ossClient.generatePresignedUrl(bucketName, objectName, expiration).toString();
//关闭OSSClient。
ossClient.shutdown();
return url;
}
/**
* 下载文件到本地
* @param objectName 完整文件名, 例如abc/efg/123.jpg
* @param localFile 下载到本地文件目录
* @Author hwf
*/
public void downFile(String objectName,
String localFile) throws Exception {
// 创建OSSClient实例。
OSS ossClient = new OSSClientBuilder().build(endPoint, keyId, keySecret);
// 下载OSS文件到本地文件。如果指定的本地文件存在会覆盖，不存在则新建。
ossClient.getObject(new GetObjectRequest(bucketName, objectName), new File(localFile));
// 关闭OSSClient。
ossClient.shutdown();
}
/**
* 删除文件
* @param objectName 完整文件名, 例如abc/efg/123.jpg
* @Author hwf
*/
public void deleteFile(String objectName) {
// 创建OSSClient实例。
OSS ossClient = new OSSClientBuilder().build(endPoint, keyId, keySecret);
// 删除文件。如需删除文件夹，请将ObjectName设置为对应的文件夹名称。如果文件夹非空，则需要将文件夹下的所有object删除后才能删除该文件夹。
ossClient.deleteObject(bucketName, objectName);
// 关闭OSSClient。
ossClient.shutdown();
}
}
实战代码：
@PostMapping("upload")
public Object upload(MultipartFile img) throws Exception {
String filename = img.getOriginalFilename();
String contentType = img.getContentType();
long millis = System.currentTimeMillis();
filename = millis + filename; //防止重复
String url = aliyunOSSUtils.uploadImage(filename, img.getBytes(), contentType, 1000);
System.out.println("url = " + url);
return R.ok("上传成功",url);
}
1915
暂无认证
到【灌水乐园】发言
CSDN-Ada助手: 亲爱的博主，非常感谢您分享了这篇有关Vue踩坑的博客，我们相信这篇文章可以帮助更多的开发者。作为一名优秀的博主，您一定还有更多的技术心得分享给大家，我们期待您的下一篇博客。 针对当前的问题，我们建议您可以写一篇有关Vue项目中常见错误及解决方案的博客，帮助更多的开发者避免常见的坑点。此外，您也可以分享一些Vue开发中的实用技巧和经验，例如Vue组件的封装、Vue路由的应用等等，帮助更多的开发者提升开发效率和项目质量。 祝您写作愉快，期待您的下一篇优秀博客！ 2023年博客之星「城市赛道」年中评选已开启（https://activity.csdn.net/creatActivity?id=10470&utm_source=blog_comment_city ）， 博主的原力值在所在城市已经名列前茅，持续创作就有机会成为所在城市的 TOP1 博主（https://bbs.csdn.net/forums/blogstar2023?typeId=3152981&utm_source=blog_comment_city），更有丰厚奖品等你来拿~。