SpringBoot中实现连接多个Redis分别读写数据

场景

在SpringBoot项目中需要连接两个Redis实例，并实现从A中获取数据并存取到B中。

另外A中redis的地址和密码不能外漏，则将A的地址和密码写在jar包中，B中redis参数可以在外置

配置文件application.yml中进行动态配置。

实现

1、新建SpringBoot项目并添加依赖


        
            redis.clients
            jedis
            3.3.0
        
 
        
            org.springframework.data
            spring-data-redis
            2.3.6.RELEASE
        
 
        
        
            com.alibaba
            fastjson
            1.2.75

2、完整的pom文件代码

 
<?xml version="1.0" encoding="UTF-8"?>

    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.3.7.RELEASE
         
    
    com.example
    demo
    0.0.1-SNAPSHOT
    demo
    Demo project for Spring Boot
    
        1.8
    
    
        
            org.springframework.boot
            spring-boot-starter-web
        
 
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
        
            redis.clients
            jedis
            3.3.0
        
 
        
            org.springframework.data
            spring-data-redis
            2.3.6.RELEASE
        
 
        
        
            com.alibaba
            fastjson
            1.2.75
        
    
 
    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

3、在配置文件application.properties中配置B的redis的参数

server.port=9090
spring.redis.user.host=另一个redis的地址
spring.redis.user.port=6379
spring.redis.user.password=123456

4、新建Redis的配置类

package com.example.demo.config;
 
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
 
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
 
    //order
    @Value("127.0.0.1")
    private String orderHost;
 
    @Value("6379")
    private String orderPort;
 
    @Value("123456")
    private String orderPassword;
 
 
    //user
    @Value("${spring.redis.user.host}")
    private String userHost;
 
    @Value("${spring.redis.user.port}")
    private String userPort;
 
    @Value("${spring.redis.user.password}")
    private String userPassword;
 
    private static final int MAX_IDLE = 200; //最大空闲连接数
    private static final int MAX_TOTAL = 1024; //最大连接数
    private static final long MAX_WAIT_MILLIS = 10000; //建立连接最长等待时间
 
 
    //配置工厂
    public RedisConnectionFactory connectionFactory(String host, int port, String password,int index) {
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName(host);
        redisStandaloneConfiguration.setPort(port);
        redisStandaloneConfiguration.setPassword(password);
        redisStandaloneConfiguration.setDatabase(index);
        return new JedisConnectionFactory(redisStandaloneConfiguration);
    }
 
    //连接池配置
    public JedisPoolConfig poolConfig(int maxIdle, int maxTotal, long maxWaitMillis, boolean testOnBorrow) {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMaxTotal(maxTotal);
        poolConfig.setMaxWaitMillis(maxWaitMillis);
        poolConfig.setTestOnBorrow(testOnBorrow);
        return poolConfig;
    }
 
    @Bean("redisTemplateOrder")
    public RedisTemplate redisTemplateOrder(RedisConnectionFactory connectionFactory) {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory(orderHost, Integer.parseInt(orderPort),orderPassword,0));
 
        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
 
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        serializer.setObjectMapper(mapper);
 
        template.setValueSerializer(serializer);
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
 
    @Bean("redisTemplateUser")
    public RedisTemplate redisTemplateUser(RedisConnectionFactory connectionFactory) {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory(userHost, Integer.parseInt(userPort),userPassword,0));
 
        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
 
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        serializer.setObjectMapper(mapper);
 
        template.setValueSerializer(serializer);
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
}

注意：

这里连接的是两个Redis，其中A的Redis命名为order,其参数直接在注解中固定赋值。

B的Redis命名为user,参数从配置文件中获取。

这其中又用到了FastJson进行序列化的工具类FastJson2JsonRedisSerializer

package com.example.demo.config;
 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.util.Assert;
 
import java.nio.charset.Charset;
 
