JavaEE 学习笔记 —— Spring Framework

已于 2022-03-18 17:45:23 修改
阅读量334 收藏 2
点赞数 3
分类专栏： Spring 文章标签： java-ee java spring
于 2021-10-22 19:46:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56651882/article/details/120637259
版权

spring framework runtime

在这里插入图片描述

核心容器

容器：servlet 容器、集合

线程池、常量池、数据库连接池的作用类似于容器
但是他们属于设计模式中的享元模式，即从池子中取东西，如果取不到，再创建

spring 中的核心容器，类似于集合

作用

  1. 存放对象
  2. 取出来使用

在 spring 中，有些对象是由容器来创建的，并且复制管理对象间的依赖

对于对象间的依赖：A 对象的属性为 B 对象，A 和 B 就产生了依赖关系

IOC

概念：IOC，(Inversion of Control，控制反转) —— 以前自己 new 对象以及组织对象间的关系，现在全部交给容器来统一管理，控制权发送了反转，因此称为控制反转。

实现方式：使用 IOC 容器来实现

在 spring 在，称为 spring bean 容器、spring 容器或 IoC 容器

DI

概念：DI， (Dependency Injection，依赖注入) —— 由 IoC 容器在运行期间，动态的将某种依赖关系注入到对象之中

注入
把 B 对象注入到 A ，称为 A 的属性
把 A 注入 IoC 容器中

IoC/DI 的作用

不使用：
在这里插入图片描述

使用：
在这里插入图片描述

作用
解耦

spring 容器使用流程

使用流程

  1. 配置 pom.xml 文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>spring01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-framework.version>5.2.10.RELEASE</spring-framework.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring-framework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring-framework.version}</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 明确指定一些插件的版本，以免受到 maven 版本的影响 -->
            <plugin>
                <artifactId>maven-clean-plugin</artifactId>
                <version>3.1.0</version>
            </plugin>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
            </plugin>
            <plugin>
                <artifactId>maven-deploy-plugin</artifactId>
                <version>2.8.2</version>
            </plugin>
            <plugin>
                <artifactId>maven-install-plugin</artifactId>
                <version>2.5.2</version>
            </plugin>
            <plugin>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.2.0</version>
            </plugin>
            <plugin>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.1.0</version>
            </plugin>
            <plugin>
                <artifactId>maven-site-plugin</artifactId>
                <version>3.3</version>
            </plugin>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
            </plugin>

        </plugins>
    </build>
</project>

点击刷新，使得配置文件完成
在这里插入图片描述

  1. 在 resources 目录下创建 beans.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
        
<!--    org.example 代表扫描 org.example 包下的文件-->
    <context:component-scan base-package="org.example"/>

</beans>
  1. 启动 spring 容器
package org.example;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {

    public static void main(String[] args) {
        //根据Spring配置文件路径创建容器：应用上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //关闭容器
        ((ClassPathXmlApplicationContext) context).close();
    }
}

理解注入流程

  1. 启动 spring 容器：new ApplicationContext 的实现类
  2. 注册 / 注入对象到容器中：加载指定的配置文件，执行包扫描，指定的包，子包下，带 spring 框架提供的四个注解，会注入到容器中
    @Controller （控制器）
    @Service（服务）
    @Repository（存储库）
    @Component （组件）
  3. 装配 / 注入依赖关系：如果注册到容器中的对象，属性使用一下两个注释
    @Autowired（自动装配）
    @Resource（资源）

注入代码讲解

1.使用 Controller 注解、Bean 注解 + 方法注入
bean 注解使用在方法上，该方法所在的类也需要注解

从容器中获取 Bean 对象的方法：

  • 通过类型获取（需要容器中只有一个对象）
  • 通过名称、id 获取
package org.example.controller;

import org.example.model.Duck;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Controller;

// 使用 Controller 注解将该类注入到 Bean 容器中
@Controller
public class LoginController {
    
    // 方法前使用 Bean 注解, 也能够注入对象
    @Bean
    public Duck d1() {
        Duck duck = new Duck();
        duck.setName("唐老鸭");
        return duck;
    }


    @Bean
    public Duck d2() {
        Duck duck = new Duck();
        duck.setName("香酥鸭");
        return duck;
    }
}
  1. 使用 Repository 注解注入
package org.example.dao;

import org.springframework.stereotype.Repository;

@Repository
public class LoginRepository {
}
  1. 创建 Bean 注入的类
package org.example.model;


import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@ToString
public class Duck {
    private String name;
}
  1. 通过 Service 注解注入
package org.example.service;

import org.springframework.stereotype.Service;

@Service
public class LoginService {
	// 如果注入的对象不止一个 那么需要使用 @Qualifier 注解来确定使用的是哪个对象
    @Autowired
    @Qualifier("luYa")
    public Duck duck;
}
  1. @Scope 注解每次都能创建新对象
package org.example.service;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

// Scope 注解每次都能获取新的 Bean 对象
@Service
@Scope("prototype")
public class LoginServicePrototype {
}
  1. 检查注入结果
package org.example;

