关于开发中系统之间耦合度高、业务拆分不明确等问题的解决方案！
开发中遇到问题，向前辈请教以后整理了一下。
1消息中间件
1.1目前我自己开发的项目系统中存在的问题
- 服务和服务之间的耦合度很高；商品审核时需要生成静态页面，需要更新索引库
- 业务拆分不明确，服务之间的先后顺序变的复杂。
- 不利于系统的维护和扩展
使用MQ（消息队列/消息中间件来解决这个问题）
1.2什么是消息中间件（MQ）
MQ ：Message Queue （消息队列），它是一种实现系统和系统之间进行通信的一种技术解决方案，用来解决我们在系统开发过程中的存在的一些问题的。
- 实现跨平台的系统通信
- 减低系统之间的耦合（主要）
- 有利于升级和扩展维护
1.3常见的消息中间的产品
（1）ActiveMQ
ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现
ActiveMQ 是apache出品的一个实现了JMS规范的MQ的其中一个产品.主要是用于消息发送和接收来实现系统之间的通信。
在易用性、扩展性、表现不错，并且有详尽官方的文档和相关支持。
（2）RabbitMQ
RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现。
AMQP ：Advanced Message Queue，高级消息队列协议。它是应用层协议的一个开放标准，为面向消息的中间件设计，基于此协议的客户端与消息中间件可传递消息，并不受产品、开发语言等条件的限制。
在易用性、扩展性、高可用性等方面表现不俗。
（3）RocketMq
RcoketMQ 是一款阿里巴巴开源的低延迟、高可靠、可伸缩、易于使用的消息中间件产品,目前已贡献给了apache。它具有以下特点：
- 能够保证严格的消息顺序
- 提供丰富的消息拉取模式
- 高效的订阅者水平扩展能力
- 实时的消息订阅机制
- 亿级消息堆积能力
（4）Kafka
Apache下的一个子项目 。
特点：高吞吐，在一台普通的服务器上既可以达到10W/s的吞吐速率；完全的分布式系统。适合处理海量数据。
1.4解决问题的基本思想架构图
用我自己的一部分代码展示具体的解决步骤。
2RocketMQ介绍
2.1什么是RocketMQ
RocketMQ作为一款阿里开源的纯java、分布式、队列模型的开源消息中间件，支持事务消息、顺序消息、批量消息、定时消息、消息回溯等。
2.2 NameServer集群
NameServer的作用是注册中心，类似于Zookeeper。每个NameServer节点互相之间是独立的，没有任何信息交互,NameServer是一个几乎无状态的节点，可集群部署。
2.3 Broker集群
Broker部署相对复杂，Broker分为Master与Slave，一个Master可以对应多个Slaver，但是一个Slaver只能对应一个Master，Master与Slaver的对应关系通过指定相同的BrokerName，不同的BrokerId来定义，BrokerId为0表示Master，非0表示Slaver。Master可以部署多个。每个Broker与NameServer集群中的所有节点建立长连接，定时注册Topic信息到所有的NameServer。
Master和slave之间的同步方式分为同步双写和异步复制，异步复制方式master和slave之间虽然会存在少量的延迟，但性能较同步双写方式要高出10%左右
2.4 Producer集群
2.4.1 与nameserver的关系
单个Producer和一台nameserver保持长连接，定时查询topic配置信息，如果该nameserver挂掉，生产者会自动连接下一个nameserver，直到有可用连接为止，并能自动重连。与nameserver之间没有心跳。
2.4.2 与broker的关系
单个Producer和与其关联的所有broker保持长连接，并维持心跳。默认情况下消息发送采用轮询方式，会均匀发到对应Topic的所有queue中。
2.5 Consumer集群
2.5.1 与nameserver的关系
单个Consumer和一台nameserver保持长连接，定时查询topic配置信息，如果该nameserver挂掉，消费者会自动连接下一个nameserver，直到有可用连接为止，并能自动重连。与nameserver之间没有心跳。
2.5.2 与broker的关系
单个Consumer和与其关联的所有broker保持长连接，并维持心跳，失去心跳后，则关闭连接，并向该消费者分组的所有消费者发出通知，分组内消费者重新分配队列继续消费。
2.6 消费模式
消费模式 指的是 消费者方使用何种方式进行消费
2.6.1 集群模式
在默认情况下，就是集群消费，此时消息发出去后将只有一个消费者集群中，只有一个消费者能获取消息。
2.6.2 广播模式
另一种消费模式，是广播消费。广播消费，消费者组中的每一个消费者都可以获取消息进行消费。
3spring 整合Rocketmq
3.1生产者方
加入spring的依赖和rocketmq的依赖：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>youhuo-parent</artifactId>
<groupId>com.youhuo</groupId>
<version>1.0-SNAPSHOT</version>
<relativePath>../youhuo-parent/pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>youhuo-rokectmq-producer</artifactId>
<name>youhuo-rokectmq-producer</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-client</artifactId>
<version>${rocketmq-version}</version>
</dependency>
</dependencies>
</project>
创建spring-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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--消息生产者-->
<bean class="org.apache.rocketmq.client.producer.DefaultMQProducer" id="defaultMQProducer" init-method="start" destroy-method="shutdown">
<property name="namesrvAddr" value="127.0.0.1:9876"></property>
<property name="producerGroup" value="producer_spring_group1"></property>
</bean>
</beans>
测试：
package com.youhuo;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
@ContextConfiguration("classpath:spring-producer.xml")
@RunWith(SpringRunner.class)
public class AppTest {
@Autowired
private DefaultMQProducer producer;
//发送消息
@Test
public void sendMessage() throws Exception{
byte[] bytes = new String ("nihao").getBytes();
Message message = new Message("springTopic","TagA",bytes);
SendResult result = producer.send(message);
System.out.println(result.getMsgId()+">>>>"+result.getSendStatus()+";>>>");
Thread.sleep(10000);
}
}
3.2消费者方
加入spring的依赖和rocketmq的依赖：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>youhuo-parent</artifactId>
<groupId>com.youhuo</groupId>
<version>1.0-SNAPSHOT</version>
<relativePath>../youhuo-parent/pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>youhuo-rokectmq-producer</artifactId>
<name>youhuo-rokectmq-producer</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-client</artifactId>
<version>${rocketmq-version}</version>
</dependency>
</dependencies>
</project>
创建spring-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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="org.apache.rocketmq.client.consumer.DefaultMQPushConsumer" id="defaultMQPushConsumer" init-method="start" destroy-method="shutdown">
<property name="namesrvAddr" value="127.0.0.1:9876"></property>
<!--消费模式 默认还是集群模式，此处可以不配置-->
<property name="messageModel" value="CLUSTERING"></property>
<property name="subscription">
<map>
<!--订阅springTopic主题，消费所有的Tag-->
<entry key="springTopic" value="*"></entry>
</map>
</property>
<!--消费者组-->
<property name="consumerGroup" value="consumer_spring_group1"></property>
<!--设置消费者监听器-->
<property name="messageListener" ref="messageListener"></property>
</bean>
<bean class="com.youhuo.listener.MyMessageListener" id="messageListener"></bean>
</beans>
创建监听器类
package com.youhuo.listener;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.message.MessageExt;
import java.util.List;
/**
* 描述
*
* @author 三国的包子
* @version 1.0
* @package com.youhuo.listener *
* @since 1.0
*/
public class MyMessageListener implements MessageListenerConcurrently {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
System.out.println("Receive New Messages:"+Thread.currentThread().getName());
if(msgs!=null){
for (MessageExt msg : msgs) {
System.out.println("mssageid===>"+msg.getMsgId()+"====>"+new String(msg.getBody())+"=====>>"+msg.getTags());
}
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
return ConsumeConcurrentlyStatus.RECONSUME_LATER;
}
}
编写测试类：
package com.youhuo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
/**
* Unit test for simple App.
*/
@ContextConfiguration("classpath:spring-consumer.xml")
@RunWith(SpringRunner.class)
public class AppTest {
@Test
public void consumer() throws Exception{
Thread.sleep(1000000);
}
}
如果是广播模式：此处修改为下图即可：
4.商品审核及删除使用RocketMQ
4.1需求分析
当运营商进行审核商品或者删除商品的时候，需要发送消息，进行商品的索引更新，静态页的生成。
思路入下图：
发送消息 消息本身的内容包含要操作的类型：比如是删除 还是更新 还是添加 以及包含消息的主题 标签 和消息的关键字等信息。
接收消息 接收消息方，会根据接收到的消息的操作类型分别来进行消息的消费。
4.2创建消息实体对象
在youhuo-common中添加依赖：
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-client</artifactId>
<version>${rocketmq-version}</version>
</dependency>
在youhuo-common的工程中创建类 ：
package com.youhuo.common.pojo;
/**
* 描述
*
* @author 三国的包子
* @version 1.0
* @package com.youhuo.common.pojo *
* @since 1.0
*/
public class MessageInfo<T>{
public static final int METHOD_ADD=1;//用于新增 操作
public static final int METHOD_UPDATE=2;//用于更新 操作
public static final int METHOD_DELETE=3;//用于删除 操作
//要发送的内容
private Object context;
private String topic;
private String tags;
private String keys;
private int method;//要执行的方法
public MessageInfo() {
}
public MessageInfo(String topic, String tags, String keys, Object context, int method) {
this.context = context;
this.topic = topic;
this.tags = tags;
this.keys = keys;
this.method = method;
}
public MessageInfo(String topic, String tags, Object context, int method) {
this.context = context;
this.topic = topic;
this.tags = tags;
this.method = method;
}
public Object getContext() {
return context;
}
public void setContext(Object context) {
this.context = context;
}
public String getTopic() {
return topic;
}
public void setTopic(String topic) {
this.topic = topic;
}
public String getTags() {
return tags;
}
public void setTags(String tags) {
this.tags = tags;
}
public String getKeys() {
return keys;
}
public void setKeys(String keys) {
this.keys = keys;
}
public int getMethod() {
return method;
}
public void setMethod(int method) {
this.method = method;
}
}
4.3 生产者方开发
在youhuo-manager-web项目中 它就是生产者
(1)创建spring-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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="org.apache.rocketmq.client.producer.DefaultMQProducer" id="defaultMQProducer" init-method="start" destroy-method="shutdown">
<property name="namesrvAddr" value="127.0.0.1:9876"></property>
<property name="producerGroup" value="producer_manager_web_group"></property>
</bean>
</beans>
(2)springmvc.xml中引入：
<import resource="spring-producer.xml"></import>
修改goodsController类：
（1） 审核商品 时发送消息
@Autowired
private DefaultMQProducer producer;
@RequestMapping("/updateStatus/{status}")
public Result updateStatus(@RequestBody Long[] ids, @PathVariable(value="status") String status){
try {
goodsService.updateStatus(ids,status);
if("1".equals(status)){
List<TbItem> tbItemListByIds = goodsService.findTbItemListByIds(ids);
MessageInfo messageInfo = new MessageInfo("Goods_Topic","goods_update_tag","updateStatus",tbItemListByIds,MessageInfo.METHOD_UPDATE);
SendResult send = producer.send(new Message(messageInfo.getTopic(), messageInfo.getTags(), messageInfo.getKeys(), JSON.toJSONString(messageInfo).getBytes()));
System.out.println(">>>>"+send.getSendStatus());
//itemSearchService.updateIndex(tbItemListByIds);
}
return new Result(true,"更新成功");
} catch (Exception e) {
e.printStackTrace();
return new Result(false,"更新失败");
}
}
（2）删除商品时 发送消息
@RequestMapping("/delete")
public Result delete(@RequestBody Long[] ids){
try {
goodsService.delete(ids);
MessageInfo messageInfo = new MessageInfo("Goods_Topic","goods_delete_tag","delete",ids,MessageInfo.METHOD_DELETE);
producer.send(new Message(messageInfo.getTopic(),messageInfo.getTags(),messageInfo.getKeys(), JSON.toJSONString(messageInfo).getBytes()));
//itemPageService.delete(ids);
return new Result(true, "删除成功");
} catch (Exception e) {
e.printStackTrace();
return new Result(false, "删除失败");
}
}
4.4 消费者方开发
4.4.1 搜索工程
在youhuo-search-service项目中 创建applicationContext-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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="org.apache.rocketmq.client.consumer.DefaultMQPushConsumer" id="defaultMQPushConsumer" init-method="start" destroy-method="shutdown">
<property name="namesrvAddr" value="127.0.0.1:9876"></property>
<property name="consumerGroup" value="consumer_search_group"></property>
<!--集群模式-->
<property name="messageModel" value="CLUSTERING"></property>
<property name="subscription">
<map>
<!--key:就是topic value就是标签-->
<entry key="Goods_Topic" value="*"></entry>
</map>
</property>
<property name="messageListener" ref="messageListener"></property>
</bean>
<bean class="com.youhuo.search.listener.GoodsMessageListener" id="messageListener"></bean>
</beans>
在applicationContext-service.xml中引入：
<import resource="applicationContext-consumer.xml"></import>
创建监听器类：
package com.youhuo.search.listener;
import com.alibaba.fastjson.JSON;
import com.youhuo.common.pojo.MessageInfo;
import com.youhuo.pojo.TbItem;
import com.youhuo.search.service.ItemSearchService;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.message.MessageExt;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/**
* 描述
*
* @author 三国的包子
* @version 1.0
* @package com.youhuo.search.listener *
* @since 1.0
*/
public class GoodsMessageListener implements MessageListenerConcurrently {
@Autowired
private ItemSearchService dao;
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
System.out.println(">>>>>>>>>>>>>>>>>>接收数据");
try {
if(msgs!=null){
for (MessageExt msg : msgs) {
byte[] body = msg.getBody();
String s = new String(body);
MessageInfo messageInfo = JSON.parseObject(s, MessageInfo.class);
switch (messageInfo.getMethod()){
case 1://新增
{
String context1 = messageInfo.getContext().toString();//获取到的是字符串
List<TbItem> tbItems = JSON.parseArray(context1, TbItem.class);
dao.updateIndex(tbItems);
break;
}
case 2://更新
{
String context1 = messageInfo.getContext().toString();//获取到的是字符串
List<TbItem> tbItems = JSON.parseArray(context1, TbItem.class);
dao.updateIndex(tbItems);
break;
}
case 3://删除
String s1 = messageInfo.getContext().toString();
Long[] longs = JSON.parseObject(s1, Long[].class);
dao.deleteByIds(longs);
break;
default:
break;
}
}
}
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ConsumeConcurrentlyStatus.RECONSUME_LATER;
}
}
}
4.4.2 静态化服务工程
创建applicationContext-conumser.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="org.apache.rocketmq.client.consumer.DefaultMQPushConsumer" init-method="start" destroy-method="shutdown">
<property name="namesrvAddr" value="127.0.0.1:9876"></property>
<property name="consumerGroup" value="consmer_page_group"></property>
<!--广播的模式 可以多个消费者一起消费一个消息 ，也就是说一个消费者可以被多个消费者消费-->
<property name="messageModel" value="BROADCASTING"></property>
<property name="subscription">
<map>
<!--主题 goods_topic 下的所有的tag的消息-->
<entry key="Goods_Topic" value="*"></entry>
</map>
</property>
<property name="messageListener" ref="messageListener"></property>
</bean>
<!--监听器 对象 用于监听消息 获取消息内容进行相关的操作-->
<bean class="com.youhuo.page.listener.PageMessageListener" id="messageListener"></bean>
</beans>
创建监听类：
package com.youhuo.page.listener;
import com.alibaba.fastjson.JSON;
import com.youhuo.common.pojo.MessageInfo;
import com.youhuo.page.service.ItemPageService;
import com.youhuo.pojo.TbItem;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.message.MessageExt;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* 描述
*
* @author 三国的包子
* @version 1.0
* @package com.youhuo.page.listener *
* @since 1.0
*/
public class PageMessageListener implements MessageListenerConcurrently {
@Autowired
private ItemPageService itemPageService;
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
System.out.println(">>>>当前的线程>>>>" + Thread.currentThread().getName());
try {
if (msgs != null)
for (MessageExt msg : msgs) {
byte[] body = msg.getBody();
MessageInfo info = JSON.parseObject(body, MessageInfo.class);
switch (info.getMethod()) {
case MessageInfo.METHOD_ADD: //新增
{
updatePageHtml(info);
break;
}
case MessageInfo.METHOD_UPDATE: //更新
{
updatePageHtml(info);
break;
}
case MessageInfo.METHOD_DELETE: //删除
{
String s = info.getContext().toString();
//获取Long数组
Long[] longs = JSON.parseObject(s, Long[].class);
itemPageService.deleteById(longs);
break;
}
default:
break;
}
}
//直接返回消费成功,如果消费失败 就是消费延迟 会重新发送消息。
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
//直接返回消费成功,如果消费失败 就是消费延迟 会重新发送消息。
return ConsumeConcurrentlyStatus.RECONSUME_LATER;
}
}
private void updatePageHtml(MessageInfo info) {
String context1 = info.getContext().toString();//获取到的是Map对象 并不能直接序列化回来 需要直接转成字符串
List<TbItem> tbItems = JSON.parseArray(context1, TbItem.class);
Set<Long> set = new HashSet<>();
for (TbItem tbItem : tbItems) {
//循环遍历进行生成静态页面。
set.add(tbItem.getGoodsId());
}
//循环遍历 生成静态页面
for (Long aLong : set) {
itemPageService.genhtml(aLong);
}
return;
}
}
4.5 删除静态页面接口开发
由于需要删除静态页面，还没有接口方法定义。我们定义一个方法并实现删除的逻辑
（1）创建接口的方法如图
代码如下：
public interface ItemPageService {
public void genItemHtml(Long longs);
public void deleteById(Long[] longs);
}
(2)实现接口的方法 删除静态页，如图：
代码如下：
@Override
public void deleteById(Long[] longs) {
try {
for (Long aLong : longs) {
FileUtils.forceDelete(new File("E:\\code\\freemarker\\" + aLong + ".html"));
}
} catch (IOException e) {
e.printStackTrace();
}
}
5.移除依赖
至此，我们通过消息中间件的方式，将系统进行解耦了。所以youhuo-manager-web中的引入page项目和search项目的依赖可以移除掉了。
这样就能够解决系统之间的通信问题！解除系统之间的耦合、利于系统扩展、维护。
扫一扫
1527
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
