Object lock = new Object();
synchronized (lock) {
}

11: monitorenter
12: aload_2
13: monitorexit

package com.leaderli.demo.lock;

public class CriticalSection {
    public static int ID = 0;
}

package com.leaderli.demo.lock;

public interface Lock {

    boolean lock();

    void unlock();
}

package com.leaderli.demo.util;

import java.util.Random;

public class SomeUtils {

    public static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static Random random = new Random();

    public static int random(int boundary) {
        return random.nextInt(boundary);
    }

    public static void logWithThread(Object msg) {
        System.out.println(Thread.currentThread() + "\t" + String.valueOf(msg));
    }

    public static void join(Thread thread) {
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

package com.leaderli.demo.lock;


import com.leaderli.demo.util.SomeUtils;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;

import java.util.ArrayList;
import java.util.List;

@SpringBootTest
class LockTest {
    @Autowired
    ApplicationContext applicationContext;


    int maxThreadCount = 10;
    int endID = 1000;
    //设置合适的值，确保持有锁期间，其他线程企图获取锁
    int randomBoundary = 10;

    @Test
    public void test() {
        Runnable task = () -> {
            //所有Lock实现类都为非单例，保证所有线程的锁不为同一个对象以模拟分布式锁
            Lock lock = applicationContext.getBean(Lock.class);
            while (true) {
                //不断消费序列号，直到测试结束
                if (task(lock)) {
                    return;
                }
            }

        };

        List<Thread> threadPool = new ArrayList<>();
        for (int i = 1; i <= maxThreadCount; i++) {
            Thread cosumer = new Thread(task);
            cosumer.setName((100 - i) + "");
            threadPool.add(cosumer);
        }
        threadPool.forEach(Thread::start);
        threadPool.forEach(SomeUtils::join);
        //断言程序是否正常结束
        Assertions.assertEquals(endID, CriticalSection.ID);
    }

    public boolean task(Lock lock) {
        if (lock.lock()) {
            //模拟重入锁
            if (SomeUtils.random(3) == 1) {
                if (task(lock)) {
                    return true;
                }
            }
            try {
                int a = CriticalSection.ID + 1;
                SomeUtils.sleep(SomeUtils.random(randomBoundary));
                if (CriticalSection.ID >= endID) {
                    //达到最大值，测试结束
                    return true;
                }
                CriticalSection.ID++;
                if (a != CriticalSection.ID) {
                    //断言失败，结束程序
                    return true;
                }
            } finally {
                lock.unlock();
            }
        }
        return false;
    }
}

package com.leaderli.demo.lock;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Component;

@ConditionalOnProperty(prefix = "lock", name = "use", havingValue = "nolock")
@Component
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class NoLock implements Lock {

    @Override
    public boolean lock() {
        return true;
    }

    @Override
    public void unlock() {
    }
}

package com.leaderli.demo.bool;


import java.util.Arrays;
import java.util.function.Predicate;

public class PipeLine<T> {


    /**
     * 在调用end时，需要找到第一个节点进行运算
     */
    private PipeLine<T> prev;
    /**
     * 存储结果，仅在显式new PipeLine时初始化
     */
    private Bool bool;
    /**
     * 每个PipeLine绑定一个操作
     */
    private Sink<T> sink;


    private PipeLine(Bool bool) {
        this.bool = bool;
    }

    public PipeLine() {
        this.bool = new Bool();
        begin();
    }

    /**
     * 本身不做任何逻辑运算，仅锚定开始位置
     */
    private void begin() {
        this.sink = new Sink<T>(bool, Sink.Type.BEGIN) {
            @Override
            public Sink<T> accept(T test) {
                return next;
            }

            @Override
            public void valid() {
                valid(Type.TEST, Type.NOT);

            }
        };
        this.prev = null;
    }

    /**
     * 实现链表
     *
     * @param sink 当前运算逻辑
     * @param type 运算结果
     * @return 新增链表节点并返回
     */
    private PipeLine<T> add(Sink<T> sink, Sink.Type type) {
        PipeLine<T> pipeLine = new PipeLine<>(this.bool);
        pipeLine.prev = this;
        pipeLine.sink = sink;
        return pipeLine;
    }

    public PipeLine<T> test(Predicate<T> predicate) {
        assert predicate != null;
        Sink<T> sink = new Sink<T>(bool, Sink.Type.TEST) {
            @Override
            public void valid() {
                valid(Type.END, Type.AND, Type.OR);
            }
        };
        sink.predicate = predicate;
        return add(sink, Sink.Type.TEST);
    }

    /**
     * 对于or来说，如果上一个运算逻辑为true，则整个表达式都为true，所以可以直接结束
     * 否则可以直接忽略or操作前面的运算结果
     */
    public PipeLine<T> or() {
        Sink<T> sink = new Sink<T>(bool, Sink.Type.OR) {
            @Override
            public boolean cancel(Bool bool) {
                return bool.result;
            }

            @Override
            public Sink<T> accept(T test) {
                return this.next;
            }

            @Override
            public void valid() {
                valid(Type.TEST, Type.NOT);
            }
        };
        return add(sink, Sink.Type.OR);
    }

    /**
     * 返回下一个test的否定
     */
    public PipeLine<T> not() {
        Sink<T> sink = new Sink<T>(bool, Sink.Type.NOT) {

            @Override
            public Sink<T> accept(T test) {
                Sink<T> sink = this.next;
                this.next = new Sink<T>(bool, Type.TEST) {
                    @Override
                    public Sink<T> accept(T test) {
                        Sink<T> accept = sink.accept(test);
                        this.bool.result = !this.bool.result;
                        return accept;
                    }
                };
                return this.next;
            }

            @Override
            public void valid() {
                valid(Type.TEST);
            }
        };
        return add(sink, Sink.Type.NOT);
    }

    /**
     * 对于or来说，如果上一个运算逻辑为false，则整个表达式都为false，所以可以直接结束
     * 否则可以直接忽略or操作前面的运算结果
     */
    public PipeLine<T> and() {
        Sink<T> sink = new Sink<T>(bool, Sink.Type.AND) {

            @Override
            public boolean cancel(Bool bool) {
                return !bool.result;
            }

            @Override
            public Sink<T> accept(T test) {
                return this.next;
            }

            @Override
            public void valid() {
                valid(Type.TEST, Type.NOT);


            }
        };
        return add(sink, Sink.Type.OR);
    }

    /**
     * 向前查找PipeLine，同时将Sink链接起来
     *
     * @return 返回链表第一个节点，即BEGIN
     */
    public PipeLine<T> end() {
        PipeLine<T> pipeLine = this;
        Sink<T> temp = pipeLine.sink;
        //最后一个操作执行一个一定会cancel的终结节点
        temp.next = new Sink<T>(bool, Sink.Type.END) {
            @Override
            public boolean cancel(Bool result) {
                return true;
            }
        };
        PipeLine<T> pr = pipeLine.prev;
        while (pr != null) {
            pipeLine = pr;
            pr = pipeLine.prev;
            pipeLine.sink.next = temp;
            temp = pipeLine.sink;
        }
        pr = null;
        return pipeLine;
    }

    /**
     * 依次执行Sink，直到触发cancel或者所有Sink执行完成,支持多次操作
     *
     * @param test 数据
     * @return 逻辑运算结果
     */
    public boolean accept(T test) {
        return forSink(sink, test);
    }

    private static class Bool {
        boolean result = false;
    }

    private static class Sink<T> {
        /**
         * 标记操作的类型，主要用来校验表达式是否合法
         */
        public enum Type {
            BEGIN,
            TEST,
            NOT,
            OR,
            END,
            AND
        }

        protected Type type;

        public Sink(Bool bool, Type type) {
            this.bool = bool;
            this.type = type;
        }

        Bool bool;
        Predicate<T> predicate;
        /**
         * 使用链表的方式，将所有操作步骤串联起来
         */
        Sink<T> next;

        /**
         * 是否需要提前结束表达式
         */
        public boolean cancel(Bool result) {
            return false;
        }

        /**
         * @param test 断言
         * @return 返回下一个操作
         */
        public Sink<T> accept(T test) {
            this.bool.result = this.predicate.test(test);
            return next;
        }

        /**
         * 表达式是否合法，一般只需要考虑当前类型操作的下一个操作类型可以为
         */
        public void valid() {
        }

        void valid(Type... types) {
            if (next == null) {
                throw new IllegalStateException("must have end()");
            }
            if (Arrays.stream(types).noneMatch(type -> next.type == type)) {
                throw new IllegalStateException(type + " --> " + Arrays.toString(types) + "; actual is : " + next.type);
            }
        }

    }

    private boolean forSink(Sink<T> sink, T test) {
        while (sink != null) {
            sink.valid();
            if (sink.cancel(bool)) {
                break;
            }
            sink = sink.accept(test);
        }
        return bool.result;
    }

}

@Component
public class BeAutowired {
    static {
        System.out.println("-------BeAutowired--------");
    }
}

@Component
@Lazy
public class Person {
    @Autowired
    BeAutowired beAutowired;
    @PostConstruct
    public void begin(){
        System.out.println(" beAutowired= " + beAutowired);
    }
}

public static void main(String[] args) {
    String packageName = Person.class.getPackage().getName();
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(packageName);
    Person person = context.getBean(Person.class);
    System.out.println("person = " + person);
}

//交由BeanFactory去加载
@Override
public <T> T getBean(Class<T> requiredType) throws BeansException {
    assertBeanFactoryActive();
    return getBeanFactory().getBean(requiredType);
}

public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
        throws BeansException {

    return doGetBean(name, requiredType, args, false);
}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

    final String beanName = transformedBeanName(name);
    Object bean;

    // 1. 如果是单例模式的，则尝试从缓存中获取bean
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                        "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        // Fail if we're already creating this bean instance:
        // We're assumably within a circular reference.
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // 2. 尝试从父类BeanFactory中加载bean
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else if (requiredType != null) {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }

        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // 3. 加载依赖bean， @DependsOn注解的bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

            // 4. 加载单例bean
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        // Explicitly remove instance from singleton cache: It might have been put there
                        // eagerly by the creation process, to allow for circular reference resolution.
                        // Also remove any beans that received a temporary reference to the bean.
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }

            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }

            else {
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }
                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) {
                    throw new BeanCreationException(beanName,
                            "Scope '" + scopeName + "' is not active for the current thread; consider " +
                            "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                            ex);
                }
            }
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    // Check if required type matches the type of the actual bean instance.
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return convertedBean;
        }
        catch (TypeMismatchException ex) {
            if (logger.isTraceEnabled()) {
                logger.trace("Failed to convert bean '" + name + "' to required type '" +
                        ClassUtils.getQualifiedName(requiredType) + "'", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
        throws BeanCreationException {

    // 1. 使用构造器实例化`bean`
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Post-processing of merged bean definition failed", ex);
            }
            mbd.postProcessed = true;
        }
    }

    //这里主要解决循环依赖的问题，这里不做深入讨论
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        if (logger.isTraceEnabled()) {
            logger.trace("Eagerly caching bean '" + beanName +
                    "' to allow for resolving potential circular references");
        }
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        //2. 对bean进行数据的初始化操作，比如加载@autowire的bean，@value的属性赋值，@PostConstruct方法执行等
        populateBean(beanName, mbd, instanceWrapper);
        //3. 执行BeanDefinition中定义的initMethod，一般在xml配置中，或者@Bean(initMethod = "initMethod")中定义的方法名
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        }
        else {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }

    if (earlySingletonExposure) {
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName,
                            "Bean with name '" + beanName + "' has been injected into other beans [" +
                            StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                            "] in its raw version as part of a circular reference, but has eventually been " +
                            "wrapped. This means that said other beans do not use the final version of the " +
                            "bean. This is often the result of over-eager type matching - consider using " +
                            "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                }
            }
        }
    }

    // Register bean as disposable.
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    if (bw == null) {
        if (mbd.hasPropertyValues()) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
        }
        else {
            // Skip property population phase for null instance.
            return;
        }
    }

    // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
    // state of the bean before properties are set. This can be used, for example,
    // to support styles of field injection.
    boolean continueWithPropertyPopulation = true;

    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    continueWithPropertyPopulation = false;
                    break;
                }
            }
        }
    }

    if (!continueWithPropertyPopulation) {
        return;
    }

    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

    int resolvedAutowireMode = mbd.getResolvedAutowireMode();
    if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        // Add property values based on autowire by name if applicable.
        if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }
        // Add property values based on autowire by type if applicable.
        if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }
        pvs = newPvs;
    }

    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

    PropertyDescriptor[] filteredPds = null;
    if (hasInstAwareBpps) {
        if (pvs == null) {
            pvs = mbd.getPropertyValues();
        }
        //对满足条件的BeanPostProcessor，执行postProcessProperties方法，对bean的属性进行赋值操作
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                if (pvsToUse == null) {
                    if (filteredPds == null) {
                        filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                    }
                    pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        return;
                    }
                }
                pvs = pvsToUse;
            }
        }
    }
    if (needsDepCheck) {
        if (filteredPds == null) {
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        }
        checkDependencies(beanName, mbd, filteredPds, pvs);
    }

    if (pvs != null) {
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    }
    else {
        //1. 若接口实现了`Aware`，则执行对应的方法
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        2. 执行所有`BeanPostProcessor`的`postProcessBeforeInitialization`方法
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        3. 执行`BeanDefinition`中定义的`init-method`
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }
    if (mbd == null || !mbd.isSynthetic()) {
        4. 执行所有`BeanPostProcessor`的`postProcessAfterInitialization`方法
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

void setInitMethodName(@Nullable String initMethodName);

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    //查找是否有@PostConstruct注解的方法
    LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
    try {
        //执行所有被注解了@PostConstruct的方法
        metadata.invokeInitMethods(bean, beanName);
    }
    catch (InvocationTargetException ex) {
        throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
    }
    return bean;
}

