#Java实现二维码登录

二维码登录的流程：

1）用户选择二维码登录；

前端发送获取二维码请求，服务器收到请求后生成一个uuid（用于绑定二维码），然后根据指定网址和uuid生成对应的二维码，将uuid作为key，一个对应的code（生成二维码成功）作为value存入Redis，再将生成二维码流返回给前端展示。前端成功获取二维码后开始两秒一次轮询后端接口，直到登录成功或二维码超时（当然也包括关闭页面）

这里使用的是Redis集群模板：
@Resource
private RedisClusterTemplate jedis;

	public AjaxResultModel generateQrCode() {
        AjaxResultModel resultModel = new AjaxResultModel();
        // 生成唯一ID
        String uuid = UUID.randomUUID().toString();
        String uuidStr = PREFILED + uuid;
        jedis.setEx(uuidStr, GENERATEQRCODE, TIMEOUTVALUE);
        resultModel.setCode(ResultCodeEnum.SUCCESS_STATUS.getCode());
        resultModel.setMessage(ResultCodeEnum.SUCCESS_STATUS.getMessage());
        resultModel.setData(createQrCode("http://baidu.com" + "?uuid=" + uuid));

        log.info("二维码登录生成uuid：{}", uuid);

        return resultModel;
    }

2）用户扫描；

用户在移动端登录后扫描网页二维码，二维码解析出来的是一个网址，经websocket直接进行跳转，跳转到确认登录页面，该页面在初始化时调用后端接口（该请求中携带uuid），改变Redis中的code（扫码成功未登录）。

	/**
	 * 扫码成功进入确认登录页面记录状态
	 * @param uuid
	 * @return
	 */
	@RequestMapping(value = "/scanCode.ajax", method = RequestMethod.POST)
    @ResponseBody
    public AjaxResultModel scanCode(@RequestBody String uuid) {
        AjaxResultModel resultModel = new AjaxResultModel();
        SessionUserCommon user = SessionUserCommonUtil.getSessionUser();
        if (user.getId() == null) {
            resultModel.setCode(ResultCodeEnum.SESSION_OUT.getCode());
            resultModel.setMessage(ResultCodeEnum.SESSION_OUT.getMessage());
            return resultModel;
        }
        String uuidStr = PREFILED + uuid;
        jedis.setEx(uuidStr, CONFIRMLOGINSCODE, TIMEOUTVALUE);
        resultModel.setCode(SCANCODE);
        resultModel.setMessage(SCANMSG);
        return resultModel;
    }

3）用户确认登录；

用户点击确认登录按钮，移动端发送一个确认登录请求（该请求中携带uuid），后端收到请求后改变Redis中的code（确认登录成功），并获取请求中的token等用户相关的登录信息，再以uuid+后缀 为key，登录信息为value存入Redis。

	/**
	 * 扫码确认登录
	 * @param uuid
	 * @return
	 */
	@RequestMapping(value = "/confirmLogin.ajax", method = RequestMethod.GET)
    @ResponseBody
    public AjaxResultModel confirmLogin(@RequestParam("uuid") String uuid, HttpServletRequest request) {
        AjaxResultModel resultModel = new AjaxResultModel();
        resultModel.setStatus("200");
        SessionUserCommon user = SessionUserCommonUtil.getSessionUser();
        if (user.getCode() == null) {
            resultModel.setCode(ResultCodeEnum.SESSION_OUT.getCode());
            resultModel.setMessage(ResultCodeEnum.SESSION_OUT.getMessage());
            resultModel.setSuccess(false);
            return resultModel;
        }
        String uuidStr = PREFILED + uuid;
        // 判断确认登录时二维码是否过期
        if (!jedis.exists(uuidStr)) {
            resultModel.setCode(QRCODEEXPIREDCODE);
            resultModel.setMessage(QRCODEEXPIREDMSG);
            resultModel.setSuccess(false);
            return resultModel;
        }
        String uuidValue = PREFILED + uuid + ENDFILED;
        String authToken = request.getHeader("AUTH_TOKEN");
        Map<String, Object> infoMap = new HashMap<>();
        // 将token和userCode放入json对象
        infoMap.put("authToken", authToken);
        infoMap.put("userCode", user.getCode());
        JSONObject jsonObject = new JSONObject(infoMap);
        jedis.setEx(uuidStr, CONFIRMLOGINSCODE, TIMEOUTVALUE);
        jedis.setEx(uuidValue, jsonObject.toJSONString(), TIMEOUTVALUE);
        resultModel.setCode(ResultCodeEnum.SUCCESS_STATUS.getCode());
        resultModel.setMessage(ResultCodeEnum.SUCCESS_STATUS.getMessage());
        resultModel.setData(uuid);
        log.info("二维码登录>>>>>> 移动端扫码确认登录成功，确认人：{}", user.getName());
        return resultModel;
    }

