框架体系——SpringIOC

已于 2022-11-30 22:07:42 修改
阅读量561 收藏
点赞数
分类专栏： 框架 文章标签： spring java jvm
于 2022-11-26 22:43:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HBUT_WANGWEI/article/details/127973886
版权

Spring IOC

IOC控制反转

  • IOC 控制反转，全称Inverse of Control，是一种设计理念
  • 由代理人来创建和管理对象，消费者通过代理人来获取对象
  • Ioc的目的是降低对象之间的耦合
  • 通过加入Ioc容器将对象统一管理，将对象关联变为弱耦合。
    在这里插入图片描述

DI依赖注入

  • IoC是设计理念，是现代程序设计遵循的标准，是宏观目标
  • DI(Dependency Injection)是具体技术实现，是微观实现。
  • DI在java中就是利用反射技术实现对象注入（Injection）

Spring

  • Spring可以从狭义和广义两个角度看待
  • 狭义的Spring是指Spring框架（Spring Framework）
  • 广义的Spring是指Spring生态体系

狭义的Spring框架

  • Spring框架是企业开发复杂性的一站式解决方案
  • Spring框架的核心是IoC容器与AoP面向切面编程
  • Spring IoC负责创建与管理系统对象，并在此基础上拓展功能

广义的Spring框架

Spring 全家桶，包括Spring data，springboot，springcloud等等

传统开发方式

  • 对象直接引用导致对象硬性关联，程序难以维护拓展
  • 在这里插入图片描述

Spring IoC容器

  • IoC容器是Spring生态的地基，用于统一创建与管理对象依赖
    在这里插入图片描述
    Spring IoC容器职责
  • 对象的控制权交由第三方统一管理
  • 利用Java反射技术实现运行时对象创建与关联（DI依赖注入）
  • 基于配置提高应用程序的可维护性与拓展性

Spring IoC初体验

需求：
在这里插入图片描述
下面是普通的代码实现，将child和apple进行强关联，这就出现了一个问题，灵活性不高，如果我想修改，就必须改动源代码

    public static void main(String[] args) {
        Apple apple1 = new Apple("红富士", "红色", "欧洲");
        Apple apple2 = new Apple("绿富士", "绿色", "绿大利");
        Apple apple3 = new Apple("蓝富士", "蓝色", "兰博基尼");
        Child lily = new Child("lily", apple1);
        Child andy = new Child("andy", apple2);
        Child luna = new Child("luna", apple3);
        lily.eat();
        andy.eat();
        luna.eat();
    }

针对这个问题，Spring应运而生，下面我们使用Spring来实现上述逻辑

Spring
首先，引入Spring的依赖

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

下面是几大重要的包
在这里插入图片描述

接着在resources下新建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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--在IoC容器启动时，自动由Spring实例化Apple对象，取名sweetApple放入容器中-->
<bean id="sweetApple" class="com.imooc.imooc.spring.ioc.eneity.Apple">
    <property name="title" value="红富士"></property>
    <property name="origin" value="欧洲"></property>
    <property name="color" value="红色"></property>
</bean>

    <bean id="sourApple" class="com.imooc.imooc.spring.ioc.eneity.Apple">
        <property name="title" value="青苹果"></property>
        <property name="origin" value="中亚"></property>
        <property name="color" value="绿色"></property>
    </bean>

    <bean id="softApple" class="com.imooc.imooc.spring.ioc.eneity.Apple">
        <property name="title" value="金帅"></property>
        <property name="origin" value="中国"></property>
        <property name="color" value="黄色"></property>
    </bean>
</beans>

然后新建SpringApplication类，看看获取对象

package com.imooc.imooc.spring.ioc.eneity;

import com.imooc.imooc.spring.ioc.Application;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/22 19:34
 * @Version 1.0
 */
