title: NoClassDefFoundError and Netty
body: <p>First to say I'm n00b in Java. I can understand most concepts but in my situation I want somebody to help me. I'm using JBoss Netty to handle simple http request and using MemCachedClient check existence of client ip in memcached.</p>
  
  <pre><code>import org.jboss.netty.channel.ChannelHandler;
  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 com.danga.MemCached.*;
  
  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 &lt;a href="http://www.jboss.org/netty/"&gt;The Netty Project&lt;/a&gt;
  * @author Andy Taylor (andy.taylor@jboss.org)
  * @author &lt;a href="http://gleamynode.net/"&gt;Trustin Lee&lt;/a&gt;
  *
  * @version $Rev: 2368 $, $Date: 2010-10-18 17:19:03 +0900 (Mon, 18 Oct 2010) $
  */
  @SuppressWarnings({"ALL"})
  public class HttpRequestHandler extends SimpleChannelUpstreamHandler {
  
      private HttpRequest request;
      private boolean readingChunks;
      /** Buffer that stores the response content */
      private final StringBuilder buf = new StringBuilder();
      protected MemCachedClient mcc = new MemCachedClient();
      private static SockIOPool poolInstance = null;
  
      static {
  
  // server list and weights
          String[] servers =
                  {
                          "lcalhost:11211"
                  };
  
  //Integer[] weights = { 3, 3, 2 };
          Integer[] weights = {1};
  
  // grab an instance of our connection pool
          SockIOPool pool = SockIOPool.getInstance();
  
  // set the servers and the weights
          pool.setServers(servers);
          pool.setWeights(weights);
  
  // set some basic pool settings
  // 5 initial, 5 min, and 250 max conns
  // and set the max idle time for a conn
  // to 6 hours
          pool.setInitConn(5);
          pool.setMinConn(5);
          pool.setMaxConn(250);
          pool.setMaxIdle(21600000); //1000 * 60 * 60 * 6
  
  // set the sleep for the maint thread
  // it will wake up every x seconds and
  // maintain the pool size
          pool.setMaintSleep(30);
  
  // set some TCP settings
  // disable nagle
  // set the read timeout to 3 secs
  // and don't set a connect timeout
          pool.setNagle(false);
          pool.setSocketTO(3000);
          pool.setSocketConnectTO(0);
  
  // initialize the connection pool
          pool.initialize();
  
  
  // lets set some compression on for the client
  // compress anything larger than 64k
          //mcc.setCompressEnable(true);
          //mcc.setCompressThreshold(64 * 1024);
      }
  
      @Override
      public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
          HttpRequest request = this.request = (HttpRequest) e.getMessage();
          if(mcc.get(request.getHeader("X-Real-Ip")) != null)
          {
              HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);
              response.setHeader("X-Accel-Redirect", request.getUri());
              ctx.getChannel().write(response).addListener(ChannelFutureListener.CLOSE);
          }
          else {
              sendError(ctx, NOT_FOUND);
          }
  
      }
  
      private void writeResponse(MessageEvent e) {
          // Decide whether to close the connection or not.
          boolean keepAlive = isKeepAlive(request);
  
          // Build the response object.
          HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);
          response.setContent(ChannelBuffers.copiedBuffer(buf.toString(), CharsetUtil.UTF_8));
          response.setHeader(CONTENT_TYPE, "text/plain; charset=UTF-8");
  
          if (keepAlive) {
              // Add 'Content-Length' header only for a keep-alive connection.
              response.setHeader(CONTENT_LENGTH, response.getContent().readableBytes());
          }
  
          // Encode the cookie.
          String cookieString = request.getHeader(COOKIE);
          if (cookieString != null) {
              CookieDecoder cookieDecoder = new CookieDecoder();
              Set&lt;Cookie&gt; cookies = cookieDecoder.decode(cookieString);
              if(!cookies.isEmpty()) {
                  // Reset the cookies if necessary.
                  CookieEncoder cookieEncoder = new CookieEncoder(true);
                  for (Cookie cookie : cookies) {
                      cookieEncoder.addCookie(cookie);
                  }
                  response.addHeader(SET_COOKIE, cookieEncoder.encode());
              }
          }
  
          // Write the response.
          ChannelFuture future = e.getChannel().write(response);
  
          // Close the non-keep-alive connection after the write operation is done.
          if (!keepAlive) {
              future.addListener(ChannelFutureListener.CLOSE);
          }
      }
  
      @Override
      public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
              throws Exception {
          e.getCause().printStackTrace();
          e.getChannel().close();
      }
  
  
      private void sendError(ChannelHandlerContext ctx, HttpResponseStatus status) {
           HttpResponse response = new DefaultHttpResponse(HTTP_1_1, status);
           response.setHeader(CONTENT_TYPE, "text/plain; charset=UTF-8");
           response.setContent(ChannelBuffers.copiedBuffer(
                   "Failure: " + status.toString() + "\r\n",
                   CharsetUtil.UTF_8));
  
           // Close the connection as soon as the error message is sent.
           ctx.getChannel().write(response).addListener(ChannelFutureListener.CLOSE);
      }
  
  }
  </code></pre>
  
  <p>When I try to send request like <a href="http://127.0.0.1:8090/1/2/3" rel="nofollow">http://127.0.0.1:8090/1/2/3</a>
  I'm getting </p>
  
  <pre><code>java.lang.NoClassDefFoundError: com/danga/MemCached/MemCachedClient
          at httpClientValidator.server.HttpRequestHandler.&lt;clinit&gt;(HttpRequestHandler.java:66)
  </code></pre>
  
  <p>I believe it's not related to classpath. May be it's related to context in which mcc doesn't exist.
  Any help appreciated</p>
  
  <p>EDIT:
  Original code <a href="http://docs.jboss.org/netty/3.2/xref/org/jboss/netty/example/http/snoop/package-summary.html" rel="nofollow">http://docs.jboss.org/netty/3.2/xref/org/jboss/netty/example/http/snoop/package-summary.html</a>
  I've modified some parts to fit my needs.</p>