14-@Autowired处理

最新推荐文章于 2024-11-12 21:14:07 发布
最新推荐文章于 2024-11-12 21:14:07 发布
阅读量604 收藏 9
点赞数 14
分类专栏： spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26813531/article/details/138093943
版权

简单的注入

准备bean

static class Bean1 {

    @Autowired
    private Bean2 bean2;

    @Autowired
    public void setBean2(Bean2 bean2) {
        this.bean2 = bean2;
    }

    @Autowired
    private Optional<Bean2> bean3;

    @Autowired
    private ObjectFactory<Bean2> bean4;

    @Autowired
    @Lazy
    private Bean2 bean5;

}


@Component("bean2")
static class Bean2 {
}

处理注入

@Configuration
public class TestAutowired {

    @SneakyThrows
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(TestAutowired.class);
        DefaultListableBeanFactory beanFactory = applicationContext.getDefaultListableBeanFactory();

        // 1. 根据成员变量类型注入
        DependencyDescriptor dd1 = new DependencyDescriptor(Bean1.class.getDeclaredField("bean2"), true);
        System.out.println(beanFactory.doResolveDependency(dd1, "bean1", null, null));

        // 2. 根据方法的入参类型注入   方法名 + 参数索引
        DependencyDescriptor dd2 = new DependencyDescriptor(new MethodParameter(Bean1.class.getMethod("setBean2", Bean2.class), 0), true);
        System.out.println(beanFactory.doResolveDependency(dd2, "bean1", null, null));

        // 3. Optional成员变量注入
        DependencyDescriptor dd3 = new DependencyDescriptor(Bean1.class.getDeclaredField("bean3"), true);
        System.out.println("bean3类型：" + dd3.getDependencyType());
        if (dd3.getDependencyType() == Optional.class) {
            // 内嵌级别+1 获取真实类型
            dd3.increaseNestingLevel();
            System.out.println("内嵌级别+1后：" + dd3.getDependencyType());
            Object ret = beanFactory.doResolveDependency(dd3, "bean1", null, null);
            System.out.println(Optional.ofNullable(ret));
        }

        // 4. ObjectFactory成员变量注入
        DependencyDescriptor dd4 = new DependencyDescriptor(Bean1.class.getDeclaredField("bean4"), true);
        System.out.println("bean4类型：" + dd4.getDependencyType());
        if (dd4.getDependencyType() == ObjectFactory.class) {
            // 内嵌级别+1 获取真实类型
            dd4.increaseNestingLevel();
            System.out.println("内嵌级别+1后：" + dd4.getDependencyType());
            Object ret = beanFactory.doResolveDependency(dd4, "bean1", null, null);
            ObjectFactory objectFactory = new ObjectFactory() {
                @Override
                public Object getObject() throws BeansException {
                    return ret;
                }
            };
            System.out.println(objectFactory.getObject());
        }

        // 5. @Lazy处理
        DependencyDescriptor dd5 = new DependencyDescriptor(Bean1.class.getDeclaredField("bean5"), true);
        // 解析@Value、@Lazy
        ContextAnnotationAutowireCandidateResolver resolver = new ContextAnnotationAutowireCandidateResolver();
        resolver.setBeanFactory(beanFactory);

        Object proxy = resolver.getLazyResolutionProxyIfNecessary(dd5, "bean1");
        System.out.println(proxy);
        // 生成的对象是动态代理
        System.out.println(proxy.getClass());

    }
}

复杂的注入

准备bean

interface Service {
}

@Component("service1")
static class Service1 implements Service {
}

@Primary
@Component("service2")
static class Service2 implements Service {
}

@Component("service3")
static class Service3 implements Service {
}

interface DAO<T> {
}

static class Student {
}

static class Teacher {
}

@Component("DAO1")
static class DAO1 implements DAO<Student> {
}

@Component("DAO2")
static class DAO2 implements DAO<Teacher> {
}

目标类

static class Target {
    @Autowired
    private Service[] serviceArr;
    @Autowired
    private List<Service> serviceList;
    @Autowired
    private ConfigurableApplicationContext applicationContext;
    @Autowired
    private DAO<Teacher> dao;  // DAO2
    @Autowired
    @Qualifier("service2")
    private Service service;
}

注入-数组

