SSM学习回顾 DAY1

SSM学习回顾 DAY1

IOC与DI

在说到IOC与DI时我们先要明确一个开发原则，就是OCP原则：对扩展开放，对修改关闭。也就是说我们可以在原有程序基础上去进行扩展开发而不能对源代码进行修改。

1.IOC(控制反转)：传统的生成一个实例对象一般采用的是直接进行对象创建（new Class）或者是通过工厂模式获得一个对象的实例，但这样做的话程序简单还能够接受，如果程序一旦变得复杂起来了或者实例对象需要量太多时系统的耦合度就变得很大，不利于后期的程序扩展与维护，如果业务需求发生改变就会要求对源码进行修改，这是不可取的。所以我们通过Spring将我们的实例对象交予Spring的Bean工厂去进行处理，当需求变动或者要增加对象时只需要修改相关的配置文件就可以了，而不需要修改源代码。

    //以前的方式
    public void demo1(){
        UserService user = new UserServiceImpl();
        user.sayOut();
    }

    //Bean工厂获取对象
    public void demo2(){
        ApplicationContext applicationContext =
                    new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService user = (UserService) applicationContext.getBean("userService");
        user.sayOut();
    }

配置文件ApplicationContext.xml

    <!-- 控制反转 将对象交予Spring创建 -->
    <bean  id="userService" class="com.imook.ioc.demo.UserServiceImpl">

2.DI(依赖注入)：依赖注入就是对对象所需要的属性和对象进行配置，也是在bean配置之中进行完成的。
举个例子说明，一个类Person，另一个类Car，如果Person的某个方法比如说drive，需要引用Car，则称Person类依赖于 Car类，延伸到对象，这种依赖关系依然成立，比如说Person类的对象boy依赖于Car类的对象toyota。
这其中的依赖关系，就导致了对象boy需要负责对象toyota的创建，甚至是整个生命周期的管理，而这样显然会带来耦合度高，不易维护等缺点，比如说要让这个男孩驾驶一辆Audi，则还需要修改类Person的代码。
依赖倒转原则，其核心思想就是要将这种具体类之间的依赖，尽量转换成抽象依赖，也就是说类Person应该依赖于抽象类ICar，而不是具体的类 Car，这里java就大力推荐了抽象和接口的使用，至于抽象和接口之间的区别。
这个依赖倒转原则在设计模式也体现得非常多，比如说工厂模式和构建模式，个人认为控制反转IoC，其实也可以认为是实现这个原则的一种设计模式。控制反转，其中的控制这个词一直不太理解是什么意思，不过控制反转的另外一种说法也就是依赖注入（dependence injection），个人觉得更易于理解。还是以上文的boy与toyota为例，其核心就是要将boy依赖的对象toyota注入到boy中去，而无需boy自己去引用toyota，这个注入的过程，通常是由一个控制程序来完成的，无需对象去关心。

Public Person{
private ICar car;
public Person(ICar onecar){
  car=onecar;
}
public void drive(){
  car.挂档;
  car.踩油门;
  car.打方向;
}
}

调用

Toyota toyota=new Toyota();
Person boy=new Person(toyota);
boy.drive();

这个时候，进行注入并且调用的过程，就很简单了，如下：

Public Person{
private ICar car;
public Person(){
}
public void drive(){
  car.挂档;
  car.踩油门;
  car.打方向;
}
public ICar getCar(){
  return this.car;
}
public void setCar(ICar onecar){
  car=onecar;
}
}

调用方式

Toyota toyota=new Toyota();
Person boy=new Person();
boy.setCar(toyota);
boy.drive();

xml文件中进行配置之后就可以直接取了

<beans>
   <bean id="oneCar" class="Toyota"> <!-- Toyota类是ICar的一个实现-->
   </bean>
   <bean id="onePerson" class="Person"> <!--本例以属性方式注入为例 -->
       <property name="car"> 
           <ref bean="oneCar"></ref>
       </property>
   </bean>
</beans>

Bean实例化的三种方式

1.直接通过构造器生成
2.通过工厂模式静态方法生成
3.通过实例工厂进行生成

对象

//对象
public class Bean {
    public Bean(){
        System.out.println("Bean已经被实例化");
    }
}

//静态工厂模式
public class Bean2Factory {
    public static Bean2 createBean2(){
        return new Bean2();
    }
}

//实例化工厂模式
    public Bean3 createBean3(){
        return new Bean3();
    }

    <!-- 第一种方式：直接通过构造器进行生成 -->
    <bean id ="bean1" class = "com.imook.ioc.demo.Bean1" />
    <!-- 第二种方式：通过工厂模式静态的方法进行生成 -->
    <bean id = "bean2" class="com.imook.ioc.demo.Bean2Factory" factory-method="createBean2" />
    <!-- 第三种方式：通过实例工厂的方法进行生成 -->
    <bean id = "bean3Factory" class="com.imook.ioc.demo.Bean3Factory" />
    <bean id = "bean3" factory-bean="bean3Factory" factory-method="createBean3"/>

获取对象方式

    public void Demo1(){
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean1 bean1 = (Bean1) applicationContext.getBean("bean1");
        Bean2 bena2 = (Bean2) applicationContext.getBean("bean2");
        Bean3 bean3 = (Bean3) applicationContext.getBean("bean3");
    }

***对三种方式的基本理解：
第一种：通过bean的缺省构造函数创建，当各个bean的业务逻辑相互比较独立的时候或者和外界关联较少的时候可以使用。
第二种：利用静态factory方法创建，可以统一管理各个bean的创建，如各个bean在创建之前需要相同的初始化处理，则可用这个factory方法险进行统一的处理等等。
第三种：利用实例化factory方法创建，即将factory方法也作为了业务bean来控制。
第一种可用于集成其他框架的bean创建管理方法，第二种斜体样式能够使bean和factory的角色互换。 ***

引用文章链接，如有侵权请立即联系我，会马上删除
链接: https://www.cnblogs.com/alltime/p/6729295.html.