README.md

@@ -133,29 +133,35 @@
 #### 5.1.4 Optional的介绍和使用(掌握)
 #### 5.1.5 Stream API的介绍和使用(了解)
 #### 5.1.6 泛型(掌握)
-
 ### 5.2 Spring框架简介(了解)
 #### 5.2.1 Spring框架的历史和发展
-#### 5.2.2 Spring的家族框架
+#### 5.2.2 Spring框架的核心特性
-#### 5.2.3 Spring的应用场景和优势
+#### 5.2.3 Spring的家族框架
-#### 5.2.4 Spring Web
+#### 5.2.4 Spring的应用场景和优势
-#### 5.2.5 Spring Boot
+#### 5.2.5 Spring Web
 ### 5.3 Spring IoC(掌握)
 #### 5.3.1 IoC
+#### 5.3.2 Spring IoC容器
 #### 5.3.3 Spring Bean的定义和生命周期
 #### 5.3.4 Bean的作用域
 #### 5.3.5 Bean的依赖注入
-### 5.4 Spring AOP(了解)
+### 5.4 Spring MVC(掌握)
-#### 5.4.1 AOP的基本概念
+#### 5.4.1 Spring MVC概述
-#### 5.4.2 使用AspectJ进行切面编程
+#### 5.4.2 使用@Controller定义控制器
-### 5.5 Spring Boot入门(掌握)
+#### 5.4.3 使用@RequestMapping处理请求
-#### 5.5.1 快速创建Spring boot项目
+#### 5.4.4 使用@ResponseBody返回JSON响应
-#### 5.5.2 创建控制器类
+#### 5.4.5 使用Spring Data JPA进行数据访问
-#### 5.5.3 控制器类中常用注解
+### 5.5 Spring AOP(了解)
-### 5.6 构建工具
+#### 5.5.1 AOP的基本概念
-#### 5.6.1 Maven(了解)
+#### 5.5.2 使用AspectJ进行切面编程
-#### 5.6.2 Gradle(掌握)
+### 5.6 Spring事务管理(了解)
-
+#### 5.6.1 事务管理的基本概念
+#### 5.6.2 Spring事务管理器
+#### 5.6.3 使用@Transactional进行声明式事务管理
+#### 5.6.4 使用编程式事务管理
+### 5.7 构建工具
+#### 5.7.1 Maven(了解)
+#### 5.7.2 Gradle(掌握)
 ## 6. [数据库访问](./docs/chapter06.md)
 ### 6.1 JDBC(掌握)
 #### 6.1.1 什么是JDBC？

docs/chapter05.md

@@ -558,7 +558,18 @@ Java 内置的 `List` 和 `Map` 类型都支持泛型，可以用来存储任意
     - **5.x**: 重点改进了对反应式编程模型的支持，引入了Spring WebFlux框架。
 - **最新版本**: 截至2024年，Spring框架的最新版本为6.x系列，持续增加了对现代Web开发趋势的支持，如微服务架构、云原生应用等。
 
-#### 5.2.2 Spring的家族框架
+#### 5.2.2 Spring框架的核心特性
+- **依赖注入 (DI)**:
+    - **定义**: 是一种设计模式，用于实现对象之间的解耦，让对象不需要直接创建依赖对象，而是由容器负责创建并注入。
+    - **好处**: 降低了组件之间的耦合度，提高了代码的可测试性和可维护性。
+- **面向切面编程 (AOP)**:
+    - **定义**: 一种编程范式，用于将横切关注点（如日志记录、事务管理）从业务逻辑中分离出来。
+    - **好处**: 通过切面编程，可以在不修改业务逻辑代码的情况下添加或修改功能。
+- **模块化**: Spring框架被设计成高度模块化的，用户可以根据需要选择使用不同的模块。
+- **可扩展性**: Spring框架提供了许多扩展点，允许开发者根据需要自定义行为。
+- **广泛的应用场景**: 从简单的Web应用到复杂的企业级应用，Spring都能提供解决方案。
+
+#### 5.2.3 Spring的家族框架
 - **Spring Boot**: 提供了一个快速搭建Spring应用的方式，通过自动化配置、依赖管理和启动器简化了开发过程。
 - **Spring Cloud**: 用于构建分布式系统和服务网格，提供了一系列工具和服务，如服务注册与发现、配置中心、熔断器等。
 - **Spring Data**: 提供了一套数据访问抽象层，简化了数据访问层的开发工作，支持各种数据库技术。
