WEB项目集成 ROCKETMQ

最新推荐文章于 2024-03-05 10:13:22 发布
最新推荐文章于 2024-03-05 10:13:22 发布
阅读量1.7k 收藏 2
点赞数
分类专栏： java

 1.pom.xm

<dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-client</artifactId>
                <version>4.3.0</version>
         </dependency>

 

 

 

2.spring-mvc-mq.consumer.xml（消费者配置）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 每个模块只需要配置一个 consumer -->
    <bean id="consumer" class="com.nobuy.service.impl.mq.RocketMqConsumerImpl" init-method="afterPropertiesSet" destroy-method="destroy">
        <property name="namesrvAddr" value="${rocketmq.namesrv}" />
          <!-- 消息组名字Group -->
        <property name="consumerGroup" value="LOANSYS" />
        <!-- 消费方式：BROADCASTING 广播消费，CLUSTERING 集群消费 -->
        <property name="messageModel" value="BROADCASTING" />
        <!-- CONCURRENTLY 无序消费  ORDERLY 有序消费 -->
        <property name="messageListener" value="ORDERLY" />
        <property name="handlermap">
            <map>
                <entry key="loanRequest">
                    <bean class="com.nobuy.service.impl.mq.LoanRequestConsumer">
                        <property name="classTypeName" value="com.nobuy.entity.mq.LoanRequest"></property>
                    </bean>
                </entry>
            </map>
        </property>
    </bean>

3.spring-mvc-mq.producer.xml（生成者配置）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 每个模块只需要配置一个 producer -->
    <bean id="producer" class="com.nobuy.service.impl.mq.RocketMqProducerImpl" init-method="afterPropertiesSet" destroy-method="destroy">
        <property name="producerGroup" value="LOANSYS"></property>
        <property name="namesrvAddr" value="${rocketmq.namesrv}"></property>
        <property name="retryAnotherBrokerWhenNotStoreOK" value="${rocketmq.retryAnotherBrokerWhenNotStoreOK}"></property>
    </bean>
</beans>

4.MQEntity（消息父类）

 

package com.nobuy.entity.mq;


import java.io.Serializable;
import java.util.LinkedHashMap;
import java.util.Map;

import javax.persistence.Entity;

import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.ToStringBuilder;

/**
 * @author Administrator
 *
 */
public class MQEntity implements java.io.Serializable{

    private static final long serialVersionUID = -2551495105702956945L;
    
    private Map<String, Object> extObj = new LinkedHashMap<String, Object>();
    
    private String mqId ;
    
    private String mqKey;

    /**
     * 添加附加字段
     * @param key
     * @param value
     */
    public void addExt(String key , Object value){
        extObj.put(key, value);
    }
    
    /**
     * 获取附加字段
     * @param key
     */
    public void getExt(String key ){
        extObj.get(key);
    }

    public String getMqId() {
        return mqId;
    }

    public void setMqId(String mqId) {
        this.mqId = mqId;
    }

    public String getMqKey() {
        return mqKey;
    }

    public void setMqKey(String mqKey) {
        this.mqKey = mqKey;
    }

    @Override
    public int hashCode() {
        return HashCodeBuilder.reflectionHashCode(this);
    }

    @Override
    public boolean equals(Object obj) {
        return EqualsBuilder.reflectionEquals(this, obj);
    }

    @Override
    public String toString() {
        return ToStringBuilder.reflectionToString(this);
    }
}

5.LoanRequest.java（测试消费对象）

package com.nobuy.entity.mq;


import java.math.BigDecimal;
import java.util.Date;

import javax.persistence.Entity;

import com.nobuy.entity.mq.MQEntity;

/**
 * 
 * @author Administrator
 */
public class LoanRequest extends MQEntity{

    private static final long serialVersionUID = 5339647958993664240L;
    
    /** 贷款申请编号，前段生存的唯一编号 */
    private String applyNo;
    
    /** 额度编号   */
    private String creditNo;
    
    /**贷款人员工号 */
    private String employeeNo;
    
    /** 贷款金额 */
    private BigDecimal payamt;
    
    /**还款方式
     *     0：多次还本、分次付息
        1：分次还本、分次付息
        2：等额本金
     **/
    private String repayMode;
    
    /**还款期限  1个月、3个月、6个月、9个月、12个月、15个月、18个月、24个月；
     * 1，3， 6
     * */
    private String oprTerm;
    
    /**用途*/
    private String lendPurpose;
    
    //申请日期
    private Date applyDate;
    
    //贷款卡号
    private String loanCardNo;
    
