目录
简介
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 {
@Override
public void saveUser(User user) {
// 实现具体的数据库保存逻辑
System.out.println("Save user: " + user.getName());
}
}
// 定义服务类 UserService，使用 @Service 注解标记为业务层组件
@Service
public class UserService {
// 使用 @Autowired 注解自动装配 UserDao 对象
@Autowired
private 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 bean
UserService 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 {
// 在初始化之前执行的方法
@PostConstruct
public void init() {
// 初始化操作...
}
// 在销毁之前执行的方法
@PreDestroy
public void destroy() {
// 销毁操作...
}
// 实现 InitializingBean 接口的方法
@Override
public void afterPropertiesSet() throws Exception {
// 初始化操作...
}
// 实现 DisposableBean 接口的方法
@Override
public void destroy() throws Exception {
// 销毁操作...
}
}
依赖注入
@Component
public class UserService {
@Autowired // 自动装配依赖对象
private UserRepository userRepository;
// 类的具体实现...
}
管理第三方 Bean
@Configuration
public class MyConfig {
@Bean // 将第三方类库的对象声明为一个 Spring 管理的 bean
public ThirdPartyService thirdPartyService() {
return new ThirdPartyService();
}
}
@Component
public class MyComponent {
@Autowired
private ThirdPartyService thirdPartyService;
// 类的具体实现...
}
为第三方 Bean 注入资源（例如数据库连接池）
@Configuration
public class DataSourceConfig {
@Bean
public DataSource dataSource() {
// 创建和配置数据源对象...
}
@Bean
public 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() 方法前后都触发该通知，并且可以控制目标方法的执行。可以用于在方法执行前后进行一些额外的处理，例如性能监控、事务管理等。