Spring两大核心之IOC

最新推荐文章于 2024-06-21 09:54:19 发布

背着黄油面包的猫

最新推荐文章于 2024-06-21 09:54:19 发布

阅读量1.6k

点赞数 36

分类专栏： SpringBoot 文章标签： spring java 数据库

本文链接：https://blog.csdn.net/m0_62569064/article/details/136338004

版权

SpringBoot 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1.1 初识IOC

先来一个实际的场景理解一下IOC的应用：

当我们存在一个Person的接口时，并由Student Teacher Worker这些实现类

当我们没有Spring时就需要手动去创建

Person p1=new Student()

Person p2=new Teacher()

这个手动的操作可以交给Spring去做，通过注解和配置文件去解决这个问题

public class UserServiceTest {
    /**
     * 创建对象的权力属于自己
     * 原始的方式
     * 耦合度高
     */
    @Test
    public void run(){
        UserService user=new UserServiceImpl();
        UserService user1=new UserServiceImpl();
        System.out.println("user的地址"+user);
        System.out.println("user的地址"+user1);
    }

    /**
     * 创建对象的权力属于Spring
     * 耦合度低
     */
    @Test
    public void run1(){
        //Spring的工厂对 bean工厂’
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        //工厂方法
        UserService us=(UserService) ac.getBean("userService");
        UserService us1=(UserService) ac.getBean("userService");
        System.out.println("us的地址"+us);
        System.out.println("us的地址"+us1);

    }
}

从上面的代码可以看出方法run2中，我们并没有new对象，却可以产生对象，这就是IOC思想的体现

1.2 什么是IOC？

IOC -- Inverse of Control，控制反转，将对象的创建权力反转给Spring框架！！

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。

解决问题：使用IOC可以解决的程序耦合性高的问题！！Spring的工厂读取配置文件。

IOC是将创建对象的权力交给Spring去管理，IOC是一个容器，IOC是一种思想

1.3 IOC的入门

创建maven的java项目并导入依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

编写接口和实现类

public interface UserService {

    public void hello();

}

public class UserServiceImpl implements UserService {
    @Override
    public void hello() {
        System.out.println("Hello IOC!!");
    }
}

编写Spring核心的配置文件，在src目录下创建applicationContext.xml的配置文件，名称是可以任意的，但是一般都会使用默认名称。

在Spring的配置文件中，配置一个bean就相当于把这个类去交给Spring的IOC容器去管理 Spring去管理的类的对象叫做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"
       xsi:schemaLocation="
                    http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!--IOC管理bean-->
    <bean id="userService" class="com.qcbyjy.service.UserServiceImpl" />
    
</beans>

把log4j.properties的配置文件拷贝到resources目录下，做为log4j的日志配置文件。

log4j.rootLogger=DEBUG, stdout, file

# 将日志信息定向到控制台
log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

# 将日志信息定向到文件中
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=C:\\log4j-application.log
log4j.appender.file.MaxFileSize=5MB
log4j.appender.file.MaxBackupIndex=10
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

创建测试类

import com.qcbyjy.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo1 {

    /**
     * 入门程序
     */
    @Test
    public void run1(){
        // 使用Spring的工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过工厂获得类:
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.hello();
    }

}

手动new对象和Spring工厂new对象的区别

手动new两个对象