SpringBoot集成redis集群 实现redis的消息队列消费者-生产者模式,订阅者发布者模式

SpringBoot项目:RedisTemplate实现轻量级消息队列 一、本文涉及知识点excel文件读写--阿里easyexcel sdk文件上传、下载--腾讯云对象存储远程服务调用--restTemplate生产者、消费者--redisTemplate leftPush和rightPop操作异步处理数据--Executors线程池读取网络文件流--HttpClient自定义注解实现用户身份认证--JWT token认证, 拦截器拦截标注有@LoginRequired注解的请求入口当然, Java实现咯 涉及的知识点比较多, 每一个知识点都可以作为专题进行学习分析, 本文将 阅读详情

       一般来说,消息队列有两种场景,一种是发布者订阅者模式,一种是生产者消费者模式。利用redis这两种场景的消息队列都能够实现。

定义:
  • 生产者消费者模式 :生产者生产消息放到队列里,多个消费者同时监听队列,谁先抢到消息谁就会从队列中取走消息;即对于每个消息只能被最多一个消费者拥有。
  • 发布者订阅者模式:发布者生产消息放到队列里,多个监听队列的消费者都会收到同一份消息;即正常情况下每个消费者收到的消息应该都是一样的。

Redis不仅可作为缓存服务器,还可用作消息队列。它的列表类型天生支持用作消息队列。如下图所示:
在这里插入图片描述
       由于Redis的列表是使用双向链表实现的,保存了头尾节点,所以在列表头尾两边插取元素都是非常快的。

在Redis中,List类型是按照插入顺序排序的字符串链表。和数据结构中的普通链表一样,我们可以在其头部(left)和尾部(right)添加新的元素。在插入时,如果该键并不存在,Redis将为该键创建一个新的链表。与此相反,如果链表中所有的元素均被移除,那么该键也将会被从数据库中删除。List中可以包含的最大元素数量是4294967295。
从元素插入和删除的效率视角来看,如果我们是在链表的两头插入或删除元素,这将会是非常高效的操作,即使链表中已经存储了百万条记录,该操作也可以在常量时间内完成。然而需要说明的是,如果元素插入或删除操作是作用于链表中间,那将会是非常低效的。相信对于有良好数据结构基础的开发者而言,这一点并不难理解。

Redis List的主要操作为**lpush/lpop/rpush/rpop**四种,分别代表从头部和尾部的**push/pop**,除此之外List还提供了两种pop操作的阻塞版本**blpop/brpop**,用于阻塞获取一个对象。

Redis通常都被用做一个处理各种后台工作或消息任务的消息服务器。 一个简单的队列模式就是:生产者把消息放入一个列表中,等待消息的消费者用 RPOP 命令(用轮询方式), 或者用 BRPOP 命令(如果客户端使用阻塞操作会更好)来得到这个消息。

以下列举SpringBoot集成redis的JedisCluster和RedisTemplate

引入依赖到pom.xml

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>jcl-over-slf4j</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

application.yml增加redis集群配置

spring:
  redis:
    password:
    clusters: 10.10.1.238:7000,10.10.1.238:7001,10.10.1.238:7002,10.10.1.238:7003,10.10.1.238:7004,10.10.1.238:7005

RedisConfig配置

package com.example.myframe.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

