项目实施-05 （Web前端 java层）

概述

这是一个严格的前后分离项目，前端开发比较头疼的地方在于小细节可真的太多了。比如拦截器、全局异常的处理、验证码、JQuery插件定制等等。

整体框架

依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.baizhi</groupId>
    <artifactId>user_web_model</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--SpringWeb Test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <!--文件支持-->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.4</version>
        </dependency>

        <!--添加jsp支持-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
        <!--自动监测页面更新-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>

        <!--引入验证码插件,这是自定义的插件,放在了Oracle目录下-->
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>6.0</version>
        </dependency>


        <!--使用lombok技术的坐标-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
            <scope>provided</scope>
        </dependency>

        <!--FastDFS系统-->
        <dependency>
            <groupId>com.github.tobato</groupId>
            <artifactId>fastdfs-client</artifactId>
            <version>1.26.6</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

yml配置文件

#设置服务器参数
server:
  port: 9999
  servlet:
    context-path: /
  #设置服务器收参格式
  tomcat:
    uri-encoding: UTF-8

#Spring设置
spring:
  servlet:
    multipart:
      enabled: true
      max-file-size: 5MB  #文件尺寸
      max-request-size: 50MB
      location: /E:/temp  #指定临时目录
  http:
    encoding:
      charset: UTF-8  #编码规则

    #全局收参日期格式
  mvc:
    date-format: yyyy-MM-dd

     #视图解析器
    view:
      prefix: /
      suffix: .jsp
  #出参的全局格式
  jackson:
    date-format: yyyy-MM-dd
    time-zone: GMT+8
#日志级别
logging:
  level:
    root: error
    com.baizhi.controller: info
    com.baizhi.interceptor: info


#文件系统
fdfs:
  tracker-list: pro1:22122,pro2:22122
  # 配置默认缩略图
  thumb-image:
    height: 80
    width: 100

入口类

package com.baizhi;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class UserWebmodelApplication {

    public static void main(String[] args) {
        SpringApplication.run(UserWebmodelApplication.class, args);
    }


    //注册一个Rest组件 SpringMVC中自带的一个Rest客户端工具，可以无缝和SpringBoot集成
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

}

工具类

这里的工具类，目的主要是实现对数据库数据进行页面上的下载时，按照CSV格式进行处理的逻辑功能

package com.baizhi.util;


import org.apache.commons.collections.CollectionUtils;

import javax.servlet.http.HttpServletResponse;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;

public class CsvExportUtil {
    /**
     * CSV文件列分隔符
     */
    private static final String CSV_COLUMN_SEPARATOR = ",";

    /**
     * CSV文件行分隔符
     */
    private static final String CSV_ROW_SEPARATOR = System.lineSeparator();

    /**
     * @param dataList 集合数据
     * @param titles   表头部数据
     * @param keys     表内容的键值
     * @param os       输出流
     */
    public static void doExport(List<Map<String, Object>> dataList, String titles, String keys, OutputStream os) throws Exception {

        // 保证线程安全
        StringBuffer buf = new StringBuffer();

        String[] titleArr = null;
        String[] keyArr = null;

        titleArr = titles.split(",");
        keyArr = keys.split(",");

        // 组装表头
        for (String title : titleArr) {
            buf.append(title).append(CSV_COLUMN_SEPARATOR);
        }
        buf.append(CSV_ROW_SEPARATOR);

        // 组装数据
        if (CollectionUtils.isNotEmpty(dataList)) {
            for (Map<String, Object> data : dataList) {
                for (String key : keyArr) {
                    buf.append(data.get(key)).append(CSV_COLUMN_SEPARATOR);
                }
                buf.append(CSV_ROW_SEPARATOR);
            }
        }

        // 写出响应
        os.write(buf.toString().getBytes("GBK"));
        os.flush();
    }

    /**
     * 设置Header
     *
     * @param fileName
     * @param response
     * @throws UnsupportedEncodingException
     */
    public static void responseSetProperties(String fileName, HttpServletResponse response) throws UnsupportedEncodingException {
        // 设置文件后缀
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
        String fn = fileName + sdf.format(new Date()) + ".csv";


        // 设置响应
        response.setContentType("application/ms-txt.numberformat:@");
        response.setCharacterEncoding("UTF-8");
        response.setHeader("Pragma", "public");
        response.setHeader("Cache-Control", "max-age=30");
        response.setHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode(fn, "UTF-8"));
    }
}

实体类

User

