redis工具类+验证码练习

最新推荐文章于 2023-08-04 20:46:23 发布
最新推荐文章于 2023-08-04 20:46:23 发布
阅读量235 收藏
点赞数
分类专栏： 基础开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaogangyyxf/article/details/79271466
版权
package com.tarena.platform.cache.util;


import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;


/**
 * 缓存工具类
 * @author chen
 *
 */
@SuppressWarnings("unchecked")
public class CacheUtil {


    private static final Logger LOG = LoggerFactory.getLogger(CacheUtil.class);


    private static RedisTemplate<String, Object> redisTemplate = CacheContextUtil.getBean("platformRedisTemplate", RedisTemplate.class);


    private static StringRedisTemplate stringRedisTemplate = CacheContextUtil.getBean("platformStringRedisTemplate", StringRedisTemplate.class);


    private static String CACHE_PREFIX;


    private static boolean CACHE_CLOSED;


    private CacheUtil() {


    }


    @SuppressWarnings("rawtypes")
    private static boolean isEmpty(Object obj) {
if (obj == null) {
   return true;
}
if (obj instanceof String) {
   String str = obj.toString();
   if ("".equals(str.trim())) {
return true;
   }
   return false;
}
if (obj instanceof List) {
   List<Object> list = (List<Object>) obj;
   if (list.isEmpty()) {
return true;
   }
   return false;
}
if (obj instanceof Map) {
   Map map = (Map) obj;
   if (map.isEmpty()) {
return true;
   }
   return false;
}
if (obj instanceof Set) {
   Set set = (Set) obj;
   if (set.isEmpty()) {
return true;
   }
   return false;
}
if (obj instanceof Object[]) {
   Object[] objs = (Object[]) obj;
   if (objs.length <= 0) {
return true;
   }
   return false;
}
return false;
    }


    /**
     * 构建缓存key值
     * @param key 缓存key
     * @return
     */
    private static String buildKey(String key) {
if (CACHE_PREFIX == null || "".equals(CACHE_PREFIX)) {
   return key;
}
return CACHE_PREFIX + ":" + key;
    }


    /**
     * 返回缓存的前缀
     * @return CACHE_PREFIX_FLAG
     */
    public static String getCachePrefix() {
return CACHE_PREFIX;
    }


    /**
     * 设置缓存的前缀
     * @param cachePrefix
     */
    public static void setCachePrefix(String cachePrefix) {
if (cachePrefix != null) {
   CACHE_PREFIX = cachePrefix.trim();
}
    }


    /**
     * 关闭缓存
     * @return true:成功 
     * false:失败
     */
    public static boolean close() {
LOG.debug(" cache closed ! ");
CACHE_CLOSED = true;
return true;
    }


    /**
     * 打开缓存
     * @return true:存在
     * false:不存在
     */
    public static boolean openCache() {
CACHE_CLOSED = false;
return true;
    }


    /**
     * 检查缓存是否开启
     * @return true:已关闭 
     * false:已开启
     */
    public static boolean isClose() {
return CACHE_CLOSED;
    }


