public class Task221024_1 {
    public static void main(String[] args) {
        System.out.println(Status.PENDING.getDescription());
        System.out.println(Status.APPROVED.ordinal());
    }
}

enum Status {
    PENDING("Waiting for approval"),
    APPROVED("Approved by admin"),
    REJECTED("Request denied");

    private String description;

    Status(String description) {
        this.description = description;
    }

    public String getDescription() {
        return description;
    }
}

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.stereotype.Component;

@Component
public class MessageService {

    public MessageService() {
        System.out.println("Создание бина MessageService");
    }

    @PostConstruct
    public void init() {
        System.out.println("Инициализация бина MessageService");
    }

    public void sendMessage(String message) {
        System.out.println("Отправка сообщения: " + message);
    }

    @PreDestroy
    public void destroy() {
        System.out.println("Уничтожение бина MessageService");
    }
}

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

@Component
public class CustomService implements InitializingBean, DisposableBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Инициализация бина CustomService через afterPropertiesSet");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("Уничтожение бина CustomService через destroy");
    }
}

<bean id="messageService" class="com.example.MessageService" 
      init-method="init" destroy-method="destroy"/>
Здесь init-method и destroy-method указывают на методы, которые будут вызваны при инициализации и уничтожении бина соответственно.

@Component
@Scope("prototype")
public class PrototypeBean {

    public PrototypeBean() {
        System.out.println("Создан новый экземпляр PrototypeBean");
    }
}
При каждом запросе PrototypeBean будет создаваться новый объект.

AnnotationConfigApplicationContext context = 
        new AnnotationConfigApplicationContext(AppConfig.class);

MessageService service = context.getBean(MessageService.class);
service.sendMessage("Привет, Spring!");

context.close();
Метод close() завершает работу контекста и вызывает методы уничтожения всех бинов.

public class Task221024_2 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig221024.class);
        MyBean myBean = context.getBean(MyBean.class);
        myBean.doSomething();
        context.close();
    }
}

@Component
class MyBean implements InitializingBean, DisposableBean {

    public MyBean() {
        System.out.println("Constructor called");
    }

    @Override
    public void afterPropertiesSet() {
        System.out.println("afterPropertiesSet (init) called");
    }

    public void doSomething() {
        System.out.println("Doing something");
    }

    @Override
    public void destroy() {
        System.out.println("destroy (cleanup) called");
    }
}

@Configuration
@ComponentScan()
class AppConfig221024 {}

import org.springframework.stereotype.Component;

@Component
public class MessageService {
    public MessageService() {
        System.out.println("Создан объект MessageService");
    }

    public void sendMessage(String message) {
        System.out.println("Отправка сообщения: " + message);
    }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        // Получаем бин MessageService дважды
        MessageService service1 = context.getBean(MessageService.class);
        service1.sendMessage("Привет, Spring!");

        MessageService service2 = context.getBean(MessageService.class);
        service2.sendMessage("Второе сообщение");

        // Проверим, что оба объекта одинаковы
        System.out.println(service1 == service2);  // true
    }
}
В данном случае Spring создает только один экземпляр MessageService, и каждый раз при запросе через context.getBean() возвращается один и тот же объект. Сообщение в консоли "Создан объект MessageService" будет выведено только один раз.

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class MessageService {
    public MessageService() {
        System.out.println("Создан новый экземпляр MessageService");
    }

    public void sendMessage(String message) {
        System.out.println("Отправка сообщения: " + message);
    }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        // Получаем бин MessageService дважды
        MessageService service1 = context.getBean(MessageService.class);
        service1.sendMessage("Привет, Spring!");

        MessageService service2 = context.getBean(MessageService.class);
        service2.sendMessage("Второе сообщение");

        // Проверим, что оба объекта разные
        System.out.println(service1 == service2);  // false
    }
}
В этом случае Spring создает новый экземпляр MessageService каждый раз при вызове context.getBean(). Вывод в консоли будет включать два сообщения "Создан новый экземпляр MessageService", указывающие на то, что создаются два разных объекта.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Lookup;
import org.springframework.stereotype.Component;

@Component
public class SingletonService {

    @Autowired
    private ObjectFactory<MessageService> messageServiceFactory;

    public void processMessage(String message) {
        MessageService messageService = messageServiceFactory.getObject();
        messageService.sendMessage(message);
    }
}
Здесь метод messageServiceFactory.getObject() создает новый экземпляр MessageService каждый раз, когда вызывается метод processMessage().

public class Task231024_1 {
    public static void main(String[] args) {
        int i = 5;
        while (i-- > 0) {
            if (i == 2) {
                continue;
            }
            System.out.print(i + " ");
        }
    }
}

public class MessageServiceFactory {

    public static MessageService createMessageService(String type) {
        if ("email".equalsIgnoreCase(type)) {
            return new EmailService();
        } else if ("sms".equalsIgnoreCase(type)) {
            return new SmsService();
        }
        throw new IllegalArgumentException("Неизвестный тип сервиса: " + type);
    }
}

<bean id="messageService" class="com.example.MessageServiceFactory" factory-method="createMessageService">
    <constructor-arg value="email"/>
