Spring Boot — создание современных веб-приложений на Java

demo/
├── pom.xml
└── src/main/
    ├── java/com/example/demo/
    │   ├── DemoApplication.java
    │   └── ...
    └── resources/
        ├── application.properties
        └── static/

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

mvn spring-boot:run

mvn package
java -jar target/demo-0.0.1-SNAPSHOT.jar

package com.example.demo.web;

import java.util.Map;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class HelloController {

    @GetMapping("/hello")
    public Map<String, String> hello() {
        return Map.of("message", "Привет, мир!");
    }

    @GetMapping("/hello/{name}")
    public Map<String, String> greet(@PathVariable String name) {
        return Map.of("message", "Привет, " + name);
    }

    @GetMapping("/sum")
    public int sum(@RequestParam(defaultValue = "0") int a,
                   @RequestParam(defaultValue = "0") int b) {
        return a + b;
    }

    @PostMapping("/hello")
    public Map<String, String> create() {
        return Map.of("status", "создано");
    }
}

package com.example.demo.service;

import com.example.demo.web.HelloController;
import org.springframework.stereotype.Service;

@Service
public class GreetingService {

    public String greet(String name) {
        return "Привет, " + name + "!";
    }
}

package com.example.demo.web;

import com.example.demo.service.GreetingService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    private final GreetingService service;

    public GreetingController(GreetingService service) {
        this.service = service;
    }

    @GetMapping("/greet/{name}")
    public String greet(@PathVariable String name) {
        return service.greet(name);
    }
}

package com.example.demo.model;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Author {

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

    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.example.demo.repository;

import com.example.demo.model.Author;
import java.util.Optional;
import org.springframework.data.jpa.repository.JpaRepository;

public interface AuthorRepository extends JpaRepository<Author, Long> {

    Optional<Author> findByName(String name);

    boolean existsByName(String name);
}

package com.example.demo.model;

import com.fasterxml.jackson.annotation.JsonIgnore;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToOne;

@Entity
public class Book {

    @Id
    private Long id;

    private String title;

    @ManyToOne(fetch = FetchType.LAZY)
    @JsonIgnore
    private Author author;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Author getAuthor() {
        return author;
    }

    public void setAuthor(Author author) {
        this.author = author;
    }
}

package com.example.demo.dto;

import jakarta.validation.constraints.NotBlank;

public class AuthorRequest {

    @NotBlank(message = "Имя не может быть пустым")
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.example.demo.web;

import com.example.demo.dto.AuthorRequest;
import jakarta.validation.Valid;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AuthorController {

    @PostMapping("/api/authors")
    public AuthorRequest create(@Valid @RequestBody AuthorRequest request) {
        return request;
    }
}

package com.example.demo.web;

import java.util.Map;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Map<String, String> handleValidation(MethodArgumentNotValidException ex) {
        HttpStatus status = HttpStatus.BAD_REQUEST;
        return Map.of("error", ex.getBindingResult().getFieldError().getDefaultMessage());
    }
}

server.port=8080

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

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

# application-prod.properties
server.port=8080
spring.datasource.url=${DB_URL}
spring.datasource.username=${DB_USER}
spring.datasource.password=${DB_PASSWORD}
spring.jpa.hibernate.ddl-auto=validate

java -jar app.jar --spring.profiles.active=prod

package com.example.demo.web;

import static org.hamcrest.Matchers.containsString;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

@SpringBootTest
@AutoConfigureMockMvc
class GreetingControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void greetsByName() throws Exception {
        mockMvc.perform(get("/greet/Иван"))
               .andExpect(status().isOk())
               .andExpect(content().string(containsString("Иван")));
    }
}

package com.example.demo.service;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import com.example.demo.repository.AuthorRepository;
import org.junit.jupiter.api.Test;

class AuthorServiceTest {

    @Test
    void findsAuthorByName() {
        AuthorRepository repository = mock(AuthorRepository.class);
        when(repository.existsByName("Анна")).thenReturn(true);

        boolean exists = repository.existsByName("Анна");

        assertEquals(true, exists);
    }
}

<dependency>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-core</artifactId>
</dependency>

CREATE TABLE author (
    id BIGSERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL
);

FROM maven:3.9-eclipse-temurin-17 AS build
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline -B
COPY src ./src
RUN mvn package -DskipTests

