首页 精品内容 本月促销 HOT 装机必备 HOT Windows macOS软件 IOS软件 Android AI PDF教程 专题

当前位置：

首页 > 编程开发 > SpringBoot集成Redis开启缓存机制的方法

SpringBoot集成Redis开启缓存机制的方法

作者：FreshDream 时间：2023-04-26 来源：互联网 浏览：0

集成springboot+redis+mybatisplus的一个小demopom文件4.0.0com.wlientspringboot_mq_redis0.0.1-SNAPSHOTspringboot_mq_redisDemoprojectforSpringBoot1.8UTF-8UTF-82.3.7.RELEASEorg.springframework.bootspring-boot-starter-amqporg.springframework.bootspring-boot-starter-dat

集成springboot+redis+mybatis plus的一个小demo

pom文件



    4.0.0
    com.wlient
    springboot_mq_redis
    0.0.1-SNAPSHOT
    springboot_mq_redis
    Demo project for Spring Boot

    
        1.8
        UTF-8
        UTF-8
        2.3.7.RELEASE
    

    
        
            org.springframework.boot
            spring-boot-starter-amqp
        
        
            org.springframework.boot
            spring-boot-starter-data-redis
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            com.baomidou
            mybatis-plus-boot-starter
            3.4.2
        

        
            org.springframework.boot
            spring-boot-devtools
            runtime
            true
        
        
            mysql
            mysql-connector-java
            runtime
        
        
            org.projectlombok
            lombok
            true
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine
                
            
        
        
            junit
            junit
            test
        
        
            org.springframework.amqp
            spring-rabbit-test
            test
        
        
            org.aspectj
            aspectjweaver
            1.9.6
        
        
        
            redis.clients
            jedis
            3.2.0
        
        
        
            com.github.xiaoymin
            knife4j-spring-boot-starter
            2.0.7
        
        
            com.alibaba
            fastjson
            1.2.76
        
    

    
        
            
                org.springframework.boot
                spring-boot-dependencies
                ${spring-boot.version}
                pom
                import
            
        
    

    
        
            
                org.apache.maven.plugins
                maven-compiler-plugin
                3.8.1
                
                    1.8
                    1.8
                    UTF-8
                
            
            
                org.springframework.boot
                spring-boot-maven-plugin
                2.3.7.RELEASE
                
                    com.wlient.springboot_mq_redis.SpringbootMqRedisApplication
                
                
                    
                        repackage
                        
                            repackage
                        
                    
                
            
        
    

yaml文件

spring:
  redis:
    host: 1.117.89.11
    port: 6378
    password: Terry123456.
    timeout: 60s
    database: 2
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms

      #spring cache 配置
      cache:
        type: redis
        redis:
          #      key过期时间 半小时
          time-to-live: 1800000 #毫秒

CacheConfig

@Configuration
public class CacheConfig  {

	@Bean
	CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
		RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();

		//common信息缓存配置
		RedisCacheConfiguration userCacheConfiguration = defaultCacheConfig
				// 设置 key为string序列化
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
				// 设置value为json序列化
				.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())).disableCachingNullValues();
		Map redisCacheConfigurationMap = new HashMap<>();
		//entryTtl设置缓存失效时间，单位是秒
		redisCacheConfigurationMap.put("common", userCacheConfiguration.entryTtl(Duration.ofSeconds(30)));


		//设置CacheManager的值序列化方式为JdkSerializationRedisSerializer,但其实RedisCacheConfiguration默认就是使用StringRedisSerializer序列化key，JdkSerializationRedisSerializer序列化value,所以以下注释代码为默认实现
		//ClassLoader loader = this.getClass().getClassLoader();
		//JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer(loader);
		//RedisSerializationContext.SerializationPair pair = RedisSerializationContext.SerializationPair.fromSerializer(jdkSerializer);
		//RedisCacheConfiguration defaultCacheConfig=RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);

		Set cacheNames = new HashSet<>();
		cacheNames.add("common");
		//初始化RedisCacheManager
		RedisCacheManager cacheManager = RedisCacheManager.builder(connectionFactory).cacheDefaults(defaultCacheConfig).initialCacheNames(cacheNames).withInitialCacheConfigurations(redisCacheConfigurationMap).build();
		return cacheManager;
	}
}
RedisConfig
package com.wlient.springboot_mq_redis.Configuar;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate template = new RedisTemplate();

        template.setConnectionFactory(factory);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper om = new ObjectMapper();

        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(om);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key采用String的序列化方式

        template.setKeySerializer(stringRedisSerializer);

        // hash的key也采用String的序列化方式

        template.setHashKeySerializer(stringRedisSerializer);

        // value序列化方式采用jackson

        template.setValueSerializer(jackson2JsonRedisSerializer);

        // hash的value序列化方式采用jackson

        template.setHashValueSerializer(jackson2JsonRedisSerializer);


        template.afterPropertiesSet();

        return template;

    }
}
SpringCacheConfig
package com.wlient.springboot_mq_redis.Configuar;

