Spring-基于注解的配置[02自动装载bean]

最新推荐文章于 2022-08-11 08:57:20 发布
最新推荐文章于 2022-08-11 08:57:20 发布
阅读量1.1w 收藏 1
点赞数 2
分类专栏： 【Spring-IOC】 文章标签： bean spring 自动注入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangshangwei/article/details/75907180
版权

使用@Autowired进行自动注入

Spring通过@Autowired注解实现Bean的依赖注入。

@Autowired默认按照类型（byType）匹配的方式在容器中查找匹配的Bean，当且仅有一个匹配的Bean时，Spring将其注入@Autowired标注的变量中。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Pilot {

    @Autowired
    private Plane plane;

    public void drivePlane() {
        plane.fly();
    }
}

实例

这里写图片描述

POJO类

package com.xgj.ioc.configuration;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Pilot {

    @Autowired
    private Plane plane;

    public void drivePlane() {
        plane.fly();
    }
}

@Component注解将Pilot标注为一个Bean，Spring会扫描加载并实例化该Bean。

通过@Autowired注入plan的Bean。

POJO类

package com.xgj.ioc.configuration;

import org.springframework.stereotype.Component;

@Component
public class Plane {

    private String brand;
    private String color;
    private int speed;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public void introduce() {
        System.out.println("Plane information【 brand:" + brand + ",color:"
                + color + ",speed:" + speed);
    }

    public void fly() {
        System.out.println("Plane begins to  fly");
    }
}

配置文件

<?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 
            http://www.springframework.org/schema/beans/spring-beans.xsd

            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context.xsd">


    <!-- (1)声明Context命名空间以及Schema文件   (2)扫描类包以及应用注解定义的bean -->
    <context:component-scan base-package="com.xgj.ioc.configuration"/>

</beans>

测试类

package com.xgj.ioc.configuration;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ConfigBeanTest {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/ioc/configuration/beans.xml");

        Pilot pilot = ctx.getBean("pilot", Pilot.class);
        pilot.drivePlane();

        Plane plane = ctx.getBean("plane", Plane.class);
        plane.setBrand("A380");
        plane.setColor("White");
        plane.setSpeed(800);

        plane.introduce();

    }
}

运行结果：

这里写图片描述

使用@Auotwired的required属性

如果容器中没有一个和标注变量类型匹配的Bean，那么Spring启动的时候会报NoSuchBeanDefinitionException异常。 如果希望Spring及时找不到匹配的Bean完成注入也不要抛出异常，那么就可以使用@Autowired(required=false)进行标注。

实例

还是以上面的例子为基础改造下，我们知道上面的扫描包配置的为

<context:component-scan base-package="com.xgj.ioc.configuration"/>

假设在com.xgj.ioc.configuration之外的包目录下 有个Tank类（com.xgj.ioc.inject.construct.type.Tank）

改造下Pilot类，引入Tank，设置自动注入

package com.xgj.ioc.configuration;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.xgj.ioc.inject.construct.type.Tank;

@Component
public class Pilot {

    @Autowired
    private Plane plane;

    @Autowired
    private Tank tank;

    public void drivePlane() {
        plane.fly();
    }
}

@Autowired 默认 required =true

运行测试类：

No qualifying bean of type 'com.xgj.ioc.inject.construct.type.Tank' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}

这里写图片描述

我们改造下@Autowired(required = false)

@Autowired(required = false)
private Tank tank;

再此运行： OK

这里写图片描述

使用@Qualifier指定注入Bean的名称

如果容器中有一个以上匹配的Bean时，则可以通过@Qualifier注解限定Bean的名称。

假设容器中有两个类型为Plane的Bean，一个名为plane,一个名为otherPlane. 因为@Autowired默认是按照类型匹配的方式在容器中查找，plane和otherPlane的类型都是Plane,怎么知道注入哪一个呢？

实例

这里写图片描述

我们在扫描的基类包下增加个子包 other，包下新增同名Plane类，通过@Component(“otherPlane”)指定Bean的名称。

com.xgj.ioc.configuration.other.Plane代码如下：

package com.xgj.ioc.configuration.other;

import org.springframework.stereotype.Component;

@Component("otherPlane")
public class Plane {

    private String brand;
    private String color;
    private int speed;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public void introduce() {
        System.out.println("OtherPlane information【 brand:" + brand + ",color:"
                + color + ",speed:" + speed);
    }

    public void fly() {
        System.out.println("OtherPlane begins to  fly");
    }
}

