Spring的反转控制你真的明白了吗？

文章目录

- IoC（控制反转）和 DI（依赖注入）
- - - Bean’
    - ApplicationContext
    - BeanFactory
    - 配置文件
  - 1. 声明 Bean
  - 2. 使用 ApplicationContext
  - 3. 依赖注入
- AOP（面向切面编程）
- - - Join Point
    - Pointcut
    - Advice
    - Aspect
  - 1. 声明切面
  - 2. 在配置文件中启用 AOP
  - 3. 测试
- MVC（模型-视图-控制器）
- - 模型(Model)：
  - 视图(View)：
  - 控制器(Controller)：
- JDBC Template
- - 1. 数据源(DataSource)
  - 2. JDBC Template
  - 3. 数据访问对象(DAO)
- Transaction Management（事务管理）
- - 1. 事务(Transaction)
  - 2. 事务管理器(Transaction Manager)
  - 3. 编程式事务管理
  - 4. 声明式事务管理

IoC（控制反转）和 DI（依赖注入）

IoC 是 Spring 的核心理念之一，也是 Spring 最为著名的特性之一。它将对象的创建、管理和销毁等过程交给 Spring 容器来完成。DI 则是 IoC 的具体实现，它通过注入依赖对象的方式来完成对象之间的解耦。 IoC（控制反转）是一种设计模式，它将对象的创建、管理和销毁等过程交给容器来完成，而不是由代码显式地进行。这样可以降低代码的耦合度和复杂度，并且提高代码的可测试性和可维护性。

DI（依赖注入）是 IoC 的具体实现方式之一，它通过注入依赖对象的方式来完成对象之间的解耦。在 Spring 中，我们可以通过构造方法注入、setter 方法注入和字段注入等方式实现依赖注入。

下面是一些常见的 IoC 和 DI 相关的概念：

Bean’

Bean 是一个由 Spring 容器管理的对象。在 Spring 中，我们可以将 Java 类声明为一个 Bean，并由容器来创建、初始化和销毁它。

ApplicationContext

ApplicationContext 是 Spring 提供的一个接口，它是 IoC 容器的核心接口。ApplicationContext 在初始化时会创建 Bean 实例，并管理它们的生命周期。

BeanFactory

BeanFactory 是 ApplicationContext 的父接口，它也是 Spring 容器的核心接口。BeanFactory 只负责管理 Bean 实例的生命周期，而不会主动地创建 Bean 实例。

配置文件

Spring 中的配置文件通常使用 XML 格式，用于描述应用程序中的 Bean、Bean 之间的依赖关系、以及其他相关的配置信息。

现在我们来看一下如何在 Java 代码中实现 IoC 和 DI。

1. 声明 Bean

我们可以使用 @Component、@Service、@Controller、@Repository 等注解来将一个 Java 类声明为一个 Bean。这些注解都是 @Component 的派生注解，它们的作用是告诉 Spring 容器，这个类需要被管理。

例如：

@Service
public class UserService {<!-- -->
    // ...
}

2. 使用 ApplicationContext

下面是一个简单的使用 ApplicationContext 的例子，其中通过 getBean() 方法获得了 UserService 实例：

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean(UserService.class);

3. 依赖注入

我们可以使用 @Autowired 注解、构造方法注入或 setter 方法注入等方式来实现依赖注入。

例如：


@Service
public class UserService {<!-- -->
    private UserDao userDao;

    @Autowired
    public UserService(UserDao userDao) {<!-- -->
        this.userDao = userDao;
    }

    // 或者使用 setter 方法注入
    // @Autowired
    // public void setUserDao(UserDao userDao) {<!-- -->
    //     this.userDao = userDao;
    // }
}

通过上述代码，Spring 在创建 UserService 对象时会自动注入一个 UserDao 实例，从而实现了对象之间的解耦。

AOP（面向切面编程）