    //开户行
    private String bankName;
    
    //联行行号
    private String bankCode ;
    
    public String getBankName() {
        return bankName;
    }

    public void setBankName(String bankName) {
        this.bankName = bankName;
    }

    public String getBankCode() {
        return bankCode;
    }

    public void setBankCode(String bankCode) {
        this.bankCode = bankCode;
    }

    public String getEmployeeNo() {
        return employeeNo;
    }

    public void setEmployeeNo(String employeeNo) {
        this.employeeNo = employeeNo;
    }

    public BigDecimal getPayamt() {
        return payamt;
    }

    public void setPayamt(BigDecimal payamt) {
        this.payamt = payamt;
    }

    public String getRepayMode() {
        return repayMode;
    }

    public void setRepayMode(String repayMode) {
        this.repayMode = repayMode;
    }

    public String getOprTerm() {
        return oprTerm;
    }

    public void setOprTerm(String oprTerm) {
        this.oprTerm = oprTerm;
    }

    public String getLendPurpose() {
        return lendPurpose;
    }

    public void setLendPurpose(String lendPurpose) {
        this.lendPurpose = lendPurpose;
    }

    public String getLoanCardNo() {
        return loanCardNo;
    }

    public void setLoanCardNo(String loanCardNo) {
        this.loanCardNo = loanCardNo;
    }

    public String getApplyNo() {
        return applyNo;
    }

    public void setApplyNo(String applyNo) {
        this.applyNo = applyNo;
    }

    public String getCreditNo() {
        return creditNo;
    }

    public void setCreditNo(String creditNo) {
        this.creditNo = creditNo;
    }

    public Date getApplyDate() {
        return applyDate;
    }

    public void setApplyDate(Date applyDate) {
        this.applyDate = applyDate;
    }


    
}

6.IConsumer（消费端接口）

package com.nobuy.service.mq;

import org.apache.rocketmq.common.message.MessageExt;

public interface IConsumer {

    /**
     * 消费端解析消息
     * @param msg
     */
    void handlerMessage( MessageExt msg );
    
}

7.IProducer（生产者接口）

package com.nobuy.service.mq;


import org.apache.rocketmq.client.producer.SendCallback;

import com.nobuy.entity.mq.MQEntity;

/**
 * mq消息生产者
 * @author Administrator
 *
 */
public interface IProducer {
    
    /**
     * 同步发送MQ
     * @param topic
     * @param entity
     */
    public void send(String topic, MQEntity entity);

    /**
     * 发送MQ,提供回调函数，超时时间默认3s
     * @param topic 
     * @param entity
     * @param sendCallback
     */
    public void send( String topic, MQEntity entity, SendCallback sendCallback );

    /**
     * 单向发送MQ，不等待服务器回应且没有回调函数触发，适用于某些耗时非常短，但对可靠性要求并不高的场景，例如日志收集。
     * @param topic
     * @param entity
     */
    public void sendOneway(String topic, MQEntity entity);
    
}

8.RocketMqProducerImpl（生成者接口实现）

 

package com.nobuy.service.impl.mq;

import java.text.MessageFormat;
import java.util.UUID;

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.common.message.Message;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Service;

import com.nobuy.entity.mq.MQEntity;
import com.nobuy.service.mq.IProducer;
import com.nobuy.utils.mq.SerializableUtil;

import net.sf.json.JSONObject;

public class RocketMqProducerImpl implements IProducer, InitializingBean{
    
    private static Logger logger = LoggerFactory.getLogger(RocketMqProducerImpl.class);
            
    private String namesrvAddr;

    private String producerGroup;

    private Boolean retryAnotherBrokerWhenNotStoreOK;

    private DefaultMQProducer producer;

    

    /**
     * spring 容器初始化所有属性后调用此方法
     */
    public void afterPropertiesSet() throws Exception {
        producer = new DefaultMQProducer();
        producer.setProducerGroup( this.producerGroup );
        producer.setNamesrvAddr( this.namesrvAddr );
        producer.setRetryAnotherBrokerWhenNotStoreOK( this.retryAnotherBrokerWhenNotStoreOK );
//        producer.setVipChannelEnabled(false);
        /*
         * Producer对象在使用之前必须要调用start初始化，初始化一次即可<br>
         * 注意：切记不可以在每次发送消息时，都调用start方法
         */
        producer.start();
        logger.info( "[{}:{}] start successd!",producerGroup,namesrvAddr );
    }
    
    /**
     * 销毁
     */
    public void destroy() throws Exception {
        if (producer != null) {
            logger.info("producer: [{}:{}] end ",producerGroup,namesrvAddr);
            producer.shutdown();
        }

    }


