Java电商项目面试--商品模块

骑猪看日落 2021-09-27 08:34 658阅读 0赞

> **面试：商品模块技术要点  
> 1、POJO、BO、VO抽象模型  
> 2、高效分页及动态排序  
> 3、FTP服务对接、富文本上传**

**一、商品模块功能**  
**前台功能：**  
1、产品搜索  
2、动态排序列表  
3、商品详情  
**后台功能：**  
1、商品列表  
2、商品搜索  
3、图片上传  
4、增加商品、更新商品、商品上下架  
**二、后台新增和更新商品**  
Controller：

@Controller
    @RequestMapping("/manage/product")
    public class ProductManageController { 
    @Autowired
    private IUserService iUserService;
    @Autowired
    private IProductService iProductService;
    @Autowired
    private IFileService iFileService;
    
    @RequestMapping("save.do")
    @ResponseBody
    public ServerResponse productSave(HttpSession session, Product product) {
        User user = (User) session.getAttribute(Const.CURRENT_USER);
        if (user == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "用户未登录,请登录管理员");
        }
        //如果是管理员
        if (iUserService.checkAdminRole(user).isSuccess()) {
            //增加或者更新商品
             return iProductService.saveOrUpdateProduct(product);
        } else {
            return ServerResponse.createByErrorMessage("无权限操作");
        }
    }

Service层：

@Service("iProductService")
    public class ProductServiceImpl implements IProductService { 
        @Autowired
        private ProductMapper productMapper;
        @Autowired
        private CategoryMapper categoryMapper;
        @Autowired
        private ICategoryService iCategoryService;
    
        //保存或者更新商品
        public ServerResponse saveOrUpdateProduct(Product product){
            if(product != null)  //产品不为空
            {
                // 获取前端传来的子图字符串用；分割~譬如前端传来1.jpg,2.jpg,3.jpg，
                // 然后第一块代码就是将这个字符串按照；来分割成字符串数组，就可以获得所有子图，
                // 然后把第一张子图当做主图来存储
                if(StringUtils.isNotBlank(product.getSubImages())){
                    String[] subImageArray = product.getSubImages().split(",");
                    if(subImageArray.length > 0)
                        product.setMainImage(subImageArray[0]);
                }
                //当产品id存在则更新商品
                if(product.getId() != null){
                    int rowCount = productMapper.updateByPrimaryKey(product);
                    if(rowCount > 0)
                        return ServerResponse.createBySuccess("更新产品成功");
                    return ServerResponse.createBySuccess("更新产品失败");
                }
                //不存在则添加
                else
                {
                    int rowCount = productMapper.insert(product);
                    if(rowCount > 0)
                        return ServerResponse.createBySuccess("新增产品成功");
                    return ServerResponse.createBySuccess("新增产品失败");
                }
            }
            return ServerResponse.createByErrorMessage("新增或更新产品参数不正确");
        }
    }

**三、后台新增和更新商品**  
Controller：

@RequestMapping("set_sale_status.do")
    @ResponseBody
    public ServerResponse setSaleStatus(HttpSession session, Integer productId,Integer status){
        User user = (User)session.getAttribute(Const.CURRENT_USER);
        if(user == null){
                 return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(),"用户未登录,请登录管理员");
        }
        if(iUserService.checkAdminRole(user).isSuccess()){
                return iProductService.setSaleStatus(productId,status);
        }else{
                return ServerResponse.createByErrorMessage("无权限操作");
        }
    }

Service：

public ServerResponse<String> setSaleStatus(Integer productId,Integer status){
        if(productId == null || status == null){
                 return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }
        Product product = new Product();
        product.setId(productId);
        product.setStatus(status);
        int rowCount = productMapper.updateByPrimaryKeySelective(product);
        if(rowCount > 0){
                return ServerResponse.createBySuccess("修改产品销售状态成功");
        }
        return ServerResponse.createByErrorMessage("修改产品销售状态失败");
    }

**四、后台获取产品详情**  
Controller：

