转 一步一步Spring整合JMS

最新推荐文章于 2024-04-23 18:52:22 发布
最新推荐文章于 2024-04-23 18:52:22 发布
阅读量43 收藏
点赞数
文章标签： java 网络
原文链接：https://yq.aliyun.com/articles/40364
版权

1.1 JMS简介

    JMS的全称是Java Message Service，即Java消息服务。它主要用于在生产者和消费者之间进行消息传递，生产者负责产生消息，而消费者负责接收消息。把它应用到实际的业务需求中的话我们可以在特定的时候利用生产者生成一消息，并进行发送，对应的消费者在接收到对应的消息后去完成对应的业务逻辑。对于消息的传递有两种类型，一种是点对点的，即一个生产者和一个消费者一一对应；另一种是发布/订阅模式，即一个生产者产生消息并进行发送后，可以由多个消费者进行接收。

1.2 Spring整合JMS

    对JMS做了一个简要介绍之后，接下来就讲一下Spring整合JMS的具体过程。JMS只是一个标准，真正在使用它的时候我们需要有它的具体实现，这里我们就使用Apache的activeMQ来作为它的实现。所使用的依赖利用Maven来进行管理，具体依赖如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
< dependencies >  
     < dependency >  
         < groupId >junit</ groupId >  
         < artifactId >junit</ artifactId >  
         < version >4.10</ version >  
         < scope >test</ scope >  
     </ dependency >  
     < dependency >  
         < groupId >org.springframework</ groupId >  
         < artifactId >spring-context</ 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-test</ artifactId >  
         < version >${spring-version}</ version >  
     </ dependency >  
     < dependency >  
         < groupId >javax.annotation</ groupId >  
         < artifactId >jsr250-api</ artifactId >  
         < version >1.0</ version >  
     </ dependency >  
     < dependency >  
         < groupId >org.apache.activemq</ groupId >  
         < artifactId >activemq-core</ artifactId >  
         < version >5.7.0</ version >  
     </ dependency >  
</ dependencies >

1.2.1 activeMQ准备

       既然是使用的apache的activeMQ作为JMS的实现，那么首先我们应该到apache官网上下载activeMQ（http://activemq.apache.org/download.html），进行解压后运行其bin目录下面的activemq.bat文件启动activeMQ。

1.2.2 配置ConnectionFactory

    ConnectionFactory是用于产生到JMS服务器的链接的，Spring为我们提供了多个ConnectionFactory，有SingleConnectionFactory和CachingConnectionFactory。SingleConnectionFactory对于建立JMS服务器链接的请求会一直返回同一个链接，并且会忽略Connection的close方法调用。CachingConnectionFactory继承了SingleConnectionFactory，所以它拥有SingleConnectionFactory的所有功能，同时它还新增了缓存功能，它可以缓存Session、MessageProducer和MessageConsumer。这里我们使用SingleConnectionFactory来作为示例。

?
1
2
< bean  id = "connectionFactory" 
     class = "org.springframework.jms.connection.SingleConnectionFactory" />

    这样就定义好产生JMS服务器链接的ConnectionFactory了吗？答案是非也。Spring提供的ConnectionFactory只是Spring用于管理ConnectionFactory的，真正产生到JMS服务器链接的ConnectionFactory还得是由JMS服务厂商提供，并且需要把它注入到Spring提供的ConnectionFactory中。我们这里使用的是ActiveMQ实现的JMS，所以在我们这里真正的可以产生Connection的就应该是由ActiveMQ提供的ConnectionFactory。所以定义一个ConnectionFactory的完整代码应该如下所示：

?
1
2
3
4
5
6
7
8
9
10
11
12
<!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->  
< bean  id = "targetConnectionFactory" 
     class = "org.apache.activemq.ActiveMQConnectionFactory" >  
     < property  name = "brokerURL"  value = "tcp://localhost:61616" />  
</ bean >  
   
<!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
< bean  id = "connectionFactory" 
     class = "org.springframework.jms.connection.SingleConnectionFactory" >  
     <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
     < property  name = "targetConnectionFactory"  ref = "targetConnectionFactory" />  
</ bean >

    ActiveMQ为我们提供了一个PooledConnectionFactory，通过往里面注入一个ActiveMQConnectionFactory可以用来将Connection、Session和MessageProducer池化，这样可以大大的减少我们的资源消耗。当使用PooledConnectionFactory时，我们在定义一个ConnectionFactory时应该是如下定义：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->  
