IOC(控制反转:Inverse ofControl )
又称作 依赖注入,是一种重要的面向对象编程的法则来削减计算机程序的耦合问题,
也是轻量级的 Spring 框架的核心
一,IOC实例
这里通过实例来讲解IOC
先写一个JavaWork.java:
public class JavaWork {
//定义一个做测试的方法
public void doTest(){
ZhangSan zhangsan=new ZhangSan();
zhangsan.test();
}
}
写一个张三来做测试,ZhangSan.java:
public class ZhangSan {
public void test(){
System.out.println("张三-测试咯");
}
}
最后建一个Test.java来执行任务:
public class Test {
public static void main(String[]) args) {
JavaWork javawork=new JavaWork();
javawork.doTest();
}
}
到这里张三的测试可以完整执行了,但是这时张三和业务完全耦合在一起,比如加一个测试员李四。这时代码要改很多,这是就提出了IOC设计思路。 改进过程如下:
1,定义一个Tester.java接口,接口里的抽象方法有test()
2,用到多态,张三和李四都继承Tester这个接口
3,JavaWork类中添加tester测试员,并对tester取一个set方法
public class JavaWork {
private Tester tester;
public void setTester(Tester tester) {
this.tester = tester;
}
public void doTest(){
/*ZhangSan zhangsan=new ZhangSan();
zhangsan.test();*/
tester.test();
}
}
4,Test类中设置某个人做测试,这样控制权就交给了主管,也就是实现了控制反转。
控制反转(IOC)又称依赖注入,是一种重要的面向对象编程的法则来消减计算机程序的耦合性问题,也是轻量级的Spring框架的核心。
import com.java1234.service.JavaWork;
import com.java1234.service.Lisi;
public class Test {
//主管执行命令
public static void main(String[] args) {
JavaWork javaWork=new JavaWork();
// javaWork.setTester(new ZhangSan());
javaWork.setTester(new Lisi());
javaWork.doTest();
}
}
当然,在Spring中,都是用beans.xml配置文件来管理的。
<?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
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="zhangsan" class="com.java1234.service.ZhangSan"></bean>
<bean id="lisi" class="com.java1234.service.Lisi"></bean>
<bean id="javaWork" class="com.java1234.service.JavaWork">
<!-- name对应javawork中的tester -->
<property name="tester" ref="zhangsan"></property>
</bean>
</beans>
对应的Test2如下:
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.java1234.service.JavaWork;
public class Test2 {
public static void main(String[] args) {
//引入ApplicationContext容器来加载beans,并获取beans
ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
JavaWork javaWork=(JavaWork)ac.getBean("javaWork");
javaWork.doTest();
}
}
二,依赖注入
依赖注入常用的有属性注入,构造函数注入(通过类型,索引,两种联合使用),工厂方法注入(非静态工厂和静态工厂)三种方法。
这里就给例子了,大家可以自己研究下
People.java
package com.java1234.entity;
public class People {
private int id;
private String name;
private int age;
public People() {
super();
}
public People(int id, String name, int age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
@Override
public String toString() {
return "People [id=" + id + ", name=" + name + ", age=" + age + "]";
}
}
PeopleFactory.java
package com.java1234.factory;
import com.java1234.entity.People;
public class PeopleFactory {
public People createPeople(){
People p=new People();
p.setId(7);
p.setName("小七");
p.setAge(77);
return p;
}
}
PeopleFactory2.java
package com.java1234.factory;
import com.java1234.entity.People;
public class PeopleFactory2 {
public static People createPeople(){
People p=new People();
p.setId(8);
p.setName("王八");
p.setAge(88);
return p;
}
}
Test.java:
package com.java1234.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.java1234.entity.People;
public class Test {
public static void main(String[] args) {
ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
People people=(People)ac.getBean("people");
System.out.println(people);
People people2=(People)ac.getBean("people2");
System.out.println(people2);
People people3=(People)ac.getBean("people3");
System.out.println(people3);
People people4=(People)ac.getBean("people4");
System.out.println(people4);
People people5=(People)ac.getBean("people5");
System.out.println(people5);
//工厂方法注入
People people7=(People)ac.getBean("people7");
System.out.println(people7);
People people8=(People)ac.getBean("people8");
System.out.println(people8);
}
}
beans.xml:
<?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="people" class="com.java1234.entity.People"></bean>
<!-- 属性注入 -->
<bean id="people2" class="com.java1234.entity.People">
<property name="id" value="1"></property>
<property name="name" value="张三"></property>
<property name="age" value="11"></property>
</bean>
<!-- 通过类型注入依赖 -->
<bean id="people3" class="com.java1234.entity.People">
<constructor-arg type="int" value="2"></constructor-arg>
<constructor-arg type="String" value="李四"></constructor-arg>
<constructor-arg type="int" value="22"></constructor-arg>
</bean>
<!-- 通过索引注入依赖 -->
<bean id="people4" class="com.java1234.entity.People">
<constructor-arg index="0" value="3"></constructor-arg>
<constructor-arg index="1" value="王五"></constructor-arg>
<constructor-arg index="2" value="55"></constructor-arg>
</bean>
<!-- 联合注入依赖 -->
<bean id="people5" class="com.java1234.entity.People">
<constructor-arg index="0" type="int" value="4"></constructor-arg>
<constructor-arg index="1" type="String" value="招六"></constructor-arg>
<constructor-arg index="2" type="int" value="66"></constructor-arg>
</bean>
<!-- 非静态工厂 -->
<bean id="peopleFactory" class="com.java1234.factory.PeopleFactory"></bean>
<bean id="people7" factory-bean="peopleFactory" factory-method="createPeople"></bean>
<!-- 静态工厂 -->
<bean id="people8" class="com.java1234.factory.PeopleFactory2" factory-method="createPeople"></bean>
</beans>
最后的注入的结果:
三,bean之间的关系和作用范围
bean之间的关系有继承依赖和引用
1,继承(张三和李四都继承于abstractPeople,但是李四对age属性进行了重写)
<!-- 定义抽象类abstractPeople,并定义一些公共属性和方法 -->
<bean id="abstractPeople" class="com.java1234.entity.People" abstract="true">
<property name="className" value="高三5班"></property>
<property name="age" value="19"></property>
</bean>
<!-- 张三继承abstractPeople;并且依赖与authority,但是id和name不一样-->
<bean id="zhangsan" parent="abstractPeople">
<property name="id" value="1"></property>
<property name="name" value="张三"></property>
</bean>
<!-- 李四也继承abstractPeople,但对age属性进行了重写,李四引用了dog -->
<bean id="lisi" parent="abstractPeople">
<property name="id" value="2"></property>
<property name="name" value="李四"></property>
<property name="age" value="20"></property>
</bean>
2,依赖
张三依赖于authority,只用先获取权限后才能定义自身的属性,依赖用depends-on
<!-- 张三继承abstractPeople;并且依赖与authority,但是id和name不一样-->
<bean id="zhangsan" parent="abstractPeople" depends-on="autority">
<property name="id" value="1"></property>
<property name="name" value="张三"></property>
</bean>
<bean id="autority" class="com.java1234.service.Authority"></bean>
3,引用
这里定义dog,然后李四引用就可以了
<!-- 定义dog,并定义属性 -->
<bean id="dog" class="com.java1234.entity.Dog">
<property name="name" value="jack"></property>
</bean>
<bean id="lisi" parent="abstractPeople">
<property name="id" value="2"></property>
<property name="name" value="李四"></property>
<property name="age" value="20"></property>
<!-- 李四引用dog -->
<property name="dog" ref="dog"></property>
</bean>
以上是bean之间的三种关系,大家可以自己写实体和测试类来测试,方法比较多,最好用到JUnit插件。
bean的作用范围
1,singletonSpring ioc 容器中仅有一个 Bean 实例,Bean 以单例的方式存在;
2,prototype 每次从容器中调用 Bean 时,都返回一个新的实例;
4,session 同一个 HTTPSession 共享一个 Bean;
5,globalsession 同一个全局 Session 共享一个 Bean,一般用于 Portlet 应用环境;
6,application 同一个 Application 共享一个 Bean;
这里提到了六个作用范围,一般开发中只用到前面两个,大家可以自行验证。