HTTP 서버 만들기

#Java/adv2/HTTP

/HTTP 서버1 - 시작
싱글 스레드로 serverSocket에서 socket을 받아, HTTP 요청 메시지를 받아 출력하고, 간단한 html 문서를 HTTP 응답 메시지로 내려주는 서버

BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), UTF_8));
PrintWriter writer = new PrintWriter(socket.getOutputStream(), false, UTF_8))
- false는 AutoFlush 옵션이다. flush 옵션이 false면 print해도 바로 전송되는게 아니라, 버퍼에 모였다가 flush 해줘야 전송된다. 마지막에 꼭 writer.flush()를 호출해야 한다.
- Stream을 Reader, Writer로 변경할 때는 항상 인코딩을 확인하자.

HTTP 요청 메시지

	private String requestToString(BufferedReader reader) throws IOException {
        StringBuilder sb = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            if (line.isEmpty()) {
                break;
            }
            sb.append(line).append("\n");
        }
        return sb.toString();
    }

HTTP 메시지 헤더의 끝은 빈 라인으로 구분할 수 있다 line.isEmpty()로 HTTP 메시지 헤더 마지막을 인식한다.

HTTP 응답

	private void responseToClient(PrintWriter writer) {
        // 웹 브라우저에 전달하는 내용
        String body = "<h1>Hello World</h1>";
        int length = body.getBytes(UTF_8).length;
        StringBuilder sb = new StringBuilder();
        sb.append("HTTP/1.1 200 OK\r\n");
        sb.append("Content-Type: text/html\r\n");
        sb.append("Content-Length: ").append(length).append("\r\n");
        sb.append("\r\n"); // header, body 구분 라인
        sb.append(body);
        log("HTTP 응답 정보 출력");
        System.out.println(sb);
        writer.println(sb);
        writer.flush();
    }

HTTP 공식 스펙에서 다음 라인은 \r\n (캐리지 리턴 + 라인 피드)로 표현한다. 참고로 \n만 사용해도 대부분의 웹 브라우저는 문제없이 작동한다.
마지막에 writer.flush()를 호출해서 데이터를 전송한다.

/HTTP 서버2 - 동시 요청 : 스레드를 사용해서 동시에 여러 요청을 처리할 수 있도록 서버를 개선해보자.

public class HttpRequestHandlerV2 implements Runnable {
    private final Socket socket;
    public HttpRequestHandlerV2(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            process();
        } catch (Exception e) {
            log(e);
        }
    }
    private void process() throws IOException {
        try (socket;
             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), UTF_8));
             PrintWriter writer = new PrintWriter(socket.getOutputStream(), false, UTF_8)) {
            String requestString = requestToString(reader);
            if (requestString.contains("/favicon.ico")) {
                log("favicon 요청");
                return;
            }
            log("HTTP 요청 정보 출력");
            System.out.println(requestString);
            log("HTTP 응답 생성중...");
            sleep(5000);
            responseToClient(writer);
            log("HTTP 응답 전달 완료");
        }
    }
	// 생략

클라이언트의 HttpRequestHandler는 이름 그대로 클라이언트가 전달한 HTTP 요청을 처리한다.
동시에 요청한 수 만큼 별도의 스레드에서 HttpRequestHandler가 수행된다.

public class HttpServerV2 {
    private final ExecutorService es = Executors.newFixedThreadPool(10);
    private final int port;
    public HttpServerV2(int port) {
        this.port = port;
    }
    public void start() throws IOException {
        ServerSocket serverSocket = new ServerSocket(port);
        log("서버 시작 port: " + port);
        while (true) {
            Socket socket = serverSocket.accept();
            es.submit(new HttpRequestHandlerV2(socket));
        }
    }
}

ExecutorService: 스레드 풀을 사용한다. 이 예제에서는 최대 10개의 스레드를 사용할 수 있도록 했다.
es.submit(new HttpRequestHandlerV2(socket)): 스레드 풀에 HttpRequestHandlerV2 작업을 요청한다.
- 스레드 풀에 있는 스레드가 HttpRequestHandlerV2의 run()을 수행한다.

