30 Spring аннотаций для 2026 года с примерами кода

@Configuration
public class AppConfig {
 @Bean
 public MyService myService() {
 return new MyServiceImpl();
 }
}

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

@Configuration
public class AppConfig {
 @Bean
 public DataSource dataSource() {
 return new EmbeddedDatabaseBuilder()
 .setType(EmbeddedDatabaseType.H2)
 .addScript("schema.sql")
 .build();
 }
}

@Service
public class MyService {
 @Value("${app.name}")
 private String appName;
 
 @Value("${app.timeout:5000}")
 private int timeout;
}

@Configuration
@PropertySource("classpath:application.properties")
public class AppConfig {
 @Autowired
 private Environment environment;
 
 @Bean
 public DataSource dataSource() {
 // Используем загруженные свойства
 }
}

@Service
public class OrderService {
 
 @Transactional
 public void createOrder(Order order) {
 // Сохраняем заказ
 orderRepository.save(order);
 
 // Вычитаем товары со склада
 inventoryService.decreaseStock(order.getItems());
 }
 
 @Transactional(propagation = Propagation.REQUIRES_NEW)
 public void logOrderCreation(Order order) {
 // Логируем создание в отдельной транзакции
 }
}

@Component
public class OrderEventListener {
 
 @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
 public void handleOrderEvent(OrderCreatedEvent event) {
 // Обрабатываем событие после успешного коммита
 notificationService.sendOrderConfirmation(event.getOrderId());
 }
}

@Service
public class PaymentService {
 
 @Transactional
 @Commit
 public void processPayment(Payment payment) {
 // Обработка платежа с обязательным коммитом
 }
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {
 
 @GetMapping("/{id}")
 public ResponseEntity<Order> getOrder(@PathVariable Long id) {
 return ResponseEntity.ok(orderService.findById(id));
 }
 
 @PostMapping
 public ResponseEntity<Order> createOrder(@RequestBody Order order) {
 return ResponseEntity.status(HttpStatus.CREATED)
 .body(orderService.create(order));
 }
}

@RestController
@RequestMapping("/api/users")
public class UserController {
 
 @GetMapping
 public List<User> getAllUsers() {
 return userService.findAll();
 }
 
 @GetMapping("/{id}")
 public ResponseEntity<User> getUserById(@PathVariable Long id) {
 return userService.findById(id)
 .map(ResponseEntity::ok)
 .orElse(ResponseEntity.notFound().build());
 }
}

@RestController
@RequestMapping("/api/products")
public class ProductController {
 
 @GetMapping
 public List<Product> getAllProducts(
 @RequestParam(defaultValue = "0") int page,
 @RequestParam(defaultValue = "10") int size) {
 return productService.findAll(PageRequest.of(page, size));
 }
}

@RestController
@RequestMapping("/api/products")
public class ProductController {
 
 @PostMapping
 public ResponseEntity<Product> createProduct(@Valid @RequestBody Product product) {
 return ResponseEntity.status(HttpStatus.CREATED)
 .body(productService.save(product));
 }
}

@RestController
@RequestMapping("/api/products/{id}")
public class ProductController {
 
 @PutMapping
 public ResponseEntity<Product> updateProduct(
 @PathVariable Long id, 
 @Valid @RequestBody Product product) {
 return ResponseEntity.ok(productService.update(id, product));
 }
}

@RestController
@RequestMapping("/api/products")
public class ProductController {
 
 @DeleteMapping("/{id}")
 public ResponseEntity<Void> deleteProduct(@PathVariable Long id) {
 productService.delete(id);
 return ResponseEntity.noContent().build();
 }
}

@Service
public class OrderService {
 
 @Autowired
 private OrderRepository orderRepository;
 
 @Autowired
 private InventoryService inventoryService;
 
 public Order createOrder(Order order) {
 // Логика создания заказа
 }
}

@Service
@Transactional
public class OrderServiceImpl implements OrderService {
 
 private final OrderRepository orderRepository;
 private final InventoryService inventoryService;
 