public class FastJson2JsonRedisSerializer implements RedisSerializer
{
    @SuppressWarnings("unused")
    private ObjectMapper objectMapper = new ObjectMapper();
 
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
 
    private Class clazz;
 
    static
    {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
    }
 
    public FastJson2JsonRedisSerializer(Class 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);
    }
 
    public void setObjectMapper(ObjectMapper objectMapper)
    {
        Assert.notNull(objectMapper, "'objectMapper' must not be null");
        this.objectMapper = objectMapper;
    }
 
    protected JavaType getJavaType(Class<?> clazz)
    {
        return TypeFactory.defaultInstance().constructType(clazz);
    }
}

5、分别新建两个Redis进行读取操作的service类

RedisServiceOrder:

package com.example.demo;
 
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 javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
 
@Component
public class RedisServiceOrder
{
    @Resource(name = "redisTemplateOrder")
    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 Long timeout, final TimeUnit timeUnit)
    {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }
 
    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @returntrue=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout)
    {
        return expire(key, timeout, TimeUnit.SECONDS);
    }
 
    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @returntrue=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit)
    {
        return redisTemplate.expire(key, timeout, unit);
    }
 
    /**
     * 获得缓存的基本对象。
     *
     * @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 long deleteObject(final Collection collection)
    {
        return redisTemplate.delete(collection);
    }
 
    /**
     * 缓存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;
    }
 
    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public  List getCacheList(final String key)
    {
        return redisTemplate.opsForList().range(key, 0, -1);
    }
 
    /**
     * 缓存Set
     *
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public  long setCacheSet(final String key, final Set dataSet)
    {
        Long count = redisTemplate.opsForSet().add(key, dataSet);
        return count == null ? 0 : count;
    }
 
    /**
     * 获得缓存的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 hKeys)
    {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }
 
    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection keys(String pattern)
    {
        return redisTemplate.keys(pattern);
    }
 
    /**
     * 获得缓存的集合(模糊查询)
     *
     * @param keys
     * @return
     */
    public  List getCacheList(Set keys) {
        return redisTemplate.opsForValue().multiGet(keys);
    }
}
RedisServiceUser:
package com.example.demo;
 
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 javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
 
@Component
public class RedisServiceUser
{
    @Resource(name = "redisTemplateUser")
    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 Long timeout, final TimeUnit timeUnit)
    {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }
 
    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @returntrue=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout)
    {
        return expire(key, timeout, TimeUnit.SECONDS);
    }
 
    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @returntrue=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit)
    {
        return redisTemplate.expire(key, timeout, unit);
    }
 
    /**
     * 获得缓存的基本对象。
     *
     * @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 long deleteObject(final Collection collection)
    {
        return redisTemplate.delete(collection);
    }
 
    /**
     * 缓存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;
    }
 
    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public  List getCacheList(final String key)
    {
        return redisTemplate.opsForList().range(key, 0, -1);
    }
 
    /**
     * 缓存Set
     *
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public  long setCacheSet(final String key, final Set dataSet)
    {
        Long count = redisTemplate.opsForSet().add(key, dataSet);
        return count == null ? 0 : count;
    }
 
    /**
     * 获得缓存的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 hKeys)
    {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }
 
    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection keys(String pattern)
    {
        return redisTemplate.keys(pattern);
    }
 
    /**
     * 获得缓存的集合(模糊查询)
     *
     * @param keys
     * @return
     */
    public  List getCacheList(Set keys) {
        return redisTemplate.opsForValue().multiGet(keys);
    }
}SpringBoot中实现连接多个Redis分别读写数据
原文链接：https://blog.csdn.net/badao_liumang_qizhi/article/details/120704221






展开阅读全文



页面更新：2024-03-19



标签：数据   前缀   字符串   缓存   对象   参数   两个   地址   时间   列表