    /**
     * 判断key值是否存在
     * @param key 缓存的key
     * @return true:存在
     * false:不存在
     */
    public static boolean hasKey(String key) {
LOG.debug(" hasKey key :{}", key);
try {
   if (isClose() || isEmpty(key)) {
return false;
   }
   key = buildKey(key);
   return redisTemplate.hasKey(key);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 匹配符合正则的key
     * @param patternKey
     * @return key的集合
     */
    public static Set<String> keys(String patternKey) {
LOG.debug(" keys key :{}", patternKey);
try {
   if (isClose() || isEmpty(patternKey)) {
return Collections.emptySet();
   }
   return redisTemplate.keys(patternKey);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return Collections.emptySet();
    }


    /**
     * 根据key删除缓存
     * @param key
     * @return true:成功 
     * false:失败
     */
    public static boolean del(String... key) {
LOG.debug(" delete key :{}", key.toString());
try {
   if (isClose() || isEmpty(key)) {
return false;
   }
   Set<String> keySet = new HashSet<>();
   for (String str : key) {
keySet.add(buildKey(str));
   }
   redisTemplate.delete(keySet);
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 根据key删除缓存
     * @param key
     * @return true:成功 
     * false:失败
     */
    public static boolean delPattern(String key) {
LOG.debug(" delete Pattern keys :{}", key);
try {
   if (isClose() || isEmpty(key)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.delete(redisTemplate.keys(key));
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 删除一组key值
     * @param keys
     * @return true:成功 
     * false:失败
     */
    public static boolean del(Set<String> keys) {
LOG.debug(" delete keys :{}", keys.toString());
try {
   if (isClose() || isEmpty(keys)) {
return false;
   }
   Set<String> keySet = new HashSet<>();
   for (String str : keys) {
keySet.add(buildKey(str));
   }
   redisTemplate.delete(keySet);
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 设置过期时间
     * @param key 缓存key
     * @param seconds 过期秒数
     * @return true:成功 
     * false:失败
     */
    public static boolean setExp(String key, long seconds) {
LOG.debug(" setExp key :{}, seconds: {}", key, seconds);
try {
   if (isClose() || isEmpty(key) || seconds > 0) {
return false;
   }
   key = buildKey(key);
   return redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 查询过期时间
     * @param key 缓存key
     * @return 秒数
     */
    public static Long getExpire(String key) {
LOG.debug(" getExpire key :{}", key);
try {
   if (isClose() || isEmpty(key)) {
return 0L;
   }
   key = buildKey(key);
   return redisTemplate.getExpire(key, TimeUnit.SECONDS);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return 0L;
    }
    
    /**
     * 缓存存入key-value
     * @param key 缓存键
     * @param value 缓存值
     * @return true:成功 
     * false:失败
     */
    public static boolean setString(String key, String value) {
LOG.debug(" setString key :{}, value: {}", key, value);
try {
   if (isClose() || isEmpty(key) || isEmpty(value)) {
return false;
   }
   key = buildKey(key);
   stringRedisTemplate.opsForValue().set(key, value);
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 缓存存入key-value
     * @param key 缓存键
     * @param value 缓存值
     * @param seconds 秒数
     * @return true:成功 
     * false:失败
     */
    public static boolean setString(String key, String value, long seconds) {
LOG.debug(" setString key :{}, value: {}, timeout:{}", key, value, seconds);
try {
   if (isClose() || isEmpty(key) || isEmpty(value)) {
return false;
   }
   key = buildKey(key);
   stringRedisTemplate.opsForValue().set(key, value, seconds, TimeUnit.SECONDS);
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 根据key取出String value
     * @param key 缓存key值
     * @return String 缓存的String
     */
    public static String getString(String key) {
LOG.debug(" getString key :{}", key);
try {
   if (isClose() || isEmpty(key)) {
return null;
   }
   key = buildKey(key);
   return stringRedisTemplate.opsForValue().get(key);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return null;
    }


    /**
     * 去的缓存中的最大值并+1
     * @param key 缓存key值
     * @return long 缓存中的最大值+1
     */
    public static long incr(String key) {
LOG.debug(" incr key :{}", key);
try {
   if (isClose() || isEmpty(key)) {
return 0;
   }
   key = buildKey(key);
   return redisTemplate.opsForValue().increment(key, 1);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return 0;
    }


    /**
     * 缓存中存入序列化的Object对象
     * @param <T>
     * @param key 缓存key
     * @param obj 存入的序列化对象
     * @return true:成功 
     * false:失败
     */
    public static boolean set(String key, Object obj) {
LOG.debug(" set key :{}, value:{}", key, obj);
try {
   if (isClose() || isEmpty(key) || isEmpty(obj)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForValue().set(key, obj);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 缓存中存入序列化的Object对象
     * @param <T>
     * @param key 缓存key
     * @param obj 存入的序列化对象
     * @return true:成功 
     * false:失败
     */
    public static boolean setObj(String key, Object obj, long seconds) {
LOG.debug(" set key :{}, value:{}, seconds:{}", key, obj, seconds);
try {
   if (isClose() || isEmpty(key) || isEmpty(obj)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForValue().set(key, obj);
   if (seconds > 0) {
redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
   }
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 取出缓存中存储的序列化对象
     * @param key 缓存key
     * @param clazz 对象类
     * @return <T> 序列化对象
     */
    public static <T> T getObj(String key, Class<T> clazz) {
LOG.debug(" get key :{}", key);
try {
   if (isClose() || isEmpty(key)) {
return null;
   }
   key = buildKey(key);
   return (T) redisTemplate.opsForValue().get(key);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return null;
    }


    /**
     * 存入Map数组
     * @param <T>
     * @param key 缓存key
     * @param map 缓存map
     * @return true:成功 
     * false:失败
     */
    public static <T> boolean setMap(String key, Map<String, T> map) {
try {
   if (isClose() || isEmpty(key) || isEmpty(map)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForHash().putAll(key, map);
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 取出缓存的map
     * @param key 缓存key
     * @return map 缓存的map
     */
    @SuppressWarnings("rawtypes")
    public static Map getMap(String key) {
LOG.debug(" getMap key :{}", key);
try {
   if (isClose() || isEmpty(key)) {
return null;
   }
   key = buildKey(key);
   return redisTemplate.opsForHash().entries(key);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return null;
    }


    /**
     * 根据key以及hashKey取出对应的Object对象
     * @param key 缓存key
     * @param hashKey 对应map的key
     * @return object map中的对象
     */
    public static Object getMapKey(String key, String hashKey) {
LOG.debug(" getMapkey :{}, hashKey:{}", key, hashKey);
try {
   if (isClose() || isEmpty(key) || isEmpty(hashKey)) {
return null;
   }
   key = buildKey(key);
   return redisTemplate.opsForHash().get(key, hashKey);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return null;
    }


    /**
     * 取出缓存中map的所有key值
     * @param key 缓存key
     * @return Set<String> map的key值合集
     */
    public static Set<Object> getMapKeys(String key) {
LOG.debug(" getMapKeys key :{}", key);
try {
   if (isClose() || isEmpty(key)) {
return null;
   }
   key = buildKey(key);
   return redisTemplate.opsForHash().keys(key);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return null;
    }


    /**
     * 删除map中指定的key值
     * @param key 缓存key
     * @param hashKey map中指定的hashKey
     * @return true:成功 
     * false:失败
     */
    public static boolean delMapKey(String key, String hashKey) {
LOG.debug(" delMapKey key :{}, hashKey:{}", key, hashKey);
try {
   if (isClose() || isEmpty(key) || isEmpty(hashKey)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForHash().delete(key, hashKey);
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 存入Map数组
     * @param <T>
     * @param key 缓存key
     * @param map 缓存map
     * @param seconds 秒数
     * @return true:成功 
     * false:失败
     */
    public static <T> boolean setMapExp(String key, Map<String, T> map, long seconds) {
LOG.debug(" setMapExp key :{}, value: {}, seconds:{}", key, map, seconds);
try {
   if (isClose() || isEmpty(key) || isEmpty(map)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForHash().putAll(key, map);
   redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * map中加入新的key
     * @param <T>
     * @param key 缓存key
     * @param hashKey map的Key值
     * @param value map的value值
     * @return true:成功 
     * false:失败
     */
    public static <T> boolean addMap(String key, String hashKey, T value) {
LOG.debug(" addMap key :{}, hashKey: {}, value:{}", key, hashKey, value);
try {
   if (isClose() || isEmpty(key) || isEmpty(hashKey) || isEmpty(value)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForHash().put(key, hashKey, value);
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 缓存存入List
     * @param <T>
     * @param key 缓存key
     * @param list 缓存List
     * @return true:成功 
     * false:失败
     */
    public static <T> boolean setList(String key, List<T> list) {
LOG.debug(" setList key :{}, list: {}", key, list);
try {
   if (isClose() || isEmpty(key) || isEmpty(list)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForList().leftPushAll(key, list.toArray());
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 根据key值取出对应的list合集
     * @param key 缓存key
     * @return List<Object> 缓存中对应的list合集
     */
    public static <V> List<V> getList(String key) {
LOG.debug(" getList key :{}", key);
try {
   if (isClose() || isEmpty(key)) {
return null;
   }
   key = buildKey(key);
   return (List<V>) redisTemplate.opsForList().range(key, 0, -1);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return null;
    }


    /**
     * 根据key值截取对应的list合集
     * @param key 缓存key
     * @param start 开始位置
     * @param end 结束位置
     * @return
     */
    public static void trimList(String key, int start, int end) {
LOG.debug(" trimList key :{}", key);
try {
   if (isClose() || isEmpty(key)) {
return;
   }
   key = buildKey(key);
   redisTemplate.opsForList().trim(key, start, end);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
    }
    
    /**
     * 取出list合集中指定位置的对象
     * @param key 缓存key
     * @param index 索引位置
     * @return Object list指定索引位置的对象
     */
    public static Object getIndexList(String key, int index) {
LOG.debug(" getIndexList key :{}, index:{}", key, index);
try {
   if (isClose() || isEmpty(key) || index < 0) {
return null;
   }
   key = buildKey(key);
   return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return null;
    }


    /**
     * Object存入List
     * @param <T>
     * @param key 缓存key
     * @param value List中的值
     * @return true:成功 
     * false:失败
     */
    public static boolean addList(String key, Object value) {
LOG.debug(" addList key :{}, value:{}", key, value);
try {
   if (isClose() || isEmpty(key) || isEmpty(value)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForList().leftPush(key, value);
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 缓存存入List
     * @param <T>
     * @param key 缓存key
     * @param list 缓存List
     * @param seconds 秒数
     * @return true:成功 
     * false:失败
     */
    public static <T> boolean setList(String key, List<T> list, long seconds) {
LOG.debug(" setList key :{}, value:{}, seconds:{}", key, list, seconds);
try {
   if (isClose() || isEmpty(key) || isEmpty(list)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForList().leftPushAll(key, list.toArray());
   if (seconds > 0) {
redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
   }
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * set集合存入缓存
     * @param <T>
     * @param key 缓存key
     * @param set 缓存set集合
     * @return true:成功 
     * false:失败
     */
    public static <T> boolean setSet(String key, Set<T> set) {
LOG.debug(" setSet key :{}, value:{}", key, set);
try {
   if (isClose() || isEmpty(key) || isEmpty(set)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForSet().add(key, set.toArray());
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * set集合中增加value
     * @param <T>
     * @param key 缓存key
     * @param value 增加的value
     * @return true:成功 
     * false:失败
     */
    public static boolean addSet(String key, Object value) {
LOG.debug(" addSet key :{}, value:{}", key, value);
try {
   if (isClose() || isEmpty(key) || isEmpty(value)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForSet().add(key, value);
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * set集合存入缓存
     * @param <T>
     * @param key 缓存key
     * @param set 缓存set集合
     * @param seconds 秒数
     * @return true:成功 
     * false:失败
     */
    public static <T> boolean setSet(String key, Set<T> set, long seconds) {
LOG.debug(" setSet key :{}, value:{}, seconds:{}", key, set, seconds);
try {
   if (isClose() || isEmpty(key) || isEmpty(set)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForSet().add(key, set.toArray());
   if (seconds > 0) {
redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
   }
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 取出缓存中对应的set合集
     * @param <T>
     * @param key 缓存key
     * @return Set<Object> 缓存中的set合集
     */
    public static <T> Set<T> getSet(String key) {
LOG.debug(" getSet key :{}", key);
try {
   if (isClose() || isEmpty(key)) {
return null;
   }
   key = buildKey(key);
   return (Set<T>) redisTemplate.opsForSet().members(key);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return null;
    }


    /**
     * 有序集合存入数值
     * @param key 缓存key
     * @param value 缓存value
     * @param score 评分
     * @return
     */
    public static boolean addZSet(String key, Object value, double score) {
LOG.debug(" addZSet key :{},value:{}, score:{}", key, value, score);
try {
   if (isClose() || isEmpty(key) || isEmpty(value)) {
return false;
   }
   key = buildKey(key);
   return redisTemplate.opsForZSet().add(key, value, score);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 从有序集合中删除指定值
     * @param key 缓存key
     * @param value 缓存value
     * @return
     */
    public static boolean removeZSet(String key, Object value) {
LOG.debug(" removeZSet key :{},value:{}", key, value);
try {
   if (isClose() || isEmpty(key) || isEmpty(value)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForZSet().remove(key, value);
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 从有序集合中删除指定位置的值
     * @param key 缓存key
     * @param start 起始位置
     * @param end 结束为止
     * @return
     */
    public static boolean removeZSet(String key, long start, long end) {
LOG.debug(" removeZSet key :{},start:{}, end:{}", key, start, end);
try {
   if (isClose() || isEmpty(key)) {
return false;
   }
   key = buildKey(key);
   redisTemplate.opsForZSet().removeRange(key, start, end);
   return true;
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return false;
    }


    /**
     * 从有序集合中获取指定位置的值
     * @param key 缓存key
     * @param start 起始位置
     * @param end 结束为止
     * @return
     */
    public static <T> Set<T> getZSet(String key, long start, long end) {
LOG.debug(" getZSet key :{},start:{}, end:{}", key, start, end);
try {
   if (isClose() || isEmpty(key)) {
return Collections.emptySet();
   }
   key = buildKey(key);
   return (Set<T>) redisTemplate.opsForZSet().range(key, start, end);
} catch (Exception e) {
   LOG.error(e.getMessage(), e);
}
return Collections.emptySet();
    }

}

2、验证码练习：

package com.tarena.tbsfront.util;


import java.awt.Color;


import java.awt.Font;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.util.Date;
import java.util.Random;


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


import com.tarena.platform.cache.util.CacheUtil;


public class RandomValidateCode {
    static String E_valcode="E-CN-";//--要提出去
    static String RANDOMCODEKEY="T_RANDOM_IMG_KEY";//--要提出去
    
    private static Random random = new Random();
    private static String randString = "234567ACDEFGHJKMNPQRSTUVWXYZ";//随机产生的字符串
    
    private static int width = 80;//图片宽
    private static int height = 26;//图片高
    private static int lineSize = 50;//干扰线数量
    private static int stringNum = 4;//随机产生字符数量
    
    public static String getValidateCode(HttpSession session) {
    return (String)session.getAttribute(RANDOMCODEKEY);//--手写的要提出去
    }
    
    public static boolean checkValidateCode(String yourInput, String uuid){
    //String valid = (String)session.getAttribute(SessionUtil.RANDOMCODEKEY);
try {
String valid = CacheUtil.getString( E_valcode+uuid );//--手写的要提出去
if (valid !=null && yourInput != null && !yourInput.equals("") && yourInput.toUpperCase().equals(valid)) {
System.out.println("\n"+new Date()+"< GET Valid CODE > : " + uuid + "="+valid + "\n yourInput = " + yourInput);//TODO delete sys.out
    return true;
    }
    return false;
} catch (Exception e) {
e.printStackTrace();
return true;
}
    }
    
    /**
     * 生成随机图片
     */
    public static void generateValidateCode(HttpServletRequest request, HttpServletResponse response) {
    //HttpSession session = request.getSession();
        //BufferedImage类是具有缓冲区的Image类,Image类是用于描述图像信息的类
        BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_BGR);
        Graphics g = image.getGraphics();//产生Image对象的Graphics对象,改对象可以在图像上进行各种绘制操作
        g.fillRect(0, 0, width, height);
        g.setFont(new Font("Times New Roman",Font.ROMAN_BASELINE,18));
        g.setColor(getRandColor(110, 133));
        //绘制干扰线
        for(int i=0;i<=lineSize;i++){
            drowLine(g);
        }
        //绘制随机字符
        String randomString = "";
        for(int i=1;i<=stringNum;i++){
            randomString=drowString(g,randomString,i);
        }
        //session.removeAttribute(SessionUtil.RANDOMCODEKEY);
        //session.setAttribute(SessionUtil.RANDOMCODEKEY, randomString);
        try {
        String uuid = request.getParameter("uuid");
        System.out.println("\n"+new Date()+"< GET Valid CODE > : " + uuid + "="+randomString + "\n");//TODO delete sys.out
        CacheUtil.setString( E_valcode+uuid, randomString, 10*60 );//单位：秒
} catch (Exception e) {
e.printStackTrace();
}
        g.dispose();
        try {
            ImageIO.write(image, "JPEG", response.getOutputStream());//将内存中的图片通过流动形式输出到客户端
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /*
     * 获得字体
     */
    private static Font getFont(){
        return new Font("Fixedsys",Font.CENTER_BASELINE,18);
    }
    /*
     * 获得颜色
     */
    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-16);
        int g = fc + random.nextInt(bc-fc-14);
        int b = fc + random.nextInt(bc-fc-18);
        return new Color(r,g,b);
    }
    
    /*
     * 绘制字符串
     */
    private static String drowString(Graphics g,String randomString,int i){
        g.setFont(getFont());
        g.setColor(new Color(random.nextInt(101),random.nextInt(111),random.nextInt(121)));
        String rand = String.valueOf(getRandomString(random.nextInt(randString.length())));
        randomString +=rand;
        g.translate(random.nextInt(3), random.nextInt(3));
        g.drawString(rand, 13*i, 16);
        return randomString;
    }
    /*
     * 绘制干扰线
     */
    private static void drowLine(Graphics g){
        int x = random.nextInt(width);
        int y = random.nextInt(height);
        int xl = random.nextInt(13);
        int yl = random.nextInt(15);
        g.drawLine(x, y, x+xl, y+yl);
    }
    /*
     * 获取随机的字符
     */
    public static String getRandomString(int num){
        return String.valueOf(randString.charAt(num));
    }
    public static String getRandomNum(int num){
    String str = "";
    for(int i=0;i<num;i++){
    str += random.nextInt(10);
    }
    return str;
    }
}


3、调用该方法

/**生成验证码
     * @param response
     * @param request
     */
    @RequestMapping("/validateCode")
    public void validateCode(HttpServletResponse response,
HttpServletRequest request) {
    RandomValidateCode.generateValidateCode(request, response);
    }




过客幽影星风
关注
专栏目录
Spring Boot进阶(01)：使用Spring Boot和Redis轻松实现高性能、高可用的缓存服务。
**My Coding Family**
08-30 4194
Spring Boot 进阶篇：spring boot如何集成 Redis？实现数据缓存，此文教你。
redis从windows到linux
weixin_43881925的博客
03-17 1014
什么是redis redis是一个高性能的key-value数据库，是为了解决高并发，高扩展的NOSQL（非关系）类型数据库，支持的数据类型包括，String，list，hash，set和Zset。 redis把数据都存储在内存中以提高读取效率，周期性（如 y=sinx T= 2Π）的进行数据写入磁盘。 ...
Redis工具+Redis桌面查看工具
04-02
使用Redis时，可以使用redis-desktop-manager查看使用的哪个数据库，可以查看缓存的数据
Redis缓存验证码
qq_42702331的博客
09-11 1651
通常项目中，在进行登录或者查看一些数据私密度高的数据的时候都需要去额外的校验一下 步骤 1.生成6位数随机验证码 2.将验证码和手机号存储在Redis缓存中 3.发送短信，用户接受短信，在指定时间填写正确验证码 4.接受前端传过来的验证码，取出Redis缓存中的验证码进行对比 5.根据对比结果，超时，填写错误，正确，返回不同的状态，校验通过则进行下一步，否则重新进行第一步 //设置验证码长度6位 private final static String EsConstants.RedisCod
Redis_缓存验证码
最新发布
m0_55679301的博客
08-04 1008
所以，Redis中的LRU算法是这样实现的：首先定义一个淘汰池，这个淘汰池是一个数组（大小为16），然后触发淘汰时会根据配置的淘汰策略，先从符合条件的key中随机采样选出5（可在配置文件中配置）个key，然后将这5个key按照空闲时间排序后放到淘汰池中，每次采样之后更新这个淘汰池，让这个淘汰池里保留的总是那些随机采样出的key中空闲时间最长的那部分key。我们知道，实现LRU算法时，需要将所有的数据按照访问时间距离当前时间的长短排序放到一个双向链表中，基于这个链表实现数据的淘汰。为了后续的校验登录状态。
SPA项目开发之登录注册
hao_dream_xi的博客
08-09 9781
SPA项目开发之登录注册 1. vue怎么引入和配置使用element-ui框架: 1.1 使用vue-cli脚手架工具创建一个vue项目 vue init webpack pro01 1.2 npm安装elementUI cd pro01 #进入新建项目的根目录 npm install ...
一种基于memcache或redis缓存架构的验证码（Redis版）
08-01
最近项目中自己研发的一款适用于分布式服务器的非session实现的验证码框架。文章链接：http://blog.csdn.net/chaijunkun/article/details/8996794，共同学习。
redis验证码
weixin_45318552的博客
10-14 444
redis验证码的实现 输入手机号，点击发送后随机生成6位数字码，3分钟有效 输入验证码，点击验证，返回成功或者失败 每个手机号每天只能输入3次 实现思路： 在0号数据库创建手机号，时间以及次数 我们在进行验证码发送的时候，首先考虑的是这个手机号是否存在 存在 —今日发送了几次了 大于3次 小于3次，生成验证码 不存在，就创建这个手机号 ，并且生成验证码 在1号数据库创建手机号，以及验证码 代码如下 index.jsp <%@ page contentType="text/html; char
Redis使用验证码
m0_51505198的博客
11-03 1860
redis获取验证码 及 redisTemplate的通用配置
Redis学习：安装，配置，idea中测试redis和编辑API工具实现传输的数据转成json并转成对象+AOP实现Redis
weixin_47742346的博客
10-13 599
1. Redis学习 =========== 0.1还原程序 0.1.1 修改YML配置文件 0.1.2 修改pro图片路径 0.1.3 修改Nginx配置文件 0.1.4 修改hosts文件 1.1 缓存机制 说明:使用缓存可以有效的降低用户访问物理设备的频次.快速从内存中获取数据,之后返回给用户,同时需要保证内存中的数据就是数据库数据. 思考: 1.缓存的运行环境应该在内存中.(快) 2.使用C语言开发缓存 3.缓存应该使用什么样的数据结构呢--------K-V结构 一般采用String类型居
基于javaweb的个人博客系统(前后端分离+java+vue+springboot+ssm+mysql+redis)
m0_70011400的博客
10-28 1682
基于javaweb的个人博客系统(前后端分离+java+vue+springboot+ssm+mysql+redis) 运行环境 Java≥8、MySQL≥5.7、Node.js≥10 开发工具 后端：eclipse/idea/myeclipse/sts等均可配置运行 前端：WebStorm/VSCode/HBuilderX等均可 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 功能说明
Redis工具类，方便缓存读写
02-22
redis工具整合java版代码。
redis可视化工具
09-16
下载解压就能用,包括可视化客户端和程序包64位。
基于javaweb+mysql的springboot少年宫活动中心后台管理系统(java+springboot+thymeleaf+redis+maven+mysql)
m0_71098312的博客
07-26 84
实现对课程安排、报名缴费、数据记录和处理、工作流程的信息化，提高工作效率和数据管理效率，并具备安全性、可升级、可扩展性。课程管理 管理活动中心的课程分类以及课程信息 - 教师管理 管理活动中心的授课教师信息 - 学员管理 和管理活动中心的学员信息 - 收费管理 查询学员课程的收费信息以及课程的收费报表 - 用户管理 管理后台系统用户，管理员身份可以进行修改、删除 - 角色管理 分配权限的最小单元，通过角色对用户分配权限 - 菜单管理 管理系统菜单，同时作为权限资源。具备基本计算机使用水平。
Redis存储验证码
qq_45860901的博客
08-09 1076
Redis存储验证码
redis缓存手机验证码案例
weixin_52236586的博客
10-24 785
redis缓存手机验证码案例
redis实现缓存功能——短信验证码的存储验证
weixin_45386898的博客
05-27 1528
整合Redis实现缓存功能整合redis在pom.xml文件中导入依赖在application.yml中添加Redis的配置及Redis中自定义key的配置。 整合redis 在pom.xml文件中导入依赖 在application.yml中添加Redis的配置及Redis中自定义key的配置。 ...
第三步： 整合Redis（实现验证码缓存）
q392636814的博客
01-06 962
1 添加依赖 <!--redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 2 添加配置 在application.yml中添加redis配置 redis: host: localhost
密码登录，redis缓存验证码和云短信的使用
m0_43609780的博客
02-23 231
redis，uuid，云短信
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值