AOP 是 Spring 的另一个核心特性，它可以在不修改原有代码的情况下，通过切入点和通知等机制，动态地添加或移除一些功能模块，比如日志记录、安全检查等。 AOP（面向切面编程）是一种编程范式，它可以在不修改原有代码的情况下，通过动态地横向切入程序执行流程中的某些特定点，往程序中添加或删除业务逻辑。AOP 通过将横切关注点与正常的业务逻辑分离来提高代码的可维护性和可扩展性。

Spring AOP 是基于代理模式实现的，它通过拦截器来实现对方法的增强。在 Spring 中，我们可以通过配置切面、切入点和通知等机制来实现 AOP。

下面是一些常见的 AOP 相关的概念：

Join Point

Join Point 是指在程序执行过程中的某个特定点，比如方法调用、异常处理等。

Pointcut

Pointcut 是指一个表达式，它定义了哪些 Join Point 应该被拦截。比如可以使用表达式 execution(* com.example….(…)) 来匹配 com.example 包及其子包下的所有方法。

Advice

Advice 是指在拦截到 Join Point 后要执行的逻辑，也就是增强的具体实现方式。Spring 提供了四种类型的 Advice，分别是 Before、After、Around 和 AfterReturning。

Aspect

Aspect 是指一个横切关注点，它可以是一个类或者一个注解。Aspect 定义了 Pointcut 和 Advice，用于描述哪些 Join Point 需要被拦截以及拦截后需要执行的逻辑。

现在我们来看一下如何在 Java 代码中实现 AOP。

1. 声明切面

我们可以使用 @Aspect 注解将一个类声明为切面。在切面中，通常会定义多个 Pointcut 和对应的 Advice。

例如：

@Aspect
@Component
public class LogAspect {
    // 定义一个 Pointcut，匹配所有 UserService 的方法
    @Pointcut("execution(* com.example.service.UserService.*(..))")
    public void userServicePointcut() {}

    // Before Advice，在 UserService 方法执行前输出日志
    @Before("userServicePointcut()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("before " + joinPoint.getSignature().getName());
    }
}

2. 在配置文件中启用 AOP

我们需要在 Spring 配置文件中启用 AOP，并将切面添加到容器中。

例如：

&lt;aop:aspectj-autoproxy/&gt;
&lt;context:component-scan base-package="com.example"/&gt;
&lt;bean id="logAspect" class="com.example.aspect.LogAspect"/&gt;

3. 测试

最后，我们可以编写一个测试类来验证 AOP 是否生效。

例如：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {<!-- -->"classpath*:applicationContext.xml"})
public class UserServiceTest {<!-- -->
    @Autowired
    private UserService userService;

    @Test
    public void test() {<!-- -->
        userService.addUser(new User());
        userService.deleteUser(123);
    }
}

通过上述代码，我们可以看到在 UserService 的方法执行前会输出日志，这就是 AOP 在工作。

以上就是 AOP 的一些基本概念和 Java 代码实现。需要注意的是，Spring 还有很多高级特性和用法，需要深入学习才能掌握。

MVC（模型-视图-控制器）

Spring 提供了一个基于 MVC 模式的 Web 开发框架，它支持多种视图技术，比如 JSP、Freemarker 等。Spring MVC 可以很好地与其他 Spring 组件集成，比如 IoC 和 AOP。 MVC（模型-视图-控制器）是一种常见的软件架构模式，它将应用程序分为三个部分：模型、视图和控制器。Spring MVC 是一个基于 MVC 模式的 Web 框架，它使用了这种模式来组织代码和功能。

下面是对 Spring MVC 的三个核心概念进行详细的解释，并给出相应的 Java 代码示例：

模型(Model)：

模型表示应用程序中的数据和业务逻辑。在 Spring MVC 中，模型通常由 POJO（普通 Java 对象）组成，这些对象负责管理应用程序的状态和行为。以下是一个简单的模型类示例：

public class User {<!-- -->
    private int id;
    private String name;

    public User(int id, String name) {<!-- -->
        this.id = id;
        this.name = name;
    }

    // 省略 getter 和 setter 方法
}

视图(View)：

