初学Spring之IOC（一）

最新推荐文章于 2024-07-25 09:53:42 发布
最新推荐文章于 2024-07-25 09:53:42 发布
阅读量112 收藏
点赞数
分类专栏： Spring 文章标签： spring java ioc bean xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fireblackbo/article/details/105341080
版权

知乎大佬写的简单明了的ioc：
知乎大佬版ioc

IOC——控制反转(Inversion of Control)

对象的创建交给外部容器完成，这个就叫控制反转
控制反转的方法：DI（依赖注入）
控制反转的容器：ioc Container
这玩意就他喵是个——中介

没有中介的时候，我们写程序：

  1. 实体类—>class User{ }

  2. Servlet–> class UserServlet{ Service service = new ServiceImpl(); }

3.Service–> class UserServiceImpl{ Repository repo = new RepositoryImpl(); }

  1. Repository–> class UserRepository{ …访问DB}

用户访问顺序：

Tomcat -> Servlet -> Service -> Repository

正转：
Servlet中需要
创建service对象调用service方法
service中需要
创建repo对象并调用方法访问数据库.

耦合度很高

使用IOC的依赖注入（DI）可以解决这个问题

1.环境搭建

IDEA

首先在IDEA中创建一个Maven工程
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>com.trygzb</groupId>
    <artifactId>aispringioc</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.11.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
            <scope>provided</scope>
            <optional>true</optional>
        </dependency>


    </dependencies>


</project>

Maven会自动下载spring需要的几个关键jar包
其中lombok工具可以使代码简化，整洁

详情见：Java开发中用到的，lombok是什么？

创建实体类：

import lombok.Data;

@Data
public class Student {
    private long id;
    private String name;
    private int age;

}

@Data会自动生成get，set方法

1.传统的开发方式，手动new Student（）

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setId(1);
        student.setName("张三");
        student.setAge(22);
        System.out.println(student);
    }
}

运行结果

Student(id=1, name=张三, age=22)

2.通过 IoC 创建对象，在配置⽂件中添加需要管理的对象XML 格式的配置⽂件，⽂件名可以⾃定义
此处为：spring.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"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
">
    <bean id="student" class="Student">
        <property name="id" value="2"></property>
        <property name="age" value="30"></property>
        <property name="name" value="李四"></property>
    </bean>

</beans>

通过id值获取类对象

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Student sd = (Student) applicationContext.getBean("student");
        System.out.println(sd);

运行结果：

