Создание HTTP-сервера на чистом Java: разработка без фреймворков

import com.sun.net.httpserver.HttpServer;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpExchange;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

public class SimpleHttpServer {
public static void main(String[] args) throws IOException {
HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);
server.createContext("/api", new MyHandler());
server.setExecutor(null); // Используем поток по умолчанию
server.start();
System.out.println("Сервер запущен на порту 8080");
}

static class MyHandler implements HttpHandler {
@Override
public void handle(HttpExchange exchange) throws IOException {
String response = "Hello, World!";
exchange.sendResponseHeaders(200, response.length());
OutputStream os = exchange.getResponseBody();
os.write(response.getBytes());
os.close();
}
}
}

HttpServer server = HttpServer.create(new InetSocketAddress(hostname, port), backlog);
server.setExecutor(executor);
server.start();

// Создаем пул потоков с оптимальными параметрами
int cores = Runtime.getRuntime().availableProcessors();
ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) Executors.newFixedThreadPool(cores * 2);

// Настраиваем параметры очереди
threadPoolExecutor.setKeepAliveTime(30, TimeUnit.SECONDS);
threadPoolExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

// Создаем и настраиваем сервер
HttpServer server = HttpServer.create(new InetSocketAddress("0.0.0.0", 8080), 100);
server.setExecutor(threadPoolExecutor);

// Добавляем обработчики и запускаем
server.createContext("/api", new ApiHandler());
server.start();

// Добавляем корректное завершение работы
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
System.out.println("Останавливаем сервер...");
server.stop(5); // Ожидаем завершения запросов 5 секунд
threadPoolExecutor.shutdown();
System.out.println("Сервер остановлен");
}));

public interface HttpHandler {
void handle(HttpExchange exchange) throws IOException;
}

public class Router {
private final HttpServer server;
private final Map<String, Map<String, HttpHandler>> routes = new HashMap<>();

public Router(HttpServer server) {
this.server = server;
// Инициализируем карту маршрутов для каждого поддерживаемого пути
routes.put("/api/users", new HashMap<>());
routes.put("/api/products", new HashMap<>());
routes.put("/api/orders", new HashMap<>());

// Регистрируем глобальный обработчик
server.createContext("/api", this::handleRequest);
}

public void addRoute(String path, String method, HttpHandler handler) {
if (!routes.containsKey(path)) {
routes.put(path, new HashMap<>());
}
routes.get(path).put(method, handler);
}

private void handleRequest(HttpExchange exchange) throws IOException {
String path = exchange.getRequestURI().getPath();
String method = exchange.getRequestMethod();

// Проверяем, поддерживается ли данный путь
if (!routes.containsKey(path)) {
sendError(exchange, 404, "Not Found");
return;
}

// Проверяем, поддерживается ли метод для этого пути
Map<String, HttpHandler> methodHandlers = routes.get(path);
if (!methodHandlers.containsKey(method)) {
sendError(exchange, 405, "Method Not Allowed");
return;
}

// Вызываем соответствующий обработчик
try {
methodHandlers.get(method).handle(exchange);
} catch (Exception e) {
e.printStackTrace();
sendError(exchange, 500, "Internal Server Error");
}
}

private void sendError(HttpExchange exchange, int code, String message) throws IOException {
exchange.sendResponseHeaders(code, message.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(message.getBytes());
}
}
}

Router router = new Router(server);

