RocketMQ入门开发

链接：https://pan.baidu.com/s/1gD-pV0boCKrOj9VKy8Zgcg?pwd=sh7s

添加环境变量ROCKETMQ_HOME和NAMESRV_ADDR

启动NameServer

D:\program\RocketMQ\rocketmq\bin>D:\program\RocketMQ\rocketmq\bin\mqnamesrv.cmd

启动Broker

D:\program\RocketMQ\rocketmq\bin>mqbroker.cmd -n localhost:9876 autoCreateTopicEnable=true -c D:\program\RocketMQ\rocketmq\conf\broker.conf

测试发送消息和接收消息

D:\program\RocketMQ\rocketmq\bin>tools.cmd org.apache.rocketmq.example.quickstart.Producer

D:\program\RocketMQ\rocketmq\bin>tools.cmd org.apache.rocketmq.example.quickstart.Consumer

RocketMQ控制台启动

D:\program\RocketMQ\rocketmq-console>mvn clean package -Dmaven.test.skip=true

D:\program\RocketMQ\rocketmq-console\target>java -jar rocketmq-console-ng-2.0.0.jar

RocketMQ控制台访问
http://localhost:8888 端口8888为application.properties设置
项目结构

父项目pom依赖



    4.0.0

    pom
    
        rocketmq-provider
        rocketmq-consumer
    
    com.java
    RocketMQ
    1.0-SNAPSHOT

    
        UTF-8
        1.8
        1.8
        2.3.2.RELEASE
        2.2.0
    

    
        
            
                org.springframework.boot
                spring-boot-dependencies
                ${springboot.version}
                pom
                import
            
            
                org.apache.rocketmq
                rocketmq-spring-boot-starter
                ${rocketmq.version}
            
        
    
    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

子项目rocketmq-provider的pom依赖



    
        RocketMQ
        com.java
        1.0-SNAPSHOT
    
    4.0.0

    rocketmq-provider

    
        
			org.springframework.boot
			spring-boot-starter-web
		
        
            org.apache.rocketmq
            rocketmq-spring-boot-starter
        
        
        
            org.springframework.boot
            spring-boot-starter-web-services
        
        
        
            org.apache.cxf
            cxf-spring-boot-starter-jaxws
            3.2.14
        
		
		
			com.sun.xml.ws
			jaxws-ri
			2.3.1

子项目rocketmq-provider的application.yml

server:
  port: 8081
  servlet:
    context-path: /

rocketmq:
  name-server: 127.0.0.1:9876
#  name-server: 192.168.1.44:9876;192.168.1.109:9876;192.168.1.124:9876;192.168.1.247:9876;
  producer:
    group: producer-demo
    send-message-timeout: 60000

子项目rocketmq-provider的启动类

package com.java;

import com.java.rocketmq.*;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class RocketmqProducerApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(RocketmqProducerApplication.class, args);
        // 发送简单消息
//        ProducerService_1 producerService_1 = (ProducerService_1) run.getBean("producerService_1");
//        producerService_1.sendMessage();
		// 发送同步消息
//        ProducerService_2 producerService_2 = (ProducerService_2) run.getBean("producerService_2");
//        producerService_2.sendMessage();
		// 发送异步消息
//        ProducerService_3 producerService_3 = (ProducerService_3) run.getBean("producerService_3");
//        producerService_3.sendMessage();
		// 发送单向消息
//        ProducerService_4 producerService_4 = (ProducerService_4) run.getBean("producerService_4");
//        producerService_4.sendMessage();
		// 消费端的消费模式：广播模式
//        ProducerService_5 producerService_5 = (ProducerService_5) run.getBean("producerService_5");
//        producerService_5.sendMessage();
		// 消费端的消费模式：负载均衡模式
//        ProducerService_6 producerService_6 = (ProducerService_6) run.getBean("producerService_6");
//        producerService_6.sendMessage();
        // 发送同步顺序消息
//        ProducerService_7 producerService_7 = (ProducerService_7) run.getBean("producerService_7");
//        producerService_7.sendMessage();
		// 发送延迟消息
//        ProducerService_8 producerService_8 = (ProducerService_8) run.getBean("producerService_8");
//        producerService_8.sendMessage();
		// 发送事务消息
//		ProducerService_9 producerService_9 = (ProducerService_9) run.getBean("producerService_9");
//		producerService_9.sendMessage();
		// 过滤消息：TAG方式
//		ProducerService_10 producerService_10 = (ProducerService_10) run.getBean("producerService_10");
//		producerService_10.sendMessage();
		// 过滤消息：SQL方式
		ProducerService_11 producerService_11 = (ProducerService_11) run.getBean("producerService_11");
		producerService_11.sendMessage();
		
    }
}

子项目rocketmq-consumer的pom依赖



    
        RocketMQ
        com.java
        1.0-SNAPSHOT
    
    4.0.0

    rocketmq-consumer

    
        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.apache.rocketmq
            rocketmq-spring-boot-starter

子项目rocketmq-consumer的application.yml

server:
  port: 8082
  servlet:
    context-path: /

rocketmq:
  name-server: 127.0.0.1:9876
#  name-server: 192.168.1.44:9876;192.168.1.109:9876;192.168.1.124:9876;192.168.1.247:9876;
  consumer:
    group_1: consumer-demo1
    group_2: consumer-demo2
    group_3: consumer-demo3
    group_4: consumer-demo4
    group_5: consumer-demo5
    group_6: consumer-demo6
    group_7: consumer-demo7
    group_8: consumer-demo8
    group_9: consumer-demo9
    group_10: consumer-demo10
    group_11: consumer-demo11

子项目rocketmq-consumer的启动类

