Java for Beginner
672 subscribers
541 photos
155 videos
12 files
827 links
Канал от новичков для новичков!
Изучайте Java вместе с нами!
Здесь мы обмениваемся опытом и постоянно изучаем что-то новое!

Наш YouTube канал - https://www.youtube.com/@Java_Beginner-Dev

Наш канал на RUTube - https://rutube.ru/channel/37896292/
Download Telegram
Настройка кастомных страниц ошибок в Spring Security

Spring Security позволяет заменить стандартные страницы ошибок на пользовательские. Это улучшает пользовательский опыт и делает интерфейс приложения более профессиональным.

1. Общие страницы ошибок Spring Security

По умолчанию Spring Security использует встроенные страницы ошибок:
401 Unauthorized: для неудачной аутентификации.
403 Forbidden: для попыток доступа без соответствующих прав.


Эти страницы достаточно просты и не подходят для продакшн-приложений. Их можно заменить на кастомные.

2. Подходы к настройке кастомных страниц ошибок

Использование обработчиков (handler):

Настройка обработчиков AuthenticationEntryPoint и AccessDeniedHandler для возврата кастомных страниц.

Глобальная обработка исключений:
Настройка глобального обработчика через @ControllerAdvice.

Перенаправление на HTML-страницы:
Использование механизма перенаправления на заранее подготовленные HTML-страницы.

3. Настройка кастомных страниц ошибок в Spring Security

3.1 Замена страницы для ошибки 403 (Forbidden)
Настраиваем кастомный AccessDeniedHandler:
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class CustomAccessDeniedHandler implements AccessDeniedHandler {

@Override
public void handle(HttpServletRequest request, HttpServletResponse response,
AccessDeniedException accessDeniedException) throws IOException {
// Перенаправление на кастомную страницу
response.sendRedirect("/error/403");
}
}


Добавляем обработчик в конфигурацию Spring Security:
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfig {

private final CustomAccessDeniedHandler accessDeniedHandler;

public SecurityConfig(CustomAccessDeniedHandler accessDeniedHandler) {
this.accessDeniedHandler = accessDeniedHandler;
}

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
http
.csrf().disable()
.authorizeRequests()
.anyRequest().authenticated()
.and()
.exceptionHandling()
.accessDeniedHandler(accessDeniedHandler); // Подключение кастомного обработчика

return http.build();
}
}


Создаем контроллер для обработки ошибок:
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class ErrorController {

@GetMapping("/error/403")
public String error403() {
return "error/403"; // Возвращаем HTML-страницу
}
}


Добавляем страницу src/main/resources/templates/error/403.html (например, для Thymeleaf):
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Access Denied</title>
</head>
<body>
<h1>403 - Access Denied</h1>
<p>Sorry, you don't have permission to access this page.</p>
</body>
</html>


#Java #Training #Spring #Security #Security_Exceptions
3.2 Замена страницы для ошибки 401 (Unauthorized)

Настраиваем кастомный AuthenticationEntryPoint:

import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class CustomAuthenticationEntryPoint implements AuthenticationEntryPoint {

@Override
public void commence(HttpServletRequest request, HttpServletResponse response,
AuthenticationException authException) throws IOException {
response.sendRedirect("/error/401");
}
}


Добавляем обработчик в конфигурацию Spring Security:
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
http
.csrf().disable()
.authorizeRequests()
.anyRequest().authenticated()
.and()
.exceptionHandling()
.authenticationEntryPoint(customAuthenticationEntryPoint); // Подключение кастомного обработчика

return http.build();
}


Создаем контроллер для обработки ошибок:
@Controller
public class ErrorController {

@GetMapping("/error/401")
public String error401() {
return "error/401"; // Возвращаем HTML-страницу
}
}


Создаем страницу src/main/resources/templates/error/401.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Unauthorized</title>
</head>
<body>
<h1>401 - Unauthorized</h1>
<p>Please log in to access this page.</p>
</body>
</html>