如果我们希望注入otherPlane呢？

我们来改造Pilot类

package com.xgj.ioc.configuration;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

// 1. 引入其他子包下的Plane  
import com.xgj.ioc.configuration.other.Plane;
import com.xgj.ioc.inject.construct.type.Tank;

@Component
public class Pilot {

    @Autowired
    // 2 通过@Qualifier限定Bean的名称
    @Qualifier("otherPlane")
    private Plane plane;

    @Autowired(required = false)
    private Tank tank;

    public void drivePlane() {
        plane.fly();
    }
}

测试类中改动的地方

记得引入 other子包下的Plane

import com.xgj.ioc.configuration.other.Plane;
.....
Plane plane = ctx.getBean("otherPlane", Plane.class);

然后运行测试类：

这里写图片描述

对类方法进行标注

@Autowired可以对类成员变量以及方法的入参进行标注。

下面在类的方法上使用@Autowired注解。

实例

这里写图片描述

package com.xgj.ioc.configuration.method;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Pilot {

    private Plane plane;

    // 自动将Plane类型传给方法入参
    @Autowired
    public void setPlane(Plane plane) {
        this.plane = plane;
    }


    public void drivePlane() {
        plane.fly();
    }

}

如果是下面这种写法

    // 自动将名为plane的Bean传给方法入参
    @Autowired
    @Qualifier("plane")
    public void setPlane(Plane plane) {
        this.plane = plane点内容**

如果一个方法拥有多个入参，在默认情况下,Spring将自动选择匹配入参类型的Bean进行注入。 Spring允许对方法入参标注@Qualifier以指定注入Bean的名称。

比如

@Autowired
    public void setPlane(Plane plane, @Qualifier("tank") Tank tank) {
        this.plane = plane;
    }

在这种情况下，Plane的入参注入为Plane类型的Bean，而Tank的入参注入的则为名称为tank的Bean.

实例代码如下：

Pilot POJO类

package com.xgj.ioc.configuration.method;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Pilot {

    private Plane plane;

    // 自动将Plane类型传给方法入参
    @Autowired
    public void setPlane(Plane plane) {
        this.plane = plane;
    }

    public void drivePlane() {
        plane.fly();
    }
}

Plane POJO类 

package com.xgj.ioc.configuration.method;

import org.springframework.stereotype.Component;

@Component // 通过注解标注为一个Bean，以便Spring扫描并实例化
public class Plane {

    public void fly() {
        System.out.println("Plane begins to  fly");
    }

}

配置文件

<?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 
            http://www.springframework.org/schema/beans/spring-beans.xsd

            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context.xsd">


    <!-- (1)声明Context命名空间以及Schema文件   (2)扫描类包以及应用注解定义的bean -->
    <context:component-scan base-package="com.xgj.ioc.configuration.method"/>

</beans>

测试类 

package com.xgj.ioc.configuration.method;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ConfigMethodTest {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/ioc/configuration/method/beans.xml");

        Pilot pilot = ctx.getBean("pilot", Pilot.class);

        pilot.drivePlane();

    }
}

运行结果

这里写图片描述

小结

一般情况下，Spring容器中大部分的Bean是单实例的，所以一般无需通过@Repository、@Service等注解的value属性指定Bean的名称，也无须使用@Qualifier注解按照名称进行注入。

虽然Spring支持在属性和方法上标注自动注入注解@Autowired,但在实际项目开发中建议采用在方法上标注@Autowired，因为这样更加“面向对象”，也方便单元测试的编写， 如果将注解标注在私有属性上，则在单元测试的时候就很难用编程的办法设置属性值。

对集合类进行标注

如果对类中集合类的变量或者方法入参进行@Autowired标注，那么Spring会将容器中类型所有匹配的Bean都自动注入进来。

实例

这里写图片描述

接口 Plugin

package com.xgj.ioc.configuration.lstmpSupport;

public interface Plugin {

}

POJO 

package com.xgj.ioc.configuration.lstmpSupport;

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Order(value = 1)
public class Plugin1 implements Plugin {
    /**
     * 
     * 
     * @Title:Plugin1
     * 
     * @Description:构造函数
     */
    public Plugin1() {
        super();
        System.out.println("Pligin1 Init");
    }
}

POJO

package com.xgj.ioc.configuration.lstmpSupport;

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Order(value = 2)
public class Plugin2 implements Plugin {
    /**
     * 
     * @Title:Plugin2
     * 
     * @Description:构造函数
     * 
     * */
    public Plugin2() {
        super();
        System.out.println("Pligin2 Init");
    }

}

