Spring的创建与使用

目录

1.创建 Spring 项⽬  

1.1 创建一个 maven 项目

1.2 添加 spring 框架支持(spring-context/spring-beans)

 2.将 Bean (对象) 存储到 Spring (容器) 中

2.1 在resources中创建一个spring配置文件

2.2 将 Bean 对象存储到 Spring 当中

2.2.1 创建 Bean 对象

2.2.2 将Bean对象配置到spring配置文件中

2.3 从Spring 中读取到Bean对象

2.3.1 得到 Spring (上下文)对象

2.3.2 取出 Bean 对象

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 对象三步(两步)走

1. 如果是第一次添加, 先在 spring 项目中添加配置文件
2. 先创建一个 Bean 对象
3. 在配置文件中将需要保存到 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