视图负责渲染模型数据并生成 HTML 输出，以便用户可以看到和交互。在 Spring MVC 中，视图通常是 JSP、Freemarker 或 Thymeleaf 文件。以下是一个简单的 JSP 视图示例：

&lt;html&gt;
&lt;head&gt;&lt;title&gt;User Profile&lt;/title&gt;&lt;/head&gt;
&lt;body&gt;
    &lt;h1&gt;User Profile:&lt;/h1&gt;
    &lt;h2&gt;ID: ${user.id}&lt;/h2&gt;
    &lt;h2&gt;Name: ${user.name}&lt;/h2&gt;
&lt;/body&gt;
&lt;/html&gt;

控制器(Controller)：

控制器处理客户端请求并返回响应。在 Spring MVC 中，控制器通常是一个带有 @Controller 注解的类，它负责将请求映射到适当的处理方法上，并将模型数据传递给视图。以下是一个简单的控制器示例：

@Controller
public class UserController {<!-- -->
    @RequestMapping("/user/{id}")
    public ModelAndView userProfile(@PathVariable("id") int id) {<!-- -->
        User user = getUserById(id);
        ModelAndView mav = new ModelAndView("user-profile");
        mav.addObject("user", user);
        return mav;
    }

    private User getUserById(int id) {<!-- -->
        // 从数据库或其他数据源中获取用户数据
        User user = new User(id, "John Doe");
        return user;
    }
}

在上面的示例中，@Controller 注解告诉 Spring 这是一个控制器类。@RequestMapping 注解指定了处理 “/user/{id}” URL 的方法。方法中使用 @PathVariable 注解将 URL 中的占位符绑定到方法参数中。getUserById 方法从数据库或其他数据源中获取用户数据，并返回一个 User 对象。最后，方法创建一个 ModelAndView 对象并将模型数据添加到该对象中，然后将其返回。

JDBC Template

JDBC Template 是 Spring 框架中的一个重要组件，它封装了 JDBC 操作，简化了数据库访问的过程，并提供了一些常见的操作方法，比如查询、更新、批量操作等。 JDBC Template 是 Spring 框架中的一个核心组件，它提供了一种简化 JDBC 操作的方式。JDBC Template 封装了常见的 JDBC 操作，使得数据库访问变得更加简单和安全。

下面是对 JDBC Template 的核心概念进行详细的解释，并给出相应的 Java 代码示例：

1. 数据源(DataSource)

数据源是 JDBC Template 连接数据库的重要配置。在 Spring 中，数据源通常由 JNDI、Spring Bean 或其他方式定义。以下是一个简单的数据源配置示例：

&lt;bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"&gt;
    &lt;property name="driverClassName" value="com.mysql.jdbc.Driver"/&gt;
    &lt;property name="url" value="jdbc:mysql://localhost:3306/mydatabase"/&gt;
    &lt;property name="username" value="root"/&gt;
    &lt;property name="password" value="password"/&gt;
&lt;/bean&gt;

2. JDBC Template

JDBC Template 是 Spring JDBC 的核心组件之一。它封装了常见的 JDBC 操作，如查询、更新和批处理等。以下是一个简单的 JDBC Template 配置示例：

@Autowired
private JdbcTemplate jdbcTemplate;

public void addUser(User user) {<!-- -->
    String sql = "INSERT INTO users (id, name, age) VALUES (?, ?, ?)";
    Object[] params = {<!-- -->user.getId(), user.getName(), user.getAge()};
    jdbcTemplate.update(sql, params);
}

在上面的示例中，我们注入了一个 JdbcTemplate 对象，并使用它执行 SQL INSERT 操作。update 方法接受两个参数：SQL 语句和参数数组。它将 SQL 语句和参数传递给数据库，并返回受影响的行数。

3. 数据访问对象(DAO)

数据访问对象是一种设计模式，它封装了对数据库的访问，并提供了一些常见的操作方法。在 Spring 中，我们可以使用 JDBC Template 来实现 DAO。以下是一个简单的 DAO 示例：

