1. 项目说明

当前这篇教程是：

1. 抽取公共模块common，集成redis，虽然只有几个工具类和redis

2. 新建Gateway网关，集成Security，做登陆和资源权限控制

3. 前端登陆，做了2种方式。用户、密码、验证码；邮箱、验证码、图片滑块；并且前端加密传给后端解密；登陆异常次数限制

4. 在分布式系统中基于Token的身份验证

5. 每次请求刷新用户会话有效时间

6. 通过AOP方式动态切换数据源

简单创建一个SpringCloud2021.0.3项目（一）

简单创建一个SpringCloud2021.0.3项目（二）

简单创建一个SpringCloud2021.0.3项目（三）

简单创建一个SpringCloud2021.0.3项目（四）

1. 版本

  1. SpringCloud版本为2021.0.3
  2. SpringBoot版本为2.7.2

2. 用到组件

  1. 注册中心：暂时用Eureka，后面再改成Nacos
  2. 网关：Gateway
  3. 权限：Security，Gateway集成
  4. 负载均衡：LoadBalancer，SpringCloud2020版之后就集成LoadBalancer
  5. 限流、熔断降级：Sentinel
  6. 配置中心：暂时用Config，后面改成Nacos
  7. 服务间访问：Feign

3. 功能

  1. 项目最基本功能，权限控制，在分布式系统中基于Token的身份验证。
  2. 前端登陆，做了2种方式。用户、密码、验证码；邮箱、验证码、图片滑块；并且前端加密传给后端解密；登陆异常次数限制；
  3. 限流、负载均衡，应对高并发情况，降低系统负载；
  4. 服务熔断降级：避免系统雪崩，提高系统可用性；
  5. 两种方式的多数据源，一种是通过AOP方式动态切换数据源，另一种是不同数据源管理的数据各不相同；
  6. 日志系统Logback，是SpringBoot默认集成

2. 上一篇教程

简单创建一个SpringCloud2021.0.3项目（一）

  1. 新建Eureka注册中心
  2. 新建Config配置中心，producerService服务读取参数
  3. 2个业务服务（producerService和webService），webService通过Feign调用producerService的服务
  4. webService用到多数据源，不同的数据源管理不同的数据

3. 创建公共模块Common

  1. 创建操作

  2. 修改pom.xml文件



点击查看代码 
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>SpringCloud202208</artifactId>
  7.         <groupId>com.xiaostudy</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>common</artifactId>
  14.     <dependencies>
  15.         <!-- SpringBoot Boot Redis -->
  16.         <dependency>
  17.             <groupId>org.springframework.boot</groupId>
  18.             <artifactId>spring-boot-starter-data-redis</artifactId>
  19.         </dependency>
  21.         <!-- JSON 解析器和生成器 -->
  22.         <dependency>
  23.             <groupId>com.alibaba.fastjson2</groupId>
  24.             <artifactId>fastjson2</artifactId>
  25.             <version>2.0.12</version>
  26.         </dependency>
  27.     </dependencies>
  29. </project>
  1. redis序列化、配置类、工具类

序列化 
  1. package com.xiaostudy.common.redis;
  3. import com.alibaba.fastjson2.JSON;
  4. import com.alibaba.fastjson2.JSONReader;
  5. import com.alibaba.fastjson2.JSONWriter;
  6. import org.springframework.data.redis.serializer.RedisSerializer;
  7. import org.springframework.data.redis.serializer.SerializationException;
  9. import java.nio.charset.Charset;
  10. import java.nio.charset.StandardCharsets;
  12. /**
  13.  * Redis使用FastJson序列化
  14.  */
  15. public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {
  17.     private Class<T> clazz;
  19.     public FastJson2JsonRedisSerializer(Class<T> clazz) {
  20.         super();
  21.         this.clazz = clazz;
  22.     }
  24.     @Override
  25.     public byte[] serialize(T t) throws SerializationException {
  26.         if (t == null) {
  27.             return new byte[0];
  28.         }
  29.         return JSON.toJSONString(t, JSONWriter.Feature.WriteClassName).getBytes(StandardCharsets.UTF_8);
  30.     }
  32.     @Override
  33.     public T deserialize(byte[] bytes) throws SerializationException {
  34.         if (bytes == null || bytes.length <= 0) {
  35.             return null;
  36.         }
  37.         String str = new String(bytes, StandardCharsets.UTF_8);
  39.         return JSON.parseObject(str, clazz, JSONReader.Feature.SupportAutoType);
  40.     }
  41. }
配置类 
  1. package com.xiaostudy.common.redis;
  3. import org.springframework.boot.autoconfigure.AutoConfigureBefore;
  4. import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
  5. import org.springframework.cache.annotation.CachingConfigurerSupport;
  6. import org.springframework.cache.annotation.EnableCaching;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  9. import org.springframework.data.redis.connection.RedisConnectionFactory;
  10. import org.springframework.data.redis.core.RedisTemplate;
  11. import org.springframework.data.redis.serializer.StringRedisSerializer;
  13. /**
  14.  * redis配置
  15.  */
  16. @Configuration
  17. // 启动redis
  18. @EnableCaching
  19. // RedisConfig在RedisAutoConfiguration之前加载
  20. @AutoConfigureBefore(RedisAutoConfiguration.class)
  21. public class RedisConfig extends CachingConfigurerSupport {
  22.     @Bean
  23.     @SuppressWarnings(value = {"unchecked" , "rawtypes"})
  24.     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
  25.         RedisTemplate<Object, Object> template = new RedisTemplate<>();
  26.         template.setConnectionFactory(connectionFactory);
  28.         FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
  30.         // 使用StringRedisSerializer来序列化和反序列化redis的key值
  31.         template.setKeySerializer(new StringRedisSerializer());
  32.         template.setValueSerializer(serializer);
  34.         // Hash的key也采用StringRedisSerializer的序列化方式
  35.         template.setHashKeySerializer(new StringRedisSerializer());
  36.         template.setHashValueSerializer(serializer);
  38.         template.afterPropertiesSet();
  39.         return template;
  40.     }
  41. }
工具类 
  1. package com.xiaostudy.common.redis;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.BoundSetOperations;
  5. import org.springframework.data.redis.core.HashOperations;
  6. import org.springframework.data.redis.core.RedisTemplate;
  7. import org.springframework.data.redis.core.ValueOperations;
  8. import org.springframework.stereotype.Component;
  10. import java.util.*;
  11. import java.util.concurrent.TimeUnit;
  13. /**
  14.  * spring redis 工具类
  15.  **/
  16. @SuppressWarnings(value = {"unchecked" , "rawtypes"})
  17. @Component
  18. public class RedisService {
  19.     @Autowired
  20.     public RedisTemplate redisTemplate;
  22.     /**
  23.      * 缓存基本的对象，Integer、String、实体类等
  24.      *
  25.      * @param key   缓存的键值
  26.      * @param value 缓存的值
  27.      */
  28.     public <T> void setCacheObject(final String key, final T value) {
  29.         redisTemplate.opsForValue().set(key, value);
  30.     }
  32.     /**
  33.      * 缓存基本的对象，Integer、String、实体类等
  34.      *
  35.      * @param key      缓存的键值
  36.      * @param value    缓存的值
  37.      * @param timeout  时间
  38.      * @param timeUnit 时间颗粒度
  39.      */
  40.     public <T> void setCacheObject(final String key, final T value, final Long timeout, final TimeUnit timeUnit) {
  41.         redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
  42.     }
  44.     /**
  45.      * 设置有效时间
  46.      *
  47.      * @param key     Redis键
  48.      * @param timeout 超时时间
  49.      * @return true=设置成功；false=设置失败
  50.      */
  51.     public boolean expire(final String key, final long timeout) {
  52.         return expire(key, timeout, TimeUnit.SECONDS);
  53.     }
  55.     /**
  56.      * 设置有效时间
  57.      *
  58.      * @param key     Redis键
  59.      * @param timeout 超时时间
  60.      * @param unit    时间单位
  61.      * @return true=设置成功；false=设置失败
  62.      */
  63.     public boolean expire(final String key, final long timeout, final TimeUnit unit) {
  64.         return redisTemplate.expire(key, timeout, unit);
  65.     }
  67.     /**
  68.      * 获取有效时间
  69.      *
  70.      * @param key Redis键
  71.      * @return 有效时间
  72.      */
  73.     public long getExpire(final String key) {
  74.         return redisTemplate.getExpire(key);
  75.     }
  77.     /**
  78.      * 判断 key是否存在
  79.      *
  80.      * @param key 键
  81.      * @return true 存在 false不存在
  82.      */
  83.     public Boolean hasKey(String key) {
  84.         return redisTemplate.hasKey(key);
  85.     }
  87.     /**
  88.      * 获得缓存的基本对象。
  89.      *
  90.      * @param key 缓存键值
  91.      * @return 缓存键值对应的数据
  92.      */
  93.     public <T> T getCacheObject(final String key) {
  94.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  95.         return operation.get(key);
  96.     }
  98.     /**
  99.      * 删除单个对象
  100.      *
  101.      * @param key
  102.      */
  103.     public boolean deleteObject(final String key) {
  104.         return redisTemplate.delete(key);
  105.     }
  107.     /**
  108.      * 删除集合对象
  109.      *
  110.      * @param collection 多个对象
  111.      * @return
  112.      */
  113.     public boolean deleteObject(final Collection collection) {
  114.         return redisTemplate.delete(collection) > 0;
  115.     }
  117.     /**
  118.      * 缓存List数据
  119.      *
  120.      * @param key      缓存的键值
  121.      * @param dataList 待缓存的List数据
  122.      * @return 缓存的对象
  123.      */
  124.     public <T> long setCacheList(final String key, final List<T> dataList) {
  125.         Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
  126.         return count == null ? 0 : count;
  127.     }
  129.     /**
  130.      * 获得缓存的list对象
  131.      *
  132.      * @param key 缓存的键值
  133.      * @return 缓存键值对应的数据
  134.      */
  135.     public <T> List<T> getCacheList(final String key) {
  136.         return redisTemplate.opsForList().range(key, 0, -1);
  137.     }
  139.     /**
  140.      * 缓存Set
  141.      *
  142.      * @param key     缓存键值
  143.      * @param dataSet 缓存的数据
  144.      * @return 缓存数据的对象
  145.      */
  146.     public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
  147.         BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
  148.         Iterator<T> it = dataSet.iterator();
  149.         while (it.hasNext()) {
  150.             setOperation.add(it.next());
  151.         }
  152.         return setOperation;
  153.     }
  155.     /**
  156.      * 获得缓存的set
  157.      *
  158.      * @param key
  159.      * @return
  160.      */
  161.     public <T> Set<T> getCacheSet(final String key) {
  162.         return redisTemplate.opsForSet().members(key);
  163.     }
  165.     /**
  166.      * 缓存Map
  167.      *
  168.      * @param key
  169.      * @param dataMap
  170.      */
  171.     public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
  172.         if (dataMap != null) {
  173.             redisTemplate.opsForHash().putAll(key, dataMap);
  174.         }
  175.     }
  177.     /**
  178.      * 获得缓存的Map
  179.      *
  180.      * @param key
  181.      * @return
  182.      */
  183.     public <T> Map<String, T> getCacheMap(final String key) {
  184.         return redisTemplate.opsForHash().entries(key);
  185.     }
  187.     /**
  188.      * 往Hash中存入数据
  189.      *
  190.      * @param key   Redis键
  191.      * @param hKey  Hash键
  192.      * @param value 值
  193.      */
  194.     public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
  195.         redisTemplate.opsForHash().put(key, hKey, value);
  196.     }
  198.     /**
  199.      * 获取Hash中的数据
  200.      *
  201.      * @param key  Redis键
  202.      * @param hKey Hash键
  203.      * @return Hash中的对象
  204.      */
  205.     public <T> T getCacheMapValue(final String key, final String hKey) {
  206.         HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
  207.         return opsForHash.get(key, hKey);
  208.     }
  210.     /**
  211.      * 获取多个Hash中的数据
  212.      *
  213.      * @param key   Redis键
  214.      * @param hKeys Hash键集合
  215.      * @return Hash对象集合
  216.      */
  217.     public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
  218.         return redisTemplate.opsForHash().multiGet(key, hKeys);
  219.     }
  221.     /**
  222.      * 删除Hash中的某条数据
  223.      *
  224.      * @param key  Redis键
  225.      * @param hKey Hash键
  226.      * @return 是否成功
  227.      */
  228.     public boolean deleteCacheMapValue(final String key, final String hKey) {
  229.         return redisTemplate.opsForHash().delete(key, hKey) > 0;
  230.     }
  232.     /**
  233.      * 获得缓存的基本对象列表
  234.      *
  235.      * @param pattern 字符串前缀
  236.      * @return 对象列表
  237.      */
  238.     public Collection<String> keys(final String pattern) {
  239.         return redisTemplate.keys(pattern);
  240.     }
  241. }
  1. 字符串工具类

点击查看代码 
  1. package com.xiaostudy.common.utils;
  3. import java.util.Arrays;
  4. import java.util.List;
  6. public class StringUtils {
  8.     public static final String BLANK = " ";
  9.     public static final String EMPTY = "";
  10.     public static final String DEFAULT_LOGOUT_SUCCESS_URL = "/web/webLogin/isLogout";
  11.     public static final String DEFAULT_LOGIN_URL_1 = "/web/webLogin/form";
  12.     public static final String DEFAULT_LOGIN_MAIL_URL_1 = "/web/webLogin/emailLogin";
  13.     public static final String DEFAULT_LOGOUT_URL_1 = "/web/webLogin/logout";
  14.     public static final String DEFAULT_REGISTER_URL_1 = "/web/webLogin/register";
  15.     public static final String DEFAULT_REGISTER_HTML_1 = "/web/register.html";
  16.     public static final String DEFAULT_LOGOUT_HTML_1 = "/web/login.html";
  17.     public static final String DEFAULT_LOGIN_MAIL_HTML = "/web/loginMail.html";
  18.     public static final String DEFAULT_INDEX_HTML_1 = "/web/index.html";
  19.     public static final String COMMA = ",";
  20.     public static final String EMAIL = "email";
  21.     public static final String WILDCARD = "**";
  22.     public static final String[] REQUEST_RUL_WHITE_S = {
  23.             DEFAULT_LOGOUT_HTML_1
  24.             , "/web/webLogin/login"
  25.             , DEFAULT_LOGOUT_SUCCESS_URL
  26.             , DEFAULT_LOGIN_MAIL_HTML
  27.             , DEFAULT_REGISTER_URL_1
  28.             , DEFAULT_REGISTER_HTML_1
  29.             , DEFAULT_LOGIN_URL_1
  30.             , "/security/verifyCode"
  31.             , "/security/sendMailVerifyCode"
  32.             , "/security/sendPhoneVerifyCode"
  33.             , "/web/webLogin/test"
  34.             , "/web/webLogin/test2"
  35.             , "/web/img/**"
  36.     };
  37.     public static final List<String> REQUEST_RUL_WHITE_LIST = Arrays.asList(REQUEST_RUL_WHITE_S);
  38.     public static final List<String> REQUEST_IP_WHITE_LIST = Arrays.asList(
  39.             "192.168.1.6"
  40.             , "192.168.1.2"
  41.             , "127.0.0.1"
  42.     );
  43. }
  1. 验证码工具类
点击查看代码 
  1. package com.xiaostudy.common.utils;
  3. import javax.imageio.ImageIO;
  4. import java.awt.*;
  5. import java.awt.geom.AffineTransform;
  6. import java.awt.image.BufferedImage;
  7. import java.io.File;
  8. import java.io.FileOutputStream;
  9. import java.io.IOException;
  10. import java.io.OutputStream;
  11. import java.util.Arrays;
  12. import java.util.Map;
  13. import java.util.Random;
  14. import java.util.concurrent.ConcurrentHashMap;
  15. import java.util.regex.Matcher;
  16. import java.util.regex.Pattern;
  18. public final class VerifyCodeUtils {
  20.     //使用到Algerian字体，系统里没有的话需要安装字体，字体只显示大写，去掉了1,0,i,o几个容易混淆的字符
  21.     public static final String VERIFY_CODES = "1234567890ABCDEFGHIJKLMNPQRSTUVWXYZ";
  22.     private static Random random = new Random();
  24.     private VerifyCodeUtils() {
  25.     }
  27.     public static final String EMAIL_REGEX = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
  29.     public static boolean isEMail(String email) {
  30.         Pattern regex = Pattern.compile(EMAIL_REGEX);
  31.         Matcher matcher = regex.matcher(email);
  32.         return matcher.matches();
  33.     }
  35.     /**
  36.      * 使用系统默认字符源生成验证码
  37.      */
  38.     public static String generateVerifyCode(int verifySize) {
  39.         return generateVerifyCode(verifySize, VERIFY_CODES);
  40.     }
  42.     /**
  43.      * 使用指定源生成验证码
  44.      */
  45.     public static String generateVerifyCode(int verifySize, String sources) {
  46.         if (sources == null || sources.length() == 0) {
  47.             sources = VERIFY_CODES;
  48.         }
  49.         int codesLen = sources.length();
  50.         Random rand = new Random(System.currentTimeMillis());
  51.         StringBuilder verifyCode = new StringBuilder(verifySize);
  52.         for (int i = 0; i < verifySize; i++) {
  53.             verifyCode.append(sources.charAt(rand.nextInt(codesLen - 1)));
  54.         }
  55.         return verifyCode.toString();
  56.     }
  58.     /**
  59.      * 生成随机验证码文件,并返回验证码值
  60.      */
  61.     public static String outputVerifyImage(int w, int h, File outputFile, int verifySize) throws IOException {
  62.         String verifyCode = generateVerifyCode(verifySize);
  63.         outputImage(w, h, outputFile, verifyCode);
  64.         return verifyCode;
  65.     }
  67.     /**
  68.      * 输出随机验证码图片流,并返回验证码值
  69.      */
  70.     public static String outputVerifyImage(int w, int h, OutputStream os, int verifySize) throws IOException {
  71.         String verifyCode = generateVerifyCode(verifySize);
  72.         outputImage(w, h, os, verifyCode);
  73.         return verifyCode;
  74.     }
  76.     /**
  77.      * 生成指定验证码图像文件
  78.      */
  79.     public static void outputImage(int w, int h, File outputFile, String code) throws IOException {
  80.         if (outputFile == null) {
  81.             return;
  82.         }
  83.         File dir = outputFile.getParentFile();
  84.         if (!dir.exists()) {
  85.             dir.mkdirs();
  86.         }
  87.         outputFile.createNewFile();
  88.         FileOutputStream fos = new FileOutputStream(outputFile);
  89.         outputImage(w, h, fos, code);
  90.         fos.close();
  91.     }
  93.     /**
  94.      * 输出指定验证码图片流
  95.      */
  96.     public static void outputImage(int w, int h, OutputStream os, String code) throws IOException {
  97.         int verifySize = code.length();
  98.         BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
  99.         Random rand = new Random();
  100.         Graphics2D g2 = image.createGraphics();
  101.         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
  102.         Color[] colors = new Color[5];
  103.         Color[] colorSpaces = new Color[]{Color.WHITE, Color.CYAN,
  104.                 Color.GRAY, Color.LIGHT_GRAY, Color.MAGENTA, Color.ORANGE,
  105.                 Color.PINK, Color.YELLOW};
  106.         float[] fractions = new float[colors.length];
  107.         for (int i = 0; i < colors.length; i++) {
  108.             colors[i] = colorSpaces[rand.nextInt(colorSpaces.length)];
  109.             fractions[i] = rand.nextFloat();
  110.         }
  111.         Arrays.sort(fractions);
  113.         g2.setColor(Color.GRAY);// 设置边框色
  114.         g2.fillRect(0, 0, w, h);
  116.         Color c = getRandColor(200, 250);
  117.         g2.setColor(c);// 设置背景色
  118.         g2.fillRect(0, 2, w, h - 4);
  120.         //绘制干扰线
  121.         Random random = new Random();
  122.         g2.setColor(getRandColor(160, 200));// 设置线条的颜色
  123.         for (int i = 0; i < 20; i++) {
  124.             int x = random.nextInt(w - 1);
  125.             int y = random.nextInt(h - 1);
  126.             int xl = random.nextInt(6) + 1;
  127.             int yl = random.nextInt(12) + 1;
  128.             g2.drawLine(x, y, x + xl + 40, y + yl + 20);
  129.         }
  131.         // 添加噪点
  132.         float yawpRate = 0.05f;// 噪声率
  133.         int area = (int) (yawpRate * w * h);
  134.         for (int i = 0; i < area; i++) {
  135.             int x = random.nextInt(w);
  136.             int y = random.nextInt(h);
  137.             int rgb = getRandomIntColor();
  138.             image.setRGB(x, y, rgb);
  139.         }
  141.         shear(g2, w, h, c);// 使图片扭曲
  143.         g2.setColor(getRandColor(100, 160));
  144.         int fontSize = h - 4;
  145.         Font font = new Font("Algerian", Font.ITALIC, fontSize);
  146.         g2.setFont(font);
  147.         char[] chars = code.toCharArray();
  148.         for (int i = 0; i < verifySize; i++) {
  149.             AffineTransform affine = new AffineTransform();
  150.             affine.setToRotation(Math.PI / 4 * rand.nextDouble() * (rand.nextBoolean() ? 1 : -1), (w / verifySize) * i + fontSize / 2, h / 2);
  151.             g2.setTransform(affine);
  152.             g2.drawChars(chars, i, 1, ((w - 10) / verifySize) * i + 5, h / 2 + fontSize / 2 - 10);
  153.         }
  155.         g2.dispose();
  156.         ImageIO.write(image, "jpg", os);
  157.     }
  159.     private static Color getRandColor(int fc, int bc) {
  160.         if (fc > 255)
  161.             fc = 255;
  162.         if (bc > 255)
  163.             bc = 255;
  164.         int r = fc + random.nextInt(bc - fc);
  165.         int g = fc + random.nextInt(bc - fc);
  166.         int b = fc + random.nextInt(bc - fc);
  167.         return new Color(r, g, b);
  168.     }
  170.     private static int getRandomIntColor() {
  171.         int[] rgb = getRandomRgb();
  172.         int color = 0;
  173.         for (int c : rgb) {
  174.             color = color << 8;
  175.             color = color | c;
  176.         }
  177.         return color;
  178.     }
  180.     private static int[] getRandomRgb() {
  181.         int[] rgb = new int[3];
  182.         for (int i = 0; i < 3; i++) {
  183.             rgb[i] = random.nextInt(255);
  184.         }
  185.         return rgb;
  186.     }
  188.     private static void shear(Graphics g, int w1, int h1, Color color) {
  189.         shearX(g, w1, h1, color);
  190.         shearY(g, w1, h1, color);
  191.     }
  193.     private static void shearX(Graphics g, int w1, int h1, Color color) {
  195.         int period = random.nextInt(2);
  197.         boolean borderGap = true;
  198.         int frames = 1;
  199.         int phase = random.nextInt(2);
  201.         for (int i = 0; i < h1; i++) {
  202.             double d = (double) (period >> 1)
  203.                     * Math.sin((double) i / (double) period
  204.                     + (6.2831853071795862D * (double) phase)
  205.                     / (double) frames);
  206.             g.copyArea(0, i, w1, 1, (int) d, 0);
  207.             if (borderGap) {
  208.                 g.setColor(color);
  209.                 g.drawLine((int) d, i, 0, i);
  210.                 g.drawLine((int) d + w1, i, w1, i);
  211.             }
  212.         }
  214.     }
  216.     private static void shearY(Graphics g, int w1, int h1, Color color) {
  218.         int period = random.nextInt(40) + 10;
  220.         boolean borderGap = true;
  221.         int frames = 20;
  222.         int phase = 7;
  223.         for (int i = 0; i < w1; i++) {
  224.             double d = (double) (period >> 1)
  225.                     * Math.sin((double) i / (double) period
  226.                     + (6.2831853071795862D * (double) phase)
  227.                     / (double) frames);
  228.             g.copyArea(i, 0, 1, h1, 0, (int) d);
  229.             if (borderGap) {
  230.                 g.setColor(color);
  231.                 g.drawLine(i, (int) d, i, 0);
  232.                 g.drawLine(i, (int) d + h1, i, h1);
  233.             }
  235.         }
  237.     }
  239. }

  1. 解密工具类

