目录

1、项目创建

1.1 初始化的 pom.xml文件

1.2 应用初始化设置

2、验证码生成前的准备

2.1 分析

2.2 整合 redis

2.3 验证码生成的工具类

2.4 定义一个统一返回给前台数据的类对象

2.5 定义返回状态码

2.6 字符串的工具类

2.7 UUID生成工具类

2.8 通用常量类

2.9 base64 编码工具

3、生成验证码

4、测试

5、总结

1、项目创建

1.1 初始化的 pom.xml文件

主要内容:

    <!-- 项目坐标 --><groupId>com.ruoyi</groupId><artifactId>ruoyi</artifactId><version>0.0.1-SNAPSHOT</version><!-- 父工程 --><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.1.1.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><!-- 依赖 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><!-- SpringBoot Web容器 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>

1.2 应用初始化设置

设置 端口号 和 应用访问的根路径

server:# 配置端口port: 8888servlet:# 应用访问路径context-path: /ruoyi

2、验证码生成前的准备

2.1 分析

浏览器发送：http://127.0.0.1:8888/ruoyi/captcha/captchaImage

服务器：

①、生成4位随机数

②、生成UUID

③、将验证码存入到 redis 中，key 为 UUID， 值为生成的4个随机数

④、生成验证码图片

⑤、将 验证码图片 和 UUID 放入返回结果中

2.2 整合 redis

2.2.1 引入 redis 相关依赖

        <!-- redis 缓存操作 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><!-- pool 对象池 --><dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId></dependency><!-- 阿里JSON解析器 --><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>${fastjson.version}</version></dependency>

2.2.2 配置 redis 

application.yml 文件新增配置

spring:# redis 配置redis:# 地址host: 114.67.69.222# 端口，默认为6379port: 6379# 密码password:    #填写自己的密码# 连接超时时间timeout: 10slettuce:pool:# 连接池中的最小空闲连接min-idle: 0# 连接池中的最大空闲连接max-idle: 8# 连接池的最大数据库连接数max-active: 8# #连接池最大阻塞等待时间（使用负值表示没有限制）max-wait: -1ms

新增redis的配置类

package com.ruoyi.framework.config;/*** redis配置** @author ruoyi*/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport
{@Bean@SuppressWarnings(value = { "unchecked", "rawtypes" })public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory){RedisTemplate<Object, Object> template = new RedisTemplate<>();template.setConnectionFactory(connectionFactory);FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);ObjectMapper mapper = new ObjectMapper();mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);serializer.setObjectMapper(mapper);template.setValueSerializer(serializer);// 使用StringRedisSerializer来序列化和反序列化redis的key值template.setKeySerializer(new StringRedisSerializer());template.afterPropertiesSet();return template;}
}

redis 配置类中用到了 fastJson 序列号, 下面是序列号类代码

package com.ruoyi.framework.config;/*** Redis使用FastJson序列化** @author ruoyi*/
public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {@SuppressWarnings("unused")private ObjectMapper objectMapper = new ObjectMapper();public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");private Class<T> clazz;static {ParserConfig.getGlobalInstance().setAutoTypeSupport(true);}public FastJson2JsonRedisSerializer(Class<T> clazz) {super();this.clazz = clazz;}public byte[] serialize(T t) throws SerializationException {if (t == null) {return new byte[0];}return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);}public T deserialize(byte[] bytes) throws SerializationException {if (bytes == null || bytes.length <= 0) {return null;}String str = new String(bytes, DEFAULT_CHARSET);return JSON.parseObject(str, clazz);}public void setObjectMapper(ObjectMapper objectMapper) {Assert.notNull(objectMapper, "'objectMapper' must not be null");this.objectMapper = objectMapper;}protected JavaType getJavaType(Class<?> clazz) {return TypeFactory.defaultInstance().constructType(clazz);}
}

2.2.3 redis工具类

封装redis 的增删改查操作

package com.ruoyi.framework.redis;/*** spring redis 工具类** @author ruoyi**/
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisCache {@Autowiredpublic RedisTemplate redisTemplate;/*** 缓存基本的对象，Integer、String、实体类等** @param key   缓存的键值* @param value 缓存的值* @return 缓存的对象*/public <T> ValueOperations<String, T> setCacheObject(String key, T value) {ValueOperations<String, T> operation = redisTemplate.opsForValue();operation.set(key, value);return operation;}/*** 缓存基本的对象，Integer、String、实体类等** @param key      缓存的键值* @param value    缓存的值* @param timeout  时间* @param timeUnit 时间颗粒度* @return 缓存的对象*/public <T> ValueOperations<String, T> setCacheObject(String key, T value, Integer timeout, TimeUnit timeUnit) {ValueOperations<String, T> operation = redisTemplate.opsForValue();operation.set(key, value, timeout, timeUnit);return operation;}/*** 获得缓存的基本对象。** @param key 缓存键值* @return 缓存键值对应的数据*/public <T> T getCacheObject(String key) {ValueOperations<String, T> operation = redisTemplate.opsForValue();return operation.get(key);}/*** 删除单个对象** @param key*/public void deleteObject(String key) {redisTemplate.delete(key);}/*** 删除集合对象** @param collection*/public void deleteObject(Collection collection) {redisTemplate.delete(collection);}/*** 缓存List数据** @param key      缓存的键值* @param dataList 待缓存的List数据* @return 缓存的对象*/public <T> ListOperations<String, T> setCacheList(String key, List<T> dataList) {ListOperations listOperation = redisTemplate.opsForList();if (null != dataList) {int size = dataList.size();for (int i = 0; i < size; i++) {listOperation.leftPush(key, dataList.get(i));}}return listOperation;}/*** 获得缓存的list对象** @param key 缓存的键值* @return 缓存键值对应的数据*/public <T> List<T> getCacheList(String key) {List<T> dataList = new ArrayList<T>();ListOperations<String, T> listOperation = redisTemplate.opsForList();Long size = listOperation.size(key);for (int i = 0; i < size; i++) {dataList.add(listOperation.index(key, i));}return dataList;}/*** 缓存Set** @param key     缓存键值* @param dataSet 缓存的数据* @return 缓存数据的对象*/public <T> BoundSetOperations<String, T> setCacheSet(String key, Set<T> dataSet) {BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);Iterator<T> it = dataSet.iterator();while (it.hasNext()) {setOperation.add(it.next());}return setOperation;}/*** 获得缓存的set** @param key* @return*/public <T> Set<T> getCacheSet(String key) {Set<T> dataSet = new HashSet<T>();BoundSetOperations<String, T> operation = redisTemplate.boundSetOps(key);dataSet = operation.members();return dataSet;}/*** 缓存Map** @param key* @param dataMap* @return*/public <T> HashOperations<String, String, T> setCacheMap(String key, Map<String, T> dataMap) {HashOperations hashOperations = redisTemplate.opsForHash();if (null != dataMap) {for (Map.Entry<String, T> entry : dataMap.entrySet()) {hashOperations.put(key, entry.getKey(), entry.getValue());}}return hashOperations;}/*** 获得缓存的Map** @param key* @return*/public <T> Map<String, T> getCacheMap(String key) {Map<String, T> map = redisTemplate.opsForHash().entries(key);return map;}/*** 获得缓存的基本对象列表** @param pattern 字符串前缀* @return 对象列表*/public Collection<String> keys(String pattern) {return redisTemplate.keys(pattern);}
}

2.3 验证码生成的工具类

该类用于生成4位随机字符串 和 验证码图片输出