4. Обработка всех ошибок через глобальный контроллер

Если нужно обрабатывать все исключения централизованно, можно использовать @ControllerAdvice:
import org.springframework.http.HttpStatus;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.core.AuthenticationException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;

@ControllerAdvice
public class GlobalErrorController {

@ExceptionHandler(AccessDeniedException.class)
@ResponseStatus(HttpStatus.FORBIDDEN)
public String handleAccessDeniedException() {
return "error/403";
}

@ExceptionHandler(AuthenticationException.class)
@ResponseStatus(HttpStatus.UNAUTHORIZED)
public String handleAuthenticationException() {
return "error/401";
}
}


#Java #Training #Spring #Security #Security_Exceptions
5. Использование встроенного механизма Spring Boot для ошибок

Spring Boot предоставляет удобный способ настройки кастомных страниц через файл application.properties:
server.error.whitelabel.enabled=false
server.error.path=/error


Затем создаем контроллер для обработки пути /error:
@Controller
public class CustomErrorController {

@GetMapping("/error")
public String handleError() {
return "error/custom";
}
}


Добавляем страницу src/main/resources/templates/error/custom.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Error</title>
</head>
<body>
<h1>An error occurred</h1>
<p>We are sorry, something went wrong.</p>
</body>
</html>


6. Обработка JSON-ответов для API

Для REST API ошибки обычно возвращаются в формате JSON. Пример глобального обработчика для API:
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class ApiErrorController {

@ExceptionHandler(AccessDeniedException.class)
public ResponseEntity<?> handleAccessDeniedException(AccessDeniedException ex) {
return ResponseEntity.status(HttpStatus.FORBIDDEN).body(Map.of(
"error", "Forbidden",
"message", ex.getMessage()
));
}
@ExceptionHandler(AuthenticationException.class)
public ResponseEntity<?> handleAuthenticationException(AuthenticationException ex) {
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(Map.of(
"error", "Unauthorized",
"message", ex.getMessage()
));
}
}


#Java #Training #Spring #Security #Security_Exceptions
REST и его архитектура

REST (Representational State Transfer) — это архитектурный стиль взаимодействия компонентов в распределенных системах, наиболее часто используемый для построения веб-сервисов. REST был предложен Роем Филдингом в его докторской диссертации в 2000 году.

REST основывается на простых принципах, обеспечивающих масштабируемость, производительность и простоту использования.

Принципы REST

Клиент-серверная архитектура
Разделение ответственности между клиентом (пользовательский интерфейс) и сервером (хранение данных и логика обработки). Это упрощает масштабирование и развитие каждого компонента.

Отсутствие состояния (Stateless)
Каждое взаимодействие между клиентом и сервером является независимым. Сервер не хранит информацию о состоянии клиента между запросами. Это упрощает обработку запросов и масштабирование.

Единый интерфейс (Uniform Interface)
REST-сервисы используют единообразные соглашения для взаимодействия. Это включает использование стандартных HTTP-методов и определенную структуру URL.

Кэшируемость (Cacheable)
Ответы сервера могут быть кэшируемыми, что улучшает производительность и снижает нагрузку на сервер.

Многоуровневая система (Layered System)
Компоненты системы могут быть разделены на уровни, например, клиент, балансировщик нагрузки, сервер приложений, сервер базы данных.

Код по требованию (Code on Demand)
(Необязательный принцип). Сервер может отправлять исполняемый код клиенту, чтобы расширить функциональность клиента.

Основные элементы REST

Ресурсы
В REST ресурс — это объект или информация, доступ к которым можно получить через URL.
Например, пользовательская информация может быть представлена как /users.


HTTP-методы REST-сервисы используют стандартные HTTP-методы для выполнения операций:
GET: Получение данных (например, список пользователей).
POST: Создание нового ресурса.
PUT: Полное обновление ресурса.
PATCH: Частичное обновление ресурса.
DELETE: Удаление ресурса.


