java 前台商品展示模块_校园商铺-8商品模块-10商品列表展示之后端开发

1.Dao层

1.1 Dao接口

package com.csj2018.o2o.dao;

import java.util.List;

import org.apache.ibatis.annotations.Param;

import com.csj2018.o2o.entity.Product;

public interface ProductDao {

/**

* 8-10查询商品列表并分页，可输入的条件有：商品名(模糊)、商品状态，店铺ID，商品类别

* @param productCondition

* @param beginIndex

* @param pageSize

* @return

*/

List queryProductList(@Param("productCondition") Product productCondition, @Param("rowIndex") int rowIndex, @Param("pageSize") int pageSize);

/**

* 8-10查询对应的商品总数

* @param productCondition

* @return

*/

int queryProductCount(@Param("productCondition") Product productCondition);

Product queryProductById(Long productId);

/**

* 插入商品

* @param product

* @return

*/

int insertProduct(Product product);

/**

* 更新商品信息

* @param product

* @return

*/

int updateProduct(Product product);

int updateProductCategoryToNull(Long productId);

int deleteProduct(Product product);

}

1.2Dao实现mapper

/p>

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >

select

p.product_id, p.product_name, p.product_desc, p.img_addr, p.normal_price, p.promotion_price, p.priority,

p.create_time, p.last_edit_time, p.enable_status, p.product_category_id, p.shop_id,

pm.product_img_id, pm.img_addr as detail_img, pm.img_desc, pm.priority, pm.create_time

from tb_product p left join tb_product_img pm

on p.product_id = pm.product_id

where p.product_id = #{productId}

order by pm.priority desc

update tb_product

product_name = #{productName},

product_desc = #{productDesc},

img_addr = #{imgAddr},

normal_price = #{normalPrice},

promotion_price = #{promotionPrice},

priority = #{priority},

last_edit_time = #{lastEditTime},

enable_status = #{enableStatus},

product_category_id = #{productCategory.productCategoryId}

where product_id = #{productId} and shop_id = #{shop.shopId}

insert into tb_product(

product_name,product_desc,img_addr,normal_price,promotion_price,

priority,create_time,last_edit_time,enable_status,product_category_id,shop_id

)values(

#{productName},#{productDesc},#{imgAddr},#{normalPrice},#{promotionPrice},

#{priority},#{createTime},#{lastEditTime},#{enableStatus},#{productCategory.productCategoryId},#{shop.shopId}

)

select

product_id, product_name, product_desc, img_addr,

normal_price, promotion_price, priority, create_time,

last_edit_time, enable_status, product_category_id, shop_id

from tb_product

and shop_id = #{productCondition.shop.shopId}

and product_category_id = #{productCondition.productCategory.productCategoryId}

and product_name like '%${productCondition.productName}%'

and enable_status = #{productCondition.enableStatus}

order by priority desc limit #{rowIndex},#{pageSize};

select count(1) from tb_product

and shop_id = #{productCondition.shop.shopId}

and product_category_id = #{productCondition.productCategory.productCategoryId}

and product_name like '%${productCondition.productName}%'

and enable_status = #{productCondition.enableStatus}

1.3 Dao单元测试

package com.csj2018.o2o.dao;

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import org.junit.FixMethodOrder;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.runners.MethodSorters;

import org.springframework.beans.factory.annotation.Autowired;

import com.csj2018.o2o.BaseTest;

import com.csj2018.o2o.entity.Product;

import com.csj2018.o2o.entity.ProductCategory;

import com.csj2018.o2o.entity.ProductImg;

import com.csj2018.o2o.entity.Shop;

@FixMethodOrder(MethodSorters.NAME_ASCENDING)

