View Javadoc

1   package org.apache.turbine.services.pool;
2   
3   /*
4    * Copyright 2001-2005 The Apache Software Foundation.
5    *
6    * Licensed under the Apache License, Version 2.0 (the "License")
7    * you may not use this file except in compliance with the License.
8    * You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  
19  import org.apache.turbine.services.TurbineServices;
20  import org.apache.turbine.util.TurbineException;
21  
22  /***
23   * This is a static accessor to common pooling tasks.
24   *
25   * @author <a href="mailto:ilkka.priha@simsoft.fi">Ilkka Priha</a>
26   * @version $Id: TurbinePool.java 264148 2005-08-29 14:21:04Z henning $
27   */
28  public abstract class TurbinePool
29  {
30      /***
31       * Gets an instance of a named class either from the pool
32       * or by calling the Factory Service if the pool is empty.
33       *
34       * @param className the name of the class.
35       * @return the instance.
36       * @throws TurbineException if recycling fails.
37       */
38      public static Object getInstance(String className)
39              throws TurbineException
40      {
41          return getService().getInstance(className);
42      }
43  
44      /***
45       * Gets an instance of a named class either from the pool
46       * or by calling the Factory Service if the pool is empty.
47       * The specified class loader will be passed to the Factory Service.
48       *
49       * @param className the name of the class.
50       * @param loader the class loader.
51       * @return the instance.
52       * @throws TurbineException if recycling fails.
53       */
54      public static Object getInstance(String className,
55                                       ClassLoader loader)
56              throws TurbineException
57      {
58          return getService().getInstance(className, loader);
59      }
60  
61      /***
62       * Gets an instance of a named class either from the pool
63       * or by calling the Factory Service if the pool is empty.
64       * Parameters for its constructor are given as an array of objects,
65       * primitive types must be wrapped with a corresponding class.
66       *
67       * @param className the name of the class.
68       * @param loader the class loader.
69       * @param params an array containing the parameters of the constructor.
70       * @param signature an array containing the signature of the constructor.
71       * @return the instance.
72       * @throws TurbineException if recycling fails.
73       */
74      public static Object getInstance(String className,
75                                       Object[] params,
76                                       String[] signature)
77              throws TurbineException
78      {
79          return getService().getInstance(className, params, signature);
80      }
81  
82      /***
83       * Gets an instance of a named class either from the pool
84       * or by calling the Factory Service if the pool is empty.
85       * Parameters for its constructor are given as an array of objects,
86       * primitive types must be wrapped with a corresponding class.
87       * The specified class loader will be passed to the Factory Service.
88       *
89       * @param className the name of the class.
90       * @param loader the class loader.
91       * @param params an array containing the parameters of the constructor.
92       * @param signature an array containing the signature of the constructor.
93       * @return the instance.
94       * @throws TurbineException if recycling fails.
95       */
96      public static Object getInstance(String className,
97                                       ClassLoader loader,
98                                       Object[] params,
99                                       String[] signature)
100             throws TurbineException
101     {
102         return getService().getInstance(className, loader, params, signature);
103     }
104 
105     /***
106      * Gets an instance of a specified class either from the pool
107      * or by instatiating from the class if the pool is empty.
108      *
109      * @param clazz the class.
110      * @return the instance.
111      * @throws TurbineException if recycling fails.
112      */
113     public static Object getInstance(Class clazz)
114             throws TurbineException
115     {
116         return getService().getInstance(clazz);
117     }
118 
119     /***
120      * Gets an instance of a specified class either from the pool
121      * or by instatiating from the class if the pool is empty.
122      *
123      * @param clazz the class.
124      * @param params an array containing the parameters of the constructor.
125      * @param signature an array containing the signature of the constructor.
126      * @return the instance.
127      * @throws TurbineException if recycling fails.
128      */
129     public static Object getInstance(Class clazz,
130                                      Object params[],
131                                      String signature[])
132             throws TurbineException
133     {
134         return getService().getInstance(clazz, params, signature);
135     }
136 
137     /***
138      * Puts a used object back to the pool. Objects implementing
139      * the Recyclable interface can provide a recycle method to
140      * be called when they are reused and a dispose method to be
141      * called when they are returned to the pool.
142      *
143      * @param instance the object instance to recycle.
144      * @return true if the instance was accepted.
145      */
146     public static boolean putInstance(Object instance)
147     {
148         return getService().putInstance(instance);
149     }
150 
151     /***
152      * Gets the pool service implementation.
153      *
154      * @return the pool service implementation.
155      */
156     public static PoolService getService()
157     {
158         return (PoolService) TurbineServices.
159                 getInstance().getService(PoolService.SERVICE_NAME);
160     }
161 }