【Spring基础】Spring源码学习（二）

最新推荐文章于 2023-03-09 21:05:36 发布
最新推荐文章于 2023-03-09 21:05:36 发布
阅读量160 收藏
点赞数 1
分类专栏： Spring 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TcCookEgg/article/details/106276134
版权

step-2将bean创建放入工厂

BeanDefinition

用BeanDefinition来描述bean（spring的bean本质上就是Object），相比step-1可以明显的看出来，更加完整了。

public class BeanDefinition {
    private Object bean;

    private Class beanClass;

    private String beanClassName;

    public BeanDefinition() {
    }

    public void setBean(Object bean) {
        this.bean = bean;
    }

    public Class getBeanClass() {
        return beanClass;
    }

    public void setBeanClass(Class beanClass) {
        this.beanClass = beanClass;
    }

    public String getBeanClassName() {
        return beanClassName;
    }

    public void setBeanClassName(String beanClassName) {
        this.beanClassName = beanClassName;
        try {
            this.beanClass = Class.forName(beanClassName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public Object getBean() {
        return bean;
    }
}

获取Class类对象的三大方法：

1、MyObject x;
Class c1 = x.getClass();
2、Class c2=Class.forName(“MyObject”)；
3、Class c3 = MyObject.class;

为Class类创建一个实例：

x.getClass.newInstance()

BeanFactory

BeanFactory本质就是一个map，存放bean的工厂，定义为接口。

public interface BeanFactory {
    Object getBean(String name);

    void registerBeanDefinition(String name, BeanDefinition beanDefinition);
}

AbstractBeanFactory

AbstractBeanFactory实现BeanFactory的抽象类。

public abstract class AbstractBeanFactory implements BeanFactory{
    private Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();

    //表示重写的方法，1、检查是否正确的重写父类方法；2、提示看代码的人，这是重写的方法
    @Override
    public Object getBean(String name) {
        return beanDefinitionMap.get(name).getBean();
    }

    @Override
    public void registerBeanDefinition(String name, BeanDefinition beanDefinition) {
        Object bean = doCreateBean(beanDefinition);
        beanDefinition.setBean(bean);
        beanDefinitionMap.put(name, beanDefinition);
    }

    /**
     * 初始化bean
     * @param beanDefinition
     * @return
     */
    protected abstract Object doCreateBean(BeanDefinition beanDefinition);
}

AutowireCapableBeanFactory

AutowireCapableBeanFactory继承AbstractBeanFactory，实现初始化bean的方法。

public class AutowireCapableBeanFactory extends AbstractBeanFactory {
    @Override
    protected Object doCreateBean(BeanDefinition beanDefinition) {
        try {
            Object bean = beanDefinition.getBeanClass().newInstance();
            return bean;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

测试运行

public class HelloWorld {
    public void say(){
        System.out.println("Hello World!");
    }
}

public class test {
    public static void main(String[] args) {
        // 1.初始化beanfactory
        AutowireCapableBeanFactory autowireCapableBeanFactory = new AutowireCapableBeanFactory();

        // 2.注入bean
        BeanDefinition beanDefinition = new BeanDefinition();
        beanDefinition.setBeanClassName("com.zhudan.test2.demo3.HelloWorld");
        autowireCapableBeanFactory.registerBeanDefinition("HelloWorld", beanDefinition);

        // 3.获取bean
        HelloWorld helloWorld = (HelloWorld) autowireCapableBeanFactory.getBean("HelloWorld");
        helloWorld.say();
    }
}

step-3为bean注入属性

PropertyValue

public class PropertyValue {
    private final String name;

    private final Object value;

    public PropertyValue(String name, Object value) {
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public Object getValue() {
        return value;
    }
}

PropertyValues

public class PropertyValues {
    private final List<PropertyValue> propertyValueList = new ArrayList<PropertyValue>();

    public PropertyValues() {
    }

    public void addPropertyValue(PropertyValue pv) {
        //为什么封装而不是直接用List? 因为可以封装一些操作。
        //比如，这里可以对于重复propertyName进行判断，直接用list没法做到
        this.propertyValueList.add(pv);
    }

    public List<PropertyValue> getPropertyValues() {
        return this.propertyValueList;
    }

}

BeanDefinition

public class BeanDefinition {
    private Object bean;

    private Class beanClass;

    private String beanClassName;

    private PropertyValues propertyValues;

    public BeanDefinition() {
    }

    public void setBean(Object bean) {
        this.bean = bean;
    }

    public Class getBeanClass() {
        return beanClass;
    }

    public void setBeanClass(Class beanClass) {
        this.beanClass = beanClass;
    }

    public String getBeanClassName() {
        return beanClassName;
    }

    public void setBeanClassName(String beanClassName) {
        this.beanClassName = beanClassName;
        try {
            this.beanClass = Class.forName(beanClassName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public Object getBean() {
        return bean;
    }

    public PropertyValues getPropertyValues() {
        return propertyValues;
    }

    public void setPropertyValues(PropertyValues propertyValues) {
        this.propertyValues = propertyValues;
    }
}

AutowireCapableBeanFactory

public class AutowireCapableBeanFactory extends AbstractBeanFactory {
    @Override
    protected Object doCreateBean(BeanDefinition beanDefinition) throws Exception {
        Object bean = createBeanInstance(beanDefinition);
        applyPropertyValues(bean, beanDefinition);
        return bean;
    }

    protected Object createBeanInstance(BeanDefinition beanDefinition) throws Exception {
        return beanDefinition.getBeanClass().newInstance();
    }

    protected void applyPropertyValues(Object bean, BeanDefinition mbd) throws Exception {
        for (PropertyValue propertyValue : mbd.getPropertyValues().getPropertyValues()) {
            Field declaredField = bean.getClass().getDeclaredField(propertyValue.getName());
            declaredField.setAccessible(true);
            declaredField.set(bean, propertyValue.getValue());
        }
    }
}

getFields()与getDeclaredFields()区别:getFields()只能访问类中声明为公有的字段,私有的字段它无法访问.getDeclaredFields()能访问类中所有的字段,与public,private,protect无关 。

测试一下

public class HelloWorld {
    private String text;

    public void setText(String text) {
        this.text = text;
    }

    public void say() {
        System.out.println(text);
    }
}

public class test {
    public static void main(String[] args) throws Exception {
        // 1.初始化beanfactory
        BeanFactory beanFactory = new AutowireCapableBeanFactory();

        // 2.bean定义
        BeanDefinition beanDefinition = new BeanDefinition();

        // 3.设置属性
        PropertyValues propertyValues = new PropertyValues();
        PropertyValue propertyValue = new PropertyValue("text", "HelloWorld!");
        propertyValues.addPropertyValue(propertyValue);

        // 4.注入bean
        beanDefinition.setPropertyValues(propertyValues);
        beanDefinition.setBeanClassName("com.zhudan.test2.demo4.HelloWorld");
        beanFactory.registerBeanDefinition("hello", beanDefinition);

        // 5.获取bean
        HelloWorld helloWorld = (HelloWorld) beanFactory.getBean("hello");
        helloWorld.say();
    }

}

Spring源码

Spring源码自然比上面的项目要复杂得多，所以我一般主要看方法和类的继承关系。

类继承关系

AbstractAutowireCapableBeanFactory

RootBeanDefinition
PropertyValue

public interface PropertyValues extends Iterable<PropertyValue>

PropertyValues

TcCookEgg
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring高级源码学习笔记.zip
05-24
总之，Spring源码学习是一个深化编程技能，理解设计模式，以及提高问题解决能力的过程。通过深入研究，程序员不仅可以优化自己的代码，还能更高效地利用Spring框架提供的功能，提升项目的可维护性和扩展性。
Springcloud学习源码记录
01-17
所有的SpringCloud能够实现三大模块： 服务发现——Netflix Eureka 客户端负载均衡——Netflix Ribbon 断路器——Netflix Hystrix 服务网关——Netflix Zuul 分布式配置——Spring Cloud Config
Spring源码学习（一）
UnknownZYB的博客
05-05 1400
人对神秘的东西即好奇又恐惧，好奇心使人想一探究竟恐惧心又使人望而却步，工作了那么久对Spring源码一直怀有这样的心态，从来没有下决心进行研读，最近感觉压力在攀升，使自己不得不战胜恐惧心，进行更深入的学习，希望自己的学习同样也能给你小伙伴们带来一丝灵感。         接下来将更加一下小例子来跟读一下源码的实现sping.xml 从上面的代码加上以往的经验来看待上面的处理逻辑：1. 读取xml2...
spring源码学习
weixin_35936021的博客
05-05 1850
Spring核心 目录IOC一、什么是IOC1、IOC解决了什么问题2、IoC和DI的区别二、IOC的应用1、启动驱动类1、Java环境下启动IoC容器2、Web环境下启动IoC容器1、从xml启动容器2、从配置类启动容器2、BeanFactory与ApplicationContext区别3、纯xml模式1、实例化Bean的三种⽅式AOP二、什么是AOP1、横切逻辑：2、AOP在解决什么问题3、为什么叫做⾯向切⾯编程 IOC 一、什么是IOC IoC Inversion of Control (控制反转/反
Spring源码学习加注释，方便学习.zip
05-11
spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文...
Spring学习笔记&源码
12-14
本资料“Spring学习笔记&源码”是基于网易云课堂黑马程序员的Spring四天精通课程，旨在帮助学习者深入理解和实践Spring框架。 笔记部分可能会涵盖以下内容： 1. **Spring概述**：介绍Spring框架的历史、特点和主要...
spring源码雷神spring源码雷神
08-06
"Spring源码雷神"可能指的是对Spring框架深入源码级别的理解和解析。以下将详细阐述Spring框架的一些核心知识点： 1. **IoC（Inversion of Control）控制反转**：Spring的核心特性之一，它通过依赖注入（Dependency...
Spring源码学习
最新发布
m0_71417028的博客
03-09 431
EntityResolver顾名思义就是实体分解器，实际上对于SAX而言，解析一个XML文件，SAX首先读取该文档上的声明，根据声明去寻找相应的DTD定义，一遍对文档进行一个验证。默认的寻找规则即通过网络（实际上就是声明的DTD的URI地址）来下载响应的DTD声明，并进行认证。而EntityResolver的作用就是项目本身就可以提供一个如何寻找DTD声明的方法，即由程序来实现寻找DTD声明的过程，比如我们将DTD文件放到项目的中的某处，在实现时直接将此文档读取并返回给SAX即可。（这个我们稍后分析）
学习笔记掘金1：Spring框架解析与源码学习
同时，Spring的源码分析也是我们学习和理解框架设计的好方法，通过深入研究源码，可以更好地发现和解决问题，提高自身的技术能力。因此，深入学习和使用Spring框架是每个Java开发者的必修课程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值