class IocKit {

    /**
     * Get @Inject Annotated field
     *
     * @param ioc         ioc container
     * @param classDefine classDefine
     * @return return FieldInjector
     */
    private static List<FieldInjector> getInjectFields(Ioc ioc, ClassDefine classDefine) {
        List<FieldInjector> injectors = new ArrayList<>();
        for (Field field : classDefine.getDeclaredFields()) {
            if (null != field.getAnnotation(InjectWith.class) || null != field.getAnnotation(Inject.class)) {
                injectors.add(new FieldInjector(ioc, field));
            }
        }
        if (injectors.size() == 0) {
            return new ArrayList<>();
        }
        return injectors;
    }

    /**
     * Get @Value Annotated field
     *
     * @param environment
     * @param classDefine
     * @return
     */
    private static List<ValueInjector> getValueInjectFields(Environment environment, ClassDefine classDefine) {
        List<ValueInjector> valueInjectors = new ArrayList<>(8);
        //handle class annotation
        if (null != classDefine.getType().getAnnotation(Value.class)) {
            String suffix = classDefine.getType().getAnnotation(Value.class).name();
            Arrays.stream(classDefine.getDeclaredFields()).forEach(field -> valueInjectors.add(
                    new ValueInjector(environment, field, suffix + "." + field.getName())
            ));
        } else {
            Arrays.stream(classDefine.getDeclaredFields()).
                    filter(field -> null != field.getAnnotation(Value.class)).
                    map(field -> new ValueInjector(
                            environment, field, field.getAnnotation(Value.class).name())
                    ).forEach(valueInjectors::add);
        }
        return valueInjectors;
    }

    public static void injection(Ioc ioc, BeanDefine beanDefine) {
        ClassDefine         classDefine    = ClassDefine.create(beanDefine.getType());
        List<FieldInjector> fieldInjectors = getInjectFields(ioc, classDefine);

        Object bean = beanDefine.getBean();
        fieldInjectors.forEach(fieldInjector -> {
            Object fieldInstance = ReflectKit.newInstance(fieldInjector.getType());
            if (fieldInjector.hasInjectFields()) {
                injection(ioc, new BeanDefine(fieldInstance));
            }
            fieldInjector.injection(bean, fieldInstance);
        });
    }

    public static void initInjection(Ioc ioc, BeanDefine beanDefine) {<FILL_FUNCTION_BODY>}

    public static void injectionValue(Environment environment, BeanDefine beanDefine) {
        ClassDefine         classDefine = ClassDefine.create(beanDefine.getType());
        List<ValueInjector> valueFields = getValueInjectFields(environment, classDefine);

        Object bean = beanDefine.getBean();

        valueFields.forEach(fieldInjector -> fieldInjector.injection(bean));
    }

    public static boolean isSingleton(Class<?> type) {
        return true;
    }

}

        ClassDefine         classDefine    = ClassDefine.create(beanDefine.getType());
        List<FieldInjector> fieldInjectors = getInjectFields(ioc, classDefine);

        Object bean = beanDefine.getBean();

        AtomicBoolean hasPrototypeField = new AtomicBoolean(false);

        fieldInjectors.forEach(fieldInjector -> {
            if (fieldInjector.isSingleton()) {
                fieldInjector.injection(bean);
            } else {
                hasPrototypeField.set(true);
            }
        });

        beanDefine.setFieldHasPrototype(hasPrototypeField.get());
    
<no_super_class>