public class SpringApplication {
    public static void main(String[] args) {
        ApplicationContext context =new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
       Apple sweetApple =  context.getBean("sweetApple",Apple.class);
        System.out.println(sweetApple.getTitle());
    }
}

配置Bean的三种方式

Spring框架有三种配置Bean的方式，分别是 XML配置Bean） ，基于注解配置Bean，基于Java代码配置Bean
下面我们详细学习如何通过XML配置Bean；

实例化bean的三种方法

而使用XML配置bean，也有三种实例化Bean方法 基于构造方法对象实例化、基于静态工厂实例化、基于工厂实例方法实例化
在这里插入图片描述

下面是通过工厂类实例化对象，优势在于隐藏了对象创建的细节。
首先是配置：

 <bean id="apple4" class="com.imooc.spring.ioc.factory.AppleStaticFactory" factory-method="CreateSweetApple"/>

    <!-- 使用工厂实例创建对象-->
    <bean id="factoryInstance" class="com.imooc.spring.ioc.factory.ApplyFactoryInstance"></bean>
    <bean id="apple5" factory-bean="factoryInstance" factory-method="createSweetApple"/>

然后是两个工厂及其方法：

public class ApplyFactoryInstance {
    public Apple createSweetApple(){
        Apple apple =new Apple();
        apple.setOrigin("欧洲");
        apple.setColor("红色");
        apple.setTitle("红富士");
        return apple;
    }
}


public class AppleStaticFactory {
    public static Apple CreateSweetApple(){
        Apple apple =new Apple();
        apple.setOrigin("欧洲");
        apple.setColor("红色");
        apple.setTitle("红富士");
        return apple;
    }
}

初始化完成后，我们如何从Ioc容器中获取bean呢？有两种方式，分别如下：
在这里插入图片描述

另外，其实在xml中 bean有ID和Name两个属性，这两个属性有什么区别呢？
首先，我们来看看他们的相同点：

  • bean id 和name都是设置对象在IoC容器中的唯一标识
  • 两者在同一个配置文件中都不允许重复
  • 两者允许在多个配置文件中出现重复，新对象覆盖旧对象

两者不同点：

  • id要求更为严格，一次只能定义一个对象标识（推荐）
  • name更为宽松，一次允许定义多个对象标识
  • tips：id和name命名要求有意义，且驼峰命名
    除此之外，其实Spring还支持无ID/name属性，此时使用类名全路径作为唯一标识。

对象依赖注入

  • 依赖注入是指运行时将容器内对象利用反射赋给其他对象的操作
  • 基于Setter注入对象
  • 基于构造方法注入对象

IOC在项目中的重要用途

示例代码如下：
在这里插入图片描述

ApplicationContext-service.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="bookService" class="com.imooc.spring.ioc.bookshop.service.BookService">
        <property name="bookDao" ref="bookDao"></property>
    </bean>
</beans>

ApplicationContext-dao.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="bookDao" class="com.imooc.spring.ioc.bookshop.dao.BookDaoImpl"></bean>
</beans>

BookDao

package com.imooc.spring.ioc.bookshop.dao;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/24 22:42
 * @Version 1.0
 */
public interface BookDao {
    public void insert();
}

BookDaoImpl

package com.imooc.spring.ioc.bookshop.dao;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/24 22:42
 * @Version 1.0
 */
public class BookDaoImpl implements BookDao{

    public void insert() {
        System.out.println("向Mysql Book 表插入一条数据");
    }
}

bookShopApplication

package com.imooc.spring.ioc.bookshop;

import com.imooc.spring.ioc.bookshop.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/24 22:47
 * @Version 1.0
 */
public class bookShopApplication {
    public static void main(String[] args) {
        ApplicationContext context =  new ClassPathXmlApplicationContext("classpath:ApplicationContext-*.xml");
        BookService bookService = context.getBean("bookService",BookService.class);
        bookService.purchase();
    }
}

实现对象依赖注入有两种方式：setter方法注入/构造方法注入

