SpringIOC
作用: 实现了层与层之间对象的逻辑性的解耦.IOC将耦合性非常高的对象进行解耦.
SpringIOC创建对象的三种方式
1.通过构造器方式
①无参数构造器(创建一个没有初始化数据的对象)
②有参 数构造器(创建一个带有初始化数据的对象)
Applicationcontext.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">
<!--创建student的bean对象-->
<!--构造器方式-->
<!--
无参构造器
特点:Spring容器默认使用无参构造方式创建对象
使用:在配置文件中直接使用bean标签配置即可,无需过多声明
-->
<bean id="stu" class="com.bjsxt.pojo.Student"></bean>
<!--有参数的构造器
特点:Spring容器对根据配置调用的有参构造器创建一个带有初始化数据的对象
使用:constructor-arg:使用bean的字标签来声明调用的构造器的形参的个数
一个字标签表示一个参数
属性:index:参数的下标
type:参数的类型,全限定路径
name:参数的形参名
value:参数要给的值
-->
<bean id="stu2" class="com.bjsxt.pojo.Student">
<constructor-arg index="0" type="java.lang.Integer" name="sid" value="1"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" name="sname" value="张三"></constructor-arg>
</bean>
</beans>
TestObject.java
package com.java.controller;
import com.java.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class testStu {
public static void main(String[] args) {
//创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationcontext.xml");
//获取容器中的对象
//无参构造器方式
Student student = (Student) ac.getBean("stu");
System.out.println("无参构造:"+student);
//有参构造器
Student student1= (Student) ac.getBean("stu2");
System.out.println("有参构造:"+student1);
}
}
2.通过属性注入(get/set)
ApplicationContext.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">
<!--创建student的bean对象-->
<!--
属性注入方式
特点:相当于创建一个空对象然后使用set方法赋值
使用:
property:在bean标签下使用子标签property,表示调用set方法给某个属性赋值
属性:name:要赋值的属性名
value:值
-->
<bean id="stu3" class="com.bjsxt.pojo.Student">
<property name="sid" value="2"></property>
<property name="sname" value="李四"></property>
</bean>
</beans>
TestObject.java
package com.java.controller;
import com.java.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class testStu {
public static void main(String[] args) {
//创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationcontext.xml");
//获取容器中的对象
//属性注入方式
Student student = (Student) ac.getBean("stu3");
System.out.println("属性注入方式"+student);
}
}
3.通过工厂模式
①动态工厂模式
②静态工厂模式
applicationcontext.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">
<!--创建student的bean对象-->
<!--工厂设计模式-->
<!--动态工厂-->
<bean id="factory" class="com.bjsxt.pojo.StudentFactory"></bean>
<!--生产Student对象-->
<bean id="stu4" factory-bean="factory" factory-method="newIntance"></bean>
<!--静态工厂-->
<!--可以理解为静态方法直接用类名调用-->
<bean id="stu5" class="com.bjsxt.pojo.StudentFactory2" factory-method="newIntance"></bean>
</beans>
TestObject.java
package com.java.controller;
import com.java.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class testStu {
public static void main(String[] args) {
//创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationcontext.xml");
//获取容器中的对象
//工厂设计模式
//动态工厂
Student student = (Student) ac.getBean("stu4");
System.out.println("动态工厂:"+student);
//静态工厂
Student student1 = (Student) ac.getBean("stu5");
System.out.println("静态工厂:"+student1);
}
}
IOC的依赖注入DI
依赖责任链:
对象之间项目依赖形成的一条链式依赖关系.
D d=new D();
C c=new C(d)
B b=new B©;
A a=new A(b);
A<—B<----C<----D
解决:
让Spring容器根据对象之间的依赖关系,将依赖责任连上的所有的对象全部配置为Bean对象.并且根据依赖关系完成对象之间的组装.将组装好的对象返回给用户使用.
概念:
DI:依赖注入,就是Spring容器根据对象之间的依赖关系完成对象的创建以及组装的过程.
applicationcontext.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">
<!--
DI依赖的使用流程
①将依赖责任链上的所有的对象都配置为bean
②根据依赖关系完成对象之间的组装配置
通过构造器方式:
i.必须在类中声明对应的构造器
ii.在bean标签下使用constructor-arg子标签完成以来注入
使用constructor-arg的属性ref,ref的值为要注入的bean的ID
通过set方法方式
i.必须在类中声明引用属性对应的set方法
ii.在bean标签下使用property子标签完成以来注入
在property子标签中使用ref属性,属性值为要被注入的bean的ID
-->
<!--配置学生bean对象-->
<bean id="stu" class="com.bjsxt.pojo.Student">
<!--构造器方式-->
<constructor-arg index="0" name="teacher" type="com.bjsxt.pojo.Teacher" ref="tea" ></constructor-arg>
<!--set方式-->
<property name="teacher" ref="tea"></property>
<property name="sname" value="张三"></property>
<property name="sid" value="1"></property>
</bean>
<bean id="tea" class="com.bjsxt.pojo.Teacher">
<property name="tid" value="2"></property>
<property name="tname" value="刘老师"></property>
</bean>
</beans>
TestIocDI.java
package com.java.contorller;
import com.java.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestIocDI {
public static void main(String[] args) {
//获取spring对象
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationcontext.xml");
Student stu = (Student) ac.getBean("stu");
System.out.println(stu);
stu.testStu();
}
}