通过@Component标注为Bean，Spring会将 Plugin1和Plugin2这两个Bean都注入到plugins中。 在默认情况下，这两个bean的加载顺序是不确定，在Spring4.0中可以通过@Order注解或者实现Ordered接口来决定Bean加载的顺序，值越小，优先被加载。

POJO

package com.xgj.ioc.configuration.lstmpSupport;

import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    private List<Plugin> plugins;

    private Map<String, Plugin> pluginMap;

    // Spring会将容器中所有类型为Plugin的Bean注入到这个变量中
    @Autowired(required = false)
    public void setPlugins(List<Plugin> plugins) {
        this.plugins = plugins;
    }

    // 将Plugin类型的Bean注入到Map中
    @Autowired
    public void setPluginMap(Map<String, Plugin> pluginMap) {
        this.pluginMap = pluginMap;
    }

    /**
     * 
     * 
     * @Title: getPlugins
     * 
     * @Description: 获取Plugins
     * 
     * @return
     * 
     * @return: List<Plugin>
     */
    public List<Plugin> getPlugins() {
        return plugins;
    }

    /**
     * 
     * 
     * @Title: getPluginMap
     * 
     * @Description: 获取Map
     * 
     * @return
     * 
     * @return: Map<String,Plugin>
     */
    public Map<String, Plugin> getPluginMap() {
        return pluginMap;
    }

}

Spring如果发现变量是一个List和一个Map的集合类，则它会将容器中匹配集合元素类型的所有Bean都注入进来。

private Map

<?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 
            http://www.springframework.org/schema/beans/spring-beans.xsd

            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context.xsd">


    <!-- (1)声明Context命名空间以及Schema文件   (2)扫描类包以及应用注解定义的bean -->
    <context:component-scan base-package="com.xgj.ioc.configuration.lstmpSupport"/>

</beans>

测试类：

package com.xgj.ioc.configuration.lstmpSupport;

import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ListMapSupportTest {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/ioc/configuration/lstmpSupport/beans.xml");
        // 从容器中获取bean
        MyComponent myComponent = ctx.getBean("myComponent", MyComponent.class);
        // 获取Map集合
        Map<String, Plugin> map = myComponent.getPluginMap();
        // Map遍历key和value
        for (Entry<String, Plugin> entry : map.entrySet()) {
            System.out.println("key:" + entry.getKey());
            System.out.println("value:" + entry.getValue());
        }
        // 获取list集合
        List<Plugin> list = myComponent.getPlugins();
        // 遍历list
        for (int i = 0; i < list.size(); i++) {
            System.out.println("list中的元素" + i + "为" + list.get(i));
        }
    }
}

运行结果：
这里写图片描述

对延迟依赖注入的支持

Spring4.0支持延迟依赖注入，即在Spring容器的时候，对已在Bean上标注了@Lazy和@Autowired注解的属性，不会立即注入属性值。 而是延迟到调用此属性的时候才会注入属性值。

对于Bean实施延迟依赖注入，要注意@Lazy注解必须同时标注在属性及目标Bean上，二者缺一不可，否则延迟注入无效。

实例

这里写图片描述

package com.xgj.ioc.configuration.lazyLoad;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
public class Pilot {

    private Plane plane;

    // 延迟注入
    @Lazy
    @Autowired(required = false)
    public void setPlane(Plane plane) {
        this.plane = plane;
    }

}

POJO

package com.xgj.ioc.configuration.lazyLoad;

import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Lazy
// @Lazy 目标Bean 延迟注入
@Component
// 通过注解标注为一个Bean，以便Spring扫描并实例化
public class Plane {

    /**
     * 
     * 
     * @Title:Plane
     * 
     * @Description:无参构造函数
     */
    public Plane() {
        super();
        System.out.println("Plan init ");
    }

    public void fly() {
        System.out.println("Plane begins to  fly");
    }

}

配置文件：

<?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 
            http://www.springframework.org/schema/beans/spring-beans.xsd

            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context.xsd">


    <!-- (1)声明Context命名空间以及Schema文件   (2)扫描类包以及应用注解定义的bean -->
    <context:component-scan base-package="com.xgj.ioc.configuration.lazyLoad"/>

</beans>

测试

package com.xgj.ioc.configuration.lazyLoad;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class LazyLoadTest {

    public static void main(String[] args) {
        // 初始化容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/ioc/configuration/lazyLoad/beans.xml");
    }
}

