高考报名时间2022年11月1日还剩 天 距离2023年6月7日高考还有 天
栏目分类:
子分类:
返回
名师互学网用户登录
名师互学网
快速导航关闭
当前搜索
当前分类
前沿技术 软件开发 系统运维 产品运营 生活办公 面试经验 考试题库
子分类
人工智能 大数据 云计算 区块链 物联网 深度学习 机器学习 NLP 计算机视觉 语音识别 其他 大数据系统 数据可视化 数据挖掘与分析 其他 Docker/k8s 虚拟化 云平台 其他 基本原理 数字货币 智能合约 EOS应用 其他 通讯技术 嵌入式开发 单片机 物联网应用 HarmonyOS 其他 后端开发 Web开发 移动开发 游戏开发 Python Java 架构设计 C/C++/C# PHP .Net Go语言 R语言
实用工具
学习工具 小学数学练习 字帖生成 在线画板 函数绘制 拼音字母表 在线词典 黄历查询 亲戚关系计算 安全期计算 中国历史 Excel函数 模拟请求 json格式化 浏览器指纹
热门搜索
路由器设置 木托盘 宝塔面板 儿童python教程 心情低落 朋友圈 vim 双一流学科 专升本 我的学校 日记学校 西点培训学校 汽修学校 情书 化妆学校 塔沟武校 异形模板 西南大学排名 最精辟人生短句 6步教你追回被骗的钱 南昌大学排名 清朝十二帝 北京印刷学院排名 北方工业大学排名 北京航空航天大学排名 首都经济贸易大学排名 中国传媒大学排名 首都师范大学排名 中国地质大学(北京)排名 北京信息科技大学排名
名师互学网 > IT > 软件开发 > 后端开发 > Java

Springboot redis 缓存使用示例 | RedisTemplate

Java 更新时间： 发布时间： IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Springboot redis 缓存使用示例 | RedisTemplate

RedisUtil  工具类代码

import java.io.Serializable;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.linkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.Map.Entry;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springblade.core.tool.utils.CollectionUtil;
import org.springblade.core.tool.utils.StringUtil;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStringCommands.SetOption;
import org.springframework.data.redis.core.RedisConnectionUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

public class RedisUtil {
    private static final Logger log = LoggerFactory.getLogger(RedisUtil.class);
    private static final String SUCCESS = "OK";
    private static final long UN_EXPIRE = -1L;
    private final RedisTemplate redisTemplate;

    public RedisUtil(RedisTemplate redisTemplate) {
        Assert.notNull(redisTemplate, "redisTemplate is null");
        this.redisTemplate = redisTemplate;
    }

    public void set(String key, Object value) {
        this.redisTemplate.opsForValue().set(key, value);
    }

    public void setEx(String key, Object value, Duration timeout) {
        this.redisTemplate.opsForValue().set(key, value, timeout);
    }

    public void setEx(String key, Object value, Long seconds) {
        this.redisTemplate.opsForValue().set(key, value, seconds, TimeUnit.SECONDS);
    }

    @Nullable
    public  T get(String key) {
        return this.redisTemplate.opsForValue().get(key);
    }

    public  T get(String key, Class clazz) {
        try {
            if (StringUtils.isEmpty(key)) {
                return null;
            } else {
                Object obj = this.redisTemplate.opsForValue().get(key);
                return obj;
            }
        } catch (Exception var5) {
            log.error("redisUtil get", var5);
            return null;
        }
    }

    @Nullable
    public  T get(String key, Supplier loader) {
        T value = this.get(key);
        if (Objects.isNull(value)) {
            return value;
        } else {
            value = loader.get();
            if (Objects.nonNull(value)) {
                this.set(key, value);
            }

            return value;
        }
    }

    public Boolean del(String key) {
        return this.redisTemplate.delete(key);
    }

    public Long del(String... keys) {
        return this.del((Collection)Arrays.asList(keys));
    }

    public Long del(Collection keys) {
        return this.redisTemplate.delete(keys);
    }

    public Set keys(String pattern) {
        return this.redisTemplate.keys(pattern);
    }

    public void multiSet(Map kvMap) {
        this.redisTemplate.opsForValue().multiSet(kvMap);
    }

