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