Spring/spring-data-redis
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Factor JredisPool to a common Pool interface

Browse Source
This commit is contained in:
Jennifer Hickey
2013-06-23 16:39:30 -07:00
parent 83b87b663e
commit bae8a579d5
12 changed files with 309 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
src/main/java/org/springframework/data/redis/connection/Pool.java Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2011-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.redis.connection;
/**
* Pool of resources
*
* @author Jennifer Hickey
*
*/
public interface Pool<T> {
/**
*
* @return A resource, if available
*/
T getResource();
/**
*
* @param resource
* A broken resource that should be invalidated
*/
void returnBrokenResource(final T resource);
/**
*
* @param resource
* A resource to return to the pool
*/
void returnResource(final T resource);
/**
* Destroys the pool
*/
void destroy();
}

46
src/main/java/org/springframework/data/redis/connection/PoolException.java Normal file
View File

@@ -0,0 +1,46 @@
/*
* Copyright 2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.redis.connection;
import org.springframework.core.NestedRuntimeException;
/**
* Exception thrown when there are issues with a resource pool
*
* @author Jennifer Hickey
*
*/
@SuppressWarnings("serial")
public class PoolException extends NestedRuntimeException {
/**
* Constructs a new <code>PoolException</code> instance.
*
* @param msg
* @param cause
*/
public PoolException(String msg, Throwable cause) {
super(msg, cause);
}
/**
* Constructs a new <code>PoolException</code> instance.
*
* @param msg
*/
public PoolException(String msg) {
super(msg);
}
}

213
src/main/java/org/springframework/data/redis/connection/jredis/DefaultJredisPool.java
View File

@@ -1,213 +0,0 @@
/*
* Copyright 2011-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.redis.connection.jredis;
import org.apache.commons.pool.BasePoolableObjectFactory;
import org.apache.commons.pool.impl.GenericObjectPool;
import org.apache.commons.pool.impl.GenericObjectPool.Config;
import org.jredis.ClientRuntimeException;
import org.jredis.JRedis;
import org.jredis.connector.Connection;
import org.jredis.connector.ConnectionSpec;
import org.jredis.connector.Connection.Socket.Property;
import org.jredis.ri.alphazero.JRedisClient;
import org.jredis.ri.alphazero.connection.DefaultConnectionSpec;
import org.springframework.util.StringUtils;
/**
* Default implementation of {@link JredisPool}
*
* @author Jennifer Hickey
*
*/
public class DefaultJredisPool implements JredisPool {
private final GenericObjectPool internalPool;
/**
* Uses the {@link Config} and {@link ConnectionSpec} defaults for
* configuring the connection pool
*
* @param hostName
* The Redis host
* @param port
* The Redis port
*/
public DefaultJredisPool(String hostName, int port) {
this(hostName, port, 0, null, 0, new Config());
}
/**
* Uses the {@link ConnectionSpec} defaults for configuring the connection
* pool
*
* @param hostName
* The Redis host
* @param port
* The Redis port
* @param poolConfig
* The pool {@link Config}
*/
public DefaultJredisPool(String hostName, int port, Config poolConfig) {
this(hostName, port, 0, null, 0, poolConfig);
}
/**
*
* Uses the {@link Config} defaults for configuring the connection pool
*
* @param connectionSpec
* The {@link ConnectionSpec} for connecting to Redis
*
*/
public DefaultJredisPool(ConnectionSpec connectionSpec) {
this.internalPool = new GenericObjectPool(new JredisFactory(connectionSpec), new Config());
}
/**
*
* @param connectionSpec
* The {@link ConnectionSpec} for connecting to Redis
*
* @param poolConfig
* The pool {@link Config}
*/
public DefaultJredisPool(ConnectionSpec connectionSpec, Config poolConfig) {
this.internalPool = new GenericObjectPool(new JredisFactory(connectionSpec), poolConfig);
}
/**
* Uses the {@link Config} defaults for configuring the connection pool
*
* @param hostName
* The Redis host
* @param port
* The Redis port
* @param dbIndex
* The index of the database all connections should use. The
* database will only be selected on initial creation of the
* pooled {@link JRedis} instances. Since calling select directly
* on {@link JRedis} is not supported, it is assumed that
* connections can be re-used without subsequent selects.
* @param password
* The password used for authenticating with the Redis server or
* null if no password required
* @param timeout
* The socket timeout or 0 to use the default socket timeout
*/
public DefaultJredisPool(String hostName, int port, int dbIndex, String password, int timeout) {
this(hostName, port, dbIndex, password, timeout, new Config());
}
/**
*
* @param hostName
* The Redis host
* @param port
* The Redis port
* @param dbIndex
* The index of the database all connections should use
* @param password
* The password used for authenticating with the Redis server or
* null if no password required
* @param timeout
* The socket timeout or 0 to use the default socket timeout
* @param poolConfig
* The pool {@link COnfig}
*/
public DefaultJredisPool(String hostName, int port, int dbIndex, String password, int timeout,
Config poolConfig) {
ConnectionSpec connectionSpec = DefaultConnectionSpec.newSpec(hostName, port, dbIndex, null);
connectionSpec.setConnectionFlag(Connection.Flag.RELIABLE, false);
if (StringUtils.hasLength(password)) {
connectionSpec.setCredentials(password);
}
if (timeout > 0) {
connectionSpec.setSocketProperty(Property.SO_TIMEOUT, timeout);
}
this.internalPool = new GenericObjectPool(new JredisFactory(connectionSpec), poolConfig);
}
public JRedis getResource() {
try {
return (JRedis) internalPool.borrowObject();
} catch (Exception e) {
throw new ClientRuntimeException("Could not get a resource from the pool", e);
}
}
public void returnBrokenResource(final JRedis resource) {
try {
internalPool.invalidateObject(resource);
} catch (Exception e) {
throw new ClientRuntimeException("Could not invalidate the broken resource", e);
}
}
public void returnResource(final JRedis resource) {
try {
internalPool.returnObject(resource);
} catch (Exception e) {
throw new ClientRuntimeException("Could not return the resource to the pool", e);
}
}
public void destroy() {
try {
internalPool.close();
} catch (Exception e) {
throw new ClientRuntimeException("Could not destroy the pool", e);
}
}
private static class JredisFactory extends BasePoolableObjectFactory {
private final ConnectionSpec connectionSpec;
public JredisFactory(ConnectionSpec connectionSpec) {
super();
this.connectionSpec = connectionSpec;
}
public Object makeObject() throws Exception {
return new JRedisClient(connectionSpec);
}
public void destroyObject(final Object obj) throws Exception {
if (obj instanceof JRedis) {
try {
((JRedis) obj).quit();
}catch(Exception e) {
// Errors may happen if returning a broken resource
}
}
}
public boolean validateObject(final Object obj) {
if (obj instanceof JRedis) {
try {
((JRedis) obj).ping();
return true;
} catch (Exception e) {
return false;
}
} else {
return false;
}
}
}
}

