JavaEE 突击 3 - Spring 创建和使用

已于 2023-01-24 10:38:33 修改
阅读量815 收藏 15
点赞数 24
分类专栏： JavaEE 新手入门 文章标签： spring java-ee java
于 2023-01-04 22:40:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53117341/article/details/128555643
版权

Spring 创建和使用

大家好 , 这个专栏给大家介绍一下 Java 家族的核心产品 - SSM 框架

Java 语言能走到现在 , 仍然屹立不衰的原因 , 有一部分就是因为 SSM 框架的存在

接下来 , 博主会带大家了解一下 Spring、Spring Boot、Spring MVC、MyBatis 相关知识点

并且带领大家进行环境的配置 , 让大家真正用好框架、学懂框架

在这里插入图片描述

目标 :

  1. Spring (Core) 项目创建
  2. 将对象存储到 Spring 中
  3. 将对象从 Spring 里面取出

在 Spring 里面 , 把对象叫做 Bean

一 . 创建 Spring 项目

我们接下来用 Maven 创建一个 Spring 项目

  1. 创建一个 Maven 项目
  2. 添加 Spring 框架支持 (spring-context : 上下文 spring-beans : 对象)
  3. 添加启动类

我们这里使用的环境是 IDEA 2021.2 社区版 , JDK 1.8

1.1 创建一个 Maven 项目




1.2 添加 Spring 框架依赖

添加两个引用 :

  1. spring - content : spring 上下文
  2. spring - beans : spring 对象

这一步很简单 , 我们只需要把下面这段代码复制到 pom.xml 里面
当然也可以去中央仓库里面找

<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 - content 和 spring - beans 啊 ? 这怎么多出来几个 ?

是这样的 , 我们的 spring - content 和 spring - beans 也是需要额外的依赖包的 , 如果单纯使用 spring - content 和 spring - beans , 也需要把它的几个依赖包导入进来 , 其实就相当于结婚的嫁妆

1.3 添加启动类

实际上就是添加 main 方法
那我们之前写 Servlet 程序 , 也没有 main 方法啊 ?

实际上 , Servlet 是隐藏 main 方法的 , 是不展示给用户的

我们这里的 Spring 程序就是一个最简单的程序 , 还是需要 main 方法的
在 java 目录底下新建一个类


二 . 将 Bean 对象存储到 Spring

存储 Bean 对象需要两步 :

  1. 存储 Bean 之前 , 先得有 Bean , 所以先创建一个 Bean 对象
  2. 将创建的 Bean 注册到 Spring 容器中

2.1 创建 Bean 对象


public class User {
    // 普通的类,普通的方法
    public void sayHi() {
        System.out.println("say hi!");
    }
}


2.2 将 Bean 存储到 Spring

在 Spring 里面 , 并不是所有的 Bean 都会被存储到 Spring 里面 , 只有需要的才会存储到 Spring 里面
而这个存储 , 也不是真正意义上的存储 , 只是告诉 Spring , 这个 Bean 需要托管给 Spring
那么我们接下来需要在 resources 里面新建一个文件 , 叫做 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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>


目前的只是准备工作 , 我们接下来才是将 Bean 存储到 Spring 的核心操作

<?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">

    <!--  注册一个对象到 Spring 中  -->
    <!--  先写一个 bean 标签  -->
    <bean id="user" class="User"></bean>

</beans>


里面的 class 也是需要写包名的 , 但是因为我们没创建包 , 所以就没写
那么我们可以改一下 , 把代码放到包里面

目前为止 , 我们只是声明存储对象到 Spring 里面了 , 并不是真正存储到 Spring 里面了 , 正常情况下 , 我们的 Spring 是懒加载 , 在启动 Spring 的时候 , 他并不会立即存储 Spring 对象 , 但是从广义上来理解 , 我们的 Spring 已经存储这个对象了

2.3 从 Spring 中取出 Bean 对象

2.3.1 先得到 Spring 对象(Spring 上下文对象)

对象都交给 Spring 管理了，所以获取对象要从 Spring 中获取，那么就得先得到 Spring 的上下文。
Spring 上下文对象可使用 ApplicationContext



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.3.2 从 Spring 上下文当中取出对象


先不管选哪个 , 我们注意 : getBean 返回值是 Object , 但是我们的对象是 User 类型 , 所以我们需要强转一下



import com.ethan.User;
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 里面获取对象
        // User user = new User();//在当前类当中创建 User 对象,原始方式不推荐[存在代码耦合]
        User user = (User)context.getBean("user");//只有第一次执行,才会创建.因为是单例模式,创建过后会一直留着,下次用直接拿走
    }
}