import java.lang.reflect.Field;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {
	/**redis密码**/
	@Value("${spring.redis.password}")
	public String password;
	
	@Value("${spring.redis.clusters}")
	public String cluster;
	
    
    @Bean
    public KeyGenerator keyGenerator() {
        return (target, method, params) -> {
			StringBuilder sb = new StringBuilder();
			sb.append(target.getClass().getName());
			sb.append(method.getName());
			for (Object obj : params) {
				sb.append(obj.toString());
			}
			return sb.toString();
		};
    }

	public  Object getFieldValueByObject (Object object , String targetFieldName) throws Exception {
		// 获取该对象的Class
		Class objClass = object.getClass();
		// 获取所有的属性数组
		Field[] fields = objClass.getDeclaredFields();
		for (Field field:fields) {
			// 属性名称
			field.setAccessible(true);
			String currentFieldName = field.getName();
			if(currentFieldName.equals(targetFieldName)){
				return field.get(object); // 通过反射拿到该属性在此对象中的值(也可能是个对象)
			}
		}
		return null;
	}

	/**
	 * 通过反射获取JedisCluster
	 * @param factory
	 * @return
	 */
	@Bean
	public JedisCluster redisCluster(RedisConnectionFactory factory){
		Object object =null;
		try {
			object= getFieldValueByObject(factory,"cluster");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return (JedisCluster)object;

	}

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
    	StringRedisTemplate template = new StringRedisTemplate(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);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
    
    @Bean(name="factory")
    public RedisConnectionFactory factory(RedisClusterConfiguration clusterConfig){
        JedisConnectionFactory redisConnectionFactory=new JedisConnectionFactory(clusterConfig);
        String redisPassword = password;
    	redisConnectionFactory.setPassword(redisPassword);
        redisConnectionFactory.setPoolConfig(createJedisPoolConfig());
        redisConnectionFactory.setTimeout(30000);
        redisConnectionFactory.setUsePool(true);  
        return redisConnectionFactory;  
    }
    
    @Bean(name="clusterConfig")
    public RedisClusterConfiguration clusterConfig(){
    	RedisClusterConfiguration config = new RedisClusterConfiguration();
    	String[] nodes = cluster.split(",");
    	for(String node : nodes){
    		String[] host =  node.split(":");
    		RedisNode redis = new RedisNode(host[0], Integer.parseInt(host[1]));
    		config.addClusterNode(redis);
    	}
    	
    	return config;
    }


    public JedisPoolConfig createJedisPoolConfig(){
   	 JedisPoolConfig config = new JedisPoolConfig();
   	//连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
   	 config.setBlockWhenExhausted(false);
   	  
   	 //设置的逐出策略类名, 默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数)
   	 config.setEvictionPolicyClassName("org.apache.commons.pool2.impl.DefaultEvictionPolicy");
   	  
   	 //是否启用pool的jmx管理功能, 默认true
   	 config.setJmxEnabled(true);
   	  
   	 //MBean ObjectName = new ObjectName("org.apache.commons.pool2:type=GenericObjectPool,name=" + "pool" + i); 默 认为"pool", JMX不熟,具体不知道是干啥的...默认就好.
   	 config.setJmxNamePrefix("pool");
   	  
   	 //是否启用后进先出, 默认true
   	 config.setLifo(true);
   	  
   	 //最大空闲连接数, 默认8个
   	 config.setMaxIdle(2000);
   	  
   	 //最大连接数, 默认8个
   	 config.setMaxTotal(5000);
   	 
   	 //获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
   	 config.setMaxWaitMillis(10000);
   	  
   	 //逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
   	 config.setMinEvictableIdleTimeMillis(1800000);
   	  
   	 //最小空闲连接数, 默认0
   	 config.setMinIdle(0);
   	  
   	 //每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
   	 config.setNumTestsPerEvictionRun(3);
   	  
   	 //对象空闲多久后逐出, 当空闲时间>该值 且 空闲连接>最大空闲数 时直接逐出,不再根据MinEvictableIdleTimeMillis判断  (默认逐出策略)   
   	 config.setSoftMinEvictableIdleTimeMillis(1800000);
   	  
   	 //在获取连接的时候检查有效性, 默认false
   	 config.setTestOnBorrow(false);
   	  
   	 //在空闲时检查有效性, 默认false
   	 config.setTestWhileIdle(false);
   	  
   	 //逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
   	 config.setTimeBetweenEvictionRunsMillis(-1);
   	 
   	 return config;
   }
}

RedisService.java辅助类

package com.example.myframe.redis.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Service("redisService")
public class RedisService {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 写入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 写入缓存设置时效时间
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 批量删除对应的value
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0){
        	redisTemplate.delete(keys);
        }
            
    }
    /**
     * 删除对应的value
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
    /**
     * 判断缓存中是否有对应的value
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
    /**
     * 读取缓存
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }
    /**
     * 哈希 添加
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value){
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key,hashKey,value);
    }

    /**
     * 哈希 获取哈希的key集合
     * @param key
     * @return
     */
    public Set<Object> hmKeys(String key){
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.keys(key);        
    }

    /**
     * 哈希 删除哈希的key
     * @param key
     * @param hashKey
     */
    public void hmDelete(String key,String hashKey){
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.delete(key, hashKey);       
    }    
    
    /**
     * 哈希获取数据
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey){
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key,hashKey);
    }
    
    /**
     * 获取所有key值
     * @param key
     * @return
     */
    public Set<Object>  hmKeySet(String key){
    	HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
    	return hash.keys(key);	
    }
    
    /**
     * 获取所有key值
     * @param key
     * @return
     */
    public void  hmRemove(String key, Object hashKey){
    	HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
    	hash.delete(key, hashKey); 	
    }
    
    
    

    /**
     * 列表添加
     * @param k
     * @param v
     */
    public void lPush(String k,Object v){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k,v);
    }

    /**
     * 列表获取
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k,l,l1);
    }

    /**
     * 集合添加
     * @param key
     * @param value
     */
    public void add(String key,Object value){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key,value);
    }

    /**
     * 集合获取
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 集合长度
     * @param key
     * @return
     */
    public Long setSize(String key){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.size(key);
    }


    /**
     * 集合获取
     * @param key
     * @param count
     * @return
     */
    public Set<Object> setMembers(String key, int count){
    	 SetOperations<String, Object> set = redisTemplate.opsForSet();
    	 return set.distinctRandomMembers(key, count);
    }
    
    /**
     * 删除集合数据
     * @param key
     * @param value
     */
    public void remove(String key, Object value){
    	 SetOperations<String, Object> set = redisTemplate.opsForSet();
    	 set.remove(key, value);
    }

    /**
     * 有序集合添加
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key,Object value,double scoure){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key,value,scoure);
    }

    /**
     * 有序集合获取
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key,double scoure,double scoure1){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
    
    /**
     * 消息队列实现
     * @param channel
     * @param message
     */
    public void convertAndSend(String channel, Object message){
    	redisTemplate.convertAndSend(channel, message);
    }
    
    /**
     * 数列添加
     * @param key
     * @param value
     */
    public void addList(String key,Object value){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(key, value);
    }

    /**
     * 数列获取
     * @param key
     * @return
     */
    public List<Object> getList(String key){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(key, 0, list.size(key));
    }
    
    /**
     * 左弹出数列
     * @param key
     * @return
     */
    public Object popList(String key) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.leftPop(key);
    }

    public Long increment(String k, Long l) {
        return redisTemplate.opsForValue().increment(k, l);
    }
}

