文章目录

• 🌴前言
• 🎋创建 Spring 项⽬
• • 🚩创建⼀个 Maven 项⽬
  • 🚩添加 Spring 框架⽀持
  • 🚩添加启动类
  • 🌳存储 Bean 对象
  • • 🚩创建Bean
    • 🚩将 Bean 注册到容器
    • 🌲获取并使⽤ Bean 对象
    • • 🚩创建 Spring 上下⽂
      • 🚩获取指定的 Bean 对象
      • • 🎈使用id获取
        • 🎈根据类型获取 Bean
        • 🎈id+ 类型获取 Bean
        • 🚩使⽤ Bean
        • 🎍 BeanFactory 与 ApplicationContext 的区别
        • • 🚩继承关系和功能⽅⾯
          • 🚩性能⽅⾯
          • ⭕总结

            🌴前言

            Spring 是⼀个包含了众多⼯具⽅法的 IoC 容器，它具备以下两个最基本的功能：

            • 将对象存储到容器（Spring）中；

            • 从容器中将对象取出来。

              在 Java 语⾔中对象也叫做 Bean，所以下文中提到的对象我们以 Bean 著称

              🎋创建 Spring 项⽬

              接下来使⽤ Maven ⽅式来创建⼀个 Spring 项⽬，创建 Spring 项⽬和 Servlet 类似，总共分为以下 3步：

              1. 创建⼀个普通 Maven 项⽬。

              2. 添加 Spring 框架⽀持（spring-context、spring-beans）。

              3. 添加启动类。

              🚩创建⼀个 Maven 项⽬

              

              🚩添加 Spring 框架⽀持

              我们需要添加的框架有

              • spring-context：spring 上下⽂
              • spring-beans：管理对象的模块。

                

                添加支持代码如下：

                    
                    
                        org.springframework
                        spring-context
                        5.2.3.RELEASE
                    
                    
                        org.springframework
                        spring-beans
                        5.2.3.RELEASE
                    
                    
                

                如果此处添加后，出现问题，说明 Maven jar 包下载失败

                相关解决问题请看博主关于《【JavaEE进阶】 Maven jar 包下载失败问题的解决方法》的讲解

                🚩添加启动类

                最后在创建好的项⽬ java ⽂件夹下创建⼀个启动类，包含 main ⽅法即可

                

                🌳存储 Bean 对象

                存储 Bean 分为以下 2 步：

                1. 存储 Bean 之前，先得有 Bean 才⾏，因此先要创建⼀个 Bean。
                2. 将创建的 Bean 注册到 Spring 容器中。

                具体实现如下。

                🚩创建Bean

                所谓的 Bean 就是 Java 语⾔中的⼀个普通对象，实现代码如下：

                

                🚩将 Bean 注册到容器

                在创建好的项⽬中添加 Spring 配置⽂件 spring-config.xml，将此⽂件放到resources 的根⽬录下，如下图所示

                

                Spring 配置⽂件 spring-config.xml 的固定格式为以下内容：

                接下来，再将 User 对象注册到 Spring 中就可以，具体操作是在 中添加如下配置

                

                🌲获取并使⽤ Bean 对象

                获取并使⽤ Bean 对象，分为以下 3 步：

                1. 得到 Spring 上下⽂对象，因为对象都交给 Spring 管理了，所以获取对象要从 Spring 中获取，那么就得先得到 Spring 的上下⽂。

                2. 通过 Spring 上下⽂，获取某⼀个指定的 Bean 对象。

                3. 使⽤ Bean 对象

                如果取多个 Bean 的话重复以上第 2、3 步骤。

                🚩创建 Spring 上下⽂

                Spring 上下⽂对象可使⽤ ApplicationContext，实现代码如下：

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

                

                🚩获取指定的 Bean 对象

                这里我们用 getBean() 这个方法来进行获取

                使用方法我们这里分为三个使用方法：

                🎈使用id获取

                由于返回的是一个Object类

                

                所以我们这里需要进行强转一下

                使用如下：

                // 1.得到 Spring 上下⽂对象
                ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
                // 2.加载某个 bean
                User user = (User) context.getBean("user");
                

                🎈根据类型获取 Bean

                ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
                User user = context.getBean(User.class);
                

                注意：

                • 这种方式由于只是根据类型获取的，当有⼀个类型被重复注册到 spring-config.xml 中时，只能使⽤根据名称获取了，如果有两个对象，则就会报错

                  🎈id+ 类型获取 Bean

                  这种方法与第一种没有什么太大的区别，不过这里的 getBean() 方法返回值是泛型，所以这里不涉及强转

                  

                  ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
                  User user = context.getBean("user",User.class);
                  

                  🚩使⽤ Bean

                  直接使用该对象所有的方法和属性即可

                  

                  🎍 BeanFactory 与 ApplicationContext 的区别

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

                  BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("springconfig.xml"));
                  

                  后续的Bean的获取和使用与ApplicationContext是一样

                  ApplicationContext 属于 BeanFactory 的⼦类，它们的区别如下

                  🚩继承关系和功能⽅⾯

                  Spring 容器有两个顶级的接⼝：BeanFactory 和ApplicationContext。

                  其中 BeanFactory 提供了基础的访问容器的能⼒，⽽ ApplicationContext 属于 BeanFactory 的⼦类

                  它除了继承了 BeanFactory 的所有功能之外，它还拥有独特的特性，还添加了对国际化⽀持、资源访问⽀持、以及事件传播等⽅⾯的⽀持

                  🚩性能⽅⾯

                  ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象，⽽BeanFactory 是需要那个才去加载那个，因此更加轻量

                  举例验证如下：

                  创建两个对象如下：

                  User类

                  public class User {
                      public User() {
                          System.out.println("我是User的构造方法！！！");
                      }
                      public String greet() {
                          return "Hello User";
                      }
                  }
                  

                  User2类

                  public class User2 {
                      public User2() {
                          System.out.println("我是User2的构造方法！！！");
                      }
                      public String greet() {
                          return "Hello User2";
                      }
                  }
                  

                  配置文件如下：

                  

                  ApplicationContext 获取上下文代码如下：

                  import org.springframework.context.ApplicationContext;
                  import org.springframework.context.support.ClassPathXmlApplicationContext;
                  public class TestMain {
                      public static void main(String[] args) {
                          ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
                          System.out.println("ApplicationContext加载getBean()前!!!");
                          User user = context.getBean("user",User.class);
                          System.out.println(user.greet());
                          User2 user2 = context.getBean("user2",User2.class);
                          System.out.println(user2.greet());
                      }
                  }
                  

                  BeanFactory 获取上下文代码如下

                  import org.springframework.beans.factory.BeanFactory;
                  import org.springframework.beans.factory.xml.XmlBeanFactory;
                  import org.springframework.core.io.ClassPathResource;
                  public class TestMain {
                      public static void main(String[] args) {
                          BeanFactory context =  new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
                          System.out.println("BeanFactory加载getBean()前!!!");
                          User user = context.getBean("user",User.class);
                          System.out.println(user.greet());
                          User2 user2 = context.getBean("user2",User2.class);
                          System.out.println(user2.greet());
                      }
                  }
                  

                  我们利用两份相同的代码来看看执行的效果，从而理解ApplicationContext 与 BeanFactory 的区别，执行结果与区别如下：

                  

                  ⭕总结

                  关于《【JavaEE进阶】 Spring 的创建和使⽤》就讲解到这儿，感谢大家的支持，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下！