import org.springframework.boot.autoconfigure.cache.CacheProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
/**
 * spring cache 配置
 */
@EnableConfigurationProperties(CacheProperties.class)
@Configuration
@EnableCaching
public class SpringCacheConfig {

    @Bean
    public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {

        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.string()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.json()));

        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        //将配置文件中所有的配置都生效
        if (redisProperties.getTimeToLive() != null) {
            config = config.entryTtl(redisProperties.getTimeToLive());
        }
        if (redisProperties.getKeyPrefix() != null) {
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        }
        if (!redisProperties.isCacheNullValues()) {
            config = config.disableCachingNullValues();
        }
        if (!redisProperties.isUseKeyPrefix()) {
            config = config.disableKeyPrefix();
        }
        return config;
    }
}
RedisService
package com.wlient.springboot_mq_redis.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Service
public class RedisService {

    @Resource
    private RedisTemplate redisTemplate;

    // =============================common============================
    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }


    // ============================String=============================
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @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) {
            e.printStackTrace();
            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) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     * @param key 键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     * @param key 键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ================================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 hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            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) {
            e.printStackTrace();
            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) {
            e.printStackTrace();
            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 items 项 可以使多个 不能为null
     */
    public void hdel(String key, Collection items) {
        redisTemplate.opsForHash().delete(key, items.toArray());
    }

    /**
     * 判断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 delta 要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForHash().increment(key, item, delta);
    }

    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param delta 要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForHash().increment(key, item, -delta);
    }

    // ============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            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) {
            e.printStackTrace();
            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) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Collection values) {
        try {
            return redisTemplate.opsForSet().add(key, values.toArray());
        } catch (Exception e) {
            e.printStackTrace();
            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) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            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) {
            e.printStackTrace();
            return 0;
        }
    }

    // ===============================list=================================
    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束 0 到 -1代表所有值
     * @return
     */
    public List lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            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) {
            e.printStackTrace();
            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) {
            e.printStackTrace();
            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) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, List value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            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) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}
Application
@SpringBootApplication
@MapperScan("com.wlient.springboot_mq_redis.dao")
@EnableCaching
public class SpringbootMqRedisApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootMqRedisApplication.class, args);
    }

}
主要是添加@EnableCaching注解开启缓存
缓存有两种方式:
方式一：直接使用对RedisTemplate进行封装的RedisService进行缓存操作
controller层
    @Autowired
    RedisService redisService;
    
    @GetMapping("selectOne2")
    public ServiceResult selectOne2(Integer id) {
        User user =  (User) redisService.get("selectOne2::"+id);
        if (user == null){
            user = userService.queryById2(id);
            redisService.set("selectOne2::"+id,user);
        }
        System.out.println(user);
        return ServiceResult.ok(user);
    }
