Spring学习笔记-IOC

最新推荐文章于 2024-11-08 14:58:24 发布

AbtYee

最新推荐文章于 2024-11-08 14:58:24 发布

阅读量114

点赞数

分类专栏： Spring 文章标签： java spring ioc

本文链接：https://blog.csdn.net/aaaabt/article/details/118298147

版权

Spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Spring学习笔记-IOC

IOC理论推导

原来的一个业务开发流程：

UserDao 数据访问接口

public interface UserDao{
    void getUser();
}

UserDaoImpl 数据访问实现类

public class UserDaoImpl implements UserDao{
    @Override
    public void getUser(){
        SyStem.out.println("获取到普通用户");
    }
}

public class UserDaoSuperImpl implements UserDao{
    @Override
    public void getUser(){
        System.out.println("获取到超级用户");
    }
}

UserService 业务接口

public interface UserService{
    void getUser();
}

UserServiceImpl 业务实现类

public class UserServiceImpl implements UserService{
    private UserDao userDao = new UserDaoImpl();
    // private UserDao userDao = new UserDaoSuperImpl();
    
    @Override
    public void getUser(){
        userDao.getUser();
    }
}

测试类

public class MyTest{
    public static void main(String[] args){
        UserService userService = new UserServiceImpl();
        userService.getUser();
    }
}

那么在我们原来的代码中，用户的需求可能会影响我们原来的代码，也即用户的需求每发生一次变更，我们就要去修改一次源代码，但如果代码量十分庞大，修改一次的代价也十分昂贵，比如如上述代码，当我们需要获取一个普通用户的时候，我们需要去new一个UserDaoImpl，而当我们需要一个超级用户的时候，又得去更改我们new的实例

而当我们在UserServiceImpl中将获取userDao实例的方式修改之后：

private UserDao userDao;

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

此时我们再来使用测试类来获取不同级别的用户，我们就可以通过只修改注入的不同实例来实现我们的需求：

public class MyTest{
    public static void main(String[] args){
        UserService userService = new UserServiceImpl();
        ((UserServiceImpl)userService).setUserDao(new UserDaoImpl());
        // ((UserServiceImpl)userService).setUserDao(new UserDaoSuperImpl());
        
        userService.getUser();
    }
}

那么两者的区别在哪呢？

前者的方式，程序都是主动创建对象，控制权在程序员手上
使用了set注入后，程序不再具有主动性，而是变成了被动的接收对象

而在这种思想上，从本质解决了问题，程序员也不用再去管理对象的创建了，系统的耦合性大大降低，可以更加专注于再业务的实现上，而这就是IOC的原型

IOC本质

控制反转(IOC)是一种设计思想，**而DI(依赖注入)**是实现IOC的一种方式。在没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由自己控制；而在控制反转后则将对象的创建转移给第三方，如在Spring中的IOC容器(applicationContext)，而在Spring中IOC的底层实现原理就是反射+工厂方法模式，使得获得依赖对象的方式反转了

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从IOC容器中取出需要对象

在这里插入图片描述

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到零配置的目的

控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中，实现控制反转的是IOC容器，其实现方法是依赖注入(DI)

代码实现

实体类

public class Hello {
    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Hello{" +
                "name='" + name + '\'' +
                '}';
    }
}

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

    <!--使用Spring来创建，在Spring中，这些都称为bean
		
		类型 变量名 = new 类型()
		Hello hello = new Hello()

		id：变量名
		class：new的对象
		property：相当于给对象设置一个值
		ref：引用Spring容器中创建好的对象
		value：具体的值
	-->
    <bean id="hello" class="com.alb.pojo.Hello">
        <property name="name" value="Alb"/>
    </bean>

</beans>

测试类

public class MyTest {
    public static void main(String[] args) {
        // 获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 我们的对象都在Spring中管理了，如果要使用，直接取出来就可以
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

IOC创建对象的方式

默认使用无参构造器创建对象

User实体类

public class User {
    private String name;

    public User(){
        System.out.println("User的无参构造");
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

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

    <bean id="user" class="com.alb.pojo.User">
        <property name="name" value="Alb"/>
    </bean>

</beans>

测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        User user = (User) context.getBean("user");
        System.out.println(user.toString());
    }
}

结果

在这里插入图片描述

有参构造器

// User实体类
public class User {
    private String name;

    public User(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

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

    <!--第一种方式，下标赋值-->
    <bean id="user" class="com.alb.pojo.User">
        <constructor-arg index="0" value="Alb"/>
    </bean>
    
    <!--第二种方式，通过类型创建，不建议使用-->
    <bean id="user" class="com.alb.pojo.User">
        <constructor-arg type="java.lang.String" value="Albb"/>
    </bean>
    
    <!--通过参数名创建-->
    <bean id="user" class="com.alb.pojo.User">
        <constructor-arg name="name" value="Albe"/>
    </bean>

</beans>