public class ProductDaoTest extends BaseTest{

@Autowired

private ProductDao productDao;

@Autowired

private ProductImgDao productImgDao;

@Test

@Ignore

public void testAInsertProduct() throws Exception{

Shop shop1 = new Shop();

shop1.setShopId(1L);

ProductCategory pc1 = new ProductCategory();

pc1.setProductCategoryId(10L);

Product product1 = new Product();

product1.setProductName("商品1");

product1.setProductDesc("商品1的描述");

product1.setImgAddr("商品1的缩略图");

product1.setPriority(1);

product1.setEnableStatus(1);

product1.setCreateTime(new Date());

product1.setLastEditTime(new Date());

product1.setShop(shop1);

product1.setProductCategory(pc1);

Product product2 = new Product();

product2.setProductName("商品2");

product2.setProductDesc("商品2的描述");

product2.setImgAddr("商品2的缩略图");

product2.setPriority(2);

product2.setEnableStatus(0);

product2.setCreateTime(new Date());

product2.setLastEditTime(new Date());

product2.setShop(shop1);

product2.setProductCategory(pc1);

Product product3 = new Product();

product3.setProductName("商品3");

product3.setProductDesc("商品3的描述");

product3.setImgAddr("商品3的缩略图");

product3.setPriority(3);

product3.setEnableStatus(1);

product3.setCreateTime(new Date());

product3.setLastEditTime(new Date());

product3.setShop(shop1);

product3.setProductCategory(pc1);

int effectedNum = productDao.insertProduct(product1);

assertEquals(1,effectedNum);

effectedNum = productDao.insertProduct(product2);

assertEquals(1,effectedNum);

effectedNum = productDao.insertProduct(product3);

assertEquals(1,effectedNum);

}

//8-10

@Test

public void testBQueryProductList() {

//product表原有9条数据，商品名包含测试的有1条

Product productCondition = new Product();

//分页查询，预期返回3条数据

List productList = productDao.queryProductList(productCondition, 0, 3);

assertEquals(3,productList.size());

int count = productDao.queryProductCount(productCondition);

assertEquals(9,count);

//查询名称为测试的商品总数

productCondition.setProductName("测试");

productList = productDao.queryProductList(productCondition, 0, 3);

count = productDao.queryProductCount(productCondition);

assertEquals(1,count);

}

@Test

@Ignore

public void testCQueryProductByProductId() throws Exception{

long productId = 1;

//初始化两个商品详情图实例，作为productId为1的商品下的详情图片

//批量插入到商品详情图标中

ProductImg productImg1 = new ProductImg();

productImg1.setImgAddr("图片1");

productImg1.setImgDesc("测试图片1");

productImg1.setPriority(1);

productImg1.setCreateTime(new Date());

productImg1.setProductId(productId);

ProductImg productImg2 = new ProductImg();

productImg2.setImgAddr("图片1");

productImg2.setImgDesc("测试图片1");

productImg2.setPriority(1);

productImg2.setCreateTime(new Date());

productImg2.setProductId(productId);

List productImgList = new ArrayList<>();

productImgList.add(productImg1);

productImgList.add(productImg2);

int effectedNum = productImgDao.batchInsertProductImg(productImgList);

assertEquals(2,effectedNum);

//查询productId为1的商品信息并校验返回的详情图实例列表size是否为2

Product product = productDao.queryProductById(productId);

assertEquals(2,product.getProductImgList().size());

//删除新增的这两个商品详情图示例，形成闭环

effectedNum = productImgDao.deleteProductImgByProductId(productId);

assertEquals(2,effectedNum);

}

@Test

@Ignore

public void testDUpdateProduct() {

Product product = new Product();

ProductCategory pc = new ProductCategory();

Shop shop = new Shop();

shop.setShopId(1L);

pc.setProductCategoryId(12L);

product.setProductId(1L);

product.setShop(shop);

product.setProductCategory(pc);

product.setProductName("躺着喝的美式咖啡");

int effectedNum = productDao.updateProduct(product);

assertEquals(1,effectedNum);

}

@Test

@Ignore

public void testEUpdateProductCategoryToNull() {}

@Test

@Ignore

public void testFDeleteShopAutoMap() {}

}

2. Service层

package com.csj2018.o2o.service.impl;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import com.csj2018.o2o.dao.ProductDao;

import com.csj2018.o2o.dao.ProductImgDao;

import com.csj2018.o2o.dto.ImageHolder;

import com.csj2018.o2o.dto.ProductExecution;

import com.csj2018.o2o.entity.Product;

import com.csj2018.o2o.entity.ProductImg;

import com.csj2018.o2o.enums.ProductStateEnum;