方式二：使用注解
作用于Service层
@Service("userService")
@CacheConfig(cacheNames = "departmentsService")
public class UserServiceImpl implements UserService {
    @Resource
    private UserDao userDao;

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    @Override
    @Cacheable(key = "#root.methodName+':'+#id")
    public User queryById(Integer id) {
        User user = this.userDao.selectById(id);
        return user;
    }
}
使用注解比较方便，但是不够灵活。
使用封装类增加了代码量，但是可以满足大部分需求
配置文件详解
RedisConfig：redis cache，设置key，value的序列化方式等
SpringCacheConfig：spring cache 配置
这两个文件缺一不可，缺失SpringCacheConfig配置文件，那么存入redis的数据会乱码
CacheConfig：可有可无，只是根据需求采用的配置（从项目里copy的）
SpringBoot集成Redis开启缓存机制的方法
                        
                                                本文内容来源于互联网，如有侵权请联系删除。
                                                

                            作者最新文章
                            
                        

                                                

                                                        编程开发
                            
                        

                                                

                            
                            
                        

                        

                            

                                相关文章
                                更多
                            

                            

                                                                

                                    C++动态数组初始化怎么写？常用语句与代码示例
                                    

                                        C++动态数组初始化怎么写？常用语句与代码示例
                                        
深入解析C++中动态数组的初始化机制，涵盖new操作符的不同用法、基本类型与类对象的初始化差异，以及为何在现代C++开发中应优先使用std::vector。

                                        

                                            

                                                2026-09-21
                                                0
                                                                                                CalmMoment
                                                                                            

                                                                                        

                                                                                                内存管理
                                                                                                C++
                                                                                                动态数组
                                                                                            

                                                                                    

                                    

                                

                                                                

                                    using namespace 使用中遇到的问题怎么解决
                                    

                                        using namespace 使用中遇到的问题怎么解决
                                        
命名空间的基本概念与常见引入问题在C++等编程语言中，命名空间（namespace）是一种将代码标识符（如变量、函数、类名）封装在特定名称下的机制，其主要目的是避免命名冲突，尤其是在大型项目或使用多个第三方库时。使用“using namespace”指令可以将指定命名空间中的所有名称引入当前作用域，

                                        

                                            

                                                2026-08-07
                                                1
                                                                                                SunnyJourney
                                                                                            

                                                                                    

                                    

                                

                                                                

                                    c语言函数递归 实操经验总结：这些技巧很实用
                                    

                                        c语言函数递归 实操经验总结：这些技巧很实用
                                        
理解递归的基本原理在C语言中，递归是一种函数调用自身的编程技术。要掌握它，首先需要理解其核心思想：将一个复杂的大问题，分解为一个或几个与原问题相似但规模更小的子问题，直到子问题足够简单，可以直接求解。这个过程通常包含两个关键部分：递归出口和递归体。递归出口定义了问题何时不再继续分解，即最简单、可直接

                                        

                                            

                                                2026-08-07
                                                0
                                                                                                SoftHope
                                                                                            

                                                                                    

                                    

                                

                                                                

                                    c语言函数递归 怎么选？常见方案对比分析
                                    

                                        c语言函数递归 怎么选？常见方案对比分析
                                        
递归函数的基本概念与适用场景在C语言编程中，递归是一种函数调用自身的编程技巧。它并非适用于所有问题，但在处理某些具有自相似结构的问题时，能提供极其清晰和优雅的解决方案。递归的核心思想是将一个大规模问题分解为一个或多个同类型但规模更小的子问题，直到子问题简单到可以直接求解。典型的适用场景包括树形结构的

                                        

                                            

                                                2026-08-07
                                                1
                                                                                                归人云淡风轻
                                                                                            

                                                                                    

                                    

                                

                                                                

                                    Objective-C 内存管理入门：从 alloc 到 dealloc 的生命周期详解
                                    

                                        Objective-C 内存管理入门：从 alloc 到 dealloc 的生命周期详解
                                        
