IOC:Inversion of Control 控制反转。(底层原理:反射)
所谓的控制反转,就是应用本身不负责依赖对象的创建及维护,依赖对象的创建及维护是由外部容器负责,这样控制权就用应用内部转移到了外部容器,这样做的目的是为了获得更好的扩展性和良好的可维护性。
DI:Dependency Injection 依赖注入 。(底层原理:内省)
所谓的依赖注入,就是在运行期,由外部容器动态地将依赖对象注入到组建中
以下是在bean.xml容器中,依赖注入的代码↓
<bean id="boy" class="com.dueeast.a_ioc.Boy" scope="prototype">
</bean>
<bean id="girl" class="com.dueeast.a_ioc.Girl">
<property name="boy">
<ref bean="boy"/>
</property>
</bean>
前提是在com.dueeast.a_ioc.Girl 中,有对com.dueeast.a_ioc.Boy这个类的set方法↓
public class Girl {
Boy boy;
public void setBoy(Boy boy) {
this.boy = boy;
}
public void kiss(){
boy.display();
System.out.println("kiss");
}
}
就可以这样使用了↓
public class App {
public static void main(String[] args) {
BeanFactory ac = new XmlBeanFactory(new FileSystemResource("D:\\10.7MyEclipseSpace\\BlogTest\\src\\beans.xml"));
Girl girl = (Girl) ac.getBean("girl");
girl.kiss();
}
}
以上是DI依赖注入的简单演示
-----------------------------------------------------------------------------------------------------------------------
在楼上代码中,下面这一句实例化了Spring的容器。
BeanFactory ac = new XmlBeanFactory(new FileSystemResource("D:\\10.7MyEclipseSpace\\BlogTest\\src\\beans.xml"));
实例化Spring容器一共有四种方式↓
(1)加载一个spring容器
ApplicationContext ac = new ClassPathXmlApplicationContext("容器全路径");
(2)加载多个spring容器
ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"容器全路径"});
(3)从外部文件系统加载容器
ApplicationContext ac = new FileSystemXmlApplicationContext("容器在本地磁盘的绝对路径");
(4)使用BeanFactory的用法
BeanFactory ac = new XmlBeanFactory(new FileSystemResource("容器在本地磁盘的绝对路径"));
项目中最常用是使用ApplicationContext和ClassPathXmlApplicationContext,一般不使用BeanFactory
ApplicationContext是对BeanFactory扩展,提供了更多功能
1、国际化处理
2、事件传递
3、Bean自动装配
4、各种不同应用层的Context实现
---------------------------------------------------------------------------------------------
创建对象的作用于模式:
单例模式singleton(默认值)
l 如果是单例的话,将spring中bean元素节点的scope设置成singleton,加载spring容器的时候,就会加载对应的构造方法,此时构造方法只执行1次,表示单例
l 在spring容器中配置:lazy-init="false"(默认值);表示只要加载spring容器,此时就会立即加载构造对象的方法。
l 在spring容器中配置:lazy-init="true";表示只有调用对应对象的时候,才会初始化对应的构造方法。
l 如果在spring容器中的beans节点配置default-lazy-init="false"(默认值),对全局所有的bean都有效
多例模式prototype(整合由于struts2是多例,在spring容器创建Action对象的时候,将其设置多例)
l 如果是单例的话,将spring中bean元素节点的scope设置成prototype,加载spring容器的时候,不会加载执行对应对象的构造方法,此时只有调用对应对象的时候,才会执行对应的构造方法,执行多次,表示多例
l 多例中不会存在lazy-init属性,因为没有意义
* request每次HTTP请求都会创建一个新的Bean,该作用域仅适用于WebApplicationContext环境(一个系统request.setAttribute () )
* session同一个HTTP Session 共享一个Bean,不同Session使用不同Bean,仅适用于WebApplicationContext 环境(一个系统session.setAttribute())
* global session一般用于Porlet应用环境,该作用域仅适用于WebApplicationContext 环境(多个系统共享一个session)
------------------------------------------------------------------------------------------
依赖注入详解
1、在类中的属性需要设置set方法(用以下javabean演示,set方法因过多而省略)
private Integer id;
private String name;
private Person person;
private List<Object> list;
private Object[] arrays;
private Set<Object> set;
private Map<String, Object> map;
private Properties properties;
//spring整合hibernate的时候,都可以在容器中使用Properties集合完成对hibernate的操作
private List<Object> listnull = new ArrayList<Object>();
2、在spring的容器中定义:
<bean id="person" class="h_setXml.Person" p:pid="30" p:pname="酸菜"></bean>
<bean id="userService" class="h_setXml.UserServiceImpl">
<!-- 1:配置bean的简单属性,基本数据类型和String。 -->
<property name="id" value="10"></property>
<property name="name" value="翠花"></property>
<!--
2:注入对象,引用其它bean(外部bean)
结论:项目开发时都会使用外部注入,因为由外部创建对象,容器中的其他对象都可以调用
如果是内部调用,只能在当前bean中才能使用
-->
<property name="person" ref="person"></property>
<!-- 2:注入对象,内部bean
<property name="person">
<bean class="cn.itcast.h_setXml.Person"></bean>
</property>-->
<!-- 3:测试p空间,为对象中的属性赋值 -->
<!-- 4:注入集合,A、装配List和数组(通用): -->
<property name="list">
<list>
<value>list001</value>
<value>list002</value>
<ref bean="person"/>
</list>
</property>
<property name="arrays">
<array>
<value>array001</value>
<value>array002</value>
<ref bean="person"/>
</array>
</property>
<!-- 4:注入集合, B、 装配set: -->
<property name="set">
<set>
<value>set001</value>
<value>set002</value>
<ref bean="person"/>
</set>
</property>
<!-- 4:注入集合,装配集合 C、 装配map: -->
<property name="map">
<map>
<entry key="key001">
<value>mapValue001</value>
</entry>
<entry key="key002">
<value>mapValue002</value>
</entry>
<entry key="key003">
<ref bean="person"/>
</entry>
</map>
</property>
<!-- 5:注入集合,D、装配Properties:值不可以是对象 -->
<property name="properties">
<props>
<prop key="prop001">propValue001</prop>
<prop key="prop002">propValue002</prop>
</props>
</property>
<!-- 6:设置空值 -->
<property name="listnull">
<null/>
</property>
</bean>
3、注入构造器并在类中使用构造器
在spring容器中定义:
<bean id="userService" class="i_constructorXml.UserServiceImpl">
<!--
constructor-arg:构造器函数注入的方式
* index:构造器方法中参数的位置,0表示第1个位置
* type:表示构造器方法中参数的类型,类型可以写成java的类型
* 要求:
1:按照位置注入:如果使用参数的位置注入,需要注入的值要符合构造方法参数的类型
2:按照参数类型注入:根据构造函数参数的位置不同,可能会注入到不同的构造方法
<!-- 结论:当使用构造器函数的时候,可以使用即按照类型指定,同时也按照参数的位置指定 -->
<constructor-arg type="java.lang.String" index="1">
<value>1</value>
</constructor-arg>
<constructor-arg type="java.lang.String" index="0">
<value>翠花</value>
</constructor-arg>
</bean>
在类中使用构造函数,注入参数的值
public UserServiceImpl(String name,Integer id){
System.out.println("先String再Integer");
this.id = id;
this.name = name;
}
public UserServiceImpl(Integer id,String name){
System.out.println("先Integer再String");
this.id = id;
this.name = name;
}
public UserServiceImpl(String name,String education){
System.out.println("先String再String");
this.name = name;
this.education = education;
}