@RequestMapping("detail.do")
    @ResponseBody
    public ServerResponse getDetail(HttpSession session, Integer productId){
        User user = (User)session.getAttribute(Const.CURRENT_USER);
        if(user == null)
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(),"用户未登录,请登录管理员");
        if(iUserService.checkAdminRole(user).isSuccess()){
            return iProductService.manageProductDetail(productId);
        }else{
            return ServerResponse.createByErrorMessage("无权限操作");
        }
    }

Service：

@Service("iProductService")
    public class ProductServiceImpl implements IProductService { 
          @Autowired
          private ProductMapper productMapper; 
          @Autowired
          private CategoryMapper categoryMapper;
          @Autowired
          private ICategoryService iCategoryService;
    
    public ServerResponse<ProductDetailVo> manageProductDetail(Integer productId){
        if(productId == null){
            return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }
        Product product = productMapper.selectByPrimaryKey(productId);
        if(product == null)
            return ServerResponse.createByErrorMessage("产品已下架或者删除");
        //VO -- value object
        ProductDetailVo productDetailVo = assembleProductDetailVo(product);
        return ServerResponse.createBySuccess(productDetailVo);
    }
    private ProductDetailVo assembleProductDetailVo(Product product){
        ProductDetailVo productDetailVo = new ProductDetailVo();
        productDetailVo.setId(product.getId());
        productDetailVo.setSubtitle(product.getSubtitle());
        productDetailVo.setPrice(product.getPrice());
        productDetailVo.setMainImage(product.getMainImage());
        productDetailVo.setSubImages(product.getSubImages());
        productDetailVo.setCategoryId(product.getCategoryId());
        productDetailVo.setDetail(product.getDetail());
        productDetailVo.setName(product.getName());
        productDetailVo.setStatus(product.getStatus());
        productDetailVo.setStock(product.getStock());
        productDetailVo.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix","http://image.long.com/"));
    
        Category category = categoryMapper.selectByPrimaryKey(product.getCategoryId());
        if(category == null){
            productDetailVo.setParentCategoryId(0);//默认根节点
        }else{
            productDetailVo.setParentCategoryId(category.getParentId());
        }
        productDetailVo.setCreateTime(DateTimeUtil.dateToStr(product.getCreateTime()));
        productDetailVo.setUpdateTime(DateTimeUtil.dateToStr(product.getUpdateTime()));
        return productDetailVo;
    }

VO：

public class ProductDetailVo { 
        private Integer  id;
        private Integer categoryId;
        private String name;
        private String subtitle;
        private String mainImage;
        private String subImages;
        private String detail;
        private BigDecimal price;
        private Integer stock;
        private Integer status;
        private String createTime;
        private String updateTime;
    
        /*******相对于Product对象对出来的属性******/
        private String imageHost;  //图片服务器url前缀
        private Integer parentCategoryId;  //父分类
        //...setter和getter方法...
     }

**简单分析下VO：**  
包装类其实就是我们项目中的pojo类，字段与数据库表的字段是相同的，而vo类可以简单理解成专门用于展示给用户看的类。  
这里使用VO，这样可以减少大量的工作量（也就意味着减少bug，减少风险），也不需要担心未来的维护工作！VO还有一个好处就是是例如时间类型，返回给前台的时候需要转String类型，pojo转vo是为了封装，例如时间做成字符串，或者枚举转换成汉字，或者增加其他属性，这样vo的灵活性就突显出来了。

**使用流读取配置properties配置文件：**  
基础部分可以看这个：[Java基础系列（二十）Properties类、commons-IO包][Java_Properties_commons-IO]  
**1、为什么使用propertie**  
有些常量需要动态的配置，如果项目上线后，每次修改Constants.java然后再编译，再上传Constants.class文件，再重启服务器。这样导致很繁琐。  
如果将需要修改的配置项写成properties文件，程序写好后，以后要修改数据，直接在配置文件里修改，程序就不用修改，也不用重新编译了，将会在项目后期维护带来很大的方便~！  
**2、propertie文件读取方式**  
① 基于 ClassLoader 读取配置文件：  
注意：该方式只能读取类路径下的配置文件，有局限但是如果配置文件在类路径下比较方便。

Properties properties = new Properties();
    // 使用ClassLoader加载properties配置文件生成对应的输入流
    InputStream in = PropertiesMain.class.getClassLoader().getResourceAsStream("config/config.properties");
    // 使用properties对象加载输入流
    properties.load(in);
    //获取key对应的value值
    properties.getProperty(String key);

② 基于 InputStream 读取配置文件：  
注意：该方式的优点在于可以读取任意路径下的配置文件

Properties properties = new Properties();
    // 使用InPutStream流读取properties文件
    BufferedReader bufferedReader = new BufferedReader(new FileReader("E:/config.properties"));
    properties.load(bufferedReader);
    // 获取key对应的value值
    properties.getProperty(String key);

③ 通过 java.util.ResourceBundle 类来读取，这种方式比使用 Properties 要方便一些：  
注意：该方式的优点在于这种方式来获取properties属性文件不需要加.properties后缀名，只需要文件名即可

properties.getProperty(String key);
    //config为属性文件名，放在包com.test.config下，如果是放在src下，直接用config即可  
    ResourceBundle resource = ResourceBundle.getBundle("com/test/config/config");
    String key = resource.getString("keyWord");

因为配置文件在类路径下使用第一种方式比较方便，所以本项目采用的是第一种方式：

public class PropertiesUtil {
        private static Logger logger = LoggerFactory.getLogger(PropertiesUtil.class);
        private static Properties props;
        static {    //读取配置
            String fileName = "mmall.properties";
            props = new Properties();
            try {
                props.load(new InputStreamReader(PropertiesUtil.class.getClassLoader().getResourceAsStream(fileName),"UTF-8"));
            } catch (IOException e) {
                logger.error("配置文件读取异常",e);
            }
        }
        public static String getProperty(String key){
            String value = props.getProperty(key.trim());
            if(StringUtils.isBlank(value))
                return null;
            return value.trim();
        }
        //如果值为空，返回defaultValue
        public static String getProperty(String key,String defaultValue){
            String value = props.getProperty(key.trim());
            if(StringUtils.isBlank(value))
                value = defaultValue;
            return value.trim();
        }
    }

**joda-time和JDK自带的SimpleDateformat的区别是什么？**  
因为jdk的Date/Calender等api使用具有一定的难度,且jdk默认的有多线程问题，Joda-Time 令时间和日期值变得易于管理、操作和理解。事实上，易于使用是 Joda 的主要设计目标。其他目标包括可扩展性、完整的特性集以及对多种日历系统的支持。并且 Joda 与 JDK 是百分之百可互操作的。

public class DateTimeUtil {
        public static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
        //字符串转时间
        public static Date strToDate(String dateTimeStr){
            DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(STANDARD_FORMAT);
            DateTime dateTime = dateTimeFormatter.parseDateTime(dateTimeStr);
            return dateTime.toDate();
        }
        //时间转字符串
        public static String dateToStr(Date date){
            if(date == null)  return StringUtils.EMPTY;
            DateTime dateTime = new DateTime(date);
            return dateTime.toString(STANDARD_FORMAT);
        }
        //测试
        public static void main(String[] args) {
            System.out.println(DateTimeUtil.dateToStr(new Date(),"yyyy-MM-dd HH:mm:ss"));
            System.out.println(DateTimeUtil.strToDate("2010-01-01 11:11:11","yyyy-MM-dd HH:mm:ss"));
        }
    }

**五、后台商品列表**  
Controller：

//商品列表
    @RequestMapping("list.do")
    @ResponseBody
    public ServerResponse getList(HttpSession session, @RequestParam(value = "pageNum",defaultValue = "1") int pageNum,@RequestParam(value = "pageSize",defaultValue = "10") int pageSize){
        User user = (User)session.getAttribute(Const.CURRENT_USER);
        if(user == null)
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(),"用户未登录,请登录管理员");
        if(iUserService.checkAdminRole(user).isSuccess())
            return iProductService.getProductList(pageNum,pageSize);  //页数，每页容量
        else
            return ServerResponse.createByErrorMessage("无权限操作");
    }