Статусы HTTP-ответов

REST использует стандартные коды статуса HTTP для указания результата операции:
200 OK — Успешная операция.
201 Created — Ресурс создан.
204 No Content — Успешно, но без контента.
400 Bad Request — Неверный запрос.
401 Unauthorized — Необходима авторизация.
403 Forbidden — Нет прав доступа.
404 Not Found — Ресурс не найден.
500 Internal Server Error — Ошибка на сервере.


Репрезентация ресурсов
Ресурсы могут быть представлены в разных форматах: JSON, XML, HTML, текст.
Наиболее часто используется JSON, так как он легковесный и легко читаемый.


URI (Уникальный идентификатор ресурса)
Каждый ресурс имеет уникальный URI. Например:
/users — Список всех пользователей.
/users/1 — Информация о пользователе с ID 1.


Преимущества REST

Простота
REST базируется на стандартных и широко известных HTTP-методах.

Масштабируемость
Из-за отсутствия состояния и кэшируемости REST-сервисы легко масштабируются.

Универсальность
REST может использоваться для различных клиентов: веб-браузеров, мобильных приложений, IoT-устройств.

Независимость клиента и сервера
Обе стороны могут развиваться независимо друг от друга.

RESTful API в Spring Framework
Spring предоставляет мощные средства для разработки RESTful сервисов через модуль Spring Web. Основные элементы включают:

1. Контроллеры REST
Контроллеры в Spring создаются с помощью аннотации @RestController. Пример простого REST-контроллера:
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.ArrayList;

@RestController
@RequestMapping("/users")
public class UserController {

private List<String> users = new ArrayList<>(List.of("Alice", "Bob", "Charlie"));

@GetMapping
public List<String> getAllUsers() {
return users;
}

@GetMapping("/{id}")
public String getUserById(@PathVariable int id) {
return users.get(id);
}

@PostMapping
public void createUser(@RequestBody String user) {
users.add(user);
}

@DeleteMapping("/{id}")
public void deleteUser(@PathVariable int id) {
users.remove(id);
}
}


#Java #Training #Spring #REST
2. Обработка ошибок
Spring позволяет обрабатывать исключения централизованно. Например, если пользователь не найден, можно вернуть 404 Not Found:
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

@RestControllerAdvice
public class GlobalExceptionHandler {

@ExceptionHandler(IndexOutOfBoundsException.class)
@ResponseStatus(HttpStatus.NOT_FOUND)
public String handleIndexOutOfBounds(IndexOutOfBoundsException ex) {
return "User not found";
}
}


3. Использование DTO
Для передачи данных рекомендуется использовать объекты DTO (Data Transfer Objects):
public class UserDTO {
private String name;
private int age;

// Getters и Setters
}


Контроллер:

@PostMapping
public void createUser(@RequestBody UserDTO user) {
System.out.println("User created: " + user.getName());
}


4. Валидация
Spring поддерживает валидацию входных данных с помощью аннотации @Valid:
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Min;

public class UserDTO {
@NotEmpty(message = "Name cannot be empty")
private String name;

@Min(value = 18, message = "Age must be at least 18")
private int age;

// Getters и Setters
}


Контроллер:
@PostMapping
public void createUser(@Valid @RequestBody UserDTO user) {
// Логика создания
}


#Java #Training #Spring #REST
Что выведет код?

import java.io.*;

class Person1812 implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private transient int age;

public Person1812(String name, int age) {
this.name = name;
this.age = age;
}

@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
}

