Spring Framework — полный курс

public class OrderService {
    private final OrderRepository repository = new OrderRepositoryImpl();
    private final NotificationService notifier = new EmailNotificationService();
}

public class OrderService {
    private final OrderRepository repository;
    private final NotificationService notifier;

    public OrderService(OrderRepository repository, NotificationService notifier) {
        this.repository = repository;
        this.notifier = notifier;
    }
}

<beans xmlns="http://www.springframework.org/schema/beans">
    <bean id="orderService" class="com.example.OrderService">
        <constructor-arg ref="orderRepository"/>
    </bean>
</beans>

@Configuration
public class AppConfig {

    @Bean
    public OrderRepository orderRepository() {
        return new JdbcOrderRepository();
    }

    @Bean
    public NotificationService notificationService() {
        return new EmailNotificationService();
    }

    @Bean
    public OrderService orderService() {
        return new OrderService(orderRepository(), notificationService());
    }
}

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
OrderService service = context.getBean(OrderService.class);

@Service
public class OrderService {
    private final OrderRepository repository;

    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }
}

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

@Service
@Scope("prototype")
public class WidgetService {
}

@Service
public class PaymentService {
    private final PaymentGateway gateway;
    private final TransactionLog log;

    @Autowired
    public PaymentService(PaymentGateway gateway, TransactionLog log) {
        this.gateway = gateway;
        this.log = log;
    }
}

@Service
public class ReportService {
    @Autowired
    private DataSource dataSource;

    @Autowired
    public void setFormatter(ReportFormatter formatter) {
        this.formatter = formatter;
    }
}

@Service
@Qualifier("email")
public class EmailNotificationService implements NotificationService { }

@Service
@Qualifier("sms")
public class SmsNotificationService implements NotificationService { }

@Service
public class AlertService {
    @Autowired
    public AlertService(@Qualifier("email") NotificationService notifier) {
        this.notifier = notifier;
    }
}

@Configuration
@PropertySource("classpath:application.properties")
public class AppConfig {

    @Value("${db.url}")
    private String dbUrl;

    @Value("${db.pool.size}")
    private int poolSize;

    @Bean
    public DataSource dataSource() {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl(dbUrl);
        ds.setMaximumPoolSize(poolSize);
        return ds;
    }
}

db.url=jdbc:postgresql://localhost:5432/mydb
db.pool.size=10

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void logMethodCall(JoinPoint joinPoint) {
        String method = joinPoint.getSignature().getName();
        System.out.println("Вызов метода: " + method);
    }

    @Around("execution(* com.example.service.*.*(..))")
    public Object measureTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.nanoTime();
        Object result = joinPoint.proceed();
        long duration = System.nanoTime() - start;
        System.out.println(joinPoint.getSignature().getName() + " — " + duration + " ns");
        return result;
    }
}

@Configuration
@EnableAspectJAutoProxy
public class AopConfig {
}

@Repository
public class UserRepository {
    private final JdbcTemplate jdbc;

    public UserRepository(DataSource dataSource) {
        this.jdbc = new JdbcTemplate(dataSource);
    }

    public User findById(long id) {
        return jdbc.queryForObject(
            "SELECT id, name, email FROM users WHERE id = ?",
            new BeanPropertyRowMapper<>(User.class),
            id
        );
    }

    public List<User> findAll() {
        return jdbc.query(
            "SELECT id, name, email FROM users",
            new BeanPropertyRowMapper<>(User.class)
        );
    }

    public void save(User user) {
        jdbc.update(
            "INSERT INTO users (name, email) VALUES (?, ?)",
            user.getName(), user.getEmail()
        );
    }
}

@Service
public class TransferService {
    private final AccountRepository accounts;

    public TransferService(AccountRepository accounts) {
        this.accounts = accounts;
    }

    @Transactional
    public void transfer(long fromId, long toId, BigDecimal amount) {
        Account from = accounts.findById(fromId);
        Account to = accounts.findById(toId);
        from.debit(amount);
        to.credit(amount);
        accounts.save(from);
        accounts.save(to);
    }
}

@Controller
@RequestMapping("/users")
public class UserController {
    private final UserService service;

    public UserController(UserService service) {
        this.service = service;
    }

    @GetMapping
    @ResponseBody
    public List<UserDto> getAll() {
        return service.findAll();
    }

    @GetMapping("/{id}")
    @ResponseBody
    public UserDto getById(@PathVariable long id) {
        return service.findById(id);
    }