TestRedisController.java

package com.example.myframe.controller;

import com.example.myframe.redis.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(value = "/redis")
public class TestRedisController {
	@Autowired
	RedisUtil redisUtil;

	/**
	 * 生产者 通过此方法来往redis的list的尾部插入数据
	 */
	@RequestMapping("/shengchangzhe")
	public void shengChangZhe() {
		redisUtil.dealShengChangZhe();
	}

	/**
	 * 消费者 ,通过此方法往redis的list的头部获取数据,直到list没有数据 阻塞,等到一有数据又继续获取
	 */
	@RequestMapping("/xiaoFeiZhe")
	public void xiaoFeiZhe() {
		redisUtil.dealXiaoFeiZhe();
	}

	/**
	 * 发布者,发布信息,监听器一旦接收到监听,就进行操作
	 */
	@RequestMapping("/faBuDingYue")
	public void faBuDingYue() {
		redisUtil.dealFaBuDingYue();
	}
}
package com.example.myframe.redis;

import com.example.myframe.redis.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisCluster;

import java.util.List;

@Component
public class RedisUtil {
	@Autowired
	JedisCluster jedisCluster;

	@Autowired
	private RedisService redisService;

	/**
	 * 生产者
	 */
	public void dealShengChangZhe() {
		for (int i = 0; i < 10; i++) {
			jedisCluster.rpush("ceshi", "value1_" + i);
		}
	}

	/**
	 * 消费者
	 */
	public void dealXiaoFeiZhe() {
		while (true) {
			//阻塞式brpop,List中无数据时阻塞,参数0表示一直阻塞下去,直到List出现数据
			List<String> listingList = jedisCluster.blpop(0, "ceshi");
			System.out.println("线程取数据:{}" + listingList.get(1));
		}
	}

