View Javadoc

1   package org.apache.commons.digester3.plugins.strategies;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import java.util.Properties;
23  
24  import org.apache.commons.digester3.Digester;
25  import org.apache.commons.digester3.plugins.PluginException;
26  import org.apache.commons.digester3.plugins.RuleFinder;
27  import org.apache.commons.digester3.plugins.RuleLoader;
28  
29  /**
30   * A rule-finding algorithm which looks for a method with a specific name on a class whose name is derived from the
31   * plugin class name.
32   * 
33   * @since 1.6
34   */
35  public class FinderFromDfltClass
36      extends RuleFinder
37  {
38      private static final String DFLT_RULECLASS_SUFFIX = "RuleInfo";
39  
40      private static final String DFLT_METHOD_NAME = "addRules";
41  
42      private final String rulesClassSuffix;
43  
44      private final String methodName;
45  
46      /** See {@link #findLoader}. */
47      public FinderFromDfltClass()
48      {
49          this( DFLT_RULECLASS_SUFFIX, DFLT_METHOD_NAME );
50      }
51  
52      /**
53       * Create a rule-finder which invokes a method on a class whenever dynamic rules for a plugin need to be loaded. See
54       * the findRules method for more info.
55       * 
56       * @param rulesClassSuffix must be non-null.
57       * @param methodName may be null.
58       */
59      public FinderFromDfltClass( String rulesClassSuffix, String methodName )
60      {
61          this.rulesClassSuffix = rulesClassSuffix;
62          this.methodName = methodName;
63      }
64  
65      /**
66       * If there exists a class whose name is the plugin class name + the suffix specified to the constructor, then load
67       * that class, locate the appropriate rules-adding method on that class, and return an object encapsulating that
68       * info.
69       * <p>
70       * If there is no such class, then just return null.
71       * <p>
72       * The returned object (when non-null) will invoke the target method on the selected class whenever its addRules
73       * method is invoked. The target method is expected to have the following prototype:
74       * <code> public static void xxxxx(Digester d, String patternPrefix); </code>
75       *
76       * @param digester The digester instance where locating plugin classes
77       * @param pluginClass The plugin Java class
78       * @param p The properties object that holds any xml attributes the user may have specified on the plugin
79       *          declaration in order to indicate how to locate the plugin rules.
80       * @return a source of digester rules for the specified plugin class.
81       * @throws PluginException if the algorithm finds a source of rules, but there is something invalid
82       *         about that source.
83       */
84      @Override
85      public RuleLoader findLoader( Digester digester, Class<?> pluginClass, Properties p )
86          throws PluginException
87      {
88          String rulesClassName = pluginClass.getName() + rulesClassSuffix;
89  
90          Class<?> rulesClass = null;
91          try
92          {
93              rulesClass = digester.getClassLoader().loadClass( rulesClassName );
94          }
95          catch ( ClassNotFoundException cnfe )
96          {
97              // nope, no rule-info class in the classpath
98              return null;
99          }
100 
101         if ( methodName == null )
102         {
103             return new LoaderFromClass( rulesClass, DFLT_METHOD_NAME );
104         }
105 
106         return new LoaderFromClass( rulesClass, methodName );
107     }
108 
109 }