Configuration以及Bean註解的使用

該知識點在Spring中應該學過，沒有學過或者遺忘的的朋友需要預習或溫習前置知識點。SpringBoot其實就是Spring的進一步簡化，所以前置知識點還是有必要的學習的，這樣更能明白其底層的原理。

好了，廢話不多說，開始！

結構目錄：

pojo--User:

  1. package com.xbhog.pojo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. @NoArgsConstructor
  8. @AllArgsConstructor
  9. @Data
  10. public class User {
  11.     private  String name;
  12.     private int age;
  13. }

config-MyConfig:

  1. package com.xbhog.config;
  3. import com.xbhog.pojo.User;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  7. @Configuration
  8. public class MyConfig {
  9.     @Bean
  10.     public User user(){
  11.         return new User("xbhog",18);
  12.     }
  13. }

controller-Mycontroller:

  1. package com.xbhog.controller;
  3. import com.xbhog.config.MyConfig;
  4. import com.xbhog.pojo.User;
  5. import org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration;
  6. import org.springframework.context.ApplicationContext;
  7. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  8. import org.springframework.context.support.ClassPathXmlApplicationContext;
  10. public class Mycontroller {
  11.     public static void main(String[] args) {
  12.         ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
  13.         User user = context.getBean("user", User.class);
  14.         System.out.println(user.toString());
  15.     }
  16. }

前面這三個檔案埋了一個坑，使用SpringBoot啟動的話是找不到Bean的，因為我們必須把檔案放到與主啟動程式同一目錄下，這樣才能找到，可以這樣：這是由於SpringBootApplication的掃描路徑決定的

但是當我們把Myapp放入主程式資料夾時：發現並沒有找到相應的元件資訊

在不改變原來的程式的情況下，我們可以使用手動掃描的方式，設定自定義掃名路徑：

  1. package com.xbhog.springboot1times;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.SpringBootConfiguration;
  5. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  7. import org.springframework.context.ConfigurableApplicationContext;
  8. import org.springframework.context.annotation.ComponentScan;
  10. //@SpringBootApplication
  11. @SpringBootConfiguration
  12. @EnableAutoConfiguration
  13. @ComponentScan("com.xbhog")   //設定掃描路徑
  14. public class Myapp {
  15.     public static void main(String[] args) {
  16.         /*1. 返回我們IOC容器*/
  17.         ConfigurableApplicationContext run = SpringApplication.run(Myapp.class, args);
  18.         /*2.檢視容器裡面的元件*/
  19.         String[] names = run.getBeanDefinitionNames();
  20.         for(String name:names){
  21.             System.out.println(name);
  22.         }
  23.     }
  24. }

效果顯示：

單例項問題：

  1. 判斷元件在容器中是否為單例項：
  1. package com.xbhog.springboot1times;
  3. import com.xbhog.pojo.Pet;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.SpringBootConfiguration;
  6. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
  7. import org.springframework.boot.autoconfigure.SpringBootApplication;
  8. import org.springframework.context.ConfigurableApplicationContext;
  9. import org.springframework.context.annotation.ComponentScan;
  11. //@SpringBootApplication
  12. @SpringBootConfiguration
  13. @EnableAutoConfiguration
  14. @ComponentScan("com.xbhog")
  15. public class Myapp {
  16.     public static void main(String[] args) {
  17.         /*1. 返回我們IOC容器*/
  18.         ConfigurableApplicationContext run = SpringApplication.run(Myapp.class, args);
  19.         /*2.從容器中獲取元件*/
  20.         Pet tom1 = run.getBean("tom11", Pet.class);
  21.         Pet tom2 = run.getBean("tom11", Pet.class);
  22.         System.out.println("元件是否為單例項："+(tom1== tom2));
  23.     }
  24. }

元件是否為單例項：true

Myconfig呼叫問題：