	/**
	 * 发布订阅模式
	 */
	public void dealFaBuDingYue() {
		redisService.convertAndSend("dealFaBuDingYue", "我是来发布信息的");
	}
}

redis消息队列监听信息

package com.example.myframe.redis.msg;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;

@Configuration
public class RedisMsgListener {
	@Autowired
	Receiver receiver;

	/**
	 * redis消息队列监听信息
	 * 
	 * @param connectionFactory
	 * @param listenerAdapter
	 * @return
	 */
	@Bean
	RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
											MessageListenerAdapter listenerAdapter) {
		RedisMessageListenerContainer container = new RedisMessageListenerContainer();
		container.setConnectionFactory(connectionFactory);
		container.addMessageListener(listenerAdapter, new PatternTopic("dealFaBuDingYue"));
		return container;
	}

	/**
	 * 监听方法
	 * 
	 * @return
	 */
	@Bean(name = "listenerAdapter")
	MessageListenerAdapter listenerAdapter() {
		// 回调数据处理方法
		return new MessageListenerAdapter(receiver, "dealJt");
	}
}
package com.example.myframe.redis.msg;

import com.example.myframe.redis.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

@Service("receiver")
public class Receiver{

	@Autowired
	private RedisService redisService;
	@Autowired
	private StringRedisTemplate redisTemplate;

    /**
     * 清除外部广告位本地缓存
     * @param message
     */
    public  void dealJt(String message){
        System.out.println("我是用来监听信息的");
        System.out.println(message);
    }

	/**
	 * 清除外部广告位本地缓存
	 * @param message
	 */
	public  void dealJt1(String message){
		System.out.println("我是用来监听信息的1");
		System.out.println(message);
	}
}
消息中间件-ActiveMQ-消息队列与发布订阅 1.消息中间件产生的背景 2.消息中间件概述 4.点对点与发布订阅 5.消息中间件应用场景 6.市面上消息中间件 产品 7.window下 ActiveMQ安装 8.JMS可靠消息机制 9.SpringBoot整合ActiveMQ 消息中间件产生的背景 1.在网络通讯中,Http请求默认采用同步请求方式,基于请求与响应模式 2.在客户端与服务器进行通讯时,客户端调用服务端接口后,必须等待服务端完成处理后返回结果给客户端才能继续执行,这种情况属于同步调用方式。 3.如果服务器端发生网络延 阅读详情

相关推荐

消息队列——发布订阅模式

在 Redis 中提供了专门的类型:Publisher(发布者)和 Subscriber(订阅者)来实现消息队列。 在文章开始之前,先来介绍消息队列中有几个基础概念,以便大家更好的理解本文的内容。 首先,发布消息的叫做发布方或发布者,也就是消息的生产者,而接收消息的叫做消息的订阅方或订阅者,也就是消费者,用来处理生产者发布的消息。 除了发布和和订阅者,在消息队列中还有一个重要的概念:channe...

磊哥聊Java 2023

SpringBoot 使用 redis实现 生产者/消费者模式 消息队列

概述 今天主要是来说一下如何在Springboot中使用redis实现一个 生产者/消费者模式的队列, 首先解释下几个问题。 1、什么是生产者/消费者模式? 消息队列一般是有两种场景 1、种是发布者订阅者模式 2、种是生产者消费者模式 生产者消费者模式 :生产者生产消息放到队列里,多个消费者同时监听队列,谁先抢到消息谁就会从队列中取走消息;即对于每个消息只能被最多一个消费者拥有。 通俗一点说就是比...

m0_37859502的博客 7011

redis 老版本生产者消费者模式

redis 老版本生产者消费者模式

【redis】生产者/消费者模式与订阅/发布模式

个人学习笔记分享,当前能力有限,请勿贬低,菜鸟互学,大佬绕道 如有勘误,欢迎指出和讨论,本文后期也会进行修正和补充 前言 设想一个场景: 你和你女朋友(假设有)打算出门,你问你女朋友打扮好了没,她说还没。 于是过了五分钟,你再去问,她说还没。 再过五分钟,你又问,她说再等会儿 再过五分钟,你又问,她说烦不烦一直问,多等会能咋了??。。。。 2000 years later,她准备好了,你已经准备打开网抑云了 其实解决方案很简单,你跟她说准备好了喊你,而你做好随时被喊的准备即可 设想如下模型: 消费者A.