< bean  id = "targetConnectionFactory" 
     class = "org.apache.activemq.ActiveMQConnectionFactory" >  
     < property  name = "brokerURL"  value = "tcp://localhost:61616" />  
</ bean >  
   
< bean  id = "pooledConnectionFactory" 
     class = "org.apache.activemq.pool.PooledConnectionFactory" >  
     < property  name = "connectionFactory"  ref = "targetConnectionFactory" />  
     < property  name = "maxConnections"  value = "10" />  
</ bean >  
   
< bean  id = "connectionFactory" 
     class = "org.springframework.jms.connection.SingleConnectionFactory" >  
     < property  name = "targetConnectionFactory"  ref = "pooledConnectionFactory" />  
</ bean >

1.2.3 配置生产者

    配置好ConnectionFactory之后我们就需要配置生产者。生产者负责产生消息并发送到JMS服务器，这通常对应的是我们的一个业务逻辑服务实现类。但是我们的服务实现类是怎么进行消息的发送的呢？这通常是利用Spring为我们提供的JmsTemplate类来实现的，所以配置生产者其实最核心的就是配置进行消息发送的JmsTemplate。对于消息发送者而言，它在发送消息的时候要知道自己该往哪里发，为此，我们在定义JmsTemplate的时候需要往里面注入一个Spring提供的ConnectionFactory对象。

?
1
2
3
4
5
<!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->  
< bean  id = "jmsTemplate"  class = "org.springframework.jms.core.JmsTemplate" >  
     <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
     < property  name = "connectionFactory"  ref = "connectionFactory" />  
</ bean >

    在真正利用JmsTemplate进行消息发送的时候，我们需要知道消息发送的目的地，即destination。在Jms中有一个用来表示目的地的Destination接口，它里面没有任何方法定义，只是用来做一个标识而已。当我们在使用JmsTemplate进行消息发送时没有指定destination的时候将使用默认的Destination。默认Destination可以通过在定义jmsTemplate bean对象时通过属性defaultDestination或defaultDestinationName来进行注入，defaultDestinationName对应的就是一个普通字符串。在ActiveMQ中实现了两种类型的Destination，一个是点对点的ActiveMQQueue，另一个就是支持订阅/发布模式的ActiveMQTopic。在定义这两种类型的Destination时我们都可以通过一个name属性来进行构造，如：

?
1
2
3
4
5
6
7
8
9
10
<!--这个是队列目的地，点对点的-->  
< bean  id = "queueDestination"  class = "org.apache.activemq.command.ActiveMQQueue" >  
     < constructor-arg >  
         < value >queue</ value >  
     </ constructor-arg >  
</ bean >  
<!--这个是主题目的地，一对多的-->  
< bean  id = "topicDestination"  class = "org.apache.activemq.command.ActiveMQTopic" >  
     < constructor-arg  value = "topic" />  
</ bean >

假设我们定义了一个ProducerService，里面有一个向Destination发送纯文本消息的方法sendMessage，那么我们的代码就大概是这个样子：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package  com.tiantian.springintejms.service.impl;  
    
import  javax.annotation.Resource;  
import  javax.jms.Destination;  
import  javax.jms.JMSException;  
import  javax.jms.Message;  
import  javax.jms.Session;  
    
import  org.springframework.jms.core.JmsTemplate;  
import  org.springframework.jms.core.MessageCreator;  
import  org.springframework.stereotype.Component;  
    
import  com.tiantian.springintejms.service.ProducerService;  
    
@Component  
public  class  ProducerServiceImpl  implements  ProducerService {  
    
     private  JmsTemplate jmsTemplate;  
       
     public  void  sendMessage(Destination destination,  final  String message) {  
         System.out.println( "---------------生产者发送消息-----------------" );  
         System.out.println( "---------------生产者发了一个消息："  + message);  
         jmsTemplate.send(destination,  new  MessageCreator() {  
             public  Message createMessage(Session session)  throws  JMSException {  
                 return  session.createTextMessage(message);  
             }  
         });  
     }   
   
     public  JmsTemplate getJmsTemplate() {  
         returnjmsTemplate;  
     }   
   
     @Resource  
     public  void  setJmsTemplate(JmsTemplate jmsTemplate) {  
         this .jmsTemplate = jmsTemplate;  
     }  
}