    public List multiGet(String... keys) {
        return this.multiGet((Collection)Arrays.asList(keys));
    }

    public List multiGet(Collection keys) {
        return this.redisTemplate.opsForValue().multiGet(new HashSet(keys));
    }

    public Long decr(String key) {
        return this.redisTemplate.opsForValue().decrement(key);
    }

    public Long decrBy(String key, long longValue) {
        return this.redisTemplate.opsForValue().decrement(key, longValue);
    }

    public Long incr(String key) {
        return this.redisTemplate.opsForValue().increment(key);
    }

    public Long incrBy(String key, long longValue) {
        return this.redisTemplate.opsForValue().increment(key, longValue);
    }

    public Long getCounter(String key) {
        return (Long)this.redisTemplate.opsForValue().get(key);
    }

    public Boolean exists(String key) {
        return this.redisTemplate.hasKey(key);
    }

    public String randomKey() {
        return (String)this.redisTemplate.randomKey();
    }

    public void rename(String oldkey, String newkey) {
        this.redisTemplate.rename(oldkey, newkey);
    }

    public Boolean move(String key, int dbIndex) {
        return this.redisTemplate.move(key, dbIndex);
    }

    public Boolean expire(String key, long seconds) {
        return this.redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
    }

    public Boolean expire(String key, Duration timeout) {
        return this.expire(key, timeout.getSeconds());
    }

    public Boolean expireAt(String key, Date date) {
        return this.redisTemplate.expireAt(key, date);
    }

    public Boolean expireAt(String key, long unixTime) {
        return this.expireAt(key, new Date(unixTime));
    }

    public Boolean pexpire(String key, long milliseconds) {
        return this.redisTemplate.expire(key, milliseconds, TimeUnit.MILLISECONDS);
    }

    public  T getSet(String key, Object value) {
        return this.redisTemplate.opsForValue().getAndSet(key, value);
    }

    public Boolean persist(String key) {
        return this.redisTemplate.persist(key);
    }

    public String type(String key) {
        if (StringUtil.isBlank(key)) {
            return "";
        } else {
            DataType dataType = this.redisTemplate.type(key);
            return Objects.nonNull(dataType) ? dataType.code() : "";
        }
    }

    public Long ttl(String key) {
        return this.redisTemplate.getExpire(key);
    }

    public Long pttl(String key) {
        return this.redisTemplate.getExpire(key, TimeUnit.MILLISECONDS);
    }

    public void hSet(String key, Object field, Object value) {
        this.redisTemplate.opsForHash().put(key, field, value);
    }

    public void hMset(String key, Map hash) {
        this.redisTemplate.opsForHash().putAll(key, hash);
    }

    public  T hGet(String key, Object field) {
        return this.redisTemplate.opsForHash().get(key, field);
    }

    public  T hGet(String key, Serializable item, Class clazz) {
        T t = null;
        if (!StringUtils.isEmpty(key) && !StringUtils.isEmpty(item)) {
            Object obj = this.redisTemplate.opsForHash().get(key, item);
            if (obj == null) {
                return null;
            } else {
                try {
                    t = obj;
                } catch (Exception var7) {
                    log.error("RedisUtil.hget", var7);
                }

                return t;
            }
        } else {
            return null;
        }
    }

    public  T hGet(String key, Serializable item, Class clazz, Supplier supplier) {
        if (!StringUtils.isEmpty(key) && !StringUtils.isEmpty(item)) {
            T t = this.redisTemplate.opsForHash().get(key, item);
            if (Objects.isNull(t)) {
                t = supplier.get();
                if (Objects.nonNull(t)) {
                    this.hSet(key, item, t);
                }
            }

            return t;
        } else {
            return null;
        }
    }

    public  T hGet(String key, Serializable item, Supplier supplier) {
        if (!StringUtils.isEmpty(key) && !StringUtils.isEmpty(item)) {
            T t = this.redisTemplate.opsForHash().get(key, item);
            if (Objects.isNull(t)) {
                t = supplier.get();
                if (Objects.nonNull(t)) {
                    this.hSet(key, item, t);
                }
            }

            return t;
        } else {
            return null;
        }
    }