package com.java;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RocketmqConsumerApplication {

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

消息发送测试：先启动rocketmq-consumer监听消息，后启动rocketmq-provider发送消息

发送简单消息

package com.java.rocketmq;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * 消息生产者service类 发送简单消息
 */
@Component("producerService_1")
public class ProducerService_1 {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送简单消息
     */
    public void sendMessage(){
        for(int i=0;i<10;i++){
            rocketMQTemplate.convertAndSend("rocketmq_1","简单消息"+i);
        }
    }
    
}

package com.java.rocketmq;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * 消息消费者service类 接收简单消息
 */
@RocketMQMessageListener(topic = "rocketmq_1",consumerGroup = "${rocketmq.consumer.group_1}")
@Component
public class ConsumerService_1 implements RocketMQListener {

	@Override
    public void onMessage(String message) {
        System.out.println("接收简单消息："+message);
    }
    
}

发送同步消息

package com.java.rocketmq;

import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * 消息生产者service类 发送同步消息
 * 同步消息根据syncSend返回值sendResult的sendStatus属性判断是否成功，然后进行后续业务处理
 * 后续业务处理期间代码不会继续往下执行
 */
@Component("producerService_2")
public class ProducerService_2 {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送同步消息
     */
    public void sendMessage(){
        for(int i=0;i<10;i++){
            SendResult sendResult = rocketMQTemplate.syncSend("rocketmq_2","同步消息"+i);
            System.out.println(sendResult);
        }
    }
    
}

package com.java.rocketmq;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * 消息消费者service类 接收同步消息
 */
@RocketMQMessageListener(topic = "rocketmq_2",consumerGroup = "${rocketmq.consumer.group_2}")
@Component
public class ConsumerService_2 implements RocketMQListener {

	@Override
    public void onMessage(String message) {
        System.out.println("接收同步消息："+message);
    }
    
}

发送异步消息

package com.java.rocketmq;

import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * 消息生产者service类 发送异步消息
 * 异步消息根据onSuccess和onException异步回调方法，然后进行后续业务处理
 * 后续业务处理期间代码继续往下执行
 */
@Component("producerService_3")
public class ProducerService_3 {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送异步消息
     */
    public void sendMessage(){
        for(int i=0;i<10;i++){
            rocketMQTemplate.asyncSend("rocketmq_3", "异步消息"+i, new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    System.out.println("异步消息发送成功！");
                }
                @Override
                public void onException(Throwable throwable) {
                    System.out.println("异步消息发送失败！");
                }
            });
        
        }
    }
    
}

package com.java.rocketmq;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * 消息消费者service类 接收异步消息
 */
@RocketMQMessageListener(topic = "rocketmq_3",consumerGroup = "${rocketmq.consumer.group_3}")
@Component
public class ConsumerService_3 implements RocketMQListener {

	@Override
    public void onMessage(String message) {
        System.out.println("接收异步消息："+message);
    }

}

发送单向消息

package com.java.rocketmq;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * 消息生产者service类 发送单向消息
 * 不特别关心发送结果的场景 例：日志发送
 * 由于不关心结果，sendOneWay方法没有返回值
 */
@Component("producerService_4")
public class ProducerService_4 {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送单向消息
     */
    public void sendMessage(){
        for(int i=0;i<10;i++){
            rocketMQTemplate.sendOneWay("rocketmq_4", "单向消息"+i);
        }
    }
    
}

package com.java.rocketmq;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * 消息消费者service类 接收单向消息
 */
@RocketMQMessageListener(topic = "rocketmq_4",consumerGroup = "${rocketmq.consumer.group_4}")
@Component
public class ConsumerService_4 implements RocketMQListener {

	@Override
    public void onMessage(String message) {
        System.out.println("接收单向消息："+message);
    }

}

消费模式：广播模式

package com.java.rocketmq;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * 消息生产者service类 消费端的消费模式：广播模式
 * 广播模式是每个消费者，都会消费消息
 */
@Component("producerService_5")
public class ProducerService_5 {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 消费端的消费模式：广播模式
     */
    public void sendMessage(){
        for(int i=0;i<10;i++){
            rocketMQTemplate.convertAndSend("rocketmq_5","广播模式"+i);
        }
    }
    
}

package com.java.rocketmq;

import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * 消息消费者service类 消费模式：广播模式
 * messageModel = MessageModel.BROADCASTING为广播模式接收消息
 * 改变消费者端口号启动多个消费者实例测试消息接收情况
 */
@RocketMQMessageListener(topic = "rocketmq_5",consumerGroup = "${rocketmq.consumer.group_5}",messageModel = MessageModel.BROADCASTING)
@Component
public class ConsumerService_5 implements RocketMQListener {

	@Override
    public void onMessage(String message) {
        System.out.println("广播模式："+message);
    }

}

消费模式：负载均衡模式

package com.java.rocketmq;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 消息生产者service类 消费端的消费模式：负载均衡模式
 * 负载均衡模式是每一个消息只会被某一个消费者消费一次
 */
@Component("producerService_6")
public class ProducerService_6 {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 消费端的消费模式：负载均衡模式
     */
    public void sendMessage(){
        for(int i=0;i<10;i++){
            rocketMQTemplate.convertAndSend("rocketmq_6","负载均衡模式"+i);
        }
    }
    
}

package com.java.rocketmq;

import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * 消息消费者service类 消费模式：负载均衡模式
 * messageModel = MessageModel.CLUSTERING为负载均衡模式接收消息
 * 改变消费者端口号启动多个消费者实例测试消息接收情况
 */
@RocketMQMessageListener(topic = "rocketmq_6",consumerGroup = "${rocketmq.consumer.group_6}",messageModel = MessageModel.CLUSTERING)
@Component
public class ConsumerService_6 implements RocketMQListener {

	@Override
    public void onMessage(String message) {
        System.out.println("负载均衡模式："+message);
    }

}

发送同步顺序消息

package com.java.rocketmq;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * 消息生产者service类 发送同步顺序消息
 * broker会管理多个消息队列，syncSendOrderly发送消息时，hashKey相同的消息属于同一个消息队列，同一个队列的消息按顺序依次被消费
 */
