一、IoC( Inversion of Control )控制反转
IoC 是什么?
- IoC 完成的事情原先由程序员主动通过 new 实例化对象事情,转交给 Spring 负责.
- 控制反转中控制指的是:控制类的对象.
- 控制反转中反转指的是转交给 Spring 负责.
- IoC 最大的作用: 解耦.程序员不需要管理对象.解除了对象管理和程序员之间的耦合
二、环境搭建测试
- 导入基础jar包，四个核心包一个日志包(commons-logging)
2. 在 src 下新建 applicationContext.xml
- Spring 容器 ApplicationContext,applicationContext.xml 配置的信息最终存储到了 AppliationContext 容器中
- Spring 配置文件是基于 schema， schema 文件扩展名.xsd，每次引入一个 xsd 文件是一个 namespace(xmlns)。配置文件中只需要引入基本 schema。配置文件中通过<bean/> 创建对象，默认配置文件被加载时创建对象。
-
<?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"> <!-- id 表示获取到对象标识 class 创建哪个类的对象 --> <bean id="peo" class="com.wzg.pojo.People"></bean> </beans>3.实体类People
-
package com.wzg.pojo; public class People { private int id; private String name; 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 People(int id, String name) { super(); System.out.println("ִ执行含参构造函数"); this.id = id; this.name = name; } public People() { super(); System.out.println("ִ执行默认构造函数"); } @Override public String toString() { return "People [id=" + id + ", name=" + name + "]"; } }3.测试类
-
getBean(“<bean>标签 id 值”,返回值类型); 如果没有第二个参数，默认是 Object
getBeanDefinitionNames()，Spring 容器中目前所有管理的所有对象
package com.wzg.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.wzg.pojo.People;
public class Test {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
People people = ac.getBean("peo2", People.class);
System.out.println(people);
String[] names = ac.getBeanDefinitionNames();
for(String n:names){
System.out.println(n.toString());
}
}
}
三、Spring创建对象的三种方式
- 通过构造方法创建
1.1 无参构造创建:默认情况.
1.2 有参构造创建:需要明确配置。需要在类中提供有参构造方法。
在 applicationContext.xml 中设置调用哪个构造方法创建对象，如果设定的条件匹配多个构造方法执行最后的构造方法
index : 参数的索引,从 0 开始
name: 参数名
type:类型(区分开关键字和封装类 int 和 Integer)
<bean id="peo" class="com.wzg.pojo.People">
<!-- ref 引用另一个 bean value 基本数据类型或String 等 -->
<constructor-arg index="0" name="id" type="int"value="123"></constructor-arg>
<constructor-arg index="1" name="name" type="java.lang.String" value=" 张三"></constructor-arg>
</bean>2.实例工厂
工厂设计模式：帮助创建类对象.一个工厂可以生产多个对象.
实例工厂：需要先创建工厂,才能生产对象
//实例工厂
public class PeopleFactory {
public People newInstance(){
return new People(1,"测试");
}
}<!-- 在 applicationContext.xml 中配置工厂对象和需要创建的对象 -->
<bean id="factory" class="com.wzg.pojo.PeopleFactory"></bean>
<bean id="peo1" factory-bean="factory" factory-method="newInstance"></bean>3.静态工厂----不需要创建工厂，快速创建对象。
//编写一个静态工厂(在方法上添加 static)
public class PeopleFactory {
public static People newInstance(){
return new People(1,"测试");
}
}在 applicationContext.xml 中
<bean id="peo2" class="com.wzg.pojo.PeopleFactory" factory-method="newInstance"></bean>四、给 Bean的属性赋值( 注入)
- 通过构造方法设置值
- 设置注入(通过 set 方法)
Bean类
package com.wzg.pojo;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class People {
private int id;
private String name;
private Set<String> sets;
private String [] strs;
private List<String> list;
private Map<String,String> map;
public void setStrs(String[] strs) {
this.strs = strs;
}
public String[] getStrs() {
return strs;
}
public void setList(List<String> list) {
this.list = list;
}
public List<String> getList() {
return list;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public Map<String, String> getMap() {
return map;
}
public void setSets(Set<String> sets) {
this.sets = sets;
}
public Set<String> getSets() {
return sets;
}
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 People(int id, String name) {
super();
this.id = id;
this.name = name;
}
public People() {
super();
}
@Override
public String toString() {
return "People [id=" + id + ", name=" + name + ", sets=" + sets
+ ", strs=" + Arrays.toString(strs) + ", list=" + list
+ ", map=" + map + "]";
}
}
- 如果属性是基本数据类型或 String 等简单类型，配置文件中为：（两种方法）
<bean id="peo" class="com.wzg.pojo.People">
<property name="id" value="1"></property>
<property name="name" value=" 张三 "></property>
</bean><bean id="peo" class="com.wzg.pojo.People">
<property name="id">
<value>1</value>
</property>
<property name="name">
<value>张三</value>
</property>
</bean>- 其他类型： Set<?> List<?> 数组 map
<property name="sets">
<set>
<value>1</value>
<value>2</value>
<value>3</value>
<value>4</value>
</set>
</property>
<property name="list">
<list>
<value>1</value>
<value>2</value>
<value>3</value>
</list>
</property>
<property name="strs" >
<array>
<value>1</value>
<value>2</value>
<value>3</value>
</array>
</property>
<property name="map">
<map>
<entry key="a" value="b" ></entry>
<entry key="c" value="d" ></entry>
</map>
</property>五、DI（依赖注入）
DI 和 IoC 是一样的。当一个类(A)中需要依赖另一个类()对象时，把 B 赋值给 A 的过程就叫做依赖注入。
新建一个bean类：
package com.wzg.pojo;
public class link {
private int id;
private String phone;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public link() {
super();
}
@Override
public String toString() {
return "link [id=" + id + ", phone=" + phone + "]";
}
}
配置文件
<bean id="peo" class="com.wzg.pojo.People">
<property name="desk" ref="link"></property>
</bean>
<bean id="link" class="com.wzg.pojo.link">
<property name="id" value="1"></property>
<property name="phone" value="123456789"></property>
</bean>