我们可以看到在sendMessage方法体里面我们是通过jmsTemplate来发送消息到对应的Destination的。到此，我们生成一个简单的文本消息并把它发送到指定目的地Destination的生产者就配置好了。

1.2.4 配置消费者

    生产者往指定目的地Destination发送消息后，接下来就是消费者对指定目的地的消息进行消费了。那么消费者是如何知道有生产者发送消息到指定目的地Destination了呢？这是通过Spring为我们封装的消息监听容器MessageListenerContainer实现的，它负责接收信息，并把接收到的信息分发给真正的MessageListener进行处理。每个消费者对应每个目的地都需要有对应的MessageListenerContainer。对于消息监听容器而言，除了要知道监听哪个目的地之外，还需要知道到哪里去监听，也就是说它还需要知道去监听哪个JMS服务器，这是通过在配置MessageConnectionFactory的时候往里面注入一个ConnectionFactory来实现的。所以我们在配置一个MessageListenerContainer的时候有三个属性必须指定，一个是表示从哪里监听的ConnectionFactory；一个是表示监听什么的Destination；一个是接收到消息以后进行消息处理的MessageListener。Spring一共为我们提供了两种类型的MessageListenerContainer，SimpleMessageListenerContainer和DefaultMessageListenerContainer。

    SimpleMessageListenerContainer会在一开始的时候就创建一个会话session和消费者Consumer，并且会使用标准的JMS MessageConsumer.setMessageListener()方法注册监听器让JMS提供者调用监听器的回调函数。它不会动态的适应运行时需要和参与外部的事务管理。兼容性方面，它非常接近于独立的JMS规范，但一般不兼容Java EE的JMS限制。

大多数情况下我们还是使用的DefaultMessageListenerContainer，跟SimpleMessageListenerContainer相比，DefaultMessageListenerContainer会动态的适应运行时需要，并且能够参与外部的事务管理。它很好的平衡了对JMS提供者要求低、先进功能如事务参与和兼容Java EE环境。

定义处理消息的MessageListener

    要定义处理消息的MessageListener我们只需要实现JMS规范中的MessageListener接口就可以了。MessageListener接口中只有一个方法onMessage方法，当接收到消息的时候会自动调用该方法。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package  com.tiantian.springintejms.listener;  
    
import  javax.jms.JMSException;  
import  javax.jms.Message;  
import  javax.jms.MessageListener;  
import  javax.jms.TextMessage;  
    
public  class  ConsumerMessageListener  implements  MessageListener {  
    
     public  void  onMessage(Message message) {  
         //这里我们知道生产者发送的就是一个纯文本消息，所以这里可以直接进行强制转换  
         TextMessage textMsg = (TextMessage) message;  
         System.out.println( "接收到一个纯文本消息。" );  
         try  {  
             System.out.println( "消息内容是："  + textMsg.getText());  
         }  catch  (JMSException e) {  
             e.printStackTrace();  
         }  
     }  
    
}

    有了MessageListener之后我们就可以在Spring的配置文件中配置一个消息监听容器了。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!--这个是队列目的地-->  
< bean  id = "queueDestination"  class = "org.apache.activemq.command.ActiveMQQueue" >  
     < constructor-arg >  
         < value >queue</ value >  
     </ constructor-arg >  
</ bean >  
<!-- 消息监听器 -->  
< bean  id = "consumerMessageListener" 
     class = "com.tiantian.springintejms.listener.ConsumerMessageListener" />      
   
<!-- 消息监听容器 -->  
< bean  id = "jmsContainer" 
     class = "org.springframework.jms.listener.DefaultMessageListenerContainer" >  
     < property  name = "connectionFactory"  ref = "connectionFactory"  />  
     < property  name = "destination"  ref = "queueDestination"  />  
     < property  name = "messageListener"  ref = "consumerMessageListener"  />  
</ bean >

我们可以看到我们定义了一个名叫queue的ActiveMQQueue目的地，我们的监听器就是监听了发送到这个目的地的消息。

       至此我们的生成者和消费者都配置完成了，这也就意味着我们的整合已经完成了。这个时候完整的Spring的配置文件应该是这样的：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
