root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Json view support for JMS 

Support of @JsonView on @JmsListener annotated method that uses the
jackson converter. Also update MappingJackson2MessageConverter to offer
a public API to set the JSON view to use to serialize a payload.

Issue: SPR-13237
This commit is contained in:
Stephane Nicoll 2015-07-22 15:15:24 +02:00
parent cdc9bf76a9
commit dc8de51408
7 changed files with 439 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
spring-jms/src/main/java/org/springframework/jms/listener/adapter/AbstractAdaptableMessageListener.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -36,6 +36,7 @@ import org.springframework.jms.support.converter.MessageConversionException;
import org.springframework.jms.support.converter.MessageConverter;
import org.springframework.jms.support.converter.MessagingMessageConverter;
import org.springframework.jms.support.converter.SimpleMessageConverter;
import org.springframework.jms.support.converter.SmartMessageConverter;
import org.springframework.jms.support.destination.DestinationResolver;
import org.springframework.jms.support.destination.DynamicDestinationResolver;
import org.springframework.util.Assert;
@ -269,14 +270,17 @@ public abstract class AbstractAdaptableMessageListener
* @see #setMessageConverter
*/
protected Message buildMessage(Session session, Object result) throws JMSException {
Object content = (result instanceof JmsResponse ? ((JmsResponse<?>) result).getResponse() : result);
if (content instanceof org.springframework.messaging.Message) {
return this.messagingMessageConverter.toMessage(content, session);
}
Object content = preProcessResponse(result instanceof JmsResponse
? ((JmsResponse<?>) result).getResponse() : result);
MessageConverter converter = getMessageConverter();
if (converter != null) {
return converter.toMessage(content, session);
if (content instanceof org.springframework.messaging.Message) {
return this.messagingMessageConverter.toMessage(content, session);
}
else {
return converter.toMessage(content, session);
}
}
if (!(content instanceof Message)) {
@ -286,6 +290,17 @@ public abstract class AbstractAdaptableMessageListener
return (Message) content;
}
/**
* Pre-process the given result before it is converted to a {@link Message}.
* @param result the result of the invocation
* @return the payload response to handle, either the {@code result} argument or any other
* object (for instance wrapping the result).
* @since 4.3
*/
protected Object preProcessResponse(Object result) {
return result;
}
/**
* Post-process the given response message before it will be sent.
* <p>The default implementation sets the response's correlation id
@ -425,12 +440,17 @@ public abstract class AbstractAdaptableMessageListener
}
@Override
protected Message createMessageForPayload(Object payload, Session session) throws JMSException {
protected Message createMessageForPayload(Object payload, Session session, Object conversionHint)
throws JMSException {
MessageConverter converter = getMessageConverter();
if (converter != null) {
return converter.toMessage(payload, session);
if (converter == null) {
throw new IllegalStateException("No message converter, cannot handle '" + payload + "'");
}
throw new IllegalStateException("No message converter - cannot handle [" + payload + "]");
if (converter instanceof SmartMessageConverter) {
return ((SmartMessageConverter) converter).toMessage(payload, session, conversionHint);
}
return converter.toMessage(payload, session);
}
}

16
spring-jms/src/main/java/org/springframework/jms/listener/adapter/MessagingMessageListenerAdapter.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -19,11 +19,14 @@ package org.springframework.jms.listener.adapter;
import javax.jms.JMSException;
import javax.jms.Session;
import org.springframework.core.MethodParameter;
import org.springframework.jms.support.JmsHeaderMapper;
import org.springframework.jms.support.converter.MessageConversionException;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessagingException;
import org.springframework.messaging.core.AbstractMessageSendingTemplate;
import org.springframework.messaging.handler.invocation.InvocableHandlerMethod;
import org.springframework.messaging.support.MessageBuilder;
/**
* A {@link javax.jms.MessageListener} adapter that invokes a configurable
@ -72,6 +75,17 @@ public class MessagingMessageListenerAdapter extends AbstractAdaptableMessageLis
}
}
@Override
protected Object preProcessResponse(Object result) {
MethodParameter returnType = this.handlerMethod.getReturnType();
if (result instanceof Message) {
return MessageBuilder.fromMessage((Message<?>) result)
.setHeader(AbstractMessageSendingTemplate.CONVERSION_HINT_HEADER, returnType).build();
}
return MessageBuilder.withPayload(result).setHeader(
AbstractMessageSendingTemplate.CONVERSION_HINT_HEADER, returnType).build();
}
protected Message<?> toMessagingMessage(javax.jms.Message jmsMessage) {
try {
return (Message<?>) getMessagingMessageConverter().fromMessage(jmsMessage);

159
spring-jms/src/main/java/org/springframework/jms/support/converter/MappingJackson2MessageConverter.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -29,12 +29,15 @@ import javax.jms.Message;
import javax.jms.Session;
import javax.jms.TextMessage;
import com.fasterxml.jackson.annotation.JsonView;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.core.MethodParameter;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
@ -55,9 +58,10 @@ import org.springframework.util.ClassUtils;
* @author Mark Pollack
* @author Dave Syer
* @author Juergen Hoeller
* @author Stephane Nicoll
* @since 3.1.4
*/
public class MappingJackson2MessageConverter implements MessageConverter, BeanClassLoaderAware {
public class MappingJackson2MessageConverter implements SmartMessageConverter, BeanClassLoaderAware {
/**
* The default encoding used for writing to text messages: UTF-8.
@ -189,6 +193,33 @@ public class MappingJackson2MessageConverter implements MessageConverter, BeanCl
return message;
}
@Override
public Message toMessage(Object object, Session session, Object conversionHint)
throws JMSException, MessageConversionException {
return toMessage(object, session, getSerializationView(conversionHint));
}
/**
* Convert a Java object to a JMS Message using the specified json view
* and the supplied session to create the message object.
* @param object the object to convert
* @param session the Session to use for creating a JMS Message
* @param jsonView the view to use to filter the content
* @return the JMS Message
* @throws javax.jms.JMSException if thrown by JMS API methods
* @throws MessageConversionException in case of conversion failure
* @since 4.3
*/
public Message toMessage(Object object, Session session, Class<?> jsonView)
throws JMSException, MessageConversionException {
if (jsonView != null) {
return toMessage(object, session, this.objectMapper.writerWithView(jsonView));
}
else {
return toMessage(object, session, this.objectMapper.writer());
}
}
@Override
public Object fromMessage(Message message) throws JMSException, MessageConversionException {
try {
@ -200,6 +231,28 @@ public class MappingJackson2MessageConverter implements MessageConverter, BeanCl
}
}
protected Message toMessage(Object object, Session session, ObjectWriter objectWriter)
throws JMSException, MessageConversionException {
Message message;
try {
switch (this.targetType) {
case TEXT:
message = mapToTextMessage(object, session, objectWriter);
break;
case BYTES:
message = mapToBytesMessage(object, session, objectWriter);
break;
default:
message = mapToMessage(object, session, objectWriter, this.targetType);
}
}
catch (IOException ex) {
throw new MessageConversionException("Could not map JSON object [" + object + "]", ex);
}
setTypeIdOnMessage(object, message);
return message;
}
/**
* Map the given object to a {@link TextMessage}.
@ -210,12 +263,31 @@ public class MappingJackson2MessageConverter implements MessageConverter, BeanCl
* @throws JMSException if thrown by JMS methods
* @throws IOException in case of I/O errors
* @see Session#createBytesMessage
* @deprecated as of 4.3, use {@link #mapToTextMessage(Object, Session, ObjectWriter)}
*/
@Deprecated
protected TextMessage mapToTextMessage(Object object, Session session, ObjectMapper objectMapper)
throws JMSException, IOException {
return mapToTextMessage(object, session, objectMapper.writer());
}
/**
* Map the given object to a {@link TextMessage}.
* @param object the object to be mapped
* @param session current JMS session
* @param objectWriter the writer to use
* @return the resulting message
* @throws JMSException if thrown by JMS methods
* @throws IOException in case of I/O errors
* @see Session#createBytesMessage
* @since 4.3
*/
protected TextMessage mapToTextMessage(Object object, Session session, ObjectWriter objectWriter)
throws JMSException, IOException {
StringWriter writer = new StringWriter();
objectMapper.writeValue(writer, object);
objectWriter.writeValue(writer, object);
return session.createTextMessage(writer.toString());
}
@ -228,13 +300,33 @@ public class MappingJackson2MessageConverter implements MessageConverter, BeanCl
* @throws JMSException if thrown by JMS methods
* @throws IOException in case of I/O errors
* @see Session#createBytesMessage
* @deprecated as of 4.3, use {@link #mapToBytesMessage(Object, Session, ObjectWriter)}
*/
@Deprecated
protected BytesMessage mapToBytesMessage(Object object, Session session, ObjectMapper objectMapper)
throws JMSException, IOException {
return mapToBytesMessage(object, session, objectMapper.writer());
}
/**
* Map the given object to a {@link BytesMessage}.
* @param object the object to be mapped
* @param session current JMS session
* @param objectWriter the writer to use
* @return the resulting message
* @throws JMSException if thrown by JMS methods
* @throws IOException in case of I/O errors
* @see Session#createBytesMessage
* @since 4.3
*/
protected BytesMessage mapToBytesMessage(Object object, Session session, ObjectWriter objectWriter)
throws JMSException, IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream(1024);
OutputStreamWriter writer = new OutputStreamWriter(bos, this.encoding);
objectMapper.writeValue(writer, object);
objectWriter.writeValue(writer, object);
BytesMessage message = session.createBytesMessage();
message.writeBytes(bos.toByteArray());
@ -256,10 +348,31 @@ public class MappingJackson2MessageConverter implements MessageConverter, BeanCl
* @return the resulting message
* @throws JMSException if thrown by JMS methods
* @throws IOException in case of I/O errors
* @deprecated as of 4.3, use {@link #mapToMessage(Object, Session, ObjectWriter, MessageType)}
*/
@Deprecated
protected Message mapToMessage(Object object, Session session, ObjectMapper objectMapper, MessageType targetType)
throws JMSException, IOException {
return mapToMessage(object, session, objectMapper.writer(), targetType);
}
/**
* Template method that allows for custom message mapping.
* Invoked when {@link #setTargetType} is not {@link MessageType#TEXT} or
* {@link MessageType#BYTES}.
* <p>The default implementation throws an {@link IllegalArgumentException}.
* @param object the object to marshal
* @param session the JMS Session
* @param objectWriter the writer to use
* @param targetType the target message type (other than TEXT or BYTES)
* @return the resulting message
* @throws JMSException if thrown by JMS methods
* @throws IOException in case of I/O errors
*/
protected Message mapToMessage(Object object, Session session, ObjectWriter objectWriter, MessageType targetType)
throws JMSException, IOException {
throw new IllegalArgumentException("Unsupported message type [" + targetType +
"]. MappingJackson2MessageConverter by default only supports TextMessages and BytesMessages.");
}
@ -391,4 +504,42 @@ public class MappingJackson2MessageConverter implements MessageConverter, BeanCl
}
}
/**
* Determine a Jackson serialization view based on the given conversion hint.
* @param conversionHint the conversion hint Object as passed into the
* converter for the current conversion attempt
* @return the serialization view class, or {@code null} if none
*/
protected Class<?> getSerializationView(Object conversionHint) {
if (conversionHint instanceof MethodParameter) {
MethodParameter methodParam = (MethodParameter) conversionHint;
JsonView annotation = methodParam.getParameterAnnotation(JsonView.class);
if (annotation == null) {
annotation = methodParam.getMethodAnnotation(JsonView.class);
if (annotation == null) {
return null;
}
}
return extractViewClass(annotation, conversionHint);
}
else if (conversionHint instanceof JsonView) {
return extractViewClass((JsonView) conversionHint, conversionHint);
}
else if (conversionHint instanceof Class) {
return (Class) conversionHint;
}
else {
return null;
}
}
private Class<?> extractViewClass(JsonView annotation, Object conversionHint) {
Class<?>[] classes = annotation.value();
if (classes.length != 1) {
throw new IllegalArgumentException(
"@JsonView only supported for handler methods with exactly 1 class argument: " + conversionHint);
}
return classes[0];
}
}

23
spring-jms/src/main/java/org/springframework/jms/support/converter/MessagingMessageConverter.java
View File

@ -24,6 +24,7 @@ import org.springframework.jms.support.JmsHeaderMapper;
import org.springframework.jms.support.SimpleJmsHeaderMapper;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.core.AbstractMessagingTemplate;
import org.springframework.util.Assert;
/**
@ -92,8 +93,11 @@ public class MessagingMessageConverter implements MessageConverter, Initializing
Message.class.getName() + "] is handled by this converter");
}
Message<?> input = (Message<?>) object;
javax.jms.Message reply = createMessageForPayload(input.getPayload(), session);
this.headerMapper.fromHeaders(input.getHeaders(), reply);
MessageHeaders headers = input.getHeaders();
Object conversionHint = (headers != null ? headers.get(
AbstractMessagingTemplate.CONVERSION_HINT_HEADER) : null);
javax.jms.Message reply = createMessageForPayload(input.getPayload(), session, conversionHint);
this.headerMapper.fromHeaders(headers, reply);
return reply;
}
@ -116,11 +120,26 @@ public class MessagingMessageConverter implements MessageConverter, Initializing
/**
* Create a JMS message for the specified payload.
* @see MessageConverter#toMessage(Object, Session)
* @deprecated as of 4.3, use {@link #createMessageForPayload(Object, Session, Object)}
*/
@Deprecated
protected javax.jms.Message createMessageForPayload(Object payload, Session session) throws JMSException {
return this.payloadConverter.toMessage(payload, session);
}
/**
* Create a JMS message for the specified payload and conversionHint. The conversion
* hint is an extra object passed to the {@link MessageConverter}, e.g. the associated
* {@code MethodParameter} (may be {@code null}}.
* @see MessageConverter#toMessage(Object, Session)
* @since 4.3
*/
@SuppressWarnings("deprecation")
protected javax.jms.Message createMessageForPayload(Object payload, Session session, Object conversionHint)
throws JMSException {
return createMessageForPayload(payload, session);
}
private MessageHeaders extractHeaders(javax.jms.Message message) {
return this.headerMapper.toHeaders(message);
}

51
spring-jms/src/main/java/org/springframework/jms/support/converter/SmartMessageConverter.java Normal file
View File

@ -0,0 +1,51 @@
/*
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.jms.support.converter;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
/**
* An extended {@link MessageConverter} SPI with conversion hint support.
*
* <p>In case of a conversion hint being provided, the framework will call
* the extended method if a converter implements this interface, instead
* of calling the regular {@code toMessage} variant.
*
* @author Stephane Nicoll
* @since 4.3
*/
public interface SmartMessageConverter extends MessageConverter {
/**
* A variant of {@link #toMessage(Object, Session)} which takes an extra conversion
* context as an argument, allowing to take e.g. annotations on a payload parameter
* into account.
* @param object the object to convert
* @param session the Session to use for creating a JMS Message
* @param conversionHint an extra object passed to the {@link MessageConverter},
* e.g. the associated {@code MethodParameter} (may be {@code null}}
* @return the JMS Message
* @throws javax.jms.JMSException if thrown by JMS API methods
* @throws MessageConversionException in case of conversion failure
* @see #toMessage(Object, Session)
*/
Message toMessage(Object object, Session session, Object conversionHint)
throws JMSException, MessageConversionException;
}

35
spring-jms/src/test/java/org/springframework/jms/listener/adapter/MessagingMessageListenerAdapterTests.java
View File

@ -27,6 +27,7 @@ import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import com.fasterxml.jackson.annotation.JsonView;
import org.junit.Before;
import org.junit.Test;
@ -236,7 +237,21 @@ public class MessagingMessageListenerAdapterTests {
verify(reply).setObjectProperty("foo", "bar");
}
private TextMessage testReplyWithJackson(String methodName, String replyContent) throws JMSException {
@Test
public void replyJacksonMessageAndJsonView() throws JMSException {
TextMessage reply = testReplyWithJackson("replyJacksonMessageAndJsonView",
"{\"name\":\"Response\"}");
verify(reply).setObjectProperty("foo", "bar");
}
@Test
public void replyJacksonPojoAndJsonView() throws JMSException {
TextMessage reply = testReplyWithJackson("replyJacksonPojoAndJsonView",
"{\"name\":\"Response\"}");
verify(reply, never()).setObjectProperty("foo", "bar");
}
public TextMessage testReplyWithJackson(String methodName, String replyContent) throws JMSException {
Queue replyDestination = mock(Queue.class);
Session session = mock(Session.class);
@ -327,6 +342,17 @@ public class MessagingMessageListenerAdapterTests {
.setHeader("foo", "bar").build();
}
@JsonView(Summary.class)
public Message<SampleResponse> replyJacksonMessageAndJsonView(Message<String> input) {
return MessageBuilder.withPayload(createSampleResponse(input.getPayload()))
.setHeader("foo", "bar").build();
}
@JsonView(Summary.class)
public SampleResponse replyJacksonPojoAndJsonView(Message<String> input) {
return createSampleResponse(input.getPayload());
}
private SampleResponse createSampleResponse(String name) {
return new SampleResponse(name, "lengthy description");
}
@ -340,15 +366,22 @@ public class MessagingMessageListenerAdapterTests {
}
}
interface Summary {};
interface Full extends Summary {};
private static class SampleResponse {
private int counter = 42;
@JsonView(Summary.class)
private String name;
@JsonView(Full.class)
private String description;
SampleResponse() {
}
public SampleResponse(String name, String description) {
this.name = name;
this.description = description;

134
spring-jms/src/test/java/org/springframework/jms/support/converter/MappingJackson2MessageConverterTests.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2013 the original author or authors.
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -17,28 +17,39 @@
package org.springframework.jms.support.converter;
import java.io.ByteArrayInputStream;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import javax.jms.BytesMessage;
import javax.jms.JMSException;
import javax.jms.Session;
import javax.jms.TextMessage;
import com.fasterxml.jackson.annotation.JsonView;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.springframework.core.MethodParameter;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* @author Arjen Poutsma
* @author Dave Syer
* @author Stephane Nicoll
*/
public class MappingJackson2MessageConverterTests {
@Rule
public final ExpectedException thrown = ExpectedException.none();
private MappingJackson2MessageConverter converter;
private Session sessionMock;
@ -167,6 +178,91 @@ public class MappingJackson2MessageConverterTests {
assertEquals("Invalid result", result, unmarshalled);
}
@Test
public void toTextMessageWithReturnType() throws JMSException, NoSuchMethodException {
Method method = this.getClass().getDeclaredMethod("summary");
MethodParameter returnType = new MethodParameter(method, -1);
testToTextMessageWithReturnType(returnType);
verify(sessionMock).createTextMessage("{\"name\":\"test\"}");
}
@Test
public void toTextMessageWithNullReturnType() throws JMSException, NoSuchMethodException {
testToTextMessageWithReturnType(null);
verify(sessionMock).createTextMessage("{\"name\":\"test\",\"description\":\"lengthy description\"}");
}
@Test
public void toTextMessageWithReturnTypeAndNoJsonView() throws JMSException, NoSuchMethodException {
Method method = this.getClass().getDeclaredMethod("none");
MethodParameter returnType = new MethodParameter(method, -1);
testToTextMessageWithReturnType(returnType);
verify(sessionMock).createTextMessage("{\"name\":\"test\",\"description\":\"lengthy description\"}");
}
@Test
public void toTextMessageWithReturnTypeAndMultipleJsonViews() throws JMSException, NoSuchMethodException {
Method method = this.getClass().getDeclaredMethod("invalid");
MethodParameter returnType = new MethodParameter(method, -1);
thrown.expect(IllegalArgumentException.class);
testToTextMessageWithReturnType(returnType);
}
private void testToTextMessageWithReturnType(MethodParameter returnType) throws JMSException, NoSuchMethodException {
converter.setTargetType(MessageType.TEXT);
TextMessage textMessageMock = mock(TextMessage.class);
MyAnotherBean bean = new MyAnotherBean("test", "lengthy description");
given(sessionMock.createTextMessage(isA(String.class))).willReturn(textMessageMock);
converter.toMessage(bean, sessionMock, returnType);
verify(textMessageMock).setStringProperty("__typeid__", MyAnotherBean.class.getName());
}
@Test
public void toTextMessageWithJsonViewClass() throws JMSException {
converter.setTargetType(MessageType.TEXT);
TextMessage textMessageMock = mock(TextMessage.class);
MyAnotherBean bean = new MyAnotherBean("test", "lengthy description");
given(sessionMock.createTextMessage(isA(String.class))).willReturn(textMessageMock);
converter.toMessage(bean, sessionMock, Summary.class);
verify(textMessageMock).setStringProperty("__typeid__", MyAnotherBean.class.getName());
verify(sessionMock).createTextMessage("{\"name\":\"test\"}");
}
@Test
public void toTextMessageWithAnotherJsonViewClass() throws JMSException {
converter.setTargetType(MessageType.TEXT);
TextMessage textMessageMock = mock(TextMessage.class);
MyAnotherBean bean = new MyAnotherBean("test", "lengthy description");
given(sessionMock.createTextMessage(isA(String.class))).willReturn(textMessageMock);
converter.toMessage(bean, sessionMock, Full.class);
verify(textMessageMock).setStringProperty("__typeid__", MyAnotherBean.class.getName());
verify(sessionMock).createTextMessage("{\"name\":\"test\",\"description\":\"lengthy description\"}");
}
@JsonView(Summary.class)
public MyAnotherBean summary() {
return new MyAnotherBean();
}
public MyAnotherBean none() {
return new MyAnotherBean();
}
@JsonView({Summary.class, Full.class})
public MyAnotherBean invalid() {
return new MyAnotherBean();
}
public static class MyBean {
public MyBean() {
@ -210,4 +306,40 @@ public class MappingJackson2MessageConverterTests {
}
}
private interface Summary {};
private interface Full extends Summary {};
private static class MyAnotherBean {
@JsonView(Summary.class)
private String name;
@JsonView(Full.class)
private String description;
private MyAnotherBean() {
}
public MyAnotherBean(String name, String description) {
this.name = name;
this.description = description;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
}
}