001    /**
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.activemq.util.xstream;
018    
019    import java.io.Serializable;
020    import java.io.StringReader;
021    import java.io.StringWriter;
022    
023    import javax.jms.JMSException;
024    import javax.jms.Message;
025    import javax.jms.MessageConsumer;
026    import javax.jms.MessageProducer;
027    import javax.jms.ObjectMessage;
028    import javax.jms.Session;
029    import javax.jms.TextMessage;
030    
031    import org.apache.activemq.MessageTransformerSupport;
032    
033    import com.thoughtworks.xstream.XStream;
034    import com.thoughtworks.xstream.io.HierarchicalStreamDriver;
035    import com.thoughtworks.xstream.io.HierarchicalStreamReader;
036    import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
037    import com.thoughtworks.xstream.io.xml.PrettyPrintWriter;
038    import com.thoughtworks.xstream.io.xml.XppReader;
039    
040    /**
041     * Transforms object messages to text messages and vice versa using
042     * {@link XStream}
043     * 
044     * @deprecated as of 5.3.0 release replaced by {@link org.apache.activemq.util.oxm.XStreamMessageTransformer}
045     * 
046     * @version $Revision: 814586 $
047     */
048    @Deprecated
049    public class XStreamMessageTransformer extends MessageTransformerSupport {
050    
051        protected MessageTransform transformType;
052        private XStream xStream;
053        
054        /**
055         * Specialized driver to be used with stream readers and writers
056         */
057        private HierarchicalStreamDriver streamDriver;
058    
059        /**
060         * Defines the type of transformation. If XML (default), - producer
061         * transformation transforms from Object to XML. - consumer transformation
062         * transforms from XML to Object. If OBJECT, - producer transformation
063         * transforms from XML to Object. - consumer transformation transforms from
064         * Object to XML. If ADAPTIVE, - producer transformation transforms from
065         * Object to XML, or XML to Object depending on the type of the original
066         * message - consumer transformation transforms from XML to Object, or
067         * Object to XML depending on the type of the original message
068         */
069        public enum MessageTransform {
070            XML, OBJECT, ADAPTIVE
071        };
072    
073    
074        public XStreamMessageTransformer() {
075            this(MessageTransform.XML);
076        }
077    
078        public XStreamMessageTransformer(MessageTransform transformType) {
079            this.transformType = transformType;
080        }
081    
082        public Message consumerTransform(Session session, MessageConsumer consumer, Message message) throws JMSException {
083            switch (transformType) {
084            case XML:
085                return (message instanceof TextMessage) ? textToObject(session, (TextMessage)message) : message;
086            case OBJECT:
087                return (message instanceof ObjectMessage) ? objectToText(session, (ObjectMessage)message) : message;
088            case ADAPTIVE:
089                return (message instanceof TextMessage) ? textToObject(session, (TextMessage)message) : (message instanceof ObjectMessage) ? objectToText(session, (ObjectMessage)message) : message;
090            default:
091            }
092            return message;
093        }
094    
095        public Message producerTransform(Session session, MessageProducer producer, Message message) throws JMSException {
096            switch (transformType) {
097            case XML:
098                return (message instanceof ObjectMessage) ? objectToText(session, (ObjectMessage)message) : message;
099            case OBJECT:
100                return (message instanceof TextMessage) ? textToObject(session, (TextMessage)message) : message;
101            case ADAPTIVE:
102                return (message instanceof TextMessage) ? textToObject(session, (TextMessage)message) : (message instanceof ObjectMessage) ? objectToText(session, (ObjectMessage)message) : message;
103            default:
104            }
105            return message;
106        }
107    
108        // Properties
109        // -------------------------------------------------------------------------
110        public XStream getXStream() {
111            if (xStream == null) {
112                xStream = createXStream();
113            }
114            return xStream;
115        }
116    
117        public void setXStream(XStream xStream) {
118            this.xStream = xStream;
119        }
120    
121        public HierarchicalStreamDriver getStreamDriver() {
122                    return streamDriver;
123        }
124    
125            public void setStreamDriver(HierarchicalStreamDriver streamDriver) {
126                    this.streamDriver = streamDriver;
127        }
128    
129            // Implementation methods
130        // -------------------------------------------------------------------------
131        protected XStream createXStream() {
132            return new XStream();
133        }
134    
135        public MessageTransform getTransformType() {
136            return transformType;
137        }
138    
139        public void setTransformType(MessageTransform transformType) {
140            this.transformType = transformType;
141        }
142    
143        /**
144         * Transforms an incoming XML encoded {@link TextMessage} to an
145         * {@link ObjectMessage}
146         * 
147         * @param session - JMS session currently being used
148         * @param textMessage - text message to transform to object message
149         * @return ObjectMessage
150         * @throws JMSException
151         */
152        protected ObjectMessage textToObject(Session session, TextMessage textMessage) throws JMSException {
153            Object object = unmarshall(session, textMessage);
154            if (object instanceof Serializable) {
155                ObjectMessage answer = session.createObjectMessage((Serializable)object);
156                copyProperties(textMessage, answer);
157                return answer;
158            } else {
159                throw new JMSException("Object is not serializable: " + object);
160            }
161        }
162    
163        /**
164         * Transforms an incoming {@link ObjectMessage} to an XML encoded
165         * {@link TextMessage}
166         * 
167         * @param session - JMS session currently being used
168         * @param objectMessage - object message to transform to text message
169         * @return XML encoded TextMessage
170         * @throws JMSException
171         */
172        protected TextMessage objectToText(Session session, ObjectMessage objectMessage) throws JMSException {
173            TextMessage answer = session.createTextMessage(marshall(session, objectMessage));
174            copyProperties(objectMessage, answer);
175            return answer;
176        }
177    
178        /**
179         * Marshalls the Object in the {@link ObjectMessage} to a string using XML
180         * encoding
181         */
182        protected String marshall(Session session, ObjectMessage objectMessage) throws JMSException {
183            Serializable object = objectMessage.getObject();
184            StringWriter buffer = new StringWriter();
185            HierarchicalStreamWriter out;
186            if (streamDriver != null) {
187                    out = streamDriver.createWriter(buffer);
188            } else {
189                    out = new PrettyPrintWriter(buffer);
190            }
191            getXStream().marshal(object, out);
192            return buffer.toString();
193        }
194    
195        /**
196         * Unmarshalls the XML encoded message in the {@link TextMessage} to an
197         * Object
198         */
199        protected Object unmarshall(Session session, TextMessage textMessage) throws JMSException {
200            HierarchicalStreamReader in;
201            if (streamDriver != null) {
202                    in = streamDriver.createReader(new StringReader(textMessage.getText()));
203            } else {
204                    in = new XppReader(new StringReader(textMessage.getText()));
205            }
206            return getXStream().unmarshal(in);
207        }
208    
209    }