我们在学习Solr索引的时候，每当添加一个商品后，都要把数据库中的数据全部重新导入到索引库，特别消耗性能和时间，这显然是我们所不能忍受的，这就需要优化我们的方案。最好是在商品添加的时候就单独将该商品同步到索引库，这样便简单快捷地实现了数据库与索引库的同步。
摆在我们面前的方案有三个：
方案一：在taotao-manager中，添加商品的业务逻辑中，添加一段同步索引库的业务逻辑。
缺点：很明显，这样会导致业务逻辑耦合度很高，业务拆分不明确，这与我们当初拆分工程，职能单一、明确的原则相违背，故不可采用。
方案二：业务逻辑在taotao-search中实现，调用服务在taotao-manager实现，业务逻辑分开。
缺点：服务与服务之间耦合度变高，服务的启动有先后顺序。服务设计的原则便是各自干各自的活儿，启动要保证互不依赖，服务之间不应该有调用行为，一旦有调用行为，依赖的一方便会因被依赖一方出现故障而无法工作。
方案三：使用消息队列，MQ是一个消息中间件。如下图所示。
怎么理解消息中间件呢？我们可以把它理解为一个秘书，消息的发布者就是大老板，大老板下午三点要开个会，他只需跟秘书说一声，下午三点，我要开个会，就行了，老板不用管秘书是怎样通知各项目经理的，也不用管项目经理要带什么材料，他所做的只是告诉秘书一声而已。秘书负责与各个项目经理联系，告诉各个项目经理应该准备什么。MQ便相当于"秘书"这个角色。当添加一个商品时，商品服务只需要告诉消息中间件MQ，MQ便去通知其它服务做各自该做的事情，比如通知搜索服务去同步索引库，通知redis服务去同步缓存，通知生成静态页面等等。
ActiveMQ的消息形式
对于消息的传递有两种类型：
一种是点对点的，即一个生产者和一个消费者一一对应；
另一种是发布/订阅模式，即一个生产者产生消息并进行发送后，可以由多个消费者进行接收。
JMS定义了五种不同的消息正文格式，以及调用的消息类型，允许你发送并接收以一些不同形式的数据，提供现有消息格式的一些级别的兼容性。我们用的最多的也就是TextMessage而已。
· StreamMessage – Java原始值的数据流
· MapMessage–一套名称-值对
· TextMessage–一个字符串对象
· ObjectMessage–一个序列化的 Java对象
· BytesMessage–一个字节的数据流
我们可以通过下面一张图来加深理解，图上半部分是"发布/订阅者"模式，两个发布者各自发布了一条消息，每条消息都可以被多个Consumer接收到。图下半部分是"面对面"模式，两个发布者各自发布了一条消息，压入队列当中，队列的特点是先进先出，一旦有某个消费者拿走了一条消息，队列中就少了一条消息，剩下的消费者就不可能再消费那条消息了，因此也就做到了一对一。
ActiveMQ的安装请详见 https://blog.csdn.net/u012453843/article/details/71305235
测试demo
创建JMS-ActiveMQ工程
添加maven依赖：
3.1点对点消息
在点对点或队列模型下，一个生产者向一个特定的队列发布消息，一个消费者从该队列中读取消息。这里，生产者知道消费者的队列，并直接将消息发送到消费者的队列。这种模式被概括为：
• 只有一个消费者将获得消息
• 生产者不需要在接收者消费该消息期间处于运行状态，接收者也同样不需要在消息发送时处于运行状态。
• 每一个成功处理的消息都由接收者签收
①创建消息生产者
package com.meiyou.test.activemq;
import java.io.IOException;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;
public class TestActiveMQ {
@Test
public void producer() throws JMSException{
//1.创建ConnectionFactory 连接工厂
String brokerUrl = "tcp://192.168.25.128:61616";
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(brokerUrl);
//2.创建Connection 连接对象
Connection connection = connectionFactory.createConnection();
//开启连接
connection.start();
//3.使用Connection对象创建一个Session对象,创建Session事务管理，通过参数设置事务级别
//第一个参数是是否开启事务，一般不使用分布式事务，因为它特别消耗性能，而且顾客体验特别差，现在互联网的
//做法是保证数据的最终一致（也就是允许暂时数据不一致），比如顾客下单购买东西，一旦订单生成完就立刻响应给用户
//下单成功。至于下单后一系列的操作，比如通知会计记账、通知物流发货、商品数量同步等等都先不用管，只需要
//发送一条消息到消息队列，消息队列来告知各模块进行相应的操作，一次告知不行就两次，直到完成所有相关操作为止，这
//也就做到了数据的最终一致性。如果第一个参数为true，那么第二个参数将会被忽略掉。如果第一个参数为false，那么
//第二个参数为消息的应答模式，常见的有手动和自动两种模式，我们一般使用自动模式。
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//4.创建Destination 目的地对象
Destination destination = session.createQueue("luo-message");
//5.创建消息的生产者
MessageProducer messageProducer = session.createProducer(destination);
//6.创建一条消息
TextMessage textMessage = session.createTextMessage("测试-消息生产者");
//7.发送消息
messageProducer.send(textMessage);
//提交事务
//session.commit();
//8.释放资源
messageProducer.close();
session.close();
connection.close();
}
}
②创建消息消费者
package com.meiyou.test.activemq;
import java.io.IOException;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;
public class TestActiveMQ {
@Test
public void consumer() throws JMSException, IOException{
//1.创建ConnectionFactory连接工厂
String brokerUrl = "tcp://192.168.25.128:61616";
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(brokerUrl);
//2.创建Connection
Connection connection = connectionFactory.createConnection();
connection.start();
//3.使用Connection对象创建一个Session对象,创建Session事务管理，通过参数设置事务级别
//第一个参数是是否开启事务，一般不使用分布式事务，因为它特别消耗性能，而且顾客体验特别差，现在互联网的
//做法是保证数据的最终一致（也就是允许暂时数据不一致），比如顾客下单购买东西，一旦订单生成完就立刻响应给用户
//下单成功。至于下单后一系列的操作，比如通知会计记账、通知物流发货、商品数量同步等等都先不用管，只需要
//发送一条消息到消息队列，消息队列来告知各模块进行相应的操作，一次告知不行就两次，直到完成所有相关操作为止，这
//也就做到了数据的最终一致性。如果第一个参数为true，那么第二个参数将会被忽略掉。如果第一个参数为false，那么
//第二个参数为消息的应答模式，常见的有手动和自动两种模式，我们一般使用自动模式。
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//4.创建Destination 目的地对象
Destination destination = session.createQueue("luo-message");
//5.创建消费者
MessageConsumer messageConsumer = session.createConsumer(destination);
//6.消费消息，监听队列中的消息，若有新消息，会执行onMessage方法
messageConsumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
TextMessage textMessage = (TextMessage) message;
try {
System.out.println("消息："+textMessage.getText());
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
//避免单元测试停止
//程序等待接收用户结束操作
//程序自己并不知道什么时候有消息，也不知道什么时候不再发送消息了，这就需要手动干预，
//当我们想停止接收消息时，可以在控制台输入任意键，然后回车即可结束接收操作（也可以直接按回车）。
System.in.read();
//7.释放资源
messageConsumer.close();
session.close();
connection.close();
}
}
3.2发布/订阅 消息
发布者／订阅者模型支持向一个特定的消息主题发布消息。0或多个订阅者可能对接收来自特定消息主题的消息感兴趣。在这种模型下，发布者和订阅者彼此不知道对方。这种模式被概括为：
• 多个消费者可以获得消息
• 在发布者和订阅者之间存在时间依赖性。发布者需要建立一个订阅（subscription），以便客户能够购订阅。订阅者必须保持持续的活动状态以接收消息。
与发送队列消息唯一不同的地方
消息发布者：
package com.meiyou.test.activemq;
import java.io.IOException;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;
public class TestActiveMQ {
@Test
public void testTopicProducer() throws JMSException{
//1.创建一个连接工厂对象ConnectionFactory对象。需要指定mq服务的ip及端口号。注意参数brokerURL的开头是
//tcp://而不是我们通常的http://，端口是61616而不是我们访问activemq后台管理页面所使用的8161
String brokerUrl = "tcp://192.168.25.128:61616";
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(brokerUrl);
//2.使用ConnectionFactory创建一个连接Connection对象
Connection connection = connectionFactory.createConnection();
//3.开启连接。调用Connection对象的start方法
connection.start();
//4.使用Connection对象创建一个Session对象
//第一个参数是是否开启事务，一般不使用分布式事务，因为它特别消耗性能，而且顾客体验特别差，现在互联网的
//做法是保证数据的最终一致（也就是允许暂时数据不一致），比如顾客下单购买东西，一旦订单生成完就立刻响应给用户
//下单成功。至于下单后一系列的操作，比如通知会计记账、通知物流发货、商品数量同步等等都先不用管，只需要
//发送一条消息到消息队列，消息队列来告知各模块进行相应的操作，一次告知不行就两次，直到完成所有相关操作为止，这
//也就做到了数据的最终一致性。如果第一个参数为true，那么第二个参数将会被忽略掉。如果第一个参数为false，那么
//第二个参数为消息的应答模式，常见的有手动和自动两种模式，我们一般使用自动模式。
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5.使用Session对象创建一个Destination对象，两种形式queue、topic。现在我们使用topic
//参数就是消息队列的名称
Topic topic = session.createTopic("luo-topic");
//6.使用Session对象创建一个Producer对象
MessageProducer producer = session.createProducer(topic);
//7.创建一个TextMessage对象
TextMessage textMessage = session.createTextMessage("hello,activemq topic");
//8.发送消息
producer.send(textMessage);
//9.关闭资源
producer.close();
session.close();
connection.close();
}
}
运行上面的测试方法，运行成功后，我们访问activemq的管理后台页面，点击"Topics"，可以看到有"luo-topic"这一行，压入消息队列一条消息，但由于没有消费者，因此没有消费掉该消息。
消息订阅者：
package com.meiyou.test.activemq;
import java.io.IOException;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;
public class TestActiveMQ {
@Test
public void testTopicConsumer() throws Exception{
//1.创建一个连接工厂对象ConnectionFactory对象。需要指定mq服务的ip及端口号。注意参数brokerURL的开头是
//tcp://而不是我们通常的http://，端口是61616而不是我们访问activemq后台管理页面所使用的8161
String brokerUrl = "tcp://192.168.25.128:61616";
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(brokerUrl);
//2.使用ConnectionFactory创建一个连接Connection对象
Connection connection = connectionFactory.createConnection();
//3.开启连接。调用Connection对象的start方法
connection.start();
//4.使用Connection对象创建一个Session对象
//第一个参数是是否开启事务，一般不使用分布式事务，因为它特别消耗性能，而且顾客体验特别差，现在互联网的
//做法是保证数据的最终一致（也就是允许暂时数据不一致），比如顾客下单购买东西，一旦订单生成完就立刻响应给用户
//下单成功。至于下单后一系列的操作，比如通知会计记账、通知物流发货、商品数量同步等等都先不用管，只需要
//发送一条消息到消息队列，消息队列来告知各模块进行相应的操作，一次告知不行就两次，直到完成所有相关操作为止，这
//也就做到了数据的最终一致性。如果第一个参数为true，那么第二个参数将会被忽略掉。如果第一个参数为false，那么
//第二个参数为消息的应答模式，常见的有手动和自动两种模式，我们一般使用自动模式。
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//5.使用Session对象创建一个Destination对象，两种形式queue、topic。现在我们使用queue
//参数就是消息队列的名称
Topic topic = session.createTopic("luo-topic");
//6.使用Session对象创建一个Consumer对象
MessageConsumer consumer = session.createConsumer(topic);
//7.向Consumer对象中设置一个MessageListener对象，用来接收消息
consumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
if(message instanceof TextMessage) {
TextMessage textMessage = (TextMessage)message;
try {
String text = textMessage.getText();
System.out.println(text);
} catch (JMSException e) {
e.printStackTrace();
}
}
}
});
//8.程序等待接收用户结束操作
//程序自己并不知道什么时候有消息，也不知道什么时候不再发送消息了，这就需要手动干预，
//当我们想停止接收消息时，可以在控制台输入任意键，然后回车即可结束接收操作（也可以直接按回车）。
System.out.println("topic消费者4444444。。。。。");
System.in.read();
//9.关闭资源
consumer.close();
session.close();
connection.close();
}
}
我们运行上面的方法，会看到控制台输出"topic消费者1111。。。。。"，为了模仿多个消费者，我们修改输出信息为"22222。。。。。"，然后再运行该方法，从而增加一个消费者，然后再修改输出信息为"3333。。。。。"，再运行该方法，就会再增加一个消费者，从而现在有三个消费者。如下图所示。
启动了三个消费者后，我们再发送一次topic消息，发完之后，我们看各个控制台的信息。如下图所示。可以看到都打印出了我们发送的topic信息。
827
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
