扫描微信二维码实现快速登录

一、什么是二维码
二维码又称二维条码，常见的二维码为QR Code，QR全称Quick Response，是一个近几年来移动设备上超流行的一种编码方式，它比传统的Bar Code条形码能存更多的信息，也能表示更多的数据类型。二维条码/二维码（2-dimensional bar code）是用某种特定的几何图形按一定规律在平面（二维方向上）分布的黑白相间的图形记录数据符号信息的；在代码编制上巧妙地利用构成计算机内部逻辑基础的“0”、“1”比特流的概念，使用若干个与二进制相对应的几何形体来表示文字数值信息，通过图象输入设备或光电扫描设备自动识读以实现信息自动处理：它具有条码技术的一些共性：每种码制有其特定的字符集；每个字符占有一定的宽度；具有一定的校验功能等。同时还具有对不同行的信息自动识别功能、及处理图形旋转变化点。
 

二、二维码生成的几种方式：

1. 在线二维码生成方式 （http://www.liantu.com/）
2. Java生成二维码使用google zxing 框架
3. 前端生成二维码使用jquery-qrcode框架
4.  

三、扫描登录及跳转原理：
3.1、使用google zxing 框架生成二维码,在二维码中绑定跳转地址
3.2、使用手机扫一扫扫描二维码跳转至地址
3.3 、如何保证二维码唯一性，及超时处理之后怎么处理。
3.3.1、使用token存储至Redis保证二维码的唯一性，
3.3.2、前端使用ajax定时发送请求，检查该token是否为登陆状态
 

四、扫描二维码登录代码如下：

1.在pom.xml文件中导入相应的jar包：

    com.google.zxing
    core
    3.3.0



    org.springframework.boot
    spring-boot-starter-data-redis



    org.springframework.boot
    spring-boot-starter-freemarker

2.在application.yml写入相应的配置如下：

codersWang:
  baseImgUrl: http://18236a01n6.51mypc.cn:51927/updateTokenState?token=
server:
  port: 8080
spring:
  http:
    encoding:
      force: true
      charset: UTF-8
  redis:
    host: 127.0.0.1
    port: 6379
    #    password: 123456
  freemarker:
    allow-request-override: false
    cache: false
    check-template-location: true
    charset: UTF-8
    content-type: text/html; charset=utf-8
    expose-request-attributes: false
    expose-session-attributes: false
    expose-spring-macro-helpers: false
    suffix: .ftl
    template-loader-path: classpath:/templates

3.写二维码生成的工具类：

package com.qrcode.code;

import java.awt.BasicStroke;
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.File;
import java.io.OutputStream;
import java.util.Hashtable;
import java.util.Random;
import javax.imageio.ImageIO;

import com.google.zxing.BarcodeFormat;
import com.google.zxing.BinaryBitmap;
import com.google.zxing.DecodeHintType;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatReader;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.Result;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.common.HybridBinarizer;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;

public class QRCodeUtil {
    private static final String CHARSET = "utf-8";
    private static final String FORMAT_NAME = "JPG";
    // 二维码尺寸
    private static final int QRCODE_SIZE = 300;
    // LOGO宽度
    private static final int WIDTH = 60;
    // LOGO高度
    private static final int HEIGHT = 60;