@Component("producerService_7")
public class ProducerService_7 {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    /**
     * 发送同步顺序消息
     */
    public void sendMessage(){
        // 9条消息分别在3个对列排队，按照步骤依次被消费
        rocketMQTemplate.syncSendOrderly("rocketmq_7", "消息队列1，第1步", "消息队列1");
        rocketMQTemplate.syncSendOrderly("rocketmq_7", "消息队列1，第2步", "消息队列1");
        rocketMQTemplate.syncSendOrderly("rocketmq_7", "消息队列1，第3步", "消息队列1");
        rocketMQTemplate.syncSendOrderly("rocketmq_7", "消息队列2，第1步", "消息队列2");
        rocketMQTemplate.syncSendOrderly("rocketmq_7", "消息队列2，第2步", "消息队列2");
        rocketMQTemplate.syncSendOrderly("rocketmq_7", "消息队列2，第3步", "消息队列2");
        rocketMQTemplate.syncSendOrderly("rocketmq_7", "消息队列3，第1步", "消息队列3");
        rocketMQTemplate.syncSendOrderly("rocketmq_7", "消息队列3，第2步", "消息队列3");
        rocketMQTemplate.syncSendOrderly("rocketmq_7", "消息队列3，第3步", "消息队列3");
    }
    
}

package com.java.rocketmq;

import org.apache.rocketmq.spring.annotation.ConsumeMode;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * 消息消费者service类 接收同步顺序消息
 * consumeMode = ConsumeMode.CONCURRENTLY 并发多线程接收消息（默认）
 * consumeMode = ConsumeMode.ORDERLY 单线程顺序接收消息
 */
@RocketMQMessageListener(topic = "rocketmq_7",consumerGroup = "${rocketmq.consumer.group_7}",consumeMode = ConsumeMode.ORDERLY)
@Component
public class ConsumerService_7 implements RocketMQListener {

	@Override
    public void onMessage(String message) {
        System.out.println("接收同步顺序消息："+message);
    }

}

发送延迟消息

package com.java.rocketmq;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

/**
 * 消息生产者service类 发送延迟消息
 * timeout:消息发送超时时间，默认是3秒
 * delayLevel=1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
 */
@Component("producerService_8")
public class ProducerService_8 {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    /**
     * 发送延迟消息
     */
    public void sendMessage(){
        rocketMQTemplate.syncSend("rocketmq_8", MessageBuilder.withPayload("延迟消息1秒").build(),3000,1);
        rocketMQTemplate.syncSend("rocketmq_8", MessageBuilder.withPayload("延迟消息5秒").build(),3000,2);
        rocketMQTemplate.syncSend("rocketmq_8", MessageBuilder.withPayload("延迟消息10秒").build(),3000,3);
    }
    
}

package com.java.rocketmq;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * 消息消费者service类 接收延迟消息
 */
@RocketMQMessageListener(topic = "rocketmq_8",consumerGroup = "${rocketmq.consumer.group_8}")
@Component
public class ConsumerService_8 implements RocketMQListener {

	@Override
    public void onMessage(String message) {
        System.out.println("接收延迟消息："+message);
    }

}

发送事务消息

package com.java.rocketmq;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

/**
 * 消息生产者service类 发送事务消息
 * 半消息:sendMessageInTransaction把消息发送到Broker后无法被消费
 * TransactionListenerImpl为事务处理类，executeLocalTransaction方法中处理事务
 * 事务处理成功：executeLocalTransaction方法返回RocketMQLocalTransactionState.COMMIT，此时消息可以被消费
 * 事务处理失败：executeLocalTransaction方法返回RocketMQLocalTransactionState.ROLLBACK，此时消息被丢弃
 * 事务处理情况未知：executeLocalTransaction方法返回RocketMQLocalTransactionState.UNKNOWN，此时消息继续等待
 * 事务处理情况未知时，每隔一段时间会执行checkLocalTransaction方法查询事务处理情况，返回值同上，最多查询15次，如果事务处理情况仍然未知则消息被丢弃
 * 测试方法：executeLocalTransaction和checkLocalTransaction分别返回不同的结果，观察消息是否被消费端消费
 */
@Component("producerService_9")
public class ProducerService_9 {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    /**
     * 发送事务消息
     */
    public void sendMessage(){
        rocketMQTemplate.sendMessageInTransaction("rocketmq_9",MessageBuilder.withPayload("事务消息").build(),null);
    }
    
}

package com.java.rocketmq;

import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;

@RocketMQTransactionListener
public class TransactionListenerImpl implements RocketMQLocalTransactionListener {
	
	@Override
	public RocketMQLocalTransactionState executeLocalTransaction(org.springframework.messaging.Message msg, Object arg) {
		// ... local transaction process, return bollback, commit or unknown
//		System.out.println("事务处理成功，消息可以被消费");
//		return RocketMQLocalTransactionState.COMMIT;
//		System.out.println("事务处理失败，消息被丢弃");
//		return RocketMQLocalTransactionState.ROLLBACK;
		System.out.println("事务处理情况未知，消息继续等待");
		return RocketMQLocalTransactionState.UNKNOWN;
	}
	
	@Override
	public RocketMQLocalTransactionState checkLocalTransaction(org.springframework.messaging.Message msg) {
		// ... check transaction status and return bollback, commit or unknown
		System.out.println("查询事务状态为成功，消息可以被消费");
		return RocketMQLocalTransactionState.COMMIT;
//		System.out.println("查询事务状态为失败，消息被丢弃");
//		return RocketMQLocalTransactionState.ROLLBACK;
//		System.out.println("查询事务状态为未知，消息继续等待");
//		return RocketMQLocalTransactionState.UNKNOWN;
	}
}

package com.java.rocketmq;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * 消息消费者service类 接收事务消息
 */
@RocketMQMessageListener(topic = "rocketmq_9",consumerGroup = "${rocketmq.consumer.group_9}")
@Component
public class ConsumerService_9 implements RocketMQListener {

	@Override
    public void onMessage(String message) {
        System.out.println("接收事务消息："+message);
    }

}

过滤消息：TAG方式

package com.java.rocketmq;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

/**
 * 消息生产者service类 过滤消息：TAG方式
 * convertAndSend方法destination参数为-->topic:TAG
 */