点击查看代码 
  1. package com.xiaostudy.common.utils;
  3. import javax.crypto.*;
  4. import javax.crypto.spec.DESedeKeySpec;
  5. import javax.crypto.spec.IvParameterSpec;
  6. import java.nio.charset.Charset;
  7. import java.nio.charset.StandardCharsets;
  8. import java.security.InvalidAlgorithmParameterException;
  9. import java.security.InvalidKeyException;
  10. import java.security.Key;
  11. import java.security.NoSuchAlgorithmException;
  12. import java.security.spec.InvalidKeySpecException;
  14. public class DESUtils {
  15.     /**
  16.      * 用户名称密码加密，密钥
  17.      */
  18.     private static final String SECRET_KEY = "mwPZ7ISbC!ox6@7cP*^…5@%$)2*V";
  19.     // 向量
  20.     private static final String IV = "mwPZ7C!n";
  21.     // 加解密统一使用的编码方式
  22.     private static final Charset encoding = StandardCharsets.UTF_8;
  24.     /**
  25.      * 3DES解密
  26.      *
  27.      * @param encryptText 加密文本
  28.      * @return
  29.      * @throws Exception
  30.      */
  31.     public static String decode(String encryptText) throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException {
  32.         DESedeKeySpec spec = new DESedeKeySpec(SECRET_KEY.getBytes());
  33.         SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
  34.         Key deskey = keyfactory.generateSecret(spec);
  35.         Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
  36.         IvParameterSpec ips = new IvParameterSpec(IV.getBytes());
  37.         cipher.init(Cipher.DECRYPT_MODE, deskey, ips);
  38.         byte[] decryptData = cipher.doFinal(hexToBytes(encryptText));
  39.         return new String(decryptData, encoding);
  40.     }
  42.     public static byte[] hexToBytes(String hex) {
  43.         hex = hex.length() % 2 != 0 ? "0" + hex : hex;
  45.         byte[] b = new byte[hex.length() / 2];
  46.         for (int i = 0; i < b.length; i++) {
  47.             int index = i * 2;
  48.             int v = Integer.parseInt(hex.substring(index, index + 2), 16);
  49.             b[i] = (byte) v;
  50.         }
  51.         return b;
  52.     }
  53. }

4. 网关Gateway

1. 创建Security

  1. 创建操作



  2. 父模块添加子模块

  1. <module>security</module>
  1. 修改pom.xml







点击查看代码 
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>com.xiaostudy</groupId>
  7.         <artifactId>SpringCloud202208</artifactId>
  8.         <version>1.0-SNAPSHOT</version>
  9.         <relativePath>../pom.xml</relativePath>
  10.     </parent>
  11.     <groupId>com.xiaostudy</groupId>
  12.     <artifactId>security</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>security</name>
  15.     <description>security</description>
  17.     <dependencies>
  18.         <dependency>
  19.             <groupId>org.springframework.boot</groupId>
  20.             <artifactId>spring-boot-starter-data-jpa</artifactId>
  21.         </dependency>
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter-security</artifactId>
  25.         </dependency>
  27.         <!--集成响应式web框架-->
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-webflux</artifactId>
  31.         </dependency>
  33.         <!-- druid数据源驱动 -->
  34.         <dependency>
  35.             <groupId>com.alibaba</groupId>
  36.             <artifactId>druid-spring-boot-starter</artifactId>
  37.             <version>1.2.1</version>
  38.         </dependency>
  40.         <!--AOP-->
  41.         <dependency>
  42.             <groupId>org.aspectj</groupId>
  43.             <artifactId>aspectjweaver</artifactId>
  44.         </dependency>
  45.         <!--动态切换数据源用到-->
  46.         <dependency>
  47.             <groupId>org.springframework.boot</groupId>
  48.             <artifactId>spring-boot-starter-data-jpa</artifactId>
  49.         </dependency>
  50.         <dependency>
  51.             <groupId>mysql</groupId>
  52.             <artifactId>mysql-connector-java</artifactId>
  53.         </dependency>
  54.         <dependency>
  55.             <groupId>org.mybatis.spring.boot</groupId>
  56.             <artifactId>mybatis-spring-boot-starter</artifactId>
  57.             <version>2.1.2</version>
  58.         </dependency>
  60.         <!-- JWT Token验证机制 -->
  61.         <dependency>
  62.             <groupId>com.auth0</groupId>
  63.             <artifactId>java-jwt</artifactId>
  64.             <version>3.13.0</version>
  65.         </dependency>
  66.         <dependency>
  67.             <groupId>io.jsonwebtoken</groupId>
  68.             <artifactId>jjwt</artifactId>
  69.             <version>0.9.0</version>
  70.         </dependency>
  72.         <!--邮箱依赖-->
  73.         <dependency>
  74.             <groupId>org.springframework.boot</groupId>
  75.             <artifactId>spring-boot-starter-mail</artifactId>
  76.         </dependency>
  78.         <!--SpringBoot中集成了jasypt在一定程度上保证密码的安全-->
  79.         <dependency>
  80.             <groupId>com.github.ulisesbocchio</groupId>
  81.             <artifactId>jasypt-spring-boot-starter</artifactId>
  82.             <version>2.1.1</version>
  83.         </dependency>
  85.         <dependency>
  86.             <groupId>com.xiaostudy</groupId>
  87.             <artifactId>common</artifactId>
  88.             <version>1.0-SNAPSHOT</version>
  89.         </dependency>
  91.         <dependency>
  92.             <groupId>org.springframework.boot</groupId>
  93.             <artifactId>spring-boot-starter-test</artifactId>
  94.             <scope>test</scope>
  95.         </dependency>
  96.         <dependency>
  97.             <groupId>org.springframework.security</groupId>
  98.             <artifactId>spring-security-test</artifactId>
  99.             <scope>test</scope>
  100.         </dependency>
  101.     </dependencies>
  103.     <build>
  104.         <plugins>
  105.             <plugin>
  106.                 <groupId>org.springframework.boot</groupId>
  107.                 <artifactId>spring-boot-maven-plugin</artifactId>
  108.             </plugin>
  109.         </plugins>
  110.     </build>
  112. </project>
  1. 修改配置文件application.properties

点击查看代码 
  1. spring:
  2.   datasource:
  3.     type: com.alibaba.druid.pool.DruidDataSource
  4.     druid:
  5.       driverClassName: com.mysql.cj.jdbc.Driver
  6.       url: jdbc:mysql://127.0.0.1:3306/test1?useUnicode=true&characterEncoding=utf8
  7.       username: root
  8.       password: 密码
  9.     druid2:
  10.       driverClassName: com.mysql.cj.jdbc.Driver
  11.       url: jdbc:mysql://127.0.0.1:3306/test2?useUnicode=true&characterEncoding=utf8
  12.       username: root
  13.       password: 密码
  14.   mail:
  15.     default-encoding: UTF-8
  16.     # 阿里云发送服务器地址
  17.     host: smtp.mxhichina.com
  18.     #    port: 25                      #端口号
  19.     # 发送人地址
  20.     username: liwei@xiaostudy.com
  21.     # 密码
  22.     password: ENC(密码加密后的字符串)
  23.     properties:
  24.       mail:
  25.         smtp:
  26.           starttls:
  27.             enable: true
  28.             required: true
  29.           auth: true
  30.           socketFactory:
  31.             class: javax.net.ssl.SSLSocketFactory
  32.             port: 465
  33. jasypt:
  34.   encryptor:
  35.     password: 密钥
  36. mybatis:
  37.   configuration:
  38.     # 下划线转驼峰
  39.     map-underscore-to-camel-case: true
  40.   # 注册映射文件
  41.   mapper-locations: mapper/*Mapper.xml
  42.   # 注册实体类别名
  43.   type-aliases-package: com.xiaostudy.security.entity
  45. session:
  46.   # session过期时间，单位秒
  47.   timeout: 1800
  48. #  timeout: 30
  1. 查询用户的实体类、service、mapper
用户实体类 
  1. package com.xiaostudy.security.entity;
  3. public class UserEentity {
  5.     private String username;
  6.     private String password;
  7.     private String role;
  8.     private Integer errorCount;
  9.     private String url;
  10.     private String email;
  12.     public String getUsername() {
  13.         return username;
  14.     }
  16.     public void setUsername(String username) {
  17.         this.username = username;
  18.     }
  20.     public String getPassword() {
  21.         return password;
  22.     }
  24.     public void setPassword(String password) {
  25.         this.password = password;
  26.     }
  28.     public String getRole() {
  29.         return role;
  30.     }
  32.     public void setRole(String role) {
  33.         this.role = role;
  34.     }
  36.     public Integer getErrorCount() {
  37.         return errorCount;
  38.     }
  40.     public void setErrorCount(Integer errorCount) {
  41.         this.errorCount = errorCount;
  42.     }
  44.     public String getUrl() {
  45.         return url;
  46.     }
  48.     public void setUrl(String url) {
  49.         this.url = url;
  50.     }
  52.     public String getEmail() {
  53.         return email;
  54.     }
  56.     public void setEmail(String email) {
  57.         this.email = email;
  58.     }
  59. }
Mapper接口 
  1. package com.xiaostudy.security.mapper;
  3. import com.xiaostudy.security.entity.UserEentity;
  4. import org.apache.ibatis.annotations.Mapper;
  5. import org.apache.ibatis.annotations.Param;
  7. import java.util.List;
  9. @Mapper
  10. public interface UserMapper {
  12.     public List<UserEentity> selectUserAll();
  13.     public UserEentity selectUserByName(@Param("name") String username);
  14.     public UserEentity selectUserByEmail(@Param("email") String email);
  15.     public UserEentity selectUserByPhone(@Param("phone") String phone);
  17.     public int loginPasswordErrorAdd(@Param("name")String username);
  18.     public int loginPasswordErrorClean(@Param("name")String username);
  19. }
Mapper.xml文件 
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.xiaostudy.security.mapper.UserMapper">
  5.     <select id="selectUserAll" resultType="com.xiaostudy.security.entity.UserEentity">
  6.         SELECT username, password, role, error_count FROM `user`
  7.     </select>
  9.     <select id="selectUserByName" resultType="com.xiaostudy.security.entity.UserEentity">
  10.         SELECT username, password, role, error_count, url, email FROM `user` where username = #{name}
  11.     </select>
  13.     <select id="selectUserByEmail" resultType="com.xiaostudy.security.entity.UserEentity">
  14.         SELECT username, password, role, error_count, url, email FROM `user` where email = #{email}
  15.     </select>
  17.     <select id="selectUserByPhone" resultType="com.xiaostudy.security.entity.UserEentity">
  18.         SELECT username, password, role, error_count, url, email, phone FROM `user` where phone = #{phone}
  19.     </select>
  21.     <update id="loginPasswordErrorAdd" parameterType="java.lang.String">
  22.         update `user` set error_count = error_count + 1 where username = #{name}
  23.     </update>
  25.     <update id="loginPasswordErrorClean" parameterType="java.lang.String">
  26.         update `user` set error_count = 0 where username = #{name}
  27.     </update>
  29. </mapper>
service 
  1. package com.xiaostudy.security.service;
  3. import com.xiaostudy.security.entity.UserEentity;
  5. import java.util.List;
  7. public interface UserService {
  9.     public List<UserEentity> selectUserAll();
  10.     public UserEentity selectUserByNameDb1(String username);
  11.     public UserEentity selectUserByEmailDb1(String email);
  12.     public UserEentity selectUserByPhoneDb1(String phone);
  13.     public UserEentity selectUserByNameDb2(String username);
  15.     public boolean loginPasswordErrorAdd(String username);
  16.     public boolean loginPasswordErrorClean(String username);
  17. }
service实现类 
  1. package com.xiaostudy.security.service.impl;
  3. import com.xiaostudy.security.datasources.annotation.DataSource;
  4. import com.xiaostudy.security.datasources.enums.DataSourceNameEnum;
  5. import com.xiaostudy.security.entity.UserEentity;
  6. import com.xiaostudy.security.mapper.UserMapper;
  7. import com.xiaostudy.security.service.UserService;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Service;
  10. import org.springframework.transaction.annotation.Transactional;
  12. import java.util.List;
  14. @Service
  15. public class UserServiceImpl implements UserService {
  17.     @Autowired
  18.     private UserMapper userMapper;
  20.     @Override
  21.     public List<UserEentity> selectUserAll() {
  22.         return userMapper.selectUserAll();
  23.     }
  25.     @DataSource(name = DataSourceNameEnum.FIRST)
  26.     @Override
  27.     public UserEentity selectUserByNameDb1(String username) {
  28.         return userMapper.selectUserByName(username);
  29.     }
  31.     @DataSource(name = DataSourceNameEnum.FIRST)
  32.     @Override
  33.     public UserEentity selectUserByEmailDb1(String email) {
  34.         return userMapper.selectUserByEmail(email);
  35.     }
  36.     @DataSource(name = DataSourceNameEnum.FIRST)
  37.     @Override
  38.     public UserEentity selectUserByPhoneDb1(String phone) {
  39.         return userMapper.selectUserByPhone(phone);
  40.     }
  42.     @DataSource(name = DataSourceNameEnum.SECOND)
  43.     @Override
  44.     public UserEentity selectUserByNameDb2(String username) {
  45.         return userMapper.selectUserByName(username);
  46.     }
  48.     @DataSource(name = DataSourceNameEnum.FIRST)
  49.     @Override
  50.     public boolean loginPasswordErrorAdd(String username) {
  51.         int i = userMapper.loginPasswordErrorAdd(username);
  52.         return 0 != i;
  53.     }
  55.     @Transactional(rollbackFor = Exception.class)
  56.     @Override
  57.     public boolean loginPasswordErrorClean(String username) {
  58.         int i = userMapper.loginPasswordErrorClean(username);
  59.         return 0 != i;
  60.     }
  61. }
多数据源枚举 
  1. package com.xiaostudy.security.datasources.enums;
  3. /**
  4.  * 多数据源配置数据源枚举
  5.  */
  6. public enum DataSourceNameEnum {
  7.     FIRST("first")
  8.     ,SECOND("second");
  10.     private String name;
  12.     DataSourceNameEnum(String name) {
  13.         this.name = name;
  14.     }
  16.     public String getName() {
  17.         return name;
  18.     }
  19. }
动态数据源路由 
  1. package com.xiaostudy.security.datasources;
  3. import com.xiaostudy.security.datasources.enums.DataSourceNameEnum;
  4. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
  6. import javax.sql.DataSource;
  7. import java.util.Map;
  9. /**
  10.  * 动态数据源路由
  11.  */
  12. public class DynamicDataSource extends AbstractRoutingDataSource {
  13.     private static final ThreadLocal<DataSourceNameEnum> contextHolder = new ThreadLocal<>();
  15.     public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
  16.         super.setDefaultTargetDataSource(defaultTargetDataSource);
  17.         super.setTargetDataSources(targetDataSources);
  18.         super.afterPropertiesSet();
  19.     }
  21.     @Override
  22.     protected Object determineCurrentLookupKey() {
  23.         return this.getDataSource();
  24.     }
  26.     public static void setDataSource(DataSourceNameEnum dataSource) {
  27.         contextHolder.set(dataSource);
  28.     }
  30.     public static DataSourceNameEnum getDataSource() {
  31.         return contextHolder.get();
  32.     }
  34.     public static void clearDataSource() {
  35.         contextHolder.remove();
  36.     }
  38. }
多数据源注解 
  1. package com.xiaostudy.security.datasources.annotation;
  3. import com.xiaostudy.security.datasources.enums.DataSourceNameEnum;
  5. import java.lang.annotation.*;
  7. /**
  8.  * 多数据源注解
  9.  */
  10. @Target(ElementType.METHOD)
  11. @Retention(RetentionPolicy.RUNTIME)
  12. @Documented
  13. public @interface DataSource {
  14.     DataSourceNameEnum name();
  15. }
多数据源AOP类 
  1. package com.xiaostudy.security.datasources.aop;
  3. import com.xiaostudy.security.datasources.DynamicDataSource;
  4. import com.xiaostudy.security.datasources.annotation.DataSource;
  5. import com.xiaostudy.security.datasources.enums.DataSourceNameEnum;
  6. import org.aspectj.lang.ProceedingJoinPoint;
  7. import org.aspectj.lang.annotation.Around;
  8. import org.aspectj.lang.annotation.Aspect;
  9. import org.aspectj.lang.annotation.Pointcut;
  10. import org.aspectj.lang.reflect.MethodSignature;
  11. import org.slf4j.Logger;
  12. import org.slf4j.LoggerFactory;
  13. import org.springframework.core.Ordered;
  14. import org.springframework.stereotype.Component;
  16. import java.lang.reflect.Method;
  18. /**
  19.  * 多数据源，切面处理类
  20.  */
  21. @Aspect
  22. @Component
  23. public class DataSourceAspect implements Ordered {
  24.     private static final Logger LOGGER = LoggerFactory.getLogger(DataSourceAspect.class);
  26.     /**
  27.      * 针对上面注解做切面拦截
  28.      */
  29.     @Pointcut("@annotation(com.xiaostudy.security.datasources.annotation.DataSource)")
  30. //    @Pointcut("execution(* com.xiaostudy.security.datasources..*.*(..))")
  31.     public void dataSourcePointCut() {}
  33.     @Around("dataSourcePointCut()")
  34.     public Object around(ProceedingJoinPoint point) throws Throwable {
  35.         MethodSignature signature = (MethodSignature) point.getSignature();
  36.         Method method = signature.getMethod();
  37.         DataSource dataSource = method.getAnnotation(DataSource.class);
  38.         if(dataSource == null){
  39.             //如果没有注解,使用默认数据源
  40.             DynamicDataSource.setDataSource(DataSourceNameEnum.FIRST);
  41.         }else {
  42.             //根据注解中设置的数据源名称,选择对应的数据源
  43.             DynamicDataSource.setDataSource(dataSource.name());
  44.             LOGGER.info("set datasource is " + dataSource.name().getName());
  45.         }
  47.         try {
  48.             return point.proceed();
  49.         } finally {
  50.             //清除数据源配置
  51.             DynamicDataSource.clearDataSource();
  52.         }
  53.     }
  55.     @Override
  56.     public int getOrder() {
  57.         return 1;
  58.     }
  59. }
