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

摘要： Spring作為Java的王牌開源專案，相信大家都用過，但是可能大家僅僅用到了Spring最常用的功能，Spring實在是龐大了，很多功能可能一輩子都不會用到，今天我就羅列下Spring中你可能不知道的事。一是可以幫助大家以後閱讀原始碼，知道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());
}
}
複製程式碼

如果選擇先例項化AnnotationConfigApplicationContext ，再去註冊，當註冊配置類的時候，不需要呼叫refresh方法，但是註冊bean的時候，需要呼叫refresh方法。

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 implementsService {
@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變的更加靈活，更加好用。