    public void send(String topic, MQEntity entity) {
        String keys = UUID.randomUUID().toString();
        entity.setMqKey(keys);
        String tags = entity.getClass().getName();
      //  logger.info("业务:{},tags:{},keys:{},entity:{}",topic, tags, keys, entity);
        String smsContent = MessageFormat.format("业务:{0},tags:{1},keys:{2},entity:{3}",topic,tags,keys,JSONObject.fromObject(entity).toString());
        logger.info(smsContent);
        
        Message msg = new Message(topic, tags, keys,
                SerializableUtil.toByte(entity));
        try {
            producer.send(msg);
        } catch (Exception e) {
            logger.error(keys.concat(":发送消息失败"), e);
            throw new RuntimeException("发送消息失败",e);
        } 
    }


    public void send(String topic, MQEntity entity, SendCallback sendCallback) {
        String keys = UUID.randomUUID().toString();
        entity.setMqKey(keys);
        String tags = entity.getClass().getName();
       // logger.info("业务:{},tags:{},keys:{},entity:{}",topic, tags, keys, entity);
        String smsContent = MessageFormat.format("业务:{0},tags:{1},keys:{2},entity:{3}",topic,tags,keys,JSONObject.fromObject(entity).toString());
        logger.info(smsContent);
        
        Message msg = new Message(topic, tags, keys,
                SerializableUtil.toByte(entity));
        try {
            producer.send(msg, sendCallback);
        } catch (Exception e) {
            logger.error(keys.concat(":发送消息失败"), e);
            throw new RuntimeException("发送消息失败",e);
        } 
    }


    public void sendOneway(String topic, MQEntity entity) {
        String keys = UUID.randomUUID().toString();
        entity.setMqKey(keys);
        String tags = entity.getClass().getName();
        String smsContent = MessageFormat.format("业务:{0},tags:{1},keys:{2},entity:{3}",topic,tags,keys,JSONObject.fromObject(entity).toString());
        logger.info(smsContent);
        Message msg = new Message(topic, tags, keys,
                SerializableUtil.toByte(entity));
        try {
            producer.sendOneway(msg);
        } catch (Exception e) {
            logger.error(keys.concat(":发送消息失败"), e);
            throw new RuntimeException("发送消息失败",e);
        }
    }
    
    public void setNamesrvAddr(String namesrvAddr) {
        this.namesrvAddr = namesrvAddr;
    }


    public void setProducerGroup(String producerGroup) {
        this.producerGroup = producerGroup;
    }


    public void setProducer(DefaultMQProducer producer) {
        this.producer = producer;
    }


    public void setRetryAnotherBrokerWhenNotStoreOK(
            Boolean retryAnotherBrokerWhenNotStoreOK) {
        this.retryAnotherBrokerWhenNotStoreOK = retryAnotherBrokerWhenNotStoreOK;
    }

    
    
}


 

9.AbstractConsumer（消费者父类）

 

package com.nobuy.service.impl.mq;

import org.apache.rocketmq.common.message.MessageExt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import com.nobuy.entity.mq.MQEntity;
import com.nobuy.service.mq.IConsumer;
import com.nobuy.utils.mq.SerializableUtil;

public abstract class AbstractConsumer implements IConsumer {
    
    protected Logger logger = LoggerFactory.getLogger(AbstractConsumer.class);

    private String classTypeName;
    
    public void handlerMessage(MessageExt msg) {
        try {
            MQEntity entity = doStart(msg);
            execute(entity);
            doEnd(entity);
        } catch (Exception e) {
            logger.error("处理mq消息异常。",e);
        }
    }

    /**
     * 解析mq消息前置处理
     * @param msg
     * @param entity 
     * @throws ClassNotFoundException 
     */
    protected MQEntity doStart(MessageExt msg) throws ClassNotFoundException {
        Class<? extends MQEntity> clazz = (Class<? extends MQEntity>) Class.forName(classTypeName);
        return SerializableUtil.parse(msg.getBody(), clazz);
    }

    /**
     * 解析mq消息后置处理
     * @param entity
     */
    protected void doEnd(MQEntity entity) {
        
    }

    /**
     * 解析mq消息 MessageExt
     * @param entity
     */
    public abstract void execute(MQEntity entity);

    public void setClassTypeName(String classTypeName) {
        this.classTypeName = classTypeName;
    }
    
    
    
}

 

12.RocketMqConsumerImpl（消费者）

 

package com.nobuy.service.impl.mq;

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

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;


