spring3学习笔记（六）bean属性的注入

什么是bean属性的注入

在创建对象的时候，向对象中注入相应的值

属性注入的方式

• 1 set方法进行注入（最常用）

public class User{
  private String name;
  public void setName(){
    this.name=name;
  }
}
public class UserTest{
  User user = new User();
  user.setName("hobbes");
}

• 2 有参的构造方法注入

public class User{
  private String name;
  public User(String name){
    this.name=name;
  }
}
public class UserTest{
  User user = new User("hobbes");
}

• 3 接口注入（不推荐使用）

public interface User{
  public void userFunction();
}
public class UserImpl implements User{
  public String name;
  public void userFunction(String name){
    this.name=name;
  }
}

spring框架中的属性注入

spring框架支持上一点中提到的set方法注入（重点）和有参构造方法注入

• 1 set方法注入（重点）：
  //需要被创建对象的类
  public class User{
  private String username;
  public void setUsername(String username){
  this.username=username;
  }
  public void userFunction(){
  System.out.print("userFuntion方法执行，username："+username);
  }
  }
  //在核心配置文件中对该类进行注册
  <bean id="user" class="com.hobbes.test.User">
  <property name="username" value="hobbes"></property>
  </bean>

//在测试类中获得该对象，并获得对象属性和方法
public class Test{
@Test
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
User user = (User)context.getBean("user");
user.userFunction();
}
//输出结果
userFuntion方法执行，username：hobbes

• 2 有参构造方法注入：

//需要被创建对象的类
public class User{
  private String username;
  public User(String username){
    this.username=username;
  }
  public void userFunction(){
    System.out.print("userFuntion方法执行，username："+username);
  }
}

//在核心配置文件中对该类进行注册
<bean id="user" class="com.hobbes.test.User">
  <!-- 使用有参构造注入，name标签对应属性名，value标签对应注入的值 -->
  <constructor-arg name="username" value="hobbes"></constructor-arg>
</bean>

//在测试类中获得该对象，并获得对象属性和方法
public class Test{
  @Test
  ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  User user = (User)context.getBean("user");
  user.userFunction();
}

//输出结果
userFuntion方法执行，username：hobbes

注入复杂类型属性的操作

上一点我们提到了对字符串类型的属性进行注入，但在实际开发过程中，我们经常会将类的对象、复杂的类型作为属性注入。接下来就对类的对象等复杂类型的注入做详解。

• 1 注入属性为类的对象时

/*需求：在UserService类中调用UserDao类中的userFuntion方法*/
//创建需要被注入属性的类
public class UserService{
  //声明需要被注入的类的对象
  private UserDao userDao;
  //生成UserDao的set方法
  public void setUserDao(UserDao userDao){
    this.userDao = userDao;
  }
  public void userFunction(){
    system.out.println("UserService类中的userFunction方法执行了");
  }
}

//创建需要被当做对象属性注入UserService类中的类
public class UserDao{
  public void userFunction(){
    system.out.println("UserDao类中的userFunction方法执行了");
  }
}

//在核心配置文件中进行注入
<!-- 注册UserDao类 -->
<bean id="userDao" class="com.hobbes.test.UserDao"></bean>
<!-- 注册UserService类 -->
<bean id="userService" class="com.hobbes.test.UserService">
  <!-- 注入UserDao类的对象，其中ref标签的值对应被注入对象bean的id值 -->
  <property name="userDao" ref="userDao"></property>
</bean>

//在测试类中获得该对象，并获得对象属性和方法
public class Test{
  @Test
  ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  UserService userServicec = (UserService)context.getBean("userService");
  userService.userFunction();
}

//输出结果
UserService类中的userFuntion方法执行了
UserDao类中的userFunction方法执行了

复杂类型对象的注入

• 1 注入数组类型
• 2 注入list集合
• 3 注入map集合
• 4 注入properties类型

//创建需要被创建的类
public class Person{
  private String pname;
  private String pname;
  public void setPname(String pname) {
    this.pname = pname;
  }
    
  private String[] arrs;
  private List<String> list;
  private Map<String,String> map;
  private Properties properties;
    
  public void setArrs(String[] arrs) {
    this.arrs = arrs;
  }
  public void setList(List<String> list) {
    this.list = list;
  }
  public void setMap(Map<String, String> map) {
    this.map = map;
  }
  public void setProperties(Properties properties) {
    this.properties = properties;
  }

  public void personTest() {
    System.out.println("arrs:"+arrs);
    System.out.println("list:"+list);
    System.out.println("map:"+map);
    System.out.println("properties"+properties);
  }
}

//在核心配置文件中注入相应的属性值
<bean id="person" class="com.hobbes.test.Person">
  <!-- 数组 -->
  <property name="arrs">
    <list>
      <value>张一</value>
      <value>张二</value>
      <value>张三</value>
    </list>
  </property>
        
  <!-- list -->
  <property name="list">
    <list>
      <value>张一</value>
      <value>张二</value>
      <value>张三</value>
    </list>         
  </property>
        
  <!-- map -->
  <property name="map">
    <map>
      <entry key="one" value="张一"></entry>
      <entry key="two" value="张二"></entry>
      <entry key="three" value="张三"></entry>
    </map>
  </property>
        
  <!-- properties -->
  <property name="properties">
    <props>
      <prop key="driverclass">com.mysql.jdbc.Driver</prop>
      <prop key="username">root</prop>
    </props>
  </property>
</bean>

//在测试类中获得该对象，并获得对象属性和方法
public class Test{
  @Test
  ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  Person person = (Person )context.getBean("person");
  person.personTest ();
}

//输出结果
arrs：[Ljava.lang.String;@1865265]
list：[张一, 张二, 张三]
map：[one=张一, two=张二, three=张三]
properties：{driverclass=com.mysql.jdbc.Driver, username=root}

总结

• 1 spring框架中的属性注入，必须重点掌握的是set方法注入
• 2 当注入属性为类的对象时，被注入输入的bean的property标签中的ref标签中的值对应注入类对应bean的id值
• 3 大家可能发现了，利用IOC可以很好地实现低耦合，但每个类的创建都需要去手动写一段比较长的注册bean代码。大家不要觉得麻烦，因为在后面的学习中，将会学到注解，到时候类的注入，属性的输入只需要一个标签就可以完成注入