2. 程式人生 > >深入Spring:自定義註解載入和使用

深入Spring:自定義註解載入和使用

阿新 • • 發佈：2019-01-08

前言

在工作中經常使用Spring的相關框架，免不了去看一下Spring的實現方法，瞭解一下Spring內部的處理邏輯。特別是開發Web應用時，我們會頻繁的定義@Controller，@Service等JavaBean元件，通過註解，Spring自動掃描載入了這些元件，並提供相關的服務。
Spring是如何讀取註解資訊，並注入到bean容器中的，本文就是通過嵌入Spring的Bean載入，來描述Spring的實現方法。完整的例子都在Github上了。

自定義註解

先看一個最簡單的例子，在使用SpringWeb應用中的過程中，大家免不了會使用@Controller，@Service，@Repository

等註解來定義JavaBean。那麼怎麼自己定義一個註解，Spring可以自動載入呢。所以就有了第一個例子。

@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface MyComponent {
    String value() default "";
}
@Configuration
public class ComponentAnnotationTest {
  public static void main(String[] args)
 
 {
    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
annotationConfigApplicationContext.register(ComponentAnnotationTest.class);
    annotationConfigApplicationContext.refresh();
    InjectClass injectClass = annotationConfigApplicationContext.getBean(InjectClass.class);
        injectClass.print();
  }
  @MyComponent
 

  public static class InjectClass {
    public void print() {
        System.out.println("hello world");
    }
  }
}

執行這個例子，就會發現，@MyComponent 註解的類，也被Spring載入進來了，而且可以當成普通的JavaBean正常的使用。檢視Spring的原始碼會發現，Spring是使用ClassPathScanningCandidateComponentProvider掃描package,這個類有這樣的註釋

A component provider that scans the classpath from a base package. 
It then applies exclude and include filters to the resulting classes to find candidates.

這個類的 registerDefaultFilters 方法有這樣幾行程式碼

