C02_D04_Understand_DI_SetterInjection-依赖注入:Setter

//bean
public class Address {

    private String province; //省
    private String city;     //市
    private String detailedAddress; //详细地址

    //使用property标记实现依赖注入，需要给属性生成对应的setter方法

    @Override
    public String toString() {
        return "地址::" + province + "省" + city + "市" + detailedAddress;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public void setDetailedAddress(String detailedAddress) {
        this.detailedAddress = detailedAddress;
    }
}
public class Company {

    private String companyName; //公司名称
    private Address companyAddress; //公司地址
    private Set<String> branchNames; //分公司名称列表
    private List<String> partnerNames; //合作伙伴名称列表
    private List<Employee> employeeList; //公司员工列表
    //Map集合的键和值都可以是任何类型，只不过通常键会选择用简单类型，如Integer或String等
    private Map<String,Employee> branchManagers; //分公司负责人

    /*Properties是一种特殊的Map集合，键和值的类型都是字符串*/
    private Properties extraInfo1; //公司额外信息1
    private Properties extraInfo2; //公司额外信息2


    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    public void setCompanyAddress(Address companyAddress) {
        this.companyAddress = companyAddress;
    }

    public void setBranchNames(Set<String> branchNames) {
        this.branchNames = branchNames;
    }

    public void setPartnerNames(List<String> partnerNames) {
        this.partnerNames = partnerNames;
    }


    public void setEmployeeList(List<Employee> employeeList) {
        this.employeeList = employeeList;
    }

    public void setBranchManagers(Map<String, Employee> branchManagers) {
        this.branchManagers = branchManagers;
    }


    public void setExtraInfo1(Properties extraInfo1) {
        this.extraInfo1 = extraInfo1;
    }



    public void setExtraInfo2(Properties extraInfo2) {
        this.extraInfo2 = extraInfo2;
    }



    public void showCompanyDetails() {
        System.out.println("--------------------------公司信息--------------------------");
        System.out.println("公司名称:" + companyName); //打印公司名称
        System.out.println("公司地址:" + companyAddress); //打印公司地址
        System.out.println(branchNames);  
        System.out.println(partnerNames);
        System.out.println(employeeList);
        System.out.println(branchManagers);
        System.out.println(extraInfo1);
        System.out.println(extraInfo2);
        System.out.println("------------------------------------------------------------");
    }
}
public class Employee {

    //对于简单值，可以直接用value注入值
    private String empId; // 员工编号
    private String empName; // 员工姓名
    private double empSalary; // 员工工资

    //address属性是引用的另一个bean
    private Address address; // 员工地址