@@ -568,7 +579,7 @@ Java 内置的 `List` 和 `Map` 类型都支持泛型，可以用来存储任意
 - **Spring WebFlux**: 用于构建非阻塞的、事件驱动的Web应用和服务器端应用，支持反应式编程模型。
 - **Spring Web**: 提供了构建Web应用程序所需的支持，包括HTTP消息处理、多部分文件上传等功能，以及与Spring MVC的紧密集成。
 
-#### 5.2.3 Spring的应用场景和优势
+#### 5.2.4 Spring的应用场景和优势
 - **应用场景**:
     - **Web应用**: Spring MVC框架为构建高性能的Web应用提供了基础。
     - **企业级应用**: Spring框架适合构建复杂的企业级应用，包括业务流程管理、数据处理等。
@@ -583,7 +594,7 @@ Java 内置的 `List` 和 `Map` 类型都支持泛型，可以用来存储任意
     - **性能**: Spring框架经过优化，能够高效地运行大规模应用。
     - **社区活跃**: Spring框架有一个活跃的社区，不断更新以适应新的技术和标准。
 
-#### 5.2.4 Spring Web
+#### 5.2.5 Spring Web
 - **概述**: Spring Web 是 Spring Framework 的一部分，它为构建Web应用程序提供了必要的支持。Spring Web 包含了多个子模块，旨在提供一套完整的Web开发解决方案。
 - **子模块**:
     - **Spring Web**: 为Web开发提供了一些基本的支持，比如HTTP消息转换、多部分文件上传、Web应用上下文等。
@@ -599,28 +610,6 @@ Java 内置的 `List` 和 `Map` 类型都支持泛型，可以用来存储任意
     - **File Upload Support**: 支持多部分文件上传，用于处理文件上传请求。
     - **Web Services Support**: 支持构建和消费Web服务，包括SOAP和RESTful服务。
     - **WebSocket Support**: 提供了WebSocket的支持，用于实现实时双向通信。
-  
-#### 5.2.5 Spring Boot
-
-Spring Boot 是 Spring Framework 的一个子项目，旨在简化 Spring 应用的开发。一些关键特性：
-
-- **自动配置（Auto Configuration）**：
-   Spring Boot 的自动配置能够根据类路径中的依赖、定义的 Bean 以及各种配置属性，自动配置 Spring 应用的基础设施和功能。
-
-- **内嵌服务器**：
-   Spring Boot 提供了内嵌的 Tomcat、Jetty 和 Undertow 服务器，这样开发者无需外部配置服务器即可运行 Web 应用。
-
-- **起步依赖（Starters）**：
-   Spring Boot 提供了一系列 "起步依赖"，这些依赖将常用的库和配置打包在一起，简化了项目的依赖管理。例如，`spring-boot-starter-web` 包含了开发 Web 应用所需的所有依赖，如 Spring MVC、内嵌的 Tomcat 等.
-
-- **产品级特性**：
-   强大的日志管理功能、健康检查和监控、安全管理、配置管理
-
-- **集成第三方库和框架**：
-    Spring Boot 提供了丰富的集成选项，使得开发者可以轻松地将第三方库和框架集成到应用程序中。
-
-这些特性使得 Spring Boot 成为一个强大的框架，帮助开发者快速构建和部署高质量的 Spring 应用程序。
-
 
 ### 5.3 Spring IoC(掌握)
 
@@ -638,72 +627,36 @@ Spring IoC容器负责管理对象的生命周期、依赖关系以及配置信
 
 通过使用框架提供的注解或者XML配置，Spring可以轻松地定义和管理Bean。
 
