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);
    }
}

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";
    }
}

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());
}

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) {
    // Логика создания
}

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();
        }
    }
}

Authorization: Bearer <JWT_TOKEN>

{
  "id": 1,
  "name": "John Doe",
  "links": [
    { "rel": "self", "href": "/users/1" },
    { "rel": "orders", "href": "/users/1/orders" }
  ]
}

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

{
  "timestamp": "2024-12-11T12:34:56Z",
  "status": 400,
  "error": "Bad Request",
  "message": "Invalid email format",
  "path": "/users"
}

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

<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>

@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
}

@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>

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);
    }
}

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

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

{
  "id": 1,
  "name": "John Doe",
  "age": 30
}

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

public class User {
    private int id;
    private String name;
    
    @JsonIgnore
    private String password;
}

public class User {
    @JsonProperty("user_id")
    private int id;
    private String name;
}

public class Event {
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime eventDate;
}

spring.jackson.default-property-inclusion=non_null

@JsonInclude(JsonInclude.Include.NON_NULL)
public class User {
    private String name;
    private String email;
}

<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
</dependency>

@XmlRootElement
public class User {
    private int id;
    private String name;

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

public class User {
    @XmlElement(name = "user_id")
    private int id;
}

public class User {
    @XmlTransient
    private String password;
}

@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;
    }
}

spring.jackson.date-format=yyyy-MM-dd HH:mm:ss

{
  "timestamp": "2024-12-11T12:00:00",
  "status": 400,
  "error": "Bad Request",
  "message": "Cannot deserialize value of type 'int' from String \"abc\""
}

@ControllerAdvice
public class CustomExceptionHandler {

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

@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);
}

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

@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();
    }
}

GET /api/users/1 HTTP/1.1
Host: example.com

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

POST /api/users HTTP/1.1
Content-Type: application/json
Host: example.com

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

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

PUT /api/users/1 HTTP/1.1
Content-Type: application/json
Host: example.com

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

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

DELETE /api/users/1 HTTP/1.1
Host: example.com

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

@GetMapping("/{id}")
public ResponseEntity<User> getUser(@PathVariable Long id) {
    return userService.findById(id)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.status(HttpStatus.NOT_FOUND).build());
}

@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"
    }
  ]
}

@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");
}

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());
    }
}

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

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;
    // Геттеры и сеттеры...
}

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

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

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);
    }
}

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();
    }
}

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

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
public class GlobalExceptionHandler {

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

@SpringBootTest
@AutoConfigureMockMvc
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

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