/HTTP 서버3 - 기능 추가 5개 URL 경로에 대한 로직을 구현한다.

home: / 첫 화면
site1: /site1 페이지 화면1
site2: /site2 페이지 화면2
search: /search 기능 검색 화면, 클라이언트에서 서버로 검색어를 전달할 수 있다.
notFound: 잘못된 URL을 호출했을 때 전달하는 화면

private void process(Socket socket) throws IOException {
        try (socket;
             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), UTF_8));
             PrintWriter writer = new PrintWriter(socket.getOutputStream(), false, UTF_8)) {
            String requestString = requestToString(reader);
            if (requestString.contains("/favicon.ico")) {
                log("favicon 요청");
                return;
            }
            log("HTTP 요청 정보 출력");
            System.out.println(requestString);
            log("HTTP 응답 생성중...");
            if (requestString.startsWith("GET /site1")) {
                site1(writer);
            } else if (requestString.startsWith("GET /site2")) {
                site2(writer);
            } else if (requestString.startsWith("GET /search")) {
                search(writer, requestString);
            } else if (requestString.startsWith("GET / ")){ // '/' 다음에 space 필수!
                // 해당 처리 내용이 누락된 경우에 대비한 처리 필요
            } else {
                home(writer);
                notFound(writer);
            }
            log("HTTP 응답 전달 완료");
        }
    }

	private static void search(PrintWriter writer, String requestString) {
        int startIndex = requestString.indexOf("q=");
        int endIndex = requestString.indexOf(" ", startIndex+2);
        String query = requestString.substring(startIndex+2, endIndex);
        String decode = URLDecoder.decode(query, UTF_8);
        writer.println("HTTP/1.1 200 OK");
        writer.println("Content-Type: text/html; charset=UTF-8");
        writer.println();
        writer.println("<h1>Search</h1>");
        writer.println("<ul>");
        writer.println("<li>query: " + query + "</li>");
        writer.println("<li>decode: " + decode + "</li>");
        writer.println("</ul>");
        writer.flush();
    }

응답 시 원칙적으로 헤더에 메시지 바디의 크기를 계산해서 Content-Length를 전달해야 하지만, 예제를 단순화하기 위해 생략했다.

/URL 인코딩