@SneakyThrows
private static void testArray(DefaultListableBeanFactory beanFactory) {
    DependencyDescriptor serviceArr = new DependencyDescriptor(Target.class.getDeclaredField("serviceArr"), true);
    // 当前属性是一个数组
    //System.out.println(serviceArr.getDependencyType());
    if (serviceArr.getDependencyType().isArray()) {
        Class<?> componentType = serviceArr.getDependencyType().getComponentType();
        System.out.println("数组类的真实类型：" + componentType);
        // 根据类型从当前容器或者父级容器中获取bean名字
        String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, componentType);
        List<Object> retBeans = new ArrayList<>();
        for (String beanName : beanNames) {
            System.out.println("findBean=>" + beanName);
            // 从容器中根据beanName获取bean
            Object ret = serviceArr.resolveCandidate(beanName, componentType, beanFactory);
            retBeans.add(ret);
        }
        // 类型转换  list->数组
        Object ret = beanFactory.getTypeConverter().convertIfNecessary(retBeans, serviceArr.getDependencyType());
        System.out.println("最终注入的数组：" + ret);
    }
}

注入-list

@SneakyThrows
private static void testList(DefaultListableBeanFactory beanFactory) {
    DependencyDescriptor serviceList = new DependencyDescriptor(Target.class.getDeclaredField("serviceList"), true);
    if (serviceList.getDependencyType() == List.class) {
        Class<?> resolveType = serviceList.getResolvableType().getGeneric().resolve();
        System.out.println("list的真实类型：" + resolveType);
        String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, resolveType);
        List<Object> ret = new ArrayList<>();
        for (String beanName : beanNames) {
            Object bean = serviceList.resolveCandidate(beanName, resolveType, beanFactory);
            ret.add(bean);
        }
        System.out.println(ret);
    }
}

注入-ApplicationContext

@SneakyThrows
private static void testApplicationContext(DefaultListableBeanFactory beanFactory) {
    DependencyDescriptor applicationContext = new DependencyDescriptor(Target.class.getDeclaredField("applicationContext"), true);

    Field resolvableDependencies = DefaultListableBeanFactory.class.getDeclaredField("resolvableDependencies");
    resolvableDependencies.setAccessible(true);
    Map<Class<?>, Object> resolvableDependencyMap = (Map<Class<?>, Object>) resolvableDependencies.get(beanFactory);
    resolvableDependencyMap.forEach((k, v) -> {
        // 几个核心类没有放在一级缓存中，而是放在了resolvableDependencies成员变量中  分别是：ResourceLoader、ApplicationEventPublisher、ApplicationContext以及BeanFactory
        System.out.println("key: " + k + ", value:" + v);
    });


    for (Map.Entry<Class<?>, Object> entry : resolvableDependencyMap.entrySet()) {
        // 左边类型   =  右边类型    即 dependencyType能否复制给 Key
        if (entry.getKey().isAssignableFrom(applicationContext.getDependencyType())) {
            System.out.println("找到了applicationContext：" + entry.getValue());
            break;
        }
    }

}

注入-泛型

@SneakyThrows
private static void testGeneric(DefaultListableBeanFactory beanFactory) {
    DependencyDescriptor dao = new DependencyDescriptor(Target.class.getDeclaredField("dao"), true);
    Class<?> dependencyType = dao.getDependencyType();

    // @Value @Lazy 判断@Autowired所需要的类型是否与某个BeanDefinition匹配()
    ContextAnnotationAutowireCandidateResolver resolver = new ContextAnnotationAutowireCandidateResolver();
    resolver.setBeanFactory(beanFactory);

    String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, dependencyType);
    for (String beanName : beanNames) {
        System.out.println("找到beanName:" + beanName);

        BeanDefinition beanDefinition = beanFactory.getMergedBeanDefinition(beanName);
        if (resolver.isAutowireCandidate(new BeanDefinitionHolder(beanDefinition, beanName), dao)) {
            System.out.println("当前beanName:" + beanName + "匹配");
            System.out.println(dao.resolveCandidate(beanName, dependencyType, beanFactory));
        } else {
            System.out.println("当前beanName:" + beanName + "不匹配");
        }
    }

}

注入-@Qualifier

@SneakyThrows
private static void testQualifier(DefaultListableBeanFactory beanFactory) {
    DependencyDescriptor service = new DependencyDescriptor(Target.class.getDeclaredField("service"), true);
    Class<?> dependencyType = service.getDependencyType();

    // @Value @Lazy 判断@Autowired所需要的类型是否与某个BeanDefinition匹配(范型、@Qualifier)
    ContextAnnotationAutowireCandidateResolver resolver = new ContextAnnotationAutowireCandidateResolver();
    resolver.setBeanFactory(beanFactory);

    String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, dependencyType);
    for (String beanName : beanNames) {
        System.out.println("找到beanName:" + beanName);

        BeanDefinition beanDefinition = beanFactory.getMergedBeanDefinition(beanName);
        if (resolver.isAutowireCandidate(new BeanDefinitionHolder(beanDefinition, beanName), service)) {
            System.out.println("当前beanName:" + beanName + "匹配");
            System.out.println(service.resolveCandidate(beanName, dependencyType, beanFactory));
        } else {
            System.out.println("当前beanName:" + beanName + "不匹配");
        }
    }

}