public class RocketMqConsumerImpl implements InitializingBean {

    private static final Logger logger = LoggerFactory.getLogger(RocketMqConsumerImpl.class);
    
    private DefaultMQPushConsumer consumer;
    
    private String namesrvAddr;

    private String consumerGroup;

    private String messageModel;

    private String messageListener;

    private Map<String, AbstractConsumer> handlermap = new HashMap<String, AbstractConsumer>();

    private void initializingMessageSelector() throws InterruptedException, MQClientException {
        consumer = new DefaultMQPushConsumer();
        if( this.consumerGroup != null && this.consumerGroup.trim().length() > 0 ) {
            consumer.setConsumerGroup( this.consumerGroup );
            logger.debug( "set consumer group " + this.consumerGroup );
        }
        consumer.setNamesrvAddr( this.namesrvAddr );
        consumer.setConsumeMessageBatchMaxSize( 1 );
        logger.debug( "set consumer name server address " + this.namesrvAddr );
        logger.debug( "set consumer message batch max size " + 1 );

        if( "BROADCASTING".equals( messageModel ) ) {
            consumer.setMessageModel( MessageModel.BROADCASTING );
            logger.debug( "set consumer message model BROADCASTING" );
        } else {
             if( "CLUSTERING".equals( messageModel ) ) {
                consumer.setMessageModel( MessageModel.CLUSTERING );
                logger.debug( "set consumer message model CLUSTERING" );
            } else {
                logger.debug( "set consumer message model should be BROADCASTING or CLUSTERING" );
                throw new RuntimeException( "set consumer message model should be BROADCASTING or CLUSTERING" );
            }
        }
        /**
         * 订阅指定topic下所有消息<br>
         * 注意：一个consumer对象可以订阅多个topic
         */
        if( handlermap != null && !handlermap.isEmpty() ) {
            for( String topic : handlermap.keySet() ) {
                consumer.subscribe( topic, "*" );
                logger.debug( "consumer subscribe topic " + topic + " *" );
            }
        } else {
            logger.debug( "you should provide at least one message handler." );
            throw new RuntimeException( "you should provide at least one message handler." );
        }
        /**
         * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
         * 如果非第一次启动，那么按照上次消费的位置继续消费
         */
        consumer.setConsumeFromWhere( ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET );
        if( "CONCURRENTLY".equals( messageListener ) ) {
            consumer.registerMessageListener( new MessageListenerConcurrently() {

                /**
                 * 默认msgs里只有一条消息，可以通过设置consumeMessageBatchMaxSize参数来批量接收消息
                 */
                public ConsumeConcurrentlyStatus consumeMessage( final List<MessageExt> msgs, final ConsumeConcurrentlyContext context ) {
                    try {
                        if( msgs != null && !msgs.isEmpty() ) {
                            for( MessageExt msg : msgs ) {
                                logger.debug( String.format( "start consum message: message:id:%s topic:%s tags:%s ", msg.getMsgId(), msg.getTopic(), msg.getTags()) );
                                AbstractConsumer handler = handlermap.get( msg.getTopic() );
                                if( handler != null ) {
                                    handler.handlerMessage( msg );
                                }
                                logger.debug( String.format( "consume message success! message:id:%s topic:%s tags:%s ", msg.getMsgId(), msg.getTopic(), msg.getTags()) );
                            }
                        }
                        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
                    } catch( Exception e ) {
                        logger.error( "consume message error!", e );
                        return ConsumeConcurrentlyStatus.RECONSUME_LATER;
                    }
                }
            } );
        } else
            if( "ORDERLY".equals( messageListener ) ) {
            consumer.registerMessageListener( new MessageListenerOrderly() {

                /**
                 * 默认msgs里只有一条消息，可以通过设置consumeMessageBatchMaxSize参数来批量接收消息
                 */
                public ConsumeOrderlyStatus consumeMessage( final List<MessageExt> msgs, final ConsumeOrderlyContext context ) {
                    try {
                        if( msgs != null && !msgs.isEmpty() ) {
                            for( MessageExt msg : msgs ) {
                                logger.debug( String.format( "start consum message: message:id:%s topic:%s tags:%s message:%s", msg.getMsgId(), msg.getTopic(), msg.getTags(), new String( msg.getBody() ) ) );
                                AbstractConsumer handler = handlermap.get( msg.getTopic() );
                                if( handler != null ) {
                                    handler.handlerMessage( msg );
                                }
                                logger.debug( String.format( "consume message success! message:id:%s topic:%s tags:%s message:%s", msg.getMsgId(), msg.getTopic(), msg.getTags(), new String( msg.getBody() ) ) );
                            }
                        }
                        return ConsumeOrderlyStatus.SUCCESS;
                    } catch( Exception e ) {
                        logger.error( "consume message error!", e );
                        return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
                    }
                }
            } );
        }

        /**
         * Consumer对象在使用之前必须要调用start初始化，初始化一次即可<br>
         */
        consumer.start();
        logger.debug( "consumer start successd!" );
    }