package com.ruoyi.common.utils;/*** 验证码工具类** @author ruoyi*/
public class VerifyCodeUtils {// 使用到Algerian字体，系统里没有的话需要安装字体，字体只显示大写，去掉了1,0,i,o几个容易混淆的字符public static final String VERIFY_CODES = "123456789ABCDEFGHJKLMNPQRSTUVWXYZ";private static Random random = new SecureRandom();/*** 使用系统默认字符源生成验证码** @param verifySize 验证码长度* @return*/public static String generateVerifyCode(int verifySize) {return generateVerifyCode(verifySize, VERIFY_CODES);}/*** 使用指定源生成验证码** @param verifySize 验证码长度* @param sources    验证码字符源* @return*/public static String generateVerifyCode(int verifySize, String sources) {if (sources == null || sources.length() == 0) {sources = VERIFY_CODES;}int codesLen = sources.length();Random rand = new Random(System.currentTimeMillis());StringBuilder verifyCode = new StringBuilder(verifySize);for (int i = 0; i < verifySize; i++) {verifyCode.append(sources.charAt(rand.nextInt(codesLen - 1)));}return verifyCode.toString();}/*** 输出指定验证码图片流** @param w* @param h* @param os* @param code* @throws IOException*/public static void outputImage(int w, int h, OutputStream os, String code) throws IOException {int verifySize = code.length();BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);Random rand = new Random();Graphics2D g2 = image.createGraphics();g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);Color[] colors = new Color[5];Color[] colorSpaces = new Color[]{Color.WHITE, Color.CYAN, Color.GRAY, Color.LIGHT_GRAY, Color.MAGENTA,Color.ORANGE, Color.PINK, Color.YELLOW};float[] fractions = new float[colors.length];for (int i = 0; i < colors.length; i++) {colors[i] = colorSpaces[rand.nextInt(colorSpaces.length)];fractions[i] = rand.nextFloat();}Arrays.sort(fractions);g2.setColor(Color.GRAY);// 设置边框色g2.fillRect(0, 0, w, h);Color c = getRandColor(200, 250);g2.setColor(c);// 设置背景色g2.fillRect(0, 2, w, h - 4);// 绘制干扰线Random random = new Random();g2.setColor(getRandColor(160, 200));// 设置线条的颜色for (int i = 0; i < 20; i++) {int x = random.nextInt(w - 1);int y = random.nextInt(h - 1);int xl = random.nextInt(6) + 1;int yl = random.nextInt(12) + 1;g2.drawLine(x, y, x + xl + 40, y + yl + 20);}// 添加噪点float yawpRate = 0.05f;// 噪声率int area = (int) (yawpRate * w * h);for (int i = 0; i < area; i++) {int x = random.nextInt(w);int y = random.nextInt(h);int rgb = getRandomIntColor();image.setRGB(x, y, rgb);}shear(g2, w, h, c);// 使图片扭曲g2.setColor(getRandColor(100, 160));int fontSize = h - 4;Font font = new Font("Algerian", Font.ITALIC, fontSize);g2.setFont(font);char[] chars = code.toCharArray();for (int i = 0; i < verifySize; i++) {AffineTransform affine = new AffineTransform();affine.setToRotation(Math.PI / 4 * rand.nextDouble() * (rand.nextBoolean() ? 1 : -1),(w / verifySize) * i + fontSize / 2, h / 2);g2.setTransform(affine);g2.drawChars(chars, i, 1, ((w - 10) / verifySize) * i + 5, h / 2 + fontSize / 2 - 10);}g2.dispose();ImageIO.write(image, "jpg", os);}private static Color getRandColor(int fc, int bc) {if (fc > 255)fc = 255;if (bc > 255)bc = 255;int r = fc + random.nextInt(bc - fc);int g = fc + random.nextInt(bc - fc);int b = fc + random.nextInt(bc - fc);return new Color(r, g, b);}private static int getRandomIntColor() {int[] rgb = getRandomRgb();int color = 0;for (int c : rgb) {color = color << 8;color = color | c;}return color;}private static int[] getRandomRgb() {int[] rgb = new int[3];for (int i = 0; i < 3; i++) {rgb[i] = random.nextInt(255);}return rgb;}private static void shear(Graphics g, int w1, int h1, Color color) {shearX(g, w1, h1, color);shearY(g, w1, h1, color);}private static void shearX(Graphics g, int w1, int h1, Color color) {int period = random.nextInt(2);boolean borderGap = true;int frames = 1;int phase = random.nextInt(2);for (int i = 0; i < h1; i++) {double d = (double) (period >> 1)* Math.sin((double) i / (double) period + (6.2831853071795862D * (double) phase) / (double) frames);g.copyArea(0, i, w1, 1, (int) d, 0);if (borderGap) {g.setColor(color);g.drawLine((int) d, i, 0, i);g.drawLine((int) d + w1, i, w1, i);}}}private static void shearY(Graphics g, int w1, int h1, Color color) {int period = random.nextInt(40) + 10; // 50;boolean borderGap = true;int frames = 20;int phase = 7;for (int i = 0; i < w1; i++) {double d = (double) (period >> 1)* Math.sin((double) i / (double) period + (6.2831853071795862D * (double) phase) / (double) frames);g.copyArea(i, 0, 1, h1, 0, (int) d);if (borderGap) {g.setColor(color);g.drawLine(i, (int) d, i, 0);g.drawLine(i, (int) d + h1, i, h1);}}}
}

2.4 定义一个统一返回给前台数据的类对象

定义一个类， 用于将封装处理请求结果的数据，返回给前端页面

package com.ruoyi.framework.web.domain;/*** 操作消息提醒** @author ruoyi*/
public class AjaxResult extends HashMap<String, Object> {private static final long serialVersionUID = 1L;/*** 状态码*/public static final String CODE_TAG = "code";/*** 返回内容*/public static final String MSG_TAG = "msg";/*** 数据对象*/public static final String DATA_TAG = "data";/*** 初始化一个新创建的 AjaxResult 对象，使其表示一个空消息。*/public AjaxResult() {}/*** 初始化一个新创建的 AjaxResult 对象** @param code 状态码* @param msg  返回内容*/public AjaxResult(int code, String msg) {super.put(CODE_TAG, code);super.put(MSG_TAG, msg);}/*** 初始化一个新创建的 AjaxResult 对象** @param code 状态码* @param msg  返回内容* @param data 数据对象*/public AjaxResult(int code, String msg, Object data) {super.put(CODE_TAG, code);super.put(MSG_TAG, msg);if (StringUtils.isNotNull(data)) {super.put(DATA_TAG, data);}}/*** 返回成功消息** @return 成功消息*/public static AjaxResult success() {return AjaxResult.success("操作成功");}/*** 返回成功数据** @return 成功消息*/public static AjaxResult success(Object data) {return AjaxResult.success("操作成功", data);}/*** 返回成功消息** @param msg 返回内容* @return 成功消息*/public static AjaxResult success(String msg) {return AjaxResult.success(msg, null);}/*** 返回成功消息** @param msg  返回内容* @param data 数据对象* @return 成功消息*/public static AjaxResult success(String msg, Object data) {return new AjaxResult(HttpStatus.SUCCESS, msg, data);}/*** 返回错误消息** @return*/public static AjaxResult error() {return AjaxResult.error("操作失败");}/*** 返回错误消息** @param msg 返回内容* @return 警告消息*/public static AjaxResult error(String msg) {return AjaxResult.error(msg, null);}/*** 返回错误消息** @param msg  返回内容* @param data 数据对象* @return 警告消息*/public static AjaxResult error(String msg, Object data) {return new AjaxResult(HttpStatus.ERROR, msg, data);}/*** 返回错误消息** @param code 状态码* @param msg  返回内容* @return 警告消息*/public static AjaxResult error(int code, String msg) {return new AjaxResult(code, msg, null);}
}

2.5 定义返回状态码

