Java tutorial
package org.apache.ojb.broker.util.factory; /* Copyright 2002-2005 The Apache Software Foundation * * Licensed 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. */ import org.apache.commons.lang.SystemUtils; import org.apache.ojb.broker.PersistenceBrokerException; import org.apache.ojb.broker.util.ClassHelper; import org.apache.ojb.broker.util.configuration.Configurable; import org.apache.ojb.broker.util.configuration.Configuration; import org.apache.ojb.broker.util.configuration.ConfigurationException; import org.apache.ojb.broker.util.configuration.impl.OjbConfigurator; import org.apache.ojb.broker.util.interceptor.InterceptorFactory; import org.apache.ojb.broker.util.logging.Logger; import org.apache.ojb.broker.util.logging.LoggerFactory; /** * ConfigurableFactory is an abstract baseclass for OJB factory classes. * It provides all infrastructure for configuration through OJB.properties. * A derived class must implement the getConfigurationKey() method. * The returned configuration key is used to lookup the class to be instantiated * by the derived factory. * The lookup is performed in the configure() method and uses the OJB.properties * information. * * @author Thomas Mahler */ public abstract class ConfigurableFactory implements Configurable { private Logger log = LoggerFactory.getLogger(this.getClass()); /** * the class to be served */ private Class classToServe = null; /** * the public constructor calls configure() to perform configuration * of the factory instance. */ public ConfigurableFactory() { OjbConfigurator.getInstance().configure(this); } /** * must be implemented in the concrete factory classes. * the configuration key is used to lookup the Class to serve * from the OjbConfiguration in configure(). */ protected abstract String getConfigurationKey(); /** * @see org.apache.ojb.broker.util.configuration.Configurable#configure(Configuration) * looks up the the key getConfigurationKey() in the OjbConfiguration * to determine the Class to be served. */ public void configure(Configuration pConfig) throws ConfigurationException { if (getConfigurationKey() == null) { getLogger().error("ConfigurableFactory configuration key is 'null'"); throw new PersistenceBrokerException("ConfigurableFactory configuration key is 'null'"); } Class clazz = pConfig.getClass(getConfigurationKey(), null); if (clazz == null) { getLogger().error("ConfigurableFactory configuration key class for key'" + getConfigurationKey() + "' does not exist."); throw new PersistenceBrokerException("ConfigurableFactory configuration key class for key'" + getConfigurationKey() + "' does not exist."); } this.setClassToServe(clazz); } /** * factory method for creating new instances * the Class to be instantiated is defined by getClassToServe(). * @return Object the created instance */ public Object createNewInstance(Class[] types, Object[] args) { try { Object result; // create an instance of the target class if (types != null) { result = ClassHelper.newInstance(getClassToServe(), types, args, true); } else { result = ClassHelper.newInstance(getClassToServe(), true); } // if defined in OJB.properties all instances are wrapped by an interceptor result = InterceptorFactory.getInstance().createInterceptorFor(result); return result; } catch (InstantiationException e) { getLogger().error("ConfigurableFactory can't instantiate class " + getClassToServe() + buildArgumentString(types, args), e); throw new PersistenceBrokerException(e); } catch (IllegalAccessException e) { getLogger().error("ConfigurableFactory can't access constructor for class " + getClassToServe() + buildArgumentString(types, args), e); throw new PersistenceBrokerException(e); } catch (Exception e) { getLogger().error("ConfigurableFactory instantiation failed for class " + getClassToServe() + buildArgumentString(types, args), e); throw new PersistenceBrokerException(e); } } protected String buildArgumentString(Class[] types, Object[] args) { StringBuffer buf = new StringBuffer(); String eol = SystemUtils.LINE_SEPARATOR; buf.append(eol + "* Factory types: "); if (types != null) { for (int i = 0; i < types.length; i++) { Class type = types[i]; buf.append(eol + (i + 1) + " - Type: " + (type != null ? type.getName() : null)); } } else buf.append(eol + "none"); buf.append(eol + "* Factory arguments: "); if (args != null) { for (int i = 0; i < args.length; i++) { Object obj = args[i]; buf.append(eol + (i + 1) + " - Argument: " + obj); } } else buf.append(eol + "none"); return buf.toString(); } /** * factory method for creating new instances * the Class to be instantiated is defined by getClassToServe(). * @return Object the created instance */ public Object createNewInstance() { return createNewInstance((Class) null, (Object) null); } /** * factory method for creating new instances * the Class to be instantiated is defined by getClassToServe(). * @return Object the created instance */ public Object createNewInstance(Class type, Object arg) { if (type != null) return createNewInstance(new Class[] { type }, new Object[] { arg }); else return createNewInstance((Class[]) null, (Object[]) null); } /** * Returns the classToServe. * @return Class */ public Class getClassToServe() { return classToServe; } /** * Sets the classToServe. * <br/> * Normally this is done by the factory using * {@link #getConfigurationKey}. * <br/> * <b>Note:</b> For internal use only! * @param classToServe The classToServe to set */ public void setClassToServe(Class classToServe) { this.classToServe = classToServe; } /** * the logger for the ConfigurableFactory */ protected Logger getLogger() { return log; } }