Spring源码之注解扫描Component-scan

本文主要介绍Spring的component-scan标签，了解spring是如何实现扫描注解进行bean的注册，主要实现实在 NamespaceHandler, NamespaceHandlerSupport 和 BeanDefinitionParser 三个接口中，还需要配置spring.handlers文件，在接下里的源码解析中会详细解析，在本篇博客中将使用ApplicationConntext作为起点，直接从差异开始讲解，如果想了解ApplicationContext 源码的全流程请看上篇博客。

GItHub:https://github.com/lantaoGitHub/spring-framework.git

这里解析解释一下他们之间的关系：

NamespaceHandlerSupport 是 Abstract 修饰的抽象类 并 实现 NamespaceHandler 接口，继而实现了 NamespaceHandler接口的parser和docreate方法，自定的NamespaceHandler需要继承NamespaceHandlerSupport类并需要实现NamespaceHandler接口的init方法，init方法需要做解析类的注册操作，代码如下：

package org.springframework.context.config;import org.springframework.beans.factory.
/** * Subclasses can call this to register the supplied {@link BeanDefinitionParser} to * handle the specified element. The element name is the local (non-namespace qualified) * name. */protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {	this.parsers.put(elementName, parser);}

BeanDefinitionParser类是解析类的顶层接口，自定义的解析类需要实现BeanDefinitionParser类的Parser方法，解析类的注册就在NameSpaceHandler的init方法中进行；

  • 还是先看一下测试类：
package lantao.scan;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPath

<?

因为这里使用ApplicationContext，ApplicationContext在上篇文章已经进行了源码解读，接下来我们直接看差异点。

  • 差异代码在DefaultBeanDefinitionDocumentReader类中的parseBeanDefinitions方法中：