运行结果：
这里写图片描述

我们可以看到，并没有实例化Plane这个Bean.

我们将@Lazy去掉，再次运行下

这里写图片描述

可以看到 启动容器的时候，Plane bean已经被加载实例化了。

对标准注解的支持

Spring还支持JSR-250中定义的@Resource和JSR-330中定义的@Inject注解，这两个标准注解和@Autowired注解的功能类似，都能对类变更及方法入参提供自动注入功能。

@Resource注解要求提供一个Bean名称的属性，如果属性为空，则自动采用标注处的变量名或者方法名作为Bean的名称。

实例

这里写图片描述

POJO 

package com.xgj.ioc.configuration.standard;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;

@Component
public class Pilot {

    private Plane plane;

    @Resource(name = "plane")
    public void setPlane(Plane plane) {
        this.plane = plane;
    }

    public void drivePlane() {
        plane.fly();
    }

}

POJO 

package com.xgj.ioc.configuration.standard;

import org.springframework.stereotype.Component;

@Component
public class Plane {

    public void fly() {
        System.out.println("plane begins to fly");
    }

}

配置文件

<?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 
            http://www.springframework.org/schema/beans/spring-beans.xsd

            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context.xsd">


    <!-- (1)声明Context命名空间以及Schema文件   (2)扫描类包以及应用注解定义的bean -->
    <context:component-scan base-package="com.xgj.ioc.configuration.standard"/>

</beans>

测试类 

package com.xgj.ioc.configuration.standard;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class StandardTest {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/ioc/configuration/standard/beans.xml");

        ctx.getBean("pilot", Pilot.class).drivePlane();
    }
}

运行结果

这里写图片描述

小结

如果@Resource未指定plane属性，则也可以根据属性方法得到需要注入的Bean名称。

@Autowired默认按照类型匹配注入bean， @Resource默认按照名称匹配注入Bean。而@Inject和@Autowired同样也是按照类型匹配注入Bean的，只不过它没有required属性。

可见不管是@Resource或者@Inject注解，其功能都没有@Autowired丰富，因此除非有不要，大可不必在乎这两个注解

