JavaEE Spring~带你初步理解Spring(Bean容器、IOC、DI) 知道Spring框架配置使用流程
文章目录
- 认识Spring
- 开发中使用Spring框架的好处
- Spring体系结构
- 使用Spring框架需要配置的pom.xml文件
- 怎么理解我们的Spring
- bean元素常用属性
- 代码演示
- 总结Spring框架配置使用的流程
认识Spring
- Spring 是另一个主流的 Java Web 开发框架，该框架是一个轻量级的应用框架，具有很高的凝聚力和吸引力。
- 在实际开发中，通常服务器端采用三层体系架构，分别为表现层（web）、业务逻辑层（service）、持久层（dao）。
- Spring 对每一层都提供了技术支持，在表现层提供了与 Struts2 框架的整合，在业务逻辑层可以管理事务和记录日志等，在持久层可以整合 Hibernate 和 JdbcTemplate 等技术。
- 从设计上看，Spring 具有简单、可测试和松耦合等特点, 所以Spring 框架给予了 Java 程序员更高的自由度.
开发中使用Spring框架的好处
(1）方便解耦，简化开发
Spring 就是一个大工厂，可以将所有对象的创建和依赖关系的维护交给 Spring 管理。
(2）方便集成各种优秀框架
Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如 Struts2、Hibernate、MyBatis 等）的直接支持。
(3）降低 Java EE API 的使用难度
Spring 对 Java EE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等）都提供了封装，使这些 API 应用的难度大大降低。
(4）方便程序的测试
Spring 支持 JUnit4，可以通过注解方便地测试 Spring 程序。
(5）AOP 编程的支持
Spring 提供面向切面编程，可以方便地实现对程序进行权限拦截和运行监控等功能。
(6）声明式事务的支持
只需要通过配置就可以完成对事务的管理，而无须手动编程。
Spring体系结构
- 我们常说的Spring其实是Spring Framework
- Spring Framework 框架采用分层架构，根据不同的功能被划分成了多个模块，这些模块大体可分为 Data Access/Integration、Web、AOP、Aspects、Messaging、Instrumentation、Core Container 和 Test
- Core Container 这是核心容器 是其他模块建立的基础 由Beans Core核心模块 Context上下文模块 和Expression Language 表达语言模块组成
- Bean模块提供了BeanFactory 是工厂模式的经典实现 Spring将管理对象称为Bean
- Core模块 提供了Spring框架的基本组成部分 包括IOC和DI功能
- Context模块 上下文模块 建立在核心和Bean模块的基础之上 他是访问定义和配置任何对象的媒介
- Expression Language模块 是运行时传和操作对象图的强大的表达式语言
Date Acc/Integration 是数据访问 集成层包括(JDBC ORM OXM等等)
Web 这层包括Web Servlet Struts和Porlet组件 可以极大的简化我们基于BS架构开发的项目
AOP 模块：提供了面向切面编程实现，允许定义方法拦截器和切入点，将代码按照功能进行分离，以降低耦合性。
Aspects 模块：提供与 AspectJ 的集成，是一个功能强大且成熟的面向切面编程（AOP）框架。
Instrumentation 模块：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。
Test 模块：支持 Spring 组件，使用 JUnit 或 TestNG 框架的测试。
使用Spring框架需要配置的pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>spring-study</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!-- Spring 需要的依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<!-- 日志需要的依赖 -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
</project>
怎么理解我们的Spring
- 理解Spring主要理解Core Container核心容器的三个核心
- Bean容器: 是提供管理Java对象的容器
- IOC : BeanFactory为IOC提供了完整的服务支持 简单来说, BeanFactory 就是一个管理 Bean容器所有对象的工厂，它主要负责初始化各种 Bean，并调用它们的生命周期方法。所以IOC是在在开发过程中 实例的创建不由调用者管理 , 而是由Spring创建并管理, Spring 容器会负责控制程序之间的关系，而不是由程序代码直接控制，因此，控制权由程序代码转移到了 Spring 容器中，控制权发生了反转，这就是 Spring 的 IOC 思想。
- DI : DI的含义是依赖的注入 其实还是给Bean容器中所有的对象提供服务支持, 本质就是给bean对象注入依赖属性 让每一个对象更加完整 更加有意义.
使用依赖注入有俩种方式:
- 属性setter注入: 指 IoC 容器使用 setter 方法注入被依赖的实例。通过调用无参构造器或无参 static 工厂方法实例化 bean 后，调用该 bean 的 setter 方法，即可实现基于 setter 的 DI
- 构造方法注入: 指 IoC 容器使用构造方法注入被依赖的实例。基于构造器的 DI 通过调用带参数的构造方法实现，每个参数代表一个依赖
bean元素常用属性
- 需要让属性有 public 权限或者 setter 有 public 权限
- 基本数据类型 + String 用 value，其他引用类型用 ref
- 如果要使用集合，有 map、list、set 等直接使用
| id | 是一个 Bean 的唯一标识符，Spring 容器对 Bean 的配置和管理都通过该属性完成
| name | Spring 容器同样可以通过此属性对容器中的 Bean 进行配置和管理，name 属性中可以为 Bean 指定多个名称，每个名称之间用逗号或分号隔开
| class | 该属性指定了 Bean 的具体实现类，它必须是一个完整的类名，使用类的全限定名
| scope | 用于设定 Bean 实例的作用域，其属性值有 singleton（单例）、prototype（原型）、request、session 和 global Session。其默认值是 singleton
| constructor-arg | 元素的子元素，可以使用此元素传入构造参数进行实例化。该元素的 index 属性指定构造参数的序号（从 0 开始），type 属性指定构造参数的类型
| property | 元素的子元素，用于调用 Bean 实例中的 Set 方法完成属性赋值，从而完成依赖注入。该元素的 name 属性指定 Bean 实例中的相应属性名
| ref | 和 等元素的子元索，该元素中的 bean 属性用于指定对 Bean 工厂中某个 Bean 实例的引用
| value | 和 等元素的子元素，用于直接指定一个常量值
| list | 用于封装 List 或数组类型的依赖注入
| set | 用于封装 Set 类型属性的依赖注入
| map | 用于封装 Map 类型属性的依赖注入
| entry | 元素的子元素，用于设置一个键值对。其 key 属性指定字符串类型的键值，ref 或 value 子元素指定其值
代码演示
- Person类
package Listen;
/**
* Created with IntelliJ IDEA.
* Description: If you don't work hard, you will a loser.
* User: Listen-Y.
* Date: 2020-08-10
* Time: 20:54
*/
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
- Teacher类
package Listen;
/**
* Created with IntelliJ IDEA.
* Description: If you don't work hard, you will a loser.
* User: Listen-Y.
* Date: 2020-08-11
* Time: 15:25
*/
public class Teacher {
private Person person;
private String teacherId;
public Teacher() {
}
public Teacher(Person person, String teacherId) {
this.person = person;
this.teacherId = teacherId;
}
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
public String getTeacherId() {
return teacherId;
}
public void setTeacherId(String teacherId) {
this.teacherId = teacherId;
}
@Override
public String toString() {
return "Teacher{" +
"person=" + person +
", teacherId='" + teacherId + '\'' +
'}';
}
}
- School类
package Listen;
import java.util.List;
/**
* Created with IntelliJ IDEA.
* Description: If you don't work hard, you will a loser.
* User: Listen-Y.
* Date: 2020-08-11
* Time: 15:26
*/
public class School {
private List<Teacher> teachers;
private String schoolName;
public School() {
}
public School(List<Teacher> teachers, String schoolName) {
this.teachers = teachers;
this.schoolName = schoolName;
}
public List<Teacher> getTeachers() {
return teachers;
}
public void setTeachers(List<Teacher> teachers) {
this.teachers = teachers;
}
public String getSchoolName() {
return schoolName;
}
public void setSchoolName(String schoolName) {
this.schoolName = schoolName;
}
@Override
public String toString() {
return "School{" +
"teachers=" + teachers +
", schoolName='" + schoolName + '\'' +
'}';
}
}
- 配置文件中的配置项的每个bean对象
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 通过bean这个标签定义bean对象 Spring Bean容器是通过id来进行管理的 id代表的意思就是Spring可以通过id找到Bean
如果没有提供id 会默认生成一个首字母小写的类名 一般建议都是写id的
默认是单例模式-->
<!-- 通过无惨的构造方法创建一个对象 如果该类型没有无惨的构造方法 就会报错 所以这个只支持有参构造方法 -->
<bean id="love" class="java.lang.String" >
<constructor-arg value="love" />
</bean>
<!-- 如果构造方法是无惨的可以使用这种进行设置属性 上面的叫构造方法注入 这叫属性setter注入(简称属性注入) -->
<bean id="person" class="Listen.Person">
<property name="name" value="listen" />
<property name="age" value="21" />
</bean>
<!-- 通过构造方法创建一个person实例 -->
<bean id="person2" class="Listen.Person">
<constructor-arg name="name" value="frank" />
<constructor-arg name="age" value="20" />
</bean>
<bean id="person3" class="Listen.Person">
<property name="name" value="jake" />
<property name="age" value="22" />
</bean>
<!-- 分别使用依赖注入和属性注入 创建实例 -->
<bean id="teacher1" class="Listen.Teacher">
<constructor-arg name="person" ref="person" />
<constructor-arg name="teacherId" value="5201314"/>
</bean>
<bean id="teacher2" class="Listen.Teacher">
<property name="person" ref="person2" />
<property name="teacherId" value="7654321" />
</bean>
<bean id="teacher3" class="Listen.Teacher">
<property name="person" ref="person3" />
<property name="teacherId" value="1234567" />
</bean>
<!-- 注入带有集合的属性 -->
<bean id="school" class="Listen.School">
<property name="teachers">
<list>
<ref bean="teacher1" />
<ref bean="teacher2" />
<ref bean="teacher3" />
</list>
</property>
<property name="schoolName" value="HappySchool" />
</bean>
</beans>
- 根据容器获取bean并且使用bean对象
import Listen.Person;
import Listen.School;
import Listen.Teacher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
//加载配置文件
//Spring开启容器的方式就是应用上下文(可以配置管理bean对象 及其他工作)
//根据classpath路径 指定一个配置文件
//根据配置文件完成配置工作(如bean的实例化)
ApplicationContext context = new
ClassPathXmlApplicationContext("applications.xml");
//通过bean的名称获取bean对象
String love = (String)context.getBean("love");
System.out.println(love);
//通过类型获得bean对象 如果该类型有多个对象 就会报错 只支持一个该类型的对象 返回的是一个泛型对象可以忽略强转
String love1 = context.getBean(String.class);
System.out.println(love1);
System.out.println("====测试自定义类====");
Person person = (Person) context.getBean("person");
System.out.println(person);
Person person2 = (Person)context.getBean("person2");
System.out.println(person2);
Person person3 = (Person)context.getBean("person3");
System.out.println(person3);
Teacher teacher1 = (Teacher)context.getBean("teacher1");
System.out.println(teacher1);
Teacher teacher2 = (Teacher)context.getBean("teacher2");
System.out.println(teacher2);
Teacher teacher3 = (Teacher)context.getBean("teacher3");
System.out.println(teacher3);
School school = (School)context.getBean("school");
System.out.println(school);
}
}
- 运行结果
16:15:44.050 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@6504e3b2
16:15:44.337 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 8 bean definitions from class path resource [applications.xml]
16:15:44.403 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'love'
16:15:44.495 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'person'
16:15:44.530 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'person2'
16:15:44.533 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'person3'
16:15:44.534 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'teacher1'
16:15:44.544 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'teacher2'
16:15:44.547 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'teacher3'
16:15:44.548 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'school'
love
love
====测试自定义类====
Person{name='listen', age=21}
Person{name='frank', age=20}
Person{name='jake', age=22}
Teacher{person=Person{name='listen', age=21}, teacherId='5201314'}
Teacher{person=Person{name='frank', age=20}, teacherId='7654321'}
Teacher{person=Person{name='jake', age=22}, teacherId='1234567'}
School{teachers=[Teacher{person=Person{name='listen', age=21}, teacherId='5201314'}, Teacher{person=Person{name='frank', age=20}, teacherId='7654321'}, Teacher{person=Person{name='jake', age=22}, teacherId='1234567'}], schoolName='HappySchool'}
Process finished with exit code 0
总结Spring框架配置使用的流程
- 加载配置文件 (加载.xml文件)
- 初始化: 根据配置文件中的配置项 进行初始化
- 使用: 根据容器获取到bean对象 (通过我们定义的配置项中的id获取 可以通过类型获取 但是如果该类型有多个对象 就会报错)