protected void registerDefaultFilters() {   
   this.includeFilters.add(new AnnotationTypeFilter(Component.class));
   ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
   try {    
      this.includeFilters.add(new AnnotationTypeFilter(((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false)); 
      logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning"); 
   }   catch (ClassNotFoundException ex) {     
     // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.   
   }   
   try {      
      this.includeFilters.add(new AnnotationTypeFilter(((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));      
      logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");   
   }  
   catch (ClassNotFoundException ex) {     
   // JSR-330 API not available - simply skip.  
   }
}

這裡就會發現Spring在掃描類資訊的使用只會判斷被@Component註解的類，所以任何自定義的註解只要帶上@Component（當然還要有String value() default "";的方法，因為Spring的Bean都是有beanName唯一標示的），都可以被Spring掃描到，並注入容器內。

定製功能

但上面的方法太侷限了，沒辦法定製，而且也沒有實際的意義。如何用特殊的註解來實現定製的功能呢，一般有兩種方式：

  1. 還是用上面的方法，在注入Spring的容器後，再取出來做自己定製的功能，Spring-MVC就是使用這樣的方法。AbstractDetectingUrlHandlerMapping 中的detectHandlers方法,這個方法取出了所有的bean，然後迴圈查詢帶有Controller的bean，並提取其中的RequestMapping資訊

    protected void detectHandlers() throws BeansException {
     if (logger.isDebugEnabled()) {
         logger.debug("Looking for URL mappings in application context: " + getApplicationContext());
     }
     String[] beanNames = (this.detectHandlersInAncestorContexts ?
             BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
             getApplicationContext().getBeanNamesForType(Object.class));

     // Take any bean name that we can determine URLs for.
     for (String beanName : beanNames) {
         String[] urls = determineUrlsForHandler(beanName);
         if (!ObjectUtils.isEmpty(urls)) {
             // URL paths found: Let's consider it a handler.
             registerHandler(urls, beanName);
         }
         else {
             if (logger.isDebugEnabled()) {
                 logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");
             }
         }
     }
 }

  2. 不依賴@Component，自定義掃描。所以就有了第二個例子。

自定義掃描

結構比較複雜，可以參考完整的例子，這裡是關鍵的幾個類

  1. 還是定義一個註解，只不過不再需要@Component了

    @Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CustomizeComponent {
  String value() default "";
}

  2. 註解修飾的類

    @CustomizeComponent
public class ScanClass1 {
 public void print() {
     System.out.println("scanClass1");
 }
}

  3. BeanScannerConfigurer用於嵌入到Spring的載入過程的中，這裡用到了BeanFactoryPostProcessor 和ApplicationContextAware。
    Spring提供了一些的介面使程式可以嵌入Spring的載入過程。這個類中的繼承ApplicationContextAware介面，Spring會讀取ApplicationContextAware型別的的JavaBean，並呼叫setApplicationContext(ApplicationContext applicationContext)傳入Spring的applicationContext。
    同樣繼承BeanFactoryPostProcessor介面，Spring會在BeanFactory的相關處理完成後呼叫postProcessBeanFactory方法，進行定製的功能。

    @Component
public static class BeanScannerConfigurer implements  BeanFactoryPostProcessor, ApplicationContextAware {
 private ApplicationContext applicationContext;

 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
   this.applicationContext = applicationContext;
 }
 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
   Scanner scanner = new Scanner((BeanDefinitionRegistry) beanFactory);
   scanner.setResourceLoader(this.applicationContext);
   scanner.scan("org.wcong.test.spring.scan");
 }
}
  4. Scanner繼承的ClassPathBeanDefinitionScanner是Spring內建的Bean定義的掃描器。
    includeFilter裡定義了類的過濾器，newAnnotationTypeFilter(CustomizeComponent.class)表示只取被CustomizeComponent修飾的類。
    doScan裡掃面了包底下的讀取道德BeanDefinitionHolder，自定義GenericBeanDefinition相關功能。
    public final static class Scanner extends ClassPathBeanDefinitionScanner {
   public Scanner(BeanDefinitionRegistry registry) {
       super(registry);
   }
   public void registerDefaultFilters() {
       this.addIncludeFilter(new AnnotationTypeFilter(CustomizeComponent.class));
   }
   public Set<BeanDefinitionHolder> doScan(String... basePackages) {
       Set<BeanDefinitionHolder> beanDefinitions =   super.doScan(basePackages);
       for (BeanDefinitionHolder holder : beanDefinitions) {
           GenericBeanDefinition definition = (GenericBeanDefinition) holder.getBeanDefinition();
           definition.getPropertyValues().add("innerClassName", definition.getBeanClassName());
           definition.setBeanClass(FactoryBeanTest.class);
       }
       return beanDefinitions;
   }
   public boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
      return super.isCandidateComponent(beanDefinition) && beanDefinition.getMetadata()
.hasAnnotation(CustomizeComponent.class.getName());
   }
}
  5. FactoryBean是Spring中比較重要的一個類。它的描述如下
    Interface to be implemented by objects used within a BeanFactory which are themselves factories. 
If a bean implements this interface, it is used as a factory for an object to expose, not directly as a bean* instance that will be exposed itself
    普通的JavaBean是直接使用類的例項，但是如果一個Bean繼承了這個藉口，就可以通過getObject()方法來自定義例項的內容，在FactoryBeanTest的getObject()就通過代理了原始類的方法，自定義類的方法。
    public static class FactoryBeanTest<T> implements InitializingBean, FactoryBean<T> {
   private String innerClassName;
   public void setInnerClassName(String innerClassName) {
       this.innerClassName = innerClassName;
   }
   public T getObject() throws Exception {
       Class innerClass = Class.forName(innerClassName);
       if (innerClass.isInterface()) {
           return (T) InterfaceProxy.newInstance(innerClass);
       } else {
           Enhancer enhancer = new Enhancer();
           enhancer.setSuperclass(innerClass);
           enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
           enhancer.setCallback(new MethodInterceptorImpl());
           return (T) enhancer.create();
       }
   }
   public Class<?> getObjectType() {
       try {
             return Class.forName(innerClassName);
       } catch (ClassNotFoundException e) {
             e.printStackTrace();
       }
       return null;
   }
   public boolean isSingleton() {
       return true;
   }
   public void afterPropertiesSet() throws Exception {
   }
}
public static class InterfaceProxy implements InvocationHandler {
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       System.out.println("ObjectProxy execute:" + method.getName());
       return method.invoke(proxy, args);
   }
   public static <T> T newInstance(Class<T> innerInterface) {
       ClassLoader classLoader = innerInterface.getClassLoader();
       Class[] interfaces = new Class[] { innerInterface };
       InterfaceProxy proxy = new InterfaceProxy();
       return (T) Proxy.newProxyInstance(classLoader, interfaces, proxy);
   }
  }
  public static class MethodInterceptorImpl implements MethodInterceptor {
       public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
       System.out.println("MethodInterceptorImpl:" + method.getName());
       return methodProxy.invokeSuper(o, objects);
   }
}
  6. main函式
    @Configuration