public class Task181224_1 {
public static void main(String[] args) {
Person1812 person = new Person1812("Alice", 30);

try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"));
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {

oos.writeObject(person);
Person1812 deserializedPerson = (Person1812) ois.readObject();

System.out.println(deserializedPerson);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}


#Tasks
Чистая правда!😜

https://t.me/Java_for_beginner_dev

#Mems
Принципы построения RESTful API

RESTful API (Representational State Transfer API) следует архитектурным принципам REST, которые обеспечивают масштабируемость, простоту, производительность и легкость использования. Соблюдение этих принципов помогает создавать API, которые легко понимаются, поддерживаются и используются разработчиками.

Основные принципы построения RESTful API

1. Идентификация ресурсов

В REST каждый ресурс должен быть уникально идентифицирован с помощью URI (Uniform Resource Identifier).
Ресурсы представляют данные (например, пользователей, заказы, товары).


Используйте понятные и предсказуемые URI:
GET /users — получить список всех пользователей.
GET /users/1 — получить данные пользователя с ID = 1.
POST /users — создать нового пользователя.
DELETE /users/1 — удалить пользователя с ID = 1.


Советы:
Используйте имена существительные вместо глаголов в URI (например, /products, а не /getProducts).
Следуйте единообразию в структуре URI.


2. Использование стандартных HTTP-методов

RESTful API основывается на семантике HTTP-методов:
GET — получение ресурса или коллекции.
POST — создание нового ресурса.
PUT — обновление существующего ресурса (полное).
PATCH — частичное обновление ресурса.
DELETE — удаление ресурса.


Пример:
GET /orders — получить все заказы.
POST /orders — создать новый заказ.
PUT /orders/123 — обновить заказ с ID = 123.
DELETE /orders/123 — удалить заказ с ID = 123.


3. Использование кодов состояния HTTP

RESTful API должен возвращать коды состояния HTTP для обозначения результата запроса:
200 OK — успешный запрос.
201 Created — ресурс создан.
204 No Content — запрос выполнен, но тело ответа пустое (например, при удалении).
400 Bad Request — ошибка в запросе клиента.
401 Unauthorized — требуется авторизация.
403 Forbidden — доступ запрещен.
404 Not Found — ресурс не найден.
500 Internal Server Error — ошибка на стороне сервера.


4. Поддержка разных форматов данных

RESTful API должен поддерживать универсальные форматы данных:
JSON — наиболее популярный формат, легковесный и легко читаемый.
XML — используется в некоторых корпоративных системах.
Plain Text — для простых данных.


Клиенты могут указывать желаемый формат данных через заголовок Accept:
Accept: application/json
Accept: application/xml
API должен возвращать данные в соответствии с этим заголовком.


5. Единообразный интерфейс

RESTful API должен иметь предсказуемую и интуитивно понятную структуру.
В URI не следует указывать действия (/getUser, /deleteUser), так как действия задаются через HTTP-методы.


6. Безопасность и отсутствие состояния (Statelessness)

API должен быть stateless — сервер не хранит состояние клиента между запросами. Все данные, необходимые для обработки запроса, передаются в каждом запросе (например, токен авторизации).
Это облегчает масштабирование и упрощает серверную часть.


Пример заголовка для авторизации:
Authorization: Bearer <JWT_TOKEN>


7. Кэшируемость

Ответы API должны быть кэшируемыми, если это возможно.

Используйте заголовки HTTP для управления кэшированием:

Cache-Control: max-age=3600 — ответ кэшируется на 1 час.
ETag — уникальный идентификатор ресурса, помогает определить, изменился ли ресурс.
Кэширование ускоряет доступ к данным и снижает нагрузку на сервер.


#Java #Training #Spring #REST #RESTful_API
8. HATEOAS (Hypermedia as the Engine of Application State)

В RESTful API ссылки (hyperlinks) должны быть частью ответа, чтобы клиент мог легко перемещаться между связанными ресурсами.

Пример ответа с HATEOAS:
{
"id": 1,
"name": "John Doe",
"links": [
{ "rel": "self", "href": "/users/1" },
{ "rel": "orders", "href": "/users/1/orders" }
]
}


Хотя HATEOAS улучшает гибкость, он реже используется в реальных API.

9. Иерархическая структура ресурсов

Ресурсы с отношениями (например, пользователь и его заказы) должны отражаться в URI.

Пример:
GET /users/1/orders — получить заказы пользователя с ID = 1.
GET /users/1/orders/2 — получить конкретный заказ пользователя.


10. Пагинация, фильтрация и сортировка

При работе с большими объемами данных API должен поддерживать:

Пагинацию:

Параметры: ?page=1&size=20.
Заголовки: X-Total-Count (общее количество ресурсов).


Фильтрацию:
Параметры: ?status=active.

Сортировку:
Параметры: ?sort=name,asc.
Пример ответа для пагинации:


{
"data": [
{ "id": 1, "name": "Alice" },
{ "id": 2, "name": "Bob" }
],
"page": 1,
"size": 2,
"total": 100
}


11. Версионирование API

Версионирование помогает избежать проблем при изменении API.

Подходы к версионированию:
В URI: /v1/users, /v2/users.
В заголовках: Accept: application/vnd.example.v1+json.


12. Обработка ошибок

RESTful API должен предоставлять информативные и структурированные сообщения об ошибках.

Пример ошибки:
{
"timestamp": "2024-12-11T12:34:56Z",
"status": 400,
"error": "Bad Request",
"message": "Invalid email format",
"path": "/users"
}


13. Документация

API должен быть хорошо документирован, чтобы разработчики могли легко его использовать:
OpenAPI/Swagger — популярный стандарт для документирования REST API.
Примеры запросов и ответов — помогают быстрее понять API.


#Java #Training #Spring #REST #RESTful_API
Форматы данных: JSON и XML

JSON (JavaScript Object Notation) и XML (eXtensible Markup Language) — это два популярных формата для обмена данными между клиентом и сервером. В рамках Spring оба формата поддерживаются для сериализации и десериализации данных, что делает их основными выбором для RESTful API и других интеграций.

JSON (JavaScript Object Notation)

JSON — это легковесный текстовый формат для обмена данными, основанный на синтаксисе JavaScript. Он разработан для передачи структурированных данных в человекочитаемой форме.

Пример JSON:
{
"id": 1,
"name": "John Doe",
"age": 30,
"isActive": true,
"roles": ["admin", "user"],
"address": {
"street": "123 Main St",
"city": "Springfield"
}
}


Преимущества JSON

Простота и читаемость:
JSON компактен и легко читается человеком.

Широкая поддержка:
JSON поддерживается большинством языков программирования.

Легковесность:
JSON менее объемный, чем XML, что снижает нагрузку на сеть.

Совместимость:
Он может быть легко интегрирован в JavaScript и другие языки.

Ограничения JSON

Ограниченный синтаксис:

Нет встроенной поддержки атрибутов, как в XML.

Менее строгий стандарт:
Возможны несовместимости при использовании сложных структур.

XML (eXtensible Markup Language)

XML — это язык разметки для представления данных в формате, удобном для чтения как человеком, так и машиной. В отличие от JSON, XML имеет более сложный синтаксис и поддерживает атрибуты.

Пример XML:
<user>
<id>1</id>
<name>John Doe</name>
<age>30</age>
<isActive>true</isActive>
<roles>
<role>admin</role>
<role>user</role>
</roles>
<address>
<street>123 Main St</street>
<city>Springfield</city>
</address>
</user>


Преимущества XML

Гибкость:
XML позволяет использовать как элементы, так и атрибуты для представления данных.

Самоописываемость:
Схемы XML (DTD, XSD) помогают проверять структуру и формат данных.

Поддержка сложных структур:

XML идеально подходит для иерархических данных.

Поддержка метаданных:
Атрибуты позволяют добавлять дополнительную информацию к элементам.

Ограничения XML

Больший размер:
XML более громоздкий по сравнению с JSON.

Сложность обработки:
XML требует большего количества ресурсов для парсинга.

Менее читаемый:
Из-за объема разметки XML менее удобен для восприятия человеком.

Поддержка JSON и XML в Spring

Spring поддерживает оба формата через модули Jackson (для JSON) и JAXB или другие парсеры (для XML).

Для работы с JSON используется библиотека Jackson. Она автоматически преобразует объекты Java в JSON и обратно.

Пример сериализации объекта в JSON:
@RestController
@RequestMapping("/users")
public class UserController {

@GetMapping("/{id}")
public User getUser(@PathVariable int id) {
return new User(1, "John Doe", 30, true);
}
}


Ответ:
{
"id": 1,
"name": "John Doe",
"age": 30,
"isActive": true
}


XML в Spring


Для работы с XML можно использовать библиотеку JAXB (Java Architecture for XML Binding) или другие парсеры.

Пример работы с XML:
@RestController
@RequestMapping("/users")
public class UserController {

@GetMapping(value = "/{id}", produces = MediaType.APPLICATION_XML_VALUE)
public User getUser(@PathVariable int id) {
return new User(1, "John Doe", 30, true);
}
}


Ответ:
<user>
<id>1</id>
<name>John Doe</name>
<age>30</age>
<isActive>true</isActive>
</user>


#Java #Training #Spring #Json #Xml
Что выведет код?

public class Task191224_1 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
int sum = 0;

for (int i = 0; i < arr.length; i += 2) {
sum += arr[i];
}

System.out.println("Sum: " + sum);
}
}


