Spring学习总结第三篇_private usermapper usermapper;

一、IoC理论推导

1.1 传统方式

• UserMapper 接口

public interface UserMapper {
    void getUser();
}
1
2
3

• UserMapperImpl 实现类

public class UserMapperImpl implements UserMapper {
    public void getUser(){
        System.out.println("默认获取的数据！");
    }
}
1
2
3
4
5

• UserService 业务接口

public interface UserService {
    void getUser();
}
1
2
3

• UserServiceImpl 业务实现类

public class UserServiceImpl implements UserService {
    //业务层调Dao层
    private UserMapper userMapper = new UserMapperImpl();
    
    public void getUser() {
       userMapper.getUser();
    }
}
1
2
3
4
5
6
7
8

• 测试类

public class MyTest {
    public static void main(String[] args) {
        //用户实际调用业务层
        UserServiceImpl userService = new UserServiceImpl();
        userService.getUser();
    }
}
1
2
3
4
5
6
7

• 输出结果
  

1.2 Set 注入

• 引出问题：如果，我们再增加一个Mysql的实现类，怎么让用户实现它？结果只能去业务实现类改变new的对象。以此类推，若再加一个Oracle的需求呢，因为客户的每一个需求，又得去重新改变代码，这就造成了很大的复杂问题。

public class UserMapperMysqlImpl implements UserMapper {
    public void getUser() {
        System.out.println("Mysql获取用户数据!");
    }
}
1
2
3
4
5

• 利用set接口进行动态实现值得注入，不再重新改变代码。

public class UserServiceImpl implements UserService {
    //业务层调Dao层
    private UserMapper userMapper;
    //set注入
    public void setUserMapper(UserMapper userMapper) {
        this.userMapper = userMapper;
    }
    public void getUser() {
       userMapper.getUser();
    }
}
1
2
3
4
5
6
7
8
9
10
11

• 总结：之前，程序是主动创建对象，控制权在程序员，所以用户的每一个需求，都需要程序员去改变。使用set注入后，程序不再具有主动性，而是变成了被动的接收对象。这种思想，从本质上解决了问题，程序员不再去管理对象的创建。系统的耦合性大大的降低，可以更加专注业务的实现，这就是IoC的原型。

二、IoC本质

控制反转IoC是一种设计思想，DI（依赖注入）是实现IoC的一种方法。没有IoC的程序中，我们使用面对对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象转移给第三方，控制反转简单的说就是：获得依赖对象的方式反转了。可以使用xml配置实现IoC，也可以使用注解的形式，也可以零配置（自动装配）实现

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

三、IoC实践

• 创建一个Hello实体类

private String str;
1

• 编写applicationContext.xml配置文件

<!--使用spring创建对象-->
<!--id:变量名  class:new的对象，property相当于给对象中的属性设置一个值-->
<bean id="hello" class="com.dmj.entity.Hello">
    <property name="str" value="Spring"/>
</bean>
1
2
3
4
5

• 编写测试类

public class MyTest {
    public static void main(String[] args) {
        //获取对象
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //取出对象
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}
1
2
3
4
5
6
7
8
9

• 运行结果
  
  总结：Hello对象由Spring创建，Hello对象的属性是由Spring容器设置的。这个过程就是控制反转。

四、改善传统方式

• 创建applicationContext.xml

<bean id="impl" class="com.dmj.dao.UserMapperImpl"/>
<bean id="mysqlImpl" class="com.dmj.dao.UserMapperMysqlImpl"/>
<bean id="oracleImpl" class="com.dmj.dao.UserMapperOracleImpl"/>

<bean id="UserServiceImpl" class="com.dmj.service.UserServiceImpl">
    <property name="userMapper" ref="mysqlImpl"/>
</bean>
1
2
3
4
5
6
7

• 测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");
        userServiceImpl.getUser();
    }
}
1
2
3
4
5
6
7

• 运行结果。用户改变需求只需改变ref属性即可。
  

五、总结

控制：以前对象由程序本身控制，创建使用Spring后，对象是Spring创建。
反转：程序本身不创建对象，而变成被动的接收对象。
依赖注入：利用set方法进行注入。
IoC是一种思想，由主动的编程变成被动的接收。