/** * Parse the elements at the root level in the document: * "import", "alias", "bean". * @param root the DOM root element of the document */protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {	//验证

主要差异就在 parseDefaultElement(ele, delegate) 和 delegate.parseCustomElement(ele) 方法上，parseDefaultElement方法仅仅会处理node的namespace是：其他标签和 自定义标签全部都是通过这个方法来解析的；

  • delegate.parseCustomElement源码：
@Nullablepublic BeanDefinition parseCustomElement(Element ele) {	return parseCustomElement(ele, null);}@Nullablepublic BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {	// 获取node的 NameSpaceURI	String namespaceUri = getNamespaceURI(ele);	if (namespaceUri == null) {		return null;	}	// 解析自定义标签 需要在 Meta-inf 文件加 增加 spring.handlers 文件 例如：http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler	// 根据指定的 NameSpaceURI 获取 NamespaceHandler handler可以参考spring.handlers文件	// abstract NamespaceHandlerSupport 实现了 NamespaceHandler 接口，继而实现了 NamespaceHandler 的两个个方法（parser，docreate），自定义handler 需要实现 NamespaceHandlerSupport 类	// 进行 NamespaceHandler 类的 init 方法的 实现， 主要是做注册 BeanDefinitionParser（ registerBeanDefinitionParser ） ， 需要自定义解析类 继承 BeanDefinitionParser 类	NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);	if (handler == null) {		error("Unable to locate Spring NamespaceHandler for

这里代码很简单，只做了以下三件事情：

1：获取Element的NamespaceUri；

2：通过命名空间处理解析器(NamespaceHandlerResolver)的resolver方法进行NameSpaceHandler的处理；

3：通过NameSpaceHandler的Parse方法进行标签解析；

  • 我们直接看 resolve方法：
/** * Locate the {@link NamespaceHandler} for the supplied namespace URI * from the configured mappings. * @param namespaceUri the relevant namespace URI * @return the located {@link NamespaceHandler}, or {@code null} if none found */@Override@Nullablepublic NamespaceHandler resolve(String namespaceUri) {  // 这里获取的是所有注册到 handlerMappings 中的 NamespaceHandler ， 	// 就是 resource/META-INF/spring.handler 中的类 key就是namespaceUri ，	// 这些类都继承了 NamespaceHandlerSupport 实现了init方法 在init方法中进行 BeanDefinitionParse 的注册	Map<String, Object> handlerMappings = getHandlerMappings();	// 通过 namespaceUri 在 handlerMappings 中获取对应的处理器或者 className 如果是初始化过的就直接返回，反之进行类初始化工作	Object handlerOrClassName = handlerMappings.get(namespaceUri);	if (handlerOrClassName == null) {		return null;	}	else if (handlerOrClassName instanceof NamespaceHandler) {		return (NamespaceHandler) handlerOrClassName;	}	else {		String className = (String) handlerOrClassName;		try {			// 实例化			Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);			// 判断实例化的类的超类或者超级接口 是否是 NamespaceHandler			if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {					throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +						"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");			}			NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);			// 注册 自定义标签所对应的 解析策略类 解析策略类都继承了 BeanDefinitionParser ，比如 ComponentScanBeanDefinitionParser			namespaceHandler.init();			// 放入缓存中			handlerMappings.put(namespaceUri, namespaceHandler);			return namespaceHandler;		}		catch (ClassNotFoundException ex) {				throw new FatalBeanException("Could not find NamespaceHandler class [" + className +						"] for namespace [" + namespaceUri + "]", ex);		}		catch (LinkageError err) {			throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +						className + "] for namespace [" + namespaceUri + "]", err);		}	}}

这里主要做了一件事情，就是获取nameSpaceUri对应的NameSpaceHandler,首先会调动getHandlerMappings方法获取全部的NameSpaceHandler，然后通过namespaceUri获取对应的NameSpaceHandler，如果还未实例化则进行实例化操作执行init方法向parsers注册解析类，反之直接返回；getHandlerMappings方法获取的NameSpaceHandler是解析于resource/META-INF/spring.handler 文件下, key就是namespaceUri,value就是自定义的NameSpaceHandler；

  • getHandlerMappings方法源码：
/** * Load the specified NamespaceHandler mappings lazily. */private Map<String, Object> getHandlerMappings() {	Map<String, Object> handlerMappings = this.handlerMappings;	if (handlerMappings == null) {		synchronized (this) {			handlerMappings = this.handlerMappings;			if (handlerMappings == null) {				if (logger.isTraceEnabled()) {					logger.trace("Loading NamespaceHandler mappings from [" + this.handlerMappingsLocation + "]");				}				try {					// 这里的handlerMappingsLocation指定的地址就是 resources 中的 META-INF/spring.handlers					Properties mappings =								PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);					if (logger.isTraceEnabled()) {						logger.trace("Loaded NamespaceHandler mappings: " + mappings);					}					handlerMappings = new ConcurrentHashMap<>(mappings.size());					CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);					this.handlerMappings = handlerMappings;				}				catch (IOException ex) {					throw new IllegalStateException(								"Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);				}			}		}	}	return handlerMappings;}

getHandlerMappings就是解析spring.handler文件和执行NameSpaceHandler的init方法并放入缓存的操作，NameSpaceHandler获取到了以后我们看一下init注册的BeanDefinitionParser的parser方法；

  • NameSpaceHandlerSupport的parse方法源码：
/** * Parses the supplied {@link Element} by delegating to the {@link BeanDefinitionParser} that is * registered for that {@link Element}. */@Override@Nullablepublic BeanDefinition parse(Element element, ParserContext parserContext) {	// 在 NamespaceHandlerSupport 中的 parser 集合中获取 BeanDefinitionParser 的实现类 进行 parser	BeanDefinitionParser parser = findParserForElement(element, parserContext);	return (parser != null ? parser.parse(element, parserContext) : null);}

parse方法做了两件事情：

1：通过定义的标签属性(例如：component-scan)获取对应的BeanDefinitionParser解析类，源码如下：

/** * Locates the {@link BeanDefinitionParser} from the register implementations using * the local name of the supplied {@link Element}. */@Nullableprivate BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {	// 这里判断各种标签的解析策略 获取标签名字	String localName = parserContext.getDelegate().getLocalName(element);	// 从 parsers 中获取对应的解析策略类 parsers 是在 NameSpaceHandler 的 init 方法是初始化的；	BeanDefinitionParser parser = this.parsers.get(localName);	if (parser == null) {		parserContext.getReaderContext().fatal(				"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);	}	// 返回对应的策略类进行解析	return parser;}

2：开始解析；

  • parse方法源码：
@Override@Nullablepublic BeanDefinition parse(Element element, ParserContext parserContext) {	// 获取 basePackage 的 路径	String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);	// 解析给定文本中的${.}，将其替换为由{@link #getProperty}解析的相应属性值 就是可以使用 ${} 和 properties中的值对应	basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);	//我们这里在设置 base-package 的值时, 可以通过上面指示的分隔符 ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS 进行多个package的指定. 可以使用"," ";" "\t\n(回车符)"来分割多个包名	String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,			ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);	// Actually scan for bean definitions and register them.	// 下面的代码就是 实际扫描bean定义并注册它们。	// 配置 ClassPathBeanDefinitionScanner	ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);	// 扫描 并 注册	Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);	// 处理 annotation-config	registerComponents(parserContext.getReaderContext(), beanDefinitions, element);	return null;}

parse方法主要做了以下五件事情：

1：获取basePackage的值，就是

2：basePackage可以配置多个，使用 ',' ';' 或者回车符 进行分割；

3：初始化ClassPathBeanDefinitionScanner，后边的解析操作有ClassPathBeanDefinitionScanner来完成；

4：扫描并注册bean；

5：处理annotation-config(这个后续会详细讲解，这里就不赘述了)

  • 先看一下configureScanner方法源码：
protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {	boolean useDefaultFilters = true;	// 设置 use-default-filters 标签 use-default-filters 属性的默认值为 true，即使用默认的 Filter 进行包扫描，而默认的 Filter 对标有 @Service,@Controller和@Repository 的注解的类进行扫描	if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {		useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));	}	// Delegate bean definition registration to scanner class.	// 将注册Bean的任务委托给ClassPathBeanDefinitionScanner类。初始化 ClassPathBeanDefinitionScanner ，ClassPathBeanDefinitionScanner 是解析conponentScanner 的类	ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);		scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());		scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());	// set RESOURCE_PATTERN_ATTRIBUTE 设置 扫描Resource(资源) 路径 默认为 "**/*.class"	if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {		scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));	}	try {		// set name-generator		// 初始化bean 名称生成器		parseBeanNameGenerator(element, scanner);	}	catch (Exception ex) {		parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());	}	try {		// 设置bean作用域		parseScope(element, scanner);	}	catch (Exception ex) {		parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());	}	// 设置扫描包含 和 排除的 注解	// 设置过滤器，即用于指定哪些类需要被处理，哪些类需要被忽略	// set INCLUDE_FILTER_ELEMENT and EXCLUDE_FILTER_ELEMENT	parseTypeFilters(element, scanner, parserContext);	return scanner;}

configureScanner方法主要做了以下五件事：

1：获取并设置use-default-filters，use-default-filters 属性的默认值为 true，即使用默认的 Filter 进行包扫描，而默认的 Filter 对标有 @Service,@Controller和@Repository 的注解的类进行扫描，如果设置为false，则需要自行对include-filter添加；

2：初始化ClassPathBeanDefinitionScanner，如果use-default-filters为true则对include-filter进行add操作；

3：初始化bean 名称生成器；

4：设置bean作用域；

5：设置扫描包含 和 排除的 注解，include-filter和exclude-filter；

上述代码就不展现了，git上代码有对应的注释；

  • 接下来看scanner.doScan方法：
/** * Perform a scan within the specified base packages, * returning the registered bean definitions. * <p>This method does <i>not</i> register an annotation config processor * but rather leaves this up to the caller. * @param basePackages the packages to check for annotated classes * @return set of beans registered if any for tooling registration purposes (never {@code null}) */protected Set<BeanDefinitionHolder> doScan(String... basePackages) {	Assert.notEmpty(basePackages, "At least one base package must be specified");	Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();	// 循环扫描	for (String basePackage : basePackages) {		// 获取指定包下所有 BeanDefinition		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);		for (BeanDefinition candidate : candidates) {			// 获取一个ScopeMetadata对象，默认为AnnotationScopeMetadataResolver			// 如果目标类未被@Scope注解，则返回一个默认的ScopeMetadata			ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);			candidate.setScope(scopeMetadata.getScopeName());			// 使用bean名称生成器生成bean名称，默认生成器为AnnotationBeanNameGenerator			// 首先是以注解的value为bean名称，如果注解的value没有值，则使用默认的名称			String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);			if (candidate instanceof AbstractBeanDefinition) {				postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);			}			if (candidate instanceof AnnotatedBeanDefinition) {				// 处理定义在目标类上的注解，包括@Lazy, @Primary, @DependsOn, @Role, @Description				// 这里会检查和 设置 AnnotatedBeanDefinition 的 @Lazy(懒加载) @Primary(主要，https://www.cnblogs.com/liaojie970/p/7885106.html) @DependsOn(需要依赖但不需要持有) 注解					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);			}			// 检查beanName是否已经存在 BeanDefinitionRegistry 中存在。			if (checkCandidate(beanName, candidate)) {				//beanName 还没使用过				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);				// 如果有必要，则创建作用域代理				// 如果创建了代理，则返回表示代理对象的BeanDefinitionHolder				definitionHolder =							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);				beanDefinitions.add(definitionHolder);				// 注册Bean				registerBeanDefinition(definitionHolder, this.registry);			}		}	}	return beanDefinitions;}

在doScan方法中都做了什么：

1：获取指定包下(指定的basePackage)所有 BeanDefinition；

2：获取一个ScopeMetadata对象，默认为AnnotationScopeMetadataResolver，如果目标类未被@Scope注解，则返回一个默认的ScopeMetadata；

3：使用bean名称生成器生成bean名称，默认生成器为AnnotationBeanNameGenerator，如果注解上的value值是null，则需要生成；

4：设置AutowireCandidate autowire-candidate="false" 表示该对象不参与自动注入，借鉴：https://blog.csdn.net/shangboerds/article/details/72758095

5：处理定义在目标类上的注解，包括@Lazy, @Primary, @DependsOn, @Role, @Description，这里会检查和设置 AnnotatedBeanDefinition 的 @Lazy(懒加载) @Primary(主要，https://www.cnblogs.com/liaojie970/p/7885106.html) @DependsOn(需要依赖但不需要持有) 注解；

6：检查beanName是否已经存在 beanDefinitionMap 中存在；

7：如果设置了scopedProxyMode，则需要创建代理类和注册代理类；

8：调用registerBeanDefinition注册bean，就是put到beanDefinitionMap中；

  • 这里只说核心的scanCandidateComponents方法，其他的方法都很简单，读者自行通过debug来做就可以了：
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {	Set<BeanDefinition> candidates = new LinkedHashSet<>();	try {		// ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX = "classpath*:";		// 通过观察resolveBasePackage()方法的实现, 我们可以在设置basePackage时, 使用形如${}的占位符, Spring会在这里进行替换		// this.resourcePattern 默认为 "**/*.class" resourcePattern 可以在

这里主要就是做了通过ResourcePatternResolver的getResource获取指定路径的资源文件，再通过资源文件Resource获取MetadataReader (元数据就是用来定义数据的数据 就是定义 class 的 属性),接下来通过isCandidateComponent方法来做核心处理，因为通过路径获取的资源是全部的，不是想要的，通过isCandidateComponent方法来做 ncludeFilters excludeFilters 的判断，再通过isCandidateComponent(sbd)判断BeanDefinition必须是一个实现类，不可以是接口等；

  • 我们看一下核心判断方法isCandidateComponent：
 /** 	 * Determine whether the given class does not match any exclude filter 	 * and does match at least one include filter. 	 * @param metadataReader the ASM ClassReader for the class 	 * @return whether the class qualifies as a candidate component 	 */ 	protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException { 		// 判断 excludeFilters 的 TypeFilter 		for (TypeFilter tf : this.excludeFilters) { 			if (tf.match(metadataReader, getMetadataReaderFactory())) { 				return false; 			} 		} 		// 判断逻辑 includeFilters 中的 TypeFilter 默认包含的filter有 @components 和 引用他的 @service @controller @Repository 		for (TypeFilter tf : this.includeFilters) { 			if (tf.match(metadataReader, getMetadataReaderFactory())) { 				// 判断 @Conditional ， @Conditional是Spring4新提供的注解，它的作用是按照一定的条件进行判断，满足条件给容器注册bean。 还有 @ConditionalOnXX 等注解 				return isConditionMatch(metadataReader); 			} 		} 		return false; 	}
/** * Determine whether the given bean definition qualifies as candidate. * <p>The default implementation checks whether the class is not an interface * and not dependent on an enclosing class. * <p>Can be overridden in subclasses. * @param beanDefinition the bean definition to check * @return whether the bean definition qualifies as a candidate component */ protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) { 	AnnotationMetadata metadata = beanDefinition.getMetadata(); 	// metadata.isIndependent() 是独立的 & 	// metadata.isConcrete() 是否是接口或者是抽象类 或 	// 必须是抽象类 和 有@lookup 注解 	return (metadata.isIndependent() && (metadata.isConcrete() || 			(metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName())))); }

到这里就已经讲完了Component-scan扫描注入的源码，这里涉及代理和annotation-config没有做详细的讲解，会在后续的文章中做，码字不易，转发请注明出处。

1615879776045-153328









原文转载：http://www.shaoqun.com/a/644723.html

跨境电商：https://www.ikjzd.com/

亚马逊 海外购：https://www.ikjzd.com/w/998

rfq：https://www.ikjzd.com/w/251


本文主要介绍Spring的component-scan标签，了解spring是如何实现扫描注解进行bean的注册，主要实现实在NamespaceHandler,NamespaceHandlerSupport和BeanDefinitionParser三个接口中，还需要配置spring.handlers文件，在接下里的源码解析中会详细解析，在本篇博客中将使用ApplicationConntext作为起
百思买：https://www.ikjzd.com/w/394
万国邮政联盟：https://www.ikjzd.com/w/861
c88：https://www.ikjzd.com/w/1017
亚马逊后台更新！这些美国订单也要征税了！：https://www.ikjzd.com/home/136708
赶紧下架！这款热卖产品品牌已被律所代理！：https://www.ikjzd.com/home/102268
拼多多的多多国际店铺如何上传商品？：https://www.ikjzd.com/home/59773

Comments

Post a Comment

Popular posts from this blog

指纹浏览器定制开发全面助力企业安全与智能升级

在数字化时代，企业信息安全和智能化管理愈发成为商务发展的两大支柱。为适应这一趋势，指纹浏览器定制开发成为了企业安全和智能升级的最佳选择。让我们一同探索，如何通过指纹浏览器的二次开发、私有部署和AI智能等关键功能，助力企业迎接未来的挑战。 指纹浏览器二次开发：保障身份识别的极致体验 随着科技的不断进步，传统身份验证方式显得越来越脆弱。指纹浏览器的二次开发为企业带来了身份识别的极致体验，通过精准的生物特征验证，极大地提高了安全性。企业无需担忧密码泄漏或仿冒风险，真正实现了信息安全的无忧管理。 私有部署：数据安全掌握在自己手中 数据是企业最重要的资产之一，而私有部署则是最为可靠的数据保护手段之一。通过将指纹浏览器定制开发系统私有部署，企业能够完全掌握对敏感数据的访问和存储。这一层级的掌控，不仅提升了数据的安全性，同时也避免了因为云服务的共享带来的潜在风险。 原文转载： https://fashion.shaoqun.com/a/1585172.html 深圳巴厘岛海景酒店 ：https://www.vstour.cn/t/深圳巴厘岛海景酒店.html 深圳巴厘岛旅行团 ：https://www.vstour.cn/t/深圳巴厘岛旅行团.html 深圳巴厘岛旅游 ：https://www.vstour.cn/t/深圳巴厘岛旅游.html 深圳巴厘岛旅游报价 ：https://www.vstour.cn/t/深圳巴厘岛旅游报价.html 深圳巴厘岛旅游价格 ：https://www.vstour.cn/t/深圳巴厘岛旅游价格.html 深圳巴厘岛旅游团 ：https://www.vstour.cn/t/深圳巴厘岛旅游团.html 红海堵塞，海湾受益？ ：https://www.kjdsnews.com/a/1743053.html 一篇文章带你了解商标注册：尼加拉瓜 ：https://www.kjdsnews.com/a/1743054.html
Read more

跨境电商资讯：一文带你走进亚马逊19大海

Image
随着全球电商行业的迅速发展，许多品牌逐渐将目光投向海外市场，寻找新的业务增长点。亚马逊作为全球最大的电商平台之一，拥有众多海外站点，为卖家提供了广阔的发展空间和优质的服务。然而，当卖家们面对海外众多不同的站点，它们的区别是什么？该选红海站点还是蓝海站点？如何才能选择适合自己的平台？这些都让许多卖家感到非常迷惑，不知所措。 别着急！接下来就让小编带大家一起了解亚马逊各大海外站点的机会优势，并分享几位卖家的实战经验，助您选好出海站点，赢在起跑线！ 目前，亚马逊在全球拥有19大海外站点，覆盖北美、拉丁美洲、欧洲、亚洲、大洋洲等多个地区，帮助卖家触达数亿消费者。这些站点各有"特长"，您可以结合自身业务、资金情况和发展需求等因素，Pick适合自己的出海站点，及时把握海外商机！ 01老牌成熟站点，新手出海首选！ 目前，亚马逊在北美地区拥有美国站和加拿大站两大站点。北美站的整体成熟度和服务完善性让许多卖家将它作为开拓生意的首站。 从宏观环境来看，北美站可谓实力超群： ●体量庞大，消费潜力高 作为亚马逊全球最大海外站点，消费实力强劲，两大站点囊括3.7亿+人口，人红利充足，Prime会员占比高； ●品类齐全，细分赛道机会多 加拿大站选品文化接近美国，选品空间广阔，有利于卖家挖掘不同品类商机! 对于新手来说，亚马逊北美站拥有多重优势助力启航： ●配套完善，服务齐全 作为最早开设的站点，亚马逊服务支持齐全，新卖家上手更轻松 ●物流便捷，配送无阻 您可使用亚马逊远程物流配送计划(NARF)，将美国站FBA库存直接配送给加拿大买家，无需将库存事先运送到加拿大，助您轻松拓展北美地区商业版图! 该计划具有以下4大优势： ●利用美国FBA库存，为加拿大的Prime买家提供免费配送服务； ●由亚马逊处理跨境配送事宜，让配送流程更简单便捷； ●进口税费和相关费用由买家支付，无需卖家承担； ●退货直接退回美国，省心省力。 如果您想坐拥巨大流量，触达更多、更广泛的消费者；如果您的选品种类丰富齐全，希望同时布局多种品类赛道……那么北美站是您不该犹豫的首选! 02高潜消费增长能力，业务拓展不二之选！ 在拉丁美洲，除了已对卖家开放的墨西哥站之外，亚马逊巴西站也于2023年12月正式对中国卖家开放，不少北美站卖家已抢先拓展生意版图，吃到了"第一只螃蟹"! 结合宏观发展趋势...
Read more

利用 Google 购物广告促进销量的初学者指南

您需要更多客户。 并且，您需要 以可接受的成本获取它们 。因为，如果你不能做这两件事呢？ ……好吧， 我们别去那里了 。 首先，如何获得更多客户？ 嗯，一种行之有效的方法是 Google Shopping 。 这一领先的电子商务流量来源 占 电子商务 网站整体销售额的 16% 以上。 那是 巨大的。 但是，当您考虑到Google每秒处理超过 40,000 个搜索查询 时，这也就不足为奇了。 不过，这还不是全部…… 2018 年，在美国电子商务领域，Google 购物广告占 零售搜索广告支出的 76.4% ，占所有付费搜索点击次数的 85.3%。 另一方面，文字广告仅吸引了 23.6% 的零售搜索广告支出和 14.7% 的付费搜索点击次数。 由于 Google 努力通过富媒体广告格式提高知名度，投资 Google Shopping 广告系列已成为零售搜索行业的主要趋势。 但是，您能否使用 Google 购物以可接受的成本获取客户，从而为您带来利润？ 一言以蔽之？ 是的 。 OMG Commerce首席执行官 Brett Curry 去年 管理的广告活动平均 广告支出回报率 (ROAS) 为 300-600% 。 您愿意花 1美元获得 3 至 6 美元的销售额吗？ 我愿意打赌你会的。 你是怎么做到的？ 在本文中，您将准确了解 Google 购物是什么、它的工作原理以及如何开始您的第一个广告系列。 好吧，系好安全带 。 Fansgurus是一个社交媒体营销在线平包含了Facebook，Instagram，Twitter，Pinterest，YouTube，Tiktok，telegram，虾皮等等海外社交媒体，并提供增粉、点赞、转发、评论浏览量直播间在线，网站引流等数据服务。快速体验： zllp.myyfrs.ciwi._okgyw?fyuokfj 什么是谷歌购物？ Google 购物广告也称为产品详情广告或 PLA。而且，当用户在 Google 上搜索产品时，它们就会显示。 它们出现 在搜索结果的顶部或页面的右上角： Google 购物广告也可以 在"购物"标签下找到。 这些广告如此有效的 部分原因 是它们位于搜索结果顶部的显着位置。 那么，Google 购物广告包含哪些内容？ 简而言之， 消费者熟悉的5 个关键组件： 产品图片 产品名称 价格 卖家姓...
Read more