    public List hmGet(String key, Object... fields) {
        return this.hmGet(key, (Collection)Arrays.asList(fields));
    }

    public List hmGet(String key, Collection hashKeys) {
        return this.redisTemplate.opsForHash().multiGet(key, hashKeys);
    }

    public Long hDel(String key, Object... fields) {
        return this.redisTemplate.opsForHash().delete(key, fields);
    }

    public Long hDel(String key, Collection fields) {
        return this.redisTemplate.opsForHash().delete(key, new Object[]{fields});
    }

    public Boolean hExists(String key, Object field) {
        return this.redisTemplate.opsForHash().hasKey(key, field);
    }

    public List hVals(String key) {
        return this.redisTemplate.opsForHash().values(key);
    }

    public Set hKeys(String key) {
        return this.redisTemplate.opsForHash().keys(key);
    }

    public Long hLen(String key) {
        return this.redisTemplate.opsForHash().size(key);
    }

    public Long hIncrBy(String key, Object field, long value) {
        return this.redisTemplate.opsForHash().increment(key, field, value);
    }

    public Double hIncrByFloat(String key, Object field, double value) {
        return this.redisTemplate.opsForHash().increment(key, field, value);
    }

    public  T lIndex(String key, long index) {
        return this.redisTemplate.opsForList().index(key, index);
    }

    public Long lLen(String key) {
        return this.redisTemplate.opsForList().size(key);
    }

    public  T lPop(String key) {
        return this.redisTemplate.opsForList().leftPop(key);
    }

    public Long lPush(String key, Object... values) {
        return this.redisTemplate.opsForList().leftPush(key, values);
    }

    public void lSet(String key, long index, Object value) {
        this.redisTemplate.opsForList().set(key, index, value);
    }

    public Long lDel(String key, long count, Object value) {
        return this.redisTemplate.opsForList().remove(key, count, value);
    }

    public Long lDelOne(String key, Object value) {
        return StringUtil.isBlank(key) ? null : this.lDel(key, 1L, value);
    }

    public Long lDelAll(String key, Object value) {
        return this.lDel(key, 0L, value);
    }

    public List lRange(String key, long start, long end) {
        return this.redisTemplate.opsForList().range(key, start, end);
    }

    public void lTrim(String key, long start, long end) {
        this.redisTemplate.opsForList().trim(key, start, end);
    }

    public  T rPop(String key) {
        return this.redisTemplate.opsForList().rightPop(key);
    }

    public Long rPush(String key, Object... values) {
        return this.redisTemplate.opsForList().rightPush(key, values);
    }

    public  T rPopLPush(String srcKey, String dstKey) {
        return this.redisTemplate.opsForList().rightPopAndLeftPush(srcKey, dstKey);
    }

    public Long sAdd(String key, Object... members) {
        return this.redisTemplate.opsForSet().add(key, members);
    }

    public  T sPop(String key) {
        return StringUtil.isBlank(key) ? null : this.redisTemplate.opsForSet().pop(key);
    }

    public Set sMembers(String key) {
        return StringUtil.isBlank(key) ? Collections.emptySet() : this.redisTemplate.opsForSet().members(key);
    }

    public  Set sMembers(String key, Class clazz) {
        if (StringUtil.isBlank(key)) {
            return Collections.emptySet();
        } else {
            Set set = this.redisTemplate.opsForSet().members(key);
            return CollectionUtil.isEmpty(set) ? Collections.emptySet() : (Set)set.stream().map((item) -> {
                return item;
            }).collect(Collectors.toSet());
        }
    }

    public boolean sIsMember(String key, Object member) {
        return !StringUtil.isBlank(key) && !Objects.isNull(member) ? this.redisTemplate.opsForSet().isMember(key, member) : false;
    }

    public Set sInter(String key, String otherKey) {
        return this.redisTemplate.opsForSet().intersect(key, otherKey);
    }

    public Set sInter(String key, Collection otherKeys) {
        return this.redisTemplate.opsForSet().intersect(key, otherKeys);
    }

    public  T sRandMember(String key) {
        return this.redisTemplate.opsForSet().randomMember(key);
    }