package com.baizhi.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class User implements Serializable {
    private Integer id; //数据库自动递增
    private String name;
    private String password;
    private Boolean sex;//false-女 ; true-男
    private Date birthDay;
    private String photo;//头像
    private String email;

}

ErrorMessage
用于接收异常错误信息

package com.baizhi.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import org.springframework.beans.factory.annotation.Autowired;

import java.io.Serializable;

@NoArgsConstructor
@AllArgsConstructor
@Data
@Accessors(chain = true)
public class ErrorMessage implements Serializable {
    private Integer code;
    private String message;
}

异常处理

这里的异常处理，主要是针对，前端发送过来的请求进行响应的异常处理，比如验证码不对，抛出此异常，将有 加强的控制器controllerAdvice进行处理
自定义异常继承 RuntimeException

• 定义一个验证码的异常

package com.baizhi.exceptions;

public class VerifyCodeException extends RuntimeException {
   public VerifyCodeException(String message){
        super(message);
    }
}

• 定义一个输入信息异常

package com.baizhi.exceptions;

public class UserNameAndPasswordException extends RuntimeException {
   public UserNameAndPasswordException(String message){
        super(message);
    }
}

• 这里，我把加强的控制器放在了此包下
  参考文档：@ControllerAdvice
  https://www.cnblogs.com/lenve/p/10748453.html

package com.baizhi.exceptions;

import com.baizhi.entities.ErrorMessage;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class UserDefinedExceptionHandle {

    //定义一个出来验证码异常的处理
    @ExceptionHandler(value = VerifyCodeException.class)
    public ErrorMessage verifyCodeException(VerifyCodeException e){
        return new ErrorMessage(100,e.getMessage());
    }
    //定义一个用户处理账号密码出错的异常处理
    @ExceptionHandler(value = UserNameAndPasswordException.class)
    public ErrorMessage userNameAndPasswordException(UserNameAndPasswordException e){
        return new ErrorMessage(101,e.getMessage());
    }
}

控制层

• 定义验证码控制器

package com.baizhi.controller;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.awt.image.BufferedImageOp;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import com.sun.org.apache.bcel.internal.classfile.Code;
import org.patchca.background.BackgroundFactory;
import org.patchca.color.ColorFactory;
import org.patchca.color.RandomColorFactory;
import org.patchca.filter.ConfigurableFilterFactory;
import org.patchca.filter.library.AbstractImageOp;
import org.patchca.filter.library.WobbleImageOp;
import org.patchca.font.RandomFontFactory;
import org.patchca.service.Captcha;
import org.patchca.service.ConfigurableCaptchaService;
import org.patchca.text.renderer.BestFitTextRenderer;
import org.patchca.text.renderer.TextRenderer;
import org.patchca.word.RandomWordFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/code")
public class CodeController {
    private static final long serialVersionUID = 5126616339795936447L;

    private ConfigurableCaptchaService configurableCaptchaService = null;
    private ColorFactory colorFactory = null;
    private RandomFontFactory fontFactory = null;
    private RandomWordFactory wordFactory = null;
    private TextRenderer textRenderer = null;