1
2
3
4
5







	

		

		
		

		

			

			
新能源车操控性心得

			

			

			因为工作原因，去年底给媳妇买了一台新能源车，纯电的比亚迪秦 PLUS EV，因为4S店没有秦EV，最开始试驾的是秦DMI 55KM，混动的，试驾效果非常棒，瞬间加速推背感非常强，尤其是红绿灯，一骑绝尘那都跟玩一样，一脚油门，不知不觉速度都上70
			

		

	

	

		

		
		

		

			

			
去年花3.2w买的全套python教程用不着了，现在送给有缘人，不要钱

			

			

			 当年2w买的全套python教程用不着了，现在送给有缘人，不要钱，一个月教你从入门到精通1、本套视频共487集,本套视频共分4季第—季:Python基础。第二季:Python深入和扩展第三季:网络编程、多线程、扩展库第四季:算法、Pytho
			

		

	

	

		

		
		

		

			

			
元宇宙，虚拟货币风口

			

			

			#风船计划2.0#何为元宇宙?元宇宙本质上是对现实世界的虚拟化、数字化过程，需要对内容生产、经济系统、用户体验以及实体世界内容等进行大量改造。但元宇宙的发展是循序渐进的，是在共享的基础设施、标准及协议的支撑下，由
			

		

	

	

		

		
		

		

			

			
如果我再买新能源汽车，我不会买比亚迪汽车

			

			

			#如果你买新能源汽车,你会选择比亚迪吗?# 首先我是一位比亚迪第一代的元ev车主，如今已经行使了将近8w公里，车子18年车跑了8万这里面的用车经历是没有什么波折的，因为家里有充电位，又是一个河南的5线小城市，平时以家庭代步
			

		

	

	

		

		
		

		

			

			
趣闻｜世界上最可爱的电动汽车开始生产，大家觉得怎样？

			

			

			 目前在欧洲市场已经开始交付。 微型汽车确实是一个概念，它常常会让美国人失去购买汽车的热情。这是因为国家的地域使得在许多地方，需要拥有一辆更大、更快的汽车才是必须的。对于电动汽车来说，情况更是如此，充电基础设施
			

		

	

	

		

		
		

		

			

			
村镇银行都踩雷了，我在互联网银行上存了一万块钱，瑟瑟发抖中

			

			

			最近几天，热门的事件莫过于唐山打人事件，还有河南村镇银行的红码事件。本来对于我这个具体人来讲，我是不蹭热门的，我知道热门的事件，本来我就把握不好，所以咱们也就不针对热门事件进行评论，毕竟有很多更专业人士在我的前面，咱
			

		

	

	

		

		
		

		

			

			
特斯拉陶琳：中国有良好的营商环境，高水平中国制造输送全世界

			

			

			6月19日消息，在“第三届跨国公司领导人青岛峰会”开幕式上，公司全球副总裁陶琳在线致辞。陶琳表示，中国用户对电动汽车的接受程度在逐步增加，中国市场在全球新能源汽车产业中发挥着不可或缺的引领作用。陶琳称，特斯拉在中
			

		

	

	

		

		
		

		

			

			
如果10年后，房价真如葱，哪些行业最赚钱？马云等大佬已经布局

			

			

			5月份的房地产“滞销”仍旧。日前，国家统计局公布了全国商品房销售及70个大中城市的住宅指数变化情况。5月份，全国新建住宅平均销售价格9878元/平方米，比前两个月的9671元/平方米、9674后有所上涨，但仍在下降通道中。与20
			

		

	

	

		

		
		

		

			

			
0619周评：两大利空来袭 下周A股或将迎来深调

			

			

			周末重要消息解读一、可转债交易迎来新规6月17日，沪深两大交易所针对可转债发布新股，主要包括两点：1、上市次日起设置20%涨跌幅限制。2、对新参与投资者增设“2年交易经验和10万元资产”的要求。之前的可转债因为T+0和无
			

		

	

	

		

		
		

		

			

			