import com.csj2018.o2o.exceptions.ProductOperationException;

import com.csj2018.o2o.service.ProductService;

import com.csj2018.o2o.util.*;

@Service

public class ProductServiceImpl implements ProductService{

@Autowired

private ProductDao productDao;

@Autowired

private ProductImgDao productImgDao;

//8-10

@Override

public ProductExecution getProductList(Product productCondition,int pageIndex,int pageSize) {

//页码转换成数据库的行码，并调用dao层取回指定页码的商品列表

int rowIndex = PageCalculator.calculatorRowIndex(pageIndex, pageSize);

List productList = productDao.queryProductList(productCondition, rowIndex, pageSize);

//基于同样的查询条件返回该查询条件下的商品总数

int count = productDao.queryProductCount(productCondition);

ProductExecution pe = new ProductExecution();

pe.setCount(count);

pe.setProductList(productList);

return pe;

}

/*

* 1.处理缩略图，获取缩略图相对路径并赋值给product

* 2.往tb_product写入商品信息，获取productId

* 3.结合productId批量处理商品详情图

* 4.将商品详情图列表批量插入tb_product_img中

* 通过spring的事务管理去执行这4不操作，任何一步出错就回滚，不会往表里写入

*/

@Override

@Transactional

public ProductExecution addProduct(Product product, ImageHolder thumbnail, List productImgHolderList)

throws ProductOperationException {

//空值判断

if(product != null && product.getShop() != null && product.getShop().getShopId() != null) {

//给商品设置默认属性

product.setCreateTime(new Date());

product.setLastEditTime(new Date());

//默认为上架的状态

product.setEnableStatus(1);

//若商品缩略图不为空，则添加缩略图信息到商品

if(thumbnail != null) {

addThumbnail(product,thumbnail);

}

try {

int effectedNum = productDao.insertProduct(product);

if(effectedNum <= 0) {

throw new ProductOperationException("创建商品失败");

}

}catch (Exception e) {

throw new ProductOperationException("创建商品失败："+e.toString());

}

//若商品详情图不为空，则向tb_product_img添加商品详情图

if(productImgHolderList != null && productImgHolderList.size() >0) {

addProductImgList(product,productImgHolderList);

}

return new ProductExecution(ProductStateEnum.SUCCESS,product);

}else {

//传参为空，则返回控制错误信息

return new ProductExecution(ProductStateEnum.EMPTY);

}

}

/**

* 向product对象添加缩略图

* @param product

* @param thumbnail

*/

private void addThumbnail(Product product, ImageHolder thumbnail) {

String dest = PathUtil.getShopImagePath(product.getShop().getShopId());

String thumbnailAddr = ImageUtil.generateThumbnail(thumbnail, dest);

product.setImgAddr(thumbnailAddr);

}

private void addProductImgList(Product product, List productImgHolderList) {

//获取图片存储路径，这里直接存放到相应店铺的文件夹下，同缩略图

String dest = PathUtil.getShopImagePath(product.getShop().getShopId());

List productImgList = new ArrayList();

//遍历，获得详情图片列表

for(ImageHolder productImgHolder:productImgHolderList) {

String imgAddr = ImageUtil.generateNormalImg(productImgHolder, dest);

ProductImg productImg = new ProductImg();

productImg.setImgAddr(imgAddr);

productImg.setProductId(product.getProductId());

productImg.setCreateTime(new Date());

productImgList.add(productImg);

}

if(productImgList.size() > 0) {

try {

int effectedNum = productImgDao.batchInsertProductImg(productImgList);

if(effectedNum <= 0) {

throw new ProductOperationException("创建商品详情图片失败");

}

}catch (Exception e) {

throw new ProductOperationException("创建商品详情图片失败："+e.toString());

}

}

}

@Override

public Product getProductById(long productId) {

return productDao.queryProductById(productId);

}

//1.若缩略图参数有值，则处理缩略图

//2.若原先存在缩略图则先删除再添加新图，之后获取缩略图相对路径并赋值给product

//3.将tb_product_img下面的该商品原先的商品详情记录全部清除

//4.更新tb_product，tb_product_img的信息

@Override

@Transactional

public ProductExecution modifyProduct(Product product, ImageHolder thumbnail, List productImgList)

throws ProductOperationException {

//空值判断。存放商品缩略图和详情图需要用到shopId做路径，因此需要针对shop做空值判断

if(product != null && product.getShop() != null && product.getShop().getShopId() != null) {

//给商品设置添加默认属性

product.setLastEditTime(new Date());

//若商品缩略图不为空且原有缩略图不为空，则删除原有缩略图并添加

if(thumbnail != null) {

//先获取一遍原有信息，因为原来的信息里有原图片地址

Product tempProduct = productDao.queryProductById(product.getProductId());

if(tempProduct.getImgAddr() != null) {

//从磁盘中删除缩略图

ImageUtil.deleteFileOfPath(tempProduct.getImgAddr());

}

addThumbnail(product,thumbnail);

}

//如果有新存入的商品详情图，则将原先的删除，并添加新的图片

if(productImgList != null && productImgList.size() > 0) {

deleteProductImgList(product.getProductId());

addProductImgList(product,productImgList);

}

try {

//更新商品信息

int effectedNum = productDao.updateProduct(product);

if(effectedNum <= 0) {

throw new ProductOperationException("更新商品信息失败");

}

return new ProductExecution(ProductStateEnum.SUCCESS,product);

}catch (Exception e) {

throw new ProductOperationException("更新商品信息失败："+e.toString());

}

}else {

return new ProductExecution(ProductStateEnum.EMPTY);

}

}

/**

* 删除某个商品下的所有详情图

* @param productId

*/

private void deleteProductImgList(long productId) {

//根据productId获取原来的图片

List productImgList = productImgDao.queryProductImgList(productId);

//从磁盘删除原来的图片

for(ProductImg productImg:productImgList) {

ImageUtil.deleteFileOfPath(productImg.getImgAddr());

}

//从数据库删除原有图片的信息

productImgDao.deleteProductImgByProductId(productId);

}

}

