Spring 创建和使用

String 的创建和使用

上一篇博客, 我们了解到, Spring 就是一个包含了众多工具和方法的 IoC 容器. 所以他就有两个最基本的功能:

• 将对象存储到容器 (Spring) 中
• 从容器中把对象 (bean) 取出来

1. 创建 Spring 对象

打开 IDEA 使用 Maven 方式来创建一个 Spring 项目

1.1 创建一个 Maven 项目

此处一定注意路径中不能有中文, 空格
项目名一般都用小写字母, 用 - 隔开

这样就创建好了一个 Maven 项目

1.2 添加 Spring 依赖(极其重要)

这里我们需要配置 Maven 国内源

1). 检测 Maven 的配置是否正确,

idea 的设置文件有两个, 一个是当前项目的配置文件, 另一个是新项目的配置文件. 我们需要把这两个都配置好

如果目录下没有 settings.xml 文件, 使用下面的文件

settings.xml

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  

  

  

  
  <pluginGroups>
    
  pluginGroups>

  
  <proxies>
    
  proxies>

  
  <servers>
    

    
  servers>

  
  <mirrors>
   <mirror>
        <id>alimavenid>
        <name>aliyun mavenname>
        <url>http://maven.aliyun.com/nexus/content/groups/public/url>
        <mirrorOf>centralmirrorOf>        
      mirror>
    
  mirrors>

  
  <profiles>
    

    
  profiles>

  
settings>

2). 然后重新下载 jar 包

在下载之前, 一定记得先清理一下之前没有下载好的文件

找到这个文件, 清空里面所有内容,

点进去, 全选, 删除

然后重新进行下载

接来来我们就可以添加依赖了

首先打开 Maven 仓库, 搜索 spring, 选择 Spring Context

我们进来看到有很多版本, 我们这里使用 5.x 的, 因为我们使用的是 JDK8

点个 5.x 版本的进去, 复制代码

复制到 pom.xml.
首先创建一个 标签, 然后粘贴到里面

如果显示标红, 手动刷新一下

3). 创建启动类

这样我们就创建好了一个 Spring 项目

---

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

2.1 创建一个 Bean

在 Java 中一个对象如果被使用多次, 就可以称之为 Bean

public class Student {
    public void sayHello() {
        System.out.println("hello");
    }
}

2.2 将 Bean 存到 Spring 容器中

创建一个 File, 配置文件

复制代码到刚才创建的文件

spring-config.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 http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
   
beans>

然后把 Bean 存储到 Spring 容器中

<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 http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    
    <bean id="student" class="Student"> bean>
beans>

注意这里的 class 如果在包里, 得写包名.类名. 比如

2.3 从 Spring 容器中读取到 Bean

得到 Spring (上下文) 对象

Spring 上下⽂对象可使⽤ ApplicationContext

// 1.得到 Spring 的上下⽂对象，创建的时候需要配置 Spring 配置信息
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");

除了 ApplicationContext 之外，我们还可以使⽤ BeanFactory 来作为 Spring 的上下⽂，如下代码所示：

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));

1. 得到 Spring

2. 从 Spring 中获取到 Bean 对象

这两处的名称必须得对应

3. 使用 Bean

import com.spring.demo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        // 1. 得到 Spring
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        // 2. 从 Spring 中获取到 Bean
        Student student =  (Student)context.getBean("student");
        // 传统方式
        // Student student1 = new Student();

        // 3. 使用 Bean (非必须)
        student.sayHello();
    }
}

4. 验证

最后我们运行验证一下

3. ApplicationContext VS BeanFactory

我们针对上面的代码稍作修改, 给各自类加上构造方法.

package com.spring.demo;

public class Student {
    public Student() {
        System.out.println("do student init");
    }
    public void sayHello() {
        System.out.println("hello");
    }
}

package com.spring.demo;

public class Teacher {
    public Teacher() {
        System.out.println("do teacher init");
    }
    public void sayHi() {
        System.out.println("hi");
    }
}

import com.spring.demo.Teacher;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class App2 {
    public static void main(String[] args) {
        // 1. 得到 Spring
        BeanFactory beanFactory =
                new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
        // 2. 从 Spring 容器中获取 Bean
        Teacher teacher = (Teacher) beanFactory.getBean("teacher");
        // 使用 bean
        teacher.sayHi();
    }
}

import com.spring.demo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        // 1. 得到 Spring
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");

        // 2. 从 Spring 中获取到 Bean
        Student student =  (Student)context.getBean("student");
        // 传统方式
        // Student student1 = new Student();

        // 3. 使用 Bean (非必须)
        student.sayHello();
    }
}

然后执行main

执行 ApplicationContext 打印结果

执行 BeanFactory 打印结果

---

我们再进行调整, 只进行得到 Spring

观察类关系

上述我们看到:

• 使用 ApplicationContext 打印结果 , 会将 xml 中所有的对象存储到 spring 容器中(进行实例化)

• 使用 BeanFactory 打印结果, 可见它是属于 惰性加载(lazy load), 只有调用 getBean 才会去加载对应的Bean

特征:

• 使用 ApplicationContext 比较费内存, 一次性加载, 之后读取就会非常快
• 使用 BeanFactory 节省内存, 调用的时候才会加载初始化 bean 到 spring 中, 所以效率不高.
• 继承关系和功能⽅⾯来说：Spring 容器有两个顶级的接⼝：BeanFactory 和 ApplicationContext。其中 BeanFactory 提供了基础的访问容器的能⼒，⽽ ApplicationContext 属于 BeanFactory 的⼦类，它除了继承了 BeanFactory 的所有功能之外，它还拥有独特的特性，还添加了对国际化⽀持、资源访问⽀持、以及事件传播等⽅⾯的⽀持。
• 从性能⽅⾯来说：ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象，⽽
  BeanFactory 是需要哪个才去哪载那个，因此更加轻量。

---

4. 获取 Bean 的三种方式

1. 通过名称获取

Student student =  (Student)context.getBean("student");

2. 通过类型方式获取

Student student = context.getBean(Student.class);

这种方式看着简洁, 但是如果 spring 中 存储了多个同种类型的变量, 就会出问题

3. 根据名称和类型查找对象(推荐)

Student student = context.getBean("stu", Student.class);

---

总结:

1. 创建 Spring 项目
   a. 创建一个 maven 项目
   b. 添加 Spring-context 依赖
   c. 创建一个启动类(为后面从 spring 容器中获取 bean 对象)
2. 存储 Bean
   a. 先创建 Bean 对象
   b. 通过 Spring 配置文件 (spring-config.xml)

<bean id="bean名称" class="包名.类名"> < /bean>

3. 读取 Bean
   a. 得到 Spring 的对象(ApplicationContext 或 BeanFactory)
   b. 通过 Spring 对象 getBean 方法获取到 Bean 对象(DI操作)
   c. 使用 Bean (非必须)