Student(id=2, name=李四, age=30）

  • 将对象作为属性值赋给学生对象
    创建Adress类
import lombok.Data;

@Data
public class Address {
    private Integer id;
    private String address;
}

在Student类中添加

private Address address;
  • 修改xml文件，使用ref将Adress赋给学生对象
<bean id="student" class="Student">
        <property name="id" value="2"></property>
        <property name="age" value="30"></property>
        <property name="name" value="李四"></property>
        <property name="address" ref="address"></property>
    </bean>
    <bean id="address" class="Address">
        <property name="id" value="1"></property>
        <property name="address" value="解放路"></property>
    </bean>

运行结果：

Student
(id=2, name=李四, age=30, address=Address(id=1,address=解放路))

IoC底层原理

  • 读取配置⽂件，解析 XML
  • 通过反射机制实例化配置⽂件中所配置所有的 bean
通过运行实类获取bean
ApplicationContext applicationContext = new
ClassPathXmlApplicationContext("spring.xml");
Student student = (Student) applicationContext.getBean(Student.class);
System.out.println(student);

通过有参构造函数创建bean

  • 在实体类Student中创建有参构造
  • 配置文件
<bean id="student3" class="com.southwind.entity.Student">
 <constructor-arg name="id" value="3"></constructor-arg>
 <constructor-arg name="name" value="⼩明"></constructor-arg>
 <constructor-arg name="age" value="18"></constructor-arg>
 <constructor-arg name="address" ref="address"></constructor-arg>
</bean>

<bean id="student3" class="com.southwind.entity.Student">
 <constructor-arg index="0" value="3"></constructor-arg>
 <constructor-arg index="2" value="18"></constructor-arg>
 <constructor-arg index="1" value="⼩明"></constructor-arg>
 <constructor-arg index="3" ref="address"></constructor-arg>
</bean>

给bean注入集合

<bean id="student" class="Student">
	 <property name="id" value="2"></property>
	 <property name="name" value="李四"></property>
	 <property name="age" value="33"></property>
	 <property name="addresses">
	 <list>
	 	<ref bean="address"></ref>
	 	<ref bean="address2"></ref>
	 </list>
	 </property>
</bean>

 
<bean id="address" class="Address">
	 <property name="id" value="1"></property>
	 <property name="name" value="科技路"></property>
</bean> 
<bean id="address2" class="Address">
	 <property name="id" value="2"></property>
	 <property name="name" value="⾼新区"></property>
</bean>

Scope的作用域

Spring 管理的 bean 是根据 scope 来⽣成的，表示 bean 的作⽤域，共4种，默认值是 singleton。

  • singleton：单例，表示通过 IoC 容器获取的 bean 是唯⼀的。Spring 在加载 spring.xml 时就会创建bean

  • prototype：原型，表示通过 IoC 容器获取的 bean 是不同的。当业务代码获取 IoC 容器中的 bean 时，Spring 才去调⽤⽆参构造创建对应的 bean

  • request：请求，表示在⼀次 HTTP 请求内有效。

  • session：回话，表示在⼀个⽤户会话内有效。

Spring 的继承

与 Java 的继承不同，Java 是类层⾯的继承，⼦类可以继承⽗类的内部结构信息；Spring 是对象层⾯的
继承，⼦对象可以继承⽗对象的属性值。

<bean id="student2" class="Student">
	 <property name="id" value="1"></property>
	 <property name="name" value="张三"></property>
	 <property name="age" value="22"></property>
	 <property name="addresses">
	 <list>
		 <ref bean="address"></ref>
		 <ref bean="address2"></ref>
	 </list>
	 </property>
</bean> 
<bean id="address" class="Address">
	 <property name="id" value="1"></property>
	 <property name="name" value="科技路"></property>
</bean> <bean id="address2" class="Address">
	 <property name="id" value="2"></property>
	 <property name="name" value="⾼新区"></property>
</bean> 
<bean id="stu" class="Student" parent="student2">
	 <property name="name" value="李四"></property>
</bean>

⼦对象必须包含⽗对象的所有属性，同时可以在此基础上添加其他的属性

Spring 的依赖

与继承类似，依赖也是描述 bean 和 bean 之间的⼀种关系，配置依赖之后，被依赖的 bean ⼀定先创
建，再创建依赖的 bean，A 依赖于 B，先创建 B，再创建 A。

Spring 的 p 命名空间

p 命名空间是对 IoC / DI 的简化操作，使⽤ p 命名空间可以更加⽅便的完成 bean 的配置以及 bean 之
间的依赖注⼊

<?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"
 xmlns:p="http://www.springframework.org/schema/p"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
">



<bean id="student" class="Student" p:id="1" p:name="张三" p:age="22" p:address-ref="address">
</bean>

<bean id="address" class="Address" p:id="2" p:name="科技路">
</bean>

</beans>

Spring 的⼯⼚⽅法

  • 静态实例方法
    创建实例类
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Car {
    private Integer id;
    private String name;
}

创建静态工厂类

public class StaticCarFactory {
    private static Map<Integer,Car> carMap;
    static {
        carMap = new HashMap<Integer, Car>();
        carMap.put(1, new Car(1,"宝马"));
        carMap.put(2, new Car(2,"马自达"));

    }
    public static Car getCar(Integer id){
        return carMap.get(id);
    }
}

xml中配置静态工厂类

<bean id="car" class="StaticCarFactory" factory-method="getCar">
    <constructor-arg value="2"></constructor-arg>
</bean>

测试类

public class Test1 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Car car = (Car) applicationContext.getBean("car");
        System.out.println(car);
    }
}