因為配置類也屬於元件，如果我們獲取配置類元件後，通過例項化物件在呼叫其中的bean,是呼叫普通方法呢，還是呼叫容器中的相應的元件？

  1. package com.xbhog.springboot1times;
  3. import com.xbhog.config.MyConfig;
  4. import com.xbhog.pojo.Pet;
  5. import com.xbhog.pojo.User;
  6. import org.springframework.boot.SpringApplication;
  7. import org.springframework.boot.SpringBootConfiguration;
  8. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
  9. import org.springframework.boot.autoconfigure.SpringBootApplication;
  10. import org.springframework.context.ConfigurableApplicationContext;
  11. import org.springframework.context.annotation.ComponentScan;
  13. //@SpringBootApplication
  14. @SpringBootConfiguration
  15. @EnableAutoConfiguration
  16. @ComponentScan("com.xbhog")
  17. public class Myapp {
  18.     public static void main(String[] args) {
  19.         /*1. 返回我們IOC容器*/
  20.         ConfigurableApplicationContext run = SpringApplication.run(Myapp.class, args);
  21.         /*2.檢視容器裡面的元件*/
  22.         String[] names = run.getBeanDefinitionNames();
  23.         for(String name:names){
  24.             System.out.println(name);
  25.         }
  26.         /*3.從容器中獲取元件*/
  27.         Pet tom1 = run.getBean("tom11", Pet.class);
  28.         Pet tom2 = run.getBean("tom11", Pet.class);
  29.         System.out.println("元件是否為單例項："+(tom1== tom2));
  31.         MyConfig bean = run.getBean(MyConfig.class);
  32.         System.out.println(bean);
  34.         User user1 = bean.user();
  35.         User user2 = bean.user();
  36.         System.out.println("測試通過Myconfig類呼叫的user元件："+(user1==user2));
  37.     }
  38. }

效果如下：

  1. 元件是否為單例項：true
  2. com.xbhog.config.MyConfig EnhancerBySpringCGLIB 9b1ae7c2@6c0905f6
  3. 測試通過Myconfig類呼叫的user元件：true

上面的效果也就是Configuration(proxyBeanMethods=true)的作用，保證每個@Bean方法被呼叫多少次返回的元件都是單例項的

實際上就是proxyBeanMethods：代理bean的方法(true)，外部無論對配置類中的這個元件註冊方法呼叫多少次獲取的都是之前註冊容器中的單例項物件,也叫：FULL模式.

當proxyBeanMethods=true時：

MyConfig返回的Bean本身就是代理物件，CGLIB，並且測試通過Myconfig類呼叫的user元件：true.

com.xbhog.config.MyConfig EnhancerBySpringCGLIB 9b1ae7c2@6c0905f6

  1. MyConfig bean = run.getBean(MyConfig.class);
  2. System.out.println(bean);
  3. //如果@Configuration(proxyBeanMethods = true)代理物件呼叫方法。
  4. // SpringBoot總會檢查這個元件是否在容器中有。
  5. User user1 = bean.user();
  6. User user2 = bean.user();
  7. System.out.println("測試通過Myconfig類呼叫的user元件："+(user1==user2));

當：proxyBeanMethods=false時(Lite模式-輕量級)：

MyCnfig返回的就不是代理模式，測試通過Myconfig類呼叫的user元件：false

總結：

proxyBeanMethods：代理bean的方法 ;

  • Full(proxyBeanMethods = true)、【保證每個@Bean方法被呼叫多少次返回的元件都是單例項的】
  • Lite(proxyBeanMethods = false)【每個@Bean方法被呼叫多少次返回的元件都是新建立的】
  • 元件依賴必須使用Full模式預設。其他預設是否Lite模式

使用場景:

現在向pojo.User中新增Pet物件:

  1. package com.xbhog.pojo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. @NoArgsConstructor
  8. @AllArgsConstructor
  9. @Data
  10. public class User {
  11.     private  String name;
  12.     private int age;
  13.     private  Pet pet;
  14. }

在proxyBeanMethods=true模式下才是正確的;

  1. package com.xbhog.config;
  3. import com.xbhog.pojo.Pet;
  4. import com.xbhog.pojo.User;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  8. @Configuration  //告訴SpringBoot這是一個配置類  ==  application.xml
  9. public class MyConfig {
  10.     @Bean  //給容器新增元件，以方法名作為元件的id，返回型別就是元件型別。返回的值，就是元件在容器中的例項
  11.     public User user(){
  12.         User user = new User("xbhog", 18);
  13.         //user元件依賴與Pet元件,使用者中的寵物與容器中的寵物時一樣的
  14.         user.setPet(tomcat());
  15.         return user;
  16.     }
  17.     @Bean("tom11")  //設定bean別名--》id的名字
  18.     public Pet tomcat(){
  19.         return new Pet("tomcat");
  20.     }
  21. }
  1. User user = run.getBean("user", User.class);
  2. Pet tom3 = run.getBean("tom11", Pet.class);
  3. System.out.println("使用者的寵物"+(user.getPet() == tom3));

使用者的寵物true;

在proxyBeanMethods=false模式後，就不會掃描容器，直接建立物件:

元件是否為單例項：true

com.xbhog.config.MyConfig@330c1f61

測試通過Myconfig類呼叫的user元件：false

使用者的寵物false

如果你看到這裡或者正好對你有所幫助，希望能點個關注或者推薦，感謝；

有錯誤的地方，歡迎在評論指出，作者看到會進行修改。