618值得选择的激光电视推荐，峰米C2开启激光观影时代

			

			

			最近一直想入手一台好用的激光电视，看了网上很多的测评和激光电视推荐的文章，感觉选择激光电视一定要只买对的不买贵的！对比了很多参数之后，选择了最近很火的618激光电视推荐——峰米C2，到货之后我就迫不及待的在家里的白
			

		

	

	

		

		
		

		

			

			
Keychron开启刷新模式，新发布的Q5有什么 不一样

			

			

			前言，Keychron，Q1 Q2齐上阵，最新的Q5有什么不一样大家好，我是林老师，我们又见面了。 如果您是MAC用户，相信或多或少的都知道在MAC圈内比较知名的键盘外设厂家Keychron，话说Keychron是货真价实国内公司，而其麾下的诸多键盘型号
			

		

	

	

		

		
		

		

			

			
三星百万元电视开售：110英寸大屏幕，首批已卖光

			

			

			开始前先问大家一个问题，如今买电视的话，你愿意花上多少钱？估计3K-1W元会是绝大多数用户的选择吧，不过在2020年12月份，三星发布了一款110英寸MicroLED电视，并于2021年第一季度在全球推出，直至今年5月份，这款电视正式在国内京
			

		

	

	

		

		
		

		

			

			
u盘安装原版win7系统

			

			

			u盘安装原版win7系统，今天先教大家制作u盘启动及下载系统教程　　首先打开浏览器，然后百度搜索老白菜回车，选择第一个打开　　双击本地下载，此时准备16g以上的空u盘，然后把u盘插到电脑u口上　　下载完老白菜装机版，打开后运
			

		

	

	

		

		
		

		

			

			
618洗烘套装好物推荐，彻底解放你的双手

			

			

			　有人可能好奇，洗烘一体机和洗烘套装怎么选、有啥差别。洗烘一体机好在便宜，而洗烘套装的洗衣机和烘干机各自做专业的工作，洗和烘的效果都更好，洗、烘过程双重除菌除螨衣物更卫生；而且烘干的容量更大，床单三件套也不是问题
			

		

	

	

		

		
		

		

			

			
刚刚发布的Vidda 4K全色激光投影C1为何好评如潮

			

			

			俗话说：金杯银杯不如老百姓的口碑。一个产品好不好，不是厂家说了算的，而是要看用户的真实反馈和实际购买意愿。前段时间Vidda发布了首款4K全色激光投影C1，发布会上Vidda官方介绍了这款投影仪的诸多亮点，那实际体验如何？用户
			

		

	


上滑加载更多 ↓






	

	
推荐阅读：


	

		

			

			
《加油！妈妈》，我最难过的是生了两个女儿

			

		

	


	

		

			

			
数据解读，凯尔特人休赛期如何补强？

			

		

	


	

		

			

			
科学健身从数据开始，佳明 Forerunner 955手表体验 - 钛

			

		

	


	

		

			

			
36岁前亚马逊变性黑客，窃取超1亿人数据被判20年监禁

			

		

	


	

		

			

			
程序开发数据库版本控制必备 - Flyway

			

		

	


	

		

			

			
争议！勇士队夺冠后，美媒第一时间评选了新的历史前十巨星

			

		

	


	

		

			

			
美媒晒哈登悲催数据！打了149场季后赛却零冠 现役属他最

			

		

	


	

		

			

			
世联赛第三周赛程时间表：中国女排将战巴西队

			

		

	


	

		

			

			
“两个打造”看乌达⑧

			

		

	


	

		

			

			
败人品！牛莉直播卖弹力裤，丧着脸不说一句话，靠照镜子打发

			

		

	


	

	
	

	
友情链接：

	

		
	

	


	

	
更多：

	

		
本站资料均由网友自行发布提供，仅用于学习交流。如有版权问题，请与我联系，QQ：4156828  

		
© CopyRight 2008-2024 All Rights Reserved. Powered By bs178.com  闽ICP备11008920号-3
闽公网安备35020302034844号

	

	

	




Top