Spring框架一文带你吃透IOC技术

本文目录

文章目录

- - 本文目录
- ✨loC的技术实现
- ✨实现步骤
- ✨创建接口和实现类
- ✨创建Spring的配置文件和声明bean
- ✨创建spring容器对象
- ✨spring容器创建对象的特点
- ✨创建非自定义类的对象
- ✨创建没有接口的类的对象
- ✨获取容器中对象的信息

loC，Inversion ofControl:控制反转，是一个理论，一个指导思想。指导开发人员如何使用对象，管理对象的。把对象的创建，属性赋值，对象的声明周期都交给代码之外的容器管理。

loC分为控制和反转
**●控制:**对象创建，属性赋值，对象声明周期管理。
●反转:把开发人员管理对象的权限转移给了代码之外的容器实现。由容器完成对象的管理。
●正转:开发人员在代码中，使用new构造方法创建对象。开发人员掌握了对象的创建，属性赋值，对象从开始到销毁的全部过程。开发人员有对对象全部控制。

通过容器，可以使用容器中的对象(容器已经创建了对象，对象属性赋值了，对象也组装好了)。 Spring就是一个容器，可以管理对象，创建对象，给属性赋值。

✨loC的技术实现

DI(依赖注入):DependencyInjection，缩写是DI是loC的一种技术实现。程序只需要提供要使用的对象的名称就可以了，对象如何创建，如何从容器中查找，获取都由容器内部自己实现。

依赖名词:比如说ClassA类使用了ClassB的属性或者方法，叫做ClassA依赖ClassB。

public class ClassB {
    public void creat(){ }

}

public class ClassA{
    //属性
    private ClassB b = new ClassB();
    
    public void buy(){
        b.creat();
    }
}

执行ClassA的buy()
ClassA a = new ClassA()；
a.buy();

注意：Spring框架使用的DI实现loC.通过spring框架，只需要提供要使用的对象名称就可以了。从容器中获取名称对应的对象。spring底层使用的反射机制，通过反射创建对象，给属性。

✨实现步骤

使用spring： spring作为容器管理对象，开发人员从spring中获取要使用的对象。

实现步骤：

● 新建maven项目

● 加入依赖，修改pom.xml
spring-context ： spring依赖
junit：单元测试

● 开发人员定义类：接口和实现类
类也可以没有接口。
接口和实现类定义：和没有spring一样。

● 创建spring的配置文件。作用：声明对象。
把对象交给spring创建和管理。
使用表示对象声明，一个bean表示一个java对象。

● 使用容器中的对象。
创建一个表示spring容器的对象 ApplicationContext
从容器中，根据名称获取对象，使用getBean(“对象名称”)

✨创建接口和实现类

public interface SomeService {
    void doSOme();
}
123
public class SomeServiceImpl implements SomeService {
    @Override
    public void doSOme() {
        System.out.println("1");
    }
}

✨创建Spring的配置文件和声明bean

在 src/main/resources/目录现创建一个 xml 文件，文件名可以随意，但Spring 建议的名称为 applicationContext.xml。spring 配置中需要加入约束文件才能正常使用，约束文件是 xsd 扩展名。

<?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">
</beans>

spring标准的配置文件：
beans是跟标签，他的后面是约束文件说明。
beans里面是bean 声明。
bean ：用于定义一个实例对象。一个实例对应一个 bean 元素。
id：该属性是 Bean 实例的唯一标识，程序通过 id 属性访问 Bean，Bean
与 Bean 间的依赖关系也是通过 id 属性关联的。
class：指定该 Bean 所属的类，注意这里只能是类，不能是接口。

下面我们开始创建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">

    <!--声明对象
       id:自定义对象名称，唯一值。(可以没有，spring可以提供默认名称)
       class：类的全限定名称，spring通过反射机制创建对象，不能是接口

       spring根据id，class创建对象， 把对象放入到spring的一个map对象。
       map.put(id,对象)
   -->
    <bean id="someService" class="youfei1_v.service.impl.SomeServiceImpl"/>
</beans>

✨创建spring容器对象

