Spring FactoryBean support.

Added a Spring FactoryBean for simplifying
MemcachedClient creation in a Spring applications.
This is a patch for
http://code.google.com/p/spymemcached/issues/detail?id=164

Change-Id: Ib4051608631d976487ab8114083f6d32d35258a7
Reviewed-on: http://review.membase.org/4752
Reviewed-by: Matt Ingenthron <[email protected]>
Tested-by: Matt Ingenthron <[email protected]>

Author: eranharel

buildfile

@@ -59,7 +59,7 @@ define "memcached" do
   compile.options.target = '1.5'
   manifest["Implementation-Vendor"] = COPYRIGHT
   compile.with "log4j:log4j:jar:1.2.15", "jmock:jmock:jar:1.2.0",
-               "junit:junit:jar:4.4"
+               "junit:junit:jar:4.4", "org.springframework:spring-beans:jar:3.0.3.RELEASE"
 
   # Gen build
   gen_build_info "net.spy.memcached", "git"

src/main/java/net/spy/memcached/spring/MemcachedClientFactoryBean.java

@@ -0,0 +1,139 @@
+package net.spy.memcached.spring;
+
+import java.util.Collection;
+
+import net.spy.memcached.AddrUtil;
+import net.spy.memcached.ConnectionFactoryBuilder;
+import net.spy.memcached.ConnectionFactoryBuilder.Locator;
+import net.spy.memcached.ConnectionFactoryBuilder.Protocol;
+import net.spy.memcached.ConnectionObserver;
+import net.spy.memcached.FailureMode;
+import net.spy.memcached.HashAlgorithm;
+import net.spy.memcached.MemcachedClient;
+import net.spy.memcached.OperationFactory;
+import net.spy.memcached.auth.AuthDescriptor;
+import net.spy.memcached.ops.OperationQueueFactory;
+import net.spy.memcached.transcoders.Transcoder;
+
+import org.springframework.beans.factory.FactoryBean;
+
+/**
+ * A Spring {@link FactoryBean} creating {@link MemcachedClient} instances.
+ * <p>
+ * Usage example:
+ * <pre>
+ * {@code
+ * <bean id="memcachedClient" class="net.spy.memcached.utils.MemcachedClientFactoryBean">
+ *   <property name="servers" value="${pajamas.remoteHosts}"/>
+ *   <property name="protocol" value="${pajamas.client.protocol}"/>
+ *   <property name="transcoder">
+ *     <bean class="net.rubyeye.xmemcached.transcoders.SerializingTranscoder"/>
+ *   </property>
+ *   <property name="hashAlg" value="${pajamas.client.hashAlg}"/>
+ *   <property name="locatorType" value="${pajamas.client.locatorType}"/>
+ * </bean>
+ * }
+ * </pre>
+ * </p>
+ * @author Eran Harel
+ */
+public class MemcachedClientFactoryBean implements FactoryBean<MemcachedClient> {
+  private final ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder();
+  private String servers;
+
+  @Override
+  public MemcachedClient getObject() throws Exception {
+    return new MemcachedClient(connectionFactoryBuilder.build(), AddrUtil.getAddresses(servers));
+  }
+
+  @Override
+  public Class<MemcachedClient> getObjectType() {
+    return MemcachedClient.class;
+  }
+
+  @Override
+  public boolean isSingleton() {
+    return true;
+  }
+
+  public void setServers(final String servers) {
+    this.servers = servers;
+  }
+
+  public void setAuthDescriptor(final AuthDescriptor to) {
+    connectionFactoryBuilder.setAuthDescriptor(to);
+  }
+
+  public void setDaemon(final boolean d) {
+    connectionFactoryBuilder.setDaemon(d);
+  }
+
+  public void setFailureMode(final FailureMode fm) {
+    connectionFactoryBuilder.setFailureMode(fm);
+  }
+
+  public void setHashAlg(final HashAlgorithm to) {
+    connectionFactoryBuilder.setHashAlg(to);
+  }
+
+  public void setInitialObservers(final Collection<ConnectionObserver> obs) {
+    connectionFactoryBuilder.setInitialObservers(obs);
+  }
+
+  public void setLocatorType(final Locator l) {
+    connectionFactoryBuilder.setLocatorType(l);
+  }
+
+  public void setMaxReconnectDelay(final long to) {
+    connectionFactoryBuilder.setMaxReconnectDelay(to);
+  }
+
+  public void setOpFact(final OperationFactory f) {
+    connectionFactoryBuilder.setOpFact(f);
+  }
+
+  public void setOpQueueFactory(final OperationQueueFactory q) {
+    connectionFactoryBuilder.setOpQueueFactory(q);
+  }
+
+  public void setOpQueueMaxBlockTime(final long t) {
+    connectionFactoryBuilder.setOpQueueMaxBlockTime(t);
+  }
+
+  public void setOpTimeout(final long t) {
+    connectionFactoryBuilder.setOpTimeout(t);
+  }
+
+  public void setProtocol(final Protocol prot) {
+    connectionFactoryBuilder.setProtocol(prot);
+  }
+
+  public void setReadBufferSize(final int to) {
+    connectionFactoryBuilder.setReadBufferSize(to);
+  }
+
+  public void setReadOpQueueFactory(final OperationQueueFactory q) {
+    connectionFactoryBuilder.setReadOpQueueFactory(q);
+  }
+
+  public void setShouldOptimize(final boolean o) {
+    connectionFactoryBuilder.setShouldOptimize(o);
+  }
+
+  public void setTimeoutExceptionThreshold(final int to) {
+    connectionFactoryBuilder.setTimeoutExceptionThreshold(to);
+  }
+
+  public void setTranscoder(final Transcoder<Object> t) {
+    connectionFactoryBuilder.setTranscoder(t);
+  }
+
+  public void setUseNagleAlgorithm(final boolean to) {
+    connectionFactoryBuilder.setUseNagleAlgorithm(to);
+  }
+
+  public void setWriteOpQueueFactory(final OperationQueueFactory q) {
+    connectionFactoryBuilder.setWriteOpQueueFactory(q);
+  }
+
+}

