目录

简介

IoC&DI

纯注解实现

定义 Bean

Bean 的作用范围和生命周期管理

依赖注入

管理第三方 Bean

为第三方 Bean 注入资源（例如数据库连接池）

AOP

纯注解实现

工作流程

切面示例

切入点表达式示例

通知类型示例

@Before（前置通知）

@After（后置通知）

@AfterReturning（返回通知）

@AfterThrowing（异常通知）

@Around（环绕通知）

---

简介

Spring Framework 是一个开源的 Java 企业级应用程序开发框架，它提供了一系列的库和工具，帮助开发人员构建高效、可维护、易扩展的企业级应用程序。Spring 框架是由 Rod Johnson 和 Juergen Hoeller 等人创建的，第一个版本发布于2002年。

Spring Framework 的核心是 IoC（Inversion of Control）容器和 AOP（Aspect Oriented Programming）框架。IoC 容器用于管理 Java 对象（即 Bean），通过依赖注入的方式实现对象之间的解耦。AOP 框架提供了对切面编程的支持，允许开发人员在不修改核心代码的情况下，通过切面技术实现横切关注点的功能，例如事务管理、安全检查等。

IoC&DI

IoC（Inversion of Control，控制反转）和 DI（Dependency Injection，依赖注入）是 Spring Framework 的核心概念之一，它们是通过解耦来提高代码的可维护性和可扩展性。

IoC 意味着对于一个对象的创建和管理不再由该对象自己来决定，而是由外部容器来控制。换句话说，控制权被反转了。在 Spring 中，IoC 通常指的是 Spring IoC 容器，它管理了应用程序中的 Java 对象，并负责调用它们的生命周期方法。

DI 是 IoC 的一种实现方式，它是指将依赖关系从代码中移除，通过容器来注入所需的依赖项。依赖项可以是其他对象、配置属性或者资源等。Spring 中的 DI 通常是通过构造函数注入、Setter 方法注入或者字段注入来实现的。

举例：