多数据配置类 
  1. package com.xiaostudy.security.datasources.config;
  3. import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
  4. import com.xiaostudy.security.datasources.DynamicDataSource;
  5. import com.xiaostudy.security.datasources.enums.DataSourceNameEnum;
  6. import org.springframework.boot.context.properties.ConfigurationProperties;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  9. import org.springframework.context.annotation.Primary;
  11. import javax.sql.DataSource;
  12. import java.util.HashMap;
  13. import java.util.Map;
  15. /**
  16.  * 多数据源配置类
  17.  */
  18. @Configuration
  19. public class DynamicDataSourceConfig {
  21.     //如果ioc容器中,同一个类型有多个bean,则bean的名称为方法的名称
  22.     @Bean("firstDataSource")
  23.     @ConfigurationProperties("spring.datasource.druid")
  24.     public DataSource firstDataSource() {
  25.         return DruidDataSourceBuilder.create().build();
  26.     }
  28.     @Bean("secondDataSource")
  29.     @ConfigurationProperties("spring.datasource.druid2")
  30.     public DataSource secondDataSource() {
  31.         return DruidDataSourceBuilder.create().build();
  32.     }
  34.     @Bean
  35.     @Primary
  36.     public DynamicDataSource dataSource(DataSource firstDataSource, DataSource secondDataSource) {
  37.         Map<Object, Object> targetDataSources = new HashMap<>();
  38.         targetDataSources.put(DataSourceNameEnum.FIRST, firstDataSource);
  39.         targetDataSources.put(DataSourceNameEnum.SECOND, secondDataSource);
  40.         return new DynamicDataSource(firstDataSource, targetDataSources);
  41.     }
  42. }

2. Security登陆配置

  1. 配置密码加密、解析器

点击查看代码 
  1. package com.xiaostudy.security.config;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  6. import org.springframework.security.crypto.password.PasswordEncoder;
  8. @Configuration
  9. public class BeanConfig {
  11.     //配置密码加密、解析器
  12.     @Bean
  13.     public PasswordEncoder passwordEncoder() {
  14.         return new BCryptPasswordEncoder();
  15.     }
  16. }
  1. IP工具类
点击查看代码 
  1. package com.xiaostudy.security.utils;
  3. import org.springframework.http.HttpHeaders;
  4. import org.springframework.http.server.reactive.ServerHttpRequest;
  6. public final class IpUtils {
  8.     private IpUtils() {
  9.     }
  11.     public static final String UNKNOWN = "unknown";
  12.     public static final String LOCAL_IPV6 = "0:0:0:0:0:0:0:1";
  13.     public static final String LOCAL_IPV4 = "127.0.0.1";
  15.     public static String getIpAddr(ServerHttpRequest request) {
  16.         HttpHeaders headers = request.getHeaders();
  17.         String ip = headers.getFirst("x-forwarded-for");
  18.         if (ip != null && ip.length() != 0 && !UNKNOWN.equalsIgnoreCase(ip) && ip.indexOf(",") != -1) {
  19.             // 多次反向代理后会有多个ip值，第一个ip才是真实ip
  20.             ip = ip.split(",")[0];
  21.         }
  22.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
  23.             ip = headers.getFirst("Proxy-Client-IP");
  24.         }
  25.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
  26.             ip = headers.getFirst("WL-Proxy-Client-IP");
  27.         }
  28.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
  29.             ip = headers.getFirst("HTTP_CLIENT_IP");
  30.         }
  31.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
  32.             ip = headers.getFirst("HTTP_X_FORWARDED_FOR");
  33.         }
  34.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
  35.             ip = headers.getFirst("X-Real-IP");
  36.         }
  37.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
  38.             ip = request.getRemoteAddress().getAddress().getHostAddress();
  39.         }
  40.         return LOCAL_IPV6.equals(ip) ? LOCAL_IPV4 : ip;
  41.     }
  42. }
  1. Token工具类
点击查看代码 
  1. package com.xiaostudy.security.utils;
  3. import com.xiaostudy.common.utils.StringUtils;
  4. import io.jsonwebtoken.*;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.http.HttpHeaders;
  8. import org.springframework.util.ObjectUtils;
  10. import java.util.Date;
  11. import java.util.HashMap;
  12. import java.util.Map;
  13. import java.util.concurrent.ConcurrentHashMap;
  14. import java.util.concurrent.ExecutorService;
  16. public class JwtTokenUtils {
  17.     private static final Logger LOGGER = LoggerFactory.getLogger(JwtTokenUtils.class);
  18.     // 有效时间，单位毫秒
  19. //    public static final long EXPIRATION = 30 * 1000L;
  20.     public static final long EXPIRATION = 40 * 60 * 1000L;
  21.     public static final long TOKEN_REFRESH_DATE = 15 * 1000L;
  22.     //    public static final long TOKEN_REFRESH_DATE = 20 * 60 * 1000L;
  23.     public static final String TOKEN_REFRESH_DATE_STR = "TOKEN_REFRESH_DATE";
  24.     //JWT密钥
  25.     public static final String SECRET = "123654";
  27.     public static final String BASIC_EMPTY = "Basic ";
  28.     public static final String BASIC_EMPTY_ = "Basic%20";
  29.     public static final String AUTHENTICATION = "Authorization";
  30.     public static final String COOKIE_AUTHENTICATION_BASIC_EMPTY_ = "Authorization=Basic%20";
  31.     public static final String COOKIE_SPLIT = ";";
  32.     public static final String COOKIE = "Cookie";
  33.     public static final String TOKEN_CREATED = "created";
  34.     public static final String TOKEN_REFRESH_FLAG = "RefreshTokenFlag";
  35.     public static final String TOKEN_REFRESH_YES = "1";
  36.     public static final String TOKEN_REFRESH_NO = "0";
  38.     public static final String VERIFY_CODE = "verifyCode";
  39.     public static final String COOKIE_VERIFY_CODE = "verifyCode=";
  40.     public static final String USER_NAME = "userName";
  41.     public static final String PASS_WORD = "passWord";
  43.     public static final int LOGIN_ERROR_COUNT = 5;
  45.     /**
  46.      * 生成token令牌
  47.      *
  48.      * @param username 用户
  49.      * @param payloads 令牌中携带的附加信息
  50.      * @return 令token牌
  51.      */
  52.     public static String generateToken(String username, Map<String, Object> payloads) {
  53.         int payloadSizes = payloads == null ? 0 : payloads.size();
  55.         Map<String, Object> claims = new HashMap<>(payloadSizes + 2);
  56.         claims.put(Claims.SUBJECT, username);
  57.         claims.put(TOKEN_CREATED, new Date());
  59.         if (payloadSizes > 0) {
  60.             claims.putAll(payloads);
  61.         }
  63.         return generateToken(claims);
  64.     }
  66.     /**
  67.      * 从claims生成令牌,如果看不懂就看谁调用它
  68.      *
  69.      * @param claims 数据声明
  70.      * @return 令牌
  71.      */
  72.     private static String generateToken(Map<String, Object> claims) {
  73.         Date expirationDate = new Date(System.currentTimeMillis() + EXPIRATION);
  74.         // 刷新token时间
  75.         claims.put(JwtTokenUtils.TOKEN_REFRESH_DATE_STR, new Date(System.currentTimeMillis() + TOKEN_REFRESH_DATE));
  76.         return Jwts.builder().setClaims(claims)
  77.                 .setExpiration(expirationDate)
  78.                 .signWith(SignatureAlgorithm.HS512, SECRET)
  79.                 .compact();
  80.     }
  82.     /**
  83.      * 判断令牌是否过期
  84.      *
  85.      * @param token 令牌
  86.      * @return 是否过期
  87.      */
  88.     public static boolean isTokenExpired(String token) {
  89.         if (ObjectUtils.isEmpty(token)) {
  90.             return false;
  91.         }
  92.         try {
  93.             Claims claims = getClaimsFromToken(token);
  94.             if (ObjectUtils.isEmpty(claims)) {
  95.                 return false;
  96.             }
  97.             Date expiration = claims.getExpiration();
  98.             return new Date().before(expiration);
  99.         } catch (Exception e) {
  100.             LOGGER.error("判断令牌是否过期异常", e);
  101.             return false;
  102.         }
  103.     }
  105.     /**
  106.      * 从令牌中获取用户名
  107.      *
  108.      * @param token 令牌
  109.      * @return 用户名
  110.      */
  111.     public static String getUsernameFromToken(String token) {
  112.         if (ObjectUtils.isEmpty(token)) {
  113.             return null;
  114.         }
  115.         String username;
  116.         try {
  117.             Claims claims = getClaimsFromToken(token);
  118.             username = claims.getSubject();
  119.         } catch (Exception e) {
  120.             LOGGER.error("从令牌中获取用户名异常1", e);
  121.             username = null;
  122.         }
  123.         return username;
  124.     }
  126.     /**
  127.      * 刷新令牌
  128.      *
  129.      * @param token 原令牌
  130.      * @return 新令牌
  131.      */
  132.     public static String refreshToken(String token) {
  133.         if (ObjectUtils.isEmpty(token)) {
  134.             return null;
  135.         }
  136.         String refreshedToken;
  137.         try {
  138.             Claims claims = getClaimsFromToken(token);
  139.             claims.put(TOKEN_CREATED, new Date());
  140.             refreshedToken = generateToken(claims);
  141.         } catch (Exception e) {
  142.             LOGGER.error("刷新令牌异常", e);
  143.             refreshedToken = null;
  144.         }
  145.         return refreshedToken;
  146.     }
  148.     /**
  149.      * 从令牌中获取数据声明,如果看不懂就看谁调用它
  150.      *
  151.      * @param token 令牌
  152.      * @return 数据声明
  153.      */
  154.     private static Claims getClaimsFromToken(String token) {
  155.         Claims claims;
  156.         try {
  157.             JwtParser jwtParser = Jwts.parser().setSigningKey(SECRET);
  158.             Jws<Claims> claimsJws = jwtParser.parseClaimsJws(token);
  159.             claims = claimsJws.getBody();
  160.         } catch (Exception e) {
  161.             LOGGER.error("从令牌中获取数据声明异常");
  162. //            LOGGER.error("从令牌中获取数据声明异常", e);
  163.             claims = null;
  164.         }
  165.         return claims;
  166.     }
  168.     public static String getCookieUsername(HttpHeaders headers) {
  169.         String authentication = getCookieAuthentication(headers);
  170.         if (ObjectUtils.isEmpty(authentication)) {
  171.             return null;
  172.         }
  173.         return getUsernameFromToken(authentication);
  174.     }
  176.     public static String getCookieAuthentication(HttpHeaders headers) {
  177.         String authentication = headers.getFirst(JwtTokenUtils.AUTHENTICATION);
  178.         if (ObjectUtils.isEmpty(authentication)) {
  179.             String cookieStr = headers.getFirst(JwtTokenUtils.COOKIE);
  180.             if (!ObjectUtils.isEmpty(cookieStr)) {
  181.                 cookieStr = cookieStr.replaceAll(StringUtils.BLANK, StringUtils.EMPTY);
  182.                 String[] cookies = cookieStr.split(JwtTokenUtils.COOKIE_SPLIT);
  183.                 for (String c : cookies) {
  184.                     if (!ObjectUtils.isEmpty(c) && c.startsWith(JwtTokenUtils.COOKIE_AUTHENTICATION_BASIC_EMPTY_)) {
  185.                         authentication = c.replaceFirst(JwtTokenUtils.COOKIE_AUTHENTICATION_BASIC_EMPTY_, StringUtils.EMPTY);
  186.                         break;
  187.                     }
  188.                 }
  189.             }
  190.         }
  191.         if (!ObjectUtils.isEmpty(authentication)) {
  192.             if (authentication.startsWith(JwtTokenUtils.BASIC_EMPTY_)) {
  193.                 authentication = authentication.replaceFirst(JwtTokenUtils.BASIC_EMPTY_, StringUtils.EMPTY);
  194.             } else if (authentication.startsWith(JwtTokenUtils.BASIC_EMPTY)) {
  195.                 authentication = authentication.replaceFirst(JwtTokenUtils.BASIC_EMPTY, StringUtils.EMPTY);
  196.             }
  197.         }
  198.         return authentication;
  199.     }
  201.     public static String getCookieVerifyCode(HttpHeaders headers) {
  202.         String cookieStr = headers.getFirst(JwtTokenUtils.COOKIE);
  203.         if (ObjectUtils.isEmpty(cookieStr)) {
  204.             return null;
  205.         }
  206.         cookieStr = cookieStr.replaceAll(StringUtils.BLANK, StringUtils.EMPTY);
  207.         String[] cookies = cookieStr.split(JwtTokenUtils.COOKIE_SPLIT);
  208.         for (String c : cookies) {
  209.             if (!ObjectUtils.isEmpty(c) && c.startsWith(JwtTokenUtils.COOKIE_VERIFY_CODE)) {
  210.                 return c.replaceFirst(JwtTokenUtils.COOKIE_VERIFY_CODE, StringUtils.EMPTY);
  211.             }
  212.         }
  213.         return null;
  214.     }
  216.     private static final Map<String, Date> LOG_TOKEN_DATE_MAP = new ConcurrentHashMap<>();
  217.     private static final ExecutorService POOL = java.util.concurrent.Executors.newFixedThreadPool(2);
  219.     public static boolean checkTokenAndRefreshToken(HttpHeaders headers, String authentication) {
  220.         boolean tokenExpired = false;
  221.         Date now = new Date();
  222.         if (ObjectUtils.isEmpty(authentication)) {
  223.             return tokenExpired;
  224.         }
  225.         try {
  226.             Claims claims = getClaimsFromToken(authentication);
  227.             if (ObjectUtils.isEmpty(claims)) {
  228.                 return tokenExpired;
  229.             }
  230.             Date expiration = claims.getExpiration();
  231.             if (now.after(expiration)) {
  232.                 return tokenExpired;
  233.             }
  234.             Date expirationTokenRefresh = claims.get(TOKEN_REFRESH_DATE_STR, Date.class);
  235.             tokenExpired = now.before(expirationTokenRefresh);
  236.         } catch (Exception e) {
  237.             LOGGER.error("判断令牌是否过期异常", e);
  238.             return false;
  239.         }
  241.         headers.set(TOKEN_REFRESH_FLAG, TOKEN_REFRESH_NO);
  242.         if (tokenExpired) {
  243.             // token有效
  244.             POOL.execute(new LogTokenRunnable(LOG_TOKEN_DATE_MAP, authentication, now));
  245.             return tokenExpired;
  246.         } else {
  247.             Date date = LOG_TOKEN_DATE_MAP.get(authentication);
  248.             if (ObjectUtils.isEmpty(date)) {
  249.                 return tokenExpired;
  250.             }
  251.             Date expirationDate = new Date(date.getTime() + EXPIRATION);
  252.             if (expirationDate.before(now)) {
  253.                 return tokenExpired;
  254.             }
  255.             String refreshToken = refreshToken(authentication);
  256.             if (ObjectUtils.isEmpty(refreshToken)) {
  257.                 return tokenExpired;
  258.             }
  259.             headers.set(TOKEN_REFRESH_FLAG, TOKEN_REFRESH_YES);
  260.             headers.set(AUTHENTICATION, BASIC_EMPTY + refreshToken);
  261.             return true;
  262.         }
  263.     }
  265.     // 记录token最后请求时间
  266.     private static class LogTokenRunnable implements Runnable {
  267.         private Map<String, Date> map;
  268.         private String token;
  269.         private Date now;
  271.         LogTokenRunnable(Map<String, Date> map, String token, Date now) {
  272.             this.map = map;
  273.             this.token = token;
  274.             this.now = now;
  275.         }
  277.         @Override
  278.         public void run() {
  279.             if (null == map || ObjectUtils.isEmpty(token) || ObjectUtils.isEmpty(now)) {
  280.                 return;
  281.             }
  282.             Date date = map.get(token);
  283.             if (ObjectUtils.isEmpty(date) || now.after(date)) {
  284.                 map.put(token, now);
  285.             }
  286.         }
  287.     }
  288. }
  1. 自定义UsernamePasswordAuthenticationToken
点击查看代码 
  1. package com.xiaostudy.security.entity;
  3. import com.xiaostudy.common.utils.StringUtils;
  4. import com.xiaostudy.security.utils.JwtTokenUtils;
  5. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  6. import org.springframework.util.MultiValueMap;
  8. public class MyUserDetails extends UsernamePasswordAuthenticationToken {
  9.     private static final long serialVersionUID = 1L;
  10.     private String username;
  11.     private String password;
  12.     private String verifyCode;
  13.     private String ipAddr;
  14.     private String email;
  16.     public MyUserDetails(String username, String password, String verifyCode, String ipAddr, String email) {
  17.         super(username, password);
  18.         this.username = username;
  19.         this.password = password;
  20.         this.verifyCode = verifyCode;
  21.         this.ipAddr = ipAddr;
  22.         this.email = email;
  23.     }
  25.     public static MyUserDetails unauthenticated(String username, String password, String verifyCode, String ipAddr, String email) {
  26.         return new MyUserDetails(username, password, verifyCode, ipAddr, email);
  27.     }
  29.     public static MyUserDetails unauthenticated(String username, String password) {
  30.         return new MyUserDetails(username, password, null, null, null);
  31.     }
  33.     public static MyUserDetails createAuthentication(MultiValueMap<String, String> data, String ipAddr) {
  34.         String username = data.getFirst(JwtTokenUtils.USER_NAME);
  35.         String password = data.getFirst(JwtTokenUtils.PASS_WORD);
  36.         String verifyCode = data.getFirst(JwtTokenUtils.VERIFY_CODE);
  37.         String email = data.getFirst(StringUtils.EMAIL);
  38.         return MyUserDetails.unauthenticated(username, password, verifyCode, ipAddr, email);
  39.     }
  41.     public String getUsername() {
  42.         return username;
  43.     }
  45.     public void setUsername(String username) {
  46.         this.username = username;
  47.     }
  49.     public String getPassword() {
  50.         return password;
  51.     }
  53.     public void setPassword(String password) {
  54.         this.password = password;
  55.     }
  57.     public String getVerifyCode() {
  58.         return verifyCode;
  59.     }
  61.     public void setVerifyCode(String verifyCode) {
  62.         this.verifyCode = verifyCode;
  63.     }
  65.     public String getIpAddr() {
  66.         return ipAddr;
  67.     }
  69.     public void setIpAddr(String ipAddr) {
  70.         this.ipAddr = ipAddr;
  71.     }
  73.     public String getEmail() {
  74.         return email;
  75.     }
  77.     public void setEmail(String email) {
  78.         this.email = email;
  79.     }
  81. }
  1. 自定义ServerFormLoginAuthenticationConverter，从表单获取参数转成自定义UsernamePasswordAuthenticationToken类
点击查看代码 
  1. package com.xiaostudy.security.config;
  3. import com.xiaostudy.common.utils.StringUtils;
  4. import com.xiaostudy.security.entity.MyUserDetails;
  5. import com.xiaostudy.security.utils.IpUtils;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  8. import org.springframework.context.annotation.Configuration;
  9. import org.springframework.security.core.Authentication;
  10. import org.springframework.security.web.server.authentication.ServerFormLoginAuthenticationConverter;
  11. import org.springframework.web.server.ServerWebExchange;
  12. import reactor.core.publisher.Mono;
  14. // 请求认证过滤器，从表单获取参数，不用security的默认参数名username、password
  15. @Configuration
  16. public class MyServerFormLoginAuthenticationConverter extends ServerFormLoginAuthenticationConverter {
  17.     private static final Logger LOGGER = LoggerFactory.getLogger(MyServerFormLoginAuthenticationConverter.class);
  19.     @Override
  20.     public Mono<Authentication> convert(ServerWebExchange exchange) {
  21.         LOGGER.info("请求认证过滤器----MyServerFormLoginAuthenticationConverter.........");
  22.         String uri = exchange.getRequest().getURI().getPath();
  23.         if (StringUtils.DEFAULT_LOGIN_URL_1.equals(uri)) {  //登录操作才对body做特殊操作，其他请求直接调用原有请求
  24.             return this.apply(exchange);
  25.         } else { //非登录操作，基本不用在网关里读取body，默认方法就行
  26.             return super.convert(exchange);
  27.         }
  28.     }
  30.     @Override
  31.     public Mono<Authentication> apply(ServerWebExchange exchange) {
  32.         final String ipAddr = IpUtils.getIpAddr(exchange.getRequest());
  33.         return exchange.getFormData().map((data) -> MyUserDetails.createAuthentication(data, ipAddr));
  34.     }
  36. }
  1. 自定义登陆处理