Service：

//后台获取商品列表 页数 每页多少条数据
    public ServerResponse<PageInfo> getProductList(int pageNum,int pageSize){
        /*********使用步骤：******* * 1、startPage * 2、填充自己的sql查询逻辑 * 3、pageHelper-收尾 *************************/
        //1、startPage
        PageHelper.startPage(pageNum,pageSize);   //页数，每页容量
        //2、填充自己的sql查询逻辑
        List<Product> productList = productMapper.selectList();  //查询产品列表
        List<ProductListVo> productListVoList = Lists.newArrayList();
        for(Product productItem : productList){
            ProductListVo productListVo = assembleProductListVo(productItem);
            productListVoList.add(productListVo);
        }
        //3、pageHelper-收尾
        PageInfo pageResult = new PageInfo(productList);
        pageResult.setList(productListVoList);
        //使用PageInfo包装查询结果，只需要将pageInfo交给页面就可以
        //使用PageInfo这个类,你需要将查询出来的list放进去:
        return ServerResponse.createBySuccess(pageResult);
    }
    //ProducyList的组装方法
    private ProductListVo assembleProductListVo(Product product){
        ProductListVo productListVo = new ProductListVo();
        productListVo.setId(product.getId());
        productListVo.setName(product.getName());
        productListVo.setCategoryId(product.getCategoryId());
        productListVo.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix","http://image.long.com/"));
        productListVo.setMainImage(product.getMainImage());
        productListVo.setPrice(product.getPrice());
        productListVo.setSubtitle(product.getSubtitle());
        productListVo.setStatus(product.getStatus());
        return productListVo;
    }