2.3.3 使用 bean (非必须)

之前怎么使用 , 现在就怎么使用

import com.ethan.User;
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 里面获取对象
        // User user = new User();//在当前类当中创建 User 对象,原始方式不推荐[存在代码耦合]
        User user = (User)context.getBean("user");//只有第一次执行,才会创建.因为是单例模式,创建过后会一直留着,下次用直接拿走

        // 3. 使用 bean
        user.sayHi();//跟以前一样
    }
}

运行一下 :

2.4 特殊情况

2.4.1 xml 配置文件一定要写正确

我们之前说 resources 目录底下的配置文件推荐大家使用 spring-config.xml
那么这个名字其实叫什么都行

那我们改成 spring 看看还能不能成功

成功了

但是这种虽然合法但是不规范
那我们试一下这种情况 :
配置文件名称叫 spring-config.xml , 我们的代码里面写成了 spring.xml

那么运行一下 , 看看会不会运行起来

那么我们帮大家排查一下错误


那么就是 spring.xml 没有找到
因为我们的配置文件叫 spring-config.xml , 不是 spring.xml , 所以就会报错
而且下面还有行数提醒

2.4.2 bean 标识一定要写正确


我们运行一下
image.png

2.5 getBean 方法的更多用法

2.5.1 getBean(String s)

我们之前介绍的方法 :
getBean(String s) : 根据名称来获取 bean 对象
这种方法需要进行强转 , 但是他有一个好处 : 我们注册多个 bean , 他会精准定位
比如 :

那么我们的这种方法能正常识别吗 ?

那么这种情况还是挺常见的 : 在公司协同开发 , 张三使用了 user , 李四不知道 , 李四也使用了 user , 这样就产生了重复
原则上来说 , 一个 key 只能出现一次 , 我们就可以把这个第二个 user 改成 user2


那有的人就问了 , 怎么证明 User 和 User2 是不一样的呢 ? 因为他们打印的结果相同啊 , 就会有人以为他们是不是一个东西起了两个名字啊 , 那很好证明

那么我们还可以去证明 user 是不是单例模式

为 true 就代表是单例模式 , 因为 Spring 中创建出一个对象就会一直存储到 Spring 中 , 方便后续使用 , 就不用再去重新创建了

2.5.2 getBean(class<T> aclass)

getBean(class<T> aclass) : 根据类型获取 bean 对象

import com.ethan.User;
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 里面获取对象
        // 2.1 根据一个 String 参数获取 bean
        //User user = (User)context.getBean("user");//只有第一次执行,才会创建.因为是单例模式,创建过后会一直留着,下次用直接拿走

        // 2.2 根据一个 Class 参数获取 bean
        User user = context.getBean(User.class);//这种方法不用强转了

        // 3. 使用 bean
        user.sayHi();//跟以前一样
    }
}


这种情况是 spring-config.xml 里面只有一个 bean 对象
那么有两个呢 ?

再运行一下 :

看一下异常


我们再看一下 spring-config.xml
image.png

import com.ethan.User;
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 里面获取对象
        // 2.1 根据一个 String 参数获取 bean
        /*User user = (User)context.getBean("user");
        User user1 = (User)context.getBean("user");
        User user2 = (User)context.getBean("user2");

        System.out.println("user:" + user);
        System.out.println("user1:" + user1);
        System.out.println("user2:" + user2);
        System.out.println("user == user1 -> " + (user == user1));
        System.out.println("user == user2 -> " + (user == user2));//为true说明他们地址相同,是一个对象;为false说明地址不同,不是同一个对象*/

        // 2.2 根据一个 Class 参数获取 bean
        User user = context.getBean(User.class);//这种方法不用强转了

        // 3. 使用 bean
        user.sayHi();//跟以前一样
    }
}

2.5.3 getBean(String s , class<T> aclass)

getBean(String s , class<T> aclass) : 这种方法更加稳健 , 虽然他比第一种也没差哪去 , 不过如果是第一种方法 , 万一内容为 null , 对 null 进行强转就会出现问题 , 但是你通过这种方法的话 , 整体就会返回一个 null , 就不存在空指针问题了