点击查看代码 
  1. package com.xiaostudy.security.config;
  3. import com.xiaostudy.common.redis.RedisService;
  4. import com.xiaostudy.common.utils.DESUtils;
  5. import com.xiaostudy.common.utils.StringUtils;
  6. import com.xiaostudy.security.entity.MyUserDetails;
  7. import com.xiaostudy.security.entity.UserEentity;
  8. import com.xiaostudy.security.service.UserService;
  9. import com.xiaostudy.security.utils.JwtTokenUtils;
  10. import org.slf4j.Logger;
  11. import org.slf4j.LoggerFactory;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.context.annotation.Configuration;
  14. import org.springframework.security.authentication.*;
  15. import org.springframework.security.core.Authentication;
  16. import org.springframework.security.core.context.SecurityContextHolder;
  17. import org.springframework.security.core.userdetails.User;
  18. import org.springframework.security.core.userdetails.UserDetails;
  19. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  20. import org.springframework.security.crypto.password.PasswordEncoder;
  21. import org.springframework.util.ObjectUtils;
  22. import reactor.core.publisher.Mono;
  24. // 自定义处理登陆
  25. @Configuration
  26. public class MyReactiveAuthenticationManager implements ReactiveAuthenticationManager {
  27.     private static final Logger LOGGER = LoggerFactory.getLogger(MyReactiveAuthenticationManager.class);
  29.     /**
  30.      * @see BeanConfig#passwordEncoder()
  31.      */
  32.     @Autowired
  33.     private PasswordEncoder passwordEncoder;
  35.     @Autowired
  36.     private UserService userService;
  38.     @Autowired
  39.     private RedisService redisService;
  41.     @Override
  42.     public Mono<Authentication> authenticate(Authentication authentication) {
  43.         LOGGER.info("自定义处理登陆----MyReactiveAuthenticationManager.........");
  44.         //获取输入的用户名
  45.         String username = authentication.getName();
  46.         //获取输入的明文
  47.         String rawPassword = (String) authentication.getCredentials();
  48.         MyUserDetails myUserDetails = null;
  49.         String verifyCode = null;
  50.         String ipAddr = null;
  51.         if (authentication instanceof MyUserDetails) {
  52.             myUserDetails = (MyUserDetails) authentication;
  53.             username = myUserDetails.getUsername();
  54.             rawPassword = myUserDetails.getPassword();
  55.             verifyCode = myUserDetails.getVerifyCode();
  56.             ipAddr = myUserDetails.getIpAddr();
  57.             String email = myUserDetails.getEmail();
  58.             if (!ObjectUtils.isEmpty(email)) {
  59.                 return this.authenticateEmail(email, verifyCode, ipAddr);
  60.             }
  61.         } else if (authentication instanceof UsernamePasswordAuthenticationToken) {
  62.             UsernamePasswordAuthenticationToken authenticationToken = (UsernamePasswordAuthenticationToken) authentication;
  63.             // TODO 不是的话要处理
  64.             username = (String) authenticationToken.getPrincipal();
  65.             rawPassword = (String) authenticationToken.getCredentials();
  66.             myUserDetails = MyUserDetails.unauthenticated(username, rawPassword);
  67.         }
  68.         if (null != ipAddr) {
  69.             if (ObjectUtils.isEmpty(verifyCode)) {
  70.                 return Mono.error(new DisabledException("请填写验证码!"));
  71.             }
  72.             String s = redisService.getCacheObject(ipAddr);
  73.             if (ObjectUtils.isEmpty(s)) {
  74.                 return Mono.error(new DisabledException("验证码过期，请重新获取验证码!"));
  75.             }
  76.             if (!s.equals(verifyCode) && !s.equals(verifyCode.toLowerCase())) {
  77.                 return Mono.error(new DisabledException("验证码有误，请重新输入!"));
  78.             }
  79.         }
  81.         try {
  82.             if (!ObjectUtils.isEmpty(username)) {
  83.                 username = DESUtils.decode(username);
  84.             }
  85.             if (!ObjectUtils.isEmpty(rawPassword)) {
  86.                 rawPassword = DESUtils.decode(rawPassword);
  87.             }
  88.         } catch (Exception e) {
  89.             LOGGER.error("解密用户密码出错!");
  90.             return Mono.error(new DisabledException("解密用户密码出错!"));
  91.         }
  93.         if ((ObjectUtils.isEmpty(username) || ObjectUtils.isEmpty(rawPassword))) {
  94.             return Mono.error(new DisabledException("请填写用户名或密码"));
  95.         }
  97.         UserDetails user = null;
  98.         UserEentity userEentity = null;
  99.         try {
  100.             userEentity = userService.selectUserByNameDb1(username);
  101.             if (ObjectUtils.isEmpty(userEentity)) {
  102.                 return Mono.error(new UsernameNotFoundException("系统无此用户，请先注册！"));
  103.             }
  104.             Integer errorCount = userEentity.getErrorCount();
  105.             if (!ObjectUtils.isEmpty(errorCount) && JwtTokenUtils.LOGIN_ERROR_COUNT == errorCount) {
  106.                 return Mono.error(new DisabledException("登陆异常次数大于" + JwtTokenUtils.LOGIN_ERROR_COUNT));
  107.             }
  108.             User.UserBuilder userBuilder = User.builder().passwordEncoder(passwordEncoder::encode)
  109.                     .username(userEentity.getUsername())
  110.                     .password(userEentity.getPassword());
  111.             String role = userEentity.getRole();
  112.             if (!ObjectUtils.isEmpty(role)) {
  113.                 userBuilder.roles(role);
  114.             }
  115.             String url = userEentity.getUrl();
  116.             if (!ObjectUtils.isEmpty(url)) {
  117.                 userBuilder.authorities(url);
  118.             }
  119.             if (ObjectUtils.isEmpty(role) && ObjectUtils.isEmpty(url)) {
  120.                 userBuilder.authorities(StringUtils.DEFAULT_INDEX_HTML_1);
  121.             }
  122.             user = userBuilder.build();
  123.         } catch (UsernameNotFoundException ufe) {
  124.             return Mono.error(ufe);
  125.         }
  127.         if (!user.isEnabled()) {
  128.             return Mono.error(new DisabledException("该账户已被禁用，请联系管理员"));
  129.         } else if (!user.isAccountNonLocked()) {
  130.             return Mono.error(new LockedException("该账号已被锁定"));
  131.         } else if (!user.isAccountNonExpired()) {
  132.             return Mono.error(new AccountExpiredException("该账号已过期，请联系管理员"));
  133.         } else if (!user.isCredentialsNonExpired()) {
  134.             return Mono.error(new CredentialsExpiredException("该账户的登录凭证已过期，请重新登录"));
  135.         }
  137.         //验证密码
  138.         if (!passwordEncoder.matches(rawPassword, user.getPassword())) {
  139.             userService.loginPasswordErrorAdd(username);
  140.             return Mono.error(new BadCredentialsException("密码错误:" + username));
  141.         }
  143.         final Authentication authentication1 = new UsernamePasswordAuthenticationToken(user, rawPassword, user.getAuthorities());
  145.         // TODO WebFlux方式默认没有放到context中，需要手动放入
  146.         SecurityContextHolder.getContext().setAuthentication(authentication1);
  148.         return Mono.just(authentication1);
  149.     }
  151.     /**
  152.      * 自定义处理登陆----邮箱登陆
  153.      *
  154.      * @param email
  155.      * @param verifyCode
  156.      * @param ipAddr
  157.      * @return reactor.core.publisher.Mono<org.springframework.security.core.Authentication>
  158.      * @author liwei
  159.      */
  160.     public Mono<Authentication> authenticateEmail(String email, String verifyCode, String ipAddr) {
  161.         LOGGER.info("自定义处理登陆----邮箱登陆.........");
  162.         if (ObjectUtils.isEmpty(ipAddr)) {
  163.             return Mono.error(new DisabledException("系统处理邮箱出错!"));
  164.         }
  165.         if (ObjectUtils.isEmpty(verifyCode)) {
  166.             return Mono.error(new DisabledException("请填写验证码!"));
  167.         }
  168.         String s = redisService.getCacheObject(ipAddr);
  169.         if (ObjectUtils.isEmpty(s)) {
  170.             return Mono.error(new DisabledException("验证码过期，请重新获取验证码!"));
  171.         }
  172.         if (!s.equals(verifyCode) && !s.equals(verifyCode.toLowerCase())) {
  173.             return Mono.error(new DisabledException("验证码有误，请重新输入!"));
  174.         }
  175.         redisService.deleteObject(ipAddr);
  177.         try {
  178.             if (!ObjectUtils.isEmpty(email)) {
  179.                 email = DESUtils.decode(email);
  180.             }
  181.         } catch (Exception e) {
  182.             LOGGER.error("解密邮箱出错!");
  183.             return Mono.error(new DisabledException("解密邮箱出错!"));
  184.         }
  186.         if (ObjectUtils.isEmpty(email)) {
  187.             return Mono.error(new DisabledException("请填写邮箱"));
  188.         }
  190.         UserDetails user;
  191.         UserEentity userEentity;
  192.         try {
  193.             userEentity = userService.selectUserByEmailDb1(email);
  194.             if (ObjectUtils.isEmpty(userEentity)) {
  195.                 return Mono.error(new DisabledException("系统无此邮箱，不支持邮箱注册"));
  196.             }
  197.             User.UserBuilder userBuilder = User.builder().passwordEncoder(passwordEncoder::encode)
  198.                     .username(userEentity.getUsername())
  199.                     .password(userEentity.getPassword());
  200.             String role = userEentity.getRole();
  201.             if (!ObjectUtils.isEmpty(role)) {
  202.                 userBuilder.roles(role);
  203.             }
  204.             String url = userEentity.getUrl();
  205.             if (!ObjectUtils.isEmpty(url)) {
  206.                 userBuilder.authorities(url);
  207.             }
  208.             if (ObjectUtils.isEmpty(role) && ObjectUtils.isEmpty(url)) {
  209.                 userBuilder.authorities(StringUtils.DEFAULT_INDEX_HTML_1);
  210.             }
  211.             user = userBuilder.build();
  212.         } catch (UsernameNotFoundException ufe) {
  213.             return Mono.error(ufe);
  214.         }
  215.         if (!user.isEnabled()) {
  216.             return Mono.error(new DisabledException("该账户已被禁用，请联系管理员"));
  217.         } else if (!user.isAccountNonLocked()) {
  218.             return Mono.error(new LockedException("该账号已被锁定"));
  219.         } else if (!user.isAccountNonExpired()) {
  220.             return Mono.error(new AccountExpiredException("该账号已过期，请联系管理员"));
  221.         } else if (!user.isCredentialsNonExpired()) {
  222.             return Mono.error(new CredentialsExpiredException("该账户的登录凭证已过期，请重新登录"));
  223.         }
  225.         userService.loginPasswordErrorAdd(userEentity.getUsername());
  227.         final Authentication authentication1 = new UsernamePasswordAuthenticationToken(user, userEentity.getPassword(), user.getAuthorities());
  229.         // TODO WebFlux方式默认没有放到context中，需要手动放入
  230.         SecurityContextHolder.getContext().setAuthentication(authentication1);
  232.         return Mono.just(authentication1);
  233.     }
  235. }
  1. 自定义鉴权处理
点击查看代码 
  1. package com.xiaostudy.security.config;
  3. import com.xiaostudy.common.utils.StringUtils;
  4. import com.xiaostudy.security.entity.UserEentity;
  5. import com.xiaostudy.security.service.UserService;
  6. import com.xiaostudy.security.utils.IpUtils;
  7. import com.xiaostudy.security.utils.JwtTokenUtils;
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.context.annotation.Configuration;
  12. import org.springframework.http.HttpHeaders;
  13. import org.springframework.http.HttpMethod;
  14. import org.springframework.http.server.reactive.ServerHttpRequest;
  15. import org.springframework.security.authentication.CredentialsExpiredException;
  16. import org.springframework.security.authentication.DisabledException;
  17. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  18. import org.springframework.security.authorization.AuthorizationDecision;
  19. import org.springframework.security.authorization.ReactiveAuthorizationManager;
  20. import org.springframework.security.core.Authentication;
  21. import org.springframework.security.core.userdetails.User;
  22. import org.springframework.security.core.userdetails.UserDetails;
  23. import org.springframework.security.web.server.authorization.AuthorizationContext;
  24. import org.springframework.util.ObjectUtils;
  25. import org.springframework.web.server.ServerWebExchange;
  26. import reactor.core.publisher.Mono;
  28. // 自定义的鉴权服务，通过鉴权的才能继续访问某个请求。反应式授权管理器接口
  29. @Configuration
  30. public class MyReactiveAuthorizationManager implements ReactiveAuthorizationManager<AuthorizationContext> {
  31.     private static final Logger LOGGER = LoggerFactory.getLogger(MyReactiveAuthorizationManager.class);
  32.     @Autowired
  33.     private UserService userService;
  35.     /**
  36.      * 实现权限验证判断
  37.      */
  38.     @Override
  39.     public Mono<AuthorizationDecision> check(Mono<Authentication> authenticationMono, AuthorizationContext authorizationContext) {
  40.         LOGGER.info("---自定义的鉴权服务---MyReactiveAuthorizationManager---");
  41.         ServerWebExchange exchange = authorizationContext.getExchange();
  42.         ServerHttpRequest request = exchange.getRequest();
  43.         String ipAddr = IpUtils.getIpAddr(request);
  44.         if (!StringUtils.REQUEST_IP_WHITE_LIST.contains(ipAddr)) {
  45.             LOGGER.debug("---自定义的鉴权服务---MyReactiveAuthorizationManager---非白名单IP不可访问");
  46.             return Mono.error(new DisabledException(String.format("IP：%s，非白名单，不可访问" , ipAddr)));
  47.         }
  48.         // option请求默认放行，解决跨域问题
  49.         if (request.getMethod().equals(HttpMethod.OPTIONS)) {
  50.             LOGGER.debug("---自定义的鉴权服务---MyReactiveAuthorizationManager---跨域放行");
  51.             return Mono.just(new AuthorizationDecision(true));
  52.         }
  53.         //请求资源
  54.         final String url = request.getURI().getPath();
  55.         // 白名单放行，不用登陆就可以访问
  56.         for (String requestRulWhite : StringUtils.REQUEST_RUL_WHITE_S) {
  57.             if ((requestRulWhite.endsWith(StringUtils.WILDCARD) && url.startsWith(requestRulWhite.substring(0, requestRulWhite.length() - StringUtils.WILDCARD.length())))
  58.                     || requestRulWhite.equals(url)) {
  59.                 LOGGER.debug("---自定义的鉴权服务---MyReactiveAuthorizationManager---白名单url放行");
  60.                 return Mono.just(new AuthorizationDecision(true));
  61.             }
  62.         }
  63.         final HttpHeaders requestHeaders = request.getHeaders();
  64.         final HttpHeaders responseHeaders = exchange.getResponse().getHeaders();
  65.         String authentication = JwtTokenUtils.getCookieAuthentication(requestHeaders);
  66.         boolean tokenExpired = JwtTokenUtils.checkTokenAndRefreshToken(responseHeaders, authentication);
  67.         if (!tokenExpired) {
  68.             LOGGER.warn("token过期");
  69.             return Mono.error(new CredentialsExpiredException("token过期，请重新登陆"));
  70.         } else {
  71.             LOGGER.debug("token有效");
  73.         }
  74.         return authenticationMono.map(auth ->
  75.                 new AuthorizationDecision(this.checkAuthorities(auth, url))
  76.         ).defaultIfEmpty(
  77.                 new AuthorizationDecision(defaultIsToken(authentication, url))
  78. //                new AuthorizationDecision(false)
  79.         );
  80.     }
  82.     // 只有token情况下处理
  83.     private boolean defaultIsToken(String token, String url) {
  84.         if (ObjectUtils.isEmpty(token)) {
  85.             return false;
  86.         }
  87.         String username = JwtTokenUtils.getUsernameFromToken(token);
  88.         return this.checkAuthorities(username, url);
  89.     }
  91.     //权限校验，指定的url需要对应的角色，不指定的登陆成功就可以访问
  92.     private boolean checkAuthorities(Authentication auth, String url) {
  93.         if (ObjectUtils.isEmpty(auth)) {
  94.             return false;
  95.         }
  96.         UserDetails principal = (UserDetails) auth.getPrincipal();
  97.         if (ObjectUtils.isEmpty(principal)) {
  98.             return false;
  99.         }
  100.         return this.checkAuthorities(principal.getUsername(), url);
  101.     }
  103.     //权限校验，指定的url需要对应的角色，不指定的登陆成功就可以访问
  104.     private boolean checkAuthorities(String username, String url) {
  105.         LOGGER.info("---自定义的鉴权服务---url:{}---" , url);
  106.         if (ObjectUtils.isEmpty(username)) {
  107.             return false;
  108.         }
  109.         UserEentity userEentity = userService.selectUserByNameDb1(username);
  110.         if (ObjectUtils.isEmpty(userEentity)) {
  111.             return false;
  112.         }
  113.         LOGGER.info("访问的URI是：{}，用户信息：{}" , url, username);
  114.         String role = userEentity.getRole();
  115.         if ("/web/webLogin/user1".equals(url)) {
  116.             return "3".equals(role);
  117.         }
  118.         if ("/web/webLogin/useri".equals(url)) {
  119.             return "k".equals(role);
  120.         }
  121.         if ("/web/webLogin/usera".equals(url)) {
  122.             return "c".equals(role) || "k".equals(role);
  123.         }
  125.         // 非指定接口，只要登陆都有权限
  126.         return true;
  127.     }
  128. }
  1. 自定义处理未登陆无访问权限的返回结果
点击查看代码 
  1. package com.xiaostudy.security.handler;
  3. import io.netty.util.CharsetUtil;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.core.io.buffer.DataBuffer;
  7. import org.springframework.http.HttpStatus;
  8. import org.springframework.http.MediaType;
  9. import org.springframework.http.server.reactive.ServerHttpResponse;
  10. import org.springframework.security.core.AuthenticationException;
  11. import org.springframework.security.web.server.authentication.HttpBasicServerAuthenticationEntryPoint;
  12. import org.springframework.stereotype.Component;
  13. import org.springframework.web.server.ServerWebExchange;
  14. import reactor.core.publisher.Flux;
  15. import reactor.core.publisher.Mono;
  17. // 未登陆无访问权限的返回结果
  18. @Component
  19. public class AuthEntryPointExceptionHandler extends HttpBasicServerAuthenticationEntryPoint {
  20.     private static final Logger LOGGER = LoggerFactory.getLogger(AuthEntryPointExceptionHandler.class);
  22.     @Override
  23.     public Mono<Void> commence(ServerWebExchange exchange, AuthenticationException e) {
  24.         LOGGER.info("未登陆无访问权限---{}--AuthEntryPointExceptionHandler.........", exchange.getRequest().getURI().getPath());
  25.         ServerHttpResponse response = exchange.getResponse();
  26.         response.setStatusCode(HttpStatus.OK);
  27.         String jsonString = "{\"code\":200,\"status\":4,\"msg\":\"您未登陆或登陆已过期，请先登陆！\"}";
  28.         response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
  29.         DataBuffer wrap = exchange.getResponse().bufferFactory().wrap(jsonString.getBytes(CharsetUtil.UTF_8));
  30.         return exchange.getResponse().writeWith(Flux.just(wrap));
  31.     }
  32. }
  1. 自定义登出成功后操作
点击查看代码 
  1. package com.xiaostudy.security.handler;
  3. import com.xiaostudy.common.utils.StringUtils;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.security.core.Authentication;
  8. import org.springframework.security.web.server.DefaultServerRedirectStrategy;
  9. import org.springframework.security.web.server.ServerRedirectStrategy;
  10. import org.springframework.security.web.server.WebFilterExchange;
  11. import org.springframework.security.web.server.authentication.logout.ServerLogoutSuccessHandler;
  12. import reactor.core.publisher.Mono;
  14. import java.net.URI;
  16. // 成功登出实现类
  17. @Configuration
  18. public class MyRedirectServerLogoutSuccessHandler implements ServerLogoutSuccessHandler {
  19.     private static final Logger LOGGER = LoggerFactory.getLogger(MyRedirectServerLogoutSuccessHandler.class);
  20.     private URI logoutSuccessUrl = URI.create(StringUtils.DEFAULT_LOGOUT_SUCCESS_URL);
  21.     private ServerRedirectStrategy redirectStrategy = new DefaultServerRedirectStrategy();
  23.     public MyRedirectServerLogoutSuccessHandler() {
  24.     }
  26.     @Override
  27.     public Mono<Void> onLogoutSuccess(WebFilterExchange exchange, Authentication authentication) {
  28.         LOGGER.info("成功登出实现类----MyRedirectServerLogoutSuccessHandler.........");
  29.         return this.redirectStrategy.sendRedirect(exchange.getExchange(), this.logoutSuccessUrl);
  30.     }
  32. }
  1. 自定义处理登录失败或其他异常访问调用
点击查看代码 
  1. package com.xiaostudy.security.handler;
  3. import io.netty.util.CharsetUtil;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.core.io.buffer.DataBuffer;
  7. import org.springframework.http.MediaType;
  8. import org.springframework.http.server.reactive.ServerHttpResponse;
  9. import org.springframework.security.authentication.*;
  10. import org.springframework.security.core.AuthenticationException;
  11. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  12. import org.springframework.security.web.server.WebFilterExchange;
  13. import org.springframework.security.web.server.authentication.ServerAuthenticationFailureHandler;
  14. import org.springframework.stereotype.Component;
  15. import reactor.core.publisher.Mono;
  17. // 登录失败或其他异常访问调用的自定义处理类
  18. @Component
  19. public class MyServerAuthenticationFailureHandler implements ServerAuthenticationFailureHandler {
  20.     private static final Logger LOGGER = LoggerFactory.getLogger(MyServerAuthenticationFailureHandler.class);
  22.     private static final String USER_NOT_EXISTS = "用户不存在，请先注册！";
  24.     private static final String USERNAME_PASSWORD_ERROR = "用户或密码错误！";
  26.     private static final String USER_LOCKED = "用户锁定！";
  27.     private static final String USER_ACCOUNT_EXPIRED = "账号已过期！";
  28.     private static final String USER_CREDENTIALS_EXPIRE = "票据已过期！";
  30.     @Override
  31.     public Mono<Void> onAuthenticationFailure(WebFilterExchange webFilterExchange, AuthenticationException exception) {
  32.         LOGGER.info("登录失败时调用的自定义处理类----MyServerAuthenticationFailureHandler.........");
  33.         ServerHttpResponse response = webFilterExchange.getExchange().getResponse();
  34.         response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
  35.         if (exception instanceof UsernameNotFoundException) {
  36.             return writeErrorMessage(response, USER_NOT_EXISTS);
  37.         } else if (exception instanceof BadCredentialsException) {
  38.             return writeErrorMessage(response, USERNAME_PASSWORD_ERROR);
  39.         } else if (exception instanceof LockedException) {
  40.             return writeErrorMessage(response, USER_LOCKED);
  41.         } else if (exception instanceof AccountExpiredException) {
  42.             return writeErrorMessage(response, USER_ACCOUNT_EXPIRED);
  43.         } else if (exception instanceof CredentialsExpiredException) {
  44.             return writeErrorMessage(response, USER_CREDENTIALS_EXPIRE);
  45.         } else if (exception instanceof DisabledException) {
  46.             return writeErrorMessage(response, "不可访问，" + exception.getMessage());
  47.         }
  48.         return writeErrorMessage(response, exception.getMessage());
  49.     }
  51.     private Mono<Void> writeErrorMessage(ServerHttpResponse response, String message) {
  52.         String jsonString = String.format("{\"code\":200,\"status\":1,\"msg\":\"%s\"}", message);
  53.         DataBuffer buffer = response.bufferFactory().wrap(jsonString.getBytes(CharsetUtil.UTF_8));
  54.         return response.writeWith(Mono.just(buffer));
  55.     }
  56. }
  1. 自定义处理登陆成功后返回结果