小小工匠
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring4新特性：泛型限定式依赖注入
曲奇
02-26 2万+
Spring 4.0已经发布RELEASE版本，不仅支持Java8，而且向下兼容到JavaSE6/JavaEE6，并移出了相关废弃类，新添加如Java8的支持、Groovy式Bean定义DSL、对核心容器进行增强、对Web框架的增强、Websocket模块的实现、测试的增强等。其中两个我一直想要的增强就是：支持泛型依赖注入、对cglib类代理不再要求必须有空参构造器了。具体更新请参考： ht
ioc自动装载
weixin_48962287的博客
05-25 1277
ioc自动装载（autowire） 自动装载，不需要手动配置property，ioc容器会自动选择完成依赖注入 自动装载有两种方式： byName:通过属性名自动装载 byType:通过属性对应的数据类型自动装载。 1.创建Person实体类 public class Person{ private int id; private String name; private Car car; } 2.在spring.xml中配置Car bean和Person bean，并通过自
IOC自动装载
m0_45045268的博客
01-08 512
IoC自动装载(Autowire) IoC负责创建对象，DI负责完成对象的依赖注入，通过配置property标签的ref属性来完成，同时Spring提供了另外一种更加简便的依 赖注入方式：自动装载，不需要手动配置property，IoC容器会自动选择bean完成注入。 自动装载有两种方式: byName : 通过属性名自动装载 byType : 通过属性的数据类型自动装载 byName <!--cars--> <bean id="c
Spring Boot v2.4.4源码解析（九）依赖注入@Autowired注解使用方式
u010141779的博客
04-28 603
Spring 依赖注入
Java每日面试题5题（二）—— Spring相关篇二
小袁同学的博客
06-11 893
（1）Autowired和Resource关键字的区别 （2）Spring基于xml注入bean的几种方式？ （3）Spring框架中都用到了哪些设计模式？ （4）Spring 中 ApplicationContext 和 BeanFactory 的区别？ （5）Spring 框架中的单例 Bean 是线程安全的么？...
spring中bean的自动装配(详细)
七一
08-15 7553
1、Bean的自动装配（xml形式） 自动装配是使用spring满足bean依赖的一种方法 spring会在应用上下文中为某个bean寻找其依赖的bean。 1.新建两个实体类 public class Address { private String address; // get,set,toString } public class Student { private String name; private Address address; // get.set.t
spring学习笔记（有代码有注解解释）
最新发布
08-12
IoC 自动装载（Autowire）；AOP以及如何使用； 适用人群：比较适合与我一样的在校普通大学生进行学习整理，以及适合初学spring的朋友进行巩固加深印象！ 阅读建议：需要有一定的代码基础，一定的知识储备
Spring Framewor开发手册
10-09
2.2.4. Annotation(注解)驱动配置 2.2.5. 在classpath中自动搜索组件 2.3. 面向切面编程(AOP) 2.3.1. 更加简单的AOP XML配置 2.3.2. 对@AspectJ 切面的支持 2.3.3. 对bean命名pointcut( bean name pointcut element)...
Spring中文帮助文档
08-05
3.11.2. 基于注解的自动连接微调 3.11.3. CustomAutowireConfigurer 3.11.4. @Resource 3.11.5. @PostConstruct 与 @PreDestroy 3.12. 对受管组件的Classpath扫描 3.12.1. @Component和更多典型化注解 3.12.2....
Spring API
09-24
3.11.2. 基于注解的自动连接微调 3.11.3. CustomAutowireConfigurer 3.11.4. @Resource 3.11.5. @PostConstruct 与 @PreDestroy 3.12. 对受管组件的Classpath扫描 3.12.1. @Component和更多典型化注解 3.12.2....
Spring.3.x企业应用开发实战（完整版）.part2
05-31
4.11.2 使用基于Java类的配置信息启动Spring容器 4.12 不同配置方式比较 4.13 小结 第5章 Spring容器高级主题 5.1 Spring容器技术内幕 5.1.1 内部工作机制 5.1.2 BeanDefinition 5.1.3 InstantiationStrategy 5.1.4 ...
模拟Spring的IoC容器实现注解自动装配
05-10
自己实现的简易的模拟Spring的IoC容器，实现注解自动装配
spring自动装配Bean的五种方式
qq_37908493的博客
03-19 1万+
no：默认方式，手动装配方式，需要通过ref设定bean的依赖关系 byName：根据bean的名字进行装配，当一个bean的名称和其他bean的属性一致，则自动装配 byType：根据bean的类型进行装配，当一个bean的属性类型与其他bean的属性的数据类型一致，则自动装配 constructor：根据构造器进行装配，与 byType 类似，如果bean的构造器有与其他bean类型相同的属...
@Autowired(required=false)注入注意的问题
热门推荐
static_coder的博客
03-16 12万+
1、前言在使用spring开发过程中，我们基本上都是使用@Autowired这个注解，用来注入已有的bean。但是有些时候，会注入失败。当我们加上参数（required=false）就能解决。今天整理一个我在实际开发中的例子2、required属性@Autowired(required=true)：当使用@Autowired注解的时候，其实默认就是@Autowired(required=true)...
Spring IoC自动装载autowire
qq_37570991的博客
08-28 402
Spring IoC自动装载autowire 自动装载是Spring提供的一种更加简便的方式来完成DI（依赖注入），不需要手动配置property，IoC容器会自动选择bean完成注入。 ⭐自动装载有两种方式： byName，通过属性名完成自动装载 byType，通过属性对应的数据类型完成自动装载 ⭐byName的方式 创建Person实体类 package com.oyrf.entity; import lombok.Data; @Data public class Person {
Spring自动装配Bean
unber的博客
08-11 258
除了使用 XML 和 Annotation 的方式装配 Bean 以外，还有一种常用的装配方式——自动装配。自动装配就是指 Spring 容器可以自动装配（autowire）相互协作的 Bean 之间的关联关系，将一个 Bean 注入其他 Bean 的 Property 中。...
Spring自动注入的几种方式
weixin_34041003的博客
06-25 3051
---恢复内容开始--- @Service("accountEmailService")public class AccountEmailServiceImpl implements AccountEmailService{ /** 通过构造器注入---begin **/ private JavaMailSender javaMailSender; @Auto...
Spring自动装配Bean的两种方法（—）
cienven的博客
12-14 1188
配置文件自动装配配置文件装配方法一共有四种：default装配bean，byName装配bean，byType装配bean，constructor装配bean
简述Spring中如何基于注解配置 Bean 和装配Bean
05-26
在Spring中，我们可以使用注解来配置和装配Bean，这可以使我们的代码更加简洁和易于维护。下面是关于如何基于注解配置和装配Bean的一些...以上就是关于Spring中基于注解配置和装配Bean的简要介绍，希望能对您有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小小工匠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值