Java tutorial
/* * $Id: ComponentDefinition.java 471754 2006-11-06 14:55:09Z husted $ * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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.apache.struts.tiles; import java.io.Serializable; import java.util.HashMap; import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.struts.tiles.xmlDefinition.XmlDefinition; import org.apache.struts.util.RequestUtils; /** * Definition of a template / component attributes. * Attributes of a component can be defined with the help of this class. * An instance of this class can be used as a bean, and passed to 'insert' tag. */ public class ComponentDefinition implements Serializable { /** * Commons Logging instance. */ protected static Log log = LogFactory.getLog(ComponentDefinition.class); /** * Definition name */ protected String name = null; /** * Component / template path (URL). */ protected String path = null; /** * Attributes defined for the component. */ protected Map attributes = null; /** * Role associated to definition. */ protected String role = null; /** Associated Controller URL or classname, if defined */ protected String controller = null; /** * Associated Controller typename, if controllerName defined. * Can be CONTROLLER, ACTION or URL, or null. */ protected String controllerType = null; /** * Controller name type. */ public static final String URL = "url"; /** * Controller name type. */ public static final String CONTROLLER = "controller"; /** * Controller name type. */ public static final String ACTION = "action"; /** * Controller associated to Definition. * Lazy creation : only on first request */ private Controller controllerInstance = null; /** * Constructor. */ public ComponentDefinition() { attributes = new HashMap(); } /** * Copy Constructor. * Create a new definition initialized with parent definition. * Do a shallow copy : attributes are shared between copies, but not the Map * containing attributes. */ public ComponentDefinition(ComponentDefinition definition) { attributes = new HashMap(definition.getAttributes()); this.name = definition.getName(); this.path = definition.getPath(); this.role = definition.getRole(); this.controllerInstance = definition.getControllerInstance(); this.controller = definition.getController(); this.controllerType = definition.getControllerType(); } /** * Constructor. * Create a new definition initialized from a RawDefinition. * Raw definitions are used to read definition from a data source (xml file, db, ...). * A RawDefinition mainly contains properties of type String, while Definition * contains more complex type (ex : Controller). * Do a shallow copy : attributes are shared between objects, but not the Map * containing attributes. * OO Design issues : Actually RawDefinition (XmlDefinition) extends ComponentDefinition. * This must not be the case. I have do it because I am lazy. * @throws InstantiationException if an error occur while instanciating Controller : * (classname can't be instanciated, Illegal access with instanciated class, * Error while instanciating class, classname can't be instanciated. */ public ComponentDefinition(XmlDefinition definition) { this((ComponentDefinition) definition); } /** * Constructor. */ public ComponentDefinition(String name, String path, Map attributes) { this.name = name; this.path = path; this.attributes = attributes; } /** * Access method for the name property. * * @return the current value of the name property */ public String getName() { return name; } /** * Sets the value of the name property. * * @param aName the new value of the name property */ public void setName(String aName) { name = aName; } /** * Access method for the path property. * * @return The current value of the path property. */ public String getPage() { return path; } /** * Sets the value of the path property. * * @param page the new value of the path property */ public void setPage(String page) { path = page; } /** * Access method for the path property. * * @return the current value of the path property */ public String getPath() { return path; } /** * Sets the value of the path property. * * @param aPath the new value of the path property */ public void setPath(String aPath) { path = aPath; } /** * Access method for the template property. * Same as getPath() * @return the current value of the template property */ public String getTemplate() { return path; } /** * Sets the value of the template property. * Same as setPath() * * @param template the new value of the path property */ public void setTemplate(String template) { path = template; } /** * Access method for the role property. * @return the current value of the role property */ public String getRole() { return role; } /** * Sets the value of the role property. * * @param role the new value of the path property */ public void setRole(String role) { this.role = role; } /** * Access method for the attributes property. * If there is no attributes, return an empty map. * @return the current value of the attributes property */ public Map getAttributes() { return attributes; } /** * Returns the value of the named attribute as an Object, or null if no * attribute of the given name exists. * * @return requested attribute or null if not found */ public Object getAttribute(String key) { return attributes.get(key); } /** * Put a new attribute in this component * * @param key String key for attribute * @param value Attibute value. */ public void putAttribute(String key, Object value) { attributes.put(key, value); } /** * Put an attribute in component / template definition. * Attribute can be used as content for tag get. * @param name Attribute name * @param content Attribute value */ public void put(String name, Object content) { put(name, content, false, null); } /** * Put an attribute in template definition. * Attribute can be used as content for tag get. * @param name Attribute name * @param content Attribute value * @param direct Determines how content is handled by get tag: true means content is printed directly; false, the default, means content is included */ public void put(String name, Object content, boolean direct) { put(name, content, direct, null); } /** * Put an attribute in template definition. * Attribute can be used as content for tag get. * @param name Attribute name * @param content Attribute value * @param direct Determines how content is handled by get tag: true means content is printed directly; false, the default, means content is included * @param role Determine if content is used by get tag. If user is in role, content is used. */ public void put(String name, Object content, boolean direct, String role) { if (direct == true) { // direct String put(name, content, "string", role); } else { put(name, content, "template", role); } } /** * Put an attribute in template definition. * Attribute can be used as content for tag get. * @param name Attribute name * @param content Attribute value * @param type attribute type: template, string, definition * @param role Determine if content is used by get tag. If user is in role, content is used. */ public void put(String name, Object content, String type, String role) { // Is there a type set ? // First check direct attribute, and translate it to a valueType. // Then, evaluate valueType, and create requested typed attribute. AttributeDefinition attribute = null; if (content != null && type != null && !(content instanceof AttributeDefinition)) { String strValue = content.toString(); if (type.equalsIgnoreCase("string")) { attribute = new DirectStringAttribute(strValue); } else if (type.equalsIgnoreCase("page")) { attribute = new PathAttribute(strValue); } else if (type.equalsIgnoreCase("template")) { attribute = new PathAttribute(strValue); } else if (type.equalsIgnoreCase("instance")) { attribute = new DefinitionNameAttribute(strValue); } else if (type.equalsIgnoreCase("definition")) { attribute = new DefinitionNameAttribute(strValue); } } putAttribute(name, attribute); } /** * Returns a description of the attributes. */ public String toString() { return "{name=" + name + ", path=" + path + ", role=" + role + ", controller=" + controller + ", controllerType=" + controllerType + ", controllerInstance=" + controllerInstance + ", attributes=" + attributes + "}\n"; } /** * Get associated controller type. * Type denote a fully qualified classname. */ public String getControllerType() { return controllerType; } /** * Set associated controller type. * Type denote a fully qualified classname. * @param controllerType Typeof associated controller */ public void setControllerType(String controllerType) { this.controllerType = controllerType; } /** * Set associated controller name as an url, and controller * type as "url". * Name must be an url (not checked). * Convenience method. * @param controller Controller url */ public void setControllerUrl(String controller) { setController(controller); setControllerType("url"); } /** * Set associated controller name as a classtype, and controller * type as "classname". * Name denote a fully qualified classname * Convenience method. * @param controller Controller classname. */ public void setControllerClass(String controller) { setController(controller); setControllerType("classname"); } /** * Get associated controller local URL. * URL should be local to webcontainer in order to allow request context followup. * URL comes as a string. */ public String getController() { return controller; } /** * Set associated controller URL. * URL should be local to webcontainer in order to allow request context followup. * URL is specified as a string. * @param url Url called locally */ public void setController(String url) { this.controller = url; } /** * Get controller instance. * @return controller instance. */ public Controller getControllerInstance() { return controllerInstance; } /** * Get or create controller. * Get controller, create it if necessary. * @return controller if controller or controllerType is set, null otherwise. * @throws InstantiationException if an error occur while instanciating Controller : * (classname can't be instanciated, Illegal access with instanciated class, * Error while instanciating class, classname can't be instanciated. */ public Controller getOrCreateController() throws InstantiationException { if (controllerInstance != null) { return controllerInstance; } // Do we define a controller ? if (controller == null && controllerType == null) { return null; } // check parameters if (controllerType != null && controller == null) { throw new InstantiationException("Controller name should be defined if controllerType is set"); } controllerInstance = createController(controller, controllerType); return controllerInstance; } /** * Set controller. */ public void setControllerInstance(Controller controller) { this.controllerInstance = controller; } /** * Create a new instance of controller named in parameter. * If controllerType is specified, create controller accordingly. * Otherwise, if name denote a classname, create an instance of it. If class is * subclass of org.apache.struts.action.Action, wrap controller * appropriately. * Otherwise, consider name as an url. * @param name Controller name (classname, url, ...) * @param controllerType Expected Controller type * @return org.apache.struts.tiles.Controller * @throws InstantiationException if an error occur while instanciating Controller : * (classname can't be instanciated, Illegal access with instanciated class, * Error while instanciating class, classname can't be instanciated. */ public static Controller createController(String name, String controllerType) throws InstantiationException { if (log.isDebugEnabled()) { log.debug("Create controller name=" + name + ", type=" + controllerType); } Controller controller = null; if (controllerType == null) { // first try as a classname try { return createControllerFromClassname(name); } catch (InstantiationException ex) { // ok, try something else controller = new UrlController(name); } } else if ("url".equalsIgnoreCase(controllerType)) { controller = new UrlController(name); } else if ("classname".equalsIgnoreCase(controllerType)) { controller = createControllerFromClassname(name); } return controller; } /** * Create a controller from specified classname * @param classname Controller classname. * @return org.apache.struts.tiles.Controller * @throws InstantiationException if an error occur while instanciating Controller : * (classname can't be instanciated, Illegal access with instanciated class, * Error while instanciating class, classname can't be instanciated. */ public static Controller createControllerFromClassname(String classname) throws InstantiationException { try { Class requestedClass = RequestUtils.applicationClass(classname); Object instance = requestedClass.newInstance(); if (log.isDebugEnabled()) { log.debug("Controller created : " + instance); } return (Controller) instance; } catch (java.lang.ClassNotFoundException ex) { throw new InstantiationException("Error - Class not found :" + ex.getMessage()); } catch (java.lang.IllegalAccessException ex) { throw new InstantiationException("Error - Illegal class access :" + ex.getMessage()); } catch (java.lang.InstantiationException ex) { throw ex; } catch (java.lang.ClassCastException ex) { throw new InstantiationException( "Controller of class '" + classname + "' should implements 'Controller' or extends 'Action'"); } } }