reflectionclassdirector.java

Java的面向对象数据库系统的源代码

// You can redistribute this software and/or modify it under the terms of
// the Ozone Library License version 1 published by ozone-db.org.
//
// The original code and portions created by SMB are
// Copyright (C) 1997-@year@ by SMB GmbH. All rights reserved.
//
// $Id: ReflectionClassDirector.java,v 1.4 2003/11/27 13:26:03 leomekenkamp Exp $
package org.ozoneDB.tools.OPP.srcgen.direct;

import org.ozoneDB.tools.OPP.srcgen.MethodResolver;
import org.ozoneDB.tools.OPP.srcgen.ResolverException;
import org.ozoneDB.tools.OPP.srcgen.ClassBuilder;
import org.ozoneDB.tools.OPP.srcgen.BuilderException;
import org.ozoneDB.tools.OPP.srcgen.ClassDirector;
import org.ozoneDB.tools.OPP.srcgen.resolve.UpdateMethodBagMapAdapter;
import org.ozoneDB.tools.OPP.message.MessageWriter;
import org.ozoneDB.core.Lock;
import org.ozoneDB.OzoneRemote;
import org.ozoneDB.OzoneCompatible;

import java.util.Set;
import java.util.HashSet;
import java.util.Map;
import java.util.HashMap;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;

/**
 * This ClassDirector uses reflection as the foundation of directs.
 * In order to determine the LockLevel of the different methods the Director can be paired with an UpdateMethodResolver..
 *
 * @author Joakim Ohlrogge
 */
public class ReflectionClassDirector implements ClassDirector {
    private MethodResolver resolver;
    private Class filterInterface;
    private Set processedMethods;
    private MessageWriter msgWriter;

    public ReflectionClassDirector(MessageWriter msgListener, MethodResolver resolver) {
        this(msgListener, resolver, OzoneRemote.class);
    }

    public ReflectionClassDirector(MessageWriter msgListener, MethodResolver resolver, Class filterInterface) {
        this.msgWriter = msgListener;
        this.resolver = resolver;
        this.filterInterface = filterInterface;
        this.processedMethods = new HashSet();
    }

    public void build(String fullClassName, ClassBuilder builder) throws BuilderException {
        msgWriter.startGeneration("Processing " + fullClassName);
        try {
            Map updateMethods = new HashMap();
            processedMethods.clear();
            msgWriter.startGeneration("Resolving update methods");
            MethodResolver.UpdateMethodBag methodBag = new UpdateMethodBagMapAdapter(updateMethods);
            try {
                resolver.resolveMethods(fullClassName, methodBag);
            } catch (ResolverException e) {
                throw new BuilderException(e);
            } finally {
                msgWriter.endGeneration();
            }
            Class sourceClass;
            try {
                sourceClass = Class.forName(fullClassName);
                if (sourceClass.isInterface()) {
                    throw new BuilderException(fullClassName + " is an interface, should be a class");
                }
                if (!OzoneCompatible.class.isAssignableFrom(sourceClass)) {
                    throw new BuilderException("The class " + fullClassName + " must extend OzoneObject or implement OzoneCompatible");
                }
            } catch (ClassNotFoundException e) {
                throw new BuilderException(e);
            }
            Class clazz = sourceClass.getSuperclass();
            String superClassName;
            if (clazz == null) {
                throw new BuilderException("No superclass exist for " + fullClassName);
            } else {
                superClassName = clazz.getName();
                //msgWriter.info("superclass for " + fullClassName + " is " + superClassName);
            }

            String interfaces[] = getClassNames(sourceClass.getInterfaces());

            // init builder
            builder.init(msgWriter);

            // Start of class
            builder.beginClass(sourceClass.getModifiers(), fullClassName, superClassName, interfaces);

            // Make constructors
            Constructor constructors[] = sourceClass.getConstructors();
            for (int i = 0; i < constructors.length; ++i) {
                Constructor constructor = constructors[i];
                ClassBuilder.Parameter parameters[] = getParameters(constructor.getParameterTypes());
                String exceptions[] = getClassNames(constructor.getExceptionTypes());
                builder.makeConstructor(constructor.getModifiers(), parameters, exceptions);
            }
            Class itfs[] = sourceClass.getInterfaces();
            for (int i = 0; i < itfs.length; i++) {
                Class itf = itfs[i];
                // filter out all interfaces that are not assignable from the filter interface
                if (!filterInterface.isAssignableFrom(itf))
                    continue;
                buildMethodsDeep(itf, builder, updateMethods);
            }


            // end of class
            builder.endClass();
        } finally {
            msgWriter.endGeneration();
        }
    }

