精华内容
下载资源
问答
  • bean的装配方式
    2021-11-14 18:00:13

    Bean的装配可以理解为依赖关系注入,Bean的装配方式即Bean的依赖注入的方式。

    Spring容器支持多种形式的Bean的装配方式,如基于XML的装配基于注解的装配自动装配等。其中最常用的是基于注解的装配。

    基于XML的装配

    Spring提供了两种基于XML的装配方式:设值注入构造注入

    Spring实例化Bean的过程中,Spring首先会调用Bean的默认构造方法来实例化Bean对象,然后通过反射的方式调用setter方法来注入属性值。

    设值注入:

    • Bean类必须提供一个默认的无参构造方法
    • Bean类必须为需要注入的属性提供对应的setter方法
    • 在配置文件中,需要使用 <property>元素为每个属性注入值

    构造注入

    • Bean类必须提供有参构造方法
    • 在配置文件中,需要使用<constructor-arg>元素来定义构造方法的参数,也可以使用其value属性来设置该参数的值

    基于注解的装配

    Spring中定义了一系列的注解,常用的注解如下:

    • @Component:描述Spring中的Bean,可以作用在任何层次
    • @Repository:用于将持久层(Dao层)的类标识为Spring中的Bean
    • @Service:用于将业务层(Service层)的类标识为Spring中的Bean
    • @Controller:用于将控制层(Controller层)的类标识为Spring中的Bean
    • @Autowired:用于对Bean的属性变量、属性的setter方法以及构造方法进行标注,配合对应的注解处理器完成Bean的自动装配工作。默认按照Bean的类型进行装配
    • @Resource:其作用与@Autowired一样。其区别在于@Autowired默认Bean的类型装配,而@Resource默认按照Bean的实例名称进行装配

    @Resource中有两个重要属性:nametype。Spring将name属性解析为Bean实例名称type属性解析为Bean实例类型。如果指定name属性,则按实例名称进行装配;如果指定type属性,则按Bean类型进行装配;如果都不指定,则先按Bean的实例名称装配,如果不能匹配,再按照Bean类型进行装配;如果都无法匹配,则抛出 NoSuchBeanDefinitionException异常。

    • @Qualifier:与@Autowired注解配合使用,会将默认的按Bean类型装配修改为Bean的实例名称装配,Bean的实例名称由 @Qualifier注解的参数指定
    @Repository("accountDao")
    public class AccountDaoImpl implements AccountDao {
    
    }
    @Service("accountService")
    public class AccountServiceImpl implements AccountService {
      
         @Resource(name="accountDao")
         private AccountDao accountDao; 
    
    }

    此时,在配置文件中,Spring注解提供了另外一种高效的注解配置方式。

    含义是:告知Spring在创建容器时要扫描的包(通知Spring扫描指定包下的所有Bean)

    
        <context:component-scan base-package="cn.itcast"></context:component-scan>

    自动装配 

    自动装配:将一个Bean自动地注入到其他Bean的Property中

    Spring的 <bean>元素中包含一个 autowire 属性,我们可以通过设置 autowire 的属性值来自动装配Bean。

    autowire属性的5个值:

    • default默认):由<beans>的default-autowire属性值来确定。
    • byName根据属性的名称自动装配。容器将根据名称查找与属性完全一致的Bean,并将其属性自动装配
    • byType根据属性的数据类型自动装配
    • constructor根据构造函数参数的数据类型,进行byType模式的自动装配
    • no:在默认情况下,不使用自动装配,Bean依赖必须通过ref元素定义

    更多相关内容
  • 主要给大家介绍了关于spring装配bean的3种方式,文中通过示例代码介绍的非常详细,对大家的学习或者使用Spring具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 学习内容:Bean装配方式 1.

    学习内容:Bean的装配方式

    1. 装配Bean的概述

    Bean的装配可以理解为依赖关系注入,Bean的装配方式,即Bean的依赖注入方式。Spring容器支持多种形式的Bean的装配方式:

    • 在XML中显式配置(基于XML的装配)
    • 在Java的接口和类中实现配置(利用java代码和注解实现装配)
    • 隐式Bean的发现机制和自动装配原则(基于注解的装配和自动装配)
        在显示的开发中,这3中方式都会被用到,并且在学习和工作中常常混合使用,因此需要我们明白这三种方式的优先级,即我们应该如何选择使用哪种方式去把Bean发布到Spring IoC容器中。

    第一,基于“约定优于配置”的原则,最优先的应该是通过隐式Bean的发现机制和自动装配的原则。这样的好处是减少程序开发者的决定权,简单又不失灵活。

    第二,在没有办法使用自动装配原则的情况下应该优先考虑Java接口和类中实现配置,这样的好处是避免XML配置的泛滥,也更为容易。这种场景典型的例子是一个父类有多个子类,比如学生类有两个子类:男生类和女生类,通过IoC容器初始化一个学生类,容器将无法知道使用哪个子类去初始化,这个时候可以使用Java的注解配置去指定。

    第三,在上述方法都无法使用的情况下,那么只能选择XML去配置Spring IoC容器。由于现实开发中常常用到第三方类库,有些类并不是我们开发的,我们无法修改里面的代码,这个时候就通过XML的方式配置使用了。

    通俗来讲,当配置的类时你自身正在开发的工程,那么应该考虑Java配置为主,而Java配置又分为自动装配和Bean名称配置。在没有歧义的基础上,优先使用自动装配,这样就可以减少大量的XML配置。如果所需配置的类并不是你的工程开发的,那么建议使用XML的方式。

    2. 基于XML的装配

    Spring主要提供俩种基于XML的装配:设值注入(Set方式注入)(Setter Injection)和构造器注入(Constructor Injection)
    在Spring实例化Bean的过程中,Spring首先会调用Bean的默认构造方法来实例化Bean对象,然后通过反射的方式调用setter()方法来注入属性值。因此,Set方式注入要求一个Bean必须满足一下要求:

    • Bean类必须提供一个默认的无参构造方法。
    • Bean类必须为需要注入的属性提供对应的setter()方法

    设值注入:Spring配置文件中需要使用<bean>元素的子元素<property>来为每个属性注入值。
    构造注入:Spring配置文件中需要使用<bean>元素的子元素<constructor-arg>来定义构造方法的参数,可以使用其value属性来设置参数的值。

    Set注入和构造器注入详情请见学习笔记“依赖注入”,点这里跳转

    3. 基于注解的装配

    尽管可以使用XML配置文件来实现Bean的装配工作,但如果Bean过多,就会导致XML配置文件过于臃肿,会对以后的维护和升级工作带来一定困难。故此,Spring提供了对Annotation(注解)技术的支持。

    @Component有几个衍生注解,我们在web开发中,会按照mvc三层架构分层!

    • dao 【@Repository
    • service 【@Service
    • controller 【@Controller
      这四个注解功能都是一样的,都是代表将某个类注册到Spring中,装配Bean

    Spring的常用注解:

    注解名称说明
    @Component可以使用此注解Spring中的Bean,但它只是一个泛化的概率,仅表示一个组件(Bean),并且可以作用在任何层次。使用时只需要将需标注在相应类上即可
    @Repository用于将数据访问层(Dao层)的类标识为Spring中的Bean,其功能与@Component相同
    @Service作用于业务层(Service层)的类标识为Spring中的Bean,其功能与@Component相同
    @Controller作用于控制层(如SpringMVC的Controller)的类标识为Spring中的Bean,其功能与@Component相同
    @Autowired用于对Bean的属性变量,属性的setter()方法及构造方法进行标注,配合对应的注解处理器完成Bean的指定配置工作,按照Bean的类型进行装配
    @Resource作用与@Autowired一样,区别在于@Autowired默认按照Bean类型装配,而@Resource默认按照Bean实例名称进行装配
    @Qualifier与@Autowired注解配合使用,将默认的Bean类型装配修改为按Bean的实例名称装配,Bean的实例名称由@Qualifier注解的参数指定

    在Spring4之后,要使用注解开发,必须要保证AOP包已经导入了
    在这里插入图片描述
    使用注解需要导入context约束,增加注解的支持!

    • applicationContext.xml
    <!--导入context约束
    xmlns:context="http://www.springframework.org/schema/context"
    注意以下代码要写在xsi:schemaLocation=""引号中
    http://www.springframework.org/schema/context
    https://www.springframework.org/schema/context/spring-context.xsd
    -->
    <?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:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">
    
        <!--开启注解的支持-->
        <context:annotation-config/>
    
        <!--此处与XML配置方式有所不同的是,这里不需要配置子元素property-->
        <bean id="user" class="pojo.User"/>
    
        <!--此处拥有更高效的注解配置方式,对包路径下的所有Bean文件进行扫描,可替换bean,但所有类和xml配置文件得在同一个文件夹中-->
        <!--指定要扫描的包,这个包下的的注解就会生效-->
        <!--    <context:component-scan base-package="pojo"/>-->
    </beans>
    
    • User.java
    import lombok.Data;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Scope;
    import org.springframework.stereotype.Component;
    
    @Data //lombok的注解
    @Component//相当于配置文件中的:<bean id="user" class="pojo.User"/>
    @Scope("prototype")//这个是设置作用域的
    public class User {
        @Value("pym")//相当于配置文件中bean标签中的:<property name="name" value="pym"></property>
        public String name;
    }
    
    • 测试类
    public class MyTest {
        @Test
        public void test(){
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            User user = context.getBean("user", User.class);
            System.out.println(user.getName());
        }
    }
    

    结果:在这里插入图片描述

    4. 自动装配

    虽然使用注解方式装配Bean在一定程度上减少了配置文件中的代码量,但也有不少项目是不使用注解开发的,那有没有什么方法既能减少代码量,又能实现Bean的装配呢?当然有。Spring的<bean>元素中包含一个autowired的属性,我们可以设置autowired的属性值来自动装配Bean。

    例子:

    • 创建三个实体类:
    public class Cat {
        public void shout(){
            System.out.println("喵喵~~");
        }
    }
    
    public class Dog {
        public void shout(){
            System.out.println("汪汪~~");
        }
    }
    
    @Data //lombok注解
    public class People {
        private Cat cat;
        private Dog dog;
        private String name;
        @Override
        public String toString() {
            return "People{" +
                    "cat=" + cat +
                    ", dog=" + dog +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    
    • applicationContext.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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="cat" class="pojo.Cat"/>
        <bean id="dog" class="pojo.Dog"/>
        <!--
            byName:会自动在容器上下文中查找,和自己对象set方法后面的值对应的bean的id!
            	(弊端:必须名字相同,但是set方法后面名字是大写,这里用小写可以,但是用大写不行)
            	
            byType:会自动在容器上下文中查找,和自己对象属性类型相同的bean!
            	(弊端:必须保证这个类型全局唯一,如果有两个就不行了)
        -->
        <!--byName-->
        <bean id="people" class="pojo.People" autowire="byName">
            <property name="name" value="pym"/>
        </bean>
    
    		<!--byType-->
    <!--    <bean id="people" class="pojo.People" autowire="byType">-->
    <!--        <property name="name" value="pym"/>-->
    <!--    </bean>-->
    
    </beans>
    
    • 测试类
    public class MyTest {
        @Test
        public void test(){
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            People people = context.getBean("people", People.class);
            people.getCat().shout();
            people.getDog().shout();
    
        }
    }
    

    结果:
    在这里插入图片描述
    小结:

    1. 当一个bean节点带有 autowire byName的属性时。
    2. 将查找其类中所有的set方法名,例如setCat,获得将set去掉并且首字母小写的字符串,即cat。
    3. 去spring容器中寻找是否有此字符串名称id的对象。如果有,就取出注入;如果没有,就报空指针异常.
    4. 使用autowire byType首先需要保证:同一类型的对象,在spring容器中唯一。如果不唯一,会报不唯一的异常。

    5. 使用注解实现自动装配

    @Autowired

    • @Autowired是按类型自动装配的,不支持id匹配。
    • 需要导入 spring-aop的包!
    • 直接在属性上用即可!也可以在set方式上使用!使用Autowired我们可以不用使用Set方法了,前提是你这个自动装配的属性在IOC(Spring)容器中存在且符合名字(IOC容器中的id和属性名相同)

    以4中例子为例:

    • 实体类(Cat、Dog类不变,People做以下修改)
    public class People {
    
    //如果显式的定义了AutoWired的required属性为false,说明这个对象可以为null,否则不允许为空
    //    @Autowired(required = false)
        @Autowired
        private Cat cat;
        @Autowired
        private Dog dog;
        private String name;
    
        @Override
        public String toString() {
            return "People{" +
                    "cat=" + cat +
                    ", dog=" + dog +
                    ", name='" + name + '\'' +
                    '}';
        }
        //使用Autowired我们可以不用使用Set方法了
        public Cat getCat() {
            return cat;
        }
        public Dog getDog() {
            return dog;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
    
    • applicationContext.xml
    <!--导入context约束
    xmlns:context="http://www.springframework.org/schema/context"
    注意以下代码要写在xsi:schemaLocation=""引号中
    http://www.springframework.org/schema/context
    https://www.springframework.org/schema/context/spring-context.xsd
    -->
    <?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:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">
    
        <!--开启注解的支持-->
        <context:annotation-config/>
    
        <bean id="cat" class="pojo.Cat"/>
        <bean id="dog" class="pojo.Dog"/>
    
    	<bean id="people" class="pojo.People"/>
    </beans>
    
    • 测试类
    public class MyTest {
        @Test
        public void test(){
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            People people = context.getBean("people", People.class);
            people.getCat().shout();
            people.getDog().shout();
    
        }
    }
    

    结果和4中一样。

    补充:

    @Autowired:自动装配通过类型、名字
    如果Autowired不能唯一自动装配上属性,则需要通过@Qualifier(value="xxx")
    @Nullable:字段标记了这个注解,说明这个字段可以为null
    @Resource:自动装配通过名字、类型
    @Component:自动装配通过名字、类型
    

    @Qualifier

    • @Autowired是根据类型自动装配的,加上@Qualifier则可以根据byName的方式自动装配
    • @Qualifier不能单独使用。

    测试:
    (1)配置文件修改内容,保证类型存在对象。且名字不为类的默认名字!

    
    <bean id="dog1" class="pojo.Dog"/>
    <bean id="dog2" class="pojo.Dog"/>
    <bean id="cat1" class="pojo.Cat"/>
    <bean id="cat2" class="pojo.Cat"/>
    

    (2)在属性上添加Qualifier注解

    @Autowired
    @Qualifier(value = "cat2")
    private Cat cat;
    
    @Autowired
    @Qualifier(value = "dog2")
    private Dog dog;
    

    @Resource

    • @Resource如有指定的name属性,先按该属性进行byName方式查找装配;
    • 其次再进行默认的byName方式进行装配;
    • 如果以上都不成功,则按byType的方式自动装配。
    • 都不成功,则报异常。

    测试一:
    实体类:

    public class User {
        //如果允许对象为null,设置required = false,默认为true
        @Resource(name = "cat2")
        private Cat cat;
        @Resource
        private Dog dog;
        private String str;
    }
    
    • beans.xml
    <bean id="dog" class="com.kuang.pojo.Dog"/>
    <bean id="cat1" class="com.kuang.pojo.Cat"/>
    <bean id="cat2" class="com.kuang.pojo.Cat"/>
    <bean id="user" class="com.kuang.pojo.User"/>
    

    测试,因为有指定的name属性,所以按该属性进行byName方式查找装配。成功。

    测试二:
    实体类上只保留注解:

    @Resource
    private Cat cat;
    @Resource
    private Dog dog;
    
    • beans.xml
    <bean id="dog" class="com.kuang.pojo.Dog"/>
    <bean id="cat1" class="com.kuang.pojo.Cat"/>
    <bean id="user" class="com.kuang.pojo.User"/>
    

    测试:先进行byName查找,失败;再进行byType查找,成功。

    小结
    @Autowired@Resource异同:

    1、@Autowired@Resource都可以用来装配bean。都可以写在字段上,或写在setter方法上。

    2、@Autowired默认按类型装配(属于spring规范),默认情况下必须要求依赖对象必须存在,如果要允许null 值,可以设置它的required属性为false,如:@Autowired(required=false) ,如果我们想使用名称装配可以结合@Qualifier注解进行使用

    3、@Resource(属于J2EE复返),默认按照名称进行装配,名称可以通过name属性进行指定。如果没有指定name属性,当注解写在字段上时,默认取字段名进行按照名称查找,如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是,如果name属性一旦指定,就只会按照名称进行装配。

    它们的作用相同都是用注解方式注入对象,但执行顺序不同。@Autowired先byType,@Resource先byName。

    6. 使用Java的方式配置Spring

    现在要完全不使用Spring的xml配置了,全权交给Java来做!
    JavaConfig是Spring的一个子项目,在Spring4之后,它成为了一个核心功能

    • 实体类
    //这里这个注解的意思,就是说明这个类被Spring接管了,注册到了容器中
    @Component
    public class User {
        private String name;
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    '}';
        }
        public String getName() {
            return name;
        }
        @Value("Serein")
        public void setName(String name) {
            this.name = name;
        }
    }
    
    • 配置文件
    import pojo.User;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Import;
    
    //这个也会被Spring容器托管,注册到容器中,因为它自身就是一个@Component,
    // @Configuration代表这是一个配置类,就和我们之前看的beans.xml一样
    @Configuration
    @Import(Config2.class)//相当于Spring配置中的import
    public class Config {
    
        //注册一个bean,就相当于我们之前写的一个bean标签
        //这个方法的名字,就相当于bean标签中的ID属性
        //这个方法的返回值,就相当于bean标签中的class属性
        @Bean
        public User getUser(){
            return new User();//就是返回要注入到bean的对象
        }
    }
    
    • 测试类
    public class MyTest {
        public static void main(String[] args) {
            //如果完全使用了配置类方式去做,我们就只能通过AnnotationConfig上下文来获取容器,通过配置类的class对象加载!
            ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
            User getUser = (User) context.getBean("getUser");
            System.out.println(getUser.getName());
        }
    }
    
    展开全文
  • 本篇文章主要介绍了 Spring的自动装配Bean的三种方式,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了Spring Bean常用的的装配方式详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Spring中Bean的三种装配方式

    千次阅读 2020-04-25 15:00:12
    Spring容器支持多种形式的Bean装配方式,如**基于XML的装配**、基于**Annotation(注解)**的装配和 自动装配 等。 说明: xml配置代码量较大,实际开发中使用的不是很多。 最常用的还是注解开发及自动装配。 二、...

    一、简介

    Bean的装配可以理解为依赖关系注入,Bean的装配方式即Bean依赖注入的方式。

    Spring容器支持多种形式的Bean装配方式,如基于XML的装配、基于Annotation(注解)的装配和 自动装配 等。
    说明:
    xml配置代码量较大,会使程序变得很臃肿,因此实际开发中使用的不是很多。
    最常用的还是注解开发及自动装配。

    二、三种装配方式

    2.1基于XML的装配

    在Spring实例化Bean的过程中,Spring首先会调用Bean的默认构造方法来实例化Bean对象,然后通过反射的方式调用setter()方法来注入属性值。
    因此,设值注入要求一个Bean必须满足以下两点要求

    • Bean类必须提供一个默认的无参构造方法。
    • Bean类必须为需要注入的属性提供对应的setter()方法。

    使用设值注入时,在Spring配置文件中需要使用<bean>元素子元素<property>为每个属性注入值;而使用构造注入时,在配置文件中需要使用<bean>元素子元素<constructor-arg>来定义构造方法的参数,可以使用其value属性(或子元素)来设置该参数的值。

    (1)src目录下创建一个com.ssm.assemble包,在该包中创建User类,并在类中定义userId、userName和list集合3个属性及对应的setter()方法,

    package com.zbw.assemble;
    
    import java.util.List;
    
    public class User {
        private int userId;
        private String userName;
        private List<String> list;
        
        /**
         *1、使用构造注入
         *1.1、提供带有所有参数的构造方法
         */
        public User(int userId, String userName, List<String> list) {
            this.userId = userId;
            this.userName = userName;
            this.list = list;
        }
        
        /**
         * 2.使用设值注入
         * 2.1提供默认空参构造方法
         * 2.2为所有属性提供setter()方法
         */
        public User() {
        }
    
        public void setUserId(int userId) {
            this.userId = userId;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public void setList(List<String> list) {
            this.list = list;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "userId=" + userId +
                    ", userName='" + userName + '\'' +
                    ", list=" + list +
                    '}';
        }
    }
    

    (2)在Spring的配置文件application.xml(文件2.2)中,增加通过构造注入和设值注入的方法装配User实例的两个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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="user1" class="com.zbw.assemble.User">
            <constructor-arg name="userId" value="111"/>
            <constructor-arg name="userName" value="张三"/>
            <constructor-arg name="list">
                <list>
                    <value>list_constructor_value1</value>
                    <value>list_constructor_value2</value>
                </list>
            </constructor-arg>
        </bean>
    
        <bean id="user2" class="com.zbw.assemble.User">
            <property name="userId" value="222"/>
            <property name="userName" value="李四"/>
            <property name="list">
                <list>
                    <value>list_value1</value>
                    <value>list_value2</value>
                </list>
            </property>
        </bean>
    
    </beans>
    

    在上述代码中,
    <constructor-arg>元素用于定义构造方法的参数,其属性name与对象的属性相对应,value属性用于设置注入的值,其子元素<list>为User类中对应的list集合属性注入值

    然后又使用设值注入方法装配User类的实例,其中<property>元素用于调用Bean实例中的
    setter()方法完成属性赋值,从而完成依赖注入,而其子元素<list>同样为User类中对应的list集合属性注入值。

    (3)测试

    package com.zbw.assemble;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class XmlAssembleTest {
        public static void main(String[] args) {
            
            //1、初始化Spring容器,加载配置文件
            ApplicationContext context 
                    = new ClassPathXmlApplicationContext("application.xml");
    
            //2、输出获得的实例
            System.out.println(context.getBean("user1"));
            System.out.println(context.getBean("user2"));
        }
    }
    

    (4)结果
    在这里插入图片描述

    2.2 Annotation装配与自动装配

    通过实例理解 Spring中Annotation装配与自动装配

    展开全文
  • Spring装配Bean方式和依赖注入的方式 装配Bean方式 1.通过注解自动化装配Bean 使用@Component注解Bean,使用@ComponentScan注解配置类 @Component public class MyBean { } ------------------------------------...

    Spring装配Bean的方式和依赖注入的方式

    装配Bean的方式

    1.通过注解自动化装配Bean
    使用@Component注解Bean,使用@ComponentScan注解配置类

    @Component
    public class MyBean {
    }
    ----------------------------------------------------------------
    @Configuration
    @ComponentScan
    public class MyConfig {
    }
    
    

    2.通过Java代码装配Bean

    @Configuration
    public class MyConfig {
        @Bean
        public MyBean getMyBean(){
            return new MyBean();
        }
    }
    

    3.通过XML文件装配Bean

     <bean id="myBean1" class="com.spring.springMVC.new_test.MyBean">
     </bean>
    
    @Configuration
    @ImportResource("classpath:test.xml")
    public class MyConfig {
    }
    

    依赖注入的方式

    注解方式
    1.构造器注入

    public class MyContext {
        public MyBean myBean;
    
        @Autowired
        public MyContext(MyBean myBean) {
            this.myBean = myBean;
        }
    }
    
    

    2.方法注入

    public class MyContext {
    
        public MyBean myBean;
    
        @Autowired
        public void setMyBean(MyBean myBean) {
            this.myBean = myBean;
        }
    }
    

    3.field变量注入

    public class MyContext {
        @Autowired
        private MyBean myBean;
    }
    

    XML文件方式
    1.构造器注入
    2.Setter方法注入
    3.静态工厂注入
    4.实例工厂注入

    接口注入
    接口注入模式因为历史较为悠久,在很多容器中都已经得到应用。但由于其在灵活性、易用性上不如其他两种注入模式,因而在 IOC 的专题世界内并不被看好。

    展开全文
  • Spring中Bean装配方式

    千次阅读 2018-03-21 09:04:09
    Bean装配可以理解为依赖关系注入Bean装配方式Bean依赖注入的方式.Spring容器支持多种形式的Bean装配方式,如基于XML的装配、基于注解(Annotation)的装配和自动装配(其中最常用的是基于注解的装配),接...
  • 主要介绍了spring boot中的条件装配bean的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 但是如果应用中有很多Bean将会使XML过于臃肿,给后续的维护和升级带来很大困难,为此Spring提供了对Annotation(注解)技术的全面支持,(注解也是Spring中实现Bean装配时最经常使用的) Spring中定义了一系列的...
  • Spring容器支持多种装配方式XML配置,注解,Java配置等多种装配方式,其中基于注解的装配是最受欢迎的。Spring提供了两种XML装配方式,构造方法注入和setter方法注入: 构造方法注入装配Bean时,Bean的实现类需要...
  • 在前面的例子中我们就可以看到了使用基于XML方式的缺点了:如果应用中有较多的Bean对象,则会导致xml文件过于臃肿,给后续的维护和升级工作造成困难。为此Spring提供了基于注解的方式。这也是我们最常使用的方式 ...
  • Spring中的依赖注入的三种方法 基于构造方法 setter注入(常用) 接口注入(不常用) Bean如下 package spring; public class Role { private Long id; private String roleName; private String n...
  • spring 自动装配 bean 有哪些方式? spring 配置文件中 节点的 autowire 参数可以控制 bean 自动装配方式 default - 默认的方式和 “no” 方式一样 no - 不自动装配,需要使用 节点或参数 byName - 根据名称进行...
  • Bean装配方式--注解装配

    千次阅读 2017-11-21 18:44:01
    1、 UserDao接口public interface UserDao { public void save();...相当于配置<bean id="userDao" class="link.UserDaoImpl" /> */ @Repository("userDao") public class UserDaoImpl implements UserDao
  • 大家都知道spring有多重配置方式,基于XML,基于注解,基于java类的配置,其中基于XML是最强大的一种,下面这篇文章主要给大家介绍了关于Spring装配Bean之XML安装配置bean的相关资料,需要的朋友可以参考借鉴,下面...
  • 众所周知Spring里面的bean就类似是定义的一个组件,而这个组件的作用就是实现某个功能的,下面这篇文章主要给大家介绍了关于spring入门教程之bean继承与自动装配的相关资料,需要的朋友可以参考借鉴,下面随着小编来...
  • Spring 装配包括手动装配和自动装配,手动装配是有基于 xml 装配、构造方法、setter 方法等自动装配有五种自动装配方式,可以用来指导 Spring 容器用自动装配方式来进行依赖注入。 五种: no:默认的方式是不进行...
  • 2.5.2 基于Annotation的装配 基于Annotation装配的使用方式如下: JDBC驱动器:由数据库厂商创建,也称为JDBC驱动程序。负责与特定的数据库连接,以及处理通信细节。 创建接口UserDao,并定义方法; 创建接口实现类...
  • Spring中bean有三种装配方式: 1.在xml文件中显式配置。(前面介绍IOC和DI的博客已经详细介绍了) 2.在Java中显式配置。 3.隐式的bean自动装配。(本篇博客重点) bean自动装配方式: 一、byName方式 修改bean配置,...
  • spring自动装配Bean的五种方式

    千次阅读 2019-03-19 19:11:35
    no:默认方式,手动装配方式,需要通过ref设定bean的依赖关系 byName:根据bean的名字进行装配,当一个bean的名称和其他bean的属性一致,则自动装配 byType:根据bean的类型进行装配,当一个bean的属性类型与其他...
  • Spring提供了三种装配bean方式

    千次阅读 2018-11-21 20:37:02
    1.Spring提供了三种装配bean方式: 2.自动装配bean: 3.通过Java代码装配bean 4.通过XML装配bean     前言:创建对象的协作关系称为装配,也就是DI(依赖注入)的本质。而在Spring容器中对bean的创建时就...
  • Spring 有多种装配 bean方式,最初学习的应该是在 xml 配置文件中装配 bean,而实际项目中最常用的当然是简单方便的自动扫描了。本文主要是记录一下通过 .java 配置类装配 bean 的三种方式。 @toc ...
  • 主要给大家介绍了关于Spring装配Bean之用Java代码安装配置bean的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用spring具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧。
  • 主要介绍了Spring自动装配Bean实现过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 183,179
精华内容 73,271
关键字:

bean的装配方式