/URL이 ASCII를 사용하는 이유
- HTTP 메시지에서 시작 라인(URL을 포함)과 HTTP 헤더의 이름은 항상 ASCII를 사용해야 한다.
  - (http://localhost:12345/search?q=하이 이런거 안됨.)
- HTTP 메시지 바디는 UTF-8과 같은 다른 인코딩을 사용할 수 있다.
- HTTP URL이 ASCII만을 지원하는 이유는 초기 인터넷의 기술적 제약과 전 세계적인 호환성을 유지하기 위한 선택이다.
  - 순수한 UTF-8로 URL을 표현하려면, 전 세계 모든 네트워크 장비, 서버, 클라이언트 소프트웨어가 이를 지원해야 한다. 그러나, 여전히 많은 시스템에서 ASCII 기반 표준에 의존하고 있기 때문에 순수한 UTF-8 URL을 사용하면 호환성 문제가 발생할 수 있다.
- HTTP 스펙은 매우 보수적이고, 호환성을 가장 우선시 한다.
/퍼센트(%) 인코딩: URL에 한글을 전달하려면 어떻게 해야할까?
- 한글을 UTF-8 인코딩으로 표현하면 한 글자에 3byte의 데이터를 사용한다. 가, 나, 다를 UTF-8 인코딩의 16진수로 표현하면 다음과 같다.
  - 가: EA, B0, 80 (3byte)
  - 나: EB, 82, 98 (3byte)
  - 다: EB, 8B, A4 (3byte)
- URL은 ASCII 문자만 표현할 수 있으므로, UTF-8 문자를 표현할 수 없다. “가”를 UTF-8 16진수로 표현한 각각의 바이트 문자 앞에 %(퍼센트)를 붙이는 것이다.
  - q=가
  - q=%EA%B0%80
- 이렇게 각각의 16진수 byte를 문자로 표현하고, 해당 문자 앞에 %를 붙이는 것을 퍼센트(%) 인코딩이라 한다.
- % 인코딩, 디코딩 진행 과정
  1. 클라이언트: 가 전송 희망
  2. 클라이언트 % 인코딩: %EA%B0%80
    1. "가"를 UTF-8로 인코딩
    2. EA, B0, 80 3byte 획득
    3. 각 byte를 16진수 문자로 표현하고 각각의 앞에 %를 붙임
  3. 클라이언트 → 서버 전송: q=%EA%B0%80
  4. 서버: %EA%B0%80 ASCII 문자를 전달 받음
    1. %가 붙은 경우 디코딩해야 하는 문자로 인식
    2. EA, B0, 80을 byte로 변환, 3byte를 획득
    3. EA, B0, 80 (3byte)를 UTF-8로 디코딩하여 문자 "가" 획득
- /% 인코딩: 자바가 제공하는 URLEncoder.encode(), URLDecoder.decode()를 사용하면 % 인코딩, 디코딩을 처리할 수 있다.
  - String encode = URLEncoder.encode("가", UTF_8);
  - String decode = URLDecoder.decode(encode, UTF_8);
% 인코딩 단점: - % 인코딩은 데이터 크기에서 보면 효율이 떨어진다. 문자 "가"는 단지 3byte만 필요하다. 그런데 % 인코딩을 사용하면 %EA%B0%80 무려 9byte가 사용된다.

/HTTP 서버4 - 요청, 응답: HTTP 메시지는 스펙이 존재한다 직접 문자열로 다루지 말고, 스펙에 맞게 객체로 만들어 사용하자.

HTTP 요청 메시지

public class HttpRequest {
    private String method;
    private String path;
    private final Map<String, String> queryParameters = new HashMap<>();
    private final Map<String, String> headers = new HashMap<>();
    public HttpRequest(BufferedReader reader) throws IOException {
        parseRequestLine(reader);
        parseHeaders(reader);
        // 메시지 바디는 이후에 처리
    }
    private void parseRequestLine(BufferedReader reader) throws IOException {
        String requestLine = reader.readLine();
        if (requestLine == null) {
            throw new IOException("EOF: No request line received");
        }
        String[] parts = requestLine.split(" ");
        if (parts.length != 3) {
            throw new IOException("Invalid request line: " + requestLine);
        }
        method = parts[0];
        String[] pathParts = parts[1].split("\\?");
        path = pathParts[0];
        if (pathParts.length > 1) {
            parseQueryParameters(pathParts[1]);
        }
    }
	// paramA=valueA&paramB= (value가 ' ' 일수도)
    private void parseQueryParameters(String queryString) {
        for (String param : queryString.split("&")) {
            String[] keyValue = param.split("=");
            String key = URLDecoder.decode(keyValue[0], UTF_8);
            String value = keyValue.length > 1 ? URLDecoder.decode(keyValue[1], UTF_8) : "";
            queryParameters.put(key, value);
        }
    }
    private void parseHeaders(BufferedReader reader) throws IOException {
        String line;
        while (!(line = reader.readLine()).isEmpty()) {
            String[] headerParts = line.split(":");
            // trim() 앞 뒤에 공백 제거
            headers.put(headerParts[0].trim(), headerParts[1].trim());
        }
    }
    public String getMethod() {
        return method;
    }
    public String getPath() {
        return path;
    }
    public String getParameter(String name) {
        return queryParameters.get(name);
    }
    public String getHeader(String name) {
        return headers.get(name);
    }
    @Override
    public String toString() {
        return "HttpRequest{" +
               "method='" + method + '\'' +
               ", path='" + path + '\'' +
               ", queryParameters=" + queryParameters +
               ", headers=" + headers +
               '}';
    }
}

reader.readLine(): 클라이언트가 연결만 하고 데이터 전송 없이 연결을 종료하는 경우 null이 반환된다. 이 경우 간단히 throw new IOException("EOF") 예외를 던지겠다.
- 일부 브라우저의 경우 성능 최적화를 위해 TCP 연결을 추가로 하나 더 하는 경우가 있다. (ex. 크롬, 자동완성 시점에 미리 연결을 맺어버림)
- 이때 추가 연결을 사용하지 않고, 그대로 종료하면, TCP 연결은 있지만 데이터는 전송하지 않고, 연결을 끊게 된다. (크게 중요한 내용은 아니니 참고만 하자)
퍼센트 디코딩도 URLDecoder.decode()를 사용해서 처리한 다음에 Map에 보관한다.
HTTP 명세에서 헤더가 끝나는 부분은 빈 라인으로 구분한다.

HTTP 응답 메시지

public class HttpResponse {

    private final PrintWriter writer;
    private int statusCode = 200;
    private final StringBuilder bodyBuilder = new StringBuilder();
    private String contentType = "text/html; charset=UTF-8";

    public HttpResponse(PrintWriter writer) {
        this.writer = writer;
    }
    public void setStatus(int statusCode) {
        this.statusCode = statusCode;
    }
    public void setContentType(String contentType) {
        this.contentType = contentType;
    }
    public void writeBody(String body) {
        bodyBuilder.append(body);
    }

    public void flush() {
        int contentLength = bodyBuilder.toString().getBytes(UTF_8).length;
        writer.println("HTTP/1.1 " + statusCode + " " + getReasonPhrase(statusCode));
        writer.println("Content-Type: " + contentType);
        writer.println("Content-Length: " + contentLength);
        writer.println();
        writer.println(bodyBuilder);
        writer.flush();
    }
    private String getReasonPhrase(int statusCode) {
        switch (statusCode) {
            case 200:
                return "OK";
            case 404:
                return "Not Found";
            case 500:
                return "Internal Server Error";
            default:
                return "Unknown Status";
        }
    }
}

HttpRequestHandlerV4

	private void process(Socket socket) throws IOException {
        try (socket;
             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), UTF_8));
             PrintWriter writer = new PrintWriter(socket.getOutputStream(), false, UTF_8)) {
            HttpRequest request = new HttpRequest(reader);
            HttpResponse response = new HttpResponse(writer);
            if (request.getPath().equals("/favicon.ico")) {
                log("favicon 요청");
                return;
            }
            log("HTTP 요청 정보 출력");
            System.out.println(request);
            if (request.getPath().equals("/site1")) {
                site1(response);
            } else if (request.getPath().equals("/site2")) {
                site2(response);
            } else if (request.getPath().equals("/search")) {
                search(request, response);
            } else if (request.getPath().equals("/")){
                home(response);
            } else {
                notFound(response);
            }
            response.flush();
            log("HTTP 응답 전달 완료");
        }
    }