    private void buildMethodsDeep(Class itf, ClassBuilder builder, Map updateMethods) throws BuilderException {
        // Make methods
        Method methods[] = itf.getMethods();
        for (int j = 0; j < methods.length; ++j) {
            Method method = methods[j];
            // Don't process a method that has already been processed
            // Mark methods as processed that aren't already marked.
            if (isProcessedAndMarkMethod(method))
                continue;
            ClassBuilder.Parameter parameters[] = getParameters(method.getParameterTypes());
            String exceptions[] = getClassNames(method.getExceptionTypes());
            Integer lockLevel = updateMethods.keySet().contains(method.getName()) ? (Integer) updateMethods.get(method.getName()) : new Integer(Lock.LEVEL_READ);
            int iLevel = lockLevel.intValue();
            if (iLevel > Lock.LEVEL_READ)
                msgWriter.info("update method [" + lockLevel + "]: " + method.getName());

            String retType = typecodeForClass(method.getReturnType());
            if (retType.equals("void"))
                retType = null;
            builder.makeMethod(method.getModifiers(), method.getName(), parameters, retType
                    , exceptions, lockLevel.intValue());
        }
    }

    private boolean isProcessedAndMarkMethod(Method method) {
        StringBuffer signatureBuf = new StringBuffer();
        signatureBuf.append("   public " + typecodeForClass(method.getReturnType()) + " " + method.getName() + "(");
        Class[] args = method.getParameterTypes();
        for (int i = 0; i < args.length; i++) {
            if (i != 0) {
                signatureBuf.append(", ");
            }
            signatureBuf.append(typecodeForClass(args[i]) + " arg" + i);
        }
        signatureBuf.append(")");
        String signatureStr = signatureBuf.toString();
        if (!processedMethods.contains(signatureStr)) {
            msgWriter.debug("Processing method: " + signatureStr);
            processedMethods.add(signatureStr);
            return false;
        } else {
            return true;
        }
    }

    /**
     Returns the name of the class in the way it is used within resolver code.
     This is similar to the internal class name with the exception that names of inner
     classes separate between class levels not by '$' but by '.'.
     */
    private String getSourcecodeClassName(String cl) {
        return cl.replace('$', '.');
    }

    private String[] getClassNames(Class types[]) {
        String classNames[] = new String[types.length];
        for (int i = 0; i < types.length; ++i) {
            classNames[i] = getSourcecodeClassName(types[i].getName());
        }
        return classNames;
    }

    protected String typecodeForClass(Class cl) {
        String ret;
        // array

        if (cl.isArray()) {
            StringBuffer b = new StringBuffer();
            while (cl.isArray()) {
                b.append("[]");
                cl = cl.getComponentType();
            }
            b.insert(0, getSourcecodeClassName(cl.getName()));
            ret = b.toString();
        } else {
            // norgetSourcecodeClassName(implementationClass)reference and primitive types

            ret = getSourcecodeClassName(cl.getName());
        }
        return ret;
    }

    private ClassBuilder.Parameter[] getParameters(Class parameterTypes[]) {
        ClassBuilder.Parameter parameters[] = new ClassBuilder.Parameter[parameterTypes.length];
        for (int j = 0; j < parameters.length; ++j) {
            parameters[j] = new ClassBuilder.Parameter(typecodeForClass(parameterTypes[j]), "arg" + j, parameterTypes[j].getName(), 0);
        }
        return parameters;
    }
}