输出结果：

Car(id=2, name=马自达)

  • 实例工厂方法
public class InstanceCarFactory {
 private Map<Long, Car> carMap;
 public InstanceCarFactory(){
 carMap = new HashMap<Long, Car>();
 carMap.put(1L,new Car(1L,"宝⻢"));
 carMap.put(2L,new Car(2L,"奔驰"));
 }
 public Car getCar(long id){
 return carMap.get(id);
 }
}

xml

<bean id="carFactory" class="com.southwind.factory.InstanceCarFactory"></bean>

<bean id="car2" factory-bean="carFactory" factory-method="getCar">
 <constructor-arg value="1"></constructor-arg>
</bean>

自动装载

  • byName：通过属性名⾃动装载
  • byType：通过属性的数据类型⾃动装载

1.byName

<bean id="cars" class="Car">
	 <property name="id" value="1"></property>
	 <property name="name" value="宝⻢"></property>
</bean> 

<bean id="person" class="Person" autowire="byName">
	 <property name="id" value="11"></property>
	 <property name="name" value="张三"></property>
</bean>

2.byType

<bean id="car" class="Car">
	 <property name="id" value="2"></property>
	 <property name="name" value="奔驰"></property>
</bean> 
<bean id="person" class="Person" autowire="byType">
	 <property name="id" value="11"></property>
	 <property name="name" value="张三"></property>
</bean>

注：

byType 需要注意，如果同时存在两个及以上的符合条件的 bean 时，⾃动装载会抛出异常。