路远不知归 2602

门控时钟(clock gating)的DFT设计

在数字IC芯片中,时钟树的功耗占比可能高达30%,因此一般会采取门控时钟的方式来降低该部分的功耗。所谓门控时钟,就是在芯片实际工作过程中,有些信号或者功能并不需要一直开启,那么就可以在它们不用的时候将其时钟信号关闭。这样一来信号不再翻转,从而能够有效减少动态功耗。 目前门控时钟都采用集成门控时钟单元(ICG,integrated clock gating cell),其结构如下。由一个latch和一个与门(也有的是或门)组成,可以过滤掉EN信号中的毛刺。一般的工艺库中都会有专门的ICG以供调用。 插入IC

weixin_44746697的博客 3878

spdk + fio测试nvme 设备的性能

fio的测试对象可以是块设备、文件等,在spdk的使用过程中会unbind默认的nvme driver,所以在系统中是看不到nvme块设备的,在spdk中可以通过fio_plugin的方式,将spdk的用户态driver部分的io功能打包成一个ioengine提供给fio使用,可以综合spdk的高性能和fio提供的复杂场景。更多DPDK相关学习资料有需要的可以自行报名学习,免费订阅,永久学习,或点击这里加。这个jobfile是spdk中提供的例子。领取,关注我持续更新哦!2.7 jobfile的例子。

lingshengxiyou的博客 1092

redis集群springboot连接

谢谢参考:https://blog.youkuaiyun.com/CNZYYH/article/details/85696674 一般来说,消息队列有两种场景,一种是发布者订阅者模式,一种是生产者消费者模式。利用redis这两种场景的消息队列都能够实现。 定义: 生产者消费者模式:生产者生产消息放到队列里,多个消费者同时监听队列,谁先抢到消息谁就会从队列中取走消息;即对于每个消息只能被最多一个消费者拥有。 发布者订阅者模式:发布者生产消息放到队列里,多个监听队列的消费者都会收到同一份消息;即正常情况下每个..

wasd986523的博客 362

IPD(集成产品开发)管理之道

IPD,是集成产品开发(Integrated Product Development)的缩写,它是集成了众多管理模型和理论、众多企业最佳管理实践的一整套体系,可以帮助企业快速响应市场变化、缩短产品上市时间、减少资源浪费、提高生产力,最终取得商业成功。IPD的思想最早来源于美国PRTM公司出版的《产品及生命周期优化法》一书中,该书详细描述了IPD模式所包含的各个方面。但IPD在中国的普及,源于IBM和华为的推行使用。IPD作为一套先进的产品研发管理模式,其成功的基础是功能部门和各团队之间的密切配合。

钢镚·真的博客 2716

SpringBoot集成redis的JedisCluster和RedisTemplate 实现redis的消息队列消费者-生产者模式,订阅者发布者模式

一般来说,消息队列有两种场景,一种是发布者订阅者模式,一种是生产者消费者模式。利用redis这两种场景的消息队列都能够实现。 定义: 生产者消费者模式 :生产者生产消息放到队列里,多个消费者同时监听队列,谁先抢到消息谁就会从队列中取走消息;即对于每个消息只能被最多一个消费者拥有。 发布者订阅者模式:发布者生产消息放到队列里,多个监听队列的消费者都会收到同一份消息;即正常情况下每个消费者收到的消息...

CNZYYH的博客 1万+

uniapp监听扫码枪键盘事件|无输入框式监听

一般的扫码枪通过USB或蓝牙连接手机或电脑,充当的是一个外接设备。当扫码后,扫码枪会自动识别内容,然后向连接的电脑或手机发送键盘事件keydown或keyup。

tcy9099的专栏 9753

《SAP FICO系统配置从入门到精通共40篇》030、集成配置:FI与生产计划(PP)的自动科目确定

