15 changed files with 1177 additions and 37 deletions
-
17common/pom.xml
-
10common/src/main/java/com/storeroom/exception/BaseException.java
-
6common/src/main/java/com/storeroom/exception/JsonException.java
-
6common/src/main/java/com/storeroom/exception/PageException.java
-
15common/src/main/java/com/storeroom/exception/constant/ResponseStatus.java
-
10common/src/main/java/com/storeroom/exception/handler/GlobalExceptionHandler.java
-
30common/src/main/java/com/storeroom/utils/ApiResponse.java
-
12common/src/main/java/com/storeroom/utils/CallBack.java
-
15common/src/main/java/com/storeroom/utils/DataStatusConst.java
-
694common/src/main/java/com/storeroom/utils/RedisUtils.java
-
178common/src/main/java/com/storeroom/utils/RsaUtils.java
-
80common/src/main/java/com/storeroom/utils/SecurityUtils.java
-
84common/src/main/java/com/storeroom/utils/SpringContextHolder.java
-
32common/src/main/java/com/storeroom/utils/enums/DataScopeEnum.java
-
25common/src/main/java/com/storeroom/utils/enums/DataStatusEnum.java
@ -0,0 +1,12 @@ |
|||
package com.storeroom.utils; |
|||
|
|||
public interface CallBack { |
|||
|
|||
//回调执行方法 |
|||
void executor(); |
|||
|
|||
//本回调任务名称 |
|||
default String getCallBackName() { |
|||
return Thread.currentThread().getId() + ":" + this.getClass().getName(); |
|||
} |
|||
} |
|||
@ -0,0 +1,15 @@ |
|||
package com.storeroom.utils; |
|||
|
|||
|
|||
//数据状态常量 |
|||
public class DataStatusConst { |
|||
|
|||
//正常状态 |
|||
public static final byte OK=1; |
|||
|
|||
//冻结状态码 |
|||
public static final byte FREEZED=2; |
|||
|
|||
//删除状态 |
|||
public static final byte DELETE=3; |
|||
} |
|||
@ -0,0 +1,694 @@ |
|||
package com.storeroom.utils; |
|||
|
|||
import com.google.common.collect.Lists; |
|||
import com.google.common.collect.Sets; |
|||
import org.slf4j.Logger; |
|||
import org.slf4j.LoggerFactory; |
|||
import org.springframework.beans.factory.annotation.Value; |
|||
import org.springframework.data.redis.connection.RedisConnection; |
|||
import org.springframework.data.redis.connection.RedisConnectionFactory; |
|||
import org.springframework.data.redis.core.*; |
|||
import org.springframework.stereotype.Component; |
|||
|
|||
import org.springframework.stereotype.Component; |
|||
|
|||
import java.util.*; |
|||
import java.util.concurrent.TimeUnit; |
|||
|
|||
/** |
|||
* redis 工具类 |
|||
*/ |
|||
@Component |
|||
public class RedisUtils { |
|||
private static final Logger log = LoggerFactory.getLogger(RedisUtils.class); |
|||
private RedisTemplate<Object, Object> redisTemplate; |
|||
@Value("${jwt.online-key}") |
|||
private String onlineKey; |
|||
|
|||
public RedisUtils(RedisTemplate<Object, Object> redisTemplate) { |
|||
this.redisTemplate = redisTemplate; |
|||
} |
|||
|
|||
/** |
|||
* 指定缓存失效时间 |
|||
* |
|||
* @param key 键 |
|||
* @param time 时间(秒) |
|||
*/ |
|||
public boolean expire(String key, long time) { |
|||
try { |
|||
if (time > 0) { |
|||
redisTemplate.expire(key, time, TimeUnit.SECONDS); |
|||
} |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
/** |
|||
* 指定缓存失效时间 |
|||
* |
|||
* @param key 键 |
|||
* @param time 时间(秒) |
|||
* @param timeUnit 单位 |
|||
*/ |
|||
public boolean expire(String key, long time, TimeUnit timeUnit) { |
|||
try { |
|||
if (time > 0) { |
|||
redisTemplate.expire(key, time, timeUnit); |
|||
} |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
/** |
|||
* 根据 key 获取过期时间 |
|||
* |
|||
* @param key 键 不能为null |
|||
* @return 时间(秒) 返回0代表为永久有效 |
|||
*/ |
|||
public long getExpire(Object key) { |
|||
return redisTemplate.getExpire(key, TimeUnit.SECONDS); |
|||
} |
|||
|
|||
/** |
|||
* 查找匹配key |
|||
* |
|||
* @param pattern key |
|||
* @return / |
|||
*/ |
|||
public List<String> scan(String pattern) { |
|||
ScanOptions options = ScanOptions.scanOptions().match(pattern).build(); |
|||
RedisConnectionFactory factory = redisTemplate.getConnectionFactory(); |
|||
RedisConnection rc = Objects.requireNonNull(factory).getConnection(); |
|||
Cursor<byte[]> cursor = rc.scan(options); |
|||
List<String> result = new ArrayList<>(); |
|||
while (cursor.hasNext()) { |
|||
result.add(new String(cursor.next())); |
|||
} |
|||
try { |
|||
RedisConnectionUtils.releaseConnection(rc, factory); |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
} |
|||
return result; |
|||
} |
|||
|
|||
/** |
|||
* 分页查询 key |
|||
* |
|||
* @param patternKey key |
|||
* @param page 页码 |
|||
* @param size 每页数目 |
|||
* @return / |
|||
*/ |
|||
public List<String> findKeysForPage(String patternKey, int page, int size) { |
|||
ScanOptions options = ScanOptions.scanOptions().match(patternKey).build(); |
|||
RedisConnectionFactory factory = redisTemplate.getConnectionFactory(); |
|||
RedisConnection rc = Objects.requireNonNull(factory).getConnection(); |
|||
Cursor<byte[]> cursor = rc.scan(options); |
|||
List<String> result = new ArrayList<>(size); |
|||
int tmpIndex = 0; |
|||
int fromIndex = page * size; |
|||
int toIndex = page * size + size; |
|||
while (cursor.hasNext()) { |
|||
if (tmpIndex >= fromIndex && tmpIndex < toIndex) { |
|||
result.add(new String(cursor.next())); |
|||
tmpIndex++; |
|||
continue; |
|||
} |
|||
// 获取到满足条件的数据后,就可以退出了 |
|||
if (tmpIndex >= toIndex) { |
|||
break; |
|||
} |
|||
tmpIndex++; |
|||
cursor.next(); |
|||
} |
|||
try { |
|||
RedisConnectionUtils.releaseConnection(rc, factory); |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
} |
|||
return result; |
|||
} |
|||
|
|||
/** |
|||
* 判断key是否存在 |
|||
* |
|||
* @param key 键 |
|||
* @return true 存在 false不存在 |
|||
*/ |
|||
public boolean hasKey(String key) { |
|||
try { |
|||
return redisTemplate.hasKey(key); |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 删除缓存 |
|||
* |
|||
* @param keys 可以传一个值 或多个 |
|||
*/ |
|||
public void del(String... keys) { |
|||
if (keys != null && keys.length > 0) { |
|||
if (keys.length == 1) { |
|||
boolean result = redisTemplate.delete(keys[0]); |
|||
log.debug("--------------------------------------------"); |
|||
log.debug(new StringBuilder("删除缓存：").append(keys[0]).append("，结果：").append(result).toString()); |
|||
log.debug("--------------------------------------------"); |
|||
} else { |
|||
Set<Object> keySet = new HashSet<>(); |
|||
for (String key : keys) { |
|||
keySet.addAll(redisTemplate.keys(key)); |
|||
} |
|||
long count = redisTemplate.delete(keySet); |
|||
log.debug("--------------------------------------------"); |
|||
log.debug("成功删除缓存：" + keySet.toString()); |
|||
log.debug("缓存删除数量：" + count + "个"); |
|||
log.debug("--------------------------------------------"); |
|||
} |
|||
} |
|||
} |
|||
|
|||
// ============================String============================= |
|||
|
|||
/** |
|||
* 普通缓存获取 |
|||
* |
|||
* @param key 键 |
|||
* @return 值 |
|||
*/ |
|||
public Object get(String key) { |
|||
return key == null ? null : redisTemplate.opsForValue().get(key); |
|||
} |
|||
|
|||
/** |
|||
* 批量获取 |
|||
* |
|||
* @param keys |
|||
* @return |
|||
*/ |
|||
public List<Object> multiGet(List<String> keys) { |
|||
List list = redisTemplate.opsForValue().multiGet(Sets.newHashSet(keys)); |
|||
List resultList = Lists.newArrayList(); |
|||
Optional.ofNullable(list).ifPresent(e-> list.forEach(ele-> Optional.ofNullable(ele).ifPresent(resultList::add))); |
|||
return resultList; |
|||
} |
|||
|
|||
/** |
|||
* 普通缓存放入 |
|||
* |
|||
* @param key 键 |
|||
* @param value 值 |
|||
* @return true成功 false失败 |
|||
*/ |
|||
public boolean set(String key, Object value) { |
|||
try { |
|||
redisTemplate.opsForValue().set(key, value); |
|||
return true; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 普通缓存放入并设置时间 |
|||
* |
|||
* @param key 键 |
|||
* @param value 值 |
|||
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期 |
|||
* @return true成功 false 失败 |
|||
*/ |
|||
public boolean set(String key, Object value, long time) { |
|||
try { |
|||
if (time > 0) { |
|||
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS); |
|||
} else { |
|||
set(key, value); |
|||
} |
|||
return true; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 普通缓存放入并设置时间 |
|||
* |
|||
* @param key 键 |
|||
* @param value 值 |
|||
* @param time 时间 |
|||
* @param timeUnit 类型 |
|||
* @return true成功 false 失败 |
|||
*/ |
|||
public boolean set(String key, Object value, long time, TimeUnit timeUnit) { |
|||
try { |
|||
if (time > 0) { |
|||
redisTemplate.opsForValue().set(key, value, time, timeUnit); |
|||
} else { |
|||
set(key, value); |
|||
} |
|||
return true; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
// ================================Map================================= |
|||
|
|||
/** |
|||
* HashGet |
|||
* |
|||
* @param key 键 不能为null |
|||
* @param item 项 不能为null |
|||
* @return 值 |
|||
*/ |
|||
public Object hget(String key, String item) { |
|||
return redisTemplate.opsForHash().get(key, item); |
|||
} |
|||
|
|||
/** |
|||
* 获取hashKey对应的所有键值 |
|||
* |
|||
* @param key 键 |
|||
* @return 对应的多个键值 |
|||
*/ |
|||
public Map<Object, Object> hmget(String key) { |
|||
return redisTemplate.opsForHash().entries(key); |
|||
|
|||
} |
|||
|
|||
/** |
|||
* HashSet |
|||
* |
|||
* @param key 键 |
|||
* @param map 对应多个键值 |
|||
* @return true 成功 false 失败 |
|||
*/ |
|||
public boolean hmset(String key, Map<String, Object> map) { |
|||
try { |
|||
redisTemplate.opsForHash().putAll(key, map); |
|||
return true; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* HashSet 并设置时间 |
|||
* |
|||
* @param key 键 |
|||
* @param map 对应多个键值 |
|||
* @param time 时间(秒) |
|||
* @return true成功 false失败 |
|||
*/ |
|||
public boolean hmset(String key, Map<String, Object> map, long time) { |
|||
try { |
|||
redisTemplate.opsForHash().putAll(key, map); |
|||
if (time > 0) { |
|||
expire(key, time); |
|||
} |
|||
return true; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 向一张hash表中放入数据,如果不存在将创建 |
|||
* |
|||
* @param key 键 |
|||
* @param item 项 |
|||
* @param value 值 |
|||
* @return true 成功 false失败 |
|||
*/ |
|||
public boolean hset(String key, String item, Object value) { |
|||
try { |
|||
redisTemplate.opsForHash().put(key, item, value); |
|||
return true; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 向一张hash表中放入数据,如果不存在将创建 |
|||
* |
|||
* @param key 键 |
|||
* @param item 项 |
|||
* @param value 值 |
|||
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间 |
|||
* @return true 成功 false失败 |
|||
*/ |
|||
public boolean hset(String key, String item, Object value, long time) { |
|||
try { |
|||
redisTemplate.opsForHash().put(key, item, value); |
|||
if (time > 0) { |
|||
expire(key, time); |
|||
} |
|||
return true; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 删除hash表中的值 |
|||
* |
|||
* @param key 键 不能为null |
|||
* @param item 项 可以使多个 不能为null |
|||
*/ |
|||
public void hdel(String key, Object... item) { |
|||
redisTemplate.opsForHash().delete(key, item); |
|||
} |
|||
|
|||
/** |
|||
* 判断hash表中是否有该项的值 |
|||
* |
|||
* @param key 键 不能为null |
|||
* @param item 项 不能为null |
|||
* @return true 存在 false不存在 |
|||
*/ |
|||
public boolean hHasKey(String key, String item) { |
|||
return redisTemplate.opsForHash().hasKey(key, item); |
|||
} |
|||
|
|||
/** |
|||
* hash递增 如果不存在,就会创建一个 并把新增后的值返回 |
|||
* |
|||
* @param key 键 |
|||
* @param item 项 |
|||
* @param by 要增加几(大于0) |
|||
* @return |
|||
*/ |
|||
public double hincr(String key, String item, double by) { |
|||
return redisTemplate.opsForHash().increment(key, item, by); |
|||
} |
|||
|
|||
/** |
|||
* hash递减 |
|||
* |
|||
* @param key 键 |
|||
* @param item 项 |
|||
* @param by 要减少记(小于0) |
|||
* @return |
|||
*/ |
|||
public double hdecr(String key, String item, double by) { |
|||
return redisTemplate.opsForHash().increment(key, item, -by); |
|||
} |
|||
|
|||
// ============================set============================= |
|||
|
|||
/** |
|||
* 根据key获取Set中的所有值 |
|||
* |
|||
* @param key 键 |
|||
* @return |
|||
*/ |
|||
public Set<Object> sGet(String key) { |
|||
try { |
|||
return redisTemplate.opsForSet().members(key); |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return null; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 根据value从一个set中查询,是否存在 |
|||
* |
|||
* @param key 键 |
|||
* @param value 值 |
|||
* @return true 存在 false不存在 |
|||
*/ |
|||
public boolean sHasKey(String key, Object value) { |
|||
try { |
|||
return redisTemplate.opsForSet().isMember(key, value); |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 将数据放入set缓存 |
|||
* |
|||
* @param key 键 |
|||
* @param values 值 可以是多个 |
|||
* @return 成功个数 |
|||
*/ |
|||
public long sSet(String key, Object... values) { |
|||
try { |
|||
return redisTemplate.opsForSet().add(key, values); |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return 0; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 将set数据放入缓存 |
|||
* |
|||
* @param key 键 |
|||
* @param time 时间(秒) |
|||
* @param values 值 可以是多个 |
|||
* @return 成功个数 |
|||
*/ |
|||
public long sSetAndTime(String key, long time, Object... values) { |
|||
try { |
|||
Long count = redisTemplate.opsForSet().add(key, values); |
|||
if (time > 0) { |
|||
expire(key, time); |
|||
} |
|||
return count; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return 0; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 获取set缓存的长度 |
|||
* |
|||
* @param key 键 |
|||
* @return |
|||
*/ |
|||
public long sGetSetSize(String key) { |
|||
try { |
|||
return redisTemplate.opsForSet().size(key); |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return 0; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 移除值为value的 |
|||
* |
|||
* @param key 键 |
|||
* @param values 值 可以是多个 |
|||
* @return 移除的个数 |
|||
*/ |
|||
public long setRemove(String key, Object... values) { |
|||
try { |
|||
Long count = redisTemplate.opsForSet().remove(key, values); |
|||
return count; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return 0; |
|||
} |
|||
} |
|||
|
|||
// ===============================list================================= |
|||
|
|||
/** |
|||
* 获取list缓存的内容 |
|||
* |
|||
* @param key 键 |
|||
* @param start 开始 |
|||
* @param end 结束 0 到 -1代表所有值 |
|||
* @return |
|||
*/ |
|||
public List<Object> lGet(String key, long start, long end) { |
|||
try { |
|||
return redisTemplate.opsForList().range(key, start, end); |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return null; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 获取list缓存的长度 |
|||
* |
|||
* @param key 键 |
|||
* @return |
|||
*/ |
|||
public long lGetListSize(String key) { |
|||
try { |
|||
return redisTemplate.opsForList().size(key); |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return 0; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 通过索引 获取list中的值 |
|||
* |
|||
* @param key 键 |
|||
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推 |
|||
* @return |
|||
*/ |
|||
public Object lGetIndex(String key, long index) { |
|||
try { |
|||
return redisTemplate.opsForList().index(key, index); |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return null; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 将list放入缓存 |
|||
* |
|||
* @param key 键 |
|||
* @param value 值 |
|||
* @return |
|||
*/ |
|||
public boolean lSet(String key, Object value) { |
|||
try { |
|||
redisTemplate.opsForList().rightPush(key, value); |
|||
return true; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 将list放入缓存 |
|||
* |
|||
* @param key 键 |
|||
* @param value 值 |
|||
* @param time 时间(秒) |
|||
* @return |
|||
*/ |
|||
public boolean lSet(String key, Object value, long time) { |
|||
try { |
|||
redisTemplate.opsForList().rightPush(key, value); |
|||
if (time > 0) { |
|||
expire(key, time); |
|||
} |
|||
return true; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 将list放入缓存 |
|||
* |
|||
* @param key 键 |
|||
* @param value 值 |
|||
* @return |
|||
*/ |
|||
public boolean lSet(String key, List<Object> value) { |
|||
try { |
|||
redisTemplate.opsForList().rightPushAll(key, value); |
|||
return true; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 将list放入缓存 |
|||
* |
|||
* @param key 键 |
|||
* @param value 值 |
|||
* @param time 时间(秒) |
|||
* @return |
|||
*/ |
|||
public boolean lSet(String key, List<Object> value, long time) { |
|||
try { |
|||
redisTemplate.opsForList().rightPushAll(key, value); |
|||
if (time > 0) { |
|||
expire(key, time); |
|||
} |
|||
return true; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 根据索引修改list中的某条数据 |
|||
* |
|||
* @param key 键 |
|||
* @param index 索引 |
|||
* @param value 值 |
|||
* @return / |
|||
*/ |
|||
public boolean lUpdateIndex(String key, long index, Object value) { |
|||
try { |
|||
redisTemplate.opsForList().set(key, index, value); |
|||
return true; |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* 移除N个值为value |
|||
* |
|||
* @param key 键 |
|||
* @param count 移除多少个 |
|||
* @param value 值 |
|||
* @return 移除的个数 |
|||
*/ |
|||
public long lRemove(String key, long count, Object value) { |
|||
try { |
|||
return redisTemplate.opsForList().remove(key, count, value); |
|||
} catch (Exception e) { |
|||
log.error(e.getMessage(), e); |
|||
return 0; |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* @param prefix 前缀 |
|||
* @param ids id |
|||
*/ |
|||
public void delByKeys(String prefix, Set<Long> ids) { |
|||
Set<Object> keys = new HashSet<>(); |
|||
for (Long id : ids) { |
|||
keys.addAll(redisTemplate.keys(new StringBuffer(prefix).append(id).toString())); |
|||
} |
|||
long count = redisTemplate.delete(keys); |
|||
// 此处提示可自行删除 |
|||
log.debug("--------------------------------------------"); |
|||
log.debug("成功删除缓存：" + keys.toString()); |
|||
log.debug("缓存删除数量：" + count + "个"); |
|||
log.debug("--------------------------------------------"); |
|||
} |
|||
} |
|||
@ -0,0 +1,178 @@ |
|||
package com.storeroom.utils; |
|||
|
|||
|
|||
import org.apache.commons.codec.binary.Base64; |
|||
|
|||
import javax.crypto.Cipher; |
|||
import java.security.*; |
|||
import java.security.interfaces.RSAPrivateKey; |
|||
import java.security.interfaces.RSAPublicKey; |
|||
import java.security.spec.PKCS8EncodedKeySpec; |
|||
import java.security.spec.X509EncodedKeySpec; |
|||
|
|||
/** |
|||
* 公钥私钥生成，加密工具类 |
|||
*/ |
|||
public class RsaUtils { |
|||
|
|||
private static final String SRC = "123456"; |
|||
|
|||
|
|||
public static void main(String[] args) throws Exception{ |
|||
System.out.println("\n"); |
|||
RsaKeyPair keyPair = generateKeyPair(); |
|||
System.out.println("公钥：" + keyPair.getPublicKey()); |
|||
System.out.println("私钥：" + keyPair.getPrivateKey()); |
|||
System.out.println("\n"); |
|||
test1(keyPair); |
|||
System.out.println("\n"); |
|||
test2(keyPair); |
|||
System.out.println("\n"); |
|||
} |
|||
|
|||
/** |
|||
* 公钥加密私钥解密 |
|||
*/ |
|||
private static void test1(RsaKeyPair keyPair) throws Exception { |
|||
System.out.println("***************** 公钥加密私钥解密开始 *****************"); |
|||
String text1 = encryptByPublicKey(keyPair.getPublicKey(), RsaUtils.SRC); |
|||
String text2 = decryptByPrivateKey(keyPair.getPrivateKey(), text1); |
|||
System.out.println("加密前：" + RsaUtils.SRC); |
|||
System.out.println("加密后：" + text1); |
|||
System.out.println("解密后：" + text2); |
|||
if (RsaUtils.SRC.equals(text2)) { |
|||
System.out.println("解密字符串和原始字符串一致，解密成功"); |
|||
} else { |
|||
System.out.println("解密字符串和原始字符串不一致，解密失败"); |
|||
} |
|||
System.out.println("***************** 公钥加密私钥解密结束 *****************"); |
|||
} |
|||
|
|||
|
|||
/** |
|||
* 构建RSA密钥对 |
|||
* |
|||
* @return / |
|||
* @throws NoSuchAlgorithmException / |
|||
*/ |
|||
public static RsaKeyPair generateKeyPair() throws NoSuchAlgorithmException { |
|||
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); |
|||
keyPairGenerator.initialize(1024); |
|||
KeyPair keyPair = keyPairGenerator.generateKeyPair(); |
|||
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic(); |
|||
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate(); |
|||
String publicKeyString = Base64.encodeBase64String(rsaPublicKey.getEncoded()); |
|||
String privateKeyString = Base64.encodeBase64String(rsaPrivateKey.getEncoded()); |
|||
return new RsaKeyPair(publicKeyString, privateKeyString); |
|||
} |
|||
|
|||
/** |
|||
* 私钥加密公钥解密 |
|||
* @throws Exception / |
|||
*/ |
|||
private static void test2(RsaKeyPair keyPair) throws Exception { |
|||
System.out.println("***************** 私钥加密公钥解密开始 *****************"); |
|||
String text1 = encryptByPrivateKey(keyPair.getPrivateKey(), RsaUtils.SRC); |
|||
String text2 = decryptByPublicKey(keyPair.getPublicKey(), text1); |
|||
System.out.println("加密前：" + RsaUtils.SRC); |
|||
System.out.println("加密后：" + text1); |
|||
System.out.println("解密后：" + text2); |
|||
if (RsaUtils.SRC.equals(text2)) { |
|||
System.out.println("解密字符串和原始字符串一致，解密成功"); |
|||
} else { |
|||
System.out.println("解密字符串和原始字符串不一致，解密失败"); |
|||
} |
|||
System.out.println("***************** 私钥加密公钥解密结束 *****************"); |
|||
} |
|||
|
|||
/** |
|||
* 公钥解密 |
|||
* |
|||
* @param publicKeyText 公钥 |
|||
* @param text 待解密的信息 |
|||
* @return / |
|||
* @throws Exception / |
|||
*/ |
|||
public static String decryptByPublicKey(String publicKeyText, String text) throws Exception { |
|||
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyText)); |
|||
KeyFactory keyFactory = KeyFactory.getInstance("RSA"); |
|||
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec); |
|||
Cipher cipher = Cipher.getInstance("RSA"); |
|||
cipher.init(Cipher.DECRYPT_MODE, publicKey); |
|||
byte[] result = cipher.doFinal(Base64.decodeBase64(text)); |
|||
return new String(result); |
|||
} |
|||
|
|||
/** |
|||
* 私钥加密 |
|||
* |
|||
* @param privateKeyText 私钥 |
|||
* @param text 待加密的信息 |
|||
* @return / |
|||
* @throws Exception / |
|||
*/ |
|||
public static String encryptByPrivateKey(String privateKeyText, String text) throws Exception { |
|||
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyText)); |
|||
KeyFactory keyFactory = KeyFactory.getInstance("RSA"); |
|||
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec); |
|||
Cipher cipher = Cipher.getInstance("RSA"); |
|||
cipher.init(Cipher.ENCRYPT_MODE, privateKey); |
|||
byte[] result = cipher.doFinal(text.getBytes()); |
|||
return Base64.encodeBase64String(result); |
|||
} |
|||
|
|||
/** |
|||
* 私钥解密 |
|||
* |
|||
* @param privateKeyText 私钥 |
|||
* @param text 待解密的文本 |
|||
* @return / |
|||
* @throws Exception / |
|||
*/ |
|||
public static String decryptByPrivateKey(String privateKeyText, String text) throws Exception { |
|||
PKCS8EncodedKeySpec pkcs8EncodedKeySpec5 = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKeyText)); |
|||
KeyFactory keyFactory = KeyFactory.getInstance("RSA"); |
|||
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec5); |
|||
Cipher cipher = Cipher.getInstance("RSA"); |
|||
cipher.init(Cipher.DECRYPT_MODE, privateKey); |
|||
byte[] result = cipher.doFinal(Base64.decodeBase64(text)); |
|||
return new String(result); |
|||
} |
|||
|
|||
/** |
|||
* 公钥加密 |
|||
* |
|||
* @param publicKeyText 公钥 |
|||
* @param text 待加密的文本 |
|||
* @return / |
|||
*/ |
|||
public static String encryptByPublicKey(String publicKeyText, String text) throws Exception { |
|||
X509EncodedKeySpec x509EncodedKeySpec2 = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyText)); |
|||
KeyFactory keyFactory = KeyFactory.getInstance("RSA"); |
|||
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec2); |
|||
Cipher cipher = Cipher.getInstance("RSA"); |
|||
cipher.init(Cipher.ENCRYPT_MODE, publicKey); |
|||
byte[] result = cipher.doFinal(text.getBytes()); |
|||
return Base64.encodeBase64String(result); |
|||
} |
|||
|
|||
public static class RsaKeyPair { |
|||
|
|||
private final String publicKey; |
|||
private final String privateKey; |
|||
|
|||
public RsaKeyPair(String publicKey, String privateKey) { |
|||
this.publicKey = publicKey; |
|||
this.privateKey = privateKey; |
|||
} |
|||
|
|||
public String getPublicKey() { |
|||
return publicKey; |
|||
} |
|||
|
|||
public String getPrivateKey() { |
|||
return privateKey; |
|||
} |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,80 @@ |
|||
package com.storeroom.utils; |
|||
|
|||
|
|||
import cn.hutool.json.JSONArray; |
|||
import cn.hutool.json.JSONObject; |
|||
import cn.hutool.json.JSONUtil; |
|||
import com.storeroom.exception.JsonException; |
|||
import com.storeroom.exception.constant.ResponseStatus; |
|||
import com.storeroom.utils.enums.DataScopeEnum; |
|||
import lombok.extern.slf4j.Slf4j; |
|||
import org.springframework.security.core.Authentication; |
|||
import org.springframework.security.core.context.SecurityContextHolder; |
|||
import org.springframework.security.core.userdetails.UserDetails; |
|||
import org.springframework.security.core.userdetails.UserDetailsService; |
|||
|
|||
import java.util.List; |
|||
|
|||
@Slf4j |
|||
public class SecurityUtils { |
|||
|
|||
/** |
|||
* 获取当前登录的用户 |
|||
* |
|||
* @return |
|||
*/ |
|||
public static UserDetails getCurrentUser() { |
|||
UserDetailsService userDetailsService = SpringContextHolder.getBean(UserDetailsService.class); |
|||
return userDetailsService.loadUserByUsername(getCurrentUsername()); |
|||
} |
|||
|
|||
/** |
|||
* 获取系统用户名称 |
|||
* |
|||
* @return 系统用户名称 |
|||
*/ |
|||
public static String getCurrentUsername() { |
|||
final Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); |
|||
if (authentication == null) { |
|||
throw new JsonException(ResponseStatus.TOKEN_UNAUTHORIZED.getCode(), ResponseStatus.TOKEN_UNAUTHORIZED.getMessage()); |
|||
} |
|||
if (authentication.getPrincipal() instanceof UserDetails) { |
|||
UserDetails userDetails = (UserDetails) authentication.getPrincipal(); |
|||
return userDetails.getUsername(); |
|||
} |
|||
throw new JsonException(ResponseStatus.TOKEN_IS_NULL.getCode(), ResponseStatus.TOKEN_IS_NULL.getMessage()); |
|||
} |
|||
|
|||
/** |
|||
* 获取系统用户id |
|||
* @return |
|||
*/ |
|||
public static Long getCurrentUserId() { |
|||
UserDetails userDetails = getCurrentUser(); |
|||
return new JSONObject(new JSONObject(userDetails).get("user")).get("id", Long.class); |
|||
} |
|||
|
|||
/** |
|||
* 获取当前用户的数据权限 |
|||
* @return / |
|||
*/ |
|||
public static List<Long> getCurrentUserDataScope(){ |
|||
UserDetails userDetails = getCurrentUser(); |
|||
JSONArray array = JSONUtil.parseArray(new JSONObject(userDetails).get("dataScopes")); |
|||
return JSONUtil.toList(array,Long.class); |
|||
} |
|||
|
|||
/** |
|||
* 获取数据权限级别 |
|||
* @return 级别 |
|||
*/ |
|||
public static String getDataScopeType() { |
|||
List<Long> dataScopes = getCurrentUserDataScope(); |
|||
if(dataScopes.size() != 0){ |
|||
return ""; |
|||
} |
|||
return DataScopeEnum.ALL.getValue(); |
|||
} |
|||
|
|||
|
|||
} |
|||
@ -0,0 +1,84 @@ |
|||
package com.storeroom.utils; |
|||
|
|||
import lombok.extern.slf4j.Slf4j; |
|||
import org.springframework.beans.BeansException; |
|||
import org.springframework.beans.factory.DisposableBean; |
|||
import org.springframework.context.ApplicationContext; |
|||
import org.springframework.context.ApplicationContextAware; |
|||
import org.springframework.stereotype.Component; |
|||
|
|||
import java.util.ArrayList; |
|||
import java.util.List; |
|||
|
|||
@Slf4j |
|||
@Component |
|||
public class SpringContextHolder implements ApplicationContextAware, DisposableBean { |
|||
|
|||
private static ApplicationContext applicationContext = null; |
|||
private static final List<CallBack> CALL_BACKS = new ArrayList<>(); |
|||
private static boolean addCallback = true; |
|||
|
|||
public synchronized static void addCallBacks(CallBack callBack) { |
|||
if (addCallback) { |
|||
SpringContextHolder.CALL_BACKS.add(callBack); |
|||
} else { |
|||
log.warn("CallBack:{} 已无法添加！立即执行", callBack.getCallBackName()); |
|||
callBack.executor(); |
|||
} |
|||
} |
|||
|
|||
public static <T> T getBean(String name) { |
|||
assertContextInjected(); |
|||
return (T) applicationContext.getBean(name); |
|||
} |
|||
|
|||
/** |
|||
* 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型. |
|||
*/ |
|||
public static <T> T getBean(Class<T> requiredType) { |
|||
assertContextInjected(); |
|||
return applicationContext.getBean(requiredType); |
|||
} |
|||
|
|||
/** |
|||
* 检查App |
|||
*/ |
|||
private static void assertContextInjected() { |
|||
if (applicationContext == null) { |
|||
throw new IllegalStateException("applicaitonContext属性未注入请在applicationContext\" +\n" + |
|||
"\".xml中定义SpringContextHolder或在SpringBoot启动类中注册SpringContextHolder."); |
|||
} |
|||
|
|||
} |
|||
|
|||
/** |
|||
* 清除SpringContextHolder中的ApplicationContext为Null. |
|||
*/ |
|||
private static void clearHolder() { |
|||
log.debug("清除SpringContextHolder中的ApplicationContext:" |
|||
+ applicationContext); |
|||
applicationContext = null; |
|||
} |
|||
|
|||
@Override |
|||
public void destroy() { |
|||
SpringContextHolder.clearHolder(); |
|||
} |
|||
|
|||
@Override |
|||
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { |
|||
if (SpringContextHolder.applicationContext != null) { |
|||
log.warn("SpringContextHolder中的ApplicationContext被覆盖, 原有ApplicationContext为:" + SpringContextHolder.applicationContext); |
|||
} |
|||
SpringContextHolder.applicationContext = applicationContext; |
|||
if (addCallback) { |
|||
for (CallBack callBack : SpringContextHolder.CALL_BACKS) { |
|||
callBack.executor(); |
|||
} |
|||
CALL_BACKS.clear(); |
|||
} |
|||
SpringContextHolder.addCallback = false; |
|||
} |
|||
|
|||
|
|||
} |
|||
@ -0,0 +1,32 @@ |
|||
package com.storeroom.utils.enums; |
|||
|
|||
|
|||
import lombok.AllArgsConstructor; |
|||
import lombok.Getter; |
|||
|
|||
|
|||
/** |
|||
* 权限等级 |
|||
*/ |
|||
@Getter |
|||
@AllArgsConstructor |
|||
public enum DataScopeEnum { |
|||
|
|||
ALL("全部", "全部数据权限"), |
|||
|
|||
THIS_LEVEL("本级", "自己部门的数据权限"), |
|||
|
|||
CUSTOMIZE("自定义", "自定义数据权限"); |
|||
|
|||
private final String value; |
|||
private final String descrption; |
|||
|
|||
public static DataScopeEnum find(String val) { |
|||
for (DataScopeEnum dataScopeEnum : DataScopeEnum.values()) { |
|||
if (val.equals(dataScopeEnum.getValue())) { |
|||
return dataScopeEnum; |
|||
} |
|||
} |
|||
return null; |
|||
} |
|||
} |
|||
@ -0,0 +1,25 @@ |
|||
package com.storeroom.utils.enums; |
|||
|
|||
import com.storeroom.utils.DataStatusConst; |
|||
import lombok.Getter; |
|||
|
|||
@Getter |
|||
public enum DataStatusEnum { |
|||
|
|||
OK(DataStatusConst.OK,"正常"), |
|||
|
|||
FREEZED(DataStatusConst.FREEZED,"冻结"), |
|||
|
|||
DELETE(DataStatusConst.DELETE,"删除"); |
|||
|
|||
|
|||
private int code; |
|||
|
|||
private String message; |
|||
|
|||
DataStatusEnum(int code, String message){ |
|||
this.code=code; |
|||
this.message=message; |
|||
} |
|||
|
|||
} |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue