Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014-2015 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.lastaflute.di.redefiner.core;
 
 import java.util.List;
 

Author(s):
modified by jflute (originated in Ymir)
 
 
     public static final String METHODPREFIX_DEFINE = "define";
 
     public static final String METHODPREFIX_NEW = "new";
 
     public static final String METHODPREFIX_DESTROY = "destroy";
 
     public static final String SUFFIX = ".class";
 
     private static final String JAR_SUFFIX = ".jar!/";
 
     private static final String DELIMITER = "_";
 
     public LaContainer build(String path) {
         return build(nullpath);
     }
 
     LaContainer build(LaContainer parentString path) {
         LaContainer container = createContainer(parentpath);
         Class<? extends LaContainerPreparerpreparerClass = getPreparerClass(path);
 
         LaContainerPreparer preparer;
         try {
             preparer = preparerClass.newInstance();
         } catch (InstantiationException ex) {
             throw new RuntimeException("Can't instanciate Preparer: " + pathex);
         } catch (IllegalAccessException ex) {
             throw new RuntimeException("Can't instanciate Preparer: " + pathex);
         }
         container.register(preparer);
         preparer.setContainer(container);
 
         Dicon dicon = preparerClass.getAnnotation(Dicon.class);
         if (dicon != null && dicon.namespace().length() > 0) {
             container.setNamespace(dicon.namespace());
         }
 
         preparer.include();
         registerComponentDefs(containerpreparer);
 
         String additionalDiconPath = constructAdditionalDiconPath(path);
         if (LaContainerBuilderUtils.resourceExists(additionalDiconPaththis)) {
             LaContainerBuilderUtils.mergeContainer(container, LaContainerFactory.create(additionalDiconPath));
         }
 
         return container;
     }
 
     protected ClassLoader getClassLoader() {
        return Thread.currentThread().getContextClassLoader();
    }
    protected String constructAdditionalDiconPath(String path) {
        return constructRedifinitionDiconPath(pathnull);
    }
    LaContainer createContainer(LaContainer parentString path) {
        LaContainer container = new LaContainerImpl();
        container.setPath(path);
        if (parent != null) {
            container.setRoot(parent.getRoot());
        }
        return container;
    }
    void registerComponentDefs(LaContainer containerLaContainerPreparer preparer) {
        Method[] methods = preparer.getClass().getMethods();
        for (int i = 0; i < methods.lengthi++) {
            String name = methods[i].getName();
            if (name.startsWith()) {
                registerComponentDef(containermethods[i], preparer);
            }
        }
    }
    void registerComponentDef(LaContainer containerMethod methodLaContainerPreparer preparer) {
        ComponentDef componentDef = constructComponentDef(methodpreparer);
        if (componentDef.getComponentName() != null) {
            componentDef = redefine(componentDefcontainer.getPath());
        }
        container.register(componentDef);
    }
    ComponentDef redefine(ComponentDef componentDefString path) {
        String name = componentDef.getComponentName();
        String diconPath = constructRedifinitionDiconPath(pathname);
        if (!LaContainerBuilderUtils.resourceExists(diconPaththis)) {
            return componentDef;
        }
        LaContainer container = LaContainerFactory.create(diconPath);
        if (!container.hasComponentDef(name)) {
            throw new RuntimeException("Can't find component definition named '" + name + "' in " + diconPath);
        }
        return container.getComponentDef(name);
    }
    protected String constructRedifinitionDiconPath(String pathString name) {
        String body;
        String suffix;
        int dot = path.lastIndexOf('.');
        if (dot < 0) {
            body = path;
            suffix = "";
        } else {
            body = path.substring(0, dot);
            suffix = path.substring(dot);
        }
        if (name == null) {
            name = "";
        }
        return body +  + name + suffix;
    }
        AnnotationHandler annoHandler = AnnotationHandlerFactory.getAnnotationHandler();
        String componentName = ClassBuilderUtils.toComponentName(method.getName().substring(.length()));
        Class<?>[] parameterTypes = method.getParameterTypes();
        if (parameterTypes.length != 1) {
            throw new RuntimeException("Definition method must have only one parameter but " + parameterTypes.length + ": "
                    + method.getName());
        }
        Class<?> componentClass = parameterTypes[0];
        Class<?>[] constructorParameterTypes = new Class[parameterTypes.length - 1];
        System.arraycopy(parameterTypes, 1, constructorParameterTypes, 0, constructorParameterTypes.length);
        ComponentDef componentDef = annoHandler.createComponentDef(componentClassnull);
        componentDef.setComponentName(componentName);
        annoHandler.appendDI(componentDef);
        annoHandler.appendAspect(componentDef);
        annoHandler.appendInterType(componentDef);
        Component componentAnnotation = method.getAnnotation(Component.class);
        if (componentAnnotation != null) {
            componentDef.setInstanceDef(InstanceDefFactory.getInstanceDef(componentAnnotation.instance().getName()));
            componentDef.setAutoBindingDef(AutoBindingDefFactory.getAutoBindingDef(componentAnnotation.autoBinding().getName()));
            componentDef.setExternalBinding(componentAnnotation.externalBinding());
        }
        Aspect aspectAnnotation = method.getAnnotation(Aspect.class);
        if (aspectAnnotation != null) {
            AspectDef aspectDef = AspectDefFactory.createAspectDef(aspectAnnotation.value(), aspectAnnotation.pointcut());
            componentDef.addAspectDef(aspectDef);
        }
        annoHandler.appendInitMethod(componentDef);
        annoHandler.appendDestroyMethod(componentDef);
        InitMethodDef initMethodDef = new InitMethodDefImpl(method);
        ArgDef argDef = new ArgDefImpl(preparer);
        initMethodDef.addArgDef(argDef);
        componentDef.addInitMethodDef(initMethodDef);
        Method destroyMethod = ClassBuilderUtils.findMethod(preparer.getClass(), componentName);
        if (destroyMethod != null) {
            DestroyMethodDef destroyMethodDef = new DestroyMethodDefImpl(destroyMethod);
            argDef = new ArgDefImpl(preparer);
            destroyMethodDef.addArgDef(argDef);
            componentDef.addDestroyMethodDef(destroyMethodDef);
        }
        return componentDef;
    }
    @SuppressWarnings("unchecked")
    protected Class<? extends LaContainerPreparergetPreparerClass(String path) {
        ClassLoader classLoader = getClassLoaderForLoadingPreparer();
        Class<?> clazz;
        if (path.indexOf(':') < 0) {
            clazz = getClassFromClassName(pathclassLoader);
        } else {
            clazz = getClassFromURL(pathclassLoader);
        }
        if (clazz == null) {
            throw new RuntimeException("Class not found: " + path);
        }
        if (LaContainerPreparer.class.isAssignableFrom(clazz)) {
            return (Class<? extends LaContainerPreparer>) clazz;
        } else {
            throw new RuntimeException("Not Preparer: " + path);
        }
    }
    protected Class<?> getClassFromURL(String pathClassLoader classLoader) {
        String[] classNames;
        int jarSuffix = path.indexOf();
        if (jarSuffix >= 0) {
            // Jar。
            classNames =
                    new String[] { path.substring(jarSuffix + .length(), path.length() - .length()).replace('/''.') };
        } else {
            path = path.substring(path.indexOf(':') + 1, path.length() - .length()).replace('/''.');
            List<StringclassNameList = new ArrayList<String>();
            int len = path.length();
            for (int i = len - 1; i >= 0; i--) {
                if (path.charAt(i) == '.') {
                    classNameList.add(path.substring(i + 1));
                }
            }
            classNames = classNameList.toArray(new String[0]);
        }
        for (int i = 0; i < classNames.lengthi++) {
            try {
                return Class.forName(classNames[i], trueclassLoader);
            } catch (ClassNotFoundException ignore) {}
        }
        return null;
    }
    Class<?> getClassFromClassName(String pathClassLoader classLoader) {
        String className = path.substring(0, path.length() - .length()).replace('/''.');
        try {
            return Class.forName(classNametrueclassLoader);
        } catch (ClassNotFoundException ex) {
            return null;
        }
    }
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        // S2Container関連のクラスがコンテキストクラスローダから見えない場合に備えてこうしている。
        return new CompositeClassLoader(new ClassLoader[] { classLoadergetClass().getClassLoader() });
    }
    public LaContainer include(LaContainer parentString path) {
        LaContainer child = build(parentpath);
        parent.include(child);
        return child;
    }
New to GrepCode? Check out our FAQ X