Какой стек технологий?

Стек технологий Java разработчика

Вот типичный стек, с которым работает Java разработчик в 2025 году:

Backend Framework

Spring Boot — 99% случаев

// Spring Boot приложение
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// REST контроллер
@RestController
@RequestMapping("/api/users")
public class UserController {
    @GetMapping("/{id}")
    public User getUser(@PathVariable int id) {
        return userService.findById(id);
    }
}

Альтернативы (редко):

• Quarkus — для микросервисов
• Micronaut — очень лёгкий
• Vert.x — для высоконагруженных систем

ORM/Database

Hibernate + JPA — стандарт

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    private UUID id;
    
    @Column(nullable = false)
    private String email;
    
    @OneToMany(mappedBy = "user")
    private List<Post> posts;
}

// Repository
@Repository
public interface UserRepository extends JpaRepository<User, UUID> {
    Optional<User> findByEmail(String email);
}

Инструменты для миграций:

• Liquibase
• Flyway

Databases

PostgreSQL — лучший выбор

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: postgres
    password: password
  jpa:
    hibernate:
      ddl-auto: validate
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQL14Dialect

Также используют:

• MySQL
• Oracle (legacy)
• MongoDB (документы)
• Redis (кеш)

Testing

JUnit 5 + Mockito — стандарт

@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    @Mock
    private UserRepository userRepository;
    
    @InjectMocks
    private UserService userService;
    
    @Test
    void testCreateUser() {
        // Arrange
        User user = new User("john@example.com");
        when(userRepository.save(user)).thenReturn(user);
        
        // Act
        User result = userService.create(user);
        
        // Assert
        assertEquals("john@example.com", result.getEmail());
        verify(userRepository).save(user);
    }
}

Интеграционные тесты:

• TestContainers — реальная БД в докере
• @DataJpaTest — слайс для данных
• @WebMvcTest — слайс для REST

Build Tool

Maven или Gradle (50/50)

<!-- Maven pom.xml -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>3.2.0</version>
</dependency>

// Gradle build.gradle
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web:3.2.0'
}

API Documentation

OpenAPI 3.0 (Swagger)

@Configuration
public class OpenApiConfig {
    @Bean
    public OpenAPI customOpenAPI() {
        return new OpenAPI()
            .info(new Info()
                .title("User API")
                .version("1.0")
                .description("API for managing users"));
    }
}

@RestController
@RequestMapping("/api/users")
public class UserController {
    @Operation(summary = "Get user by ID")
    @GetMapping("/{id}")
    public User getUser(@PathVariable UUID id) {
        return userService.findById(id);
    }
}

Security

Spring Security + JWT/OAuth2

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .httpBasic();
        return http.build();
    }
}

Caching

Redis с Spring Cache

@Configuration
@EnableCaching
public class CacheConfig {
}

@Service
public class UserService {
    @Cacheable(value = "users", key = "#id")
    public User findById(UUID id) {
        return userRepository.findById(id).orElseThrow();
    }
    
    @CacheEvict(value = "users", key = "#user.id")
    public void updateUser(User user) {
        userRepository.save(user);
    }
}

Message Queue

RabbitMQ или Apache Kafka

@Component
public class MessageProducer {
    private final RabbitTemplate rabbitTemplate;
    
    public void sendMessage(String message) {
        rabbitTemplate.convertAndSend("myQueue", message);
    }
}

@Component
public class MessageConsumer {
    @RabbitListener(queues = "myQueue")
    public void consumeMessage(String message) {
        System.out.println("Received: " + message);
    }
}

Containerization

Docker + Docker Compose

# Dockerfile
FROM openjdk:21-jdk
COPY target/app.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

# docker-compose.yml
version: '3.8'
services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - SPRING_DATASOURCE_URL=jdbc:postgresql://db:5432/mydb
  db:
    image: postgres:15
    environment:
      - POSTGRES_DB=mydb
      - POSTGRES_PASSWORD=password

CI/CD

GitHub Actions / GitLab CI / Jenkins

# GitHub Actions
name: Build and Test
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-java@v3
        with:
          java-version: '21'
      - run: mvn clean test
      - run: mvn clean package

Monitoring

Prometheus + Grafana + Spring Boot Actuator

spring:
  boot:
    admin:
      client:
        url: http://localhost:9000
management:
  endpoints:
    web:
      exposure:
        include: health, metrics, prometheus
  metrics:
    export:
      prometheus:
        enabled: true

Logging

SLF4J + Logback

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

@Service
public class UserService {
    private static final Logger logger = LoggerFactory.getLogger(UserService.class);
    
    public void processUser(User user) {
        logger.info("Processing user: {}", user.getId());
        try {
            // логика
        } catch (Exception e) {
            logger.error("Error processing user", e);
        }
    }
}

Modern Java Stack (2025)

┌─────────────────────────────────────────────────────┐
│          Java 21 с Project Loom (Virtual Threads)   │
├─────────────────────────────────────────────────────┤
│ Spring Boot 3.2+                                    │
│ Spring Cloud для микросервисов                      │
│ Spring Native для GraalVM компиляции                │
│ Quarkus для lightweight контейнеров                  │
│ Kubernetes для оркестрации                          │
│ Observability (OpenTelemetry)                       │
│ Automated Testing (SpockFramework, Testcontainers)  │
└─────────────────────────────────────────────────────┘

Ключевые выводы

• Spring Boot — выбор 99% компаний
• PostgreSQL + Hibernate — стандартная пара для БД
• Docker + Kubernetes — обязательны для продакшена
• JUnit 5 + Mockito — testing стандарт
• GitHub Actions / GitLab CI — CI/CD инструменты
• Prometheus + Grafana — для мониторинга
• OpenAPI/Swagger — для документирования API
• Java 21 — последняя LTS версия