乐优商城笔记二：分类与品牌模块

最新推荐文章于 2024-09-06 23:00:58 发布
最新推荐文章于 2024-09-06 23:00:58 发布
阅读量986 收藏 5
点赞数
分类专栏： 乐优商城
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1031893936/article/details/91955254
版权
分类模块与品牌模块实现

准备工作

使用nginx，通过域名访问本地项目

  1. 下载nginx压缩包（我这里直接下载的windows包，解压后编写配置文件，即可使用）
  2. nginx.conf
...
# 配置两个server节点即可
    server {
        listen       80;
        server_name  manage.leyou.com;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
        	proxy_pass http://127.0.0.1:9001;
			proxy_connect_timeout 600;
			proxy_read_timeout 600;
        }
    }

    server {
        listen       80;
        server_name  api.leyou.com;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
        	proxy_pass http://127.0.0.1:10001;
			proxy_connect_timeout 600;
			proxy_read_timeout 600;
        }
    }
...

跨域问题解决(采用CORS)

  1. 在ly-gateway中配置bean即可
package com.leyou.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

@Configuration
public class CorsConfig {

    @Bean
    public CorsFilter corsFilter() {
        //1.添加CORS配置信息
        CorsConfiguration config = new CorsConfiguration();
        //1) 允许的域,不要写*，否则cookie就无法使用了
        config.addAllowedOrigin("http://manage.leyou.com");
        //2) 是否发送Cookie信息
        config.setAllowCredentials(true);
        //3) 允许的请求方式
        config.addAllowedMethod("OPTIONS");
        config.addAllowedMethod("HEAD");
        config.addAllowedMethod("GET");
        config.addAllowedMethod("PUT");
        config.addAllowedMethod("POST");
        config.addAllowedMethod("DELETE");
        config.addAllowedMethod("PATCH");
        // 4）允许的头信息
        config.addAllowedHeader("*");
        // 5) 设置第一次跨域通过后，往后的请求不需要再次发送跨域预请求
        config.setMaxAge(7200L);

        //2.添加映射路径，我们拦截一切请求
        UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();
        configSource.registerCorsConfiguration("/**", config);

        //3.返回新的CorsFilter.
        return new CorsFilter(configSource);
    }
}

创建数据库

  1. 创建数据库leyou

  2. 导入数据库文件

    leyou.sql

分类管理模块

后端

添加实体类
package com.leyou.pojo;

import lombok.Data;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Id;
import javax.persistence.Table;

@Table(name="tb_category")
@Data
public class Category {
    @Id
    @KeySql(useGeneratedKeys = true)
    private Long id;
    private String name;
    private Long parentId;
    private Boolean isParent;
    private Integer sort;
}

注意：

​ 实体类放到ly-item-interface中

​ 实体类中使用的注解需要引入mapper-core的依赖。

编写mapper
package com.leyou.item.mapper;

import com.leyou.pojo.Category;
import tk.mybatis.mapper.common.Mapper;

public interface CategoryMapper extends Mapper<Category> {
}

注意：

​ 需要在启动类上加入@MapperScan(com.leyou.item.mapper)注解

编写service
package com.leyou.item.service;

import com.leyou.common.enums.LyExceptionEnum;
import com.leyou.common.exception.LyException;
import com.leyou.item.mapper.CategoryMapper;
import com.leyou.pojo.Category;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.List;

@Service
public class CategoryService {

    @Autowired
    private CategoryMapper categoryMapper;

    /**
     * 按分类父ID查询分类列表
     * @param pid 父ID
     * @return 分类列表
     */
    public List<Category> queryCategoryListByPid(Long pid) {
        Category category = new Category();
        category.setParentId(pid);
        List<Category> categoryList = categoryMapper.select(category);
        if (CollectionUtils.isEmpty(categoryList)) {
            throw new LyException(LyExceptionEnum.CATEGORY_LIST_NOT_FOUND);
        }
        return categoryList;
    }

    /**
     * 新增分类
     * @param category 分类
     * @return 分类
     */
    public Category addCategory(Category category) {
        // 判断其父节点是否为父节点
        if (category.getParentId() != CategoryConstans.FIRST_CATEGORY_PARENT_ID) {
            Category pCategory = categoryMapper.selectByPrimaryKey(category.getParentId());
            if (pCategory != null) {
                // 判断是否已经是父菜单
                if (!pCategory.getIsParent()) {// 不为父菜单
                    // 设置为父菜单并保存
                    pCategory.setIsParent(true);
                    categoryMapper.updateByPrimaryKey(pCategory);
                }
            } else {
                throw new LyException(LyExceptionEnum.PARENT_CATEGORY_NOT_FOUND);
            }
        }
        if (categoryMapper.insert(category) != 1) {
            throw new LyException(LyExceptionEnum.SAVE_FAILURE);
        }
        return category;
    }