// Добавляем обработчики для разных путей и методов
router.addRoute("/api/users", "GET", exchange -> {
String response = "[{\"id\": 1, \"name\": \"Иван\"}, {\"id\": 2, \"name\": \"Мария\"}]";
exchange.getResponseHeaders().set("Content-Type", "application/json");
exchange.sendResponseHeaders(200, response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
});

router.addRoute("/api/users", "POST", exchange -> {
// Логика создания пользователя
String response = "{\"id\": 3, \"name\": \"Новый пользователь\", \"status\": \"created\"}";
exchange.getResponseHeaders().set("Content-Type", "application/json");
exchange.sendResponseHeaders(201, response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
});

// Класс для хранения информации о маршруте с шаблоном
class RoutePattern {
private final Pattern pattern;
private final List<String> paramNames;
private final Map<String, HttpHandler> methods;

public RoutePattern(String patternString) {
paramNames = new ArrayList<>();
methods = new HashMap<>();

// Преобразуем шаблон вида "/users/:id" в regex "/users/([^/]+)"
// и сохраняем имена параметров
String regex = patternString;
Matcher matcher = Pattern.compile(":(\\w+)").matcher(patternString);
while (matcher.find()) {
paramNames.add(matcher.group(1));
regex = regex.replace(matcher.group(0), "([^/]+)");
}

this.pattern = Pattern.compile(regex);
}

// Остальные методы класса...
}

public class UserHandler implements HttpHandler {
@Override
public void handle(HttpExchange exchange) throws IOException {
if (!"GET".equals(exchange.getRequestMethod())) {
sendMethodNotAllowed(exchange);
return;
}

// Разбор URI и извлечение параметров
URI uri = exchange.getRequestURI();
String query = uri.getQuery();
Map<String, String> params = parseQueryParameters(query);

// Логика обработки запроса
String response;
if (params.containsKey("id")) {
// Получение пользователя по ID
String id = params.get("id");
response = getUserById(id);
} else {
// Получение списка пользователей
response = getAllUsers();
}

// Формирование ответа
exchange.getResponseHeaders().set("Content-Type", "application/json");
exchange.sendResponseHeaders(200, response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
}

private Map<String, String> parseQueryParameters(String query) {
Map<String, String> params = new HashMap<>();
if (query != null) {
String[] pairs = query.split("&");
for (String pair : pairs) {
String[] keyValue = pair.split("=");
if (keyValue.length == 2) {
params.put(keyValue[0], keyValue[1]);
}
}
}
return params;
}

private String getUserById(String id) {
// Имитация получения данных из базы
return "{\"id\": " + id + ", \"name\": \"Пользователь " + id + "\", \"email\": \"user" + id + "@example.com\"}";
}

private String getAllUsers() {
// Имитация получения всех пользователей
return "[{\"id\": 1, \"name\": \"Иван\"}, {\"id\": 2, \"name\": \"Мария\"}]";
}

private void sendMethodNotAllowed(HttpExchange exchange) throws IOException {
String response = "{\"error\": \"Method not allowed\"}";
exchange.getResponseHeaders().set("Content-Type", "application/json");
exchange.sendResponseHeaders(405, response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
}
}

public class CreateUserHandler implements HttpHandler {
@Override
public void handle(HttpExchange exchange) throws IOException {
if (!"POST".equals(exchange.getRequestMethod())) {
sendMethodNotAllowed(exchange);
return;
}

// Проверка Content-Type
Headers headers = exchange.getRequestHeaders();
String contentType = headers.getFirst("Content-Type");
if (contentType == null || !contentType.contains("application/json")) {
sendBadRequest(exchange, "Content-Type must be application/json");
return;
}

// Чтение тела запроса
try (InputStream is = exchange.getRequestBody()) {
String requestBody = new String(is.readAllBytes());

// Здесь можно использовать библиотеку для парсинга JSON
// или написать простой парсер для учебных целей
Map<String, String> userData = parseJson(requestBody);

// Валидация данных
if (!userData.containsKey("name") || !userData.containsKey("email")) {
sendBadRequest(exchange, "Name and email are required");
return;
}

// Создание пользователя (имитация)
String response = createUser(userData);

// Отправка ответа
exchange.getResponseHeaders().set("Content-Type", "application/json");
exchange.sendResponseHeaders(201, response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
} catch (Exception e) {
sendInternalError(exchange, e.getMessage());
}
}

// Простой парсер JSON (для учебных целей)
private Map<String, String> parseJson(String json) {
Map<String, String> result = new HashMap<>();
// Удаляем фигурные скобки и разбиваем по запятым
String content = json.replaceAll("[{}\"]", "").trim();
String[] pairs = content.split(",");

for (String pair : pairs) {
String[] keyValue = pair.split(":");
if (keyValue.length == 2) {
result.put(keyValue[0].trim(), keyValue[1].trim());
}
}

return result;
}

private String createUser(Map<String, String> userData) {
// Имитация создания пользователя
int id = (int) (Math.random() * 1000);
return "{\"id\": " + id + ", \"name\": \"" + userData.get("name") + "\", \"email\": \"" + userData.get("email") + "\", \"status\": \"created\"}";
}

private void sendMethodNotAllowed(HttpExchange exchange) throws IOException {
String response = "{\"error\": \"Method not allowed\"}";
exchange.getResponseHeaders().set("Content-Type", "application/json");
exchange.sendResponseHeaders(405, response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
}

private void sendBadRequest(HttpExchange exchange, String message) throws IOException {
String response = "{\"error\": \"" + message + "\"}";
exchange.getResponseHeaders().set("Content-Type", "application/json");
exchange.sendResponseHeaders(400, response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
}

private void sendInternalError(HttpExchange exchange, String message) throws IOException {
String response = "{\"error\": \"Internal server error\", \"message\": \"" + message + "\"}";
exchange.getResponseHeaders().set("Content-Type", "application/json");
exchange.sendResponseHeaders(500, response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
}
}

public class StaticFileHandler implements HttpHandler {
private final String rootDirectory;
private final Map<String, String> mimeTypes;

public StaticFileHandler(String rootDirectory) {
this.rootDirectory = rootDirectory;
this.mimeTypes = new HashMap<>();

// Инициализация MIME-типов
mimeTypes.put("html", "text/html");
mimeTypes.put("css", "text/css");
mimeTypes.put("js", "application/javascript");
mimeTypes.put("jpg", "image/jpeg");
mimeTypes.put("jpeg", "image/jpeg");
mimeTypes.put("png", "image/png");
mimeTypes.put("gif", "image/gif");
mimeTypes.put("ico", "image/x-icon");
}

@Override
public void handle(HttpExchange exchange) throws IOException {
String path = exchange.getRequestURI().getPath();

// Нормализация пути запроса
if (path.equals("/")) {
path = "/index.html";
}

// Формируем полный путь к файлу
File file = new File(rootDirectory + path);

if (!file.exists() || file.isDirectory()) {
sendNotFound(exchange);
return;
}

// Определяем MIME-тип по расширению файла
String contentType = getContentType(file.getName());

// Отправляем файл
try (FileInputStream fis = new FileInputStream(file)) {
exchange.getResponseHeaders().set("Content-Type", contentType);
exchange.sendResponseHeaders(200, file.length());

try (OutputStream os = exchange.getResponseBody()) {
byte[] buffer = new byte[8192]; // 8KB буфер
int count;
while ((count = fis.read(buffer)) != -1) {
os.write(buffer, 0, count);
}
}
} catch (IOException e) {
e.printStackTrace();
sendInternalError(exchange);
}
}

private String getContentType(String fileName) {
String extension = "";
int i = fileName.lastIndexOf('.');
if (i > 0) {
extension = fileName.substring(i + 1).toLowerCase();
}

return mimeTypes.getOrDefault(extension, "application/octet-stream");
}

private void sendNotFound(HttpExchange exchange) throws IOException {
String response = "404 Not Found";
exchange.sendResponseHeaders(404, response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
}

private void sendInternalError(HttpExchange exchange) throws IOException {
String response = "500 Internal Server Error";
exchange.sendResponseHeaders(500, response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
}
}

HttpServer server = HttpServer.create(new InetSocketAddress("localhost", 8080), 0);

// Регистрация обработчика для статики
server.createContext("/static", new StaticFileHandler("./public"));

// Регистрация API-обработчиков
server.createContext("/api", new ApiHandler());

server.setExecutor(Executors.newFixedThreadPool(10));
server.start();

public class HeaderFilter {
private final HttpHandler next;

public HeaderFilter(HttpHandler next) {
this.next = next;
}

public HttpHandler wrap() {
return exchange -> {
// Добавляем стандартные заголовки безопасности
Headers headers = exchange.getResponseHeaders();

// Защита от XSS
headers.set("X-XSS-Protection", "1; mode=block");

// Запрет встраивания в фреймы
headers.set("X-Frame-Options", "DENY");

// Content Security Policy
headers.set("Content-Security-Policy", "default-src 'self'");

// CORS-заголовки для API
if (exchange.getRequestURI().getPath().startsWith("/api")) {
headers.set("Access-Control-Allow-Origin", "*");
headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");

// Обработка preflight-запросов
if ("OPTIONS".equals(exchange.getRequestMethod())) {
exchange.sendResponseHeaders(204, -1);
return;
}
}

// Передаем запрос дальше
next.handle(exchange);
};
}
}

HttpServer server = HttpServer.create(new InetSocketAddress("localhost", 8080), 0);

// Создаем и регистрируем обработчики с фильтром заголовков
HeaderFilter headerFilter = new HeaderFilter(new ApiHandler());
server.createContext("/api", headerFilter.wrap());

server.start();

public class SessionManager {
private final Map<String, Session> sessions = new ConcurrentHashMap<>();
private final String cookieName = "JSESSIONID";
private final int sessionTimeout = 1800; // 30 минут в секундах

public Session getSession(HttpExchange exchange, boolean create) {
String sessionId = getSessionIdFromCookie(exchange);
Session session = null;

if (sessionId != null) {
session = sessions.get(sessionId);

// Если сессия найдена, обновляем время последнего доступа
if (session != null) {
session.access();
}
}

if (session == null && create) {
// Создаем новую сессию
sessionId = generateSessionId();
session = new Session(sessionId);
sessions.put(sessionId, session);

// Устанавливаем cookie с ID сессии
setCookie(exchange, sessionId);
}

return session;
}

public void invalidateSession(HttpExchange exchange) {
String sessionId = getSessionIdFromCookie(exchange);

if (sessionId != null) {
sessions.remove(sessionId);
}

// Удаляем cookie
deleteCookie(exchange);
}

private String getSessionIdFromCookie(HttpExchange exchange) {
Headers headers = exchange.getRequestHeaders();
List<String> cookies = headers.get("Cookie");

if (cookies != null) {
for (String cookie : cookies) {
String[] parts = cookie.split(";");
for (String part : parts) {
part = part.trim();
if (part.startsWith(cookieName + "=")) {
return part.substring(cookieName.length() + 1);
}
}
}
}

return null;
}

private void setCookie(HttpExchange exchange, String sessionId) {
exchange.getResponseHeaders().add("Set-Cookie",
cookieName + "=" + sessionId + "; Path=/; HttpOnly; SameSite=Strict");
}

private void deleteCookie(HttpExchange exchange) {
exchange.getResponseHeaders().add("Set-Cookie",
cookieName + "=; Path=/; Max-Age=0; HttpOnly");
}

private String generateSessionId() {
return UUID.randomUUID().toString();
}

// Фоновая задача для удаления устаревших сессий
public void startSessionCleanup() {
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
scheduler.scheduleAtFixedRate(this::cleanupSessions, 10, 10, TimeUnit.MINUTES);
}

private void cleanupSessions() {
long currentTime = System.currentTimeMillis();
sessions.entrySet().removeIf(entry -> {
Session session = entry.getValue();
return (currentTime – session.getLastAccessTime()) / 1000 > sessionTimeout;
});
}

// Класс для хранения данных сессии
public static class Session {
private final String id;
private long lastAccessTime;
private final Map<String, Object> attributes = new ConcurrentHashMap<>();

public Session(String id) {
this.id = id;
this.lastAccessTime = System.currentTimeMillis();
}

public void setAttribute(String name, Object value) {
attributes.put(name, value);
}

public Object getAttribute(String name) {
return attributes.get(name);
}

public void removeAttribute(String name) {
attributes.remove(name);
}

public String getId() {
return id;
}

public long getLastAccessTime() {
return lastAccessTime;
}

void access() {
this.lastAccessTime = System.currentTimeMillis();
}
}
}

public class SessionAwareHandler implements HttpHandler {
private final SessionManager sessionManager;

public SessionAwareHandler(SessionManager sessionManager) {
this.sessionManager = sessionManager;
}

@Override
public void handle(HttpExchange exchange) throws IOException {
// Получаем сессию (создаем, если не существует)
SessionManager.Session session = sessionManager.getSession(exchange, true);

// Получаем счетчик посещений из сессии
Integer visits = (Integer) session.getAttribute("visits");
if (visits == null) {
visits = 0;
}

// Увеличиваем счетчик
visits++;
session.setAttribute("visits", visits);

// Формируем ответ
String response = "Вы посетили эту страницу " + visits + " раз(а).";

exchange.getResponseHeaders().set("Content-Type", "text/plain; charset=UTF-8");
exchange.sendResponseHeaders(200, response.getBytes().length);
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
}
}

HttpServer server = HttpServer.create(new InetSocketAddress("localhost", 8080), 0);

// Создаем менеджер сессий
SessionManager sessionManager = new SessionManager();
sessionManager.startSessionCleanup();

// Регистрируем обработчик с поддержкой сессий
server.createContext("/counter", new SessionAwareHandler(sessionManager));

// Другие обработчики...

server.setExecutor(Executors.newFixedThreadPool(10));
server.start();