4）登录完成；

在整个过程中网页端一直在轮询后端接口，当uuid对应的code为“确认登录成功”时将用户相关的登录信息返回，此时轮询结束。

	/**
     * PC端轮询
     * 放开鉴权
     * @param uuid
     * @return
     */
    @RequestMapping(value = "/polling.ajax", method = RequestMethod.GET)
    @ResponseBody
    public AjaxResultModel polling (@RequestParam("uuid") String uuid) {
        AjaxResultModel resultModel = new AjaxResultModel();
        String uuidValue = PREFILED + uuid;
        String uuidInfoValue = uuidValue + ENDFILED;
        String uuidStr = PREFILED + uuid;
        String status = jedis.get(uuidValue);
        // 判断过期
        if (!jedis.exists(uuidStr)) {
            status = QRCODEEXPIREDCODE;
        }
        switch (status) {
            case GENERATEQRCODE:
                resultModel.setCode(GENERATEQRCODE);
                resultModel.setMessage(GENERATEQRMSG);
                break;
            case SCANCODE:
                resultModel.setCode(SCANCODE);
                resultModel.setMessage(SCANMSG);
                break;
            case CONFIRMLOGINSCODE:
                String info = jedis.get(uuidInfoValue);
                jedis.del(uuidValue);
                jedis.del(uuidInfoValue);
                resultModel.setCode(CONFIRMLOGINSCODE);
                resultModel.setMessage(CONFIRMLOGINSMSG);
                resultModel.setData(info);
                break;
            case QRCODEEXPIREDCODE:
                jedis.del(uuidValue);
                jedis.del(uuidInfoValue);
                resultModel.setCode(QRCODEEXPIREDCODE);
                resultModel.setMessage(QRCODEEXPIREDMSG);
                resultModel.setSuccess(false);
                break;
             default:
                 resultModel.setCode(UUIDNOTEXITCODE);
                 resultModel.setMessage(UUIDNOTEXITMSG);
                 break;
        }
        return resultModel;
    }

注：生成二维码代码：

package com.example.demo;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Shape;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import javax.imageio.ImageIO;

import com.google.zxing.*;
import com.google.zxing.client.j2se.BufferedImageLuminanceSource;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.common.HybridBinarizer;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;

/**
 * 生成二维码
 * @author chuangchuang.yang
 * @date 2020年4月19日
 * @version v6
 */
public class QrCodeUtil {
    private static final int BLACK = Color.black.getRGB();
    private static final int BLUE = Color.blue.getRGB();
    private static final int WHITE = Color.WHITE.getRGB();
    private static final int DEFAULT_QR_SIZE = 183;
    // 图片类型：位图
    private static final String DEFAULT_QR_FORMAT = "png";
    private static final byte[] EMPTY_BYTES = new byte[0];