<? 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"  
     xmlns:jms = "http://www.springframework.org/schema/jms"  
     xsi:schemaLocation="http://www.springframework.org/schema/beans  
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
     http://www.springframework.org/schema/context  
     http://www.springframework.org/schema/context/spring-context-3.0.xsd  
     http://www.springframework.org/schema/beans 
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
     http://www.springframework.org/schema/jms 
     http://www.springframework.org/schema/jms/spring-jms-3.0.xsd">  
    
     < context:component-scan  base-package = "com.tiantian"  />  
    
     <!-- Spring提供的JMS工具类，它可以进行消息发送、接收等 -->  
     < bean  id = "jmsTemplate"  class = "org.springframework.jms.core.JmsTemplate" >  
         <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
         < property  name = "connectionFactory"  ref = "connectionFactory" />  
     </ bean >  
       
     <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->  
     < bean  id = "targetConnectionFactory" 
         class = "org.apache.activemq.ActiveMQConnectionFactory" >  
         < property  name = "brokerURL"  value = "tcp://localhost: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 >queue</ value >  
         </ constructor-arg >  
     </ bean >  
     <!-- 消息监听器 -->  
     < bean  id = "consumerMessageListener" 
         class = "com.tiantian.springintejms.listener.ConsumerMessageListener" />  
     <!-- 消息监听容器 -->  
     < bean  id = "jmsContainer"  
         class = "org.springframework.jms.listener.DefaultMessageListenerContainer" >  
         < property  name = "connectionFactory"  ref = "connectionFactory"  />  
         < property  name = "destination"  ref = "queueDestination"  />  
         < property  name = "messageListener"  ref = "consumerMessageListener"  />  
     </ bean >  
</ beans >

    接着我们来测试一下，看看我们的整合是否真的成功了，测试代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package  com.tiantian.springintejms.test;  
    
import  javax.jms.Destination;  
    
import  org.junit.Test;  
import  org.junit.runner.RunWith;  
import  org.springframework.beans.factory.annotation.Autowired;  
import  org.springframework.beans.factory.annotation.Qualifier;  
import  org.springframework.test.context.ContextConfiguration;  
import  org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
import  com.tiantian.springintejms.service.ProducerService;  
    
@RunWith (SpringJUnit4ClassRunner. class )  
@ContextConfiguration ( "/applicationContext.xml" )  
public  class  ProducerConsumerTest {  
    
     @Autowired  
     private  ProducerService producerService;  
     @Autowired  
     @Qualifier ( "queueDestination" )  
     private  Destination destination;  
       
     @Test  
     public  void  testSend() {  
         for  ( int  i= 0 ; i< 2 ; i++) {  
             producerService.sendMessage(destination,  "你好，生产者！这是消息："  + (i+ 1 ));  
         }  
     }  
       
}

    在上面的测试代码中我们利用生产者发送了两个消息，正常来说，消费者应该可以接收到这两个消息。运行测试代码后控制台输出如下：

182011_BpIX_1434710.png

    看，控制台已经进行了正确的输出，这说明我们的整合确实是已经成功了。


    拓展：关于JMS的其他部分知识，请至原博客的后续博客查看。