    @PostMapping
    @ResponseBody
    @ResponseStatus(HttpStatus.CREATED)
    public UserDto create(@RequestBody CreateUserRequest request) {
        return service.create(request);
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**").permitAll()
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .defaultSuccessUrl("/dashboard")
            )
            .logout(logout -> logout.permitAll());
        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

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

@Configuration
@Profile("prod")
public class ProdConfig {
    @Bean
    DataSource dataSource() {
        return DataSourceBuilder.create()
            .url("jdbc:postgresql://db-prod:5432/app")
            .username("${DB_USER}")
            .password("${DB_PASSWORD}")
            .build();
    }
}

# application-prod.properties
spring.profiles.active=prod
server.port=8080
app.retry.max=5

@Configuration
@EnableAsync
public class AsyncConfig {
    @Bean
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(4);
        executor.setMaxPoolSize(16);
        executor.setQueueCapacity(100);
        return executor;
    }
}

@Service
public class NotifyService {
    @Async
    public void sendWelcomeEmail(String email) {
        // трудоёмкая отправка не блокирует ответ
    }
}

@Async("taskExecutor")
public CompletableFuture<Order> loadOrder(Long id) { ... }

@SpringBootTest
@ActiveProfiles("test")
class OrderServiceTest {

    @Autowired
    OrderService orderService;

    @Test
    void createOrder_calculatesTotal() {
        Order order = orderService.create(42, List.of(10, 20));
        assertEquals(30, order.total());
    }
}

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(NotFoundException.class)
    public ResponseEntity<ApiError> handleNotFound(NotFoundException e) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
            .body(new ApiError(e.getMessage()));
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ApiError> handleValidation(
            MethodArgumentNotValidException e) {
        String msg = e.getBindingResult().getFieldErrors()
            .stream()
            .map(f -> f.getField() + ": " + f.getDefaultMessage())
            .collect(Collectors.joining("; "));
        return ResponseEntity.badRequest().body(new ApiError(msg));
    }
}

public record CreateUserRequest(
    @NotBlank @Email String email,
    @Size(min = 8) String password,
    @Min(18) int age
) {}

@Entity
public class User {
    @Id @GeneratedValue
    private Long id;
    private String email;
    private String name;
}

public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByEmailContaining(String part);
    Optional<User> findByEmail(String email);

    @Query("select u from User u where u.name = :name")
    List<User> searchByName(@Param("name") String name);
}

@Configuration
@EnableCaching
public class CacheConfig { }

@Service
public class CatalogService {
    private final CatalogRepository catalog;

    @Cacheable(value = "catalog", key = "#categoryId")
    public List<Item> itemsByCategory(long categoryId) {
        return catalog.findByCategory(categoryId);
    }

    @CacheEvict(value = "catalog", allEntries = true)
    public void refreshCatalog() { }

    @CachePut(value = "stats", key = "#item.id")
    public Item update(Item item) { ... }
}

// ключевые инструменты Spring Cloud
Spring Cloud Config  — централизованная конфигурация
Spring Cloud Gateway — единая точка входа и маршрутизация
Eureka / Consul      — реестр сервисов (discovery)
Sleuth               — трассировка между сервисами
Resilience4j         — защита от каскадных падений

@CircuitBreaker(name = "payments", fallbackMethod = "fallbackPay")
public Payment pay(Order order) {
    return paymentsClient.process(order);
}

@ConfigurationProperties("app.mail")
public class MailProperties {
    private String host;
    private int port;
    private Credentials credentials = new Credentials();

    public static class Credentials {
        private String user;
        private String password;
        // геттеры/сеттеры обязательны
    }
    // геттеры/сеттеры
}

app.mail.host= smtp.example.com
app.mail.port= 587
app.mail.credentials.user= bot
app.mail.credentials.password= секрет

# messages.properties
greeting=Привет, {0}!
# messages_en.properties
greeting=Hello, {0}!

@Autowired MessageSource messages;

String text = messages.getMessage("greeting",
        new Object[]{name}, LocaleContextHolder.getLocale());

@RestController
public class ProfileController {
    @GetMapping("/profile")
    public Mono<Profile> profile(@AuthenticationPrincipal User u) {
        return Mono.zip(
            userService.findById(u.getId()),
            orderService.sumByUser(u.getId()))
          .map(t -> new Profile(t.getT1(), t.getT2()));
    }
}

// через себя @Transactional не сработает (прокси-вызов)
class Payment { @Transactional public void pay() {...}
               void process() { this.pay(); /* ✗ */ } }