src/test/java/net/spy/memcached/spring/MemcachedClientFactoryBeanTest.java

@@ -0,0 +1,45 @@
+package net.spy.memcached.spring;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+import net.spy.memcached.ConnectionFactoryBuilder.Protocol;
+import net.spy.memcached.FailureMode;
+import net.spy.memcached.HashAlgorithm;
+import net.spy.memcached.MemcachedClient;
+import net.spy.memcached.transcoders.SerializingTranscoder;
+import net.spy.memcached.transcoders.Transcoder;
+
+import org.junit.Test;
+
+/**
+ * Test cases for the {@link MemcachedClientFactoryBean} implementation.
+ *
+ * @author Eran Harel
+ */
+public class MemcachedClientFactoryBeanTest extends TestCase {
+
+  @Test
+  public void testGetObject() throws Exception {
+    final MemcachedClientFactoryBean factory = new MemcachedClientFactoryBean();
+    factory.setDaemon(true);
+    factory.setFailureMode(FailureMode.Cancel);
+    factory.setHashAlg(HashAlgorithm.CRC32_HASH);
+    factory.setProtocol(Protocol.BINARY);
+    factory.setServers("localhost:22211 localhost:22212");
+    factory.setShouldOptimize(true);
+    final Transcoder<Object> transcoder = new SerializingTranscoder();
+    factory.setTranscoder(transcoder);
+
+    final MemcachedClient memcachedClient = factory.getObject();
+
+    Assert.assertEquals("deamon", true, memcachedClient.isDaemon());
+    Assert.assertEquals("servers", 2, memcachedClient.getUnavailableServers().size());
+    Assert.assertSame("transcoder", transcoder, memcachedClient.getTranscoder());
+  }
+
+  @Test
+  public void testGetObjectType() {
+    Assert.assertEquals("object type", MemcachedClient.class, new MemcachedClientFactoryBean().getObjectType());
+  }
+
+}