    public Set sUnion(String key, String otherKey) {
        return this.redisTemplate.opsForSet().union(key, otherKey);
    }

    public Set sUnion(String key, Collection otherKeys) {
        return this.redisTemplate.opsForSet().union(key, otherKeys);
    }

    public Set sDiff(String key, String otherKey) {
        return this.redisTemplate.opsForSet().difference(key, otherKey);
    }

    public Set sDiff(String key, Collection otherKeys) {
        return this.redisTemplate.opsForSet().difference(key, otherKeys);
    }

    public boolean hCover(String key, Map map) {
        if (!StringUtil.isBlank(key) && !Objects.isNull(map)) {
            String result = (String)this.redisTemplate.execute((connection) -> {
                try {
                    connection.multi();
                    StringRedisSerializer srs = (StringRedisSerializer)this.redisTemplate.getKeySerializer();
                    byte[] rawKey = srs.serialize(key);
                    if (Objects.isNull(rawKey)) {
                        return null;
                    }

                    connection.del(new byte[][]{rawKey});
                    Map hashes = new linkedHashMap(map.size());
                    GenericJackson2JsonRedisSerializer hashKeySerializer = (GenericJackson2JsonRedisSerializer)this.redisTemplate.getHashKeySerializer();
                    GenericJackson2JsonRedisSerializer hashValueSerializer = (GenericJackson2JsonRedisSerializer)this.redisTemplate.getHashValueSerializer();
                    Iterator var9 = map.entrySet().iterator();

                    while(var9.hasNext()) {
                        Entry entry = (Entry)var9.next();
                        hashes.put(hashKeySerializer.serialize(entry.getKey()), hashValueSerializer.serialize(entry.getValue()));
                    }

                    connection.hMSet(rawKey, hashes);
                    connection.exec();
                } catch (SerializationException var11) {
                    connection.discard();
                }

                return null;
            });
            return Objects.equals("OK", result);
        } else {
            return false;
        }
    }

    public void hdel(String key, Object... item) {
        this.redisTemplate.opsForHash().delete(key, item);
    }

    public  boolean hSetBatch(List list, Function keyFunction, Function hashKeyFunction, Function hashValueFunction) {
        RedisConnection connection = null;

        boolean var7;
        try {
            if (!CollectionUtils.isEmpty(list) && !Objects.isNull(keyFunction) && !Objects.isNull(hashKeyFunction) && !Objects.isNull(hashValueFunction)) {
                connection = ((RedisConnectionFactory)Objects.requireNonNull(this.redisTemplate.getConnectionFactory())).getConnection();
                StringRedisSerializer srs = (StringRedisSerializer)this.redisTemplate.getKeySerializer();
                GenericJackson2JsonRedisSerializer hashKeySerializer = (GenericJackson2JsonRedisSerializer)this.redisTemplate.getHashKeySerializer();
                GenericJackson2JsonRedisSerializer hashValueSerializer = (GenericJackson2JsonRedisSerializer)this.redisTemplate.getHashValueSerializer();
                connection.openPipeline();
                Iterator var9 = list.iterator();

                while(var9.hasNext()) {
                    T t = var9.next();
                    connection.hSet((byte[])Objects.requireNonNull(srs.serialize((String)keyFunction.apply(t))), (byte[])Objects.requireNonNull(hashKeySerializer.serialize(hashKeyFunction.apply(t))), (byte[])Objects.requireNonNull(hashValueSerializer.serialize(hashValueFunction.apply(t))));
                }

                connection.closePipeline();
                boolean var18 = true;
                return var18;
            }

            boolean var6 = false;
            return var6;
        } catch (Exception var14) {
            var7 = false;
        } finally {
            if (Objects.nonNull(connection) && !connection.isClosed()) {
                if (connection.isPipelined()) {
                    connection.closePipeline();
                }

                RedisConnectionUtils.releaseConnection(connection, this.redisTemplate.getConnectionFactory());
            }

        }

        return var7;
    }

