控制反转(IoC)与面向切面编程(AOP)
一、控制反转（IoC）
控制反转（IoC）是Spring框架的核心原则之一，旨在将组件间的依赖关系从硬编码中解放出来，交由外部容器来管理。通过IoC，我们可以实现应用程序组件的解耦，提高系统的可维护性和可扩展性。
IoC实现方式：依赖注入（DI）
在Spring中，IoC通常通过依赖注入（DI）来实现。DI是一种设计模式，允许我们在不修改类代码的情况下，将类所依赖的对象或属性在运行时注入到类中。Spring提供了多种DI方式，包括构造器注入、setter注入和字段注入。
示例代码：
假设我们有一个MessageService类依赖于MessageDao类。在没有使用IoC的情况下，我们可能会在MessageService类中直接实例化MessageDao对象。但是，使用Spring的IoC和DI后，我们可以将MessageDao对象的创建和注入交由Spring容器来管理。
首先，定义接口和实现类：
public interface MessageDao {
void saveMessage(String message);
}
public class MessageDaoImpl implements MessageDao {
@Override
public void saveMessage(String message) {
System.out.println("Saving message: " + message);
}
}
public interface MessageService {
void sendMessage(String message);
}
public class MessageServiceImpl implements MessageService {
private MessageDao messageDao;
// 通过setter方法注入MessageDao依赖
public void setMessageDao(MessageDao messageDao) {
this.messageDao = messageDao;
}
@Override
public void sendMessage(String message) {
messageDao.saveMessage(message);
}
}
然后，在Spring配置文件中配置bean和依赖关系：
<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="messageDao" class="com.example.MessageDaoImpl" />
<bean id="messageService" class="com.example.MessageServiceImpl">
<property name="messageDao" ref="messageDao" />
bean>
beans>
最后，在应用程序中使用Spring容器获取MessageService实例：
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
MessageService messageService = context.getBean("messageService", MessageService.class);
messageService.sendMessage("Hello, IoC!"); // 输出：Saving message: Hello, IoC!
二、面向切面编程（AOP）
面向切面编程（AOP）是Spring提供的另一个强大特性，它允许开发者在不改变现有业务逻辑代码的情况下，对程序进行横向切分，添加额外的行为或功能。AOP常用于实现日志记录、事务管理、安全检查等横切关注点。
AOP核心概念：切面（Aspect）、连接点（Join Point）、通知（Advice）和切点（Pointcut）
- 切面定义了哪些连接点会得到通知。
- 连接点是程序执行过程中的一个点，如方法的调用或异常的抛出。
- 通知是要在连接点执行的代码片段。
- 切点定义了哪些连接点会被通知所影响。
在Spring AOP中，你可以定义一个切面（Aspect）来拦截方法调用，并在方法执行前后添加日志记录。下面是一个简单的例子，展示了如何定义一个切面类和方法前后的通知：
首先，你需要添加Spring AOP的依赖到你的项目中。如果你使用的是Maven，可以在pom.xml文件中添加如下依赖：
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-aopartifactId>
dependency>
接下来，定义一个切面类：
package com.example.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LoggingAspect {
private static final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);
// 定义一个切入点表达式，用来确定哪些类需要代理
// 这里的表达式表示com.example.service包下所有类的所有方法
private static final String POINTCUT_EXPRESSION = "execution(* com.example.service.*.*(..))";
// 在方法执行前打印日志
@Before(POINTCUT_EXPRESSION)
public void logBefore(JoinPoint joinPoint) {
logger.info("Before executing method: " + joinPoint.getSignature().getName());
}
// 在方法执行后打印日志，并获取返回值
@AfterReturning(pointcut = POINTCUT_EXPRESSION, returning = "returnValue")
public void logAfterReturning(JoinPoint joinPoint, Object returnValue) {
logger.info("After executing method: " + joinPoint.getSignature().getName() + ", return value: " + returnValue);
}
// 在方法抛出异常时打印日志，并获取异常信息
@AfterThrowing(pointcut = POINTCUT_EXPRESSION, throwing = "exception")
public void logAfterThrowing(JoinPoint joinPoint, Throwable exception) {
logger.error("Exception in method: " + joinPoint.getSignature().getName() + ", exception: " + exception);
}
}
在这个例子中，LoggingAspect类是一个切面类，它定义了三个通知方法：logBefore、logAfterReturning和logAfterThrowing。这些通知方法分别在目标方法执行前、执行后和抛出异常时被调用。切入点表达式POINTCUT_EXPRESSION用来指定哪些类的方法需要被拦截。在这个例子中，它拦截了com.example.service包下所有类的所有方法。你可以根据需要修改这个表达式来拦截特定的方法。