package com.ruoyi.common.constant;/*** 返回状态码** @author ruoyi*/
public interface HttpStatus {/*** 操作成功*/public static final int SUCCESS = 200;/*** 对象创建成功*/public static final int CREATED = 201;/*** 请求已经被接受*/public static final int ACCEPTED = 202;/*** 操作已经执行成功，但是没有返回数据*/public static final int NO_CONTENT = 204;/*** 资源已被移除*/public static final int MOVED_PERM = 301;/*** 重定向*/public static final int SEE_OTHER = 303;/*** 资源没有被修改*/public static final int NOT_MODIFIED = 304;/*** 参数列表错误（缺少，格式不匹配）*/public static final int BAD_REQUEST = 400;/*** 未授权*/public static final int UNAUTHORIZED = 401;/*** 访问受限，授权过期*/public static final int FORBIDDEN = 403;/*** 资源，服务未找到*/public static final int NOT_FOUND = 404;/*** 不允许的http方法*/public static final int BAD_METHOD = 405;/*** 资源冲突，或者资源被锁*/public static final int CONFLICT = 409;/*** 不支持的数据，媒体类型*/public static final int UNSUPPORTED_TYPE = 415;/*** 系统内部错误*/public static final int ERROR = 500;/*** 接口未实现*/public static final int NOT_IMPLEMENTED = 501;
}

2.6 字符串的工具类

该类封装了对字符串常用操作, 若判断字符串、集合、数组、Map等类型是否为空，字符串去空格，字符串截取等操作

2.6.1 引入常用工具包

		<!--常用工具类 --><dependency><groupId>org.apache.commons</groupId><artifactId>commons-lang3</artifactId></dependency>

2.6.2 字符集工具类

package com.ruoyi.common.core.text;/*** 字符集工具类** @author ruoyi*/
public class CharsetKit {/*** ISO-8859-1*/public static final String ISO_8859_1 = "ISO-8859-1";/*** UTF-8*/public static final String UTF_8 = "UTF-8";/*** GBK*/public static final String GBK = "GBK";/*** ISO-8859-1*/public static final Charset CHARSET_ISO_8859_1 = Charset.forName(ISO_8859_1);/*** UTF-8*/public static final Charset CHARSET_UTF_8 = Charset.forName(UTF_8);/*** GBK*/public static final Charset CHARSET_GBK = Charset.forName(GBK);/*** 转换为Charset对象** @param charset 字符集，为空则返回默认字符集* @return Charset*/public static Charset charset(String charset) {return StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset);}/*** 转换字符串的字符集编码** @param source      字符串* @param srcCharset  源字符集，默认ISO-8859-1* @param destCharset 目标字符集，默认UTF-8* @return 转换后的字符集*/public static String convert(String source, String srcCharset, String destCharset) {return convert(source, Charset.forName(srcCharset), Charset.forName(destCharset));}/*** 转换字符串的字符集编码** @param source      字符串* @param srcCharset  源字符集，默认ISO-8859-1* @param destCharset 目标字符集，默认UTF-8* @return 转换后的字符集*/public static String convert(String source, Charset srcCharset, Charset destCharset) {if (null == srcCharset) {srcCharset = StandardCharsets.ISO_8859_1;}if (null == destCharset) {srcCharset = StandardCharsets.UTF_8;}if (StringUtils.isEmpty(source) || srcCharset.equals(destCharset)) {return source;}return new String(source.getBytes(srcCharset), destCharset);}/*** @return 系统字符集编码*/public static String systemCharset() {return Charset.defaultCharset().name();}
}

2.6.3 类型转换器