Mapper.xml：

<select id="selectList" resultMap="BaseResultMap" >
      SELECT
      <include refid="Base_Column_List"/>
      from mmall_product
      ORDER BY id asc
    </select>

Mybatis配置：

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mapperLocations" value="classpath*:mappers/*Mapper.xml"></property>
    
        
        <property name="plugins">
            <array>
                <bean class="com.github.pagehelper.PageHelper">
                    <property name="properties">
                        <value>
                            dialect=mysql
                        </value>
                    </property>
                </bean>
            </array>
        </property>
    </bean>
    
    
    <bean name="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        
        <property name="basePackage" value="com.mmall.dao"/>
    </bean>

PageInfo底层：

//当前页
    private int pageNum;
    //每页的数量
    private int pageSize;
    //当前页的数量
    private int size;
    //排序
    private String orderBy;
    
    //由于startRow和endRow不常用，这里说个具体的用法
    //可以在页面中"显示startRow到endRow 共size条数据"
    
    //当前页面第一个元素在数据库中的行号
    private int startRow;
    //当前页面最后一个元素在数据库中的行号
    private int endRow;
    //总记录数
    private long total;
    //总页数
    private int pages;
    //结果集
    private List<T> list;
    
    //第一页
    private int firstPage;
    //前一页
    private int prePage;
    //下一页
    private int nextPage;
    //最后一页
    private int lastPage;
    
    //是否为第一页
    private boolean isFirstPage = false;
    //是否为最后一页
    private boolean isLastPage = false;
    //是否有前一页
    private boolean hasPreviousPage = false;
    //是否有下一页
    private boolean hasNextPage = false;
    //导航页码数
    private int navigatePages;
    //所有导航页号
    private int[] navigatepageNums;

**Mybatis流程**  
![这里写图片描述][70]  
从图中可以看出，mybatis中首先要在配置文件中配置一些东西，然后根据这些配置去创建一个会话工厂，再根据会话工厂创建会话，会话发出操作数据库的sql语句，然后通过执行器操作数据，再使用mappedStatement对数据进行封装，这就是整个mybatis框架的执行情况。那么mybatis的插件作用在哪一环节呢？它主要作用在Executor执行器与mappedeStatement之间，也就是说mybatis可以在插件中获得要执行的sql语句，在sql语句中添加limit语句，然后再去对sql进行封装，从而可以实现分页处理。  
**动态分页**  
pageHelper分页的底层主要是通过 aop来实现，在执行sql之前会在sql语句中添加limit offset这两个参数。这样就完成了动态的分页。  
我们需要用vo返回给前端。如果我们用vo里的字段，是和pojo总会有不一致的地方。例如时间的类型，又例如添加的一些枚举状态等。那么为了自动分页，我们会用dao层找到原始的pojoList，(因为pageHelper是对dao层在执行mapper的时候才会动态分页，所以我们要先执行一下mapper)然后转换成vo。那么其实这两个list的集合的分页参数是一致的。所以用了一个比较巧妙的办法，来把vo进行分页。  
**六、后台商品搜索功能**  
Controller：

//商品搜索功能
    @RequestMapping("search.do")
    @ResponseBody
    public ServerResponse productSearch(HttpSession session,String productName,Integer productId, @RequestParam(value = "pageNum",defaultValue = "1") int pageNum,@RequestParam(value = "pageSize",defaultValue = "10") int pageSize){
        User user = (User)session.getAttribute(Const.CURRENT_USER);
        if(user == null)
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(),"用户未登录,请登录管理员");
        if(iUserService.checkAdminRole(user).isSuccess())
            return iProductService.searchProduct(productName,productId,pageNum,pageSize);  //填充业务
        else
            return ServerResponse.createByErrorMessage("无权限操作");
    }

Service：

//商品搜索功能
    public ServerResponse<PageInfo> searchProduct(String productName,Integer productId,int pageNum,int pageSize){
        PageHelper.startPage(pageNum,pageSize);
        if(StringUtils.isNotBlank(productName))     //商品名字
            productName = new StringBuilder().append("%").append(productName).append("%").toString(); //%商品名字%
        List<Product> productList = productMapper.selectByNameAndProductId( productName , productId );
        List<ProductListVo> productListVoList = Lists.newArrayList();
        for(Product productItem : productList){
            ProductListVo productListVo = assembleProductListVo(productItem);
            productListVoList.add(productListVo);
        }
        PageInfo pageResult = new PageInfo(productList);
        pageResult.setList(productListVoList);
        return ServerResponse.createBySuccess(pageResult);
    }

Mapper.xml：

<select id="selectByNameAndProductId" resultMap="BaseResultMap" parameterType="map">
      SELECT
      <include refid="Base_Column_List"/>
          from mmall_product
          <where>
               <if test="productName != null">
                    and name like #{productName}
               </if>
               <if test="productId != null">
                    and id = #{productId}
               </if>
          </where>
    </select>

**七、后台商品图片上传功能**  
Controller：

//上传文件功能
    @RequestMapping("upload.do")
    @ResponseBody
    public ServerResponse upload(HttpSession session,@RequestParam(value = "upload_file",required = false) MultipartFile file,HttpServletRequest request){
        User user = (User)session.getAttribute(Const.CURRENT_USER);
        if(user == null)
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(),"用户未登录,请登录管理员");
        if(iUserService.checkAdminRole(user).isSuccess()){   //检查是否是管理员
            String path = request.getSession().getServletContext().getRealPath("upload");
            String targetFileName = iFileService.upload(file,path);   //上传文件
            String url = PropertiesUtil.getProperty("ftp.server.http.prefix")+targetFileName;
    
            Map fileMap = Maps.newHashMap();
            fileMap.put("uri",targetFileName);
            fileMap.put("url",url);
    
            return ServerResponse.createBySuccess(fileMap);   //返回给前端
        }else{
            return ServerResponse.createByErrorMessage("无权限操作");
        }
    }

Service：

@Service("iFileService")
    public class FileServiceImpl implements IFileService { 
    
        private Logger logger = LoggerFactory.getLogger(FileServiceImpl.class);
    
        public String upload(MultipartFile file,String path){   //文件和路径
            String fileName = file.getOriginalFilename();   //获取文件的名字
            String fileExtensionName = fileName.substring(fileName.lastIndexOf(".")+1);  //获取扩展名，例如文件名为：abc.jpg
            String uploadFileName = UUID.randomUUID().toString()+"."+fileExtensionName;  //上传文件的名字，随机字符串+文件扩展名
            logger.info("开始上传文件,上传文件的文件名:{},上传的路径:{},新文件名:{}",fileName,path,uploadFileName);
    
            File fileDir = new File(path);  //创建目录
            if(!fileDir.exists()){
                fileDir.setWritable(true);
                fileDir.mkdirs();
            }
            File targetFile = new File(path,uploadFileName);   //创建文件（假设在upload文件夹下）
            try {
                file.transferTo(targetFile);  //文件已经上传成功到了upload文件夹
                FTPUtil.uploadFile(Lists.newArrayList(targetFile));  //已经上传到ftp服务器上
                targetFile.delete();   //上传成功之后，就删除创建的的文件，如upload下面的文件
            } catch (IOException e) {
                logger.error("上传文件异常",e);
                return null;
            }
            return targetFile.getName();
        }
    }

FTPUtil：

public class FTPUtil { 
    private static  final Logger logger = LoggerFactory.getLogger(FTPUtil.class);
    
    private static String ftpIp = PropertiesUtil.getProperty("ftp.server.ip");
    private static String ftpUser = PropertiesUtil.getProperty("ftp.user");
    private static String ftpPass = PropertiesUtil.getProperty("ftp.pass");
    
    public FTPUtil(String ip,int port,String user,String pwd){   //构造器
        this.ip = ip;
        this.port = port;
        this.user = user;
        this.pwd = pwd;
    }
    //上传文件
    public static boolean uploadFile(List<File> fileList) throws IOException {
        FTPUtil ftpUtil = new FTPUtil(ftpIp,21,ftpUser,ftpPass);
        logger.info("开始连接ftp服务器");
        boolean result = ftpUtil.uploadFile("img",fileList);     //上传文件到FTP服务器下面的img目录下
        logger.info("开始连接ftp服务器,结束上传,上传结果:{}");
        return result;
    }
    //上传文件
    private boolean uploadFile(String remotePath,List<File> fileList) throws IOException {  //远程路径
        boolean uploaded = true;     //是否传了
        FileInputStream fis = null;
        if(connectServer(this.ip,this.port,this.user,this.pwd)){  //连接FTP服务器
            try {
                ftpClient.changeWorkingDirectory(remotePath);
                ftpClient.setBufferSize(1024);
                ftpClient.setControlEncoding("UTF-8");
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
                ftpClient.enterLocalPassiveMode();
                for(File fileItem : fileList){
                    fis = new FileInputStream(fileItem);
                    ftpClient.storeFile(fileItem.getName(),fis);
                }
            } catch (IOException e) {
                logger.error("上传文件异常",e);
                uploaded = false;
                e.printStackTrace();
            } finally {
                fis.close();
                ftpClient.disconnect();
            }
        }
        return uploaded;
    }
    //连接服务器函数
    private boolean connectServer(String ip,int port,String user,String pwd){
        boolean isSuccess = false;
        ftpClient = new FTPClient();
        try {
            ftpClient.connect(ip);
            isSuccess = ftpClient.login(user,pwd);
        } catch (IOException e) {
            logger.error("连接FTP服务器异常",e);
        }
        return isSuccess;
    }

**八、后台富文本中图片上传**  
Controller：

//富文本中图片上传
    @RequestMapping("richtext_img_upload.do")
    @ResponseBody
    public Map richtextImgUpload(HttpSession session, @RequestParam(value = "upload_file",required = false) MultipartFile file, HttpServletRequest request, HttpServletResponse response){
        Map resultMap = Maps.newHashMap();
        User user = (User)session.getAttribute(Const.CURRENT_USER);
        if(user == null){
            resultMap.put("success",false);
            resultMap.put("msg","请登录管理员");
            return resultMap;
        }
        /** 富文本中对于返回值有自己的要求,我们使用是simditor所以按照simditor的要求进行返回 { "success": true/false, "msg": "error message", # optional 是可选的 "file_path": "[real file path]" } **/
        if(iUserService.checkAdminRole(user).isSuccess()){
            String path = request.getSession().getServletContext().getRealPath("upload");
            String targetFileName = iFileService.upload(file,path);
            if(StringUtils.isBlank(targetFileName)){
                resultMap.put("success",false);
                resultMap.put("msg","上传失败");
                return resultMap;
            }
            String url = PropertiesUtil.getProperty("ftp.server.http.prefix")+targetFileName;
            resultMap.put("success",true);
            resultMap.put("msg","上传成功");
            resultMap.put("file_path",url);
            response.addHeader("Access-Control-Allow-Headers","X-File-Name");
            return resultMap;
        }else{
            resultMap.put("success",false);
            resultMap.put("msg","无权限操作");
            return resultMap;
        }
    }

