Spring中你可能不知道的事(一)

Spring作爲Java的王牌開源項目,相信大家都用過,但是可能大家僅僅用到了Spring最常用的功能,Spring實在是龐大了,很多功能可能一輩子都不會用到,今天我就羅列下Spring中你可能不知道的事。一是可以幫助大家以後閱讀源碼,知道Spring爲什麼會這麼寫,二是可以作爲知識儲備,當人家不會的時候,你正好知道這個點,三下五除二就搞定了,嘿嘿。三是平時吹牛的時候可以更有資本。。。當然最重要的就是可以對Spring有一個更全面的認識。

register

現在官方推薦應該就是用JavaConfig的風格來完成Spring的配置,也是現在的主流用法。我們經常這麼寫:

@Configuration
@ComponentScan
public class AppConfig {
}
AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(AppConfig.class);

這段代碼太簡單,就不再解釋了,但是我們可以把方法拆分下:

AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext();
context.register(AppConfig.class);

在第二行代碼纔去註冊配置類。

效果是一樣的,我們除了可以註冊配置類,還可以單獨註冊一個 bean:

@Component
public class Service {
}
public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(Service.class);
        context.refresh();//很重要        
        System.out.println(context.getBean(Service.class).getClass().getSimpleName());
    }
}

這樣我們就可以完成對bean的注入,這裏面有一個細節很重要,需要調用refresh方法,不然會報錯:

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(Service.class);
        System.out.println(context.getBean(Service.class).getClass().getSimpleName());
    }
}

registerBean

上面的方法雖然可以單獨註冊一個bean,但是在bean的類上,你必須打上@Component或者@Service或者@Repository,如果你不想用默認的作用域,也得打上@Scope,有沒有一種方法,可以不用在bean的類上打各種註解?此時registerBean出場了:

public class Service {
    public Service(String str){
        System.out.println(str);
    }
}
public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.registerBean("myService", Service.class, () -> new Service("Hello"), z -> {
            z.setScope("prototype");
        });
        context.refresh();
        System.out.println(context.getBean("myService").getClass().getSimpleName());
        System.out.println(context.getBeanDefinition("myService").getScope());
    }
}

我註冊了名爲myService的Bean,類是Service,並且作用域爲prototype,且會調用帶參的構造方法:

BeanPostProcessor

如果說上面兩個小點不重要,那麼這一個就是重磅級的了,BeanPostProcessor是Spring擴展點之一,BeanPostProcessor是一個接口,程序員可以通過實現它,插手bean的實例化過程,在bean創建前後做一些事情。在Spring內部,也大量的運用了BeanPostProcessor來完成各種功能。我們可以看下Spring內部有多少類實現了BeanPostProcessor接口(注意,注意,前方高能)。

Spring內部有這麼多類(間接)實現了BeanPostProcessor接口,可想而知這個接口的重要性,那麼這個接口應該怎麼使用呢,很簡單,我們只需要寫一個類去實現BeanPostProcessor接口就可以。

在這裏,我利用這個接口,來完成一個閹割版的JDK動態代理的注入:

首先定義一個接口:

public interface Service {
    void query();
}

實現類:

@Component
public class ServiceImpl implements  Service {
    @Override
    public void query() {
        System.out.println("正在查詢中");
    }
}

實現InvocationHandler接口:

public class MyInvationHandler implements InvocationHandler {
    private Object target;

    public MyInvationHandler(Object target){
        this.target=target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("進來了");
        Object obj = method.invoke(target, args);
        System.out.println("出去了");
        return obj;
    }
}

實現BeanPostProcessor 接口:

@Component
public class MyBeanPostProcess implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        Object o = Proxy.newProxyInstance(MyBeanPostProcess.class.getClassLoader(),
                bean.getClass().getInterfaces(), new MyInvationHandler(bean));
        return o;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

配置類

@Configuration
@ComponentScan
public class AppConfig {
}

測試方法:

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        context.getBean(Service.class).query();
    }
}

運行結果:

有木有很神奇,不管在main方法,還是業務的實現類,都沒有看到JDK動態代理的影子,但是動態代理真真實實生效了,這就是BeanPostProcessor接口的神奇所在,事實上,Spring內部也是通過實現BeanPostProcessor接口來完成動態代理的,這個暫時不表。