public class AppMain {

    public static void main(String args[]){
        //SomeService service  = new SomeServiceImpl();
        //service.doSome();

        //1.指定spring配置文件: 从类路径（classpath）之下开始的路径
        String config="beans.xml";
        //2.创建容器对象， ApplicationContext 表示spring容器对象。 通过ctx获取某个java对象
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //3.从容器中获取指定名称的对象， 使用getBean(“id”)
        SomeService service = (SomeService) ctx.getBean("someService");
        //4.调用对象的方法，接口中的方法
        service.doSome();

    }
}

测试类

//spring创建对象， 调用是类的那个方法？
    //默认是调用类的无参数构造方法。
    @Test
    public void test01(){
        String config="beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

       // SomeService service  = (SomeService) ctx.getBean("someService");
     //   service.doSome();
     
		//按照类型获取对象，就不用转换对象了
        SomeService service = ctx.getBean(SomeService.class);
        service.doSome();
    }

ApplicationContext介绍
在这里插入图片描述

✨spring容器创建对象的特点

1.容器对象ApplicationContext:接口
通过ApplicationContext对象，获取要使用的其他iava对象，执行getBean(“bean的id”
2.spring默认是调用类的无参数构造方法，创建对象
3.spring读取配置文件，一次创建好所有的java对象，都放到map中。

public class SomeServiceImpl implements SomeService {

    /**
     * spring默认使用的无参数构造方法，创建对象。
     * 如果定义了有参数构造方法， 应该在定义无参数构造方法
     */
    public SomeServiceImpl() {
        System.out.println("SomeServiceImpl的无参数构造方法");
    }
}
//spring创建对象， 调用是类的那个方法？
    //默认是调用类的无参数构造方法。
    @Test
    public void test01(){
        String config="beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //SomeService service = ctx.getBean(SomeService.class);
        //service.doSome();

        SomeService service  = (SomeService) ctx.getBean("someService");
        service.doSome();
    }

创建容器对象时会自动创建配置文件中的对象

   /**
      spring是在什么时候创建的对象？
      创建spring容器对象的时候，会读取配置文件，创建文件中声明的java对象。

      优点：
         获取对象的速度快， 因为对象已经创建好了

      缺点：
         占用内存
     */
    @Test
    public void test02(){
        String config="beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //SomeService service  = (SomeService) ctx.getBean("someService");
        //service.doSome();
    }
/**
     *  spring容器创建对象， 一次创建几个 ？
     *  在创建容器（ApplicationContext）对象时，会把配置文件中的所有对象都创建出来（spring的默认规则）(有几个bean就创建几个对象)
     */
    @Test
    public void test03(){
        String config="beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //SomeService service  = (SomeService) ctx.getBean("someService");
        //service.doSome();
    }

✨创建非自定义类的对象

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">

    <!--创建非自定义对象-->
    <bean id="mydate" class="java.util.Date" />

</beans>

测试

//让spring创建非自定义类的对象
    //有class就能让spring创建对象
    @Test
    public void test05(){
        String config="beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        Date date = (Date) ctx.getBean("mydate");
        System.out.println("date==="+date);
    }

✨创建没有接口的类的对象

//没有接口的类
public class OtherService {
    public void doOther(){
        System.out.println("执行OtherService的doOther()");
    }
}

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">

    <bean id="otherService" class="com.service.OtherService"/>

</beans>

测试

    //有class就能让spring创建对象
    @Test
    public void test05(){
        String config="beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        OtherService service = (OtherService) ctx.getBean("otherService");
        service.doOther();
    }

✨获取容器中对象的信息

    /**
     * 获取容器中对象的信息
     */
    @Test
    public void test04(){
        String config="beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

        //获取容器中定义对象的数量 。一个bean对应一个对象
        int nums = ctx.getBeanDefinitionCount();
        System.out.println("容器中定义对象的数量=="+nums);

        //获取容器中定义的对象名称
        String names[] = ctx.getBeanDefinitionNames();
        for(String name:names){
            System.out.println("容器中对象的名称=="+name);
        }
    }