    public boolean hDelBatch(List keys, Object item) {
        RedisConnection connection = ((RedisConnectionFactory)Objects.requireNonNull(this.redisTemplate.getConnectionFactory())).getConnection();
        StringRedisSerializer srs = (StringRedisSerializer)this.redisTemplate.getKeySerializer();
        GenericJackson2JsonRedisSerializer hashKeySerializer = (GenericJackson2JsonRedisSerializer)this.redisTemplate.getHashKeySerializer();
        connection.openPipeline();
        Iterator var6 = keys.iterator();

        while(var6.hasNext()) {
            String key = (String)var6.next();
            connection.hDel((byte[])Objects.requireNonNull(srs.serialize(key)), new byte[][]{hashKeySerializer.serialize(item)});
        }

        connection.closePipeline();
        return true;
    }

    public boolean setNxPx(String key, String val, long expire) {
        if (StringUtil.isAnyBlank(new CharSequence[]{key, val})) {
            return false;
        } else {
            try {
                RedisConnection conn = this.redisTemplate.getConnectionFactory().getConnection();
                byte[] rawKeys = key.getBytes(StandardCharsets.UTF_8);
                byte[] rawValues = val.getBytes(StandardCharsets.UTF_8);
                return conn.set(rawKeys, rawValues, Expiration.from(expire, TimeUnit.MILLISECONDS), SetOption.SET_IF_ABSENT);
            } catch (Exception var8) {
                log.error("set nx px error ", var8);
                return false;
            }
        }
    }

    public  Map hgetAll(String key, Class hkClazz, Class hvClazz) {
        try {
            Map data = this.redisTemplate.opsForHash().entries(key);
            if (CollectionUtils.isEmpty(data)) {
                return Collections.emptyMap();
            } else {
                Map result = new linkedHashMap();
                Iterator var6 = data.entrySet().iterator();

                while(var6.hasNext()) {
                    Entry entry = (Entry)var6.next();
                    result.put(entry.getKey(), entry.getValue());
                }

                return result;
            }
        } catch (Exception var8) {
            return Collections.emptyMap();
        }
    }

    public  Map hgetAll(String key, Class clazz) {
        try {
            Map data = this.redisTemplate.opsForHash().entries(key);
            if (CollectionUtils.isEmpty(data)) {
                return Collections.emptyMap();
            } else {
                Map result = new linkedHashMap();
                Iterator var5 = data.entrySet().iterator();

                while(var5.hasNext()) {
                    Entry entry = (Entry)var5.next();
                    result.put(entry.getKey(), entry.getValue());
                }

                return result;
            }
        } catch (Exception var7) {
            return Collections.emptyMap();
        }
    }

    public boolean setNxPx(String key, String val) {
        return this.setNxPx(key, val, -1L);
    }

    public  List lGetAll(String key, Class clazz) {
        if (StringUtil.isBlank(key)) {
            return Collections.emptyList();
        } else {
            try {
                long size = this.redisTemplate.opsForList().size(key);
                if (size <= 0L) {
                    return Collections.emptyList();
                } else {
                    List list = this.redisTemplate.opsForList().range(key, 0L, size);
                    return CollectionUtil.isEmpty(list) ? Collections.emptyList() : (List)list.stream().map((item) -> {
                        return item;
                    }).collect(Collectors.toList());
                }
            } catch (Exception var6) {
                log.error("RedisUtil.lGet", var6);
                return null;
            }
        }
    }

    public RedisTemplate getRedisTemplate() {
        return this.redisTemplate;
    }
}
 

 

示例一  用户信息缓存
 

import org.springblade.core.redis.cache.RedisUtil;
import org.springblade.core.tool.utils.MapUtil;
import org.springblade.core.tool.utils.SpringUtil;
import org.springblade.gis.modules.user.entity.User;
import org.springblade.gis.modules.user.service.UserService;

import java.util.Collection;
import java.util.List;
import java.util.Map;

import static org.springblade.gis.common.constant.CacheConstant.*;


public class SystemCache {

    private static final RedisUtil REDIS_UTIL;
    private static final UserService USER_SERVICE;

