深入了解spring中的FactoryBean(二)

最新推荐文章于 2025-02-03 20:46:03 发布
原创 最新推荐文章于 2025-02-03 20:46:03 发布 · 224 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细探讨了Spring框架中FactoryBean的工作原理，通过`DefaultListableBeanFactory`的`resolveBean`方法追踪到`getObject`的调用，揭示了如何从FactoryBean获取实际的bean实例。在`doGetObjectFromFactoryBean`方法中，最终调用了FactoryBean的`getObject`方法，实现了对`PersionService`实例的获取。整个过程展示了Spring如何处理FactoryBean及其对象的创建和管理。

在深入了解spring的FactoryBean(一)中我们提到了NamedBeanHolder这个类。

看下NamedBeanHolder类

public class NamedBeanHolder<T> implements NamedBean {

	private final String beanName;

	private final T beanInstance;

	/**
	 * Create a new holder for the given bean name plus instance.
	 * @param beanName the name of the bean
	 * @param beanInstance the corresponding bean instance
	 */
	public NamedBeanHolder(String beanName, T beanInstance) {
		Assert.notNull(beanName, "Bean name must not be null");
		this.beanName = beanName;
		this.beanInstance = beanInstance;
	}
	/**
	 * Return the name of the bean.
	 */
	@Override
	public String getBeanName() {
		return this.beanName;
	}
	/**
	 * Return the corresponding bean instance.
	 */
	public T getBeanInstance() {
		return this.beanInstance;
	}
}

以上一篇为例子：beanName则是MyFactoryBean，beanInstance则为PersionService,那么这个PersionService实例是怎么获取到的呢？具体如何调用MyFactoryBean的getObject方法呢？

DefaultListableBeanFactory#resolveBean()

    @Nullable
    private <T> T resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) {
        NamedBeanHolder<T> namedBean = this.resolveNamedBean(requiredType, args, nonUniqueAsNull);
        if (namedBean != null) {
            return namedBean.getBeanInstance();
        } else {
            BeanFactory parent = this.getParentBeanFactory();
            if (parent instanceof DefaultListableBeanFactory) {
                return ((DefaultListableBeanFactory)parent).resolveBean(requiredType, args, nonUniqueAsNull);
            } else if (parent != null) {
                ObjectProvider<T> parentProvider = parent.getBeanProvider(requiredType);
                if (args != null) {
                    return parentProvider.getObject(args);
                } else {
                    return nonUniqueAsNull ? parentProvider.getIfUnique() : parentProvider.getIfAvailable();
                }
            } else {
                return null;
            }
        }
    }

NamedBeanHolder namedBean = this.resolveNamedBean(requiredType, args, nonUniqueAsNull);
这行代码封装了NamedBeanHolder，我们跟进去看看。

DefaultListableBeanFactory#resolveNamedBean()

    private <T> NamedBeanHolder<T> resolveNamedBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) throws BeansException {
        Assert.notNull(requiredType, "Required type must not be null");
        String[] candidateNames = this.getBeanNamesForType(requiredType);
        String[] var6;
        int var7;
        int var8;
        String beanName;
        if (candidateNames.length > 1) {
            List<String> autowireCandidates = new ArrayList(candidateNames.length);
            var6 = candidateNames;
            var7 = candidateNames.length;

            for(var8 = 0; var8 < var7; ++var8) {
                beanName = var6[var8];
                if (!this.containsBeanDefinition(beanName) || this.getBeanDefinition(beanName).isAutowireCandidate()) {
                    autowireCandidates.add(beanName);
                }
            }

            if (!autowireCandidates.isEmpty()) {
                candidateNames = StringUtils.toStringArray(autowireCandidates);
            }
        }

        if (candidateNames.length == 1) {
            String beanName = candidateNames[0];
            return new NamedBeanHolder(beanName, this.getBean(beanName, requiredType.toClass(), args));
        } else {
            if (candidateNames.length > 1) {
                Map<String, Object> candidates = new LinkedHashMap(candidateNames.length);
                var6 = candidateNames;
                var7 = candidateNames.length;

                for(var8 = 0; var8 < var7; ++var8) {
                    beanName = var6[var8];
                    if (this.containsSingleton(beanName) && args == null) {
                        Object beanInstance = this.getBean(beanName);
                        candidates.put(beanName, beanInstance instanceof NullBean ? null : beanInstance);
                    } else {
                        candidates.put(beanName, this.getType(beanName));
                    }
                }

                String candidateName = this.determinePrimaryCandidate(candidates, requiredType.toClass());
                if (candidateName == null) {
                    candidateName = this.determineHighestPriorityCandidate(candidates, requiredType.toClass());
                }

                if (candidateName != null) {
                    Object beanInstance = candidates.get(candidateName);
                    if (beanInstance == null || beanInstance instanceof Class) {
                        beanInstance = this.getBean(candidateName, requiredType.toClass(), args);
                    }

                    return new NamedBeanHolder(candidateName, beanInstance);
                }

                if (!nonUniqueAsNull) {
                    throw new NoUniqueBeanDefinitionException(requiredType, candidates.keySet());
                }
            }

            return null;
        }
    }

