Spring笔记04（DI（给属性赋值），自动装配（autowire））

给不同数据类型注入值：

 

<?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-3.2.xsd">
    <bean id="entity" class="entity.TestEntity">
        <!-- 使用<![CDATA[]]>标记处理XML特 殊字符 -->
        <property name="specialCharacter1">
            <value><![CDATA[P&G]]></value>
        </property>
        <!-- 把XML特殊字符替换为实体引用 -->
        <property name="specialCharacter2">
            <value>P&amp;G</value>
        </property>
        <!-- 定义内部Bean -->
        <property name="innerBean">
            <bean class="entity.User">
                <property name="username">
                    <value>Mr. Inner</value>
                </property>
            </bean>
        </property>
        <!-- 注入List类型 -->
        <property name="list">
            <list>
                <!-- 定义List中的元素 -->
                <value>足球</value>
                <value>篮球</value>
            </list>
        </property>
        <!-- 注入数组类型 -->
        <property name="array">
            <arry>
                <!-- 定义数组中的元素 -->
                <value>足球</value>
                <value>篮球</value>
            </arry>
        </property>
        <!-- 注入Set类型 -->
        <property name="set">
            <set>
                <!-- 定义Set或数组中的元素 -->
                <value>足球</value>
                <value>篮球</value>
            </set>
        </property>
        <!-- 注入Map类型 -->
        <property name="map">
            <map>
                <!-- 定义Map中的键值对 -->
                <entry>
                    <key>
                        <value>football</value>
                    </key>
                    <value>足球</value>
                </entry>
                <entry>
                    <key>
                        <value>basketball</value>
                    </key>
                    <value>篮球</value>
                </entry>
            </map>
        </property>
        <!-- 注入Properties类型 -->
        <property name="props">
            <props>
                <!-- 定义Properties中的键值对 -->
                <prop key="football">足球</prop>
                <prop key="basketball">篮球</prop>
            </props>
        </property>
        <!-- 注入空字符串值 -->
        <property name="emptyValue">
            <value></value>
        </property>
        <!-- 注入null值 -->
        <property name="nullValue">
            <null/>
        </property>
    </bean>
</beans>

 

 

 

 

1.DI（给属性赋值）的四种方式：

01.Student实体类:

package cn.pb.bean;

/**
 * 学生实体类
 */
public class Student {
    private  String   name;  //姓名
    private  Integer  age;  //年龄
    private  Grade   grade;  //年级

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", grade=" + grade
                + "]";
    }

    // p 注入的时候 必须要有无参构造
    public Student() {
        super();
    }
    // c 注入的时候 必须要有带参构造
    public Student(String name, Integer age, Grade grade) {
        super();
        this.name = name;
        this.age = age;
        this.grade = grade;
    }
    //p注入的时候 必须要有set（）
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Grade getGrade() {
        return grade;
    }
    public void setGrade(Grade grade) {
        this.grade = grade;
    }


}

02.Grade实体类:

package cn.pb.bean;

/**
 * 年级实体类
 */
public class Grade {
    private String  name;  //年级名称


    @Override
    public String toString() {
        return "Grade [name=" + name + "]";
    }

    public Grade() {
        super();
    }