#Tasks
Варианты ответа:
Anonymous Quiz
19%
15
10%
12
57%
9
14%
6
Это отец подложил?🧐😂

https://t.me/Java_for_beginner_dev

#Mems
Настройка сериализации данных в Spring

Сериализация данных — это процесс преобразования объектов в формат, пригодный для передачи (например, JSON или XML). В Spring сериализация используется для обмена данными между клиентом и сервером, в основном в рамках RESTful API.

Spring поддерживает сериализацию данных через такие библиотеки, как:
Jackson для JSON,
JAXB или другие парсеры для XML.


Настройка сериализации в Spring позволяет управлять тем, как данные преобразуются и передаются клиентам.

Основы сериализации данных в Spring

Использование аннотации @RestController
Аннотация @RestController позволяет автоматизировать процесс сериализации. Методы, возвращающие объекты, автоматически сериализуют их в указанный формат (например, JSON или XML).

Пример контроллера:
@RestController
@RequestMapping("/users")
public class UserController {

@GetMapping("/{id}")
public User getUser(@PathVariable int id) {
return new User(1, "John Doe", 30);
}
}


Выходной формат по умолчанию (JSON):
{
"id": 1,
"name": "John Doe",
"age": 30
}


Настройка формата ответа через заголовки

Клиент может указать, в каком формате он хочет получить данные, с помощью заголовка Accept:

Accept: application/json — вернуть JSON.
Accept: application/xml — вернуть XML.

Spring автоматически определит нужный формат, если конфигурация включает поддержку соответствующих библиотек.

Настройка сериализации в JSON

Spring использует библиотеку Jackson для работы с JSON. Она предоставляется по умолчанию, если в проект добавлен модуль spring-boot-starter-web.

Зависимость Jackson (если нужно вручную):
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>


Настройка свойств через аннотации Jackson

Исключение ненужных полей: Используйте @JsonIgnore для исключения определённых полей из сериализации:
public class User {
private int id;
private String name;

@JsonIgnore
private String password;
}


Переименование полей: Используйте @JsonProperty для указания имени поля в JSON:
public class User {
@JsonProperty("user_id")
private int id;
private String name;
}


Настройка формата дат: Для работы с датами можно использовать @JsonFormat:
public class Event {
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime eventDate;
}


Исключение пустых или null полей: Можно настроить глобально через файл application.properties:
spring.jackson.default-property-inclusion=non_null


Или с помощью аннотации @JsonInclude:
@JsonInclude(JsonInclude.Include.NON_NULL)
public class User {
private String name;
private String email;
}


Настройка сериализации в XML

Для работы с XML используется библиотека JAXB или другие парсеры.


Зависимость JAXB:
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
</dependency>