@Repository
public class UserDao {<!-- -->
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public List&lt;User&gt; getAllUsers() {<!-- -->
        String sql = "SELECT * FROM users";
        return jdbcTemplate.query(sql, new UserRowMapper());
    }

    private static final class UserRowMapper implements RowMapper&lt;User&gt; {<!-- -->
        public User mapRow(ResultSet rs, int rowNum) throws SQLException {<!-- -->
            int id = rs.getInt("id");
            String name = rs.getString("name");
            int age = rs.getInt("age");
            return new User(id, name, age);
        }
    }
}

在上面的示例中，我们定义了一个 UserDao 类，并注入了一个 JdbcTemplate 对象。getAllUsers 方法使用 query 方法执行 SQL SELECT 操作，并使用 UserRowMapper 对象将结果集映射为 User 对象列表。

以上就是 JDBC Template 的核心概念及相应的 Java 代码示例。JDBC Template 可以大大简化数据库访问的过程，使得开发人员能够更加专注于业务逻辑的实现。

Transaction Management（事务管理）

Spring 提供了多种事务管理方式，支持编程式和声明式两种方式。通过 Spring 的事务管理机制，我们可以很方便地实现数据的一致性和完整性。

事务管理是任何应用程序中必不可少的一部分，它确保应用程序对数据库的操作是原子性、一致性、隔离性和持久性。Spring 提供了多种事务管理方式，并支持编程式和声明式两种方式。

下面是对 Spring 事务管理的核心概念进行详细的解释，并给出相应的 Java 代码示例：

1. 事务(Transaction)

事务是一组相关的操作，它们在一个逻辑单元内执行，并且要么全部成功完成，要么全部回滚。在 Spring 中，事务通常由 @Transactional 注解定义。以下是一个简单的事务定义示例：

@Transactional
public void transferMoney(Account from, Account to, double amount) {<!-- -->
    // 执行转账操作
}

在上面的示例中，@Transactional 注解告诉 Spring 这是一个事务方法。如果该方法成功完成，则所有操作将被提交；否则，所有操作将被回滚。

2. 事务管理器(Transaction Manager)

事务管理器负责协调和管理事务。在 Spring 中，我们可以使用 JdbcTemplate 或 Hibernate 等数据访问技术来执行事务，同时也可以使用 Spring 的事务管理器来控制事务的边界。以下是一个简单的事务管理器配置示例：

&lt;bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"&gt;
    &lt;property name="dataSource" ref="dataSource"/&gt;
&lt;/bean&gt;

3. 编程式事务管理

编程式事务管理通常意味着手动管理事务。在 Spring 中，我们可以使用 TransactionTemplate 对象来完成编程式事务管理。以下是一个简单的编程式事务管理示例：

@Autowired
private DataSource dataSource;

public void transferMoney(Account from, Account to, double amount) {<!-- -->
    TransactionTemplate transactionTemplate = new TransactionTemplate();
    transactionTemplate.setTransactionManager(new DataSourceTransactionManager(dataSource));
    transactionTemplate.execute(status -&gt; {<!-- -->
        // 执行转账操作
        return null;
    });
}

在上面的示例中，我们使用 TransactionTemplate 对象来执行转账操作，并将其包装在一个 Lambda 表达式中。execute 方法接受一个 Lambda 表达式，该表达式包含要在事务内执行的代码。

4. 声明式事务管理

声明式事务管理通常意味着使用 AOP 技术来自动管理事务。在 Spring 中，我们可以使用 @Transactional 注解来定义声明式事务。以下是一个简单的声明式事务管理示例：

@Transactional
public void transferMoney(Account from, Account to, double amount) {<!-- -->
    // 执行转账操作
}

在上面的示例中，@Transactional 注解告诉 Spring 这是一个事务方法。如果该方法成功完成，则所有操作将被提交；否则，所有操作将被回滚。

以上就是 Spring 事务管理的核心概念及相应的 Java 代码示例。通过 Spring 的事务管理机制，我们可以很方便地实现数据的一致性和完整性，从而确保应用程序的正确性和可靠性。