java框架技术第三课——IOC(控制反转)

已于 2023-10-09 16:24:42 修改
阅读量60 收藏
点赞数
文章标签： java 单例模式 开发语言
于 2023-09-29 14:08:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67466364/article/details/132950548
版权

创建对象的方式

23种设计模式之——工厂模式

目的：解耦（降低耦合度）
在这里插入图片描述

一.创建对象的方式

1.构造器的方法

javabean文件

package com.neuedu.homework1;

public class Student {
    private String name;
    private int age;
    private String gender;
    private String address;

    public Student(){
        System.out.println("构造器");
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

在这里插入图片描述

配置applicationContext.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">
       
<!--    Student构造器-->
    <bean id="stu0" class="com.neuedu.homework1.Student">
        <property name="name" value="构造器测试"/>
        <property name="age" value="3"/>
        <property name="gender" value="1"/>
        <property name="address" value="tjnu"/>
    </bean>
    
</beans>

在这里插入图片描述

2.静态工厂

javabean文件

package com.neuedu.homework1;

public class StuStaticFactor {
    public static Student getInstance(){
        Student stu=new Student();
        stu.setName("静态工厂测试");
        stu.setAge(1);
        stu.setGender("1");
        stu.setAddress("tjnu");
        return stu;
    }
}

配置applicationContext.xml文件

<!--    Student静态工厂-->
    <bean id="stu1" class="com.neuedu.homework1.StuStaticFactor" factory-method="getInstance"/>

3.实例工厂

javabean文件

package com.neuedu.homework1;

public class StuInstanceFactor {
    public Student getInstance() {
        Student stu = new Student();
        stu.setName("实例工厂测试");
        stu.setAge(1);
        stu.setGender("1");
        stu.setAddress("tjnu");
        return stu;
    }
}

配置applicationContext.xml文件

<!--    Student实例工厂-->
    <bean id="stu2" class="com.neuedu.homework1.StuInstanceFactor"/>
    <bean id="stu2-1" factory-bean="stu2" factory-method="getInstance"/>

4.测试代码

import com.neuedu.entity.User;
import com.neuedu.homework1.Student;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class StudentTest {
    private static ApplicationContext applicationContext;

    //加载配置文件，通过反射 创建配置文件里的对象=》注入属性值=》将该对象放入到Spring容器中
    @Before
    public void setup(){
        applicationContext=new
                ClassPathXmlApplicationContext("applicationContext.xml");
    }
    @Test
    public void testBean(){
        Student stu0 = (Student) applicationContext.getBean("stu0");
        System.out.println(stu0.getName());
//        System.out.println(stu0.getGender());
//        System.out.println(stu0.getAge());
//        System.out.println(stu0.getAddress());
        System.out.println("stu0:"+stu0);

        Student stu1= (Student) applicationContext.getBean("stu1");
        System.out.println(stu1.getName());
        System.out.println("stu1:"+stu1);

        Student stu2= (Student) applicationContext.getBean("stu2-1");
        System.out.println(stu2.getName());
        System.out.println("stu2:"+stu2);
    }


}

在这里插入图片描述

5.单例模式

单例模式是指内存中只会创建且仅创建一次对象的设计模式.
参考文章: link

二.对象创建的时机

1.lazy-init属性

default/false->在spring容器启动的时候,创建对象(不延迟初始化)
true->在context.getBean时,创建对象(延迟初始化)

在这里插入图片描述

applicationContext实现的默认行为就是在启动时将所有singleton bean提前进行实例化(也就是依赖注入).
提前实例化意味着作为初始化过程的一部分,applicationContext实例会创建并配置所有的singleton bean
通常情况下这是件好事,因为这样在配置中的任何错误就会立即被发现.

<!--    懒加载(默认设置)-->
    <bean id="student" class="com.neuedu.homework1.Student"/>
 <!--    该bean默认的设置为-->
 <bean id="student" lazy-init="" class="com.neuedu.homework1.Student"/>

在这里插入图片描述

但是如果有一个bean中有一个属性,该属性含有大量的数据,这时候不希望该bean过早的停留在内存中怎lazy-init=“true”

<!--    懒加载(context.getBean时加载)-->
    <bean id="student" lazy-init="true" class="com.neuedu.homework1.Student"/>

在这里插入图片描述

2.scope作用域

scope属性

singleton->单例(默认设置)
prototype->多例
  • 在默认情况下,放入到spring中的bean都是单例的
  • 设置为prototype之后,就会创建多个实例,可以理解为会new很多次.而singleton只会new一个实例

applicationContext.xml

<!--    对象scope的作用域-->
    <bean id="student1" class="com.neuedu.homework1.Student" scope="singleton"></bean>

    <bean id="student2" class="com.neuedu.homework1.Student" scope="prototype"></bean>

StudentTest测试代码

//        scope="singleton"
        Student student1 = (Student) applicationContext.getBean("student1");
        Student student2 = (Student) applicationContext.getBean("student1");
        
        System.out.println("student1:"+student1);
        System.out.println("student2:"+student2);
        
//        scope="prototype"
        Student student3= (Student) applicationContext.getBean("student2");
        Student student4= (Student) applicationContext.getBean("student2");

        System.out.println("student3:"+student3);
        System.out.println("student4:"+student4););

输出结果

在这里插入图片描述

说明: scope=“prototype” -> 只在Context.getBean时创建对象(lazy-init失效)

三.初始化和销毁方法

Student

public class Student(){
	private String namel
	private int age;
	private String gender;
	private String address;
	
