【Spring】——Spring的创建与使用
目录
一、传统程序开发与控制反转
1、传统程序开发
传统程序开发的缺陷
解决传统开发中的缺陷
2、控制反转思维程序开发
3 对比总结规律
二、Spring创建与使用
1、创建Spring
Ⅰ、创建Maven项目
Ⅱ、添加Spring框架支持
Ⅲ、添加启动类
注意：maven 项目下载 jar 失败的解决方案
Ⅰ、配置好国内的Maven源
配置国内源
Ⅱ、重新下载jar包
Ⅲ、其他问题
2.存储 Bean 对象
Ⅰ、创建Bean
Ⅱ、将 Bean 注册到容器
3.获取并使用Bean 对象
Ⅰ、获取Spring对象
多学一招：ApplicationContext与BeanFactory（常见面试题）
Ⅱ、获取指定的 Bean 对象
Ⅲ、使用Bean对象
多学一招：getBean 方法的更多用法
Ⅰ、根据类型获取 Bean：
Ⅱ、根据名称 + 类型获取 Bean
两种方法的区别
操作流程图
Spring_冷兮雪的博客-CSDN博客
上期我们讲解了Spring是什么及Spring的核心特点，其中重点讲解了控制反转（IoC）和依赖注入（DI），下面我们通过示例代码来去更深刻了解这其中的含义。
一、传统程序开发与控制反转
1、传统程序开发
在传统开发中，如果我们现在想构建⼀辆“⻋”的程序，我们的实现思路是这样的：
构建⼀辆车（Car Class），然而车需要依赖车身(FrameWork Class)，而车身需要依赖底盘（Bottom Class），而底盘需要依赖轮胎（Tire Class），最终程序的实现代码如下
public class NewCarExample {
public static void main(String[] args) {
Car car = new Car();
car.init();
}
/**
* 汽⻋对象
*/
static class Car {
public void init() {
// 依赖⻋身
Framework framework = new Framework();
framework.init();
}
}
/**
* ⻋身类
*/
static class Framework {
public void init() {
// 依赖底盘
Bottom bottom = new Bottom();
bottom.init();
}
}
/**
* 底盘类
*/
static class Bottom {
public void init() {
// 依赖轮胎
Tire tire = new Tire();
tire.init();
}
}
/**
* 轮胎类
*/
static class Tire {
public void init() {
// 尺⼨
int size = 30;
System.out.println("轮胎尺⼨：" + size);
}
}
}
传统程序开发的缺陷
以上程序中，轮胎的尺寸的固定的，然而随着对的车的需求量越来越大，个性化需求也会越来越多，这时候我们就需要加工多种尺寸的轮胎，那这个时候就要对上面的程序进行修改了，修改后的代码如下所示：
public class NewCarUpdateExample {
public static void main(String[] args) {
Car car = new Car(20);
car.run();
}
/**
* 汽⻋对象
*/
static class Car {
private Framework framework;
public Car(int size) {
framework = new Framework(size);
}
public void run() {
// 依赖⻋身
framework.init();
}
}
/**
* ⻋身类
*/
static class Framework {
private Bottom bottom;
public Framework(int size) {
bottom = new Bottom(size);
}
public void init() {
// 依赖底盘
bottom.init();
}
}
/**
* 底盘类
*/
static class Bottom {
private Tire tire;
public Bottom(int size) {
tire = new Tire(size);
}
public void init() {
// 依赖轮胎
tire.init();
}
}
/**
* 轮胎类
*/
static class Tire {
// 尺⼨
private int size;
public Tire(int size) {
this.size = size;
}
public void init() {
System.out.println("轮胎尺⼨：" + size);
}
}
}
从以上代码可以看出，以上程序的问题是：当最底层代码改动之后，整个调用链上的所有代码都需要修改。
解决传统开发中的缺陷
如何解决上述问题呢？
我们可以尝试不在每个类中自己创建下级类，如果自己创建下级类就会出现当下级类发生改变操作，自己也要跟着修改。
此时，我们只需要将原来由自己创建的下级类，改为传递的方式（也就是注入的方式），因为我们不需要在当前类中创建下级类了，所以下级类即使发生变化（创建或减少参数），当前类本身也无需修改任何代码，这样就完成了程序的解耦。
PS：解耦指的是解决了代码的耦合性，耦合性也可以换⼀种叫法叫程序相关性。好的程序代码的耦合 性（代码之间的相关性）是很低的，也就是代码之间要实现解耦。
这就好比我们打造⼀辆完整的汽车，如果所有的配件都是自己造，那么当客户需求发生改变的时候， 比如轮胎的尺寸不再是原来的尺寸了，那我们要自己动手来改了，但如果我们是把轮胎外包出去，那么即使是轮胎的尺寸发生改变了，我们只需要向代理工厂下订单就行了，我们自身是不需要出力的。
2、控制反转思维程序开发
基于以上思路，我们把调用汽车的程序示例改造⼀下，把创建子类的方式，改为注入传递的方式，具体实现代码如下：
public class IocCarExample {
public static void main(String[] args) {
Tire tire = new Tire(20);
Bottom bottom = new Bottom(tire);
Framework framework = new Framework(bottom);
Car car = new Car(framework);
car.run();
}
static class Car {
private Framework framework;
public Car(Framework framework) {
this.framework = framework;
}
public void run() {
framework.init();
}
}
static class Framework {
private Bottom bottom;
public Framework(Bottom bottom) {
this.bottom = bottom;
}
public void init(){
bottom.init();
}
}
static class Bottom {
private Tire tire;
public Bottom(Tire tire) {
this.tire = tire;
}
public void init() {
tire.init();
}
}
static class Tire {
private int size;
public Tire(int size) {
this.size = size;
}
public void init() {
System.out.println("轮胎：" + size);
}
}
}
代码经过以上调整，无论底层类如何变化，整个调用链是不用做任何改变的，这样就完成了代码之间的解耦，从而实现了更加灵活、通用的程序设计了。
3 对比总结规律
在传统的代码中对象创建顺序是：Car -> Framework -> Bottom -> Tire
改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car
我们发现了⼀个规律：通用程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了Framework，Framework创建并创建了 Bottom，依次往下，而改进之后的控制权发生的反转，不再是上级对象创建并控制下级对象了，而是下级对象把注⼊将当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发生任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。
我们理解到了Spring的核心，下面我们来开始写第一个Spring代码。
二、Spring创建与使用
1、创建Spring
下面我们通过Maven 方式来创建⼀个 Spring 项目，具体可以分为三步：
- 创建⼀个普通 Maven 项目。
- 添加 Spring 框架支持（spring-context、spring-beans）。
- 创建一个普通类和main方法运行Spring框架。
Ⅰ、创建Maven项目
Ⅱ、添加Spring框架支持
创建好了之后，在pom.xml添加 Spring 框架支持
添加的框架有 spring-context：spring 上下文，还有 spring-beans：管理对象的模块。
org.springframework
spring-context
5.2.3.RELEASE
org.springframework
spring-beans
5.2.3.RELEASE
添加之后
4.0.0
org.example
springdemo
1.0-SNAPSHOT
8
8
org.springframework
spring-context
5.2.3.RELEASE
org.springframework
spring-beans
5.2.3.RELEASE
Ⅲ、添加启动类
在创建好的项目 java 文件夹下创建⼀个启动类，包含 main 方法即可：
public class App {
public static void main(String[] args) {
}
}注意：maven 项目下载 jar 失败的解决方案
Ⅰ、配置好国内的Maven源
检查项⼀共有两个：
1. 确认右边的两个勾已经选中，如果没有请点击选中。
2. 检查 User Settings file 的 settings.xml 文件是否存在：
a. 如果不存在，复制下面配置了国内源的 settings.xml 文件，放到 User Settings file 目录下。
b. 如果存在，检查 settings.xml 是否配置了国内源。
注意：两个路径中都不能出现中文！不能出现中文！不能出现中文！（重要的事说三遍）
配置国内源
可以在Settings->搜索maven中 找到settings.xml 文件
配置的国内源的 settings.xml 配置如下：
C:\Users\intel\.m2\repository
alimaven
aliyun maven
http://maven.aliyun.com/nexus/content/groups/public/
central
Ⅱ、重新下载jar包
经过了第一步配置好国内maven源之后，一定要先配置好第一步！多检查几遍，然后删除本地存储 jar 包的目录，本地存储 jar 包的目录如下：
删除本地jar目录中的所有文件，切换到 Idea 中，重新下载 jar 包，如下图所示
待下载完成，如果还是下载失败那就是本地网速问题，重复步骤 1 和步骤 2 直到下载成功！
Ⅲ、其他问题
如果经过上面配置，还是下载不了，那么有可能是以下问题：
- 上面的步骤没看仔细，可能遗漏了其中一步；
- Maven 路径中出现中文：出现中文会 导致下载的jar 包，在项目中不能正常使用；
- 当前网络运营商有问题：当前所在区域连接的网络运营商（中国电信、移动..）连接数据源有问题，尝试更好网络，使用手机热点或朋友的手机热点尝试，如果还是不行，就等三四个小时之后再试。
2.存储 Bean 对象
存储 Bean 分为以下 2 步：
- 先创建⼀个 Bean。
- 将创建的 Bean 注册到 Spring 容器中。
Ⅰ、创建Bean
所谓的 Bean 就是 Java 语言中的⼀个普通对象，我们写一个简单的 hello word 代码
public class User {
public String sayHi(String name){
return "hello"+name;
}
}
Ⅱ、将 Bean 注册到容器
在创建好的项目中添加 Spring 配置文件 spring-config.xml，将此文件放到 resources 的根目录下， 如下图所示：
创建：
创建之后
Spring 配置文件的固定格式为以下内容：
然后再将 User 对象注册到 Spring 中就可以，具体操作是在 中添加如下配置：
3.获取并使用Bean 对象
获取并使用 Bean 对象，有以下 3 步：
- 得到 Spring 上下文对象，因为对象都交给 Spring 管理了，所以获取对象要从 Spring 中获取，那么就得先得到 Spring 的上下文。
- 通过Spring 上下文，获取某⼀个指定的 Bean 对象。
- 使用Bean 对象。
Ⅰ、获取Spring对象
ApplicationContext：来自于Spring框架的接口。通过这个接口去获取Spring对象。
多学一招：ApplicationContext与BeanFactory（常见面试题）
BeanFactory是以前的老方法了，现在已经被弃用，或者说现在比较少用了
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
public class App {
public static void main(String[] args) {
//1、获取spring对象
BeanFactory context = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
//2、从Spring中取出Bean对象 根据名称 + 类型获取 Bean
User user= (User) context.getBean("user",User.class);//输出hello张三
//3、使用Bean（可选）
System.out.println(user.sayHi("张三"));
}
}ApplicationContext VS BeanFactory
相同点：
- 都可以得到 Spring 上下文对象。
- 都是来自 Spring 的接口。
不同点
1、继承关系和功能: 虽然都是Spring 容器的接口，但 ApplicationContext 属于 BeanFactory 的子类 。其中BeanFactory提供了基础的访问容器的能力，ApplicationContext除了继承BeanFactory 的所有功能之外，它还拥有独特的特性，还添加了对国际化支持、资源访问支持、以及事件传播等方面的支持。2、性能：ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象，而BeanFactory 是需要哪个才去加载哪个，因此更加轻量。
Ⅱ、获取指定的 Bean 对象
然后通过getBean方法取出Bean对象
注意：Bean 的 Id 要⼀⼀对应：
Ⅲ、使用Bean对象
我们现在就可以使用Bean，然后调用其中的方法了
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对象
User user= (User) context.getBean("user");
//3、使用Bean（可选）
System.out.println(user.sayHi("李四"));
}
}
多学一招：getBean 方法的更多用法
getBean() 方法有很多种重载方法，我们也可以使用其他方式来获取 Bean 对象，比如以下这两种：
Ⅰ、根据类型获取 Bean：
User user= (User) context.getBean(User.class);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对象 Ⅰ、根据类型获取Bean
User user= (User) context.getBean(User.class);
//3、使用Bean（可选）
System.out.println(user.sayHi("张三"));
}
}
Ⅱ、根据名称 + 类型获取 Bean
User user= (User) context.getBean("user",User.class);两种方法的区别
当有⼀个类型被重复注册到 spring-config.xml 中时，只能使用 根据名称+类型获取了，比如以下程序
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对象 Ⅰ、根据类型获取Bean
User user= (User) context.getBean(User.class);//报错
//Ⅱ、根据名称 + 类型获取 Bean
//User user= (User) context.getBean("user",User.class);//输出hello张三
//3、使用Bean（可选）
System.out.println(user.sayHi("张三"));
}
public static void main1(String[] args) {
//1、获取spring对象
ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
//2、从Spring中取出Bean对象
User user= (User) context.getBean("user");
//3、使用Bean（可选）
System.out.println(user.sayHi("李四"));
}
}
操作流程图
