同步索引库分析
方案一：manager中，添加商品的业务逻辑中，添加一个同步索引库的业务逻辑。
缺点：业务逻辑耦合度高，业务拆分不明确
方案二：业务逻辑在search中实现，调用服务在manager实现。业务逻辑分开。
缺点：服务之间的耦合度变高。服务的启动有先后顺序。
方案三：使用消息队列。MQ是一个消息中间件。
ActiveMQ测试方法
把jar包添加到工程中。使用5.11.2版本的jar包
<!-- ActiveMQ客户端依赖的jar包 -->
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-all</artifactId>
</dependency>
Queue
Producer
生产者：生产消息，发送端。
第一步：创建ConnectionFactory对象，需要指定服务端ip及端口号。
第二步：使用ConnectionFactory对象创建一个Connection对象。
第三步：开启连接，调用Connection对象的start方法。
第四步：使用Connection对象创建一个Session对象。
第五步：使用Session对象创建一个Destination对象（topic、queue），此处创建一个Queue对象。
第六步：使用Session对象创建一个Producer对象。
第七步：创建一个Message对象，创建一个TextMessage对象。
第八步：使用Producer对象发送消息。
第九步：关闭资源。
package cn.e3mall.activemq;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;
public class ActiveMqTest {
/**
* 点到点发送消息
*/
@Test
public void testQueueProducer() throws Exception {
// 1.创建一个连接工厂对象, 需要服务的ip及端口号
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.25.3:61616");
// 2.使用工厂对象创建一个Connection对象
Connection connection = connectionFactory.createConnection();
// 3.开启连接,调用Connection对象的start
connection.start();
// 4.创建一个Session对象
// 第一个参数: 是否开启事务, 如果true开启事务, 第二个参数无意义. 一般不开启事务false
// 第二个参数: 应答模式. 自动应答或者手动应答, 一班自动应答.
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 5.使用Session对象创建一个Destination(目的地)对象. 两种形式queue、topic, 现在应该使用queue
Queue queue = session.createQueue("test-queue");
// 6.使用Session对象创建一个Producer(生产者)对象
MessageProducer messageProducer = session.createProducer(queue);
// 7.创建一个Massage对象, 可以使用TextMessage
TextMessage textMessage = session.createTextMessage("hello activemq");
// 8.发送消息
messageProducer.send(textMessage);
// 9.关闭资源
messageProducer.close();
session.close();
connection.close();
}
}
Consumer
消费者：接收消息。
第一步：创建一个ConnectionFactory对象。
第二步：从ConnectionFactory对象中获得一个Connection对象。
第三步：开启连接。调用Connection对象的start方法。
第四步：使用Connection对象创建一个Session对象。
第五步：使用Session对象创建一个Destination对象。和发送端保持一致queue，并且队列的名称一致。
第六步：使用Session对象创建一个Consumer对象。
第七步：接收消息。
第八步：打印消息。
第九步：关闭资源
package cn.e3mall.activemq;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;
public class ActiveMqTest {
@Test
public void testQueueConsumer() throws Exception {
// 创建一个ConnectionFactory对象连接MQ服务器
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.25.3:61616");
// 创建一个连接对象
Connection connection = connectionFactory.createConnection();
// 开启连接
connection.start();
// 使用Connection创建一个Session对象
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 创建一个Destination对象,queue对象
Queue queue = session.createQueue("test-queue");
// 使用Session对象创建一个Consumer(消费者)对象
MessageConsumer messageConsumer = session.createConsumer(queue);
// 接受消息
messageConsumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
// 打印结果
TextMessage textMessage = (TextMessage) message;
String text;
try {
text = textMessage.getText();
System.out.println(text);
} catch (JMSException e) {
e.printStackTrace();
}
}
});
System.out.println("-----queue消费者启动-----");
// 等待接收消息
System.in.read();
// 关闭资源
messageConsumer.close();
session.close();
connection.close();
}
}
消息消费完就没了
Topic
Producer
使用步骤：
第一步：创建ConnectionFactory对象，需要指定服务端ip及端口号。
第二步：使用ConnectionFactory对象创建一个Connection对象。
第三步：开启连接，调用Connection对象的start方法。
第四步：使用Connection对象创建一个Session对象。
第五步：使用Session对象创建一个Destination对象（topic、queue），此处创建一个Topic对象。
第六步：使用Session对象创建一个Producer对象。
第七步：创建一个Message对象，创建一个TextMessage对象。
第八步：使用Producer对象发送消息。
第九步：关闭资源。
package cn.e3mall.activemq;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
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 ActiveMqTest {
@Test
public void testTopicProducer() throws Exception {
// 1.创建一个连接工厂对象, 需要服务的ip及端口号
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.25.3:61616");
// 2.使用工厂对象创建一个Connection对象
Connection connection = connectionFactory.createConnection();
// 3.开启连接,调用Connection对象的start
connection.start();
// 4.创建一个Session对象
// 第一个参数: 是否开启事务, 如果true开启事务, 第二个参数无意义. 一般不开启事务false
// 第二个参数: 应答模式. 自动应答或者手动应答, 一班自动应答.
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 5.使用Session对象创建一个Destination(目的地)对象. 两种形式queue、topic, 现在使用topic
Topic topic = session.createTopic("test-topic");
// 6.使用Session对象创建一个Producer(生产者)对象
MessageProducer messageProducer = session.createProducer(topic);
// 7.创建一个Massage对象, 可以使用TextMessage
TextMessage textMessage = session.createTextMessage("topic message");
// 8.发送消息
messageProducer.send(textMessage);
// 9.关闭资源
messageProducer.close();
session.close();
connection.close();
}
}
Consumer
消费者：接收消息。
第一步：创建一个ConnectionFactory对象。
第二步：从ConnectionFactory对象中获得一个Connection对象。
第三步：开启连接。调用Connection对象的start方法。
第四步：使用Connection对象创建一个Session对象。
第五步：使用Session对象创建一个Destination对象。和发送端保持一致topic，并且话题的名称一致。
第六步：使用Session对象创建一个Consumer对象。
第七步：接收消息。
第八步：打印消息。
第九步：关闭资源
package cn.e3mall.activemq;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;
public class ActiveMqTest {
@Test
public void testTopicConsumer() throws Exception {
// 创建一个ConnectionFactory对象连接MQ服务器
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.25.3:61616");
// 创建一个连接对象
Connection connection = connectionFactory.createConnection();
// 开启连接
connection.start();
// 使用Connection创建一个Session对象
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 创建一个Destination对象,topic对象
Topic topic = session.createTopic("test-topic");
// 使用Session对象创建一个Consumer(消费者)对象
MessageConsumer messageConsumer = session.createConsumer(topic);
// 接受消息
messageConsumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
// 打印结果
TextMessage textMessage = (TextMessage) message;
String text;
try {
text = textMessage.getText();
System.out.println(text);
} catch (JMSException e) {
e.printStackTrace();
}
}
});
System.out.println("-----topic消费者启动-----");
// 等待接收消息
System.in.read();
// 关闭资源
messageConsumer.close();
session.close();
connection.close();
}
}
ActiveMQ整合Spring
发送消息
在manager-service层引入相关的jar包
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
<!-- ActiveMQ客户端依赖的jar包 -->
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-all</artifactId>
</dependency>
配置Activemq整合spring
在manager-service层创建applicationContext-activemq.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
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-4.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">
<!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供 -->
<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://192.168.25.3:61616" />
</bean>
<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
<property name="targetConnectionFactory" ref="targetConnectionFactory" />
</bean>
<!--这个是队列目的地，点对点的 -->
<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg>
<value>spring-queue</value>
</constructor-arg>
</bean>
<!--这个是主题目的地，一对多的 -->
<bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
<constructor-arg value="itemAddtopic" />
</bean>
<bean id="myMessageListener" class="cn.e3mall.search.message.MyMessageListener"></bean>
<!-- 消息监听容器 -->
<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="queueDestination" />
<property name="messageListener" ref="myMessageListener" />
</bean>
<!-- 监听商品添加消息,同步索引库 -->
<bean id="itemAddMessageListener" class="cn.e3mall.search.message.ItemAddMessageListener"></bean>
<!-- 消息监听容器 -->
<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="topicDestination" />
<property name="messageListener" ref="itemAddMessageListener" />
</bean>
</beans>
测试方法
发送消息
第一步：初始化一个spring容器
第二步：从容器中获得JMSTemplate对象
第三步：从容器中获得一个Destination对象
第四步：使用JMSTemplate对象发送消息，需要知道Destination
package cn.e3mall.activemq;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
public class ActiveMqSpring {
@Test
public void sendMessage()throws Exception {
//初始化spring容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-activemq.xml");
//从容其中获得jmsTemplate对象
JmsTemplate jmsTemplate = applicationContext.getBean(JmsTemplate.class);
//从容器中获得一个Destination对象
Destination destination = (Destination) applicationContext.getBean("queueDestination");
//发送消息;
jmsTemplate.send(destination, new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
return session.createTextMessage("send activemq message");
}
});
}
}
接收消息
search-service中接收消息
把Activemq相关的jar包添加到工程中
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
<!-- ActiveMQ客户端依赖的jar包 -->
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-all</artifactId>
</dependency>
配置Activemq和spring整合
在search-service层创建applicationContext-activemq.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
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-4.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">
<!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供 -->
<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://192.168.25.3:61616" />
</bean>
<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
<bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
<!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
<property name="targetConnectionFactory" ref="targetConnectionFactory" />
</bean>
<!--这个是队列目的地，点对点的 -->
<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg>
<value>spring-queue</value>
</constructor-arg>
</bean>
<!--这个是主题目的地，一对多的 -->
<bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
<constructor-arg value="itemAddtopic" />
</bean>
<bean id="myMessageListener" class="cn.e3mall.search.message.MyMessageListener"></bean>
<!-- 消息监听容器 -->
<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="queueDestination" />
<property name="messageListener" ref="myMessageListener" />
</bean>
<!-- 监听商品添加消息,同步索引库 -->
<bean id="itemAddMessageListener" class="cn.e3mall.search.message.ItemAddMessageListener"></bean>
<!-- 消息监听容器 -->
<bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<property name="destination" ref="topicDestination" />
<property name="messageListener" ref="itemAddMessageListener" />
</bean>
</beans>
创建一个MessageListener的实现类
package cn.e3mall.search.message;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
public class MyMessageListener implements MessageListener {
@Override
public void onMessage(Message message) {
//取消息内容
TextMessage textMessage = (TextMessage) message;
try {
String text = textMessage.getText();
System.out.println(text);
} catch (JMSException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
把MessageListener配置到spring容器中,并配置监听容器把MessageListener和connectionFactory整合到一块(前面的spring容器里面已经配置过了)
测试方法
package cn.e3mall.activemq;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MessageConsumer {
@Test
public void msgConsumer() throws Exception{
//初始化sping容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-activemq.xml");
//等待 回车结束
System.in.read();
}
}
再发送一个消息能看到已经接收到消息了
实现添加商品同步索引库
实现流程
mapper
mapper映射文件
<select id="getItemById" parameterType="long" resultType="cn.e3mall.common.pojo.SearchItem">
SELECT
a.id,
a.title,
a.sell_point,
a.price,
a.image,
b. NAME category_name
FROM
tb_item a
LEFT JOIN tb_item_cat b ON a.cid = b.id
WHERE
a.`status` = 1
AND a.id = #{itemId}
</select>
也可以不写service, 我们只需要一个listener做同步
package cn.e3mall.search.message;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
import org.apache.solr.client.solrj.SolrServer;
import org.apache.solr.common.SolrInputDocument;
import org.springframework.beans.factory.annotation.Autowired;
import cn.e3mall.common.pojo.SearchItem;
import cn.e3mall.search.mapper.ItemMapper;
/**
* 监听商品添加消息, 接收消息后,将对应的商品信息同步到索引库
* @author 11501
*
*/
public class ItemAddMessageListener implements MessageListener {
@Autowired
private ItemMapper itemMapper;
@Autowired
private SolrServer solrServer;
@Override
public void onMessage(Message message) {
try {
// 从商品中取商品id
TextMessage textMessage = (TextMessage) message;
String text = textMessage.getText();
Long itemId = new Long(text);
//等待事务提交
Thread.sleep(1000);
// 根据商品id查询商品信息
SearchItem searchItem = itemMapper.getItemById(itemId);
// 创建一个文档对象
SolrInputDocument document = new SolrInputDocument();
// 向文档对象中添加域
document.addField("id", searchItem.getId());
document.addField("item_title", searchItem.getTitle());
document.addField("item_sell_point", searchItem.getSell_point());
document.addField("item_price", searchItem.getPrice());
document.addField("item_image", searchItem.getImage());
document.addField("item_category_name", searchItem.getCategory_name());
// 把文档写入索引库
solrServer.add(document);
// 提交
solrServer.commit();
} catch (Exception e) {
e.printStackTrace();
}
}
}
还是把MessageListener配置到spring容器中, 并配置监听容器把MessageListener和connectionFactory整合到一块(前面的spring容器里面也已经配置过了)
在商品添加service里修改代码
发送消息用到的注解
@Autowired
private JmsTemplate jmsTemplate;
@Resource
private Destination topicDestination;
添加商品是发送消息
@Override
public E3Result addItem(TbItem item, String desc) {
// 生成商品id
final long itemId = IDUtils.genItemId();
// 补全item的属性
item.setId(itemId);
// 1-正常 2-下架 3-删除
item.setStatus((byte) 1);
item.setCreated(new Date());
item.setUpdated(new Date());
// 向商品表插入数据
itemMapper.insert(item);
// 创建一个商品描述表对应的pojo对象
TbItemDesc itemDesc = new TbItemDesc();
// 补全属性
itemDesc.setItemId(itemId);
itemDesc.setItemDesc(desc);
itemDesc.setCreated(new Date());
itemDesc.setUpdated(new Date());
// 向商品描述表插入数据
itemDescMapper.insert(itemDesc);
// 发送商品添加消息
jmsTemplate.send(topicDestination, new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
TextMessage textMessage = session.createTextMessage(itemId + "");
return textMessage;
}
});
// 返回成功
return E3Result.ok();
}
发送消息时事务可能还没有提交, 但这时候消息已经发出去了
消息就会到MessageListener, 这时候取id能取到, 但是去数据库中去查, 会查不到报空指针异常
解决办法, 等待事务提交(前面的代码中已经添加过这个了)
扫一扫
1380
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
