[jboss-user] [JBoss Seam] - Re: Hot deploy error
gmoraes
do-not-reply at jboss.com
Tue Apr 10 15:31:19 EDT 2007
I was trying to use hotdeploy in tomcat 5.5 with components registered in /WEB-INF/dev/META-INF/components.xml and got some problems so I made some little corrections in Initialization.java.
Please verify the changes e test if I created some type of problem.
| /*
| * JBoss, Home of Professional Open Source
| *
| * Distributable under LGPL license. See terms of license at gnu.org.
| */
| package org.jboss.seam.init;
|
| import java.io.File;
| import java.io.IOException;
| import java.io.InputStream;
| import java.net.MalformedURLException;
| import java.net.URL;
| import java.net.URLClassLoader;
| import java.util.ArrayList;
| import java.util.Enumeration;
| import java.util.HashMap;
| import java.util.HashSet;
| import java.util.List;
| import java.util.Map;
| import java.util.Properties;
| import java.util.Set;
| import java.util.StringTokenizer;
| import java.util.TreeSet;
|
| import javax.servlet.ServletContext;
| import javax.servlet.http.HttpSession;
|
| import org.dom4j.Attribute;
| import org.dom4j.DocumentException;
| import org.dom4j.Element;
| import org.jboss.seam.Component;
| import org.jboss.seam.ScopeType;
| import org.jboss.seam.Seam;
| import org.jboss.seam.annotations.Install;
| import org.jboss.seam.annotations.Name;
| import org.jboss.seam.annotations.Namespace;
| import org.jboss.seam.annotations.Role;
| import org.jboss.seam.annotations.Roles;
| import org.jboss.seam.contexts.Context;
| import org.jboss.seam.contexts.Contexts;
| import org.jboss.seam.contexts.Lifecycle;
| import org.jboss.seam.core.Expressions;
| import org.jboss.seam.core.Init;
| import org.jboss.seam.core.Jbpm;
| import org.jboss.seam.core.PojoCache;
| import org.jboss.seam.deployment.ComponentScanner;
| import org.jboss.seam.deployment.NamespaceScanner;
| import org.jboss.seam.log.LogProvider;
| import org.jboss.seam.log.Logging;
| import org.jboss.seam.util.Conversions;
| import org.jboss.seam.util.Naming;
| import org.jboss.seam.util.Reflections;
| import org.jboss.seam.util.Resources;
| import org.jboss.seam.util.Strings;
| import org.jboss.seam.util.XML;
|
| /**
| * @author Gavin King
| * @author <a href="mailto:theute at jboss.org">Thomas Heute</a>
| * @version $Revision: 1.166 $
| */
| public class Initialization
| {
| public static final String COMPONENT_SUFFIX = ".component";
| private static final LogProvider log = Logging.getLogProvider(Initialization.class);
|
| private ServletContext servletContext;
| private Map<String, Conversions.PropertyValue> properties = new HashMap<String, Conversions.PropertyValue>();
| private Map<String, Set<ComponentDescriptor>> componentDescriptors = new HashMap<String, Set<ComponentDescriptor>>();
| private List<FactoryDescriptor> factoryDescriptors = new ArrayList<FactoryDescriptor>();
| private Set<Class> installedComponentClasses = new HashSet<Class>();
| private Set<String> importedPackages = new HashSet<String>();
| private Map<String, NamespaceDescriptor> namespaceMap = new HashMap<String, NamespaceDescriptor>();
| private final Map<String, EventListenerDescriptor> eventListenerDescriptors = new HashMap<String, EventListenerDescriptor>();
|
| private File[] hotDeployPaths;
| private ClassLoader hotDeployClassLoader;
|
| public Initialization(ServletContext servletContext)
| {
| this.servletContext = servletContext;
| }
|
| public Initialization create()
| {
| addNamespaces();
| initComponentsFromXmlDocument("/WEB-INF/components.xml");
| initComponentsFromXmlDocument("/WEB-INF/events.xml"); //deprecated
| initComponentsFromXmlDocuments();
| initPropertiesFromServletContext();
| initPropertiesFromResource();
| initJndiProperties();
| return this;
| }
|
| private void initComponentsFromXmlDocuments()
| {
| ClassLoader cl = Thread.currentThread().getContextClassLoader();
| if (hotDeployClassLoader != null) {
| // Must create a new ClassLoader without parent resources to prevent
| // error of duplicate component registration
| URL[] urls = ((URLClassLoader)hotDeployClassLoader).getURLs();
| cl = new URLClassLoader(urls);
| }
| Enumeration<URL> resources;
| try
| {
| resources = cl.getResources("META-INF/components.xml");
| }
| catch (IOException ioe)
| {
| throw new RuntimeException("error scanning META-INF/components.xml files", ioe);
| }
|
| Properties replacements = getReplacements();
| while (resources.hasMoreElements())
| {
| URL url = resources.nextElement();
| try
| {
| log.info("reading " + url);
| installComponentsFromXmlElements( XML.getRootElement( url.openStream() ), replacements );
| }
| catch (Exception e)
| {
| throw new RuntimeException("error while reading " + url, e);
| }
| }
|
| }
|
| private void initComponentsFromXmlDocument(String resource)
| {
| InputStream stream = Resources.getResourceAsStream(resource, servletContext);
| if (stream != null)
| {
| log.info("reading " + resource);
| try
| {
| installComponentsFromXmlElements( XML.getRootElement(stream), getReplacements() );
| }
| catch (Exception e)
| {
| throw new RuntimeException("error while reading /WEB-INF/components.xml", e);
| }
| }
| }
|
| private Properties getReplacements()
| {
| try
| {
| Properties replacements = new Properties();
| InputStream replaceStream = Resources.getResourceAsStream("components.properties");
| if (replaceStream != null) replacements.load(replaceStream);
| return replacements;
| }
| catch (IOException ioe)
| {
| throw new RuntimeException("error reading components.properties", ioe);
| }
| }
|
| @SuppressWarnings("unchecked")
| private void installComponentsFromXmlElements(Element rootElement, Properties replacements)
| throws DocumentException, ClassNotFoundException
| {
| List<Element> importElements = rootElement.elements("import-java-package");
| for (Element importElement : importElements)
| {
| String pkgName = importElement.getTextTrim();
| importedPackages.add(pkgName);
| addNamespace(Package.getPackage(pkgName));
| }
|
| List<Element> componentElements = rootElement.elements("component");
| for (Element component : componentElements)
| {
| installComponentFromXmlElement(component, component.attributeValue("name"), component
| .attributeValue("class"), replacements);
| }
|
| List<Element> factoryElements = rootElement.elements("factory");
| for (Element factory : factoryElements)
| {
| installFactoryFromXmlElement(factory);
| }
|
| List<Element> elements = rootElement.elements("event");
| for (Element event: elements)
| {
| installEventListenerFromXmlElement(event);
| }
|
| for (Element elem : (List<Element>) rootElement.elements())
| {
| String ns = elem.getNamespace().getURI();
| NamespaceDescriptor nsInfo = namespaceMap.get(ns);
| if (nsInfo != null)
| {
| String name = elem.attributeValue("name");
| String elemName = toCamelCase( elem.getName(), true );
|
| String className = nsInfo.getPackage().getName() + '.' + elemName;
| try
| {
| //get the class implied by the namespaced XML element name
| Class<Object> clazz = Reflections.classForName(className);
| Name nameAnnotation = clazz.getAnnotation(Name.class);
|
| //if the name attribute is not explicitly specified in the XML,
| //imply the name from the @Name annotation on the class implied
| //by the XML element name
| if (name == null && nameAnnotation!=null)
| {
| name = nameAnnotation.value();
| }
|
| //if this class already has the @Name annotation, the XML element
| //is just adding configuration to the existing component, don't
| //add another ComponentDescriptor (this is super-important to
| //allow overriding!)
| if ( nameAnnotation!=null && nameAnnotation.value().equals(name) )
| {
| Install install = clazz.getAnnotation(Install.class);
| if ( install == null || install.value() )
| {
| className = null;
| }
| }
| }
| catch (ClassNotFoundException cnfe)
| {
| //there is no class implied by the XML element name so the
| //component must be defined some other way, assume that we are
| //just adding configuration, don't add a ComponentDescriptor
| className = null;
| }
|
| //finally, if we could not get the name from the XML name attribute,
| //or from an @Name annotation on the class, imply it
| if (name == null)
| {
| String prefix = nsInfo.getNamespace().prefix();
| name = Strings.isEmpty(prefix) ?
| elemName : prefix + '.' + elemName;
| }
|
| installComponentFromXmlElement(elem, name, className, replacements);
| }
| }
| }
|
| @SuppressWarnings("unchecked")
| private void installEventListenerFromXmlElement(Element event)
| {
| String type = event.attributeValue("type");
| if (type==null)
| {
| throw new IllegalArgumentException("must specify type for <event/> declaration");
| }
| EventListenerDescriptor eventListener = eventListenerDescriptors.get(type);
| if (eventListener==null)
| {
| eventListener = new EventListenerDescriptor(type);
| eventListenerDescriptors.put(type, eventListener);
| }
|
| List<Element> actions = event.elements("action");
| for (Element action: actions)
| {
| String actionExpression = action.attributeValue("expression");
| if (actionExpression==null)
| {
| throw new IllegalArgumentException("must specify expression for <action/> declaration");
| }
| eventListener.getListenerMethodBindings().add(actionExpression);
| }
| }
|
| private void installFactoryFromXmlElement(Element factory)
| {
| String scopeName = factory.attributeValue("scope");
| String name = factory.attributeValue("name");
| if (name == null)
| {
| throw new IllegalArgumentException("must specify name in <factory/> declaration");
| }
| String method = factory.attributeValue("method");
| String value = factory.attributeValue("value");
| if (method == null && value == null)
| {
| throw new IllegalArgumentException(
| "must specify either method or value in <factory/> declaration for variable: "
| + name);
| }
| ScopeType scope = scopeName == null ? ScopeType.UNSPECIFIED : ScopeType.valueOf(scopeName
| .toUpperCase());
| boolean autoCreate = "true".equals(factory.attributeValue("auto-create"));
| factoryDescriptors.add(new FactoryDescriptor(name, scope, method, value, autoCreate));
| }
|
| private String replace(String value, Properties replacements)
| {
| if (value.startsWith("@"))
| {
| value = replacements.getProperty(value.substring(1, value.length() - 1));
| }
| return value;
| }
|
| @SuppressWarnings("unchecked")
| private void installComponentFromXmlElement(Element component, String name, String className,
| Properties replacements) throws ClassNotFoundException
| {
| String installText = component.attributeValue("installed");
| boolean installed = false;
| if (installText == null || "true".equals(replace(installText, replacements)))
| {
| installed = true;
| }
|
| String scopeName = component.attributeValue("scope");
| String jndiName = component.attributeValue("jndi-name");
| String precedenceString = component.attributeValue("precedence");
| int precedence = precedenceString==null ? Install.APPLICATION : Integer.valueOf(precedenceString);
| ScopeType scope = scopeName == null ? null : ScopeType.valueOf(scopeName.toUpperCase());
| boolean autoCreate = "true".equals(component.attributeValue("auto-create"));
| if (className != null)
| {
| Class<?> clazz = null;
| try
| {
| if (hotDeployClassLoader != null) {
| clazz = hotDeployClassLoader.loadClass(className);
| } else {
| clazz = Reflections.classForName(className);
| }
| }
| catch (ClassNotFoundException cnfe)
| {
| for (String pkg : importedPackages)
| {
| try
| {
| if (hotDeployClassLoader != null) {
| clazz = hotDeployClassLoader.loadClass(pkg + '.' + className);
| } else {
| clazz = Reflections.classForName(pkg + '.' + className);
| }
| break;
| }
| catch (Exception e)
| {
| }
| }
| if (clazz == null) throw cnfe;
| }
|
| if (name == null)
| {
| if ( !clazz.isAnnotationPresent(Name.class) )
| {
| throw new IllegalArgumentException(
| "Component class must have @Name annotation or name must be specified in components.xml: " +
| clazz.getName());
| }
|
| name = clazz.getAnnotation(Name.class).value();
| }
|
| ComponentDescriptor descriptor = new ComponentDescriptor(name, clazz, scope, autoCreate, jndiName, installed, precedence);
| addComponentDescriptor(descriptor);
| installedComponentClasses.add(clazz);
| }
| else if (name == null)
| {
| throw new IllegalArgumentException("must specify either class or name in <component/> declaration");
| }
|
| for (Element prop : (List<Element>) component.elements())
| {
| String propName = prop.attributeValue("name");
| if (propName == null)
| {
| propName = prop.getQName().getName();
| }
| String qualifiedPropName = name + '.' + toCamelCase(propName, false);
| properties.put(qualifiedPropName, getPropertyValue(prop, qualifiedPropName, replacements));
| }
|
| for (Attribute prop: (List<Attribute>) component.attributes())
| {
| String attributeName = prop.getName();
| boolean isProperty = !"name".equals(attributeName) &&
| !"installed".equals(attributeName) &&
| !"scope".equals(attributeName) &&
| !"class".equals(attributeName) &&
| !"jndi-name".equals(attributeName) &&
| !"precedence".equals(attributeName) &&
| !"auto-create".equals(attributeName);
| if (isProperty)
| {
| String qualifiedPropName = name + '.' + toCamelCase( prop.getQName().getName(), false );
| properties.put(qualifiedPropName, getPropertyValue(prop, replacements));
| }
| }
| }
|
| private void addComponentDescriptor(ComponentDescriptor descriptor)
| {
| String name = descriptor.getName();
| Set<ComponentDescriptor> set = componentDescriptors.get(name);
| if (set==null)
| {
| set = new TreeSet<ComponentDescriptor>(new ComponentDescriptor.PrecedenceComparator());
| componentDescriptors.put(name, set);
| }
| if ( !set.isEmpty() )
| {
| log.info("two components with same name, higher precedence wins: " + name);
| }
| if ( !set.add(descriptor) )
| {
| throw new IllegalStateException("Two components with the same name and precedence: " + name);
| }
| }
|
| private Conversions.PropertyValue getPropertyValue(Attribute prop, Properties replacements)
| {
| return new Conversions.FlatPropertyValue( trimmedText(prop, replacements) );
| }
|
| @SuppressWarnings("unchecked")
| private Conversions.PropertyValue getPropertyValue(Element prop, String propName,
| Properties replacements)
| {
| List<Element> keyElements = prop.elements("key");
| List<Element> valueElements = prop.elements("value");
|
| if (valueElements.isEmpty() && keyElements.isEmpty())
| {
| return new Conversions.FlatPropertyValue(
| trimmedText(prop, propName, replacements));
| }
| else if (keyElements.isEmpty())
| {
| // a list-like structure
| int len = valueElements.size();
| String[] values = new String[len];
| for (int i = 0; i < len; i++)
| {
| values = trimmedText(valueElements.get(i), propName, replacements);
| }
| return new Conversions.MultiPropertyValue(values);
| }
| else
| {
| // a map-like structure
| if (valueElements.size() != keyElements.size())
| {
| throw new IllegalArgumentException("value elements must match key elements: "
| + propName);
| }
| Map<String, String> keyedValues = new HashMap<String, String>();
| for (int i = 0; i < keyElements.size(); i++)
| {
| String key = trimmedText(keyElements.get(i), propName, replacements);
| String value = trimmedText(valueElements.get(i), propName, replacements);
| keyedValues.put(key, value);
| }
| return new Conversions.AssociativePropertyValue(keyedValues);
| }
| }
|
| private String trimmedText(Element element, String propName, Properties replacements)
| {
| String text = element.getTextTrim();
| if (text == null)
| {
| throw new IllegalArgumentException("property value must be specified in element body: "
| + propName);
| }
| return replace(text, replacements);
| }
|
| private String trimmedText(Attribute attribute, Properties replacements)
| {
| return replace( attribute.getText(), replacements );
| }
|
| public Initialization setProperty(String name, Conversions.PropertyValue value)
| {
| properties.put(name, value);
| return this;
| }
|
| public Initialization init()
| {
| log.info("initializing Seam");
| Lifecycle.beginInitialization(servletContext);
| Contexts.getApplicationContext().set(Component.PROPERTIES, properties);
| initHotDeployClassLoader();
| initComponentsFromXmlDocuments();
| scanForHotDeployableComponents();
| scanForComponents();
|
| addComponent( new ComponentDescriptor(Init.class), Contexts.getApplicationContext() );
| Init init = (Init) Component.getInstance(Init.class, ScopeType.APPLICATION);
| ComponentDescriptor desc = findDescriptor(Jbpm.class);
| if (desc != null && desc.isInstalled())
| {
| init.setJbpmInstalled(true);
| }
| init.setTimestamp( System.currentTimeMillis() );
| init.setHotDeployPaths(hotDeployPaths);
|
| addSpecialComponents(init);
| installComponents(init);
| Lifecycle.endInitialization();
| log.info("done initializing Seam");
| return this;
| }
|
| public Initialization redeploy(HttpSession session)
| {
| log.info("redeploying");
| Lifecycle.beginReinitialization(servletContext, session);
| Init init = Init.instance();
| for ( String name: init.getHotDeployableComponents() )
| {
| Component component = Component.forName(name);
| ScopeType scope = component.getScope();
| if ( scope!=ScopeType.STATELESS && scope.isContextActive() )
| {
| scope.getContext().remove(name);
| }
| Contexts.getApplicationContext().remove(name + ".component");
| }
| init.getHotDeployableComponents().clear();
| Contexts.getApplicationContext().set(Component.PROPERTIES, properties);
| initHotDeployClassLoader();
| initComponentsFromXmlDocuments();
| scanForHotDeployableComponents();
| init.setTimestamp( System.currentTimeMillis() );
| init.setHotDeployPaths(hotDeployPaths);
| installComponents(init);
| Lifecycle.endInitialization();
| log.info("done redeploying");
| return this;
| }
|
| private void initHotDeployClassLoader()
| {
| ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
| try
| {
| URL resource = contextClassLoader.getResource("META-INF/debug.xhtml");
| if (resource!=null)
| {
| String path = resource.toExternalForm();
| String hotDeployDirectory = path.substring( 9, path.length()-46 ) + "dev";
| File directory = new File(hotDeployDirectory);
| if ( directory.exists() )
| {
| URL url = directory.toURI().toURL();
| /*File[] jars = directory.listFiles( new FilenameFilter() {
| public boolean accept(File file, String name) { return name.endsWith(".jar"); }
| } );
| URL[] urls = new URL[jars.length];
| for (int i=0; i<jars.length; i++)
| {
| urls = jars.toURL();
| }*/
| URL[] urls = {url};
| hotDeployClassLoader = new URLClassLoader(urls, contextClassLoader);
| hotDeployPaths = new File[] {directory};
| }
| }
| }
| catch (MalformedURLException mue)
| {
| throw new RuntimeException(mue);
| }
| }
|
| private void scanForHotDeployableComponents()
| {
| if ( hotDeployClassLoader!=null )
| {
| Set<Class<Object>> scannedClasses = new HashSet<Class<Object>>();
| scannedClasses.addAll( new ComponentScanner(null, hotDeployClassLoader).getClasses() );
| Set<Package> scannedPackages = new HashSet<Package>();
| for (Class<Object> scannedClass: scannedClasses)
| {
| installScannedClass(scannedPackages, scannedClass);
| }
| }
| }
|
| private void scanForComponents()
| {
| Set<Class<Object>> scannedClasses = new HashSet<Class<Object>>();
| scannedClasses.addAll( new ComponentScanner("seam.properties").getClasses() );
| scannedClasses.addAll( new ComponentScanner("META-INF/seam.properties").getClasses() );
| scannedClasses.addAll( new ComponentScanner("META-INF/components.xml").getClasses() );
|
| Set<Package> scannedPackages = new HashSet<Package>();
| for (Class<Object> scannedClass: scannedClasses)
| {
| installScannedClass(scannedPackages, scannedClass);
| }
| }
|
| private void installScannedClass(Set<Package> scannedPackages, Class<Object> scannedClass)
| {
| installScannedComponentAndRoles(scannedClass);
| installComponentsFromDescriptor( classDescriptorFilename(scannedClass), scannedClass );
| Package pkg = scannedClass.getPackage();
| if (pkg != null && scannedPackages.add(pkg) )
| {
| installComponentsFromDescriptor( packageDescriptorFilename(pkg), scannedClass );
| }
| }
|
| private static String classDescriptorFilename(Class<Object> scannedClass)
| {
| return scannedClass.getName().replace('.', '/') + ".component.xml";
| }
|
| private static String packageDescriptorFilename(Package pkg)
| {
| return pkg.getName().replace('.', '/') + "/components.xml";
| }
|
| private void installComponentsFromDescriptor(String fileName, Class clazz)
| {
| //note: this is correct, we do not need to scan other classloaders!
| InputStream stream = clazz.getClassLoader().getResourceAsStream(fileName);
| if (stream != null)
| {
| try
| {
| Properties replacements = getReplacements();
| Element root = XML.getRootElement(stream);
| if ( root.getName().equals("components") )
| {
| installComponentsFromXmlElements(root, replacements);
| }
| else
| {
| //TODO: namespaced components!!!
| installComponentFromXmlElement(
| root,
| root.attributeValue("name"),
| clazz.getName(), replacements
| );
| }
| }
| catch (Exception e)
| {
| throw new RuntimeException("error while reading " + fileName, e);
| }
| }
| }
|
| private void installScannedComponentAndRoles(Class<Object> scannedClass)
| {
| if (scannedClass.isAnnotationPresent(Name.class))
| {
| addComponentDescriptor(new ComponentDescriptor(scannedClass));
| }
| if (scannedClass.isAnnotationPresent(Role.class))
| {
| installRole(scannedClass, scannedClass.getAnnotation(Role.class));
| }
| if (scannedClass.isAnnotationPresent(Roles.class))
| {
| Role[] roles = scannedClass.getAnnotation(Roles.class).value();
| for (Role role : roles)
| {
| installRole(scannedClass, role);
| }
| }
| }
|
| private void installRole(Class<Object> scannedClass, Role role)
| {
| ScopeType scope = Seam.getComponentRoleScope(scannedClass, role);
| addComponentDescriptor( new ComponentDescriptor( role.name(), scannedClass, scope ) );
| }
|
| private void addNamespace(Package pkg)
| {
| if (pkg != null)
| {
| Namespace ns = pkg.getAnnotation(Namespace.class);
| if (ns != null)
| {
| log.info("Namespace: " + ns.value() + ", package: " + pkg.getName() + ", prefix: " + ns.prefix());
| namespaceMap.put(ns.value(), new NamespaceDescriptor(ns, pkg));
| }
| }
| }
|
| private void addNamespaces()
| {
| for ( Package pkg : new NamespaceScanner("META-INF/components.xml").getPackages() )
| {
| addNamespace(pkg);
| }
| for ( Package pkg : new NamespaceScanner("seam.properties").getPackages() )
| {
| addNamespace(pkg);
| }
| for ( Package pkg : new NamespaceScanner("META-INF/seam.properties").getPackages() )
| {
| addNamespace(pkg);
| }
| }
|
| private void initPropertiesFromServletContext()
| {
| Enumeration params = servletContext.getInitParameterNames();
| while (params.hasMoreElements())
| {
| String name = (String) params.nextElement();
| properties.put(name, new Conversions.FlatPropertyValue(servletContext
| .getInitParameter(name)));
| }
| }
|
| private void initPropertiesFromResource()
| {
| Properties props = loadFromResource("/seam.properties");
| for (Map.Entry me : props.entrySet())
| {
| properties.put((String) me.getKey(), new Conversions.FlatPropertyValue((String) me
| .getValue()));
| }
| }
|
| private void initJndiProperties()
| {
| Properties jndiProperties = new Properties();
| jndiProperties.putAll(loadFromResource("/jndi.properties"));
| jndiProperties.putAll(loadFromResource("/seam-jndi.properties"));
| Naming.setInitialContextProperties(jndiProperties);
| }
|
| private Properties loadFromResource(String resource)
| {
| Properties props = new Properties();
| InputStream stream = Resources.getResourceAsStream(resource, servletContext);
| if (stream != null)
| {
| log.info("reading properties from: " + resource);
| try
| {
| props.load(stream);
| }
| catch (IOException ioe)
| {
| log.error("could not read " + resource, ioe);
| }
| }
| else
| {
| log.debug("not found: " + resource);
| }
| return props;
| }
|
| protected ComponentDescriptor findDescriptor(Class<?> componentClass)
| {
| for (Set<ComponentDescriptor> components : componentDescriptors.values())
| {
| for (ComponentDescriptor component: components)
| {
| if ( component.getComponentClass().equals(componentClass) )
| {
| return component;
| }
| }
| }
| return null;
| }
|
| private void addSpecialComponents(Init init)
| {
| try
| {
| Reflections.classForName("org.jboss.cache.aop.PojoCache");
| addComponentDescriptor( new ComponentDescriptor(PojoCache.class, true) );
| }
| catch (ClassNotFoundException e) {}
| catch (NoClassDefFoundError e) {
| //temp solution due to broken JEMS installer portal profile!
| log.warn("Did not install PojoCache due to NoClassDefFoundError: " + e.getMessage());
| }
| }
|
| private void installComponents(Init init)
| {
| log.info("Installing components...");
| Context context = Contexts.getApplicationContext();
|
| DependencyManager manager = new DependencyManager(componentDescriptors);
|
| Set<ComponentDescriptor> installable = manager.installedSet();
| for (ComponentDescriptor componentDescriptor: installable) {
| String compName = componentDescriptor.getName() + COMPONENT_SUFFIX;
|
| if (!context.isSet(compName)) {
| addComponent(componentDescriptor, context);
|
| if (componentDescriptor.isAutoCreate()) {
| init.addAutocreateVariable( componentDescriptor.getName() );
| }
|
| if (componentDescriptor.isFilter()) {
| init.addInstalledFilter( componentDescriptor.getName() );
| }
|
| if (componentDescriptor.isResourceProvider()) {
| init.addResourceProvider( componentDescriptor.getName() );
| }
| }
| }
|
|
| for (FactoryDescriptor factoryDescriptor : factoryDescriptors)
| {
| if (factoryDescriptor.isValueBinding())
| {
| init.addFactoryValueBinding(factoryDescriptor.getName(), factoryDescriptor.getValue(),
| factoryDescriptor.getScope());
| }
| else
| {
| init.addFactoryMethodBinding(factoryDescriptor.getName(),
| factoryDescriptor.getMethod(), factoryDescriptor.getScope());
| }
| if (factoryDescriptor.isAutoCreate())
| {
| init.addAutocreateVariable(factoryDescriptor.getName());
| }
| }
|
| for (EventListenerDescriptor listenerDescriptor: eventListenerDescriptors.values())
| {
| for (String expression: listenerDescriptor.getListenerMethodBindings())
| {
| init.addObserverMethodBinding( listenerDescriptor.getType(), Expressions.instance().createMethodBinding(expression) );
| }
| }
| }
|
|
| /**
| * This actually creates a real Component and should only be called when
| * we want to install a component
| */
| protected void addComponent(ComponentDescriptor descriptor, Context context)
| {
| String name = descriptor.getName();
| String componentName = name + COMPONENT_SUFFIX;
| try
| {
| Component component = new Component(
| descriptor.getComponentClass(),
| name,
| descriptor.getScope(),
| descriptor.getJndiName()
| );
| context.set(componentName, component);
| if ( descriptor.getComponentClass().getClassLoader()==hotDeployClassLoader )
| {
| Init.instance().addHotDeployableComponent( component.getName() );
| }
| }
| catch (Throwable e)
| {
| throw new RuntimeException("Could not create Component: " + name, e);
| }
| }
|
| private static String toCamelCase(String hyphenated, boolean initialUpper)
| {
| StringTokenizer tokens = new StringTokenizer(hyphenated, "-");
| StringBuilder result = new StringBuilder( hyphenated.length() );
| String firstToken = tokens.nextToken();
| if (initialUpper)
| {
| result.append( Character.toUpperCase( firstToken.charAt(0) ) )
| .append( firstToken.substring(1) );
| }
| else
| {
| result.append(firstToken);
| }
| while ( tokens.hasMoreTokens() )
| {
| String token = tokens.nextToken();
| result.append( Character.toUpperCase( token.charAt(0) ) )
| .append( token.substring(1) );
| }
| return result.toString();
| }
|
|
|
| private static class EventListenerDescriptor
| {
| private String type;
| private List<String> listenerMethodBindings = new ArrayList<String>();
|
| EventListenerDescriptor(String type)
| {
| this.type = type;
| }
|
| public String getType()
| {
| return type;
| }
|
| public List<String> getListenerMethodBindings()
| {
| return listenerMethodBindings;
| }
|
| @Override
| public String toString()
| {
| return "EventListenerDescriptor(" + type + ')';
| }
| }
|
|
| }
|
|
View the original post : http://www.jboss.com/index.html?module=bb&op=viewtopic&p=4036101#4036101
Reply to the post : http://www.jboss.com/index.html?module=bb&op=posting&mode=reply&p=4036101
More information about the jboss-user
mailing list