`
xiongzhenhui
  • 浏览: 209746 次
  • 性别: Icon_minigender_1
  • 来自: 厦门
社区版块
存档分类
最新评论

Spring JMS的开发应用--自定义消息转换器的使用（四）

    博客分类：
  • jms
 
阅读更多

在Spring JMS、中可以通过实现MessageConverter自定义自己的消息转换器实现消息的转换。在Spring 的JMS1.1有SimpleMessageConverter实现基本的消息转换，在JMS1.02中SimpleMessageConverter102实现消息的转换的工作。

 

Java代码 复制代码 收藏代码
  1. package com.easyway.jboss.jms.ptp.service;   
  2.   
  3. public class SMS  implements java.io.Serializable{   
  4.     /**  
  5.      *   
  6.      */  
  7.     private static final long serialVersionUID = 1L;   
  8.     private String username;   
  9.     private String message;   
  10.        
  11.     public SMS(){   
  12.            
  13.     }   
  14.     public SMS(String username,String message){   
  15.         this.username=username;   
  16.         this.message=message;   
  17.     }   
  18.     public String getUsername() {   
  19.         return username;   
  20.     }   
  21.     public void setUsername(String username) {   
  22.         this.username = username;   
  23.     }   
  24.     public String getMessage() {   
  25.         return message;   
  26.     }   
  27.     public void setMessage(String message) {   
  28.         this.message = message;   
  29.     }   
  30.        
  31.        
  32.        
  33.   
  34. }  
package com.easyway.jboss.jms.ptp.service;

public class SMS  implements java.io.Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private String username;
	private String message;
	
	public SMS(){
		
	}
	public SMS(String username,String message){
		this.username=username;
		this.message=message;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getMessage() {
		return message;
	}
	public void setMessage(String message) {
		this.message = message;
	}
	
	
	

}

 

 

消息转换器：

Java代码 复制代码 收藏代码
  1. package com.easyway.jboss.jms.ptp.spring.service;   
  2.   
  3. import javax.jms.JMSException;   
  4. import javax.jms.MapMessage;   
  5. import javax.jms.Message;   
  6. import javax.jms.Session;   
  7.   
  8. import org.springframework.jms.support.converter.MessageConversionException;   
  9. import org.springframework.jms.support.converter.MessageConverter;   
  10.   
  11. import com.easyway.jboss.jms.ptp.service.SMS;   
  12. /**  
  13.  * 自定义消息转换器MessageConverter实现  
  14.  * 在JmsTemplate提供了各种send方法，供发送消息使用，其中JmsTemplate中的  
  15.  * convertAndSend和receiveAndConvert方法能够借助于MessageConverter接口  
  16.  * 实现消息做相应的转换。  
  17.  * JMS1.1中SimpleMessageConverter实现String与TextMessage,等之间的转换  
  18.  * @author longgangbai  
  19.  *  
  20.  */  
  21. public class SMSConverter implements MessageConverter {   
  22.   
  23.     @Override  
  24.     public Object fromMessage(Message message) throws JMSException,   
  25.             MessageConversionException {   
  26.          SMS sms=new SMS();   
  27.          MapMessage  mapmessage= (MapMessage  )message;   
  28.          sms.setMessage(mapmessage.getString("message"));   
  29.          sms.setUsername(mapmessage.getString("username"));   
  30.         return sms;   
  31.     }   
  32.   
  33.     @Override  
  34.     public Message toMessage(Object object, Session session)   
  35.             throws JMSException, MessageConversionException {   
  36.          SMS sms=(SMS)object;   
  37.          MapMessage  mapmessage=session.createMapMessage();   
  38.          mapmessage.setString("username", sms.getUsername());   
  39.          mapmessage.setString("message", sms.getMessage());   
  40.          return mapmessage;   
  41.     }   
  42.   
  43. }  
package com.easyway.jboss.jms.ptp.spring.service;

import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.jms.support.converter.MessageConversionException;
import org.springframework.jms.support.converter.MessageConverter;

import com.easyway.jboss.jms.ptp.service.SMS;
/**
 * 自定义消息转换器MessageConverter实现
 * 在JmsTemplate提供了各种send方法，供发送消息使用，其中JmsTemplate中的
 * convertAndSend和receiveAndConvert方法能够借助于MessageConverter接口
 * 实现消息做相应的转换。
 * JMS1.1中SimpleMessageConverter实现String与TextMessage,等之间的转换
 * @author longgangbai
 *
 */
public class SMSConverter implements MessageConverter {

	@Override
	public Object fromMessage(Message message) throws JMSException,
			MessageConversionException {
		 SMS sms=new SMS();
		 MapMessage  mapmessage= (MapMessage  )message;
		 sms.setMessage(mapmessage.getString("message"));
		 sms.setUsername(mapmessage.getString("username"));
		return sms;
	}

	@Override
	public Message toMessage(Object object, Session session)
			throws JMSException, MessageConversionException {
		 SMS sms=(SMS)object;
		 MapMessage  mapmessage=session.createMapMessage();
		 mapmessage.setString("username", sms.getUsername());
		 mapmessage.setString("message", sms.getMessage());
		 return mapmessage;
	}

}

 

applicationContext-cjms-sender.xml：

Java代码 复制代码 收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2. <beans   
  3.     xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xmlns:p="http://www.springframework.org/schema/p"  
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">   
  7.     
  8.  <!-- 设置消息服务的初始化参数信息 -->   
  9.  <bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">   
  10.       <property name="environment">   
  11.            <props>   
  12.                <prop key="java.naming.factory.initial">   
  13.                    org.jnp.interfaces.NamingContextFactory   
  14.                </prop>   
  15.                <prop key="java.naming.provider.url">   
  16.                   jnp://localhost:1099   
  17.                </prop>   
  18.                <prop key="java.naming.factory.url.pkgs">   
  19.                    org.jboss.naming:org.jnp.interfaces   
  20.                </prop>   
  21.            </props>   
  22.       </property>   
  23.  </bean>   
  24. <!--    
  25.    创建消息服务的连接工厂的信息   
  26.        
  27.                  JMS1.02 TopicConnectionFactory 和QueueConnectionFactory   
  28.                 JMS1.1 TopicConnectionFactory 和QueueConnectionFactory合并为ConnectionFactory   
  29.                    
  30.  -->   
  31. <bean id="connectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">   
  32.    <property name="jndiName">   
  33.        <value>ConnectionFactory</value>   
  34.    </property>   
  35.    <property name="jndiTemplate">   
  36.         <ref local="jndiTemplate"/>   
  37.    </property>   
  38. </bean>   
  39. <!-- 创建JMS的目的地信息 -->   
  40. <bean  id="destination" class="org.springframework.jndi.JndiObjectFactoryBean">   
  41.     <property name="jndiName">   
  42.         <value>queue/longgangbai</value>   
  43.      </property>   
  44.      <property name="jndiTemplate">   
  45.          <ref  local="jndiTemplate"/>   
  46.      </property>   
  47. </bean>   
  48.   
  49. <!--    
  50.    创建自定义转换器   
  51.  -->   
  52. <bean id="smsconverter" class="com.easyway.jboss.jms.ptp.spring.service.SMSConverter"></bean>   
  53.   
  54. <!-- 创建JMS发送信息的模板的对象 -->   
  55. <bean  id="jmsTemplate"  class="org.springframework.jms.core.JmsTemplate">   
  56.     <property name="connectionFactory">   
  57.        <ref  local="connectionFactory"/>   
  58.      </property>   
  59.         
  60.      <property name="defaultDestination">   
  61.         <ref local="destination"/>   
  62.      </property>   
  63.        <!-- 设置自定义转换器 -->   
  64.      <property name="messageConverter">   
  65.         <ref local="smsconverter"/>   
  66.      </property>   
  67. </bean>   
  68.   
  69. </beans>  
<?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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 
 <!-- 设置消息服务的初始化参数信息 -->
 <bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
      <property name="environment">
           <props>
               <prop key="java.naming.factory.initial">
                   org.jnp.interfaces.NamingContextFactory
               </prop>
               <prop key="java.naming.provider.url">
                  jnp://localhost:1099
               </prop>
               <prop key="java.naming.factory.url.pkgs">
                   org.jboss.naming:org.jnp.interfaces
               </prop>
           </props>
      </property>
 </bean>
<!-- 
   创建消息服务的连接工厂的信息
    
                 JMS1.02 TopicConnectionFactory 和QueueConnectionFactory
				JMS1.1 TopicConnectionFactory 和QueueConnectionFactory合并为ConnectionFactory
				
 -->
<bean id="connectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
   <property name="jndiName">
       <value>ConnectionFactory</value>
   </property>
   <property name="jndiTemplate">
        <ref local="jndiTemplate"/>
   </property>
</bean>
<!-- 创建JMS的目的地信息 -->
<bean  id="destination" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName">
        <value>queue/longgangbai</value>
     </property>
     <property name="jndiTemplate">
         <ref  local="jndiTemplate"/>
     </property>
</bean>

<!-- 
   创建自定义转换器
 -->
<bean id="smsconverter" class="com.easyway.jboss.jms.ptp.spring.service.SMSConverter"></bean>

<!-- 创建JMS发送信息的模板的对象 -->
<bean  id="jmsTemplate"  class="org.springframework.jms.core.JmsTemplate">
    <property name="connectionFactory">
       <ref  local="connectionFactory"/>
     </property>
     
     <property name="defaultDestination">
        <ref local="destination"/>
     </property>
       <!-- 设置自定义转换器 -->
     <property name="messageConverter">
        <ref local="smsconverter"/>
     </property>
</bean>

</beans>

 发送消息的代码那：

Java代码 复制代码 收藏代码
  1. package com.easyway.jboss.jms.ptp.spring.service;   
  2.   
  3. import org.apache.commons.logging.Log;   
  4. import org.apache.commons.logging.LogFactory;   
  5. import org.springframework.context.ApplicationContext;   
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  7. import org.springframework.jms.core.JmsTemplate;   
  8.   
  9. import com.easyway.jboss.jms.ptp.service.SMS;   
  10.   
  11. /**  
  12.  * Spring中JMS的简单应用  
  13.  * Spring JMS的创建并发送  
  14.  * @author longgangbai  
  15.  *  
  16.  */  
  17. public class SpringCJMSQueueSender {   
  18.        
  19.     private static final Log log=LogFactory.getLog(SpringCJMSQueueSender.class);   
  20.        
  21.     public static void main(String[] args) {   
  22.         ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext-cjms-sender.xml");   
  23.         JmsTemplate jt=(JmsTemplate)ctx.getBean("jmsTemplate");   
  24.         SMS sms=new SMS();   
  25.         sms.setMessage("message");   
  26.         sms.setUsername("wangna");   
  27.         jt.convertAndSend(sms);   
  28.         log.info("发送信息成功！");   
  29.            
  30.     }   
  31. }  
package com.easyway.jboss.jms.ptp.spring.service;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;

import com.easyway.jboss.jms.ptp.service.SMS;

/**
 * Spring中JMS的简单应用
 * Spring JMS的创建并发送
 * @author longgangbai
 *
 */
public class SpringCJMSQueueSender {
	
	private static final Log log=LogFactory.getLog(SpringCJMSQueueSender.class);
	
	public static void main(String[] args) {
		ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext-cjms-sender.xml");
		JmsTemplate jt=(JmsTemplate)ctx.getBean("jmsTemplate");
		SMS sms=new SMS();
		sms.setMessage("message");
		sms.setUsername("wangna");
		jt.convertAndSend(sms);
		log.info("发送信息成功！");
		
	}
}

 

applicationContext-cjms-receive.xml：

Java代码 复制代码 收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2. <beans   
  3.     xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xmlns:p="http://www.springframework.org/schema/p"  
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">   
  7.     
  8.  <!-- 设置消息服务的初始化参数信息 -->   
  9.  <bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">   
  10.       <property name="environment">   
  11.            <props>   
  12.                <prop key="java.naming.factory.initial">   
  13.                    org.jnp.interfaces.NamingContextFactory   
  14.                </prop>   
  15.                <prop key="java.naming.provider.url">   
  16.                   jnp://localhost:1099   
  17.                </prop>   
  18.                <prop key="java.naming.factory.url.pkgs">   
  19.                    org.jboss.naming:org.jnp.interfaces   
  20.                </prop>   
  21.            </props>   
  22.       </property>   
  23.      
  24.  </bean>   
  25. <!--    
  26.                                   创建消息服务的连接工厂的信息   
  27.                  JMS1.02 TopicConnectionFactory 和QueueConnectionFactory   
  28.                 JMS1.1 TopicConnectionFactory 和QueueConnectionFactory合并为ConnectionFactory   
  29.  -->   
  30. <bean id="connectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">   
  31.    <property name="jndiName">   
  32.        <value>ConnectionFactory</value>   
  33.    </property>   
  34.    <property name="jndiTemplate">   
  35.         <ref local="jndiTemplate"/>   
  36.    </property>   
  37. </bean>   
  38. <!-- 创建JMS的目的地信息 -->   
  39. <bean  id="destination" class="org.springframework.jndi.JndiObjectFactoryBean">   
  40.     <property name="jndiName">   
  41.         <value>queue/longgangbai</value>   
  42.      </property>   
  43.      <property name="jndiTemplate">   
  44.          <ref  local="jndiTemplate"/>   
  45.      </property>   
  46. </bean>   
  47. <!--    
  48.    创建自定义转换器   
  49.  -->   
  50. <bean id="smsconverter" class="com.easyway.jboss.jms.ptp.spring.service.SMSConverter"></bean>   
  51.   
  52. <!-- 创建JMS发送信息的模板的对象 -->   
  53. <bean  id="jmsTemplate"  class="org.springframework.jms.core.JmsTemplate">   
  54.     <property name="connectionFactory">   
  55.        <ref  local="connectionFactory"/>   
  56.      </property>   
  57.      <property name="defaultDestination">   
  58.         <ref local="destination"/>   
  59.      </property>   
  60.      <!-- 设置自定义转换器 -->   
  61.        <property name="messageConverter">   
  62.         <ref local="smsconverter"/>   
  63.      </property>   
  64. </bean>   
  65.   
  66. </beans>  
<?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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 
 <!-- 设置消息服务的初始化参数信息 -->
 <bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
      <property name="environment">
           <props>
               <prop key="java.naming.factory.initial">
                   org.jnp.interfaces.NamingContextFactory
               </prop>
               <prop key="java.naming.provider.url">
                  jnp://localhost:1099
               </prop>
               <prop key="java.naming.factory.url.pkgs">
                   org.jboss.naming:org.jnp.interfaces
               </prop>
           </props>
      </property>
  
 </bean>
<!-- 
                                  创建消息服务的连接工厂的信息
                 JMS1.02 TopicConnectionFactory 和QueueConnectionFactory
				JMS1.1 TopicConnectionFactory 和QueueConnectionFactory合并为ConnectionFactory
 -->
<bean id="connectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
   <property name="jndiName">
       <value>ConnectionFactory</value>
   </property>
   <property name="jndiTemplate">
        <ref local="jndiTemplate"/>
   </property>
</bean>
<!-- 创建JMS的目的地信息 -->
<bean  id="destination" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName">
        <value>queue/longgangbai</value>
     </property>
     <property name="jndiTemplate">
         <ref  local="jndiTemplate"/>
     </property>
</bean>
<!-- 
   创建自定义转换器
 -->
<bean id="smsconverter" class="com.easyway.jboss.jms.ptp.spring.service.SMSConverter"></bean>

<!-- 创建JMS发送信息的模板的对象 -->
<bean  id="jmsTemplate"  class="org.springframework.jms.core.JmsTemplate">
    <property name="connectionFactory">
       <ref  local="connectionFactory"/>
     </property>
     <property name="defaultDestination">
        <ref local="destination"/>
     </property>
     <!-- 设置自定义转换器 -->
       <property name="messageConverter">
        <ref local="smsconverter"/>
     </property>
</bean>

</beans>

 接收消息的代码如下：

Java代码 复制代码 收藏代码
  1. package com.easyway.jboss.jms.ptp.spring.service;   
  2.   
  3. import org.apache.commons.logging.Log;   
  4. import org.apache.commons.logging.LogFactory;   
  5. import org.springframework.context.ApplicationContext;   
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  7. import org.springframework.jms.core.JmsTemplate;   
  8.   
  9. import com.easyway.jboss.jms.ptp.service.SMS;   
  10. /**  
  11.  * Spring JMS 消息的接受  
  12.  * @author longgangbai  
  13.  *  
  14.  */  
  15. public class SpringCJMSQueueReceive {   
  16. private static final Log log=LogFactory.getLog(SpringCJMSQueueReceive.class);   
  17.        
  18.     public static void main(String[] args) {   
  19.         ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext-cjms-receive.xml");   
  20.         JmsTemplate jt=(JmsTemplate)ctx.getBean("jmsTemplate");   
  21.         SMS sms=(SMS)jt.receiveAndConvert();   
  22.         System.out.println("username:"+sms.getUsername());   
  23.         System.out.println("message:"+sms.getMessage());   
  24.         System.out.println(".......");   
  25.            
  26.     }   
  27. }  
分享到：
| Spring JMS基础学习
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    ActiveMQ与spring集成实例之使用消息转换器

    Spring 提供了多种内置的消息转换器，如 `SimpleMessageConverter` 和 `XmlMessageConverter`，但也可以自定义转换器。 例如，如果我们要将 Java 对象转换为 JSON 格式并发送，可以使用 Jackson 库配合 `...

    spring-integration-stream-2.1.5.RELEASE.zip

    通过定义消息通道（channels）、消息源（sources）、消息处理器（gateways）和消息转换器（transformers），可以构建出强大的集成解决方案。同时，其丰富的监控和日志记录功能也有助于排查和优化系统的运行情况。 ...

    spring-framework-4-reference

    Registering a LoadTimeWeaver允许在应用类加载器的加载时将类转换器应用到类上。 此外，ApplicationContext接口提供了Spring IoC容器的主要实现，它扩展了BeanFactory接口，增加了更多的企业级功能，如支持国际化...

    sample-spring-boot-war-jms:使用JPA和Spring-Boot的示例Spring JMS

    7. **消息转换器**: Spring JMS提供了一些内置的消息转换器，如`StringMessageConverter`，可以根据需要自定义转换规则，确保消息体能在消息生产者和消费者之间正确转换。 8. **Web层整合**: 将JMS与RESTful API...

    Spring整合JMS（三）——MessageConverter介绍

    Spring提供了对JMS的全面支持，包括连接工厂配置、消息生产者、消费者以及消息转换器等。JMS允许应用程序通过消息中间件进行解耦通信，提高系统的可扩展性和可靠性。Spring JMS抽象了JMS API，提供了更易于使用的...

    spring集成JMS

    Spring框架作为一个强大的企业级应用开发框架，提供了对JMS的全面支持，使得开发者能够方便地在Spring应用中集成JMS，实现异步消息处理和高可用性。 一、JMS简介 JMS是一种API，用于在分布式环境中发送、接收和管理...

    spring-flex-reference

    #### 四、使用Spring Security保护BlazeDS目的地 ##### 4.1 引言 为了确保应用程序的安全性，需要对BlazeDS目的地进行访问控制。Spring Security提供了一种强大的方式来实现这一点。 ##### 4.2 配置Spring ...

    springboot学习思维笔记.xmind

    Spring-JMS Spring的生态 Spring Boot Spring XD Spring Cloud Spring Data Spring Integration Spring Batch Spring Security Spring HATEOAS Spring ...

    spring-frame-4-reference

    Spring提供了强大的验证、数据绑定和类型转换功能，这对于Web开发尤为重要。主要包括以下几个方面： - **Validation using Spring’s Validator interface**：Spring支持通过Validator接口实现数据验证。 - **...

    Spring整合JMS

    当我们谈论"Spring整合JMS"时，意味着我们要将Spring框架与Java消息服务（Java Message Service）进行集成，以便利用JMS的异步通信能力来处理应用程序中的消息传递。 **JMS简介** JMS是一种标准API，用于在分布式...

    消息中间件-spring-MQ.zip

    总的来说，Spring MQ的使用能够帮助开发者轻松地在Spring应用中实现消息驱动的架构，提升系统的稳定性和扩展性。"spring-MQ-main"项目可能包含了这些概念的实现，通过学习和运行这个项目，你可以更深入地理解和掌握...

    Spring 2.0 开发参考手册

    19.3.1. 使用消息转换器 19.3.2. SessionCallback 和ProducerCallback 19.4. 接收消息 19.4.1. 同步接收 19.4.2. 异步接收 - 消息驱动的POJOs 19.4.3. SessionAwareMessageListener 接口 19.4.4. ...

    spring-reference

    Spring框架是一个轻量级的Java应用开发框架，旨在简化企业级应用的开发过程。它通过提供一系列强大的特性来实现这一目标，比如依赖注入（Dependency Injection, DI）、面向切面编程（Aspect-Oriented Programming, ...

    spring的jar包源码

    Spring框架是Java开发中不可或缺的一部分，它以其模块化、易用性和灵活性著称。源码分析可以帮助我们深入了解其内部机制，提升我们的编程技能。以下是对标题"spring的jar包源码"和描述"spring的jar包源码"中涉及的...

    Spring-Reference_zh_CN（Spring中文参考手册）

    6.8.4. 在Spring应用中使用AspectJ Load-time weaving（LTW） 6.9. 其它资源 7. Spring AOP APIs 7.1. 简介 7.2. Spring中的切入点API 7.2.1. 概念 7.2.2. 切入点实施 7.2.3. AspectJ切入点表达式 7.2.4. 便利的切入...

    spring-messaging源码

    五、消息转换器与消息模板 Spring Messaging提供了`MessageConverter`接口，用于在消息体和Java对象之间进行转换。常见的实现有`SimpleMessageConverter`和`Jackson2JsonMessageConverter`，分别支持基本类型和JSON...

    spring integration in action

    - **Spring Integration 如何简化集成开发：** 通过使用标准的 Java POJO 和 Spring Bean 定义，简化了集成应用的开发和维护过程。 #### Part 2 - 消息传递 **3: 消息和通道** - **消息模型：** 解释了 Spring ...

    spring integration reference 4

    - **@IntegrationConverter**：自定义消息转换器，可以在消息转换过程中进行转换。 - **@EnablePublisher**：用于启用对发布者的支持，能够发送消息到一个或多个订阅者。 - **Redis Channel Message Stores**：使用 ...

    Spring-Framework-4.x参考文档.pdf

    Spring Framework 是一个开源的企业级 Java 应用程序框架，旨在简化企业级应用程序的开发过程。它提供了全面的编程模型，使得开发者能够更轻松地构建和维护复杂的应用系统。 **1.2 依赖注入与控制反转** - **1.2.1...

Magicbox
Global site tag (gtag.js) - Google Analytics