Использование аннотаций JAXB


Аннотация @XmlRootElement: Указывает корневой элемент XML:
@XmlRootElement
public class User {
private int id;
private String name;

// Геттеры и сеттеры...
}


Указание имени поля в XML: Используйте @XmlElement:
public class User {
@XmlElement(name = "user_id")
private int id;
}


Исключение полей: Используйте
@XmlTransient:
public class User {
@XmlTransient
private String password;
}


#Java #Training #Spring #Serialization
Глобальная настройка сериализации

Настройка через ObjectMapper:
ObjectMapper — это основной класс Jackson для управления сериализацией и десериализацией JSON. Его можно настроить через бин в Spring:
@Configuration
public class JacksonConfig {

@Bean
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
return mapper;
}
}


Настройка глобального форматирования дат: В application.properties:
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss


Обработка ошибок при сериализации

Если при сериализации возникают ошибки, например, несоответствие типов, Spring возвращает стандартное сообщение об ошибке.
{
"timestamp": "2024-12-11T12:00:00",
"status": 400,
"error": "Bad Request",
"message": "Cannot deserialize value of type 'int' from String \"abc\""
}


Чтобы настроить собственный обработчик ошибок, можно использовать @ControllerAdvice:
@ControllerAdvice
public class CustomExceptionHandler {

@ExceptionHandler(JsonMappingException.class)
public ResponseEntity<String> handleJsonMappingException(JsonMappingException ex) {
return ResponseEntity.badRequest().body("Ошибка в JSON данных: " + ex.getMessage());
}
}


Выбор формата ответа на уровне метода

Если нужно вручную управлять форматом данных для отдельных методов, можно использовать параметр produces в аннотациях:
@GetMapping(value = "/user/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
public User getUserAsJson(@PathVariable int id) {
return new User(1, "John Doe", 30);
}

@GetMapping(value = "/user/{id}", produces = MediaType.APPLICATION_XML_VALUE)
public User getUserAsXml(@PathVariable int id) {
return new User(1, "John Doe", 30);
}


Тестирование сериализации


Для проверки работы сериализации можно использовать инструменты, такие как:

Postman: отправлять запросы и проверять ответ.
Spring MockMvc: тестирование сериализации на уровне кода:

@Test
public void testJsonSerialization() throws Exception {
mockMvc.perform(get("/users/1")
.accept(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.name").value("John Doe"));
}


#Java #Training #Spring #Serialization
Работа с HTTP-методами в Spring: GET, POST, PUT, DELETE

HTTP-методы (или «глаголы») — это действия, которые клиент может выполнять на ресурсе в веб-приложении. В контексте RESTful архитектуры, они представляют собой стандартные операции для взаимодействия с ресурсами.

Spring предоставляет удобный механизм работы с HTTP-методами через аннотации контроллеров, такие как @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, которые упрощают реализацию RESTful API.

Настройка HTTP-методов в Spring


Общий пример контроллера
@RestController
@RequestMapping("/api/users")
public class UserController {

@GetMapping("/{id}")
public User getUser(@PathVariable Long id) {
return new User(id, "John Doe", "john@example.com");
}

@PostMapping
public ResponseEntity<User> createUser(@RequestBody User user) {
user.setId(1L); // Пример генерации ID
return ResponseEntity.status(HttpStatus.CREATED).body(user);
}

@PutMapping("/{id}")
public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
user.setId(id);
return ResponseEntity.ok(user);
}

@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
return ResponseEntity.noContent().build();
}
}


HTTP-методы


1. GET — Чтение данных

Назначение: Возвращает данные с сервера (например, список пользователей, детали одного пользователя).
Идемпотентный метод: Повторный вызов GET не изменяет состояние ресурса.


Пример запроса:
GET /api/users/1 HTTP/1.1
Host: example.com


Реализация в Spring:
@GetMapping("/{id}")
public User getUser(@PathVariable Long id) {
return new User(id, "John Doe", "john@example.com");
}


Особенности:
Используется аннотация @GetMapping.
Данные возвращаются в формате JSON или XML в зависимости от заголовка Accept.


2. POST — Создание нового ресурса
Назначение: Создает новый ресурс на сервере.
Не идемпотентный метод: Повторный вызов создаёт новые записи.


Пример запроса:
POST /api/users HTTP/1.1
Content-Type: application/json
Host: example.com

{
"name": "Jane Doe",
"email": "jane@example.com"
}


Реализация в Spring:

@PostMapping
public ResponseEntity<User> createUser(@RequestBody User user) {
user.setId(1L); // Симуляция сохранения с генерацией ID
return ResponseEntity.status(HttpStatus.CREATED).body(user);
}


Особенности:
Используется аннотация @PostMapping.
Данные передаются через тело запроса (
@RequestBody).
В ответе часто возвращается код 201 Created и URL нового ресурса.


3. PUT — Обновление ресурса
Назначение: Обновляет существующий ресурс или создаёт его, если он не существует.
Идемпотентный метод: Повторный вызов приводит к тому же результату.


Пример запроса:
PUT /api/users/1 HTTP/1.1
Content-Type: application/json
Host: example.com

{
"name": "John Smith",
"email": "john.smith@example.com"
}


Реализация в Spring:
@PutMapping("/{id}")
public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
user.setId(id); // Симуляция обновления ресурса
return ResponseEntity.ok(user);
}


