Spring Ioc

Spring Ioc的好处：耦合性高，  

Spring的作用：管理各种业务Bean（dao,servcie,action）

 Spring的优点：

             （1）低侵入式设计

             （2）独立于各种应用服务器

             （3）依赖注入特性将组件关系透明化，降低耦合度

             （4）面向切面编程特性允许将通用任务进行集中处理

             （5）与第三方框架的良好整合

 context自动引用AOP和expression

 beans自动引用core

  控制反转:

                控制反转（Inversion of Control ,IoC）,也称依赖注入（Dependency Injection ,DI）,是面向对象程序中的一种设计理念，用来降低程序代码之间的耦合度。

　IOC: Inversion of Control(控制反转)是一种设计思想，就是容器控制应用程序所需要外部资源的创建和管理，然后将其反转给应用程序。对象及其依赖对象的创建及维护都不需要在应用程序中实现，将其交给IOC容器去管理。传统的开发中，我们自己在对象内部创建依赖对象并注入当前对象，完成依赖关系的维护；对于IOC而言，它强调是将主动变为被动，由IOC容器来负责依赖对象的创建和查找，由IOC容器来进行注入组合对象，我们只需要在相关的配置文件中维护对象之间的依赖关系即可。（IOC 思想控制反转）

　　DI: Dependency Injection，即“依赖注入”。其实IOC和DI本就是同一个概念的两种不同的表述，应用程序依赖容器提供的外部对象，容器将其依赖的外部资源在运行期注入到应用程序中；某个对象被调用时，其所依赖的对象由容器注入。（DI 实现的层面，依赖注入。）

Spring体系结构四个核心组件
  beans：Bean是包装我们应用程序自定义对象Object的，Object中存有数据
  core ：Context在发现、建立、维护Bean之间关系所需要的一些工具，如资源的加载，资源的抽象等。 
  context Context就是一个Bean关系的集合
  expression 
  

依赖注入的三种方式：（1）接口注入（2）Construct注入（3）Setter注入

控制反转（IoC）与依赖注入（DI）是同一个概念，引入IOC的目的：（1）脱开、降低类之间的耦合；（2）倡导面向接口编程、实施依赖倒换原则； （3）提高系统可插入、可测试、可修改等特性。

组件化的思想：分离关注点，使用接口，不再关注实现

依赖的注入;将组件的构建和使用分开

示例：

   首先创建一个包，并在该包中创建一个接口，写上实现的方法。

/**
 * Created by java on 2017/7/23.
 */
public interface Ink {
    public  String  color();
}

然后在创建两个实现类并将该接口的方法引用过去

public class GortyInk implements Ink {
    public String color() {
        return "黑白墨色";
    }
}
----------------------------------------------------
public class GreayInk implements Ink {
    public String color() {
        return "彩色墨盒";
    }
}
之后在创建一个包，和上面的步骤大致相同，在该包中创建接口并写上实现方法

/**
 * Created by java on 2017/7/23.
 */
public interface Paper {
    public String getpaper();
}
---------------------------------------------------

public class A4paper implements Paper {
    public String getpaper() {
        return "A4";
    }
}
------------------------------------
public class B5paper implements Paper {
    public String getpaper() {
        return "B5";
    }
}
------------------------------------------------
接下来在创建一个print包，将前两个包中的接口名进行属性封装，然后在再将前面的方法名进行连接。
public class printer {
    private Paper  paper;
    private Ink ink;
      public   void   print(){
          System.out.println("用"+ink.color()+"\t颜色的磨合在"+paper.getpaper()+"\t类型的纸上打印出来");
      }

    public Paper getPaper() {
        return paper;
    }

    public void setPaper(Paper paper) {
        this.paper = paper;
    }

    public Ink getInk() {
        return ink;
    }

    public void setInk(Ink ink) {
        this.ink = ink;
    }
}
当然也少不了applicationContext.xml
<!--这里存放的都不能是接口，必须是实现类-->
    <!--准备一个彩色墨盒-->
      <bean id="colorink" class="cn.happy.printer.link.GreayInk"></bean>
    <!--准备一个B5纸-->
    <bean id="b5paper" class="cn.happy.printer.paper.B5paper"></bean>
    <bean id="a4paper" class="cn.happy.printer.paper.A4paper"></bean>
    <!--准备一台打印机-->
    <bean id="pinter" class="cn.happy.printer.print.printer">
        <property name="ink" ref="colorink"></property>
        <property name="paper" ref="a4paper"></property>
    </bean>

接下来就该是测试了
@Test
public  void  test02(){
    ApplicationContext   cte=new ClassPathXmlApplicationContext("applicationContext.xml");
      //装配出一台打印机
 printer  pp= (printer) cte.getBean("pinter");
 pp.print();
}
   
   

    
    

   
   
之后打印出来的结果是：用彩色墨盒     颜色的磨合在A4	类型的纸上打印出来

---------------------------------------------------

事例：

public class HappyServices {
   private  String  info;
   public void  work(){
       System.out.println("work"+info);
   }
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
    }
}

 <bean id="happyService" class="cn.happy.services.HappyServices">
 <property  name="info" value="22222222"></property>
 </bean>

    
 @Test
 public void test01() {
 //获取Spring容器对象
 ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
 HappyServices service = (HappyServices) ctx.getBean("happyService");
 //service.setInfo("123456");
 service.work();
}
结果是：work22222222