    public void afterPropertiesSet() throws Exception {
        initializingMessageSelector();
    }
    
    public void destroy() throws Exception {
        if (consumer != null) {
            consumer.shutdown();
            logger.debug( "consumer shutdown!" );
        }
    }

    public void setNamesrvAddr( String namesrvAddr ) {
        this.namesrvAddr = namesrvAddr;
    }

    public void setConsumerGroup( String consumerGroup ) {
        this.consumerGroup = consumerGroup;
    }

    public void setMessageModel( String messageModel ) {
        this.messageModel = messageModel;
    }

    public void setMessageListener( String messageListener ) {
        this.messageListener = messageListener;
    }

    public void setHandlermap( Map<String, AbstractConsumer> handlermap ) {
        this.handlermap = handlermap;
    }

    
}

13.LoanRequestConsumer（消费者实现）

package com.nobuy.service.impl.mq;

import com.nobuy.entity.mq.MQEntity;

public class LoanRequestConsumer extends AbstractConsumer {

    @Override
    public void execute(MQEntity entity) {
        System.out.println("LoanRequestConsumer 消费消息");
        System.out.println(entity.toString());
    }

}

14SerializableUtil（工具类）

package com.nobuy.utils.mq;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

/**
 * java的序列化和反序列化
 * 
 * @author Administrator
 */
public class SerializableUtil {

    @SuppressWarnings("unchecked")
    public static <T> T parse(byte[] rec, Class<T> classType) {
        ByteArrayInputStream arrayInputStream = null;
        ObjectInputStream objectInputStream = null;
        try {
            arrayInputStream = new ByteArrayInputStream(rec);
            objectInputStream = new ObjectInputStream(arrayInputStream);
            T t = (T) objectInputStream.readObject();
            return t;
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            closeQuietly(arrayInputStream);
            closeQuietly(objectInputStream);
        }
        return null;
    }

    public static byte[] toByte(Object obj) {
        ByteArrayOutputStream arrayOutputStream = null;
        ObjectOutputStream objectOutputStream = null;
        try {
            arrayOutputStream = new ByteArrayOutputStream();
            objectOutputStream = new ObjectOutputStream(arrayOutputStream);
            objectOutputStream.writeObject(obj);
            objectOutputStream.flush();
            byte[] rtn = arrayOutputStream.toByteArray();
            return rtn;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            closeQuietly(objectOutputStream);
            closeQuietly(arrayOutputStream);
        }
        return null;
    }
    
    public static void closeQuietly(InputStream in){
        if(in!=null){
            try {
                in.close();
            } catch (Exception e) {
            }
        }
    }
    
    public static void closeQuietly(OutputStream out){
        if(out!=null){
            try {
                out.close();
            } catch (Exception e) {
            }
        }
    }
    
    

}

 

15.ProducerTest（生成者test）

package com.nobuy.mq;


import java.math.BigDecimal;
import java.util.Date;

import org.jeecgframework.core.util.ApplicationContextUtil;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;

import com.nobuy.entity.mq.LoanRequest;
import com.nobuy.service.mq.IProducer;
import com.nobuy.service.pay.PayServiceI;


@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(locations = {"classpath*:spring*.xml"})
public class ProducerTest {
    
    @Autowired
    private IProducer producer;

    @Test
    public void testSendMq() {
        LoanRequest loanRequest= new LoanRequest();
        loanRequest.setApplyNo("loan00005432231");
        loanRequest.setCreditNo("credit0000001");
        loanRequest.setEmployeeNo("test1");
        loanRequest.setLendPurpose("test1");
        loanRequest.setLoanCardNo("362226197403220017");
        loanRequest.setBankCode(null);
        loanRequest.setBankName(null);
        loanRequest.setOprTerm("12");
        loanRequest.setPayamt(new BigDecimal(100000));
        loanRequest.setRepayMode("0"); //0   1    2
        loanRequest.setApplyDate(new Date());
        producer.send("loanRequest", loanRequest);
    }
    
}

转载后稍加修改

出自：https://www.cnblogs.com/yun965861480/p/7384915.html

 

