001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018
019 package org.apache.commons.beanutils;
020
021
022 import java.io.Serializable;
023 import java.lang.reflect.Constructor;
024 import java.lang.reflect.InvocationTargetException;
025 import java.util.HashMap;
026
027
028 /**
029 * <p>Minimal implementation of the <code>DynaClass</code> interface. Can be
030 * used as a convenience base class for more sophisticated implementations.</p> *
031 * <p><strong>IMPLEMENTATION NOTE</strong> - The <code>DynaBean</code>
032 * implementation class supplied to our constructor MUST have a one-argument
033 * constructor of its own that accepts a <code>DynaClass</code>. This is
034 * used to associate the DynaBean instance with this DynaClass.</p>
035 *
036 * @author Craig McClanahan
037 * @version $Revision: 926529 $ $Date: 2010-03-23 11:44:24 +0000 (Tue, 23 Mar 2010) $
038 */
039
040 public class BasicDynaClass implements DynaClass, Serializable {
041
042
043 // ----------------------------------------------------------- Constructors
044
045
046 /**
047 * Construct a new BasicDynaClass with default parameters.
048 */
049 public BasicDynaClass() {
050
051 this(null, null, null);
052
053 }
054
055
056 /**
057 * Construct a new BasicDynaClass with the specified parameters.
058 *
059 * @param name Name of this DynaBean class
060 * @param dynaBeanClass The implementation class for new instances
061 */
062 public BasicDynaClass(String name, Class dynaBeanClass) {
063
064 this(name, dynaBeanClass, null);
065
066 }
067
068
069 /**
070 * Construct a new BasicDynaClass with the specified parameters.
071 *
072 * @param name Name of this DynaBean class
073 * @param dynaBeanClass The implementation class for new intances
074 * @param properties Property descriptors for the supported properties
075 */
076 public BasicDynaClass(String name, Class dynaBeanClass,
077 DynaProperty[] properties) {
078
079 super();
080 if (name != null) {
081 this.name = name;
082 }
083 if (dynaBeanClass == null) {
084 dynaBeanClass = BasicDynaBean.class;
085 }
086 setDynaBeanClass(dynaBeanClass);
087 if (properties != null) {
088 setProperties(properties);
089 }
090
091 }
092
093
094 // ----------------------------------------------------- Instance Variables
095
096
097 /**
098 * The constructor of the <code>dynaBeanClass</code> that we will use
099 * for creating new instances.
100 */
101 protected transient Constructor constructor = null;
102
103
104 /**
105 * The method signature of the constructor we will use to create
106 * new DynaBean instances.
107 */
108 protected static Class[] constructorTypes = { DynaClass.class };
109
110
111 /**
112 * The argument values to be passed to the constructore we will use
113 * to create new DynaBean instances.
114 */
115 protected Object[] constructorValues = { this };
116
117
118 /**
119 * The <code>DynaBean</code> implementation class we will use for
120 * creating new instances.
121 */
122 protected Class dynaBeanClass = BasicDynaBean.class;
123
124
125 /**
126 * The "name" of this DynaBean class.
127 */
128 protected String name = this.getClass().getName();
129
130
131 /**
132 * The set of dynamic properties that are part of this DynaClass.
133 */
134 protected DynaProperty[] properties = new DynaProperty[0];
135
136
137 /**
138 * The set of dynamic properties that are part of this DynaClass,
139 * keyed by the property name. Individual descriptor instances will
140 * be the same instances as those in the <code>properties</code> list.
141 */
142 protected HashMap propertiesMap = new HashMap();
143
144
145 // ------------------------------------------------------ DynaClass Methods
146
147
148 /**
149 * Return the name of this DynaClass (analogous to the
150 * <code>getName()</code> method of <code>java.lang.Class</code), which
151 * allows the same <code>DynaClass</code> implementation class to support
152 * different dynamic classes, with different sets of properties.
153 *
154 * @return the name of the DynaClass
155 */
156 public String getName() {
157
158 return (this.name);
159
160 }
161
162
163 /**
164 * Return a property descriptor for the specified property, if it exists;
165 * otherwise, return <code>null</code>.
166 *
167 * @param name Name of the dynamic property for which a descriptor
168 * is requested
169 * @return The descriptor for the specified property
170 *
171 * @exception IllegalArgumentException if no property name is specified
172 */
173 public DynaProperty getDynaProperty(String name) {
174
175 if (name == null) {
176 throw new IllegalArgumentException
177 ("No property name specified");
178 }
179 return ((DynaProperty) propertiesMap.get(name));
180
181 }
182
183
184 /**
185 * <p>Return an array of <code>ProperyDescriptors</code> for the properties
186 * currently defined in this DynaClass. If no properties are defined, a
187 * zero-length array will be returned.</p>
188 *
189 * <p><strong>FIXME</strong> - Should we really be implementing
190 * <code>getBeanInfo()</code> instead, which returns property descriptors
191 * and a bunch of other stuff?</p>
192 *
193 * @return the set of properties for this DynaClass
194 */
195 public DynaProperty[] getDynaProperties() {
196
197 return (properties);
198
199 }
200
201
202 /**
203 * Instantiate and return a new DynaBean instance, associated
204 * with this DynaClass.
205 *
206 * @return A new <code>DynaBean</code> instance
207 * @exception IllegalAccessException if the Class or the appropriate
208 * constructor is not accessible
209 * @exception InstantiationException if this Class represents an abstract
210 * class, an array class, a primitive type, or void; or if instantiation
211 * fails for some other reason
212 */
213 public DynaBean newInstance()
214 throws IllegalAccessException, InstantiationException {
215
216 try {
217 // Refind the constructor after a deserialization (if needed)
218 if (constructor == null) {
219 setDynaBeanClass(this.dynaBeanClass);
220 }
221 // Invoke the constructor to create a new bean instance
222 return ((DynaBean) constructor.newInstance(constructorValues));
223 } catch (InvocationTargetException e) {
224 throw new InstantiationException
225 (e.getTargetException().getMessage());
226 }
227
228 }
229
230
231 // --------------------------------------------------------- Public Methods
232
233
234 /**
235 * Return the Class object we will use to create new instances in the
236 * <code>newInstance()</code> method. This Class <strong>MUST</strong>
237 * implement the <code>DynaBean</code> interface.
238 *
239 * @return The class of the {@link DynaBean}
240 */
241 public Class getDynaBeanClass() {
242
243 return (this.dynaBeanClass);
244
245 }
246
247
248 // ------------------------------------------------------ Protected Methods
249
250
251 /**
252 * Set the Class object we will use to create new instances in the
253 * <code>newInstance()</code> method. This Class <strong>MUST</strong>
254 * implement the <code>DynaBean</code> interface.
255 *
256 * @param dynaBeanClass The new Class object
257 *
258 * @exception IllegalArgumentException if the specified Class does not
259 * implement the <code>DynaBean</code> interface
260 */
261 protected void setDynaBeanClass(Class dynaBeanClass) {
262
263 // Validate the argument type specified
264 if (dynaBeanClass.isInterface()) {
265 throw new IllegalArgumentException
266 ("Class " + dynaBeanClass.getName() +
267 " is an interface, not a class");
268 }
269 if (!DynaBean.class.isAssignableFrom(dynaBeanClass)) {
270 throw new IllegalArgumentException
271 ("Class " + dynaBeanClass.getName() +
272 " does not implement DynaBean");
273 }
274
275 // Identify the Constructor we will use in newInstance()
276 try {
277 this.constructor = dynaBeanClass.getConstructor(constructorTypes);
278 } catch (NoSuchMethodException e) {
279 throw new IllegalArgumentException
280 ("Class " + dynaBeanClass.getName() +
281 " does not have an appropriate constructor");
282 }
283 this.dynaBeanClass = dynaBeanClass;
284
285 }
286
287
288 /**
289 * Set the list of dynamic properties supported by this DynaClass.
290 *
291 * @param properties List of dynamic properties to be supported
292 */
293 protected void setProperties(DynaProperty[] properties) {
294
295 this.properties = properties;
296 propertiesMap.clear();
297 for (int i = 0; i < properties.length; i++) {
298 propertiesMap.put(properties[i].getName(), properties[i]);
299 }
300
301 }
302
303
304 }