@Component("producerService_10")
public class ProducerService_10 {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    /**
     * 过滤消息：TAG方式
     */
    public void sendMessage(){
        rocketMQTemplate.convertAndSend("rocketmq_10" + ":" + "TAG1", MessageBuilder.withPayload("过滤消息TAG1").build());
        rocketMQTemplate.convertAndSend("rocketmq_10" + ":" + "TAG2", MessageBuilder.withPayload("过滤消息TAG2").build());
        rocketMQTemplate.convertAndSend("rocketmq_10" + ":" + "TAG3", MessageBuilder.withPayload("过滤消息TAG3").build());
        rocketMQTemplate.convertAndSend("rocketmq_10" + ":" + "TAG4", MessageBuilder.withPayload("过滤消息TAG4").build());
        rocketMQTemplate.convertAndSend("rocketmq_10" + ":" + "TAG5", MessageBuilder.withPayload("过滤消息TAG5").build());
        rocketMQTemplate.convertAndSend("rocketmq_10" + ":" + "TAG6", MessageBuilder.withPayload("过滤消息TAG6").build());
    }
    
}

package com.java.rocketmq;

import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.annotation.SelectorType;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * 消息消费者service类 过滤消息：TAG方式
 * selectorType = SelectorType.TAG为TAG方式接收消息
 * selectorExpression = "TAG1 || TAG2"根据TAG指定需要消费的消息
 */
@RocketMQMessageListener(topic = "rocketmq_10",consumerGroup = "${rocketmq.consumer.group_10}",selectorType = SelectorType.TAG,selectorExpression = "TAG1 || TAG3 || TAG5")
@Component
public class ConsumerService_10 implements RocketMQListener {

	@Override
    public void onMessage(String message) {
        System.out.println("TAG方式："+message);
    }

}

过滤消息：SQL方式

package com.java.rocketmq;

import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * 消息生产者service类 过滤消息：SQL方式
 * convertAndSend方法headers参数用来封装需要过滤的参数
 */
@Component("producerService_11")
public class ProducerService_11 {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    /**
     * 过滤消息：SQL方式
     */
    public void sendMessage(){
        Map headers1 = new HashMap<>() ;
        headers1.put("name", "张三") ;
        headers1.put("age", 5) ;
        rocketMQTemplate.convertAndSend("rocketmq_11", MessageBuilder.withPayload("过滤消息SQL1").build(), headers1);
        
        Map headers2 = new HashMap<>() ;
        headers2.put("name", "李四") ;
        headers2.put("age", 10) ;
        rocketMQTemplate.convertAndSend("rocketmq_11", MessageBuilder.withPayload("过滤消息SQL2").build(), headers2);
        
        Map headers3 = new HashMap<>() ;
        headers3.put("name", "王五") ;
        headers3.put("age", 15) ;
        rocketMQTemplate.convertAndSend("rocketmq_11", MessageBuilder.withPayload("过滤消息SQL3").build(), headers3);
    }
    
}

package com.java.rocketmq;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.annotation.SelectorType;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * 消息消费者service类 过滤消息：SQL方式
 * selectorType = SelectorType.SQL92为SQL方式接收消息
 * 启动报错：The broker does not support consumer to filter message by SQL92（broker默认不支持SQL92过滤消息）
 * D:\program\RocketMQ\rocketmq\conf\broker.conf中添加SQL方式过滤消息支持enablePropertyFilter=true，重新启动broker
 * D:\program\RocketMQ\rocketmq\bin>mqbroker.cmd -n localhost:9876 autoCreateTopicEnable=true -c D:\program\RocketMQ\rocketmq\conf\broker.conf
 * selectorExpression = "name='张三' or age>10",根据SQL指定需要消费的消息
 * 数字比较：> >= < <= BETWEEN =
 * 字符比较：= <> IN
 * 逻辑运算符：AND OR NOT
 */
@RocketMQMessageListener(topic = "rocketmq_11",consumerGroup = "${rocketmq.consumer.group_11}",selectorType = SelectorType.SQL92,selectorExpression = "name='张三' or age>10")
@Component
public class ConsumerService_11 implements RocketMQListener {

	@Override
    public void onMessage(String message) {
        System.out.println("SQL方式："+message);
    }

}

https://blog.csdn.net/caoli201314?type=blog

你可能感兴趣的:(rocketmq)

