SpringCore项目的创建和使用

写个堆排

已于 2023-10-31 10:00:20 修改

阅读量989

点赞数 1

文章标签： spring java spring boot

于 2022-10-23 08:56:06 首次发布

本文链接：https://blog.csdn.net/weixin_61518137/article/details/127470346

版权

1.Spring框架的发展史

1.1)IOC思想:

1)实现代码的解耦合

2)对象Bean的生命周期交给IOC框架来维护，程序员无需再进行关注了

1.2)Spring是包含了众多工具方法的IOC容器，既然是容器那么它就有两个最基本的功能:

将对象存储到Spring容器里面，把对象从容器中取出来，在Java中，对象称之为bean

1)最早的Spring项目:2018年的老框架Spring框架，基于maven项目，这种Spring运行方式没有比Servlet有很大的优势，不明显，是需要用到Tomact来进行运行，也是需要到官方找jar包，引入依赖到pom.xml里面；

2)新的Spring项目:SpringBoot项目诞生了，去掉了外部Tomact，并不再使用XML，极大的简化了Spring的开发；

3)现在:2020年之后，还是基于Spring Boot，更先进的，Spring Cloud(基于Spring Boot)

Spring就是一个包含了众多方法的IOC容器，如果说是容器那么它就有两个功能；

1)将对象存储到容器里面

2)从容器中将对象取出来

1)创建Spring项目

配置国内源:

如果是在引入相关依赖失败后进行的国内源配置，就要去本地管理jar包的目录将jar包都进行删除，然后重新刷新下载依赖即可

2)将对象存储在Spring框架里面

3)将对象从Spring框架中读出来:

Spring core项目是用来负责发现、创建并处理bean之间的关系的一个工具包，core把bean的创建，bean的互相注入的方法，定义完毕，上层服务只需要进行调用；

a)创建maven项目

写一下项目的名称以及保存路径

Name:项目名称；

Location:本地目录，项目存储位置；

GroupId:组织信息，域名的倒写(com.bit)；

ArtifactId:项目ID；

我们在现实中是靠GroupId和ArtifactId来进行确定一个唯一项目的，因为不同的公司可能会有相同的项目ID；

Version:版本号，发布版本，Tomact 8.5，Tomact 8.1；

在maven中配置国内源:

1)点击File再次点击Settings，进行搜索maven，将这两个箭头进行打勾重新导入maven；

2)看看setting.xml有没有mirrors；

因为我们不光是配置当前项目的国内源，还是要配置新项目的国内源；

当前还是有一种可能，就是说如果你配置了国内源，你进行添加jar包的时候还是会失败，运行程序还是错误:

原因就是你之前没有配置国内源，导致你当前下载jar包的时候下载了一半，就是这个jar包已经下载到本地仓库了，但是不是完整的，然后你又配置了国内源，配置了国内源你去下载之后要去检测的，会检测你本地仓库里面有没有这个jar包，有，就不下载了，但是他不知道你这个jar包不是一个完整的jar包，我们的解决方案就是点击本地仓库，全选然后删除，有可能是说网络拉夸的问题，然后配置一个更好的校园网；

b)添加Spring框架支持，在maven项目中引入Spring的核心包

2.1)上下文，SpringContext的jar包，做对象管理的一个jar包，SpringBeans；

2.2)添加此jar包彻底变成Spring项目，Spring-Bean的jar包，去中央仓库找不依赖于Tomact，这个使用来管理我们的Bean对象的；

不光会引入这两个包，还会引入这两个包相关的依赖包；

在pom.xml里面存入的依赖
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.3.RELEASE</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.2.3.RELEASE</version>
</dependency>

c)创建启动类添加mian方法

但是需要后面测试对象的存入和取出的，而不是需要Tomact的，如果测试的是SpringWeb项目或者是SpringMVC项目的话，是要依靠Tomact的，当前创建的是Spring Core项目，也就是说是一个最基本的Spring项目，不需要Tomact只需要测试Bean对象的存入和取出；

