View Javadoc

1   /*
2    * $Id: PooledJavaComponent.java 20486 2010-12-07 11:12:25Z dirk.olmes $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  
11  package org.mule.component;
12  
13  import org.mule.api.MuleContext;
14  import org.mule.api.MuleException;
15  import org.mule.api.component.Component;
16  import org.mule.api.component.InterfaceBinding;
17  import org.mule.api.component.LifecycleAdapter;
18  import org.mule.api.lifecycle.InitialisationCallback;
19  import org.mule.api.lifecycle.InitialisationException;
20  import org.mule.api.model.EntryPointResolverSet;
21  import org.mule.api.object.ObjectFactory;
22  import org.mule.config.PoolingProfile;
23  import org.mule.util.pool.DefaultLifecycleEnabledObjectPool;
24  import org.mule.util.pool.LifecyleEnabledObjectPool;
25  import org.mule.util.pool.ObjectPool;
26  
27  import java.util.List;
28  
29  /**
30   * <code>PooledJavaComponent</code> implements pooling.
31   */
32  public class PooledJavaComponent extends AbstractJavaComponent
33  {
34  
35      protected PoolingProfile poolingProfile;
36      protected LifecyleEnabledObjectPool lifecycleAdapterPool;
37  
38      public PooledJavaComponent()
39      {
40          super();
41      }
42  
43      public PooledJavaComponent(ObjectFactory objectFactory)
44      {
45          this(objectFactory, null);
46      }
47  
48      public PooledJavaComponent(ObjectFactory objectFactory, PoolingProfile poolingProfile)
49      {
50          super(objectFactory);
51          this.poolingProfile = poolingProfile;
52      }
53  
54      public PooledJavaComponent(ObjectFactory objectFactory,
55                                 PoolingProfile poolingProfile,
56                                 EntryPointResolverSet entryPointResolverSet,
57                                 List<InterfaceBinding> bindings)
58      {
59          super(objectFactory, entryPointResolverSet, bindings);
60          this.poolingProfile = poolingProfile;
61      }
62  
63      @Override
64      protected LifecycleAdapter borrowComponentLifecycleAdaptor() throws Exception
65      {
66          return (LifecycleAdapter) lifecycleAdapterPool.borrowObject();
67      }
68  
69      @Override
70      protected void returnComponentLifecycleAdaptor(LifecycleAdapter lifecycleAdapter)
71      {
72          lifecycleAdapterPool.returnObject(lifecycleAdapter);
73      }
74  
75      @Override
76      protected void doStart() throws MuleException
77      {
78          super.doStart();
79          // Wrap pool's objectFactory with a LifeCycleAdaptor factory so we pool
80          // LifeCycleAdaptor's and not just pojo instances.
81          lifecycleAdapterPool = new DefaultLifecycleEnabledObjectPool(new LifeCycleAdapterFactory(), poolingProfile, muleContext);
82          lifecycleAdapterPool.initialise();
83          lifecycleAdapterPool.start();
84      }
85  
86      @Override
87      protected void doStop() throws MuleException
88      {
89          super.doStop();
90          if (lifecycleAdapterPool != null)
91          {
92              lifecycleAdapterPool.stop();
93              lifecycleAdapterPool.close();
94              lifecycleAdapterPool = null;
95          }
96      }
97  
98      public void setPoolingProfile(PoolingProfile poolingProfile)
99      {
100         // TODO What happens if this is set while component is started? Should we i)
101         // do nothing ii) issue warning iii) stop/start the pool
102         // (!!) iv) throw exception?
103         this.poolingProfile = poolingProfile;
104     }
105 
106     public PoolingProfile getPoolingProfile()
107     {
108         return poolingProfile;
109     }
110 
111     /**
112      * <code>LifeCycleAdaptorFactory</code> wraps the Component' s
113      * {@link ObjectFactory}. The LifeCycleAdaptorFactory <code>getInstance()</code> method
114      * creates a new {@link LifecycleAdapter} wrapping the object instance obtained
115      * for the component instance {@link ObjectFactory} set on the {@link Component}.
116      * <br/>
117      * This allows us to keep {@link LifecycleAdapter} creation in the Component and
118      * out of the {@link DefaultLifecycleEnabledObjectPool} and to use the generic
119      * {@link ObjectPool} interface.
120      */
121     protected class LifeCycleAdapterFactory implements ObjectFactory
122     {
123         public Object getInstance(MuleContext context) throws Exception
124         {
125             return createLifecycleAdaptor();
126         }
127 
128         public Class<?> getObjectClass()
129         {
130             return LifecycleAdapter.class;
131         }
132 
133         public void initialise() throws InitialisationException
134         {
135             objectFactory.initialise();
136         }
137 
138         public void dispose()
139         {
140             objectFactory.dispose();
141         }
142 
143         public void addObjectInitialisationCallback(InitialisationCallback callback)
144         {
145             objectFactory.addObjectInitialisationCallback(callback);
146         }
147 
148         public boolean isSingleton()
149         {
150             return false;
151         }
152 
153         public boolean isExternallyManagedLifecycle()
154         {
155             return objectFactory.isExternallyManagedLifecycle();
156         }
157 
158         public boolean isAutoWireObject()
159         {
160             return objectFactory.isAutoWireObject();
161         }
162     }
163 }