diff --git a/src/main/java/org/jboss/netty/handler/codec/http/HttpMethod.java b/src/main/java/org/jboss/netty/handler/codec/http/HttpMethod.java
index bb107adc92..6f6187997f 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/HttpMethod.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/HttpMethod.java
@@ -21,6 +21,9 @@
  */
 package org.jboss.netty.handler.codec.http;
 
+import java.util.HashMap;
+import java.util.Map;
+
 /**
  * This defines the methods available via a HTTP Request.
  *
@@ -30,61 +33,118 @@ package org.jboss.netty.handler.codec.http;
  *
  * @apiviz.exclude
  */
-public enum HttpMethod {
+public class HttpMethod implements Comparable<HttpMethod> {
     /**
      * The OPTIONS method represents a request for information about the communication options available on the request/response
      * chain identified by the Request-URI. This method allows the client to determine the options and/or requirements
      * associated with a resource, or the capabilities of a server, without implying a resource action or initiating a
      * resource retrieval.
      */
-    OPTIONS("OPTIONS"),
+    public static final HttpMethod OPTIONS = new HttpMethod("OPTIONS");
 
     /**
      * The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI.
      * If the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the entity
      * in the response and not the source text of the process, unless that text happens to be the output of the process.
      */
-    GET("GET"),
+    public static final HttpMethod GET = new HttpMethod("GET");
 
     /**
      * The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response.
      */
-    HEAD("HEAD"),
+    public static final HttpMethod HEAD = new HttpMethod("HEAD");
 
     /**
      * The POST method is used to request that the origin server accept the entity enclosed in the request as a new
      * subordinate of the resource identified by the Request-URI in the Request-Line.
      */
-    POST("POST"),
+    public static final HttpMethod POST = new HttpMethod("POST");
 
     /**
      * The PUT method requests that the enclosed entity be stored under the supplied Request-URI.
      */
-    PUT("PUT"),
+    public static final HttpMethod PUT = new HttpMethod("PUT");
 
     /**
      * The DELETE method requests that the origin server delete the resource identified by the Request-URI.
      */
-    DELETE("DELETE"),
+    public static final HttpMethod DELETE = new HttpMethod("DELETE");
 
     /**
      * The TRACE method is used to invoke a remote, application-layer loop- back of the request message.
      */
-    TRACE("TRACE"),
+    public static final HttpMethod TRACE = new HttpMethod("TRACE");
 
     /**
      * This specification reserves the method name CONNECT for use with a proxy that can dynamically switch to being a tunnel
      */
-    CONNECT("CONNECT"),;
+    public static final HttpMethod CONNECT = new HttpMethod("CONNECT");
+
+    private static final Map<String, HttpMethod> methodMap =
+            new HashMap<String, HttpMethod>();
+
+    static {
+        methodMap.put(OPTIONS.toString(), OPTIONS);
+        methodMap.put(GET.toString(), GET);
+        methodMap.put(HEAD.toString(), HEAD);
+        methodMap.put(POST.toString(), POST);
+        methodMap.put(PUT.toString(), PUT);
+        methodMap.put(DELETE.toString(), DELETE);
+        methodMap.put(TRACE.toString(), TRACE);
+        methodMap.put(CONNECT.toString(), CONNECT);
+    }
+
+    public static HttpMethod valueOf(String method) {
+        if (method == null) {
+            throw new NullPointerException("method");
+        }
+        method = method.trim().toUpperCase();
+
+        HttpMethod result = methodMap.get(method);
+        if (result != null) {
+            return result;
+        } else {
+            return new HttpMethod(method);
+        }
+    }
 
     private String method;
 
+    public HttpMethod(String method) {
+        if (method == null) {
+            throw new NullPointerException("method");
+        }
+
+        method = method.trim().toUpperCase();
+
+        if (method.length() == 0) {
+            throw new IllegalArgumentException("empty method");
+        }
 
-    private HttpMethod(String method) {
         this.method = method;
     }
 
-    public String getMethod() {
+    @Override
+    public int hashCode() {
+        return method.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof HttpMethod)) {
+            return false;
+        }
+
+        HttpMethod that = (HttpMethod) o;
+        return method.equals(that.method);
+    }
+
+    @Override
+    public String toString() {
         return method;
     }
+
+    public int compareTo(HttpMethod o) {
+        return method.compareTo(o.method);
+    }
 }
diff --git a/src/main/java/org/jboss/netty/handler/codec/http/HttpRequestEncoder.java b/src/main/java/org/jboss/netty/handler/codec/http/HttpRequestEncoder.java
index 633885d2ef..0250c875c2 100644
--- a/src/main/java/org/jboss/netty/handler/codec/http/HttpRequestEncoder.java
+++ b/src/main/java/org/jboss/netty/handler/codec/http/HttpRequestEncoder.java
@@ -41,7 +41,7 @@ public class HttpRequestEncoder extends HttpMessageEncoder {
     @Override
     protected void encodeInitialLine(ChannelBuffer buf, HttpMessage message) throws Exception {
         HttpRequest request = (HttpRequest) message;
-        buf.writeBytes(request.getMethod().getMethod().getBytes());
+        buf.writeBytes(request.getMethod().toString().getBytes());
         buf.writeByte(SP);
         buf.writeBytes(request.getUri().getBytes());
         buf.writeByte(SP);