Spring的IOC入门

清风冉起

已于 2023-04-23 19:52:16 修改

阅读量323

点赞数 1

文章标签： spring java servlet Powered by 金山文档

于 2023-03-25 08:44:20 首次发布

本文链接：https://blog.csdn.net/m0_73671382/article/details/129762453

版权

1.IOC、IOC容器、DI

1.1==IOC(Inversion of Control) 控制反转==

（1）什么是控制反转呢？

使用对象时，由主动new产生对象转换为由==外部==提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。

业务层要用数据层的类对象，以前是自已new的

现在自己不new了，交给别人[外部]来创建对象

别人[外部]就反转控制了数据层对象的创建权

这种思想就是控制反转

别人[外部]指定是什么呢?继续往下学

（2）Spring和IOC之间的关系是什么呢?

Spring技术对1OC思想进行了实现

Spring提供了一个容器，称为==IOC容器==，用来充当IOC思想中的"外部"

IOC思想中的别人[外部]指的就是Spring的IOC容器

（3）IOC容器的作用以及内部存放的是什么?

IOC容器负责对象的创建、初始化等一系列工作，其中包含了数据层和业务层的类对象

被创建或被管理的对象在IOC容器中统称为==Bean==

IOC容器中放的就是一个个的Bean对象

（4）当I0C容器中创建好service和dao对象后，程序能正确执行么?

不行，因为service运行需要依赖dao对象

IOC容器中虽然有service和dao对象

但是service对象和dao对象没有任何关系

需要把dao对象交给service也就是说要绑定service和dao对象之间的关系

（5）IOC的技术实现

DI（依赖注入）：dependency injection ，程序只需要提供要使用的对象名称就可以了，对象如何创建，如何从容器中查找，获取都是由容器内部自己实现。

依赖名词：比如说class A类使用了class B类的属性或者方法，叫做class A依赖B；

（6）spring框架使用的是DI实现IOC

通过spring框架，只需要提供要使用的对象名词就可以了，从容器中获取名称对应的对象。

spring底层使用的反射机制，通过反射创建对象，和属性。

DI：依赖注入，一个BookService类的功能需要依赖另外一个BookDao类配合，同时需要赋上一
个具体的对象，则成这种关系是依赖注入；
IOC：控制反转，以前依赖的对象自己直接new，现在不需要new，框架会自动注入对象，创建对
象的权利转移给了框架；
spring框架负责所有对象的创建、管理和依赖注入；所有的对象存储的容器叫做IOC容器；

1.2IOC原理

IOC底层使用到是三个东西：

xml解析：解析我们写在xml文件中的配置

工厂模式：及把对象统一交给工厂管理，获取对象都从工厂获取，降低对象之间耦合

反射：用于用解析的xml里的配置创建出对象

IOC底层实现依赖一个对象工厂，这个工厂就是IOC容器，负责创建并提供对象。

Spring 提供 IOC 容器实现两种方式：（两个接口）

（1）BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用。加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象。

（2）ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。加载配置文件时候就会把在配置文件对象进行创建。

2.创建项目，导入spring的jar 包

3.按照如下目录结构创建接口及其实现类，做好准备工作

servlet层

package com.zhao.servlet;

import com.zhao.service.BookService;
import com.zhao.service.impl.BookServiceVip;
import com.zhao.service.impl.BookServicelmpl;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class BookServlet {

    BookService bookService;

    /**
     * 更换功能需要修改源代码
     */
    @Test
    public void add(){
        System.out.println("BookServlet...add");
        //1.获得IOC容器
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        //2.根据名字从容器中获取对象
        bookService= (BookService) context.getBean("bookService");
        bookService.save();
    }

}

service层

//接口
package com.zhao.service;

public interface BookService {
    void save();
}

//实现类
public class BookServicelmpl implements BookService {

    private String name;
    private BookDao bookDao;

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

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }


@Override
    public void save() {

        System.out.println("BookServicelmpl...save"+name);
        bookDao.insert();

    }

dao层

//接口
package com.zhao.dao;

public interface BookDao {
    public void insert();
}

//实现类
public class BookDaoImpl implements BookDao {

    @Override
    public void insert() {

        System.out.println("BookDaoImpl...save");
    }
}

注意：
此时项目没办法执行，因为没有做依赖对象的注入。

4.使用spring完成IOC的配置和DI依赖注入

4.1创建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的IOC容器中，并起上名字
    id：表示给对象起名字
    class：类的全类名
    -->
    <bean id="bookDao" class="com.zhao.dao.impl.BookDaoImpl"></bean>

    <bean id="bookService" class="com.zhao.service.impl.BookServicelmpl">
        <property name="name" value="张三" />
        <property name="bookDao" ref="bookDao" />
    </bean>
</beans>

bean标签表示把对应class的对象创建到IOC容器中，如果当前对象有依赖的其他对象，那么可以
通过property对依赖的对象使用ref引用容器中已经注册过的对象。

spring标准配置文件：

（1）.根标签是beans

（2）后面是约束文件

（3）beans里面是bean声明

（4）什么是bean：bean就是Java对象，spring容器管理的Java对象就叫bean

spring创建对象的特点

（1）容器对象ApplicationContext对象，获取要使用的Java对象，执行getbean(“的id”)；

（2）spring默认的是调用类的无参构造方法，创建对象，

（3）spring读取配置文件时，会一次创建后所有声明的Java对象，都放到map中

DI：给属性赋值

spring调用类的无参构造方法，创建对象，对象创建后，给属性赋值，

给属性赋值有

（1）xml配置文件中的标签和属性；

（2）使用注解

DI分类：set注入，也叫设值注入，构造注入

基于xml的DI

在xml配置文件中使用标签属性，完成对象创建，属性赋值

注意：BookServiceImpl需要给bookDao属性设置setter方法，框架才能自动注入

public class BookServicelmpl implements BookService {

    private String name;
    private BookDao bookDao;

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

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }




    @Override
    public void save() {

        System.out.println("BookServicelmpl...save"+name);
        bookDao.insert();

    }
}

4.2在servlet中进行测试

1.首先获取IOC的容器；
2.从容器中获取bookService对象；
3.执行方法：servlet执行---service执行，由于spring完成了依赖注入------dao层执行

public class BookServlet {

    BookService bookService;

    /**
     * 更换功能需要修改源代码
     */
    @Test
    public void add(){
        System.out.println("BookServlet...add");
        //1.获得IOC容器
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        //2.根据名字从容器中获取对象
        bookService= (BookService) context.getBean("bookService");
        bookService.save();
    }

}

4.3测试结果：

清风冉起

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring的IOC入门

DI：依赖注入，一个BookService类的功能需要依赖另外一个BookDao类配合，同时需要赋上一个具体的对象，则成这种关系是依赖注入；IOC：控制反转，以前依赖的对象自己直接new，现在不需要new，框架会自动注入对象，创建对象的权利转移给了框架；spring框架负责所有对象的创建、管理和依赖注入；所有的对象存储的容器叫做IOC容器；
复制链接

扫一扫