5
src/main/java/org/springframework/data/redis/connection/jredis/JredisConnection.java
View File

@@ -38,6 +38,7 @@ import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.RedisSystemException;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.connection.Pool;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.connection.SortParameters;
@@ -57,7 +58,7 @@ public class JredisConnection implements RedisConnection {
private static final Method SERVICE_REQUEST;
private final JRedis jredis;
private final JredisPool pool;
private final Pool<JRedis> pool;
private boolean isClosed = false;
/** flag indicating whether the connection needs to be dropped or not */
private boolean broken = false;
@@ -77,7 +78,7 @@ public class JredisConnection implements RedisConnection {
this(jredis, null);
}
public JredisConnection(JRedis jredis, JredisPool pool) {
public JredisConnection(JRedis jredis, Pool<JRedis> pool) {
Assert.notNull(jredis, "a not-null instance required");
this.jredis = jredis;
this.pool = pool;

6
src/main/java/org/springframework/data/redis/connection/jredis/JredisConnectionFactory.java
View File

@@ -16,6 +16,7 @@
package org.springframework.data.redis.connection.jredis;
import org.jredis.ClientRuntimeException;
import org.jredis.JRedis;
import org.jredis.connector.Connection;
import org.jredis.connector.Connection.Socket.Property;
import org.jredis.connector.ConnectionSpec;
@@ -24,6 +25,7 @@ import org.jredis.ri.alphazero.connection.DefaultConnectionSpec;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.Pool;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.util.Assert;
@@ -44,7 +46,7 @@ public class JredisConnectionFactory implements InitializingBean, DisposableBean
private String password = null;
private int timeout;
private int dbIndex = DEFAULT_REDIS_DB;
private JredisPool pool;
private Pool<JRedis> pool;
private static final int DEFAULT_REDIS_PORT = 6379;
private static final int DEFAULT_REDIS_DB = 0;
@@ -67,7 +69,7 @@ public class JredisConnectionFactory implements InitializingBean, DisposableBean
this.connectionSpec = connectionSpec;
}
public JredisConnectionFactory(JredisPool pool) {
public JredisConnectionFactory(Pool<JRedis> pool) {
this.pool = pool;
}

192
src/main/java/org/springframework/data/redis/connection/jredis/JredisPool.java
View File

@@ -15,42 +15,200 @@
*/
package org.springframework.data.redis.connection.jredis;
import org.jredis.ClientRuntimeException;
import org.apache.commons.pool.BasePoolableObjectFactory;
import org.apache.commons.pool.impl.GenericObjectPool;
import org.apache.commons.pool.impl.GenericObjectPool.Config;
import org.jredis.JRedis;
import org.jredis.connector.Connection;
import org.jredis.connector.Connection.Socket.Property;
import org.jredis.connector.ConnectionSpec;
import org.jredis.ri.alphazero.JRedisClient;
import org.jredis.ri.alphazero.connection.DefaultConnectionSpec;
import org.springframework.data.redis.connection.Pool;
import org.springframework.data.redis.connection.PoolException;
import org.springframework.util.StringUtils;
/**
* Pool of {@link JRedis} connection objects.
* JRedis implementation of {@link Pool}
*
* @author Jennifer Hickey
*
*/
public interface JredisPool {
public class JredisPool implements Pool<JRedis> {
private final GenericObjectPool internalPool;
/**
* Uses the {@link Config} and {@link ConnectionSpec} defaults for
* configuring the connection pool
*
* @param hostName
* The Redis host
* @param port
* The Redis port
*/
public JredisPool(String hostName, int port) {
this(hostName, port, 0, null, 0, new Config());
}
/**
* Uses the {@link ConnectionSpec} defaults for configuring the connection
* pool
*
* @param hostName
* The Redis host
* @param port
* The Redis port
* @param poolConfig
* The pool {@link Config}
*/
public JredisPool(String hostName, int port, Config poolConfig) {
this(hostName, port, 0, null, 0, poolConfig);
}
/**
*
* @return A {@link JRedis} connection, if available. Throws a
* {@link ClientRuntimeException} if a connection cannot be borrowed
* from the pool
* Uses the {@link Config} defaults for configuring the connection pool
*
* @param connectionSpec
* The {@link ConnectionSpec} for connecting to Redis
*
*/
JRedis getResource();
public JredisPool(ConnectionSpec connectionSpec) {
this.internalPool = new GenericObjectPool(new JredisFactory(connectionSpec), new Config());
}
/**
*
* @param resource
* A broken {@link JRedis} connection that should be invalidated
*
* @param connectionSpec
* The {@link ConnectionSpec} for connecting to Redis
*
* @param poolConfig
* The pool {@link Config}
*/
void returnBrokenResource(final JRedis resource);
public JredisPool(ConnectionSpec connectionSpec, Config poolConfig) {
this.internalPool = new GenericObjectPool(new JredisFactory(connectionSpec), poolConfig);
}
/**
*
* @param resource
* A {@link JRedis} connection to return to the pool
* Uses the {@link Config} defaults for configuring the connection pool
*
* @param hostName
* The Redis host
* @param port
* The Redis port
* @param dbIndex
* The index of the database all connections should use. The
* database will only be selected on initial creation of the
* pooled {@link JRedis} instances. Since calling select directly
* on {@link JRedis} is not supported, it is assumed that
* connections can be re-used without subsequent selects.
* @param password
* The password used for authenticating with the Redis server or
* null if no password required
* @param timeout
* The socket timeout or 0 to use the default socket timeout
*/
void returnResource(final JRedis resource);
public JredisPool(String hostName, int port, int dbIndex, String password, int timeout) {
this(hostName, port, dbIndex, password, timeout, new Config());
}
/**
* Destroys the connection pool
*
* @param hostName
* The Redis host
* @param port
* The Redis port
* @param dbIndex
* The index of the database all connections should use
* @param password
* The password used for authenticating with the Redis server or
* null if no password required
* @param timeout
* The socket timeout or 0 to use the default socket timeout
* @param poolConfig
* The pool {@link COnfig}
*/
void destroy();
public JredisPool(String hostName, int port, int dbIndex, String password, int timeout,
Config poolConfig) {
ConnectionSpec connectionSpec = DefaultConnectionSpec.newSpec(hostName, port, dbIndex, null);
connectionSpec.setConnectionFlag(Connection.Flag.RELIABLE, false);
if (StringUtils.hasLength(password)) {
connectionSpec.setCredentials(password);
}
if (timeout > 0) {
connectionSpec.setSocketProperty(Property.SO_TIMEOUT, timeout);
}
this.internalPool = new GenericObjectPool(new JredisFactory(connectionSpec), poolConfig);
}
public JRedis getResource() {
try {
return (JRedis) internalPool.borrowObject();
} catch (Exception e) {
throw new PoolException("Could not get a resource from the pool", e);
}
}
public void returnBrokenResource(final JRedis resource) {
try {
internalPool.invalidateObject(resource);
} catch (Exception e) {
throw new PoolException("Could not invalidate the broken resource", e);
}
}
public void returnResource(final JRedis resource) {
try {
internalPool.returnObject(resource);
} catch (Exception e) {
throw new PoolException("Could not return the resource to the pool", e);
}
}
public void destroy() {
try {
internalPool.close();
} catch (Exception e) {
throw new PoolException("Could not destroy the pool", e);
}
}
private static class JredisFactory extends BasePoolableObjectFactory {
private final ConnectionSpec connectionSpec;
public JredisFactory(ConnectionSpec connectionSpec) {
super();
this.connectionSpec = connectionSpec;
}
public Object makeObject() throws Exception {
return new JRedisClient(connectionSpec);
}
public void destroyObject(final Object obj) throws Exception {
if (obj instanceof JRedis) {
try {
((JRedis) obj).quit();
}catch(Exception e) {
// Errors may happen if returning a broken resource
}
}
}
public boolean validateObject(final Object obj) {
if (obj instanceof JRedis) {
try {
((JRedis) obj).ping();
return true;
} catch (Exception e) {
return false;
}
} else {
return false;
}
}
}
}