netty里集成spring注入jedis

Jedis是官方推荐的连接redius的客户端，之所以没有使用redis的jdbc的原因是：

1) redis的jdbc的set方法有问题，set字符串，但是取出来的却是字符串长度

2)redis的jdbc的性能低并且不稳定，网上有人做测试证明过。

1.准备好需要的jar包

 

spring.jar            //spring包
netty-3.2.4.Final.jar   // netty库
commons-dbcp.jar    // dbcp数据库连接池
mysql-connector-java-5.1.6.jar // dbcp数据库连接池需要依赖
commons-logging.jar  //spring.jar需要依赖
commons-pool.jar   // dbcp数据库连接池需要依赖
jedis-2.0.0.jar  //jedis包

2.新建java工程TestNettyServer并添加spring

详情见《netty里集成spring注入mysq连接池》

3.注入jedis

 

3.1构建访问redis通用类

在RedisUtil.java里加入

 

import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;


/**
 * 连接和使用数据库资源的工具类
 *
 * @author yifangyou
 * @version IAM 2011-07-27
 */
public class RedisUtil {

    /**
     * 数据源
     */
    private ShardedJedisPool shardedJedisPool;



    /**
     * 获取数据库连接
     * @return conn
     */
    public ShardedJedis getConnection() {
        ShardedJedis jedis=null;
        try {
            jedis=shardedJedisPool.getResource();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return jedis;
    }

    /**
     * 关闭数据库连接
     * @param conn
     */
    public void closeConnection(ShardedJedis jedis) {
        if (null != jedis) {
            try {
                shardedJedisPool.returnResource(jedis);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 设置数据
     * @param conn
     */
    public boolean setData(String key,String value) {
            try {
                ShardedJedis jedis=shardedJedisPool.getResource();
                jedis.set(key,value);
                shardedJedisPool.returnResource(jedis);
                return true;
            } catch (Exception e) {
                e.printStackTrace();

            }
        return false;
    }

    /**
     * 获取数据
     * @param conn
     */
    public String getData(String key) {
        String value=null;
            try {
                ShardedJedis jedis=shardedJedisPool.getResource();
                value=jedis.get(key);
                shardedJedisPool.returnResource(jedis);
                return value;
            } catch (Exception e) {
                e.printStackTrace();

            }
        return value;
    }

    /**
     * 设置连接池
     * @return 数据源
     */
    public void setShardedJedisPool(ShardedJedisPool shardedJedisPool) {
        this.shardedJedisPool = shardedJedisPool;
    }

    /**
     * 获取连接池
     * @return 数据源
     */
    public ShardedJedisPool getShardedJedisPool() {
        return shardedJedisPool;
    }
}

3.2HttpRequestHandler注入jedis

在applicationContext.xml里加入

 

 <!-- POOL配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <property name="maxActive"  value="20" />
    <property name="maxIdle" value="10" />
    <property name="maxWait" value="1000" />
    <property name="testOnBorrow"  value="true"/>
</bean>

<!-- jedis shard信息配置 -->
<bean id="jedis.shardInfo" class="redis.clients.jedis.JedisShardInfo">
    <constructor-arg index="0" value="122.49.26.60" />
    <constructor-arg index="1" value="6379" />
</bean>

<!-- jedis shard pool配置 -->
<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
    <constructor-arg index="0" ref="jedisPoolConfig" />
    <constructor-arg index="1">
        <list>
            <ref bean="jedis.shardInfo" />
        </list>
    </constructor-arg>
</bean>
 <bean id="redisUtil" class="org.jboss.netty.example.http.snoop.RedisUtil">
    <property name="shardedJedisPool" ref="shardedJedisPool" />
</bean>
 <bean id="httpServerPipelineFactory" class="org.jboss.netty.example.http.snoop.HttpServerPipelineFactory" scope="prototype">
    <property name="httpRequestHandler" ref="httpRequestHandler" />
 </bean>
 <bean id="httpRequestHandler" class="org.jboss.netty.example.http.snoop.HttpRequestHandler" scope="prototype">
    <property name="databaseUtil" ref="databaseUtil" />
    <property name="redisUtil" ref="redisUtil" />
 </bean>

4.测试

访问

http://127.0.0.1:8081/sfds?username=yifangyou

 

 

 

源码下载：http://down.51cto.com/data/229434

 

修改HttpRequestHandler.java

 

package org.jboss.netty.example.http.snoop;

  import static org.jboss.netty.handler.codec.http.HttpHeaders.*;
  import static org.jboss.netty.handler.codec.http.HttpHeaders.Names.*;
  import static org.jboss.netty.handler.codec.http.HttpResponseStatus.*;
  import static org.jboss.netty.handler.codec.http.HttpVersion.*;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Set;

  import org.jboss.netty.buffer.ChannelBuffer;
  import org.jboss.netty.buffer.ChannelBuffers;
  import org.jboss.netty.channel.ChannelFuture;
  import org.jboss.netty.channel.ChannelFutureListener;
  import org.jboss.netty.channel.ChannelHandlerContext;
  import org.jboss.netty.channel.ExceptionEvent;
  import org.jboss.netty.channel.MessageEvent;
  import org.jboss.netty.channel.SimpleChannelUpstreamHandler;
  import org.jboss.netty.handler.codec.http.Cookie;
  import org.jboss.netty.handler.codec.http.CookieDecoder;
  import org.jboss.netty.handler.codec.http.CookieEncoder;
  import org.jboss.netty.handler.codec.http.DefaultHttpResponse;
  import org.jboss.netty.handler.codec.http.HttpChunk;
  import org.jboss.netty.handler.codec.http.HttpChunkTrailer;
  import org.jboss.netty.handler.codec.http.HttpRequest;
  import org.jboss.netty.handler.codec.http.HttpResponse;
import org.jboss.netty.handler.codec.http.HttpResponseStatus;
  import org.jboss.netty.handler.codec.http.QueryStringDecoder;
import org.jboss.netty.util.CharsetUtil;

  /**
   * @author <a href="http://www.jboss.org/netty/">The Netty Project</a>
   * @author Andy Taylor ([e-mail])
   * @author <a href="http://gleamynode.net/">Trustin Lee</a>
   *
   * @version $Rev: 2368 $, $Date: 2010-10-18 17:19:03 +0900 (Mon, 18 Oct 2010) $
   */
  public class HttpRequestHandler extends SimpleChannelUpstreamHandler {

      private DatabaseUtil databaseUtil;
      private RedisUtil redisUtil;
      private HttpRequest request;
      /** Buffer that stores the response content */
      private final StringBuilder buf = new StringBuilder();

      @Override
      public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
              HttpRequest request = this.request = (HttpRequest) e.getMessage();
              redisUtil.setData("yifangyou", "testpassword");
              buf.setLength(0);
              QueryStringDecoder queryStringDecoder = new QueryStringDecoder(request.getUri());
              Map<String, List<String>> params = queryStringDecoder.getParameters();
              if (!params.isEmpty()) {
                  HttpResponseStatus httpResponseStatus=HttpResponseStatus.OK;
                  if(params.containsKey("username")){
                      List<String> values=params.get("username");
                      String username="";
                      if(values.size()>0){
                          username=values.get(0);
                      }
                      String password=redisUtil.getData(username);
                      if(password==null){
                          buf.append("not found ");
                      }else{
                          buf.append(username+"'s password is:"+password);
                      }
                  }else{
                      buf.append("miss username");
                  }
                  writeResponse(e,httpResponseStatus,buf);
              }else{
                  buf.append("miss username");
                  writeResponse(e,OK,buf);
              }
     }

     private void writeResponse(MessageEvent e,HttpResponseStatus httpResponseStatus,StringBuilder buf) {
         // Decide whether to close the connection or not.
         boolean keepAlive = isKeepAlive(request);

         // Build the response object.
         HttpResponse response = new DefaultHttpResponse(HTTP_1_1, httpResponseStatus);
         response.setContent(ChannelBuffers.copiedBuffer(buf.toString(), CharsetUtil.UTF_8));
         response.setHeader(CONTENT_TYPE, "text/plain; charset=UTF-8");

         // Write the response.
         ChannelFuture future = e.getChannel().write(response);

         // Close the non-keep-alive connection after the write operation is done.
         future.addListener(ChannelFutureListener.CLOSE);
     }

     private void send100Continue(MessageEvent e) {
         HttpResponse response = new DefaultHttpResponse(HTTP_1_1, CONTINUE);
         e.getChannel().write(response);
     }

     @Override
     public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
             throws Exception {
         e.getCause().printStackTrace();
         e.getChannel().close();
     }

    public void setDatabaseUtil(DatabaseUtil databaseUtil) {
        this.databaseUtil = databaseUtil;
    }

    public DatabaseUtil getDatabaseUtil() {
        return databaseUtil;
    }

    public void setRedisUtil(RedisUtil redisUtil) {
        this.redisUtil = redisUtil;
    }

    public RedisUtil getRedisUtil() {
        return redisUtil;
    }
 }

本文出自 “一方有” 博客，请务必保留此出处http://yifangyou.blog.51cto.com/900206/628163