    /**
     * Servlet销毁方法,负责销毁所使用资源. <br>
     */
    public void destroy() {
        wordFactory = null;
        colorFactory = null;
        fontFactory = null;
        textRenderer = null;
        configurableCaptchaService = null;
    }

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doPost(request, response);
    }

    private void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("image/png");
        response.setHeader("cache", "no-cache");

        HttpSession session = request.getSession(true);
        OutputStream outputStream = response.getOutputStream();

        // 得到验证码对象,有验证码图片和验证码字符串
        Captcha captcha = configurableCaptchaService.getCaptcha();
        // 取得验证码字符串放入Session
        String validationCode = captcha.getChallenge();
        session.setAttribute("code", validationCode);
        // 取得验证码图片并输出
        BufferedImage bufferedImage = captcha.getImage();
        ImageIO.write(bufferedImage, "png", outputStream);

        outputStream.flush();
        outputStream.close();
    }

    /**
     * Servlet初始化方法
     */
    public void init() throws ServletException {
        configurableCaptchaService = new ConfigurableCaptchaService();

        // 颜色创建工厂,使用一定范围内的随机色
        colorFactory = new RandomColorFactory();
        configurableCaptchaService.setColorFactory(colorFactory);

        // 随机字体生成器
        fontFactory = new RandomFontFactory();
        fontFactory.setMaxSize(32);
        fontFactory.setMinSize(28);
        configurableCaptchaService.setFontFactory(fontFactory);

        // 随机字符生成器,去除掉容易混淆的字母和数字,如o和0等
        wordFactory = new RandomWordFactory();
        wordFactory.setCharacters("abcdefghkmnpqstwxyz23456789");
        wordFactory.setMaxLength(5);
        wordFactory.setMinLength(4);
        configurableCaptchaService.setWordFactory(wordFactory);

        // 自定义验证码图片背景
        MyCustomBackgroundFactory backgroundFactory = new MyCustomBackgroundFactory();
        configurableCaptchaService.setBackgroundFactory(backgroundFactory);

        // 图片滤镜设置
        ConfigurableFilterFactory filterFactory = new ConfigurableFilterFactory();

        List<BufferedImageOp> filters = new ArrayList<BufferedImageOp>();
        WobbleImageOp wobbleImageOp = new WobbleImageOp();
        wobbleImageOp.setEdgeMode(AbstractImageOp.EDGE_MIRROR);
        wobbleImageOp.setxAmplitude(2.0);
        wobbleImageOp.setyAmplitude(1.0);
        filters.add(wobbleImageOp);
        filterFactory.setFilters(filters);

        configurableCaptchaService.setFilterFactory(filterFactory);

        // 文字渲染器设置
        textRenderer = new BestFitTextRenderer();
        textRenderer.setBottomMargin(3);
        textRenderer.setTopMargin(3);
        configurableCaptchaService.setTextRenderer(textRenderer);

        // 验证码图片的大小
        configurableCaptchaService.setWidth(82);
        configurableCaptchaService.setHeight(32);
    }

    /**
     * 自定义验证码图片背景,主要画一些噪点和干扰线
     */
    private static class MyCustomBackgroundFactory implements BackgroundFactory {
        private Random random = new Random();

        public void fillBackground(BufferedImage image) {
            Graphics graphics = image.getGraphics();

            // 验证码图片的宽高
            int imgWidth = image.getWidth();
            int imgHeight = image.getHeight();

            // 填充为白色背景
            graphics.setColor(Color.WHITE);
            graphics.fillRect(0, 0, imgWidth, imgHeight);

            // 画100个噪点(颜色及位置随机)
            for (int i = 0; i < 100; i++) {
                // 随机颜色
                int rInt = random.nextInt(255);
                int gInt = random.nextInt(255);
                int bInt = random.nextInt(255);

                graphics.setColor(new Color(rInt, gInt, bInt));

                // 随机位置
                int xInt = random.nextInt(imgWidth - 3);
                int yInt = random.nextInt(imgHeight - 2);

                // 随机旋转角度
                int sAngleInt = random.nextInt(360);
                int eAngleInt = random.nextInt(360);

                // 随机大小
                int wInt = random.nextInt(6);
                int hInt = random.nextInt(6);

                graphics.fillArc(xInt, yInt, wInt, hInt, sAngleInt, eAngleInt);

                // 画5条干扰线
                if (i % 20 == 0) {
                    int xInt2 = random.nextInt(imgWidth);
                    int yInt2 = random.nextInt(imgHeight);
                    graphics.drawLine(xInt, yInt, xInt2, yInt2);
                }
            }
        }
    }

    @GetMapping("/code")
    public String code(HttpServletRequest request,HttpServletResponse response,HttpSession session) throws ServletException, IOException {
        init();
        doPost(request, response);
        destroy();
        return null;
    }
}

• 定义处理前端请求的控制器

package com.baizhi.controller;

import com.baizhi.entities.User;
import com.baizhi.exceptions.UserNameAndPasswordException;
import com.baizhi.exceptions.VerifyCodeException;
import com.github.tobato.fastdfs.domain.fdfs.StorePath;
import com.github.tobato.fastdfs.domain.upload.FastImageFile;
import com.github.tobato.fastdfs.domain.upload.ThumbImage;
import com.github.tobato.fastdfs.service.FastFileStorageClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.*;

@Controller
@RequestMapping("/user")
public class LoginController {
    //获取一个日志对象
    private Logger logger = LoggerFactory.getLogger(LoginController.class);
    //自动注入一个rest模板
    @Autowired
    private RestTemplate restTemplate;
    //注入一个FastDFS客户端
    @Autowired
    private FastFileStorageClient fastFileStorageClient;
    //定义一个访问地址抬头
    private String prefix="http://localhost:9090/user/restUserManager";


