【Spring——Spring的基础与创建】

最新推荐文章于 2023-07-23 20:57:00 发布
最新推荐文章于 2023-07-23 20:57:00 发布
阅读量324 收藏
点赞数
分类专栏： Java 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41233305/article/details/131763095
版权

目录

🍧1. 什么是 Spring ？

🫖1.1 容器

🍙1.2 IoC

🥽1.3 汽车类——传统写法

🍘1.4 汽车类——IoC 写法

🌭2. 配置 maven 国内源

🌮2.1 在设置中勾选文件

🍤2.2 在 settings.xml 中配置国内源

🍥2.3 删除本地仓库的所有 jar 包，重新下载

🍢3. 创建一个 Spring 项目

🥣3.1 创建一个普通的 Maven 项目

🍬3.2 添加 Spring 依赖

🫖3.3 创建一个启动测试类

🥮4. ApplicationContext 与 BeanFactory 

🍚5. getBean 的多种写法

🍭5.1 根据 名称 获取 Bean 对象

🧃5.2 根据 类型 获取 Bean 对象 

🍉5.3 根据 名称 + 类型 获取 Bean 

1. 什么是 Spring ？

Spring 指的是 Spring Framework (Spring 框架)，用一句话来概括 Spring，那就是就 Spring 是包含了众多工具方法的 IoC 容器。将这个定义进一步拆分去理解的话，那就变成，什么是容器？什么是 IoC 容器了。

1.1 容器

直观上去理解，那就是容器是用来装东西的，像水杯拿来装水的。之前的文章中介绍的各种数据结构，像 List / Map / LinkedList 等，这些都是存储数据的容器。而 Tomcat ，则是 Web 容器。

1.2 IoC

Spring 是一个 IoC 容器。IoC = Inversion of Control，翻译成中文就是 “控制权反转”。在传统的程序开发中，对象的生命周期都是由程序员来控制的。程序员需要在哪个节点 new 一个对象，就手动创建。而在 Spring 中，对象的生命周期，不再由程序员或当前的代码片段来控制，而是由 Spring 来控制，即实现了控制权的翻转。听起来有点抽象，但通过下面列举的案例，会让同学们对控制权反转的概念有进一步的印象。

1.3 汽车类——传统写法

package Traditional;

public class Car {
    private Framework framework;

    public Car(){
        this.framework = new Framework();
    }

    public void init(){
        System.out.println("Car init");
        framework.init();
    }
}
package Traditional;

public class Framework {
    private Bottom bottom;

    public Framework(){
        this.bottom = new Bottom();
    }

    public void init(){
        System.out.println("Framework init");
        bottom.init();
    }
}

package Traditional;

public class Bottom {
    private Tire tire;

    public Bottom(){
        this.tire = new Tire();
    }

    public void init(){
        System.out.println("Bottom init");
        tire.init();
    }
}
package Traditional;

public class Tire {
    private int size = 15;

    public void init(){
        System.out.println("执行了 Tire init， size："+size);
    }
}
package Traditional;

public class Test {
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

 输出：

Car init
Framework init
Bottom init
执行了 Tire init， size：15

如果当我们想自定义轮胎的大小，而不是上面写的那样默认是 15 时，代码就必须修改成以下形式：

package Traditional;

public class Tire {
    private int size = 15;

    public Tire(int size){
        this.size = size;
    }

    public void init(){
        System.out.println("执行了 Tire init， size："+size);
    }
}
package Traditional;

public class Bottom {
    private Tire tire;

    public Bottom(int size){
        this.tire = new Tire(size);
    }

    public void init(){
        System.out.println("Bottom init");
        tire.init();
    }
}
package Traditional;

public class Car {
    private Framework framework;

    public Car(int size){
        this.framework = new Framework(size);
    }