public class CustomizeScanTest {
 public static void main(String[] args) {
     AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();                
     annotationConfigApplicationContext.register(CustomizeScanTest.class);
     annotationConfigApplicationContext.refresh();
     ScanClass1 injectClass = annotationConfigApplicationContext.getBean(ScanClass1.class);
     injectClass.print();
 }
}

至此一個完整的例子就完成了，這裡主要用到了BeanFactoryPostProcessor，ApplicationContextAware，FactoryBean等Spring內建的介面，來嵌入Spring的載入和使用過程，這樣就實現了自定義註解，和自定義代理了。



文／wcong（簡書作者）
原文連結：http://www.jianshu.com/p/7c2948f64b1c
著作權歸作者所有，轉載請聯絡作者獲得授權，並標註“簡書作者”。

相關推薦

深入Spring:自定義註解載入和使用

前言在工作中經常使用Spring的相關框架，免不了去看一下Spring的實現方法，瞭解一下Spring內部的處理邏輯。特別是開發Web應用時，我們會頻繁的定義@Controller，@Service等JavaBean元件，通過註解，Spring自動掃描載入了這些元件，並提供相

深入Spring:自定義註解載入和使用 144 作者 wcong 關注 2016.03.23 13:41* 字數 1573 閱讀 7651評論 7喜歡 22 前言 在工作中經常使用Spring的相

前言 在工作中經常使用Spring的相關框架，免不了去看一下Spring的實現方法，瞭解一下Spring內部的處理邏輯。特別是開發Web應用時，我們會頻繁的定義@Controller，@Service等JavaBean元件，通過註解，Spring自動掃描載入了這些元件，並提供相關的服務。 Spring是如

Spring自定義註解載入

在工作中經常使用Spring的相關框架，免不了去看一下Spring的實現方法，瞭解一下Spring內部的處理邏輯。特別是開發Web應用時，我們會頻繁的定義@Controller，@Service等JavaBean元件，通過註解，Spring自動掃描載入了這些元件

spring --自定義註解（配合@Aspect）

IT ng- runtime 自定義 alt type cee pan cut 1:首先，聲明自定義註解 @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) public @interface

Json過濾器（基於spring自定義註解的方式，對欄位進行過濾）

在實際的開發過程中，會經常遇到如下情景： 後臺需要給前端返回JSON資料,但是查詢出來返回的資料裡面有很多屬性是不需要的 本文通過自定義註解的方式進行實現，對response進行攔截，通過註解引數，設定欄位資訊（即，過濾哪些欄位，保留哪些欄位）,並將bean自動封裝

初識Spring自定義註解的使用