 @Autowired
 public OrderServiceImpl(OrderRepository orderRepository, 
 InventoryService inventoryService) {
 this.orderRepository = orderRepository;
 this.inventoryService = inventoryService;
 }
 
 @Override
 public Order createOrder(Order order) {
 return orderRepository.save(order);
 }
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
 
 @Query("SELECT u FROM User u WHERE u.email = :email")
 Optional<User> findByEmail(@Param("email") String email);
 
 @Modifying
 @Query("UPDATE User u SET u.active = false WHERE u.lastLogin < :date")
 void deactivateInactiveUsers(@Param("date") Date date);
}

@Component
public class EmailNotificationService implements NotificationService {
 
 @Autowired
 private JavaMailSender mailSender;
 
 @Value("${app.email.from}")
 private String fromEmail;
 
 @Override
 public void sendNotification(String to, String subject, String content) {
 SimpleMailMessage message = new SimpleMailMessage();
 message.setFrom(fromEmail);
 message.setTo(to);
 message.setSubject(subject);
 message.setText(content);
 mailSender.send(message);
 }
}

@Service
public class PaymentService {
 
 private final PaymentProcessor paymentProcessor;
 
 public PaymentService(@Qualifier("creditCardProcessor") 
 PaymentProcessor paymentProcessor) {
 this.paymentProcessor = paymentProcessor;
 }
}

@Configuration
public class PaymentConfig {
 
 @Bean
 @Primary
 public PaymentProcessor creditCardProcessor() {
 return new CreditCardProcessor();
 }
 
 @Bean
 public PaymentProcessor paypalProcessor() {
 return new PayPalProcessor();
 }
}

@Service
public class DatabaseInitializer {
 
 @Autowired
 private UserRepository userRepository;
 
 @PostConstruct
 public void init() {
 if (userRepository.count() == 0) {
 // Создаем начальные данные
 userRepository.save(new User("admin", "admin@example.com", Role.ADMIN));
 userRepository.save(new User("user", "user@example.com", Role.USER));
 }
 }
}

@Service
public class ConnectionPoolService {
 
 private final ConnectionPool connectionPool;
 
 public ConnectionPoolService() {
 this.connectionPool = new ConnectionPool();
 }
 
 @PreDestroy
 public void cleanup() {
 connectionPool.close();
 }
}

@Service
public class AdminService {
 
 @Secured("ROLE_ADMIN")
 public void deleteUser(Long userId) {
 // Только администраторы могут удалять пользователей
 }
 
 @Secured({"ROLE_ADMIN", "ROLE_MANAGER"})
 public void manageUsers() {
 // Администраторы и менеджеры могут управлять пользователями
 }
}

@Service
public class OrderService {
 
 @PreAuthorize("hasRole('ADMIN') or #userId == authentication.principal.id")
 public Order getOrder(Long userId, Long orderId) {
 return orderRepository.findByIdAndUserId(orderId, userId)
 .orElseThrow(() -> new OrderNotFoundException(orderId));
 }
 
 @PreAuthorize("@orderSecurity.canModifyOrder(#orderId)")
 public void updateOrder(Long orderId, Order order) {
 // Логика обновления заказа
 }
}

@Service
public class DocumentService {
 
 @PostAuthorize("returnObject.owner == authentication.principal.name")
 public Document getDocument(Long documentId) {
 return documentRepository.findById(documentId)
 .orElseThrow(() -> new DocumentNotFoundException(documentId));
 }
}

@Service
public class ReportService {
 
 @RolesAllowed({"ADMIN", "FINANCE_MANAGER"})
 public void generateFinancialReport() {
 // Только администраторы и менеджеры финансов могут генерировать отчеты
 }
}

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

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class MyApplication {
}

@Configuration
@ConfigurationProperties(prefix = "app.database")
public class DatabaseProperties {
 
 private String url;
 private String username;
 private String password;
 private int poolSize;
 
 // Геттеры и сеттеры
}

@Configuration
@ConditionalOnProperty(name = "app.feature.enabled", havingValue = "true")
public class FeatureConfig {
 
 @Bean
 @ConditionalOnMissingBean
 public FeatureService featureService() {
 return new FeatureServiceImpl();
 }
}