区别在于xml‘中bean参数 一个使用 property 一个使用 constructor-arg

注入集合对象

1. 注入List：
在这里插入图片描述

2. 注入set
在这里插入图片描述

3. 注入map
在这里插入图片描述

  1. 注入Properties
    在这里插入图片描述

示例代码：

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--list可重复-->
   <!-- <bean id="company" class="com.imooc.spring.ioc.entity.Company">
        <property name="rooms">
            <list>
                <value>2001-总裁办</value>
                <value>2003-总经理办公室</value>
                <value>2010-研发部会议室</value>
                <value>2010-研发部会议室</value>
            </list>
        </property>
    </bean>-->
<!-- set 可重复 -->
    <bean id="c1" class="com.imooc.spring.ioc.entity.Computer">
        <constructor-arg name="brand" value="联想"></constructor-arg>
        <constructor-arg name="type" value="台式机"></constructor-arg>
        <constructor-arg name="sn" value="8389283012"></constructor-arg>
        <constructor-arg name="price" value="3085"></constructor-arg>
    </bean>

    <bean id="company" class="com.imooc.spring.ioc.entity.Company">
        <property name="rooms">
            <set>
                <value>2001-总裁办</value>
                <value>2003-总经理办公室</value>
                <value>2010-研发部会议室</value>
                <value>2010-研发部会议室</value>
            </set>
        </property>

        <property name="computers">
            <map>
                <entry key="dev-880172" value-ref="c1"></entry>

                <entry key="dev-88173">
                    <bean class="com.imooc.spring.ioc.entity.Computer">
                        <constructor-arg name="brand" value="华为"></constructor-arg>
                        <constructor-arg name="type" value="笔记本"></constructor-arg>
                        <constructor-arg name="sn" value="8389283013"></constructor-arg>
                        <constructor-arg name="price" value="5085"></constructor-arg>
                    </bean>
                </entry>
            </map>
        </property>

        <property name="info">
            <props>
                <prop key="phone">010-12345678</prop>
                <prop key="address">湖北省武汉市xx中心</prop>
                <prop key="website">http:www.baidu.com</prop>
            </props>
        </property>
    </bean>
</beans>

查看容器内对象

示例代码：

package com.imooc.spring.ioc;

import com.imooc.spring.ioc.entity.Company;
import com.imooc.spring.ioc.entity.Computer;
import javafx.application.Application;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/24 23:09
 * @Version 1.0
 */
public class SpringApplication {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:ApplicationContext.xml");
        Company company = context.getBean("company", Company.class);
        System.out.println(company);
        System.out.println(company.getInfo().getProperty("website"));
		// 获取容器内对象名称
        String[] beanNames = context.getBeanDefinitionNames();
        for (String beanName : beanNames) {
            System.out.println(beanName);
            System.out.println("类型："+context.getBean(beanName).getClass().getName());
            System.out.println("内容："+context.getBean(beanName).toString());
        }
    }
}

bean scope属性

  • bean scope 属性用于决定对象核实被创建
  • bean scope 配置将影响容器内对象的数量
  • 默认情况下bean会在IoC容器创建后自动序列化，全局唯一

bean scope属性清单

在这里插入图片描述

singleton 与 prototype对比

在这里插入图片描述

bean的生命周期

在这里插入图片描述
配置示例：
在这里插入图片描述

实现极简IoC容器（模拟Spring实现流程）

首先是IOC容器类：
接口：

package com.imooc.spring.ioc.context;

/**
 * ApplicationContext 接口
 *
 * @Author wangw
 * @Date 2022/11/26 22:15
 * @Version 1.0
 */
public interface ApplicationContext {
    public Object getBean(String beanId);
}

实现类：

package com.imooc.spring.ioc.context;

import com.imooc.spring.ioc.entity.Apple;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

import java.lang.reflect.Method;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * ApplicationContext 实现类，本质就是一个IOC容器
 *
 * @Author wangw
 * @Date 2022/11/26 22:16
 * @Version 1.0
 */