-在Spring框架中，有多种注解可以用来定义一个类为Spring Bean。以下是一些常用的注解：
+- **生命周期**:
-
+    - **初始化**: 包括默认初始化、自定义初始化等。
-**@Component** - 这是一个通用的注解，用于标记任何轻量级的、可由Spring IoC容器管理的组件。
+    - **销毁**: 包括默认销毁、自定义销毁等。
-
-**@Service** - 通常用于业务层组件，表示服务逻辑的实现。
-
-**@Repository** - 用于数据访问层组件，比如DAO（Data Access Object）类，用于处理数据存储相关的逻辑。
-
-**@Controller** - 用于表现层组件，特别是用在Web应用中作为控制器。
-
-**@Configuration** - 标记配置类，这类类中的方法可以使用@Bean注解来定义和初始化bean。
-
-**@RestController** - 组合了@Controller和@ResponseBody两个注解，用于构建RESTful Web服务。
-
-**@Bean** - 虽然不是直接用来标注类的，但是当与@Configuration一起使用时，可以在配置类的方法上声明以创建和初始化bean。
-
-通过使用上述注解之一，Spring框架会在启动时自动扫描这些带有注解的类，并将它们注册为Spring容器中的bean。这样就可以利用Spring的依赖注入（Dependency Injection, DI）和其他特性来管理和使用这些bean了。
 
 - **注解方式定义Bean的示例**:
 
   ```java
   @Component
   public class MyBean {
+      public MyBean() {
+          System.out.println("MyBean created.");
+      }
+      
+      @PostConstruct
+      public void init() {
+          System.out.println("MyBean initialized.");
+      }
+      
+      @PreDestroy
+      public void destroy() {
+          System.out.println("MyBean destroyed.");
+      }
   }
   ```
 
-  ```java
-  @Component
-  public class MyService {
-  }
-  ```
-
-  ```java
-  @RestController
-  public class MyController {
-  }
-  ```
-  
 - **XML配置方式定义Bean**:
 ```xml
 <bean id="myBean" class="com.example.MyBean"/>
 ```
 
-
-- **生命周期**:
-  - **初始化**: 包括默认初始化、自定义初始化等。
-  - **销毁**: 包括默认销毁、自定义销毁等。
-```java
-@Component
-public class MyBean {
-    public MyBean() {
-        System.out.println("MyBean created.");
-    }
-
-    @PostConstruct
-    public void init() {
-        System.out.println("MyBean initialized.");
-    }
-
-    @PreDestroy
-    public void destroy() {
-        System.out.println("MyBean destroyed.");
-    }
-}
-```  
-
 #### 5.3.4 Bean的作用域
 在Spring框架中，默认情况下，如果没有显式指定作用域，Bean的作用域是Singleton。但是，可以通过不同的方式来指定Bean的作用域。
 