目标类

static class Target2 {
    @Autowired
    private Service service;

    @Autowired
    private Service service3;
}

注入-@Primary

@SneakyThrows
private static void testPrimary(DefaultListableBeanFactory beanFactory) {
    DependencyDescriptor service = new DependencyDescriptor(Target2.class.getDeclaredField("service"), true);
    Class<?> dependencyType = service.getDependencyType();

    String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, dependencyType);
    for (String beanName : beanNames) {
        System.out.println("找到beanName:" + beanName);

        BeanDefinition beanDefinition = beanFactory.getMergedBeanDefinition(beanName);
        if (beanDefinition.isPrimary()) {
            System.out.println("当前beanName:" + beanName + "匹配");
            System.out.println(service.resolveCandidate(beanName, dependencyType, beanFactory));
        } else {
            System.out.println("当前beanName:" + beanName + "不匹配");
        }
    }

}

注入-byName

@SneakyThrows
private static void testName(DefaultListableBeanFactory beanFactory) {
    DependencyDescriptor service3 = new DependencyDescriptor(Target2.class.getDeclaredField("service3"), true);
    Class<?> dependencyType = service3.getDependencyType();

    String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, dependencyType);
    for (String beanName : beanNames) {
        System.out.println("找到beanName:" + beanName);
        if (beanName.equals(service3.getDependencyName())) {
            System.out.println("当前beanName:" + beanName + "匹配");
            System.out.println(service3.resolveCandidate(beanName, dependencyType, beanFactory));
        } else {
            System.out.println("当前beanName:" + beanName + "不匹配");
        }
    }

}
【保姆级】超超超简单的自定义注解实现@Autowired同款功能
aqin1012的博客
02-08 827
对，构造函数，我们把原先构造函数中添加autowiredAnnotationTypes中的注解类换成了我们自定义的注解类AqinAutowired.class，所以在这次的逻辑中，会将被注解AqinAutowired修饰的字段/方法添加进特定存放的集合。着急想看到效果的同学可以直接无脑copy我贴出的代码，先执行成功开心一下（或者直接往下看我的截的执行结果颅内兴奋下也成(￣∇￣)>），我把分析放在最后，有兴趣自行前往观看(｡･ω･｡)ﾉ。1个自定义注解类（AqinAutowired.java）
Spring-Core-Container @Autowired源码探讨
wang704987562的博客
07-01 4242
前言 本文整理@Autowired注解背后源码处理机制 @Autowired 通过 @Autowired 注解注入 bean 的逻辑主要是通过 AutowiredAnnotationBeanPostProcessor bean-post-processor 实现 AutowiredAnnotationBeanPostProcessor AutowiredAnnotationBea...
Spring源码分析--@Autowired注入的不是代理对象，导致事务回滚失败(@Transactional无效)
TragedyXD的专栏
02-13 7931
@Autowired注入的不是代理对象，导致事务回滚失败(@Transactional无效)结论：不要在@Configuration类中的@Bean中直接注入需要成为代理对象的对象问题分析我们都知道Spring的事务控制是使用AOP实现的，所以@Autowired注入的对象必须是一个代理对象(类似：$Proxy89@10644)。 但是我们在使用@Bean进行配置的时候，很可能写出如下代码：
controller 中@autowired 报错_springBoot中的常用注解
weixin_42117032的博客
01-15 637
1. @SpringBootApplication2. @Repository3. @Service4. @RestController5. @Controller6. @Component7. @ResponseBody8. @RequestBody9. @ComponentScan10. @Configuration11. @Bean12. @EnableAutoConfiguration13...
autowired java_@Autowired用法详解
weixin_39731107的博客
02-12 997
@Autowired 注释，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。通过 @Autowired的使用来消除 set ，get方法。在使用@Autowired之前，我们对一个bean配置起属性时，是这用用的通过这种方式来，配置比较繁琐，而且代码比较多。在Spring 2.5 引入了 @Autowired 注释下面用案例来具体说明UserRepository.java1 pa...
WebSocket 中使用 @Autowired 注入对应为null
_江屿_
05-31 484
WebSocket 中使用 @Autowired 注入对应为null
@Autowired用法详解
baihehaitangyijiu的博客
03-26 650
Autowired: 自动装配 Spring IOC就是控制反转，Spring通过依赖注入的方式，给你自动生成对象并注入到你想要的地方，我只用在想要对象的地方声明一下就好了。@Autowired就可以加到你想要对象的上面，表示你需要给我注入(装配)这个对象。 多插一句： 一般想要的地方都会是一个接口，IOC会根据上下文给你配置实现这个接口的对象。这也就是反射，动态加载类对象，并生成对象，在代码执行...
JavaSpringBoot 中 @Autowired用法
weixin_41290863的博客
12-22 6707
@Autowired用法详解 @Autowired 注释，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。通过 @Autowired的使用来消除 set ，get方法。在使用@Autowired之前，我们对一个bean配置起属性时，是这用用的 <property name="属性名" value=" 属性值"/> 通过这种方式来，配置比较繁琐，而且代码比较多。在Spring 2.5 引入了 @Autowired 注释 下面用案例来具体说明 ..
Spring注解驱动开发第20讲——使用@Autowired、@Qualifier、@Primary这三大注解自动装配组件，你会了吗？
李阿昀的博客
12-02 4483
你知道@Autowired、@Qualifier、@Primary这些注解吗？ @Autowired注解 @Autowired注解可以对类成员变量、方法和构造函数进行标注，完成自动装配的工作。@Autowired注解可以放在类、接口以及方法上。 在使用@Autowired注解之前，我们对一个bean配置属性时，是用如下XML配置文件的形式进行配置的。 <property name="属性名" value=" 属性值"/> 下面我们来看一下@Autowired注解的源码，如下所示。 这儿对@A
Spring学习笔记（五）关于@Autowired寻找bean的顺序以及bean的歧义性问题
qq_43283391的博客
05-13 1336
创建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:context="http://www.springframework.org/schema/context" xsi:schemaLocation.
依赖注入及注解@Autowired和@Primary和@Qualifier的使用——SpringBoot
qq_44891295的博客
09-15 1151
文章目录一，演示依赖注入二，注解@Autowired三，消除歧义性——@Primary和@Qualifier 一，演示依赖注入 Bean之间的依赖，在SpringIOC容器中，我们称为依赖注入。 列如：人类有时候会利用一些动物去完成一些事情，比如狗是看门，猫抓老鼠。于是做一些事情就依赖于那些可爱的动物。 为了更好展现此过程，我们做一个演示 第一步：定义人和动物接口，并写分别写两个实现类 接口：Pe...
分析@Resource和@Autowired注解区别
xiaoweids的博客
07-08 290
Resource优点：简单易用，在类中使用非常方便。可以和@Inject注解一起使用。支持指定Bean名称，可以更精确地进行依赖注入。@Resource缺点：Spring框架对@Resource注解的支持不如@Autowired丰富。仅支持byName和byType两种注入方式，比@Autowired的支持更为有限。@Autowired优点：支持复杂的依赖注入配置，可以通过多种方式进行依赖注入。
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 199
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
1112--接口
最新发布
kequanrrr的博客
11-12 138
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot 实现图片加水印
心猿意码
11-11 302
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 381
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 476
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 309
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
JAVA学习接口案例实例
shangan_3的博客
11-08 218
【代码】JAVA学习接口案例实例。
@RestController public class FileController { @Autowired @Qualifier("menusService") private MenusService menusService; @RequestMapping("upload") public String fileUpload(CommonsMultipartFile file, Menus menus, HttpServletRequest request)throws IOException { menusService.insert(menus); //获取文件名 String uploadFilename = file.getOriginalFilename(); //如果文件名为空，直接返回 if("".equals(uploadFilename)){ return "redirect: menus_add.jsp"; } System.out.println("上传文件名："+uploadFilename); //上传保存路径 String path=request.getServletContext().getRealPath("/public/img"); //如果路径不存在，新建一个 File realPath= new File(path); if (!realPath.exists()){ realPath.mkdirs(); } System.out.println("上传文件保存地址："+realPath); //文件输入流 InputStream is =file.getInputStream(); //文件输出流 OutputStream os =new FileOutputStream(new File(realPath,uploadFilename)); //读取写出 int len=0; byte[] buffer = new byte[1024]; while ((len=is.read(buffer))!=-1) { os.write(buffer,0,len); os.flush(); } os.close(); is.close(); return "/admin/main"; } }
07-20
2. `@Autowired`：该注解用于自动注入依赖对象，这里注入了MenusService类的实例。 3. `@Qualifier("menusService")`：该注解用于指定要注入的具体实现类的名称，这里指定了menusService。 4. `@RequestMapping(...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

层巅余落日

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

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

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

打赏作者

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

抵扣说明：

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

余额充值