FI和PP的自动科目确定,本质上是把生产业务翻译成会计语言。翻译规则就藏在那些配置表里。配的时候多想一步:这个业务动作,在财务眼里是什么?是材料消耗?是产出入库?还是工费分摊?想清楚这个,再看配置界面,那些代码就不是天书了。最好的测试方式,是月底关账前,让生产部门跑一遍所有类型的生产订单。配置对不对,业务最知道。

985大学毕业,前某大厂员工,啥都会点的程序员! 576

【Springboot+Redis】Springboot+Redis实现消息队列(生产者/消费者、发布订阅模式)

  一般来说,消息队列有两种场景,一种是发布者订阅者模式,一种是生产者消费者模式。利用redis这两种场景的消息队列都能够实现。 定义:         生产者消费者模式:生产者生产消息放到队列里,多个消费者同时监听队列,谁先抢到消息谁就会从队列中取走消息;即...

HD243608836的博客 1152

什么是 SAP FICO 的 GL?

GL,即总账,是 SAP FI(Financial Accounting)模块中的一个重要组件。它的主要作用是收集、分类和汇总所有财务交易,以便企业可以生成财务报表,如资产负债表、利润表和现金流量表。科目结构:GL 账户(G/L Account)用于记录企业的财务交易,并按会计准则分类。实时更新:由于 SAP 是基于事务驱动的系统,每一笔业务发生后,都会实时反映到总账科目中。集成性。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 1690

【实战】SpringBoot整合Websocket、Redis实现Websocket集群负载均衡

因为有websocket的存在,使得前后的主动交互变得容易和低成本。其实在JAVA领域用SpringBoot框架集成Websoket还是很简单的,今天我们重点不是集成而是通过Redis的发布订阅实现Websocket集群通信,当然有条件的也可以用MQ代替。

勤于笔记,成于点滴。 4498

基于点云数据的统计滤波算法改进

随着三维视觉和点云处理技术的发展,点云数据在机器人、自动驾驶、增强现实等领域得到了广泛应用。而点云数据中常常包含着各种噪声和异常点,这些噪声和异常点会影响后续的数据处理和分析任务。因此,对点云数据进行滤波处理是必不可少的一步。在点云滤波算法中,统计滤波(Statistical Filtering)是一种常见且有效的方法。它通过对点云数据进行统计分析,将噪声和异常点剔除或修复,从而得到更为准确和可靠的点云数据。本文将介绍一种改进的统计滤波算法,并提供相应的源代码实现。

QfcaLinux的博客 292

智能手表 BOM 表与版本管理记录

试产与量产阶段 智能手表 BOM 表与版本管理记录

hoony123的博客 1053

Spring Boot 使用 Redis 实现消息队列

本文介绍了Spring Boot使用Redis实现消息队列的完整方案。首先通过咖啡厅留言板的比喻解释了Redis消息队列的基本概念,对比了Redis与专业消息中间件的特性差异。其次详细讲解了Redis实现消息队列的三种方式:基于List的简单队列、Pub/Sub发布订阅模式和Stream高级队列,并分析了各自适用场景。文章还提供了Spring Boot整合Redis消息队列的代码实现示例,包括生产者发送普通/延迟消息和消费者定时消费消息的功能实现。这种轻量级方案适合异步任务处理、流量削峰和系统解耦等常见业务

奔跑的坏蜗牛 1636

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

Redis底层实现原理之订阅发布机制

文章介绍了Pub/Sub发布订阅和Redis Stream生产消费者机制,以深入浅出的方式介绍其知识点和底层原理。

Armyyyyy丶的博客 1035

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Redis 作为消息队列的三种使用方式与 Spring Boot 实践

在 Spring 体系中,Redis 的集成方式非常成熟且丰富,无论是基于 List 的简易队列、基于 Pub/Sub 的实时广播消息,还是基于 Stream 的分布式消息队列,都可以通过 Spring Data Redis 顺畅地接入应用系统。其中 Redis Stream 是目前最值得推荐的方案,它具备消息持久化、消费者组、消息确认机制(ACK)、Pending 列表管理、顺序性保证等能力,能够提供接近 Kafka 那样的消息投递可靠性,同时又保持了 Redis 一贯的简单部署和轻量成本。

深耕后端、偏爱架构,用代码与设计构建可靠系统 1438

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