weixin_33858249
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring整合Weblogic jms实例详解
08-25
主要介绍了Spring整合Weblogic jms实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring消息（JMS）
吃四碗饭的嘤嘤怪的博客
07-18 9977
1.异步消息简介 1.首先看一下同步模式和异步模式的区别：   客户端调用远程方法时，客户端必须等到远程方法完成后，才能继续执行。即使远程方法不向客户端返回任何信息，客户端也要被阻塞直到服务完成。 客户端不需要等待服务处理消息，甚至不需要等待消息投递完成。客户端发送消息，然后继续执行，这是因为客户端假定服务最终可以收到并处理这条消息。 1.发送消息     在异步消息中有两个...
spring 中的JMS是什么？
wzs535131的博客
07-11 4850
程序员看源码是成长的必要条件，最近在看spring的源码，看到spring框架中有一个模块是JMS，那么JMS到底是什么呢？那我们分成几个步骤来了解下吧。 1.什么是JMS？以及JMS的作用。 JMS:Java消息服务（Java Message Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用来在两个应用程序之间，或分布式系统中发送消息，进行异步通信。 比如2个应用程序之间需要进行消息传递，我们可以使用JMS服务进行消息的传递，通过使用JMS使2个应用程序之间
Spring整合JMS——基于ActiveMQ实现
kss820的专栏
06-23 685
1.1     JMS简介        JMS的全称是Java Message Service，即Java消息服务。它主要用于在生产者和消费者之间进行消息传递，生产者负责产生消息，而消费者负责接收消息。把它应用到实际的业务需求中的话我们可以在特定的时候利用生产者生成一消息，并进行发送，对应的消费者在接收到对应的消息后去完成对应的业务逻辑。对于消息的传递有两种类型，一种是点对点的，即一个生产者和
Spring集成JMS入门
做一个好的程序猿的博客
03-09 577
在学习Spring集成JMS之前最好可以是先去了解JMS基本概念和ActiveMQ 自己学习Spring整合JMS的一些心得，希望可以帮到大家 2、Spring整合JMS 2.1、使用点对点消息传送模型 2.1.1 创建生产者项目 1、pom.xml文件中的依赖 <properties> <spring.version>4.2.5.RELEASE</s...
Spring 中自带 JMS的使用
口袋里的小龙的专栏
06-21 710
Spring 中自带 JMS的使用
Spring和ActiveMQ的整合实例源码
09-26
此实例基于Spring+JMS+ActiveMQ+Tomcat，注解的完整实例，包含jar包
Spring Boot基于Active MQ实现整合JMS
08-18
主要介绍了Spring Boot基于Active MQ实现整合JMS,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring整合JMS实现同步收发消息(基于ActiveMQ的实现)
08-28
本篇文章主要介绍了spring整合JMS实现同步收发消息(基于ActiveMQ的实现)，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Spring整合JMS
02-25
对JMS做了一个简要介绍，讲一下Spring整合JMS的具体过程。JMS只是一个标准，真正在使用它的时候我们需要有它的具体实现，这里我们就使用Apache的activeMQ来作为它的实现
SpringBoot2整合Jms超级简单攻略(基于ActiveMQ)
04-12
SpringBoot2整合Jms超级简单攻略(基于ActiveMQ).。消息主题(Topic)，需要一个固定的主题，例如大家都是在谈论外卖，那主题就是外卖，别人讨论其他的跟你无关。 消息队列(MQ) ，存放或者实现JMS的功能，需要用到队列，有人放入消息到外卖队列，有人从外卖队列读取消息，就是一个消息队列的模型。 发送者(Sender)，通过什么事或者想做什么事，就发个信息，例如点个外卖呗。 接收者(Receiver)，然后外卖员就收到信息，办事。 1、运行springoboot主类 2、直接访问localhost：8080/test?id=123 3.在控制台就可以看到mq打印消息，因为消费者2运算量太大，所以一直等待输出，消费者1消费两个消息
Spring整合JMS——三种connectionFactory
热门推荐
s296850101的专栏
08-30 1万+
1、SingleConnectionFactory：对于建立JMS服务器链接的请求会一直返回同一个链接，并且会忽略Connection的close方法调用。(org.springframework.jms.connection.SingleConnectionFactory) 2、CachingConnectionFactory：继承了SingleConnectionFactory，所以它拥有S
Spring消息——JMS发送消息
szuaudi的博客
03-25 484
Spring消息——JMS发送消息JMS概述ActiveMQ概述ActiveMQ安装使用传统JMS发送消息编码新建工程目录结构编写rmi功能运行实例 JMS概述 Java Message Service (JMS) The Java Message Service (JMS) API is a messaging standard that allows application componen...
Spring整合JMS(消息中间件)
爱琴孩的博客
09-28 327
一、消息异步处理类似于RMI、Hessian、Burlap等远程方法调用，它们都是同步的，所谓同步调用就是客户端必须等待操作完成，如果远程服务没有返回任何响应，客户端会一直等待直到服务完成。 异步调用则不同，客户端发送完消息无需等待服务处理完成便可立即返回，就像发送完消息就立刻被处理成功一样。 1.1 消息的发送在异步处理的世界，我们可以把消息的发送比作一个邮局系统。比如我们要给某个人发送信
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 239
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1349
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 490
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1259
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
spring整合jms(ibm) sendAndReceive
06-10
好的，下面是Spring整合JMS（IBM）使用sendAndReceive方法发送和接收消息的步骤： 1. 在Spring中配置JMS连接工厂和目标资源，可以使用Spring的JmsTemplate来发送和接收消息。 2. 编写发送和接收消息的代码。使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值