目录
1.2 添加 spring 框架支持(spring-context/spring-beans)
2.将 Bean (对象) 存储到 Spring (容器) 中
3.ApplicationContext与BeanFactory
3.1 经典面试问题: ApplicationContext 与 BeanFactory 有什么区别?
3.2 ApplicationContext与BeanFactory的加载问题
1.创建 Spring 项⽬
1.1 创建一个 maven 项目
输入项目名就可以了
1.2 添加 spring 框架支持(spring-context/spring-beans)
先配置镜像国内源
接下来我们需要找到setting.xml去配置国内源
在setting.xml中找到<mirrors>添加一个阿里云的url
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>central</mirrorOf>
</mirror>
然后再添加Spring框架支持
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
</dependencies>
(3) 创建一个启动类并添加 main
2.将 Bean (对象) 存储到 Spring (容器) 中
存储 Bean 对象三步(两步)走
- 如果是第一次添加, 先在 spring 项目中添加配置文件
- 先创建一个 Bean 对象
- 在配置文件中将需要保存到 spring 中的 Bean 对象进行注册
2.1 在resources中创建一个spring配置文件
不管html,xml...只要不是java代码都是资源文件
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>
2.2 将 Bean 对象存储到 Spring 当中
2.2.1 创建 Bean 对象
2.2.2 将Bean对象配置到spring配置文件中
id相当于我给bean起了一个别名/名称(不能重复,相当于主键)
类似于:域名
class相当于对象本身:包名+类名
类似于:IP
我们可以通过直接访问class,但是通常情况下对象本身是复杂的(包名是非常的长且复杂的),我们可以像IP一样,因为IP不好记,我们可以通过访问域名一样来访问IP
这里我们就是通过访问id来访问对象
2.3 从Spring 中读取到Bean对象
2.3.1 得到 Spring (上下文)对象
ApplicationContext:来自于spring framework,是jar包底下的,就代表spring本身,因为它来自于spring,使用可以说就是spring的化身
这里的new ClassPathXmlApplicationContext("spring-config.xml")意思是通过xml的方式来得到spring的上下文对象
2.3.2 取出 Bean 对象
1.根据 Bean 的名称(标识)来得到 Bean 对象的
到了我们后期的Spring学习中我们可以把所有的对象都创建好,在我们需要使用的时候直接拿就好了
spring的加载是懒加载,虽然我们已经把类放给spring了,但是不是在spring使用的时候就会加载,只有真正调用的时候才加载不使用的时候是不会占用资源的,是不会加载的
2.根据 Bean 类型来获取 Bean
直接返回泛型,不用强转了
这样的方法还是存在问题的
当xml配置文件当中,一个类包含了多个对象的时候,两则则打起来了
问题:当spring当中存在相同的对象时,使用类型来获取bean的方式就会报错,实际用途并不多
但是实际上对于第一个使用名称来获取对象的方式也是不完美的,当我们getBean()的时候得到的是一个null,并且还要进行强转的时候是会出问题的
3.根据 Bean 名称+Bean类型获取Bean对象
3.ApplicationContext与BeanFactory
除了ApplicationContext之外,我们还可以使用BeanFactory 来作为Spring的上下文,如下代码示:
3.1 经典面试问题: ApplicationContext 与 BeanFactory 有什么区别?
相同点:
1.都可以得到spring上下文对象/Ioc容器
2.都来自spring的顶级接口
不同点:
1.继承关系和功能: ApplicationContext属于BeanFactory 的子类;BeanFactory只有最基础访问Bean 的能力,而ApplicationContext除了拥有BeanFactory功能之外,还包含了更多的功能,如:国际化支持、资源访问、事件传播等。
2.性能: ApplicationContext 加载方式是将Bean对象一次性加载,所以在后面访问Bean对象时会很快;BeanFactory需要某个Bean时,采取加载 Bean对象,所以它在执行 Bean获取时,比较慢,因此更为轻量。
3.2 ApplicationContext与BeanFactory的加载问题
到这里我不禁会问,ApplicationContext不是懒加载吗,为什么会一次性加载呢?
ApplicationContext 是根据设备的硬件条件以及综合情况来决定,在初始化的时候加载多一些还是少一些的,当spring判断你的条件就比较差的时候会优先加载重要的部分,甚至懒加载;但是当我们使用服务器的时候,内存资源和CPU资源都是很丰富的他就会转换另一种策略,牺牲资源换取速度。
包括他也会根据你的需求来判断的,像我这次写的代码的需求根据你的代码spring来进行优化和配置是一个智能的分配,所需要的内存和其他条件不是很大的情况下,他还是实现一次性加载(饿汉模式)当内存等资源不够用的时候就是懒汉模式了
实例:
当我们使用的是BeanFactory的时候
我们在User类中添加构造方法
//普通 Bean 对象
public class User {
public User(){
System.out.println("这里是User的构造方法!");
}
public String sayHi(){
return "Hello,World!";
}
}
同时我们修改App中的代码如:
public class APP {
public static void main(String[] args) {
// 1.先得到 spring 对象
BeanFactory context = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
System.out.println("准备开始得到 Bean 对象了");
// 2.从 spring 中取出 bean 对象
User user = context.getBean("user",User.class);//根据 Bean 名称+Bean类型获取Bean对象
// 3.使用Bean(可选)
System.out.println(user.sayHi());
}
}
我们得到的结果是
从这里我们不难看出 BeanFactory 是懒加载的方式,在需要 Bean 时才加载
对于BeanFactory
BeanFactory context = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));是spring初始化的过程
spring初始化好了之后是没有去加载对象的,只有它调用getBean()的时候才加载对象的,说明BeanFactory是懒汉模式
当我们修改App代码如:
public class APP {
public static void main(String[] args) {
// 1.先得到 spring 对象
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
System.out.println("准备开始得到 Bean 对象了");
// 2.从 spring 中取出 bean 对象
User user = context.getBean("user",User.class);//根据 Bean 名称+Bean类型获取Bean对象
// 3.使用Bean(可选)
System.out.println(user.sayHi());
}
}
我们得到的结果为
这里可以看出 ApplicationContext 是一次性加载并初始化所有 Bean 对象了
ApplicationContext的spring是先加载的,在加载的时候new了那个对象,是一起执行的,先启动自身的类,然后去将xml重的类给实例化保存到spring中
在System.out.println("准备开始得到 Bean 对象了");打印之前
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
System.out.println("准备开始得到 Bean 对象了");
就是整个spring的启动过程,当实例化完了实例对象后才打印,这就是ApplicationContext