Springboot 整合 jna 对接dll springboot jms

一、同步

1.创建springboot的生产者

1>创建module的springboot项目(选择Spring Initializr)

2>添加依赖: 

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-pool</artifactId>
</dependency>

3>配置:application.properties

#配置连接url
spring.activemq.broker-url=tcp://localhost:61616
#配置目的地
spring.jms.template.default-destination=springQueue

4>创建相关实现接口和类

4.1>创建controller

@RestController
public class MessageController {
    @Autowired
    private MessageService messageService;
    @RequestMapping("/send/message")
    public String sendMessage(){
        String message = "springboot集成activeMQ发送消息";
        messageService.sendMessage(message);
        return "OK";
    }
}
4.2>创建service

public interface MessageService {
    public void sendMessage(String message);
}

@Service
public class MessageServiceImpl implements MessageService {
    @Autowired
    private MessageDao messageDao;
    @Override
    public void sendMessage(String message) {
        messageDao.sendMessage(message);
    }
}
4.3>创建dao

public interface MessageDao {
    public void sendMessage(String message);
}

@Repository
public class MessageDaoImpl implements MessageDao {
    @Autowired
    private JmsTemplate jmsTemplate;
    @Override
    public void sendMessage(final String message) {
        jmsTemplate.send(new MessageCreator() {
            @Override
            public Message createMessage(Session session) throws JMSException {
                System.out.println("create message");
                return session.createTextMessage(message);
            }
        });
    }
}
5>Application项目启动
页面访问http://localhost:8080/send/message 页面弹出OK,查看http://localhost:8161观察springQueue的消息情况
2.创建springboot的消费者
1>添加依赖

<!--添加springboot对应的activemq的依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>
2>配置application.properties

#配置连接url
spring.activemq.broker-url=tcp://localhost:61616
#配置目的地
spring.jms.template.default-destination=springQueue
3>创建相关实现接口和类
3.1>controller

@RestController
public class MessageController {
    @Autowired
    private MessageService messageService;
    @RequestMapping("/receive/message")
    public String receive(){
        return messageService.receive();
    }
}
3.2>service

public interface MessageService {
    public String receive();
}

@Service
public class MessageServiceImpl implements MessageService {
    @Autowired
    private MessageDao messageDao;
    @Override
    public String receive() {
        return messageDao.receive();
    }
}
3.3>dao

public interface MessageDao {
    public String receive();
}

@Repository
public class MessageDaoImpl implements MessageDao {
    @Autowired
    private JmsTemplate jmsTemplate;
    @Override
    public String receive() {
        Message message = jmsTemplate.receive();
        if (message instanceof TextMessage){
            try {
                return  ((TextMessage) message).getText();
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
        return "";
    }
}
4>启动Application类，访问http://localhost:8080/receive/message，页面弹出收到的消息springboot集成activeMQ发送消息，访问http://localhost:8161/admin/queues.jsp，消息信息发生变化
二、异步
实现异步方式一:
1.创建生产者同同步模式一致<因为同步异步只是针对消费者>
2.创建消费者
1>创建maven项目springInitiziler
2>添加依赖

<!--添加springboot对应的activemq的依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>
3>配置application.properties

server.port=9090
#配置连接url
spring.activemq.broker-url=tcp://localhost:61616
#配置目的地
spring.jms.template.default-destination=springQueue
4>创建监听器类

@Component
public class MessageListener {
@JmsListener(destination="${spring.jms.template.default-destination}")
    public void asynReceiveMessage(Message message){
        if(message instanceof Message){
            try {
                String text = ((TextMessage)message).getText();
                System.out.println(text);
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }
}
运行生产者和消费者发现是异步进行的

实现异步方式二:
实现消费者
1.创建maven项目springboot
2.添加依赖
3.配置application.properties文件
4.创建实现类

@Configuration
public class ActiveMQConfig {
    @Value("${spring.jms.template.default-destination}")
    private String defaultDestinationName;
    /**
     * springboot自动初始化的,不用创建
     */
    @Autowired
    public ActiveMQConnectionFactory activeMQConnectionFactory;
    @Autowired
    private MyMessageListener myMessageListener;
    /*
    @Bean对应<bean>
    id对应方法名称
    class对应类型
    property对应设置属性

    <!--创建一个连接工厂-->
    <bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <!--连接地址-->
        <property name="brokerURL" value="tcp://localhost:61616"/>
        <property name="userName" value="admin"/>
        <property name="password" value="admin"/>
    </bean>
    <!--配置一个spring的jms消息监听器-->
    <bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="DestinationName" value="springTopic"/>
        <property name="messageListener" ref="myMessageListener"/>
        <!--pubSubDomain这个property对应模式true代表发布订阅，false代表点对点，默认是false，-->
        <property name="pubSubDomain" value="true"/>
    </bean>
    <bean id="myMessageListener" class="com.test.jms.listener.MyMessageListener"/>
    */
    @Bean
    public DefaultMessageListenerContainer defaultMessageListenerContainer(){
        DefaultMessageListenerContainer defaultMessageListenerContainer = new DefaultMessageListenerContainer();
        defaultMessageListenerContainer.setConnectionFactory(activeMQConnectionFactory);
        defaultMessageListenerContainer.setDestinationName(defaultDestinationName);
        defaultMessageListenerContainer.setMessageListener(myMessageListener);
        defaultMessageListenerContainer.setPubSubDomain(true);
        return defaultMessageListenerContainer;
    }
}

@Component
public class MyMessageListener implements MessageListener {
    @Override
    public void onMessage(Message message) {
        if(message instanceof TextMessage){
            String text = null;
            try {
                text = ((TextMessage)message).getText();
                System.out.println("接收到的消息是:"+text);
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }
}

发布订阅模式
一、同步
在点对点的同步模式的基础上添加:
application.properties中添加一个配置
#发送模式，true表示发布订阅，false表示点对点，默认是false
spring.jms.pub-sub-domain=true;
注意消费者先启动
二、异步
在点对点模式的基础上
方式一:

application.properties中添加一个配置
#发送模式，true表示发布订阅，false表示点对点，默认是false
spring.jms.pub-sub-domain=true;
方式二:
配置文件也添加

spring.jms.pub-sub-domain=true;创建一个属性类似

@Value("${spring.jms.template.default-destination}")
    private String defaultDestinationName;
去读取，读取完成后设置

defaultMessageListenerContainer.setPubSubDomain(pubSubDomain);
或者

defaultMessageListenerContainer.setPubSubDomain(true);
总结:
一般项目中采用异步的方式-监听器，
如果是消息被消费一次，采用点对点模式；
如果项目中消息被多个消费者消费，就采用发布订阅模式；

同步方式一直接收的话采用while(true)接收；
异步方式的监听器就是一直接收；