路人*
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Rocketmq web控制台
07-19
直接将war包丢到tomcat上，启动tomcat，访问地址为 http://tomcatIP地址:8080/rocketmq-console/cluster/list.do， 将tomcatIP地址替换掉就好了
spring-boot示例项目
03-25
本项目示例基于spring boot 最新版本（2.1.9）实现，Spring Boot、Spring Cloud 学习示例，将持续更新…… 在基于Spring Boot、Spring Cloud 分布微服务开发过程中，根据实际项目环境，需要选择、集成符合项目需求的各种组件和积累各种解决方案。基于这样的背景下，我开源了本示例项目，方便大家快速上手Spring Boot、Spring Cloud 。 每个示例都带有详细的介绍文档、作者在使用过程中踩过的坑、解决方案及参考资料，方便快速上手为你提供学习捷径，少绕弯路，提高开发效率。 有需要写关于spring boot、spring cloud示例，可以给我提issue哦 ## 项目介绍 spring boot demo 是一个Spring Boot、Spring Cloud的项目示例，根据市场主流的后端技术，共集成了30+个demo，未来将持续更新。该项目包含helloworld(快速入门)、web(ssh项目快速搭建）、aop(切面编程)、data-redis(redis缓存)、quartz(集群任务实现)、shiro（权限管理）、oauth2（四种认证模式）、shign(接口参数防篡改重放）、encoder（用户密码设计）、actuator（服务监控）、cloud-config（配置中心）、cloud-gateway（服务网关）、email（邮件发送）、cloud-alibaba（微服务全家桶）等模块 ### 开发环境 - JDK1.8 + - Maven 3.5 + - IntelliJ IDEA ULTIMATE 2019.1 - MySql 5.7 + ### Spring Boot 模块 模块名称|主要内容 ---|--- helloworld|[spring mvc,Spring Boot项目创建,单元测试](https://github.com/smltq/spring-boot-demo/blob/master/helloworld/HELP.md) web|[ssh项目,spring mvc,过滤器,拦截器,监视器,thymeleaf,lombok,jquery,bootstrap,mysql](https://github.com/smltq/spring-boot-demo/blob/master/web/HELP.md) aop|[aop,正则,前置通知,后置通知,环绕通知](https://github.com/smltq/spring-boot-demo/blob/master/aop/HELP.md) data-redis|[lettuce,redis,session redis,YAML配置,连接池,对象存储](https://github.com/smltq/spring-boot-demo/blob/master/data-redis/HELP.md) quartz|[Spring Scheduler,Quartz,分布式调度,集群,mysql持久化等](https://github.com/smltq/spring-boot-demo/blob/master/quartz/HELP.md) shiro|[授权、认证、加解密、统一异常处理](https://github.com/smltq/spring-boot-demo/blob/master/shiro/HELP.md) sign|[防篡改、防重放、文档自动生成](https://github.com/smltq/spring-boot-demo/blob/master/sign/HELP.md) security|[授权、认证、加解密、mybatis plus使用](https://github.com/smltq/spring-boot-demo/blob/master/security/HELP.md) mybatis-plus-generator|[基于mybatisplus代码自动生成](https://github.com/smltq/spring-boot-demo/blob/master/mybatis-plus-generator) mybatis-plus-crud|[基于mybatisplus实现数据库增、册、改、查](https://github.com/smltq/spring-boot-demo/blob/master/mybatis-plus-crud) encoder|[主流加密算法介绍、用户加密算法推荐](https://github.com/smltq/spring-boot-demo/blob/master/encoder/HELP.md) actuator|[autuator介绍](https://github.com/smltq/spring-boot-demo/blob/master/actuator/README.md) admin|[可视化服务监控、使用](https://github.com/smltq/spring-boot-demo/blob/master/admin/README.md) security-oauth2-credentials|[oauth2实现密码模式、客户端模式](https://github.com/smltq/spring-boot-demo/blob/master/security-oauth2-credentials/README.md) security-oauth2-auth-code|[基于spring boot实现oauth2授权模式](https://github.com/smltq/spring-boot-demo/blob/master/security-oauth2-auth-code/README.md) mybatis-multi-datasource|[mybatis、数据库集群、读写分离、读库负载均衡](https://github.com/smltq/spring-boot-demo/blob/master/mybatis-multi-datasource) template-thymeleaf|[thymeleaf实现应用国际化示例](https://github.com/smltq/spring-boot-demo/blob/master/template-thymeleaf) mq-redis|[redis之mq实现，发布订阅模式](https://github.com/smltq/spring-boot-demo/blob/master/mq-redis) email|[email实现邮件发送](https://github.com/smltq/spring-boot-demo/blob/master/email) jGit|[java调用git命令、jgit使用等](https://github.com/smltq/spring-boot-demo/blob/master/jGit) webmagic|[webmagic实现某电影网站爬虫示例](https://github.com/smltq/spring-boot-demo/blob/master/webmagic) netty|[基于BIO、NIO等tcp服务器搭建介绍](https://github.com/smltq/spring-boot-demo/blob/master/netty) ### Spring Cloud 模块 模块名称|主要内容 ---|--- cloud-oauth2-auth-code|[基于spring cloud实现oath2授权模式](https://github.com/smltq/spring-boot-demo/blob/master/cloud-oauth2-auth-code) cloud-gateway|[API主流网关、gateway快速上手](https://github.com/smltq/spring-boot-demo/blob/master/cloud-gateway) cloud-config|[配置中心(服务端、客户端)示例](https://github.com/smltq/spring-boot-demo/blob/master/cloud-config) cloud-feign|[Eureka服务注册中心、负载均衡、声明式服务调用](https://github.com/smltq/spring-boot-demo/blob/master/cloud-feign) cloud-hystrix|[Hystrix服务容错、异常处理、注册中心示例](https://github.com/smltq/spring-boot-demo/blob/master/cloud-hystrix) cloud-zuul|[zuul服务网关、过滤器、路由转发、服务降级、负载均衡](https://github.com/smltq/spring-boot-demo/blob/master/cloud-zuul) cloud-alibaba|[nacos服务中心、配置中心、限流等使用(系列示例整理中...)](https://github.com/smltq/spring-boot-demo/blob/master/cloud-alibaba) #### Spring Cloud Alibaba 模块 模块名称|主要内容 ---|--- nacos|[Spring Cloud Alibaba（一）如何使用nacos服务注册和发现](https://github.com/smltq/spring-boot-demo/blob/master/cloud-alibaba/README1.md) config|[Spring Cloud Alibaba（二）配置中心多项目、多配置文件、分目录实现](https://github.com/smltq/spring-boot-demo/blob/master/cloud-alibaba/README2.md) Sentinel|[Spring Cloud Alibaba（三）Sentinel之熔断降级](https://github.com/smltq/spring-boot-demo/blob/master/cloud-alibaba/README3.md) Dubbo|[Spring Cloud Alibaba（四）Spring Cloud与Dubbo的融合](https://github.com/smltq/spring-boot-demo/blob/master/cloud-alibaba/README4.md) RocketMQ|[Spring Cloud Alibaba（五）RocketMQ 异步通信实现](https://github.com/smltq/spring-boot-demo/blob/master/cloud-alibaba/README5.md) ### 其它 模块名称|主要内容 ---|--- leetcode|[力扣题解目录](https://github.com/smltq/spring-boot-demo/blob/master/leetcode) ## Spring Boot 概述 Spring Boot简化了基于Spring的应用开发，通过少量的代码就能创建一个独立的、产品级别的Spring应用。 Spring Boot为Spring平台及第三方库提供开箱即用的设置，这样你就可以有条不紊地开始。多数Spring Boot应用只需要很少的Spring配置。 Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Sprin
SpringBoot集成rocketmq-client
Lyhdreamer的博客
03-05 559
SpringBoot集成rocketmq-client的生产者和消费者demo
阿里云RocketMQ使用http协议接入
zsj777的专栏
04-24 2066
1、pom <dependency> <groupId>com.aliyun.mq</groupId> <artifactId>mq-http-sdk</artifactId> <!--以下版本号请替换为Java SDK的最新版本号--> <version>1.0.3.2</version>
RocketMQ初识
kitonGao的博客
06-06 243
概念 MQ（Message Queue）：也就是消息队列。主要是为了吧传送的数据放在队列中，通过消息队列来实现消息传递的作用，其中生产者是把消息放入消息队列中，消费者是到指定的队列中拿到消息进行具体处理。 特性 削峰填谷：主要是解决系统瞬间(流量突然变大)时系统写压力大于平时系统的处理能力，导致系统崩溃，消息丢失 系统解耦合：将系统解耦合。不会使系统过分依赖所有业务模块导致系统臃肿，维护困难 提升系统性能：当系统解耦合后，当遇到系统一个系统调用多个系统的时候，可以通过给消息队列发一条消息，再让消息队列通
分布式消息队列RocketMQ(二)：RocketMQ的安装启动&基本概念&系统架构
anndy_的专栏
09-09 478
一、基本概念 官网地址: http://rocketmq.apache.org 1 消息(Message) 消息是指，消息系统所传输信息的物理载体，生产和消费数据的最小单位，每条消息必须属于一个主题。 2 主题(Topic) Topic表示一类消息的集合，每个主题包含若干条消息，每条消息只能属于一个主题，是RocketMQ进行消息订阅的基本单位。 topic:message 1:n message:topic 1:1 一个生产者可以同时发送多种Topic的消息;而一个消费者只对某种特定的Topic感兴趣，即
RocketMQ接入指南
qq_41203483的博客
04-24 4808
RocketMQ接入指南 本篇主要介绍在SpringBoot项目中接入RocketMQ，对于RocketMQ的原理概念请自行了解。 RocketMQ 基本概念可参考： 【https://help.aliyun.com/document_detail/29533.html】【https://blog.csdn.net/qq_21040559/article/details/122703715】 1 对接自己搭建的RocketMQ环境 1、引入maven依赖 <dependency> &lt
RocketMq(二)-访问面板搭建及问题修复
qq_21067307的博客
07-28 1781
RocketMq访问面板及连接异常处理
RocketMq(三)-springboot项目访问
qq_21067307的博客
07-28 568
Springboot项目访问rocketmq
rocketMq 单机及集群搭建，附java连接示例
qq_37519791的博客
05-18 3002
本篇文章搭建环境 centos7、jdk1.8、rocketmq 4.8.0 rocketmq官网地址：http://rocketmq.apache.org/ 一、单机搭建 1.配置host 输入命令查看hostname：hostnamectl 2.vim /etc/hosts 添加配置：192.168.202.221localhost.localdomain 3.解压rocketMQ包放到指定目录下 例如我的存放目录：/opt/rocketMQ/rocketmq-a...
RocketMQ 实战之快速入门
weixin_34055910的博客
07-20 163
2019独角兽企业重金招聘Python工程师标准>>> ...
研究各种Java技术(Springboot+Redis+Dubbo+Rocketmq)
10-06
whatsmars-spring spring原理、集成及新特性 whatsmars-tomcat 模拟tomcat实现 whatsmars-dbrouter 分库分表实现 whatsmars-worker 多实例任务调度 whatsmars-dubbo Dubbo demo whatsmars-mq rocketmq,activemq ...
研究各种Java技术(Springboot+Redis+Dubbo+Rocketmq) 京东技术 www.toutiao.im
09-12
研究各种Java技术(Springboot+Redis+Dubbo+Rocketmq)，地址https://github.com/javahongxi/whatsmars，为maven项目，含如下模块： whatsmars-common mongodb,mail,AES,DES加解密 whatsmars-earth-web springmvc+...
基于springBoot实现的一个分布式电商系统，本科毕业设计，java web全栈开发学习模板
06-19
基于springBoot实现的一个分布式电商系统，开发里程： 4月21日 搭建springBoot平台 4月21日 集成mybatis框架 4月21日 集成mycat数据库中间件 4月22日 后台认证集成shiro,采用单...2月25日 集成RocketMQ实现削峰解耦
ActiveMQ与Tomcat整合
04-17
ActiveMQ与Tomcat整合,提供了详细的配置过程和一个web工程源码
python学习导航.txt
05-06
python
node-v8.3.0-linux-s390x.tar.xz
最新发布
05-06
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
嵌入式微处理器设计及应用
05-06
摘要：为满足智能家居座椅的交互式运动控制需求，基于AT89S52设计了嵌入式座椅运动控制系统。使用VB.net设计了游戏手柄按键读取软件，并在此基础上设计了座椅运动控制软件，软件可分别在“手柄模式”和“鼠标模式”下与嵌入式座椅运动控制器通信，进而控制座椅进行加速、减速、正转和反转等运动；构建了控制系统实验装置，实验结果表明，“鼠标模式”下，通过鼠标点击控制软件上功能按钮可实现对座椅的准确运动控制；“手柄模式”下，游戏手柄不仅可控制座椅运动，还可同步控制电脑上运行的游戏或远程遥控车，实现浸入感较强的座椅运动娱乐应用。
2024年中国NFC RFID阅读器行业研究报告.docx
05-06
2024年中国NFC RFID阅读器行业研究报告
springboot集成rocketmq实战
08-15
要在Spring Boot中集成RocketMQ，您可以按照以下步骤进行操作： 1. 添加RocketMQ依赖：在您的Spring Boot项目的`pom.xml`文件中，添加以下依赖： ```xml <groupId>org.apache.rocketmq <artifactId>rocketmq-...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值