Spring 4 学习笔记-依赖注入（一）

一、配置文件的合并

可以使用<import/>标签导入其它配置文件

<beans>
 <importresource="services.xml"/>
 <importresource="resources/messageSource.xml"/>
 <importresource="/resources/themeSource.xml"/>
 <bean id="bean1"class="..."/>
 <bean id="bean2"class="..."/>
</beans>

二、配置文件Bean节点属性的

属性	说明
class	要实例化的javabean
name	bean 的名称
scope	bean 的范围
constructor arguments	bean 的构造方法参数（依赖注入）
properies	bean 的属性（依赖注入）
autowiring mode	装配者模式
lazy-initialization mode	延迟初始化bean
initialization method	初始化bean 的时候要调用的方法
destruction method	销毁bean 的时候要调用的方法

三、java bean的基本配置与使用

1．命名规范

官方建议bean的命名采用驼峰命名法：accountManager、accountService、userDao

2．别名

在一个系统中，同一个bean对象在不同的子系统中的Name会不尽相同，我们可以使用<alias/>标签来定义bean的别名。

fromName：是指要使用别名的bean的Name值

toName：别名的名称

3．使用静态工厂初始化bean

spring 默认是通过调用无参的构造方法来创建对象的，spring还允许通过静态工厂来创建对象。

4．内部静态类

spring是可以创建一个类的内部静态类的对象的，使用$隔开外部类与内部静态类。

四、依赖注入之基本注入

1．构造方法参数注入

使用构造方法进行依赖注入要使用Bean的字标签<constructor-arg/>

（1）．使用参数名进行注入

<span style="white-space:pre">		</span><constructor-arg name="参数名称"value="参数值"/>
		<constructor-arg name="参数名称"ref="引用其它bean的name"/>

（2）．使用参数顺序进行注入

		<constructor-arg index="参数序号（从0开始）"value="参数值"/>
		<constructor-arg index="参数序号（从0开始）"ref="引用其它bean的name"/>

（3）．使用参数类型进行注入

	<span style="white-space:pre">	</span><constructor-arg type="参数的类型 "value="值"/>
		<constructor-arg type="参数的类型 "ref="引用其它bean的name"/>

注：如果多个参数类型一样，以标签的顺序依次注入

2． Seter方法注入

bean的依赖注入还可以通过Seter方法进行注入。

	<propertyname="user" ref="user"/>
	<propertyname="i" value="100"/>
  	<propertyname="str" value="str"/>

五、示例

User.java

packagebeans;
 
/**
 * Created by xuejike on 2014/10/16.
 */
publicclass User {
    private int uid=10;
 
    public int getUid() {
        return uid;
    }
 
    public void setUid(int uid) {
        this.uid = uid;
    }
    public static class  Name{
        private StringfirstName="xue";
        private StringsecondName="jike";
 
        public String getFirstName() {
            return firstName;
        }
 
        public void setFirstName(StringfirstName) {
            this.firstName = firstName;
        }
 
        public String getSecondName() {
            return secondName;
        }
 
        public void setSecondName(StringsecondName) {
            this.secondName = secondName;
        }
    }
}

SeterBean.java

 
packagebeans;
 
/**
 * Created by xuejike on 2014/10/19.
 */
publicclass SeterBean {
    private User user;
    private String str;
    private int i;
 
    public User getUser() {
        return user;
    }
 
    public void setUser(User user) {
        this.user = user;
    }
 
    public String getStr() {
        return str;
    }
 
    public void setStr(String str) {
        this.str = str;
    }
 
    public int getI() {
        return i;
    }
 
    public void setI(int i) {
        this.i = i;
    }
 
    @Override
    public String toString() {
        return"user="+user.toString()+" str="+str+" i="+i;
    }
}

ConstructorTypeBean.java

packagebeans;
 
/**
 * Created by xuejike on 2014/10/19.
 */
publicclass ConstructorTypeBean {
    private String s1;
    private String s2;
 
    public ConstructorTypeBean(String s1,String s2) {
        this.s1 = s1;
        this.s2 = s2;
    }
 
    @Override
    public String toString() {
        return "s1=" + s1 + "s2=" + s2;
    }
}
 
ConstructorBean.java
packagebeans;
 
/**
 * Created by xuejike on 2014/10/17.
 */
publicclass ConstructorBean {
    private int i;
    private String str;
    private User user;
    private double d;
 
    public ConstructorBean(int i, Stringstr,double d, User user) {
        this.i = i;
        this.str = str;
        this.user = user;
        this.d=d;
    }
 
 
 
    @Override
    public String toString() {
        return "i="+i+" str="+str+"d="+d+" user="+user.toString();
    }
}

beans.xml

<?xmlversion="1.0" encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <!--bean的别名的定义-->
    <alias name="user"alias="myUser"/>
 
    <bean name="user"class="beans.User"></bean>
 
    <!--使用静态工厂创建bean对象-->
    <bean name="client"class="beans.ClientService"factory-method="createInstance"/>
 
    <!--内部类的定义-->
    <bean name="userName"class="beans.User$Name"/>
 
    <!--使用带参数的构造方法创建bean-->
    <bean name="constructorBean"class="beans.ConstructorBean">
        <!--设置构造方法参数的值-->
        <!--指定参数的名称-->
        <constructor-arg name="i"value="100"/>
        <!--指定参数的序号-->
        <constructor-arg index="1"value="this is string"/>
        <!--指定参数的类型-->
        <constructor-argtype="double" value="1.11"/>
 
        <!--构造方法中参数的值 引用其它bean-->
        <constructor-argname="user" ref="user" />
    </bean>
 
    <bean name="ctBean"class="beans.ConstructorTypeBean">
        <constructor-argtype="java.lang.String" value="s13"/>
        <constructor-argtype="java.lang.String" value="s2"/>
    </bean>
 
    <!--通过Seter方法进行依赖注入-->
    <bean name="seterBean"class="beans.SeterBean">
        <property name="user"ref="user"/>
        <property name="i"value="100"/>
        <property name="str"value="str"/>
    </bean>
 
</beans>

测试：

ApplicationContextcontext=new ClassPathXmlApplicationContext("beans.xml");
 
//        Bean的别名
        User myUser =context.getBean("myUser", User.class);
        System.out.println("Bean的别名");
        System.out.println(myUser.getUid());
//        构造方法依赖注入（参数类型、索引号、参数名）
        ConstructorBean constructorBean =context.getBean("constructorBean", ConstructorBean.class);
        System.out.println("构造方法依赖注入（参数类型、索引号、参数名）");
        System.out.println(constructorBean);
 
//构造方法依赖注入（有多个相同的参数类型使用参数类型进行依赖注入）
        ConstructorTypeBean ctBean =context.getBean("ctBean", ConstructorTypeBean.class);
        System.out.println("构造方法依赖注入（有多个相同的参数类型使用参数类型进行依赖注入）");
        System.out.println(ctBean);
 
//        使用Seter方法进行依赖注入
        SeterBean seterBean =context.getBean("seterBean", SeterBean.class);
        System.out.println("使用Seter方法进行依赖注入");
       System.out.println(seterBean);

Spring 4 学习笔记-依赖注入（一）

猜你喜欢