3)创建启动类，是为了测试spring核心功能，存对象和取对象，我们直接进行创建一个类，里面写一个main方法，当前类启动的时候，咱们的框架也启动了，因为这个类是放在框架里面的，而咱们的框架是Spring框架，也就是说启动此类的时候，那么Spring框架也就随之启动；

4)先进行创建一个业务对象；

5)把业务对象存放到Spring框架之中，在resource里面创建一个xml文件，使用声明式注册的方式来插入到Spring里面，创建<beans>标签，里面再进行创建bean对象；

6)从Spring框架中读取业务对象，先创建上下文对象，实现对Spring的控制；

2)将Bean添加存储到Spring容器中

1)先在Spring项目中添加配置文件，在resource目录下面创建一个xml文件

2)创建Bean对象(创建一个普通的JAVA类文件)；

3)在配置文件里面需要将需要保存在Spring中的Bean对象进行注册，存对象是依靠Key和Value这样的键值对来进行存储的，Key就是我们自定义的ID名字，Value就是我们实际上面的Bean对象，后续取出对象的时候，直接通过ID来进行取就可以了

4)Map<String<XML中的BeanID，存入的Class类>，这里面的ID和类名没啥关系，这里面的ID没啥规范，大小写都是可以的；
在resources目录下的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"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <beans>
    <bean id="user" class="HelloSpring"></bean>
    将HelloSpring类存入到Spring容器里面
    <bean id="随便写" class="包名.类名"></bean>
    </beans>
</beans>
1)保存在Spring中的对象,将这个bean存入到Spring里面，所有托管于Spring中的对象，都会放到这里面；
2)id是bean的标识符，后面进行读取对象的时候会用到，class是保存到Spring中的那个对象，将bean注册到框架里面

3)在Spring中将对象取出来:

1)得到Spring的上下文对象(四种方式)，因为我们的对象都交给Spring进行管理了，所以说想要获取对象就要从Spring中进行获取，那么就要先得到Spring的上下文对象，先拿到对应的Bean对象；
2)通过Spring的上下文提供的方法，来进行获取到自己在XML中一个指定的Bean对象；
3)使用Bean对象，调用里面的方法；
public class HelloServlet {
当前类进行启动的时候,咱们的框架也进行启动了,因为这个类是存放在当前的框架里面的
但是咱们的框架是Spring框架，也就是说启动此类的时候
    咱们的Spring框架也就随之启动了
    public static void main(String[] args) {
1获取到Spring的上下文对象,获取到Spring框架
ApplicationContext context=new ClassPathXmlApplicationContext("web.xml");
2通过Spring的上下文对象和ID来进行获取到业务Bean,返回的是Object,这个对象这可不是new出来的
HelloSpring helloSpring=(HelloSpring)context.getBean("user");
2通过Spring上下文对象和类型来进行获取到业务对象,这里面就和ID没啥关系了
  HelloSpring helloSpring=context.getBean(HelloSpring.class);
2通过Spring上下文对象和类型加ID来进行获取到业务对象
 HelloSpring helloSpring=context.getBean("user",HelloSpring.class);
3使用bean对象
helloSpring.start();
    }

GetBean()方法的重载:
1)只通过bean的ID也就是bean的name来进行获取的，不足的地方就是需要进行强制类型转换，因为返回的是Object类型，ID只是一个名字，后面获取Spring中存入的Bean对象有用；

当我们进行强转null的时候会发生报错
HelloSpring helloSpring=(HelloSpring)context.getBean("user")；

2)通过类名.class，也就是bean的Type的方式来进行获取，这样做我们就不需要进行强制类型转换了，但是也有一个很大的缺点，对于多个对象的同一种类型Bean的获取会报错，把一个类型注册了两次，把一个Bean注册到了Spring两次，当同一个类型被注入到Spring多次之后，就会报错；
  <bean id="user" class="HelloSpring"></bean>
  <bean id="config" class="HelloSpring"></bean>
 HelloSpring helloSpring=context.getBean(HelloSpring.class);
1)上面的代码就是把我们创建的HelloSpring这个类向Spring容器中注册了两次；

