Spring-IOC配置(学习笔记)

Instantiating beans

instantiation with a constructor

<bean id = "car" class = "com.jiakai.spring.Car"/>

public class Car {

public Car(){
System.out.println("make car with default");
}
public void run(){
System.out.println("the car run on the road");
}
}

此时创建bean的时候,会调用class属性中类的,无参数的构造方法.

2. Instantiation with a static factory method

<bean id = "car" class = "com.jiakai.spring.BMW" factory-method = "createCar"/>

public class Car {
private String name;

public Car(){
System.out.println("make car with default");
}
public void run(){
System.out.println(name+" car run on the road");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

public class BMW {
public static Car createCar(){
Car car = new Car();
car.setName("bmw");
System.out.println("make car with BMW static factory method");
return car;
}
}

此时,会调用class属性中的类的,静态的,factory-method方法创建对象.

如果factory-method方法有参数,可以利用constructor-arg来设定.

<bean id = "car" class = "com.jiakai.spring.BMW" factory-method = "createCar">
<constructor-arg name="msg" value="have args"/>
<constructor-arg name="level" value="55"/>
</bean>

package com.jiakai.spring;

public class BMW {
public static Car createCar(String msg,int level){
System.out.println(msg);
System.out.println(level);
Car car = new Car();
car.setName("bmw");
System.out.println("make car with BMW static factory method");
return car;
}
}

3.Instantiation using an instance factory method

<bean id = "bmw" class = "com.jiakai.spring.BMW"/>

<bean id = "car" factory-bean = "bmw" factory-method = "createCar">
<constructor-arg name="msg" value="have args"/>
<constructor-arg name="level" value="55"/>
</bean>

public class BMW {
public Car createCar(String msg,int level){
System.out.println(msg);
System.out.println(level);
Car car = new Car();
car.setName("bmw");
System.out.println("make car with BMW object factory method");
return car;
}
}

此时,会调用factory-bean对象的factory-method方法创建bean.

Dependency injection

1.Constructor-based dependency injection

<bean id = "people" class = "com.jiakai.spring.People">
<constructor-arg name="name" value="jiakai"/>
<constructor-arg name="age" value="22"/>
</bean>

package com.jiakai.spring;

public class People {
private String name;
private int age;

public People(String name,int age) {
System.out.println("make people");
this.name = name;
this.age = age;
}

@Override
public String toString() {
return name+" "+age;
}
}

利用构造函数注入

2.Setter-based dependency injection

<bean id = "people" class = "com.jiakai.spring.People">
<property name="name" value="gaoshang" />
<property name="age" value="25" />
</bean>

package com.jiakai.spring;

public class People {
private String name;
private int age;

public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return name+" "+age;
}
}

利用setter方法注入

3.Collections

<bean id="moreComplexObject" class="example.ComplexObject">
<!-- results in a setAdminEmails(java.util.Properties) call -->
<property name="adminEmails">
<props>
<prop key="administrator">administrator@example.org</prop>
<prop key="support">support@example.org</prop>
<prop key="development">development@example.org</prop>
</props>
</property>
<!-- results in a setSomeList(java.util.List) call -->
<property name="someList">
<list>
<value>a list element followed by a reference</value>
<ref bean="myDataSource" />
</list>
</property>
<!-- results in a setSomeMap(java.util.Map) call -->
<property name="someMap">
<map>
<entry key="an entry" value="just some string"/>
<entry key ="a ref" value-ref="myDataSource"/>
</map>
</property>
<!-- results in a setSomeSet(java.util.Set) call -->
<property name="someSet">
<set>
<value>just some string</value>
<ref bean="myDataSource" />
</set>
</property>
</bean>

4.Null and empty string values

<bean class="ExampleBean">
<property name="email" value=""/>
</bean>
<bean class="ExampleBean">
<property name="email"><null/></property>
</bean>

5.Lazy-initialized beans

<bean id = "car" class = "com.jiakai.spring.Car" lazy-init="true"/>

<beans default-lazy-init="true">
<!-- no beans will be pre-instantiated... -->
</beans>

懒初始化

6.Autowiring collaborators

no: 不进行自动装配
byType:根据类型进行自动装配,如果匹配类型时,有多个匹配结果,则抛异常.
byName:根据名字进行自动装配,如果找不到名字相同的bean时,则抛异常.

Bean scopes

1.singleton:只有一个

2.prototype:每次都新建一个

Customizing the nature of a bean

<bean id="exampleInitBean" class="examples.ExampleBean" init-method="init"/>

<bean id="exampleInitBean" class="examples.ExampleBean" destroy-method="cleanup"/>

Annotation-based container configuration

<context:annotation-config/>

对Spring进行Annotation配置的时候,首先要在beans.xml里面加上上面那句话。
相当于,加载了一些类扫描器,这样Spring在初始化容器的时候,一边初始化bean一边扫描Annotation,辅助初始化bean.

1.@Required

标识该属性为对象必需的属性,如果构造该bean的时候,没有注入该属性,则抛异常。
相当于检查某属性,是否被注入过。

2.@Autowired

为对象注入属性，默认按类型装配,也可以与@Qualifier配合使用.
另外@Autowired中有一个required属性,默认为true.

<bean id = "people" class = "com.jiakai.spring.People"/>

<bean id = "ttcar" class = "com.jiakai.spring.Car">
<qualifier value="cc"/>
</bean>
<bean id = "ttcar1" class = "com.jiakai.spring.Car">

</bean>

package com.jiakai.spring;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Required;

public class People {
private String name;
private int age;
private Car car;

public void setName(String name) {
this.name = name;
}

public void setAge(int age) {
this.age = age;
}
public void drive(){
this.car.run();
}
@Autowired
@Qualifier(value="cc")
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return name+" "+age;
}
}

3.@Resource
为对象注入属性,默认按照名称装配,当找不到与名称匹配的bean才会按照类型装配.
可以通过name属性指定,如果没有指定name属性,则按照属性名匹配.

<bean id = "people" class = "com.jiakai.spring.People"/>

<bean id = "car" class = "com.jiakai.spring.Car"/>

package com.jiakai.spring;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Required;

public class People {
private String name;
private int age;
private Car car;

public void setName(String name) {
this.name = name;
}

public void setAge(int age) {
this.age = age;
}
public void drive(){
this.car.run();
}
@Resource
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return name+" "+age;
}
}

4.@PostConstruct & @PreDestroy
@PostConstruct:在对象创建之后,调用该方法.

@PreDestroy:在对象销毁之前,调用该方法.

<bean id = "car" class = "com.jiakai.spring.Car"/>

package com.jiakai.spring;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class Car {
private String name;

public Car(){
System.out.println("make car with default");
}
public void run(){
System.out.println(name+" car run on the road");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@PostConstruct
public void init(){
System.out.println("init");
}
@PreDestroy
public void destroy(){
System.out.println("destroy");
}
}

5.@Component
相当于Spring会生成该类的一个对象,作为自己的组件bean进行管理.
该注解需要与下面的配置配合使用.

<context:component-scan base-package="com.jiakai"/>

设置需要扫描Component的包.