**八、前台功能**  
Controller：

//查询商品详情
    @RequestMapping("detail.do")
    @ResponseBody
    public ServerResponse<ProductDetailVo> detail(Integer productId){
        return iProductService.getProductDetail(productId);
    }
    //商品搜索
    @RequestMapping("list.do")
    @ResponseBody
    public ServerResponse<PageInfo> list(@RequestParam(value = "keyword",required = false)String keyword,
                                         @RequestParam(value = "categoryId",required = false)Integer categoryId,
                                         @RequestParam(value = "pageNum",defaultValue = "1") int pageNum,
                                         @RequestParam(value = "pageSize",defaultValue = "10") int pageSize,
                                         @RequestParam(value = "orderBy",defaultValue = "") String orderBy){
        return iProductService.getProductByKeywordCategory(keyword,categoryId,pageNum,pageSize,orderBy);
    }

Service：

//前台获取商品信息
    public ServerResponse<ProductDetailVo> getProductDetail(Integer productId){
        if(productId == null)
            return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        Product product = productMapper.selectByPrimaryKey(productId);
        if(product == null)
            return ServerResponse.createByErrorMessage("产品已下架或者删除");
        if(product.getStatus() != Const.ProductStatusEnum.ON_SALE.getCode())
            return ServerResponse.createByErrorMessage("产品已下架或者删除");
        ProductDetailVo productDetailVo = assembleProductDetailVo(product);
        return ServerResponse.createBySuccess(productDetailVo);
    }
    
    //获取商品列表，搜索商品，排序
    public ServerResponse<PageInfo> getProductByKeywordCategory(String keyword,Integer categoryId,int pageNum,int pageSize,String orderBy){
        if(StringUtils.isBlank(keyword) && categoryId == null)
            return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        List<Integer> categoryIdList = new ArrayList<Integer>();
        if(categoryId != null){
            Category category = categoryMapper.selectByPrimaryKey(categoryId);  //获取分类
            if(category == null && StringUtils.isBlank(keyword)){  //没有该分类,并且还没有关键字,这个时候返回一个空的结果集,不报错
                PageHelper.startPage(pageNum,pageSize);
                List<ProductListVo> productListVoList = Lists.newArrayList();
                PageInfo pageInfo = new PageInfo(productListVoList);
                return ServerResponse.createBySuccess(pageInfo);
            }
            categoryIdList = iCategoryService.selectCategoryAndChildrenById(category.getId()).getData();  //根据id查询此节点id和其子节点id的集合
        }
    
        if(StringUtils.isNotBlank(keyword))
            keyword = new StringBuilder().append("%").append(keyword).append("%").toString();  //%关键字%
    
        PageHelper.startPage( pageNum , pageSize );
        //排序处理
        if(StringUtils.isNotBlank(orderBy)){  //如果排序关键字不为空
            if(Const.ProductListOrderBy.PRICE_ASC_DESC.contains(orderBy)){  //price_desc
                String[] orderByArray = orderBy.split("_");
                PageHelper.orderBy(orderByArray[0]+" "+orderByArray[1]);  //格式为price desc
            }
        }
    
        List<Product> productList = productMapper.selectByNameAndCategoryIds(StringUtils.isBlank(keyword)?null:keyword,categoryIdList.size()==0?null:categoryIdList);
    
        List<ProductListVo> productListVoList = Lists.newArrayList();
        for(Product product : productList){
            ProductListVo productListVo = assembleProductListVo(product);    //封装为VO
            productListVoList.add(productListVo);
        }
    
        PageInfo pageInfo = new PageInfo(productList);
        pageInfo.setList(productListVoList);
        return ServerResponse.createBySuccess(pageInfo);
    }

