beanserializer.java

json-rpc是和DWR类似的ajax-rpc实现。我比较细化

/*
 * JSON-RPC-Java - a JSON-RPC to Java Bridge with dynamic invocation
 *
 * $Id: BeanSerializer.java,v 1.7.2.2 2006/03/06 12:39:21 mclark Exp $
 *
 * Copyright Metaparadigm Pte. Ltd. 2004.
 * Michael Clark <[e-mail]>
 *
 * 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 com.metaparadigm.jsonrpc;

import java.util.Map;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.logging.Logger;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
import java.beans.Introspector;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.beans.BeanInfo;
import org.json.JSONObject;

public class BeanSerializer extends AbstractSerializer
{
    private final static long serialVersionUID = 1;

    private final static Logger log =
	Logger.getLogger(BeanSerializer.class.getName());

    private static HashMap beanCache = new HashMap();

    private static Class[] _serializableClasses = new Class[] { };
    private static Class[] _JSONClasses = new Class[] { };

    public Class[] getSerializableClasses() { return _serializableClasses; }
    public Class[] getJSONClasses() { return _JSONClasses; }

    public boolean canSerialize(Class clazz, Class jsonClazz)
    {
	return (!clazz.isArray() &&
		!clazz.isPrimitive() &&
		!clazz.isInterface() &&
		(jsonClazz == null || jsonClazz == JSONObject.class));
    }

    protected static class BeanData
    {
        //in absence of getters and setters, these fields are 
        //public to allow subclasses to access.
        public BeanInfo beanInfo;
        public HashMap readableProps;
        public HashMap writableProps;	
    }

    protected static class BeanSerializerState
    {
        //in absence of getters and setters, these fields are 
        //public to allow subclasses to access.

        // Circular reference detection
        public HashSet beanSet = new HashSet();
    }

    public static BeanData analyzeBean(Class clazz)
	throws IntrospectionException
    {
	log.info("analyzing " + clazz.getName());
	BeanData bd = new BeanData();
	bd.beanInfo = Introspector.getBeanInfo(clazz, Object.class);
	PropertyDescriptor props[] = bd.beanInfo.getPropertyDescriptors();
	bd.readableProps = new HashMap();
	bd.writableProps = new HashMap();
	for(int i=0; i < props.length; i++) {
	    if(props[i].getWriteMethod() != null) {
		bd.writableProps.put(props[i].getName(),
				     props[i].getWriteMethod());
	    }
	    if(props[i].getReadMethod() != null) {
		bd.readableProps.put(props[i].getName(),
				     props[i].getReadMethod());
	    }
	}
	return bd;
    }

    public static BeanData getBeanData(Class clazz)
	throws IntrospectionException
    {
	BeanData bd;
	synchronized (beanCache) {
	    bd = (BeanData)beanCache.get(clazz);
	    if(bd == null) {
		bd = analyzeBean(clazz);
		beanCache.put(clazz, bd);
	    }
	}
	return bd;
    }

    public ObjectMatch tryUnmarshall(SerializerState state,
				     Class clazz, Object o)
	throws UnmarshallException
    {
	JSONObject jso = (JSONObject)o;
	BeanData bd = null;
	try {
	    bd = getBeanData(clazz);
	} catch (IntrospectionException e) {
	    throw new UnmarshallException(clazz.getName() + " is not a bean");
	}

	int match = 0, mismatch = 0;
	Iterator i = bd.writableProps.entrySet().iterator();
	while(i.hasNext()) {
	    Map.Entry ent = (Map.Entry)i.next();
	    String prop = (String)ent.getKey();
	    Method method = (Method)ent.getValue();
	    if(jso.has(prop)) match++;
	    else mismatch++;
	}
	if(match == 0) throw new UnmarshallException("bean has no matches");

	ObjectMatch m = null, tmp = null;
	i = jso.keys();
	while(i.hasNext()) {
	    String field = (String)i.next();
	    Method setMethod = (Method)bd.writableProps.get(field);
	    if(setMethod != null) {
		try {
		    Class param[] = setMethod.getParameterTypes();
		    if(param.length != 1)
			throw new UnmarshallException
			    ("bean " + clazz.getName() +
			     " method " + setMethod.getName() +
			     " does not have one arg");
		    tmp = ser.tryUnmarshall(state, param[0], jso.get(field));
		    if(m == null) m = tmp;
		    else m = m.max(tmp);
		} catch (UnmarshallException e) {
		    throw new UnmarshallException("bean " + clazz.getName() +
					     " " + e.getMessage());
		}
	    } else {
		mismatch++;
	    }
	}
	return m.max(new ObjectMatch(mismatch));
    }

    public Object unmarshall(SerializerState state, Class clazz, Object o)
	throws UnmarshallException
    {
	JSONObject jso = (JSONObject)o;
	BeanData bd = null;
	try {
	    bd = getBeanData(clazz);
	} catch (IntrospectionException e) {
	    throw new UnmarshallException(clazz.getName() + " is not a bean");
	}
	if(ser.isDebug())
	    log.fine("instantiating " + clazz.getName());
	Object instance = null;
	try {
	    instance = clazz.newInstance();
	} catch (Exception e) {
	    throw new UnmarshallException
		("can't instantiate bean " +
		 clazz.getName() + ": " + e.getMessage());
	}
	Object invokeArgs[] = new Object[1];
	Object fieldVal;
	Iterator i = jso.keys();
	while(i.hasNext()) {
	    String field = (String)i.next();
	    Method setMethod = (Method)bd.writableProps.get(field);
	    if(setMethod != null) {
		try {
		    Class param[] = setMethod.getParameterTypes();
		    fieldVal = ser.unmarshall(state, param[0], jso.get(field));
		} catch (UnmarshallException e) {
		    throw new UnmarshallException("bean " + clazz.getName() +
						  " " + e.getMessage());
		}
		if(ser.isDebug())
		    log.fine("invoking " + setMethod.getName() +
			     "(" + fieldVal + ")");
		invokeArgs[0] = fieldVal;
		try {
		    setMethod.invoke(instance, invokeArgs);
		} catch (Throwable e) {
		    if(e instanceof InvocationTargetException)
			e = ((InvocationTargetException)e).
			    getTargetException();
		    throw new UnmarshallException
			("bean " + clazz.getName() + "can't invoke " +
			 setMethod.getName() + ": " + e.getMessage());
		}
	    }
	}
	return instance;
    }

    public Object marshall(SerializerState state, Object o)
	throws MarshallException
    {
	BeanSerializerState beanState;
	try {
	    beanState = (BeanSerializerState)
		state.get(BeanSerializerState.class);
	} catch (Exception e) {
	    throw new MarshallException("bean serializer internal error");
	}
	Integer identity = new Integer(System.identityHashCode (o));
	if(beanState.beanSet.contains(identity))
	    throw new MarshallException("circular reference");
	beanState.beanSet.add(identity);

	BeanData bd = null;
	try {
	    bd = getBeanData(o.getClass());
	} catch (IntrospectionException e) {
	    throw new MarshallException
		(o.getClass().getName() + " is not a bean");
	}
    
	JSONObject val = new JSONObject();
        if (ser.getMarshallClassHints())
            val.put("javaClass", o.getClass().getName());
	Iterator i = bd.readableProps.entrySet().iterator();
	Object args[] = new Object[0];
	Object result = null;
	while(i.hasNext()) {
	    Map.Entry ent = (Map.Entry)i.next();
	    String prop = (String)ent.getKey();
	    Method getMethod = (Method)ent.getValue();
	    if(ser.isDebug())
		log.fine("invoking " + getMethod.getName() + "()");
	    try {
		result = getMethod.invoke(o, args);
	    } catch (Throwable e) {
		if(e instanceof InvocationTargetException)
		    e = ((InvocationTargetException)e).
			getTargetException();
		throw new MarshallException
		    ("bean " + o.getClass().getName() + " can't invoke " +
		     getMethod.getName() + ": " + e.getMessage());
	    }
	    try {
                if (result != null || ser.getMarshallNullAttributes()) 
                    val.put(prop, ser.marshall(state, result));
	    } catch (MarshallException e) {
		throw new MarshallException
		    ("bean " + o.getClass().getName() + " " + e.getMessage());
	    }
	}

	beanState.beanSet.remove(identity);
	return val;
    }
}