package com.ruoyi.common.core.text;/*** 类型转换器** @author ruoyi*/
public class Convert {/*** 转换为字符串<br>* 如果给定的值为null，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static String toStr(Object value, String defaultValue) {if (null == value) {return defaultValue;}if (value instanceof String) {return (String) value;}return value.toString();}/*** 转换为字符串<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static String toStr(Object value) {return toStr(value, null);}/*** 转换为字符<br>* 如果给定的值为null，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Character toChar(Object value, Character defaultValue) {if (null == value) {return defaultValue;}if (value instanceof Character) {return (Character) value;}final String valueStr = toStr(value, null);return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);}/*** 转换为字符<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Character toChar(Object value) {return toChar(value, null);}/*** 转换为byte<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Byte toByte(Object value, Byte defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Byte) {return (Byte) value;}if (value instanceof Number) {return ((Number) value).byteValue();}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return Byte.parseByte(valueStr);} catch (Exception e) {return defaultValue;}}/*** 转换为byte<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Byte toByte(Object value) {return toByte(value, null);}/*** 转换为Short<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Short toShort(Object value, Short defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Short) {return (Short) value;}if (value instanceof Number) {return ((Number) value).shortValue();}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return Short.parseShort(valueStr.trim());} catch (Exception e) {return defaultValue;}}/*** 转换为Short<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Short toShort(Object value) {return toShort(value, null);}/*** 转换为Number<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Number toNumber(Object value, Number defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Number) {return (Number) value;}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return NumberFormat.getInstance().parse(valueStr);} catch (Exception e) {return defaultValue;}}/*** 转换为Number<br>* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Number toNumber(Object value) {return toNumber(value, null);}/*** 转换为int<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Integer toInt(Object value, Integer defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Integer) {return (Integer) value;}if (value instanceof Number) {return ((Number) value).intValue();}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return Integer.parseInt(valueStr.trim());} catch (Exception e) {return defaultValue;}}/*** 转换为int<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Integer toInt(Object value) {return toInt(value, null);}/*** 转换为Integer数组<br>** @param str 被转换的值* @return 结果*/public static Integer[] toIntArray(String str) {return toIntArray(",", str);}/*** 转换为Long数组<br>** @param str 被转换的值* @return 结果*/public static Long[] toLongArray(String str) {return toLongArray(",", str);}/*** 转换为Integer数组<br>** @param split 分隔符* @param split 被转换的值* @return 结果*/public static Integer[] toIntArray(String split, String str) {if (StringUtils.isEmpty(str)) {return new Integer[]{};}String[] arr = str.split(split);final Integer[] ints = new Integer[arr.length];for (int i = 0; i < arr.length; i++) {final Integer v = toInt(arr[i], 0);ints[i] = v;}return ints;}/*** 转换为Long数组<br>** @param split 分隔符* @param str   被转换的值* @return 结果*/public static Long[] toLongArray(String split, String str) {if (StringUtils.isEmpty(str)) {return new Long[]{};}String[] arr = str.split(split);final Long[] longs = new Long[arr.length];for (int i = 0; i < arr.length; i++) {final Long v = toLong(arr[i], null);longs[i] = v;}return longs;}/*** 转换为String数组<br>** @param str 被转换的值* @return 结果*/public static String[] toStrArray(String str) {return toStrArray(",", str);}/*** 转换为String数组<br>** @param split 分隔符* @param split 被转换的值* @return 结果*/public static String[] toStrArray(String split, String str) {return str.split(split);}/*** 转换为long<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Long toLong(Object value, Long defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Long) {return (Long) value;}if (value instanceof Number) {return ((Number) value).longValue();}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {// 支持科学计数法return new BigDecimal(valueStr.trim()).longValue();} catch (Exception e) {return defaultValue;}}/*** 转换为long<br>* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Long toLong(Object value) {return toLong(value, null);}/*** 转换为double<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Double toDouble(Object value, Double defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Double) {return (Double) value;}if (value instanceof Number) {return ((Number) value).doubleValue();}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {// 支持科学计数法return new BigDecimal(valueStr.trim()).doubleValue();} catch (Exception e) {return defaultValue;}}/*** 转换为double<br>* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Double toDouble(Object value) {return toDouble(value, null);}/*** 转换为Float<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Float toFloat(Object value, Float defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Float) {return (Float) value;}if (value instanceof Number) {return ((Number) value).floatValue();}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return Float.parseFloat(valueStr.trim());} catch (Exception e) {return defaultValue;}}/*** 转换为Float<br>* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Float toFloat(Object value) {return toFloat(value, null);}/*** 转换为boolean<br>* String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static Boolean toBool(Object value, Boolean defaultValue) {if (value == null) {return defaultValue;}if (value instanceof Boolean) {return (Boolean) value;}String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}valueStr = valueStr.trim().toLowerCase();switch (valueStr) {case "true":return true;case "false":return false;case "yes":return true;case "ok":return true;case "no":return false;case "1":return true;case "0":return false;default:return defaultValue;}}/*** 转换为boolean<br>* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static Boolean toBool(Object value) {return toBool(value, null);}/*** 转换为Enum对象<br>* 如果给定的值为空，或者转换失败，返回默认值<br>** @param clazz        Enum的Class* @param value        值* @param defaultValue 默认值* @return Enum*/public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue) {if (value == null) {return defaultValue;}if (clazz.isAssignableFrom(value.getClass())) {@SuppressWarnings("unchecked")E myE = (E) value;return myE;}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return Enum.valueOf(clazz, valueStr);} catch (Exception e) {return defaultValue;}}/*** 转换为Enum对象<br>* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>** @param clazz Enum的Class* @param value 值* @return Enum*/public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value) {return toEnum(clazz, value, null);}/*** 转换为BigInteger<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static BigInteger toBigInteger(Object value, BigInteger defaultValue) {if (value == null) {return defaultValue;}if (value instanceof BigInteger) {return (BigInteger) value;}if (value instanceof Long) {return BigInteger.valueOf((Long) value);}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return new BigInteger(valueStr);} catch (Exception e) {return defaultValue;}}/*** 转换为BigInteger<br>* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static BigInteger toBigInteger(Object value) {return toBigInteger(value, null);}/*** 转换为BigDecimal<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value        被转换的值* @param defaultValue 转换错误时的默认值* @return 结果*/public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue) {if (value == null) {return defaultValue;}if (value instanceof BigDecimal) {return (BigDecimal) value;}if (value instanceof Long) {return new BigDecimal((Long) value);}if (value instanceof Double) {return new BigDecimal((Double) value);}if (value instanceof Integer) {return new BigDecimal((Integer) value);}final String valueStr = toStr(value, null);if (StringUtils.isEmpty(valueStr)) {return defaultValue;}try {return new BigDecimal(valueStr);} catch (Exception e) {return defaultValue;}}/*** 转换为BigDecimal<br>* 如果给定的值为空，或者转换失败，返回默认值<br>* 转换失败不会报错** @param value 被转换的值* @return 结果*/public static BigDecimal toBigDecimal(Object value) {return toBigDecimal(value, null);}/*** 将对象转为字符串<br>* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法** @param obj 对象* @return 字符串*/public static String utf8Str(Object obj) {return str(obj, CharsetKit.CHARSET_UTF_8);}/*** 将对象转为字符串<br>* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法** @param obj         对象* @param charsetName 字符集* @return 字符串*/public static String str(Object obj, String charsetName) {return str(obj, Charset.forName(charsetName));}/*** 将对象转为字符串<br>* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法** @param obj     对象* @param charset 字符集* @return 字符串*/public static String str(Object obj, Charset charset) {if (null == obj) {return null;}if (obj instanceof String) {return (String) obj;} else if (obj instanceof byte[] || obj instanceof Byte[]) {return str((Byte[]) obj, charset);} else if (obj instanceof ByteBuffer) {return str((ByteBuffer) obj, charset);}return obj.toString();}/*** 将byte数组转为字符串** @param bytes   byte数组* @param charset 字符集* @return 字符串*/public static String str(byte[] bytes, String charset) {return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));}/*** 解码字节码** @param data    字符串* @param charset 字符集，如果此字段为空，则解码的结果取决于平台* @return 解码后的字符串*/public static String str(byte[] data, Charset charset) {if (data == null) {return null;}if (null == charset) {return new String(data);}return new String(data, charset);}/*** 将编码的byteBuffer数据转换为字符串** @param data    数据* @param charset 字符集，如果为空使用当前系统字符集* @return 字符串*/public static String str(ByteBuffer data, String charset) {if (data == null) {return null;}return str(data, Charset.forName(charset));}/*** 将编码的byteBuffer数据转换为字符串** @param data    数据* @param charset 字符集，如果为空使用当前系统字符集* @return 字符串*/public static String str(ByteBuffer data, Charset charset) {if (null == charset) {charset = Charset.defaultCharset();}return charset.decode(data).toString();}// ----------------------------------------------------------------------- 全角半角转换/*** 半角转全角** @param input String.* @return 全角字符串.*/public static String toSBC(String input) {return toSBC(input, null);}/*** 半角转全角** @param input         String* @param notConvertSet 不替换的字符集合* @return 全角字符串.*/public static String toSBC(String input, Set<Character> notConvertSet) {char c[] = input.toCharArray();for (int i = 0; i < c.length; i++) {if (null != notConvertSet && notConvertSet.contains(c[i])) {// 跳过不替换的字符continue;}if (c[i] == ' ') {c[i] = '\u3000';} else if (c[i] < '\177') {c[i] = (char) (c[i] + 65248);}}return new String(c);}/*** 全角转半角** @param input String.* @return 半角字符串*/public static String toDBC(String input) {return toDBC(input, null);}/*** 替换全角为半角** @param text          文本* @param notConvertSet 不替换的字符集合* @return 替换后的字符*/public static String toDBC(String text, Set<Character> notConvertSet) {char c[] = text.toCharArray();for (int i = 0; i < c.length; i++) {if (null != notConvertSet && notConvertSet.contains(c[i])) {// 跳过不替换的字符continue;}if (c[i] == '\u3000') {c[i] = ' ';} else if (c[i] > '\uFF00' && c[i] < '\uFF5F') {c[i] = (char) (c[i] - 65248);}}String returnString = new String(c);return returnString;}/*** 数字金额大写转换 先写个完整的然后将如零拾替换成零** @param n 数字* @return 中文大写数字*/public static String digitUppercase(double n) {String[] fraction = {"角", "分"};String[] digit = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};String[][] unit = {{"元", "万", "亿"}, {"", "拾", "佰", "仟"}};String head = n < 0 ? "负" : "";n = Math.abs(n);String s = "";for (int i = 0; i < fraction.length; i++) {s += (digit[(int) (Math.floor(n * 10 * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", "");}if (s.length() < 1) {s = "整";}int integerPart = (int) Math.floor(n);for (int i = 0; i < unit[0].length && integerPart > 0; i++) {String p = "";for (int j = 0; j < unit[1].length && n > 0; j++) {p = digit[integerPart % 10] + unit[1][j] + p;integerPart = integerPart / 10;}s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;}return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");}
}

2.6.4 字符串格式化

