Java for Beginner

Варианты ответа:

Anonymous Quiz

31%

Person{name='Alice', age=30}

46%

Person{name='Alice', age=0}

15%

Ошибка компиляции

Исключение времени выполнения

13 voters110 views08:48

Java for Beginner

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

https://t.me/Java_for_beginner_dev

#Mems

133 views10:29

Java for Beginner

Принципы построения 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

114 views13:59

Java for Beginner

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

107 views13:59

Java for Beginner

Форматы данных: 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

115 views05:29

Java for Beginner

Что выведет код?

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

128 views08:44

Java for Beginner

Варианты ответа:

Anonymous Quiz

21 voters122 views08:48

Java for Beginner

Это отец подложил?🧐😂

https://t.me/Java_for_beginner_dev

#Mems

121 views10:31

Java for Beginner

Настройка сериализации данных в 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

114 views13:59

Java for Beginner

Глобальная настройка сериализации

Настройка через 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

119 views13:59

Java for Beginner

Работа с 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

118 views05:29

Java for Beginner

Примеры сложных сценариев

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

128 views05:29

Java for Beginner

Что выведет код?

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

126 views08:44

Java for Beginner

Варинаты ответа:

Anonymous Quiz

30%

70%

20 voters125 views08:48

Java for Beginner

И куча банков🙈😂

https://t.me/Java_for_beginner_dev

#Mems

130 views10:31

Java for Beginner

Создание CRUD API в Spring

Разработка CRUD API (Create, Read, Update, Delete) — стандартная задача для построения RESTful приложений. Использование Spring Boot и PostgreSQL позволяет быстро и эффективно создать такое API.

Шаг 1: Создание проекта Spring Boot

Перейдите на Spring Initializr.

Выберите:
Project: Maven.
Language: Java.
Dependencies: Spring Web, Spring Data JPA, PostgreSQL Driver, Validation (для валидации данных).
Скачайте проект и откройте его в IDE.

Шаг 2: Настройка подключения к PostgreSQL

Добавьте настройки базы данных в файл application.properties.

Пример application.properties:

spring.datasource.url=jdbc:postgresql://localhost:5432/my_database
spring.datasource.username=postgres
spring.datasource.password=password

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

Расшифровка настроек:
spring.datasource.url: URL подключения к PostgreSQL (с указанием базы данных).
spring.jpa.hibernate.ddl-auto: Автоматическое управление схемой базы данных (update, create, none).
spring.jpa.show-sql: Показывать SQL-запросы в консоли.
spring.jpa.properties.hibernate.dialect: Dialect Hibernate для PostgreSQL.

Шаг 3: Создание сущности (Entity)

Сущность представляет таблицу в базе данных.

import jakarta.persistence.*;
import jakarta.validation.constraints.*;

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank(message = "Name is mandatory")
    private String name;

    @Email(message = "Email should be valid")
    @NotBlank(message = "Email is mandatory")
    private String email;

    @NotNull(message = "Age is mandatory")
    private Integer age;
    // Геттеры и сеттеры...
}

Примечания:
Аннотация @Entity связывает класс с таблицей в базе данных.
Аннотация @Id указывает первичный ключ.
Аннотация @GeneratedValue используется для автоинкремента.
@Table(name = "users") указывает имя таблицы.
Аннотации валидации (@NotBlank, @Email, @NotNull) проверяют корректность данных.

Шаг 4: Создание слоя доступа к данным (Repository)

Интерфейс репозитория предоставляет методы для взаимодействия с базой данных.

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

Особенности:
JpaRepository предоставляет стандартные CRUD-методы (save, findById, findAll, deleteById).
Не нужно реализовывать методы вручную.

Шаг 5: Реализация бизнес-логики (Service)

Слой Service инкапсулирует логику работы с данными.

import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public User getUserById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User not found with id: " + id));
    }

    public User createUser(User user) {
        return userRepository.save(user);
    }

    public User updateUser(Long id, User updatedUser) {
        User existingUser = getUserById(id);
        existingUser.setName(updatedUser.getName());
        existingUser.setEmail(updatedUser.getEmail());
        existingUser.setAge(updatedUser.getAge());
        return userRepository.save(existingUser);
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

Примечания:
Методы инкапсулируют работу с UserRepository.
Если пользователь не найден, выбрасывается исключение.

#Java #Training #Spring #CRUD_API

118 views13:59

Java for Beginner

Шаг 6: Создание REST-контроллера

Контроллер обрабатывает HTTP-запросы и возвращает данные клиенту.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import jakarta.validation.Valid;
import java.util.List;

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

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        return ResponseEntity.ok(userService.getUserById(id));
    }

    @PostMapping
    public ResponseEntity<User> createUser(@Valid @RequestBody User user) {
        return ResponseEntity.status(201).body(userService.createUser(user));
    }

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

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

Примечания:
Методы контроллера возвращают данные с помощью ResponseEntity.
Данные валидируются аннотацией @Valid.
Используются стандартные HTTP-коды:
200 OK для успешных операций.
201 Created для создания ресурса.
204 No Content для удаления.

Шаг 7: Тестирование API

Пример запросов (с использованием Postman или curl):
Получение всех пользователей:

GET http://localhost:8080/api/users

Получение пользователя по ID:

GET http://localhost:8080/api/users/1

Создание пользователя:

POST http://localhost:8080/api/users
Content-Type: application/json

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

Обновление пользователя:

PUT http://localhost:8080/api/users/1
Content-Type: application/json

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

Удаление пользователя:

DELETE http://localhost:8080/api/users/1

Дополнительные возможности

Обработка ошибок: Добавьте обработчик ошибок с помощью @ControllerAdvice:

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntimeException(RuntimeException ex) {
        return ResponseEntity.status(404).body(ex.getMessage());
    }
}

Тестирование с помощью MockMvc:

@SpringBootTest
@AutoConfigureMockMvc
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testGetAllUsers() throws Exception {
        mockMvc.perform(get("/api/users"))
               .andExpect(status().isOk());
    }
}

#Java #Training #Spring #CRUD_API

138 views13:59

Java for Beginner

Доброго субботнего утра! ☀️

Как Ваши дела? Елку поставили?🎄

Готовлю на завтра выполнение тестового задания от одного из работодателей с hh.ru.🤌

Посмотрим, разберем, да что-нибудь напишем🤪😂

Всем хороших выходных🎉

144 viewsedited 04:59

Java for Beginner

Всем привет!✊

В 16:00 по МСК, я вновь жду Вас на встрече в Яндекс.Телемост!

Попробуем сделать тестовое задание от работодателя на hh.ru, обсудим детали)

Жду всех!✌️

155 views04:45

Java for Beginner

Встреча создана!

https://telemost.yandex.ru/j/89268837201575

Залетаем!

143 views12:49

Java for Beginner

Пишем тестовое задание от реального работодателя. Встреча от 22.12.2024

Запись нашей сегодняшней встречи -
YOUTUBE
RUTUBE

Крайне благодарен всем кто пришел, за участие!💪

На сегодняшней встрече мы начали писать тестовый сервис по документации реального работодателя с hh.ru:
— разобрали логику приложения
— создали сущность и Dto
— начали писать сервисы и контроллер

Смотрите, комментируйте, задавайте вопросы! Обязательно подписывайтесь на ютуб и рутюб каналы!!!

Всем хорошего настроения! 🫡✌️

148 viewsedited 15:51

About

Blog

Apps

Platform