클라이언트의 요청이 오면 요청 정보를 기반으로 HttpRequest 객체를 만들어둔다. 이때 HttpResponse도 함께 만든다.
- 이제 HTTP 요청 메시지를 파싱하는 역할을 HttpRequest 객체의 생성자에서 수행하고,
- HTTP 응답 메시지의 헤더를 구성하고 + 네트워크 스트림에 print() 하는 것 또한 HttpResponse 객체가 수행한다.

	private static void site2(HttpResponse response) {
        response.writeBody("<h1>site2</h1>");
    }
    private static void search(HttpRequest request, HttpResponse response) {
        String query = request.getParameter("q");
        response.writeBody("<h1>Search</h1>");
        response.writeBody("<ul>");
        response.writeBody("<li>query: " + query + "</li>");
        response.writeBody("</ul>");
    }

HttpRequest 를 통해서 필요한 정보를 편리하게 찾을 수 있다.
/search 의 경우 퍼센트 디코딩을 고민하지 않아도 된다. 이미 HttpRequest 에서 다 처리해두었다.
응답의 경우 HttpResponse 를 사용하고, HTTP 메시지 바디에 출력할 부분만 적어주면 된다. 나머지는 HttpResponse 객체가 대신 처리해준다.
response.flush() 는 꼭 호출해주어야 한다. 그래야 실제 응답이 클라이언트에 전달된다.

V4 정리

HttpRequest와 HttpResponse 객체가 HTTP 요청과 응답을 구조화한 덕분에 많은 중복을 제거하고, 또 코드도 매우 효과적으로 리팩토링 할 수 있었다.