上节中我们说到String[] candidateNames = this.getBeanNamesForType(requiredType);返回的是FactoryBean的name(对应我们的例子是MyFactoryBean)，而在
return new NamedBeanHolder(beanName, this.getBean(beanName, requiredType.toClass(), args)); 代码中用了有参构造函数封装了NamedBeanHolder，beanName就是我们的MyFactoryBean，下面分析下this.getBean();

AbstractBeanFactory#getBean

	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;

		// Eagerly check singleton cache for manually registered singletons.
		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);
			}

			// Check if bean definition exists in this factory.
			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);

				// Guarantee initialization of beans that the current bean depends on.
				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);
						}
					}
				}

				// Create bean instance.
				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;
	}

在bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); 中 四个参数 sharedInstance(MyFactoryBean.class),name(&MyFactoryBean),beanName(MyFactoryBean),接下来看这个方法。

AbstractAutowireCapableBeanFactory#getObjectForBeanInstance()

	protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		String currentlyCreatedBean = this.currentlyCreatedBean.get();
		if (currentlyCreatedBean != null) {
			registerDependentBean(beanName, currentlyCreatedBean);
		}

		return super.getObjectForBeanInstance(beanInstance, name, beanName, mbd);
	}

这个方法没有什么内容，我们接着看super.getObjectForBeanInstance(beanInstance, name, beanName, mbd)方法。

