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();

    }
}

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

        System.out.println("Hello world!");
    }
}

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

这个时候我们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();


    }

<?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="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">
        <!--
             ref： 引用spring容器中创建好的对象
             value： 具体的值，基本数据类型
        -->
        <property name="userDao" ref="mysqlImpl" />
    </bean>

<!--   我来捋一捋
    UserDao作为接口，有一个方法  UserDaoImpl 实现该方法
    然后UserService接口类方法同名 UserServiceImpl实现改方法
    id    = oracle 也就是context.getBean("oracle"); 标识符
     UserServiceImpl userService1 = (UserServiceImpl) context.getBean("oracle");
      <property name="userDao" ref="oracleImpl" />
      userDao 也就是 set方法的名字
      ref 指向  oracleImpl也就是下边这条语句
          <bean id="oracleImpl" class="com.xh.dao.impl.UserOracleDaoImpl">
    </bean>
-->
    <bean id="oracle" class="com.xh.service.impl.UserServiceImpl">
        <!--
             ref： 引用spring容器中创建好的对象
             value： 具体的值，基本数据类型
        -->

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

</beans>

IOC创建对象的方式

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

       <!--
         无参构造
         <bean id="main" class="com.xh.Main">
              <property name="user" value="作者"/>
          </bean>-->

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

     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");
     
         }
     }
  

• 下标赋值

  <bean id="main" class="com.xh.Main">
    <constructor-arg index="0" value="小黑">
        </constructor-arg>
     </bean>
  

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

      <!--第二种
             通过类型创建，不推荐使用
          -->
         <bean id="main" class="com.xh.Main">
             <constructor-arg type="java.lang.String" value="小黑"/>
         </bean>
  

• 直接通过参数名

     <bean id="main" class="com.xh.Main">
             <constructor-arg name="user" value="小黑"/>
         </bean>
  

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

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