    public void init(){
        System.out.println("Car init");
        framework.init();
    }
}
package Traditional;

public class Test {
    public static void main(String[] args) {
        Car car = new Car(20);
        car.init();
    }
}

输出：

Car init
Framework init
Bottom init
执行了 Tire init， size：20

当需要设定轮胎尺寸的时候，牵一发动全身，依次修改了所有类。

1.4 汽车类——IoC 写法

package IoC;

public class Car {
    private Framework framework;
    public Car(Framework framework){
        this.framework = framework;
    }
    public void init(){
        System.out.println("Car init");
        framework.init();
    }
}
package IoC;

public class Framework {
    private Bottom bottom;
    public Framework(Bottom bottom){
        this.bottom = bottom;
    }
    public void init(){
        System.out.println("Framework init");
        bottom.init();
    }
}
package IoC;

public class Bottom {
    private Tire tire;
    public Bottom(Tire tire){
        this.tire = tire;
    }
    public void init(){
        System.out.println("Bottom init");
        tire.init();
    }
}
package IoC;

public class Tire {
    private int size = 15;
    public Tire(int size){
        this.size = size;
    }
    public void init(){
        System.out.println("Tire init, Size:"+size);
    }
}
package IoC;

/*
* 模拟 IoC
 */
public class Test {
    private Tire tire;
    private Bottom bottom;
    private Framework framework;
    private Car car;
    public Test(){
        this.tire = new Tire(100);
        this.bottom = new Bottom(this.tire);
        this.framework = new Framework(this.bottom);
        this.car = new Car(this.framework);
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.car.init();
    }
}

输出：

Car init
Framework init
Bottom init
Tire init, Size:100

可以看到，后面要修改轮胎尺寸只要在 Test 的构造方法里修改即可。也就表明了，IoC 这种方法，让类与类之间进行了解耦合。

2. 配置 maven 国内源

2.1 在设置中勾选文件

为了成功创建 Spring / Spring Boot，需要配置 maven 国内源。IDEA 中，有两份配置文件，所以在后续的配置过程中，要设置两次：给当前的项目配置以及给以后的新项目进行配置，如下图：

勾选 settings.xml 配置文件以及本次仓库文件如下： 

 

2.2 在 settings.xml 中配置国内源

 有上述文件的用户，需要将以下代码复制到<mirrors><mirrors>标签里面，完成国内源的配置：

<mirror>
        <id>alimaven</id>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <mirrorOf>central</mirrorOf>        
</mirror>

2.3 删除本地仓库的所有 jar 包，重新下载

C:\Users\92002\.m2\repository

 删除该文件夹下的所有文件。

3. 创建一个 Spring 项目

3.1 创建一个普通的 Maven 项目

出现上述情况，便是 maven 国内源配置成功。

3.2 添加 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>

3.3 创建一个启动测试类

创建一个 Bean 对象

package com.IoC.demo;

public class UserService {
    public void sayHi(){
        System.out.println("Hi, UserService ~");
    }
}

将 Bean 存储到 Spring 中

在 resources 下创建一个文件，以让人知道意思的方式进行命名，此处命名为 spring_config.xml ，在这个文件里面添加以下代并添加 Bean 对象：

<?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">
    <bean id="user" class="com.IoC.demo.UserService"></bean>
</beans>

 创建一个测试类来获取 Bean 对象

import com.IoC.demo.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        // 1. 先得到 spring 上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring_config.xml");
        // 2. 获取 Bean 对象【依赖查找 -》 IoC 的一种实现方式】
        UserService userService = (UserService) context.getBean("user");
        // 3. 使用 Bean 对象（非必须）
        userService.sayHi();
    }
}

 

4. ApplicationContext 与 BeanFactory 

前面使用了 ApplicationContext 来得到 Spring 的上下文对象，下面使用 BeanFactory 来进行同样的操作：

import com.IoC.demo.UserService;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class Test2 {
    public static void main(String[] args) {
        // 1. 得到 Spring 上下文对象
        BeanFactory context =
                new XmlBeanFactory(new ClassPathResource("spring_config.xml"));
        // 2. 获取 Bean
        UserService userService = (UserService) context.getBean("user");
        // 3. 使用 Bean
        userService.sayHi();
    }
}

可以得到一样的结果。那二者有何区别呢？

相同点：两者都是容器管理对象，都可以获取 Bean，但要知道的是，BeanFactory 已经被弃用。

不同点：

1. ApplicationContext 是 BeanFactory 的子类，子类拥有父类的所有属性，也就意味着 ApplicationContext 拥有更多的功能。

2. 加载 Bean 的机制不同：BeanFactory 懒加载，按需加载，即使用一个 Bean，才加载一个 Bean，而 ApplicationContext 会一次性加载所有的 Bean 对象，虽然在一开始的时候会比较的慢，但后续获取对象飞快。

