Spring DI IOC

做为一名即将毕业的大四学生，虽然我已经在公司实习了4个多月，可是几乎接触不到ssh搭建框架的配置。好比hibernate的一对多，多对多关系啊，还有spring的一些配置。最近准备去参加下面试，在看java面试宝典的时候发现不少基础的配置都忘记了，因而拿出书来复习下。顺便共享下，但愿也能帮到正在找工做的同窗们哈。话很少说，进入主题。

面试和笔试常常会看到Spring IOC DI AOP的问题下面咱们就来解释和实战下这几个东东

IOC(Inversion of Control)控制反转

它把传统上由程序代码直接操控的对象的调用权交给容器，经过容器来实现对象组建的装配和管理。

IOC主要有两种实现的方式

（1）依赖查找（Dependency Lookup）:容器提供回调接口和上下文环境给组件。EJB和Apache Avalon都使用这种方法。

（不懂没用过，从书上抄过来，面试的时候能说下）

（2）依赖注入（Dependency Injection）:组件不作定位查询，只提供普通的Java方法让容器去决定依赖关系。

                                                          Inversion of Control

                                                                            |

                                            ______________________________________________

                                            |                                                                    |

                                    Dependency Lookup                                    Dependency Injection

                                                                                                                    |

                                                                                               ————————————————

                                                                                               |                            |                             |

                                                                                   interface Injection       Setter Injection       Constructor Injection

上面的结构图，图字应该打引号，不知道怎么画图的说。你们将就下吧。

下面上代码，设置注入

package com.ioc.test;
public interface Person { // 定义Person接口
 public void userAxe(); // Person接口里定义一个使用斧头的方法
}

package com.ioc.test;
public interface Axe { // 定义Axe接口
 public String chop(); // Axe接口里面有个砍的方法
}

package com.ioc.test;
public class Chinese implements Person { // Chinese实现Person接口
 private Axe axe; // 面向Axe接口编程，而不是具体的实现类
 public Chinese() { // 默认的构造方法
 }
 public void setAxe(Axe axe) { // 设置注入所须要的setXxx()方法
  this.axe = axe;
 }
 public void userAxe() { // 实现Person接口的userAxe方法
  System.out.println(axe.chop());
 }
}

package com.ioc.test;
public class StoneAxe implements Axe { // Axe的一个实现类StoneAxe
 public StoneAxe() { // 默认构造方法
 }
 public String chop() { // 实现Axe接口的chop()方法
  return "石斧砍柴好慢";
 }
}

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

"
http://www.springframework.org.dtd/spring-beans.dtd
">

<beans>

 <!-- 定义的Bean的id是chinese,class指定实现类 -->

 <bean id="chinese" class="com.ioc.test.Chinese">

 <!-- property元素用来指定须要容器注入的属性，axe属性须要容器注入，此处是设置注入，所以Chinese类必须拥有setAxe()方法 -->

  <property name="axe">

   <ref local="stoneAxe"/>

  </property>

 </bean>

 <bean id="stoneAxe" class="com.ioc.test.StoneAxe">

 </bean>

</beans>

package com.ioc.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BeanTest {
 public static void main(String[] args) {
  ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml"); // 这两个方法要传入的路径不一样 bean.xml在src目录下
  // ApplicationContext ctx = new FileSystemXmlApplicationContext("src/bean.xml");
  Person p = (Person) ctx.getBean("chinese"); // 经过id得到person
  p.userAxe();
 }
}

    上面就是设置注入的代码，运行结果控制台打印出  石斧砍柴好慢 。

在该程序中，咱们并无手动构造任何对象，StoneAxe 和 Chinese 实例都是由BeanFactory构造的，并且它们的依赖关系设置也是有DI容器完成的。咱们所作的事情，只是告诉了BeanFactory这些对象间的依赖关系。     

提示：主程序调用Person的userAxe()方法时，该方法须要使用Axe的实例，但程序中并无将特定的Person实例和Axe实例耦合在一块儿。或者说，程序里没有为Person实例传入Axe的实例，Axe的实例由Spring在运行期间动态注入。  

构造注入代码

package com.ioc.test;
public class Animal {
 private String name;
 private int age;
 public Animal(String name, int age) {
  this.name = name;
  this.age = age;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
}

 <bean id="animal" class="com.ioc.test.Animal">

  <constructor-arg><value>Dog</value></constructor-arg>

  <constructor-arg><value>3</value></constructor-arg>

 </bean>

这样就能getBean("animal")获得com.ioc.test.Animal类。 可是3 和 Dog的顺序不能错，不然报出异常。

咱们能够经过按类型匹配传入参数

 <bean id="animal" class="com.ioc.test.Animal">

  <constructor-arg type="java.lang.String"><value>Dog</value></constructor-arg>

  <constructor-arg type="int"><value>3</value></constructor-arg>

 </bean>

当不肯定参数类型而肯定参数个数时，能够用索引匹配传入参数

<bean id="animal" class="com.ioc.test.Animal">


  <constructor-arg index="0"><value>Dog</value></constructor-arg>


  <constructor-arg index="1"><value>3</value></constructor-arg>


 </bean>

联合使用

<bean id="animal" class="com.ioc.test.Animal">



  <constructor-arg type="java.lang.String" index="0"><value>Dog</value></constructor-arg>



  <constructor-arg type="int" index="1"><value>3</value></constructor-arg>



 </bean>

提示：设值注入与构造注入的区别在于：设值注入是在须要某一个Bean实例时，建立一个默认的Bean实例，而后调用对应的设值方法注入依赖关系；而构造注入则在建立Bean实例时，已经完成了依赖关系的注入。

关于他们的优缺点：看上面的例子想下把，或者百度一下啦。

属性注入

@Autowired,@Resource ，@EJB

前面两个的区别你们去百度吧，EJB没用过

package com.ioc.test;
public class Office {
 private String officeNo = "001";
 public String toString() {
  return "办公号： " + officeNo;
 }
 public String getOfficeNo() {
  return officeNo;
 }
 public void setOfficeNo(String officeNo) {
  this.officeNo = officeNo;
 }
}

package com.ioc.test;
import org.springframework.beans.factory.annotation.Autowired;
public class Boss {
 @Autowired
 private Office office;
 public String toString() {
  return "office--" + office;
 }
 public Office getOffice() {
  return office;
 }
 public void setOffice(Office office) {
  this.office = office;
 }
}

 <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"></bean>

 <bean id="boss" class="com.ioc.test.Boss">

 </bean>

 <bean id="office" class="com.ioc.test.Office">

  <property name="officeNo" value="002"> <!-- 从新给officeNo属性赋值 -->

  </property>

 </bean>

在测试类中

   Boss boss = (Boss) ctx.getBean("boss"); // 经过id得到person

  System.out.println(boss);

打印结果  ： office--办公号： 002

还有方法注入，可是书上说方法注入的使用过于复杂，并且不适用。咱们彻底能够经过改进应用的架构设计，避免使用它。

做为应届生只知道这么点啦。AOP的例子晚点写上来，但愿能帮助到你们。