SpringBoot整合AMQP

SpringBoot整合AMQP 文章目录SpringBoot整合AMQP前言一、JMS、AMQP概念以及区别二、RabbitMQ简介三、互联网大厂为什么选择RabbitMQ四、RabbitMQ的一些核心概念五、RabbitMQ的部署安装 前言 消息队列(Message Queue)是一种进程间或者线程间的异步通信方式。使用消息队列,消息生产者会将消息保存在消息队列中,知道消息消费者来取走它。实现服务的解耦合,并提高系统的可靠性和扩展性。 目前常用的开源消息队列有很多,RabbitMQ、ActiveMQ、

lwd2307997664的博客 1534

Kafka入门学习(一)-- 基本概念及springboot集成

kafka入门学习 一、基本概念 Kafka是一个分布式的发布 - 订阅消息传递系统和一个强大的队列,具有很好的吞吐量,内置分区,复制和固有容错功能,因此非常适合大型消息处理应用程序。 二、安装与启动 1、kafka依赖于zookeeper,所以先安装启动zookeeper 上传zookeeper压缩包 并解压 修改/my/zookeeper/zookeeper-3.4.9/conf/zoo...

dicklong91的博客 590

【Redis】实战篇之黑马点评 10w字详解

比如数据库密码报错:java: 源值 8 已过时,将在未来发行版中删除原因:项目编译指定的 Java 源码版本为 8,但你当前使用的 JDK 版本较高(JDK11+、JDK17、JDK21)解决:我把1.8改为17报错:java: java.lang.ExceptionInInitializerErrorcom.sun.tools.javac.code.TypeTag :: UNKNOWN解决:修改lombok版本 修改springboot版本 修改MySQL驱动版本 报错:Loading class co

ashiho的博客 882

Redis在Web项目中的应用与实践

原文链接:Redis在Web项目中的应用与实践 Redis作为一个开源的(BSD)基于内存的高性能存储系统,已经被各大互联网公司广泛使用,并且有着诸多的应用场景。本篇文章将基于PHP来详细讲解Redis在Web项目中的主要应用与实践。 缓存 这里所介绍的缓存是指可以丢失或过期的数据。常用的命令有 set, hset, get, hget...

weixin_34029949的博客 94

RabbitMQ

RabbitMQ 1.初识MQ 1.1.同步和异步通讯 微服务间通讯有同步和异步两种方式: 同步通讯:就像打电话,需要实时响应。 异步通讯:就像发邮件,不需要马上回复。 两种方式各有优劣,打电话可以立即得到响应,但是你却不能跟多个人同时通话。发送邮件可以同时与多个人收发邮件,但是往往响应会有延迟。 1.1.1.同步通讯 我们之前学习的Feign调用就属于同步方式,虽然调用可以实时得到结果,但存在下面的问题: 总结: 同步调用的优点: 时效性较强,可以立即得到结果 同步调用的问题: 耦合度高 性能和

学过的东西,讲不出来等于没学。 396

java初级面试官常问的问题,2024Java面经

什么是ActiveMQ?ActiveMQ服务器宕机怎么办?丢消息怎么办?持久化消息非常慢怎么办?消息的不均匀消费怎么办?死信队列怎么办?ActiveMQ中的消息重发时间间隔和重发次数吗?

2401_83329402的博客 443

让人抓狂的Nginx性能调优,面试总结

前言 事务我们都知道是什么,而Spring事务就是在数据库之上利用AOP提供声明式事务和编程式事务帮助我们简化开发,解耦业务逻辑和系统逻辑。但是Spring事务原理是怎样?事务在方法间是如何传播的?为什么有时候事务会失效?接下来咱就一一解答~重点分析Spring事务源码,让我们彻底搞懂Spring事务的原理。 SpringCloud面试题 什么是 Spring Cloud? 使用 Spring Cloud 有什么优势? 服务注册和发现是什么意思?Spring Cloud 如何实现? Spring Clo

m0_57286518的博客 199
上一篇: mybatis多表关联查询及高级映射
下一篇: Druid与Dbutils集成实现查询结果集封装
zhg_vincent
博客等级 码龄12年 93粉丝 45原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值