    public static BufferedImage createImage(String content, String imgPath, boolean needCompress) throws Exception {
        Hashtable hints = new Hashtable();
        hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
        hints.put(EncodeHintType.CHARACTER_SET, CHARSET);
        hints.put(EncodeHintType.MARGIN, 1);
        BitMatrix bitMatrix = new MultiFormatWriter().encode(content, BarcodeFormat.QR_CODE, QRCODE_SIZE, QRCODE_SIZE,
                hints);
        int width = bitMatrix.getWidth();
        int height = bitMatrix.getHeight();
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                image.setRGB(x, y, bitMatrix.get(x, y) ? 0xFF000000 : 0xFFFFFFFF);
            }
        }
        if (imgPath == null || "".equals(imgPath)) {
            return image;
        }
        // 插入图片
        QRCodeUtil.insertImage(image, imgPath, needCompress);
        return image;
    }

    private static void insertImage(BufferedImage source, String imgPath, boolean needCompress) throws Exception {
        File file = new File(imgPath);
        if (!file.exists()) {
            System.err.println("" + imgPath + "   该文件不存在！");
            return;
        }
        Image src = ImageIO.read(new File(imgPath));
        int width = src.getWidth(null);
        int height = src.getHeight(null);
        if (needCompress) { // 压缩LOGO
            if (width > WIDTH) {
                width = WIDTH;
            }
            if (height > HEIGHT) {
                height = HEIGHT;
            }
            Image image = src.getScaledInstance(width, height, Image.SCALE_SMOOTH);
            BufferedImage tag = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
            Graphics g = tag.getGraphics();
            g.drawImage(image, 0, 0, null); // 绘制缩小后的图
            g.dispose();
            src = image;
        }
        // 插入LOGO
        Graphics2D graph = source.createGraphics();
        int x = (QRCODE_SIZE - width) / 2;
        int y = (QRCODE_SIZE - height) / 2;
        graph.drawImage(src, 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();
    }

    public static void encode(String content, String imgPath, String destPath, boolean needCompress) throws Exception {
        BufferedImage image = QRCodeUtil.createImage(content, imgPath, needCompress);
        mkdirs(destPath);
        // String file = new Random().nextInt(99999999)+".jpg";
        // ImageIO.write(image, FORMAT_NAME, new File(destPath+"/"+file));
        ImageIO.write(image, FORMAT_NAME, new File(destPath));
    }

    public  BufferedImage encode(String content, String imgPath, boolean needCompress) throws Exception {
        BufferedImage image = QRCodeUtil.createImage(content, imgPath, needCompress);
        return image;
    }

    public static void mkdirs(String destPath) {
        File file = new File(destPath);
        // 当文件夹不存在时，mkdirs会自动创建多层目录，区别于mkdir．(mkdir如果父目录不存在则会抛出异常)
        if (!file.exists() && !file.isDirectory()) {
            file.mkdirs();
        }
    }

    public static void encode(String content, String imgPath, String destPath) throws Exception {
        QRCodeUtil.encode(content, imgPath, destPath, false);
    }
    // 被注释的方法
    /*
     * public static void encode(String content, String destPath, boolean
     * needCompress) throws Exception { QRCodeUtil.encode(content, null, destPath,
     * needCompress); }
     */

    public static void encode(String content, String destPath) throws Exception {
        QRCodeUtil.encode(content, null, destPath, false);
    }

    public static void encode(String content, String imgPath, OutputStream output, boolean needCompress)
            throws Exception {
        BufferedImage image = QRCodeUtil.createImage(content, imgPath, needCompress);
        ImageIO.write(image, FORMAT_NAME, output);
    }

    public static void encode(String content, OutputStream output) throws Exception {
        QRCodeUtil.encode(content, null, output, false);
    }

    public static String decode(File file) throws Exception {
        BufferedImage image;
        image = ImageIO.read(file);
        if (image == null) {
            return null;
        }
        BufferedImageLuminanceSource source = new BufferedImageLuminanceSource(image);
        BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
        Result result;
        Hashtable hints = new Hashtable();
        hints.put(DecodeHintType.CHARACTER_SET, CHARSET);
        result = new MultiFormatReader().decode(bitmap, hints);
        String resultStr = result.getText();
        return resultStr;
    }

    public static String decode(String path) throws Exception {
        return QRCodeUtil.decode(new File(path));
    }

}

package com.qrcode.code;

import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;

import com.google.zxing.LuminanceSource;

public class BufferedImageLuminanceSource extends LuminanceSource {

    private final BufferedImage image;
    private final int left;
    private final int top;

    public BufferedImageLuminanceSource(BufferedImage image) {
        this(image, 0, 0, image.getWidth(), image.getHeight());
    }

    public BufferedImageLuminanceSource(BufferedImage image, int left, int top, int width, int height) {
        super(width, height);

        int sourceWidth = image.getWidth();
        int sourceHeight = image.getHeight();
        if (left + width > sourceWidth || top + height > sourceHeight) {
            throw new IllegalArgumentException("Crop rectangle does not fit within image data.");
        }

        for (int y = top; y < top + height; y++) {
            for (int x = left; x < left + width; x++) {
                if ((image.getRGB(x, y) & 0xFF000000) == 0) {
                    image.setRGB(x, y, 0xFFFFFFFF); // = white
                }
            }
        }

        this.image = new BufferedImage(sourceWidth, sourceHeight, BufferedImage.TYPE_BYTE_GRAY);
        this.image.getGraphics().drawImage(image, 0, 0, null);
        this.left = left;
        this.top = top;
    }

