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

目录

🍧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. 获取 BeanUserService userService = (UserService) context.getBean("user");// 3. 使用 BeanuserService.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. 获取 BeanUserService 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);

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/28088.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

自动化测试selenium(1)

自动化测试selenium(1)

自动化测试&#x1f4ea;selenium 自动化测试&#x1f4ea;selenium自动化测试&#x1f4d1;selenium定位元素&#x1f4cd; 实战测试百度搜索&#x1f50d;安装测试环境Idea中进行自动化脚本编写打开网页&#xff1a;实现搜索功能&#xff1a;浏览器清空效果clear()&#xff1…
阅读更多...
使用typora+PicGo+Gitee简单实现图片上传功能

使用typora+PicGo+Gitee简单实现图片上传功能

本文通过配置PicGoGitee来实现typora图片上传功能&#xff0c;系统是window 注意下载的清单有&#xff1a;PicGo&#xff0c;node.js&#xff0c;配置有&#xff1a;PicGo&#xff0c;node.js&#xff0c;gitee&#xff0c;typora 看着复杂实际上并不难&#xff0c;只是繁琐&am…
阅读更多...
基于时域特征和频域特征组合的敏感特征集，再利用CNN进行轴承故障诊断(python编程)

基于时域特征和频域特征组合的敏感特征集，再利用CNN进行轴承故障诊断(python编程)

1.文件夹介绍&#xff08;使用的是CWRU数据集&#xff09; 0HP-3HP四个文件夹装载不同工况下的内圈故障、外圈故障、滚动体故障和正常轴承数据。 2.模型 按照1024的长度分割样本&#xff0c;构建内圈故障、外圈故障、滚动体故障和正常轴承样本集 2.1.计算11种时域特征值 # 计…
阅读更多...
专题-【线索二叉树】

专题-【线索二叉树】

15年三-1&#xff09; 20年一-11&#xff09;
阅读更多...
MYSQL表操作（DML,DDL)

MYSQL表操作（DML,DDL)

建表并插入数据&#xff1a; mysql> create table worker(-> dept_id int(11) not null,-> emp_id int (11) not null,-> work_time date not null,-> salary float(8,2) not null,-> poli_face varchar(10) not null default 群众,-> name varchar(20) …
阅读更多...
【云原生】k8s图形化管理工具之rancher

【云原生】k8s图形化管理工具之rancher

前言 在前面的k8s基础学习中&#xff0c;我们学习了各种资源的搭配运用&#xff0c;以及命令行&#xff0c;声明式文件创建。这些都是为了k8s管理员体会k8s的框架&#xff0c;内容基础。在真正的生产环境中&#xff0c;大部分的公司还是会选用图形化管理工具来管理k8s集群&…
阅读更多...
『分割』 平面模型分割

『分割』 平面模型分割

PCL提供的几个常见模型&#xff1a; pcl::SACMODEL_PLANE&#xff1a;平面模型&#xff0c;用于拟合平面结构的点云数据。 pcl::SACMODEL_SPHERE&#xff1a;球体模型&#xff0c;适用于拟合球体结构的点云数据。 pcl::SACMODEL_CYLINDER&#xff1a;圆柱体模型&#xff0c;用…
阅读更多...
Java阶段五Day08

Java阶段五Day08

Java阶段五Day08 文章目录 Java阶段五Day08内容回顾学习内容目的自动配置原理SPI-API:一对类似的概念 自定义Starter属性配置问题 网关组件SpringCloud Gateway网关架构微服务网关介绍Spring Cloud Gateway&#xff08;技术选型&#xff09;网关转发入门案例明确案例需求实现案…
阅读更多...
LCD-STM32液晶显示中英文-（5.字符编码）

LCD-STM32液晶显示中英文-（5.字符编码）

目录 字符编码 字符编码说明参考网站 字符编码 ASCII编码 ASCII编码介绍 ASCII编码表 中文编码 1. GB2312标准 区位码 2. GBK编码 3. GB18030 各个标准的对比说明 4. Big5编码 字符编码 字符编码说明参考网站 字符编码及转换测试&#xff1a;导航菜单 - 千千秀字 …
阅读更多...
Linux5.17 Ceph应用

Linux5.17 Ceph应用

文章目录 计算机系统5G云计算第四章 LINUX Ceph应用一、创建 CephFS 文件系统 MDS 接口1.服务端操作2.客户端操作 二、创建 Ceph 块存储系统 RBD 接口三、创建 Ceph 对象存储系统 RGW 接口四、OSD 故障模拟与恢复 计算机系统 5G云计算 第四章 LINUX Ceph应用 一、创建 CephF…
阅读更多...
C语言#define和宏

C语言#define和宏

C语言#define和宏 #define定义标识符#define定义宏#define的替换规则# 和 ####的作用带副作用的宏参数宏和函数对比命名约定 #define定义标识符 #define MAX 1000 #define reg register //为 register这个关键字&#xff0c;创建一个简短的名字 reg #define do_forev…
阅读更多...
不满足于RPC，详解Dubbo的服务调用链路

不满足于RPC，详解Dubbo的服务调用链路

系列文章目录 【收藏向】从用法到源码&#xff0c;一篇文章让你精通Dubbo的SPI机制 面试Dubbo &#xff0c;却问我和Springcloud有什么区别&#xff1f; 超简单&#xff0c;手把手教你搭建Dubbo工程&#xff08;内附源码&#xff09; Dubbo最核心功能——服务暴露的配置、使用…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023