().in(field, values));
}
/**
* 逐条插入，适合少量数据插入，或者对性能要求不高的场景
*
* 如果大量，请使用 {@link com.baomidou.mybatisplus.extension.service.impl.ServiceImpl#saveBatch(Collection)} 方法
*
* @param entities 实体们
*/
default void insertBatch(Collection entities) {
entities.forEach(this::insert);
}
default void updateBatch(T update) {
update(update, new QueryWrapper<>());
}
}
================================================
FILE: campus-common/src/main/java/com/oddfar/campus/common/core/LambdaQueryWrapperX.java
================================================
package com.oddfar.campus.common.core;
import cn.hutool.core.util.ArrayUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import org.springframework.util.StringUtils;
import java.util.Collection;
import java.util.Map;
/**
* 拓展 MyBatis Plus QueryWrapper 类，主要增加如下功能：
*
* 1. 拼接条件的方法，增加 xxxIfPresent 方法，用于判断值不存在的时候，不要拼接到条件中。
*
* @param 数据类型
*/
public class LambdaQueryWrapperX extends LambdaQueryWrapper {
public LambdaQueryWrapperX likeIfPresent(SFunction column, String val) {
if (StringUtils.hasText(val)) {
return (LambdaQueryWrapperX) super.like(column, val);
}
return this;
}
public LambdaQueryWrapperX inIfPresent(SFunction column, Collection values) {
if (!CollectionUtils.isEmpty(values)) {
return (LambdaQueryWrapperX) super.in(column, values);
}
return this;
}
public LambdaQueryWrapperX inIfPresent(SFunction column, Object... values) {
if (!ArrayUtil.isEmpty(values)) {
return (LambdaQueryWrapperX) super.in(column, values);
}
return this;
}
public LambdaQueryWrapperX eqIfPresent(SFunction column, Object val) {
if (val != null) {
return (LambdaQueryWrapperX) super.eq(column, val);
}
return this;
}
public LambdaQueryWrapperX neIfPresent(SFunction column, Object val) {
if (val != null) {
return (LambdaQueryWrapperX) super.ne(column, val);
}
return this;
}
public LambdaQueryWrapperX gtIfPresent(SFunction column, Object val) {
if (val != null) {
return (LambdaQueryWrapperX) super.gt(column, val);
}
return this;
}
public LambdaQueryWrapperX geIfPresent(SFunction column, Object val) {
if (val != null) {
return (LambdaQueryWrapperX) super.ge(column, val);
}
return this;
}
public LambdaQueryWrapperX ltIfPresent(SFunction column, Object val) {
if (val != null) {
return (LambdaQueryWrapperX) super.lt(column, val);
}
return this;
}
public LambdaQueryWrapperX leIfPresent(SFunction column, Object val) {
if (val != null) {
return (LambdaQueryWrapperX) super.le(column, val);
}
return this;
}
public LambdaQueryWrapperX betweenIfPresent(SFunction column, Object val1, Object val2) {
if (val1 != null && val2 != null) {
return (LambdaQueryWrapperX) super.between(column, val1, val2);
}
if (val1 != null) {
return (LambdaQueryWrapperX) ge(column, val1);
}
if (val2 != null) {
return (LambdaQueryWrapperX) le(column, val2);
}
return this;
}
public LambdaQueryWrapperX betweenIfPresent(SFunction column, Object[] values) {
Object val1 = ArrayUtil.get(values, 0);
Object val2 = ArrayUtil.get(values, 1);
return betweenIfPresent(column, val1, val2);
}
public LambdaQueryWrapperX betweenIfPresent(SFunction column, Map values) {
String val1 = (String) values.get("beginTime");
String val2 = (String) values.get("endTime");
return betweenIfPresent(column, val1, val2);
}
// ========== 重写父类方法，方便链式调用 ==========
@Override
public LambdaQueryWrapperX eq(boolean condition, SFunction column, Object val) {
super.eq(condition, column, val);
return this;
}
@Override
public LambdaQueryWrapperX eq(SFunction column, Object val) {
super.eq(column, val);
return this;
}
@Override
public LambdaQueryWrapperX orderByDesc(SFunction column) {
super.orderByDesc(true, column);
return this;
}
@Override
public LambdaQueryWrapperX last(String lastSql) {
super.last(lastSql);
return this;
}
@Override
public LambdaQueryWrapperX in(SFunction column, Collection coll) {
super.in(column, coll);
return this;
}
}
================================================
FILE: campus-common/src/main/java/com/oddfar/campus/common/core/RedisCache.java
================================================
package com.oddfar.campus.common.core;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* spring redis 工具类
*
* @author ruoyi
**/
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisCache {
@Autowired
public RedisTemplate redisTemplate;
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
*/
public void setCacheObject(final String key, final T value) {
redisTemplate.opsForValue().set(key, value);
}
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
* @param timeout 时间
* @param timeUnit 时间颗粒度
*/
public void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功；false=设置失败
*/
public boolean expire(final String key, final long timeout) {
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功；false=设置失败
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit) {
return redisTemplate.expire(key, timeout, unit);
}
/**
* 获取有效时间
*
* @param key Redis键
* @return 有效时间
*/
public long getExpire(final String key) {
return redisTemplate.getExpire(key);
}
/**
* 判断 key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public Boolean hasKey(String key) {
return redisTemplate.hasKey(key);
}
/**
* 获得缓存的基本对象。
*
* @param key 缓存键值
* @return 缓存键值对应的数据
*/
public T getCacheObject(final String key) {
ValueOperations operation = redisTemplate.opsForValue();
return operation.get(key);
}
/**
* 删除单个对象
*
* @param key
*/
public boolean deleteObject(final String key) {
return redisTemplate.delete(key);
}
/**
* 删除集合对象
*
* @param collection 多个对象
* @return
*/
public boolean deleteObject(final Collection collection) {
return redisTemplate.delete(collection) > 0;
}
/**
* 缓存List数据
*
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
public long setCacheList(final String key, final List dataList) {
Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
return count == null ? 0 : count;
}
/**
* 重新set缓存List数据
*
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
public long reSetCacheList(final String key, final List dataList) {
this.deleteObject(key);
Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
return count == null ? 0 : count;
}
/**
* 获得缓存的list对象
*
* @param key 缓存的键值
* @return 缓存键值对应的数据
*/
public List getCacheList(final String key) {
return redisTemplate.opsForList().range(key, 0, -1);
}
/**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
public BoundSetOperations setCacheSet(final String key, final Set dataSet) {
BoundSetOperations setOperation = redisTemplate.boundSetOps(key);
Iterator it = dataSet.iterator();
while (it.hasNext()) {
setOperation.add(it.next());
}
return setOperation;
}
/**
* 获得缓存的set
*
* @param key
* @return
*/
public Set getCacheSet(final String key) {
return redisTemplate.opsForSet().members(key);
}
/**
* 缓存Map
*
* @param key
* @param dataMap
*/
public void setCacheMap(final String key, final Map dataMap) {
if (dataMap != null) {
redisTemplate.opsForHash().putAll(key, dataMap);
}
}
/**
* 获得缓存的Map
*
* @param key
* @return
*/
public Map getCacheMap(final String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public void setCacheMapValue(final String key, final String hKey, final T value) {
redisTemplate.opsForHash().put(key, hKey, value);
}
/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public T getCacheMapValue(final String key, final String hKey) {
HashOperations opsForHash = redisTemplate.opsForHash();
return opsForHash.get(key, hKey);
}
/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public List getMultiCacheMapValue(final String key, final Collection
](https://www.jetbrains.com/?from=campus)
[