Examples with UnknownHandlerConfig com.opensymphony.xwork2.config.entities.UnknownHandlerConfig used on opensource projects

Example 1 with UnknownHandlerConfig

use of com.opensymphony.xwork2.config.entities.UnknownHandlerConfig in project struts by apache.

the class XmlConfigurationProvider method register.

public void register(ContainerBuilder containerBuilder, LocatableProperties props) throws ConfigurationException {
    LOG.trace("Parsing configuration file [{}]", configFileName);
    Map<String, Node> loadedBeans = new HashMap<>();
    for (Document doc : documents) {
        Element rootElement = doc.getDocumentElement();
        NodeList children = rootElement.getChildNodes();
        int childSize = children.getLength();
        for (int i = 0; i < childSize; i++) {
            Node childNode = children.item(i);
            if (childNode instanceof Element) {
                Element child = (Element) childNode;
                final String nodeName = child.getNodeName();
                if ("bean-selection".equals(nodeName)) {
                    String name = child.getAttribute("name");
                    String impl = child.getAttribute("class");
                    try {
                        Class classImpl = ClassLoaderUtil.loadClass(impl, getClass());
                        if (BeanSelectionProvider.class.isAssignableFrom(classImpl)) {
                            BeanSelectionProvider provider = (BeanSelectionProvider) classImpl.newInstance();
                            provider.register(containerBuilder, props);
                        } else {
                            throw new ConfigurationException("The bean-provider: name:" + name + " class:" + impl + " does not implement " + BeanSelectionProvider.class.getName(), childNode);
                        }
                    } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
                        throw new ConfigurationException("Unable to load bean-provider: name:" + name + " class:" + impl, e, childNode);
                    }
                } else if ("bean".equals(nodeName)) {
                    String type = child.getAttribute("type");
                    String name = child.getAttribute("name");
                    String impl = child.getAttribute("class");
                    String onlyStatic = child.getAttribute("static");
                    String scopeStr = child.getAttribute("scope");
                    boolean optional = "true".equals(child.getAttribute("optional"));
                    Scope scope;
                    if ("prototype".equals(scopeStr)) {
                        scope = Scope.PROTOTYPE;
                    } else if ("request".equals(scopeStr)) {
                        scope = Scope.REQUEST;
                    } else if ("session".equals(scopeStr)) {
                        scope = Scope.SESSION;
                    } else if ("singleton".equals(scopeStr)) {
                        scope = Scope.SINGLETON;
                    } else if ("thread".equals(scopeStr)) {
                        scope = Scope.THREAD;
                    } else {
                        scope = Scope.SINGLETON;
                    }
                    if (StringUtils.isEmpty(name)) {
                        name = Container.DEFAULT_NAME;
                    }
                    try {
                        Class classImpl = ClassLoaderUtil.loadClass(impl, getClass());
                        Class classType = classImpl;
                        if (StringUtils.isNotEmpty(type)) {
                            classType = ClassLoaderUtil.loadClass(type, getClass());
                        }
                        if ("true".equals(onlyStatic)) {
                            // Force loading of class to detect no class def found exceptions
                            classImpl.getDeclaredClasses();
                            containerBuilder.injectStatics(classImpl);
                        } else {
                            if (containerBuilder.contains(classType, name)) {
                                Location loc = LocationUtils.getLocation(loadedBeans.get(classType.getName() + name));
                                if (throwExceptionOnDuplicateBeans) {
                                    throw new ConfigurationException("Bean type " + classType + " with the name " + name + " has already been loaded by " + loc, child);
                                }
                            }
                            // Force loading of class to detect no class def found exceptions
                            classImpl.getDeclaredConstructors();
                            LOG.debug("Loaded type: {} name: {} impl: {}", type, name, impl);
                            containerBuilder.factory(classType, name, new LocatableFactory(name, classType, classImpl, scope, childNode), scope);
                        }
                        loadedBeans.put(classType.getName() + name, child);
                    } catch (Throwable ex) {
                        if (!optional) {
                            throw new ConfigurationException("Unable to load bean: type:" + type + " class:" + impl, ex, childNode);
                        } else {
                            LOG.debug("Unable to load optional class: {}", impl);
                        }
                    }
                } else if ("constant".equals(nodeName)) {
                    String name = child.getAttribute("name");
                    String value = child.getAttribute("value");
                    if (valueSubstitutor != null) {
                        LOG.debug("Substituting value [{}] using [{}]", value, valueSubstitutor.getClass().getName());
                        value = valueSubstitutor.substitute(value);
                    }
                    props.setProperty(name, value, childNode);
                } else if (nodeName.equals("unknown-handler-stack")) {
                    List<UnknownHandlerConfig> unknownHandlerStack = new ArrayList<UnknownHandlerConfig>();
                    NodeList unknownHandlers = child.getElementsByTagName("unknown-handler-ref");
                    int unknownHandlersSize = unknownHandlers.getLength();
                    for (int k = 0; k < unknownHandlersSize; k++) {
                        Element unknownHandler = (Element) unknownHandlers.item(k);
                        Location location = LocationUtils.getLocation(unknownHandler);
                        unknownHandlerStack.add(new UnknownHandlerConfig(unknownHandler.getAttribute("name"), location));
                    }
                    if (!unknownHandlerStack.isEmpty())
                        configuration.setUnknownHandlerStack(unknownHandlerStack);
                }
            }
        }
    }
}

Example 2 with UnknownHandlerConfig

use of com.opensymphony.xwork2.config.entities.UnknownHandlerConfig in project struts by apache.

