**
springIoC容器注入方式有set注入，构造器注入，注解注入。
**
一：set方式注入
1.先准备几个bean类，一个普通的学生类，以及一个A类，A类组合了学生类对象。
Student.java
复制代码
package com.cnblogs.bean;
public class Student {
// 学号
private String sNo;
private String name;
private int age;
// 性别
private String sex;
//年级
private String grade;
public Student() {
super();
}
public Student(String sNo, String name, int age, String sex, String grade) {
super();
this.sNo = sNo;
this.name = name;
this.age = age;
this.sex = sex;
this.grade = grade;
}
// set和get方法
// toString方法()
}
A.java
复制代码
package com.cnblogs.bean;
public class A {
private String desc;
private Student stu;
public A() {
super();
// TODO Auto-generated constructor stub
}
public A(String desc, Student stu) {
super();
this.desc = desc;
this.stu = stu;
}
// set和get方法
// toString方法()
}
set.xml中
<!-- 基于set方法的注入 -->
<bean name="stu" class="com.cnblogs.bean.Student">
<property name="sNo" value="1001"></property>
<property name="name" value="jack"></property>
<property name="age" value="12"></property>
<property name="sex" value="male"></property>
<property name="grade" value="三年级"></property>
</bean>
<!-- 注入引用类型 -->
<bean name="A" class="com.cnblogs.bean.A">
<property name="desc" value="A组合了Student类对象"></property>
<!-- ref属性表示调用这个setStudent方法的时候要用的参数是名字为stu的对象 -->
<property name="stu" ref="stu"></property>
</bean>
1.标签中，name和id起标识这个对象的作用，id会帮我们检查给对象起的名字是否规范(名字不能重复，不能有空格，不能已数字开头)，name不会检查这些东西。
class属性是一个类的全限定名，标识配置那个类。
2.springIoC默认是已单例模式管理对象，即通过相同的名字多次拿出来的对象一样，可以再标签中加属性 scope="prototype"代表非单例，
scope="Singleton"代表单例模式。
3.可以给某一个对象加别名，在后面加一条。可以通过stu拿对象，也可以通过s1 拿对象。
4.当类中的一个成员变量为另一个类的对象时，在子标签中可以通过ref引入，ref的值为一个标签的name或id值。
5.同一个类可以配置多个对象，但是标识多个对象的id或name值要不同。
注意：set方式底层会用到一个bean类的set方法，如果bean类的成员变量没有set方法却采用了set方式注入会报错。
/**
* 基于set方法的注入
*/
@Test
public void set(){
try{
String[] path = {"com/cnblogs/ioc/set/set.xml"};
ApplicationContext container = new ClassPathXmlApplicationContext(path);
Student stu = (Student)container.getBean("stu");
System.out.println(stu);
Object a = container.getBean("A");
System.out.println(a);
} catch(Exception e) {
e.printStackTrace();
}
}
结果：
Student [sNo=1001, name=jack, age=12, sex=male, grade=三年级]
A [desc=A组合了Student类对象, stu=Student [sNo=1001, name=jack, age=12, sex=male, grade=三年级]]
2.set方式注入之集合的注入
(1)准备一个B类，里面包括了各种集合：list，set，map，property
B.java
package com.cnblogs.bean;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class B {
// list集合
private List<String> list;
// set集合
private Set<String> set;
// map
private Map<String,String> map;
// prop
private Properties prop;
// set和get方法
}
collection.xml
!-- 集合的注入 -->
<bean name="coll" class="com.cnblogs.bean.B">
<!-- list集合 -->
<property name="list">
<list>
<value>jack</value>
<value>tom</value>
<value>tina</value>
</list>
</property>
<!-- set集合 -->
<property name="set">
<set>
<value>1001</value>
<value>1002</value>
<value>1003</value>
</set>
</property>
<!-- map集合 -->
<property name="map">
<map>
<entry key="name" value="zhangsan"></entry>
<entry key="age" value="12"></entry>
<entry key="gender" value="male"></entry>
</map>
</property>
<!-- properties集合注入 -->
<property name="prop">
<props>
<prop key="driver">com.mysql.jdbc.Driver</prop>
<prop key="username">study</prop>
</props>
</property>
</bean>
复制代码
测试方法：和上面那个一样，就是xml的文件路径改一下。
(2):如果一个list集合的泛型是一个类，也可以注入。
HobbyGroup.java
package com.cnblogs.bean;
import java.util.List;
// 兴趣小组
public class HobbyGroup {
private Long id;
private String name;
private List<Student> stu;
public HobbyGroup() {
super();
// TODO Auto-generated constructor stub
}
public HobbyGroup(Long id, String name, List<Student> stu) {
super();
this.id = id;
this.name = name;
this.stu = stu;
}
// set和get方法
// toString方法()
}
collection.xml
<bean name="hg" class="com.cnblogs.bean.HobbyGroup">
<property name="id" value="1"></property>
<property name="name" value="羽毛球兴趣小组"></property>
<property name="stu">
<list>
<bean name="stu1" class="com.cnblogs.bean.Student" >
<property name="sNo" value="1001"></property>
<property name="name" value="jack"></property>
<property name="age" value="12"></property>
<property name="sex" value="male"></property>
<property name="grade" value="三年级"></property>
</bean>
<bean name="stu2" class="com.cnblogs.bean.Student">
<property name="sNo" value="1002"></property>
<property name="name" value="tom"></property>
<property name="age" value="13"></property>
<property name="sex" value="male"></property>
<property name="grade" value="三年级"></property>
</bean>
<bean name="stu3" class="com.cnblogs.bean.Student">
<property name="sNo" value="1003"></property>
<property name="name" value="tina"></property>
<property name="age" value="11"></property>
<property name="sex" value="female"></property>
<property name="grade" value="三年级"></property>
</bean>
</list>
</property>
</bean>
3.set注入之自动注入
1.自动注入一般针对一个类中组合了另一类的对象。
2.自动注入有byName注入和byType注入
3.byName注入：spring容器会到当前的类中找property的名字,然后再根据这个名字去spring容器中找有没有和这个property名字相同的对象,有的话,
就把这个对象当做参数放到setXxxx这个方法里面注入进来。（找到多个不会报错）
4.byType注入：spring容器会根据set方法的参数类型去容器中找相匹配的对象，找到就注入，没找到就算了。如果找到多个会报错。
5.可以在标签中加 default-autowire=“byType”，则下面的标签会根据byType方式自动注入。
6.可以在标签中autowire=" “指定注入方式，该方式会屏蔽 default-autowire=” "。
示例：
同样用到com.cnblogs.bean.A类和com.cnblogs.bean.Student类。
autowired.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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd"
default-autowire="byName"
>
<bean name="stu" class="com.cnblogs.bean.Student">
<property name="sNo" value="1001"></property>
<property name="name" value="jack"></property>
<property name="age" value="12"></property>
<property name="sex" value="male"></property>
<property name="grade" value="三年级"></property>
</bean>
<!-- byName -->
<bean name="A1" class="com.cnblogs.bean.A">
<property name="desc" value="A组合了Student类对象,byName"></property>
</bean>
<!-- byType -->
<bean name="A2" class="com.cnblogs.bean.A" autowire="byType">
<property name="desc" value="A组合了Student类对象,byType"></property>
</bean>
</beans>
测试方法：
@Test
public void autowired(){
try{
String[] path = {"com/cnblogs/ioc/autowired/autowired.xml"};
ApplicationContext container = new ClassPathXmlApplicationContext(path);
// byName
A a1 = (A) container.getBean("A1");
System.out.println(a1);
// byType
A a2 = (A) container.getBean("A2");
System.out.println(a2);
} catch(Exception e) {
e.printStackTrace();
}
}
结果：
A [desc=A组合了Student类对象,byName, stu=Student [sNo=1001, name=jack, age=12, sex=male, grade=三年级]]
A [desc=A组合了Student类对象,byType, stu=Student [sNo=1001, name=jack, age=12, sex=male, grade=三年级]]
二：构造器注入
构造器有分两种注入方式，一个根据参数类型注入，一个根据下标注入。
1.根据参数类型注入
同样用到com.cnblogs.bean.Student类。
constructor.xml
<!-- 根据参数类型 -->
<bean name="stu1" class="com.cnblogs.bean.Student">
<constructor-arg type="String" value="1001"></constructor-arg>
<constructor-arg type="String" value="jack"></constructor-arg>
<constructor-arg type="int" value="12"></constructor-arg>
<constructor-arg type="String" value="male"></constructor-arg>
<constructor-arg type="String" value="三年级"></constructor-arg>
</bean>
2.根据参数下标注入
<!-- 根据下标 -->
<bean name="stu2" class="com.cnblogs.bean.Student">
<constructor-arg index="0" value="1002"></constructor-arg>
<constructor-arg index="1" value="tina"></constructor-arg>
<constructor-arg index="2" value="12"></constructor-arg>
<constructor-arg index="3" value="female"></constructor-arg>
<constructor-arg index="4" value="三年级"></constructor-arg>
</bean>
三、注解注入
首先需要在xml文件中指定使用注解注入的包，springIoC容器读取这个文件的时候就会知道。
anatation.xml:
<context:component-scan base-package="com.cnblogs.ioc.anatation" />
com.cnblogs.ioc.annotation.Office.java
package com.cnblogs.ioc.anatation;
import org.springframework.stereotype.Component;
@Component
public class Office {
private String num = "001";
public Office(){
}
public Office(String num) {
this.num = num;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
}
com.cnblogs.ioc.annotation.Car.java
package com.cnblogs.ioc.anatation;
import org.springframework.stereotype.Component;
@Component
public class Car {
private double price;
private String name;
public Car(){
}
public Car(double price, String name) {
this.price = price;
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
com.cnblogs.ioc.annotation.Boss.java
package com.cnblogs.ioc.anatation;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
@Component
@Scope("prototype")
public class Boss {
private String name;
@Autowired
private Car car;
@Resource
private Office office;
public Boss(){
}
public Boss(String name, Car car, Office office) {
this.name = name;
this.car = car;
this.office = office;
}
public Boss( Car car, Office office) {
this.car = car;
this.office = office;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
public Office getOffice() {
return office;
}
public void setOffice(Office office) {
this.office = office;
}
@PostConstruct
public void init(){
System.out.println("初始化..");
}
@PreDestroy
public void destory(){
System.out.println("销毁...");
}
}
测试方法：
/**
* 注解注入
*/
@Test
public void anatation(){
try{
String[] path = {"com/cnblogs/ioc/anatation/anatation.xml"};
ApplicationContext container = new ClassPathXmlApplicationContext(path);
Boss boss = (Boss) container.getBean("boss");
System.out.println(boss.getName());
System.out.println(boss.getCar());
System.out.println(boss.getOffice());
System.out.println(boss);
} catch(Exception e) {
e.printStackTrace();
}
}
null
com.cnblogs.ioc.anatation.Car@50de0926
com.cnblogs.ioc.anatation.Office@2473b9ce
com.cnblogs.ioc.anatation.Boss@60438a68
几个注解的作用：
复制代码
@Autowired
1) @Autowired使用后需要在xml文件加入以下配置才能生效: context:annotation-config/
2) @Autowired注解可以写在成员变量、setter方法、构造器函数上面
3) @Autowired默认按照byType匹配的方式进行注入,如果没有一个bean的类型是匹配的则会抛异常,如果有多个bean的类型都匹配成功了,
那么再按byName方式进行选择
4) @Autowired如果最终匹配不成功(注意一定是一个都没有找到的情况)则会抛出异常,但是如果设置为 @Autowired(required=false),
则最终匹配不成功没有不会抛出异常。
5) @Autowired可以结合@Qualifier("beanName")来使用,则可以达到byName的效果
@Resource
1) @Resource使用后需要在xml文件加入以下配置才能生效:context:annotation-config/
2) @Resource的作用和@Autowired差不多,只不过 @Resource是默认先用byName,如果找不到合适的就再用byType来注入
3) @Resource有俩个属性,name和type,使用name属性则表示要byName匹配,使用type属性则表示要byType匹配
@PostConstruct和@PreDestroy
1) 标注了@PostConstruct注解的方法将在类实例化后调用
2) 标注了@PreDestroy注解的方法将在类销毁之前调用
@Component
1) @Component注解可以直接定义bean,而无需在xml定义。但是若两种定义同时存在,xml中的定义会覆盖类中注解的Bean定义
2) @Component注解直接写在类上面即可
3) @Component有一个可选的参数,用于指定bean的名称
@Component("boss")
public class Boss{}
4) @Component如果不指定参数,则bean的名称为当前类的类名小写
//和上面例子的相关相同
@Component
public class Boss{}
5) @Component使用之后需要在xml文件配置一个标签
<context:component-scan/>
6) <context:component-scan base-package="com.briup.ioc.annotation" />
表示spring检查指定包下的java类,看它们是否使用了 @Component注解
7) @Component定义的bean默认情况下都是单例模式的,如果要让这个bean变为非单例,可以再结合这个@Scope注解来达到目标@Scope("prototype")
@Component是Spring中所有bean组件的通用形式, @Repository @Service @Controller 则是 @Component的细化,用来表示更具体的用例,
分别对应了持久化层、服务层和表现层。但是至少到现在为止这个四种注解的实质区别很小(甚至几乎没有),都是把当前类注册为spring容器中
的一个bean
注意:
1.component-scan标签默认情况下自动扫描指定路径下的包(含所有子包)
2.component-scan标签将带有@Component @Repository @Service @Controller注解的类自动注册到spring容器中
3.component-scan标签对标记了@Required @Autowired @PostConstruct @PreDestroy @Resource @WebServiceRef @EJB
@PersistenceContext @PersistenceUnit等注解的类进行对应的操作,使注解生效
4.component-scan标签包含了annotation-config标签的作用