    public byte[] getRow(int y, byte[] row) {
        if (y < 0 || y >= getHeight()) {
            throw new IllegalArgumentException("Requested row is outside the image: " + y);
        }
        int width = getWidth();
        if (row == null || row.length < width) {
            row = new byte[width];
        }
        image.getRaster().getDataElements(left, top + y, width, 1, row);
        return row;
    }

    public byte[] getMatrix() {
        int width = getWidth();
        int height = getHeight();
        int area = width * height;
        byte[] matrix = new byte[area];
        image.getRaster().getDataElements(left, top, width, height, matrix);
        return matrix;
    }

    public boolean isCropSupported() {
        return true;
    }

    public LuminanceSource crop(int left, int top, int width, int height) {
        return new BufferedImageLuminanceSource(image, this.left + left, this.top + top, width, height);
    }

    public boolean isRotateSupported() {
        return true;
    }

    public LuminanceSource rotateCounterClockwise() {
        int sourceWidth = image.getWidth();
        int sourceHeight = image.getHeight();
        AffineTransform transform = new AffineTransform(0.0, -1.0, 1.0, 0.0, 0.0, sourceWidth);
        BufferedImage rotatedImage = new BufferedImage(sourceHeight, sourceWidth, BufferedImage.TYPE_BYTE_GRAY);
        Graphics2D g = rotatedImage.createGraphics();
        g.drawImage(image, transform, null);
        g.dispose();
        int width = getWidth();
        return new BufferedImageLuminanceSource(rotatedImage, top, sourceWidth - (left + width), getHeight(), width);
    }

}

4.Redis工具类：

package com.qrcode.token;

import java.util.List;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class RedisUtil {
   @Autowired
   private StringRedisTemplate stringRedisTemplate;

   // 如果key存在的话返回fasle 不存在的话返回true
   public Boolean setNx(String key, String value, Long timeout) {
      Boolean setIfAbsent = stringRedisTemplate.opsForValue().setIfAbsent(key, value);
      if (timeout != null) {
         stringRedisTemplate.expire(key, timeout, TimeUnit.SECONDS);
      }
      return setIfAbsent;
   }

   public StringRedisTemplate getStringRedisTemplate() {
      return stringRedisTemplate;
   }

   public void setList(String key, List listToken) {
      stringRedisTemplate.opsForList().leftPushAll(key, listToken);
   }

   /**
    * 存放string类型
    * 
    * @param key
    *            key
    * @param data
    *            数据
    * @param timeout
    *            超时间
    */
   public void setString(String key, String data, Long timeout) {
      try {

         stringRedisTemplate.opsForValue().set(key, data);
         if (timeout != null) {
            stringRedisTemplate.expire(key, timeout, TimeUnit.SECONDS);
         }

      } catch (Exception e) {

      }

   }

   /**
    * 开启Redis 事务
    * 
    * @param
    */
   public void begin() {
      // 开启Redis 事务权限
      stringRedisTemplate.setEnableTransactionSupport(true);
      // 开启事务
      stringRedisTemplate.multi();

   }

   /**
    * 提交事务
    * 
    * @param
    */
   public void exec() {
      // 成功提交事务
      stringRedisTemplate.exec();
   }

   /**
    * 回滚Redis 事务
    */
   public void discard() {
      stringRedisTemplate.discard();
   }

   /**
    * 存放string类型
    * 
    * @param key
    *            key
    * @param data
    *            数据
    */
   public void setString(String key, String data) {
      setString(key, data, null);
   }

   /**
    * 根据key查询string类型
    * 
    * @param key
    * @return
    */
   public String getString(String key) {
      String value = stringRedisTemplate.opsForValue().get(key);
      return value;
   }

   /**
    * 根据对应的key删除key
    * 
    * @param key
    */
   public Boolean delKey(String key) {
      return stringRedisTemplate.delete(key);

   }
}

package com.qrcode.token;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Component
public class GenerateToken {
   @Autowired
   private RedisUtil redisUtil;

