Spring 在业务场景使用方式（IOC实现策略模式、AOP实现拦截、Event解耦等）
引言
Spring 框架作为 Java 开发中的重要利器，不仅提供了依赖注入（DI）和面向切面编程（AOP）等核心特性，还提供了丰富的功能和组件，可以应对各种业务场景。本文将通过示例详细解析 Spring 在业务中的常见应用场景和用法，包括使用 IoC 实现策略模式、AOP 实现日志切面、监听器实现业务异步解耦，以及其他常见用法。
1. 使用 IoC 实现策略模式
很多时候，面对不同的业务场景需要不同的业务逻辑，为了避免使用if-else导致代码臃肿，不具备扩展性，我们一般会使用策略模式。策略模式是一种常见的设计模式，它定义了一系列的算法，并将每个算法封装起来，使它们可以相互替换。在 Spring 中，可以通过 IoC 容器来实现策略模式，使用法更加灵活方便。
通过实现InitializingBean的afterPropertiesSet方法完成bean的初始化， 示例代码：
// 定义策略接口
public interface PaymentStrategy extends InitializingBean {
void pay(BigDecimal amount);
PayType getPayType();
@Override
default void afterPropertiesSet() throws Exception {
PayFactory.register(getPayType(), this);
}
}
// 实现具体的支付策略
@Component
public class CreditCardPayment implements PaymentStrategy {
@Override
public void pay(BigDecimal amount) {
System.out.println("使用信用卡支付：" + amount);
}
@Override
public PayType getPayType() {
return PayType.CREDIT;
}
}
@Component
public class CashPayment implements PaymentStrategy {
@Override
public void pay(BigDecimal amount) {
System.out.println("使用现金支付：" + amount);
}
@Override
public PayType getPayType() {
return PayType.CASH;
}
}
// 创建和获取bean的类
public class PayFactory {
private static final Map<PayType, PaymentStrategy> PAY_MAP = new HashMap<>();
public static void register(PayType payType, PaymentStrategy strategy) {
PAY_MAP.put(payType, strategy);
}
public static PaymentStrategy getStrategy(PayType payType) {
return PAY_MAP.get(payType);
}
}
// 使用策略的业务类
@Test
void strategy() {
PaymentStrategy paymentStrategy = PayFactory.getStrategy(PayType.CASH);
paymentStrategy.pay(BigDecimal.ONE);
}
2. 使用 AOP 实现拦截
在开发过程中，经常需要使用AOP将与业务无关的操作进行切面处理，以便于专注于业务代码的开发和维护。通常是通过注解和AOP结合，实现思路就是先定义一个注解，然后通过AOP去发现使用该注解的类或方法，增加额外的逻辑，如参数校验，缓存，日志等。
参数校验
代码示例：
// 定义一个注解作用于方法
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ParamCheck {
}
// 编写一个切面，做参数校验处理
@Aspect
@Component
public class ParamCheckAspect {
@Before("@annotation(com.example.ParamCheck)")
public void beforeMethodExecution(JoinPoint joinPoint) {
Object[] args = joinPoint.getArgs();
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
Method method = methodSignature.getMethod();
ParamCheck annotation = method.getAnnotation(ParamCheck.class);
if (annotation != null) {
// 进行参数校验逻辑
for (Object arg : args) {
if (arg == null) {
throw new IllegalArgumentException("参数不能为空");
}
// 其他校验逻辑...
}
}
}
}
缓存
定义一个注解用于标记缓存的方法，value是缓存的唯一标识，可通过expiration设置缓存过期时间。
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Cacheable {
String value() default "";
long expiration() default 60;
}
定义一个切面获取注解标注的方法，获取注解信息，如果缓存中有值，直接返回。如果缓存中没有或者过期，先执行方法，再将结果进行缓存。如果需要根据方法入参进行缓存对应的数据，可以自行扩展。
@Aspect
@Component
public class CacheAspect {
private final Map<String, CacheEntry> cache = new HashMap<>();
@Around("@annotation(com.example.Cacheable) && execution(* *(..))")
public Object cacheMethodExecution(ProceedingJoinPoint joinPoint) throws Throwable {
Cacheable annotation = getCacheableAnnotation(joinPoint);
String cacheKey = annotation.value();
if (!cache.containsKey(cacheKey) || cache.get(cacheKey).isExpired()) {
Object result = joinPoint.proceed();
long expirationTime = System.currentTimeMillis() + annotation.expiration() * 1000;
cache.put(cacheKey, new CacheEntry(result, expirationTime));
}
return cache.get(cacheKey).getResult();
}
// 获取Cacheable注解
private Cacheable getCacheableAnnotation(ProceedingJoinPoint joinPoint) {
return joinPoint.getTarget().getClass().getMethod(getMethodName(joinPoint)).getAnnotation(Cacheable.class);
}
private String getMethodName(ProceedingJoinPoint joinPoint) {
return joinPoint.getSignature().getName();
}
// 存放缓存信息的对象，包括缓存结果和缓存过期时间
private static class CacheEntry {
private final Object result;
private final long expirationTime;
public CacheEntry(Object result, long expirationTime) {
this.result = result;
this.expirationTime = expirationTime;
}
public Object getResult() {
return result;
}
public boolean isExpired() {
return System.currentTimeMillis() > expirationTime;
}
}
}
日志打印
对于日志打印，实现也是类似，定义一个注解用于AOP发现，使用前置通知和返回通知处理日志信息。代码示例：
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Loggable {
}
@Aspect
@Component
public class LoggingAspect {
private final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);
@Pointcut("@annotation(com.example.Loggable)")
public void loggableMethods() {}
@Before("loggableMethods()")
public void logBefore(JoinPoint joinPoint) {
logger.info("Before executing method: {}", joinPoint.getSignature().getName());
}
@AfterReturning(pointcut = "loggableMethods()", returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {
logger.info("After executing method: {}, result: {}", joinPoint.getSignature().getName(), result);
}
}
3. 使用监听器实现业务异步解耦
监听器（Listener）是 Spring 框架中的重要组件，可以实现事件驱动的编程模式，用于解耦业务逻辑。举个例子：订单从确认到支付成功，需要触发财务记账，仓库扣减等操作。如果订单状态的修改需要同步处理下游的业务，这对订单业务非常不友好，对于这种情况，就需要Event异步解耦。
示例代码：
// 支付成功发布事件
@Component
public class PayEventPublishService {
@Autowired
private ApplicationEventPublisher publisher;
public void publish() {
// 发布事件
System.out.println("支付成功");
// 支付信息
PayEvent event = new PayEvent("34", 4, true);
publisher.publishEvent(event);
System.out.println("修改订单状态");
}
}
// 记账监听
@Component
public class BillListenerService {
@EventListener
public void BillListen(PayEvent payEvent) {
// 记账逻辑
System.out.println("开始记账,金额扣减"+ payEvent.getMoney());
}
}
// 仓库监听
@Component
public class WarehouseListenerService {
@EventListener
public void WarehouseListen(PayEvent payEvent) {
// 仓库扣减逻辑
System.out.println("仓库扣减"+ payEvent.getCount());
}
}
4. 使用 Spring Data JPA 进行数据访问
Spring Data JPA 是 Spring 框架的一部分，它提供了简化数据访问的方式，可以轻松地与数据库进行交互。
示例代码：
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
List<User> findByLastName(String lastName);
}
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
public List<User> findByLastName(String lastName) {
return userRepository.findByLastName(lastName);
}
}
结语
通过以上示例，我们详细解析了 Spring 在业务中的常见应用场景和用法，包括使用 IoC 实现策略模式、AOP 实现日志切面、监听器实现业务异步解耦，以及使用 Spring Data JPA 进行数据访问等。这些功能和组件能够帮助我们简化开发、提高代码质量和可维护性，是 Java 开发中不可或缺的利器。
希望本文能够帮助读者更好地理解和应用 Spring 框架，在实际项目中发挥其最大的作用。