public class Task181024 {
    public static void main(String[] args) {
        ServiceA serviceA = new ServiceA(new ServiceB());
        serviceA.printMessage();
    }
}

interface Service {
    void printMessage();
}

class ServiceA implements Service {
    private final ServiceB serviceB;

    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }

    @Override
    public void printMessage() {
        System.out.println("Message from " + serviceB.getMessage());
    }
}

class ServiceB {
    public String getMessage() {
        return "ServiceB";
    }
}

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

@Component
public class SimpleBean {

    // Конструктор бина
    public SimpleBean() {
        System.out.println("1. Бин SimpleBean создан");
    }

    // Метод, вызываемый после внедрения зависимостей
    @PostConstruct
    public void init() {
        System.out.println("2. Бин SimpleBean инициализирован");
    }

    // Метод, вызываемый перед уничтожением бина
    @PreDestroy
    public void destroy() {
        System.out.println("3. Бин SimpleBean уничтожается");
    }
}

1. Бин SimpleBean создан
2. Бин SimpleBean инициализирован
3. Бин SimpleBean уничтожается

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

@Component
public class LifecycleBean implements InitializingBean, DisposableBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Бин инициализирован через afterPropertiesSet");
    }

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

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

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

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);

        PrototypeBean bean1 = context.getBean(PrototypeBean.class);
        PrototypeBean bean2 = context.getBean(PrototypeBean.class);

        // Два разных экземпляра
        System.out.println(bean1);
        System.out.println(bean2);
    }
}

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

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

        SimpleBean bean = context.getBean(SimpleBean.class);
        System.out.println("Бин использован в приложении");
    }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

public class Task181024_2 {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService service1 = context.getBean(MyService.class);
        MyService service2 = context.getBean(MyService.class);
        System.out.println(service1 == service2);
        System.out.println(service1.getDependencyMessage());
    }
}

class MyService {
    private final Dependency dependency;

    public MyService(Dependency dependency) {
        this.dependency = dependency;
    }

    public String getDependencyMessage() {
        return dependency.getMessage();
    }
}

class Dependency {
    private final String message;

    public Dependency(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

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

    @Bean
    @Scope("prototype")
    public Dependency dependency() {
        return new Dependency("Injected Dependency Message");
    }
}

<bean id="orderService" class="com.example.OrderService">
   <constructor-arg ref="paymentService"/>
</bean>
<bean id="paymentService" class="com.example.PaymentService"/>

@Component
public class OrderService {
    private PaymentService paymentService;

    @Autowired
    public OrderService(@Qualifier("paypalService") PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

<bean id="singletonService" class="com.example.SingletonService" scope="singleton"/>
<bean id="prototypeService" class="com.example.PrototypeService" scope="prototype"/>

@Component
public class LifecycleBean {
    @PostConstruct
    public void init() {
        System.out.println("Bean is initialized");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("Bean is destroyed");
    }
}

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.28</version>
    </dependency>
</dependencies>

dependencies {
    implementation 'org.springframework:spring-context:5.3.28'
}

<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">

    <bean id="paymentService" class="com.example.PaymentService"/> естественно путь укажите свой
    <bean id="orderService" class="com.example.OrderService">
        <constructor-arg ref="paymentService"/>
    </bean>
</beans>
Здесь мы определили два бина: OrderService и PaymentService. В OrderService внедряется зависимость через конструктор.

package com.example;

public class PaymentService {
    public void processPayment() {
        System.out.println("Payment processed.");
    }
}

package com.example;

public class OrderService {
    private PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Order placed.");
        paymentService.processPayment();
    }
}

package com.example;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        OrderService orderService = context.getBean("orderService", OrderService.class);
        orderService.placeOrder();
    }
}
Теперь при запуске приложения Spring контейнер создаст объекты и внедрит зависимости согласно XML конфигурации.

Order placed.
Payment processed.

package com.example;

import org.springframework.stereotype.Component;

@Component
public class PaymentService {
    public void processPayment() {
        System.out.println("Payment processed.");
    }
}

package com.example;

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

@Component
public class OrderService {
    private PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Order placed.");
        paymentService.processPayment();
    }
}

package com.example;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.example") - не забудьте верно указать директорию которую будет сканировать Spring для поиска бинов
public class AppConfig {
}