import org.example.controller.LoginController;
import org.example.dao.LoginRepository;
import org.example.model.Duck;
import org.example.service.LoginService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {


    public static void main(String[] args) {
        //根据Spring配置文件路径创建容器：应用上下文对象
        // 类加载路径下的 beans.xml 文件
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");


        // 1. 通过类型获取
        LoginRepository login1 = context.getBean(LoginRepository.class);

        // 2. 通过类名获取, 注意, 类名首字母小写
        LoginRepository login2 = (LoginRepository) context.getBean("loginRepository");

        System.out.println(login1);
        System.out.println(login2);


        // 通过类型获取
        LoginController login3 = context.getBean(LoginController.class);

        // 通过类名获取
        LoginController login4 = (LoginController) context.getBean("loginController");

        System.out.println(login3);
        System.out.println(login4);


        LoginService login5 = context.getBean(LoginService.class);

        // 通过类名获取
        LoginService login6 = (LoginService) context.getBean("loginService");

        System.out.println(login5);
        System.out.println(login6);


        Duck d1 = (Duck) context.getBean("d1");
        Duck d2 = (Duck) context.getBean("d2");

        System.out.println(d1);
        System.out.println(d2);

        // 同一类型注册了两个以上对象, 不能通过类型来获取
//        Duck d3 = context.getBean(Duck.class);
//        System.out.println(d3);
        //关闭容器
        ((ClassPathXmlApplicationContext) context).close();
    }
}




// 		  打印结果
//        org.example.dao.LoginRepository@76a4d6c
//        org.example.dao.LoginRepository@76a4d6c
//        org.example.controller.LoginController@517cd4b
//        org.example.controller.LoginController@517cd4b
//        org.example.service.LoginService@6cc7b4de
//        org.example.service.LoginService@6cc7b4de
//        Duck(name=唐老鸭)
//        Duck(name=香酥鸭)

BeanFactory 和 FactoryBean 的区别

  1. BeanFactory 是 Spring 的顶级接口
  2. FactroyBean 是工厂 Bean，本身是一个 Bean，且主要是生成 Bean 的工厂
    把 getObject() 方法的返回值注册到容器中