    /**
     * 编辑分类
     * @param category 分类
     * @return 分类
     */
    public Category saveCategory(Category category) {
        if (categoryMapper.updateByPrimaryKey(category) != 1) {
            throw new LyException(LyExceptionEnum.SAVE_FAILURE);
        }
        return category;
    }

    /**
     * 删除费雷
     * @param categoryId 分类id
     * @return 被删除的分类
     */
    public Category deleteCategory(Long categoryId) {
        Category category = categoryMapper.selectByPrimaryKey(categoryId);
        if (category == null) {
            throw new LyException(LyExceptionEnum.CATEGORY_NOT_FOUND);
        }
        // 判断该分类是否为父分类，若为父分类判断分类下是否有子分类
        if (category.getIsParent()) {
            Category param = new Category();
            param.setParentId(categoryId);
            if (categoryMapper.select(param).size() > 0) {
                throw new LyException(LyExceptionEnum.DELETE_INVALID);
            }
        }
        if (categoryMapper.delete(category) != 1) {
            throw new LyException(LyExceptionEnum.SAVE_FAILURE);
        }
        return category;
    }
}

新增异常枚举：

CATEGORY_LIST_NOT_FOUND(404, "未查询到分类列表"),
CATEGORY_NOT_FOUND(404, "该分类不存在"),
PARENT_CATEGORY_NOT_FOUND(404, "该父分类不存在"),
SAVE_FAILURE(500, "保存失败"),
DELETE_FAILURE(500, "删除失败"),
DELETE_INVALID(500, "该分类下含有子分类，请先删除其子分类"),

新增分类常量类：

package com.leyou.pojo;

public final class CategoryConstans {
    // 分类一级菜单的父ID
    public static final long FIRST_CATEGORY_PARENT_ID = 0;
}
编写controller
package com.leyou.item.cotroller;

import com.leyou.common.enums.LyExceptionEnum;
import com.leyou.common.exception.LyException;
import com.leyou.item.service.CategoryService;
import com.leyou.pojo.Category;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/category")
public class CategoryController {

    @Autowired
    private CategoryService categoryService;

    @GetMapping("/list")
    public ResponseEntity<List<Category>> queryCategoryListByPid(@RequestParam(value = "pid", defaultValue = "0") Long pid) {
        return ResponseEntity.ok(categoryService.queryCategoryListByPid(pid));
    }

    @PostMapping()
    public ResponseEntity<Category> addCategory(@RequestBody Category category) {
        if (category == null) {
            throw new LyException(LyExceptionEnum.PARAM_CANNOT_BE_NULL);
        }
        return ResponseEntity.status(HttpStatus.CREATED).body(categoryService.addCategory(category));
    }

    @PutMapping()
    public ResponseEntity<Category> saveCategory(@RequestBody Category category) {
        if (category == null) {
            throw new LyException(LyExceptionEnum.PARAM_CANNOT_BE_NULL);
        }
        return ResponseEntity.ok(categoryService.saveCategory(category));
    }

    @DeleteMapping("/{categoryId}")
    public ResponseEntity<Category> deleteCategory(@PathVariable("categoryId") Long categoryId) {
        if (categoryId == null) {
            throw new LyException(LyExceptionEnum.PARAM_CANNOT_BE_NULL);
        }
        return ResponseEntity.ok(categoryService.deleteCategory(categoryId));
    }
}

前端

Category.vue
<template>
  <v-card>
      <v-flex xs12 sm10>
        <v-tree url="/item/category/list"
                :isEdit="isEdit"
                @handleAdd="handleAdd"
                @handleEdit="handleEdit"
                @handleDelete="handleDelete"
                @handleClick="handleClick"
        />
      </v-flex>
  </v-card>
</template>