BeanFactoryPostProcessor

BeanFactoryPostProcessor也是Spring的擴展點,程序員可以通過實現它,讀取bean的定義,然後對其進行修改,比如我需要修改bean的作用域爲prototype,可以這麼做:

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory factory) throws BeansException {
        factory.getBeanDefinition("repo").setScope("prototype");
    }
}
@Repository
public class Repo {
}
public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        System.out.println(context.getBeanDefinition("repo").getScope());
    }
}

大家都知道bean的默認作用域爲singleton,這裏就通過實現BeanFactoryPostProcessor接口,把作用域改成了prototype。

BeanFactoryPostProcessor 在 BeanPostProcessor之前。

單例bean中有原型bean

如果一個單例的bean中,包含原型的bean,會發生什麼事情呢?我們寫一個例子看一下:

@Configuration
@ComponentScan
public class AppConfig {
    @Bean
    @Scope("singleton")
    public Single singleton(){
        return new Single();
    }
    @Bean
    @Scope("prototype")
    public Prototype prototype(){
        return new Prototype();
    }
}
public class Single {
    public Single(){
        System.out.println("Single構造方法");
    }
    @Autowired
    private Prototype prototype;
    public Prototype getPrototype() {
        return prototype;
    }
    public void setPrototype(Prototype prototype) {
        this.prototype = prototype;
    }
    public void say() {
        System.out.println(this);
        prototype.say();
    }
}
public class Prototype {
    public Prototype(){
        System.out.println("Prototype構造方法");
    }
    public void say() {
        System.out.println(this);
    }
}
@Component
public class Test {
    @Autowired
    Single single;
    public void run() {
        for (int i = 0; i < 5; i++) {
            single.say();
        }
    }
}

因爲代碼比較長,避免大家上下來回滾動,我簡單的說明下這段代碼:Single類是單例的,Prototype是原型的,Single類依賴Prototype,分別給兩個類添加一個構造方法,打印一句話,Single類中的方法調用Prototype類的方法,兩個方法都打印this。然後再測試方法中自動注入Single,循環5次,調用Single類中的方法。

運行結果:


這結果明顯有問題,Single因爲是單例的,只能執行到一次構造方法,每次打印出來的對象也相同,這是沒有問題的,但是Prototype是原型的,也只運行了一次構造函數,打印出來的對象也相同,這就有問題了。

這問題怎麼解決呢?

ApplicationContextAware

對Single類進行改造,讓它實現ApplicationContextAware接口中的setApplicationContext方法:

public class Single implements ApplicationContextAware {
    public Single() {
        System.out.println("Single構造方法");
    }

    private ApplicationContext context;

    public void say() {
        System.out.println(this);
        context.getBean(Prototype.class).say();
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }
}

運行結果:

說的簡單點,就是通過ApplicationContextAware接口中的setApplicationContext方法,獲得ApplicationContext ,賦值給類中的變量ApplicationContext context, 然後從context中獲得Prototype Bean。

此方法需要依賴ApplicationContext。

lookup

@Component
@Scope("singleton")
public class Single {
    public Single() {
        System.out.println("Single構造方法");
    }
    public void say() {
        System.out.println(this);
        getPrototype().say();
    }
    @Lookup
    public Prototype getPrototype() {
        return null;
    }
}
@Component
@Scope("prototype")
public class Prototype {
    public Prototype(){
        System.out.println("Prototype構造方法");
    }

    public void say() {
        System.out.println(this);
    }
}

運行結果:

此方法需要把配置類中的定義bean改爲在類上加註解的方式。

Import

Import是Spring提供的註解,可以通過這個註解,在一個類引入另外一個類, 並且自動完成另外一個類的註冊:

@Configuration
@Import(ServiceImpl.class)
public class AppConfig {
}
public class ServiceImpl  {
    public void query() {
        System.out.println("正在查詢中");
    }
}
public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        context.getBean(ServiceImpl.class).query();
    }
}

運行結果:

