Spring框架的创建和使用

最新推荐文章于 2024-05-07 10:31:24 发布

陌上烟雨齐

最新推荐文章于 2024-05-07 10:31:24 发布

阅读量737

点赞数 5

分类专栏： Spring 文章标签： spring java 后端

本文链接：https://blog.csdn.net/qq_63525426/article/details/131805868

版权

Spring 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Spring框架概述

什么是Spring框架

我们常说的Spring指的是Spring Framework（Spring 框架），是一个开源的框架，有着活跃且庞大的社区。同时Spring还支持广泛的引用场景，它可以让Java企业级的应用程序开发更加的简单。

总体来说Spring就是包含了众多工具方法的IoC容器。

上面这句话包含了两个重要信息，也是Spring的本质。那么什么是容器，什么又是IoC容器？

什么是容器

我们回想我们之前学过得容器，是干什么的。

比如：

List/Map是存储数据的容器。
Tomcat是存储Web网站的容器。

Spring里面的容器其实也是同样的性质，都是用来存储东西的。具体存储的是就是对象。

什么是IoC容器

在我们知道了什么是容器里面存储的是对象之后，那么IoC容器又是什么呢？

IoC：翻译成中文就是控制翻转的意思，也就说Spring是一个控制翻转的容器。

控制翻转具体控制的是啥，又把什么给翻转了？

对象的生命周期：在传统的开发过程中，对象的生命周期是由程序员直接控制的。然而在Spring中，对象的生命周期不在是程序员控制了，而是交给Spring，让Spring去管理和控制对象的生命周期。Spring本身右具有存储对象和获取对象的能力。控制的就是对象，翻转的就是对象的控制权。

这里的IoC是一种设计思想。

Spring的核心功能

上述描述我们知道了Spring是一个包含了众多工具方法的IoC容器。

既然是容器，那么具备的两个基本的功能：

将对象存储在容器中
从容器中获取对象

也就说Spring最核心的功能就是将对象如何存储到Spring中，再从Spring中如何获取对象的过程。

IoC容器和普通程序开发的区别

将对象存储到IoC容器中的好处：将对象存储到IoC容器中相当于将以后可能会用到的所有工具都制作好放到仓库中，需要的时候直接取就好了，用完再次放到仓库中去。然后普通程序开发是每次需要工具的时候，才先做，也就是new，当这个new出来的对象用完了之后，就直接扔掉，也不会保存，如果下次需要了还得new。这就是IoC容器和普通程序开发的区别。

使用IoC容器还有一个好处就是可以实现代码之间的解耦。

DI

提到IoC,不得不提就是DI，DI是Dependency Injection的缩写，中文就是依赖注入的意思。

所谓的依赖注入，就是在IoC容器运行的过程中，动态的将某种依赖关系注入到对象之中。

依赖注入（DI）和控制翻转（IoC）都是在不同的角度描述一件事情。就是值通过引入IoC容器，利用依赖注入的方式，实现对象直接的解耦。

IoC是一种设计思想，而DI则是一种具体的实现方式。

Spring项目的创建和使用

前面我们说了那么多，那么接下来我们就创建一个Spring项目。

Spring项目创建

Spring项目是通过Maven的方式来创建一个Spring项目，创建Spring项目总共可以分为3步：

创建一个普通的maven项目
添加Spring框架支持（spring-conext、spring-beans）
添加一个启动类。

解下来我们一步一步来：

创建一个maven项目

点击下一步：

添加Spring框架支持

在创建好的项目中，有一个pom.xml文件，在里面添加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>

从上述添加的框架中可以看出，添加的框架有spring-context和spring-beans

spring-context: spring的上下文

spring-beans: spring管理对象的模块

从这里就能看出spring框架与传统开发的区别就是针对对象（在spring中Bean）的管理。

添加一个启动类

最后在创建好的项目中，src/main/java这个路径中创建一个启动类，包含一个main方法即可。

public class App {
    public static void main(String[] args) {
        
    }
}

经过上述步骤之后，我们就成功的创建了一个spring项目。注意在上述创建的过程中，如果出现pom.xml文件里面爆红现象，那么就是maven的国内源没有配置上。关于maven国内源的配置，这里不在过多赘述。

Spring项目的使用

当我们在创建好了spring项目之后，我们就得使用spring项目了。

前面已经说过，spring的核心功能：

存储Bean对象
获取Bean对象

接下来spring的使用也将围绕着这两个Spring的核心功能来使用。

存储Bean对象

在存储Bean对象之前我们先要有Bean对象，这里Bean对象就是就是普通的对象。

我们先创建一个Bean对象：

在src/main/java下面创建了如上目录。

User类如下：

package com.dgz.domo;

