Examples with RootPackages jodd.madvoc.RootPackages used on opensource projects

Example 1 with RootPackages

use of jodd.madvoc.RootPackages in project jodd by oblac.

the class ActionMethodParser method readPackageActionPath.

// ---------------------------------------------------------------- readers
/**
	 * Reads action path for package. It can be used only if root package is set in
	 * {@link MadvocConfig madvoc configuration}.
	 * If annotation is not set on package-level, class package will be used for
	 * package action path part.
	 */
protected void readPackageActionPath(ActionNames actionNames, Class actionClass) {
    Package actionPackage = actionClass.getPackage();
    String actionPackageName = actionPackage.getName();
    final RootPackages rootPackages = madvocConfig.getRootPackages();
    String packagePath = rootPackages.getPackageActionPath(actionPackageName);
    if (packagePath == null) {
        packagePath = rootPackages.findPackagePathForActionPackage(actionPackageName);
        String rootPackage = null;
        if (packagePath != null) {
            rootPackage = rootPackages.findRootPackageForActionPath(packagePath);
        }
        // try locating marker class
        {
            String packageName = actionPackageName;
            String madvocRootPackageClassName = madvocConfig.getMadvocRootPackageClassName();
            if (madvocRootPackageClassName != null) {
                while (true) {
                    String className = packageName + '.' + madvocRootPackageClassName;
                    try {
                        Class<?> madvocRootPackageClass = ClassLoaderUtil.loadClass(className, actionClass.getClassLoader());
                        // class found, find the mapping
                        String mapping = StringPool.EMPTY;
                        MadvocAction madvocAction = madvocRootPackageClass.getAnnotation(MadvocAction.class);
                        if (madvocAction != null) {
                            mapping = madvocAction.value();
                        }
                        // register root package - so not to lookup twice
                        madvocConfig.getRootPackages().addRootPackage(packageName, mapping);
                        // repeat lookup
                        packagePath = rootPackages.findPackagePathForActionPackage(actionPackageName);
                        break;
                    } catch (ClassNotFoundException ignore) {
                        // continue
                        int dotNdx = packageName.lastIndexOf('.');
                        if (dotNdx == -1) {
                            break;
                        }
                        packageName = packageName.substring(0, dotNdx);
                        if (rootPackage != null) {
                            // don't go beyond found root package
                            if (packageName.equals(rootPackage)) {
                                break;
                            }
                        }
                    }
                }
            }
        }
        rootPackages.registerPackageActionPath(actionPackageName, packagePath);
    }
    // read package-level annotation
    MadvocAction madvocActionAnnotation = actionPackage.getAnnotation(MadvocAction.class);
    String packageActionPath = madvocActionAnnotation != null ? madvocActionAnnotation.value().trim() : null;
    if (StringUtil.isEmpty(packageActionPath)) {
        packageActionPath = null;
    }
    // if not set, resolve value
    if (packageActionPath == null) {
        // no package-level annotation
        if (packagePath == null) {
            // no root package path, just return
            return;
        }
        packageActionPath = packagePath;
    }
    actionNames.setPackageNames(StringUtil.stripChar(packagePath, '/'), StringUtil.surround(packageActionPath, StringPool.SLASH));
}