点击查看代码 
  1. package com.xiaostudy.security.handler;
  3. import com.xiaostudy.security.utils.JwtTokenUtils;
  4. import io.netty.util.CharsetUtil;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.core.io.buffer.DataBuffer;
  8. import org.springframework.http.HttpHeaders;
  9. import org.springframework.http.HttpStatus;
  10. import org.springframework.http.MediaType;
  11. import org.springframework.http.server.reactive.ServerHttpResponse;
  12. import org.springframework.security.core.Authentication;
  13. import org.springframework.security.core.userdetails.UserDetails;
  14. import org.springframework.security.web.server.WebFilterExchange;
  15. import org.springframework.security.web.server.authentication.ServerAuthenticationSuccessHandler;
  16. import org.springframework.stereotype.Component;
  17. import reactor.core.publisher.Mono;
  19. // 登录成功时调用的自定义处理类
  20. @Component
  21. public class MyServerAuthenticationSuccessHandler implements ServerAuthenticationSuccessHandler {
  22.     private static final Logger LOGGER = LoggerFactory.getLogger(MyServerAuthenticationSuccessHandler.class);
  24.     @Override
  25.     public Mono<Void> onAuthenticationSuccess(WebFilterExchange webFilterExchange, Authentication authentication) {
  26.         LOGGER.info("登录成功时调用的自定义处理类----MyServerAuthenticationSuccessHandler.........");
  27.         // 登录成功后可以放入一些参数到session中
  28.         ServerHttpResponse response = webFilterExchange.getExchange().getResponse();
  29.         response.setStatusCode(HttpStatus.OK);
  30.         HttpHeaders headers = response.getHeaders();
  32.         UserDetails principal = (UserDetails) authentication.getPrincipal();
  33.         String username = principal.getUsername();
  35.         String token = JwtTokenUtils.generateToken(username, null);
  36.         headers.set(JwtTokenUtils.AUTHENTICATION, String.format("%s%s", JwtTokenUtils.BASIC_EMPTY, token));
  38.         String jsonString = String.format("{\"code\":200,\"status\":0,\"msg\":\"%s您登陆成功！\"}", username);
  39.         headers.setContentType(MediaType.APPLICATION_JSON);
  40.         DataBuffer buffer = response.bufferFactory().wrap(jsonString.getBytes(CharsetUtil.UTF_8));
  41.         return response.writeWith(Mono.just(buffer));
  42.     }
  43. }
  1. 自定义处理登陆后无权限访问返回结果
点击查看代码 
  1. package com.xiaostudy.security.handler;
  3. import com.xiaostudy.common.utils.StringUtils;
  4. import com.xiaostudy.security.utils.JwtTokenUtils;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.http.HttpStatus;
  8. import org.springframework.http.MediaType;
  9. import org.springframework.http.server.reactive.ServerHttpResponse;
  10. import org.springframework.security.access.AccessDeniedException;
  11. import org.springframework.security.core.Authentication;
  12. import org.springframework.security.core.context.SecurityContextHolder;
  13. import org.springframework.security.core.userdetails.UserDetails;
  14. import org.springframework.security.web.server.authorization.ServerAccessDeniedHandler;
  15. import org.springframework.stereotype.Component;
  16. import org.springframework.util.ObjectUtils;
  17. import org.springframework.web.server.ServerWebExchange;
  18. import reactor.core.publisher.Flux;
  19. import reactor.core.publisher.Mono;
  21. import java.nio.charset.StandardCharsets;
  23. // 无权限访问被拒绝时的自定义处理器。如不自己处理，默认返回403错误<br>
  24. @Component
  25. public class MyWebFluxServerAccessDeniedHandler implements ServerAccessDeniedHandler {
  26.     private static final Logger LOGGER = LoggerFactory.getLogger(MyWebFluxServerAccessDeniedHandler.class);
  28.     @Override
  29.     public Mono<Void> handle(ServerWebExchange exchange, AccessDeniedException e) {
  30.         LOGGER.info("无权限访问被拒绝时的自定义处理器----MyAccessDeniedHandlerWebFlux.........");
  31.         String username = JwtTokenUtils.getCookieUsername(exchange.getRequest().getHeaders());
  32.         if (ObjectUtils.isEmpty(username)) {
  33.             Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
  34.             if (!ObjectUtils.isEmpty(authentication)) {
  35.                 UserDetails userDetails = (UserDetails) authentication.getPrincipal();
  36.                 if (!ObjectUtils.isEmpty(userDetails)) {
  37.                     username = userDetails.getUsername();
  38.                 }
  39.             }
  40.         }
  41.         if (null == username) {
  42.             username = StringUtils.EMPTY;
  43.         }
  45.         String jsonString = String.format("{\"code\":200,\"status\":3,\"msg\":\"%s您无此资源的访问权限！\"}" , username, exchange.getRequest().getURI().getPath());
  46.         ServerHttpResponse response = exchange.getResponse();
  47.         response.setStatusCode(HttpStatus.OK);
  48.         response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
  49.         return response.writeAndFlushWith(Flux.just(Flux.just(response.bufferFactory().wrap(jsonString.getBytes(StandardCharsets.UTF_8)))));
  50.     }
  51. }
  1. 重写存储认证信息，实时修改用户session的过期时间
点击查看代码 
  1. package com.xiaostudy.security.filter;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.beans.factory.annotation.Value;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.http.server.reactive.ServerHttpRequest;
  8. import org.springframework.security.core.context.SecurityContext;
  9. import org.springframework.security.web.server.context.WebSessionServerSecurityContextRepository;
  10. import org.springframework.web.server.ServerWebExchange;
  11. import reactor.core.publisher.Mono;
  13. import java.time.Duration;
  15. // 重写存储认证信息，修改session默认时效和更新会话时间
  16. @Configuration
  17. public class MyWebSessionServerSecurityContextRepository extends WebSessionServerSecurityContextRepository {
  18.     private static final Logger LOGGER = LoggerFactory.getLogger(MyWebSessionServerSecurityContextRepository.class);
  19.     @Value("${session.timeout}")
  20.     private Long timeout;
  22.     @Override
  23.     public Mono<Void> save(ServerWebExchange exchange, SecurityContext context) {
  24.         // 只有登陆时执行，并且在load()执行之后
  25.         LOGGER.info("存储认证信息---save---url：{}", exchange.getRequest().getURI().getPath());
  26.         return exchange.getSession()
  27.                 .doOnNext(session -> {
  28.                     if (context == null) {
  29.                         session.getAttributes().remove(super.DEFAULT_SPRING_SECURITY_CONTEXT_ATTR_NAME);
  30.                     } else {
  31.                         session.getAttributes().put(super.DEFAULT_SPRING_SECURITY_CONTEXT_ATTR_NAME, context);
  32.                         // 在这里设置过期时间 单位使用Duration类中的定义  有秒、分、天等
  33.                         session.setMaxIdleTime(Duration.ofSeconds(timeout));
  34.                     }
  35.                 })
  36.                 .flatMap(session -> session.changeSessionId());
  37.     }
  39.     @Override
  40.     public Mono<SecurityContext> load(ServerWebExchange exchange) {
  41.         ServerHttpRequest request = exchange.getRequest();
  42.         String url = request.getURI().getPath();
  43.         LOGGER.info("存储认证信息---load---url：{}", url);
  44.         return exchange.getSession().flatMap((session) -> {
  45.             SecurityContext context = session.getAttribute(super.DEFAULT_SPRING_SECURITY_CONTEXT_ATTR_NAME);
  46.             if (context == null) {
  47.                 session.getAttributes().remove(super.DEFAULT_SPRING_SECURITY_CONTEXT_ATTR_NAME);
  48.             } else {
  49.                 session.getAttributes().put(super.DEFAULT_SPRING_SECURITY_CONTEXT_ATTR_NAME, context);
  50.                 // 在这里设置过期时间 单位使用Duration类中的定义  有秒、分、天等
  51.                 session.setMaxIdleTime(Duration.ofSeconds(timeout));
  52.             }
  53.             return Mono.justOrEmpty(context);
  54.         });
  55.     }
  57. }
  1. 主要过滤配置类
点击查看代码 
  1. package com.xiaostudy.security.config;
  3. import com.xiaostudy.common.utils.StringUtils;
  4. import com.xiaostudy.security.filter.MyWebSessionServerSecurityContextRepository;
  5. import com.xiaostudy.security.handler.AuthEntryPointExceptionHandler;
  6. import com.xiaostudy.security.handler.MyServerAuthenticationFailureHandler;
  7. import com.xiaostudy.security.handler.MyServerAuthenticationSuccessHandler;
  8. import com.xiaostudy.security.handler.MyWebFluxServerAccessDeniedHandler;
  9. import org.slf4j.Logger;
  10. import org.slf4j.LoggerFactory;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.context.annotation.Bean;
  13. import org.springframework.context.annotation.Configuration;
  14. import org.springframework.http.HttpMethod;
  15. import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
  16. import org.springframework.security.config.web.server.ServerHttpSecurity;
  17. import org.springframework.security.web.server.SecurityWebFilterChain;
  18. import org.springframework.security.web.server.authentication.AuthenticationWebFilter;
  19. import org.springframework.security.web.server.authentication.logout.ServerLogoutSuccessHandler;
  20. import org.springframework.security.web.server.util.matcher.ServerWebExchangeMatchers;
  21. import org.springframework.web.server.WebFilter;
  23. import java.util.Iterator;
  25. @Configuration
  26. @EnableWebFluxSecurity
  27. public class SecurityWebFluxConfig {
  28.     private static final Logger LOG = LoggerFactory.getLogger(SecurityWebFluxConfig.class);
  30.     @Autowired
  31.     private MyReactiveAuthorizationManager reactiveAuthorizationManager;
  33.     @Autowired
  34.     private AuthEntryPointExceptionHandler serverAuthenticationEntryPoint;
  36.     @Autowired
  37.     private MyServerAuthenticationSuccessHandler myServerAuthenticationSuccessHandler;
  39.     @Autowired
  40.     private MyServerAuthenticationFailureHandler myServerAuthenticationFailureHandler;
  42.     @Autowired
  43.     private MyWebFluxServerAccessDeniedHandler myWebFluxServerAccessDeniedHandler;
  45.     @Autowired
  46.     private ServerLogoutSuccessHandler logoutSuccessHandler;
  47.     @Autowired
  48.     private MyWebSessionServerSecurityContextRepository myWebSessionServerSecurityContextRepository;
  49.     @Autowired
  50.     private MyServerFormLoginAuthenticationConverter myServerFormLoginAuthenticationConverter;
  51.     @Autowired
  52.     private MyReactiveAuthenticationManager myReactiveAuthenticationManager;
  54.     // 主要过滤配置类
  55.     @Bean
  56.     public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
  57.         LOG.info("加载security 权限配置....");
  58.         http
  59. //                .headers()
  60. //                .cors()
  61.                 // 关闭csrf
  62.                 .csrf().disable()
  63.                 // 存储认证信息，这里修改session时效
  64.                 .securityContextRepository(myWebSessionServerSecurityContextRepository)
  65.                 // 设置登陆地址，如果是前后端分离，就不用设置，前端处理。
  66.                 .formLogin().loginPage(StringUtils.DEFAULT_LOGOUT_HTML_1)
  67.                 // 登陆请求方式和接口
  68.                 .requiresAuthenticationMatcher(ServerWebExchangeMatchers.pathMatchers(HttpMethod.POST, StringUtils.DEFAULT_LOGIN_URL_1, StringUtils.DEFAULT_LOGIN_MAIL_URL_1))
  69.                 // 处理登陆
  70.                 .authenticationManager(myReactiveAuthenticationManager)
  71.                 // 登录成功handler
  72.                 .authenticationSuccessHandler(myServerAuthenticationSuccessHandler)
  73.                 // 登陆失败handler
  74.                 .authenticationFailureHandler(myServerAuthenticationFailureHandler)
  76.                 // 关闭默认登录验证
  77.                 .and().httpBasic().disable()
  79. //                .requestCache()
  81.                 // 登出，设置登出请求类型和URL
  82.                 .logout().requiresLogout(ServerWebExchangeMatchers.pathMatchers(HttpMethod.GET, StringUtils.DEFAULT_LOGOUT_URL_1))
  83.                 // 登出成功后自定义处理
  84.                 .logoutSuccessHandler(logoutSuccessHandler)
  86.                 // 未登陆无访问权限handler
  87.                 .and().exceptionHandling().authenticationEntryPoint(serverAuthenticationEntryPoint)
  88.                 // 登陆无访问权限
  89.                 .and().exceptionHandling().accessDeniedHandler(myWebFluxServerAccessDeniedHandler)
  91.                 // 自定义鉴权
  92. //                .and().authorizeExchange().pathMatchers(StringUtils.REQUEST_RUL_WHITE_S).permitAll()
  93.                 .and().authorizeExchange().anyExchange().access(reactiveAuthorizationManager)
  94. //                .anyExchange().authenticated()
  95.         ;
  96.         SecurityWebFilterChain chain = http.build();
  97.         Iterator<WebFilter> weIterable = chain.getWebFilters().toIterable().iterator();
  98.         while (weIterable.hasNext()) {
  99.             WebFilter f = weIterable.next();
  100.             if (f instanceof AuthenticationWebFilter) {
  101.                 AuthenticationWebFilter webFilter = (AuthenticationWebFilter) f;
  102.                 //将自定义的AuthenticationConverter添加到过滤器中
  103.                 webFilter.setServerAuthenticationConverter(myServerFormLoginAuthenticationConverter);
  104.             }
  105.         }
  106.         return chain;
  107.     }
  108. }

上面的图，验证码和解密工具类已经抽取到公共模块

  1. 邮箱实体类
点击查看代码 
  1. package com.xiaostudy.security.email;
  3. import java.io.File;
  5. public class MailEntity {
  6.     /**
  7.      * 主题
  8.      */
  9.     private String subject;
  10.     /**
  11.      * 内容
  12.      */
  13.     private String content;
  14.     /**
  15.      * 邮箱
  16.      */
  17.     private String toAccount;
  18.     /**
  19.      * 附件
  20.      */
  21.     private File attachmentFile;
  22.     /**
  23.      * 附件文件名
  24.      */
  25.     private String attachmentFileName;
  27.     public String getSubject() {
  28.         return subject;
  29.     }
  31.     public void setSubject(String subject) {
  32.         this.subject = subject;
  33.     }
  35.     public String getContent() {
  36.         return content;
  37.     }
  39.     public void setContent(String content) {
  40.         this.content = content;
  41.     }
  43.     public String getToAccount() {
  44.         return toAccount;
  45.     }
  47.     public void setToAccount(String toAccount) {
  48.         this.toAccount = toAccount;
  49.     }
  51.     public File getAttachmentFile() {
  52.         return attachmentFile;
  53.     }
  55.     public void setAttachmentFile(File attachmentFile) {
  56.         this.attachmentFile = attachmentFile;
  57.     }
  59.     public String getAttachmentFileName() {
  60.         return attachmentFileName;
  61.     }
  63.     public void setAttachmentFileName(String attachmentFileName) {
  64.         this.attachmentFileName = attachmentFileName;
  65.     }
  66. }
  1. 邮箱工具类
点击查看代码 
  1. package com.xiaostudy.security.email;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.boot.autoconfigure.mail.MailProperties;
  5. import org.springframework.mail.SimpleMailMessage;
  6. import org.springframework.mail.javamail.JavaMailSender;
  7. import org.springframework.mail.javamail.MimeMessageHelper;
  8. import org.springframework.stereotype.Component;
  10. import javax.mail.MessagingException;
  11. import javax.mail.internet.MimeMessage;
  13. @Component
  14. public class MailUtils {
  16.     @Autowired
  17.     private MailProperties mailProperties;
  18.     @Autowired
  19.     private JavaMailSender javaMailSender;
  21.     /**
  22.      * 发送邮件，里面有判断是否发文件
  23.      */
  24.     public void sendMail(MailEntity mailEntity) {
  25.         if (null != mailEntity) {
  26.             if (null != mailEntity.getAttachmentFile() && mailEntity.getAttachmentFile().exists()) {
  27.                 if (null == mailEntity.getAttachmentFileName()) {
  28.                     mailEntity.setAttachmentFileName(mailEntity.getAttachmentFile().getName());
  29.                 }
  30.                 sendMailAttachment(mailEntity);
  31.             } else {
  32.                 sendSimpleMail(mailEntity);
  33.             }
  34.         }
  35.     }
  37.     /**
  38.      * 发送邮件，这里只发内容，不发文件
  39.      */
  40.     public void sendSimpleMail(MailEntity mailEntity) {
  41.         SimpleMailMessage mimeMessage = new SimpleMailMessage();
  42.         mimeMessage.setFrom(mailProperties.getUsername());
  43.         mimeMessage.setTo(mailEntity.getToAccount());
  44.         mimeMessage.setSubject(mailEntity.getSubject());
  45.         mimeMessage.setText(mailEntity.getContent());
  46.         javaMailSender.send(mimeMessage);
  47.     }
  49.     /**
  50.      * 发送邮件-附件邮件
  51.      *
  52.      * @param mailEntity
  53.      */
  54.     public boolean sendMailAttachment(MailEntity mailEntity) {
  55.         try {
  56.             MimeMessage mimeMessage = javaMailSender.createMimeMessage();
  57.             MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
  58.             helper.setFrom(mailProperties.getUsername());
  59.             helper.setTo(mailEntity.getToAccount());
  60.             helper.setSubject(mailEntity.getSubject());
  61.             helper.setText(mailEntity.getContent(), true);
  62.             // 增加附件名称和附件
  63.             helper.addAttachment(mailEntity.getAttachmentFileName(), mailEntity.getAttachmentFile());
  64.             javaMailSender.send(mimeMessage);
  65.             return true;
  66.         } catch (MessagingException e) {
  67.             e.printStackTrace();
  68.             return false;
  69.         }
  70.     }
  71. }
  1. 验证码接口
点击查看代码 
  1. package com.xiaostudy.security.controller;
  3. import com.xiaostudy.common.redis.RedisService;
  4. import com.xiaostudy.common.utils.DESUtils;
  5. import com.xiaostudy.common.utils.StringUtils;
  6. import com.xiaostudy.common.utils.VerifyCodeUtils;
  7. import com.xiaostudy.security.email.MailEntity;
  8. import com.xiaostudy.security.email.MailUtils;
  9. import com.xiaostudy.security.utils.IpUtils;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.core.io.buffer.DataBuffer;
  12. import org.springframework.http.MediaType;
  13. import org.springframework.http.server.reactive.ServerHttpResponse;
  14. import org.springframework.util.ObjectUtils;
  15. import org.springframework.web.bind.annotation.RequestMapping;
  16. import org.springframework.web.bind.annotation.RestController;
  17. import org.springframework.web.server.ServerWebExchange;
  18. import reactor.core.publisher.Flux;
  19. import reactor.core.publisher.Mono;
  21. import java.io.ByteArrayOutputStream;
  22. import java.io.IOException;
  23. import java.util.concurrent.TimeUnit;
  25. @RestController
  26. @RequestMapping("security")
  27. public class VerifyCodeController {
  29.     @Autowired
  30.     private MailUtils mailUtils;
  31.     @Autowired
  32.     private RedisService redisService;
  34.     @RequestMapping("/verifyCode")
  35.     public Mono<Void> verifyCode(ServerWebExchange exchange) throws IOException {
  36.         String code = VerifyCodeUtils.generateVerifyCode(4).toLowerCase();
  37.         redisService.setCacheObject(IpUtils.getIpAddr(exchange.getRequest()), code, 60L, TimeUnit.SECONDS);
  38.         ByteArrayOutputStream data = new ByteArrayOutputStream();
  39.         VerifyCodeUtils.outputImage(100, 40, data, code);
  40.         ServerHttpResponse response = exchange.getResponse();
  41.         response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
  42.         DataBuffer buffer = response.bufferFactory().wrap(data.toByteArray());
  44.         return response.writeWith(Flux.just(buffer));
  45.     }
  47.     @RequestMapping("/sendMailVerifyCode")
  48.     public Mono<String> sendMailVerifyCode(ServerWebExchange exchange) {
  49.         exchange.getResponse().getHeaders().setContentType(MediaType.APPLICATION_JSON);
  50.         return exchange.getFormData().map(data -> {
  51.             String code = VerifyCodeUtils.generateVerifyCode(4).toLowerCase();
  52.             redisService.setCacheObject(IpUtils.getIpAddr(exchange.getRequest()), code, 5L, TimeUnit.MINUTES);
  53.             String email = data.getFirst(StringUtils.EMAIL);
  54.             try {
  55.                 if (!ObjectUtils.isEmpty(email)) {
  56.                     email = DESUtils.decode(email);
  57.                 }
  58.             } catch (Exception e) {
  59.                 return "{\"code\":200,\"status\":1,\"msg\":\"解密邮箱出错！\"}";
  60.             }
  61.             if (ObjectUtils.isEmpty(email)) {
  62.                 return "{\"code\":200,\"status\":1,\"msg\":\"请输入邮箱！\"}";
  63.             }
  64.             if (!VerifyCodeUtils.isEMail(email)) {
  65.                 return "{\"code\":200,\"status\":1,\"msg\":\"邮箱格式不对！\"}";
  66.             }
  67.             if ("xxxxx@163.com".equals(email)) {
  68.                 MailEntity mailEntity = new MailEntity();
  69.                 mailEntity.setToAccount(email);
  70.                 mailEntity.setSubject("登陆系统验证码");
  71.                 mailEntity.setContent(String.format("5分钟有效，您登陆的验证码是：%s" , code));
  72.                 mailUtils.sendMail(mailEntity);
  74.                 return "{\"code\":200,\"status\":0,\"msg\":\"验证码已发送至邮箱！\"}";
  75.             }
  76.             // TODO
  77.             return "{\"code\":200,\"status\":1,\"msg\":\"测试，非自己邮箱不发！\"}";
  78.         });
  79.     }
  81. }
  1. 获取当前用户名、测试动态切换数据源接口