    //判断用户名是否存在
    @PostMapping(value = "/existsUser")
    @ResponseBody
    public boolean exists(User user) throws IOException {
        System.out.println("注册申请的用户名是"+user.getName());
        String url=prefix+"/queryUserByName?name={name}";
        //发请求
        logger.info("收到参数---->"+user.getName());
        Map<String,Object> map = new HashMap<>();
        //放入数据
        map.put("name",user.getName());
        User user1 = restTemplate.getForObject(url,User.class,map);
        //如果查到了，就返回false;
        return user1==null?true:false;
    }


    //登录验证
    @ResponseBody
    @PostMapping("/loginCheck")
    public void login(User user,
                      @RequestParam(value = "verifyCode") String code,
                      HttpSession session){
        //完善访问地址
        String url = prefix+"/userLogin";
        //获取输入的验证码，进行校验
        if(session.getAttribute("code")!=null && code.equals((String)session.getAttribute("code"))){
            //发请求
            logger.info("收到参数---->"+user.getName()+"\t"+user.getPassword());
            //构建表单参数,创建一个MultiValueMap 对象
        /*    MultiValueMap<String,Object> formData = new LinkedMultiValueMap<String, Object>();
            formData.add("user",user);*/
            User user1 = restTemplate.postForObject(url, user, User.class);
            if(user1!=null){
                //将当前登录的用户信息，存入session
                session.setAttribute("user",user1);
                logger.info("用户登录成功！！！");
            }else{
                logger.info("用户名或密码错误！！！");
                throw  new UserNameAndPasswordException("用户名或密码错误！！") ;
            }
        }else{
            logger.info("验证码错误！！！");
            throw new VerifyCodeException("验证码错误！！！") ;
        }

    }
    //获取会话属性
    @RequestMapping("/session")
    public String CheckSession(HttpSession session){
        //获取当前请求中的user
        if(session.getAttribute("user")!=null){
            return "redirect:/work/homepage/main.html";
        }else{
            return "redirect:/work/login/dialog.html";
        }

    }

    //获取当前会话的用户
    @ResponseBody
    @RequestMapping("/current")
    public User getCurrentUser(HttpSession session){
        User current = (User)session.getAttribute("user");
        return  current;
    }


    //注销
    @RequestMapping("/logout")
    public String logout(HttpSession session){
        //获取当前会话中的用户
        session.removeAttribute("user");
        logger.info("用户登出-----Session已销毁");
        return "redirect:/work/login/dialog.html";

    }

    //管理员增加用户
    @ResponseBody
    @PostMapping("/regist")
    public void regist(User user,
                       @RequestParam(value = "multipartFile",required = false) MultipartFile multipartFile) throws IOException {
        //定义文件名
        String photo = null;
        //如果头像图片不为空,并且是图片类型
        if (multipartFile!=null && ("image".equals(multipartFile.getContentType().split("/")[0]))) {
                //获取文件的输入流，存入文件系统
                FastImageFile fastImageFile = new FastImageFile(multipartFile.getInputStream(), multipartFile.getSize(), multipartFile.getContentType().split("/")[1], new HashSet<>());
                //上传文件
                StorePath storePath = fastFileStorageClient.uploadImage(fastImageFile);
                //设置真实文件路径，存入数据库
                photo = storePath.getFullPath();
        }
        //判断页面性别
        if(user.getSex()==null){
            //如果装换开关关闭,则设置性别为false
            user.setSex(false);
        }
        //为参数设置图片信息
        user.setPhoto(photo);
        //定义完整的访问路径
        String url = prefix+"/registerUser";
        //构建表单参数,创建一个MultiValueMap 对象
        MultiValueMap<String,Object> formData = new LinkedMultiValueMap<String, Object>();
        formData.add("user",user);
      //  formData.add("multipartFile",multipartFile);
        logger.info("添加用户收参---->"+user.toString());
        //定义一个接收返回值的参数
        User user1 = null;
        //发送请求
        try {
            user1 = restTemplate.postForObject(url, formData, User.class);
        }catch (Exception e){
            logger.info("发送数据失败！！");
        }finally {
            if(user1!=null){
                logger.info("添加成功");
            }else {
                logger.info("添加失败");
            }
        }
    }