<script>
  export default {
    name: "category",
    data() {
      return {
        isEdit:true
      }
    },
    methods: {
      handleAdd(node) {
        // console.log("add .... ");
        console.log(node);
        this.$http.post('/item/category', {
          "name": node.name,
          "sort": node.sort,
          "parentId": node.parentId,
          "isParent": node.isParent
        }).then((response) => {
          if (response.status === 201) {
            this.$message.info('添加成功');
          } else {
            this.$message.error(response['message']);
          }
        }).catch(() => {
          this.$message.error('添加失败');
        })
      },
      handleEdit(id, name) {
        console.log("edit... id: " + id + ", name: " + name)
        // 这个树菜单的编辑，我也没玩明白。23333333

      },
      handleDelete(id) {
        // console.log("delete ... " + id)
        this.$http.delete('/item/category/' + id)
          .then((response) => {
            if (response.status === 200) {
              this.$message.info("删除成功")
            } else {
              this.$message.error(response['message'])
            }
          })
          .catch(() => {
            this.$message.error("删除失败")
          })
      },
      handleClick(node) {
      }
    }
  };
</script>

<style scoped>

</style>

树菜单的编辑，我也没玩明白，有玩明白了可以留言一下。

品牌管理模块

后端

添加实体类
package com.leyou.pojo;

import lombok.Data;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Id;
import javax.persistence.Table;

@Table(name = "tb_brand")
@Data
public class Brand {
    @Id
    @KeySql(useGeneratedKeys = true)
    private Long id;
    private String name;
    private String image;
    private Character letter;
}
编写mapper
package com.leyou.item.mapper;

import com.leyou.pojo.Brand;
import tk.mybatis.mapper.common.Mapper;

public interface BrandMapper extends Mapper<Brand> {
}
编写service
package com.leyou.item.service;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.leyou.common.enums.LyExceptionEnum;
import com.leyou.common.exception.LyException;
import com.leyou.common.vo.PageResult;
import com.leyou.item.mapper.BrandMapper;
import com.leyou.pojo.Brand;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import tk.mybatis.mapper.entity.Example;

import java.util.List;

@Service
@Transactional
public class BrandService {

    @Autowired
    private BrandMapper brandMapper;

    /**
     * 分页查询品牌列表
     *
     * @param page   当前页码
     * @param rows   每页记录数
     * @param sortBy 排序字段
     * @param desc   是否降序
     * @param key    查询关键字
     * @return 品牌分页列表
     */
    public PageResult<Brand> queryBrandByPage(int page, int rows, String sortBy, Boolean desc, String key) {
        // 分页查询
        PageHelper.startPage(page, rows);
        // 封装查询条件
        Example example = new Example(Brand.class);
        if (StringUtils.isNoneBlank(key)) {
            example.createCriteria().andLike("name", "%" + key + "%");
        }
        // 排序
        if (StringUtils.isNoneBlank(sortBy)) {
            example.setOrderByClause(sortBy + (desc ? " DESC" : " ASC"));
        }
        List<Brand> brands = brandMapper.selectByExample(example);
        if (brands.size() < 1) {
            throw new LyException(LyExceptionEnum.BRAND_LIST_NOT_FOUND);
        }
        // 获取分页信息并返回
        PageInfo<Brand> pageInfo = new PageInfo<>(brands);
        return new PageResult<>(pageInfo.getTotal(), brands);
    }

    /**
     * 新增品牌
     *
     * @param brand      品牌
     * @param categories 品牌所属分类
     * @return 品牌
     */
    public Brand addBrand(Brand brand, List<Long> categories) {
        // 新增品牌
        if (brandMapper.insert(brand) != 1) {
            throw new LyException(LyExceptionEnum.SAVE_FAILURE);
        }
        // 添加关联的品牌分类
        insertCategoryBrand(brand, categories);

        return brand;
    }

    /**
     * 编辑品牌
     *
     * @param brand      品牌
     * @param categories 品牌所属分类
     * @return 品牌
     */
    public Brand saveBrand(Brand brand, List<Long> categories) {
        // 更新品牌
        if (brandMapper.updateByPrimaryKeySelective(brand) != 1) {
            throw new LyException(LyExceptionEnum.SAVE_FAILURE);
        }
        // 更新关联的品牌分类
        brandMapper.deleteCategoryBrandByBrandId(brand.getId());
        insertCategoryBrand(brand, categories);
        return brand;
    }