    public void setEmpId(String empId) {
        this.empId = empId;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public void setEmpSalary(double empSalary) {
        this.empSalary = empSalary;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public void showEmployeeDetails() {
        System.out.println("---------------员工信息---------------");
        // 输出员工基本信息
        System.out.println("工号：" + empId);
        System.out.println("姓名：" + empName);
        System.out.println("工资：" + empSalary);
        // 输出员工地址信息
        System.out.println(address);
    }

    @Override
    public String toString() {
        return "[empId=" + empId + ", empName=" + empName + "]";
    }
}

//config-beans.xml
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 对于property标记，name指定类中属性的名称，
         value指定要注入的简单值，
         如果属性的值是引用的其他bean，
         则使用ref属性指定引用的bean的id或name -->

    <bean id="addr1" class="com.qdu.bean.Address">
        <!-- 依赖注入可注入简单值（基本数据类型和字符串类型） -->
        <!-- property标记用于实现依赖注入 ，它是通过调用对应的setter方法实现注入 -->
        <!-- name指定要注入的属性的名称，value指定要注入的值 -->
        <!-- 简单值使用value注入 -->
        <property name="province" value="山东" />
        <property name="city" value="青岛" />
        <property name="detailedAddress" value="宁夏路308号 青岛大学" />
    </bean>

    <bean id="addr2" class="com.qdu.bean.Address">
        <property name="province" value="山东" />
        <property name="city" value="临沂" />
        <property name="detailedAddress" value="人民广场" />
    </bean>

    <!-- spring提供一种更简洁的依赖注入写法，和使用property标记等效 -->
    <!-- p:属性名=属性值 -->
    <bean id="addr3" class="com.qdu.bean.Address" p:province="山东"
        p:city="烟台" p:detailedAddress="芝罘区" />

    <bean id="emp1" class="com.qdu.bean.Employee">
        <!-- 使用property标记，name属性的值是通过调用对应的setter方法注入 -->
        <!-- 注入简单值，直接使用value属性指定要注入的值即可 -->
        <property name="empId" value="E001" />
        <property name="empName" value="小明" />
        <property name="empSalary" value="10000" />
        <!-- 注入引用的其他bean，使用ref指定bean的id或name -->
        <!-- 如果一个属性是引用的其他bean，则需要使用ref属性，而不是value属性 -->
        <!-- 指定引用的bean的id或name -->
        <property name="address" ref="addr1" />
    </bean>

    <!-- spring提供一种更简洁的写法：可使用“p:属性名”或“p:属性名-ref"的形式来实现注入 -->
    <!-- 如果是简单值，直接写"p:属性名" 实现注入简单值 -->
    <!-- 如果是引用的其他bean，需要写“p:属性名-ref”实现注入引用的其他bean -->
    <bean id="emp2" class="com.qdu.bean.Employee" p:empId="E002"
        p:empName="小红" p:empSalary="200000" p:address-ref="addr2" />

    <bean id="company" class="com.qdu.bean.Company">
        <property name="companyName" value="Sunrise .Ltd" />
        <property name="companyAddress" ref="addr1" />
        <!-- 注入set集合：使用set标记 -->
        <property name="branchNames">
            <set>
                <!-- 如果集合中是简单值，直接用value标记指定每个元素的值即可 -->
                <!-- 如果集合中是其他bean，如Address，则需要使用<ref bean="id或name" /> -->
                <!-- <ref bean="addr1" /> <ref bean="addr2" /> <ref bean="addr3" /> -->
                <value>山东分公司</value>
                <value>山西分公司</value>
                <value>广东分公司</value>
                <value>广西分公司</value>
            </set>
        </property>
        <!-- 如果集合中是简单值，直接使用value注入要注入的值即可 -->
        <property name="partnerNames">
            <list>
                <value>Oracle</value>
                <value>Microsoft</value>
                <value>IBM</value>
            </list>
        </property>
        <!-- 如果集合中是引用的其他bean，则使用ref标记， -->
        <!-- 并使用bean属性指定要注入集合的bean的id或name即可 -->
        <property name="employeeList">
            <list>
                <ref bean="emp1" />
                <ref bean="emp2" />
            </list>
        </property>
        <property name="branchManagers">
            <map>
                <!-- Map集合中一个数据项，也就是一个键值对叫做一个entry -->
                <!-- 如果键是简单值类型，使用key指定键的名称 -->
                <!-- 如果键是引用的其他bean，使用key-ref指定键引用的其他bean的id或name -->
                <!-- 如果值是简单值类型，使用value注入值 -->
                <!-- 如果值是引用的其他bean，使用value-ref指定值引用的其他bean的id或name -->
                <entry key="山东分公司" value-ref="emp1" />
                <entry key="山西分公司" value-ref="emp2" />
            </map>
        </property>
        <property name="extraInfo1">
            <!-- 对于Properties类型的属性，可以使用props标记+prop标记实现注入 -->
            <props>
                <!-- Properties集合中的每个元素使用一个prop标记注入，key指定键的名称，prop标记的内容是要注入的值 -->
                <prop key="type">Joint venture</prop>
                <prop key="registeredCapital">2000000</prop>
                <prop key="legalPerson">Allen</prop>
            </props>
        </property>
        <property name="extraInfo2">
           <!-- 对于Properties集合，也可直接使用value标记定义要注入的各个集合的值 -->
           <!-- 在value中指定每个元素的键和值即可 -->
            <value>
                type=Joint venture
                registeredCapital=2000000
                legalPerson=Allen
            </value>
        </property>
    </bean>

</beans>

//main
/**
 * *实现依赖注入-DI：注入简单值
 * 
 * @author 22-426
 */
public class Test1_UseDI_注入简单值 {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext("config/beans.xml");

        Address addr1 = (Address) ctx.getBean("addr1");
        System.out.println(addr1);

        Address addr2 = (Address) ctx.getBean("addr2");
        System.out.println(addr2);

        Address addr3 = (Address) ctx.getBean("addr3");
        System.out.println(addr3);
    }
}
/**
 * *实现依赖注入-DI：注入简单值和引用的其他Bean
 * 
 * @author 22-426
 */
public class Test2_UseDI_注入简单值和引用的其他bean {

    public static void main(String[] args) {

        ApplicationContext ctx 
        = new ClassPathXmlApplicationContext("config/beans.xml");

        Employee emp1 = (Employee) ctx.getBean("emp1");
        emp1.showEmployeeDetails();

        Employee emp2 = (Employee) ctx.getBean("emp2");
        emp2.showEmployeeDetails();

    }
}

/**
 * *实现依赖注入-DI：注入集合（List、Set、|Map、Properties）
 * 
 * @author 22-426
 */
public class Test3_UseDI_注入集合 {

    public static void main(String[] args) {

        ApplicationContext ctx
        = new ClassPathXmlApplicationContext("config/beans.xml");

        Company comp = (Company) ctx.getBean("company");
        comp.showCompanyDetails();

    }
}