Spring Framework

@Configuration
@EnableAsync
public class AsyncConfig {}

@Service
public class EmailService {
    @Async
    public CompletableFuture<Boolean> sendEmail(String to, String msg) {
        // Executes asynchronously in worker thread pool
        return CompletableFuture.completedFuture(true);
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(Customizer.withDefaults())
            .build();
    }
}

<!-- web.xml architecture -->
<!-- 1. Root Context: services & DAOs -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 2. Child Context: MVC controllers -->
<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>

@Configuration // Full mode (CGLIB proxied)
public class AppConfig {
    @Bean public Engine engine() { return new Engine(); }
    @Bean public Car car() {
        return new Car(engine()); // Calls CGLIB proxy, returning singleton Engine
    }
}

@Service
public class ProductService {
    @Cacheable(value = "products", key = "#id")
    public Product getProduct(Long id) { return productDao.findById(id); }

    @CachePut(value = "products", key = "#product.id")
    public Product updateProduct(Product product) { return productDao.save(product); }

    @CacheEvict(value = "products", key = "#id")
    public void deleteProduct(Long id) { productDao.delete(id); }
}

@Component @Primary
public class DefaultEmailService implements MessageService {}

@Component("sms")
public class SmsService implements MessageService {}

// Injection:
@Autowired
@Qualifier("sms") // Overrides @Primary and injects SmsService
private MessageService service;

@Configuration
public class ThirdPartyConfig {
    @Bean // Creates bean from external library class
    public ObjectMapper objectMapper() {
        return new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    }
}

@RestController
public class UserController {
    @PostMapping("/users/{deptId}")
    public User createUser(
        @PathVariable Long deptId,
        @RequestParam(defaultValue = "true") boolean active,
        @Valid @RequestBody UserDTO dto
    ) { return userService.create(deptId, active, dto); }
}

public class AuditInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object handler) {
        System.out.println("Intercepted request: " + req.getRequestURI());
        return true; // continue pipeline
    }
}

@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(ResourceNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public ErrorResponse handleNotFound(ResourceNotFoundException ex) {
        return new ErrorResponse(404, ex.getMessage());
    }
}

// Event definition
public record OrderPlacedEvent(Long orderId) {}

@Service
public class OrderService {
    @Autowired private ApplicationEventPublisher publisher;
    public void createOrder() {
        publisher.publishEvent(new OrderPlacedEvent(101L));
    }
}

@Component
public class NotificationListener {
    @EventListener
    public void onOrderPlaced(OrderPlacedEvent event) {
        System.out.println("Send email for order: " + event.orderId());
    }
}

@Repository
public class UserRepository {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public User findById(Long id) {
        return jdbcTemplate.queryForObject(
            "SELECT id, username FROM users WHERE id = ?",
            (rs, rowNum) -> new User(rs.getLong("id"), rs.getString("username")),
            id
        );
    }
}

@Component
public class TaxService {
    @Value("#{systemProperties['user.country']}")
    private String defaultCountry;

    @Value("#{orderService.calculateDiscount(100)}")
    private double calculatedDiscount;
}

@Component
public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory factory) {
        // Inspect or modify bean definition metadata
        BeanDefinition def = factory.getBeanDefinition("myService");
        def.setScope("prototype");
    }
}

@Repository // Automatically translates vendor SQLExceptions to Spring DataAccessException
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

@Controller
public class HomeController {
    @GetMapping("/welcome")
    public String home(Model model) {
        model.addAttribute("message", "Welcome to Spring MVC");
        return "homeView"; // ViewResolver maps to /WEB-INF/views/homeView.jsp
    }
}

@Transactional(isolation = Isolation.REPEATABLE_READ)
public Balance getAccountBalance(Long id) {
    return accountDao.findById(id);
}

@Service
public class AccountService {
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void processAuditLog(String action) {
        // Executes in its own isolated transaction independently
        auditDao.save(action);
    }
}

@Service
public class OrderService {
    @Autowired
    private OrderService self; // Self-injected proxy reference

    public void placeOrder() {
        // this.saveInternal(); // BYPASSES TRANSACTION!
        self.saveInternal();    // Correct: Hits the proxy interceptor
    }
    @Transactional
    public void saveInternal() { /* DB operations */ }
}

// Enable explicit CGLIB class-based proxying:
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AopConfig {}

@Aspect
@Component
public class LoggingAspect {
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethods() {}

    @Around("serviceMethods()")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object proceed = joinPoint.proceed();
        System.out.println(joinPoint.getSignature() + " took " + (System.currentTimeMillis() - start) + "ms");
        return proceed;
    }
}

@Service
public class ServiceA {
    private final ServiceB serviceB;
    // @Lazy breaks circular constructor injection deadlock:
    public ServiceA(@Lazy ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

@Service
public class CustomerService {
    private final CustomerRepository repository; // Immutable & final
    // Injected safely through constructor:
    public CustomerService(CustomerRepository repository) {
        this.repository = Objects.requireNonNull(repository);
    }
}

@Service
public class NotificationService {
    @Autowired
    @Qualifier("smsSender") // Matches specific bean name
    private MessageSender messageSender;

    @Resource(name = "emailSender") // JSR-250 injection by name
    private MessageSender emailSender;
}

@Service
public class SingletonOrderService {
    @Autowired
    private ObjectProvider<PrototypeCart> cartProvider;

    public void processNewOrder() {
        PrototypeCart cart = cartProvider.getObject(); // Fresh prototype instance every time!
        cart.checkout();
    }
}

@Component
@Scope("prototype")
public class TaskToken {
    private final UUID id = UUID.randomUUID();
}

@Component
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public class AppService {}

@Component
public class DatabaseConnector implements InitializingBean, DisposableBean {
    @PostConstruct
    public void init() { System.out.println("1. PostConstruct"); }
    @Override
    public void afterPropertiesSet() { System.out.println("2. afterPropertiesSet"); }
    @PreDestroy
    public void cleanup() { System.out.println("3. PreDestroy"); }
    @Override
    public void destroy() { System.out.println("4. destroy"); }
}

// BeanFactory: Basic & Lazy loading
// DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

// ApplicationContext: Advanced & Eager pre-instantiation
ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
UserService service = ctx.getBean(UserService.class);

@Service
public class OrderService {
    private final PaymentProcessor paymentProcessor;
    // Constructor Dependency Injection:
    public OrderService(PaymentProcessor paymentProcessor) {
        this.paymentProcessor = paymentProcessor;
    }
}

// Spring Framework: Explicit Java Config
@Configuration
@ComponentScan("com.example")
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserServiceImpl(userDao());
    }
    @Bean
    public UserDao userDao() {
        return new UserDaoImpl();
    }
}