Как использовать одну логику для нескольких Bean в Spring

1️⃣ Как кратко ответить

В Spring для использования одной логики в нескольких Bean можно применить подходы, такие как наследование, использование интерфейсов, внедрение общих компонентов через Dependency Injection, а также использование аспектов (AOP) для отделения кросс-секционных задач.

2️⃣ Подробное объяснение темы

В Spring Framework часто возникает необходимость использовать одну и ту же бизнес-логику в нескольких Bean. Это может быть достигнуто несколькими способами, каждый из которых имеет свои преимущества и подходит для различных сценариев.

Наследование

Наследование позволяет создать базовый класс, содержащий общую логику, и затем расширять его в других классах. Это классический подход объектно-ориентированного программирования.

public abstract class BaseService {
    public void commonLogic() {
        // Общая логика
    }
}
​
public class ServiceA extends BaseService {
    // Специфическая логика для ServiceA
}
​
public class ServiceB extends BaseService {
    // Специфическая логика для ServiceB
}

• BaseService содержит общую логику.
• ServiceA и ServiceB наследуют BaseService и могут использовать commonLogic().

Интерфейсы и композиция

Интерфейсы позволяют определить контракт, который должны реализовать классы. Это позволяет использовать композицию для внедрения общей логики.

public interface CommonService {
    void commonLogic();
}
​
public class CommonServiceImpl implements CommonService {
    @Override
    public void commonLogic() {
        // Общая логика
    }
}
​
public class ServiceA {
    private final CommonService commonService;
​
    public ServiceA(CommonService commonService) {
        this.commonService = commonService;
    }
​
    public void execute() {
        commonService.commonLogic();
        // Специфическая логика для ServiceA
    }
}

• CommonService — интерфейс, определяющий общую логику.
• CommonServiceImpl — реализация интерфейса.
• ServiceA использует CommonService через композицию.

Dependency Injection

Spring позволяет внедрять зависимости, что упрощает повторное использование компонентов.

@Component
public class CommonComponent {
    public void commonLogic() {
        // Общая логика
    }
}
​
@Service
public class ServiceA {
    private final CommonComponent commonComponent;
​
    @Autowired
    public ServiceA(CommonComponent commonComponent) {
        this.commonComponent = commonComponent;
    }
​
    public void execute() {
        commonComponent.commonLogic();
        // Специфическая логика для ServiceA
    }
}

• CommonComponent — компонент, содержащий общую логику.
• ServiceA получает CommonComponent через Dependency Injection.

Аспектно-ориентированное программирование (AOP)

AOP позволяет отделить кросс-секционные задачи, такие как логирование, транзакции и безопасность, от бизнес-логики.

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example..*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Executing: " + joinPoint.getSignature().getName());
    }
}
​
@Service
public class ServiceA {
    public void execute() {
        // Специфическая логика для ServiceA
    }
}

• LoggingAspect — аспект, который выполняет логирование перед выполнением методов.
• @Before — указывает, что метод logBefore должен выполняться перед методами, соответствующими указанному выражению.

Заключение

Каждый из этих подходов имеет свои преимущества и может быть использован в зависимости от требований проекта. Наследование и интерфейсы подходят для структурирования бизнес-логики, тогда как AOP лучше всего подходит для кросс-секционных задач. Dependency Injection упрощает управление зависимостями и способствует повторному использованию кода.