public class ClassPathXmlApplicationContext implements ApplicationContext {
    private Map iocContainer = new HashMap();

    public ClassPathXmlApplicationContext() {
        try {
            String filePath = this.getClass().getResource("/applicationContext.xml").getPath();
            filePath = new URLDecoder().decode(filePath, "UTF-8");
            SAXReader reader = new SAXReader();
            Document document = reader.read(filePath);
            List<Node> nodes = document.getRootElement().selectNodes("bean");
            for (Node node : nodes) {
                Element element = (Element) node;
                String id = element.attributeValue("id");
                String className = element.attributeValue("class");
                Class class1 = Class.forName(className);
                Object obj = class1.newInstance();
                List<Node> list = element.selectNodes("property");
                for (Node node1 : list) {
                    Element property = (Element) node1;
                    String propName = property.attributeValue("name");
                    String propValue = property.attributeValue("value");
                    String setMethodName ="set"+propName.substring(0,1).toUpperCase()+propName.substring(1);
                    System.out.println("准备执行"+setMethodName+"方法注入数据");
                    Method method = class1.getMethod(setMethodName,String.class);
                    method.invoke(obj,propValue);

                }
                iocContainer.put(id, obj);
                System.out.println("ioc容器初始化完毕");
                System.out.println(iocContainer);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public Object getBean(String beanId) {
        return iocContainer.get(beanId);
    }
}

配置XML:

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <bean id ="sweetApple" class="com.imooc.spring.ioc.entity.Apple">
        <property name="title" value="红富士"></property>
        <property name="origin" value="欧洲"></property>
        <property name="color" value="红色"></property>
    </bean>
</beans>

实体类：

package com.imooc.spring.ioc.entity;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/26 22:11
 * @Version 1.0
 */
public class Apple {
    private String title;
    private String color;
    private String origin;

    public Apple() {
    }

    public Apple(String title, String color, String origin) {
        this.title = title;
        this.color = color;
        this.origin = origin;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getOrigin() {
        return origin;
    }

    public void setOrigin(String origin) {
        this.origin = origin;
    }
}

启动类：

package com.imooc.spring.ioc;

import com.imooc.spring.ioc.context.ApplicationContext;
import com.imooc.spring.ioc.context.ClassPathXmlApplicationContext;
import com.imooc.spring.ioc.entity.Apple;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/26 22:27
 * @Version 1.0
 */
public class Application {
    public static void main(String[] args) {
        ApplicationContext context =new ClassPathXmlApplicationContext();
        Apple apple = (Apple) context.getBean("sweetApple");
        System.out.println(apple);

    }
}

至此实现效果如下，可以看出其实Spring IoC容器就是通过反射实现的
在这里插入图片描述

基于注解和Java Config 配置 IoC容器

基于注解的优势

  • 摆脱繁琐的XML形式的bean与依赖注入配置
  • 基于"声明式"的原则，更适合轻量级的现代企业应用
  • 让代码可读性变得更好，研发人员拥有更好的开发体验

三类注解

  • 组件类型注解——声明当前类的功能和职责
  • 自动装配注解——根据属性特征自动注入对象
  • 元数据注解——更细化的辅助IoC容器管理对象的注解

四类组件类型注解

在这里插入图片描述
如果我们需要使用上面几个注解，有个前提条件是需要 开启组件扫描，即
在这里插入图片描述
在这里需要注意的是 基于注解配置和基于xml配置的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"
       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">

    <context:component-scan base-package="com.imooc"/>

</beans>

两类自动装配注解

在这里插入图片描述
在使用按类型装配过程中可能会存在一个问题，就是存在两个相同类型的对象，会存在装配失败的情况，此时可以使用@Primary注解标识其中一个为主要，当注入时就会优先选用这个。
或者我们可以按照名称装配完成注入。
需要注意的是当使用@Resource注解时，有以下情况：
当配置了name时候：直接按照name在IoC容器中注入bean
未配置name时，首先根据属性名称去IoC容器中匹配，匹配上则注入，如果没有匹配上则按照类型去匹配注入，此时同@Autowired

其他元数据注解

在这里插入图片描述
我们使用@Value注解时有几个点需要注意：
第一是一般@Value数据从配置文件读取，所以首先需要增加配置文件，如：
在这里插入图片描述
第二是需要在applicationContext.xml增加：
在这里插入图片描述
第三则是引用配置，如下：
在这里插入图片描述

基于Java Config 配置IoC容器

基于Java Config的优势

  • 完全摆脱了XML束缚，使用独立J啊v阿雷管理对象和依赖
  • 注解配置相对分散，利用 Java Config 可以对配置集中管理
  • 可以在编译时进行依赖检查，不容易出错

Java Config 核心注解

在这里插入图片描述

下面给出示例代码：
Config类：

package com.imooc.spring.ioc;

import com.imooc.spring.ioc.controller.UserController;
import com.imooc.spring.ioc.dao.EmployeeDao;
import com.imooc.spring.ioc.dao.UserDao;
import com.imooc.spring.ioc.service.UserService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/28 22:36
 * @Version 1.0
 */
@Configuration //说明当前类是一个【配置类，用于替代applicationContext.xml
@ComponentScan(basePackages = {"com.imooc"}) //配置这个等同于xml中的content:component-scan
public class Config {
    @Bean
    public UserDao userDao() {
     UserDao userDao = new UserDao();
     System.out.println(userDao);
        return userDao;
    }
 @Bean
 //先按name尝试注入，不存在则按照类型注入
 public UserService userService(UserDao userDao , EmployeeDao employeeDao) {
     UserService userService = new UserService();
  System.out.println(userService);
  System.out.println("注入userDao"+userDao);
     userService.setUserDao(userDao);
  userService.setEmployeeDao(employeeDao);
  return userService;
 }

 @Bean
 public UserController userController(UserService userService) {
  UserController userController = new UserController();
  System.out.println("注入userService"+userService);
  userController.setUserService(userService);
  return userController;
 }



}

启动类：（首句发生改变，使用 new AnnotationConfigApplicationContext(Config.class)）

package com.imooc.spring.ioc;

import javafx.application.Application;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.lang.annotation.Annotation;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/28 22:42
 * @Version 1.0
 */
public class SpringApplication {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        System.out.println("-------------------------------------------------------------");
        String[] ids= context.getBeanDefinitionNames();
        for (String id : ids) {
            System.out.println(id+":"+context.getBean(id));
        }
    }
}

其余类无特殊配置，仅给出一个示例：

package com.imooc.spring.ioc.service;

import com.imooc.spring.ioc.dao.EmployeeDao;
import com.imooc.spring.ioc.dao.UserDao;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/28 22:36
 * @Version 1.0
 */
public class UserService {
    private UserDao userDao;
    private EmployeeDao employeeDao;

    public EmployeeDao getEmployeeDao() {
        return employeeDao;
    }

    public void setEmployeeDao(EmployeeDao employeeDao) {
        this.employeeDao = employeeDao;
    }

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

经过上面基于xml的配置以及基于java Config的配置，可以看出，xml便于维护，但是较复杂，Java Config的注解适用于开发，但不利于维护，所以xml更适合大型项目的协同合作，基于Java Config的注解更适合于敏捷开发，例如：springboot就默认使用这个

Spring Test 测试模块

  • Spring Test 是Spring中用于测试的模块
  • Spring Test 对JUnit单元测试框架有良好的整合
  • 通过Spring Tets 可在JUnit在单元测试时初始化IoC容器

Spring与JUnit整合过程

  • maven 依赖spring-test
  • 利用 @RunWith 及 @ContextConfiguration描述测试用例类
  • 测试用例类从容器获取对象完成测试用例的执行
import com.imooc.spring.ioc.servie.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

/**
 * todo {类简要说明}
 *
 * @Author wangw
 * @Date 2022/11/28 23:20
 * @Version 1.0
 */
// 将Junit4的执行权加交由Spring Test，在测试用例执行前自动初始化IoC容器
@RunWith(SpringJUnit4ClassRunner.class)
// ioc初始化过程中通知加载哪个配置文件
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class SpringTestor {
    @Resource
    private UserService userService;

    @Test
    public void testUserService(){
        userService.createUser();
    }
}
知虚
关注
专栏目录
Spring框架——IOC
weixin_60246887的博客
08-19 1773
spring框架IOC部分的内容，可配合尚硅谷spring5视频实用。基于视频内容根据自己理解整理出的，按照视频顺序的笔记可以看另一位博主的文章，链接如下：https://blog.csdn.net/m0_63324772/article/details/124129130
【IOC框架】分析与理解
weixin_34153893的博客
02-01 3923
1 IoC理论的背景我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。图1：软件系统中耦合的对象如果我们打开机械式手表的后盖，就会看到与上面类似的情形，各个齿轮分别带动时针、分针和秒针顺时针旋转，从而在表盘上产生正确的时间。图1中描述的就是这样的一个齿轮组，它拥有多个独立的齿轮，这些齿轮相互啮合在一起，协同工作，共同...
C#进阶-快速了解IOC控制反转及相关框架的使用
最新发布
rwo_bear的博客
09-11 2677
IOC，即控制反转（Inversion of Control），它通过将对象的创建和管理责任从应用程序代码中转移到外部容器或框架中，实现了对象之间的松耦合和依赖性反转。
Spring5入门(1)
细数长流
03-03 151
Spring框架的描述 1、Spring 是轻量级的开源的 JavaEE 框架 2、Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部分：IOC 和 Aop （1）IOC：控制反转，把创建对象过程交给 Spring 进行管理 （2）Aop：面向切面，不修改源代码进行功能增强 4、Spring 特点 （1）方便解耦，简化开发 （2）Aop 编程支持 （3）方便程序测试 （4）方便和其他框架进行整合 （5）方便进行事务操作 （6）降低 API 开发难度 顺便说一下GA是稳定版 SNAP
Spring框架（IOC）
eyvr的博客
03-01 4014
一、什么是 IOC （1）控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理 （2）使用 IOC 目的：为了耦合度降低 二、IOC 底层原理 xml 解析、工厂模式、反射 三、IOC过程 xml解析帮助我们得到xml文件中我们需要的属性值 利用这个属性值配和下面的class类的两个方法创建出我们需要的对象（返回前做类型强转） 三、BeanFactory 接口 IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂 Spring 提供 IOC 容器实现两种方式：（两个接口）
Spring学习总结——Spring实现IoC的多种方式
m0_68850571的博客
04-19 3259
一、Spring框架概述 1.1、资源 1.2、Spring历史 1.3、框架特征与功能 1.4、Spring组成 1.5、Spring Boot与Spring Cloud 二、IoC基础 三、使用XML配置的方式实现IOC 3.1、使用无参构造方法创建对象 3.2、使用有参构造方法创建对象 3.3、通过属性赋值 3.4、对象引用 3.5、对象作用域 3.6、延迟初始化bean 四、使用Spring注解配置IOC 4.1、修改BookDAO 4.2
SSM框架——Spring的Ioc和DI及数据源的配置
成功在于坚持！
05-01 388
目录 1. Spring简介 1.1 Spring是什么 1.2 Spring发展历程 1.3 Spring的优势 1.4 Spring的体系结构 2. Spring快速入门 2.1 Spring程序开发步骤 2.2 导入Spring开发的基本包坐标 2.3 编写Dao接口和实现类 2.4 创建Spring核心配置文件 2.5 在Spring配置文件中配置UserDaoImpl 2.6 使用Spring的API获得Bean实例 2.7 知识要点 3. Spring配置文件 3.
手写Spring框架——IOC实现(四)
2201_75694536的博客
12-14 1030
通过本文的扩展，我们进一步完善了mini-spring的ioc功能，实现了基于@Component的扫描与BeanDefinition注册过程，还实现了@Autowired的部分功能；下一章我们将构建完整的工厂体系，实现DefaultListableBeanFactory，并且扩充原有的BeanFactory的功能；之后，介绍Spring的事件发布监听机制及应用案例，然后完善mini-spring的事件的发布与监听功能。
Spring核心功能之——IOC与AOP
yzl1293346757的博客
12-07 1260
Spring中的IOC与AOP的思想,以及在Spring中是如何使用的
【SSH进阶之路】Spring的IOC逐层深入——Spring的IOC原理[通俗解释一下]（三）
努力+坚持，而且还很年轻
01-23 9899
1. IoC理论的背景 我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。 图1：软件系统中耦合的对象 如果我们打开机械式手表的后盖，就会看到与上面类似的情形，各个齿轮分别带动时针、分针和秒针顺时针旋转，从而在表盘上产生正确的时间。图1中描述的就是这样的一个齿轮组，它拥有多个独立的齿轮，这些齿轮相互啮合在一起，
Spring IOC
Hern（宋兆恒）
08-06 305
广义的 IOC IoC(Inversion of Control) 控制反转，即“不用打电话过来，我们会打给你”。两种实现：依赖查找（DL）和依赖注入（DI）。 IOC 和 DI 、DL 的关系（这个 DL，Avalon 和 EJB 就是使用的这种方式实现的 IoC）： DL 已经被抛弃，因为他需要用户自己去是使用 API 进行查找资源和组装对象。即有侵入性。 DI 是 S...
SpringIoc原理分析（手把手教你自制springioc框架）
何小杰的博客
11-06 1045
手写SpringIOC框架 什么是SpringIOC 什么是SpringIOC，就是把每一个bean(实体类)与bean(实体了)之间的关系交给第三方容器进行管理。 Xml配置: &amp;amp;amp;lt;beans&amp;amp;amp;gt; &amp;amp;amp;lt;bean id=&amp;amp;quot;user1&amp;amp;quot; class=&amp;amp;quot;com.itmayiedu.entity.Us
Spring框架(IOC)
wangyesky的博客
03-25 100
Spring框架 IOC(控制反转) 问题：1.谁控制谁 2.什么叫反转 3.为何要这么做 举个例子:有如下的类 public interface IDao public class ITopicDaoImpl implements IDao public class IUsersDaoImpl implements IDao public class IUsersServicesImpl pub...
spring框架 IoC
hello_momo的博客
03-31 107
spring核心之一，控制反转（IoC） 目标类 提供UserService接口和实现类 获得UserService实现类的实例 spring之前，new一个对象 spring之后，IoC控制反转 需要实例对象时，从spring容器中获得，需要将实现类的全限定类名配置到xml中 本例中将接口，实现类，测试类，配置xml放在同一个package中 接口： public interface U...
Spring框架，IOC
weixin_67358175的博客
03-25 159
1.控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理2.使用 IOC 目的：为了耦合度降低IoC是Inversion of Control的简写，即控制反转。IoC并不是一门技术，而是一种设计思想。在没有IoC设计的场景下，开发人员在使用所需的对象时，需手动创建各种对象，如new Student()。有了IoC这样的设计思想，在开发中，意味着将设计好的对象交给容器管理，而不再是像传统的编程方式中，在对象内部直接控制对象。
Spring框架-IOC
J的博客
03-22 435
介绍Spring框架的重点-IOC
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

知虚

权当做笔记，打赏随您心意

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

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

打赏作者

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

抵扣说明：

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

余额充值