@@ -887,9 +840,72 @@ public class MyService {
 - **@Inject**：JSR-330标准注解，用于依赖注入，可以与Spring集成使用。
 - **@Resource**：JSR-250标准注解，通常用于按名称注入Bean。
 
-### 5.4 Spring AOP(了解)
 
-#### 5.4.1 AOP的基本概念
+### 5.4 Spring MVC(掌握)
+
+#### 5.4.1 Spring MVC概述
+- **定义**: Spring MVC是Spring web框架的一部分，基于Model-View-Controller (MVC) 模式,用于构建Web应用。
+- **特点**:
+    - **请求处理**: 通过@Controller注解来定义控制器。
+    - **视图解析**: 通过ViewResolver来解析视图。
+
+#### 5.4.2 使用@Controller定义控制器
+- **定义**: 使用`@Controller`注解定义控制器类。
+- **示例**:
+  ```java
+  @Controller
+  public class HelloController {
+      @RequestMapping("/hello")
+      public String hello(Model model) {
+          model.addAttribute("message", "Hello, Spring MVC!");
+          return "hello";
+      }
+  }
+  ```
+
+#### 5.4.3 使用@RequestMapping处理请求
+- **定义**: 使用`@RequestMapping`注解来映射请求路径。
+- **示例**:
+  ```java
+  @Controller
+  public class HelloController {
+      @RequestMapping(value = "/hello", method = RequestMethod.GET)
+      public String hello(@RequestParam String name, Model model) {
+          model.addAttribute("message", "Hello, " + name + "!");
+          return "hello";
+      }
+  }
+  ```
+
+#### 5.4.4 使用@ResponseBody返回JSON响应
+- **定义**: 使用`@ResponseBody`注解来直接返回JSON响应。
+- **示例**:
+  ```java
+  @Controller
+  public class HelloController {
+      @RequestMapping(value = "/hello-json", method = RequestMethod.GET)
+      @ResponseBody
+      public Map<String, String> helloJson(@RequestParam String name) {
+          Map<String, String> response = new HashMap<>();
+          response.put("message", "Hello, " + name + "!");
+          return response;
+      }
+  }
+  ```
+
+#### 5.4.5 使用Spring Data JPA进行数据访问
+- **定义**: Spring Data JPA是Spring Data项目的一部分，用于简化JPA的数据访问。
+- **示例**:
+  ```java
+  @Repository
+  public interface UserRepository extends JpaRepository<User, Long> {
+      User findByUsername(String username);
+  }
+  ```
+
+### 5.5 Spring AOP(了解)
+
+#### 5.5.1 AOP的基本概念
 
 - **概念**:
 
@@ -907,7 +923,7 @@ public class MyService {
     - **通知 (Advice)**: 在特定连接点（join point）处由切面（aspect）执行的操作。不同的通知类型包括“环绕”（around）、“前置”（before）和“后置”（after）通知。许多AOP框架，包括Spring，都将通知建模为拦截器，并在连接点周围维持一个拦截器链。
     - **切面 (Aspect)**: 一个跨越多个类的关注点的模块化。事务管理是J2EE应用中一个很好的横切关注点的例子。在Spring AOP中，切面是使用普通的类（基于模式的方法）或使用@Aspect注解的普通类（@AspectJ风格）来实现的。
 
-#### 5.4.2 使用AspectJ进行切面编程
+#### 5.5.2 使用AspectJ进行切面编程
 - **定义**: AspectJ是一种常用的AOP框架，提供了强大的切面编程能力。
 - **示例**:
   ```java
@@ -957,100 +973,9 @@ public class MyService {
   }
   ```
 
-### 5.5 Spring Boot入门(掌握)
-
-#### 5.5.1 快速创建Spring boot项目
-
-- 使用官方在线工具[start.spring.io](https://start.spring.io)创建初始项目
-
-
-- 将生成的zip文件在本机解压
-- 在idea中打开项目
-- 修改maven仓库地址,使用国内源加快下载速度，在build.gralde文件中添加如下配置:
-```groovy
-repositories {
-	mavenLocal()
-	maven { url 'https://mirrors.cloud.tencent.com/nexus/repository/maven-public/' }
-	maven { url 'https://maven.aliyun.com/repository/central' }
-	maven { url 'https://maven.aliyun.com/repository/public' }
-	mavenCentral()
-}
-```
-- 刷新gradle,下载依赖包
-
-- 运行项目
-
-
-#### 5.5.2 创建控制器
-
- **示例**:
-```java
-@RestController
-@RequestMapping("/hello")
-public class HelloController {
-  @GetMapping
-  public String hello() {
-    return "Hello World";
-  }
-
-  @GetMapping("/json")
-  public Map<String,String> json() {
-    Map<String,String> data = new HashMap<>();
-    data.put("code","200");
-    data.put("message","Hello World");
-    return data;
-  }
-
-}
-
- ```
-
-#### 5.5.3 控制器中常用注解
-
-- **@RestController注解 **
-
-> @RestController注解是Spring Boot框架中的一个注解，用于标识一个类是一个RESTful风格的控制器（Controller）。它结合了@Controller和@ResponseBody注解的功能，使得编写RESTful风格的控制器更加简单和方便。
->具体来说，@RestController注解的作用包括：
-
-> - 将类标记为RESTful控制器，方便Spring Boot框架自动扫描和注册。
-> - 将所有方法的返回值自动转换为JSON格式，并通过HTTP响应返回给客户端。
-> - 简化了编写RESTful控制器的过程，不需要再使用@Controller和@ResponseBody注解。
-
-
-- **@RequestMapping注解**
-
-> @RequestMapping注解用于映射HTTP请求到控制器的处理方法上。它可以应用在类或方法上，用于指定处理请求的路径和请求方法。
-
-> 应用在类上，@RequestMapping注解表示这个类中的所有处理方法都共享相同的请求路径前缀
-
-> 在方法级别上，@RequestMapping注解用于指定处理请求的具体路径和请求方法。
-
-
-- **http method对应的注解（应用在方法上）**
-
-> @GetMapping用于处理HTTP GET请求。它可以接受一个URI模式参数，用于指定处理的请求路径。当客户端发送GET请求到对应的URI时，Spring Boot将会通过该注解所标注的方法来处理请求，并返回相应的数据。
-
-> @PostMapping则是专门处理HTTP POST请求的注解，它是@RequestMapping(method = RequestMethod.POST)的缩写形式。与@GetMapping类似，它接受一个URI模式参数，用于指定处理的请求路径。客户端向指定的URI发送POST请求时，Spring Boot将会根据该注解所标注的方法来处理请求并返回相应结果。
-
-> @PutMapping注解用于处理HTTP PUT请求，将请求映射到具体的处理方法中。它是一个组合注解，相当于@RequestMapping(method = RequestMethod.PUT)的快捷方式。通过该注解可以指定请求的URI、请求参数、响应类型等信息，当客户端向指定URI发送PUT请求时，Spring Boot会自动找到对应的处理方法进行处理并返回响应数据。
-
-> @DeleteMapping则用于处理HTTP DELETE请求，它也是一个组合注解，相当于@RequestMapping(method = RequestMethod.DELETE)。它可以将HTTP DELETE请求映射到Spring Boot中的消费者方法，实现删除特定资源的功能。类似于@PutMapping，@DeleteMapping也支持设置请求的URI、请求参数、响应类型等信息
-
-- **获得Request请求参数的注解**
-
-> @PathVariable、@RequestBody和@RequestParam是三个常用的注解，它们分别用于获取并处理HTTP请求中的路径变量、请求体和请求参数。
-
-> @PathVariable注解用于处理URI路径中的占位符参数，即将URI中的某个部分作为参数传递给对应的控制器方法。例如，/users/{id}表示URI路径中的id部分是一个路径变量，我们可以在控制器方法中使用@PathVariable("id")注解来获取该值，并进行相应的业务操作。
-
-> @RequestBody注解用于获取HTTP请求的请求体，通常用于接收JSON格式的数据。当客户端向后端发送POST请求时，使用该注解可以将请求体中的数据绑定到Java对象上，从而方便地进行数据处理。
-
-> @RequestParam注解用于获取HTTP请求中的查询参数，例如?name=John&age=20。使用该注解可以将查询参数值绑定到对应的控制器方法的参数中，并进行相应的业务操作。需要注意的是，@RequestParam注解默认情况下是必需的，即如果没有传递对应的查询参数，则会抛出异常。如果想要将其设置为可选的，可以在注解中添加required=false属性。
-
-
-
-
 ### 5.6 构建工具
 
+
 构建工具（Build Tools）是软件开发过程中用于自动化构建、测试和打包软件应用程序的工具。它们通常用于编译源代码、运行测试、生成文档、打包应用程序以及执行其他与构建过程相关的任务。
 
 java项目常用的构建工具有：

docs/index.md

@@ -132,28 +132,35 @@
 #### 5.1.4 Optional的介绍和使用(掌握)
 #### 5.1.5 Stream API的介绍和使用(了解)
 #### 5.1.6 泛型(掌握)
-
 ### 5.2 Spring框架简介(了解)
 #### 5.2.1 Spring框架的历史和发展
-#### 5.2.2 Spring的家族框架
+#### 5.2.2 Spring框架的核心特性
-#### 5.2.3 Spring的应用场景和优势
+#### 5.2.3 Spring的家族框架
-#### 5.2.4 Spring Web
+#### 5.2.4 Spring的应用场景和优势
-#### 5.2.5 Spring Boot
+#### 5.2.5 Spring Web
 ### 5.3 Spring IoC(掌握)
 #### 5.3.1 IoC
+#### 5.3.2 Spring IoC容器
 #### 5.3.3 Spring Bean的定义和生命周期
 #### 5.3.4 Bean的作用域
 #### 5.3.5 Bean的依赖注入
-### 5.4 Spring AOP(了解)
+### 5.4 Spring MVC(掌握)
-#### 5.4.1 AOP的基本概念
+#### 5.4.1 Spring MVC概述
-#### 5.4.2 使用AspectJ进行切面编程
+#### 5.4.2 使用@Controller定义控制器
-### 5.5 Spring Boot入门(掌握)
+#### 5.4.3 使用@RequestMapping处理请求
-#### 5.5.1 快速创建Spring boot项目
+#### 5.4.4 使用@ResponseBody返回JSON响应
-#### 5.5.2 创建控制器类
+#### 5.4.5 使用Spring Data JPA进行数据访问
-#### 5.5.3 控制器类中常用注解
+### 5.5 Spring AOP(了解)
-### 5.6 构建工具
+#### 5.5.1 AOP的基本概念
-#### 5.6.1 Maven(了解)
+#### 5.5.2 使用AspectJ进行切面编程
-#### 5.6.2 Gradle(掌握)
+### 5.6 Spring事务管理(了解)
+#### 5.6.1 事务管理的基本概念
+#### 5.6.2 Spring事务管理器
+#### 5.6.3 使用@Transactional进行声明式事务管理
+#### 5.6.4 使用编程式事务管理
+### 5.7 构建工具
+#### 5.7.1 Maven(了解)
+#### 5.7.2 Gradle(掌握)
 
 ## 6. [数据库访问](./docs/chapter06.md)
 ### 6.1 JDBC(掌握)

examples/chapter05/spring-bean-aop-demo/src/main/java/com/lk/demo/FirstBean.java

@@ -1,36 +0,0 @@
-package com.lk.demo;
-
-import jakarta.annotation.PostConstruct;
-import jakarta.annotation.PreDestroy;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-
-@Component
-public class FirstBean {
-
-    // 通过属性（字段）注入，需要使用@Autowired 注解注入
-    @Autowired
-    private SecondBean secondBean;
-
-    public FirstBean() {
-        System.out.println("FirstBean created.");
-    }
-
-    public String getMessage() {
-        return "Hello FirstBean";
-    }
-
-    public void doSomething() {
-        System.out.println("Doing something in FirstBean.");
-        secondBean.doSomething();
-    }
-    @PostConstruct
-    public void init() {
-        System.out.println("FirstBean initialized.");
-    }
-
-    @PreDestroy
-    public void destroy() {
-        System.out.println("FirstBean destroyed.");
-    }
-}

examples/chapter05/spring-bean-aop-demo/src/main/java/com/lk/demo/InjectedBean.java

@@ -0,0 +1,28 @@
+package com.lk.demo;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.PreDestroy;
+import org.springframework.stereotype.Component;
+
+@Component
+public class InjectedBean {
+
+    public void print() {
+        System.out.println("hello bean");
+    }
+
+    public InjectedBean() {
+        System.out.println("InjectedBean created.");
+    }
+
+    @PostConstruct
+    public void init() {
+        System.out.println("InjectedBean initialized.");
+    }
+
+    @PreDestroy
+    public void destroy() {
+        System.out.println("InjectedBean destroyed.");
+    }
+
+}

examples/chapter05/spring-bean-aop-demo/src/main/java/com/lk/demo/LoggingAspect.java

@@ -23,13 +23,7 @@ public class LoggingAspect {
     @Before("execution(* com.lk.demo.*.*(..))") // 切点定义
     public void logBefore(JoinPoint joinPoint) {
         // 连接点：在方法调用之前
-        System.out.println("--这是在调用:[" + joinPoint.getSignature()+"]之前");
+        System.out.println("Executing: " + joinPoint.getSignature());
-
-        // 获取方法参数
-        Object[] args = joinPoint.getArgs();
-        for (int i = 0; i < args.length; i++) {
-               System.out.println("参数: "+args[i].toString() );
-        }
     }
 
     /**
@@ -43,18 +37,14 @@ public class LoggingAspect {
     @Around("execution(* com.lk.demo.MyService.*(..))") // 切点定义
     public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
         // 连接点：在方法调用之前
-        System.out.println("**在调用["+ joinPoint.getSignature()+"]之前.");
+        System.out.println("Before method call...");
 
         try {
             // Proceed to the actual method invocation
             // 执行连接点上的方法
             Object result = joinPoint.proceed();
             // 连接点：在方法调用之后
-            if(result!=null){
+            System.out.println("After method call...");
-                System.out.println("**在调用["+ joinPoint.getSignature()+"]后得到返回值:"+result.toString());
-            }else{
-                System.out.println("**在调用["+ joinPoint.getSignature()+"]之后.");
-            }
 
             return result;
         } catch (Exception e) {

examples/chapter05/spring-bean-aop-demo/src/main/java/com/lk/demo/Main.java

@@ -5,13 +5,16 @@ import org.springframework.boot.CommandLineRunner;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
+import javax.swing.*;
+
 @SpringBootApplication
 
-// CommandLineRunner 是 Spring Boot 提供的一个特定接口，允许你在应用程序上下文加载完成后运行一些代码。
 public class Main implements CommandLineRunner {
 
     @Autowired
     private MyService myService;
+    @Autowired
+    private MyBean myBean;
 
     public static void main(String[] args) {
         SpringApplication.run(Main.class, args);
@@ -21,6 +24,8 @@ public class Main implements CommandLineRunner {
     @Override
     public void run(String... args) throws Exception {
         myService.doSomething();
-        myService.workHard("hard");
+        System.out.println(myBean.getMessage());
+
+
     }
 }

examples/chapter05/spring-bean-aop-demo/src/main/java/com/lk/demo/MyBean.java

@@ -0,0 +1,26 @@
+package com.lk.demo;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.PreDestroy;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MyBean {
+    public String getMessage() {
+        return "Hello World";
+    }
+
+    public MyBean() {
+        System.out.println("MyBean created.");
+    }
+
+    @PostConstruct
+    public void init() {
+        System.out.println("MyBean initialized.");
+    }
+
+    @PreDestroy
+    public void destroy() {
+        System.out.println("MyBean destroyed.");
+    }
+}

examples/chapter05/spring-bean-aop-demo/src/main/java/com/lk/demo/MyService.java

@@ -1,29 +1,17 @@
 package com.lk.demo;
 
 import jakarta.annotation.PreDestroy;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 @Service
 public class MyService {
 
-    private FirstBean firstBean;
+    @Autowired
-    private SecondBean secondBean;
+    InjectedBean injectedBean;
-
-    // 使用构造函数注入依赖
-    public MyService(FirstBean firstBean, SecondBean secondBean){
-        this.firstBean = firstBean;
-        this.secondBean = secondBean;
-    }
-
     public void doSomething(){
-        System.out.println("Doing something in MyService.");
+        System.out.println("Doing something");
-        firstBean.doSomething();
+        injectedBean.print();
-        secondBean.doAnother();
-    }
-
-    public String workHard(String input){
-        System.out.println("Working hard with input: " + input);
-        return "Result: OK";
     }
 
     @PreDestroy

examples/chapter05/spring-bean-aop-demo/src/main/java/com/lk/demo/SecondBean.java

@@ -1,15 +0,0 @@
-package com.lk.demo;
-
-import org.springframework.context.annotation.Bean;
-import org.springframework.stereotype.Component;
-
-@Component
-public class SecondBean {
-    public void doSomething(){
-        System.out.println("Second Bean do somting.");
-    }
-
-    public void doAnother(){
-        System.out.println("Second Bean do another.");
-    }
-}

examples/chapter05/spring-boot-web-demo/src/main/java/com/lk/demo/User.java

@@ -1,37 +0,0 @@
-package com.lk.demo;
-
-public class User {
-    private String name;
-    private String email;
-    private String phone;
-
-    public User(String name, String email, String phone) {
-        this.name = name;
-        this.email = email;
-        this.phone = phone;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    public String getEmail() {
-        return email;
-    }
-
-    public void setEmail(String email) {
-        this.email = email;
-    }
-
-    public String getPhone() {
-        return phone;
-    }
-
-    public void setPhone(String phone) {
-        this.phone = phone;
-    }
-}

examples/chapter05/spring-boot-web-demo/src/main/java/com/lk/demo/UserController.java

@@ -1,21 +0,0 @@
-package com.lk.demo;
-
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import java.util.List;
-
-@RestController
-@RequestMapping("/users")
-public class UserController {
-
-    @Autowired
-    private UserService userService;
-
-    @GetMapping("")
-    public List<User> index() {
-        return userService.getUsers();
-    }
-}

examples/chapter05/spring-boot-web-demo/src/main/java/com/lk/demo/UserService.java

@@ -1,17 +0,0 @@
-package com.lk.demo;
-
-import org.springframework.stereotype.Service;
-
-import java.util.ArrayList;
-import java.util.List;
-
-@Service
-public class UserService {
-    public List<User> getUsers(){
-       List<User> users = new ArrayList<>();
-       users.add(new User("mike","mike@mail.com", "188111111"));
-       users.add(new User("john","john@mail.com", "133222222"));
-       users.add(new User("tom","tom@mail.com", "199222222"));
-       return users;
-    }
-}