点击查看代码 
  1. package com.xiaostudy.security.controller;
  3. import com.xiaostudy.common.utils.StringUtils;
  4. import com.xiaostudy.security.datasources.annotation.DataSource;
  5. import com.xiaostudy.security.datasources.enums.DataSourceNameEnum;
  6. import com.xiaostudy.security.entity.UserEentity;
  7. import com.xiaostudy.security.service.UserService;
  8. import com.xiaostudy.security.utils.JwtTokenUtils;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.http.server.reactive.ServerHttpRequest;
  11. import org.springframework.security.core.Authentication;
  12. import org.springframework.security.core.context.SecurityContextHolder;
  13. import org.springframework.security.core.userdetails.UserDetails;
  14. import org.springframework.util.ObjectUtils;
  15. import org.springframework.web.bind.annotation.GetMapping;
  16. import org.springframework.web.bind.annotation.RequestMapping;
  17. import org.springframework.web.bind.annotation.RestController;
  19. import java.util.List;
  20. import java.util.stream.Collectors;
  22. @RestController
  23. @RequestMapping("user")
  24. public class UserController {
  26.     @Autowired
  27.     private UserService userService;
  29.     @GetMapping("getCurrentUserName")
  30.     public String getCurrentUserName(Authentication authentication, ServerHttpRequest request) {
  31.         String username = JwtTokenUtils.getCookieUsername(request.getHeaders());
  32.         if (!ObjectUtils.isEmpty(username)) {
  33.             return username;
  34.         }
  35.         if (ObjectUtils.isEmpty(authentication)) {
  36.             authentication = SecurityContextHolder.getContext().getAuthentication();
  37.         }
  38.         if (ObjectUtils.isEmpty(authentication)) {
  39.             return null;
  40.         }
  41.         Object principal = authentication.getPrincipal();
  42.         if (ObjectUtils.isEmpty(principal)) {
  43.             return null;
  44.         }
  45.         if (principal instanceof UserDetails) {
  46.             return ((UserDetails) principal).getUsername();
  47.         } else if (principal instanceof String) {
  48.             return (String) principal;
  49.         }
  50.         return null;
  51.     }
  53.     @DataSource(name = DataSourceNameEnum.FIRST)
  54.     @GetMapping("testDataSource1")
  55.     public String testDataSource1() {
  56.         List<UserEentity> userEentities = userService.selectUserAll();
  57.         if (ObjectUtils.isEmpty(userEentities)) {
  58.             return null;
  59.         }
  60.         return userEentities.stream().map(UserEentity::getUsername).collect(Collectors.joining(StringUtils.COMMA));
  61.     }
  63.     @DataSource(name = DataSourceNameEnum.SECOND)
  64.     @GetMapping("testDataSource2")
  65.     public String testDataSource2() {
  66.         List<UserEentity> userEentities = userService.selectUserAll();
  67.         if (ObjectUtils.isEmpty(userEentities)) {
  68.             return null;
  69.         }
  70.         return userEentities.stream().map(UserEentity::getUsername).collect(Collectors.joining(StringUtils.COMMA));
  71.     }
  72. }

  1. 删除启动类

3. 创建Gateway服务

  1. 创建操作



  2. 父模块添加子模块

  1. <module>gateway</module>
  1. 修改pom.xml文件



点击查看代码 
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>com.xiaostudy</groupId>
  7.         <artifactId>SpringCloud202208</artifactId>
  8.         <version>1.0-SNAPSHOT</version>
  9.         <relativePath>../pom.xml</relativePath>
  10.     </parent>
  11.     <groupId>com.xiaostudy</groupId>
  12.     <artifactId>gateway</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>gateway</name>
  15.     <description>gateway</description>
  16.     <dependencies>
  17.         <dependency>
  18.             <groupId>org.springframework.cloud</groupId>
  19.             <artifactId>spring-cloud-starter-gateway</artifactId>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>org.springframework.cloud</groupId>
  23.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  24.         </dependency>
  26.         <dependency>
  27.             <groupId>com.xiaostudy</groupId>
  28.             <artifactId>security</artifactId>
  29.             <version>0.0.1-SNAPSHOT</version>
  30.         </dependency>
  32.         <dependency>
  33.             <groupId>org.springframework.boot</groupId>
  34.             <artifactId>spring-boot-starter-test</artifactId>
  35.             <scope>test</scope>
  36.         </dependency>
  37.     </dependencies>
  39.     <build>
  40.         <plugins>
  41.             <plugin>
  42.                 <groupId>org.springframework.boot</groupId>
  43.                 <artifactId>spring-boot-maven-plugin</artifactId>
  44.             </plugin>
  45.         </plugins>
  46.     </build>
  48. </project>
  1. 配置文件application.properties修改为application.yml，然后配置
点击查看代码 
  1. server:
  2.   port: '@gateway.port@'
  4. eureka:
  5.   port: '@eureka.port@'
  6.   ip: '@eureka.ip@'
  7.   url-name: '@eureka.url.name@'
  8.   instance:
  9.     # 把本机IP注册到eureka而不是本机机器名
  10.     preferIpAddress: true
  11.     # 把本机IP注册到eureka，由下面参数组成
  12.     instance-id: ${spring.cloud.client.ip-address}:${server.port}
  13.   client:
  14.     serviceUrl:
  15.       defaultZone: http://@eureka.user.name@:@eureka.user.password@@${eureka.ip}:${eureka.port}/${eureka.url-name}/
  17. spring:
  18.   application:
  19.     name: '@gateway.application.name@'
  20.   cloud:
  21.     loadbalancer:
  22.       retry:
  23.         # 关闭重试
  24.         enabled: false
  25.     gateway:
  26.       routes:
  27.         # 路由的id,没有规定规则但要求唯一,建议配合服务名
  28.         - id: '@producer.application.name@'
  29.           # 匹配后提供服务的路由地址
  30.           uri: lb://@producer.application.name@
  31.           predicates:
  32.             - Path=/producer/** # 断言，路径相匹配的进行路由
  33.           filters:
  34.             # 去掉url一级前缀，例如http://localhost:9904/producer/test/getByName，等同于http://localhost:9904/test/getByName
  35.             - StripPrefix=1
  36.         - id: '@web.application.name@'
  37.           # lb:协议表示开启负载均衡
  38.           uri: lb://@web.application.name@
  39.           predicates:
  40.             - Path=/web/** #断言,路径相匹配的进行路由
  41.           filters:
  42.             - StripPrefix=1
  43.   redis:
  44.     # 默认值：localhost
  45.     host: localhost
  46.     # 默认值：6379
  47.     port: 6379
  48.     # 默认值：0
  49.     database: 1
  50.     lettuce:
  51.       pool:
  52.         # 连接池最大连接数（使用负值表示没有限制），默认值：8
  53.         max-active: 20
  54.         # 连接池中的最大空闲连接，默认值：8
  55.         max-idle: 10
  56.         #连接池中的最小空闲连接，默认值：0
  57.         min-idle: 1
  58.         # 连接池最大阻塞等待时间（使用负值表示没有限制），默认值：-1，单位：毫秒
  59.         max-wait: 2000
  61.   profiles:
  62.     # 使用的配置文件后缀application-security.yml。一个或多个，中间英文逗号分开
  63.     active: security
  1. 启动类添加注解

点击查看代码 
  1. @ComponentScan(
  2.         basePackages = {
  3.                 // 把security服务下的包交给spring管理
  4.                 "com.xiaostudy.security"
  5.                 , "com.xiaostudy.gateway"
  6.                 , "com.xiaostudy.common"
  7.         }
  8. )
  9. @MapperScan("com.xiaostudy.security.mapper")

  1. 启动



  2. 注册中心看服务

4. feign模块添加gateway接口

  1. application-feign.yml添加配置

此时application-feign.yml 
  1. producer:
  2.   application:
  3.     name: @producer.application.name@
  4. gateway:
  5.   application:
  6.     name: @gateway.application.name@
  7. feign:
  8.   client:
  9.     config:
  10.       default:
  11.         # 默认是1000
  12.         connect-timeout: 5000
  13.         read-timeout: 5000
  1. 添加gateway接口

点击查看代码 
  1. package com.xiaostudy.feign.apis;
  3. import com.xiaostudy.feign.config.FeignConfig;
  4. import org.springframework.cloud.openfeign.FeignClient;
  5. import org.springframework.web.bind.annotation.GetMapping;
  7. @FeignClient(name = "${gateway.application.name}" , contextId = "GatewayServiceApis" , configuration = FeignConfig.class)
  8. public interface GatewayServiceApis {
  9.     @GetMapping(value = "/user/getCurrentUserName")
  10.     public String getCurrentUserName();
  12.     @GetMapping(value = "/user/testDataSource1")
  13.     public String testDataSource1();
  15.     @GetMapping(value = "/user/testDataSource2")
  16.     public String testDataSource2();
  17. }

5. webService简单登陆

  1. 注册请求类
点击查看代码 
  1. package com.xiaostudy.webservice.entity;
  3. import java.io.Serializable;
  5. public class RegisterRequest implements Serializable {
  6.     private static final Long serialVersionUID = 1L;
  8.     private String userName;
  9.     private String passWord;
  10.     private String verifyCode;
  12.     public String getUserName() {
  13.         return userName;
  14.     }
  16.     public void setUserName(String userName) {
  17.         this.userName = userName;
  18.     }
  20.     public String getPassWord() {
  21.         return passWord;
  22.     }
  24.     public void setPassWord(String passWord) {
  25.         this.passWord = passWord;
  26.     }
  28.     public String getVerifyCode() {
  29.         return verifyCode;
  30.     }
  32.     public void setVerifyCode(String verifyCode) {
  33.         this.verifyCode = verifyCode;
  34.     }
  35. }
  1. IP工具类
点击查看代码 
package com.xiaostudy.webservice.utils;

import org.springframework.http.HttpHeaders;

import org.springframework.http.server.reactive.ServerHttpRequest;

import javax.servlet.http.HttpServletRequest;

import java.net.InetAddress;

import java.net.UnknownHostException;

public final class IpUtils {

    private IpUtils() {

    }

    public static final String UNKNOWN = "unknown";

    public static final String LOCAL_IPV6 = "0:0:0:0:0:0:0:1";

    public static final String LOCAL_IPV4 = "127.0.0.1";

    public static String getIpAddr(HttpServletRequest request) {

        String ipAddress;

        try {

            ipAddress = request.getHeader("x-forwarded-for");

            if (null == ipAddress || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {

                ipAddress = request.getHeader("Proxy-Client-IP");

            }

            if (null == ipAddress || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {

                ipAddress = request.getHeader("WL-Proxy-Client-IP");

            }

            if (null == ipAddress || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {

                ipAddress = request.getHeader("HTTP_CLIENT_IP");

            }

            if (null == ipAddress || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {

                ipAddress = request.getHeader("HTTP_X_FORWARDED_FOR");

            }

            if (null == ipAddress || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {

                ipAddress = request.getHeader("X-Real-IP");

            }

            if (null == ipAddress || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {

                ipAddress = request.getRemoteAddr();

                if (LOCAL_IPV4.equals(ipAddress) || LOCAL_IPV6.equals(ipAddress)) {

                    // 根据网卡取本机配置的IP

                    InetAddress inet = null;

                    try {

                        inet = InetAddress.getLocalHost();

                    } catch (UnknownHostException e) {

                        e.printStackTrace();

                    }

                    ipAddress = inet.getHostAddress();

                }

            }

            // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割

            if (ipAddress != null && ipAddress.length() > 15) {

                if (ipAddress.indexOf(',') > 0) {

                    ipAddress = ipAddress.substring(0, ipAddress.indexOf(','));

                }

            }

        } catch (Exception e) {

            ipAddress = "";

        }

        return LOCAL_IPV6.equals(ipAddress) ? LOCAL_IPV4 : ipAddress;

    }

    public static String getIpAddr(ServerHttpRequest request) {

        HttpHeaders headers = request.getHeaders();

        String ip = headers.getFirst("x-forwarded-for");

        if (ip != null && ip.length() != 0 && !UNKNOWN.equalsIgnoreCase(ip) && ip.indexOf(",") != -1) {

            // 多次反向代理后会有多个ip值，第一个ip才是真实ip

            ip = ip.split(",")[0];

        }

        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {

            ip = headers.getFirst("Proxy-Client-IP");

        }

        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {

            ip = headers.getFirst("WL-Proxy-Client-IP");

        }

        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {

            ip = headers.getFirst("HTTP_CLIENT_IP");

        }

        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {

            ip = headers.getFirst("HTTP_X_FORWARDED_FOR");

        }

        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {

            ip = headers.getFirst("X-Real-IP");

        }

        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {

            ip = request.getRemoteAddress().getAddress().getHostAddress();

        }

        return LOCAL_IPV6.equals(ip) ? LOCAL_IPV4 : ip;

    }

}
  1. 添加公共模块

<dependency>

    <groupId>com.xiaostudy</groupId>

    <artifactId>common</artifactId>

    <version>1.0-SNAPSHOT</version>

</dependency>
  1. 登陆跳转和一些测试
点击查看代码 
package com.xiaostudy.webservice.controller;

import com.xiaostudy.common.redis.RedisService;

import com.xiaostudy.common.utils.DESUtils;

import com.xiaostudy.common.utils.StringUtils;

import com.xiaostudy.feign.apis.GatewayServiceApis;

import com.xiaostudy.webservice.entity.RegisterRequest;

import com.xiaostudy.webservice.entity.db1.UserEentity;

import com.xiaostudy.webservice.utils.IpUtils;

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

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

import org.springframework.stereotype.Controller;

import org.springframework.util.ObjectUtils;

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

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

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

import javax.servlet.http.HttpServletRequest;

@Controller

@RequestMapping("/webLogin")

public class LoginController {

    @Autowired

    private GatewayServiceApis gatewayServiceApis;

    @Value("${my.gateway.ip}")

    private String ip;

    @Value("${my.gateway.port}")

    private String port;

    @Value("${server.port}")

    private String applicationPort;

    @Autowired

    private com.xiaostudy.webservice.service.db1.UserService userService1;

    @Autowired

    private RedisService redisService;

    @RequestMapping("/login")

    public String login() {

        return String.format("redirect:http://%s:%s/web/login.html" , ip, port);

    }

    @RequestMapping("/isLogout")

    @ResponseBody

    public String isLogout() {

        return "{\"code\":200,\"status\":0,\"msg\":\"登出成功！\"}";

    }

    @RequestMapping("/register")

    @ResponseBody

    public String register(HttpServletRequest request, @RequestBody RegisterRequest registerRequest) {

        String verifyCode = registerRequest.getVerifyCode();

        String userName = registerRequest.getUserName();

        String passWord = registerRequest.getPassWord();

        if (ObjectUtils.isEmpty(verifyCode)) {

            return "{\"code\":200,\"status\":1,\"msg\":\"请输入验证码！\"}";

        }

        String ipAddr = IpUtils.getIpAddr(request);

        if (ObjectUtils.isEmpty(ipAddr)) {

            return "{\"code\":200,\"status\":1,\"msg\":\"系统出错，请稍后再试！\"}";

        }

        String s = redisService.getCacheObject(ipAddr);

        if (ObjectUtils.isEmpty(s)) {

            return "{\"code\":200,\"status\":1,\"msg\":\"验证码过期，请重新获取！\"}";

        }

        if (!s.equals(verifyCode) && !s.equals(verifyCode.toLowerCase())) {

            return "{\"code\":200,\"status\":1,\"msg\":\"验证码错误，请重新输入！\"}";

        }

        try {

            if (!ObjectUtils.isEmpty(userName)) {

                userName = DESUtils.decode(userName);

            }

            if (!ObjectUtils.isEmpty(passWord)) {

                passWord = DESUtils.decode(passWord);

            }

        } catch (Exception e) {

            return "{\"code\":200,\"status\":1,\"msg\":\"解密用户名密码出错！\"}";

        }

        if (ObjectUtils.isEmpty(userName)) {

            return "{\"code\":200,\"status\":1,\"msg\":\"请输入用户名！\"}";

        }

        if (ObjectUtils.isEmpty(passWord)) {

            return "{\"code\":200,\"status\":1,\"msg\":\"请输入密码！\"}";

        }

        UserEentity userEentity = userService1.selectUserByUsername(userName);

        if (!ObjectUtils.isEmpty(userEentity)) {

            return String.format("{\"code\":200,\"status\":1,\"msg\":\"%s用户名已存在！\"}" , userName);

        }

        userEentity = new UserEentity();

        userEentity.setUsername(userName);

        userEentity.setPassword(passWord);

        userEentity.setErrorCount(0);

        userEentity.setUrl(StringUtils.DEFAULT_INDEX_HTML_1);

        boolean insertUser = userService1.insertUser(userEentity);

        if (!insertUser) {

            return "{\"code\":200,\"status\":1,\"msg\":\"创建用户失败！\"}";

        }

        redisService.deleteObject(ipAddr);

        return "{\"code\":200,\"status\":0,\"msg\":\"创建用户成功！\"}";

    }

    @RequestMapping("/getCurrentUserName")

    @ResponseBody

    public String getCurrentUserName() {

        return gatewayServiceApis.getCurrentUserName();

    }

    @RequestMapping("/test")

    @ResponseBody

    public String test() {

        return "不用登陆";

    }

    @RequestMapping("/yes")

    @ResponseBody

    public String yes() {

        return gatewayServiceApis.getCurrentUserName() + "登陆成功就可以查看，应用端口：" + applicationPort;

    }

    @RequestMapping("/test2")

    @ResponseBody

    public String test2() {

        return "不用登陆2";

    }

    @RequestMapping("/useri")

    @ResponseBody

    public String useri() {

        String currentUserName = gatewayServiceApis.getCurrentUserName();

        return String.format("你好用户%s或用户x,有角色k权限" , currentUserName);

    }

    @RequestMapping("/usera")

    @ResponseBody

    public String usera() {

        String currentUserName = gatewayServiceApis.getCurrentUserName();

        return String.format("你好用户%s或用户x,有角色c权限" , currentUserName);

    }

    @RequestMapping("/user1")

    @ResponseBody

    public String user1() {

        String currentUserName = gatewayServiceApis.getCurrentUserName();

        return String.format("你好用户%s,有角色3权限" , currentUserName);

    }

}
  1. 前端-首页html

点击查看代码 
<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <title>首页</title>

    <style>

        * {

            padding: 0;

            margin: 0;

            font-family: "楷体";

        }

        header {

            background-color: #9b9c98;

            height: 100vh;

            background-size: cover;

            background-position: center;

        }

        ul {

            float: right;

            list-style-type: none;

            margin: 15px;

        }

        ul li {

            display: inline-block;

        }

        ul li a {

            text-decoration: none;

            color: #fff;

            padding: 5px 20px;

            border: 1px solid transparent;

            transition: .6s ease;

            border-radius: 20px;

        }

        ul li a:hover {

            background-color: #fff;

            color: #000;

        }

        ul li.active a {

            background-color: #fff;

            color: #000;

        }

        .title {

            position: absolute;

            top: 50%;

            left: 50%;

            transform: translate(-50%, -50%);

        }

        .title h1 {

            color: #fff;

            font-size: 70px;

            font-family: Century Gothic;

        }

    </style>

</head>

<body>

<header>

    <div class="main">

        <ul>

            <li id="user">你好</li>

            <li class="active"><a href="javascript:void(0);" onclick="logout();">退出</a></li>

            <li><a href="javascript:void(0);" onclick="index('/web/webUser/multiDataSource')">多数据源</a></li>

            <li><a href="javascript:void(0);" onclick="index('/web/webLogin/useri')">i有权</a></li>

            <li><a href="javascript:void(0);" onclick="index('/web/webLogin/usera')">a有权</a></li>

            <li><a href="javascript:void(0);" onclick="index('/web/webLogin/user1')">1有权</a></li>

            <li><a href="javascript:void(0);" onclick="index('/web/webLogin/yes')">登陆看yes</a></li>

            <li><a href="javascript:void(0);" onclick="index('/web/webLogin/test')">不用登看test</a></li>

            <li><a href="javascript:void(0);" onclick="index('/web/webLogin/test2')">不用登陆看test2</a></li>

            <li><a href="javascript:void(0);" onclick="index('/producer/producerTest/getByName')">直接访问producer</a></li>

            <li><a href="javascript:void(0);" onclick="index('/web/webUser/getProducerTest')">登陆看getTest</a></li>

        </ul>

    </div>

    <div class="title">

        <h1><span style="color: crimson;">My</span> Homepage</h1>

    </div>

</header>

</body>

<script type="application/javascript">

    window.onload = getCurrentUserName;

    var userName = "";

    var Authorization = "";

    var authorizationName = "Authorization";

    var refreshTokenFlag = "RefreshTokenFlag";

    var TOKEN_REFRESH_YES = "1";

    function getHeader() {

        var req = new XMLHttpRequest();

        req.open('GET', document.location.href, false);

        req.send(null);

        var refreshTokenFlagValue = req.getResponseHeader(refreshTokenFlag);

        if (TOKEN_REFRESH_YES === refreshTokenFlagValue) {

            Authorization = req.getResponseHeader(authorizationName);

            setCookie(authorizationName, Authorization, document.location.href);

        }

    }

    function getCurrentUserName() {

        userName = getCookie("username");

        Authorization = getCookie(authorizationName);

        getHeader();

        // if (undefined === userName || "" == userName || null == userName) {

            //步骤一:创建异步对象

            var xhr = new XMLHttpRequest();

            //步骤二:设置请求的url参数,参数一是请求的类型,参数二是请求的url,可以带参数,动态的传递参数starName到服务端

            xhr.open('get', '/web/webLogin/getCurrentUserName');

            //步骤三:发送请求

            xhr.send();

            //步骤四:注册事件 onreadystatechange 状态改变就会调用

            xhr.onreadystatechange = function () {

                if (xhr.readyState == 4 && xhr.status == 200) {

                    //步骤五 如果能够进到这个判断 说明 数据 完美的回来了,并且请求的页面是存在的　　　　console.log(xhr.responseText);//输入相应的内容  　　}

                    userName = xhr.responseText;

                    document.getElementById("user").innerText = "你好：" + userName + "！";

                    var refreshTokenFlagValue = xhr.getResponseHeader(refreshTokenFlag);

                    if (TOKEN_REFRESH_YES === refreshTokenFlagValue) {

                        Authorization = xhr.getResponseHeader(authorizationName);

                        setCookie(authorizationName, Authorization, "/web/index.html");

                    }

                }

            }

        // } else {

        //     document.getElementById("user").innerText = "你好：" + userName + "！";

        // }

    }

    function logout() {

        //步骤一:创建异步对象

        var xhr = new XMLHttpRequest();

        //步骤二:设置请求的url参数,参数一是请求的类型,参数二是请求的url,可以带参数,动态的传递参数starName到服务端

        xhr.open('get', '/web/webLogin/logout');

        //步骤三:发送请求

        xhr.send();

        //步骤四:注册事件 onreadystatechange 状态改变就会调用

        xhr.onreadystatechange = function () {

            if (xhr.readyState == 4 && xhr.status == 200) {

                //步骤五 如果能够进到这个判断 说明 数据 完美的回来了,并且请求的页面是存在的　　　　console.log(xhr.responseText);//输入相应的内容  　　}

                var jsonStr = xhr.responseText;

                jsonStr = eval("(" + jsonStr + ")");

                var code = jsonStr.code;

                if (code != undefined && 200 === code) {

                    var status = jsonStr.status;

                    if (status != undefined && 0 === status) {

                        location.replace("/web/login.html");

                    } else {

                        alert(jsonStr.msg);

                    }

                } else {

                    // alert("登陆异常");

                }

            } else {

                console.log("登出异常");

            }

        }

    }

    function index(url) {

        //步骤一:创建异步对象

        var xhr = new XMLHttpRequest();

        //步骤二:设置请求的url参数,参数一是请求的类型,参数二是请求的url,可以带参数,动态的传递参数starName到服务端

        xhr.open('get', url);

        xhr.setRequestHeader(authorizationName, Authorization);

        xhr.setRequestHeader('Content-Type', 'application/json;charset=UTF-8');

        //步骤三:发送请求

        xhr.send();

        //步骤四:注册事件 onreadystatechange 状态改变就会调用

        xhr.onreadystatechange = function () {

            if (xhr.readyState == 4 && xhr.status == 200) {

                //步骤五 如果能够进到这个判断 说明 数据 完美的回来了,并且请求的页面是存在的　　　　console.log(xhr.responseText);//输入相应的内容  　　}

                var jsonStr = xhr.responseText;

                console.log(jsonStr);

            } else {

                // console.log("异常，状态非200");

            }

        }

    }

    function setCookie(name, value, url) {

        /*

        *--------------- setCookie(name,value) -----------------

        * setCookie(name,value)

        * 功能:设置得变量name的值

        * 参数:name,字符串;value,字符串.

        * 实例:setCookie('username','baobao')

        *--------------- setCookie(name,value) -----------------

        */

        var Days = 30; //此 cookie 将被保存 30 天

        var exp = new Date();

        exp.setTime(exp.getTime() + Days * 24 * 60 * 60 * 1000);

        document.cookie = name + "=" + escape(value) + ";expires=" + exp.toGMTString();

        location.href = url; //接收页面.

    }

    function getCookie(name) {

        /*

        * getCookie(name)

        * 功能:取得变量name的值

        * 参数:name,字符串.

        * 实例:alert(getCookie("username"));

        */

        var arr = document.cookie.match(new RegExp("(^| )" + name + "=([^;]*)(;|$)"));

        if (arr != null) {

            console.log(arr);

            return unescape(arr[2]);

        }

        return null;

    }