private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
    //是否有指定注解的方法存在
    if (!AnnotationUtils.isCandidateClass(clazz, Arrays.asList(this.initAnnotationType, this.destroyAnnotationType))) {
        return this.emptyLifecycleMetadata;
    }

    List<LifecycleElement> initMethods = new ArrayList<>();
    List<LifecycleElement> destroyMethods = new ArrayList<>();
    Class<?> targetClass = clazz;

    do {
        final List<LifecycleElement> currInitMethods = new ArrayList<>();
        final List<LifecycleElement> currDestroyMethods = new ArrayList<>();

        ReflectionUtils.doWithLocalMethods(targetClass, method -> {
            if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
                LifecycleElement element = new LifecycleElement(method);
                currInitMethods.add(element);
                if (logger.isTraceEnabled()) {
                    logger.trace("Found init method on class [" + clazz.getName() + "]: " + method);
                }
            }
            if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
                currDestroyMethods.add(new LifecycleElement(method));
                if (logger.isTraceEnabled()) {
                    logger.trace("Found destroy method on class [" + clazz.getName() + "]: " + method);
                }
            }
        });
        //将扫描到的init,destroy方法放入LifecycleMetadata
        initMethods.addAll(0, currInitMethods);
        destroyMethods.addAll(currDestroyMethods);
        targetClass = targetClass.getSuperclass();
    }
    while (targetClass != null && targetClass != Object.class);

    return (initMethods.isEmpty() && destroyMethods.isEmpty() ? this.emptyLifecycleMetadata :
            new LifecycleMetadata(clazz, initMethods, destroyMethods));
}