import com.ethan.User;
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 里面获取对象
        // 2.1 根据一个 String 参数获取 bean
        /*User user = (User)context.getBean("user");
        User user1 = (User)context.getBean("user");
        User user2 = (User)context.getBean("user2");

        System.out.println("user:" + user);
        System.out.println("user1:" + user1);
        System.out.println("user2:" + user2);
        System.out.println("user == user1 -> " + (user == user1));
        System.out.println("user == user2 -> " + (user == user2));//为true说明他们地址相同,是一个对象;为false说明地址不同,不是同一个对象*/

        // 2.2 根据一个 Class 参数获取 bean
        //User user = context.getBean(User.class);//这种方法不用强转了

        // 2.3 根据 String(bean id) 和 Class 参数获取 bean
        User user = context.getBean("user",User.class);//更加的稳健
        // 3. 使用 bean
        user.sayHi();//跟以前一样
    }
}


同样的方式 , 我再去读 user2 也是没问题的

2.6 面试题 : ApplicationContext VS BeanFactory

Spring 上下文对象可使用 ApplicationContext , 我们还可以使用 BeanFactory (ApplicationContext的父类) 来作为 Spring 的上下文

不过 IDEA 已经不推荐我们使用这种方法了

import com.ethan.User;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class App {
    public static void main(String[] args) {
        // 1. 获取上下文对象
        BeanFactory context = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
        // 2. 从 Spring 里面获取对象
        User user = context.getBean("user2", User.class);
        // 3. 使用方法
        user.sayHi();
    }
}

运行一下 :

那么既然他们都能运行成功 , 那有什么区别呢 ?

  1. 共同点 : 都是用来获取 Spring 的上下文对象
  2. 不同点 :
  3. 继承关系和功能 : ApplicationContext 属于 BeanFactory 的子类 , ApplicationContext 具备了 BeanFactory 所有的功能 , 而 BeanFactory 只具备最基础访问 Bean 的功能 . Application 还具备了更多的能力 , 比如 : 国际化支持 资源访问支持 事件传播 …
  4. 从性能方面来说 , ApplicationContext 是一次性加载并初始化所有的 Bean 对象 , 而 BeanFactory 是按需加载 , 需要使用 Bean 的时候才去加载

三 . 总结

  1. 操作容器之前，先要有容器，所以先要得到容器 , 就需要我们创建 Spring 项目
  2. 存对象
    1. 创建 Bean（普通类）。
    2. 将 Bean 注册（配置）到 spring-confing.xml 中。
  3. 取对象
    1. 得到 Spring 上下文，并读取到 Spring 的配置文件。
    2. 获取某⼀个 Bean 对象。
    3. 使用 Bean 对象。

加勒比海涛
关注
  • 24
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 39
    评论