package com.ruoyi.common.core.text;/*** 字符串格式化** @author ruoyi*/
public class StrFormatter {public static final String EMPTY_JSON = "{}";public static final char C_BACKSLASH = '\\';public static final char C_DELIM_START = '{';public static final char C_DELIM_END = '}';/*** 格式化字符串<br>* 此方法只是简单将占位符 {} 按照顺序替换为参数<br>* 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>* 例：<br>* 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>* 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>* 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>** @param strPattern 字符串模板* @param argArray   参数列表* @return 结果*/public static String format(final String strPattern, final Object... argArray) {if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray)) {return strPattern;}final int strPatternLength = strPattern.length();// 初始化定义好的长度以获得更好的性能StringBuilder sbuf = new StringBuilder(strPatternLength + 50);int handledPosition = 0;int delimIndex;// 占位符所在位置for (int argIndex = 0; argIndex < argArray.length; argIndex++) {delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);if (delimIndex == -1) {if (handledPosition == 0) {return strPattern;} else { // 字符串模板剩余部分不再包含占位符，加入剩余部分后返回结果sbuf.append(strPattern, handledPosition, strPatternLength);return sbuf.toString();}} else {if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH) {if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH) {// 转义符之前还有一个转义符，占位符依旧有效sbuf.append(strPattern, handledPosition, delimIndex - 1);sbuf.append(Convert.utf8Str(argArray[argIndex]));handledPosition = delimIndex + 2;} else {// 占位符被转义argIndex--;sbuf.append(strPattern, handledPosition, delimIndex - 1);sbuf.append(C_DELIM_START);handledPosition = delimIndex + 1;}} else {// 正常占位符sbuf.append(strPattern, handledPosition, delimIndex);sbuf.append(Convert.utf8Str(argArray[argIndex]));handledPosition = delimIndex + 2;}}}// 加入最后一个占位符后所有的字符sbuf.append(strPattern, handledPosition, strPattern.length());return sbuf.toString();}
}

2.6.5 字符串工具类

