spring的三种注入方式

蔚落 2022-09-18 09:55 231阅读 0赞

**spring的三种注入方式：**

--------------------

1.  接口注入（不推荐）
2.  getter，setter方式注入（比较常用）
3.  构造器注入（死的应用）

--------------------

***关于getter和setter方式的注入***：

*   autowire="defualt"
 *   autowire=“byName”
 *   autowire="bytype"

例如：

package org.jia;
     2 
     3 public class Order {
     4     private String orderNum;
     5     @SuppressWarnings("unused")
     6     private OrderItem orderitem;
     7 
     8     public OrderItem getOrderitem() {
     9         return orderitem;
    10     }
    11 
    12     public void setOrderitem(OrderItem orderitem) {
    13         this.orderitem = orderitem;
    14     }
    15 
    16     public String getOrderNum() {
    17         return orderNum;
    18     }
    19 
    20     public void setOrderNum(String orderNum) {
    21         this.orderNum = orderNum;
    22     }
    23     
    24 }
    25 package org.jia;
    26 
    27 public class OrderItem {
    28     private String orderdec;
    29 
    30     public String getOrderdec() {
    31         return orderdec;
    32     }
    33 
    34     public void setOrderdec(String orderdec) {
    35         this.orderdec = orderdec;
    36     }
    37 }
    38

getter&&setter方式第一种注入：

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
    
    <beans>
        <bean id="orderItem" class="org.jia.OrderItem">
            <property name="orderdec" value="item00001"></property>
        </bean>
        <bean id="order" class="org.jia.Order" >
            
            <property name="orderNum" value="order000007"></property>
             <！--注入对象 名字为orderitem，所属的类的应用id为orderItem-->
            <property name="orderitem" ref="orderItem"></property>
        
        --></bean>
    
    
    </beans>

getter&&setter方式第二种注入： byName

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
    <beans>
        
        <bean id="orderitem" class="org.jia.OrderItem">
            <property name="orderdec" value="item00001"></property>
        </bean>
        <bean id="order" class="org.jia.Order" autowire="byName">
            <property name="orderNum" value="order000007"></property>
        </bean>
    </beans>

getter&&setter方式第三种注入：byType

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
    <beans>
        
        <bean id="orderitdfadafaem" class="org.jia.OrderItem">
            <property name="orderdec" value="item00001"></property>
        </bean>
        <bean id="order" class="org.jia.Order" autowire="byType">
            <property name="orderNum" value="order000007"></property>
        </bean>
    </beans>

***关于构造器的注入：***  
  
 autowire="constructor"  
需要在Order.java中加入一个构造器  
public Order(OrderItem item )\{ orderitem = item; \}

*  构造器注入

这种方式的注入是指带有参数的构造函数注入，看下面的例子，我创建了两个成员变量SpringDao和User，

public class SpringAction {   
        //注入对象springDao   
        private SpringDao springDao;   
        private User user;   
           
        public SpringAction(SpringDao springDao,User user){   
            this.springDao = springDao;   
            this.user = user;   
            System.out.println("构造方法调用springDao和user");   
        }   
               
            public void save(){   
            user.setName("卡卡");   
            springDao.save(user);   
        }   
    }

在XML文件中同样不用<property>的形式，而是使用<constructor-arg>标签，ref属性同样指向其它<bean>

<bean name="springAction" class="com.bless.springdemo.action.SpringAction">  
              
            <constructor-arg ref="springDao"></constructor-arg>  
            <constructor-arg ref="user"></constructor-arg>  
        </bean>  
            <bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl"></bean>  
             <bean name="user" class="com.bless.springdemo.vo.User"></bean>

解决构造方法参数的不确定性，你可能会遇到构造方法传入的两参数都是同类型的，为了分清哪个该赋对应值，则需要进行一些小处理：

下面是设置index，就是参数位置：

另一种是设置参数类型：

**<constructor-arg** type="java.lang.String" ref=""**/>**

*  静态工厂的方法注入

静态工厂顾名思义，就是通过调用静态工厂的方法来获取自己需要的对象，为了让spring管理所有对象，我们不能直接通过"工程类.静态方法()"来获取对象，而是依然通过spring注入的形式获取：

Java代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

1.  package com.bless.springdemo.factory;   
2.    
3.  import com.bless.springdemo.dao.FactoryDao;   
4.  import com.bless.springdemo.dao.impl.FactoryDaoImpl;   
5.  import com.bless.springdemo.dao.impl.StaticFacotryDaoImpl;   
6.    
7.  public class DaoFactory \{   
8.      //静态工厂   
9.      public static final FactoryDao getStaticFactoryDaoImpl()\{   
10.         return new StaticFacotryDaoImpl();   
11.     \}   
12. \}

package com.bless.springdemo.factory;
    
    import com.bless.springdemo.dao.FactoryDao;
    import com.bless.springdemo.dao.impl.FactoryDaoImpl;
    import com.bless.springdemo.dao.impl.StaticFacotryDaoImpl;
    
    public class DaoFactory {
    	//静态工厂
    	public static final FactoryDao getStaticFactoryDaoImpl(){
    		return new StaticFacotryDaoImpl();
    	}
    }