</script>

</html>
  1. 前端-普通账号密码登陆

点击查看代码 
<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <title>登陆</title>

    <style>

        body {

            background: #353f42;

        }

        * {

            padding: 0;

            margin: 0;

        }

        .main {

            margin: 0 auto;

            padding-left: 25px;

            padding-right: 25px;

            padding-top: 15px;

            width: 350px;

            /*height: 350px;*/

            height: 430px;

            background: #FFFFFF;

            /*以下css用于让登录表单垂直居中在界面,可删除*/

            position: absolute;

            top: 50%;

            left: 50%;

            margin-top: -175px;

            margin-left: -175px;

        }

        .title {

            width: 100%;

            height: 40px;

            line-height: 40px;

        }

        .title span {

            font-size: 18px;

            color: #353f42;

        }

        .title-msg {

            width: 100%;

            height: 64px;

            line-height: 64px;

        }

        .title:hover {

            cursor: default;

        }

        .title-msg:hover {

            cursor: default;

        }

        .title-msg span {

            font-size: 12px;

            color: #707472;

        }

        .input-content {

            width: 100%;

            /*height: 120px;*/

            height: 200px;

        }

        .input-content input {

            width: 330px;

            height: 40px;

            border: 1px solid #dad9d6;

            background: #ffffff;

            padding-left: 10px;

            padding-right: 10px;

        }

        .enter-btn {

            width: 350px;

            height: 40px;

            color: #fff;

            background: #0bc5de;

            line-height: 40px;

            text-align: center;

            border: 0px;

        }

        .foor {

            width: 100%;

            height: auto;

            color: #9b9c98;

            font-size: 12px;

            margin-top: 20px;

        }

        .enter-btn:hover {

            cursor: pointer;

            background: #1db5c9;

        }

        .foor div:hover {

            cursor: pointer;

            color: #484847;

            font-weight: 600;

        }

        .left {

            float: left;

        }

        .right {

            float: right;

        }

    </style>

</head>

<body>

<div class="main">

    <div class="title">

        <span>密码登录</span>

    </div>

    <div class="title-msg">

        <span>请输入登录账户和密码</span>

    </div>

    <!--输入框-->

    <div class="input-content">

        <!--autoFocus-->

        <div>

            <input type="text" autocomplete="off"

                   placeholder="用户名" name="username" id="username" required/>

        </div>

        <div style="margin-top: 16px">

            <input type="password"

                   autocomplete="off" placeholder="登录密码" name="password" id="password" required maxlength="32"/>

        </div>

        <div style="margin-top: 16px">

            <img src="/security/verifyCode" title="看不清，请点我" onclick="refresh(this)" onmouseover="mouseover(this)"/>

            <input type="text" class="form-control" name="verifyCode" id="verifyCode" required="required" placeholder="验证码" autocomplete="off">

        </div>

    </div>

    <!--登入按钮-->

    <div style="text-align: center;margin-top: 30px;">

        <button type="submit" class="enter-btn" onclick="login()">登录</button>

    </div>

    <div class="foor">

        <div class="left" onclick="loginMail()"><span>邮箱登陆</span></div>

        <div class="right" onclick="register()"><span>注册账户</span></div>

    </div>

</div>

<!-- 引入 CDN Crypto.js 开始 AES加密 注意引入顺序 -->

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/core.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/enc-base64.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/md5.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/evpkdf.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/cipher-core.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/aes.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/pad-pkcs7.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/mode-ecb.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/enc-utf8.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/enc-hex.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/tripledes.js"></script>

<!-- 引入 CDN Crypto.js 结束 -->

<script type="application/javascript">

    function loginMail() {

        location.replace("/web/loginMail.html");

    }

    function register() {

        location.replace("/web/register.html");

    }

    function refresh(obj) {

        obj.src = "/security/verifyCode?" + Math.random();

    }

    function mouseover(obj) {

        obj.style.cursor = "pointer";

    }

    var authorizationName = "Authorization";

    function login() {

        var username1 = document.getElementById("username").value;

        var password = document.getElementById("password").value;

        var verifyCode = document.getElementById("verifyCode").value;

        var username = encryptByDES(username1);

        password = encryptByDES(password);

        var indexUrl = "/web/index.html";

        //步骤一:创建异步对象

        var xhr = new XMLHttpRequest();

        //步骤二:设置请求的url参数,参数一是请求的类型,参数二是请求的url,可以带参数,动态的传递参数starName到服务端

        xhr.open('post', '/web/webLogin/form');

        xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

        xhr.send("userName=" + username + "&passWord=" + password + "&verifyCode=" + verifyCode + "&_t=" + new Date().getTime());

        //步骤四:注册事件 onreadystatechange 状态改变就会调用

        xhr.onreadystatechange = function () {

            if (xhr.readyState == 4 && xhr.status == 200) {

                //步骤五 如果能够进到这个判断 说明 数据 完美的回来了,并且请求的页面是存在的　　　　console.log(xhr.responseText);//输入相应的内容  　　}

                var jsonStr = xhr.responseText;

                jsonStr = eval("(" + jsonStr + ")");

                var code = jsonStr.code;

                if (code != undefined && 200 === code) {

                    var status = jsonStr.status;

                    if (status != undefined && 0 === status) {

                        location.replace(indexUrl);

                        setCookie("username", username1, indexUrl);

                        setCookie(authorizationName, xhr.getResponseHeader(authorizationName), indexUrl);

                    } else {

                        alert(jsonStr.msg);

                    }

                } else {

                    // alert("登陆异常");

                }

            } else {

                // alert("登陆异常");

            }

        }

    }

    function setCookie(name, value, url) {

        /*

        *--------------- setCookie(name,value) -----------------

        * setCookie(name,value)

        * 功能:设置得变量name的值

        * 参数:name,字符串;value,字符串.

        * 实例:setCookie('username','baobao')

        *--------------- setCookie(name,value) -----------------

        */

        var Days = 30; //此 cookie 将被保存 30 天

        var exp = new Date();

        exp.setTime(exp.getTime() + Days*24*60*60*1000);

        document.cookie = name + "="+ escape(value) + ";expires=" + exp.toGMTString();

        location.href = url; //接收页面.

    }

    var cryptoJSKey = CryptoJS.enc.Utf8.parse('mwPZ7ISbC!ox6@7cP*^…5@%$)2*V');

    var cryptoJSIv = CryptoJS.enc.Utf8.parse('mwPZ7C!n');

    function encryptBy(username, password) {

        let message = username + ':' + password;

        return encryptByDES(message);

    }

    //base64 账号加密码

    function encryptByDES(message) {

        let option = {

            iv: cryptoJSIv,

            mode: CryptoJS.mode.CBC,

            padding: CryptoJS.pad.Pkcs7

        }

        let encrypted = CryptoJS.TripleDES.encrypt(message, cryptoJSKey, option);

        return encrypted.ciphertext.toString().toUpperCase();

    }

</script>

</body>
  1. 前端-邮箱登陆

点击查看代码 
<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <title>登陆</title>

    <style>

        body {

            background: #353f42;

        }

        * {

            padding: 0;

            margin: 0;

        }

        .main {

            margin: 0 auto;

            padding-left: 25px;

            padding-right: 25px;

            padding-top: 15px;

            width: 350px;

            height: 580px;

            background: #FFFFFF;

            /*以下css用于让登录表单垂直居中在界面,可删除*/

            position: absolute;

            top: 40%;

            left: 50%;

            margin-top: -175px;

            margin-left: -175px;

        }

        .title {

            width: 100%;

            height: 40px;

            line-height: 40px;

        }

        .title span {

            font-size: 18px;

            color: #353f42;

        }

        .title-msg {

            width: 100%;

            height: 64px;

            line-height: 64px;

        }

        .title:hover {

            cursor: default;

        }

        .title-msg:hover {

            cursor: default;

        }

        .title-msg span {

            font-size: 12px;

            color: #707472;

        }

        .input-content {

            width: 100%;

            height: 360px;

        }

        .input-content input {

            width: 330px;

            height: 40px;

            border: 1px solid #dad9d6;

            background: #ffffff;

            padding-left: 10px;

            padding-right: 10px;

        }

        .enter-btn {

            margin-top: 30px;

            width: 350px;

            height: 40px;

            color: #fff;

            background: #CCCCCC;

            line-height: 40px;

            text-align: center;

            border: 0px;

            cursor: not-allowed;

        }

        .foor {

            width: 100%;

            height: auto;

            color: #9b9c98;

            font-size: 12px;

            margin-top: 20px;

        }

        .foor div:hover {

            cursor: pointer;

            color: #484847;

            font-weight: 600;

        }

        .left {

            float: left;

        }

        .right {

            float: right;

        }

        /*滑块开始*/

        .container {

            width: 350px;

            margin: 16px auto;

        }

        #msg {

            width: 100%;

            line-height: 40px;

            font-size: 14px;

            text-align: center;

        }

        a:link,

        a:visited,

        a:hover,

        a:active {

            margin-left: 100px;

            color: #0366D6;

        }

        .block {

            position: absolute;

            left: 0;

            top: 0;

        }

        .sliderContainer {

            position: relative;

            text-align: center;

            width: 350px;

            height: 40px;

            line-height: 40px;

            margin-top: 15px;

            background: #f7f9fa;

            color: #45494c;

            border: 1px solid #e4e7eb;

        }

        .sliderContainer_active .slider {

            height: 38px;

            top: -1px;

            border: 1px solid #1991FA;

        }

        .sliderContainer_active .sliderMask {

            height: 38px;

            border-width: 1px;

        }

        .sliderContainer_success .slider {

            height: 38px;

            top: -1px;

            border: 1px solid #52CCBA;

            background-color: #52CCBA !important;

        }

        .sliderContainer_success .sliderMask {

            height: 38px;

            border: 1px solid #52CCBA;

            background-color: #D2F4EF;

        }

        .sliderContainer_success .sliderIcon {

            background-position: 0 0 !important;

        }

        .sliderContainer_fail .slider {

            height: 38px;

            top: -1px;

            border: 1px solid #f57a7a;

            background-color: #f57a7a !important;

        }

        .sliderContainer_fail .sliderMask {

            height: 38px;

            border: 1px solid #f57a7a;

            background-color: #fce1e1;

        }

        .sliderContainer_fail .sliderIcon {

            background-position: 0 -83px !important;

        }

        .sliderContainer_active .sliderText,

        .sliderContainer_success .sliderText,

        .sliderContainer_fail .sliderText {

            display: none;

        }

        .sliderMask {

            position: absolute;

            left: 0;

            top: 0;

            height: 40px;

            border: 0 solid #1991FA;

            background: #D1E9FE;

        }

        .slider {

            position: absolute;

            top: 0;

            left: 0;

            width: 40px;

            height: 40px;

            background: #fff;

            box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);

            cursor: pointer;

            transition: background .2s linear;

        }

        .slider:hover {

            background: #1991FA;

        }

        .slider:hover .sliderIcon {

            background-position: 0 -13px;

        }

        .sliderIcon {

            position: absolute;

            top: 15px;

            left: 13px;

            width: 14px;

            height: 11px;

            background: #f57a7a;

            background-size: 20px 14px;

        }

        .refreshIcon {

            position: absolute;

            right: 0;

            top: 0;

            width: 34px;

            height: 34px;

            cursor: pointer;

            background: url(img/refresh.png) 50% 50%;

            background-size: 30px 30px;

        }

        /*滑块结束*/

    </style>

</head>

<body>

<div class="main">

    <div class="title">

        <span>邮箱登录</span>

    </div>

    <div class="title-msg">

        <span>请输入邮箱获取验证码</span>

    </div>

    <!--输入框-->

    <div class="input-content">

        <div>

            <input type="text" autocomplete="off"

                   placeholder="邮箱" name="username" id="email" required/>

        </div>

        <div style="margin-top: 16px">

            <div class="clear"></div>

            <input name="code" type="text" class="form-control" id="code" placeholder="请输入验证码" autocomplete="off">

            <input style="width: 200px;" type="button" value="发送验证码" id="send" onclick="onclickSend()">

            <span id="smscode_info" class="res-error"></span>

        </div>

        <div class="container" style="margin-top: 16px">

            <div id="captcha" style="position: relative"></div>

        </div>

    </div>

    <!--登入按钮-->

    <div>

        <button type="submit" class="enter-btn" onclick="login()" id="submit" disabled>登录</button>

    </div>

    <div class="foor">

        <div class="left" onclick="loginHtml()"><span>账号登陆</span></div>

        <div class="right" onclick="register()"><span>注册账户</span></div>

    </div>

</div>

<!-- 引入 CDN Crypto.js 开始 AES加密 注意引入顺序 -->

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/core.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/enc-base64.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/md5.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/evpkdf.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/cipher-core.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/aes.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/pad-pkcs7.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/mode-ecb.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/enc-utf8.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/enc-hex.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/tripledes.js"></script>

<!-- 引入 CDN Crypto.js 结束 -->