    public Student(){
        System.out.println("Student构造器");
    }

    public void init(){
        System.out.println("Student初始化方法");
    }

    public void destory(){
        System.out.println("Student销毁方法");
    }

applicationContext.xml

<!--    初始化和销毁方法配置-->
    <bean id="stu3" init-method="init" destroy-method="destory"
          class="com.neuedu.homework1.Student"/>

StudentTest

//        销毁方法
        ClassPathXmlApplicationContext application=
                (ClassPathXmlApplicationContext) applicationContext;

        application.close();

说明:
1.init方法是由spring内部执行的
2.destory方法 只有党spring容器关闭以后才会执行
3.如果一个bean的配置是scope=“prototype”,则spring容器不负责销毁

总结

利用了反射技术，其中，applicationContext.xml文件中的一个bean的id就相当于创建了一个对象

Spring容器什么时候产生的？

测试时，加载applicationContext.xml文件就会产生Spring容器
也就是下述代码的作用

//加载配置文件，通过反射 创建配置文件里的对象=》注入属性值=》将该对象放入到Spring容器中
    @Before
    public void setup(){
        applicationContext=new
                ClassPathXmlApplicationContext("applicationContext.xml");
    }

反射机制通过类地址——去创建对象——一个bean的id就是创建了一个对象——创建的这个对象就放到hashmap中；当我们调用getBean（“user”）时（user就是bean的id）——getBean就会去hash容器里面取
在这里插入图片描述

_小杜小杜_
关注
【项目实战】Spring框架的核心概念——控制反转（IoC）与依赖注入（DI）的基本原理
本本本添哥
05-18 143
Spring框架的核心概念包括控制反转（IoC）、依赖注入（DI）和面向切面编程（AOP）Spring框架通过IoC和DI实现了松耦合的架构，而AOP则提供了一种灵活的方式来处理横切关注点。它们让Spring框架能够提供强大的模块化、松耦合的解决方案，使开发者能更高效地管理应用的结构和行为。它们都是Spring框架能够广泛应用于各种软件开发场景的重要原因。它们都是面向对象编程和软件设计中非常重要的概念和技术。它们在提高代码的可维护性、可扩展性和可重用性方面起着关键作用。
Spring-boot框架使用手册之一——Spring Ioc（基于注解）
kuaidi100的博客
09-06 1677
Spring-boot框架使用手册之一——Spring Ioc（基于注解） 快递100是专业的快递物流互联网平台，为数以亿记的用户提供快递物流的查、寄件服务。快递100的各种服务已经稳定高效的运行了多年，为中国的快递物流行业的快速发展做出了很大的贡献，这一切都离不开背后默默贡献的程序猿们。 从第一个独立站点上线至今，快递100已经走过了10个年头，10年沧海桑田，10年经历了一次又一次的技术、架构升级。今年来，由于spring-boot、spring-cloud技术的兴起，快递100技术团队也开...
Java轻量级IOC框架Guice
12-22
Guice是由Google大牛Bob lee开发的一款轻量级的java IoC容器。其优势在于： 　　速度快，号称比spring快100倍。 　　无外部配置(如需要使用外部可以可以选用Guice的扩展包)，完全基于annotation特性，支持重构，代码静态检查。 　　简单，快速，基本没有学习成本。 　　Guice和spring各有所长，Guice更适合与嵌入式或者高性能但项目简单方案，如OSGI容器，spring更适合大型项目组织。 　　注入方式 　　在我们谈到IOC框架，首先我们的话题将是构造，属性以及函数注入方式，Guice的实现只需要在构造函数，字段，或者注入函数上标注@I
Guice：Java IOC框架 挑战Spring
leagle
03-15 918
　　Google 近日宣布发布 Guice。Guice, 发音为juice, 是Google内部使用的 Java依赖注入框架。Guice新版本宣布已经完全支持annotations 以及 generics.　　Guice无配置文件，实用JDK5.0的annotation描述组件依赖，相比Spring更加简单。　　Guice 能够注入 constructors, fields 以及 me
01-Java框架-Spring01-IOC
码赛客1024的博客
05-26 687
Spring框架的学习笔记，跟着一起码起来吧。
google-guic: Java IOC 框架.
一点一点的努力~~~
03-19 643
Guice, 发音为'juice', 是Google内部使用的 Java依赖注入框架. Guice新版本宣布已经完全支持annotations 以及 generics. Guice无配置文件，实用JDK5.0的annotation描述组件依赖，相比Spring更加简单. Guice 能够注入 constructors, fields 以及 methods (任何方法, 任意参数, 而不仅仅...
java架构解密——Spring框架的ioc自我实现
ESOO
03-01 3227
在java的开发中，经常使用的框架当属SSH，而在这张框架中，我们首先接触到的就是神奇的Spring，虽然有N多前辈说Spring就是N多公共代码的集合，是帮助我们实现了，我们很久之前就想实现或者已经实现的好的点子的集合，但是作为一名合格工程师，怎么能不懂spring的底层实现呢！在今天咱们就一起探索Spring是怎么完成IOC工作的，也自己做一个简单Spring框架！ 1，Spring中Bea
java框架SSM学习——IoC概念以及为什么要用IoC？
weixin_43877761的博客
06-18 637
什么是IOC？ IOC全称为Inversion of Control，中文翻译为控制反转。那到底什么是控制反转？我们学到这里，应该对调用dao层和service层有一定的了解，首先来看一个小案例： 转账dao层接口类 package com.dao; //账户的持久层接口 public interface IAccountDao { //模拟保存账户 void saveAccount(); } 转账dao层接口实现类 package com.dao.impl; import com.d
Java EE 框架整合开发⼊⻔到实战——Spring+Spring MVC+MyBatis（微课版）课后习题答案.pdf
06-18
接下来，文档讨论了Spring中的控制反转（IoC）和依赖注入（DI）的设计模式。IoC是一种设计原则，用于减少代码之间的耦合。在Spring框架中，IoC容器管理Java对象的生命周期和对象之间的依赖关系。通过IoC，对象被动地...
Spring_IoC控制反转、依赖注入详解
WziH_CSDN的博客
09-30 691
Spring_IoC 一、IoC相关概念简介 1、理解【控制】和【依赖】的概念 IoC即控制反转、依赖注入 。—— OOAD依赖倒置 【控制】和【依赖】都代表对象之间的关联关系，而且他们在Spring中是一对近义词，控制和依赖几乎是并存的。 例如，现有如下需求：汽车的功能是行驶，司机的功能是驾驶汽车，令汽车行驶。 我们可以通过代码描述上述关系： public class Car { // 汽车类 private String name; // 品牌 private Double price;
自己的IoC框架实现
05-20
根据Spring的IoC原理，实现自己的IoC框架。
自己搭建轻量级javaWeb框架之mvc以及ioc
05-15
自己搭建轻量级javaWeb框架之mvc以及ioc
自己动手做框架——ORM，MVC，IOC框架
03-07
自己动手做框架——ORM，MVC，IOC框架及整合视频教程 源码
Java框架 Spring--IOC
weixin_65637841的博客
08-16 637
IOC：Inversion of Control，翻译过来是反转控制。
ioc框架 java_从零开始实现一个简易的Java MVC框架(三)--实现IOC
weixin_42348363的博客
02-12 153
Spring中的IOCIoC全称是Inversion of Control，就是控制反转，他其实不是spring独有的特性或者说也不是java的特性，他是一种设计思想。而DI(Dependency Injection)，即依赖注入就是Ioc的一种实现方式。关于Ioc和DI的具体定义和优缺点等大家可以自行查找资料了解一下，这里就不详细赘述，总之spring的IoC功能很大程度上便捷了我们的开发工作。...
手把手教你入门java框架：spring IOC/DI
yeah的博客
11-23 297
临到毕业季，才发现自己在学校学的东西都是很偏理论的，真正要用到工作中，还欠缺很多东西，所以只好再次求助于网络资源，一点一点的学起来！[卑微.jpg] 注：以下学习过程都是参照how2j中站长亲自撸的教程完成的，分享给有需要的同学，也算是自己学习的一个过程记录吧，大佬们绕道就好啦！ Spring是一个基于IOC和AOP的结构J2EE系统的框架。IOC反转控制是Spring的基础，Inver...
java中什么是ioc?
最新发布
周祥平程序专栏
12-11 1419
IoC的核心思想是将组件的创建、组装和管理等控制权从应用程序代码中反转到容器中，由容器负责组件的创建和管理，并在需要的时候将组件注入到相应的地方。传统的程序设计中，组件之间的依赖关系由程序代码直接控制，而在IoC容器中，控制权被反转，由IoC容器来管理和控制组件之间的关系。是Spring框架最基本的IoC容器，提供了基本的IoC功能。IoC容器可以管理组件的生命周期，确保组件在需要的时候正确地创建、销毁等。IoC容器负责将组件之间的依赖关系注入到相应的组件中，使得组件之间解耦。
Spring-day02注解开发
m0_46690280的博客
08-05 195
注解开发1)注解驱动的意义1.1)什么是注解驱动1.2)注解驱动的弊端2)常用注解2.1)启动注解功能 1)注解驱动的意义 注解其实是一个标记 通过反射拿到一个类上或者一个方法上的注解是啥名，然后判断这个注解是不是我们自己定义的注解，如果是就执行一些你的操作 1.1)什么是注解驱动 注解启动时使用注解的形式替代xml配置，将繁杂的spring配置文件从工程中彻底消除掉，简化书写 1.2)注解驱动的弊端 为了达成注解驱动的目的，可能会将原先很简单的书写，变的更加复杂 XML中配置第三方开发的资源是
18.JAVA之三大框架Spring、IOC和DI、拦截器、MVC项目、Mybatis持久层、动态SQL、SSM
weixin_56027329的博客
05-09 589
JAVA之三大框架Spring、IOC和DI、拦截器、MVC项目、Mybatis持久层、动态SQL、SSM
理解Spring IOC：控制反转与依赖注入
原本，一个类需要依赖另一个类时，通常会自行创建依赖对象，但在IOC的帮助下，这种控制权被反转：依赖的创建和管理交给了一个第三方——也就是Spring容器。这样做的好处在于提高了代码的灵活性、可测试性和可维护性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值