View Javadoc

1   /**
2    *  Copyright 2003-2006 Greg Luck
3    *
4    *  Licensed under the Apache License, Version 2.0 (the "License");
5    *  you may not use this file except in compliance with the License.
6    *  You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   *  Unless required by applicable law or agreed to in writing, software
11   *  distributed under the License is distributed on an "AS IS" BASIS,
12   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   *  See the License for the specific language governing permissions and
14   *  limitations under the License.
15   */
16  
17  package net.sf.ehcache.distribution;
18  
19  import net.sf.ehcache.event.CacheEventListener;
20  import net.sf.ehcache.event.CacheEventListenerFactory;
21  import net.sf.ehcache.util.PropertyUtil;
22  
23  import java.util.Properties;
24  
25  /**
26   * Creates an RMICacheReplicator using properties. Config lines look like:
27   * <pre>&lt;cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
28   * properties="
29   * replicateAsynchronously=true,
30   * replicatePuts=true
31   * replicateUpdates=true
32   * replicateUpdatesViaCopy=true
33   * replicateRemovals=true
34   * "/&gt;</pre>
35   *
36   * @author <a href="mailto:gluck@thoughtworks.com">Greg Luck</a>
37   * @version $Id: RMICacheReplicatorFactory.java 52 2006-04-24 14:50:03Z gregluck $
38   */
39  public final class RMICacheReplicatorFactory extends CacheEventListenerFactory {
40      private static final String REPLICATE_PUTS = "replicatePuts";
41      private static final String REPLICATE_UPDATES = "replicateUpdates";
42      private static final String REPLICATE_UPDATES_VIA_COPY = "replicateUpdatesViaCopy";
43      private static final String REPLICATE_REMOVALS = "replicateRemovals";
44      private static final String REPLICATE_ASYNCHRONOUSLY = "replicateAsynchronously";
45  
46      /**
47       * Create a <code>CacheEventListener</code> which is also a CacheReplicator.
48       * <p/>
49       * The defaults if properties are not specified are:
50       * <ul>
51       * <li>replicatePuts=true
52       * <li>replicateUpdates=true
53       * <li>replicateUpdatesViaCopy=true
54       * <li>replicateRemovals=true;
55       * <li>replicateAsynchronously=true
56       * </ul>
57       *
58       * @param properties implementation specific properties. These are configured as comma
59       *                   separated name value pairs in ehcache.xml e.g.
60       *                   <p/>
61       *                   <code>
62       *                   &lt;cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
63       *                   properties="
64       *                   replicateAsynchronously=true,
65       *                   replicatePuts=true
66       *                   replicateUpdates=true
67       *                   replicateUpdatesViaCopy=true
68       *                   replicateRemovals=true
69       *                   "/&gt;</code>
70       * @return a constructed CacheEventListener
71       */
72      public final CacheEventListener createCacheEventListener(Properties properties) {
73          boolean replicatePuts = extractReplicatePuts(properties);
74          boolean replicateUpdates = extractReplicateUpdates(properties);
75          boolean replicateUpdatesViaCopy = extractReplicateUpdatesViaCopy(properties);
76          boolean replicateRemovals = extractReplicateRemovals(properties);
77          boolean replicateAsynchronously = extractReplicateAsynchronously(properties);
78  
79          if (replicateAsynchronously) {
80              return new RMIAsynchronousCacheReplicator(
81                      replicatePuts,
82                      replicateUpdates,
83                      replicateUpdatesViaCopy,
84                      replicateRemovals);
85          } else {
86              return new RMISynchronousCacheReplicator(
87                      replicatePuts,
88                      replicateUpdates,
89                      replicateUpdatesViaCopy,
90                      replicateRemovals);
91          }
92      }
93  
94      private static boolean extractReplicateAsynchronously(Properties properties) {
95          boolean replicateAsynchronously;
96          String replicateAsynchronouslyString = PropertyUtil.extractAndLogProperty(REPLICATE_ASYNCHRONOUSLY, properties);
97          if (replicateAsynchronouslyString != null) {
98              replicateAsynchronously = parseBoolean(replicateAsynchronouslyString);
99          } else {
100             replicateAsynchronously = true;
101         }
102         return replicateAsynchronously;
103     }
104 
105     private static boolean extractReplicateRemovals(Properties properties) {
106         boolean replicateRemovals;
107         String replicateRemovalsString = PropertyUtil.extractAndLogProperty(REPLICATE_REMOVALS, properties);
108         if (replicateRemovalsString != null) {
109             replicateRemovals = parseBoolean(replicateRemovalsString);
110         } else {
111             replicateRemovals = true;
112         }
113         return replicateRemovals;
114     }
115 
116     private static boolean extractReplicateUpdatesViaCopy(Properties properties) {
117         boolean replicateUpdatesViaCopy;
118         String replicateUpdatesViaCopyString = PropertyUtil.extractAndLogProperty(REPLICATE_UPDATES_VIA_COPY, properties);
119         if (replicateUpdatesViaCopyString != null) {
120             replicateUpdatesViaCopy = parseBoolean(replicateUpdatesViaCopyString);
121         } else {
122             replicateUpdatesViaCopy = true;
123         }
124         return replicateUpdatesViaCopy;
125     }
126 
127     private static boolean extractReplicateUpdates(Properties properties) {
128         boolean replicateUpdates;
129         String replicateUpdatesString = PropertyUtil.extractAndLogProperty(REPLICATE_UPDATES, properties);
130         if (replicateUpdatesString != null) {
131             replicateUpdates = parseBoolean(replicateUpdatesString);
132         } else {
133             replicateUpdates = true;
134         }
135         return replicateUpdates;
136     }
137 
138     private static boolean extractReplicatePuts(Properties properties) {
139         boolean replicatePuts;
140         String replicatePutsString = PropertyUtil.extractAndLogProperty(REPLICATE_PUTS, properties);
141         if (replicatePutsString != null) {
142             replicatePuts = parseBoolean(replicatePutsString);
143         } else {
144             replicatePuts = true;
145         }
146         return replicatePuts;
147     }
148 
149     private static boolean parseBoolean(String name) {
150         return ((name != null) && name.equalsIgnoreCase("true"));
151     }
152 }