**动态排序**  
两种方法：  
1、方式1

//其中A为排序依据的字段名，B为排序规律，desc为降序，asc为升序
    PageHelper.startPage(pageNum , pageSize);
    PageHelper.orderBy("A B");

2、方式2

//其中A为排序依据的字段名，B为排序规律，desc为降序，asc为升序
    String orderBy="A B"；
    PageHelper.startPage(pageNum, pageSize, orderBy)；

**九、FTP服务器**  
**1、FTP是什么？**  
 FTP是File Transfer Protocol(文件传输协议)的英文简称，用于Internet上的控制文件的双向传输。简单的说，支持FTP协议的服务器就是FTP服务器。FTP是一个客户机/服务器系统。用户通过一个支持FTP协议的客户机程序，连接到在远程主机上的FTP服务器程序。用户通过客户机程序向服务器程序发出命令，服务器程序执行用户所发出的命令，并将执行的结果返回到客户机。  
**2、为什么使用FTP服务器**  
从一个小网站说起。一台服务器也就足够了。文件服务器，数据库，还有应用都部署在一台机器，俗称ALL IN ONE。随着我们用户越来越多，访问越来越大，硬盘，CPU，内存等都开始吃紧。一台服务器已经满足不了，我们将数据服务和应用服务分离，给应用服务器配置更好的 CPU，内存。而给数据服务器配置更好更大的硬盘。分离之后提高一定的可用性，例如Files Server挂了，我们还是可以操作应用和数据库等。  
![这里写图片描述][70 1]  
**3、对比FTP和FastDFS**  
单独部署的文件服务器是互联网项目必不可少的一项。简单的话可以采用FTP做文件服务器，但是项目访问量持续增加的话，必要考虑文件服务器的扩展性与高可用。这时候采用FastDFS是比较明智的，当服务器容量不够用时，FastDFS可以快速的进行线性扩容。FastDFS是用c语言编写的一款开源的分布式文件系统。FastDFS为互联网量身定制，充分考虑了冗余备份、负载均衡、线性扩容等机制，并注重高可用、高性能等指标，使用FastDFS很容易搭建一套高性能的文件服务器集群提供文件上传、下载等服务。

--------------------

**Java面试的完整博客目录如下：[Java笔试面试目录][Java]**

> **转载请标明出处，原文地址：[https://blog.csdn.net/weixin\_41835916][https_blog.csdn.net_weixin_41835916] 如果觉得本文对您有帮助，请点击顶支持一下，您的支持是我写作最大的动力，谢谢。  
> ![这里写图片描述][70 2]**

[Java_Properties_commons-IO]: https://blog.csdn.net/weixin_41835916/article/details/80578344
[70]: /images/20210923/499a1accffbd4e288846759b06d0022a.png
[70 1]: /images/20210923/12592cd9a8d441aca46ed46c956d10b3.png
[Java]: https://blog.csdn.net/weixin_41835916/article/details/81413498
[https_blog.csdn.net_weixin_41835916]: https://blog.csdn.net/weixin_41835916
[70 2]: /images/20210923/91aeb1694ebf4c6b88bd8606383d3d94.png