逍遥ovo
关注
专栏目录
Spring Framework Java 应用程序框架
YDLsogood的博客
06-23 473
在 LogAspect 类中，我们使用了 Spring AOP 的 Before 注解，并指定了切入点表达式 execution(* com.example.service.UserService.*(..))，表示执行 UserService 类中的任意方法时，都会在方法执行前调用 LogAspect 类中的 before 方法，从而实现了日志记录的功能。综上所述，通过使用 Spring 的 IoC 和 AOP，我们可以实现对象的依赖关系解耦和横切关注点的模块化，从而提高了代码的可维护性和可重用性。
学习笔记——spring5概念和原理
fangfeng1021的博客
05-27 349
文章目录一、 spring5概述和原理Spring5 框架概述Spring5入门案例IOC（概念和原理）IOC（BeanFactory 接口）IOC操作 Bean 管理（概念）IOC操作 Bean 管理（基于 xml 方式）IOC操作 Bean 管理（ xml 注入其他类型属性）IOC 操作 Bean 管理（xml 注入集合属性）IOC操作 Bean 管理（ FactoryBean）IOC操作 Bean 管理（ bean 作用域）IOC操作 Bean 管理（ bean 生命周期)IOC操作 Bean 管理（
SpringFramework核心技术一（IOC：基于Java的容器配置)
向小凯同学学习
06-07 442
@Bean和@Configuration Spring新的Java配置支持中的中心构件是 - @Configuration注释类和@Bean注释方法。 一、基本概念：@Bean和@Configuration Spring新的Java配置支持中的中心构件是 - @Configuration注释类和@Bean注释方法。 该@Bean注释被用于指示一个方法实例，配置和初始化为通过Spring...
Java必修课——Spring框架
最新发布
qq_43556680的博客
09-29 2496
Spring是轻量级的开源的JAVAEE框架Spring可以解决企业应用开发的复杂性Spring有两个核心部分：IOC和AopIOC：控制反转，把创建对象的过程交个Spring进行管理Aop：面向切面，不修改源代码进行功能增强Spring特点方便解耦，简化开发Aop编程支持方便程序测试方便和其他框架进行整合方便进行事务操作降低API的使用难度IOC容器IOC底层原理IOC接口（BeanFactory）IOC操作Bean管理（基于XML）IOC操作Bean管理（基于注解）
JavaEE_Spring Framework
weixin_34209851的博客
03-06 54
问题 　　什么时候使用IOC容器，什么时候不使用？ 　　场景1. Spring Framework 的源码实现，违反了IOC初衷。为什么？ 　　场景2. 有些中间件如Mycat不使用IOC，为什么？ 　　场景3. 为什么业务系统经常使用IOC？ 　　场景4. 为什么不使用EJB的IOC容器？ 　　场景5. 为什么要有JavaEE，学习Java是否可以不做JavaEE？ 资料 　　D...
【java】 SpringFramework ———— 注入
weixin_44938441的博客
09-26 230
我们这次的目的有三个： 1.组建Bean工厂（上下文，容器）； 2.能够对Bean的成员进行注入； 3.能够取得Bean； Bean，又称Java Bean，或者说POJO，平凡的Java类。 将这些平凡的Java类对象组织到一个容器中，就形成了所谓的“上下文”或“容器”，容器的形成需要配置手段，可以采用注解或者Xml文件的形式，在这里我们采用注解的形式。 @Component//该...
Spring Framework Runtime
风泊月
03-11 2397
Test 对应spring-test.jar. Spring提供的测试工具,可以整合JUnit测试,简化测试环节. CoreContainer Spring的核心组件,包含了Spring框架最基本的支撑. Beans, 对应spring-beans.jar. Spring进行对象管理时依赖的jar包. Core,对应spring-core.jar, Spring核心jar...
JavaEE框架学习笔记——SpringMVC篇
2401_84092574的博客
05-03 729
针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。下面的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）最新整理电子书《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！最新整理电子书[外链图片转存中…(img-AOISp3IX-1714673441642)]《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》
JavaEE框架学习笔记——SpringMVC篇，字节跳动硬件开发工程师面试经验
pckzzy117的博客
04-19 761
切莫死记硬背，小心面试官直接让你出门右拐1000道互联网Java面试题：
动力节点B站Spring6学习笔记——Spring的入门程序
2301_76637757的博客
05-11 320
根据B站动力节点老杜讲的Spring6教程整理了学习笔记，分享给大家，共同学习进步~这套Spring教程基于Spring6讲解，Spring6是下一个十年的新开端。
Spring学习笔记——Bean
qq_47102228的博客
04-06 569
初识Spring框架、Spring核心容器，Spring中的Bean
Spring Framework 中文
12-05
Spring Framework 中文,学习，开发
Java-SpringFrameWork学习
weixin_43926250的博客
05-10 267
本人为C#码农，Java学习中，所以细节尽量描述详细，高手请忽略
Spring框架runtime
Thinkao 的博客
03-02 689
Spring框架简述： 1.test:spring提供测试功能 2.Core Container：核心容器 -- Spring启动最基本的条件 Beans：Spring负责管理对象 Core：核心类 Context：上下文参数，获取外部资源或者管理注释等 SpEL：expression.jar 3.AOP:实现aop功能需要依赖 4.Aspe...
零基础学习-spring框架（一）
小码农的博客
05-11 670
零基础学习-spring框架一Spring框架1. spring官网2. Spring框架3. 通过无参数构造方法，使用Spring创建对象，并从Spring中获取对象4. 通过静态工厂方法创建并获取对象【不常用】5. 通过实例工厂创建并管理对象【不常用】6. 由Spring管理的对象的作用域【仅了解】7. 由Spring管理的对象的生命周期【不常用】 Spring框架 1. spring官网 官网：https://spring.io/ 2. Spring框架 框架(Framework)：一系列的jar包，
java-Springframwork学习
weixin_44712669的博客
06-29 479
1.为什么要使用spring 对于 Java 编程来说，使用 Spring 能完成的更加快速，更容易并更安全。Spring 专注于速度，便捷与开发效率，也正是如此，让Spring成为了全世界最流行的 Java 框架。 2.Spring Framework Spring专注于为 Java 企业应用提供一站式的开发框架，目的是让 Java 企业开发更加便捷，安全与高效。 Spring Framework 属于其中最基础，最核心的部分，Spring下的其他大部分框架都依赖 Spring Framework 。 官
Java - Spring 框架 SpringFramework 详解（三）
Kevinblant的博客
10-11 315
目录1. 自动装配(autowire)2. 通用注解3. 关于对象的作用域与生命周期方法的注解4. 自动装配的注解5. Spring知识小结---------------------------------------------------------附1：关于@Autowired和@Resource注解 1. 自动装配(autowire) 自动装配：不需要显式的为属性注入值，Spring框架会自动的将合适的值注入到属性中！ 自动装配的做法：在Spring的配置文件中，为需要自动装配的<bean&g
Java - Spring 框架 SpringFramework 详解（二）
Kevinblant的博客
10-11 289
目录1. Spring IoC1.1. 什么是IoC1.2. 通过SET方式注入属性的值1.3. 通过构造方法注入属性的值【不常用】2. 注入集合类型的值2.1. 注入List类型的值【不常用】2.2. 注入SET集合类型的属性值【不常用】2.3. 注入数组类型的属性值【不常用】2.4. 注入Map集合类型的属性值【不常用】2.5. 使用系列节点【不常用】2.6. 注入Properties类型的属性值【常用】3. Spring表达式附1：什么时候需要定义构造方法附2：关于集合的类型 1. Spring Io
JavaEE学习笔记概览：从基础到进阶
"JavaEE学习笔记是一个全面的学习资料，由作者续祥于2008年11月1日整理编撰。该笔记涵盖了多个关键领域，包括Java基础、JavaEE技术、Unix系统管理、CoreJava、Tiger语言特性升级、XML技术以及Oracle数据库管理。以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值