下面通过给 Bean 对象创建构造方法来看看这两种不同的加载方式把：

package com.IoC.demo;

public class UserService {
    public UserService(){
        System.out.println("hello~");
    }
    public void sayHi(){
        System.out.println("Hi, UserService ~");
    }
}

对于 ApplicationContext 来说： 

import com.IoC.demo.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        // 1. 先得到 spring 上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring_config.xml");
//        // 2. 获取 Bean 对象【依赖查找 -》 IoC 的一种实现方式】
//        UserService userService = (UserService) context.getBean("user");
//        // 3. 使用 Bean 对象（非必须）
//        userService.sayHi();
    }
}

 而对于 BeanFactory 来说：

import com.IoC.demo.UserService;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class Test2 {
    public static void main(String[] args) {
        // 1. 得到 Spring 上下文对象
        BeanFactory context =
                new XmlBeanFactory(new ClassPathResource("spring_config.xml"));
//        // 2. 获取 Bean
//        UserService userService = (UserService) context.getBean("user");
//        // 3. 使用 Bean
//        userService.sayHi();
}
}

import com.IoC.demo.UserService;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class Test2 {
    public static void main(String[] args) {
        // 1. 得到 Spring 上下文对象
        BeanFactory context =
                new XmlBeanFactory(new ClassPathResource("spring_config.xml"));
        // 2. 获取 Bean
        UserService userService = (UserService) context.getBean("user");
//        // 3. 使用 Bean
//        userService.sayHi();
  }
}

 

5. getBean 的多种写法

5.1 根据 名称 获取 Bean 对象

UserService userService = (UserService) context.getBean("user");

5.2 根据 类型 获取 Bean 对象 

UserService userService = context.getBean(UserService.class);

 这样就不需要强制类型转换了。但这里存在一个问题，那就是如果像 Spring 中注入多个同一类型的 Bean 对象该怎么办？

<bean id="user" class="com.IoC.demo.UserService"></bean>
<bean id="user1" class="com.IoC.demo.UserService"></bean>

 IDEA 便会报错，说找到了两个，不知道是哪个：

 

5.3 根据 名称 + 类型 获取 Bean 

UserService userService = context.getBean("user",UserService.class);