专栏目录
使用java的方式配置Spring---JavaConfig
TIANJIAWEN的博客
05-16 279
不适用Spring的xml配置 全部交给java来做 JavaConfig是Spring的一个子项目，在Spring4之后 其变成了核心功能config文件 package com.kero.config; import com.kero.pojo.User; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import or
使用Java的方式配置Spring
niceYF的博客
03-24 322
完全不使用Spring的配置了，全部交由Java来做！ JavaConfig是Spring的一个子项目，在spring4之后，它成为了一个核心功能。 先写配置类 //这个也会注册到spring容器中，因为它本来就是一个@Conponent //configuration代表这是一个配置类，就和我们之前看到的beans.xml是一样的 @Configuration @ComponentScan("com.yf.pojo") @Import(YfConfig2.class) public class Y
Spring的创建与使用
m0_67683346的博客
01-13 418
Spring的创建和使用
Java之Spring
m0_62824239的博客
07-14 5271
（1）先创建一个maven项目 （2）添加spring框架支持（spring-context / spring-beans） 在pom.xml中添加如下代码 设置国内源： （3）创建一个启动类并添加main 创建一个类。类名可以任意取。 （1）先在spring项目中添加配置文件，如果不是第一次配置，则此步骤可以省略。 （2）创建bean对象 在Java中就是普通的对象。 创建一个User对象 （3）在配置文件中将需要保持到spring中的对象进行注册。 将bean通过配置文件注册到spring中
JavaEE源代码 spring-hibernate3
07-09
JavaEE源代码 spring-hibernate3JavaEE源代码 spring-hibernate3JavaEE源代码 spring-hibernate3JavaEE源代码 spring-hibernate3JavaEE源代码 spring-hibernate3JavaEE源代码 spring-hibernate3JavaEE源代码 spring-...
javaee-api-8.0-javadoc.jar
10-12
javaee-api-8.0-javadoc.jar，这是javaee1.8api的jar包，解压后可用javadoc2chm制作成chm帮助文档。
JavaEE示例-mybatis-spring-springMVC
12-16
本例子使用的是mybatis-spring-springMVC，占位符占位符占位符占位符占位符占位符占位符
JavaEE主流开源框架-Spring部分rmvb格式.zip
05-23
JavaEE主流开源框架-Spring部分rmvb格式。 JavaEE主流开源框架-Spring部分rmvb格式。 JavaEE主流开源框架-Spring部分rmvb格式。 JavaEE主流开源框架-Spring部分rmvb格式。 JavaEE主流开源框架-Spring部分rmvb格式。 ...
JavaEE源代码 spring-core
07-09
JavaEE源代码 spring-coreJavaEE源代码 spring-coreJavaEE源代码 spring-coreJavaEE源代码 spring-coreJavaEE源代码 spring-coreJavaEE源代码 spring-coreJavaEE源代码 spring-coreJavaEE源代码 spring-coreJavaEE源...
java 加载spring_普通java类加入spring容器的四种方式
weixin_35997246的博客
02-12 1352
今天在自己开发的工具类中使用了spring注入的方式调用了其他类，但是发生的报错，在整理了后今天小结一下。首先简单介绍下spring容器，spring容器是整个spring框架的核心,通常我们说的spring容器就是bean工厂,bean工厂负责创建和初始化bean、装配bean并且管理应用程序中的bean.spring中提供了两个核心接口：BeanFactory和ApplicationConte...
javaweb项目添加spring框架
lin594188的博客
01-05 728
1.添加相关的依赖包 使用maven的话只需要一个依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>3.2.17.RELEASE</version> </dependency> 2.添加applicationContext.xm
Java类中加载Spring中的ApplicationContext.xml文件的方式
享受学习的过程
06-10 873
1>、利用ClassPathXmlApplicationContext,可以从classpath中读取XML文件   //读取一个文件    1. ApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");    UserDAO userDAO= (UserDAO )con
Eclipse新建一个Spring项目（最基础）
热门推荐
望穿秋水见伊人的博客
07-24 5万+
我在这里使用eclipse新建一个最基础的spring项目，提高初学者的实践能力，如果看完这篇文章后，你感到其实spring不难，可以轻松学会学好，我就达到写本篇文章的目的了。 首先，笼统介绍一下，什么是spring 1、Spring 的主要作用就是为代码“解耦”，降低代码间的耦合度。 根据功能的不同，可以将一个系统中的代码分为主业务逻辑与系统级业务逻辑两类。它们各自具有鲜明的特点：主业务代码...
eclipse中导入spring详细过程
有图有真相
05-16 1万+
spring简介Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。eclipse中导入spring在导入spring之前先要下载spring-framework-x.xx.RELEASE下载地址：springframework
java中spring的使用
悦分享
11-19 2万+
java中spring的使用 　Spring是一个开源框架，框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核...
在Eclipse中手动为其添加spring开发支持
Tajyl的博客
03-01 4802
第一步：首先打开在spring官网打开spring-tool-suite-3.7.3.RELEASE-e4.5.2-win32-x86_64.zip文件的地址戳这里===》》》https://spring.io/tools/sts第二步：解压下载后的文件第三步：打开sts-3.9.4.RELEASE目录，可以看到如下两个文件夹，复制一下第四步：打开Eclipse的文件目录；放在dropins即可第...
SSM详解2：Spring的创建和使用
dghehe的博客
10-15 406
从设计来说：ApplicationContext是BeanFactory的子类，BeanFactory只提供了基础访问Bean的方法ApplicationContext除了有BeanFactory所有的方法，还提供了更多的实现，比如对国际化的支持，资源访问的支持，以及事件和传播等方面的支持。2、根据bean type（context.class）,来获取不需要强转，但是一个Bean对象被注册过多次的时候就会出错。一般id我们使用bean的类名的小驼峰形式，class=Java包下该bean的路径。
使用java反射优化Spring自动生成的DAO实现类！
Fantasy
03-29 5183
    在使用Struts+Hibernate+Spring框架时，发现Spring为应用程序生成的数据访问层的代码都非常的重复，这样给人的感觉非常的不爽，基本上有多少个DAO，每个DAO都是重复的方法，无非就是换了一下具体的相对应的pojo类而已，这样感觉非常违背java代码重用的原则，因此想对此做一下改进，以便让代码的重用率更高一些，真实体现java在方法重用上的优雅性， 我想到了用jav
必须声明元素 javaee:handler-chains
最新发布
06-03
在 Java EE 中，可以使用 javaee:handler-chains 元素来定义处理程序链。处理程序链是一系列处理程序，用于处理 Web 服务请求和响应。在声明 javaee:handler-chains 元素时，需要指定处理程序链的名称，并为每个处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 39
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

加勒比海涛

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值