    /**
     * 新增品牌分类关联数据(品牌 1 -> n 分类)
     *
     * @param brand      品牌
     * @param categories 分类
     */
    private void insertCategoryBrand(Brand brand, List<Long> categories) {
        categories.forEach(categoryId -> {
            if (brandMapper.insertCategoryBrand(categoryId, brand.getId()) != 1) {
                throw new LyException(LyExceptionEnum.SAVE_FAILURE);
            }
        });
    }

    /**
     * 删除品牌
     *
     * @param brandId 品牌ID
     * @return 被删除的品牌
     */
    public Brand deleteBrand(long brandId) {
        // 查询要删除的品牌
        Brand brand = brandMapper.selectByPrimaryKey(brandId);
        if (brand == null) {
            throw new LyException(LyExceptionEnum.BRAND_LIST_NOT_FOUND);
        }
        // 删除品牌
        if(brandMapper.delete(brand) != 1){
            throw new LyException(LyExceptionEnum.DELETE_FAILURE);
        }
        // 删除品牌的关联分类数据
        brandMapper.deleteCategoryBrandByBrandId(brandId);
        return brand;
    }
}
编写controller
package com.leyou.item.cotroller;

import com.leyou.common.enums.LyExceptionEnum;
import com.leyou.common.exception.LyException;
import com.leyou.common.vo.PageResult;
import com.leyou.item.service.BrandService;
import com.leyou.pojo.Brand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("brand")
public class BrandController {

    @Autowired
    private BrandService brandService;

    @GetMapping("/page")
    public ResponseEntity<PageResult<Brand>> queryBrandByPage(@RequestParam(value = "page", defaultValue = "1") int page,
                                                              @RequestParam(value = "rows", defaultValue = "5") int rows,
                                                              @RequestParam("sortBy") String sortBy,
                                                              @RequestParam(value = "desc",defaultValue = "false") Boolean desc,
                                                              @RequestParam("key") String key) {
        return ResponseEntity.ok(brandService.queryBrandByPage(page, rows, sortBy, desc, key));
    }

    @PostMapping
    public ResponseEntity<Brand> addBrand(@RequestBody Brand brand,
                                          @RequestParam("categories") List<Long> categories) {
        if (CollectionUtils.isEmpty(categories)) {
            throw new LyException(LyExceptionEnum.PARAM_INVALID);
        }
        return ResponseEntity.status(HttpStatus.CREATED).body(brandService.addBrand(brand, categories));
    }

    @PutMapping
    public ResponseEntity<Brand> editBrand(@RequestBody Brand brand,
                                           @RequestParam("categories") List<Long> categories) {
        if (CollectionUtils.isEmpty(categories) || brand.getId() == null) {
            throw new LyException(LyExceptionEnum.PARAM_INVALID);
        }
        return ResponseEntity.ok(brandService.saveBrand(brand, categories));
    }

    @DeleteMapping("/{brandId}")
    public ResponseEntity<Brand> deleteBrand(@PathVariable("brandId") long brandId) {
        return ResponseEntity.ok(brandService.deleteBrand(brandId));
    }


}

文件上传微服务

在品牌管理模块的新增和修改中，需要进行上传图片。所以我们将其抽离出来，形成专门的微服务，以后所有文件上传，无论是图片或者是其他文件，都可以通过此文件上传微服务完成。

搭建项目

创建maven项目
  • GroupId：com.leyou.service
  • ArtifactId：ly-upload
编写pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>parent</artifactId>
        <groupId>com.leyou</groupId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.leyou.service</groupId>
    <artifactId>ly-upload</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>com.leyou.common</groupId>
            <artifactId>ly-common</artifactId>
            <version>${leyou.latest.version}</version>
        </dependency>
    </dependencies>
</project>
启动类
package com.leyou;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class LyUpload {
    public static void main(String[] args) {
        SpringApplication.run(LyUpload.class, args);
    }
}

注意在网关中添加文件上传微服务的路由

编写application.yml
server:
  port: 8082
spring:
  application:
    name: upload-service
  servlet:
    multipart:
      # 限制单个文件的大小
      max-file-size: 5MB
# Eureka
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:9999/eureka

ly:
  upload:
    imageServer: http://image.leyou.com/
    imageTypes:
        - image/jpeg
        - image/bmp
        - image/png

优化

默认情况下，请求通过Zuul网关，Spring MVC会对请求做预处理和缓存，但是文件一旦缓存，会给服务器造成不必要的负担。所以我们需要上传文件的请求不进行缓存。官方给出的解决方案就是在请求的最前面加上/zuul这样就可以绕开请求的缓存，直接将请求路由到指定的微服务。

