Redis 工具类 与 Redis 布隆过滤器

news2024/11/18 1:50:03

Redis 工具类

1. 核心依赖

<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.31</version>
</dependency>

2. 序列化

public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
 
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
 
    private Class<T> clazz;
 
    static {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
    }
 
    public FastJsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }
 
    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }
 
    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);
        return JSON.parseObject(str, clazz);
    }

    protected JavaType getJavaType(Class<?> clazz)
    {
        return TypeFactory.defaultInstance().constructType(clazz);
    }
}

@Configuration
public class RedisSerializeConfig {

    @Bean
    @SuppressWarnings(value = { "unchecked", "rawtypes" })
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
        template.setConnectionFactory(connectionFactory);
        FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);
        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }
}

3. 布隆过滤器

/**
 * 算法过程：
 * 1. 首先需要k个hash函数，每个函数可以把key散列成为1个整数
 * 2. 初始化时，需要一个长度为n比特的数组，每个比特位初始化为0
 * 3. 某个key加入集合时，用k个hash函数计算出k个散列值，并把数组中对应的比特位置为1
 * 4. 判断某个key是否在集合时，用k个hash函数计算出k个散列值，并查询数组中对应的比特位，如果所有的比特位都是1，认为在集合中。
 **/
@Component
public class BloomFilterHelper<T> {

    private int numHashFunctions;

    private int bitSize;

    private Funnel<T> funnel;

    private static final int NUM_BITS = (int) 1e4;
    private static final double RATE = 0.03;//不存在误判为存在的概率

    private static void funnel(@Nullable Object o, PrimitiveSink primitiveSink) {
        primitiveSink.putBytes(o.toString().getBytes());
    }

    public BloomFilterHelper() {
        this((Funnel) BloomFilterHelper::funnel, NUM_BITS, RATE);
    }
    public BloomFilterHelper(Funnel<T> funnel, int expectedInsertions, double fpp) {
        this.funnel = funnel;
        // 计算bit数组长度
        bitSize = optimalNumOfBits(expectedInsertions, fpp);
        // 计算hash方法执行次数
        numHashFunctions = optimalNumOfHashFunctions(expectedInsertions, bitSize);
    }

    public int[] getHashOffset() {
        return new int[numHashFunctions];
    }

    public int[] murmurHashOffset(T value) {
        int[] offset = new int[numHashFunctions];

        long hash64 = Hashing.murmur3_128().hashObject(value, funnel).asLong();
        int hash1 = (int) hash64;
        int hash2 = (int) (hash64 >>> 32);
        for (int i = 1; i <= numHashFunctions; i++) {
            int nextHash = hash1 + i * hash2;
            if (nextHash < 0) {
                nextHash = ~nextHash;
            }
            offset[i - 1] = nextHash % bitSize;
        }
        return offset;
    }

    /**
     * 计算bit数组长度
     */
    private int optimalNumOfBits(long n, double p) {
        if (p == 0) {
            // 设定最小期望长度
            p = Double.MIN_VALUE;
        }
        return (int) (-n * Math.log(p) / (Math.log(2) * Math.log(2)));
    }

    /**
     * 计算hash方法执行次数
     */
    private int optimalNumOfHashFunctions(long n, long m) {
        return Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
    }
}

@Component
@RequiredArgsConstructor
public class RedisBloomFilter {

    private final RedisTemplate redisTemplate;

    private final BloomFilterHelper bloomFilterHelper;

    public void init(String bloomFilterName) {
        int[] offset = bloomFilterHelper.getHashOffset();
        for (int i : offset) {
            redisTemplate.opsForValue().setBit(bloomFilterName, i, true);
        }
    }

    /**
     * 根据给定的布隆过滤器添加值
     */
    public <T> void add(String bloomFilterName, T value) {
        int[] offset = bloomFilterHelper.murmurHashOffset(value);
        for (int i : offset) {
            redisTemplate.opsForValue().setBit(bloomFilterName, i, true);
        }
    }

    /**
     * 根据给定的布隆过滤器判断值是否存在
     */
    public <T> boolean contains(String bloomFilterName, T value) {
        int[] offset = bloomFilterHelper.murmurHashOffset(value);
        for (int i : offset) {
            if (!redisTemplate.opsForValue().getBit(bloomFilterName, i)) {
                return false;
            }
        }
        return true;
    }

}

4. Redis工具类

@Component
@RequiredArgsConstructor
@Slf4j
@SuppressWarnings(value = { "unchecked", "rawtypes" })
public class RedisCache {

    private final RedisTemplate redisTemplate;