    //注册用户
    @PostMapping("/zhuce")
    public String add(User user,
                       @RequestParam(value = "multipartFile",required = false) MultipartFile multipartFile,HttpSession session) throws IOException {
        //定义文件名
        String photo = null;
        //如果头像图片不为空,并且是图片类型
        if (multipartFile!=null && ("image".equals(multipartFile.getContentType().split("/")[0]))) {
            //获取文件的输入流，存入文件系统
            FastImageFile fastImageFile = new FastImageFile(multipartFile.getInputStream(), multipartFile.getSize(), multipartFile.getContentType().split("/")[1], new HashSet<>());
            //上传文件
            StorePath storePath = fastFileStorageClient.uploadImage(fastImageFile);
            //设置真实文件路径，存入数据库
            photo = storePath.getFullPath();
        }
        //判断页面性别
        if(user.getSex()==null){
            //如果装换开关关闭,则设置性别为false
            user.setSex(false);
        }
        //为参数设置图片信息
        user.setPhoto(photo);
        //定义完整的访问路径
        String url = prefix+"/registerUser";
        //构建表单参数,创建一个MultiValueMap 对象
        MultiValueMap<String,Object> formData = new LinkedMultiValueMap<String, Object>();
        formData.add("user",user);
        //  formData.add("multipartFile",multipartFile);
        logger.info("添加用户收参---->"+user.toString());
        //定义一个接收返回值的参数
        User user1 = null;
        //发送请求
        try {
            user1 = restTemplate.postForObject(url, formData, User.class);
        }catch (Exception e){
            logger.info("发送数据失败！！");
        }finally {
            if(user1!=null){
                logger.info("注册成功");
                session.setAttribute("user",user1);
                return "redirect:/work/homepage/main.html";
            }else {
                logger.info("添加失败");
               return "redirect:/work/login/dialog.html";
            }
        }
    }

    @GetMapping("/queryByPage")
    @ResponseBody
    public Map<String,Object> queryByPage(@RequestParam(value = "page",defaultValue = "1") Integer pageNow,
                                          @RequestParam(value = "rows",defaultValue = "10") Integer pageSize,
                                          @RequestParam(value = "column",required = false,defaultValue = "name") String column,
                                          @RequestParam(value = "value",required = false) String value) {
        //定义发送地址
        String url = prefix + "/queryUserByPage?page={p}&rows={r}&column={c}&value={v}";
        //构建传参集合
        HashMap<String, Object> map = new HashMap<>();
        //传递参数
        map.put("p", pageNow);
        map.put("r", pageSize);
        map.put("c", column);
        map.put("v", value);
        //开始执行
        User[] users = restTemplate.getForObject(url, User[].class, map);
        logger.info("返回"+users.length);
        //需要加载总数据
        //定义第二个地址
        String url2 = prefix+"/queryUserCount?column={c1}&value={v1}";
        //构建传参集合
        HashMap<String, Object> map2 = new HashMap<>();
        //传递参数
        map2.put("c1", column);
        map2.put("v1", value);
        //发送请求
        Integer count = restTemplate.getForObject(url2, Integer.class, map2);
        logger.info("返回数量"+count);
        //定义一个返回值
        Map<String,Object> results=new HashMap<>();
        Set<String> keys = results.keySet();
        for (String key : keys) {
            logger.info("接收层返回值\t"+key+"\t"+results.get(key).toString()+"\t");
        }
        //接收参数
        results.put("rows",users);
        results.put("total",count);
        return  results;

    }

    //修改
    @PutMapping(value = "/update")
    public void updateUser(User user,
                           @RequestParam(value = "multipartFile",required = false) MultipartFile multipartFile)throws IOException{
        //定义文件名
        String photo = null;
        //如果头像图片不为空,并且是图片类型
        if (multipartFile!=null && ("image".equals(multipartFile.getContentType().split("/")[0]))) {
            //获取文件的输入流，存入文件系统
            FastImageFile fastImageFile = new FastImageFile(multipartFile.getInputStream(), multipartFile.getSize(), multipartFile.getContentType().split("/")[1], new HashSet<>());
            //上传文件
            StorePath storePath = fastFileStorageClient.uploadImage(fastImageFile);
            //设置真实文件路径，存入数据库
            photo = storePath.getFullPath();
            //为参数设置图片信息
            user.setPhoto(photo);
        }


        //定义完整的访问路径
        String url = prefix+"/updateUser";
        //构建表单参数,创建一个MultiValueMap 对象
        MultiValueMap<String,Object> formData = new LinkedMultiValueMap<String, Object>();
        formData.add("user",user);
        //  formData.add("multipartFile",multipartFile);
        logger.info("修改用户收参---->"+user.toString());


        //发送请求
        try {
           restTemplate.put(url, formData);
        }catch (Exception e){
            logger.info("发送数据失败！！");
        }
    }

