zoukankan      html  css  js  c++  java

  • Spring Bean基本管理--bean注入方式汇总

    依赖注入方式：Spring支持两种依赖注入方式，分别是属性注入和构造函数注入。还有工厂方法注入方式。
    依赖注入还分为：注入依赖对象可以采用手工装配或自动装配，在实际应用开发中建议使用手工装配，因为自动装配会产生许多未知情况，开发人员无法预见最终的装配结果。
    手工装配依赖对象又分为3种方式：
    1、编程方式（写的过程中向BeanFactory去注册）
    2、是在XML文件中，通过在bean节点下配置；如上面讲到的使用属性的setter方法注入依赖对象和使用构造器方法注入依赖对象都是这种方式。
    3、就是在java代码中使用注解的方式进行装配，在代码中加入@Resource或者@Autowired等，怎样使用注解的方式来为某个bena注入依赖对象呢？
    自动装配依赖对象分为2种方式：
    1、配置文件的bean中增加autowire
    2、也可以选择在beans中加入default-autowire属性，为所有bean设置默认自动装配

    Spring中提供了自动装配依赖对象的机制，但是在实际应用中并不推荐使用自动装配，因为自动装配会产生未知情况，开发人员无法预见最终的装配结果。

    自动装配是在配置文件中实现的，如下：

    <bean id="***" class="***" autowire="byType">

    只需要配置一个autowire属性即可完成自动装配，不用再配置文件中写<property>,但是在类中还是要生成依赖对象的setter方法。

    Autowire的属性值有如下几个：

    · byType 按类型装配  可以根据属性类型，在容器中寻找该类型匹配的bean，如有多个，则会抛出异常，如果没有找到，则属性值为null；

    · byName 按名称装配  可以根据属性的名称在容器中查询与该属性名称相同的bean，如果没有找到，则属性值为null；

    · constructor 与byType方式相似，不同之处在与它应用于构造器参数，如果在容器中没有找到与构造器参数类型一致的bean，那么将抛出异常；

    · autodetect 通过bean类的自省机制(introspection)来决定是使用constructor还是byType的方式进行自动装配。如果发现默认的构造器，那么将使用byType的方式。
     
    ---------------分割线-----------------------------------------------------------------------------------------------------
    示例：
    一、使用属性setter方法注入
     
    下面是Bean和beans-config.xml文件。
      
    public class HelloBean {  

    private String helloWord; 

    //...省略getter、setter方法     

}

    xml文件：

    <?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="helloBean"  
          class="onlyfun.caterpillar.HelloBean">  
        <property name="helloWord"> 
            <value>Hello!Justin!</value> 
        </property>  
    </bean>  
</beans>

    java:

    public class SpringDemo {  
    public static void main(String[] args) {  
        Resource rs = new FileSystemResource("beans-config.xml");  
        BeanFactory factory = new XmlBeanFactory(rs);  
         
        HelloBean hello = (HelloBean) factory.getBean("helloBean");  
        System.out.println(hello.getHelloWord());  
    }  
}
    二、使用constructor方式完成注入
    其中xml配置有如下方式：
    在配置文件中配置该类的bean，并配置构造器，在配置构造器中用到了<constructor-arg>节点，该节点有四个属性：

    · index是索引，指定注入的属性，从0开始，如：0代表personDao，1代表str属性；

    · type是指该属性所对应的类型，如Persondao对应的是com.aptech.dao.PersonDAO；

    · ref 是指引用的依赖对象；

    · value 当注入的不是依赖对象，而是基本数据类型时，就用value；

     java代码：
    public class HelloBean { 
    private String name; 
    private String helloWord; 

    // 建议有要无参数建构方法 
    public HelloBean() { 
    } 
     
    public HelloBean(String name, String helloWord) { 
        this.name = name; 
        this.helloWord = helloWord; 
    } 

    //...省略getter、setter方法     
}

    xml文件：

    <?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="helloBean"  
          class="onlyfun.caterpillar.HelloBean">  
        <constructor-arg index="0"> 
            <value>Justin</value> 
        </constructor-arg>  
        <constructor-arg index="1"> 
            <value>Hello</value> 
        </constructor-arg>  
    </bean>  