    public static byte[] createQrCode(String content, int size, String extension) {
        Image image = null;
        try {
            image = ImageIO.read(new File("D:\\download\\mmexport1586329085259.jpg"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return createQrCode(content, size, extension, image);
    }

    /**
     * 生成带图片的二维码
     * @param content  二维码中要包含的信息
     * @param size  大小
     * @param extension  文件格式扩展
     * @param insertImg  中间的logo图片
     * @return
     */
    public static byte[] createQrCode(String content, int size, String extension, Image insertImg) {
        if (size <= 0) {
            throw new IllegalArgumentException("size (" + size + ")  cannot be <= 0");
        }
        ByteArrayOutputStream baos = null;
        try {
            Map<EncodeHintType, Object> points = new HashMap<EncodeHintType, Object>();
            points.put(EncodeHintType.CHARACTER_SET, "utf-8");
            points.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.M);

            //使用信息生成指定大小的点阵
            BitMatrix matrix = new MultiFormatWriter().encode(content, BarcodeFormat.QR_CODE, size, size, points);

            //去掉白边
            matrix = updateBit(matrix, 0);

            int width = matrix.getWidth();
            int height = matrix.getHeight();

            //将BitMatrix中的信息设置到BufferdImage中，形成黑白图片
            BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
            for (int i = 0; i < width; i++) {
                for (int j = 0; j < height; j++) {
                    bufferedImage.setRGB(i, j, matrix.get(i, j) ? BLUE : WHITE);
                }
            }
            if (insertImg != null) {
                // 插入中间的logo图片
                insertImage(bufferedImage, insertImg, matrix.getWidth());
            }
            //将因为去白边而变小的图片再放大
            bufferedImage = zoomInImage(bufferedImage, size, size);
            baos = new ByteArrayOutputStream();
            ImageIO.write(bufferedImage, extension, baos);

            return baos.toByteArray();
        } catch (Exception e) {
        } finally {
            if(baos != null)
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
        return EMPTY_BYTES;
    }

    /**
     * 自定义二维码白边宽度
     * @param matrix
     * @param margin
     * @return
     */
    private static BitMatrix updateBit(BitMatrix matrix, int margin) {
        int tempM = margin * 2;
        int[] rec = matrix.getEnclosingRectangle(); // 获取二维码图案的属性
        int resWidth = rec[2] + tempM;
        int resHeight = rec[3] + tempM;
        BitMatrix resMatrix = new BitMatrix(resWidth, resHeight); // 按照自定义边框生成新的BitMatrix
        resMatrix.clear();
        for (int i = margin; i < resWidth - margin; i++) { // 循环，将二维码图案绘制到新的bitMatrix中
            for (int j = margin; j < resHeight - margin; j++) {
                if (matrix.get(i - margin + rec[0], j - margin + rec[1])) {
                    resMatrix.set(i, j);
                }
            }
        }
        return resMatrix;
    }

    // 图片放大缩小
    public static BufferedImage zoomInImage(BufferedImage originalImage, int width, int height) {
        BufferedImage newImage = new BufferedImage(width, height, originalImage.getType());
        Graphics g = newImage.getGraphics();
        g.drawImage(originalImage, 0, 0, width, height, null);
        g.dispose();
        return newImage;
    }

    private static void insertImage(BufferedImage source, Image insertImg, int size) {
        try {
            int width = insertImg.getWidth(null);
            int height = insertImg.getHeight(null);
            width = width > size / 6 ? size / 6 : width;  // logo设为二维码的六分之一大小
            height = height > size / 6 ? size / 6 : height;
            Graphics2D graph = source.createGraphics();
            int x = (size - width) / 2;
            int y = (size - height) / 2;
            graph.drawImage(insertImg, x, y, width, height, null);
            Shape shape = new RoundRectangle2D.Float(x, y, width, width, 6, 6);
            graph.setStroke(new BasicStroke(3f));
            graph.draw(shape);
            graph.dispose();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static byte[] createQrCode(String content) {
        return createQrCode(content, DEFAULT_QR_SIZE, DEFAULT_QR_FORMAT);
    }

    /** 
          * 二维码解析 
          * @param analyzePath    二维码路径 
          * @return 
          * @throws IOException 
          */  
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static String zxingCodeAnalyze(String analyzePath) throws Exception{
        MultiFormatReader formatReader = new MultiFormatReader();
        String resultStr = null;
        try {
            File file = new File(analyzePath);
            if (!file.exists())
            {
                return "二维码不存在";
            }
            BufferedImage image = ImageIO.read(file);
            LuminanceSource source = new BufferedImageLuminanceSource(image);
            Binarizer binarizer = new HybridBinarizer(source);
            BinaryBitmap binaryBitmap = new BinaryBitmap(binarizer);
            Map hints = new HashMap();
            hints.put(EncodeHintType.CHARACTER_SET, "UTF-8");
            Result result = formatReader.decode(binaryBitmap, hints);
            resultStr = result.getText();
        } catch (NotFoundException e) {
            e.printStackTrace();
        }
        return resultStr;
    }

    public static void main(String[] args){
        try {
            // 生成唯一ID
            int uuid = (int) (Math.random() * 100000);
            // 生成二维码时绑定uuid (移动端扫码后跳转到确认登录的页面，此时已经携带该uuid，在确认登录时携带该uuid访问后端接口)
//            byte[] qrCode = createQrCode("" + "?uuid=" + uuid);

            FileOutputStream fos = new FileOutputStream("D:\\usuallyUse\\erweima.png");
            fos.write(createQrCode("http://baidu.com" + "?uuid=" + uuid));
            fos.close();

//            System.out.println(zxingCodeAnalyze("D:\\usuallyUse\\erweima.png"));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}