public CommonAnnotationBeanPostProcessor() {
    setOrder(Ordered.LOWEST_PRECEDENCE - 3);
    setInitAnnotationType(PostConstruct.class);
    setDestroyAnnotationType(PreDestroy.class);
    ignoreResourceType("javax.xml.ws.WebServiceContext");
}

|--------------------------------------------------------------|
|                     Object Header (64 bits)                  |
|------------------------------------|-------------------------|
|        Mark Word (32 bits)         |    Klass Word (32 bits) |
|------------------------------------|-------------------------|

|---------------------------------------------------------------------------------|
|                                 Object Header (96 bits)                         |
|--------------------------------|-----------------------|------------------------|
|        Mark Word(32bits)       |    Klass Word(32bits) |  array length(32bits)  |
|--------------------------------|-----------------------|------------------------|

|-------------------------------------------------------|--------------------|
|                  Mark Word (32 bits)                  |       State        |
|-------------------------------------------------------|--------------------|
| identity_hashcode:25 | age:4 | biased_lock:1 | lock:2 |       Normal       |
|-------------------------------------------------------|--------------------|
|  thread:23 | epoch:2 | age:4 | biased_lock:1 | lock:2 |       Biased       |
|-------------------------------------------------------|--------------------|
|               ptr_to_lock_record:30          | lock:2 | Lightweight Locked |
|-------------------------------------------------------|--------------------|
|               ptr_to_heavyweight_monitor:30  | lock:2 | Heavyweight Locked |
|-------------------------------------------------------|--------------------|
|                                              | lock:2 |    Marked for GC   |
|-------------------------------------------------------|--------------------|