    static {
        REDIS_UTIL = SpringUtil.getBean(RedisUtil.class);
        USER_SERVICE = SpringUtil.getBean(UserService.class);
    }

    
    public static User getUser (Long userId) {
        return REDIS_UTIL.hGet(USER_CACHE, userId, User.class, () -> USER_SERVICE.getById(userId));
    }

    
    public static Collection getAllUser () {
        return REDIS_UTIL.hgetAll(USER_CACHE, Long.class, User.class).values();
    }

    
    public static void delUser (List userIds) {
        REDIS_UTIL.hDel(USER_CACHE, userIds);
        REDIS_UTIL.hDel(USER_NAME_CACHE, userIds);
    }

    public static void delAllUser(){
        REDIS_UTIL.del(USER_CACHE);
    }

    
    public static void deloneUser (Long userId) {
        REDIS_UTIL.hDel(USER_CACHE, userId);
        REDIS_UTIL.hDel(USER_NAME_CACHE, userId);
    }

    
    public static void saveUser (User user) {
        REDIS_UTIL.hSet(USER_CACHE, user.getId(), user);
        REDIS_UTIL.hSet(USER_NAME_CACHE, user.getId(), user.getRealName());
    }

    public static void initUser () {
        List list = USER_SERVICE.list();
        REDIS_UTIL.hMset(USER_CACHE, (Map) MapUtil.map(User::getId, list));
        REDIS_UTIL.hMset(USER_NAME_CACHE, MapUtil.map(User::getId, User::getRealName, list));
    }

}

 

redis 图形化展示
 

 

 

示例二  业务数据缓存
 


import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import org.springblade.core.redis.cache.RedisUtil;
import org.springblade.core.tool.utils.SpringUtil;
import org.springblade.gis.modules.dynamictable.entity.DynamicEntity;

import java.util.Collection;
import java.util.List;



public class DynamicDataCache {

    private static final RedisUtil REDIS_UTIL;

    static {
        REDIS_UTIL = SpringUtil.getBean(RedisUtil.class);
    }

    
    public static Collection getData (String batchNo) {
        return  REDIS_UTIL.hgetAll(batchNo,Long.class,DynamicEntity.class).values();
    }


    
    public static void delData (String batchNo) {
        REDIS_UTIL.del(batchNo);
    }

    
    public static void saveData (String batchNo,List entities) {
        entities.forEach(e->{
            REDIS_UTIL.hSet(batchNo, IdWorker.get32UUID(),e);
        });
        REDIS_UTIL.expire(batchNo,180L);
    }



}

 








转载请注明：文章转载自 www.mshxw.com















Java相关栏目本月热门文章












热门相关搜索






路由器设置
木托盘
宝塔面板
儿童python教程
心情低落
朋友圈
vim
双一流学科
专升本
我的学校
日记学校
西点培训学校
汽修学校
情书
化妆学校
塔沟武校
异形模板
西南大学排名
最精辟人生短句
6步教你追回被骗的钱
南昌大学排名
清朝十二帝
北京印刷学院排名
北方工业大学排名
北京航空航天大学排名
首都经济贸易大学排名
中国传媒大学排名
首都师范大学排名
中国地质大学(北京)排名
北京信息科技大学排名
中央民族大学排名
北京舞蹈学院排名
北京电影学院排名
中国戏曲学院排名
河北政法职业学院排名
河北经贸大学排名
天津中德应用技术大学排名
天津医学高等专科学校排名
天津美术学院排名
天津音乐学院排名
天津工业大学排名
北京工业大学耿丹学院排名
北京警察学院排名
天津科技大学排名
北京邮电大学(宏福校区)排名
北京网络职业学院排名
北京大学医学部排名
河北科技大学排名
河北地质大学排名
河北体育学院排名















学习工具


代数计算器


三角函数


解析几何


立体几何






知识解答


教育知识


百科知识


生活知识


常识知识






写作必备


作文大全


作文素材


句子大全



实用范文






关于我们


关于我们


联系我们


网站地图






 交流群

名师互学网交流群




名师互学网客服

名师互学网客服












名师互学网 版权所有 (c)2021-2022      ICP备案号：晋ICP备2021003244-6号
 








我们一直用心在做

关于我们
文章归档
网站地图
联系我们

版权所有 (c)2021-2022 MSHXW.COM


ICP备案号：晋ICP备2021003244-6号