Особенности:
Используется аннотация @PutMapping.
Данные для обновления передаются через тело запроса.
В ответе обычно возвращается 200 OK с обновлённым ресурсом.


4. DELETE — Удаление ресурса
Назначение: Удаляет ресурс на сервере.
Идемпотентный метод: Повторный вызов приводит к тому же результату (ресурс уже удалён).


Пример запроса:
DELETE /api/users/1 HTTP/1.1
Host: example.com


Реализация в Spring:
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
return ResponseEntity.noContent().build();
}


Особенности:
Используется аннотация @DeleteMapping.
В ответе часто возвращается 204 No Content.


#Java #Training #Spring #GET #PUT #POST #DELETE
Примеры сложных сценариев

1. Обработка ошибок
Если ресурс не найден, можно вернуть соответствующий HTTP-ответ:
@GetMapping("/{id}")
public ResponseEntity<User> getUser(@PathVariable Long id) {
return userService.findById(id)
.map(ResponseEntity::ok)
.orElse(ResponseEntity.status(HttpStatus.NOT_FOUND).build());
}


2. Валидация данных

Использование @Valid для проверки корректности входящих данных:
@PostMapping
public ResponseEntity<User> createUser(@Valid @RequestBody User user) {
user.setId(1L);
return ResponseEntity.status(HttpStatus.CREATED).body(user);
}


Пример ошибок валидации:
{
"timestamp": "2024-12-11T12:00:00",
"status": 400,
"errors": [
{
"field": "name",
"message": "Name is required"
}
]
}


3. Поддержка разных форматов данных
Spring поддерживает автоматическое преобразование данных в зависимости от заголовков запроса:
JSON (application/json)
XML (application/xml)


Пример настройки:
@GetMapping(value = "/{id}", produces = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
public User getUser(@PathVariable Long id) {
return new User(id, "John Doe", "john@example.com");
}


#Java #Training #Spring #GET #PUT #POST #DELETE
Что выведет код?

import java.util.HashSet;
import java.util.Set;

public class Task201224_1 {
public static void main(String[] args) {
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(3);
set.add(2);
set.add(1);

System.out.println(set.size());
}
}


#Tasks
Варинаты ответа:
Anonymous Quiz
30%
5
0%
4
70%
3
0%
2
И куча банков🙈😂

https://t.me/Java_for_beginner_dev

#Mems