同样看关键类，这里我需要注入一个FactoryDao对象，这里看起来跟第一种注入一模一样，但是看随后的xml会发现有很大差别:

Java代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

1.   public class SpringAction \{   
2.          //注入对象   
3.      private FactoryDao staticFactoryDao;   
4.         
5.      public void staticFactoryOk()\{   
6.          staticFactoryDao.saveFactory();   
7.      \}   
8.      //注入对象的set方法   
9.      public void setStaticFactoryDao(FactoryDao staticFactoryDao) \{   
10.         this.staticFactoryDao = staticFactoryDao;   
11.     \}   
12. \}

public class SpringAction {
            //注入对象
    	private FactoryDao staticFactoryDao;
    	
    	public void staticFactoryOk(){
    		staticFactoryDao.saveFactory();
    	}
    	//注入对象的set方法
    	public void setStaticFactoryDao(FactoryDao staticFactoryDao) {
    		this.staticFactoryDao = staticFactoryDao;
    	}
    }

Spring的IOC配置文件，注意看<bean name="staticFactoryDao">指向的class并不是FactoryDao的实现类，而是指向静态工厂 DaoFactory，并且配置  factory-method="getStaticFactoryDaoImpl"指定调用哪个工厂方法：

Xml代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

1.    
2.      **<bean** name="springAction" class="com.bless.springdemo.action.SpringAction" **>**  
3.            
4.          **<property** name="staticFactoryDao" ref="staticFactoryDao"**></property>**  
5.                  **</property>**  
6.      **</bean>**  
7.        
8.      **<bean** name="staticFactoryDao" class="com.bless.springdemo.factory.DaoFactory" factory-method="getStaticFactoryDaoImpl"**></bean>**  
9.

<bean name="springAction" class="com.bless.springdemo.action.SpringAction" >
    		
    		<property name="staticFactoryDao" ref="staticFactoryDao"></property>
                    </property>
    	</bean>
    	
    	<bean name="staticFactoryDao" class="com.bless.springdemo.factory.DaoFactory" factory-method="getStaticFactoryDaoImpl"></bean>

*  实例工厂的方法注入

实例工厂的意思是获取对象实例的方法不是静态的，所以你需要首先new工厂类，再调用普通的实例方法：

Java代码

public  class DaoFactory \{

1.      //实例工厂   
2.      public FactoryDao getFactoryDaoImpl()\{   
3.          return new FactoryDaoImpl();   
4.      \}   
5.  \}

public class DaoFactory {
    	//实例工厂
    	public FactoryDao getFactoryDaoImpl(){
    		return new FactoryDaoImpl();
    	}
    }

那么下面这个类没什么说的，跟前面也很相似，但是我们需要通过实例工厂类创建FactoryDao对象：

Java代码

public  class SpringAction \{

1.      //注入对象   
2.      private FactoryDao factoryDao;   
3.         
4.      public void factoryOk()\{   
5.          factoryDao.saveFactory();   
6.      \}   
7.    
8.      public void setFactoryDao(FactoryDao factoryDao) \{   
9.          this.factoryDao = factoryDao;   
10.     \}   
11. \}

public class SpringAction {
    	//注入对象
    	private FactoryDao factoryDao;
    	
    	public void factoryOk(){
    		factoryDao.saveFactory();
    	}
    
    	public void setFactoryDao(FactoryDao factoryDao) {
    		this.factoryDao = factoryDao;
    	}
    }

最后看spring配置文件：

Xml代码

1.    
2.      **<bean** name="springAction" class="com.bless.springdemo.action.SpringAction"**>**  
3.            
4.          **<property** name="factoryDao" ref="factoryDao"**></property>**  
5.      **</bean>**  
6.         
7.        
8.      **<bean** name="daoFactory" class="com.bless.springdemo.factory.DaoFactory"**></bean>**  
9.      **<bean** name="factoryDao" factory-bean="daoFactory" factory-method="getFactoryDaoImpl"**></bean>**

<bean name="springAction" class="com.bless.springdemo.action.SpringAction">
    		
    		<property name="factoryDao" ref="factoryDao"></property>
    	</bean>
    	
    	
    	<bean name="daoFactory" class="com.bless.springdemo.factory.DaoFactory"></bean>
    	<bean name="factoryDao" factory-bean="daoFactory" factory-method="getFactoryDaoImpl"></bean>

*  总结

Spring IOC注入方式用得最多的是(1)(2)种，多谢多练就会非常熟练。

另外注意：通过Spring创建的对象默认是单例的，如果需要创建多实例对象可以在<bean>标签后面添加一个属性：

Java代码

1.  <bean name="..." class="..." scope="prototype">

[icon_copy.gif]: http://blessht.iteye.com/images/icon_copy.gif
[_icon_copy.gif]: http://blessht.iteye.com/blog/1162131#
[icon_star.png]: http://blessht.iteye.com/images/icon_star.png
[spinner.gif]: /images/20220828/b9309c61c4de4d1c8af187dfe92202be.png