理解内存管理的基石在Objective-C的编程世界中，内存管理是开发者必须掌握的核心技能之一。它直接关系到应用的性能、稳定性与资源利用效率。与一些采用自动垃圾回收机制的语言不同，Objective-C在很长一段时间里，依赖一套基于引用计数的、需要开发者部分介入的管理规则。这套规则的核心思想是明确的

                                        

                                            

                                                2026-08-07
                                                0
                                                                                                SunnyJourney
                                                                                            

                                                                                    

                                    

                                

                                                                

                                    如何正确使用 dealloc 以避免 iOS 应用中的内存泄漏
                                    

                                        如何正确使用 dealloc 以避免 iOS 应用中的内存泄漏
                                        
理解 dealloc 的角色与时机在 iOS 应用开发中，内存管理是保障应用性能与稳定性的基石。dealloc 方法是 Objective-C 中对象生命周期结束时的关键回调，它标志着对象即将被系统回收内存。正确理解其触发时机至关重要：当一个对象的引用计数降为零时，运行时系统会自动调用该对象的 de

                                        

                                            

                                                2026-08-07
                                                0
                                                                                                WarmHope
                                                                                            

                                                                                    

                                    

                                

                                                                

                                    深入理解 Objective-C 中的 dealloc 方法：内存管理核心机制
                                    

                                        深入理解 Objective-C 中的 dealloc 方法：内存管理核心机制
                                        
内存管理的基石在Objective-C的世界里，内存管理是开发者必须掌握的核心技能之一。作为一门在手动引用计数（MRC）时代诞生的语言，Objective-C要求程序员对对象的生命周期有清晰的认识。dealloc方法正是这一生命周期中至关重要的终点站。它是一个实例方法，当对象的引用计数降为零时，系统

                                        

                                            

                                                2026-08-07
                                                0
                                                                                                归人云淡风轻
                                                                                            

                                                                                    

                                    

                                

                                                                

                                    理解 native2ascii：Java 国际化开发中的字符编码工具
                                    

                                        理解 native2ascii：Java 国际化开发中的字符编码工具
                                        
native2ascii 工具的基本定位在Ja va应用程序的国际化与本地化开发过程中，处理非拉丁字符集是一个常见且关键的环节。Ja va内部使用Unicode字符集来统一表示全球各种语言的文字，但其属性文件（.properties）在历史上要求使用ASCII编码，或者更准确地说，要求非ASCII字

                                        

                                            

                                                2026-08-07
                                                0
                                                                                                小确幸
                                                                                            

                                                                                    

                                    

                                

                                                                

                                    如何使用 native2ascii 转换中文字符为 Unicode 转义序列
                                    

                                        如何使用 native2ascii 转换中文字符为 Unicode 转义序列
                                        
理解 native2ascii 工具的基本用途在软件开发，特别是涉及国际化处理的场景中，开发者常常需要处理不同编码的文本资源。native2ascii 是 Ja va 开发工具包（JDK）中提供的一个命令行实用程序，其主要功能是将包含本地字符编码（非ASCII字符）的文件，转换为包含 Unicode

                                        

                                            

                                                2026-08-07
                                                0
                                                                                                慢热型
                                                                                            

                                                                                    

                                    

                                

                                                                

                                    Java native2ascii 命令详解：解决属性文件乱码问题
                                    

                                        Java native2ascii 命令详解：解决属性文件乱码问题
                                        
native2ascii 命令的由来与作用在Ja va开发中，处理国际化资源文件是一个常见需求。资源文件通常以.properties格式存储，用于支持多语言界面。然而，Ja va属性文件默认采用ISO-8859-1字符集编码，这导致了一个直接的问题：当文件中包含非拉丁字符（如中文、日文、韩文等）时，

                                        

                                            

                                                2026-08-07
                                                0
                                                                                                SoftHope
                                                                                            

                                                                                    

                                    

                                

                                                            

                            查看更多
                        

                    
                    

                        

                            

                                热门文章
                                更多
                            

                            

                                                                Yandex中文入口及登录使用全攻略
                                                                B站免费入口永久有效网址推荐
                                                                51漫画高清入口及最新章节更新
                                                                58动漫网入口及永久访问方法
                                                                B站免费入口网站高效连接方法
                                                                蓝海书屋免费小说全本阅读推荐入口
                                                                高德地图开启海拔显示方法
                                                                海棠文学入口地址 海棠小说追书绿色安全平台稳定入口
                                                                QQ网页版登录入口大全 QQ网页版官方登录指南
                                                                我的世界网页版即点即玩入口推荐
                                
                            

                        

                        

                            

                                精品专题
                                更多
                            

                            

                                                                

                                    装机必备
                                    

                                        装机必备
                                        
