001/**
002 * Copyright 2005-2015 The Kuali Foundation
003 *
004 * Licensed under the Educational Community 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 * http://www.opensource.org/licenses/ecl2.php
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 */
016package org.kuali.rice.krad.service.impl;
017
018import java.lang.reflect.Field;
019import java.util.ArrayList;
020import java.util.Iterator;
021
022import org.apache.commons.logging.Log;
023import org.apache.commons.logging.LogFactory;
024import org.kuali.rice.krad.service.LegacyDataAdapter;
025import org.kuali.rice.krad.service.XmlObjectSerializerService;
026import org.kuali.rice.krad.service.util.DateTimeConverter;
027import org.springframework.beans.factory.annotation.Required;
028
029import com.thoughtworks.xstream.XStream;
030import com.thoughtworks.xstream.converters.MarshallingContext;
031import com.thoughtworks.xstream.converters.reflection.ObjectAccessException;
032import com.thoughtworks.xstream.converters.reflection.PureJavaReflectionProvider;
033import com.thoughtworks.xstream.converters.reflection.ReflectionConverter;
034import com.thoughtworks.xstream.converters.reflection.ReflectionProvider;
035import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
036import com.thoughtworks.xstream.mapper.Mapper;
037
038
039/**
040 * Service implementation for the XmlObjectSerializer structure. This is the default implementation that gets
041 * delivered with Kuali. It utilizes the XStream open source libraries and framework.
042 *
043 * @author Kuali Rice Team (rice.collab@kuali.org)
044 */
045public class XmlObjectSerializerServiceImpl implements XmlObjectSerializerService {
046        private static final Log LOG = LogFactory.getLog(XmlObjectSerializerServiceImpl.class);
047
048        protected LegacyDataAdapter lda;
049
050        protected XStream xstream;
051
052        public XmlObjectSerializerServiceImpl() {
053                xstream = new XStream(new ProxyAwareJavaReflectionProvider());
054
055        // See http://xstream.codehaus.org/faq.html#Serialization_CGLIB
056        // To use a newer version of XStream we may need to do something like this:
057//        xstream = new XStream() {
058//
059//            @Override
060//            public ReflectionProvider getReflectionProvider() {
061//                return new ProxyAwareJavaReflectionProvider();
062//            }
063//
064//            protected MapperWrapper wrapMapper(MapperWrapper next) {
065//                return new CGLIBMapper(next);
066//            }
067//        };
068//        xstream.registerConverter(new CGLIBEnhancedConverter(xstream.getMapper(), xstream.getReflectionProvider()));
069
070                xstream.registerConverter(new ProxyConverter(xstream.getMapper(), xstream.getReflectionProvider() ));
071        try {
072                Class<?> objListProxyClass = Class.forName("org.apache.ojb.broker.core.proxy.ListProxyDefaultImpl");
073            xstream.addDefaultImplementation(ArrayList.class, objListProxyClass);
074        } catch ( Exception ex ) {
075                // Do nothing - this will blow if the OJB class does not exist, which it won't in some installs
076        }
077        xstream.registerConverter(new DateTimeConverter());
078        }
079
080    @Required
081    public void setLegacyDataAdapter(LegacyDataAdapter lda) {
082        this.lda = lda;
083    }
084
085    @Override
086        public String toXml(Object object) {
087        if ( LOG.isDebugEnabled() ) {
088                LOG.debug( "toXml(" + object + ") : \n" + xstream.toXML(object) );
089        }
090        return xstream.toXML(object);
091    }
092
093    @Override
094        public Object fromXml(String xml) {
095        if ( LOG.isDebugEnabled() ) {
096                LOG.debug( "fromXml() : \n" + xml );
097        }
098        if ( xml != null ) {
099                xml = xml.replaceAll( "--EnhancerByCGLIB--[0-9a-f]{0,8}", "" );
100        }
101        return xstream.fromXML(xml);
102    }
103
104    /**
105     * This custom converter only handles proxies for BusinessObjects.  List-type proxies are handled by configuring XStream to treat
106     * ListProxyDefaultImpl as ArrayLists (see constructor for this service).
107     */
108    public class ProxyConverter extends ReflectionConverter {
109        public ProxyConverter(Mapper mapper, ReflectionProvider reflectionProvider) {
110            super(mapper, reflectionProvider);
111        }
112
113        @Override
114        // since the ReflectionConverter supertype defines canConvert without using a parameterized Class type, we must declare
115        // the overridden version the same way
116        @SuppressWarnings("unchecked")
117        public boolean canConvert(Class clazz) {
118            return clazz.getName().contains("CGLIB");
119        }
120
121        @Override
122        public void marshal(Object obj, HierarchicalStreamWriter writer, MarshallingContext context) {
123            super.marshal(lda.resolveProxy(obj), writer, context);
124        }
125
126        // we shouldn't need an unmarshal method because all proxy metadata is taken out of the XML, so we'll reserialize as a base BO.
127    }
128
129    public class ProxyAwareJavaReflectionProvider extends PureJavaReflectionProvider {
130
131        /**
132         * @see com.thoughtworks.xstream.converters.reflection.PureJavaReflectionProvider#visitSerializableFields(java.lang.Object, com.thoughtworks.xstream.converters.reflection.ReflectionProvider.Visitor)
133         */
134        @Override
135        public void visitSerializableFields(Object object, Visitor visitor) {
136            for (Iterator iterator = fieldDictionary.serializableFieldsFor(object.getClass()); iterator.hasNext();) {
137                Field field = (Field) iterator.next();
138                if (!fieldModifiersSupported(field)) {
139                    continue;
140                }
141                validateFieldAccess(field);
142                if (ignoreField(field)) {
143                    continue;
144                }
145                Object value = null;
146                try {
147                    value = field.get(object);
148                    if (value != null && lda.isProxied(value)) {
149                        value = lda.resolveProxy(value);
150                    }
151                } catch (Exception e) {
152                    throw new ObjectAccessException("Could not get field " + field.getClass() + "." + field.getName() + " on " + object, e);
153                }
154                visitor.visit(field.getName(), field.getType(), field.getDeclaringClass(), value);
155            }
156        }
157
158        protected boolean ignoreField(Field field) {
159            return false;
160        }
161
162    }
163
164}