2)上面的代码就会报错，会抛出NoUniqueBeanDefinitionException异常，没有一个独一无二的Bean对象，ID和类名没有任何关系，但是要符合规范；

3)我们此时就应该通过ID和类型来进行获取到Bean-----是第一种和第二种的一个综合
 HelloSpring helloSpring=context.getBean("user",HelloSpring.class);
 HelloSpring helloSpring1=context.getBean("config",HelloSpring.class);
这样做的好处在于无需进行强制类型转换况且对于多个对象指向一种类型的情况是不会报错的，况且如果是null，那么最多helloSpring的值就是null;

而这里面的Spring上下文对象又是有两个:

ApplicationContext是BeanFactory的子类；

BeanFactory是一个Bean的制造工厂，通过这个制造工厂我们也是可以获取到Bean对象的

获取到Spring上下文对象的方式和区别：

相同点:

1)两个Spring上下文对象都可以从容器中获取到Bean对象

2)并且都是通过getBean()方法来进行获取并且多个getBean()方法可以构成重载，通过ID获取，通过类名获取，通过ID+类名；

1)ApplicationContext context=new ClassPathXmlApplicationContext("web.xml");
2)BeanFactory context=new ClassPathXmlApplicationContext("web.xml");
//这是Bean的创建工厂,BeanFactory是一个接口
3)BeanFactory context=new XmlBeanFactory(new ClassPathResource("web.xml"));
//里面传入的是XML文件里面的名字

1)从性能方面来看:ApplicationContext创建的时候是一次性加载并初始化所有的Bean对象，不管这个bean对象是否拥有，是否要进行使用，都会在一启动的时候加载并初始化所有的bean对象,一开始启动的时候比较慢，但是在执行后续的操作的时候就会非常快，访问的人比较多，一次全加载完了得了，对于第一次访问的用户响应速度非常快，不会管系统资源会进行浪费，也就是说当我们创建ApplicationContext对象的时候，在里面的构造方法写上配置文件的时候，要制定配置文件名字的时候，就已经加载所有的Bean对象了；

上面的对象会被全部存入到Spring对象里面

但是BeanFactory需要使用到哪个Bean才会去加载那个Bean，进行初始化，会更加轻量，适用于项目比较小，比较有优势，当你去触发的时候，才会去执行，用谁加载时，不会造成资源的浪费，节省资源，在一开始启动访问的时候，占用的系统资源更少，启动的很快，但后续的执行访问速度可能会很慢，其实就是在系统资源和性能上面做平衡；

2)两者来自的Jar包不同，ApplicationContext来自于org.springframework.context.ApplicationContext这个包底下

但是BeanFactory来自于 org.springframework.beans.factory.BeanFactory;

3)从继承关系和功能方面来说，Spring容器有两个最顶级的接口:

BeanFactory和ApplicationContext，其中的BeanFactory只提供了基础访问Bean的能力，但是ApplicationContext属于BeanFactory的子类，ApplicationContext除了拥有于BeanFactory的所有功能之外，ApplicationContext还具有独特的特性和方法的实现，还添加了对国际化的支持，资源访问支持，以及事件和传播等方面的支持；

四总结:

1)创建Spring项目:

1)创建一个maven项目

2)添加Spring框架支持

3)添加启动类

2)存储Bean对象

0)在resource目录下面创建配置文件

1)存储Bean之前，首先要有Bean，所以我们需要先创建一个Bean，注册到配置文件里面，声明式的注入，并不是现在是把Bean对象注册到Spring容器里面，但是还没有执行；

2)将创建的Bean注册到Spring容器里面；

3)创建启动类，来启动我们的Spring框架；

3)获取并使用Bean对象:

1)先得到Spring的上下文对象，因为对象都交给Spring管理了，所以获取对象的时候，要从Spring中进行获取，那么就必须先得到Spring的上下文；

2)先通过Spring的上下文对象，再通过上下文对象，得到一个指定的Bean对象；

3)使用Bean对象，和正常new的方式是一样的；