用依赖注入获取如下效果：

mmexport1614247527820.jpg

什么是依赖注入

  • 依赖注入（Dependency Injection,DI）。
  • 依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 .
  • 注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 .

set注入:

1.编写pojo测试类

wife.java

  1. package com.sy.pojo;
  3. import java.util.*;
  5. public class Wife {
  7.     private String name;
  8.     private Address address;
  9.     private String[] books;
  10.     private List<String> hobbys;
  11.     private Map<String,String> games;
  12.     private Set<String> pow;
  13.     private String hasben;
  14.     private Properties info;
  16.     public Set<String> getPow() {
  17.         return pow;
  18.     }
  20.     public void setPow(Set<String> pow) {
  21.         this.pow = pow;
  22.     }
  24.     @Override
  25.     public String toString() {
  26.         return "Wife：" +"\n" +
  27.                 "name='" + name + '\'' + "\n" +
  28.                 " address=" + address +"\n" +
  29.                 " books=" + Arrays.toString(books) +"\n" +
  30.                 " hobbys=" + hobbys +"\n" +
  31.                 " games=" + games +"\n" +
  32.                 " pow=" + pow +"\n" +
  33.                 " hasben='" + hasben + '\'' +"\n" +
  34.                 " info=" + info
  35.                 ;
  36.     }
  38.     public String getName() {
  39.         return name;
  40.     }
  42.     public void setName(String name) {
  43.         this.name = name;
  44.     }
  46.     public Address getAddress() {
  47.         return address;
  48.     }
  50.     public void setAddress(Address address) {
  51.         this.address = address;
  52.     }
  54.     public String[] getBooks() {
  55.         return books;
  56.     }
  58.     public void setBooks(String[] books) {
  59.         this.books = books;
  60.     }
  62.     public List<String> getHobbys() {
  63.         return hobbys;
  64.     }
  66.     public void setHobbys(List<String> hobbys) {
  67.         this.hobbys = hobbys;
  68.     }
  70.     public Map<String, String> getGames() {
  71.         return games;
  72.     }
  74.     public void setGames(Map<String, String> games) {
  75.         this.games = games;
  76.     }
  80.     public String getHasben() {
  81.         return hasben;
  82.     }
  84.     public void setHasben(String hasben) {
  85.         this.hasben = hasben;
  86.     }
  88.     public Properties getInfo() {
  89.         return info;
  90.     }
  92.     public void setInfo(Properties info) {
  93.         this.info = info;
  94.     }
  95. }

Address.java

  1. package com.sy.pojo;
  3. public class Address {
  4.     private String address;
  6.     @Override
  7.     public String toString() {
  8.         return "Address{" +
  9.                 "address='" + address + '\'' +
  10.                 '}';
  11.     }
  13.     public String getAddress() {
  14.         return address;
  15.     }
  17.     public void setAddress(String address) {
  18.         this.address = address;
  19.     }
  20. }

2.在容器中注入

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.         http://www.springframework.org/schema/beans/spring-beans.xsd">
  8.     <bean id="wife" class="com.sy.pojo.Wife" name="LaoPo,sama">
  9.         <property name="name" value="食蜂操祈"/>
  10.         <property name="address" ref="address"/>
  11.         <property name="books">
  12.             <array>
  13.                 <value>某科学的超星星眼</value>
  14.                 <value>魔法星星目录</value>
  15.             </array>
  16.         </property>
  17.         <property name="hobbys">
  18.             <list>
  19.                 <value>甜点</value>
  20.                 <value>做梦</value>
  21.             </list>
  22.         </property>
  24.         <property name="games">
  25.             <map>
  26.                 <entry key="排球" value="运动"/>
  27.                 <entry key="操纵" value="意念"/>
  28.             </map>
  29.         </property>
  31.         <property name="pow">
  32.             <set>
  33.             <value>心灵操纵</value>
  34.             <value>球球大作战</value>
  35.             </set>
  36.         </property>
  38.         <property name="hasben">
  39.             <null/>
  40.         </property>
  42.         <property name="info">
  43.             <props>
  44.                 <prop key="等级">5</prop>
  45.                 <prop key="体重">89</prop>
  46.             </props>
  47.         </property>
  48.     </bean>
  50.     <bean id="address" class="com.sy.pojo.Address">
  51.         <property name="address" value="学园都市"/>
  52.     </bean>
  54. </beans>

3.获取容器后输出就好啦

public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Wife wife = (Wife) context.getBean("wife");
        System.out.println(wife.toString());
    }

c命名空间和p命名空间

需要导入约束

p:

xmlns:p="http://www.springframework.org/schema/p"

c:

 xmlns:c="http://www.springframework.org/schema/c"

User.java

package com.sy.pojo;

public class User {
    private String name;
    private int age;

    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 "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

    public User() {
    }
}

注意：p命名是不用有参构造 c命名时要构造有参，两个都用时有参无参都加上
Userbean.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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--p命名空间注入，可以直接注入属性的值：property-->
    <bean id="user" class="com.sy.pojo.User" p:name="林俊杰" p:age="3"/>
    <!--c命名空间注入,通过构造器注入：construct-orgs-->
    <bean id="user2" class="com.sy.pojo.User" c:name="一方通行" c:age="18"/>
</beans>

Bean的作用域

image.png
singleton单例 全局唯一（Spring默认机制）

<bean id="user2" class="com.sy.pojo.User" c:name="一方通行" c:age="18" scope="singleton" />

当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。Singleton是单例类型，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象。注意，Singleton作用域是Spring中的缺省作用域。
prototype原型 每一个对象有自己的
每次从容器中get，都会产生一个对象

<bean id="user2" class="com.sy.pojo.User" c:name="一方通行" c:age="18" scope="prototype"/>

Prototype
当一个bean的作用域为Prototype，表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。根据经验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。

当一个bean的作用域为Request，表示在一次HTTP请求中，一个bean定义对应一个实例；即每个HTTP请求都会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

<bean id=”loginAction” class=cn.csdn.LoginAction” scope=”request”/>
针对每次HTTP请求，Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例，且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例的内部状态，而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。当处理请求结束，request作用域的bean实例将被销毁。

Session

当一个bean的作用域为Session，表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：


针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例，且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据userPreferences创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。