淘先锋技术网

首页 1 2 3 4 5 6 7

**

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标签的作用

转自