精华内容
下载资源
问答
  • 在这里,我仍旧直接通过例子来解释怎么通过xml装配bean。 xml version="1.0" encoding="UTF-8"?> xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=...

    在这里,我仍旧直接通过例子来解释怎么通过xml装配bean。

    <?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:c="http://www.springframework.org/schema/c"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <!--通过xml装配bean-->
        <!--步骤:
        1.创建XML配置规范(即创建一个SpringXML文档)
        2.声明bean(bean元素类似于JavaConfig中的@Bean注解)
        3.注入bean
        -->
        
        
        <!--如果没有指明id属性,那么会默认为全类名#0,其中“#0”是一个计数的形式,用于区分相同类型的其他bean
        这里建议最好自己设置id属性并指明id属性值
        -->
        <bean id="compactDisc" class="lm.practice.bean.impl.CompactDiscImpl"></bean>
    
        <!--演示借助构造器注入初始化bean-->
        <!--这个bean,当spring遇见的时候,会创建一个CDPlayer的实例,
        constructor-arg会告诉spring要将这个id为compactDisc的bean引用传递到CDPlayer的构造器
        -->
        <bean id="cdPlayer" class="lm.practice.bean.CDPlayer">
            <constructor-arg ref="compactDisc"/>
        </bean>
    
        <!--使用c-命名空间代替constructor-arg-->
        <!--c:cd-ref="compactDisc"
        c:表示c-命名空间前缀
        cd:构造器参数名称
        -ref:注入bean引用
        compactDisc:要注入的bean的id
        ***********************************
        这里要说一下,cd是构造器的参数,可以使用_0或者_直接代替。
        -->
        <bean id="cdPlayerC" class="lm.practice.bean.CDPlayer" c:cd-ref="compactDisc"/>
    
        <!--装配字面量:
        constructor-arg的value属性进行装配字面量
        -->
        <bean id="blankDisc" class="lm.practice.bean.impl.BlankDisc">
            <constructor-arg value="Sgt. Papper's Lonely Heartsub Band"/>
            <constructor-arg value="The Beatles"/>
        </bean>
        
        <!--c命名的方式-->
        <!--<bean id="blankDiscC" class="lm.practice.bean.impl.BlankDisc"-->
              <!--c:_0="Sgt. Papper's Lonely Heartsub Band"-->
              <!--c:_1="The Beatles"/>-->
        <bean id="blankDiscC" class="lm.practice.bean.impl.BlankDisc"
              c:title="Sgt. Papper's Lonely Heartsub Band"
              c:artist="The Beatles"/>
    
        <!--装配集合-->
        <bean id="listDisc" class="lm.practice.bean.impl.ListDisc">
            <constructor-arg value="Sgt. Papper's Lonely Heartsub Band"/>
            <constructor-arg value="The Beatles"/>
            <constructor-arg>
                <list><!--这里也可以使用<set>,使用set不能保证存放顺序和重复值-->
                    <value>Sgt. Papper's Lonely Heartsub Band</value>
                    <value>The Beatles</value>
                </list>
            </constructor-arg>
        </bean>
    </beans>

    相信大家都看得懂这样一个xml,而且我加了详细的注释。

    1.通过xml装配bean,不可置疑的就是必须要有这么一个xml文档,该文档的跟为<beans>。然后在通过在xml文档中配置bean。

    2.<bean>元素就是我们要设置的bean的标记了,id表示这个bean的标识,class表示类全名。这样就设置了一个简单的bean。

    3.创建完bean之后,无可避免的就是注入bean。有两种方式实现构造器注入,一种是通过construtor-arg,一种是通过c-命名空间,这两种方式可以相互替代,但是construtor-arg可以注入集合,c-命名空间暂时不支持集合注入。这里有一些需要说明的地方,就是c-命名空间的c:前缀之后紧跟着的参数,上面的注释中说的很详细,可以是构造器的参数,也可以是_计数(这里之所以加上下划线,是因为数字不允许作为参数的开头)。



    展开全文
  • 大家都知道spring有多重配置方式,基于XML,基于注解,基于java类的配置,其中基于XML是最强大的一种,下面这篇文章主要给大家介绍了关于Spring装配BeanXML安装配置bean的相关资料,需要的朋友可以参考借鉴,下面...
  • Spring IOC 容器可以自动装配Bean。需要做的仅是在<bean>的autowire属性里指定自动装配的模式 byType(根据类型自动装配):若IOC容器有多个与目标Bean类型一致的Bean.在这种情况下,Spring将无法判定哪个Bean...

    Spring IOC 容器可以自动装配Bean。需要做的仅是在<bean>的autowire属性里指定自动装配的模式

    byType(根据类型自动装配):若IOC容器有多个与目标Bean类型一致的Bean.在这种情况下,Spring将无法判定哪个Bean最合适该属性,所以不能执行自动装配。

    byName(根据名称自动装配):必须将目标Bean的名称和属性名设置的完全相同。

    constructor(通过构造器自动装配):当Bean中存在多个构造器时,此种自动装配方式将会很复杂。不推荐使用

    autowire.xml配置文件:是使用了byName去自动装配的。

    <?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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            ">
    
        <bean id="car" class="autowire.Car">
            <property name="carName" value="baoma"></property>
            <property name="carPrice" value="10000.00"></property>
        </bean>
        <bean id="address" class="autowire.Address">
            <property name="city" value="beijing"></property>
            <property name="street" value="zhonghuajie"></property>
        </bean>
        <!--使用autowire自动装配,而与它伴随的是p命名-->
        <bean id="person" class="autowire.Person" p:name="chen" p:age="23" autowire="byName"></bean>
    </beans>
    package autowire;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Main {
        public static void main(String[] args) {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext ("spring1.xml");
            collection.Person person = (collection.Person) applicationContext.getBean ("person");
            System.out.println (person);
        }
    }
    

    Address类的文件

    package autowire;
    
    public class Address {
        public String city;
        public String street;
    
        public String getCity() {
            return city;
        }
    
        public void setCity(String city) {
            this.city = city;
        }
    
        public String getStreet() {
            return street;
        }
    
        public void setStreet(String street) {
            this.street = street;
        }
    
        @Override
        public String toString() {
            return "Address{" +
                    "city='" + city + '\'' +
                    ", street='" + street + '\'' +
                    '}';
        }
    }
    

     

    Car类的文件

    package autowire;
    
    public class Car {
        public String carName;
        public double carPrice;
        public String getCarName() {
            return carName;
        }
    
        public void setCarName(String carName) {
            this.carName = carName;
        }
    
        public double getCarPrice() {
            return carPrice;
        }
    
        public void setCarPrice(double carPrice) {
            this.carPrice = carPrice;
        }
    
        @Override
        public String toString() {
            return "Car{" +
                    "carName='" + carName + '\'' +
                    ", carPrice=" + carPrice +
                    '}';
        }
    }
    

     

    Main类文件:

    package autowire;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Main {
        public static void main(String[] args) {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext ("spring1.xml");
            collection.Person person = (collection.Person) applicationContext.getBean ("person");
            System.out.println (person);
        }
    }
    

     

    输出结果:

    collection.Person{name='chen', age=56, cars=[Car{name='baoma', num=12, color='red', price=0.0}, Car{name='bentian', num=13, color='blue', price=0.0}]}

     

    byType(根据类型自动装配):

    autowire.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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            ">
    
        <bean id="car" class="autowire.Car">
            <property name="carName" value="baoma"></property>
            <property name="carPrice" value="10000.00"></property>
        </bean>
        <bean id="car1" class="autowire.Car">
            <property name="carName" value="bentian"></property>
            <property name="carPrice" value="2000000.00"></property>
        </bean>
        <bean id="address" class="autowire.Address">
            <property name="city" value="beijing"></property>
            <property name="street" value="zhonghuajie"></property>
        </bean>
        <!--使用autowire自动装配,而与它伴随的是p命名-->
        <!--<bean id="person" class="autowire.Person" p:name="chen" p:age="23" autowire="byName"></bean>-->
        <bean id="person" class="autowire.Person"  p:name="chen" p:age="32" autowire="byType"></bean>
    </beans>

     

    其它文件都是与上面一样的。

    总结:

    可以使用autowire属性指定自动装配的方式

    byName 根据bean的名字和当前bean的setter风格的属性名进行自动装配,若有匹配,则进行自动匹配。若没有匹配的,则不装配。

    byType 根据bean的类型和当前bean的属性的类型进行自动装配,若IOC容器中有1个以上的类型匹配的bean,则抛异常。会出现装配的bean不唯一的错误。

     

    展开全文
  • 在上两篇文章中记录了Spring Bean中的配置属性+实例化+作用域+生命周期,此文将Spring Bean的补充Bean装配方式。 这是上两篇链接: Spring5基础(3)——Spring Bean(配置属性+实例化+作用域) Spring5基础(4)——...

    此博客为学习笔记,记录下来怕自己后面学着学着忘记了。 简书内容同步更新,id同名,本文简书链接

    在上两篇文章中记录了Spring Bean中的配置属性+实例化+作用域+生命周期,此文将Spring Bean的补充Bean装配方式。
    这是上两篇链接:
    Spring5基础(3)——Spring Bean(配置属性+实例化+作用域)
    Spring5基础(4)——Spring Bean(生命周期)

    Spring Bean装配方式

    Spring Bean装配即将Bean类依赖注入到Spring IoC容器中,Spring Bean装配方式即Bean的依赖注入方式。
    Bean的装配方式主要有以下三种:

    • 基于xml配置文件的装配方式
    • 基于注解的装配方式
    • 自动装配
      前两种是最主流的装配方式。

    一.使用xml配置文件装配
    之前在
    Spring5基础(2)——Spring IoC控制反转(基础)
    Spring5基础(3)——Spring Bean(配置属性+实例化+作用域)
    中都有相关的例子。
    这种装配方式分为两种:①使用构造方法注入 ②使用属性setter方法注入
    由于之前在Spring5基础(3)——Spring Bean(配置属性+实例化+作用域)一文中有几个bean下的四个子元素没有尝试过(< list >、< map >、< set >、< enty >这四个子元素),所以这里还是尝试写个栗子试试,对同一个类使用构造方法和属性setter方法注入两次。
    对于属性setter注入:需提供无参构造和属性set方法
    当然竟然涉及到list ,map 和 set。就顺便找了几篇博客复习一下:
    java中Map,List与Set的区别

    package com.lipiao.demo;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    public class D {
        private String name;
        private String[] strings;//数组
        private List<String> stringList;//列表
        private Map<String, String> stringStringMap;//映射
        private Set<String> stringSet;//集合
    
        //构造方法注入
        public D(String name, String[] strings, List<String> stringList,
                 Map<String, String> stringStringMap, Set<String> stringSet) {
            this.name = name;
            this.strings = strings;
            this.stringList = stringList;
            this.stringStringMap = stringStringMap;
            this.stringSet = stringSet;
        }
    
        //属性setter注入:需提供无参构造和属性set方法
        public D() {
    
        }
         public void setName(String name) {
            this.name = name;
        }
    
        public void setStrings(String[] strings) {
            this.strings = strings;
        }
    
        public void setStringList(List<String> stringList) {
            this.stringList = stringList;
        }
    
        public void setStringStringMap(Map<String, String> stringStringMap) {
            this.stringStringMap = stringStringMap;
        }
    
        public void setStringSet(Set<String> stringSet) {
            this.stringSet = stringSet;
        }
    }
    
     <!--    构造注入-->
        <bean id="D1" class="com.lipiao.demo.D">
    
        </bean>
    

    **首先使用构造方法注入:88
    填写完bean类的基本信息之后按下快捷键alt+enter,选择第一个,IDEA便会自动根据bean类进行内容补全,如下所示:
    快捷注入
    自动补全如下:< list >、< map >、< set >、< enty >这四个子元素的使用也就一目了然了。

    <!--    构造注入-->
        <bean id="D1" class="com.lipiao.demo.D">
    
            <constructor-arg index="0" value=""/>
            <constructor-arg index="1">
                <list>
                    <value></value>
                </list>
            </constructor-arg>
            <constructor-arg index="2">
                <list>
                    <value></value>
                </list>
            </constructor-arg>
            <constructor-arg index="3">
                <map>
                    <entry key="" value=""/>
                </map>
            </constructor-arg>
            <constructor-arg index="4">
                <set>
                    <value></value>
                </set>
            </constructor-arg>
        </bean>
    

    这样就能直接填写初始数据就好啦。

     <!--    构造注入-->
        <bean id="D1" class="com.lipiao.demo.D">
    
            <constructor-arg index="0" value="构造方法注入name"/>
            <constructor-arg index="1">
                <list>
                    <value>构造方法注入strings元素一</value>
                    <value>构造方法注入strings元素二</value>
                </list>
            </constructor-arg>
            <constructor-arg index="2">
                <list>
                    <value>构造方法注入stringList元素一</value>
                    <value>构造方法注入stringList元素二</value>
                </list>
            </constructor-arg>
            <constructor-arg index="3">
                <map>
                    <entry key="element1" value="构造方法注入stringStringMap元素一"/>
                    <entry key="element2" value="构造方法注入stringStringMap元素二"/>
                </map>
            </constructor-arg>
            <constructor-arg index="4">
                <set>
                    <value>构造方法注入stringSet元素一</value>
                    <value>构造方法注入stringSet元素二</value>
                </set>
            </constructor-arg>
        </bean>
    

    接下来看看setter属性注入
    同样是上边的D类,已经为所有属性都写了setter方法。
    对于属性setter注入:需提供无参构造和属性set方法
    xml中使用< property > 元素为变量提供初始值,如下所示:
    setter注入

        <!--属性setter注入-->
        <bean id="D2" class="com.lipiao.demo.D">
            <property name="name" value="属性setter注入name"/>
            <property name="strings">
                <array>
                    <value>属性setter注入strings元素一</value>
                    <value>属性setter注入strings元素二</value>
                </array>
            </property>
            <property name="stringList">
                <list>
                    <value>属性setter注入stringList元素一</value>
                    <value>属性setter注入stringList元素二</value>
                </list>
            </property>
            <property name="stringStringMap">
                <map>
                    <entry key="element1" value="属性setter注入stringStringMap元素一"/>
                    <entry key="element2" value="属性setter注入stringStringMap元素二"/>
                </map>
            </property>
            <property name="stringSet">
                <set>
                    <value>构造方法注入stringSet元素一</value>
                    <value>构造方法注入stringSet元素二</value>
                </set>
            </property>
        </bean>
    

    当有大量的Bean需要注入时,使用xml配置文件装配难免会将xml文件写的很长,难于后期维护。
    这时更推荐使用注解装配。
    下一篇文章将记录注解装配的学习笔记与编程案例。

    展开全文
  • Bean配置文件里设置autowire属性进行自动装配将会装配Bean的所有属性,然而,若只希望装配个别属性时,autowire属性就不够灵活了。 autowire属性要么根据类型自动装配,要么根据名称自动装配,不能两者兼而得之。...

    在Bean配置文件里设置autowire属性进行自动装配将会装配Bean的所有属性,然而,若只希望装配个别属性时,autowire属性就不够灵活了。

    autowire属性要么根据类型自动装配,要么根据名称自动装配,不能两者兼而得之。

    一般情况下,在实际的项目中很少使用自动装配功能,因为和自动装配功能所带来的好处比起来,明确清晰的配置文档更有说服力一些。

    展开全文
  • Spring Bean xml显式装配之构造函数

    千次阅读 2017-05-30 22:23:57
    对于喜欢用xml配置文件来说,xml装配bean 例子还是老师注入学生bean 1.老师和学生接口 package com.jack.bean.chatpter2.autowiredBeanJava; public interface Student { void learn(); } package ...
  • Bean装配可以理解为依赖关系注入,Bean装配方式有三种。如:基于XML装配,基于注解的装配和自动装配(其中最常用的是基于注解的装配),今天就来练习基于XML装配 而Spring提供了两种基于XML装配方式:设...
  • 通过属性的setter方法名和配置bean的ID自动匹配,注意是用setter方法和bean匹配,不是属性去匹配。 Person类 package com.yusys.spring; public class Person { private String name; private int age; ...
  • spring的三大特性spring...在代码中可以使用注解或在xml文件用装配bean。以这种低入侵的方式为应用程序提供实例化对象。 DI:依赖注入,是IOC的一种重要实现 一个对象的创建往往需要依赖另一个对象,比如对象A有一个
  • 文章目录Spring Bean一、Bean配置二、Bean的实例化1、构造方法实例化2、静态工厂实例化3、实例工厂实例化三、Bean的作用域1、singleton作用域2、prototype作用域四、Bean的生命周期五、Bean装配方式1、基于XML...
  • 本系列博客为spring In Action 这本书的学习笔记在之前的两篇博客里我们说完了自动装配和通过Java代码装配Bean, 这篇博文里我们将介绍最后一种装配Bean的方式 — 通过XML装配.1. 创建一个XML配置文件和上一篇通过...
  • XML配置方式 一、三种实例化Bean的方式 1.使用类构造器实例化(默认无参数) 2.使用静态工厂方法实例化  class="com.itcast.factory.PersonServiceFactory"  factory-method="createPersonService" /> ...
  • Spring的自动装配,也就是定义bean的时候让spring自动帮你匹配到所需的bean,而不需要我们自己指定了。例如:User实体类里面有一个属性role1234567public class User { private int id; private String username;...
  • 虽然项目中常用的是通过注解的方式装配bean,但是XML文件配置作为最初的配置方式,对于Spring学习者来说,还是很有必要了解一下的。
  • 1.使用xml装配Bean对象   在applicationContext.xml文件中使用<bean></bean>标签进行装配。class中写要装配的Bean对象的全类名,id中写该Bean对象的唯一标识。 说明:<bean></bean>标签...
  • 文章目录Bean装配方式基于XML装配基于注解(Annotation)的装配自动装配 IoC是Spring框架的核心内容,使用多种方式完美的实现了IoC,可以使用XML配置,也可以使用注解,新版本的Spring也可以零配置实现IoC。 ...
  • Spring(四)基于XML装配bean(实例化方式)

    千次阅读 2016-12-06 16:02:30
    基于xml装配bean 的实例化方式共有三种 1.默认构造 2.静态工厂 3.实例化工厂 1默认构造1.1 说明 用于生成实例化对象,必须未重写bean的默认构造方法。 1.2 xml配置<bean id="" class=""> 必须提供默认构造方法...
  • Spring 装配Bean 基于XML

    千次阅读 2017-06-03 16:39:04
    基于xml装配Bean -实例化方式使用一个或者多个xml作为配置文件,Spring配置文件的根元素是。 bean的实例化方式有3种:默认构造、静态工厂、实例工厂(1)默认构造 <bean id="" class="">(2)静态工厂 常用与...
  • 一、@Component 用注解来装配bean ...二、bean.xml配置@Componet方式装配bean 1、开启注解装配bean依赖注入方式和类使用的自动注入 2、 其中,通过类型获取对象时候,传入接口类和接口的实现类都...
  • 而是引用了第三方的类库,这个时候自动装配便无法实现,Spring对此也提供了相应的解决方案,那就是通过显示的装配机制——Java配置XML配置的方式来实现bean装配。作者:陈本布衣 出处:...
  • 里面定义autowire属性可以完成自动装配Bean <bean id="admin" class="com.yuan.Admin" autowire="byName" /> 关于自动装配有五种: <1>,直接使用ref属性 <bean id="admin" class=...
  • 用spring的时候需要一个bean容器来管理所有的bean,所有bean默认是写在applicationContext.xml里的。 当然如果是几个人同时合作完成一个工程的话,也可以每人有一个xml配置文件,最后在applicationContext.xml一起...
  • 对于小的程序来说,在XML配置bean数目很少。但是如果对于一个大一点的应用,需要在XML配置很多的bean。那么有没有简化XML配置的方法呢,Spring为我们提供了这个机制,现在就讲几种简化XML配置的方法。 装配一...
  • 在java的大多数开源框架中,都是会使用xml文件惊醒配置框架在项目中的使用,这样
  • 2 装配Bean概述 大部分场景下,都会使用ApplicationContext的具体实现类,因为其对应的SpringIOC容器功能相对强大....  第一优先级:基于约定优于配置的原则,最优先的应该是通过隐式Bean的发现机制和自动装配的原则.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,362
精华内容 22,144
关键字:

beanxml怎么装配配置