HTTP 서버와 관련된 부분
- HttpServer, HttpRequestHandler, HttpRequest, HttpResponse
서비스 개발을 위한 로직
- home(), site1(), site2(), search(), notFound()

/HTTP 서버5 - 커맨드 패턴 : 서비스 개발을 위한 로직과 명확하게 분리
HttpRequestHandler는 비즈니스 로직에 강하게 의존하고 있다.

if (request.getPath().equals("/site1")) {
    site1(response);
} else if (request.getPath().equals("/site2")) {
    site2(response);
} else if (request.getPath().equals("/search")) {
    search(request, response);
} else if (request.getPath().equals("/")){
    home(response);
} else {
    notFound(response);
}

또한 이 부분은 커맨드 패턴을 도입하면 좋을 것이라 생각할 수 있다. 커맨드 패턴을 도입해 확장성을 챙기고, HTTP 서버와 관련된 부분과 서비스 개발을 위한 로직을 분리해보자.

package was.httpserver;
import java.io.IOException;
public interface HttpServlet {
    void service(HttpRequest request, HttpResponse response) throws IOException;
}

HttpServlet이라는 이름의 인터페이스를 만들었다.
- HTTP, Server, Applet의 줄임말이다. (HTTP 서버에서 실행되는 작은 자바 프로그램(애플릿))
- 커맨드 객체라고 보면 된다.
이 인터페이스의 service() 메서드가 있는데, 여기에 서비스 개발과 관련된 부분을 구현하면 된다.
매개변수로 HttpRequest, HttpResponse가 전달된다. HttpRequest를 통해서 HTTP 요청 정보를 꺼내고, HttpResponse를 통해서 필요한 응답을 할 수 있기 때문에 이 정도면 충분하다.

서비스 서블릿

public class HomeServlet implements HttpServlet {
    @Override
    public void service(HttpRequest request, HttpResponse response) throws IOException {
        response.writeBody("<h1>home</h1>");
        response.writeBody("<ul>");
        response.writeBody("<li><a href='/site1'>site1</a></li>");
        response.writeBody("<li><a href='/site2'>site2</a></li>");
        response.writeBody("<li><a href='/search?q=hello'>검색</a></li>");
        response.writeBody("</ul>");
    }
}

공용 서블릿: NotFoundServlet, InternalErrorServlet, DiscardServlet은 여러 프로젝트에서 공용으로 사용하는 서블릿이다.

public class NotFoundServlet implements HttpServlet {
    @Override
    public void service(HttpRequest request, HttpResponse response) {
        response.setStatus(404);
        response.writeBody("<h1>404 페이지를 찾을 수 없습니다.</h1>");
    }
}

public class InternalErrorServlet implements HttpServlet {
    @Override
    public void service(HttpRequest request, HttpResponse response) {
        response.setStatus(500);
        response.writeBody("<h1>Internal Error</h1>");
    }
}

public class DiscardServlet implements HttpServlet {
    @Override
    public void service(HttpRequest request, HttpResponse response) throws IOException {
        // empty
    }
}

PageNotFound 예외

package was.httpserver;
public class PageNotFoundException extends RuntimeException {
    public PageNotFoundException(String message) {
        super(message);
    }
}

페이지를 찾지 못했을 때 사용하는 예외이다.

서블릿(커맨드)들을 관리할 수 있는 서블릿 매니저 또한 구현해야 겠죠?

public class ServletManager {
    private final Map<String, HttpServlet> servletMap = new HashMap<>();
	// {경로 : 커맨드 객체} 등록
    private HttpServlet defaultServlet;
    private HttpServlet notFoundErrorServlet = new NotFoundServlet();
    private HttpServlet internalErrorServlet = new InternalErrorServlet();
    public ServletManager() {
    }
    public void add(String path, HttpServlet servlet) {
        servletMap.put(path, servlet);
    }
    public void setDefaultServlet(HttpServlet defaultServlet) {
        this.defaultServlet = defaultServlet;
    }
    public void setNotFoundErrorServlet(HttpServlet notFoundErrorServlet) {
        this.notFoundErrorServlet = notFoundErrorServlet;
    }
    public void setInternalErrorServlet(HttpServlet internalErrorServlet) {
        this.internalErrorServlet = internalErrorServlet;
    }
    public void execute(HttpRequest request, HttpResponse response) throws IOException {
        try {
            HttpServlet servlet = servletMap.getOrDefault(request.getPath(), defaultServlet); // 경로에 대응되는 커맨드 객체 꺼낸다.
            if (servlet == null) {
                throw new PageNotFoundException("request url= " + request.getPath());
            }
            servlet.service(request, response);
        } catch (PageNotFoundException e) {
            e.printStackTrace();
            notFoundErrorServlet.service(request, response);
        } catch (Exception e) {
            e.printStackTrace();
            internalErrorServlet.service(request, response);
        }
    }
}