是Christy的博客呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring项目的创建
xhhhx_的博客
07-01 3149
spring项目的创建、bean对象的简单创建、获取及使用；2种方法获取spring配置文件中的bean对象以及二者的区别；BeanFactory与ApplicationContext
Spring Boot ——Spring回顾——Spring基础
菜园子丶For丨丶Tomorrow的博客
10-17 158
一、概述 Spring框架是一个轻量级的企业级开发的一站式解决方案。Spring框架主要提供了IoC容器、AOP、数据访问、Web开发、消息、测试等相关技术的支持。 二、基础配置 1、Spring框架四大原则 1）使用POJO进行轻量级和最小侵入式开发 2）通过依赖注入和基于接口编程实现松耦合 3）通过AOP和默认习惯进行声明式编程 4）使用AOP和模板减少模块化代码 2、依赖注入...
Spring创建和使用
c_study__c的博客
04-17 325
Spring创建和使用以及对象获取的操作流程详细解析
Spring的创建与使用
如风暖阳的博客
12-04 1877
Spring的创建与使用
Spring 的创建和使用
最新发布
1226
07-23 765
操作容器之前，先要有容器，所以先要得到容器存对象创建 Bean（普通类）将 Bean 注册（配置）到 spring-confing.xml 中取对象得到 Spring 上下文，并读取到 Spring 的配置文件获取某⼀个 Bean 对象使用 Bean 对象。
Spring进阶——Spring使用和Bean创建原理
qq_39308401的博客
09-24 1385
1. IOC `Inverse Of Controll`:控制反转反转了依赖关系的满足方式，由之前的自己创建依赖对象，变为由工厂推送。(变主动为被动，即反转)解决了具有依赖关系的组件之间的强耦合，使得项目形态更加稳健 2. DI `Dependency Injection`：依赖注入全新的依赖满足方式，体现在编码中就是全新的赋值方式 ==> `在工厂中为属性推送值`如：`<proper...
初识Spring——Spring核心容器
02-24
而控制反转就是把传统程序中需要实现对象的创建、代码的依赖，反转给一个专门的"第三方"即容器来实现，即将创建和查找依赖对象的控制权交给容器，由容器将对象进行组合注入，实现对象与对象的松耦合，便于功能的复用...
dubbo——与spring boot整合1
08-04
在本篇内容中，我们将探讨如何将Apache Dubbo与Spring Boot进行整合，创建一个服务提供者（Provider）和一个服务消费者（Consumer）。首先，我们来理解一下这两个关键组件的定义：服务提供者是指实现了特定接口并...
SpringCloud——服务的注册与发现Eureka
09-11
SpringCloud是中国开发者广泛使用的微服务框架之一，其中Eureka是其核心组件，主要负责服务的注册与发现。本文将深入探讨Eureka的工作原理、配置以及如何在实际项目中使用它来构建服务注册中心和实现服务提供者的...
Spring(三)如何创建一个spring项目
03-15
NULL 博文链接：https://wlh269.iteye.com/blog/322607
spring boot整合JPA——demo
01-25
本示例“spring boot整合JPA——demo”将演示如何在Spring Boot项目中配置和使用JPA。 首先，我们需要理解Spring Boot与JPA的关系。Spring Boot是基于Spring框架的快速开发工具，它通过自动化配置减少了常规设置...
Spring基本概念和创建流程
Zincy星辰
07-18 620
SpringFramework）是一个开源框架。其支持广泛的应用场景，可以让Java企业级的应用程序开发起来更简单。IoC容器（InversionofControl）控制反转容器【IoC】实现代码解耦；类的创建顺序与传统相比发生了反转；调用下属类的控制权发生反转【DI】DependencyInjection依赖注入。由IoC容器在运行期间，动态地将某种依赖关系注入到对象中SpringIoC容器的基本功能：存【将对象存储在Spring容器中】取【将对象从Spring容器中取出来】......
如何创建Spring项目以及如何使用？
crazy_xieyi的博客
12-10 4196
Spring 就是⼀个包含了众多⼯具⽅法的 IoC 容器，它具备两个最基本的功能： 将对象存储到容器（Spring）中；从容器中将对象取出来。使用Spring项目包含以下步骤：1.操作容器之前，先要有容器，所以先要得到容器。2. 存对象（a. 创建 Bean（普通类）。b. 将 Bean 注册（配置）到 spring-confing.xml 中。）3. 取对象（a. 得到 Spring 上下⽂，并读取到 Spring 的配置⽂件。b. 获取某⼀个 Bean 对象。c. 使⽤ Bean 对象。）
如何创建Spring项目？
qq_44769557的博客
07-06 5726
Intellij IDEA开发。 新建Spring 项目 1、创建Spring的maven项目 2、创建maven 3、起一个项目的名字 4.finish，完成。 配置依赖 1.导入spring的jar包，在pom.xml中添加下面的代码，点击Load一下maven就会自动导入了 <dependencies> <dependency> <groupId>org.springframework</groupId>
使用IDEA创建一个spring项目详细步骤
热门推荐
星月昭铭的博客
04-26 7万+
第一次使用idea创建spring项目的小伙伴可能都会碰到各种问题，我也老是碰到问题，所以写个博客巩固下，方便以后使用，好了 闲话就不多说了 开始 首先得做个准备工作（电脑里得有idea和maven），项目所使用得包都是使用maven导入，所以没下载maven的还得下一个maven. 打开idea，新建项目(不是社区版，社区版没有JavaEE功能) 一个使用maven的java项目就新...
简单的spring项目搭建流程
YXAAA520的博客
08-05 4903
一个简单的spring项目搭建流程
spring 搭建手动版实战
qq_39094614的博客
07-15 199
1. 获取spring 框架jar包在http://maven.springframework.org/release/org/springframework/spring/里选择不同的框架2.
如何搭建spring环境
weixin_40129969的博客
06-09 2214
idea里面的spring环境搭建
Spring源码分析——bean对象创建过程
Spring源码分析.docx是一份详细的关于Spring源码中bean对象创建过程的文件。在这份文件中，作者详细描述了在Spring框架中bean对象的创建过程，包括了8个步骤： 1、创建工厂，到达 BeanDefintion 步骤； 2、调用 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值