Java tutorial
/* * 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.commons.configuration; import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Set; import javax.naming.Context; import javax.naming.InitialContext; import javax.naming.NameClassPair; import javax.naming.NameNotFoundException; import javax.naming.NamingEnumeration; import javax.naming.NamingException; import javax.naming.NotContextException; import org.apache.commons.lang.StringUtils; import org.apache.commons.logging.LogFactory; /** * This Configuration class allows you to interface with a JNDI datasource. * A JNDIConfiguration is read-only, write operations will throw an * UnsupportedOperationException. The clear operations are supported but the * underlying JNDI data source is not changed. * * @author <a href="mailto:epugh@upstate.com">Eric Pugh</a> * @version $Id: JNDIConfiguration.java 549591 2007-06-21 19:57:25Z oheger $ */ public class JNDIConfiguration extends AbstractConfiguration { /** The prefix of the context. */ private String prefix; /** The initial JNDI context. */ private Context context; /** The base JNDI context. */ private Context baseContext; /** The Set of keys that have been virtually cleared. */ private Set clearedProperties = new HashSet(); /** * Creates a JNDIConfiguration using the default initial context as the * root of the properties. * * @throws NamingException thrown if an error occurs when initializing the default context */ public JNDIConfiguration() throws NamingException { this((String) null); } /** * Creates a JNDIConfiguration using the default initial context, shifted * with the specified prefix, as the root of the properties. * * @param prefix the prefix * * @throws NamingException thrown if an error occurs when initializing the default context */ public JNDIConfiguration(String prefix) throws NamingException { this(new InitialContext(), prefix); } /** * Creates a JNDIConfiguration using the specified initial context as the * root of the properties. * * @param context the initial context */ public JNDIConfiguration(Context context) { this(context, null); } /** * Creates a JNDIConfiguration using the specified initial context shifted * by the specified prefix as the root of the properties. * * @param context the initial context * @param prefix the prefix */ public JNDIConfiguration(Context context, String prefix) { this.context = context; this.prefix = prefix; setLogger(LogFactory.getLog(getClass())); addErrorLogListener(); } /** * This method recursive traverse the JNDI tree, looking for Context objects. * When it finds them, it traverses them as well. Otherwise it just adds the * values to the list of keys found. * * @param keys All the keys that have been found. * @param context The parent context * @param prefix What prefix we are building on. * @param processedCtx a set with the so far processed objects * @throws NamingException If JNDI has an issue. */ private void recursiveGetKeys(Set keys, Context context, String prefix, Set processedCtx) throws NamingException { processedCtx.add(context); NamingEnumeration elements = null; try { elements = context.list(""); // iterates through the context's elements while (elements.hasMore()) { NameClassPair nameClassPair = (NameClassPair) elements.next(); String name = nameClassPair.getName(); Object object = context.lookup(name); // build the key StringBuffer key = new StringBuffer(); key.append(prefix); if (key.length() > 0) { key.append("."); } key.append(name); if (object instanceof Context) { // add the keys of the sub context Context subcontext = (Context) object; if (!processedCtx.contains(subcontext)) { recursiveGetKeys(keys, subcontext, key.toString(), processedCtx); } } else { // add the key keys.add(key.toString()); } } } finally { // close the enumeration if (elements != null) { elements.close(); } } } /** * Returns an iterator with all property keys stored in this configuration. * * @return an iterator with all keys */ public Iterator getKeys() { return getKeys(""); } /** * Returns an iterator with all property keys starting with the given * prefix. * * @param prefix the prefix * @return an iterator with the selected keys */ public Iterator getKeys(String prefix) { // build the path String[] splitPath = StringUtils.split(prefix, "."); List path = new ArrayList(); for (int i = 0; i < splitPath.length; i++) { path.add(splitPath[i]); } try { // find the context matching the specified path Context context = getContext(path, getBaseContext()); // return all the keys under the context found Set keys = new HashSet(); if (context != null) { recursiveGetKeys(keys, context, prefix, new HashSet()); } else if (containsKey(prefix)) { // add the prefix if it matches exactly a property key keys.add(prefix); } return keys.iterator(); } catch (NamingException e) { fireError(EVENT_READ_PROPERTY, null, null, e); return new ArrayList().iterator(); } } /** * Because JNDI is based on a tree configuration, we need to filter down the * tree, till we find the Context specified by the key to start from. * Otherwise return null. * * @param path the path of keys to traverse in order to find the context * @param context the context to start from * @return The context at that key's location in the JNDI tree, or null if not found * @throws NamingException if JNDI has an issue */ private Context getContext(List path, Context context) throws NamingException { // return the current context if the path is empty if (path == null || path.isEmpty()) { return context; } String key = (String) path.get(0); // search a context matching the key in the context's elements NamingEnumeration elements = null; try { elements = context.list(""); while (elements.hasMore()) { NameClassPair nameClassPair = (NameClassPair) elements.next(); String name = nameClassPair.getName(); Object object = context.lookup(name); if (object instanceof Context && name.equals(key)) { Context subcontext = (Context) object; // recursive search in the sub context return getContext(path.subList(1, path.size()), subcontext); } } } finally { if (elements != null) { elements.close(); } } return null; } /** * Returns a flag whether this configuration is empty. * * @return the empty flag */ public boolean isEmpty() { try { NamingEnumeration enumeration = null; try { enumeration = getBaseContext().list(""); return !enumeration.hasMore(); } finally { // close the enumeration if (enumeration != null) { enumeration.close(); } } } catch (NamingException e) { fireError(EVENT_READ_PROPERTY, null, null, e); return true; } } /** * <p><strong>This operation is not supported and will throw an * UnsupportedOperationException.</strong></p> * * @param key the key * @param value the value * @throws UnsupportedOperationException */ public void setProperty(String key, Object value) { throw new UnsupportedOperationException("This operation is not supported"); } /** * Removes the specified property. * * @param key the key of the property to remove */ public void clearProperty(String key) { clearedProperties.add(key); } /** * Checks whether the specified key is contained in this configuration. * * @param key the key to check * @return a flag whether this key is stored in this configuration */ public boolean containsKey(String key) { if (clearedProperties.contains(key)) { return false; } key = StringUtils.replace(key, ".", "/"); try { // throws a NamingException if JNDI doesn't contain the key. getBaseContext().lookup(key); return true; } catch (NameNotFoundException e) { // expected exception, no need to log it return false; } catch (NamingException e) { fireError(EVENT_READ_PROPERTY, key, null, e); return false; } } /** * Returns the prefix. * @return the prefix */ public String getPrefix() { return prefix; } /** * Sets the prefix. * * @param prefix The prefix to set */ public void setPrefix(String prefix) { this.prefix = prefix; // clear the previous baseContext baseContext = null; } /** * Returns the value of the specified property. * * @param key the key of the property * @return the value of this property */ public Object getProperty(String key) { if (clearedProperties.contains(key)) { return null; } try { key = StringUtils.replace(key, ".", "/"); return getBaseContext().lookup(key); } catch (NameNotFoundException e) { // expected exception, no need to log it return null; } catch (NotContextException nctxex) { // expected exception, no need to log it return null; } catch (NamingException e) { fireError(EVENT_READ_PROPERTY, key, null, e); return null; } } /** * <p><strong>This operation is not supported and will throw an * UnsupportedOperationException.</strong></p> * * @param key the key * @param obj the value * @throws UnsupportedOperationException */ protected void addPropertyDirect(String key, Object obj) { throw new UnsupportedOperationException("This operation is not supported"); } /** * Return the base context with the prefix applied. * * @return the base context * @throws NamingException if an error occurs */ public Context getBaseContext() throws NamingException { if (baseContext == null) { baseContext = (Context) getContext().lookup(prefix == null ? "" : prefix); } return baseContext; } /** * Return the initial context used by this configuration. This context is * independent of the prefix specified. * * @return the initial context */ public Context getContext() { return context; } /** * Set the initial context of the configuration. * * @param context the context */ public void setContext(Context context) { // forget the removed properties clearedProperties.clear(); // change the context this.context = context; } }