001/* 002 * Copyright 2002-2018 the original author or authors. 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * https://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 */ 016 017package org.springframework.messaging.core; 018 019import java.util.Map; 020 021import org.springframework.lang.Nullable; 022import org.springframework.messaging.Message; 023 024/** 025 * An extension of {@link AbstractMessageReceivingTemplate} that adds support for 026 * request-reply style operations as defined by {@link MessageRequestReplyOperations}. 027 * 028 * @author Mark Fisher 029 * @author Rossen Stoyanchev 030 * @author Stephane Nicoll 031 * @since 4.0 032 * @param <D> the destination type 033 */ 034public abstract class AbstractMessagingTemplate<D> extends AbstractMessageReceivingTemplate<D> 035 implements MessageRequestReplyOperations<D> { 036 037 @Override 038 @Nullable 039 public Message<?> sendAndReceive(Message<?> requestMessage) { 040 return sendAndReceive(getRequiredDefaultDestination(), requestMessage); 041 } 042 043 @Override 044 @Nullable 045 public Message<?> sendAndReceive(D destination, Message<?> requestMessage) { 046 return doSendAndReceive(destination, requestMessage); 047 } 048 049 @Nullable 050 protected abstract Message<?> doSendAndReceive(D destination, Message<?> requestMessage); 051 052 053 @Override 054 @Nullable 055 public <T> T convertSendAndReceive(Object request, Class<T> targetClass) { 056 return convertSendAndReceive(getRequiredDefaultDestination(), request, targetClass); 057 } 058 059 @Override 060 @Nullable 061 public <T> T convertSendAndReceive(D destination, Object request, Class<T> targetClass) { 062 return convertSendAndReceive(destination, request, null, targetClass); 063 } 064 065 @Override 066 @Nullable 067 public <T> T convertSendAndReceive( 068 D destination, Object request, @Nullable Map<String, Object> headers, Class<T> targetClass) { 069 070 return convertSendAndReceive(destination, request, headers, targetClass, null); 071 } 072 073 @Override 074 @Nullable 075 public <T> T convertSendAndReceive( 076 Object request, Class<T> targetClass, @Nullable MessagePostProcessor postProcessor) { 077 078 return convertSendAndReceive(getRequiredDefaultDestination(), request, targetClass, postProcessor); 079 } 080 081 @Override 082 @Nullable 083 public <T> T convertSendAndReceive(D destination, Object request, Class<T> targetClass, 084 @Nullable MessagePostProcessor postProcessor) { 085 086 return convertSendAndReceive(destination, request, null, targetClass, postProcessor); 087 } 088 089 @SuppressWarnings("unchecked") 090 @Override 091 @Nullable 092 public <T> T convertSendAndReceive(D destination, Object request, @Nullable Map<String, Object> headers, 093 Class<T> targetClass, @Nullable MessagePostProcessor postProcessor) { 094 095 Message<?> requestMessage = doConvert(request, headers, postProcessor); 096 Message<?> replyMessage = sendAndReceive(destination, requestMessage); 097 return (replyMessage != null ? (T) getMessageConverter().fromMessage(replyMessage, targetClass) : null); 098 } 099 100}