手撸spring15: @Autowired自动注入bean 以及@Value自动注入属性

最新推荐文章于 2024-04-15 16:36:01 发布
最新推荐文章于 2024-04-15 16:36:01 发布
阅读量585 收藏
点赞数
分类专栏： spring 文章标签： java spring java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45369440/article/details/125264843
版权

上回书我们就说到要用@Value来取代spring配置, 顺便手撸一下@Autowired 其实很简单,撸完加深了对注解开发的理解

三个注解

都在这个目录下

package com.linnine.spring.beans.factory.annotation;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.CONSTRUCTOR,ElementType.FIELD,ElementType.METHOD})
public @interface Autowired {
}


/**
 * 用于配合Autowire的使用 限定名称
 */
@Target({ElementType.FIELD,ElementType.METHOD,ElementType.PARAMETER,ElementType.TYPE,ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Qualifier {

    String value() default "";
}

@Target({ElementType.FIELD,ElementType.METHOD,ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Value {
    String value();
}

AutowiredAnnotationBeanPostProcessor

然后就是对这三个注解的处理,等下给他爹加个抽象方法

package com.linnine.spring.beans.factory.annotation;

public class AutowiredAnnotationBeanPostProcessor implements InstantiationAwareBeanPostProcessor, BeanFactoryAware {

    private ConfigurableListableBeanFactory beanFactory;

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
    }

    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs,Object bean,String beanName) throws BeansException{
        Class<?> clazz = bean.getClass();
        //判断是否被代理的类 这块代码在下面
        clazz = ClassUtils.isCglibProxyClass(clazz)?clazz.getSuperclass():clazz;
        //获取类所有声明的字段 包括public private protect
        Field[] declaredFields = clazz.getDeclaredFields();
        //处理@Value
        for (Field field : declaredFields) {
            // 看这个字段是否有大@Value注解
            Value valueAnnotation = field.getAnnotation(Value.class);
            if (null != valueAnnotation){
                String value = valueAnnotation.value();
                //解析字符串 如占位符替换成值
                value = beanFactory.resolveEmbeddedValue(value);
                //把值塞到这个对象的这个属性里
                BeanUtil.setFieldValue(bean,field.getName(),value);
            }
        }
        //处理 @Autowired
        for (Field field : declaredFields) {
            Autowired autowiredAnnotation = field.getAnnotation(Autowired.class);
            if (null!= autowiredAnnotation){
                Class<?> fieldType = field.getType();
                String dependentBeanName;
                //看是否有指定bean名称
                Qualifier qualifierAnnotation = field.getAnnotation(Qualifier.class);
                Object dependentBean;
                if (null != qualifierAnnotation){
                    dependentBeanName =qualifierAnnotation.value();
                    dependentBean = beanFactory.getBean(dependentBeanName,fieldType);
                }else {
                    //没有就通过类型获取
                    dependentBean =beanFactory.getBean(fieldType);
                }
                BeanUtil.setFieldValue(bean,field.getName(),dependentBean);
            }
        }


        return pvs;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }
}

InstantiationAwareBeanPostProcessor

增加一个属性填充前的方法

package com.linnine.spring.beans.factory.config;

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor{


    /**
     * 在 Bean 对象执行初始化方法之前，执行此方法
     * @param beanClass
     * @param beanName
     * @return
     * @throws BeansException
     */
    Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;


    /**
     * 在bean 对象实例化完成后,设置属性操作之前执行此方法
     * @param pvs
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    PropertyValues postProcessPropertyValues(PropertyValues pvs, Object bean, String beanName) throws BeansException;

}

ClassPathBeanDefinitionScanner

然后注册一下这个后处理

public void doScan(String... basePackages){
   ...省略

    // 注册处理注解的 BeanPostProcessor（@Autowired、@Value）
    registry.registerBeanDefinition("internalAutowiredAnnotationProcessor",new BeanDefinition(AutowiredAnnotationBeanPostProcessor.class));
}

ClassUtils

工具类

package com.linnine.spring.utils;

public class ClassUtils {

    public static ClassLoader getDefaultClassLoader() {
        ClassLoader cl = null;
        try {
            cl = Thread.currentThread().getContextClassLoader();
        }
        catch (Throwable ex) {
            // Cannot access thread context ClassLoader - falling back to system class loader...
        }
        if (cl == null) {
            // No thread context class loader -> use class loader of this class.
            cl = ClassUtils.class.getClassLoader();
        }
        return cl;
    }

    public static boolean isCglibProxyClass(Class<?> clazz) {
        return clazz!=null && isCglibProxyClassName(clazz.getName());
    }

    public static boolean isCglibProxyClassName(String className) {
        return className!=null && className.contains("$$");
    }
}

StringValueResolver

开一个字符串解析接口
package com.linnine.spring.utils;

/**
 * 字符串解析
 */
public interface StringValueResolver {

    String resolveStringValue(String strVal);
}

PropertyPlaceholderConfigurer

之前的value占位符注入主要是解析xml配置文件的, 所以需要整合提取一下

package com.linnine.spring.beans.factory;

@Data
public class PropertyPlaceholderConfigurer implements BeanFactoryPostProcessor {

    /**
     * 读取 占位符 格式 ${value}
     */
    private static final String DEFAULT_PLACEHOLDER_PREFIX = "${";

    private static final String DEFAULT_PLACEHOLDER_SUFFIX = "}";

    private String location;

    @Override
    public void postProcessorBeanFactory(ConfigurableListableBeanFactory beanFactory) {

        //加载属性文件
        DefaultResourceLoader resourceLoader = new DefaultResourceLoader();
        Resource resource = resourceLoader.getResource(location);
        Properties properties = new Properties();
        try {
            //加载配置信息
            properties.load(resource.getInputStream());
            //获取所有bean定义名
            String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
            for (String beanName: beanDefinitionNames) {
                //根据定义名获取定义信息
                BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
                //获取属性配置
                PropertyValues propertyValues = beanDefinition.getPropertyValues();
                for (PropertyValue propertyValue : propertyValues.getPropertyValues()) {
                    //获取属性值
                    Object value = propertyValue.getValue();
                    //如果 属性值 不是字符串的退出
                    if (!(value instanceof String)) continue;
                    value = resolvePlaceholder((String) value, properties);
                    //重新填入
                    propertyValues.addPropertyValue(new PropertyValue(propertyValue.getName(), value));
                }
            }
            //将配置信息存进去以供转换
            StringValueResolver valueResolver = new PlaceholderResolvingStringValueResolver(properties);
            beanFactory.addEmbeddedValueResolver(valueResolver);
        } catch (IOException ioException) {
            ioException.printStackTrace();
        }
    }

    /**
     * 方法提取出来 对占位符进行处理
     * @param strVal
     * @param properties
     * @return
     */
    private String resolvePlaceholder(String strVal, Properties properties) {
        StringBuilder builder = new StringBuilder(strVal);
        int startIdx = strVal.indexOf(DEFAULT_PLACEHOLDER_PREFIX);
        int stopIdx = strVal.indexOf(DEFAULT_PLACEHOLDER_SUFFIX);
        if (startIdx != -1 && stopIdx != -1 && startIdx < stopIdx) {
            //拆除占位符内的 字符串名字
            String propKey = strVal.substring(startIdx + 2, stopIdx);
            //从配置中读资源
            String propVal = properties.getProperty(propKey);
            //替换
            builder.replace(startIdx, stopIdx + 1, propVal);
        }
        return builder.toString();
    }

    private class PlaceholderResolvingStringValueResolver implements StringValueResolver {

        private final Properties properties;

        private PlaceholderResolvingStringValueResolver(Properties properties) {
            this.properties = properties;
        }

        @Override
        public String resolveStringValue(String strVal) {
            return PropertyPlaceholderConfigurer.this.resolvePlaceholder(strVal, properties);
        }
    }	
}

AbstractBeanFactory

管理一下这些字符串解析处理类

/**
 * 15 新增 字符串解析(如解析占位符替换)
 */
private final List<StringValueResolver> embeddedValueResolvers = new ArrayList<>();;

@Override
public void addEmbeddedValueResolver(StringValueResolver valueResolver){
    this.embeddedValueResolvers.add(valueResolver);
}

@Override
public String resolveEmbeddedValue(String value) {
   String result =value;
   //每个字符串解析工具都解析一下
    for (StringValueResolver resolver : this.embeddedValueResolvers) {
        result = resolver.resolveStringValue(result);
    }
    return result;
}

ConfigurableBeanFactory

上面重写的接口定义在这里

void addEmbeddedValueResolver(StringValueResolver valueResolver);

String resolveEmbeddedValue(String value);

AbstractAutowireCapableBeanFactory

在bean实例化后 调用一下我们准备的那些注解扫描注入填充到属性中
在这里插入图片描述

   protected void applyBeanPostProcessorsBeforeApplyingPropertyValues(String beanName, Object bean, BeanDefinition beanDefinition){
        for (BeanPostProcessor beanPostProcessor : getBeanPostProcessors()) {
            if (beanPostProcessor instanceof  InstantiationAwareBeanPostProcessor){
                PropertyValues pvs = ((InstantiationAwareBeanPostProcessor) beanPostProcessor).postProcessPropertyValues(beanDefinition.getPropertyValues(), bean, beanName);
                if (null != pvs){
                    for (PropertyValue propertyValue : pvs.getPropertyValues()) {
                        beanDefinition.getPropertyValues().addPropertyValue(propertyValue);
                    }
                }

            }
        }
    }

BeanFactory

补充一个根据class获取bean的方法

<T> T getBean(Class<T> requiredType) throws BeansException;

DefaultListableBeanFactory

实现

@Override
    public <T> T getBean(Class<T> requiredType) throws BeansException {
        List<String> beanNames = new ArrayList<>();
        for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
            Class<?> beanClass = entry.getValue().getBeanClass();
            if (requiredType.isAssignableFrom(beanClass)){
                beanNames.add(entry.getKey());
            }
        }
        if (1 == beanNames.size()){
            return getBean(beanNames.get(0),requiredType);
        }
        throw new BeansException(requiredType + "expected single bean but found " + beanNames.size() + ": " + beanNames);
    }

AbstractApplicationContext

调用

@Override
public <T> T getBean(Class<T> requiredType) throws BeansException {
    return  getBeanFactory().getBean(requiredType);
}

UserService

改造测试相关的类
package com.linnine.spring.bean.service;

@Getter
@Setter
@Component("userService")
public class UserService implements IUserService {

    @Value("${token}")
    private String token;

    @Autowired
    private UserDao userDao;

    @Override
    public String queryUserInfo() {
        try {
            Thread.sleep(new Random(1).nextInt(100));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return userDao.queryUserName("10001")+","+token;
    }
    @Override
    public String register(String userName) {
        try {
            Thread.sleep(new Random(1).nextInt(100));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "注册用户：" + userName + " success！";
    }

    @Override
    public String toString() {
        return "UserService#token = { " + token + " }";
    }

}

userDao那边自己加个@Component 注解

spring.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="http://www.springframework.org/schema/beans
	         http://www.springframework.org/schema/beans/spring-beans.xsd
		 http://www.springframework.org/schema/context">
    <bean class="com.linnine.spring.beans.factory.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:token.properties"/>
    </bean>

    <context:component-scan base-package="com.linnine.spring.bean"/>

</beans>

开始测试

@Test
public void test_scan15(){
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring.xml");
    IUserService userService = applicationContext.getBean("userService", IUserService.class);
    System.out.println("测试结果：" + userService.queryUserInfo());
}

在这里插入图片描述

Java充电桩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring系列-bean标签内autowire属性应用
mystonelxj的博客
09-06 364
autowire属性是Spring框架中Bean标签的一个可选属性，该属性具有多个固定字符串值：byName、byType、constructor、 default、no，该属性受属性property与constructor-arg影响
关于@Value和@Autowired
weixin_43519121的博客
09-18 642
关于@Value和@Autowired ConfigurationClassPostProcessor ConfigurationClassParser ConfigurationClassBeanDefinitionReader 一切的一切又得回到Spring中大多数bean的起点ConfigurationClassPostProcessor，ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor接口。我们在Sprin
@Autowire/@Value注解实现
u013015681的博客
09-01 276
在Spring中，autowire注解的功能主要是通过AutowiredAnnotationBeanPostProcessor类来实现的，AutowiredAnnotationBeanPostProcessor类本身会通过xml标签"context:annotation-config" and "context:component-scan"进行注册，可以去掉或者管理默认的注解配置，如果你希望去声明一个个性化的AutowiredAnnotationBeanPostProcessor bean...
spring注入的autowired和value都没有效果
一叶知春秋
03-21 1215
博客一：http://blog.csdn.net/sinat_32366329/article/details/78341231点击打开链接博客二：http://blog.csdn.net/sinat_32366329/article/details/78339935点击打开链接以上2篇博客是之前遇到value的值无法读取时候的文章说明。本篇介绍遇到的第三种情况为什么没效果。往下看之前请先检查项目...
【Spring】深入解析 bean 的属性填充 一 autowireByName autowireByType
小水牛的博客
03-23 1200
@Autowired 原理
详解Spring @Autowired 注入小技巧
08-27
我们都知道 @Autowired 可以根据类型（Type）进行自动注入，并且默认注入的 bean 为单例（SingleTon）的，那么我们可能会问，上面注入两次不会重复吗？答案是肯定的。而且每次注入的实例都是同一个实例。 下面我们...
Spring Bean的属性注入方式
08-28
"Spring Bean的属性注入方式" Spring Bean的属性注入方式是Spring框架中一个非常重要的概念，用于将Bean的属性值注入到Bean实例中。 Spring Bean的属性注入方式有多种，包括构造器注入、Setter方法注入、集合属性...
Spring@Autowired注解与自动装配.rar
09-16
- **自动装配候选列表**：可以使用`@Autowired`注解的`@Qualifier`注解的`value`属性，提供一个bean的名称列表，Spring会尝试从列表中找到匹配的bean。 ### 4. 配置控制 - **@Autowired注解的可选性**：使用`...
SSH笔记-通过@Autowired配置注入关系
06-10
8. **`@Autowired`的替代品**：Spring还提供了一些其他的注解，如`@Resource`（基于名称的注入）和`@Value`（用于注入基本类型或属性值）作为`@Autowired`的补充。 结合前一篇文章中的注解笔记，我们可以推断出上一...
Spring定义bean的三种方式和自动注入
08-10
- `byType`：如果Bean的属性类型只有一个匹配的Bean，那么Spring会自动注入。 `@Autowired`注解则更加智能，它会根据属性类型找到合适的Bean进行注入，如果存在多个匹配的Bean，可以通过`@Qualifier`注解指定特定的...
Spring源码解析：@Autowired，@Value需要的值是如何被注入的？（AutowiredAnnotationBeanPostProcessor）
小识的博客
03-31 710
介绍 AutowiredAnnotationBeanPostProcessor是在容器启动时就会被注入到容器中的BeanPostProcessor，用来支持@Autowired，@Value，@Inject注解 AutowiredAnnotationBeanPostProcessor的继承关系如图所示 根据Bean的生命周期可以得出在Bean创建的过程中会依次调用如下方法 SmartInstantiationAwareBeanPostProcessor#determineCandidateConstru.
@autowired注解_品Spring：对@Autowired和@Value注解的处理方法（文末附spring系列资源合集）...
weixin_39719042的博客
11-27 163
作者：编程新说李新杰出自：微信公众号“编程新说”原文：品Spring：对@Autowired和@Value注解的处理方法在Spring中能够完成依赖注入的注解有JavaSE提供的@Resource注解，就是上一篇文章介绍的。还有JavaEE提供的@javax.inject.Inject注解，这个用的很少，因为一般都不会去引用JavaEE的jar包。编程新说注：JavaEE早已经被Oracle抛弃了...
Spring的Bean的自动装配属性autowire
weixin_43432438的博客
04-23 883
Spring的Bean的自动装配属性autowire
Spring注解之@Autowired、@Qualifier、@Resource、@Value
宜春
12-26 9676
@Autowired、@Qualifier、@Resource、@Value四个注解都是用于注入数据的，他们的作用就和在xml配置文件中的bean标签中写一个标签的作用是一样的！本篇中特别要讲解的重心是@Autowired注解 1、先给出一个场景 讲@Autowired注解前先给出一个场景： dao层代码 @Repository public class AccountDao { public void save() { System.out.println
【Spring】依赖注入(DI)时常用的注解@Autowired和@Value
最新发布
m0_65277261的博客
04-15 1426
如果是非SpringBoot配置文件，需要额外通过@PropertySource去指定属性文件的类路径，如果是SpringBoot配置文件(application.properties)，就无需额外配置@PropertySource。
spring中依赖注入@Value和@Autowired的使用
qq_27579471的博客
01-29 3285
可以写在何处 @Value可以写在变量、方法（包括构造方法）入参、只有一个参数的方法（包括构造方法）上 @Autowired可以写在变量、方法（包括构造方法）上 在spring4.x中新增了新的特性：如果类只提供了一个带参数的构造方法，则不需要对其内部的属性写@Autowired注解，spring会自动为你注入属性；配合lombok的@RequiredArgsConstructor使用体验很好。 @Value与@Autowired混合使用 执行到有@Autowired的构造方法时: 执行到有@Po
《Spring》第十五篇 DI自动注入之@Value注解
入坑太深起不来
02-23 360
二. @Value 1. 可以定义的位置 从源码的位置看, @Value可以定义在属性字段,方法,参数,最常见的是定义在属性上。只有一个属性元素value @Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Value { /
spring 自动注入(autowire)
villasy的博客
01-18 506
在开发中，我们常常使用标签为JavaBean注入它依赖的对象。这种方式比较耗费资源同时也会导致系统的复杂性。在定义Bean时，标签有一个autowire属性，我们可以通过指定它来让容器为受管JavaBean自动注入依赖对象。 1、 No：即不启用自动装配。Autowire默认的值。不使用Autowire，引用关系显示声明，spring的reference也建议不用autoware，因为这会破坏模...
websocket使用@Autowired、@Value获取值为null解决方法
kakahu2015的博客
03-11 3716
作为一名资深码农，原本以为闭着眼睛都可以用@Autowired、@Value轻松获取注入的对象，不料最近在一个写一个小工具时碰了一鼻子灰，先上代码： @ServerEndpoint("/log") @Component public class LogWebSocketHandle { @Value("${wslog_commond}")// private String wslog_commond1; 相信java 码农们再熟悉不过了，不过你不要高兴太早，取值时候一个null足以
Spring注解详解：@Bean、@Autowired与配置类注解
"这篇文档主要介绍了Spring框架中的一些核心注解，包括@Bean、@Resource、@Autowired、@Qualifier、@Configuration、@RequestMapping、@PathVariable、@RequestParam、@RequestBody以及@Component系列注解，并提及了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值