</bean>
В этом примере бин MessageService создается с помощью фабрики, и мы можем легко изменять его тип без необходимости изменения основного кода.

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class ServiceLocatorExample {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        // Получаем бин по его типу
        MessageService service = context.getBean(MessageService.class);
        service.sendMessage("Сообщение через Service Locator");
    }
}
Паттерн Service Locator хорош, когда необходимо динамически получать зависимости, но следует быть осторожным, чтобы не злоупотреблять этим паттерном, так как он может нарушить принципы инверсии управления.

@Component
public class MessageService {
    private final NotificationService notificationService;

    @Autowired
    public MessageService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void sendMessage(String message) {
        notificationService.notify(message);
    }
}
Здесь зависимость NotificationService внедряется в конструктор класса MessageService.

@Component
public class MessageService {
    private NotificationService notificationService;

    @Autowired
    public void setNotificationService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void sendMessage(String message) {
        notificationService.notify(message);
    }
}

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void logBeforeMethod(JoinPoint joinPoint) {
        System.out.println("Вызов метода: " + joinPoint.getSignature().getName());
    }
}
Здесь мы создаём аспект (Aspect), который использует прокси для добавления логирования перед вызовом любого метода в указанном пакете.

@Autowired
private JdbcTemplate jdbcTemplate;

public void addUser(String name, int age) {
    String sql = "INSERT INTO users (name, age) VALUES (?, ?)";
    jdbcTemplate.update(sql, name, age);
}
Здесь JdbcTemplate инкапсулирует шаблонный метод для выполнения SQL-запросов, а детали (вроде обработки исключений или управления транзакциями) обрабатываются внутри JdbcTemplate.

// Определение события
public class UserCreatedEvent extends ApplicationEvent {
    private String username;

    public UserCreatedEvent(Object source, String username) {
        super(source);
        this.username = username;
    }

    public String getUsername() {
        return username;
    }
}

// Публикация события
@Component
public class UserService {

    @Autowired
    private ApplicationEventPublisher eventPublisher;

    public void createUser(String username) {
        System.out.println("Создание пользователя: " + username);
        eventPublisher.publishEvent(new UserCreatedEvent(this, username));
    }
}

// Обработчик события
@Component
public class UserEventListener {

    @EventListener
    public void handleUserCreated(UserCreatedEvent event) {
        System.out.println("Пользователь создан: " + event.getUsername());
    }
}
Здесь UserService публикует событие UserCreatedEvent, которое обрабатывается компонентом UserEventListener.

public interface NotificationStrategy {
    void send(String message);
}

@Component
public class EmailNotification implements NotificationStrategy {
    public void send(String message) {
        System.out.println("Отправка email: " + message);
    }
}

@Component
public class SmsNotification implements NotificationStrategy {
    public void send(String message) {
        System.out.println("Отправка SMS: " + message);
    }
}

@Component
public class NotificationService {

    private final NotificationStrategy notificationStrategy;

    @Autowired
    public NotificationService(NotificationStrategy notificationStrategy) {
        this.notificationStrategy = notificationStrategy;
    }

    public void sendNotification(String message) {
        notificationStrategy.send(message);
    }
}
В этом примере стратегия уведомлений может быть легко изменена путем внедрения различных реализаций интерфейса NotificationStrategy.

import org.springframework.context.annotation.*;

@Configuration
class Config {
    @Bean
    @Scope("singleton")
    public MyBean2310 singletonBean() {
        return new MyBean2310("singleton");
    }

    @Bean
    @Scope("prototype")
    public MyBean2310 prototypeBean() {
        return new MyBean2310("prototype");
    }
}

class MyBean2310 {
    public MyBean2310(String scope) {
        System.out.println("MyBean created for "+scope);
    }
}

public class Task231024_2 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);

        MyBean2310 singleton1 = context.getBean("singletonBean", MyBean2310.class);
        MyBean2310 singleton2 = context.getBean("singletonBean", MyBean2310.class);

        MyBean2310 prototype1 = context.getBean("prototypeBean", MyBean2310.class);
        MyBean2310 prototype2 = context.getBean("prototypeBean", MyBean2310.class);

        context.close();
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class NotificationService {

    private final MessageService messageService;

    // Внедрение зависимости через конструктор
    @Autowired
    public NotificationService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void sendNotification(String message) {
        messageService.sendMessage(message);
    }
}

@Component
public class MessageService {

    public void sendMessage(String message) {
        System.out.println("Отправка сообщения: " + message);
    }
}
В данном примере класс NotificationService получает зависимость MessageService через конструктор. Аннотация @Autowired сообщает Spring, что нужно автоматически внедрить MessageService в этот конструктор.

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        // Получаем бин NotificationService
        NotificationService notificationService = context.getBean(NotificationService.class);

        // Используем сервис для отправки уведомления
        notificationService.sendNotification("Привет, Spring!");
    }
}

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- Определение бина MessageService -->
    <bean id="messageService" class="com.example.MessageService"/>

    <!-- Определение бина NotificationService с внедрением через конструктор -->
    <bean id="notificationService" class="com.example.NotificationService">
        <constructor-arg ref="messageService"/>
    </bean>
</beans>
При такой конфигурации Spring автоматически передаст бин messageService в конструктор бина notificationService.