{경로 : 커맨드 객체} 등록
경로에 대응되는 커맨드 객체(서블릿)을 꺼내서 service()를 호출한다.
defaultServlet: HttpServlet을 찾지 못할 때 기본으로 실행된다.
notFoundErrorServlet: PageNotFoundException이 발생할 때 실행된다.
- URL 요청 경로를 servletMap에서 찾을 수 없고, defaultServlet도 없는 경우 PageNotFoundException을 던진다.
internalErrorServlet: 처리할 수 없는 예외가 발생하는 경우 실행된다.

HttpRequestHandler: 서블릿을 활용하여 리팩토링

public class HttpRequestHandler implements Runnable {
    private final Socket socket;
    private final ServletManager servletManager;
    public HttpRequestHandler(Socket socket, ServletManager servletManager) {
        this.socket = socket;
        this.servletManager = servletManager;
    }
    @Override
    public void run() {
        try {
            process(socket);
        } catch (Exception e) {
            log(e);
            e.printStackTrace();
        }
    }
    private void process(Socket socket) throws IOException {
        try (socket;
             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), UTF_8));
             PrintWriter writer = new PrintWriter(socket.getOutputStream(), false, UTF_8)) {
            HttpRequest request = new HttpRequest(reader);
            HttpResponse response = new HttpResponse(writer);
            log("HTTP 요청: " + request);
            servletManager.execute(request, response);
            response.flush();
            log("HTTP 응답 완료");
        }
    }
}

필드에 ServletManager 참조 추가
이제 경로 분석 및 실행에 관한 역할을 서블릿이 담당한다.
HttpRequest, HttpResponse를 만들고, servletManager에 전달하면 된다.

메인 - 설정

package was.v5;
import was.httpserver.HttpServer;
import was.httpserver.ServletManager;
import was.httpserver.servlet.DiscardServlet;
import java.io.IOException;
public class ServerMainV5 {
    private static final int PORT = 12345;
    public static void main(String[] args) throws IOException {
        ServletManager servletManager = new ServletManager();
        servletManager.add("/", new HomeServlet());
        servletManager.add("/site1", new Site1Servlet());
        servletManager.add("/site2", new Site2Servlet());
        servletManager.add("/search", new SearchServlet());
        servletManager.add("/favicon.ico", new DiscardServlet());
        HttpServer server = new HttpServer(PORT, servletManager);
        server.start();
    }
}

먼저 필요한 서블릿(HttpServlet)들을 서블릿 매니저에 등록하자. 이 부분이 바로 서비스 개발을 위한 로직들이다.
그리고 HttpServer를 생성하면서 서블릿 매니저를 전달하면 된다.

정리
이제 HTTP 서버와 서비스 개발을 위한 로직이 명확하게 분리되어 있다.

HTTP 서버와 관련된 부분 - was.httpserver 패키지
- HttpServer, HttpRequestHandler, HttpRequest, HttpResponse
- HttpServlet, HttpServletManager
- was.httpserver.servlet 패키지
  - InternalErrorServlet, NotFoundServlet, DiscardServlet
서비스 개발을 위한 로직 - v5.servlet 패키지
- HomeServlet
- Site1Servlet
- Site2Servlet
- SearchServlet

이후에 다른 HTTP 기반의 프로젝트를 시작해야 한다면, HTTP 서버와 관련된 was.httpserver 패키지의 코드를 그대로 재사용하면 된다. 그리고 해당 서비스에 필요한 서블릿을 구현하고, 서블릿 매니저에 등록한 다음에 서버를 실행하면 된다.