package com.ruoyi.common.utils;/*** 字符串工具类** @author ruoyi*/
public class StringUtils extends org.apache.commons.lang3.StringUtils {/*** 空字符串*/private static final String NULLSTR = "";/*** 下划线*/private static final char SEPARATOR = '_';/*** 获取参数不为空值** @param value defaultValue 要判断的value* @return value 返回值*/public static <T> T nvl(T value, T defaultValue) {return value != null ? value : defaultValue;}/*** * 判断一个Collection是否为空， 包含List，Set，Queue** @param coll 要判断的Collection* @return true：为空 false：非空*/public static boolean isEmpty(Collection<?> coll) {return isNull(coll) || coll.isEmpty();}/*** * 判断一个Collection是否非空，包含List，Set，Queue** @param coll 要判断的Collection* @return true：非空 false：空*/public static boolean isNotEmpty(Collection<?> coll) {return !isEmpty(coll);}/*** * 判断一个对象数组是否为空** @param objects 要判断的对象数组*                * @return true：为空 false：非空*/public static boolean isEmpty(Object[] objects) {return isNull(objects) || (objects.length == 0);}/*** * 判断一个对象数组是否非空** @param objects 要判断的对象数组* @return true：非空 false：空*/public static boolean isNotEmpty(Object[] objects) {return !isEmpty(objects);}/*** * 判断一个Map是否为空** @param map 要判断的Map* @return true：为空 false：非空*/public static boolean isEmpty(Map<?, ?> map) {return isNull(map) || map.isEmpty();}/*** * 判断一个Map是否为空** @param map 要判断的Map* @return true：非空 false：空*/public static boolean isNotEmpty(Map<?, ?> map) {return !isEmpty(map);}/*** * 判断一个字符串是否为空串** @param str String* @return true：为空 false：非空*/public static boolean isEmpty(String str) {return isNull(str) || NULLSTR.equals(str.trim());}/*** * 判断一个字符串是否为非空串** @param str String* @return true：非空串 false：空串*/public static boolean isNotEmpty(String str) {return !isEmpty(str);}/*** * 判断一个对象是否为空** @param object Object* @return true：为空 false：非空*/public static boolean isNull(Object object) {return object == null;}/*** * 判断一个对象是否非空** @param object Object* @return true：非空 false：空*/public static boolean isNotNull(Object object) {return !isNull(object);}/*** * 判断一个对象是否是数组类型（Java基本型别的数组）** @param object 对象* @return true：是数组 false：不是数组*/public static boolean isArray(Object object) {return isNotNull(object) && object.getClass().isArray();}/*** 去空格*/public static String trim(String str) {return (str == null ? "" : str.trim());}/*** 截取字符串** @param str   字符串* @param start 开始* @return 结果*/public static String substring(final String str, int start) {if (str == null) {return NULLSTR;}if (start < 0) {start = str.length() + start;}if (start < 0) {start = 0;}if (start > str.length()) {return NULLSTR;}return str.substring(start);}/*** 截取字符串** @param str   字符串* @param start 开始* @param end   结束* @return 结果*/public static String substring(final String str, int start, int end) {if (str == null) {return NULLSTR;}if (end < 0) {end = str.length() + end;}if (start < 0) {start = str.length() + start;}if (end > str.length()) {end = str.length();}if (start > end) {return NULLSTR;}if (start < 0) {start = 0;}if (end < 0) {end = 0;}return str.substring(start, end);}/*** 格式化文本, {} 表示占位符<br>* 此方法只是简单将占位符 {} 按照顺序替换为参数<br>* 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>* 例：<br>* 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>* 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>* 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>** @param template 文本模板，被替换的部分用 {} 表示* @param params   参数值* @return 格式化后的文本*/public static String format(String template, Object... params) {if (isEmpty(params) || isEmpty(template)) {return template;}return StrFormatter.format(template, params);}/*** 字符串转set** @param str 字符串* @param sep 分隔符* @return set集合*/public static final Set<String> str2Set(String str, String sep) {return new HashSet<String>(str2List(str, sep, true, false));}/*** 字符串转list** @param str         字符串* @param sep         分隔符* @param filterBlank 过滤纯空白* @param trim        去掉首尾空白* @return list集合*/public static final List<String> str2List(String str, String sep, boolean filterBlank, boolean trim) {List<String> list = new ArrayList<String>();if (StringUtils.isEmpty(str)) {return list;}// 过滤空白字符串if (filterBlank && StringUtils.isBlank(str)) {return list;}String[] split = str.split(sep);for (String string : split) {if (filterBlank && StringUtils.isBlank(string)) {continue;}if (trim) {string = string.trim();}list.add(string);}return list;}/*** 下划线转驼峰命名*/public static String toUnderScoreCase(String str) {if (str == null) {return null;}StringBuilder sb = new StringBuilder();// 前置字符是否大写boolean preCharIsUpperCase = true;// 当前字符是否大写boolean curreCharIsUpperCase = true;// 下一字符是否大写boolean nexteCharIsUpperCase = true;for (int i = 0; i < str.length(); i++) {char c = str.charAt(i);if (i > 0) {preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));} else {preCharIsUpperCase = false;}curreCharIsUpperCase = Character.isUpperCase(c);if (i < (str.length() - 1)) {nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));}if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase) {sb.append(SEPARATOR);} else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase) {sb.append(SEPARATOR);}sb.append(Character.toLowerCase(c));}return sb.toString();}/*** 是否包含字符串** @param str  验证字符串* @param strs 字符串组* @return 包含返回true*/public static boolean inStringIgnoreCase(String str, String... strs) {if (str != null && strs != null) {for (String s : strs) {if (str.equalsIgnoreCase(trim(s))) {return true;}}}return false;}/*** 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld** @param name 转换前的下划线大写方式命名的字符串* @return 转换后的驼峰式命名的字符串*/public static String convertToCamelCase(String name) {StringBuilder result = new StringBuilder();// 快速检查if (name == null || name.isEmpty()) {// 没必要转换return "";} else if (!name.contains("_")) {// 不含下划线，仅将首字母大写return name.substring(0, 1).toUpperCase() + name.substring(1);}// 用下划线将原始字符串分割String[] camels = name.split("_");for (String camel : camels) {// 跳过原始字符串中开头、结尾的下换线或双重下划线if (camel.isEmpty()) {continue;}// 首字母大写result.append(camel.substring(0, 1).toUpperCase());result.append(camel.substring(1).toLowerCase());}return result.toString();}/*** 驼峰式命名法 例如：user_name->userName*/public static String toCamelCase(String s) {if (s == null) {return null;}s = s.toLowerCase();StringBuilder sb = new StringBuilder(s.length());boolean upperCase = false;for (int i = 0; i < s.length(); i++) {char c = s.charAt(i);if (c == SEPARATOR) {upperCase = true;} else if (upperCase) {sb.append(Character.toUpperCase(c));upperCase = false;} else {sb.append(c);}}return sb.toString();}
}

2.7 UUID生成工具类

定义一个 UUID 类

package com.ruoyi.common.core.lang;/*** 提供通用唯一识别码（universally unique identifier）（UUID）实现** @author ruoyi*/
public final class UUID implements java.io.Serializable, Comparable<UUID> {private static final long serialVersionUID = -1185015143654744140L;/*** SecureRandom 的单例*/private static class Holder {static final SecureRandom numberGenerator = getSecureRandom();}/*** 此UUID的最高64有效位*/private final long mostSigBits;/*** 此UUID的最低64有效位*/private final long leastSigBits;/*** 私有构造** @param data 数据*/private UUID(byte[] data) {long msb = 0;long lsb = 0;assert data.length == 16 : "data must be 16 bytes in length";for (int i = 0; i < 8; i++) {msb = (msb << 8) | (data[i] & 0xff);}for (int i = 8; i < 16; i++) {lsb = (lsb << 8) | (data[i] & 0xff);}this.mostSigBits = msb;this.leastSigBits = lsb;}/*** 使用指定的数据构造新的 UUID。** @param mostSigBits  用于 {@code UUID} 的最高有效 64 位* @param leastSigBits 用于 {@code UUID} 的最低有效 64 位*/public UUID(long mostSigBits, long leastSigBits) {this.mostSigBits = mostSigBits;this.leastSigBits = leastSigBits;}/*** 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的本地线程伪随机数生成器生成该 UUID。** @return 随机生成的 {@code UUID}*/public static UUID fastUUID() {return randomUUID(false);}/*** 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的强伪随机数生成器生成该 UUID。** @return 随机生成的 {@code UUID}*/public static UUID randomUUID() {return randomUUID(true);}/*** 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的强伪随机数生成器生成该 UUID。** @param isSecure 是否使用{@link SecureRandom}如果是可以获得更安全的随机码，否则可以得到更好的性能* @return 随机生成的 {@code UUID}*/public static UUID randomUUID(boolean isSecure) {final Random ng = isSecure ? Holder.numberGenerator : getRandom();byte[] randomBytes = new byte[16];ng.nextBytes(randomBytes);randomBytes[6] &= 0x0f; /* clear version */randomBytes[6] |= 0x40; /* set to version 4 */randomBytes[8] &= 0x3f; /* clear variant */randomBytes[8] |= 0x80; /* set to IETF variant */return new UUID(randomBytes);}/*** 根据指定的字节数组获取类型 3（基于名称的）UUID 的静态工厂。** @param name 用于构造 UUID 的字节数组。* @return 根据指定数组生成的 {@code UUID}*/public static UUID nameUUIDFromBytes(byte[] name) {MessageDigest md;try {md = MessageDigest.getInstance("MD5");} catch (NoSuchAlgorithmException nsae) {throw new InternalError("MD5 not supported");}byte[] md5Bytes = md.digest(name);md5Bytes[6] &= 0x0f; /* clear version */md5Bytes[6] |= 0x30; /* set to version 3 */md5Bytes[8] &= 0x3f; /* clear variant */md5Bytes[8] |= 0x80; /* set to IETF variant */return new UUID(md5Bytes);}/*** 根据 {@link #toString()} 方法中描述的字符串标准表示形式创建{@code UUID}。** @param name 指定 {@code UUID} 字符串* @return 具有指定值的 {@code UUID}* @throws IllegalArgumentException 如果 name 与 {@link #toString} 中描述的字符串表示形式不符抛出此异常*/public static UUID fromString(String name) {String[] components = name.split("-");if (components.length != 5) {throw new IllegalArgumentException("Invalid UUID string: " + name);}for (int i = 0; i < 5; i++) {components[i] = "0x" + components[i];}long mostSigBits = Long.decode(components[0]).longValue();mostSigBits <<= 16;mostSigBits |= Long.decode(components[1]).longValue();mostSigBits <<= 16;mostSigBits |= Long.decode(components[2]).longValue();long leastSigBits = Long.decode(components[3]).longValue();leastSigBits <<= 48;leastSigBits |= Long.decode(components[4]).longValue();return new UUID(mostSigBits, leastSigBits);}/*** 返回此 UUID 的 128 位值中的最低有效 64 位。** @return 此 UUID 的 128 位值中的最低有效 64 位。*/public long getLeastSignificantBits() {return leastSigBits;}/*** 返回此 UUID 的 128 位值中的最高有效 64 位。** @return 此 UUID 的 128 位值中最高有效 64 位。*/public long getMostSignificantBits() {return mostSigBits;}/*** 与此 {@code UUID} 相关联的版本号. 版本号描述此 {@code UUID} 是如何生成的。* <p>* 版本号具有以下含意:* <ul>* <li>1 基于时间的 UUID* <li>2 DCE 安全 UUID* <li>3 基于名称的 UUID* <li>4 随机生成的 UUID* </ul>** @return 此 {@code UUID} 的版本号*/public int version() {// Version is bits masked by 0x000000000000F000 in MS longreturn (int) ((mostSigBits >> 12) & 0x0f);}/*** 与此 {@code UUID} 相关联的变体号。变体号描述 {@code UUID} 的布局。* <p>* 变体号具有以下含意：* <ul>* <li>0 为 NCS 向后兼容保留* <li>2 <a href="http://www.ietf.org/rfc/rfc4122.txt">IETF&nbsp;RFC&nbsp;4122</a>(Leach-Salz), 用于此类* <li>6 保留，微软向后兼容* <li>7 保留供以后定义使用* </ul>** @return 此 {@code UUID} 相关联的变体号*/public int variant() {// This field is composed of a varying number of bits.// 0 - - Reserved for NCS backward compatibility// 1 0 - The IETF aka Leach-Salz variant (used by this class)// 1 1 0 Reserved, Microsoft backward compatibility// 1 1 1 Reserved for future definition.return (int) ((leastSigBits >>> (64 - (leastSigBits >>> 62))) & (leastSigBits >> 63));}/*** 与此 UUID 相关联的时间戳值。** <p>* 60 位的时间戳值根据此 {@code UUID} 的 time_low、time_mid 和 time_hi 字段构造。<br>* 所得到的时间戳以 100 毫微秒为单位，从 UTC（通用协调时间） 1582 年 10 月 15 日零时开始。** <p>* 时间戳值仅在在基于时间的 UUID（其 version 类型为 1）中才有意义。<br>* 如果此 {@code UUID} 不是基于时间的 UUID，则此方法抛出 UnsupportedOperationException。** @throws UnsupportedOperationException 如果此 {@code UUID} 不是 version 为 1 的 UUID。*/public long timestamp() throws UnsupportedOperationException {checkTimeBase();return (mostSigBits & 0x0FFFL) << 48//| ((mostSigBits >> 16) & 0x0FFFFL) << 32//| mostSigBits >>> 32;}/*** 与此 UUID 相关联的时钟序列值。** <p>* 14 位的时钟序列值根据此 UUID 的 clock_seq 字段构造。clock_seq 字段用于保证在基于时间的 UUID 中的时间唯一性。* <p>* {@code clockSequence} 值仅在基于时间的 UUID（其 version 类型为 1）中才有意义。 如果此 UUID 不是基于时间的 UUID，则此方法抛出* UnsupportedOperationException。** @return 此 {@code UUID} 的时钟序列* @throws UnsupportedOperationException 如果此 UUID 的 version 不为 1*/public int clockSequence() throws UnsupportedOperationException {checkTimeBase();return (int) ((leastSigBits & 0x3FFF000000000000L) >>> 48);}/*** 与此 UUID 相关的节点值。** <p>* 48 位的节点值根据此 UUID 的 node 字段构造。此字段旨在用于保存机器的 IEEE 802 地址，该地址用于生成此 UUID 以保证空间唯一性。* <p>* 节点值仅在基于时间的 UUID（其 version 类型为 1）中才有意义。<br>* 如果此 UUID 不是基于时间的 UUID，则此方法抛出 UnsupportedOperationException。** @return 此 {@code UUID} 的节点值* @throws UnsupportedOperationException 如果此 UUID 的 version 不为 1*/public long node() throws UnsupportedOperationException {checkTimeBase();return leastSigBits & 0x0000FFFFFFFFFFFFL;}/*** 返回此{@code UUID} 的字符串表现形式。** <p>* UUID 的字符串表示形式由此 BNF 描述：** <pre>* {@code* UUID                   = <time_low>-<time_mid>-<time_high_and_version>-<variant_and_sequence>-<node>* time_low               = 4*<hexOctet>* time_mid               = 2*<hexOctet>* time_high_and_version  = 2*<hexOctet>* variant_and_sequence   = 2*<hexOctet>* node                   = 6*<hexOctet>* hexOctet               = <hexDigit><hexDigit>* hexDigit               = [0-9a-fA-F]* }* </pre>** </blockquote>** @return 此{@code UUID} 的字符串表现形式* @see #toString(boolean)*/@Overridepublic String toString() {return toString(false);}/*** 返回此{@code UUID} 的字符串表现形式。** <p>* UUID 的字符串表示形式由此 BNF 描述：** <pre>* {@code* UUID                   = <time_low>-<time_mid>-<time_high_and_version>-<variant_and_sequence>-<node>* time_low               = 4*<hexOctet>* time_mid               = 2*<hexOctet>* time_high_and_version  = 2*<hexOctet>* variant_and_sequence   = 2*<hexOctet>* node                   = 6*<hexOctet>* hexOctet               = <hexDigit><hexDigit>* hexDigit               = [0-9a-fA-F]* }* </pre>** </blockquote>** @param isSimple 是否简单模式，简单模式为不带'-'的UUID字符串* @return 此{@code UUID} 的字符串表现形式*/public String toString(boolean isSimple) {final StringBuilder builder = new StringBuilder(isSimple ? 32 : 36);// time_lowbuilder.append(digits(mostSigBits >> 32, 8));if (false == isSimple) {builder.append('-');}// time_midbuilder.append(digits(mostSigBits >> 16, 4));if (false == isSimple) {builder.append('-');}// time_high_and_versionbuilder.append(digits(mostSigBits, 4));if (false == isSimple) {builder.append('-');}// variant_and_sequencebuilder.append(digits(leastSigBits >> 48, 4));if (false == isSimple) {builder.append('-');}// nodebuilder.append(digits(leastSigBits, 12));return builder.toString();}/*** 返回此 UUID 的哈希码。** @return UUID 的哈希码值。*/public int hashCode() {long hilo = mostSigBits ^ leastSigBits;return ((int) (hilo >> 32)) ^ (int) hilo;}/*** 将此对象与指定对象比较。* <p>* 当且仅当参数不为 {@code null}、而是一个 UUID 对象、具有与此 UUID 相同的 varriant、包含相同的值（每一位均相同）时，结果才为 {@code true}。** @param obj 要与之比较的对象* @return 如果对象相同，则返回 {@code true}；否则返回 {@code false}*/public boolean equals(Object obj) {if ((null == obj) || (obj.getClass() != UUID.class)) {return false;}UUID id = (UUID) obj;return (mostSigBits == id.mostSigBits && leastSigBits == id.leastSigBits);}// Comparison Operations/*** 将此 UUID 与指定的 UUID 比较。** <p>* 如果两个 UUID 不同，且第一个 UUID 的最高有效字段大于第二个 UUID 的对应字段，则第一个 UUID 大于第二个 UUID。** @param val 与此 UUID 比较的 UUID* @return 在此 UUID 小于、等于或大于 val 时，分别返回 -1、0 或 1。*/public int compareTo(UUID val) {// The ordering is intentionally set up so that the UUIDs// can simply be numerically compared as two numbersreturn (this.mostSigBits < val.mostSigBits ? -1 : //(this.mostSigBits > val.mostSigBits ? 1 : //(this.leastSigBits < val.leastSigBits ? -1 : //(this.leastSigBits > val.leastSigBits ? 1 : //0))));}// -------------------------------------------------------------------------------------------------------------------// Private method start/*** 返回指定数字对应的hex值** @param val    值* @param digits 位* @return 值*/private static String digits(long val, int digits) {long hi = 1L << (digits * 4);return Long.toHexString(hi | (val & (hi - 1))).substring(1);}/*** 检查是否为time-based版本UUID*/private void checkTimeBase() {if (version() != 1) {throw new UnsupportedOperationException("Not a time-based UUID");}}/*** 获取{@link SecureRandom}，类提供加密的强随机数生成器 (RNG)** @return {@link SecureRandom}*/public static SecureRandom getSecureRandom() {try {return SecureRandom.getInstance("SHA1PRNG");} catch (NoSuchAlgorithmException e) {throw new RuntimeException(e);}}/*** 获取随机数生成器对象<br>* ThreadLocalRandom是JDK 7之后提供并发产生随机数，能够解决多个线程发生的竞争争夺。** @return {@link ThreadLocalRandom}*/public static ThreadLocalRandom getRandom() {return ThreadLocalRandom.current();}
}

ID生成器工具类

package com.ruoyi.common.utils;/*** ID生成器工具类** @author ruoyi*/
public class IdUtils {/*** 获取随机UUID** @return 随机UUID*/public static String randomUUID() {return UUID.randomUUID().toString();}/*** 简化的UUID，去掉了横线** @return 简化的UUID，去掉了横线*/public static String simpleUUID() {return UUID.randomUUID().toString(true);}/*** 获取随机UUID，使用性能更好的ThreadLocalRandom生成UUID** @return 随机UUID*/public static String fastUUID() {return UUID.fastUUID().toString();}/*** 简化的UUID，去掉了横线，使用性能更好的ThreadLocalRandom生成UUID** @return 简化的UUID，去掉了横线*/public static String fastSimpleUUID() {return UUID.fastUUID().toString(true);}
}

2.8 通用常量类

package com.ruoyi.common.constant;
/*** 通用常量信息** @author ruoyi*/
public class Constants {/*** UTF-8 字符集*/public static final String UTF8 = "UTF-8";/*** 通用成功标识*/public static final String SUCCESS = "0";/*** 通用失败标识*/public static final String FAIL = "1";/*** 登录成功*/public static final String LOGIN_SUCCESS = "Success";/*** 注销*/public static final String LOGOUT = "Logout";/*** 登录失败*/public static final String LOGIN_FAIL = "Error";/*** 验证码 redis key*/public static final String CAPTCHA_CODE_KEY = "captcha_codes:";/*** 登录用户 redis key*/public static final String LOGIN_TOKEN_KEY = "login_tokens:";/*** 验证码有效期（分钟）*/public static final Integer CAPTCHA_EXPIRATION = 2;/*** 令牌*/public static final String TOKEN = "token";/*** 令牌前缀*/public static final String TOKEN_PREFIX = "Bearer ";/*** 令牌前缀*/public static final String LOGIN_USER_KEY = "login_user_key";/*** 用户ID*/public static final String JWT_USERID = "userid";/*** 用户名称*///public static final String JWT_USERNAME = Claims.SUBJECT;/*** 用户头像*/public static final String JWT_AVATAR = "avatar";/*** 创建时间*/public static final String JWT_CREATED = "created";/*** 用户权限*/public static final String JWT_AUTHORITIES = "authorities";/*** 资源映射路径 前缀*/public static final String RESOURCE_PREFIX = "/profile";
}

2.9 base64 编码工具

package com.ruoyi.common.utils.sign;/*** Base64工具类** @author ruoyi*/
public final class Base64 {static private final int BASELENGTH = 128;static private final int LOOKUPLENGTH = 64;static private final int TWENTYFOURBITGROUP = 24;static private final int EIGHTBIT = 8;static private final int SIXTEENBIT = 16;static private final int FOURBYTE = 4;static private final int SIGN = -128;static private final char PAD = '=';static final private byte[] base64Alphabet = new byte[BASELENGTH];static final private char[] lookUpBase64Alphabet = new char[LOOKUPLENGTH];static {for (int i = 0; i < BASELENGTH; ++i) {base64Alphabet[i] = -1;}for (int i = 'Z'; i >= 'A'; i--) {base64Alphabet[i] = (byte) (i - 'A');}for (int i = 'z'; i >= 'a'; i--) {base64Alphabet[i] = (byte) (i - 'a' + 26);}for (int i = '9'; i >= '0'; i--) {base64Alphabet[i] = (byte) (i - '0' + 52);}base64Alphabet['+'] = 62;base64Alphabet['/'] = 63;for (int i = 0; i <= 25; i++) {lookUpBase64Alphabet[i] = (char) ('A' + i);}for (int i = 26, j = 0; i <= 51; i++, j++) {lookUpBase64Alphabet[i] = (char) ('a' + j);}for (int i = 52, j = 0; i <= 61; i++, j++) {lookUpBase64Alphabet[i] = (char) ('0' + j);}lookUpBase64Alphabet[62] = (char) '+';lookUpBase64Alphabet[63] = (char) '/';}private static boolean isWhiteSpace(char octect) {return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);}private static boolean isPad(char octect) {return (octect == PAD);}private static boolean isData(char octect) {return (octect < BASELENGTH && base64Alphabet[octect] != -1);}/*** Encodes hex octects into Base64** @param binaryData Array containing binaryData* @return Encoded Base64 array*/public static String encode(byte[] binaryData) {if (binaryData == null) {return null;}int lengthDataBits = binaryData.length * EIGHTBIT;if (lengthDataBits == 0) {return "";}int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;char encodedData[] = null;encodedData = new char[numberQuartet * 4];byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;int encodedIndex = 0;int dataIndex = 0;for (int i = 0; i < numberTriplets; i++) {b1 = binaryData[dataIndex++];b2 = binaryData[dataIndex++];b3 = binaryData[dataIndex++];l = (byte) (b2 & 0x0f);k = (byte) (b1 & 0x03);byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];}// form integral number of 6-bit groupsif (fewerThan24bits == EIGHTBIT) {b1 = binaryData[dataIndex];k = (byte) (b1 & 0x03);byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];encodedData[encodedIndex++] = PAD;encodedData[encodedIndex++] = PAD;} else if (fewerThan24bits == SIXTEENBIT) {b1 = binaryData[dataIndex];b2 = binaryData[dataIndex + 1];l = (byte) (b2 & 0x0f);k = (byte) (b1 & 0x03);byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];encodedData[encodedIndex++] = PAD;}return new String(encodedData);}/*** Decodes Base64 data into octects** @param encoded string containing Base64 data* @return Array containind decoded data.*/public static byte[] decode(String encoded) {if (encoded == null) {return null;}char[] base64Data = encoded.toCharArray();// remove white spacesint len = removeWhiteSpace(base64Data);if (len % FOURBYTE != 0) {return null;// should be divisible by four}int numberQuadruple = (len / FOURBYTE);if (numberQuadruple == 0) {return new byte[0];}byte decodedData[] = null;byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;char d1 = 0, d2 = 0, d3 = 0, d4 = 0;int i = 0;int encodedIndex = 0;int dataIndex = 0;decodedData = new byte[(numberQuadruple) * 3];for (; i < numberQuadruple - 1; i++) {if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))|| !isData((d3 = base64Data[dataIndex++])) || !isData((d4 = base64Data[dataIndex++]))) {return null;} // if found "no data" just return nullb1 = base64Alphabet[d1];b2 = base64Alphabet[d2];b3 = base64Alphabet[d3];b4 = base64Alphabet[d4];decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);}if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {return null;// if found "no data" just return null}b1 = base64Alphabet[d1];b2 = base64Alphabet[d2];d3 = base64Data[dataIndex++];d4 = base64Data[dataIndex++];if (!isData((d3)) || !isData((d4))) {// Check if they are PAD charactersif (isPad(d3) && isPad(d4)) {if ((b2 & 0xf) != 0)// last 4 bits should be zero{return null;}byte[] tmp = new byte[i * 3 + 1];System.arraycopy(decodedData, 0, tmp, 0, i * 3);tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);return tmp;} else if (!isPad(d3) && isPad(d4)) {b3 = base64Alphabet[d3];if ((b3 & 0x3) != 0)// last 2 bits should be zero{return null;}byte[] tmp = new byte[i * 3 + 2];System.arraycopy(decodedData, 0, tmp, 0, i * 3);tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));return tmp;} else {return null;}} else { // No PAD e.g 3cQlb3 = base64Alphabet[d3];b4 = base64Alphabet[d4];decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);}return decodedData;}/*** remove WhiteSpace from MIME containing encoded Base64 data.** @param data the byte array of base64 data (with WS)* @return the new length*/private static int removeWhiteSpace(char[] data) {if (data == null) {return 0;}// count characters that's not whitespaceint newSize = 0;int len = data.length;for (int i = 0; i < len; i++) {if (!isWhiteSpace(data[i])) {data[newSize++] = data[i];}}return newSize;}
}

3、生成验证码

编写Controller 处理验证码请求：

package com.ruoyi.project.common;/*** 验证码操作处理** @author ruoyi*/
@RestController
@CrossOrigin
public class CaptchaController {@Autowiredprivate RedisCache redisCache;/*** 生成验证码*/@GetMapping("/captcha/captchaImage")public AjaxResult getCode(HttpServletResponse response) throws IOException {// 生成随机字串String verifyCode = VerifyCodeUtils.generateVerifyCode(4);// 唯一标识String uuid = IdUtils.simpleUUID();String verifyKey = Constants.CAPTCHA_CODE_KEY + uuid;redisCache.setCacheObject(verifyKey, verifyCode, Constants.CAPTCHA_EXPIRATION, TimeUnit.MINUTES);// 生成图片int w = 111, h = 36;ByteArrayOutputStream stream = new ByteArrayOutputStream();VerifyCodeUtils.outputImage(w, h, stream, verifyCode);try {AjaxResult ajax = AjaxResult.success();ajax.put("uuid", uuid);ajax.put("img", Base64.encode(stream.toByteArray()));return ajax;} catch (Exception e) {e.printStackTrace();return AjaxResult.error(e.getMessage());} finally {stream.close();}}
}

4、测试

启动SpringBoot 项目，然后重启前台项目，看一下验证码是否生成？

5、总结

本章节看上去内容挺多，实际并不是很多,章节的中间部分有很多工具类, 如封装redis缓存工具类,字符串工具类, 生成UUID工具类

最主要的是思路

这里回顾一下：

①、新建项目，引入 springboot-web和test 模块

②、指定端口号和项目访问根路径

③、整合 redis（引入依赖、配置reids，Redis配置类-为容器中注入redisTemplate），并封装redis常用操作

④、定义统一的AjaxResult返回类，以及相应状态码

⑤、封装 UUID、生成UUID、生成图片的工具类

⑥、编写Controller， 处理获取验证码请求！