Spring中你可能不知道的事（一）

時間  2019-11-29
標籤 spring 可能 不知道 欄目 Spring 简体版
原文   原文鏈接

Spring做爲Java的王牌開源項目，相信你們都用過，可是可能你們僅僅用到了Spring最經常使用的功能，Spring實在是龐大了，不少功能可能一生都不會用到，今天我就羅列下Spring中你可能不知道的事。一是能夠幫助你們之後閱讀源碼，知道Spring爲何會這麼寫，二是能夠做爲知識儲備，當人家不會的時候，你正好知道這個點，三下五除二就搞定了，嘿嘿。三是平時吹牛的時候能夠更有資本。。。固然最重要的就是能夠對Spring有一個更全面的認識。程序員

register

如今官方推薦應該就是用JavaConfig的風格來完成Spring的配置，也是如今的主流用法。咱們常常這麼寫：數組

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

這段代碼太簡單，就再也不解釋了，可是咱們能夠把方法拆分下：bash

AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext();
context.register(AppConfig.class);
複製代碼

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

效果是同樣的，咱們除了能夠註冊配置類，還能夠單獨註冊一個 bean：ide

@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());
    }
}
複製代碼

image.png

registerBean

上面的方法雖然能夠單獨註冊一個bean，可是在bean的類上，你必須打上@Component或者@Service或者@Repository，若是你不想用默認的做用域，也得打上@Scope，有沒有一種方法，能夠不用在bean的類上打各類註解？此時registerBean出場了：post

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，且會調用帶參的構造方法：測試

image.png

BeanPostProcessor

若是說上面兩個小點不重要，那麼這一個就是重磅級的了，BeanPostProcessor是Spring擴展點之一，BeanPostProcessor是一個接口，程序員能夠經過實現它，插手bean的實例化過程，在bean建立先後作一些事情。在Spring內部，也大量的運用了BeanPostProcessor來完成各類功能。咱們能夠看下Spring內部有多少類實現了BeanPostProcessor接口(注意，注意，前方高能)。ui

image.png

Spring內部有這麼多類（間接）實現了BeanPostProcessor接口，可想而知這個接口的重要性，那麼這個接口應該怎麼使用呢，很簡單，咱們只須要寫一個類去實現BeanPostProcessor接口就能夠。this

在這裏，我利用這個接口，來完成一個閹割版的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();
    }
}
複製代碼

運行結果：

image.png

有木有很神奇，無論在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());
    }
}
複製代碼

image.png
你們都知道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類中的方法。

運行結果：

image.png

這結果明顯有問題，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;
    }
}
複製代碼

運行結果：

image.png

說的簡單點，就是經過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);
    }
}
複製代碼

運行結果：

image.png

此方法須要把配置類中的定義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();
    }
}
複製代碼

運行結果：

image.png

能夠看到雖然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上的註解刪除，運行：

image.png

當咱們不須要使用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());
    }
}
複製代碼

運行結果：

image.png

咱們能夠看到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變的更加靈活，更加好用。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程