    //删除
    @ResponseBody
    @DeleteMapping(value = "/delete")
    public void delteUserByIds(@RequestParam(value = "ids") Integer[] ids){
       //完善访问路径
        String url = prefix+"/deleteUserByIds?ids={ids}";
        //创建一个集合接收参数
        logger.info("删除的数据id是"+ids);
        Map<String,Object> parameters=new HashMap<String,Object>();
        //获取 从参数的流，然后对流取数据进行按照,拼接
        parameters.put("ids", Arrays.stream(ids).map(i->i.toString()).reduce((v1,v2)->v1+","+v2).get());
       /* parameters.put("ids", Arrays.stream(ids).map(i->i.toString()).reduce((x,y)->x+","+y).get());*/
        //发送请求
        restTemplate.delete(url,parameters);
        logger.info("删除成功"+ids);
    }
}

• 定义处理下载CSV文件请求的控制器

package com.baizhi.controller;

import com.baizhi.entities.User;
import com.baizhi.exceptions.UserNameAndPasswordException;
import com.baizhi.exceptions.VerifyCodeException;
import com.baizhi.util.CsvExportUtil;
import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.FileSystemResource;
import org.springframework.stereotype.Controller;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.util.*;

@Controller
@RequestMapping(value = "/formExportManager")
public class FormExportController {
    private static final Logger LOGGER= LoggerFactory.getLogger(FormExportController.class);
    @Autowired
    private RestTemplate restTemplate;
    private String urlPrefix="http://localhost:9090/user/restUserManager";

    @GetMapping(value = "/exportUser")
    public void exportUser(HttpServletResponse response,
                           @RequestParam(value = "page",defaultValue = "1") Integer pageNow,
                           @RequestParam(value = "rows",defaultValue = "10") Integer pageSize,
                           @RequestParam(value = "column",required = false,defaultValue = "name") String column,
                           @RequestParam(value = "value",required = false) String value) throws Exception {

        String url=urlPrefix+"/queryUserByPage?page={page}&rows={rows}&column={column}&value={value}";

        Map<String, Object> params= new HashMap<String, Object>();
        params.put("page",pageNow);
        params.put("rows",pageSize);
        params.put("column",column);
        params.put("value",value);

        User[]  users=restTemplate.getForObject(url,User[].class,params);

        List<Map<String, Object>> datas = new ArrayList<>();
        Map<String, Object> map = null;

        if (users!=null && users.length>0){
            for (User u : users) {
                map = new HashMap<>();
                map.put("id", u.getId());
                map.put("name", u.getName());
                map.put("sex", u.getSex());
                map.put("birthDay",u.getBirthDay());
                map.put("email", u.getEmail());
                map.put("password", u.getPassword());
                map.put("photo", u.getPhoto());
                datas.add(map);
            }
        }

        // 设置导出文件前缀
        String fName = "用户列表详情_";

        // 文件导出
        OutputStream os = response.getOutputStream();
        CsvExportUtil.responseSetProperties(fName, response);
        String titles = "id,用户名,性别,出生日期,邮件,密码,照片";
        String keys="id,name,sex,birthDay,email,password,photo";
        CsvExportUtil.doExport(datas, titles, keys, os);
        os.close();
    }
}

拦截器

package com.baizhi.interceptor;

import com.baizhi.controller.LoginController;
import com.baizhi.entities.User;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//将此拦截器交给工厂管理
@Component
class UserInterceptor implements HandlerInterceptor {
    //获取一个日志对象
    private Logger logger = LoggerFactory.getLogger(UserInterceptor.class);
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        User user = (User)httpServletRequest.getSession().getAttribute("user");
        logger.info("进入拦截器");
        if(user!=null){
            logger.info("拦截器---->放行"+"\t当前用户\t"+user.getName());
            return true;
        }else {
            logger.info("拦截器----->阻塞");
            httpServletResponse.sendRedirect("/work/login/dialog.html");
            return false;
        }

    }

    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

    }
}

• 使拦截器生效

package com.baizhi.interceptor;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

//配置拦截器属性，使拦截器生效
@Configuration
class RealInerceptor implements WebMvcConfigurer {

    //注入自定义拦截器
    @Autowired
    UserInterceptor userInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(userInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/static/**")
                .excludePathPatterns("/work/login/**")
                .excludePathPatterns("/user/loginCheck")
                .excludePathPatterns("/user/session")
                .excludePathPatterns("/user/existsUser")
                .excludePathPatterns("/user/zhuce")
                .excludePathPatterns("/code/**");
    }
}