public class User {
    private int userId;
    private String name;

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void sayHi() {
        System.out.println("Hi spring");
    }
    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", name='" + name + '\'' +
                '}';
    }
}

这样我们就有了一个Bean对象。

接下来我们需要把这个Bean对象存储到Spring中，在存储之前，我们需要创建一个Spring配置文件。

在resources文件夹下面创建一个spring-config.xml文件：

并在spring-config.xml文件里面添加如下代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:content="http://www.springframework.org/schema/context"
       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对象即可。

接下来我们将User对象注册到Spring中，具体操作是在beans标签中添加一个bean标签，然后在里面添加注册User对象的属性即可。

    <bean id="user" class="com.dgz.domo.User"></bean>

这里id就是我们在将来获取Bean对象的时候需要填写的属性。class为User这个类的具体路径。

经过上述的操作我们就将一个Bean对象完成的注册到（存储到）Spring中去了。

获取并使用Bean对象

获取并使用Bean对象一共分为3步：

得到Spring上下文对象，因为对象都交给Spring去管理了，所以获取要到Spring中获取，那么就要得到Spring的上下文对象。
通过Spring上下文对象，获取某一个指定的Bean对象。
使用Bean对象

获取Spring上下文对象

Spring上下文可以通过使用ApplicationContext来获取到。

我们在启动类中可以通过如下代码来获取上下文对象：


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

除了ApplicationContext之外，我们还可以使用BeanFactory来作为Spring的上下文对象。

如下代码所示：

//使用BeanFactory
        BeanFactory factory = new 
XmlBeanFactory( new ClassPathResource("spring-config.xml"));

这两个获取Spring上下文对象的区别：（面试题）

ApplicationContext和BeanFactory的区别：

ApplicationContext是BeanFactory的子类，ApplicationContext拥有更多功能。
加载Bean的机制不同，BeanFactory懒加载，按需加载，（使用一个bean加载一个Bean） ApplicationContext则是一次性加载所有的Bean对象。
ApplicationContext启动慢，但是启动之后获取对象非常快 BeanFactory启动快，占用内存很少，但是后期获取对象非常慢。

获取指定的Bean对象

如下代码：

public class App {
    public static void main(String[] args) {

        //得到Spring上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //使用BeanFactory
        BeanFactory factory = new XmlBeanFactory( new ClassPathResource("spring-config.xml"));

        //使用ApplicationContext的方式来获取Bean对象
        User user = (User) context.getBean("user");
    }
}

这里需要注意我们在getBean里面的参数是不是很熟悉，这个参数就是我们之前在spring-config.xml文件中配置的id属性。

这里的id要一一对应：

getBean的更多用法：

getBean有很多重载的方法，我们也可以通过其他的方式来获取Bean对象，比如下面这种：

        //根据类型来获取Bean
        User user1 = context.getBean(User.class);

        //根据id+类型来获取Bean
        User user2 = context.getBean("user",User.class);

这两种方式的区别就是当有一个类被重复的注册到spring-config.xml中的时候，就只能使用名称获取了

我们把一个类重复的注册到spring-config.xml中，然后再通过上述两种方式来获取，就会发现报错了。

上述这个错误就是说找到了两个user对象，但是获取的方式无法区分到底是要获取那个Bean，这时就要使用id的获取方式获取id+类型的方式。

使用Bean对象

由于我们之前已经通过各种的方式获取到了Bean对象，这时我们就能使用Bean对象了。

public class App {
    public static void main(String[] args) {
        //得到Spring上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //使用BeanFactory
        BeanFactory factory = new XmlBeanFactory( new ClassPathResource("spring-config.xml"));
        //使用ApplicationContext的方式来获取Bean对象
        //根据id来获取Bean
        User user = (User) context.getBean("user");
        //根据类型来获取Bean
       // User user1 = context.getBean(User.class);
        //根据id+类型来获取Bean
       /* User user2 = context.getBean("user",User.class);
        User user3 = context.getBean("user1",User.class);*/

        //使用Bean对象
        user.sayHi();

    }
}

操作流程

陌上烟雨齐

关注

5
点赞
踩
7

收藏

觉得还不错? 一键收藏
2
评论
Spring框架的创建和使用

常说的Spring指的是Spring Framework（Spring 框架），是一个开源的框架，有着活跃且庞大的社区。同时Spring还支持广泛的引用场景，它可以让Java企业级的应用程序开发更加的简单。总体来说Spring就是包含了众多工具方法的IoC容器。上面这句话包含了两个重要信息，也是Spring的本质。那么什么是容器，什么又是IoC容器？我们回想我们之前学过得容器，是干什么的。List/Map是存储数据的容器。Tomcat是存储Web网站的容器。
复制链接

扫一扫