在專案上遇到Spring自定義註解時，一直想搞明白如何使用，今天就找個時間來研究一下…供初學者參考，歡迎大家的指正。 Java5.0定義的元註解： [email protected], 　　　　[email protected], 　　　　[emai

【Redis】redis非同步訊息佇列+Spring自定義註解+AOP方式實現系統日誌持久化

說明： 　　SSM專案中的每一個請求都需要進行日誌記錄操作。一般操作做的思路是：使用springAOP思想，對指定的方法進行攔截。拼裝日誌資訊實體，然後持久化到資料庫中。可是仔細想一下會發現：每次的客戶端的每一次請求，伺服器都會處理兩件事情。一個是正常的業務操作；另一個就是我們額外要做的日誌資料記錄。這樣的

spring自定義註解的簡單使用案例+ApplicationContextAware介面的使用

  程式碼 註解 @Target({ ElementType.TYPE })//註解用在介面上 @Retention(RetentionPolicy.RUNTIME)//VM將在執行期也保留註釋，因此可以通過反射機制讀取註解的資訊 @Component public @inter

spring 自定義註解實現登陸攔截

需求：自定義一個註解，使得controller層的類或者方法在寫上這個註解後，會有登陸驗證。實現原理：（1）先寫一個自定義註解，註解上可以通過註釋確定是類/方法可以加此註解。（2）之後，寫一個攔截器，攔截器內可以通過handler得到被攔截器攔截的類或者方法，之後可以通過這個

spring 自定義註解實現日誌統一處理

需求：通過註解的方式 統一處理controller和service的日誌（實現上可能不太嚴謹，主要是實現流程）原理：先自定義註解。用aop切面攔截方法的使用，看是否有對應的自定義的註解，如果有，在切面中進行日誌的統一列印，可以獲取到加了註解方法的類名、方法名、引數。如果想每個

spring 自定義註解annotation+aspect 環繞通知配置對dubbo的consumer監控報警

背景： 對dubbo 的consumer端進行統一監控，實現consumer的統一異常處理、前置provider服務的可用性校驗(若dubobo服務不可以發簡訊提醒) 思路： (1)自定義annotation,僅作用在類、方法上。減少程式碼耦合性，consumer的

spring自定義註解

java註解 即是註釋了，百度解釋：也叫元資料。一種程式碼級別的說明。 個人理解：就是內容可以被程式碼理解的註釋，一般是一個類。 元資料 也叫元註解，是放在被定義的一個註解類的前面 ，是對註解一種限制。 談下這兩個： @Retention 和 @Target   @

Java自定義註解(原理和API)初探

    今天稍稍學習了下註解，關於註解，我想大家都不陌生，目前可能在hibernate配置中可能會用的多一點，在JPA中也會用到。我想說的是學習註解可以幫助我們更好的理解註解在框架中（比如hibernate和Spirng等）的應用。     Annotation是JDK5版本以來的新特性。目前在JavaSE

藉助Spring和自定義註解完成多資料來源配置

前一段時間研究了一下spring多資料來源的配置和使用，為了後期從多個數據源拉取資料定時進行資料分析和報表統計做準備。由於之前做過的專案都是單資料來源的，沒有遇到這種場景，所以也一直沒有去了解過如何配置多資料來源。 後來發現其實基於spring來配置和使用多資

spring boot通過自定義註解和AOP攔截指定的請求

本文主要通過切面類和自定註解的方式，攔截指定的介面（程式碼中已經作了詳細的說明） 目錄 一 準備工作 三 切面類 五 測試結果  一 準備工作 1.1 新增依賴 通過spr

Spring自定義標籤和spring.handlers的載入過程

版權宣告：------------轉載請標明連結.部落格內容僅供參考,一切以官方文件為準!------------    https://blog.csdn.net/wabiaozia/article/details/78631259 此篇部落格分為三部分：1 sch

利用Spring AOP自定義註解解決日誌和簽名校驗

一、需解決的問題 部分API有簽名引數（signature），Passport首先對簽名進行校驗，校驗通過才會執行實現方法。 　　　　第一種實現方式(Origin)：在需要簽名校驗的接口裡寫校驗的程式碼，例如： boolean isValid = accountService.val

Spring 關於bean的獲取以及自定義註解的起始注入和獲取

    最近有收穫了一點東西，特來記錄。假設一個場景，一個學生的學習計劃根據其不同的人，和學習內容有不同的結果，和處理方式。按照我們正常的寫法，應該是就是構造一個’內容‘介面。例如 public interface PersonAnnotationService {

自己試驗在spring的環繞通知裡獲取目標物件的類名和目標方法的引數類名，用於根據自定義註解判斷訪問許可權，有沒有更好的辦法，高手指點一下

public Object doInBusiness(ProceedingJoinPoint pjp) throws Throwable{   Object[] args = pjp.getArgs();   Class[] argsClass = new Class[ar

通過自定義註解和java反射實現Spring-DI依賴注入

依賴注入的原理就是簡單說就是從頭往下遞迴生成依賴物件的，然後對引用欄位賦值最後返回。 這裡實現通過變數型別來生成相應的物件。 模擬一個使用者的註冊業務，首先是controller層呼叫service層，然後呼叫dao層程式碼實現儲存使用者。 檔案結構： UserC