可以看到雖然ServiceImpl類上沒有打上任何註解,但是在AppConfig配置類上通過Import註解,把ServiceImpl給引入進來了,並且自動註冊了ServiceImpl。

也許,單單使用Import註解,會把代碼搞得更復雜,所以需要搭配使用,才能把它的能力發揮出來,下面讓我們有請ImportSelector。

ImportSelector

讓我們把目光回到介紹BeanPostProcessor的這一段中,在其中,我們定義了一個MyBeanPostProcess來完成JDK動態代理,但是讓我們想一個問題,如果我們不需要使用這個MyBeanPostProcess了,怎麼辦?我們需要把MyBeanPostProcess類上的Component註解刪除,哪天又需要使用了,還得加上,如果只有一個類,還不算糟糕,但是如何有幾十個類呢?相當麻煩,我們能不能在一個類中統一處理,需要啓動哪些Bean,就像Spring Boot 一樣?當然可以。我們可以藉助於ImportSelector來完成:

首先我們需要定義一個類,實現ImportSelector 中的
selectImports方法,這個方法返回的是需要與此類綁定的bean的名稱的數組:

public class AspectSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{MyBeanPostProcess.class.getName()};
    }
}

我們再自定義一個註解,打上Import註解,引入上面的類:

@Import(AspectSelector.class)
@Retention(RetentionPolicy.RUNTIME)
public @interface EnableAspect{
}

注意看AppConfig 的註解,多了一個EnableAspect註解:

@Configuration
@ComponentScan
@EnableAspect
public class AppConfig {
}
public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        context.getBean(Service.class).query();
    }
}

然後我們把MyBeanPostProcess上的註解刪除,運行:

當我們不需要使用MyBeanPostProcess了,只要在AppConfig刪除EnableAspect註解就OK了。

這是相當炫酷的一個技巧,在SpringBoot大量使用,比如開啓事務管理EnableTransactionManagement。

FactoryBean

FactoryBean經常會和BeanFactory放在一起比較,因爲他們太像了,不過僅僅是長得像,其實它們完全不是同一個東西。

FactoryBean,是一種特殊的Bean,特殊在它除了自身是Baen,還可以生產Bean,是不是很符合FactoryBean這個名稱?

FactoryBean是一個接口,我們需要實現它:

@Component
public class MyFactoryBean implements FactoryBean {

    public Object getObject() throws Exception {
        return new DataSource();
    }
    @Override
    public Class<?> getObjectType() {
        return null;
    }
}
public class DataSource {
}
@Configuration
@ComponentScan
public class AppConfig {
}
public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        System.out.println(context.getBean("myFactoryBean").getClass().getSimpleName());
        System.out.println(context.getBean("&myFactoryBean").getClass().getSimpleName());
    }
}

運行結果:

我們可以看到MyFactoryBean上打了一個Component,它可以被掃描到,但是DataSource上什麼都沒有加,按理來說,是沒有被掃描到的,但是它就是被註冊進去了,因爲它實現了FactoryBean接口,在getObject方法返回了DataSource的實例,可以理解爲DataSource是MyFactoryBean生產出來的一個Bean。

讓我們仔細看下main方法和運行結果,可以看到 MyFactoryBean本身的BeanName是&myFactoryBean,MyFactoryBean生產出來的Bean的BeanName是myFactoryBean。

這有什麼用呢?可以隱藏構建Bean的細節。如果我們的DataSource是第三方提供的,裏面有一堆的字段需要配置,還有一堆的依賴,如果我們來配置的話,根本無法完成,最好的辦法就是還是交給維護第三方去配置,但是DataSource是不能去修改的。這個時候,就可以用FactoryBean來完成,在getObject配置好DataSource,並且返回。我們經常使用的Mybatis也利用了FactoryBean接口。

Spring實在是太龐大了,很多功能都不是經常用,我在這裏只是稍微羅列了幾個小點,加上我們經常用的那些,可能還不及Spring的十分之一,這已經是樂觀的了。

限於篇幅關係,這一章的內容到這裏就結束了,其中BeanPostProcessor,BeanFactoryPostProcessor,FactoryBean,Import,ImportSelector這幾塊內容非常重要,正在由於這些,才讓Spring變的更加靈活,更加好用。

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章