AbstractBeanFactory#getObjectForBeanInstance()

	protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		// 如果bean不是工厂，不让其往下执行了
		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
			
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
			}
		}

		//现在我们有了个bean的实例，这个实例可能会是正常的bean或者FactoryBean。如果是FactoryBean我们使用它创建实例，但是如果用户想要
		//直接获取工厂实例而不是工厂的getObject方法对应的实例，那么传入的name应该加个前缀&
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}

		Object object = null;
		if (mbd == null) {
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			// Return bean instance from factory.
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// Caches object obtained from FactoryBean if it is a singleton.
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

FactoryBeanRegistrySupport#getObjectFromFactoryBean()

	protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		if (factory.isSingleton() && containsSingleton(beanName)) {
			synchronized (getSingletonMutex()) {
				Object object = this.factoryBeanObjectCache.get(beanName);
				if (object == null) {
					object = doGetObjectFromFactoryBean(factory, beanName);
					// Only post-process and store if not put there already during getObject() call above
					// (e.g. because of circular reference processing triggered by custom getBean calls)
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
					if (alreadyThere != null) {
						object = alreadyThere;
					}
					else {
						if (shouldPostProcess) {
							if (isSingletonCurrentlyInCreation(beanName)) {
								// Temporarily return non-post-processed object, not storing it yet..
								return object;
							}
							beforeSingletonCreation(beanName);
							try {
								object = postProcessObjectFromFactoryBean(object, beanName);
							}
							catch (Throwable ex) {
								throw new BeanCreationException(beanName,
										"Post-processing of FactoryBean's singleton object failed", ex);
							}
							finally {
								afterSingletonCreation(beanName);
							}
						}
						if (containsSingleton(beanName)) {
							this.factoryBeanObjectCache.put(beanName, object);
						}
					}
				}
				return object;
			}
		}
		else {
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			if (shouldPostProcess) {
				try {
					object = postProcessObjectFromFactoryBean(object, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
				}
			}
			return object;
		}
	}

FactoryBeanRegistrySupport#doGetObjectFromFactoryBean()

	private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
			throws BeanCreationException {

		Object object;
		try {
			if (System.getSecurityManager() != null) {
				AccessControlContext acc = getAccessControlContext();
				try {
					object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				object = factory.getObject();
			}
		}
		catch (FactoryBeanNotInitializedException ex) {
			throw new BeanCurrentlyInCreationException(beanName, ex.toString());
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
		}

		// Do not accept a null value for a FactoryBean that's not fully
		// initialized yet: Many FactoryBeans just return null then.
		if (object == null) {
			if (isSingletonCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(
						beanName, "FactoryBean which is currently in creation returned null from getObject");
			}
			object = new NullBean();
		}
		return object;
	}

经过重重跟踪，在doGetObjectFromFactoryBean()方法中终于找到了我们想要的方法object = factory.getObject(); 至此我们终于知道是如何获取到PersionService了。

Spring-IOC之BeanDefinitionHolder
九师兄
02-01 1259
1.美图 2.概述 BeanDefinitionHolder顾名思义就是对BeanDefinition的持有，同时持有的包括BeanDefinition的名称和别名，BeanDefinitionHolder同时实现了BeanMetadataElement，BeanMetadataElement 3.源码 //实现了BeanMetadataElement接口 public class BeanDe...
Java对象拷贝的那些事以及必坑指南
qq_37080455的博客
06-06 1058
在工作中经常会涉及到对象的复制和拷贝。特别是在调用外部的RPC接口时，经常不会直接使用调用结果的dto，而是按照需要自己定义的需要的字段，包装成新的dto,用于后续的业务，进行逻辑处理。在这中间就涉及到对象复制的问题。不仅仅局限于调用远程接口，在实际的开发中的一些增删改查操作，也涉及到对对象复制的操作。总之，对象复制是在工作中非常常用的一个操作。需要我们重视。 浅拷贝：使用一个已知实例对新创建实例的成员变量逐个赋值，这个方式被称为浅拷贝。 深拷贝：当一个类的拷贝构造方法，不仅要复制对象的
Spring源码：bean的生命周期（一）
有志者事竟成
05-14 215
本节将正式介绍Spring源码细节，将讲解Bean生命周期。请注意，虽然我们不希望过于繁琐地理解Spring源码，但也不要认为Spring源码很简单。在本节中，我们将主要讲解Spring 5.3.10版本的源代码。如果您看到的代码与我讲解的不同，也没有关系，因为其中的原理和业务逻辑基本相同。为了更好地理解，我们将先讲解Bean的生命周期，再讲解Spring的启动原理和流程，因为启动是准备工作的一部分。
ApplicationContextAware构建BeanHolder
zhaoyaxuan001的博客
05-16 348
Author：赵志乾 Date：2019-05-16 Declaration：All Right Reserved！！！ 基于Spring框架的实际项目，会将Bean放入IoC容器进行统一管理(包括依赖管理和生命周期管理)。而从IoC容器中获取需要的Bean则主要是通过容器接口ApplicationContext。 Web项目中，通常都是由Web容器和Spring IoC容器相互配合完成B...
SpringContextHolder直接从spring容器中获取bean
jasnet_u的博客
07-29 633
SpringContextHolder直接从spring容器中获取bean 创建类 SpringContextHolder import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.
spring源码解读之getBean方法（一）
wangjimmy1994的博客
05-07 4686
前言 大家使用spring，最常接触到的就是bean，大家也知道spring中用一句getBean就能取出一个实例化好的bean，这个bean是属于IOC容器管理的，那么大家有没有看过getBean方法的源码呢，知不知道spring容器到底是怎么得到一个实例化好的bean的呢，这一次，我和大家一起来研究getBean方法的源码 开始 首先我来一段非常简单的代码 //我是用注解方式配置的a...
深入了解Spring中的FactoryBean
08-25
深入了解Spring中的FactoryBean FactoryBean是一个非常重要的概念，在Spring框架中扮演着核心角色。它提供了一种灵活的方式来创建和管理对象实例。在本篇文章中，我们将深入了解FactoryBean的概念和应用。 一、...
spring中FactoryBean中的getObject()方法实例解析
08-28
今天，我们将深入探讨 FactoryBean 中的 getObject() 方法实例解析，了解它的工作机制和应用场景。 FactoryBean 接口定义了三个重要的方法：getObject()、isSingleton() 和 getObjectType()。其中，getObject() ...
深入理解Spring框架中FactoryBean的实现原理
在深入了解FactoryBean的工作原理以及如何使用它之前，我们首先需要了解Spring IoC容器（控制反转）的概念和基本操作。 Spring IoC容器是Spring框架的核心，它负责管理对象的生命周期和对象间的依赖关系。开发者...
深入探究 Spring 中 FactoryBean 注册服务的实现与原理
最新发布
shaozheng0503的博客
02-03 1118
Class<?} else {try {= null) {// 如果是 FactoryBean，则需要调用 FactoryBean#getObjectif (!@Override@Override@Override@Override@Override通过对注册服务的深入分析，我们了解到 Spring 框架通过接口、类和类的协作，提供了一种灵活、高效的对象创建和管理方式。
spring中的BeanFactory与FactoryBean的讲解
08-26
Spring中的BeanFactory与...总结：今天，我们探讨了Spring中的BeanFactory和FactoryBean这两个概念，了解了它们在Spring IOC容器中的角色和作用。希望本文的内容对大家的学习或者工作具有一定的参考学习价值。
Spring在web项目中配置的几种方式的分析
chenj8211的专栏
12-15 251
1、 配置在web.xml中 a) 定义成listene org.springframework.web.context.ContextLoaderListener b) 定义成servlet SpringContextServlet org.springframework.web.context.ContextLoaderServlet...
aop创建代理对象核心源码分析-23
u012222011的博客
02-20 141
在此处打断点，不要在 new classpathxmlApplication打断点，入如果这样的话，会导致进入很多断点 UserService userService = acx.getBean(UserService.class); 349 Object resolved = resolveBean(ResolvableType.forRawClass(requiredType), args, false); 420 NamedBeanHolder<T> namedBean = ...
使用SpringContextHolder获取bean实例
热门推荐
滚蛋吧，生活。
11-23 5万+
使用SpringContextHolder获取bean实例
bean标签的解析及注册——BeanDefinitionHolder
JAVA圈的博客
06-08 3241
1、默认标签的解析在parseBeanDefinitions(root, this.delegate)，主要对import、alias、bean、beans进行不同的处理2、bean标签解析bean解析最为复杂2.1、解析通过BeanDefinitionParserDelegate的parseBeanDefinitionElement进行元素解析，并返回BeanDefinitionHolder，通...
DynaBeanHolder动态bean构造器实现
Jevons’ Blog
02-20 423
转载请注明出处：https://blog.youkuaiyun.com/jevons优快云/article/details/87824271 【Jevons’Blog】 依赖包： commons-logging.jar commons-beanutils-1.8.0-BETA.jar cglib-nodep-3.2.10.jar 辅助包： fastjson-1.1.39.jar 优化复制方法...
Spring源码学习--BeanDefinitionHolder
井底之蛙
06-27 6124
上一篇博客Spring源码学习--Bean注入解析结果BeanDefinition我们已经介绍了BeanDefinition相关的知识，这边博客我们介绍一下BeanDefinitionHolder，简单来说其就是一个BeanDefinition的持有者，其定义了一下变量，并对以下变量提供get和set操作。private final BeanDefinition beanDefinition;
spring源码--IOC容器的实现:概述(2)
jackllvv的博客
06-11 357
引言 上一篇分析了springIOC相关的核心接口，下面分析一下这些接口中用到的一些相关的类。 boolean BeanFactory .isTypeMatch(String name, ResolvableType typeToMatch) ResolvableType 可以看做spring对class类的增强，提供了一些spring需要的一些方法。比如: – boolean isA...
死磕Spring原理 -- 注入过程详解
wwjjhh的博客
08-17 898
本文着重分析执行流程。 DI流程简介 ioc容器：BeanFactory，工厂容器 初始化获取BeanDefinition：InstantiationStrategy，实例化策略 依赖注入：AbstractPropertyAccessor，属性访问器，用于各种方式的注入，如setter方法注入，构造器注入等 实例化Bean：BeanWrapper，Bean的包装类 DI过程概述 核心方法getBean() 非lazyInit在refresh的方法finishBeanFactoryInitializat
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_当i已成往事

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值