当前位置：首页 > article >正文

【Java】【Spring框架】【复习】1

article 2024/12/25 2:13:30

Java-Spring框架-复习-1

注：本文基于《Java EE 企业级应用开发教程》（第2版）黑马程序员编著整理

1 Spring 介绍

1.1 Spring 概述

一个分层的 JavaSE/EE 一站式（full-stack）轻量级开源框架
核心理念： 控制反转（IoC）和面向切面编程（AOP）
- IoC： Spring 的基础，支撑着 Spring 对 Java Bean 的管理功能；
- AOP： Spring 的重要特性，通过预编译方式和运行期间动态代理实现程序功能（即，可以在不修改源代码的情况下，为程序统一添加功能）。
在表现层、业务逻辑层和持久层的作用：
- 表现层： 提供 Spring MVC 框架
- 业务逻辑层： 管理事务、记录日志
- 持久层： 可以整合 MyBatis、Hibernate、JdbcTemplate 等技术

1.2 Spring 框架的优点

非侵入式设计
降低耦合性，方便开发
支持 AOP 编程
支持声明式事务
方便程序的测试
方便集成各种优秀框架
降低 Java EE API 的使用难度

1.3 Spring 的体系结构

Spring体系结构

Spring 主要分为八大模块，上面的灰色背景模块是 Spring 的主要模块

核心容器
- Beans 模块
- Core 模块
- Contest 模块
- SpEL 模块
数据访问及集成
- JDBC 模块
- ORM 模块
- OXM 模块
- JMS 模块
- Transactions 模块
Web
- WebSocket 模块
- Servlet 模块
- Web 模块
- Portlet 模块
其他模块
- AOP 模块
- Aspects 模块
- Instrumentation 模块
- Messaging 模块
- Test 模块

2 控制反转和依赖注入

2.1 控制反转的概念

控制反转（Inversion of Control，缩写为 IoC）是面向对象编程中的一个设计原则，用来降低程序代码之间的耦合度。

在传统面向对象编程中，获取对象的方式是用new关键字主动创建一个对象，也就是说应用程序掌握着对象的控制权。

传统面向对象程序设计原则

IoC 控制反转机制指的是对象由 IoC 容器统一管理，当程序需要使用对象时，可以直接从 IoC 容器中获取。这样对象的控制权就从应用程序转移到了 IoC 容器。

IoC设计原则

2.2 依赖注入的概念

依赖注入（Dependency Inject，缩写DI）就是由 IoC 容器在运行期间动态地将某种依赖资源注入对象之中。

例如： 将对象B注入（赋值）给对象A的成员变量。
基本思想： 明确地定义组件接口，独立开发各个组件，然后根据组件的依赖关系组装运行。

2.3 依赖注入的类型

构造方法注入
属性 setter 方法注入

构造方法注入

Spring 容器调用构造方法注入被依赖的实例，构造方法可以是有参的或者是无参的。Spring 在读取配置信息后，会通过反射方式调用实例的构造方法，如果是有参构造方法，可以在构造方法中传入所需的参数值，最后创建类对象。

编写用户类： 新建 User1 类，在 User1 类中定义 id、name 和 password 三个属性

public class User1{
    private int id;
    private String name;
    private String password;
    
    // 有参构造函数
    public User1(int id,String name,String password){
        this.id=id;
        this.name=name;
        this.password=password;
    }
}

获取Bean的配置信息： 创建 applicationContext-User.xml 文件，在该文件中添加 User1 类的配置信息
```
<bean id="user1" class="cn.lzjtu.User1">
    <constructor-arg name="id" value="001"></constructor-arg>
    <constructor-arg name="name" value="张三"></constructor-arg>
    <constructor-arg name="password" value="123456"></constructor-arg>
</bean>
```
一个元素表示构造方法的一个参数，且定义时不区分顺序，只需要通过元素的 name 属性指定参数即可。元素还提供了 type 属性类指定参数的类型，避免字符串和基本数据类型的混淆。

编写测试类： 创建测试类 TestUser1，用于测试依赖注入的结果

public class TestUser1{
    public static void main(String[] args)throws Exception{
        // 加载 applicationContext.xml 配置
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext-Uesr1.xml");
        // 获取配置中的 User1 实例
        User1 user1=applicationContext.getBean("user1",User1.class);
        System.out.println(user1);
    }
}

属性setter方法注入

Spring最主流的注入方法，这种注入方法简单、直观，它是在被注入的类中声明一个setter方法，通过setter方法的参数注入对应的值。

编写用户类： 新建 User2 类，在 User2 类中定义 id、name 和 password 三个属性

public class User2 {
    private int id;
    private String name;
    private String password;
    
    // getter/setter 方法
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

获取Bean的配置信息： 创建 applicationContext-User2.xml 文件，并在该文件的 bean 元素中添加 User2 类的配置信息

<bean id="user2" class="cn.lzjtu.User2">
    <property name="id" value="002"></property>
    <property name="name" value="李四"></property>
    <property name="password" value="123456"></property>
</bean>

编写测试类： 创建测试类 TestUser2，用于测试依赖注入的结果

public class TestUser2{
    public static void main(String[] args)throws Exception{
        // 加载 applicationContext.xml 配置
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext-User2.xml");
        // // 获取配置中的 User2 实例
        User2 user2=applicationContext.getBean("user2",User2.class);
        System.out.println(user2);
    }
}