村里最好的博客

Spring 源码解析—创建 bean

Posted on 2017-11-20 Edited on 2023-12-23 In 源码分析

在经历过 AbstractAutowireCapableBeanFactory#createBean 中的 resolveBeforeInstantiation 方法后，程序有两个选择，如果创建了代理或者说重写了 InstantiationAwareBeanPostProcessor 的 postProcessBeforeInstantiation 方法并在方法 postProcessBeforeInstantiation 中改变了 bean，则直接返回就可以了，否则需要进行常规 bean 的创建。而这常规 bean 的创建就是在 doCreateBean 中完成的。

AbstractAutowireCapableBeanFactory#doCreateBean

JVM系列—虚拟机类加载机制

Posted on 2017-11-17 Edited on 2023-12-23 In 基础原理

概述

什么是类加载

虚拟机把描述类的数据从 Class 文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的 Java 类型，这就是虚拟机的类加载机制。

Spring 源码解析—Bean的加载前奏

Posted on 2017-11-14 Edited on 2023-12-23 In 源码分析

User user = (User)context.getBean("testbean");

由这句入手

Spring-源码分析-bean的解析(3)

Posted on 2017-11-12 Edited on 2023-12-23 In 源码分析

当前版本 Spring 4.3.8

自定义标签的解析

自定义标签使用

在很多情况下，当使用默认配置过于繁琐时候，解析工作或许是一个不得不考虑的负担。Spring 提供了可扩展 Scheme 的支持。大概需要以下几个步骤：

Spring-源码分析-bean的解析(2)

Posted on 2017-11-03 Edited on 2023-12-23 In 源码分析

当前版本 Spring 4.3.8

默认标签的解析

接上 parseDefaultElement(ele, delegate);

Java 技巧—懒加载

Posted on 2017-10-28 Edited on 2023-12-23 In 工具

package io.github.binglau;

import java.util.function.Supplier;

/**
 * 文件描述: 懒加载大对象 Heavy
 * 利用类加载机制达到 LazyLoad 为单例
 */

public final class LazyLoad {
    private LazyLoad() {
    }

    private static class Holder {
        private static final LazyLoad INSTANCE = new LazyLoad();
    }

    public static final LazyLoad getInstance() {
        return Holder.INSTANCE;
    }

    private Supplier<Heavy> heavy = this::createAndCacheHeavy;
    private Normal normal = new Normal();

    public Heavy getHeavy() {
        return heavy.get();
    }

    public Normal getNormal() {
        return normal;
    }

    private synchronized Heavy createAndCacheHeavy() {
        class HeavyFactory implements Supplier<Heavy> {
            private final Heavy heavyInstance = new Heavy();
            @Override
            public Heavy get() {
                return heavyInstance;
            }
        }

        if (!HeavyFactory.class.isInstance(heavy)) {
            heavy = new HeavyFactory();
        }

        return heavy.get();
    }

    public static void main(String[] args) throws InterruptedException {
        LazyLoad.getInstance().getNormal();
        LazyLoad.getInstance().getHeavy();
    }

}

class Heavy {
    public Heavy() {
        System.out.println("Creating Heavy ...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("... Heavy created");
    }
}

class Normal {
    public Normal() {
        System.out.println("Creating Normal ...");
        System.out.println("... Normal created");
    }
}