    public Grade(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

 

03.DI注入的方式:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       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">

    <!--  配置年级对应的bean-->
      <bean  id="grade" class="com.xdf.bean.Grade">
          <!--01.设值注入 (推荐使用，便于阅读)  在对应的类中必须有set方法，因为底层执行反射机制查询类中对应的setXxx(DI)    -->
          <property name="gradeId" value="1"/>
          <property name="name" value="一年级"/>
      </bean>

    <!--  配置学生对应的bean   02.p命名空间赋值 必须有set()和无参构造
    <bean id="student" class="com.xdf.bean.Student"
          p:age="18" p:name="小黑" p:grade-ref="grade"/>-->

    <!--03.通过构造方法给属性赋值 前提是 必须有对应的带参构造方法  不需要set和get，无参构造也不需要
    <bean id="student"  class="com.xdf.bean.Student">
        001:使用参数的下标
        <constructor-arg index="0" value="xiaohei"/>
        <constructor-arg index="1" value="19"/>
        <constructor-arg index="2" ref="grade"/>
        002:使用参数的名称
        <constructor-arg name="name" value="xiaohei"/>
        <constructor-arg name="age" value="19"/>
        <constructor-arg name="grade" ref="grade"/>
        003:使用参数的默认顺序
        <constructor-arg  value="xiaohei"/>
        <constructor-arg  value="19"/>
        <constructor-arg  ref="grade"/>
    </bean>-->

    <!--04.通过c命名空间（构造方法）给属性赋值 前提是 必须有对应的带参构造方法-->
    <bean id="student"  class="com.xdf.bean.Student"
     c:age="18" c:name="xiaobai" c:grade-ref="grade"/>


</beans>

04.测试代码:

package cn.pb;

import cn.pb.bean.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class StudentTest {
    @Test
    public  void  test01(){
        ApplicationContext context=
                new ClassPathXmlApplicationContext("applicationContext.xml");
        /*
         * 获取容器给我们创建的Student对象   ioc的体现
         *  本身由自身创建对象的过程，把创建对象的权利移交给了spring容器!  IOC  控制反转
         *
         * 之前 Student student=new Student();
         * 现在context.getBean("student");
         * context容器来创建对象了
         *
         */
        Student student=(Student) context.getBean("student");
        System.out.println(student);
    }
}

 

2.自动装配（autowire）：

01.主人实体类:

/**
 * 主人类
 */
public class Person {

     private  String  name; //姓名
     private  int  age; //年龄
     private   Dog  dog;  //主人的宠物
     private   Cat  cat;  //主人的宠物

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", dog=" + dog +
                ", cat=" + cat +
                '}';
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {

    }
}

02.宠物狗实体类:

/**
 * 宠物狗类
 */
public class Dog {
    private   String  name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
}

03.宠物狗的子类小狗实体类:

/**
　*继承了宠物狗类 所以宠物狗的非私有的东西 他全有
　*/
public class SmallDog  extends  Dog {

}

 

04.宠物猫实体类:

/**
 * 小猫咪类
 */
public class Cat {
    private   String  name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
}

 

05.applicationContext.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"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- autowire  自动装配对象 有两种方式
   01.byName
      spring会根据实体类中的属性名，去找xml文件中id为属性名的bean进行装配！
   02.byType
       spring会根据实体类中的属性类型，去找xml文件中找一个class是 属性类型的类进行装配,
       如果有多个 会报错！
 -->


    <!--配置的主人bean-->
    <bean id="person" class="cn.pb.bean.Person" autowire="byName">
        <property name="age" value="20"/>
        <property name="name" value="xiaohei"/>
          <!--直接引用  autowire属性没有效果  <property name="dog" ref="dog"/>-->
    </bean>

    <!--配置 宠物狗bean-->
    <bean id="dog" class="cn.pb.bean.Dog">
         <property name="name"  value="哈士奇"/>
    </bean>
    <!--配置 小狗bean-->
    <bean id="smallDog" class="cn.pb.bean.SmallDog">
        <!--SmallDog中没有任何属性 ，但是继承父类的name-->
         <property name="name"  value="小狗哈士奇"/>
    </bean>

    <!--主人的第二个宠物 猫咪-->
    <bean id="cat" class="cn.pb.bean.Cat">
        <property name="name"  value="机器锚"/>
    </bean>
</beans>

06.测试代码:

public class PersonDemo {

    public static void main(String[] args) {

        ApplicationContext context=new ClassPathXmlApplicationContext
                ("applicationContext.xml");

      //获取主人信息
        Person person = (Person) context.getBean("person");
        System.out.println(person);
    }

}