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());
}
}
複製程式碼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變的更加靈活，更加好用。