配置nginx路径重写

修改nginx.conf配置文件

分布式文件系统FastDFS

FastDFS简介

参考：http://www.xushuai.fun/2018/12/22/FastDFS简介/

FastDFS安装

参考：http://www.xushuai.fun/2018/12/22/FastDFS安装/

引入FastDFS-client依赖
  1. java-客户端

  1. 编辑pom.xml文件，新增依赖

    <dependency>
    <groupId>com.github.tobato</groupId>
    <artifactId>fastdfs-client</artifactId>
</dependency>
新增配置
fdfs:
  so-timeout: 1501
  connect-timeout: 601
  thumb-image:             #缩略图生成参数
    width: 150
    height: 150
  tracker-list:            #TrackerList参数,支持多个
    - 192.168.136.100:22122
引入配置类
package com.leyou.upload.config;

import com.github.tobato.fastdfs.FdfsClientConfig;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableMBeanExport;
import org.springframework.context.annotation.Import;
import org.springframework.jmx.support.RegistrationPolicy;

/**
 * 导入FastDFS-Client组件
 * 
 * @author tobato
 *
 */
@Configuration
@Import(FdfsClientConfig.class)
// 解决jmx重复注册bean的问题
@EnableMBeanExport(registration = RegistrationPolicy.IGNORE_EXISTING)
public class ComponetImport {
    // 导入依赖组件
}
编写上传逻辑

  • service

    package com.leyou.upload.service;

import com.github.tobato.fastdfs.domain.StorePath;
import com.github.tobato.fastdfs.service.FastFileStorageClient;
import com.leyou.common.enums.LyExceptionEnum;
import com.leyou.common.exception.LyException;
import com.leyou.upload.constans.FileTypeConstans;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.IOException;

@Service
@Slf4j
public class UploadService {

    @Autowired
    private FastFileStorageClient fastFileStorageClient;

    @Autowired
    private ImageTypeConfigProperty imageTypeConfigProperty;

    /**
     * 文件上传
     *
     * @param file 文件
     * @return 文件url
     */
    public String uploadFile(MultipartFile file, String fileType) {
        String url = null;
        switch (fileType) {
            case FileTypeConstans.IMAGE:
                url = uploadImage(file);
                break;
            default:
                throw new LyException(LyExceptionEnum.FILE_TYPE_ERROR);
        }
        return url;
    }

    /**
     * 图片上传
     *
     * @param file 图片
     * @return 图片url
     */
    private String uploadImage(MultipartFile file) {
        try {
            // 校验图片内容，防止修改后缀名恶意上传
            BufferedImage image = ImageIO.read(file.getInputStream());
            if (image == null || image.getWidth() == 0 || image.getHeight() == 0) {
               throw new LyException(LyExceptionEnum.FILE_TYPE_ERROR);
            }
            // 获取文件后缀名
            String filename = file.getOriginalFilename();
            String suffix = filename.substring(filename.indexOf(".") + 1);

            // 上传文件
            StorePath storePath = fastFileStorageClient.uploadFile(file.getInputStream(), file.getSize(), suffix, null);
            // 返回文件路径
            return imageTypeConfigProperty.getImageServer() + storePath.getFullPath();
        } catch (IOException e) {
            log.error("读取文件内容发生IO异常.  e = {}", e);
            throw new LyException(LyExceptionEnum.READ_FILE_FAILURE);
        }
    }
}

  • controller

    package com.leyou.upload.controller;

import com.leyou.common.enums.LyExceptionEnum;
import com.leyou.common.exception.LyException;
import com.leyou.upload.config.ImageTypeConfigProperty;
import com.leyou.upload.constans.FileTypeConstans;
import com.leyou.upload.service.UploadService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

@RestController
@RequestMapping("/upload")
public class UploadController {

    @Autowired
    private UploadService uploadService;

    @Autowired
    private ImageTypeConfigProperty imageTypeConfigProperty;