package com.example;

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

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        OrderService orderService = context.getBean(OrderService.class);
        orderService.placeOrder();
    }
}

Order placed.
Payment processed.

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

@Component
public class SingletonService {
    public void doSomething() {
        System.out.println("Singleton instance: " + this);
    }
}

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

@Component
@Scope("prototype")
public class PrototypeService {
    public void doSomething() {
        System.out.println("Prototype instance: " + this);
    }
}

        // Получение синглтон-бинов (должны быть одинаковыми)
        SingletonService singleton1 = context.getBean(SingletonService.class);
        SingletonService singleton2 = context.getBean(SingletonService.class);

        // Получение прототип-бинов (должны быть разными)
        PrototypeService prototype1 = context.getBean(PrototypeService.class);
        PrototypeService prototype2 = context.getBean(PrototypeService.class);

        // Проверка синглтон-бинов
        System.out.println("Checking Singleton beans:");
        if (singleton1 == singleton2) {
            System.out.println("Singleton1 and Singleton2 are the same instance.");
        } else {
            System.out.println("Singleton1 and Singleton2 are different instances.");
        }

        // Проверка прототип-бинов
        System.out.println("\nChecking Prototype beans:");
        if (prototype1 == prototype2) {
            System.out.println("Prototype1 and Prototype2 are the same instance.");
        } else {
            System.out.println("Prototype1 and Prototype2 are different instances.");
        }

        // Вывод информации о бин-объектах
        System.out.println("\nSingleton bean instances:");
        singleton1.doSomething();
        singleton2.doSomething();

        System.out.println("\nPrototype bean instances:");
        prototype1.doSomething();
        prototype2.doSomething();

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

@Component
public class LifecycleBean {

    @PostConstruct
    public void init() {
        System.out.println("Bean initialized.");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("Bean destroyed.");
    }
}

<bean id="lifecycleBean" class="com.example.LifecycleBean" init-method="init" destroy-method="destroy"/>

public class OrderService {
    private PaymentService paymentService;

    @Autowired
    public void setPaymentService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Order placed.");
        paymentService.processPayment();
    }
}

@Component
public class PaymentFactory {
    public PaymentService createPaymentService(String type) {
        if (type.equals("paypal")) {
            return new PayPalService();
        } else {
            return new CreditCardService();
        }
    }
}

public interface MessageService {
    void sendMessage(String message);
}

public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Отправка Email: " + message);
    }
}

public class MessageProcessor {
    private MessageService messageService;

    // Внедрение зависимости через сеттер
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

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

<?xml version="1.0" encoding="UTF-8"?>
<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">

    <!-- Определение бина для сервиса отправки сообщений -->
    <bean id="emailService" class="com.example.EmailService"/>

    <!-- Определение бина для процессора сообщений с внедрением зависимости -->
    <bean id="messageProcessor" class="com.example.MessageProcessor">
        <property name="messageService" ref="emailService"/>
    </bean>
</beans>
Как это работает?
<bean id="emailService">: здесь определяется бин для класса EmailService. Контейнер Spring создаст объект этого класса при запуске.
<bean id="messageProcessor">: бин для MessageProcessor, в котором указана зависимость messageService. С помощью элемента <property> контейнер внедрит объект EmailService в MessageProcessor.

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        // Загрузка XML-конфигурации
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        // Получение бина messageProcessor
        MessageProcessor processor = (MessageProcessor) context.getBean("messageProcessor");

        // Использование бина
        processor.processMessage("Привет, Spring!");
    }
}

<bean id="emailService" class="com.example.EmailService"/>

<bean id="messageProcessor" class="com.example.MessageProcessor">
    <constructor-arg ref="emailService"/>
</bean>
В данном случае зависимость будет передана через конструктор класса MessageProcessor.

<bean id="listBean" class="java.util.ArrayList">
    <constructor-arg>
        <list>
            <value>Item 1</value>
            <value>Item 2</value>
        </list>
    </constructor-arg>
</bean>

<bean id="emailService" class="com.example.EmailService" scope="prototype"/>
singleton (по умолчанию) — один и тот же бин создается для всего приложения.
prototype — новый экземпляр бина создается каждый раз при обращении.

import java.util.*;

public class Task211024_1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "orange"));
        list.removeIf(s -> s.startsWith("b"));
        list.replaceAll(String::toUpperCase);
        System.out.println(list);
    }
}