3.controller层

package com.csj2018.o2o.web.shopadmin;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.multipart.MultipartHttpServletRequest;

import org.springframework.web.multipart.MultipartRequest;

import org.springframework.web.multipart.commons.CommonsMultipartFile;

import org.springframework.web.multipart.commons.CommonsMultipartResolver;

import com.csj2018.o2o.dto.ImageHolder;

import com.csj2018.o2o.dto.ProductExecution;

import com.csj2018.o2o.entity.Product;

import com.csj2018.o2o.entity.ProductCategory;

import com.csj2018.o2o.entity.Shop;

import com.csj2018.o2o.enums.ProductStateEnum;

import com.csj2018.o2o.service.ProductCategoryService;

import com.csj2018.o2o.service.ProductService;

import com.csj2018.o2o.util.CodeUtil;

import com.csj2018.o2o.util.HttpServletRequestUtil;

import com.fasterxml.jackson.databind.ObjectMapper;

import org.slf4j.Logger;

@Controller

@RequestMapping("/shopadmin")

public class ProductManagementController {

Logger logger = LoggerFactory.getLogger(ProductManagementController.class);

@Autowired

private ProductService productService;

@Autowired

private ProductCategoryService productCategoryService;

@RequestMapping(value="/getproductlistbyshop",method=RequestMethod.GET)

@ResponseBody

private Map getProductListByShop(HttpServletRequest request){

Map modelMap = new HashMap();

//获取从前台传过来的页码

int pageIndex = HttpServletRequestUtil.getInt(request, "pageIndex");

//获取从前台传过来的每页要求返回的商品数上线

int pageSize = HttpServletRequestUtil.getInt(request, "pageSize");

//从当前session中获取店铺信息，主要是shopId

Shop currentShop = (Shop)request.getSession().getAttribute("currentShop");

//控制判断

if((pageIndex > -1) && (pageSize > -1)&& (currentShop != null) && (currentShop.getShopId() != null)) {

//获取传入的需要检索的条件，包括是否需要从某个商品类别以及模糊查找商品，去筛选某个店铺下的商品列表

//筛选的条件可以进行排列组合

long productCategoryId = HttpServletRequestUtil.getLong(request, "productCategoryId");

String productName = HttpServletRequestUtil.getString(request, "productName");

Product productCondition = compactProductCondition(currentShop.getShopId(),productCategoryId,productName);

//传入查询条件以及分页信息进行查询，返回相应商品列表以及总数

ProductExecution pe = productService.getProductList(productCondition, pageIndex, pageSize);

modelMap.put("productList", pe.getProductList());

modelMap.put("count", pe.getCount());

modelMap.put("success", true);

}else {

modelMap.put("success", false);

modelMap.put("errMsg", "empty pageSize or pageIndex or shopId");

logger.info("页码"+pageIndex+"\t"+pageSize);

logger.info("店铺"+currentShop.getShopId());

}

return modelMap;

}

//支持上传图片详情图的最大数值

private static final int IMAGEMAXCOUNT = 6;

@RequestMapping(value="/addproduct",method=RequestMethod.POST)

@ResponseBody

private Map addProduct(HttpServletRequest request){

Map modelMap = new HashMap();

//验证码校验

if(!CodeUtil.checkVerifyCode(request)) {

modelMap.put("success", false);

modelMap.put("errMsg", "输入了错误的验证码");

return modelMap;

}

//接收前端参数的变量的初始化，包括商品、缩略图、详情图列表实体类

ObjectMapper mapper = new ObjectMapper();

Product product = null;

String productStr = HttpServletRequestUtil.getString(request, "productStr");

MultipartHttpServletRequest multipartRequest = null;

ImageHolder thumbnail = null;

List productImgList = new ArrayList();

CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver(request.getSession().getServletContext());

try {

//若请求中存在文件流，则取出相关的文件(包括缩略图和详情图)

if(multipartResolver.isMultipart(request)) {

multipartRequest = (MultipartHttpServletRequest) request;

//取出缩略图并构建ImageHolder的对象

CommonsMultipartFile thumbnailFile = (CommonsMultipartFile) multipartRequest.getFile("thumbnail");

if(thumbnailFile != null) {

thumbnail = handleImage(request,thumbnail,productImgList);

}

}else {

modelMap.put("success", false);

modelMap.put("errMsg", "上传图片不为空");

return modelMap;

}

}catch (Exception e) {

modelMap.put("success", false);

modelMap.put("errMsg", e.toString());

return modelMap;

}

try {

//

product = mapper.readValue(productStr,Product.class);

}catch(Exception e) {

modelMap.put("success", false);

modelMap.put("errMsg", e.toString());

return modelMap;

}

//若product信息，缩略图、详情图不为空，则开始进行商品添加操作

if(product != null && thumbnail != null &&productImgList.size() != 0) {

try {

//从session中获取当前店铺的ID，并赋值给product，减少对前端数据的依赖

Shop currentShop = (Shop) request.getSession().getAttribute("currentShop");

product.setShop(currentShop);

//执行添加操作

ProductExecution pe = productService.addProduct(product, thumbnail, productImgList);

if(pe.getState() == ProductStateEnum.SUCCESS.getState()) {

modelMap.put("success", true);

}else {

modelMap.put("success", false);

modelMap.put("errMsg", pe.getStateInfo());

}

}catch (RuntimeException e) {

modelMap.put("success", false);

modelMap.put("errMsg", e.toString());

return modelMap;

}

}else {

modelMap.put("success",false);

modelMap.put("errMsg", "请输入商品信息");

}

return modelMap;

}

/**

* 8-7

* @param productId

* @return

*/

@RequestMapping(value="/getproductbyid", method=RequestMethod.GET)

@ResponseBody

private Map getProductById(@RequestParam Long productId){

Map modelMap = new HashMap<>();

//非空判断

if(productId > -1) {

//获取商品信息

Product product = productService.getProductById(productId);

System.out.println(product.getShop().getShopId());

//获取该店铺下的商品类别列表

List productCategoryList = productCategoryService.getProductCategoryList(product.getShop().getShopId());

modelMap.put("product", product);

modelMap.put("productCategoryList", productCategoryList);

modelMap.put("success", true);

}else {

modelMap.put("success", false);

modelMap.put("errMsg", "empty productId");

}

return modelMap;

}

@RequestMapping(value="/modifyproduct", method=RequestMethod.POST)

@ResponseBody

private Map modifyProduct(HttpServletRequest request){

Map modelMap = new HashMap();

//是商品编辑时候调用,还是上下架操作时候调用

//若为前者则进行验证码判断，后者则跳过验证码判断

boolean statusChange = HttpServletRequestUtil.getBoolean(request, "statusChange");

//验证码判断

if(!statusChange && !CodeUtil.checkVerifyCode(request)) {

modelMap.put("success", false);

modelMap.put("errMsg", "输入了错误的验证码");

return modelMap;

}

//接收前端参数的变量的初始化，包括商品，缩略图，详情图列表实体类

ObjectMapper mapper = new ObjectMapper();

Product product = null;

ImageHolder thumbnail = null;

List productImgList = new ArrayList();

CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver(request.getSession().getServletContext());

//若请求中存在文件流，则取出相关的文件(包括缩略图和详情图)

try {

if(multipartResolver.isMultipart(request)) {

thumbnail = handleImage(request, thumbnail, productImgList);

logger.info("详情图长度："+productImgList.size());

}

}catch (Exception e) {

modelMap.put("success", false);

modelMap.put("errMsg", e.toString());

return modelMap;

}

try {

String productStr = HttpServletRequestUtil.getString(request, "productStr");

//尝试获取从前端传过来的表单String流，并将其转化为Product对象

product = mapper.readValue(productStr, Product.class);

}catch(Exception e) {

modelMap.put("success", false);

modelMap.put("errMsg", e.toString());

return modelMap;

}

//非空判断

if(product != null) {

try {

//从session中获取当前店铺的ID并赋值给product，减少对前端数据的依赖

Shop currentShop = (Shop) request.getSession().getAttribute("currentShop");

product.setShop(currentShop);

//开始进行商品信息变更操作

logger.info("193");

ProductExecution pe = productService.modifyProduct(product, thumbnail, productImgList);

logger.info("195");

if(pe.getState() == ProductStateEnum.SUCCESS.getState()) {

modelMap.put("success", true);

}else {

modelMap.put("false", false);

modelMap.put("errMsg", pe.getStateInfo());

}

}catch(RuntimeException e) {

modelMap.put("success", false);

modelMap.put("errMsg", e.toString());

return modelMap;

}

}

return modelMap;

}

private ImageHolder handleImage(HttpServletRequest request, ImageHolder thumbnail, List productImgList) throws IOException{

MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;

//取出缩略图并构建ImageHolder对象

CommonsMultipartFile thumbnailFile = (CommonsMultipartFile) multipartRequest.getFile("thumbnail");

if(thumbnailFile != null) {

thumbnail = new ImageHolder(thumbnailFile.getOriginalFilename(), thumbnailFile.getInputStream());

}

//取出详情图并构建List列表对象，最多支持6张图片上传

for(int i=0;i

CommonsMultipartFile productImgFile = (CommonsMultipartFile) multipartRequest.getFile("productImg"+i);

if(productImgFile != null) {

//若取出的第i个详情图片流不为空，则将其加入详情图列表

ImageHolder productImg = new ImageHolder(productImgFile.getOriginalFilename(),productImgFile.getInputStream());

productImgList.add(productImg);

}else {

//若取出的第i个图片文件流为空，则终止循环

break;

}

}

return thumbnail;

}

//8-10

private Product compactProductCondition(long shopId,long productCategoryId,String productName) {

Product productCondition = new Product();

Shop shop = new Shop();

shop.setShopId(shopId);

productCondition.setShop(shop);

//若有指定类别的要求，则添加进入

if(productCategoryId != -1L) {

ProductCategory productCategory = new ProductCategory();

productCategory.setProductCategoryId(productCategoryId);

productCondition.setProductCategory(productCategory);

}

//若有商品名模糊查询的要求，则添加进去

if(productName != null) {

productCondition.setProductName(productName);

}

return productCondition;

}

}

4.验证

1.先访问http://127.0.0.1:18080/o2o/shopadmin/shopmanagement?shopId=1，获取currentShop

2.再访问http://127.0.0.1:18080/o2o/shopadmin/getproductlistbyshop?pageIndex=1&pageSize=999，验证结果