Files
mtusi2026lab3/src/main/java/ru/mtusi/messenger/MessengerApplication.java
T

408 lines
33 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package ru.mtusi.messenger;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.*;
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.ClassPathResource;
import com.fasterxml.jackson.databind.JsonNode;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.*;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.databind.MapperFeature;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.time.*;
import java.util.*;
import java.util.Base64;
// Главная аннотация Spring Boot: включает запуск приложения и автоматическую настройку.
@SpringBootApplication
public class MessengerApplication {
// Стабильный идентификатор экземпляра API, генерируется при старте приложения.
private static final String INSTANCE_ID = UUID.randomUUID().toString();
// Метод main является точкой входа в Java-программу.
// Здесь Spring Boot запускает встроенный HTTP-сервер.
public static void main(String[] args) {
// Передаём главный класс и аргументы командной строки Spring Boot.
SpringApplication.run(MessengerApplication.class, args);
}
// @Bean регистрирует возвращаемый объект в контейнере Spring.
// BCrypt хранит пароль в виде хеша, поэтому исходный пароль не попадает в базу.
@Bean
BCryptPasswordEncoder passwordEncoder() {
// Возвращаем BCrypt-кодировщик, который Spring передаст контроллеру.
return new BCryptPasswordEncoder();
}
// Отключаем автоматическое превращение чисел в строки при чтении JSON.
@Bean
Jackson2ObjectMapperBuilderCustomizer strictJson() {
return builder -> builder.featuresToDisable(MapperFeature.ALLOW_COERCION_OF_SCALARS);
}
// Выполняем версионируемую миграцию до создания REST API.
@Bean(name="migration")
Object migration(javax.sql.DataSource dataSource) {
new ResourceDatabasePopulator(new ClassPathResource("db/migration/V1__init.sql")).execute(dataSource);
new ResourceDatabasePopulator(new ClassPathResource("db/migration/V2__idempotency.sql")).execute(dataSource);
return new Object();
}
// @Bean регистрирует фильтр в контейнере Spring.
// Фильтр добавляет общий идентификатор каждому HTTP-ответу.
@Bean OncePerRequestFilter requestId() {
return new OncePerRequestFilter() {
// Метод фильтра вызывается для каждого HTTP-запроса.
protected void doFilterInternal(HttpServletRequest r, HttpServletResponse s, FilterChain c)
throws ServletException, IOException {
// Создаём уникальный идентификатор текущего запроса.
String id=UUID.randomUUID().toString();
// Добавляем идентификатор в HTTP-ответ.
s.setHeader("X-Request-Id", id);
// Добавляем стабильный идентификатор экземпляра API.
s.setHeader("X-Instance-Id", INSTANCE_ID);
// Сохраняем тот же идентификатор для обработчика ошибок.
r.setAttribute("requestId", id);
// Передаём запрос дальше по цепочке Spring.
c.doFilter(r, s);
}
};
}
// Эти record-классы описывают JSON-модели ответов и запросов.
// Публичная модель пользователя без пароля.
record User(UUID id, String username, String display_name, Instant created_at) {}
// Модель чата со списком участников.
record Chat(UUID id, String title, List<UUID> member_ids, Instant created_at) {}
// Модель сообщения с автором и временем создания.
record Message(UUID id, UUID chat_id, UUID sender_id, String text, Instant created_at) {}
// Универсальная модель страницы списка.
record Page<T>(List<T> items, String next_cursor) {}
// Ответ успешного входа с Bearer-токеном.
record Session(String token, String token_type, Instant expires_at, User user) {}
// Тело запроса регистрации.
record UserIn(JsonNode username, JsonNode display_name, JsonNode password) {}
// Тело запроса создания чата.
record ChatIn(JsonNode title, List<UUID> member_ids) {}
// Тело запроса отправки сообщения.
record MessageIn(JsonNode text) {}
// Поля внутренней ошибки API.
record Error(String code, String message, String request_id) {}
// Обёртка, требуемая форматом JSON ошибки.
record ErrorBody(Error error) {}
// Исключение хранит HTTP-статус и безопасный код ошибки.
static class ApiException extends RuntimeException {
// HTTP-статус, который будет отправлен клиенту.
final HttpStatus status;
// Короткий код ошибки для программы-клиента.
final String code;
ApiException(HttpStatus s, String c, String m) {
// Сохраняем текст сообщения в стандартном RuntimeException.
super(m);
status=s;
code=c;
}
}
// @RestController объединяет @Controller и @ResponseBody.
// Методы этого класса принимают HTTP-запросы и возвращают JSON.
@DependsOn("migration")
@RestController
static class Api {
// JdbcTemplate работает с PostgreSQL, RedisTemplate — с Redis-сессиями.
// JdbcTemplate отправляет SQL-запросы в PostgreSQL.
final JdbcTemplate db;
// StringRedisTemplate работает со строковыми ключами Redis.
final StringRedisTemplate redis;
// BCryptPasswordEncoder проверяет и хеширует пароли.
final BCryptPasswordEncoder encoder;
// Генератор создаёт 32 случайных байта для каждой сессии.
final SecureRandom random = new SecureRandom();
// TTL можно уменьшить через переменную окружения для проверки expiry.
final long ttl = Long.parseLong(System.getenv().getOrDefault("SESSION_TTL_SECONDS", "3600"));
Api(JdbcTemplate d, StringRedisTemplate r, BCryptPasswordEncoder e) {
// Сохраняем зависимости, созданные Spring Boot.
db=d;
redis=r;
encoder=e;
}
// Метод проверяет доступность PostgreSQL тестовым запросом.
void dbOk() {
try {
// Простой запрос проверяет соединение с PostgreSQL.
db.queryForObject("select 1", Integer.class);
} catch (Exception e) {
// Внутреннюю ошибку базы не показываем клиенту.
throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","database is unavailable");
}
}
// Метод проверяет Bearer-токен и возвращает UUID пользователя.
UUID auth(HttpServletRequest req) {
// Читаем заголовок авторизации из HTTP-запроса.
String h=req.getHeader("Authorization");
// Защищённые методы принимают только Bearer-схему.
if (h==null || !h.startsWith("Bearer ")) throw unauth();
// В Redis хранится связь токена с UUID пользователя.
try { String v=redis.opsForValue().get("session:"+h.substring(7)); if(v==null) throw unauth(); return UUID.fromString(v); }
catch (ApiException e) { throw e; } catch (Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); }
}
ApiException unauth() { return new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","valid Bearer session required"); }
// Загружаем пользователя по UUID из PostgreSQL.
// Метод ищет пользователя в PostgreSQL по его UUID.
User user(UUID id) {
return db.query("select id,username,display_name,created_at from users where id=?", rs -> rs.next()
? new User(rs.getObject(1,UUID.class),rs.getString(2),rs.getString(3),rs.getTimestamp(4).toInstant()) : null, id);
}
// Метод проверяет, состоит ли пользователь в выбранном чате.
boolean member(UUID chat, UUID user) {
// Пользователь должен состоять в чате, иначе ресурс для него скрыт.
return Boolean.TRUE.equals(db.queryForObject("select exists(select 1 from chat_members where chat_id=? and user_id=?)",Boolean.class,chat,user));
}
// Загружает один чат и его участников напрямую по идентификатору.
Chat chatById(UUID id) {
return db.query("select id,title,created_at from chats where id=?",rs -> rs.next()
? new Chat(rs.getObject(1,UUID.class),rs.getString(2),
db.query("select user_id from chat_members where chat_id=?",(z,k)->z.getObject(1,UUID.class),id),
rs.getTimestamp(3).toInstant()) : null,id);
}
// Считает символы как Unicode code points, а не как UTF-16 char.
int codePointLength(String value) {
return value.codePointCount(0,value.length());
}
// Возвращает значение только если JSON-поле действительно является строкой.
String string(JsonNode value) { return value!=null && value.isTextual()?value.textValue():null; }
// PostgreSQL не хранит нулевой байт, поэтому заменяем его безопасным символом.
String databaseText(String value) { return value==null?null:value.replace('\0','\uFFFD'); }
// Проверяет обязательную непустую строку и её максимальную длину.
boolean text(String value, int max) { return value!=null && !value.isBlank() && codePointLength(value)<=max; }
// Предварительный SHA-256 сохраняет весь пароль перед ограниченным BCrypt.
String passwordValue(String value) {
try { return Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-256").digest(value.getBytes(StandardCharsets.UTF_8))); }
catch (Exception e) { throw new IllegalStateException("password hashing is unavailable",e); }
}
// Готовность проверяет не только Java-процесс, но и его зависимости.
// @GetMapping связывает GET-запрос с Java-методом.
@GetMapping({"/health/live","/health/ready"})
// Для ready дополнительно проверяем PostgreSQL и Redis.
// Метод возвращает JSON со статусом приложения.
Map<String,String> health(HttpServletRequest r) { if (r.getRequestURI().endsWith("ready")) { dbOk(); try { redis.hasKey("health"); } catch(Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); } } return Map.of("status","ok"); }
// @PostMapping связывает POST-запрос с методом регистрации.
@PostMapping("/api/v1/users")
// @RequestBody преобразует JSON-тело запроса в объект UserIn.
ResponseEntity<User> register(@RequestBody UserIn in) {
String username=in==null?null:string(in.username());
String displayName=in==null?null:string(in.display_name());
String password=in==null?null:string(in.password());
// До запроса в базу проверяем формат обязательных полей.
if(username==null || !username.matches("[a-z0-9_]{3,32}") || !text(displayName,100) || password==null || password.isBlank() || codePointLength(password)<12 || codePointLength(password)>128) bad();
displayName=databaseText(displayName);
// Создаём UUID пользователя и фиксируем время регистрации.
UUID id=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS);
// Значения передаются параметрами, а не склеиваются со строкой SQL.
try { db.update("insert into users values(?,?,?,?,?)",id,username,displayName,encoder.encode(passwordValue(password)),java.sql.Timestamp.from(now)); }
// Уникальное ограничение username превращаем в понятный ответ 409.
catch(DuplicateKeyException e) { throw new ApiException(HttpStatus.CONFLICT,"conflict","username is already used"); }
// Возвращаем созданного пользователя без пароля.
return ResponseEntity.status(201).body(new User(id,username,displayName,now));
}
// POST-метод входа проверяет Basic-логин и создаёт Bearer-сессию.
@PostMapping("/api/v1/auth/sessions")
// HttpServletRequest позволяет прочитать заголовок Authorization.
ResponseEntity<Session> login(HttpServletRequest req) {
// Читаем Basic-заголовок, который используется только при входе.
String h=req.getHeader("Authorization");
if(h==null || !h.startsWith("Basic ")) { HttpHeaders x=new HttpHeaders(); x.set("WWW-Authenticate","Basic realm=\"messenger\", charset=\"UTF-8\""); throw new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","Basic authentication required"); }
// Basic используется только для входа, после него клиент получает Bearer-токен.
String[] p; try { p=new String(Base64.getDecoder().decode(h.substring(6)),StandardCharsets.UTF_8).split(":",2); } catch(Exception e) { p=new String[0]; }
// Получаем BCrypt-хеш пользователя из PostgreSQL.
String hash=p.length==2 ? db.query("select password_hash from users where username=?",rs -> rs.next()?rs.getString(1):null,p[0]) : null;
// Сравниваем введённый пароль с сохранённым хешем.
if(p.length!=2 || hash==null || codePointLength(p[1])<12 || codePointLength(p[1])>128 || !encoder.matches(passwordValue(p[1]),hash)) { HttpHeaders x=new HttpHeaders(); x.set("WWW-Authenticate","Basic realm=\"messenger\", charset=\"UTF-8\""); throw new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","invalid credentials"); }
// После успешной проверки загружаем полную модель пользователя.
User u=user(db.queryForObject("select id from users where username=?",UUID.class,p[0]));
// Генерируем непрозрачный случайный токен сессии.
byte[] secret=new byte[32]; random.nextBytes(secret);
String token=Base64.getUrlEncoder().withoutPadding().encodeToString(secret);
// Вычисляем момент, когда сессия перестанет действовать.
Instant exp=Instant.now().plusSeconds(ttl);
// Сессия автоматически удалится из Redis после окончания TTL.
try { redis.opsForValue().set("session:"+token,u.id().toString(),Duration.ofSeconds(ttl)); } catch(Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); }
return ResponseEntity.status(201).body(new Session(token,"Bearer",exp,u));
}
// @DeleteMapping связывает DELETE-запрос с удалением сессии.
// Logout сразу удаляет текущий токен из Redis.
@DeleteMapping("/api/v1/auth/sessions/current") ResponseEntity<Void> logout(HttpServletRequest r) { auth(r); redis.delete("session:"+r.getHeader("Authorization").substring(7)); return ResponseEntity.noContent().build(); }
// GET-запрос возвращает данные текущего авторизованного пользователя.
@GetMapping("/api/v1/users/me") User me(HttpServletRequest r) { return user(auth(r)); }
// @Transactional объединяет несколько SQL-команд в одну транзакцию.
// Если одна команда завершится ошибкой, изменения откатываются.
// Вставка чата и всех его участников выполняется как одна транзакция.
@Transactional
// POST-запрос создаёт новый чат.
@PostMapping("/api/v1/chats") ResponseEntity<Chat> createChat(@RequestBody ChatIn in,HttpServletRequest r) {
// Владелец чата определяется по Bearer-сессии.
String title=in==null?null:string(in.title());
UUID owner=auth(r); if(!text(title,100)||in.member_ids()==null||in.member_ids().isEmpty()||in.member_ids().size()>100||new HashSet<>(in.member_ids()).size()!=in.member_ids().size()||!in.member_ids().contains(owner)) bad();
// Проверяем существование каждого участника.
for(UUID id:in.member_ids()) if(user(id)==null) bad();
// ID и время создаются сервером.
UUID id=UUID.randomUUID(); Instant now=Instant.now();
// Записываем чат и участников в одной транзакции.
title=databaseText(title);
db.update("insert into chats values(?,?,?)",id,title,java.sql.Timestamp.from(now)); for(UUID m:in.member_ids()) db.update("insert into chat_members values(?,?)",id,m);
// Возвращаем созданную модель чата.
return ResponseEntity.status(201).body(new Chat(id,title,in.member_ids(),now));
}
// GET-запрос получает список чатов текущего пользователя.
@GetMapping("/api/v1/chats")
Page<Chat> chats(HttpServletRequest r) {
// Определяем пользователя, для которого строится список.
UUID u=auth(r);
String cursor=r.getParameter("cursor");
int limit=parseLimit(r.getParameter("limit"));
// Запрашиваем только чаты, где пользователь является участником.
String sql="select c.id,c.title,c.created_at from chats c join chat_members m on m.chat_id=c.id where m.user_id=? ";
List<Object> args=new ArrayList<>(List.of(u));
if(cursor!=null) {
try {
String[] p=new String(Base64.getUrlDecoder().decode(cursor),StandardCharsets.UTF_8).split("\\|",-1);
if(p.length!=2) bad();
sql+="and (c.created_at,c.id)>(?,?) ";
args.add(java.sql.Timestamp.from(OffsetDateTime.parse(p[0]).toInstant()));
args.add(UUID.fromString(p[1]));
} catch(Exception e) { if(e instanceof ApiException a) throw a; bad(); }
}
sql+="order by c.created_at,c.id limit ?";
args.add(limit+1);
List<Chat> x=db.query(sql,(rs,n)->new Chat(rs.getObject(1,UUID.class),rs.getString(2),db.query("select user_id from chat_members where chat_id=?", (z,k)->z.getObject(1,UUID.class),rs.getObject(1)),rs.getTimestamp(3).toInstant()),args.toArray());
String next=x.size()>limit?Base64.getUrlEncoder().withoutPadding().encodeToString((x.get(limit-1).created_at()+"|"+x.get(limit-1).id()).getBytes(StandardCharsets.UTF_8)):null;
return new Page<>(x.subList(0,Math.min(limit,x.size())),next);
}
// {id} является переменной частью URL.
@GetMapping("/api/v1/chats/{id}")
// @PathVariable получает id из адреса запроса.
Chat chat(@PathVariable UUID id,HttpServletRequest r) {
// Сначала проверяем токен и членство в чате.
UUID u=auth(r); if(!member(id,u)) throw notFound();
// Загружаем чат напрямую, поэтому поздние записи не зависят от первой страницы списка.
Chat result=chatById(id);
if(result==null) throw notFound();
return result;
}
// POST-запрос добавляет сообщение в выбранный чат.
// @PathVariable получает id чата, а @RequestBody — текст из JSON.
@Transactional
@PostMapping("/api/v1/chats/{id}/messages") ResponseEntity<Message> message(@PathVariable UUID id,@RequestBody MessageIn in,HttpServletRequest r) {
// Автор сообщения берётся из сессии, а не из тела запроса.
String messageText=databaseText(in==null?null:string(in.text()));
UUID u=auth(r); if(!member(id,u)) throw notFound(); if(!text(messageText,4000)) bad();
// Проверяем обязательный Idempotency-Key.
String key=r.getHeader("Idempotency-Key");
if(key==null || !key.matches("[A-Za-z0-9._:-]{1,128}")) throw new ApiException(HttpStatus.BAD_REQUEST,"invalid_request","valid Idempotency-Key required");
// Вычисляем хеш тела запроса для проверки повторов с тем же ключом.
String bodyHash;
try { bodyHash=Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-256").digest((messageText==null?"":messageText).getBytes(StandardCharsets.UTF_8))); }
catch(Exception e) { throw new IllegalStateException("hash unavailable",e); }
// Проверяем существующий результат для этого ключа.
UUID existingId=db.query("select message_id,request_hash from idempotency_keys where user_id=? and chat_id=? and idempotency_key=?",rs -> {
if(rs.next()) {
if(!bodyHash.equals(rs.getString(2))) throw new ApiException(HttpStatus.CONFLICT,"conflict","different body with same idempotency key");
return rs.getObject(1,UUID.class);
}
return null;
},u,id,key);
// Если сообщение уже создано, возвращаем его.
if(existingId!=null) {
Message existing=db.queryForObject("select id,chat_id,sender_id,text,created_at from messages where id=?",
(rs,n)->new Message(rs.getObject(1,UUID.class),rs.getObject(2,UUID.class),rs.getObject(3,UUID.class),rs.getString(4),rs.getTimestamp(5).toInstant()),existingId);
return ResponseEntity.status(201).body(existing);
}
// Сервер создаёт ID и время сообщения.
UUID mid=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS);
// Атомарно записываем сообщение и ключ идемпотентности.
db.update("insert into messages values(?,?,?,?,?)",mid,id,u,messageText,java.sql.Timestamp.from(now));
db.update("insert into idempotency_keys values(?,?,?,?,?,?)",key,u,id,bodyHash,mid,java.sql.Timestamp.from(now));
return ResponseEntity.status(201).body(new Message(mid,id,u,messageText,now));
}
// GET-запрос возвращает историю сообщений с cursor-пагинацией.
// @RequestParam получает limit и cursor из параметров URL.
@GetMapping("/api/v1/chats/{id}/messages") Page<Message> messages(@PathVariable UUID id,@RequestParam(required=false) String limit,@RequestParam(required=false) String cursor,HttpServletRequest r) {
// Историю может читать только участник чата.
UUID u=auth(r); if(!member(id,u)) throw notFound(); int pageLimit=parseLimit(limit);
// Начинаем параметризованный запрос истории.
String sql="select id,chat_id,sender_id,text,created_at from messages where chat_id=? ";
// Список параметров передаётся в JdbcTemplate отдельно от SQL.
List<Object> args=new ArrayList<>(List.of(id));
if(cursor!=null) {
try {
// Cursor хранит время и ID последнего сообщения предыдущей страницы.
// Декодируем cursor из Base64 в обычную строку.
String[] p=new String(Base64.getUrlDecoder().decode(cursor),StandardCharsets.UTF_8).split("\\|",-1);
if(p.length!=3 || !id.equals(UUID.fromString(p[0]))) bad();
// Добавляем условие keyset-пагинации после последнего сообщения.
sql+="and (created_at,id)>(?,?) "; args.add(java.sql.Timestamp.from(OffsetDateTime.parse(p[1]).toInstant())); args.add(UUID.fromString(p[2]));
} catch(Exception e) { bad(); }
}
// Сортируем историю и берём одну запись сверх лимита для следующего cursor.
sql+="order by created_at,id limit ?"; args.add(pageLimit+1);
// Выполняем запрос и превращаем строки базы в объекты Message.
List<Message> x=db.query(sql,(rs,n)->new Message(rs.getObject(1,UUID.class),rs.getObject(2,UUID.class),rs.getObject(3,UUID.class),rs.getString(4),rs.getTimestamp(5).toInstant()),args.toArray());
// Если запись сверх лимита есть, кодируем её позицию как следующий cursor.
String next=x.size()>pageLimit?Base64.getUrlEncoder().withoutPadding().encodeToString((id+"|"+x.get(pageLimit-1).created_at()+"|"+x.get(pageLimit-1).id()).getBytes(StandardCharsets.UTF_8)):null; return new Page<>(x.subList(0,Math.min(pageLimit,x.size())),next);
}
// Преобразует limit списка чатов в число и проверяет диапазон.
int parseLimit(String value) { try { int limit=value==null?50:Integer.parseInt(value); if(limit<1||limit>100) bad(); return limit; } catch(NumberFormatException e) { bad(); return 0; } }
// Формируем ошибку, не раскрывая наличие чужого объекта.
ApiException notFound(){return new ApiException(HttpStatus.NOT_FOUND,"not_found","object not found");}
// Формируем общую ошибку некорректного запроса.
void bad(){throw new ApiException(HttpStatus.BAD_REQUEST,"invalid_request","invalid request");}
}
// @RestControllerAdvice применяет обработчики ко всем REST-контроллерам.
// Благодаря этому ошибки возвращаются в одном формате JSON.
@RestControllerAdvice static class Errors {
// Все ошибки API приводятся к одному JSON-формату.
// @ExceptionHandler связывает тип исключения с методом обработки.
// Здесь обрабатываются специально созданные ошибки API.
@ExceptionHandler(ApiException.class) ResponseEntity<ErrorBody> api(ApiException e,HttpServletRequest r){
// Создаём заголовки ответа с ошибкой.
HttpHeaders h=new HttpHeaders();
if(e.status==HttpStatus.UNAUTHORIZED) h.set("WWW-Authenticate",r.getRequestURI().equals("/api/v1/auth/sessions")?"Basic realm=\"messenger\", charset=\"UTF-8\"":"Bearer realm=\"messenger\"");
// Возвращаем статус, заголовки и единое тело ошибки.
return ResponseEntity.status(e.status).headers(h).body(new ErrorBody(new Error(e.code,e.getMessage(),id(r))));
}
// Неожиданные исключения превращаем в безопасный ответ 500.
// Этот обработчик является запасным для неожиданных исключений.
@ExceptionHandler(Exception.class) ResponseEntity<ErrorBody> other(Exception e,HttpServletRequest r){ LoggerFactory.getLogger(Errors.class).error("request failed",e); return ResponseEntity.status(500).body(new ErrorBody(new Error("internal_error","internal server error",id(r)))); }
// Неправильный JSON считается ошибкой входных данных клиента.
// Этот обработчик ловит неправильный или повреждённый JSON.
@ExceptionHandler(HttpMessageNotReadableException.class) ResponseEntity<ErrorBody> malformed(HttpServletRequest r){ return ResponseEntity.badRequest().body(new ErrorBody(new Error("invalid_request","invalid request",id(r)))); }
// Ошибка преобразования UUID или числового параметра означает неверный запрос.
@ExceptionHandler(MethodArgumentTypeMismatchException.class) ResponseEntity<ErrorBody> mismatch(HttpServletRequest r){ return ResponseEntity.badRequest().body(new ErrorBody(new Error("invalid_request","invalid request",id(r)))); }
// Ошибка PostgreSQL возвращается как временная недоступность зависимости.
@ExceptionHandler(DataAccessException.class) ResponseEntity<ErrorBody> database(DataAccessException e,HttpServletRequest r){ return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(new ErrorBody(new Error("unavailable","database is unavailable",id(r)))); }
// Получаем ID запроса, который добавил фильтр.
String id(HttpServletRequest r){ return String.valueOf(r.getAttribute("requestId")); }
}
}