    @PostMapping("/image")
    public String uploadImage(@RequestParam("file") MultipartFile file) {
        // 判断图片类型
        if (!imageTypeConfigProperty.getImageTypes().contains(file.getContentType())) {
            throw new LyException(LyExceptionEnum.FILE_TYPE_ERROR);
        }

        return uploadService.uploadFile(file, FileTypeConstans.IMAGE);
    }
}
imxushuai
关注
专栏目录
乐优商城各个模块话术
技术高手
05-09 3697
我主要负责的是后台管理模块中商品的操作，我们后台管理系统是采用Vue+webpack+vue-cli+vue-route+Vuetify所构建的单页应用，所谓单页应用，就是我们一整个项目只有一个html页面，通过VueRoute根据路由规则来切换展示的页面，达到动态切换的效果，采用nginx反向代理，与前台项目共享一个微服务集群，使用axios来发起异步的ajax请求，达到前后端分离的结果，因为我们后台域名与后端域名不同，ajax请求默认不允许跨域，我们通过Cors来解决跨域问题，在商品的图片存储上，我们使
乐优商城商品分类，分页查询，新增品牌
oOoOoOoO_oO的博客
01-09 674
乐优商城商品分类，分页查询，新增品牌商品分类分页及新增品牌 商品分类 传递商品分类的父id值，获取属于这个父id的所有分类信息 CategoryController： CategoryDTO：实体类TbCategory的数据传输对象 根据pid查询返回的是一个集合ResponseEntity<List<>> ResponseEntity.ok= 200 ； 查询成功时返回...
乐优商城项目总结——05品牌查询（stream流，自定义异常等）
胡辣汤麻辣烫的博客
07-31 365
品牌查询 品牌查询实现步骤基本跟分类差不多，只不过有的需要接收很多参数。 代码 service： /** * 分页查询spu * * @param page * @param rows * @param saleable * @param key * @return */ @GetMapping("/spu/p...
品优购项目：一站式资源集合，助力高效开发
最新发布
gitblog_09781的博客
09-06 379
品优购项目：一站式资源集合，助力高效开发 pinyg.rar项目地址:https://gitcode.com/open-source-toolkit/0a7e0 项目介绍 品优购项目是一个专注于为开发者提供完整资源集合的开源项目。无论你是前端开发者、UI设计师，还是后端工程师，品优购项目都能为你提供所需的一切素材和代码，帮助你快速理解和实现品优购项目。 项目技术分析 品优购项目的技术栈涵盖了前端...
乐优商城之分类查询&品牌查询(八)
zzq的博客
07-28 1113
文章目录 (一)编写分类查询 (二)跨域问题 (三)cors跨域原理 (四)解决跨域问题 (一)编写分类查询 分类查询对应的组件是Category.vue，其中用到的<v-tree>子组件是全局组件，可以直接使用 详情见资料包中的自定义组件用法指南，如下： 首先使用:treeData和模拟数据（treeData数组，稍后会导入）进行测试，如下： 导入模拟数据，如下： 效果如下： 我们确认没问题后，去掉:treeData="treeData"，开始编写远程请求的代码 数据库对应表单的对象
乐优商场项目day13—页面分页效果
猿兄
01-14 484
一、添加需要的数据 分页的话，我们需要知道总页数(totalPage)、总条数(total)、当前页(page), 所以我们先在data中记录这几个变量： 因为page是搜索条件之一，所以记录在search搜索对象中： 二、后台提供所需数据 我们后台中返回的PageResult对象里，其实是有这两个数据的： 我们只需要在返回时，将值填上： 重启搜索微服务，然...
乐优商城《项目笔记》.rar
10-11
乐优商城是一个全面的B2C电子商务平台，旨在提供各种类别的商品，让用户能够方便地进行线上购物。在这个项目中，我们关注的核心知识点主要涵盖了从基础的网站架构设计到复杂的功能实现，包括用户交互、购物体验、...
乐优商城项目最新笔记和完成版代码!!注意最新的,不是前8天
01-22
3. **乐优商城项目结构**：一个标准的电商项目通常包括用户模块、商品模块、订单模块、支付模块、物流模块等。在乐优商城中，这些模块可能通过微服务的方式进行拆分，每个模块独立运行，提高系统的可扩展性和可维护...
乐优商城：笔记（七）：搜索微服务：LySearchApplication
dianemax
05-30 1772
文章目录引言客户端的选择创建索引和映射新增数据自定义查询聚合1 环境搭建1.1 创建搜索微服务1.1.1 导入依赖1.1.2 配置文件1.1.3 启动类1.2 搜索结果的数据结构 引言 客户端的选择 搭建好门户网站以后，很重要的一个功能的就是搜索，以京东为例： 在搜索框输入 手机 ，之后点击搜索按钮出现类别为手机的全部商品，这就需要——全文检索技术，在这个微服务当中，我们选择的是全文检索技术是...
乐优商城：笔记（一）：项目概述
dianemax
05-07 6018
文章目录1.系统架构1.1 前端技术简述1.2 前端技术选型 1.系统架构 1.1 前端技术简述 Vuetify vuetify是一个Vue的UI库，提供非常丰富的Vue组件供开发者使用，它支持SSR（服务端渲染），单页应用程序等。 NUXT 这个貌似老师没有讲唉，不知道前端用没用，前端99%都是老师写的，我对前端拿来主义~ （ps：nuxt是做服务器渲染之类的，但是搜索引擎要搜索到页面，必须...
乐优商城：笔记（五）：商品微服务（上）：LyItemApplication
dianemax
05-24 1915
商品微服务：1 微服务结构2 父工程的构建2.1 ly-item-interface2.2 ly-item-service       乐优商城是一个全品类的电商购物平台，那么核心自然就是商品，因此搭建商品微服务 ly-item，包含商品相关的一系列内容的管理，包括： 商品分类管理 品牌管理 商品规格参数管理 商品管理 库存管理 1 ...
乐优商城项目总结1
08-08
1、Spring Boot的特点（1）快速开发spring应用的框架（2）内嵌tomcat和jetty servlet容器，不需要单独安装容器，jar包直接发布
分布式乐优商城项目
12-12
分布式商城项目，后台使用SpringBoot+Springcloud+ElasticSearch+FastDFS+Rabbitmq+Redis+MongoDB+SpringDataJpa,前端使用vue
乐优商城前端
10-08
乐优商城门户网站，门户系统面向的是用户，安全性很重要，而且搜索引擎对于单页应用并不友好。因此门户系统不再采用与后台系统类似的SPA（单页应用）。依然是前后端分离，不过前端的页面会使用独立的html，在每个页面中使用vue来做页面渲染。
leyou数据库修改后的.sql
12-12
用dbeaver亲测可用，包含tb_spec_group,tb_spec_param表是更新后的，阿拉啦啦啦啦
乐优商场开发第四天笔记
wwg18895736195的博客
10-12 1776
0.学习目标 了解电商行业 了解乐优商城项目结构 能独立搭建项目基本框架 能参考使用ES6的新语法   1.了解电商行业 学习电商项目，自然要先了解这个行业，所以我们首先来聊聊电商行业   1.1.项目分类 主要从需求方、盈利模式、技术侧重点这三个方面来看它们的不同 1.1.1.传统项目 各种企业里面用的管理系统（ERP、HR、OA、CRM、物...
乐优商城之品牌新增&fastDFS(九)
zzq的博客
07-30 4756
文章目录 (一)请求处理过程 (二)品牌新增页面分析 (三)品牌新增后台代码 (四)qs工具 (五)页面校验 (一)请求处理过程 以品牌查询为例，如下： (二)品牌新增页面分析 之前完成了品牌的查询，接下来就是新增功能，点击新增品牌按钮，如下： Brand.vue页面有一个提交按钮，如下： 点击触发addBrand方法，如下： this.show就是我们要找的弹窗，如下： 分析该自定义组件中级联选择的实现，如下： 新增品牌后看报错，可以看到请求路径和请求方式，如下： 请求参数如下： 大概
乐优商城问题1：新增品牌失败
weixin_30265103的博客
04-19 300
教学视频中： 我的浏览器中： 问题所在： 前端源代码中有一个地方和视频中不一样，参数不对，教学视频中沒写前端，结果前端出错了，下载的源码有问题，而我没做前端， 所以不知道哪儿错了。（浪费时间一天半 - -！坑） 改正后： 解决： 改正前端出错地方。再次启动，新增成功。浏览器参数也和视频中一致了。 转载于:https://www.cnblogs.com/weiqang/p/10736921...
乐优商城笔记五：搜索模块
Bbb的博客
06-14 1207
乐优商城搜索微服务的搭建与实现 服务搭建 创建工程 GroupId：com.leyou.service ArtifactId：ly-search 编写pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:x...
Node.js学习笔记：事件驱动与模块化
"Node.js学习笔记，包括Node.js的定义、特点、npm和yarn的使用以及模块化的介绍。" Node.js是一种基于Chrome V8引擎的JavaScript运行环境，它为JavaScript提供了一个独立于浏览器的运行环境，使JavaScript可以脱离...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值