单节点canal的介绍和搭建（对接mysql和rocketMQ）汀风中间件阿里云 mysql java
单节点canal-server+canal-admin的介绍和搭建（对接mysql和rocketMQ）一、简介1、Canal1、工作原理2、MySQL主从复制实现3、canal架构4、binarylog1、新增binlog2、更新binglog3、增加字段bin-log4、删除字段bin-log5、修改字段bin-log二、使用2.1安装1、本地安装2、docker安装canal-admincan
RocketMQ 架构简析，看这篇就够了！ V搜编程进阶路 Java程序员 java-rocketmq rocketmq 架构
生产者组（ProducerGroup）同一类Producer的集合，这类Producer发送同一类消息且发送逻辑一致。如果发送的是事务消息且原始生产者在发送之后崩溃，则Broker服务器会联系同一生产者组的其他生产者实例以提交或回溯消费。消费者组（ConsumerGroup）同一类Consumer的集合，这类Consumer通常消费同一类消息且消费逻辑一致。消费者组使得在消息消费方面，实现负载均衡
RocketMQ消息重复消费--一起学习吧之架构吗喽一只 rocketmq 学习架构
一、定义RocketMQ中的消息重复消费（DuplicateConsumption）指的是在某些情况下，消息可能会被多次消费，从而导致业务逻辑的重复执行。重复消费是MQ中常见的问题，尤其在系统调用频繁的场景下，可能会因为超时重试等原因导致重复消费。在RocketMQ中，重复消费可能由多种原因造成，例如服务端重启后的数据恢复、主从同步offset失败，以及消息处理异常等。二、原因RocketMQ消息
分布式中间件-几个常用的消息中间件问道飞鱼分布式技术分布式中间件
文章目录常见消息中间件1.RabbitMQ2.ApacheKafka3.RedisPub/Sub4.ActiveMQ5.AmazonSimpleNotificationService(SNS)和SimpleQueueService(SQS)6.RocketMQ差异总结消息协议1.AMQP(AdvancedMessageQueuingProtocol)2.STOMP(SimpleTextOrient
RocketMQ复习 slh别学了微服务 rocketmq 微服务 java
之前写的博客太杂，最近想把RocketMQ的知识点再系统的过一遍，带着自己的理解使用简短的话把一些问题总结一下，尤其是开发中和面试中的高频问题，基础知识点可以参考之前写的一些博客，这篇不再赘述。SpringCloud入门(3)RabbitMQRocketMQ学习(1)快速入门RocketMQ学习(2)深入学习RocketMQ学习(3)秒杀实战目录MQ技术对比基本概念(消费者组、订阅关系等)消费模式
python使用rocketmq发送消息_阿里云消息队列RocketMQ使用示例 weixin_39953481
本文代码示例参见：https://gitee.com/imlichao/RocketMQ-exampleApacheRocketMQ文档：http://rocketmq.apache.org/docs/quick-start/阿里云RocketMQ文档：https://help.aliyun.com/product/29530.html简介消息队列RocketMQ是阿里巴巴集团自主研发的专业消息中
python调用rocketmq的api_Python：Rocketmq消息队列使用 weixin_39914868
rocketmq可以与kafka等一起使用，用于实时消息处理。安装rocketmq：pipinstallrocketmq[-ihttps://pypi.tuna.tsinghua.edu.cn/simple]生产消息producer：fromrocketmq.clientimportProducer,Messageimportjsonproducer=Producer('PID-test')pro
Python API操作RocketMQ 京城小筑 #Python编程 python
背景：开发背景:公司相关报表需求需要将订单业务数据同步至RocketMQ中，由于需要保证开发的一致性(多个部门协同开发)，所以采用读取Hive离线数据的方式通过PythonAPI写入RocketMQ中，便于其他开发同事调用~开发环境:本地调试系统MacPython3.7.5rocketmq0.4.4(Python模块)rocketmq-client-python2.0.0(Python模块)服务器
python操作rocket-mq AQH~ Python
1、参考源码看源码，可以修改消息字节长度限制（rocketmq/client.py）2、推送消息fromrocketmq.clientimportProducer,Messageproducer=Producer('PID-001')#随便producer.set_namesrv_addr('ip:port')#ip和端口producer.start()msg=Message('rocket_mq
Docker部署RocketMQ5.2.0集群 egzosn docker 容器运维
部署架构说明：(1)Producer：生产者(2)Consumer：消费者(3)NameServer：RockerMQ的注册中心，多个实例组成集群，但相互独立，没有信息交换。每个Broker都向所有NameServer实例注册。(4)Broker：负责存储消息、转发消息。部署模式RocketMQ作为消息中间件，其主要功能为消息的Publish/Subscribe。而Broker担任的消息转发和存储
RocketMq解决消息重复消费的问题壹佰大多 java-rocketmq rocketmq redis
一、RocketMq解决业务端去重步骤：1、记录下每个消息的msgID2、新消息来的时候，查看该消息的msgID是否已记录，是则抛弃，否则消费二、RocketMq一般用redis进行记录，该msg是否被记录1、消费端接收到消息的时候，调用redis提供的incr自增方法，以msgID作为key（具有唯一性），value则默认从1开始递增。2、当incr返回值为1时，设置其失效时间为两分钟以后（每个
RocketMQ 幂等性 (消息重复处理) JAVA代码搬运工 RocketMQ java-rocketmq rocketmq
RocketMQ无法避免消息重复，所以如果业务对消费重复非常敏感，务必要在业务局面去重，有以下几种去重方式1.将消息的唯一键，可以是msgId，也可以是消息内容中的唯一标识字段，例如订单Id等，消费前判断是否在Db或Tair(全局KV存储)中存在，如果不存在则插入，幵消费，否则跳过。（实际过程要考虑原子性问题，判断是否存在可以尝试插入，如果报主键冲突，则插入失败，直接跳过）msgId一定是全局唯一
【Java】已解决：MQBrokerException: CODE: 1 DESC: create mapped file failed, server is busy or broke 屿小夏 java 开发语言
文章目录一、分析问题背景场景示例：二、可能出错的原因三、错误代码示例错误分析：四、正确代码示例代码改进说明：五、注意事项在分布式消息中间件如ApacheRocketMQ的使用过程中，MQBrokerException是一个开发者可能会遇到的常见异常之一。特别是CODE:1DESC:createmappedfilefailed,serverisbusyorbroke这个错误，通常指示了在消息存储过程
ASP.NET Core 入门教学八集成RocketMQ消息队列充值内卷 asp.net rocketmq 后端
在ASP.NETCore中集成RocketMQ消息队列，你需要遵循以下步骤：1.安装RocketMQ客户端库首先，你需要在你的ASP.NETCore项目中安装RocketMQ的.NET客户端库。你可以使用NuGet包管理器来完成这个任务。在VisualStudio中，右键点击你的项目，选择“管理NuGet程序包”，然后搜索并安装Apache.RocketMQ.Client包。2.配置RocketM
阿里云RocketMQ_Exception]valid resource owner failed. maybe the resource wswy_tp_test_1 not created fantasyYan2 阿里云 recket mq 消息中间件
这是我之前工作时遇到过的一个问题，在网上提供的解决方法都不可用，于是询问了阿里云的工单，终于解决了这个问题，现在把这个可行的解决方法拿出来和大家分享：1.instanceId是否有填，虽然给的demo说默认为空，其实不填就会报这个错，可能是由于mq版本升级的问题2.查看AccessKeyId对应的用户是否有操作mq的权限3.顺序消息类型不支持http请求（本人的项目就是由这个问题引起的，这个阿里云
RocketMQ 如何保证消息不丢失？ JinYD2018 #RocketMQ java-rocketmq rocketmq java
RocketMQ的消息想要确保不丢失，需要生产者、消费者以及Broker的共同努力，缺一不可。生产者（Producer）1、发送方式：选择同步发送同步发送：发送消息后，需要阻塞等待Broker确认收到消息，生产者才能拿到返回的SendResult异步发送：Producer首先构建一个向broker发送消息的任务，把该任务提交给线程池，等执行完该任务时，回调用户自定义的回调函数，执行处理结果。2、重
Kafka、RabbitMQ、RocketMQ 之间的区别是什么 m0_67394230 面试学习路线阿里巴巴 android 前端后端
Kafka、RabbitMQ、RocketMQ之间的区别是什么?-知乎Kafka和RabbitMQ的区别:RabbitMQ有这么个特性，它在官方文档就声明了自己是不保证多线程消费同一个队列的消息，一定保证顺序的。而不保证的原因，是因为多线程时，当一个线程消费消息报错的时候，RabbitMQ会把消费失败的消息再入队，此时就可能出现乱序的情况。用RabbitMQ，出现了三个问题：为了实现发布订阅功能，
spring使用@Resource 注入map Java知识技术分享 spring技术 spring java 后端
spring使用@Resource注入map注入多个Service：/***单笔付款状态MQ消费**@authorzkg*@since2024-09-0616:11:19*/@Slf4j@Component@RocketMQMessageListener(topic=PayGlobalConstants.PAY_APPL_SINGLE_TOPIC,consumerGroup=PayGlobalCo
Kafka的事务实现 Mirana_77 消息队列 kafka java 分布式
Kafka的事务Kafka的事务解决的问题和RocketMQ是不太一样的。RocketMQ中的事务，它解决的问题是，确保执行本地事务和发消息这两个操作，要么都成功，要么都失败。并且，RocketMQ增加了一个事务反查的机制，来尽量提高事务执行的成功率和数据一致性。而Kafka中的事务，它解决的问题是，确保在一个事务中发送的多条消息，要么都成功，要么都失败。注意，这里面的多条消息不一定要在同一个主题
SpringBoot整合Kafka ITBOY_ITBOX SpringBoot kafka spring boot java
安装windows版安装包下载地址：https://kafka.apache.org/downloads下载完毕后得到tgz压缩文件，使用解压缩软件解压缩即可使用，解压后得到如下文件建议使用windows版2.8.1版本。启动服务器kafka服务器的功能相当于RocketMQ中的broker，kafka运行还需要一个类似于命名服务器的服务。在kafka安装目录中自带一个类似于命名服务器的工具，叫做
rocketmq 同步复制，异步复制，同步刷盘，异步刷盘详解 husterlichf #RocketMQ java-rocketmq rocketmq java
一、刷盘模式同步刷盘：在返回写成功状态时，消息已经被写入磁盘。具体流程是，消息写入内存的PAGECACHE后，立刻通知刷盘线程刷盘，然后等待刷盘完成，刷盘线程执行完成后唤醒等待的线程，返回消息写成功的状态。优点：机器宕机消息也会被保留，缺点：写入速度慢，吞吐量小。异步刷盘：在返回写成功状态时，消息只是被写入了内存的PAGECACHE，这样的好处是写操作的返回快，吞吐量大；当内存里的消息量积累到一定
聊聊rocketmq的PullConsumerImpl go4it
序本文主要研究一下rocketmq的PullConsumerImplPullConsumerImplio/openmessaging/rocketmq/consumer/PullConsumerImpl.javapublicclassPullConsumerImplimplementsPullConsumer{privatefinalDefaultMQPullConsumerrocketmqPul
使用 Shell 脚本管理 RocketMQ 服务：启动、停止与状态检查 heromps rocketmq
在分布式系统中，RocketMQ是一个流行的消息队列中间件。在开发和运维过程中，能够高效地启动、停止和检查RocketMQ相关服务的状态非常重要。本文将介绍如何使用Shell脚本来管理RocketMQ的NameServer、Broker和Dashboard服务，并提供相应的脚本示例和说明。安装可以查看这篇博客RocketMQ实战：在macOS上安装与前端访问全流程指南1.脚本概述这个脚本将涵盖以下
SpringBoot优雅的封装不同研发环境下（环境隔离）RocketMq自动ack和手动ack 小吴先生666 spring boot rocketmq 手动ACK和自动ACK MQ环境隔离
1.RocketMq的maven依赖版本：org.apache.rocketmqrocketmq-spring-boot-starter2.3.02.RocketMq的yml文件：#自定义属性system:environment:#隔离环境名称，拼接到topic后，xxx_topic_tianxin，默认空字符串name:dev#启动隔离，会自动在topic上拼接激活的配置文件，达到自动隔离的效果
helm学习第四篇-微服务组件的加入 Wade_Crab java-rocketmq 微服务 spring boot 云计算 kubernetes
微服务的组件也放进去—向外扩张要将Nacos服务添加到你已经包含了SpringBoot、Redis、MySQL和RocketMQ的HelmChart中，你可以按照以下步骤操作：注意！！：nacos好像只有helm文件的github仓库，没有helm的包地址仓库。所以一会思路：找到nacos的github仓库：nacos仓库修改values.yaml内容1.添加NacosHelmChart依赖首先，
helm学习第三篇--结合 springboot 单做 Wade_Crab java-rocketmq spring boot redis kubernetes
创建一个springboot项目放到里面去—开山立派要将你的SpringBoot项目代码与Redis、MySQL和RocketMQ组合到同一个HelmChart中，你可以按照以下步骤进行操作：1.准备SpringBoot项目确保你的SpringBoot项目已经打包为Docker镜像。如果还没有创建Docker镜像，可以在SpringBoot项目的根目录下创建一个Dockerfile，并使用以下内容
12306项目学习笔记（框架篇Base） Rainyocode 学习
首先学习的是基础框架ApplicationContextHolderApplicationContextHolder提供了一种静态方式来访问Spring容器中的Bean，适用于某些特定场景，如工具类和框架集成。在12306项目中由于我们引入了RocketMQ消息队列，这些库的对象通常不是Spring管理的，无法直接使用@Autowired注入，所以需要ApplicationContextHolde
【Rust光年纪】深度解读：Rust语言中各类消息队列客户端库详细对比 friklogff Rust光年纪 rust 开发语言后端
选择最佳Rust消息队列客户端库：全面对比与分析前言随着现代应用程序的复杂性不断增加，消息队列成为构建可靠、高性能系统的重要组件。本文将介绍一些用于Rust语言的消息队列客户端库，包括AMQP、ApacheKafka、NSQ、ApachePulsar和RocketMQ，探讨它们的核心功能、使用场景、安装配置以及API概览。欢迎订阅专栏：Rust光年纪文章目录选择最佳Rust消息队列客户端库：全面对
编写组合helm, 组合之前的几个组件 -2 Wade_Crab docker kubernetes
刚刚是独立安装，现在要组合他们到一个Chart里面—初入江湖要将Redis、MySQL和RocketMQ组合在一个HelmChart中，并且部署到同一个KubernetesPod或者同一个Helmrelease中，你可以创建一个自定义的HelmChart，将这三个服务作为子Chart来管理。1.创建自定义HelmChart首先，创建一个新的HelmChart：helmcreatemy-stack这
RocketMQ顺序消费葵续浅笑 rocketmq java
根据公司项目的一个使用场景，针对实时预警任务，会有同时消费某个设备正常或异常的事件，而这类事件具有时间维度上的先后性，需要符合先进先出（FIFO）原则进行发布和消费，而MQ消费为了吞吐量基本会使用多线程消费，RocketMQ也会分为多个消息队列，会造成消费无序的情况，这时候为了综合兼顾顺序消费+性能的考虑，可以使用分区顺序消息的策略。生产顺序性发送时将ShardingKey相同（例如同一设备）的消
mysql主从数据同步林鹤霄 mysql主从数据同步
配置mysql5.5主从服务器(转) 教程开始：一、安装MySQL 说明：在两台MySQL服务器192.168.21.169和192.168.21.168上分别进行如下操作，安装MySQL 5.5.22 二、配置MySQL主服务器（192.168.21.169）mysql -uroot -p &nb
oracle学习笔记 caoyong oracle
1、ORACLE的安装 a>、ORACLE的版本 8i,9i : i是internet 10g,11g : grid (网格) 12c : cloud (云计算) b>、10g不支持win7 &
数据库，SQL零基础入门天子之骄 sql 数据库入门基本术语
数据库，SQL零基础入门做网站肯定离不开数据库，本人之前没怎么具体接触SQL，这几天起早贪黑得各种入门，恶补脑洞。一些具体的知识点，可以让小白不再迷茫的术语，拿来与大家分享。数据库，永久数据的一个或多个大型结构化集合，通常与更新和查询数据的软件相关
pom.xml 一炮送你回车库 pom.xml
1、一级元素dependencies是可以被子项目继承的 2、一级元素dependencyManagement是定义该项目群里jar包版本号的，通常和一级元素properties一起使用，既然有继承，也肯定有一级元素modules来定义子元素 3、父项目里的一级元素<modules> <module>lcas-admin-war</module> <
sql查地区省市县 3213213333332132 sql mysql
-- db_yhm_city SELECT * FROM db_yhm_city WHERE class_parent_id = 1 -- 海南 class_id = 9 港、奥、台 class_id = 33、34、35 SELECT * FROM db_yhm_city WHERE class_parent_id =169 SELECT d1.cla
关于监听器那些让人头疼的事宝剑锋梅花香画图板监听器鼠标监听器
本人初学JAVA，对于界面开发我只能说有点蛋疼，用JAVA来做界面的话确实需要一定的耐心（不使用插件，就算使用插件的话也没好多少）既然Java提供了界面开发，老师又要求做，只能硬着头皮上啦。但是监听器还真是个难懂的地方，我是上了几次课才略微搞懂了些。
JAVA的遍历MAP darkranger map
Java Map遍历方式的选择 1. 阐述　　对于Java中Map的遍历方式，很多文章都推荐使用entrySet，认为其比keySet的效率高很多。理由是：entrySet方法一次拿到所有key和value的集合；而keySet拿到的只是key的集合，针对每个key，都要去Map中额外查找一次value，从而降低了总体效率。那么实际情况如何呢？　　为了解遍历性能的真实差距，包括在遍历ke
POJ 2312 Battle City 优先多列+bfs aijuans 搜索
来源：http://poj.org/problem?id=2312 题意：题目背景就是小时候玩的坦克大战，求从起点到终点最少需要多少步。已知S和R是不能走得，E是空的，可以走，B是砖，只有打掉后才可以通过。思路：很容易看出来这是一道广搜的题目，但是因为走E和走B所需要的时间不一样，因此不能用普通的队列存点。因为对于走B来说，要先打掉砖才能通过，所以我们可以理解为走B需要两步，而走E是指需要1
Hibernate与Jpa的关系，终于弄懂 avords java Hibernate 数据库 jpa
我知道Jpa是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。在play中定义Model时，使用的是jpa的annotations，比如javax.persistence.Entity, Table, Column, OneToMany
酸爽的console.log bee1314 console
在前端的开发中，console.log那是开发必备啊，简直直观。通过写小函数，组合大功能。更容易测试。但是在打版本时，就要删除console.log，打完版本进入开发状态又要添加，真不够爽。重复劳动太多。所以可以做些简单地封装，方便开发和上线。 /** * log.js hufeng * The safe wrapper for `console.xxx` functions *
哈佛教授：穷人和过于忙碌的人有一个共同思维特质 bijian1013 时间管理励志人生穷人过于忙碌
一个跨学科团队今年完成了一项对资源稀缺状况下人的思维方式的研究，结论是：穷人和过于忙碌的人有一个共同思维特质，即注意力被稀缺资源过分占据，引起认知和判断力的全面下降。这项研究是心理学、行为经济学和政策研究学者协作的典范。　　这个研究源于穆来纳森对自己拖延症的憎恨。他7岁从印度移民美国，很快就如鱼得水，哈佛毕业
other operate 征客丶 OS osx
一、Mac Finder 设置排序方式，预览栏在显示－》查看显示选项中二、有时预览显示时，卡死在那，有可能是一些临时文件夹被删除了，如：/private/tmp[有待验证] -------------------------------------------------------------------- 若有其他凝问或文中有错误，请及时向我指出，我好及时改正，同时也让我们一
【Scala五】分析Spark源代码总结的Scala语法三 bit1129 scala
1. If语句作为表达式 val properties = if (jobIdToActiveJob.contains(jobId)) { jobIdToActiveJob(stage.jobId).properties } else { // this stage will be assigned to "default" po
ZooKeeper 入门 BlueSkator 中间件 zk
ZooKeeper是一个高可用的分布式数据管理与系统协调框架。基于对Paxos算法的实现，使该框架保证了分布式环境中数据的强一致性，也正是基于这样的特性，使得ZooKeeper解决很多分布式问题。网上对ZK的应用场景也有不少介绍，本文将结合作者身边的项目例子，系统地对ZK的应用场景进行一个分门归类的介绍。值得注意的是，ZK并非天生就是为这些应用场景设计的，都是后来众多开发者根据其框架的特性，利
MySQL取得当前时间的函数是什么格式化日期的函数是什么 BreakingBad mysql Date
取得当前时间用 now() 就行。在数据库中格式化时间用DATE_FORMA T(date, format) . 根据格式串format 格式化日期或日期和时间值date，返回结果串。可用DATE_FORMAT( ) 来格式化DATE 或DATETIME 值，以便得到所希望的格式。根据format字符串格式化date值: %S, %s 两位数字形式的秒（ 00,01,
读《研磨设计模式》-代码笔记-组合模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; abstract class Component { public abstract void printStruct(Str
4_JAVA+Oracle面试题(有答案) chenke oracle
基础测试题卷面上不能出现任何的涂写文字，所有的答案要求写在答题纸上，考卷不得带走。选择题 1、 What will happen when you attempt to compile and run the following code? （3） public class Static { static { int x = 5; // 在static内有效 } st
新一代工作流系统设计目标 comsci 工作算法脚本
用户只需要给工作流系统制定若干个需求，流程系统根据需求，并结合事先输入的组织机构和权限结构，调用若干算法，在流程展示版面上面显示出系统自动生成的流程图，然后由用户根据实际情况对该流程图进行微调，直到满意为止，流程在运行过程中，系统和用户可以根据情况对流程进行实时的调整，包括拓扑结构的调整，权限的调整，内置脚本的调整。。。。。在这个设计中，最难的地方是系统根据什么来生成流
oracle 行链接与行迁移 daizj oracle 行迁移
表里的一行对于一个数据块太大的情况有二种(一行在一个数据块里放不下) 第一种情况: INSERT的时候，INSERT时候行的大小就超一个块的大小。Oracle把这行的数据存储在一连串的数据块里(Oracle Stores the data for the row in a chain of data blocks)，这种情况称为行链接(Row Chain)，一般不可避免(除非使用更大的数据
[JShop]开源电子商务系统jshop的系统缓存实现 dinguangx jshop 电子商务
前言 jeeshop中通过SystemManager管理了大量的缓存数据，来提升系统的性能，但这些缓存数据全部都是存放于内存中的，无法满足特定场景的数据更新（如集群环境）。JShop对jeeshop的缓存机制进行了扩展，提供CacheProvider来辅助SystemManager管理这些缓存数据，通过CacheProvider,可以把缓存存放在内存,ehcache,redis，memcache
初三全学年难记忆单词 dcj3sjt126com english word
several 儿子；若干 shelf 架子 knowledge 知识；学问 librarian 图书管理员 abroad 到国外，在国外 surf 冲浪 wave 浪；波浪 twice 两次；两倍 describe 描写；叙述 especially 特别；尤其 attract 吸引 prize 奖品；奖赏 competition 比赛；竞争 event 大事；事件 O
sphinx实践 dcj3sjt126com sphinx
安装参考地址:http://briansnelson.com/How_to_install_Sphinx_on_Centos_Server yum install sphinx 如果失败的话使用下面的方式安装 wget http://sphinxsearch.com/files/sphinx-2.2.9-1.rhel6.x86_64.rpm yum loca
JPA之JPQL（三） frank1234 orm jpa JPQL
1 什么是JPQL JPQL是Java Persistence Query Language的简称，可以看成是JPA中的HQL， JPQL支持各种复杂查询。 2 检索单个对象 @Test public void querySingleObject1() { Query query = em.createQuery("sele
Remove Duplicates from Sorted Array II hcx2013 remove
Follow up for "Remove Duplicates":What if duplicates are allowed at most twice? For example,Given sorted array nums = [1,1,1,2,2,3], Your function should return length
Spring4新特性——Groovy Bean定义DSL jinnianshilongnian spring 4
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
CentOS安装Mysql5.5 liuxingguome centos
CentOS下以RPM方式安装MySQL5.5 首先卸载系统自带Mysql： yum remove mysql mysql-server mysql-libs compat-mysql51 rm -rf /var/lib/mysql rm /etc/my.cnf 查看是否还有mysql软件： rpm -qa|grep mysql 去http://dev.mysql.c
第14章工具函数（下） onestopweb 函数
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
POJ 1050 SaraWon 二维数组子矩阵最大和
POJ ACM第1050题的详细描述，请参照 http://acm.pku.edu.cn/JudgeOnline/problem?id=1050 题目意思：给定包含有正负整型的二维数组，找出所有子矩阵的和的最大值。如二维数组 0 -2 -7 0 9 2 -6 2 -4 1 -4 1 -1 8 0 -2 中和最大的子矩阵是 9 2 -4 1 -1 8 且最大和是15
Java8全新打造，英语学习supertool yangshangchuan java superword 闭包 java8 函数式编程
superword是一个Java实现的英文单词分析软件，主要研究英语单词音近形似转化规律、前缀后缀规律、词之间的相似性规律等等。Clean code、Fluent style、Java8 feature: Lambdas, Streams and Functional-style Programming。升学考试、工作求职、充电提高，都少不了英语的身影，英语对我们来说实在太重要