the class DefaultUnknownHandlerManager method build.

/**
 * Builds a list of UnknownHandlers in the order specified by the configured "unknown-handler-stack".
 * If "unknown-handler-stack" was not configured, all UnknownHandlers will be returned, in no specific order
 *
 * @throws Exception in case of any error
 */
protected void build() throws Exception {
    Configuration configuration = container.getInstance(Configuration.class);
    ObjectFactory factory = container.getInstance(ObjectFactory.class);
    if (configuration != null && container != null) {
        List<UnknownHandlerConfig> unkownHandlerStack = configuration.getUnknownHandlerStack();
        unknownHandlers = new ArrayList<>();
        if (unkownHandlerStack != null && !unkownHandlerStack.isEmpty()) {
            // get UnknownHandlers in the specified order
            for (UnknownHandlerConfig unknownHandlerConfig : unkownHandlerStack) {
                UnknownHandler uh = factory.buildUnknownHandler(unknownHandlerConfig.getName(), new HashMap<String, Object>());
                unknownHandlers.add(uh);
            }
        } else {
            // add all available UnknownHandlers
            Set<String> unknownHandlerNames = container.getInstanceNames(UnknownHandler.class);
            for (String unknownHandlerName : unknownHandlerNames) {
                UnknownHandler uh = container.getInstance(UnknownHandler.class, unknownHandlerName);
                unknownHandlers.add(uh);
            }
        }
    }
}

Example 3 with UnknownHandlerConfig

use of com.opensymphony.xwork2.config.entities.UnknownHandlerConfig in project struts by apache.

the class XmlConfigurationProviderUnknownHandlerStackTest method testEmptyStack.

public void testEmptyStack() throws ConfigurationException {
    final String filename = "com/opensymphony/xwork2/config/providers/xwork-unknownhandler-stack-empty.xml";
    ConfigurationProvider provider = buildConfigurationProvider(filename);
    loadConfigurationProviders(provider);
    configurationManager.reload();
    List<UnknownHandlerConfig> unknownHandlerStack = configuration.getUnknownHandlerStack();
    assertNull(unknownHandlerStack);
}

Example 4 with UnknownHandlerConfig

use of com.opensymphony.xwork2.config.entities.UnknownHandlerConfig in project struts by apache.

the class StrutsJavaConfigurationProvider method register.

@Override
public void register(ContainerBuilder builder, LocatableProperties props) throws ConfigurationException {
    Map<String, Object> loadedBeans = new HashMap<>();
    // bean
    List<BeanConfig> beanConfigs = javaConfig.beans();
    if (beanConfigs != null) {
        for (BeanConfig bc : beanConfigs) {
            if (bc != null) {
                registerBean(loadedBeans, builder, bc);
            }
        }
    }
    // constant
    List<ConstantConfig> constantConfigList = javaConfig.constants();
    if (constantConfigList != null) {
        for (ConstantConfig constantConf : constantConfigList) {
            if (constantConf != null) {
                Map<String, String> constantMap = constantConf.getAllAsStringsMap();
                for (Entry<String, String> entr : constantMap.entrySet()) {
                    if (entr.getKey() != null && entr.getValue() != null) {
                        registerConstant(props, entr.getKey(), entr.getValue());
                    }
                }
            }
        }
    }
    // bean-selection
    javaConfig.beanSelection().ifPresent(beanSelectionConfig -> {
        try {
            LOG.debug("Registering bean selection provider {} of type {}", beanSelectionConfig.getName(), beanSelectionConfig.getClazz().getName());
            BeanSelectionProvider provider = beanSelectionConfig.getClazz().newInstance();
            provider.register(builder, props);
        } catch (IllegalAccessException | InstantiationException e) {
            throw new ConfigurationException("Unable to load : name:" + beanSelectionConfig.getName() + " class:" + beanSelectionConfig.getClazz().getName());
        }
    });
    // unknown-handler-stack
    List<String> unknownHandlers = javaConfig.unknownHandlerStack();
    if (unknownHandlers != null) {
        List<UnknownHandlerConfig> unknownHandlerStack = new ArrayList<>();
        for (String unknownHandler : unknownHandlers) {
            Location location = LocationUtils.getLocation(unknownHandler);
            unknownHandlerStack.add(new UnknownHandlerConfig(unknownHandler, location));
        }
        if (!unknownHandlerStack.isEmpty()) {
            configuration.setUnknownHandlerStack(unknownHandlerStack);
        }
    }
}

Example 5 with UnknownHandlerConfig

use of com.opensymphony.xwork2.config.entities.UnknownHandlerConfig in project struts by apache.

the class XmlConfigurationProviderUnknownHandlerStackTest method testStackWithElements.

public void testStackWithElements() throws ConfigurationException {
    final String filename = "com/opensymphony/xwork2/config/providers/xwork-unknownhandler-stack.xml";
    ConfigurationProvider provider = buildConfigurationProvider(filename);
    loadConfigurationProviders(provider);
    configurationManager.reload();
    List<UnknownHandlerConfig> unknownHandlerStack = configuration.getUnknownHandlerStack();
    assertNotNull(unknownHandlerStack);
    assertEquals(2, unknownHandlerStack.size());
    assertEquals("uh1", unknownHandlerStack.get(0).getName());
    assertEquals("uh2", unknownHandlerStack.get(1).getName());
    UnknownHandlerManager unknownHandlerManager = new DefaultUnknownHandlerManager();
    container.inject(unknownHandlerManager);
    assertTrue(unknownHandlerManager.hasUnknownHandlers());
}