diff --git a/study/src/test/java/study/FileTest.java b/study/src/test/java/study/FileTest.java
index e1b6cca042..5ce2ba1184 100644
--- a/study/src/test/java/study/FileTest.java
+++ b/study/src/test/java/study/FileTest.java
@@ -1,5 +1,9 @@
 package study;
 
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.nio.file.Files;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
@@ -27,8 +31,9 @@ class FileTest {
     void resource_디렉터리에_있는_파일의_경로를_찾는다() {
         final String fileName = "nextstep.txt";
 
-        // todo
-        final String actual = "";
+        // TODO
+        URL resource = getClass().getClassLoader().getResource(fileName);
+        String actual = resource.getFile();
 
         assertThat(actual).endsWith(fileName);
     }
@@ -40,14 +45,15 @@ class FileTest {
      * File, Files 클래스를 사용하여 파일의 내용을 읽어보자.
      */
     @Test
-    void 파일의_내용을_읽는다() {
+    void 파일의_내용을_읽는다() throws IOException {
         final String fileName = "nextstep.txt";
 
         // todo
-        final Path path = null;
+        URL resource = getClass().getClassLoader().getResource(fileName);
+        Path path = new File(resource.getPath()).toPath();
 
         // todo
-        final List<String> actual = Collections.emptyList();
+        final List<String> actual = Files.readAllLines(path);
 
         assertThat(actual).containsOnly("nextstep");
     }
diff --git a/study/src/test/java/study/IOStreamTest.java b/study/src/test/java/study/IOStreamTest.java
index 47a79356b6..3e774f5556 100644
--- a/study/src/test/java/study/IOStreamTest.java
+++ b/study/src/test/java/study/IOStreamTest.java
@@ -7,6 +7,7 @@
 import java.io.*;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.in;
 import static org.mockito.Mockito.*;
 
 /**
@@ -53,8 +54,9 @@ class OutputStream_학습_테스트 {
              * todo
              * OutputStream 객체의 write 메서드를 사용해서 테스트를 통과시킨다
              */
-
+            outputStream.write(bytes);
             final String actual = outputStream.toString();
+            // byte[] info = actual.getBytes("utf-8"); <- info = bytes
 
             assertThat(actual).isEqualTo("nextstep");
             outputStream.close();
@@ -72,12 +74,12 @@ class OutputStream_학습_테스트 {
         @Test
         void BufferedOutputStream을_사용하면_버퍼링이_가능하다() throws IOException {
             final OutputStream outputStream = mock(BufferedOutputStream.class);
-
             /**
              * todo
              * flush를 사용해서 테스트를 통과시킨다.
              * ByteArrayOutputStream과 어떤 차이가 있을까?
              */
+            outputStream.flush();
 
             verify(outputStream, atLeastOnce()).flush();
             outputStream.close();
@@ -96,7 +98,8 @@ class OutputStream_학습_테스트 {
              * try-with-resources를 사용한다.
              * java 9 이상에서는 변수를 try-with-resources로 처리할 수 있다.
              */
-
+            try(outputStream) {
+            }
             verify(outputStream, atLeastOnce()).close();
         }
     }
@@ -128,7 +131,13 @@ class InputStream_학습_테스트 {
              * todo
              * inputStream에서 바이트로 반환한 값을 문자열로 어떻게 바꿀까?
              */
-            final String actual = "";
+            Reader reader = new InputStreamReader(inputStream);
+            StringBuilder result = new StringBuilder();
+            for (int data = reader.read(); data != -1; data = reader.read()) {
+                result.append((char)data);
+            }
+
+            final String actual = result.toString();
 
             assertThat(actual).isEqualTo("🤩");
             assertThat(inputStream.read()).isEqualTo(-1);
@@ -148,6 +157,8 @@ class InputStream_학습_테스트 {
              * try-with-resources를 사용한다.
              * java 9 이상에서는 변수를 try-with-resources로 처리할 수 있다.
              */
+            try(inputStream) {
+            }
 
             verify(inputStream, atLeastOnce()).close();
         }
@@ -169,12 +180,12 @@ class FilterStream_학습_테스트 {
          * 버퍼 크기를 지정하지 않으면 버퍼의 기본 사이즈는 얼마일까?
          */
         @Test
-        void 필터인_BufferedInputStream를_사용해보자() {
+        void 필터인_BufferedInputStream를_사용해보자() throws IOException {
             final String text = "필터에 연결해보자.";
             final InputStream inputStream = new ByteArrayInputStream(text.getBytes());
-            final InputStream bufferedInputStream = null;
+            final InputStream bufferedInputStream = new BufferedInputStream(inputStream);
 
-            final byte[] actual = new byte[0];
+            final byte[] actual = bufferedInputStream.readAllBytes();
 
             assertThat(bufferedInputStream).isInstanceOf(FilterInputStream.class);
             assertThat(actual).isEqualTo("필터에 연결해보자.".getBytes());
@@ -197,15 +208,19 @@ class InputStreamReader_학습_테스트 {
          * 필터인 BufferedReader를 사용하면 readLine 메서드를 사용해서 문자열(String)을 한 줄 씩 읽어올 수 있다.
          */
         @Test
-        void BufferedReader를_사용하여_문자열을_읽어온다() {
+        void BufferedReader를_사용하여_문자열을_읽어온다() throws IOException {
             final String emoji = String.join("\r\n",
                     "😀😃😄😁😆😅😂🤣🥲☺️😊",
                     "😇🙂🙃😉😌😍🥰😘😗😙😚",
                     "😋😛😝😜🤪🤨🧐🤓😎🥸🤩",
                     "");
             final InputStream inputStream = new ByteArrayInputStream(emoji.getBytes());
+            final InputStreamReader reader = new InputStreamReader(inputStream);
 
-            final StringBuilder actual = new StringBuilder();
+            StringBuilder actual = new StringBuilder();
+            for (int data = reader.read(); data != -1; data = reader.read()) {
+                actual.append((char)data);
+            }
 
             assertThat(actual).hasToString(emoji);
         }
diff --git a/tomcat/src/main/java/nextstep/jwp/model/User.java b/tomcat/src/main/java/nextstep/jwp/model/User.java
index 4c2a2cd184..b24e92311d 100644
--- a/tomcat/src/main/java/nextstep/jwp/model/User.java
+++ b/tomcat/src/main/java/nextstep/jwp/model/User.java
@@ -26,6 +26,10 @@ public String getAccount() {
         return account;
     }
 
+    public String getPassword() {
+        return password;
+    }
+
     @Override
     public String toString() {
         return "User{" +
diff --git a/tomcat/src/main/java/org/apache/catalina/Manager.java b/tomcat/src/main/java/org/apache/catalina/Manager.java
index e69410f6a9..debe0b538e 100644
--- a/tomcat/src/main/java/org/apache/catalina/Manager.java
+++ b/tomcat/src/main/java/org/apache/catalina/Manager.java
@@ -1,18 +1,16 @@
 package org.apache.catalina;
 
-import jakarta.servlet.http.HttpSession;
-
 import java.io.IOException;
+import java.util.Optional;
+import org.apache.coyote.http11.common.Session;
 
 /**
- * A <b>Manager</b> manages the pool of Sessions that are associated with a
- * particular Container.  Different Manager implementations may support
- * value-added features such as the persistent storage of session data,
- * as well as migrating sessions for distributable web applications.
+ * A <b>Manager</b> manages the pool of Sessions that are associated with a particular Container.  Different Manager
+ * implementations may support value-added features such as the persistent storage of session data, as well as migrating
+ * sessions for distributable web applications.
  * <p>
- * In order for a <code>Manager</code> implementation to successfully operate
- * with a <code>Context</code> implementation that implements reloading, it
- * must obey the following constraints:
+ * In order for a <code>Manager</code> implementation to successfully operate with a <code>Context</code> implementation
+ * that implements reloading, it must obey the following constraints:
  * <ul>
  * <li>Must implement <code>Lifecycle</code> so that the Context can indicate
  *     that a restart is required.
@@ -29,28 +27,24 @@ public interface Manager {
      *
      * @param session Session to be added
      */
-    void add(HttpSession session);
+    void add(Session session);
 
     /**
-     * Return the active Session, associated with this Manager, with the
-     * specified session id (if any); otherwise return <code>null</code>.
+     * Return the active Session, associated with this Manager, with the specified session id (if any); otherwise
+     * return
+     * <code>null</code>.
      *
      * @param id The session id for the session to be returned
-     *
-     * @exception IllegalStateException if a new session cannot be
-     *  instantiated for any reason
-     * @exception IOException if an input/output error occurs while
-     *  processing this request
-     *
-     * @return the request session or {@code null} if a session with the
-     *         requested ID could not be found
+     * @return the request session or {@code null} if a session with the requested ID could not be found
+     * @throws IllegalStateException if a new session cannot be instantiated for any reason
+     * @throws IOException           if an input/output error occurs while processing this request
      */
-    HttpSession findSession(String id) throws IOException;
+    Optional<Session> findSession(String id) throws IOException;
 
     /**
      * Remove this Session from the active Sessions for this Manager.
      *
      * @param session Session to be removed
      */
-    void remove(HttpSession session);
+    void remove(Session session);
 }
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/Http11Processor.java b/tomcat/src/main/java/org/apache/coyote/http11/Http11Processor.java
index 7f1b2c7e96..e41fb307f5 100644
--- a/tomcat/src/main/java/org/apache/coyote/http11/Http11Processor.java
+++ b/tomcat/src/main/java/org/apache/coyote/http11/Http11Processor.java
@@ -1,13 +1,18 @@
 package org.apache.coyote.http11;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.Socket;
 import nextstep.jwp.exception.UncheckedServletException;
 import org.apache.coyote.Processor;
+import org.apache.coyote.http11.common.request.HttpRequest;
+import org.apache.coyote.http11.common.response.HttpResponse;
+import org.apache.coyote.http11.servlet.Servlet;
+import org.apache.coyote.http11.servlet.ServletFinder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
-import java.net.Socket;
-
 public class Http11Processor implements Runnable, Processor {
 
     private static final Logger log = LoggerFactory.getLogger(Http11Processor.class);
@@ -28,15 +33,11 @@ public void run() {
     public void process(final Socket connection) {
         try (final var inputStream = connection.getInputStream();
              final var outputStream = connection.getOutputStream()) {
+            final var bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
 
-            final var responseBody = "Hello world!";
-
-            final var response = String.join("\r\n",
-                    "HTTP/1.1 200 OK ",
-                    "Content-Type: text/html;charset=utf-8 ",
-                    "Content-Length: " + responseBody.getBytes().length + " ",
-                    "",
-                    responseBody);
+            HttpRequest request = HttpRequest.create(bufferedReader);
+            Servlet servlet = ServletFinder.find(request);
+            HttpResponse response = servlet.handle(request);
 
             outputStream.write(response.getBytes());
             outputStream.flush();
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/ContentType.java b/tomcat/src/main/java/org/apache/coyote/http11/common/ContentType.java
new file mode 100644
index 0000000000..a6da2bb317
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/ContentType.java
@@ -0,0 +1,34 @@
+package org.apache.coyote.http11.common;
+
+import java.util.Arrays;
+
+public enum ContentType {
+    TEXT_PLAIN("", "text/plain;charset=utf-8"),
+    TEXT_HTML(".html", "text/html;charset=utf-8"),
+    TEXT_CSS(".css", "text/css"),
+    APPLICATION_JAVASCRIPT(".js", "application/javascript");
+
+    private String extension;
+    private String detail;
+
+    ContentType(final String extension, final String detail) {
+        this.extension = extension;
+        this.detail = detail;
+    }
+
+    public String getExtension() {
+        return extension;
+    }
+
+    public String getDetail() {
+        return detail;
+    }
+
+    public static String getDetailfromExtension(String extension) {
+        return Arrays.stream(ContentType.values())
+                .filter(it -> it.extension.equals(extension))
+                .findFirst()
+                .map(ContentType::getDetail)
+                .orElseThrow(() -> new IllegalArgumentException("No enum constant with extension: " + extension));
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/Cookies.java b/tomcat/src/main/java/org/apache/coyote/http11/common/Cookies.java
new file mode 100644
index 0000000000..e6c2e5dace
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/Cookies.java
@@ -0,0 +1,28 @@
+package org.apache.coyote.http11.common;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.coyote.http11.util.Parser;
+
+public class Cookies {
+
+    private static final String EMPTY_STRING = "";
+
+    private Map<String, String> values;
+
+    public Cookies(final Map<String, String> values) {
+        this.values = values;
+    }
+
+    public static Cookies create(String line) {
+        return Parser.parseToCookie(line);
+    }
+
+    public static Cookies empty() {
+        return new Cookies(new HashMap<>());
+    }
+
+    public String getCookie(String name) {
+        return values.getOrDefault(name, EMPTY_STRING);
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/HttpHeaderName.java b/tomcat/src/main/java/org/apache/coyote/http11/common/HttpHeaderName.java
new file mode 100644
index 0000000000..19429bf2e4
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/HttpHeaderName.java
@@ -0,0 +1,19 @@
+package org.apache.coyote.http11.common;
+
+public enum HttpHeaderName {
+    CONTENT_TYPE("Content-Type"),
+    CONTENT_LENGTH("Content-Length"),
+    LOCATION("Location"),
+    SET_COOKIE("Set-Cookie"),
+    ALLOW("Allow");
+
+    private String name;
+
+    HttpHeaderName(final String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/HttpHeaders.java b/tomcat/src/main/java/org/apache/coyote/http11/common/HttpHeaders.java
new file mode 100644
index 0000000000..b4777d67a0
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/HttpHeaders.java
@@ -0,0 +1,51 @@
+package org.apache.coyote.http11.common;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class HttpHeaders {
+
+    private static final String DELIMITER = ": ";
+    private static final String EMPTY_STRING = "";
+
+    private Map<String, String> headers;
+
+    public HttpHeaders() {
+        headers = new LinkedHashMap<>();
+    }
+
+    private HttpHeaders(final Map<String, String> headers) {
+        this.headers = headers;
+    }
+
+    public static HttpHeaders create(final List<String> lines) {
+        Map<String, String> headers = new LinkedHashMap<>();
+        for (String line : lines) {
+            String[] split = line.split(DELIMITER);
+            headers.put(split[0], split[1]);
+        }
+
+        return new HttpHeaders(headers);
+    }
+
+    public static HttpHeaders create(final Map<String, String> headers) {
+        return new HttpHeaders(new LinkedHashMap<>(headers));
+    }
+
+    public void addHeader(HttpHeaderName header, String value) {
+        headers.put(header.getName(), value);
+    }
+
+    public String getHeader(String name) {
+        return headers.getOrDefault(name, EMPTY_STRING);
+    }
+
+    @Override
+    public String toString() {
+        return headers.entrySet().stream()
+                .map(entry -> entry.getKey() + DELIMITER + entry.getValue() + " ")
+                .collect(Collectors.joining(System.lineSeparator()));
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/HttpVersion.java b/tomcat/src/main/java/org/apache/coyote/http11/common/HttpVersion.java
new file mode 100644
index 0000000000..6f9e80d7f4
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/HttpVersion.java
@@ -0,0 +1,27 @@
+package org.apache.coyote.http11.common;
+
+import java.util.Arrays;
+
+public enum HttpVersion {
+    ZERO_POINT_NINE("HTTP/0.9"),
+    ONE_POINT_ZERO("HTTP/1.0"),
+    ONE_POINT_ONE("HTTP/1.1"),
+    TWO_POINT_ZERO("HTTP/2.0");
+
+    private final String detail;
+
+    HttpVersion(String detail) {
+        this.detail = detail;
+    }
+
+    public static HttpVersion fromDetail(String detail) {
+        return Arrays.stream(HttpVersion.values())
+                .filter(it -> it.detail.equals(detail))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("No enum constant with detail: " + detail));
+    }
+
+    public String getDetail() {
+        return detail;
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/MessageBody.java b/tomcat/src/main/java/org/apache/coyote/http11/common/MessageBody.java
new file mode 100644
index 0000000000..df3d93397f
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/MessageBody.java
@@ -0,0 +1,24 @@
+package org.apache.coyote.http11.common;
+
+public class MessageBody {
+    private final String content;
+
+    private MessageBody(String content) {
+        this.content = content;
+    }
+
+    public static MessageBody empty() {
+        return new MessageBody(null);
+    }
+
+    public static MessageBody create(final String input) {
+        return new MessageBody(input);
+    }
+
+    public String getContent() {
+        if (content == null) {
+            return "";
+        }
+        return content;
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/Session.java b/tomcat/src/main/java/org/apache/coyote/http11/common/Session.java
new file mode 100644
index 0000000000..3a286bf281
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/Session.java
@@ -0,0 +1,36 @@
+package org.apache.coyote.http11.common;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+public class Session {
+
+    private String id;
+    private Map<String, Object> values;
+
+    public Session(final String id) {
+        this.id = id;
+        this.values = new HashMap<>();
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public Optional<Object> getAttribute(final String name) {
+        return Optional.ofNullable(values.get(name));
+    }
+
+    public void setAttribute(final String name, final Object value) {
+        values.put(name, value);
+    }
+
+    public void removeAttribute(final String name) {
+        values.remove(name);
+    }
+
+    public void invalidate() {
+        values.clear();
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/SessionManager.java b/tomcat/src/main/java/org/apache/coyote/http11/common/SessionManager.java
new file mode 100644
index 0000000000..85cd9d2317
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/SessionManager.java
@@ -0,0 +1,26 @@
+package org.apache.coyote.http11.common;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import org.apache.catalina.Manager;
+
+public class SessionManager implements Manager {
+
+    private static final Map<String, Session> SESSIONS = new HashMap<>();
+
+    @Override
+    public void add(final Session session) {
+        SESSIONS.put(session.getId(), session);
+    }
+
+    @Override
+    public Optional<Session> findSession(final String id) {
+        return Optional.ofNullable(SESSIONS.get(id));
+    }
+
+    @Override
+    public void remove(final Session session) {
+        SESSIONS.remove(session.getId());
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/request/HttpMethod.java b/tomcat/src/main/java/org/apache/coyote/http11/common/request/HttpMethod.java
new file mode 100644
index 0000000000..de1b66ae3f
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/request/HttpMethod.java
@@ -0,0 +1,13 @@
+package org.apache.coyote.http11.common.request;
+
+public enum HttpMethod {
+    GET, POST, PATCH, PUT, DELETE, NONE;
+
+    public static HttpMethod from(final String name) {
+        try {
+            return valueOf(name);
+        } catch (IllegalArgumentException e) {
+            return NONE;
+        }
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/request/HttpRequest.java b/tomcat/src/main/java/org/apache/coyote/http11/common/request/HttpRequest.java
new file mode 100644
index 0000000000..c4f3e0f355
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/request/HttpRequest.java
@@ -0,0 +1,109 @@
+package org.apache.coyote.http11.common.request;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import org.apache.coyote.http11.common.Cookies;
+import org.apache.coyote.http11.common.HttpHeaderName;
+import org.apache.coyote.http11.common.HttpHeaders;
+import org.apache.coyote.http11.common.MessageBody;
+import org.apache.coyote.http11.common.Session;
+import org.apache.coyote.http11.common.SessionManager;
+
+public class HttpRequest {
+
+    public static final String SESSIONID = "JSESSIONID";
+    public static final String COOKIE = "Cookie";
+
+    private final StartLine startLine;
+    private final HttpHeaders headers;
+    private final MessageBody body;
+    private final SessionManager sessionManager;
+
+    private HttpRequest(final StartLine startLine, final HttpHeaders headers, final MessageBody body) {
+        this.startLine = startLine;
+        this.headers = headers;
+        this.body = body;
+        this.sessionManager = new SessionManager();
+    }
+
+    public static HttpRequest create(BufferedReader br) throws IOException {
+        StartLine startLine = findStartLine(br);
+        HttpHeaders headers = findHeaders(br);
+        MessageBody body = findBody(headers, br);
+        return new HttpRequest(startLine, headers, body);
+    }
+
+    private static StartLine findStartLine(BufferedReader br) throws IOException {
+        String firstLine = br.readLine();
+        return StartLine.create(firstLine);
+    }
+
+    private static HttpHeaders findHeaders(BufferedReader br) throws IOException {
+        List<String> headers = new ArrayList<>();
+        String line = br.readLine();
+        while (!"".equals(line)) {
+            headers.add(line);
+            line = br.readLine();
+        }
+        return HttpHeaders.create(headers);
+    }
+
+    private static MessageBody findBody(HttpHeaders headers, BufferedReader br) throws IOException {
+        String contentLength = headers.getHeader(HttpHeaderName.CONTENT_LENGTH.getName());
+        if (contentLength.isEmpty()) {
+            return MessageBody.empty();
+        }
+        final int length = Integer.parseInt(contentLength);
+        char[] buffer = new char[length];
+        br.read(buffer, 0, length);
+        return MessageBody.create(new String(buffer));
+    }
+
+    public RequestUri getUri() {
+        return this.startLine.getUri();
+    }
+
+    public HttpMethod getMethod() {
+        return this.startLine.getMethod();
+    }
+
+    public Cookies getCookies() {
+        String cookieLine = headers.getHeader(COOKIE);
+        if (cookieLine.isEmpty()) {
+            return Cookies.empty();
+        }
+        return Cookies.create(cookieLine);
+    }
+
+    public MessageBody getBody() {
+        return body;
+    }
+
+    public Optional<Session> getSession(boolean create) {
+        String sessionId = getCookies().getCookie(SESSIONID);
+        if (sessionId.isEmpty()) {
+            if (create) {
+                return Optional.of(makeNewSession());
+            }
+            return Optional.empty();
+        }
+        Optional<Session> session = sessionManager.findSession(sessionId);
+        if (session.isEmpty()) {
+            if (create) {
+                return Optional.of(makeNewSession());
+            }
+            return Optional.empty();
+        }
+        return session;
+    }
+
+    private Session makeNewSession() {
+        Session session = new Session(UUID.randomUUID().toString());
+        sessionManager.add(session);
+        return session;
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/request/QueryParams.java b/tomcat/src/main/java/org/apache/coyote/http11/common/request/QueryParams.java
new file mode 100644
index 0000000000..c6f827e05b
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/request/QueryParams.java
@@ -0,0 +1,35 @@
+package org.apache.coyote.http11.common.request;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.coyote.http11.util.Parser;
+
+public class QueryParams {
+
+    public static final String START_MARK_OF_QUERY_PARAMS = "?";
+    public static final String EMPTY_STRING = "";
+    public static final int HAS_NO_QUERY_PARAMS = -1;
+
+    private final Map<String, String> params;
+
+    public QueryParams(final Map<String, String> params) {
+        this.params = params;
+    }
+
+    public static QueryParams create(String line) {
+        int questionMarkIdx = line.indexOf(START_MARK_OF_QUERY_PARAMS);
+        if (questionMarkIdx == HAS_NO_QUERY_PARAMS) {
+            return QueryParams.empty();
+        }
+        String paramLine = line.substring(questionMarkIdx + 1);
+        return Parser.parseToQueryParams(paramLine);
+    }
+
+    public static QueryParams empty() {
+        return new QueryParams(new HashMap<>());
+    }
+
+    public String getParam(String name) {
+        return params.getOrDefault(name, EMPTY_STRING);
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/request/RequestUri.java b/tomcat/src/main/java/org/apache/coyote/http11/common/request/RequestUri.java
new file mode 100644
index 0000000000..e669b4048b
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/request/RequestUri.java
@@ -0,0 +1,36 @@
+package org.apache.coyote.http11.common.request;
+
+public class RequestUri {
+
+    public static final int START_OF_LINE = 0;
+    public static final String START_MARK_OF_QUERY_PARAMS = "?";
+    public static final int HAS_NO_QUERY_PARAMS = -1;
+    public static final String START_MARK_OF_EXTENSION = ".";
+    public static final int HAS_NO_EXTENSION = -1;
+
+    private final String value;
+
+    private RequestUri(final String value) {
+        this.value = value;
+    }
+
+    public static RequestUri create(String line) {
+        int idx = line.indexOf(START_MARK_OF_QUERY_PARAMS);
+        if (idx == HAS_NO_QUERY_PARAMS) {
+            return new RequestUri(line);
+        }
+        return new RequestUri(line.substring(START_OF_LINE, idx));
+    }
+
+    public String getExtension() {
+        int idx = value.indexOf(START_MARK_OF_EXTENSION);
+        if (idx == HAS_NO_EXTENSION) {
+            return "";
+        }
+        return value.substring(idx);
+    }
+
+    public String getValue() {
+        return value;
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/request/StartLine.java b/tomcat/src/main/java/org/apache/coyote/http11/common/request/StartLine.java
new file mode 100644
index 0000000000..c710c33ff0
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/request/StartLine.java
@@ -0,0 +1,41 @@
+package org.apache.coyote.http11.common.request;
+
+public class StartLine {
+    public static final String DELIMITER = " ";
+    public static final int METHOD_IDX = 0;
+    public static final int URI_IDX = 1;
+
+    private final HttpMethod method;
+    private final RequestUri uri;
+    private final QueryParams params;
+
+    private StartLine(final HttpMethod method, final RequestUri uri, final QueryParams params) {
+        this.method = method;
+        this.uri = uri;
+        this.params = params;
+    }
+
+    public static StartLine create(final String line) {
+        String[] targets = line.split(DELIMITER);
+
+        HttpMethod method = HttpMethod.from(targets[METHOD_IDX]);
+
+        String uriWithParams = targets[URI_IDX];
+        RequestUri uri = RequestUri.create(uriWithParams);
+        QueryParams params = QueryParams.create(uriWithParams);
+
+        return new StartLine(method, uri, params);
+    }
+
+    public RequestUri getUri() {
+        return uri;
+    }
+
+    public QueryParams getParams() {
+        return params;
+    }
+
+    public HttpMethod getMethod() {
+        return method;
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/response/HttpResponse.java b/tomcat/src/main/java/org/apache/coyote/http11/common/response/HttpResponse.java
new file mode 100644
index 0000000000..97cdd1027f
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/response/HttpResponse.java
@@ -0,0 +1,62 @@
+package org.apache.coyote.http11.common.response;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.apache.coyote.http11.common.ContentType;
+import org.apache.coyote.http11.common.HttpHeaderName;
+import org.apache.coyote.http11.common.HttpHeaders;
+import org.apache.coyote.http11.common.MessageBody;
+import org.apache.coyote.http11.common.request.HttpMethod;
+import org.apache.coyote.http11.servlet.Page;
+import org.apache.coyote.http11.util.StaticFileLoader;
+
+public class HttpResponse {
+
+    private final StatusLine statusLine;
+    private final HttpHeaders httpHeaders;
+    private final MessageBody messageBody;
+
+    private HttpResponse(final StatusLine statusLine, final HttpHeaders httpHeaders, final MessageBody messageBody) {
+        this.statusLine = statusLine;
+        this.httpHeaders = httpHeaders;
+        this.messageBody = messageBody;
+    }
+
+    public static HttpResponse create(StatusCode code, HttpHeaders headers) {
+        return new HttpResponse(StatusLine.create(code), headers, MessageBody.empty());
+    }
+
+    public static HttpResponse create(StatusCode code, HttpHeaders headers, String content) {
+        return new HttpResponse(StatusLine.create(code), headers, MessageBody.create(content));
+    }
+
+    public static HttpResponse createBadRequest() throws IOException {
+        String content = StaticFileLoader.load(Page.BAD_REQUEST.getUri());
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.addHeader(HttpHeaderName.CONTENT_TYPE, ContentType.TEXT_HTML.getDetail());
+        headers.addHeader(HttpHeaderName.CONTENT_LENGTH, String.valueOf(content.getBytes().length));
+
+        return HttpResponse.create(StatusCode.BAD_REQUEST, headers, content);
+    }
+
+    public static HttpResponse createMethodNotAllowed(List<HttpMethod> methods) {
+        String allowedMethod = methods.stream()
+                .map(Enum::toString)
+                .collect(Collectors.joining(", "));
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.addHeader(HttpHeaderName.ALLOW, allowedMethod);
+        return HttpResponse.create(StatusCode.METHOD_NOT_ALLOWED, headers);
+    }
+
+    public byte[] getBytes() {
+        String status = statusLine.toString();
+        String headers = httpHeaders.toString();
+        String body = messageBody.getContent();
+        return String.join(System.lineSeparator(), status, headers, "", body)
+                .getBytes(StandardCharsets.UTF_8);
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/response/StatusCode.java b/tomcat/src/main/java/org/apache/coyote/http11/common/response/StatusCode.java
new file mode 100644
index 0000000000..f0e3fde91c
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/response/StatusCode.java
@@ -0,0 +1,25 @@
+package org.apache.coyote.http11.common.response;
+
+public enum StatusCode {
+    OK("200", "OK"),
+    FOUND("302", "Found"),
+    BAD_REQUEST("400", "Bad Request"),
+    NOT_FOUND("404", "Not Found"),
+    METHOD_NOT_ALLOWED("405", "Method Not Allowed");
+
+    private final String code;
+    private final String text;
+
+    StatusCode(String code, String text) {
+        this.code = code;
+        this.text = text;
+    }
+
+    public String getCode() {
+        return code;
+    }
+
+    public String getText() {
+        return text;
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/common/response/StatusLine.java b/tomcat/src/main/java/org/apache/coyote/http11/common/response/StatusLine.java
new file mode 100644
index 0000000000..71a8888ebd
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/common/response/StatusLine.java
@@ -0,0 +1,31 @@
+package org.apache.coyote.http11.common.response;
+
+import org.apache.coyote.http11.common.HttpVersion;
+
+public class StatusLine {
+    private static final HttpVersion DEFAULT_VERSION = HttpVersion.ONE_POINT_ONE;
+
+    private final HttpVersion version;
+    private final StatusCode code;
+
+    private StatusLine(final HttpVersion version, final StatusCode code) {
+        this.version = version;
+        this.code = code;
+    }
+
+    public static StatusLine create(StatusCode code) {
+        return new StatusLine(DEFAULT_VERSION, code);
+    }
+
+    public static StatusLine create(String version, StatusCode code) {
+        return new StatusLine(HttpVersion.fromDetail(version), code);
+    }
+
+    @Override
+    public String toString() {
+        return String.join(" ",
+                version.getDetail(),
+                code.getCode(),
+                code.getText(), "");
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/servlet/HelloWorldServlet.java b/tomcat/src/main/java/org/apache/coyote/http11/servlet/HelloWorldServlet.java
new file mode 100644
index 0000000000..6e03ca7263
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/servlet/HelloWorldServlet.java
@@ -0,0 +1,29 @@
+package org.apache.coyote.http11.servlet;
+
+import java.util.List;
+import org.apache.coyote.http11.common.ContentType;
+import org.apache.coyote.http11.common.HttpHeaderName;
+import org.apache.coyote.http11.common.HttpHeaders;
+import org.apache.coyote.http11.common.request.HttpMethod;
+import org.apache.coyote.http11.common.request.HttpRequest;
+import org.apache.coyote.http11.common.response.HttpResponse;
+import org.apache.coyote.http11.common.response.StatusCode;
+
+public class HelloWorldServlet implements Servlet {
+
+    public static final String HELLO_WORLD = "Hello world!";
+
+    @Override
+    public HttpResponse handle(final HttpRequest request) {
+        if (request.getMethod() == HttpMethod.GET) {
+            String body = HELLO_WORLD;
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.addHeader(HttpHeaderName.CONTENT_TYPE, ContentType.TEXT_PLAIN.getDetail());
+            headers.addHeader(HttpHeaderName.CONTENT_LENGTH, String.valueOf(body.getBytes().length));
+
+            return HttpResponse.create(StatusCode.OK, headers, body);
+        }
+        return HttpResponse.createMethodNotAllowed(List.of(HttpMethod.GET));
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/servlet/LoginServlet.java b/tomcat/src/main/java/org/apache/coyote/http11/servlet/LoginServlet.java
new file mode 100644
index 0000000000..32c6056d62
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/servlet/LoginServlet.java
@@ -0,0 +1,107 @@
+package org.apache.coyote.http11.servlet;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Optional;
+import nextstep.jwp.db.InMemoryUserRepository;
+import nextstep.jwp.model.User;
+import org.apache.coyote.http11.common.ContentType;
+import org.apache.coyote.http11.common.HttpHeaderName;
+import org.apache.coyote.http11.common.HttpHeaders;
+import org.apache.coyote.http11.common.Session;
+import org.apache.coyote.http11.common.request.HttpMethod;
+import org.apache.coyote.http11.common.request.HttpRequest;
+import org.apache.coyote.http11.common.request.QueryParams;
+import org.apache.coyote.http11.common.response.HttpResponse;
+import org.apache.coyote.http11.common.response.StatusCode;
+import org.apache.coyote.http11.util.Parser;
+import org.apache.coyote.http11.util.StaticFileLoader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LoginServlet implements Servlet {
+
+    private static final Logger log = LoggerFactory.getLogger(LoginServlet.class);
+    public static final String ACCOUNT = "account";
+    public static final String PASSWORD = "password";
+    public static final String USER = "user";
+
+    @Override
+    public HttpResponse handle(final HttpRequest request) throws IOException {
+        if (request.getMethod() == HttpMethod.GET) {
+            return doGet(request);
+        }
+        if (request.getMethod() == HttpMethod.POST) {
+            return doPost(request);
+        }
+        return HttpResponse.createMethodNotAllowed(List.of(HttpMethod.GET, HttpMethod.POST));
+    }
+
+    private HttpResponse doGet(final HttpRequest request) throws IOException {
+        if (isLoggedIn(request)) {
+            HttpHeaders headers = new HttpHeaders();
+            headers.addHeader(HttpHeaderName.LOCATION, Page.INDEX.getUri());
+            return HttpResponse.create(StatusCode.FOUND, headers);
+        }
+        String content = StaticFileLoader.load(Page.LOGIN.getUri());
+        HttpHeaders headers = new HttpHeaders();
+        headers.addHeader(HttpHeaderName.CONTENT_TYPE, ContentType.TEXT_HTML.getDetail());
+        headers.addHeader(HttpHeaderName.CONTENT_LENGTH, String.valueOf(content.getBytes().length));
+        return HttpResponse.create(StatusCode.OK, headers, content);
+    }
+
+    private HttpResponse doPost(final HttpRequest request) throws IOException {
+        QueryParams params = Parser.parseToQueryParams(request.getBody().getContent());
+        String account = params.getParam(ACCOUNT);
+        String password = params.getParam(PASSWORD);
+
+        if (account.isEmpty() || password.isEmpty()) {
+            return HttpResponse.createBadRequest();
+        }
+        return InMemoryUserRepository.findByAccount(account)
+                .filter(user -> user.checkPassword(password))
+                .map(user -> loginSuccess(request, user))
+                .orElseGet(this::loginFail);
+    }
+
+    private boolean isLoggedIn(HttpRequest request) {
+        Optional<Session> session = request.getSession(false);
+        if (session.isEmpty()) {
+            return false;
+        }
+        Optional<Object> attribute = session.get().getAttribute(USER);
+        if (attribute.isEmpty()) {
+            return false;
+        }
+
+        User userInSession = (User) attribute.get();
+        if (isValidUser(userInSession)) {
+            return true;
+        }
+        session.get().removeAttribute(USER);
+        return false;
+    }
+
+    private boolean isValidUser(final User userInSession) {
+        return InMemoryUserRepository.findByAccount(userInSession.getAccount())
+                .filter(userInDb -> userInDb.checkPassword(userInSession.getPassword()))
+                .isPresent();
+    }
+
+    private HttpResponse loginSuccess(HttpRequest request, User user) {
+        log.info("로그인 성공 : {}", user);
+        Session session = request.getSession(true).get();
+        session.setAttribute(USER, user);
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.addHeader(HttpHeaderName.LOCATION, Page.INDEX.getUri());
+        headers.addHeader(HttpHeaderName.SET_COOKIE, "JSESSIONID=" + session.getId());
+        return HttpResponse.create(StatusCode.FOUND, headers);
+    }
+
+    private HttpResponse loginFail() {
+        HttpHeaders headers = new HttpHeaders();
+        headers.addHeader(HttpHeaderName.LOCATION, Page.UNAUTHORIZED.getUri());
+        return HttpResponse.create(StatusCode.FOUND, headers);
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/servlet/NotFoundServlet.java b/tomcat/src/main/java/org/apache/coyote/http11/servlet/NotFoundServlet.java
new file mode 100644
index 0000000000..785ec087dc
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/servlet/NotFoundServlet.java
@@ -0,0 +1,24 @@
+package org.apache.coyote.http11.servlet;
+
+import java.io.IOException;
+import org.apache.coyote.http11.common.ContentType;
+import org.apache.coyote.http11.common.HttpHeaderName;
+import org.apache.coyote.http11.common.HttpHeaders;
+import org.apache.coyote.http11.common.request.HttpRequest;
+import org.apache.coyote.http11.common.response.HttpResponse;
+import org.apache.coyote.http11.common.response.StatusCode;
+import org.apache.coyote.http11.util.StaticFileLoader;
+
+public class NotFoundServlet implements Servlet {
+
+    @Override
+    public HttpResponse handle(final HttpRequest request) throws IOException {
+        String content = StaticFileLoader.load(Page.NOT_FOUND.getUri());
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.addHeader(HttpHeaderName.CONTENT_TYPE, ContentType.TEXT_HTML.getDetail());
+        headers.addHeader(HttpHeaderName.CONTENT_LENGTH, String.valueOf(content.getBytes().length));
+
+        return HttpResponse.create(StatusCode.NOT_FOUND, headers, content);
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/servlet/Page.java b/tomcat/src/main/java/org/apache/coyote/http11/servlet/Page.java
new file mode 100644
index 0000000000..5bf13ed562
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/servlet/Page.java
@@ -0,0 +1,21 @@
+package org.apache.coyote.http11.servlet;
+
+public enum Page {
+    INDEX("/index.html"),
+    LOGIN("/login.html"),
+    REGISTER("/register.html"),
+    BAD_REQUEST("/400.html"),
+    UNAUTHORIZED("/401.html"),
+    NOT_FOUND("/404.html")
+    ;
+
+    private String uri;
+
+    Page(final String uri) {
+        this.uri = uri;
+    }
+
+    public String getUri() {
+        return uri;
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/servlet/RegisterServlet.java b/tomcat/src/main/java/org/apache/coyote/http11/servlet/RegisterServlet.java
new file mode 100644
index 0000000000..a00e6dae03
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/servlet/RegisterServlet.java
@@ -0,0 +1,60 @@
+package org.apache.coyote.http11.servlet;
+
+import java.io.IOException;
+import java.util.List;
+import nextstep.jwp.db.InMemoryUserRepository;
+import nextstep.jwp.model.User;
+import org.apache.coyote.http11.common.ContentType;
+import org.apache.coyote.http11.common.HttpHeaderName;
+import org.apache.coyote.http11.common.HttpHeaders;
+import org.apache.coyote.http11.common.request.HttpMethod;
+import org.apache.coyote.http11.common.request.HttpRequest;
+import org.apache.coyote.http11.common.request.QueryParams;
+import org.apache.coyote.http11.common.response.HttpResponse;
+import org.apache.coyote.http11.common.response.StatusCode;
+import org.apache.coyote.http11.util.Parser;
+import org.apache.coyote.http11.util.StaticFileLoader;
+
+public class RegisterServlet implements Servlet {
+
+    public static final String ACCOUNT = "account";
+    public static final String PASSWORD = "password";
+    public static final String EMAIL = "email";
+
+    @Override
+    public HttpResponse handle(final HttpRequest request) throws IOException {
+        if (request.getMethod() == HttpMethod.GET) {
+            return doGet();
+        }
+        if (request.getMethod() == HttpMethod.POST) {
+            return doPost(request);
+        }
+        return HttpResponse.createMethodNotAllowed(List.of(HttpMethod.GET, HttpMethod.POST));
+    }
+
+    private static HttpResponse doGet() throws IOException {
+        String content = StaticFileLoader.load(Page.REGISTER.getUri());
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.addHeader(HttpHeaderName.CONTENT_TYPE, ContentType.TEXT_HTML.getDetail());
+        headers.addHeader(HttpHeaderName.CONTENT_LENGTH, String.valueOf(content.getBytes().length));
+        return HttpResponse.create(StatusCode.OK, headers, content);
+    }
+
+    private static HttpResponse doPost(final HttpRequest request) throws IOException {
+        QueryParams params = Parser.parseToQueryParams(request.getBody().getContent());
+        String account = params.getParam(ACCOUNT);
+        String password = params.getParam(PASSWORD);
+        String email = params.getParam(EMAIL);
+
+        if (account.isEmpty() || password.isEmpty() || email.isEmpty()) {
+            return HttpResponse.createBadRequest();
+        }
+        User user = new User(account, password, email);
+        InMemoryUserRepository.save(user);
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.addHeader(HttpHeaderName.LOCATION, Page.INDEX.getUri());
+        return HttpResponse.create(StatusCode.FOUND, headers);
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/servlet/Servlet.java b/tomcat/src/main/java/org/apache/coyote/http11/servlet/Servlet.java
new file mode 100644
index 0000000000..310d8ceb67
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/servlet/Servlet.java
@@ -0,0 +1,10 @@
+package org.apache.coyote.http11.servlet;
+
+import java.io.IOException;
+import org.apache.coyote.http11.common.request.HttpRequest;
+import org.apache.coyote.http11.common.response.HttpResponse;
+
+public interface Servlet {
+
+    HttpResponse handle(HttpRequest request) throws IOException;
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/servlet/ServletFinder.java b/tomcat/src/main/java/org/apache/coyote/http11/servlet/ServletFinder.java
new file mode 100644
index 0000000000..30a2e9f9bf
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/servlet/ServletFinder.java
@@ -0,0 +1,34 @@
+package org.apache.coyote.http11.servlet;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.coyote.http11.common.request.HttpRequest;
+import org.apache.coyote.http11.common.request.RequestUri;
+
+public class ServletFinder {
+    private static final Map<String, Servlet> servlets;
+    private static final Servlet STATIC_RESOURCE_SERVLET;
+    private static final Servlet NOT_FOUND_SERVLET;
+
+    private ServletFinder() {
+    }
+
+    static {
+        servlets = new HashMap<>();
+        servlets.put("/", new HelloWorldServlet());
+        servlets.put("/login", new LoginServlet());
+        servlets.put("/register", new RegisterServlet());
+
+        STATIC_RESOURCE_SERVLET = new StaticResourceServlet();
+        NOT_FOUND_SERVLET = new NotFoundServlet();
+    }
+
+    public static Servlet find(HttpRequest request) {
+        RequestUri uri = request.getUri();
+        if (!uri.getExtension().isBlank()) {
+            return STATIC_RESOURCE_SERVLET;
+        }
+        String path = uri.getValue();
+        return servlets.getOrDefault(path, NOT_FOUND_SERVLET);
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/servlet/StaticResourceServlet.java b/tomcat/src/main/java/org/apache/coyote/http11/servlet/StaticResourceServlet.java
new file mode 100644
index 0000000000..3248c30ac1
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/servlet/StaticResourceServlet.java
@@ -0,0 +1,40 @@
+package org.apache.coyote.http11.servlet;
+
+import java.io.IOException;
+import java.util.List;
+import org.apache.coyote.http11.common.ContentType;
+import org.apache.coyote.http11.common.HttpHeaderName;
+import org.apache.coyote.http11.common.HttpHeaders;
+import org.apache.coyote.http11.common.request.HttpMethod;
+import org.apache.coyote.http11.common.request.HttpRequest;
+import org.apache.coyote.http11.common.response.HttpResponse;
+import org.apache.coyote.http11.common.response.StatusCode;
+import org.apache.coyote.http11.util.StaticFileLoader;
+
+public class StaticResourceServlet implements Servlet {
+
+    @Override
+    public HttpResponse handle(final HttpRequest request) throws IOException {
+        if (request.getMethod() == HttpMethod.GET) {
+            return doGet(request);
+        }
+        return HttpResponse.createMethodNotAllowed(List.of(HttpMethod.GET));
+    }
+
+    private static HttpResponse doGet(final HttpRequest request) throws IOException {
+        String detail = request.getUri().getValue();
+        String content = StaticFileLoader.load(detail);
+        String extension = request.getUri().getExtension();
+
+        if (content.isEmpty()) {
+            content = StaticFileLoader.load(Page.NOT_FOUND.getUri());
+            extension = ContentType.TEXT_HTML.getExtension();
+        }
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.addHeader(HttpHeaderName.CONTENT_TYPE, ContentType.getDetailfromExtension(extension));
+        headers.addHeader(HttpHeaderName.CONTENT_LENGTH, String.valueOf(content.getBytes().length));
+
+        return HttpResponse.create(StatusCode.OK, headers, content);
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/util/Parser.java b/tomcat/src/main/java/org/apache/coyote/http11/util/Parser.java
new file mode 100644
index 0000000000..078a941f2e
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/util/Parser.java
@@ -0,0 +1,46 @@
+package org.apache.coyote.http11.util;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.coyote.http11.common.Cookies;
+import org.apache.coyote.http11.common.request.QueryParams;
+
+public class Parser {
+
+    public static final String QUERY_PARAM_REGEX = "&";
+    public static final String DELIMITER = "=";
+    public static final String COOKIE_REGEX = "; ";
+
+    private Parser() {
+    }
+
+    public static QueryParams parseToQueryParams(String line) {
+        if (line == null) {
+            return QueryParams.empty();
+        }
+        String[] split = line.split(QUERY_PARAM_REGEX);
+
+        Map<String, String> params = new HashMap<>();
+        for (String piece : split) {
+            int idx = piece.indexOf(DELIMITER);
+            params.put(piece.substring(0, idx), piece.substring(idx + 1));
+        }
+
+        return new QueryParams(params);
+    }
+
+    public static Cookies parseToCookie(String line) {
+        if (line == null) {
+            return Cookies.empty();
+        }
+        String[] split = line.split(COOKIE_REGEX);
+
+        Map<String, String> cookies = new HashMap<>();
+        for (String piece : split) {
+            int idx = piece.indexOf(DELIMITER);
+            cookies.put(piece.substring(0, idx), piece.substring(idx + 1));
+        }
+
+        return new Cookies(cookies);
+    }
+}
diff --git a/tomcat/src/main/java/org/apache/coyote/http11/util/StaticFileLoader.java b/tomcat/src/main/java/org/apache/coyote/http11/util/StaticFileLoader.java
new file mode 100644
index 0000000000..6f8ae80dad
--- /dev/null
+++ b/tomcat/src/main/java/org/apache/coyote/http11/util/StaticFileLoader.java
@@ -0,0 +1,24 @@
+package org.apache.coyote.http11.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public class StaticFileLoader {
+
+    private static final String STATIC = "static";
+
+    private StaticFileLoader() {
+    }
+
+    public static String load(String fileName) throws IOException {
+        URL resource = StaticFileLoader.class.getClassLoader().getResource(STATIC + fileName);
+        if (resource == null) {
+            return "";
+        }
+        Path path = new File(resource.getPath()).toPath();
+        return new String(Files.readAllBytes(path));
+    }
+}
diff --git a/tomcat/src/main/resources/static/400.html b/tomcat/src/main/resources/static/400.html
new file mode 100644
index 0000000000..975cd068c7
--- /dev/null
+++ b/tomcat/src/main/resources/static/400.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no" />
+    <meta name="description" content="" />
+    <meta name="author" content="" />
+    <title>400 Bad Request</title>
+    <link href="css/styles.css" rel="stylesheet" />
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/js/all.min.js" crossorigin="anonymous"></script>
+</head>
+<body>
+<div id="layoutError">
+    <div id="layoutError_content">
+        <main>
+            <div class="container">
+                <div class="row justify-content-center">
+                    <div class="col-lg-6">
+                        <div class="text-center mt-4">
+                            <img class="mb-4 img-error" src="assets/img/error-404-monochrome.svg" />
+                            <p class="lead">This request is Bad.</p>
+                            <a href="index.html">
+                                <i class="fas fa-arrow-left me-1"></i>
+                                Return to Dashboard
+                            </a>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </main>
+    </div>
+    <div id="layoutError_footer">
+        <footer class="py-4 bg-light mt-auto">
+            <div class="container-fluid px-4">
+                <div class="d-flex align-items-center justify-content-between small">
+                    <div class="text-muted">Copyright &copy; Your Website 2021</div>
+                    <div>
+                        <a href="#">Privacy Policy</a>
+                        &middot;
+                        <a href="#">Terms &amp; Conditions</a>
+                    </div>
+                </div>
+            </div>
+        </footer>
+    </div>
+</div>
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js" crossorigin="anonymous"></script>
+<script src="js/scripts.js"></script>
+</body>
+</html>
diff --git a/tomcat/src/main/resources/static/login.html b/tomcat/src/main/resources/static/login.html
index f4ed9de875..bc933357f2 100644
--- a/tomcat/src/main/resources/static/login.html
+++ b/tomcat/src/main/resources/static/login.html
@@ -20,7 +20,7 @@
                                 <div class="card shadow-lg border-0 rounded-lg mt-5">
                                     <div class="card-header"><h3 class="text-center font-weight-light my-4">로그인</h3></div>
                                     <div class="card-body">
-                                        <form method="get" action="login">
+                                        <form method="post" action="login">
                                             <div class="form-floating mb-3">
                                                 <input class="form-control" id="inputLoginId" name="account" type="Text" placeholder="아이디를 입력하세요" />
                                                 <label for="inputLoginId">아이디</label>
diff --git a/tomcat/src/test/java/nextstep/org/apache/coyote/http11/Http11ProcessorTest.java b/tomcat/src/test/java/nextstep/org/apache/coyote/http11/Http11ProcessorTest.java
index 512b919f09..8e5f5cf400 100644
--- a/tomcat/src/test/java/nextstep/org/apache/coyote/http11/Http11ProcessorTest.java
+++ b/tomcat/src/test/java/nextstep/org/apache/coyote/http11/Http11ProcessorTest.java
@@ -1,16 +1,22 @@
 package nextstep.org.apache.coyote.http11;
 
-import support.StubSocket;
-import org.apache.coyote.http11.Http11Processor;
-import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import java.io.File;
 import java.io.IOException;
 import java.net.URL;
 import java.nio.file.Files;
+import nextstep.jwp.model.User;
+import org.apache.coyote.http11.Http11Processor;
+import org.apache.coyote.http11.common.Session;
+import org.apache.coyote.http11.common.SessionManager;
+import org.junit.jupiter.api.DisplayNameGeneration;
+import org.junit.jupiter.api.DisplayNameGenerator.ReplaceUnderscores;
+import org.junit.jupiter.api.Test;
+import support.StubSocket;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
+@DisplayNameGeneration(ReplaceUnderscores.class)
+@SuppressWarnings("NonAsciiCharacters")
 class Http11ProcessorTest {
 
     @Test
@@ -23,21 +29,193 @@ void process() {
         processor.process(socket);
 
         // then
-        var expected = String.join("\r\n",
+        var expected = String.join(System.lineSeparator(), "HTTP/1.1 200 OK ",
+                "Content-Type: text/plain;charset=utf-8 ", "Content-Length: 12 ", "", "Hello world!");
+
+        assertThat(socket.output()).isEqualTo(expected);
+    }
+
+    @Test
+    void index() throws IOException {
+        // given
+        final String httpRequest = String.join(System.lineSeparator(), "GET /index.html HTTP/1.1 ",
+                "Host: localhost:8080 ", "Connection: keep-alive ", "", "");
+
+        final var socket = new StubSocket(httpRequest);
+        final Http11Processor processor = new Http11Processor(socket);
+
+        // when
+        processor.process(socket);
+
+        // then
+        final URL resource = getClass().getClassLoader().getResource("static/index.html");
+        var expected = String.join(System.lineSeparator(), "HTTP/1.1 200 OK ", "Content-Type: text/html;charset=utf-8 ",
+                "Content-Length: 5564 ", "", new String(Files.readAllBytes(new File(resource.getFile()).toPath())));
+
+        assertThat(socket.output()).isEqualTo(expected);
+    }
+
+    @Test
+    void css() {
+        // given
+        final String httpRequest = String.join(System.lineSeparator(),
+                "GET /css/styles.css HTTP/1.1 ",
+                "Host: localhost:8080 ",
+                "Connection: keep-alive ",
+                "",
+                "");
+
+        final var socket = new StubSocket(httpRequest);
+        final Http11Processor processor = new Http11Processor(socket);
+
+        // when
+        processor.process(socket);
+
+        // then
+        var expected = String.join(System.lineSeparator(), "HTTP/1.1 200 OK ", "Content-Type: text/css ",
+                "Content-Length: 211991 ", "");
+
+        assertThat(socket.output()).startsWith(expected);
+    }
+
+    @Test
+    void js() {
+        // given
+        final String httpRequest = String.join(System.lineSeparator(),
+                "GET /js/scripts.js HTTP/1.1 ",
+                "Host: localhost:8080 ",
+                "Connection: keep-alive ",
+                "",
+                "");
+
+        final var socket = new StubSocket(httpRequest);
+        final Http11Processor processor = new Http11Processor(socket);
+
+        // when
+        processor.process(socket);
+
+        // then
+        var expected = String.join(System.lineSeparator(),
+                "HTTP/1.1 200 OK ",
+                "Content-Type: application/javascript ",
+                "Content-Length: 976 ", "");
+
+        assertThat(socket.output()).startsWith(expected);
+    }
+
+    @Test
+    void get_login_without_cookie() {
+        // given
+        final String httpRequest = String.join(System.lineSeparator(),
+                "GET /login HTTP/1.1 ",
+                "Host: localhost:8080 ",
+                "Connection: keep-alive ",
+                "",
+                "");
+
+        final var socket = new StubSocket(httpRequest);
+        final Http11Processor processor = new Http11Processor(socket);
+
+        // when
+        processor.process(socket);
+
+        // then
+        var expected = String.join(System.lineSeparator(),
                 "HTTP/1.1 200 OK ",
                 "Content-Type: text/html;charset=utf-8 ",
-                "Content-Length: 12 ",
+                "Content-Length: 3797 ", "");
+
+        assertThat(socket.output()).startsWith(expected);
+    }
+
+    @Test
+    void get_login_with_cookie() {
+        // given
+        Session session = new Session("oingsession");
+        session.setAttribute("user", new User("gugu", "password", "hkkang@woowahan.com"));
+        SessionManager manager = new SessionManager();
+        manager.add(session);
+
+        final String httpRequest = String.join(System.lineSeparator(),
+                "GET /login HTTP/1.1 ",
+                "Host: localhost:8080 ",
+                "Connection: keep-alive ",
+                "Cookie: JSESSIONID=oingsession",
                 "",
-                "Hello world!");
+                "");
 
-        assertThat(socket.output()).isEqualTo(expected);
+        final var socket = new StubSocket(httpRequest);
+        final Http11Processor processor = new Http11Processor(socket);
+
+        // when
+        processor.process(socket);
+
+        // then
+        var expected = String.join(System.lineSeparator(),
+                "HTTP/1.1 302 Found ",
+                "Location: /index.html ", "");
+
+        assertThat(socket.output()).startsWith(expected);
     }
 
     @Test
-    void index() throws IOException {
+    void post_login_success() {
+        // given
+        String body = "account=gugu&password=password";
+        final String httpRequest = String.join(System.lineSeparator(),
+                "POST /login HTTP/1.1 ",
+                "Host: localhost:8080 ",
+                "Connection: keep-alive ",
+                "Content-Length: " + body.getBytes().length,
+                "",
+                body);
+
+        final var socket = new StubSocket(httpRequest);
+        final Http11Processor processor = new Http11Processor(socket);
+
+        // when
+        processor.process(socket);
+
+        // then
+        var expected = String.join(System.lineSeparator(),
+                "HTTP/1.1 302 Found ",
+                "Location: /index.html ",
+                "Set-Cookie: ");
+
+        assertThat(socket.output()).startsWith(expected);
+    }
+
+    @Test
+    void post_login_failure() {
         // given
-        final String httpRequest= String.join("\r\n",
-                "GET /index.html HTTP/1.1 ",
+        String body = "account=oing&password=password";
+        final String httpRequest = String.join(System.lineSeparator(),
+                "POST /login HTTP/1.1 ",
+                "Host: localhost:8080 ",
+                "Connection: keep-alive ",
+                "Content-Length: " + body.getBytes().length,
+                "",
+                body);
+
+        final var socket = new StubSocket(httpRequest);
+        final Http11Processor processor = new Http11Processor(socket);
+
+        // when
+        processor.process(socket);
+
+        // then
+        var expected = String.join(System.lineSeparator(),
+                "HTTP/1.1 302 Found ",
+                "Location: /401.html ");
+
+        assertThat(socket.output()).startsWith(expected);
+    }
+
+    @Test
+    void get_register() {
+        // given
+        final String httpRequest = String.join(System.lineSeparator(),
+                "GET /register HTTP/1.1 ",
                 "Host: localhost:8080 ",
                 "Connection: keep-alive ",
                 "",
@@ -50,13 +228,36 @@ void index() throws IOException {
         processor.process(socket);
 
         // then
-        final URL resource = getClass().getClassLoader().getResource("static/index.html");
-        var expected = "HTTP/1.1 200 OK \r\n" +
-                "Content-Type: text/html;charset=utf-8 \r\n" +
-                "Content-Length: 5564 \r\n" +
-                "\r\n"+
-                new String(Files.readAllBytes(new File(resource.getFile()).toPath()));
+        var expected = String.join(System.lineSeparator(),
+                "HTTP/1.1 200 OK ",
+                "Content-Type: text/html;charset=utf-8 ", "Content-Length: 4319 ", "");
 
-        assertThat(socket.output()).isEqualTo(expected);
+        assertThat(socket.output()).startsWith(expected);
+    }
+
+    @Test
+    void post_register() {
+        // given
+        String body = "account=oing&password=pwpw&email=oing@naver.com";
+        final String httpRequest = String.join(System.lineSeparator(),
+                "POST /register HTTP/1.1 ",
+                "Host: localhost:8080 ",
+                "Connection: keep-alive ",
+                "Content-Length: " + body.getBytes().length,
+                "",
+                body);
+
+        final var socket = new StubSocket(httpRequest);
+        final Http11Processor processor = new Http11Processor(socket);
+
+        // when
+        processor.process(socket);
+
+        // then
+        var expected = String.join(System.lineSeparator(),
+                "HTTP/1.1 302 Found ",
+                "Location: /index.html ", "", "");
+
+        assertThat(socket.output()).startsWith(expected);
     }
 }
diff --git a/tomcat/src/test/java/org/apache/coyote/http11/common/ContentTypeTest.java b/tomcat/src/test/java/org/apache/coyote/http11/common/ContentTypeTest.java
new file mode 100644
index 0000000000..496ed4b079
--- /dev/null
+++ b/tomcat/src/test/java/org/apache/coyote/http11/common/ContentTypeTest.java
@@ -0,0 +1,24 @@
+package org.apache.coyote.http11.common;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayNameGeneration;
+import org.junit.jupiter.api.DisplayNameGenerator.ReplaceUnderscores;
+import org.junit.jupiter.api.Test;
+
+@DisplayNameGeneration(ReplaceUnderscores.class)
+@SuppressWarnings("NonAsciiCharacters")
+class ContentTypeTest {
+
+    @Test
+    void 확장자에_따라_해당하는_ContentType을_반환한다() {
+        // given
+        String extension = ".css";
+
+        // when
+        String actual = ContentType.getDetailfromExtension(extension);
+
+        // then
+        assertThat(actual).isEqualTo("text/css");
+    }
+}
diff --git a/tomcat/src/test/java/org/apache/coyote/http11/common/HttpHeadersTest.java b/tomcat/src/test/java/org/apache/coyote/http11/common/HttpHeadersTest.java
new file mode 100644
index 0000000000..de68e82cbb
--- /dev/null
+++ b/tomcat/src/test/java/org/apache/coyote/http11/common/HttpHeadersTest.java
@@ -0,0 +1,45 @@
+package org.apache.coyote.http11.common;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+import org.junit.jupiter.api.DisplayNameGeneration;
+import org.junit.jupiter.api.DisplayNameGenerator.ReplaceUnderscores;
+import org.junit.jupiter.api.Test;
+
+@DisplayNameGeneration(ReplaceUnderscores.class)
+@SuppressWarnings("NonAsciiCharacters")
+class HttpHeadersTest {
+
+    @Test
+    void 문자열_리스트를_받아_HttpHeaders를_만든다() {
+        // given
+        List<String> strings = List.of(
+                "Content-Length: 12",
+                "Content-Type: text/css");
+
+        // when
+        HttpHeaders headers = HttpHeaders.create(strings);
+
+        // then
+        assertThat(headers.getHeader("Content-Length")).isEqualTo("12");
+        assertThat(headers.getHeader("Content-Type")).isEqualTo("text/css");
+    }
+
+    @Test
+    void header를_추가할_수_있다() {
+        // given
+        List<String> strings = List.of(
+                "Content-Length: 12",
+                "Content-Type: text/css");
+        HttpHeaders headers = HttpHeaders.create(strings);
+
+        // when
+        headers.addHeader(HttpHeaderName.LOCATION, "/index.html");
+
+        // then
+        assertThat(headers.getHeader("Content-Length")).isEqualTo("12");
+        assertThat(headers.getHeader("Content-Type")).isEqualTo("text/css");
+        assertThat(headers.getHeader("Location")).isEqualTo("/index.html");
+    }
+}
diff --git a/tomcat/src/test/java/org/apache/coyote/http11/common/request/RequestUriTest.java b/tomcat/src/test/java/org/apache/coyote/http11/common/request/RequestUriTest.java
new file mode 100644
index 0000000000..997d61098d
--- /dev/null
+++ b/tomcat/src/test/java/org/apache/coyote/http11/common/request/RequestUriTest.java
@@ -0,0 +1,49 @@
+package org.apache.coyote.http11.common.request;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayNameGeneration;
+import org.junit.jupiter.api.DisplayNameGenerator.ReplaceUnderscores;
+import org.junit.jupiter.api.Test;
+
+@DisplayNameGeneration(ReplaceUnderscores.class)
+@SuppressWarnings("NonAsciiCharacters")
+class RequestUriTest {
+
+    @Test
+    void 쿼리파라미터가_있는_경우_물음표_전까지만() {
+        // given
+        String input = "/login?account=gugu&password=pw";
+
+        // when
+        RequestUri requestUri = RequestUri.create(input);
+
+        // then
+        assertThat(requestUri.getValue()).isEqualTo("/login");
+    }
+
+    @Test
+    void 쿼리파라미터가_없는_경우_전부() {
+        // given
+        String input = "/login";
+
+        // when
+        RequestUri requestUri = RequestUri.create(input);
+
+        // then
+        assertThat(requestUri.getValue()).isEqualTo("/login");
+    }
+
+    @Test
+    void 확장자를_반환할_수_있다() {
+        // given
+        String input = "/index.html";
+        RequestUri requestUri = RequestUri.create(input);
+
+        // when
+        String extension = requestUri.getExtension();
+
+        // then
+        assertThat(extension).isEqualTo(".html");
+    }
+}
diff --git a/tomcat/src/test/java/org/apache/coyote/http11/common/request/StartLineTest.java b/tomcat/src/test/java/org/apache/coyote/http11/common/request/StartLineTest.java
new file mode 100644
index 0000000000..877a9d39c4
--- /dev/null
+++ b/tomcat/src/test/java/org/apache/coyote/http11/common/request/StartLineTest.java
@@ -0,0 +1,25 @@
+package org.apache.coyote.http11.common.request;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayNameGeneration;
+import org.junit.jupiter.api.DisplayNameGenerator.ReplaceUnderscores;
+import org.junit.jupiter.api.Test;
+
+@DisplayNameGeneration(ReplaceUnderscores.class)
+@SuppressWarnings("NonAsciiCharacters")
+class StartLineTest {
+
+    @Test
+    void 문자열을_받아_StartLine을_만들_수_있다() {
+        // given
+        String input = "GET /index.html HTTP/1.1";
+
+        // when
+        StartLine startLine = StartLine.create(input);
+
+        // then
+        assertThat(startLine.getMethod()).isEqualTo(HttpMethod.GET);
+        assertThat(startLine.getUri().getValue()).isEqualTo("/index.html");
+    }
+}
diff --git a/tomcat/src/test/java/org/apache/coyote/http11/common/response/HttpResponseTest.java b/tomcat/src/test/java/org/apache/coyote/http11/common/response/HttpResponseTest.java
new file mode 100644
index 0000000000..a87f88ca83
--- /dev/null
+++ b/tomcat/src/test/java/org/apache/coyote/http11/common/response/HttpResponseTest.java
@@ -0,0 +1,45 @@
+package org.apache.coyote.http11.common.response;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import org.apache.coyote.http11.common.HttpHeaders;
+import org.junit.jupiter.api.DisplayNameGeneration;
+import org.junit.jupiter.api.DisplayNameGenerator.ReplaceUnderscores;
+import org.junit.jupiter.api.Test;
+
+@DisplayNameGeneration(ReplaceUnderscores.class)
+@SuppressWarnings("NonAsciiCharacters")
+class HttpResponseTest {
+
+    @Test
+    void StatusCode와_HttpHeader를_넣으면_HttpReponse를_만들_수_있다() {
+        // given
+        StatusCode code = StatusCode.FOUND;
+        HttpHeaders headers = HttpHeaders.create(Map.of("Location", "/index.html"));
+
+        // when
+        HttpResponse response = HttpResponse.create(code, headers);
+
+        // then
+        assertThat(response).isNotNull();
+    }
+
+    @Test
+    void Response를_byte로_변환할_수_있다() {
+        // given
+        StatusCode code = StatusCode.FOUND;
+        HttpHeaders headers = HttpHeaders.create(Map.of("Location", "/index.html"));
+        HttpResponse response = HttpResponse.create(code, headers);
+
+        // when
+        byte[] actual = response.getBytes();
+
+        // then
+        byte[] expected = String.join(System.lineSeparator(), "HTTP/1.1 302 Found ", "Location: /index.html ", "", "")
+                .getBytes(StandardCharsets.UTF_8);
+
+        assertThat(actual).isEqualTo(expected);
+    }
+}
diff --git a/tomcat/src/test/java/org/apache/coyote/http11/util/ParserTest.java b/tomcat/src/test/java/org/apache/coyote/http11/util/ParserTest.java
new file mode 100644
index 0000000000..e8fb5856f8
--- /dev/null
+++ b/tomcat/src/test/java/org/apache/coyote/http11/util/ParserTest.java
@@ -0,0 +1,42 @@
+package org.apache.coyote.http11.util;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.apache.coyote.http11.common.Cookies;
+import org.apache.coyote.http11.common.request.QueryParams;
+import org.junit.jupiter.api.DisplayNameGeneration;
+import org.junit.jupiter.api.DisplayNameGenerator.ReplaceUnderscores;
+import org.junit.jupiter.api.Test;
+
+@DisplayNameGeneration(ReplaceUnderscores.class)
+@SuppressWarnings("NonAsciiCharacters")
+class ParserTest {
+
+    @Test
+    void 주어진_문자열에서_형식에_맞게_QueryParams을_추출한다() {
+        // given
+        String line = "name=oing&age=24&gender=female";
+
+        // when
+        QueryParams queryParams = Parser.parseToQueryParams(line);
+
+        // then
+        assertThat(queryParams.getParam("name")).isEqualTo("oing");
+        assertThat(queryParams.getParam("age")).isEqualTo("24");
+        assertThat(queryParams.getParam("gender")).isEqualTo("female");
+    }
+
+    @Test
+    void 주어진_문자열에서_형식에_맞게_Cookies을_추출한다() {
+        // given
+        String line = "name=oing; age=24; gender=female";
+
+        // when
+        Cookies cookies = Parser.parseToCookie(line);
+
+        // then
+        assertThat(cookies.getCookie("name")).isEqualTo("oing");
+        assertThat(cookies.getCookie("age")).isEqualTo("24");
+        assertThat(cookies.getCookie("gender")).isEqualTo("female");
+    }
+}