Tcml_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
反射模拟springIOC.rar
06-02
1. **配置文件解析**：在`springIOC_0602`项目中，我们有一个XML配置文件，它定义了bean的声明和它们的依赖。JDOM库被用来读取这个文件，解析bean的定义，包括bean的类名、属性、依赖等。 2. **Bean的创建**：解析...
初学者认识和书写Spring IoC 和AOP
11-19
初学者认识和书写Spring IoC 和AOP
初学Spring之 IOC 控制反转
m0_58838332的博客
07-02 384
每次都要 new 新的 dao 层类，不适用）用户实际调用的是业务层，dao 层用户不需要接触（程序在 dao 层修改）（Inversion of Control），获得依赖对象的方式反转，即把。即不通过直接访问 dao 层，通过 service 层作为桥梁来调用。（如果不是这种设计思想，主动权在业务层，SpringCloud：（协调）SpringBoot：（构建）1.一个快速开发的脚手架。
Spring之IoC操作Bean
Nicer_feng's blog
09-16 274
上一篇博客主要介绍IoC是什么，本篇主要介绍IoC的Bean管理，刚学的时候懵懵懂懂，不知道xml配置是干什么呀，有的类头上还有个注解是什么意思呢，相信很多初学者也是这样，下面带来管理Bean的两种主要方式。（其实有三种）
初学Spring-IOC
起名好难呀！
10-13 76
初始Spring-IOC 控制反转（IOC）：是一种设计思想，DI(依赖注入)是实现IOC的一种方法，也有人认为DI只是IOC的另一种中说法。没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方。所谓的控制反转就是：后的依赖对象的方式发生了改变。 采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达
初学spring IOC
weixin_53639255的博客
12-13 57
spring ioc和DI的简单概念和使用；依赖注入的类型
Spring中ioc的实现原理
qq_43842093的博客
12-04 6740
学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念，对于初学Spring的人来说，总觉得IoC 、DI这两个概念是模糊不清的，是很难理解的，今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解。 IOC理解 首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解，写得非常通俗易懂，以下内容全部来自原文，原文地址：http://jinnianshilongnian.iteye.com/bl
初学者 Spring IOC 简单理解
Messi杨的博客
11-12 165
什么是IOC  Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。 简单的说就是比如平时我们有两个类，一个teacher类， 一个student类，我们要在teacher中调用student类，可能就是 Student student = new stu...
Spring的IoC和DI初学
qq_44959028的博客
12-06 95
Spring的IoC和DI 一、搭建spring 1.导包 2.创建配置文件ApplicationContext.xml 3.在配置文件(xml/容器)中创建bean对象 <bean id="" class=""></bean> 二.IoC控制反转 将控制对象的权限交给第三方(Spring) IoC底层实现：工厂–反射–xml 1.IoC实现 配置<bean> Spring工厂获取 BeanFactory 的子接口ApplicationContext Applicat
初学Spring--IOC容器之ApplicationContext
weixin_45844558的博客
09-10 103
IOC容器之ApplicationContext
Spring中IOC的简单实战理解
菜根檀的博客
11-08 376
IOC：控制反转 首先，我们回顾下我们平时普通不进行IOC时如果需要创建调用对象应该怎么实现，以下我们有4个类，分别是Dog，Animals，Cat，SayHello public class interface Animals{ public void sayHello(); } public class Dog implements Animals{ @Override public void sayHello(){ System.out.println("wang wang"); }
Spring 之IOC浅析
遛弯的兔子
03-13 168
  学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念，对于初学Spring的人来说，总觉得IoC 、DI这两个概念是模糊不清的，是很难理解的，今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解。1.1 Ioc是什么？Ioc—Inversion of Control，即“控制反转”，不是什么技术...
helloIoc.zip spring ioc控制反转简单测试代码
01-13
Spring框架的核心特性之一就是依赖注入（Dependency Injection，简称DI），它通过控制反转（Inversion of Control，简称IOC）实现。这个"helloIoc.zip"压缩包包含的是一组用于演示Spring IOC基本概念和使用的测试...
模拟Spring IoC
08-17
Spring IoC，全称Inversion of Control，即控制反转，是Spring框架的核心特性之一。它是一种设计模式，通过将对象的创建和管理交由容器处理，使得开发人员可以专注于业务逻辑，而不是对象间的依赖关系。在Spring框架...
Spring项目初学（一）
07-19
**IoC（Inversion of Control，控制反转）**是Spring的核心特性之一。它改变了传统的对象创建方式，将对象的依赖关系管理从代码中剥离出来，交由Spring容器来负责。这样做的好处是提高了代码的可测试性、可维护性和...
探索 Spring WebFlux：构建响应式 Web 应用
最新发布
修复bug生成bug
07-25 315
Spring WebFlux 是 Spring 5 中引入的一个响应式 Web 框架，它是对 Spring MVC 的补充。与传统的 Spring MVC 不同，Spring WebFlux 基于 Reactor 项目，使用非阻塞的 I/O 和响应式流来处理请求和响应。
SpringCloud之使用 Nacos 实现高效购物车商品信息处理
Takumilove的博客
07-24 1151
通过上述步骤，我们成功实现了一个高效的购物车商品信息处理流程。使用 Nacos 来进行服务发现，并结合手写的负载均衡策略，确保了服务调用的高可用性和稳定性。这样不仅提升了系统的性能，还能给用户带来更好的购物体验。
Spring 事务管理 04
程序员进阶之路
07-23 861
事务Transaction）是数据库管理系统（DBMS）中的一个重要概念，它确保数据库操作的**一致性**、**完整性**和**持久性**。在软件开发中，特别是涉及到多个数据库操作或者复杂的数据更新过程时，使用事务能够有效地保证数据操作的正确性和可靠性。以下是几个需要事务的主要原因：
SpringBoot启动命令过长
tiantiantbtb的博客
07-24 378
Error running 'DromaraApplication': Command line is too long. Shorten command line for DromaraApplication or also for Spring Boot default configuration?
Spring IoC入门与容器详解
《Spring揭秘》精选版是一本由王福强撰写的关于Spring框架中Inversion of Control (IoC)的重要学习资料，适合初学者深入了解。本书由InfoQ中文站提供，强调Spring IoC容器在软件开发中的核心作用，特别是它如何通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值