// 定义数据访问接口 UserDao，使用 @Repository 注解标记为持久化层组件
@Repository
public interface UserDao {void saveUser(User user);
}// 实现 UserDao 接口，使用 @Repository 注解标记为持久化层组件
@Repository
public class UserDaoImpl implements UserDao {@Overridepublic void saveUser(User user) {// 实现具体的数据库保存逻辑System.out.println("Save user: " + user.getName());}
}// 定义服务类 UserService，使用 @Service 注解标记为业务层组件
@Service
public class UserService {// 使用 @Autowired 注解自动装配 UserDao 对象@Autowiredprivate UserDao userDao;public void saveUser(User user) {userDao.saveUser(user);}
}// 创建 Spring 配置类 AppConfig，用于配置 IoC 容器和依赖注入
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {// 无需手动定义 bean，因为使用了 @ComponentScan 注解自动扫描并注册组件
}// 编写测试代码，验证 IoC 和 DI 的效果
public class Main {public static void main(String[] args) {// 创建 Spring IoC 容器，并加载 AppConfig 配置类AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);// 从容器中获取 UserService beanUserService userService = context.getBean(UserService.class);// 创建一个 User 对象User user = new User("John Doe");// 调用 UserService 的方法保存用户userService.saveUser(user);}
}

纯注解实现

定义 Bean

@Component // 使用 @Component 注解将该类标记为 Spring 管理的组件
public class UserService {// 类的具体实现...
}

Bean 的作用范围和生命周期管理

@Component // 默认为单例作用域，相当于 @Scope("singleton")
public class MySingletonBean {// 类的具体实现...
}@Component
@Scope("prototype") // 指定为原型（多例）作用域
public class MyPrototypeBean {// 类的具体实现...
}@Component
public class MyBeanLifecycle implements InitializingBean, DisposableBean {// 在初始化之前执行的方法@PostConstructpublic void init() {// 初始化操作...}// 在销毁之前执行的方法@PreDestroypublic void destroy() {// 销毁操作...}// 实现 InitializingBean 接口的方法@Overridepublic void afterPropertiesSet() throws Exception {// 初始化操作...}// 实现 DisposableBean 接口的方法@Overridepublic void destroy() throws Exception {// 销毁操作...}
}

依赖注入

@Component
public class UserService {@Autowired // 自动装配依赖对象private UserRepository userRepository;// 类的具体实现...
}

管理第三方 Bean

@Configuration
public class MyConfig {@Bean // 将第三方类库的对象声明为一个 Spring 管理的 beanpublic ThirdPartyService thirdPartyService() {return new ThirdPartyService();}
}@Component
public class MyComponent {@Autowiredprivate ThirdPartyService thirdPartyService;// 类的具体实现...
}

为第三方 Bean 注入资源（例如数据库连接池）

@Configuration
public class DataSourceConfig {@Beanpublic DataSource dataSource() {// 创建和配置数据源对象...}@Beanpublic JdbcTemplate jdbcTemplate(DataSource dataSource) {// 使用第三方 bean，并注入资源return new JdbcTemplate(dataSource);}
}

AOP

Spring 的 AOP（面向切面编程）是一种基于代理机制的编程方式，它可以在不改变原有代码逻辑的情况下，通过动态地将额外的行为织入到程序中。这些额外的行为通常包括日志记录、性能监控、事务管理等与业务功能无关的横切关注点。

在 Spring 中，AOP 可以通过配置或注解来实现。其核心是定义切面（Aspect），切面定义了哪些方法需要被拦截，以及拦截后要执行什么逻辑。而切面具体实现的逻辑则由通知（Advice）来完成。通知可以在目标方法执行前、执行后或者抛出异常时执行，通常采用环绕、前置、后置和异常拦截四种类型。

举例：

@Aspect // 声明该类为切面
@Component
public class LogAspect {@Pointcut("execution(* com.example.service.*.*(..))")private void serviceMethod() {} // 定义切点，匹配 com.example.service 包下的所有方法@Before("serviceMethod()")public void logBefore(JoinPoint joinPoint) {String methodName = joinPoint.getSignature().getName();System.out.println("[LogAspect] Before method: " + methodName);}@AfterReturning("serviceMethod()")public void logAfterReturning(JoinPoint joinPoint) {String methodName = joinPoint.getSignature().getName();System.out.println("[LogAspect] AfterReturning method: " + methodName);}
}

纯注解实现

工作流程

1. 定义切面（Aspect）：通过使用 @Aspect 注解声明一个类为切面，并在该类中定义切入点和通知。
2. 定义切入点（Pointcut）：使用 @Pointcut 注解定义一个切入点表达式，指定哪些方法需要被拦截。
3. 定义通知（Advice）：使用 @Before、@After、@AfterReturning、@AfterThrowing 或       @Around 注解定义通知类型，并编写相应的逻辑。
4. 将切面和目标对象进行织入：Spring 容器会自动检测并织入切面到匹配的目标对象中。
5.执行增强逻辑：在目标方法执行前、执行后或抛出异常时，触发相应的通知进行增强处理

切面示例

@Aspect
@Component
public class LoggingAspect {@Pointcut("execution(* com.example.service.*.*(..))")private void serviceMethod() {}@Before("serviceMethod()")public void beforeAdvice(JoinPoint joinPoint) {System.out.println("Before executing method: " + joinPoint.getSignature().getName());}@After("serviceMethod()")public void afterAdvice(JoinPoint joinPoint) {System.out.println("After executing method: " + joinPoint.getSignature().getName());}
}

切入点表达式示例

@Pointcut("execution(* com.example.service.UserService.*(..))")
private void userServiceMethods() {}@Pointcut("within(com.example.repository.*)")
private void repositoryMethods() {}

通知类型示例

@Before（前置通知）

@Before("execution(* com.example.service.UserService.createUser(String, int))")
public void beforeCreateUserAdvice(JoinPoint joinPoint) {Object[] args = joinPoint.getArgs();System.out.println("Before creating user... Name: " + args[0] + ", Age: " + args[1]);
}

功能：在执行 com.example.service.UserService.createUser() 方法之前触发该通知，可以用于进行一些预处理操作，例如权限检查、参数校验等。

@After（后置通知）

@After("execution(* com.example.service.UserService.deleteUser(..))")
public void afterDeleteUserAdvice() {System.out.println("After deleting user...");
}

功能：在执行 com.example.service.UserService.deleteUser() 方法之后触发该通知，无论方法是否抛出异常都会执行。可以用于进行一些清理操作，例如资源释放、日志记录等。

@AfterReturning（返回通知）

@AfterReturning(pointcut = "execution(* com.example.service.UserService.updateUser(..))", returning = "result")
public void afterUpdateUserAdvice( Object result) {System.out.println("After updating user... Result: " + result);
}

功能：在执行 com.example.service.UserService.updateUser() 方法并且方法正常返回后触发该通知。可以用于获取方法的返回值并进行相应的处理，例如记录返回结果、统计信息等。

@AfterThrowing（异常通知）

@AfterThrowing(pointcut = "execution(* com.example.service.UserService.getUser(..))", throwing = "ex")
public void afterThrowingGetUserAdvice(Exception ex) {System.out.println("After throwing exception in getUser() method: " + ex.getMessage());
}

功能：在执行 com.example.service.UserService.getUser() 方法抛出异常时触发该通知。可以用于捕获方法抛出的异常并进行相应的处理，例如记录异常信息、进行异常处理等。

@Around（环绕通知）

@Around("execution(* com.example.service.UserService.getAllUsers())")
public Object aroundGetAllUsersAdvice(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("Before executing getAllUsers() method...");Object result = null;try {result = joinPoint.proceed();} catch (Exception ex) {System.out.println("Exception occurred: " + ex.getMessage());}System.out.println("After executing getAllUsers() method... Result: " + result);return result;
}

功能：在执行 com.example.service.UserService.getAllUsers() 方法前后都触发该通知，并且可以控制目标方法的执行。可以用于在方法执行前后进行一些额外的处理，例如性能监控、事务管理等。