<script type="application/javascript">

    function loginHtml() {

        location.replace("/web/login.html");

    }

    function register() {

        location.replace("/web/register.html");

    }

    function onclickSend() {

        var email = document.getElementById("email").value;

        if ('' == email) {

            alert("请填写邮箱");

            return;

        }

        email = encryptByDES(email);

        var info = "秒后重新发送";

        var num = 6;

        var send = document.getElementById("send");

        send.setAttribute('value', num + info);

        send.setAttribute('disabled', 'true');

        send.removeAttribute('onclick');

        var t = setInterval(() => {

            num -= 1;

            var send = document.getElementById("send");

            send.setAttribute('value', num + info);

            if (num == 0) {

                clearInterval(t);

                send.setAttribute('value', '发送验证码');

                send.setAttribute('onclick', 'onclickSend()');

                send.removeAttribute('disabled');

            }

        }, 1000);

        //步骤一:创建异步对象

        var xhr = new XMLHttpRequest();

        //步骤二:设置请求的url参数,参数一是请求的类型,参数二是请求的url,可以带参数,动态的传递参数starName到服务端

        xhr.open('post', '/security/sendMailVerifyCode');

        xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

        xhr.send("email=" + email + "&_t=" + new Date().getTime());

        //步骤四:注册事件 onreadystatechange 状态改变就会调用

        xhr.onreadystatechange = function () {

            if (xhr.readyState == 4 && xhr.status == 200) {

                //步骤五 如果能够进到这个判断 说明 数据 完美的回来了,并且请求的页面是存在的　　　　console.log(xhr.responseText);//输入相应的内容  　　}

                var jsonStr = xhr.responseText;

                jsonStr = eval("(" + jsonStr + ")");

                var code = jsonStr.code;

                if (code != undefined && 200 === code) {

                    var status = jsonStr.status;

                    if (status != undefined && 0 === status) {

                        info = "秒后重新发送，已发送至邮箱";

                    } else {

                        alert(jsonStr.msg);

                    }

                } else {

                    // alert("登陆异常");

                }

            } else {

                // alert("登陆异常");

            }

        }

    }

    var authorizationName = "Authorization";

    function login() {

        var email = document.getElementById("email").value;

        if ('' == email) {

            alert("请填写邮箱");

            return;

        }

        var verifyCode = document.getElementById("code").value;

        if ('' == verifyCode) {

            alert("请填写验证码");

            return;

        }

        email = encryptByDES(email);

        var indexUrl = "/web/index.html";

        //步骤一:创建异步对象

        var xhr = new XMLHttpRequest();

        //步骤二:设置请求的url参数,参数一是请求的类型,参数二是请求的url,可以带参数,动态的传递参数starName到服务端

        xhr.open('post', '/web/webLogin/emailLogin');

        xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

        xhr.send("email=" + email + "&verifyCode=" + verifyCode + "&_t=" + new Date().getTime());

        //步骤四:注册事件 onreadystatechange 状态改变就会调用

        xhr.onreadystatechange = function () {

            if (xhr.readyState == 4 && xhr.status == 200) {

                //步骤五 如果能够进到这个判断 说明 数据 完美的回来了,并且请求的页面是存在的　　　　console.log(xhr.responseText);//输入相应的内容  　　}

                var jsonStr = xhr.responseText;

                jsonStr = eval("(" + jsonStr + ")");

                var code = jsonStr.code;

                if (code != undefined && 200 === code) {

                    var status = jsonStr.status;

                    if (status != undefined && 0 === status) {

                        location.replace(indexUrl);

                        setCookie(authorizationName, xhr.getResponseHeader(authorizationName), indexUrl);

                    } else {

                        alert(jsonStr.msg);

                    }

                } else {

                    // alert("登陆异常");

                }

            } else {

                // alert("登陆异常");

            }

        }

    }

    function setCookie(name, value, url) {

        /*

        *--------------- setCookie(name,value) -----------------

        * setCookie(name,value)

        * 功能:设置得变量name的值

        * 参数:name,字符串;value,字符串.

        * 实例:setCookie('username','baobao')

        *--------------- setCookie(name,value) -----------------

        */

        var Days = 30; //此 cookie 将被保存 30 天

        var exp = new Date();

        exp.setTime(exp.getTime() + Days * 24 * 60 * 60 * 1000);

        document.cookie = name + "=" + escape(value) + ";expires=" + exp.toGMTString();

        location.href = url; //接收页面.

    }

    var cryptoJSKey = CryptoJS.enc.Utf8.parse('mwPZ7ISbC!ox6@7cP*^…5@%$)2*V');

    var cryptoJSIv = CryptoJS.enc.Utf8.parse('mwPZ7C!n');

    function encryptBy(username, password) {

        let message = username + ':' + password;

        return encryptByDES(message);

    }

    //base64 账号加密码

    function encryptByDES(message) {

        let option = {

            iv: cryptoJSIv,

            mode: CryptoJS.mode.CBC,

            padding: CryptoJS.pad.Pkcs7

        }

        let encrypted = CryptoJS.TripleDES.encrypt(message, cryptoJSKey, option);

        return encrypted.ciphertext.toString().toUpperCase();

    }

    // ==============================================================滑动开始===========================

    (function(window) {

        const l = 42, // 滑块边长

            r = 10, // 滑块半径

            w = 350, // canvas宽度

            h = 155, // canvas高度

            PI = Math.PI

        const L = l + r * 2 // 滑块实际边长

        function getRandomNumberByRange(start, end) {

            return Math.round(Math.random() * (end - start) + start)

        }

        function createCanvas(width, height) {

            const canvas = createElement('canvas')

            canvas.width = width

            canvas.height = height

            return canvas

        }

        function createImg(onload) {

            const img = createElement('img')

            img.crossOrigin = "Anonymous"

            img.onload = onload

            img.onerror = () => {

                img.src = getRandomImg()

            }

            img.src = getRandomImg()

            return img

        }

        function createElement(tagName) {

            return document.createElement(tagName)

        }

        function addClass(tag, className) {

            tag.classList.add(className)

        }

        function removeClass(tag, className) {

            tag.classList.remove(className)

        }

        function getRandomImg() {

            return 'https://picsum.photos/300/150/?image=' + getRandomNumberByRange(0, 100)

        }

        function draw(ctx, operation, x, y) {

            ctx.beginPath()

            ctx.moveTo(x, y)

            ctx.lineTo(x + l / 2, y)

            ctx.arc(x + l / 2, y - r + 2, r, 0, 2 * PI)

            ctx.lineTo(x + l / 2, y)

            ctx.lineTo(x + l, y)

            ctx.lineTo(x + l, y + l / 2)

            ctx.arc(x + l + r - 2, y + l / 2, r, 0, 2 * PI)

            ctx.lineTo(x + l, y + l / 2)

            ctx.lineTo(x + l, y + l)

            ctx.lineTo(x, y + l)

            ctx.lineTo(x, y)

            ctx.fillStyle = '#fff'

            ctx[operation]()

            ctx.beginPath()

            ctx.arc(x, y + l / 2, r, 1.5 * PI, 0.5 * PI)

            ctx.globalCompositeOperation = "xor"

            ctx.fill()

        }

        function sum(x, y) {

            return x + y

        }

        function square(x) {

            return x * x

        }

        class jigsaw {

            constructor(el, success, fail) {

                this.el = el

                this.success = success

                this.fail = fail

            }

            init() {

                this.initDOM()

                this.initImg()

                this.draw()

                this.bindEvents()

            }

            initDOM() {

                const canvas = createCanvas(w, h) // 画布

                const block = canvas.cloneNode(true) // 滑块

                const sliderContainer = createElement('div')

                const refreshIcon = createElement('div')

                const sliderMask = createElement('div')

                const slider = createElement('div')

                const sliderIcon = createElement('span')

                const text = createElement('span')

                block.className = 'block'

                sliderContainer.className = 'sliderContainer'

                refreshIcon.className = 'refreshIcon'

                sliderMask.className = 'sliderMask'

                slider.className = 'slider'

                sliderIcon.className = 'sliderIcon'

                text.innerHTML = '向右滑动滑块填充拼图'

                text.className = 'sliderText'

                const el = this.el

                el.appendChild(canvas)

                el.appendChild(refreshIcon)

                el.appendChild(block)

                slider.appendChild(sliderIcon)

                sliderMask.appendChild(slider)

                sliderContainer.appendChild(sliderMask)

                sliderContainer.appendChild(text)

                el.appendChild(sliderContainer)

                Object.assign(this, {

                    canvas,

                    block,

                    sliderContainer,

                    refreshIcon,

                    slider,

                    sliderMask,

                    sliderIcon,

                    text,

                    canvasCtx: canvas.getContext('2d'),

                    blockCtx: block.getContext('2d')

                })

            }

            initImg() {

                const img = createImg(() => {

                    this.canvasCtx.drawImage(img, 0, 0, w, h)

                    this.blockCtx.drawImage(img, 0, 0, w, h)

                    const y = this.y - r * 2 + 2

                    const ImageData = this.blockCtx.getImageData(this.x, y, L, L)

                    this.block.width = L

                    this.blockCtx.putImageData(ImageData, 0, y)

                })

                this.img = img

            }

            draw() {

                // 随机创建滑块的位置

                this.x = getRandomNumberByRange(L + 10, w - (L + 10))

                this.y = getRandomNumberByRange(10 + r * 2, h - (L + 10))

                draw(this.canvasCtx, 'fill', this.x, this.y)

                draw(this.blockCtx, 'clip', this.x, this.y)

            }

            clean() {

                this.canvasCtx.clearRect(0, 0, w, h)

                this.blockCtx.clearRect(0, 0, w, h)

                this.block.width = w

            }

            bindEvents() {

                this.el.onselectstart = () => false

                this.refreshIcon.onclick = () => {

                    this.reset()

                }

                let originX, originY, trail = [],

                    isMouseDown = false

                this.slider.addEventListener('mousedown', function(e) {

                    originX = e.x, originY = e.y

                    isMouseDown = true

                })

                document.addEventListener('mousemove', (e) => {

                    if(!isMouseDown) return false

                    const moveX = e.x - originX

                    const moveY = e.y - originY

                    if(moveX < 0 || moveX + 38 >= w) return false

                    this.slider.style.left = moveX + 'px'

                    var blockLeft = (w - 40 - 20) / (w - 40) * moveX

                    this.block.style.left = blockLeft + 'px'

                    addClass(this.sliderContainer, 'sliderContainer_active')

                    this.sliderMask.style.width = moveX + 'px'

                    trail.push(moveY)

                })

                document.addEventListener('mouseup', (e) => {

                    if(!isMouseDown) return false

                    isMouseDown = false

                    if(e.x == originX) return false

                    removeClass(this.sliderContainer, 'sliderContainer_active')

                    this.trail = trail

                    const {

                        spliced,

                        TuringTest

                    } = this.verify()

                    if(spliced) {

                        if(TuringTest) {

                            addClass(this.sliderContainer, 'sliderContainer_success')

                            this.success && this.success()

                        } else {

                            addClass(this.sliderContainer, 'sliderContainer_fail')

                            this.text.innerHTML = '再试一次'

                            this.reset()

                        }

                    } else {

                        // alert("验证失败");

                        addClass(this.sliderContainer, 'sliderContainer_fail')

                        this.fail && this.fail();

                        //验证失败后，1秒后重新加载图片

                        setTimeout(() => {

                            this.reset()

                        }, 1000)

                    }

                })

            }

            verify() {

                const arr = this.trail // 拖动时y轴的移动距离

                const average = arr.reduce(sum) / arr.length // 平均值

                const deviations = arr.map(x => x - average) // 偏差数组

                const stddev = Math.sqrt(deviations.map(square).reduce(sum) / arr.length) // 标准差

                const left = parseInt(this.block.style.left)

                return {

                    spliced: Math.abs(left - this.x) < 10,

                    TuringTest: average !== stddev, // 只是简单的验证拖动轨迹，相等时一般为0，表示可能非人为操作

                }

            }

            reset() {

                this.sliderContainer.className = 'sliderContainer'

                this.slider.style.left = 0

                this.block.style.left = 0

                this.sliderMask.style.width = 0

                this.clean()

                this.img.src = getRandomImg()

                this.draw()

            }

        }

        window.jigsaw = {

            init: function(element, success, fail) {

                new jigsaw(element, success, fail).init()

            }

        }

    }(window))

    jigsaw.init(document.getElementById('captcha'), function() {

        var slider = document.querySelector('.slider');

        slider.setAttribute('disabled', 'true');

        var submit = document.querySelector('.enter-btn');

        submit.style.background = '#0bc5de';

        submit.style.setProperty('cursor', 'pointer');

        submit.removeAttribute('disabled');

    })

    // ==============================================================滑动结束===========================

</script>

</body>

图片

  1. 前端-用户注册

点击查看代码 
<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <title>注册</title>

    <style>

        body {

            background: #353f42;

        }

        * {

            padding: 0;

            margin: 0;

        }

        .main {

            margin: 0 auto;

            padding-left: 25px;

            padding-right: 25px;

            padding-top: 15px;

            width: 350px;

            /*height: 350px;*/

            height: 430px;

            background: #FFFFFF;

            /*以下css用于让登录表单垂直居中在界面,可删除*/

            position: absolute;

            top: 50%;

            left: 50%;

            margin-top: -175px;

            margin-left: -175px;

        }

        .title {

            width: 100%;

            height: 40px;

            line-height: 40px;

        }

        .title span {

            font-size: 18px;

            color: #353f42;

        }

        .title-msg {

            width: 100%;

            height: 64px;

            line-height: 64px;

        }

        .title:hover {

            cursor: default;

        }

        .title-msg:hover {

            cursor: default;

        }

        .title-msg span {

            font-size: 12px;

            color: #707472;

        }

        .input-content {

            width: 100%;

            /*height: 120px;*/

            height: 200px;

        }

        .input-content input {

            width: 330px;

            height: 40px;

            border: 1px solid #dad9d6;

            background: #ffffff;

            padding-left: 10px;

            padding-right: 10px;

        }

        .enter-btn {

            width: 350px;

            height: 40px;

            color: #fff;

            background: #0bc5de;

            line-height: 40px;

            text-align: center;

            border: 0px;

        }

        .foor {

            width: 100%;

            height: auto;

            color: #9b9c98;

            font-size: 12px;

            margin-top: 20px;

        }

        .enter-btn:hover {

            cursor: pointer;

            background: #1db5c9;

        }

        .foor div:hover {

            cursor: pointer;

            color: #484847;

            font-weight: 600;

        }

        .left {

            float: left;

        }

        .right {

            float: right;

        }

    </style>

</head>

<body>

<div class="main">

    <div class="title">

        <span>用户注册</span>

    </div>

    <div class="title-msg">

        <span>请输入账户和密码</span>

    </div>

    <!--输入框-->

    <div class="input-content">

        <!--autoFocus-->

        <div>

            <input type="text" autocomplete="off"

                   placeholder="用户名" name="username" id="username" required/>

        </div>

        <div style="margin-top: 16px">

            <input type="password"

                   autocomplete="off" placeholder="登录密码" name="password" id="password" required maxlength="32"/>

        </div>

        <div style="margin-top: 16px">

            <img src="/security/verifyCode" title="看不清，请点我" onclick="refresh(this)" onmouseover="mouseover(this)"/>

            <input type="text" class="form-control" name="verifyCode" id="verifyCode" required="required" placeholder="验证码">

        </div>

    </div>

    <!--登入按钮-->

    <div style="text-align: center;margin-top: 30px;">

        <button type="submit" class="enter-btn" onclick="register()">注册</button>

    </div>

    <div class="foor">

        <div class="right" onclick="login()"><span>返回登陆</span></div>

    </div>

</div>

<!-- 引入 CDN Crypto.js 开始 AES加密 注意引入顺序 -->

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/core.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/enc-base64.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/md5.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/evpkdf.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/cipher-core.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/aes.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/pad-pkcs7.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/mode-ecb.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/enc-utf8.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/enc-hex.min.js"></script>

<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.3.0/tripledes.js"></script>

<!-- 引入 CDN Crypto.js 结束 -->

<script type="application/javascript">

    function login() {

        location.replace("/web/login.html");

    }

    function refresh(obj) {

        obj.src = "/security/verifyCode?" + Math.random();

    }

    function mouseover(obj) {

        obj.style.cursor = "pointer";

    }

    function register() {

        var username1 = document.getElementById("username").value;

        var password = document.getElementById("password").value;

        var verifyCode = document.getElementById("verifyCode").value;

        var username = encryptByDES(username1);

        password = encryptByDES(password);

        var indexUrl = "/web/login.html";

        //步骤一:创建异步对象

        var xhr = new XMLHttpRequest();

        //步骤二:设置请求的url参数,参数一是请求的类型,参数二是请求的url,可以带参数,动态的传递参数starName到服务端

        xhr.open('post', '/web/webLogin/register');

        xhr.setRequestHeader('Content-Type', 'application/json;charset=utf8');

        var para=JSON.stringify({"userName":username,"passWord":password,"verifyCode":verifyCode});

        xhr.send(para);

        //步骤四:注册事件 onreadystatechange 状态改变就会调用

        xhr.onreadystatechange = function () {

            if (xhr.readyState == 4 && xhr.status == 200) {

                //步骤五 如果能够进到这个判断 说明 数据 完美的回来了,并且请求的页面是存在的　　　　console.log(xhr.responseText);//输入相应的内容  　　}

                var jsonStr = xhr.responseText;

                jsonStr = eval("(" + jsonStr + ")");

                var code = jsonStr.code;

                if (code != undefined && 200 === code) {

                    var status = jsonStr.status;

                    if (status != undefined && 0 === status) {

                        alert("注册成功，请前往登陆！");

                        // location.replace(indexUrl);

                    } else {

                        alert(jsonStr.msg);

                    }

                } else {

                    // alert("登陆异常");

                }

            } else {

                // alert("登陆异常");

            }

        }

    }

    var cryptoJSKey = CryptoJS.enc.Utf8.parse('mwPZ7ISbC!ox6@7cP*^…5@%$)2*V');

    var cryptoJSIv = CryptoJS.enc.Utf8.parse('mwPZ7C!n');

    function encryptBy(username, password) {

        let message = username + ':' + password;

        return encryptByDES(message);

    }

    //base64 账号加密码

    function encryptByDES(message) {

        let option = {

            iv: cryptoJSIv,

            mode: CryptoJS.mode.CBC,

            padding: CryptoJS.pad.Pkcs7

        }

        let encrypted = CryptoJS.TripleDES.encrypt(message, cryptoJSKey, option);

        return encrypted.ciphertext.toString().toUpperCase();

    }

</script>

</body>

6. 演示

  1. 未登陆-无需登陆就可以看到，访问url白名单

    http://localhost:9904/web/webLogin/test

  2. 未登录

    http://localhost:9904/web/webLogin/getTest

  3. 登陆-用户不存在



  4. 验证码错误



  5. 账号密码正确

  6. url权限控制



  7. 邮箱登陆





简单创建一个SpringCloud2021.0.3项目（二）的更多相关文章

  1. 简单创建一个SpringCloud2021.0.3项目（四）

    目录 1. 项目说明 1. 版本 2. 用到组件 3. 功能 2. 上三篇教程 3. 日志处理 1. 创建日志公共模块 2. Eureka引入日志模块 4. 到此的功能代码 5. 注册中心换成naco ...

  2. 简单创建一个SpringCloud2021.0.3项目（三）

    目录 1. 项目说明 1. 版本 2. 用到组件 3. 功能 2. 上俩篇教程 3. Gateway集成sentinel,网关层做熔断降级 1. 超时熔断降级 2. 异常熔断 3. 集成sentine ...

  3. 简单创建一个SpringCloud2021.0.3项目（一）

    目录 1. 项目说明 1. 版本 2. 用到组件 3. 功能 2. 新建父模块和注册中心 1. 新建父模块 2. 新建注册中心Eureka 3. 新建配置中心Config 4. 新建两个业务服务 1. ...

  4. 【Vue-Cli3.0】【1】创建一个Vue-Cli3.0的项目

    最近在做爬虫,然后要爬好多数据,代码写完了,就让它在爬了.不想闲着就复习一下Vue吧! 开始开始! ***正式讲解之前 先下载一个node.js吧! 一.首先检查一下 版本 PS D:\徐孟林\D D ...

  5. 通过beego快速创建一个Restful风格API项目及API文档自动化

    通过beego快速创建一个Restful风格API项目及API文档自动化 本文演示如何快速(一分钟内,不写一行代码)的根据数据库及表创建一个Restful风格的API项目,及提供便于在线测试API的界 ...

  6. 通过beego快速创建一个Restful风格API项目及API文档自动化(转)

    通过beego快速创建一个Restful风格API项目及API文档自动化 本文演示如何快速(一分钟内,不写一行代码)的根据数据库及表创建一个Restful风格的API项目,及提供便于在线测试API的界 ...

  7. 如何使用maven建一个web3.0的项目

    使用eclipse手动建一个maven的web project可能会有版本不合适的情况,例如使用spring的websocket需要web3.0什么的,不全面的修改可能会出现各种红叉,甚是苦恼.我从我 ...

  8. 以sb7code为基础创建一个基本的OpenGL项目

      以sb7code为基础创建一个基本的OpenGL项目   从github上面下载sb7code代码: https://github.com/openglsuperbible/sb7code 打开H ...

  9. 简单创建一个完整的struts2框架小程序

    要完成一个struts2框架的搭建, 1.首先应该从官网上下载最新的jar包,网络连接:http://struts.apache.org/download.cgi#struts2514.1,选择下载F ...

随机推荐

  1. 技术分享 | App常见bug解析

    原文链接 功能Bug 内容显示错误 前端页面展示的内容有误. 这种错误的产生有两种可能 1.前端代码写的文案错误 2.接口返回值错误 功能错误 功能错误是在测试过程中最常见的类型之一,也就是产品的功能 ...

  2. ExtJS 布局-Card 布局（Card layout）

    更新记录: 2022年6月1日 开始. 2022年6月6日 发布. 1.说明 卡片布局类似牌堆,每次只有一个子组件可见,子组件几乎填满了整个容器.卡片布局常用于向导(Wizard)和选项卡(Tabs) ...

  3. UiPath Level3讲解

    匠厂出品,必属精品   Uipath中文社区qq交流群:465630324 uipath中文交流社区:https://uipathbbs.com RPA之家qq群:465620839 第一课--UiP ...

  4. Java开发学习(六)----DI依赖注入之setter及构造器注入解析

    一.DI依赖注入 首先来介绍下Spring中有哪些注入方式? 我们先来思考 向一个类中传递数据的方式有几种? 普通方法(set方法) 构造方法 依赖注入描述了在容器中建立bean与bean之间的依赖关 ...

  5. java: 程序包org.springframework.boot不存在

    如果你的settings中的maven配置没问题的话,尝试下面这个 在控制台输入  mvn idea:idea  重构一下

  6. 一文搞懂 Netty 发送数据全流程 | 你想知道的细节全在这里

    欢迎关注公众号:bin的技术小屋,如果大家在看文章的时候发现图片加载不了,可以到公众号查看原文 本系列Netty源码解析文章基于 4.1.56.Final版本 在<Netty如何高效接收网络数据 ...

  7. Learning Latent Graph Representations for Relational VQA

    The key mechanism of transformer-based models is cross-attentions, which implicitly form graphs over ...

  8. c# SerialPort HEX there is no data received

    C#窗口程序进行串口通信,按照串口通信协议,设置com口,波特率,停止位,校验位,数据位,本地虚拟串口调试ok,但是和外设调试时,发送HEX模式数据命令,没有数据返回, 所以关键问题在于HEX模式,发 ...

  9. AI2(App Inventor 2) 离线版

    介绍 我们的目标:搭建一个本地多用户的App Inventor 2 服务器目的:课堂教学,社团活动,兴趣学习优势:管理权限(用户管理,账号切换,资源打包),网络链接速度快,拥有配套服务.注意:每次退出 ...

  10. DHCP原理及配置

    DHCP工作原理 集中的管理.分配IP地址,使client动态的获得IP地址.Gateway地址.DNS服务器地址等信息,并能够提升地址的使用率. 简单来说,DHCP就是一个不需要账号密码登录的.自动 ...