</beans>

    java代码：

    public class SpringDemo {  
    public static void main(String[] args) {  
        ApplicationContext context =  
            new FileSystemXmlApplicationContext("beans-config.xml"); 
          
        HelloBean hello = (HelloBean) context.getBean("helloBean"); 
        System.out.print("Name: "); 
        System.out.println(hello.getName()); 
        System.out.print("Word: "); 
        System.out.println(hello.getHelloWord());  
    }  
}
    三、属性参考
     
    public class HelloBean {  
        private String helloWord;  
        private Date date;  
         
        //...省略getter、setter方法     
    }
     
    <beans>  
        <bean id="dateBean" class="java.util.Date"/>  
        <bean id="helloBean" class="onlyfun.caterpillar.HelloBean">  
            <property name="helloWord">  
                <value>Hello!</value>  
            </property>  
            <property name="date">  
                <ref bean="dateBean"/>  
            </property>  
        </bean>  
    </beans>
     
    public class SpringDemo {  
        public static void main(String[] args) {  
            ApplicationContext context =  
                new FileSystemXmlApplicationContext("beans-config.xml"); 
              
            HelloBean hello = (HelloBean) context.getBean("helloBean"); 
            System.out.print(hello.getHelloWord()); 
            System.out.print(" It's "); 
            System.out.print(hello.getDate()); 
            System.out.println("."); 
        }  
    }
     
    四、“byType”自动绑定
     
    将“三”中的配置文件改为下面，即可完成bean属性的按类型自动绑定。
     
    <beans>  
        <bean id="dateBean" class="java.util.Date"/>  
        <bean id="helloBean" class="onlyfun.caterpillar.HelloBean" autowire="byType">  
            <property name="helloWord">  
                <value>Hello!</value>  
            </property>  
        </bean>  
    </beans>
     
    五、“byName”自动绑定
     
    将“三”中的配置文件改为下面，即可完成bean属性的按名称自动绑定。
     
    <beans>  
        <bean id="dateBean" class="java.util.Date"/>  
        <bean id="helloBean" class="onlyfun.caterpillar.HelloBean" autowire="byName">  
            <property name="helloWord">  
                <value>Hello!</value>  
            </property>  
        </bean>  
    </beans>
     
    六、“constructor”自动绑定
     
    将“三”中的配置文件改为下面，即可完成bean属性的按构造方法自动绑定。在建立依赖关系时，Srping容器会试图比对容器中的Bean实例类型，及相关的构造方法上的参数类型，看看在类型上是否符合，如果有的话，则选用该构造方法来建立Bean实例。如果无法绑定，则抛出org.springframework.beans.factory.UnsatisfiedDependencyException异常。
     
    <beans>  
        <bean id="dateBean" class="java.util.Date"/>  
        <bean id="helloBean" class="onlyfun.caterpillar.HelloBean" autowire="constructor">  
            <property name="helloWord">  
                <value>Hello!</value>  
            </property>  
        </bean>  
    </beans>
     
    七、“autodetect”自动绑定
     
    将“三”中的配置文件改为下面，即可完成bean属性的自动绑定，这个自动绑定是Spring会尝试用入constructor来处理依赖关系的建立，如果不行，则再尝试用byType类建立依赖关系。
     
    <beans>  
        <bean id="dateBean" class="java.util.Date"/>  
        <bean id="helloBean" class="onlyfun.caterpillar.HelloBean" autowire="autodetect">  
            <property name="helloWord">  
                <value>Hello!</value>  
            </property>  
        </bean>  
    </beans>
     
    八、依赖检查方式
     
    在自动绑定中，由于没办法从定义文件中，清楚地看到是否每个属性都完成设定，为了确定某些依赖关系确实建立，您可以假如依赖检查，在<bean>标签使用时设定"dependency-check"，可以有四种依赖检查方式：simple、objects、all、none。
     
    simple：只检查简单的类型（像原生数据类型或字符串对象）属性是否完成依赖关系，。
    objects：检查对象类型的属性是否完成依赖关系。
    all：则检查全部的属性是否完成依赖关系。
    none：设定是默认值，表示不检查依赖性。
     
    <beans>  
        <bean id="dateBean" class="java.util.Date"/>  
        <bean id="helloBean" class="onlyfun.caterpillar.HelloBean" autowire="autodetect" dependeny-check="all">  
            <property name="helloWord">  
                <value>Hello!</value>  
            </property>  
        </bean>  
    </beans>
     
    九、集合对象注入
     
    对于像数组、List、Set、Map等集合对象，在注入前必须填充一些对象至集合中，然后再将集合对象注入至所需的Bean时，也可以交由Spring的IoC容器来自动维护或生成集合对象，并完成依赖注入。
     
    public class SomeBean { 
        private String[] someStrArray; 
        private Some[] someObjArray; 
        private List someList; 
        private Map someMap; 

        public String[] getSomeStrArray() { 
            return someStrArray; 
        } 
        public void setSomeStrArray(String[] someStrArray) { 
            this.someStrArray = someStrArray; 
        } 
        public Some[] getSomeObjArray() { 
            return someObjArray; 
        } 
        public void setSomeObjArray(Some[] someObjArray) { 
            this.someObjArray = someObjArray; 
        } 
        public List getSomeList() { 
            return someList; 
        } 
        public void setSomeList(List someList) { 
            this.someList = someList; 
        } 
        public Map getSomeMap() { 
            return someMap; 
        } 
        public void setSomeMap(Map someMap) { 
            this.someMap = someMap; 
        } 
    }
     
    public class Some { 
        private String name; 

        public String getName() { 
            return name; 
        } 
        public void setName(String name) { 
            this.name = name; 
        } 
        public String toString() { 
            return name; 
        } 
    }
     
    <?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="some1" class="onlyfun.caterpillar.Some"> 
            <property name="name"> 
                <value>Justin</value> 
            </property> 
        </bean> 
         
        <bean id="some2" class="onlyfun.caterpillar.Some"> 
            <property name="name"> 
                <value>momor</value> 
            </property> 
        </bean> 
         
        <bean id="someBean" class="onlyfun.caterpillar.SomeBean"> 
            <property name="someStrArray"> 
                <list> 
                    <value>Hello</value> 
                    <value>Welcome</value> 
                </list> 
            </property> 
             
            <property name="someObjArray"> 
                <list> 
                     <ref bean="some1"/> 
                     <ref bean="some2"/> 
                </list> 
            </property> 
             
            <property name="someList"> 
                <list> 
                     <value>ListTest</value> 
                     <ref bean="some1"/> 
                     <ref bean="some2"/> 
                </list> 
            </property> 
             
            <property name="someMap"> 
                <map> 
                     <entry key="MapTest"> 
                         <value>Hello!Justin!</value> 
                     </entry> 
                     <entry key="someKey1"> 
                         <ref bean="some1"/> 
                     </entry> 
                </map> 
            </property> 
        </bean>  
    </beans>
     
    public class SpringDemo {  
        public static void main(String[] args) {  
            ApplicationContext context =  
                new FileSystemXmlApplicationContext( 
                        "beans-config.xml"); 
              
            SomeBean someBean =  
                (SomeBean) context.getBean("someBean"); 
             
            // 取得数组型态依赖注入对象 
            String[] strs =  
                (String[]) someBean.getSomeStrArray(); 
            Some[] somes =  
                (Some[]) someBean.getSomeObjArray(); 
            for(int i = 0; i < strs.length; i++) { 
                System.out.println(strs[i] + ","  
                        + somes[i].getName()); 
            } 

            // 取得List型态依赖注入对象 
            System.out.println(); 
            List someList = (List) someBean.getSomeList();  
            for(int i = 0; i < someList.size(); i++) { 
                System.out.println(someList.get(i)); 
            } 
             
            // 取得Map型态依赖注入对象 
            System.out.println(); 
            Map someMap = (Map) someBean.getSomeMap(); 
            System.out.println(someMap.get("MapTest")); 
            System.out.println(someMap.get("someKey1")); 
        }  
    }
     

    十、静态工厂的方法注入

    静态工厂顾名思义，就是通过调用静态工厂的方法来获取自己需要的对象，为了让spring管理所有对象，我们不能直接通过"工程类.静态方法()"来获取对象，而是依然通过spring注入的形式获取：
    Java代码  
        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代码
    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代码
    <!--配置bean,配置后该类由spring管理-->  
    <bean name="springAction" class="com.bless.springdemo.action.SpringAction" >  
        <!--(3)使用静态工厂的方法注入对象,对应下面的配置文件(3)-->  
        <property name="staticFactoryDao" ref="staticFactoryDao"></property>  
                </property>  
    </bean>  
    <!--(3)此处获取对象的方式是从工厂类中获取静态方法-->  
    <bean name="staticFactoryDao" class="com.bless.springdemo.factory.DaoFactory" factory-method="getStaticFactoryDaoImpl"></bean>

    十一、实例工厂的方法注入

    实例工厂的意思是获取对象实例的方法不是静态的，所以你需要首先new工厂类，再调用普通的实例方法：
    Java代码
    public class DaoFactory {  
    //实例工厂  
    public FactoryDao getFactoryDaoImpl(){  
        return new FactoryDaoImpl();  
    }  
}
    那么下面这个类没什么说的，跟前面也很相似，但是我们需要通过实例工厂类创建FactoryDao对象：
    Java代码 
    public class SpringAction {  
    //注入对象  
    private FactoryDao factoryDao;  
      
    public void factoryOk(){  
        factoryDao.saveFactory();  
    }  
  
    public void setFactoryDao(FactoryDao factoryDao) {  
        this.factoryDao = factoryDao;  
    }  
}
    最后看spring配置文件：
    Xml代码
        <!--配置bean,配置后该类由spring管理-->  
        <bean name="springAction" class="com.bless.springdemo.action.SpringAction">  
            <!--(4)使用实例工厂的方法注入对象,对应下面的配置文件(4)-->  
            <property name="factoryDao" ref="factoryDao"></property>  
        </bean>  
          
        <!--(4)此处获取对象的方式是从工厂类中获取实例方法-->  
        <bean name="daoFactory" class="com.bless.springdemo.factory.DaoFactory"></bean>  
        <bean name="factoryDao" factory-bean="daoFactory" factory-method="getFactoryDaoImpl"></bean>
     
     
  • 相关阅读:
    简简单单制作鼠标静态动态 ani cur 小结 鼠标形状指针
    【VB6 学习文档管理系统源码】
    Delphi 中的全局快捷键+给指定窗体发送按键
    C# 委托实例实现的多种类型
    PyCharm 上传项目到码云托管平台
    vs rdlc 设置Tablix 在新页面重复表头
    .net C# Chart控件的简单使用
    发邮件，阿里云，未指定邮件服务器端口导致的报错
    使用Quartz Job 简单的做一个定时服务
    FromBase64String 输入的不是有效的 Base-64 字符串，因为它包含非 Base-64 字符、两个以上的填充字符，或者填充字符间包含非法字符
  • 原文地址：https://www.cnblogs.com/duanxz/p/4716720.html
Copyright © 2011-2022 走看看