正软商城装机必备专区，精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件，帮助用户快速完成新电脑软件配置。

                                    

                                

                                                                

                                    Windows
                                    

                                        Windows
                                        
正软商城Windows软件专区，汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件，提供软件介绍、系统要求、正版授权及购买下载服务。

                                    

                                

                                                                

                                    macOS软件
                                    

                                        macOS软件
                                        
正软商城macOS软件专区，精选适用于Mac电脑的办公、设计、影音、效率、开发和系统工具，提供软件功能介绍、macOS兼容版本、正版授权及购买下载服务。

                                    

                                

                                                            

                        

                        

                            

                                Mac软件
                                更多
                            

                            

                                                                

                                    灵活计算器
                                    

                                        灵活计算器
                                        

                                                                                        macOS/iOS/Android

                                                                                    

                                        
灵活计算器是一款笔记式算数应用，支持实时计算、动态关联和云端同步功能。记录、整理和输出之间的过渡会更自然，适合长期写作、做笔记或持续沉淀个人内容。

                                    

                                

                                                                

                                    赤友清理大师
                                    

                                        赤友清理大师
                                        

                                                                                        macOS

                                                                                    

                                        
赤友清理大师是一款为 Mac 设计的智能清理优化工具，可精准扫描垃圾、大文件、重复文件等，释放磁盘空间。做扫描整理、文字提取和表格转换时，它能把识别后的处理步骤接得更顺，资料录入这类场景会省下不少时间。

                                    

                                

                                                                

                                    极度公式
                                    

                                        极度公式
                                        

                                                                                        Windows/macOS/Linux

                                                                                    

                                        
极度公式是一款跨平台专业LaTeX公式识别编辑软件，支持OCR公式识别和多平台编辑。和使用说明，避免使用，享受完整功能与稳定支持。做扫描整理、文字提取和表格转换时，它能把识别后的处理步骤接得更顺，资料录入这类场景会省下不少时间。

                                    

                                

                                
                            

                        

                        

                            

                                WINDOWS
                                更多
                            

                            

                                                                

                                    Windows 10
                                    

                                        Windows 10
                                        

                                                                                        Windows

                                                                                    

                                        
Windows 10 是一款微软推出的经典操作系统，拥有硬件兼容性与多任务处理能力。它更偏向把系统状态查看和常用调节动作放在一起，适合需要持续观察和微调设备状态的场景。

                                    

                                

                                                                

                                    极度公式
                                    

                                        极度公式
                                        

                                                                                        Windows/macOS/Linux

                                                                                    

                                        
极度公式是一款跨平台专业LaTeX公式识别编辑软件，支持OCR公式识别和多平台编辑。和使用说明，避免使用，享受完整功能与稳定支持。做扫描整理、文字提取和表格转换时，它能把识别后的处理步骤接得更顺，资料录入这类场景会省下不少时间。

                                    

                                

                                                                

                                    密码键盘
                                    

                                        密码键盘
                                        

                                                                                        Windows/macOS/iOS/Android

                                                                                    

                                        
密码键盘是一款兼具安全性与便捷性的高效密码管理器。日常使用里的持续防护和信息管理会更突出，适合把安全控制放进长期使用流程中的场景。

                                    

                                

                                                            

                        


                                            

                
            
        
                

        

        
网站备案号：苏ICP备2026018738号-1 联系邮箱：bd@zhengruan.com 网站地图

        
Copyright ©2018-2026