Spring -IOC理念

学到现在，我们编程的时候架构模板应该是都有了的，笔者主要使用的就是接口和实现接口的方式，下边以dao和service为规范简单的来看几行代码。

public class UserServiceImpl implements UserService {

    private UserDao  userDao = new UserDaoImpl();
    private UserDao userDao1 = new UserMysqlDaoImpl();
    private UserDao userDao2 = new UserOracleDaoImpl();

    @Override
    public void getUser() {
        //当用户需求改变，我们将要每次都要改变代码，很麻烦，从而springIoc的简单就来了。
        userDao1.getUser();//这是新添加的需求，我要改源代码
        userDao2.getUser();  //这又是新添加的需求，我又要改。
        userDao.getUser();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

        System.out.println("Hello world!");
    }
}
1
2
3
4
5
6
7
8

这是我们经常写的代码，上边代码里边的注释咱们可以认真查看一下，我们发现，如果我们通过上述代码的方式会有一些麻烦的操作，就是当用户更改需求的时候，我们要更改相应的代码，如果产品没上线，我们可以进行源代码更改，这样虽然会麻烦一点，但也不会造成太大损失，但是如果我们产品上线，那么造成的后果就比较严重了。

这个时候我们SpringIOC就派上用场了。

那么什么是IOC?

控制反转IOC是一种编程思想，DI（依赖注入）实现IOC的一种方法，可以说Ioc是思想 DI则是实现方式。

IOC可以说是:把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是 松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

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

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

@Override
    public void getUser() {
        System.out.println("默认获取数据");

    }
public interface UserDao {
    void getUser();
}
 private UserDao userDao;
    private UserDao userDao1;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    /*    private UserDao  userDao = new UserDaoImpl();
    private UserDao userDao1 = new UserMysqlDaoImpl();
    private UserDao userDao2 = new UserOracleDaoImpl();*/

    @Override
    public void getUser() {
        //当用户需求改变，我们将要每次都要改变代码，很麻烦，从而springIoc的简单就来了。
        //userDao1.getUser();//这是新添加的需求，我要改源代码
       // userDao2.getUser();  //这又是新添加的需求，我又要改。
        userDao.getUser();


    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

<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="mysqlImpl" class="com.xh.dao.impl.UserMysqlDaoImpl">

    bean>
    <bean id="oracleImpl" class="com.xh.dao.impl.UserOracleDaoImpl">
    bean>

    <bean id="UserServiceImpl" class="com.xh.service.impl.UserServiceImpl">
        
        <property name="userDao" ref="mysqlImpl" />
    bean>


    <bean id="oracle" class="com.xh.service.impl.UserServiceImpl">
        

        <property name="userDao" ref="oracleImpl" />
    bean>

beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

IOC创建对象的方式

• 使用无参构造创建对象，没有无参构造将会报错，默认

       
1
2
3
4
5

• 假设我们要使用有参构造。

     public class Main {
     
         private String user;
     
         @Override
         public String toString() {
             return "Main{" +
                     "user='" + user + '\'' +
                     '}';
         }
     
       /*  public Main() {
             System.out.println("无参构造");
         }*/
     
     
     
         public Main(String user) {
             this.user = user;
         }
     
         public void setUser(String user) {
             this.user = user;
         }
         public void  show(){
             System.out.println("user:"+user);
         }
     
     }
     
     -----------------------------------------------------
         public class MyTest {
         public static void main(String[] args) {
             //spring相当于婚介网站
             ApplicationContext context=  new ClassPathXmlApplicationContext("bean.xml");
     
             Main main = (Main) context.getBean("main");
             main.show();
           //  Main main1 = (Main) context.getBean("main1");
     
         }
     }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42

• 下标赋值

  
    
        
     
  1
  2
  3
  4

• 通过类型创建，不推荐使用

      
         
             
         
  1
  2
  3
  4
  5
  6

• 直接通过参数名

     
             
         
  1
  2
  3

重点使用name有参构造好用，无参构造直接第一个配置

总结：在配置文件加载的时候，容器中的管理对象就已经初始化了