FROM eclipse-temurin:17-jre
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

docker build -t demo-app .
docker run -p 8080:8080 demo-app

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

curl http://localhost:8080/actuator/health

# в docker-compose.yml
healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
  interval: 30s
  timeout: 5s
  retries: 3

# application.yml — общее
app:
  name: shop-service
  retry: 3

# application-prod.yml
spring:
  datasource:
    url: jdbc:postgresql://prod-db:5432/shop
    username: ${DB_USER}
    password: ${DB_PASSWORD}

java -jar shop.jar \
  --spring.profiles.active=prod
# или:
SPRING_PROFILES_ACTIVE=prod java -jar shop.jar

spring-boot-starter-security
jjwt-api, jjwt-impl, jjwt-jackson

POST /api/login { "email": "...", "password": "..." }
→ Authorization: Bearer eyJhbGciOiJIUzI1NiJ9...

@Configuration
@EnableWebSecurity
class SecurityConfig {

    @Bean
    SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(AbstractHttpConfigurer::disable)
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/login", "/api/register").permitAll()
                .anyRequest().authenticated())
            .sessionManagement(sm ->
                sm.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .build();
    }
}

implementation 'org.springframework.boot:spring-boot-starter-actuator'

# применить в application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Service
public class OrderService {
    private static final Logger log =
        LoggerFactory.getLogger(OrderService.class);

    public Order create(CreateOrderRequest req) {
        log.info("Создание заказа: user={}, total={}",
                 req.userId(), req.total());
        try {
            return doCreate(req);
        } catch (PaymentException e) {
            log.error("Оплата не прошла: order={}, reason={}",
                      req.orderId(), e.getMessage(), e);
            throw e;
        }
    }
}

# src/main/resources/logback-spring.xml (фрагмент)
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"/>
<root level="INFO">
    <appender-ref ref="CONSOLE"/>
</root>

@Configuration
@EnableScheduling
public class SchedulerConfig { }

@Service
public class ReportsJob {
    private final ReportService reports;

    @Scheduled(cron = "0 0 2 * * *")         // ежедневно в 02:00
    public void nightlyReport() { reports.buildDaily(); }

    @Scheduled(fixedDelay = 60_000)          // через 60 с после конца
    public void cleanupExpired() { ... }
}

// build.gradle / pom.xml
implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui'

@Operation(summary = "Создать заказ",
           description = "Создаёт заказ и резервирует товар")
@ApiResponses({
    @ApiResponse(responseCode = "201", description = "Заказ создан"),
    @ApiResponse(responseCode = "400", description = "Невалидные данные")
})
@PostMapping("/orders")
public OrderDto create(@Valid @RequestBody CreateOrderRequest req) { ... }

@Testcontainers
@SpringBootTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class OrderRepositoryTest {

    @Container
    static PostgreSQLContainer<?> postgres =
        new PostgreSQLContainer<>("postgres:16")
            .withDatabaseName("test")
            .withUsername("test")
            .withPassword("test");

    @DynamicPropertySource
    static void props(DynamicPropertyRegistry r) {
        r.add("spring.datasource.url", postgres::getJdbcUrl);
        r.add("spring.datasource.username", postgres::getUsername);
        r.add("spring.datasource.password", postgres::getPassword);
    }

    @Test
    void findsByEmail() { ... }
}

# application.yml
spring.jackson:
  ser.write-dates-as-timestamps: false   # ISO-8601 строкой
  default-property-inclusion: non_null  # не отдавать null-поля
  property-naming-strategy: SNAKE_CASE # поля без camelCase

@GetMapping("/products")
public Page<ProductDto> list(@PageableDefault(size=20) Pageable pageable) {
    return repo.findAll(pageable).map(ProductDto::from);
}

// SPECIFICATION: фильтр динамический
Specification<Product> spec = (root, q, cb) ->
    cb.and(cb.equal(root.get("category"), "tech"),
           cb.greaterThan(root.get("price"), 1000));
repo.findAll(spec, pageable);

management:
  endpoint.health.probes.enabled: true
  health.livenessstate.enabled: true
  health.readinessstate.enabled: true

server.shutdown: graceful
spring.lifecycle.timeout-per-shutdown-phase: 20s

# application.yml
spring.threads.virtual.enabled: true

mvn -Pnative native:compile   # требуется GraalVM + native-build-tools