Spring之底層架構核心概念解析
BeanDefinition
BeanDefinition表示Bean定義，BeanDefinition中存在很多屬性用來描述一個Bean的特點。比如：
- class，表示Bean型別
- scope，表示Bean作用域，單例或原型等
- lazyInit：表示Bean是否是懶載入
- initMethodName：表示Bean初始化時要執行的方法
- destroyMethodName：表示Bean銷燬時要執行的方法
- 還有很多...
在Spring中，我們經常會通過以下幾種方式來定義Bean：
- <bean/>
- @Bean
- @Component(@Service,@Controller)
這些，我們可以稱之申明式定義Bean。
我們還可以程式設計式定義Bean，那就是直接通過BeanDefinition，比如：
1 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); 2 3 // 生成一個BeanDefinition物件，並設定beanClass為User.class，並註冊到ApplicationContext中 4 AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();5 beanDefinition.setBeanClass(User.class); 6 context.registerBeanDefinition("user", beanDefinition); 7 8 System.out.println(context.getBean("user"));
我們還可以通過BeanDefinition設定一個Bean的其他屬性
1 beanDefinition.setScope("prototype"); // 設定作用域 2 beanDefinition.setInitMethodName("init"); // 設定初始化方法 3 beanDefinition.setLazyInit(true); // 設定懶載入
和申明式事務、程式設計式事務類似，通過<bean/>，@Bean，@Component等申明式方式所定義的Bean，最終都會被Spring解析為對應的BeanDefinition物件，並放入Spring容器中。
BeanDefinitionReader
接下來，我們來介紹幾種在Spring原始碼中所提供的BeanDefinition讀取器（BeanDefinitionReader），這些BeanDefinitionReader在我們使用Spring時用得少，但在Spring原始碼中用得多，相當於Spring原始碼的基礎設施。
AnnotatedBeanDefinitionReader
可以直接把某個類轉換為BeanDefinition，並且會解析該類上的註解，比如
1 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); 2 3 AnnotatedBeanDefinitionReader annotatedBeanDefinitionReader = new AnnotatedBeanDefinitionReader(context); 4 5 // 將User.class解析為BeanDefinition 6 annotatedBeanDefinitionReader.register(User.class); 7 8 System.out.println(context.getBean("user"));
注意：它能解析的註解是：@Conditional，@Scope、@Lazy、@Primary、@DependsOn、@Role、@Description
XmlBeanDefinitionReader
可以解析<bean/>標籤
1 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); 2 3 XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(context); 4 int i = xmlBeanDefinitionReader.loadBeanDefinitions("spring.xml"); 5 6 System.out.println(context.getBean("user"));
ClassPathBeanDefinitionScanner
ClassPathBeanDefinitionScanner是掃描器，但是它的作用和BeanDefinitionReader類似，它可以進行掃描，掃描某個包路徑，對掃描到的類進行解析，比如，掃描到的類上如果存在@Component註解，那麼就會把這個類解析為一個BeanDefinition，比如：
1 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); 2 context.refresh(); 3 4 ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context); 5 scanner.scan("com.zhouyu"); 6 7 System.out.println(context.getBean("userService"));
BeanFactory
BeanFactory表示Bean工廠，所以很明顯，BeanFactory會負責建立Bean，並且提供獲取Bean的API。
而ApplicationContext是BeanFactory的一種，在Spring原始碼中，是這麼定義的：
1 public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, 2 MessageSource, ApplicationEventPublisher, ResourcePatternResolver { 3 4 ... 5 }
首先，在Java中，介面是可以多繼承的，我們發現ApplicationContext繼承了ListableBeanFactory和HierarchicalBeanFactory，而ListableBeanFactory和HierarchicalBeanFactory都繼承至BeanFactory，所以我們可以認為ApplicationContext繼承了BeanFactory，相當於蘋果繼承水果，寶馬繼承汽車一樣，ApplicationContext也是BeanFactory的一種，擁有BeanFactory支援的所有功能，不過ApplicationContext比BeanFactory更加強大，ApplicationContext還基礎了其他介面，也就表示ApplicationContext還擁有其他功能，比如MessageSource表示國際化，ApplicationEventPublisher表示事件釋出，EnvironmentCapable表示獲取環境變數，等等，關於ApplicationContext後面再詳細討論。
在Spring的原始碼實現中，當我們new一個ApplicationContext時，其底層會new一個BeanFactory出來，當使用ApplicationContext的某些方法時，比如getBean()，底層呼叫的是BeanFactory的getBean()方法。
在Spring原始碼中，BeanFactory介面存在一個非常重要的實現類是：DefaultListableBeanFactory，也是非常核心的。具體重要性，隨著後續課程會感受更深。
所以，我們可以直接來使用DefaultListableBeanFactory，而不用使用ApplicationContext的某個實現類，比如：
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory(); AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition(); beanDefinition.setBeanClass(User.class); beanFactory.registerBeanDefinition("user", beanDefinition); System.out.println(beanFactory.getBean("user"));
DefaultListableBeanFactory是非常強大的，支援很多功能，可以通過檢視DefaultListableBeanFactory的類繼承實現結構來看
這部分現在看不懂沒關係，原始碼熟悉一點後回來再來看都可以。
它實現了很多介面，表示，它擁有很多功能：
- AliasRegistry：支援別名功能，一個名字可以對應多個別名
- BeanDefinitionRegistry：可以註冊、儲存、移除、獲取某個BeanDefinition
- BeanFactory：Bean工廠，可以根據某個bean的名字、或型別、或別名獲取某個Bean物件
- SingletonBeanRegistry：可以直接註冊、獲取某個單例Bean
- SimpleAliasRegistry：它是一個類，實現了AliasRegistry介面中所定義的功能，支援別名功能
- ListableBeanFactory：在BeanFactory的基礎上，增加了其他功能，可以獲取所有BeanDefinition的beanNames，可以根據某個型別獲取對應的beanNames，可以根據某個型別獲取{型別：對應的Bean}的對映關係
- HierarchicalBeanFactory：在BeanFactory的基礎上，添加了獲取父BeanFactory的功能
- DefaultSingletonBeanRegistry：它是一個類，實現了SingletonBeanRegistry介面，擁有了直接註冊、獲取某個單例Bean的功能
- ConfigurableBeanFactory：在HierarchicalBeanFactory和SingletonBeanRegistry的基礎上，添加了設定父BeanFactory、類載入器（表示可以指定某個類載入器進行類的載入）、設定Spring EL表示式解析器（表示該BeanFactory可以解析EL表示式）、設定型別轉化服務（表示該BeanFactory可以進行型別轉化）、可以新增BeanPostProcessor（表示該BeanFactory支援Bean的後置處理器），可以合併BeanDefinition，可以銷燬某個Bean等等功能
- FactoryBeanRegistrySupport：支援了FactoryBean的功能
- AutowireCapableBeanFactory：是直接繼承了BeanFactory，在BeanFactory的基礎上，支援在建立Bean的過程中能對Bean進行自動裝配
- AbstractBeanFactory：實現了ConfigurableBeanFactory介面，繼承了FactoryBeanRegistrySupport，這個BeanFactory的功能已經很全面了，但是不能自動裝配和獲取beanNames
- ConfigurableListableBeanFactory：繼承了ListableBeanFactory、AutowireCapableBeanFactory、ConfigurableBeanFactory
- AbstractAutowireCapableBeanFactory：繼承了AbstractBeanFactory，實現了AutowireCapableBeanFactory，擁有了自動裝配的功能
- DefaultListableBeanFactory：繼承了AbstractAutowireCapableBeanFactory，實現了ConfigurableListableBeanFactory介面和BeanDefinitionRegistry介面，所以DefaultListableBeanFactory的功能很強大
ApplicationContext
上面有分析到，ApplicationContext是個介面，實際上也是一個BeanFactory，不過比BeanFactory更加強大，比如：
- HierarchicalBeanFactory：擁有獲取父BeanFactory的功能
- ListableBeanFactory：擁有獲取beanNames的功能
- ResourcePatternResolver：資源載入器，可以一次性獲取多個資源（檔案資源等等）
- EnvironmentCapable：可以獲取執行時環境（沒有設定執行時環境功能）
- ApplicationEventPublisher：擁有廣播事件的功能（沒有新增事件監聽器的功能）
- MessageSource：擁有國際化功能
具體的功能演示，後面會有。
我們先來看ApplicationContext兩個比較重要的實現類：
- AnnotationConfigApplicationContext
- ClassPathXmlApplicationContext
AnnotationConfigApplicationContext
這部分現在看不懂沒關係，原始碼熟悉一點後回來再來看都可以。
- ConfigurableApplicationContext：繼承了ApplicationContext介面，增加了，新增事件監聽器、新增BeanFactoryPostProcessor、設定Environment，獲取ConfigurableListableBeanFactory等功能
- AbstractApplicationContext：實現了ConfigurableApplicationContext介面
- GenericApplicationContext：繼承了AbstractApplicationContext，實現了BeanDefinitionRegistry介面，擁有了所有ApplicationContext的功能，並且可以註冊BeanDefinition，注意這個類中有一個屬性(DefaultListableBeanFactory beanFactory)
- AnnotationConfigRegistry：可以單獨註冊某個為類為BeanDefinition（可以處理該類上的@Configuration註解，已經可以處理@Bean註解），同時可以掃描
- AnnotationConfigApplicationContext：繼承了GenericApplicationContext，實現了AnnotationConfigRegistry介面，擁有了以上所有的功能
ClassPathXmlApplicationContext
它也是繼承了AbstractApplicationContext，但是相對於AnnotationConfigApplicationContext而言，功能沒有AnnotationConfigApplicationContext強大，比如不能註冊BeanDefinition
國際化
先定義一個MessageSource:
1 @Bean 2 public MessageSource messageSource() { 3 ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource(); 4 messageSource.setBasename("messages"); 5 return messageSource; 6 }
有了這個Bean，你可以在你任意想要進行國際化的地方使用該MessageSource。
同時，因為ApplicationContext也擁有國家化的功能，所以可以直接這麼用：
context.getMessage("test", null, new Locale("en_CN"))
資源載入
ApplicationContext還擁有資源載入的功能，比如，可以直接利用ApplicationContext獲取某個檔案的內容：
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); Resource resource = context.getResource("file://D:\\IdeaProjects\\spring-framework-5.3.10\\tuling\\src\\main\\java\\com\\zhouyu\\service\\UserService.java"); System.out.println(resource.contentLength());
你可以想想，如果你不使用ApplicationContext，而是自己來實現這個功能，就比較費時間了。
還比如你可以：
1 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); 2 3 Resource resource = context.getResource("file://D:\\IdeaProjects\\spring-framework-5.3.10\\tuling\\src\\main\\java\\com\\zhouyu\\service\\UserService.java"); 4 System.out.println(resource.contentLength()); 5 System.out.println(resource.getFilename()); 6 7 Resource resource1 = context.getResource("https://www.baidu.com"); 8 System.out.println(resource1.contentLength()); 9 System.out.println(resource1.getURL()); 10 11 Resource resource2 = context.getResource("classpath:spring.xml"); 12 System.out.println(resource2.contentLength()); 13 System.out.println(resource2.getURL());
還可以一次性獲取多個：
1 Resource[] resources = context.getResources("classpath:com/zhouyu/*.class"); 2 for (Resource resource : resources) { 3 System.out.println(resource.contentLength()); 4 System.out.println(resource.getFilename()); 5 }
獲取執行時環境
1 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); 2 3 Map<String, Object> systemEnvironment = context.getEnvironment().getSystemEnvironment(); 4 System.out.println(systemEnvironment); 5 6 System.out.println("======="); 7 8 Map<String, Object> systemProperties = context.getEnvironment().getSystemProperties(); 9 System.out.println(systemProperties); 10 11 System.out.println("======="); 12 13 MutablePropertySources propertySources = context.getEnvironment().getPropertySources(); 14 System.out.println(propertySources); 15 16 System.out.println("======="); 17 18 System.out.println(context.getEnvironment().getProperty("NO_PROXY")); 19 System.out.println(context.getEnvironment().getProperty("sun.jnu.encoding")); 20 System.out.println(context.getEnvironment().getProperty("zhouyu"));
注意，可以利用
1 @PropertySource("classpath:spring.properties")
來使得某個properties檔案中的引數新增到執行時環境中
事件釋出
先定義一個事件監聽器
1 @Bean 2 public ApplicationListener applicationListener() { 3 return new ApplicationListener() { 4 @Override 5 public void onApplicationEvent(ApplicationEvent event) { 6 System.out.println("接收到了一個事件"); 7 } 8 }; 9 }
然後釋出一個事件：
1 context.publishEvent("kkk");
型別轉化
在Spring原始碼中，有可能需要把String轉成其他型別，所以在Spring原始碼中提供了一些技術來更方便的做物件的型別轉化，關於型別轉化的應用場景， 後續看原始碼的過程中會遇到很多。
PropertyEditor
這其實是JDK中提供的型別轉化工具類
1 public class StringToUserPropertyEditor extends PropertyEditorSupport implements PropertyEditor { 2 3 @Override 4 public void setAsText(String text) throws IllegalArgumentException { 5 User user = new User(); 6 user.setName(text); 7 this.setValue(user); 8 } 9 }
1 StringToUserPropertyEditor propertyEditor = new StringToUserPropertyEditor(); 2 propertyEditor.setAsText("1"); 3 User value = (User) propertyEditor.getValue(); 4 System.out.println(value);
如何向Spring中註冊PropertyEditor：
1 @Bean 2 public CustomEditorConfigurer customEditorConfigurer() { 3 CustomEditorConfigurer customEditorConfigurer = new CustomEditorConfigurer(); 4 Map<Class<?>, Class<? extends PropertyEditor>> propertyEditorMap = new HashMap<>(); 5 6 // 表示StringToUserPropertyEditor可以將String轉化成User型別，在Spring原始碼中，如果發現當前物件是String，而需要的型別是User，就會使用該PropertyEditor來做型別轉化 7 propertyEditorMap.put(User.class, StringToUserPropertyEditor.class); 8 customEditorConfigurer.setCustomEditors(propertyEditorMap); 9 return customEditorConfigurer; 10 }
假設現在有如下Bean:
1 @Component 2 public class UserService { 3 4 @Value("xxx") 5 private User user; 6 7 public void test() { 8 System.out.println(user); 9 } 10 11 }
那麼test屬性就能正常的完成屬性賦值
ConversionService
Spring中提供的型別轉化服務，它比PropertyEditor更強大
1 public class StringToUserConverter implements ConditionalGenericConverter { 2 3 @Override 4 public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) { 5 return sourceType.getType().equals(String.class) && targetType.getType().equals(User.class); 6 } 7 8 @Override 9 public Set<ConvertiblePair> getConvertibleTypes() { 10 return Collections.singleton(new ConvertiblePair(String.class, User.class)); 11 } 12 13 @Override 14 public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) { 15 User user = new User(); 16 user.setName((String)source); 17 return user; 18 } 19 }
1 DefaultConversionService conversionService = new DefaultConversionService(); 2 conversionService.addConverter(new StringToUserConverter()); 3 User value = conversionService.convert("1", User.class); 4 System.out.println(value);
如何向Spring中註冊ConversionService：
1 @Bean 2 public ConversionServiceFactoryBean conversionService() { 3 ConversionServiceFactoryBean conversionServiceFactoryBean = new ConversionServiceFactoryBean(); 4 conversionServiceFactoryBean.setConverters(Collections.singleton(new StringToUserConverter())); 5 6 return conversionServiceFactoryBean; 7 }
TypeConverter
整合了PropertyEditor和ConversionService的功能，是Spring內部用的
1 SimpleTypeConverter typeConverter = new SimpleTypeConverter(); 2 typeConverter.registerCustomEditor(User.class, new StringToUserPropertyEditor()); 3 //typeConverter.setConversionService(conversionService); 4 User value = typeConverter.convertIfNecessary("1", User.class); 5 System.out.println(value);
OrderComparator
OrderComparator是Spring所提供的一種比較器，可以用來根據@Order註解或實現Ordered介面來執行值進行筆記，從而可以進行排序。
比如：
1 public class A implements Ordered { 2 3 @Override 4 public int getOrder() { 5 return 3; 6 } 7 8 @Override 9 public String toString() { 10 return this.getClass().getSimpleName(); 11 } 12 }
1 public class B implements Ordered { 2 3 @Override 4 public int getOrder() { 5 return 2; 6 } 7 8 @Override 9 public String toString() { 10 return this.getClass().getSimpleName(); 11 } 12 }
1 public class Main { 2 3 public static void main(String[] args) { 4 A a = new A(); // order=3 5 B b = new B(); // order=2 6 7 OrderComparator comparator = new OrderComparator(); 8 System.out.println(comparator.compare(a, b)); // 1 9 10 List list = new ArrayList<>(); 11 list.add(a); 12 list.add(b); 13 14 // 按order值升序排序 15 list.sort(comparator); 16 17 System.out.println(list); // B，A 18 } 19 }
另外，Spring中還提供了一個OrderComparator的子類：AnnotationAwareOrderComparator，它支援用@Order來指定order值。比如：
1 @Order(3) 2 public class A { 3 4 @Override 5 public String toString() { 6 return this.getClass().getSimpleName(); 7 } 8 9 }
1 @Order(2) 2 public class B { 3 4 @Override 5 public String toString() { 6 return this.getClass().getSimpleName(); 7 } 8 9 }
1 public class Main { 2 3 public static void main(String[] args) { 4 A a = new A(); // order=3 5 B b = new B(); // order=2 6 7 AnnotationAwareOrderComparator comparator = new AnnotationAwareOrderComparator(); 8 System.out.println(comparator.compare(a, b)); // 1 9 10 List list = new ArrayList<>(); 11 list.add(a); 12 list.add(b); 13 14 // 按order值升序排序 15 list.sort(comparator); 16 17 System.out.println(list); // B，A 18 } 19 }
BeanPostProcessor
BeanPostProcess表示Bena的後置處理器，我們可以定義一個或多個BeanPostProcessor，比如通過一下程式碼定義一個BeanPostProcessor：
1 @Component 2 public class ZhouyuBeanPostProcessor implements BeanPostProcessor { 3 4 @Override 5 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 6 if ("userService".equals(beanName)) { 7 System.out.println("初始化前"); 8 } 9 10 return bean; 11 } 12 13 @Override 14 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 15 if ("userService".equals(beanName)) { 16 System.out.println("初始化後"); 17 } 18 19 return bean; 20 } 21 }
一個BeanPostProcessor可以在任意一個Bean的初始化之前以及初始化之後去額外的做一些使用者自定義的邏輯，當然，我們可以通過判斷beanName來進行鍼對性處理（針對某個Bean，或某部分Bean）。
我們可以通過定義BeanPostProcessor來干涉Spring建立Bean的過程。
BeanFactoryPostProcessor
BeanFactoryPostProcessor表示Bean工廠的後置處理器，其實和BeanPostProcessor類似，BeanPostProcessor是干涉Bean的建立過程，BeanFactoryPostProcessor是干涉BeanFactory的建立過程。比如，我們可以這樣定義一個BeanFactoryPostProcessor：
1 @Component 2 public class ZhouyuBeanFactoryPostProcessor implements BeanFactoryPostProcessor { 3 4 @Override 5 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { 6 System.out.println("加工beanFactory"); 7 } 8 }
我們可以在postProcessBeanFactory()方法中對BeanFactory進行加工。
FactoryBean
上面提到，我們可以通過BeanPostPorcessor來干涉Spring建立Bean的過程，但是如果我們想一個Bean完完全全由我們來創造，也是可以的，比如通過FactoryBean：
1 @Component 2 public class ZhouyuFactoryBean implements FactoryBean { 3 4 @Override 5 public Object getObject() throws Exception { 6 UserService userService = new UserService(); 7 8 return userService; 9 } 10 11 @Override 12 public Class<?> getObjectType() { 13 return UserService.class; 14 } 15 }
通過上面這段程式碼，我們自己創造了一個UserService物件，並且它將成為Bean。但是通過這種方式創造出來的UserService的Bean，只會經過初始化後，其他Spring的生命週期步驟是不會經過的，比如依賴注入。
有同學可能會想到，通過@Bean也可以自己生成一個物件作為Bean，那麼和FactoryBean的區別是什麼呢？其實在很多場景下他倆是可以替換的，但是站在原理層面來說的，區別很明顯，@Bean定義的Bean是會經過完整的Bean生命週期的。
ExcludeFilter和IncludeFilter
這兩個Filter是Spring掃描過程中用來過濾的。ExcludeFilter表示排除過濾器，IncludeFilter表示包含過濾器。
比如以下配置，表示掃描com.zhouyu這個包下面的所有類，但是排除UserService類，也就是就算它上面有@Component註解也不會成為Bean。
1 @ComponentScan(value = "com.zhouyu", 2 excludeFilters = {@ComponentScan.Filter( 3 type = FilterType.ASSIGNABLE_TYPE, 4 classes = UserService.class)}.) 5 public class AppConfig { 6 }
再比如以下配置，就算UserService類上沒有@Component註解，它也會被掃描成為一個Bean。
1 @ComponentScan(value = "com.zhouyu", 2 includeFilters = {@ComponentScan.Filter( 3 type = FilterType.ASSIGNABLE_TYPE, 4 classes = UserService.class)}) 5 public class AppConfig { 6 }
FilterType分為：
- ANNOTATION：表示是否包含某個註解
- ASSIGNABLE_TYPE：表示是否是某個類
- ASPECTJ：表示否是符合某個Aspectj表示式
- REGEX：表示是否符合某個正則表示式
- CUSTOM：自定義
在Spring的掃描邏輯中，預設會新增一個AnnotationTypeFilter給includeFilters，表示預設情況下Spring掃描過程中會認為類上有@Component註解的就是Bean。
MetadataReader、ClassMetadata、AnnotationMetadata
在Spring中需要去解析類的資訊，比如類名、類中的方法、類上的註解，這些都可以稱之為類的元資料，所以Spring中對類的元資料做了抽象，並提供了一些工具類。
MetadataReader表示類的元資料讀取器，預設實現類為SimpleMetadataReader。比如：
1 public class Test { 2 3 public static void main(String[] args) throws IOException { 4 SimpleMetadataReaderFactory simpleMetadataReaderFactory = new SimpleMetadataReaderFactory(); 5 6 // 構造一個MetadataReader 7 MetadataReader metadataReader = simpleMetadataReaderFactory.getMetadataReader("com.zhouyu.service.UserService"); 8 9 // 得到一個ClassMetadata，並獲取了類名 10 ClassMetadata classMetadata = metadataReader.getClassMetadata(); 11 12 System.out.println(classMetadata.getClassName()); 13 14 // 獲取一個AnnotationMetadata，並獲取類上的註解資訊 15 AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata(); 16 for (String annotationType : annotationMetadata.getAnnotationTypes()) { 17 System.out.println(annotationType); 18 } 19 20 } 21 }
需要注意的是，SimpleMetadataReader去解析類時，使用的ASM技術。
為什麼要使用ASM技術，Spring啟動的時候需要去掃描，如果指定的包路徑比較寬泛，那麼掃描的類是非常多的，那如果在Spring啟動時就把這些類全部載入進JVM了，這樣不太好，所以使用了ASM技術。