/웹 애플리케이션 서버의 역사
우리가 지금까지 개발한게 WAS이다. 이러한 WAS는 A사, B사, … 개개인이 구현하기에 따라 시그니처들이 다 다를 것이다. 클래스도 다르고 인터페이스도 모두 다르다. 결과적으로 A사의 HTTP 서버를 사용하다가 B사의 HTTP 서버를 사용하려면 코드를 완전히 다 변경해야 한다.

서블릿과 웹 애플리케이션 서버
이런 문제를 해결하기 위해 1990년대 자바 진영에서는 서블릿(Servlet)이라는 표준이 등장하게 된다. 참고로 우리가 앞서 만든 바로 그 서블릿이다.

package jakarta.servlet;
import java.io.IOException;
public interface Servlet {
    void service(ServletRequest var1, ServletResponse var2)
        throws ServletException, IOException;
    ...
}

서블릿은 Servlet, HttpServlet, ServletRequest, ServletResponse를 포함한 많은 표준을 제공한다.
HTTP 서버를 만드는 회사들은 모두 서블릿을 기반으로 기능을 제공한다.
처음에는 javax.servlet 패키지를 사용했는데, 이후에 jakarta.servlet으로 변경된다.

표준화의 장점
HTTP 서버를 만드는 회사들이 서블릿을 기반으로 기능을 제공한 덕분에, 개발자는 jakarta.servlet.Servlet 인터페이스를 구현하면 된다. 그리고 Apache Tomcat 같은 애플리케이션 서버에서 작성한 Servlet 구현체를 실행할 수 있다.
그러다가 만약 성능이나 부가 기능이 더 필요해서 상용 WAS로 변경하거나, 또는 다른 오픈소스로 WAS로 변경해도 기능 변경 없이 구현한 서블릿들을 그대로 사용할 수 있다.

이것이 바로 표준화의 큰 장점이다. 개발자는 코드의 변경이 거의 없이 다른 애플리케이션 서버를 선택할 수 있고, 애플리케이션 서버를 만드는 입장에서도 사용자를 잃지 않으면서 더 나은 기능을 제공하는 데 집중할 수 있다. 즉, 표준화된 서블릿 스펙 덕분에 애플리케이션 서버를 제공하는 회사들은 각자의 경쟁력을 키우기 위해 성능 최적화나 부가 기능, 관리 도구 등의 차별화 요소에 집중할 수 있고, 개발자들은 서버에 종속되지 않는 코드를 작성할 수 있는 자유를 얻게 된다.

이와 같은 표준화의 이점은 개발 생태계 전반에 걸쳐 효율성과 생산성을 높여준다. 애플리케이션 서버의 선택에 따른 리스크가 줄어들고, 서버 교체나 환경 변화를 쉽게 받아들일 수 있게 되며, 이는 곧 유지 보수 비용 감소와 장기적인 안정성 확보로 이어진다. 특히 대규모 시스템을 운영하는 기업들에게는 이러한 표준화된 기술 스택이 비용 절감과 더불어 운영의 유연성을 크게 높여준다.

결국, 서블릿 표준은 다양한 벤더들이 상호 운용 가능한 환경을 제공할 수 있게 만들어 주며, 이는 개발자와 기업 모두에게 큰 이점을 제공한다.

Ref) 김영한의 실전 자바 - 고급 2편, I/O, 네트워크, 리플렉션 강의 | 김영한 - 인프런

'Java > IO, Network' 카테고리의 다른 글

[Java] 52. 채팅 프로그램(feat. Command Pattern) (0)	2025.07.01
[Java] 51. 네트워크 - 프로그램(2) (0)	2025.07.01
[Java] 50. 네트워크 - 프로그램(1) (0)	2025.07.01
[Java] 49. File, Files (0)	2025.07.01
[Java] 48. 자바 I/O 활용 (0)	2025.07.01

[Java] 53. HTTP 서버 만들기

HTTP 서버 만들기

'Java > IO, Network' 카테고리의 다른 글

티스토리툴바