   /**
    * 生成令牌
    *
    * @param keyPrefix
    *            令牌key前缀
    * @param redisValue
    *            redis存放的值
    * @return 返回token
    */
   public String createToken(String keyPrefix, String redisValue) {
      return createToken(keyPrefix, redisValue, null);
   }

   /**
    * 生成令牌
    *
    * @param keyPrefix
    *            令牌key前缀
    * @param redisValue
    *            redis存放的值
    * @param time
    *            有效期
    * @return 返回token
    */
   public String createToken(String keyPrefix, String redisValue, Long time) {
      if (StringUtils.isEmpty(redisValue)) {
         new Exception("redisValue Not nul");
      }
      String token = keyPrefix + UUID.randomUUID().toString().replace("-", "");
      redisUtil.setString(token, redisValue, time);
      return token;
   }

   public void createListToken(String keyPrefix, String redisKey, Long tokenQuantity) {
      List listToken = getListToken(keyPrefix, tokenQuantity);
      redisUtil.setList(redisKey, listToken);
   }

   public List getListToken(String keyPrefix, Long tokenQuantity) {
      List listToken = new ArrayList<>();
      for (int i = 0; i < tokenQuantity; i++) {
         String token = keyPrefix + UUID.randomUUID().toString().replace("-", "");
         listToken.add(token);
      }
      return listToken;

   }

   public String getListKeyToken(String key) {
      String value = redisUtil.getStringRedisTemplate().opsForList().leftPop(key);
      return value;
   }

   /**
    * 根据token获取redis中的value值
    *
    * @param token
    * @return
    */
   public String getToken(String token) {
      if (StringUtils.isEmpty(token)) {
         return null;
      }
      String value = redisUtil.getString(token);
      return value;
   }

   /**
    * 移除token
    *
    * @param token
    * @return
    */
   public Boolean removeToken(String token) {
      if (StringUtils.isEmpty(token)) {
         return null;
      }
      return redisUtil.delKey(token);

   }

}

5.返回前端的controller层

package com.qrcode.controller;

import com.qrcode.code.QRCodeUtil;
import com.qrcode.token.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import java.util.UUID;

/**
 * @author EDZ
 * @date 2019/5/28
 */
@Controller
public class LoginController {
    @Autowired
    private RedisUtil redisUtil;
    @Value("${codersWang.baseImgUrl}")
    private String baseImgUr;

    @RequestMapping("/qc")
    public String index(HttpServletRequest request) throws Exception {
        //获取token
        String token = getToken();
        request.setAttribute("token", token);
        return "index";
}

    @RequestMapping("/success")
    public String success() {
        return "success";
    }

    @RequestMapping("/updateTokenState")
    public String updateTokenState(String token) {
        String redisToken = redisUtil.getString(token);
        if (StringUtils.isEmpty(redisToken) || redisToken.equals("1")) {
            return "failure";
        }
        // 将该token的状态改为1
        redisUtil.setString(token, "1");
        return "success";
    }

    @RequestMapping("/failure")
    public String failure() {
        return "failure";
    }


    //生成token，生成二维码
    private String getToken() throws Exception {
        // 1.使用UUID生成token替换掉 "-"
        String token = UUID.randomUUID().toString().replace("-", "");
        // 2. 存放在redis中 0 表示没有被扫过，1表示已经扫过
        redisUtil.setString(token, "0",20000L);
        // 3.1存放在二维码中的内容
        // 3.2嵌入二维码的图片路径
        String imgPath = "G:/aa.jpg";
        // 3.3生成的二维码的路径及名称
        String destPath = "G:/aa" + token + ".jpg";
        // 4.生成二维码
        QRCodeUtil.encode(baseImgUr + token, imgPath, destPath, true);
        // 5.解析二维码
        QRCodeUtil.decode(destPath);
        return token;
    }
}

6.访问接口  生成二维码返回前端   访问地址：http://localhost:8080/qc

 

7.扫描以上二维码会跳转登录成功页  如下：

8.前端的相应页面代码如下：
index.ftl页面：

扫一下该二维码，实现扫码登陆

success.ftl页面：
 

六一儿童节快乐

failure.ftl页面：
 

Token已过期!
.

9.注意 以上代码是在本地调试    微信和本地不在一个网段  所以需要用到内网渗透   本人用的是花生壳    将本地端口映射到花生壳上即可  如下：