    private final RedisBloomFilter redisBloomFilter;

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public Boolean expire(final String key, final long timeout, final TimeUnit timeUnit) {
        log.info("为 Redis 的键值设置超时时间\t[{}]-[{}  {}]", key, timeout, timeUnit.name());
        return redisTemplate.expire(key, timeout, timeUnit);
    }

    /**
     * 原子设置过期时间
     * @param key
     * @param value
     * @param timeout
     */
    public <T> void execute(final String key, final T value, final long timeout, final TimeUnit timeUnit) {
        log.info("尝试存入 Redis\t[{}]-[{}]，超时时间:[{}  {}]", key, value, timeout, timeUnit.name());
        redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations redisOperations) throws DataAccessException {
                redisOperations.multi();
                redisOperations.opsForValue().set(key, value);
                redisOperations.expire(key, timeout, timeUnit);
                return redisOperations.exec();
            }
        });
    }

    /**
     *  获得对象的剩余存活时间
     * @param key 键
     * @return 剩余存活时间
     */
    public long getKeyTTL(final String key, final TimeUnit timeUnit) {
        int ttl = Math.toIntExact(redisTemplate.opsForValue().getOperations().getExpire(key));
        String message = null;
        switch (ttl) {
            case -1:
                message = "没有设置过期时间";
                break;
            case -2:
                message = "key不存在";
                break;
            default:
                message = ttl + "  " + TimeUnit.SECONDS.name();
                break;
        }
        log.info("查询 Redis key[{}] 剩余存活时间:{}", key, message);
        return TimeUnit.SECONDS.convert(ttl, timeUnit);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value) {
        log.info("存入 Redis\t[{}]-[{}]", key, value);
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timout 超时时间
     */
    public <T> void setCacheObject(final String key, final T value, final long timout, final TimeUnit timeUnit) {
        log.info("存入 Redis\t[{}]-[{}]，超时时间:[{}  {}]", key, value, timout, timeUnit.name());
        redisTemplate.opsForValue().set(key, value, timout, timeUnit);
    }

    /**
     * 获取键值
     * @param key 键
     * @return 键对应的值，并封装成 Optional 对象
     * @param <T>
     */
    public <T> Optional<T> getCacheObject(final String key) {
        T value = (T) redisTemplate.opsForValue().get(key);
        log.info("查询 Redis\t[{}]-[{}]", key, value);
        return Optional.ofNullable(value);
    }

    /**
     * 让指定 Redis 键值进行自减
     * @param key 键
     * @return 自减后的值
     */
    public long decrementCacheNumber(final String key) {
        long number = redisTemplate.opsForValue().decrement(key);
        log.info("Redis key[{}] 自减后：{}", key, number);
        return number;
    }

    /**
     * 让指定 Redis 键值进行自增
     * @param key 键
     * @return 自增后的值
     */
    public long incrementCacheNumber(final String key) {
        long number = redisTemplate.opsForValue().increment(key);
        log.info("Redis key[{}] 自增后：{}", key, number);
        return number;
    }

    /**
     * 初始化布隆过滤器
     * @param bloomFilterName
     */
    public void initBloomFilter(final String bloomFilterName) {
        log.info("初始化布隆过滤器[{}]", bloomFilterName);
        redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations redisOperations) throws DataAccessException {
                redisOperations.multi();
                redisBloomFilter.init(bloomFilterName);
                return redisOperations.exec();
            }
        });
    }

    /**
     * 初始化布隆过滤器
     * @param bloomFilterName
     * @param timeout
     * @param timeUnit
     */
    public void initBloomFilter(final String bloomFilterName, final long timeout, final TimeUnit timeUnit) {
        redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations redisOperations) throws DataAccessException {
                redisOperations.multi();
                redisBloomFilter.init(bloomFilterName);
                expire(bloomFilterName, timeout, timeUnit);
                return redisOperations.exec();
            }
        });
    }

    /**
     * 加入布隆过滤器
     * @param bloomFilterName 隆过滤器的名字
     * @param key key 键
     */
    public <T> void addToBloomFilter(final String bloomFilterName, final T key) {
        log.info("加入布隆过滤器[{}]\tkey[{}]", bloomFilterName, key);
        redisTemplate.execute(new SessionCallback() {
            @Override
            public Object execute(RedisOperations redisOperations) throws DataAccessException {
                redisOperations.multi();
                redisBloomFilter.add(bloomFilterName, key);
                return redisOperations.exec();
            }
        });
    }

    /**
     * 布隆过滤器是否存在该键值
     * @param bloomFilterName 布隆过滤器的名字
     * @param key 键
     * @return 键是否存在
     */
    public <T> boolean containsInBloomFilter(final String bloomFilterName, final T key) {
        boolean flag = redisBloomFilter.contains(bloomFilterName, key);
        log.info("key[{}]\t是否存在于布隆过滤器[{}]:\t{}", key, bloomFilterName, flag);
        return flag;
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param data
     */
    public <K, T> void setCacheMap(final String key, final Map<K, T> data) {
        if (Objects.nonNull(data)) {
            log.info("Map 存入 Redis\t[{}]-[{}]", key, data);
            redisTemplate.opsForHash().putAll(key, data);
        }
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param data
     */
    public <K, T> void setCacheMap(final String key, final Map<K, T> data, long timeout, final TimeUnit timeUnit) {
        if (Objects.nonNull(data)) {
            Map<String, T> map = new HashMap<>();
            data.entrySet().stream().parallel().forEach(entry -> {
                map.put(entry.getKey().toString(), entry.getValue());
            });
            log.info("尝试存入 Redis\t[{}]-[{}] 超时时间:[{}  {}]", key, map, timeout, timeUnit.name());
            redisTemplate.execute(new SessionCallback() {
                @Override
                public Object execute(RedisOperations redisOperations) throws DataAccessException {
                    redisOperations.multi();
                    redisTemplate.opsForHash().putAll(key, map);
                    expire(key, timeout, timeUnit);
                    return redisOperations.exec();
                }
            });
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <K, T> Optional<Map<K, T>> getCacheMap(final String key) {
        Map<K, T> data = redisTemplate.opsForHash().entries(key);
        data = data.size() == 0 ? null: data;
        log.info("获取 Redis 中的 Map 缓存\t[{}]-[{}]", key, data);
        return Optional.ofNullable(data);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key Redis键
     * @param hashKey Hash键
     * @param value 值
     */
    public <K, T> void setCacheMapValue(final String key, final K hashKey, final T value) {
        log.info("存入 Redis 的某个 Map\t[{}.{}]-[{}]", key, hashKey, value);
        redisTemplate.opsForHash().put(key, hashKey.toString(), value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key Redis键
     * @param hashKey Hash键
     * @return Hash中的对象
     */
    public <K, T> Optional<T> getCacheMapValue(final String key, final K hashKey) {
        T value = (T) redisTemplate.opsForHash().get(key, hashKey.toString());
        log.info("获取 Redis 中的 Map 的键值\t[{}.{}]-[{}]", key, hashKey, value);
        return Optional.ofNullable(value);
    }

    /**
     * 删除Hash中的数据
     *
     * @param key
     * @param hashKey
     */
    public <K> void delCacheMapValue(final String key, final K hashKey) {
        log.info("删除 Redis 中的 Map 的键值\tkey[{}.{}]", key, hashKey);
        redisTemplate.opsForHash().delete(key, hashKey.toString());
    }

    /**
     * 让指定 HashMap 的键值进行自减
     * @param key HashMap的名字
     * @param hashKey HashMap的一个键
     * @return 自减后的值
     */
    public <K> long decrementCacheMapNumber(final String key, final K hashKey) {
        long number = redisTemplate.opsForHash().increment(key, hashKey.toString(), -1);
        log.info("Redis key[{}.{}] 自减后：{}", key, hashKey, number);
        return number;
    }

    /**
     * 让指定 HashMap 的键值进行自增
     * @param key HashMap的名字
     * @param hashKey HashMap的一个键
     * @return 自增后的值
     */
    public <K> long incrementCacheMapNumber(final String key, final K hashKey) {
        long number = redisTemplate.opsForHash().increment(key, hashKey.toString(), +1);
        log.info("Redis key[{}.{}] 自增后：{}", key, hashKey, number);
        return number;
    }

    /**
     * 删除单个对象
     * @param key
     */
    public boolean deleteObject(final String key) {
        log.info("删除 Redis 的键值\tkey[{}]", key);
        return redisTemplate.delete(key);
    }

}

5. 查询Redis与Redis设置缓存的技巧

伪代码：

redisCache.getCacheObject(redisKey)
    .orElseGet(() -> {
        /* balabala ....*/
        // 可能查询有误，所以这里也可能没法获取到data（为null），也就可能没必要设置缓存
        redisCache.setCacheObject(redisKey, data, ttl, unit); 
        /* balabala ....*/
        return data;
    }));

现实示例：

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1467099.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

网卡本质,网络发展(局域网,广域网概念)

网卡本质,网络发展(局域网,广域网概念)

目录 引入 网卡的本质 网络的发展 引入 早期 局域网LAN&#xff08;Local Area Network&#xff09; 广域网WAN&#xff08;Wide Area Network&#xff09; 注意 引入 前面我们已经学习了很多关于linux系统的知识,其中文件系统和线程尤为繁杂 而网络其实也算系统的一部…
阅读更多...
Vue监听器(上)之组合式watch

Vue监听器(上)之组合式watch

1. 定义监听器 //要监视的属性被改变时触发 watch(要监视的属性, (更改后的心值, 更改前的旧值) > {具体操作}, );//监视对象为getter的时候 //表达式内任意响应式属性被改变时触发 watch(() > return表达式, (表达式的新值, 表达式的旧值) > {具体操作} );//数组中任…
阅读更多...
如何实现一个规则研究区域内数据的提取（matlab）

如何实现一个规则研究区域内数据的提取（matlab）

在利用经验正交分解&#xff08;EOF&#xff09;进行某一个研究区域分析时&#xff0c;我们需要将研究区域转换成N*M的矩阵&#xff0c;其中N为空间维度&#xff0c;M为时间维度&#xff0c;这意味着我们之前的数据加上时间维度是三维的&#xff0c;即&#xff08;lon,lat,rg&a…
阅读更多...
【深入理解设计模式】原型设计模式

【深入理解设计模式】原型设计模式

原型设计模式 原型设计模式&#xff08;Prototype Pattern&#xff09;是一种创建型设计模式&#xff0c;它允许通过复制已有对象来创建新对象&#xff0c;而无需直接依赖它们的具体类。这种模式通常用于需要频繁创建相似对象的场景&#xff0c;以避免昂贵的创建操作或初始化过…
阅读更多...
泛微e-office系统敏感信息泄露漏洞

泛微e-office系统敏感信息泄露漏洞

声明 本文仅用于技术交流&#xff0c;请勿用于非法用途 由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失&#xff0c;均由使用者本人负责&#xff0c;文章作者不为此承担任何责任 1、系统简介 泛微e-office系统是标准、易用、快速部署上线的专业协同OA软…
阅读更多...
C++之类作用域

C++之类作用域

目录 1、全局作用域 2、类作用域 2.1、设计模式之Pimpl 2.2、单例模式的自动释放 2.2.0、检测内存泄漏的工具valgrind 2.2.1、可以使用友元形式进行设计 2.2.2、内部类加静态数据成员形式 2.2.3、atexit方式进行 2.2.4、pthread_once形式 作用域可以分为类作用域、类名…
阅读更多...
【MIT-PHP-推荐】imi-ai 是一个 ChatGPT 开源项目

【MIT-PHP-推荐】imi-ai 是一个 ChatGPT 开源项目

mi-ai 是一个 ChatGPT 开源项目&#xff0c;支持聊天、问答、写代码、写文章、做作业等功能。 项目架构合理&#xff0c;代码编写优雅&#xff0c;简单快速部署。前后端代码完全开源&#xff0c;不管是学习自用还是商用二开都很适合。 本项目现已支持 ChatGPT 聊天 AI 和 Emb…
阅读更多...
PyTorch概述（五）---LINEAR

PyTorch概述（五）---LINEAR

torch.nn.Linear torch.nn.Linear(in_features,out_features,biasTrue,deviceNone,dtypeNone) 对输入的数据应用一个线性变换&#xff1a; 该模块支持TensorFLoat32类型的数据&#xff1b;在某些ROCm设备上&#xff0c;使用float16类型的数据输入时&#xff0c;该模块在反向传…
阅读更多...
电路设计（28）——交通灯控制器的multisim仿真

电路设计（28）——交通灯控制器的multisim仿真

1.功能设定 南北、东西两道的红灯时间、绿灯时间均为24S&#xff0c;数码管显示倒计时。在绿灯的最后5S内&#xff0c;黄灯闪烁。有夜间模式&#xff1a;按下按键进入夜间模式。在夜间模式下&#xff0c;数码管显示计数最大值&#xff0c;两个方向的黄灯不停闪烁。 2.电路设计 …
阅读更多...
高通XBL阶段读取分区

高通XBL阶段读取分区

【需求】： 在某些场景下，需要在XBL阶段读取分区数据，需要验证xbl阶段方案 这里主要以裸分区为例，比如oem分区。 1、创建一个1MB大小的oem.img，写入内容“test oem partition” 创建方式： dd if=/dev/null of=oem.img bs=1024 count=1oem.img内容： 2、XBL阶段读分区方…
阅读更多...
一个更好的IP工具箱MyIP

一个更好的IP工具箱MyIP

什么是 MyIP &#xff1f; MyIP 是一个完全开源的 IP 信息查看器&#xff0c;可以轻松检查你的 IP&#xff0c;IP 地理位置&#xff0c;检查 DNS 泄漏&#xff0c;检查 WebRTC 连接&#xff0c;速度测试&#xff0c;ping 测试&#xff0c;MTR 测试&#xff0c;检查网站可用性等…
阅读更多...
洛谷C++简单题小练习day20—小狗暴躁，津津的不高兴程度两个小程序（祝大家元宵节happy)

洛谷C++简单题小练习day20—小狗暴躁，津津的不高兴程度两个小程序（祝大家元宵节happy)

day20--小狗暴躁--2.24 习题概述 题目描述 在一个小村子里&#xff0c;邮递员、送奶工、垃圾清理工每天早晨都面临着同样的难题&#xff1a;18 号房子的门前有两条看门狗。他们所不知道的是&#xff0c;这两条狗的表现是有迹可循的。 当一天开始时&#xff0c;其中一条狗会…
阅读更多...
流畅的Python笔记

流畅的Python笔记

流畅的Python 第一部分 序幕第 1 章 Python 数据模型 第二部分 数据结构第 2 章 序列构成的数组列表推导生成器表达式元组切片对序列使用和*序列的增量赋值list.sort方法和内置函数sortedbisect数组memoryviewdeque 第 3 章 字典和集合第 4 章 文本和字节序列 第三部分 把函数视…
阅读更多...
Leetcode 209.长度最小的子数组

Leetcode 209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。 找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl1, ..., numsr-1, numsr] &#xff0c;并返回其长度。如果不存在符合条件的子数组&#xff0c;返回 0 。 示例 1&#xff1a; 输入&…
阅读更多...
Linux---权限管理（ACL权限、特殊位和隐藏属性）

Linux---权限管理（ACL权限、特殊位和隐藏属性）

目录 1.ACT权限 1.1什么是ACT权限 1.2ACT图解 2.操作步骤 2.1添加测试目录、用户、组&#xff0c;并将用户添加到组 2.2修改目录的所有者和所属组 2.3设定权限 2.4为临时用户分配权限 2.4.1添加临时用户 2.4.2为临时用户分配特定权限 2.4.3查看目录权限&#xff0c;注…
阅读更多...
Moment.js——轻松处理日期和和时间，有实例代码

Moment.js——轻松处理日期和和时间，有实例代码

hello&#xff0c;我是贝格前端工场&#xff0c;本期给大家带来便捷的处理日期和时间的js库&#xff1a;Moment.js&#xff0c;用这个类库处理时间将会十分方便&#xff0c;欢迎老铁们点赞关注&#xff0c;如有前端定制开发需求可以私信我们。 一、Moment.js的简介和功能 Mom…
阅读更多...
C++多线程同步（上）

C++多线程同步（上）

多线程同步 引言总述详情互斥锁示例运行结果分析条件变量示例一实现分析优化运行结果示例二实现代码运行结果示例三实现代码运行结果读写锁示例实现代码注意分析运行结果附言实现运行结果运行结果个人心得引言 项目中使用多线程，会遇到两种问题，一种是对共享资源的访问时需要…
阅读更多...
echarts多y轴样式重叠问题

echarts多y轴样式重叠问题

1、主要属性设置 yAxis: [{//y轴1nameTextStyle: {align: "right",padding: 0}},{//y轴2nameTextStyle: {align: "left",padding: 0}},{//y轴3axisLabel: {margin: 50},nameTextStyle: {align: "left",padding: [0, 0, 0, 50]},axisPointer: {l…
阅读更多...
Web基础02 -CSS+CSS3

Web基础02 -CSS+CSS3

目录 一、CSS 1.CSS盒模型 2.元素宽度计算 3.元素高度计算 4.宽度和高度的度量单位 5.设置元素的极限宽高 6.CSS属性&#xff08;第二部分&#xff09; &#xff08;1&#xff09;纯色背景 &#xff08;2&#xff09;图片背景 &#xff08;3&#xff09;列表样式 &am…
阅读更多...
Tomcat信创平替之TongWEB(东方通),安装步骤

Tomcat信创平替之TongWEB(东方通),安装步骤

我的系统: 银河麒麟桌面系统V10(SP1) 开局先吐槽一下(当然国产也是需要大量时间与金钱的投入),感觉国产软件进入死循环:国家推动国产→国产收费→还要钱?→用国外开源→国产无发普及→靠国家推动 正题: 1.先进入东方通申请使用 2.客服会发送一个TongWEB包与license.dat给你…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023