<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.2.6.RELEASEversion>
dependency>
public class User {
private Integer id;
private String name;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
规范:Spring官方没有对配置文件的 名字|位置 规定规范,但是开发通常将配置文件放到/resource/applicationContsext.xml中。
<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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean name="user" class="com.leo.domain.User">bean>
beans>
public class App {
public static void main(String[] args) {
//1.创建spring容器
ApplicationContext ac =
new ClassPathXmlApplicationContext("applicationContsext.xml");
//2.从spring容器中获得user对象
User user = (User) ac.getBean("user");
System.out.println(user);
}
}
ApplicationContext是更加常用的容器类型;
BeanFactory是spring框架刚刚出现时,诞生的原始的容器类型;
ApplicationContext是spring框架后续随着发展诞生的拥有更多功能的容器类型;
ApplicationContext接口是BeanFactory接口的子类,ApplicationContext拥有BeanFactory的全部功能;
BeanFactory是只具备容器的基本功能;
ApplicationContext对容器功能进行了极大的丰满:
IOC:inverse of control 反转控制。
理解:开发人员以前创建对象时,都是需要用到什么对象就去手动创建什么对象,如果对象中有依赖关系存在,就需要手动去维护依赖关系,例如:我们需要A对象,但A对象依赖于B对象,我们就需要先手动创建B对象,然后手动创建A对象,再把B对象注入到A对象中,总结说,就是整个对象的生命周期都是由开发人员手动维护的。
上面这段话可以理解为传统的控制方式,或者说正向的控制对象方式。
什么是反转控制呢?
将对象的创建以及依赖关系的注入全部交给程序帮我们完成,而不再是由我们自己去控制你程序完成,那么就可以称之为反转控制,反转的是对象的创建方式。
DI:Dependency Injection 依赖注入
理解: 将依赖的属性注入到对象的过程,即为依赖注入。
例如:Servlet依赖于Service,Service依赖于Dao等,我们将Service注入到Servlet的过程就是依赖注入,依赖注入的方 式有两种,一种是set方法注入,还用一种是构造方法注入,这两种方式,Spring都支持。
我们要实现IOC设计必须要有DI技术的支持。
<bean name="user" class="com.leo.domain.User">
bean>
工厂方法:
public class UserFactory {
//创建User对象并返回
public static User getUser1(){
User u = new User();
u.setName("jerry");
u.setId(2);
return u;
}
}
配置文件:
<bean name="user2" class="com.leo.factory.UserFactory" factory-method="getUser1">bean>
测试:
public class App {
public static void main(String[] args) {
//1.创建spring容器
ApplicationContext ac =
new ClassPathXmlApplicationContext("applicationContsext.xml");
//2.从spring容器中获得user对象
User user = (User) ac.getBean("user2");
System.out.println(user);
}
}
工厂方法:
//创建User对象并返回 -> 动态工厂方法
public User getUser2(){
User u = new User();
u.setName("jack");
u.setId(3);
return u;
}
xml配置:
<bean name="userFactory" class="com.leo.factory.UserFactory">bean>
<bean name="user3" factory-bean="userFactory" factory-method="getUser2">bean>
测试:
public class App {
public static void main(String[] args) {
//1.创建spring容器
ApplicationContext ac =
new ClassPathXmlApplicationContext("applicationContsext.xml");
//2.从spring容器中获得user对象
User user = (User) ac.getBean("user3");
System.out.println(user);
}
}
配置:
<bean name="user4" class="com.leo.domain.User" scope="singleton" destroy-method="destory" init-method="init">bean>
测试:
@Test
public void fun1() {
//1.创建spring容器
ApplicationContext ac =
new ClassPathXmlApplicationContext("applicationContsext.xml");
//2.从spring容器中获得user对象
//同一个User4只存在一个实例
User user1 = (User) ac.getBean("user4");
User user2 = (User) ac.getBean("user4");
//true => 只有一个User4实例(singleton)
//false => 每次从容器中获取的都是不同的对象(prototype)
System.out.println(user1 == user2);
}
@Test
public void fun2() {
//1.创建spring容器 -> 创建所有singleton对象
ClassPathXmlApplicationContext ac =
new ClassPathXmlApplicationContext("applicationContsext.xml");
//2.关闭spring容器 -> 销毁所有singleton对象
ac.close();
}