|------------------------------------------------------------------------------|--------------------|
|                                  Mark Word (64 bits)                         |       State        |
|------------------------------------------------------------------------------|--------------------|
| unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1 | lock:2 |       Normal       |
|------------------------------------------------------------------------------|--------------------|
| thread:54 |       epoch:2        | unused:1 | age:4 | biased_lock:1 | lock:2 |       Biased       |
|------------------------------------------------------------------------------|--------------------|
|                       ptr_to_lock_record:62                         | lock:2 | Lightweight Locked |
|------------------------------------------------------------------------------|--------------------|
|                     ptr_to_heavyweight_monitor:62                   | lock:2 | Heavyweight Locked |
|------------------------------------------------------------------------------|--------------------|
|                                                                     | lock:2 |    Marked for GC   |
|------------------------------------------------------------------------------|--------------------|

public class Permission {
    // 是否允许查询
    private boolean allowSelect;
    // 是否允许新增
    private boolean allowInsert;
    // 是否允许删除
    private boolean allowDelete;
    // 是否允许更新
    private boolean allowUpdate;
}

public class NewPermission {
    // 是否允许查询，二进制第1位，0表示否，1表示是
    public static final int ALLOW_SELECT = 1 << 0; // 0001
    // 是否允许新增，二进制第2位，0表示否，1表示是
    public static final int ALLOW_INSERT = 1 << 1; // 0010
    // 是否允许修改，二进制第3位，0表示否，1表示是
    public static final int ALLOW_UPDATE = 1 << 2; // 0100
    // 是否允许删除，二进制第4位，0表示否，1表示是
    public static final int ALLOW_DELETE = 1 << 3; // 1000
    // 存储目前的权限状态
    private int flag；
    /**
        *  重新设置权限
        */
    public void setPermission(int permission) {
        flag = permission;
    }
    /**
        *  添加一项或多项权限
        */
    public void enable(int permission) {
        flag |= permission;
    }
    /**
        *  删除一项或多项权限
        */
    public void disable(int permission) {
        flag &= ~permission;
    }
    /**
        *  是否拥某些权限
        */
    public boolean isAllow(int permission) {
        return (flag & permission) == permission;
    }
    /**
        *  是否禁用了某些权限
        */
    public boolean isNotAllow(int permission) {
        return (flag & permission) == 0;
    }
    /**
        *  是否仅仅拥有某些权限
        */
    public boolean isOnlyAllow(int permission) {
        return flag == permission;
    }
}

public void enable(int permission) {
    flag |= permission; // 相当于flag = flag | permission;
}

permission.enable(NewPermission.ALLOW_UPDATE);

permission.enable(NewPermission.ALLOW_INSERT
    | NewPermission.ALLOW_UPDATE | NewPermission.ALLOW_DELETE);

permission.setAllowInsert(true);
permission.setAllowUpdate(true);
permission.setAllowDelete(true);

permission.setAllowSelect(true);
permission.setAllowInsert(true);
permission.setAllowUpdate(false);
permission.setAllowDelete(false);

permission.setPermission(NewPermission.ALLOW_SELECT | NewPermission.ALLOW_INSERT);

if (permission.isAllowSelect() && permission.isAllowInsert() && permission.isAllowUpdate())

if (permission. isAllow (NewPermission.ALLOW_SELECT
    | NewPermission.ALLOW_INSERT | NewPermission.ALLOW_UPDATE))

if (permission.isAllowSelect() && permission.isAllowInsert()
    && !permission.isAllowUpdate() && !permission.isAllowDelete())

if (permission. isOnlyAllow (NewPermission.ALLOW_SELECT | NewPermission.ALLOW_INSERT))