作者 | 蘇三 ? ?責編 | 張文
來源 | 蘇三說技術(ID:gh_9f551dfec941)
最近越來越多的讀者認可我的文章,還是件挺讓人高興的事情。有些讀者私信我說希望后面多分享 Spring 方面的文章,這樣能夠在實際工作中派上用場。正好我對spring源碼有過一定的研究,并結合我這幾年實際的工作經驗,把 Spring中我認為不錯的知識點總結一下,希望對您有所幫助。
@Servicepublic class PersonService implements BeanFactoryAware { private BeanFactory beanFactory;@Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { this.beanFactory = beanFactory; }public void add() { Person person = (Person) beanFactory.getBean("person"); }}
實現 BeanFactoryAware 接口,然后重寫 setBeanFactory 方法,就能從該方法中獲取到 Spring 容器對象。
@Servicepublic class PersonService2 implements ApplicationContextAware { private ApplicationContext applicationContext;@Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = applicationContext; }public void add() { Person person = (Person) applicationContext.getBean("person"); }
}
Springboot項目,實現 ApplicationContextAware 接口,然后重寫 setApplicationContext方法,也能從該方法中獲取到spring容器對象。
@Servicepublic class PersonService3 implements ApplicationListener<ContextRefreshedEvent> { private ApplicationContext applicationContext;@Override public void onApplicationEvent(ContextRefreshedEvent event) { applicationContext = event.getApplicationContext(); }public void add() { Person person = (Person) applicationContext.getBean("person"); }
}
實現 ApplicationListener 接口,需要注意的是該接口接收的泛型是 ContextRefreshedEvent 類,然后重寫 onApplicationEvent 方法,也能從該方法中獲取到 Spring 容器對象。
此外,不得不提一下 Aware 接口,它其實是一個空接口,里面不包含任何方法。
Spring源碼、它表示已感知的意思,通過這類接口可以獲取指定對象,比如:
通過 BeanFactoryAware 獲取 BeanFactory
通過 ApplicationContextAware 獲取 ApplicationContext
Spring Framework?通過 BeanNameAware 獲取 BeanName 等
Aware 接口是很常用的功能,目前包含如下功能:
Spring 中支持 3 種初始化 bean 的方法:
怪物獵人世界升華的武器代碼、xml中指定init-method方法
使用@PostConstruct注解
實現InitializingBean接口
java代碼優化、第一種方法太古老了,現在用的人不多,具體用法就不介紹了。
@Servicepublic class AService {@PostConstruct public void init() { System.out.println("===初始化==="); }}
在需要初始化的方法上增加@PostConstruct注解,這樣就有初始化的能力。
@Servicepublic class BService implements InitializingBean {@Override public void afterPropertiesSet() throws Exception { System.out.println("===初始化==="); }}
實現InitializingBean接口,重寫afterPropertiesSet方法,該方法中可以完成初始化功能。
這里順便拋出一個有趣的問題:init-method、PostConstruct 和 InitializingBean 的執行順序是什么樣的?
決定他們調用順序的關鍵代碼在AbstractAutowireCapableBeanFactory類的initializeBean方法中。
這段代碼中會先調用BeanPostProcessor的postProcessBeforeInitialization方法,而PostConstruct是通過InitDestroyAnnotationBeanPostProcessor實現的,它就是一個BeanPostProcessor,所以PostConstruct先執行。
而invokeInitMethods方法中的代碼:
決定了先調用InitializingBean,再調用init-method。
所以得出結論,他們的調用順序是:
我們都知道spring默認支持的Scope只有兩種:
singleton 單例,每次從spring容器中獲取到的bean都是同一個對象。
prototype 多例,每次從spring容器中獲取到的bean都是不同的對象。
spring web又對Scope進行了擴展,增加了:
RequestScope 同一次請求從spring容器中獲取到的bean都是同一個對象。
SessionScope 同一個會話從spring容器中獲取到的bean都是同一個對象。
即便如此,有些場景還是無法滿足我們的要求。
比如,我們想在同一個線程中從spring容器獲取到的bean都是同一個對象,該怎么辦?
這就需要自定義 Scope 了。
第一步實現 Scope 接口:
public class ThreadLocalScope implements Scope {private static final ThreadLocal THREAD_LOCAL_SCOPE = new ThreadLocal();@Override public Object get(String name, ObjectFactory<?> objectFactory) { Object value = THREAD_LOCAL_SCOPE.get(); if (value != null) { return value; }Object object = objectFactory.getObject(); THREAD_LOCAL_SCOPE.set(object); return object; }@Override public Object remove(String name) { THREAD_LOCAL_SCOPE.remove(); return null; }@Override public void registerDestructionCallback(String name, Runnable callback) {}@Override public Object resolveContextualObject(String key) { return null; }@Override public String getConversationId() { return null; }}
第二步將新定義的 Scope 注入到 Spring 容器中:
@Componentpublic class ThreadLocalBeanFactoryPostProcessor implements BeanFactoryPostProcessor {@Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { beanFactory.registerScope("threadLocalScope", new ThreadLocalScope()); }}
第三步使用新定義的 Scope:
@Scope("threadLocalScope")@Servicepublic class CService {public void add() { }}
說起 FactoryBean 就不得不提 BeanFactory,因為面試官老喜歡問它們的區別。
BeanFactory:Spring 容器的頂級接口,管理 bean 的工廠。
FactoryBean:并非普通的工廠bean,它隱藏了實例化一些復雜 Bean的細節,給上層應用帶來了便利。
如果你看過 Spring 源碼,會發現它有 70 多個地方在用 FactoryBean 接口。
上面這張圖足以說明該接口的重要性,請勿忽略它好嗎?
特別提一句:mybatis 的 SqlSessionFactory 對象就是通過 SqlSessionFactoryBean 類創建的。
我們一起定義自己的 FactoryBean:
@Componentpublic class MyFactoryBean implements FactoryBean {@Override public Object getObject() throws Exception { String data1 = buildData1(); String data2 = buildData2(); return buildData3(data1, data2); }private String buildData1() { return "data1"; }private String buildData2() { return "data2"; }private String buildData3(String data1, String data2) { return data1 + data2; }@Override public Class<?> getObjectType() { return null; }}
獲取 FactoryBean 實例對象:
@Servicepublic class MyFactoryBeanService implements BeanFactoryAware { private BeanFactory beanFactory;@Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { this.beanFactory = beanFactory; }public void test() { Object myFactoryBean = beanFactory.getBean("myFactoryBean"); System.out.println(myFactoryBean); Object myFactoryBean1 = beanFactory.getBean("&myFactoryBean"); System.out.println(myFactoryBean1); }}
getBean("myFactoryBean");獲取的是MyFactoryBeanService類中getObject方法返回的對象,
getBean("&myFactoryBean");獲取的才是MyFactoryBean對象。
Spring目前支持3中類型轉換器:
Converter<S,T>:將 S 類型對象轉為 T 類型對象
ConverterFactory<S, R>:將 S 類型對象轉為 R 類型及子類對象
GenericConverter:它支持多個source和目標類型的轉化,同時還提供了source和目標類型的上下文,這個上下文能讓你實現基于屬性上的注解或信息來進行類型轉換。
這 3 種類型轉換器使用的場景不一樣,我們以 Converter<S,T> 為例。假如:接口中接收參數的實體對象中,有個字段的類型是 Date,但是實際傳參的是字符串類型:2021-01-03 10:20:15,要如何處理呢?
第一步,定義一個實體 User:
@Datapublic class User {private Long id; private String name; private Date registerDate;}
第二步,實現 Converter 接口:
public class DateConverter implements Converter<String, Date> {private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");@Override public Date convert(String source) { if (source != null && !"".equals(source)) { try { simpleDateFormat.parse(source); } catch (ParseException e) { e.printStackTrace(); } } return null; }}
第三步,將新定義的類型轉換器注入到 Spring 容器中:
@Configurationpublic class WebConfig extends WebMvcConfigurerAdapter {@Override public void addFormatters(FormatterRegistry registry) { registry.addConverter(new DateConverter()); }}
第四步,調用接口
@RequestMapping("/user")@RestControllerpublic class UserController {@RequestMapping("/save") public String save(@RequestBody User user) { return "success"; }}
請求接口時 User 對象中 registerDate 字段會被自動轉換成 Date 類型。
Spring mvc 攔截器根 Spring 攔截器相比,它里面能夠獲取 HttpServletRequest 和 HttpServletResponse 等 Web 對象實例。
Spring mvc?攔截器的頂層接口是:HandlerInterceptor,包含三個方法:
preHandle?目標方法執行前執行
postHandle?目標方法執行后執行
afterCompletion?請求完成時執行
為了方便我們一般情況會用 HandlerInterceptor 接口的實現類 HandlerInterceptorAdapter 類。
假如有權限認證、日志、統計的場景,可以使用該攔截器。
第一步,繼承 HandlerInterceptorAdapter 類定義攔截器:
public class AuthInterceptor extends HandlerInterceptorAdapter {@Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { String requestUrl = request.getRequestURI(); if (checkAuth(requestUrl)) { return true; }return false; }private boolean checkAuth(String requestUrl) { System.out.println("===權限校驗==="); return true; }}
第二步,將該攔截器注冊到 Spring 容器:
@Configurationpublic class WebAuthConfig extends WebMvcConfigurerAdapter { @Bean public AuthInterceptor getAuthInterceptor() { return new AuthInterceptor(); }@Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(new AuthInterceptor()); }}
第三步,在請求接口時 Spring mvc 通過該攔截器,能夠自動攔截該接口,并且校驗權限。
該攔截器其實相對來說,比較簡單,可以在DispatcherServlet類的doDispatch方法中看到調用過程:
順便說一句,這里只講了 Spring mvc 的攔截器,并沒有講 Spring 的攔截器,是因為我有點小私心,后面就會知道。
不知道你有沒有用過Enable開頭的注解,比如:EnableAsync、EnableCaching、EnableAspectJAutoProxy等,這類注解就像開關一樣,只要在@Configuration定義的配置類上加上這類注解,就能開啟相關的功能。
是不是很酷?
讓我們一起實現一個自己的開關:
第一步,定義一個LogFilter:
public class LogFilter implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException {}@Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { System.out.println("記錄請求日志"); chain.doFilter(request, response); System.out.println("記錄響應日志"); }@Override public void destroy() { }}
第二步,注冊LogFilter:
@ConditionalOnWebApplicationpublic class LogFilterWebConfig {@Bean public LogFilter timeFilter() { return new LogFilter(); }}
注意,這里用了@ConditionalOnWebApplication注解,沒有直接使用@Configuration注解。
第三步,定義開關@EnableLog注解:
@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Import(LogFilterWebConfig.class)public @interface EnableLog {
}
第四步,只需在springboot啟動類加上@EnableLog注解即可開啟LogFilter記錄請求和響應日志的功能。
我們使用RestTemplate調用遠程接口時,有時需要在header中傳遞信息,比如:traceId,source等,便于在查詢日志時能夠串聯一次完整的請求鏈路,快速定位問題。
這種業務場景就能通過ClientHttpRequestInterceptor接口實現,具體做法如下:
第一步,實現ClientHttpRequestInterceptor接口:
public class RestTemplateInterceptor implements ClientHttpRequestInterceptor {@Override public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException { request.getHeaders().set("traceId", MdcUtil.get()); return execution.execute(request, body); }}
第二步,定義配置類:
@Configurationpublic class RestTemplateConfiguration {@Bean public RestTemplate restTemplate() { RestTemplate restTemplate = new RestTemplate(); restTemplate.setInterceptors(Collections.singletonList(restTemplateInterceptor())); return restTemplate; }@Bean public RestTemplateInterceptor restTemplateInterceptor() { return new RestTemplateInterceptor(); }}
其中MdcUtil其實是利用MDC工具在ThreadLocal中存儲和獲取traceId
public class MdcUtil {private static final String TRACE_ID = "TRACE_ID";public static String get() { return MDC.get(TRACE_ID); }public static void add(String value) { MDC.put(TRACE_ID, value); }}
當然,這個例子中沒有演示MdcUtil類的add方法具體調的地方,我們可以在filter中執行接口方法之前,生成traceId,調用MdcUtil類的add方法添加到MDC中,然后在同一個請求的其他地方就能通過MdcUtil類的get方法獲取到該traceId。
以前我們在開發接口時,如果出現異常,為了給用戶一個更友好的提示,例如:
@RequestMapping("/test")@RestControllerpublic class TestController {@GetMapping("/add") public String add() { int a = 10 / 0; return "成功"; }}
如果不做任何處理請求add接口結果直接報錯:
what?用戶能直接看到錯誤信息?
這種交互方式給用戶的體驗非常差,為了解決這個問題,我們通常會在接口中捕獲異常:
@GetMapping("/add")public String add() { String result = "成功"; try { int a = 10 / 0; } catch (Exception e) { result = "數據異常"; } return result;}
接口改造后,出現異常時會提示:“數據異常”,對用戶來說更友好。
看起來挺不錯的,但是有問題。。。
如果只是一個接口還好,但是如果項目中有成百上千個接口,都要加上異常捕獲代碼嗎?
答案是否定的,這時全局異常處理就派上用場了:RestControllerAdvice。
@RestControllerAdvicepublic class GlobalExceptionHandler {@ExceptionHandler(Exception.class) public String handleException(Exception e) { if (e instanceof ArithmeticException) { return "數據異常"; } if (e instanceof Exception) { return "服務器內部異常"; } retur n null; }}
只需在handleException方法中處理異常情況,業務接口中可以放心使用,不再需要捕獲異常(有人統一處理了)。真是爽歪歪。
以前我們在使用異步功能時,通常情況下有三種方式:
繼承Thread類
實現Runable接口
使用線程池
讓我們一起回顧一下:
繼承Thread類
public class MyThread extends Thread {@Override public void run() { System.out.println("===call MyThread==="); }public static void main(String[] args) { new MyThread().start(); }}
實現Runable接口
public class MyWork implements Runnable { @Override public void run() { System.out.println("===call MyWork==="); }public static void main(String[] args) { new Thread(new MyWork()).start(); }}
使用線程池
public class MyThreadPool {private static ExecutorService executorService = new ThreadPoolExecutor(1, 5, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(200));static class Work implements Runnable {@Override public void run() { System.out.println("===call work==="); } }public static void main(String[] args) { try { executorService.submit(new MyThreadPool.Work()); } finally { executorService.shutdown(); }}}
這三種實現異步的方法不能說不好,但是spring已經幫我們抽取了一些公共的地方,我們無需再繼承Thread類或實現Runable接口,它都搞定了。
如何 Spring 異步功能呢?
第一步,springboot項目啟動類上加@EnableAsync注解。
@EnableAsync@SpringBootApplicationpublic class Application {public static void main(String[] args) { new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args); }}
第二步,在需要使用異步的方法上加上@Async注解:
@Servicepublic class PersonService {@Async public String get() { System.out.println("===add=="); return "data"; }}
然后在使用的地方調用一下:personService.get();就擁有了異步功能,是不是很神奇。
默認情況下,Spring會為我們的異步方法創建一個線程去執行,如果該方法被調用次數非常多的話,需要創建大量的線程,會導致資源浪費。
這時,我們可以定義一個線程池,異步方法將會被自動提交到線程池中執行。
@Configurationpublic class ThreadPoolConfig {@Value("${thread.pool.corePoolSize:5}") private int corePoolSize;@Value("${thread.pool.maxPoolSize:10}") private int maxPoolSize;@Value("${thread.pool.queueCapacity:200}") private int queueCapacity;@Value("${thread.pool.keepAliveSeconds:30}") private int keepAliveSeconds;@Value("${thread.pool.threadNamePrefix:ASYNC_}") private String threadNamePrefix;@Bean public Executor MessageExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(corePoolSize); executor.setMaxPoolSize(maxPoolSize); executor.setQueueCapacity(queueCapacity); executor.setKeepAliveSeconds(keepAliveSeconds); executor.setThreadNamePrefix(threadNamePrefix); executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); executor.initialize(); return executor; }}
Spring異步的核心方法:
根據返回值不同,處理情況也不太一樣,具體分為如下情況:
Spring cache架構圖:
它目前支持多種緩存:
我們在這里以caffeine為例,它是 Spring 官方推薦的。
第一步,引入caffeine的相關jar包
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId></dependency><dependency> <groupId>com.github.ben-manes.caffeine</groupId> <artifactId>caffeine</artifactId> <version>2.6.0</version></dependency>
第二步,配置CacheManager,開啟EnableCaching
@Configuration@EnableCachingpublic class CacheConfig { @Bean public CacheManager cacheManager(){ CaffeineCacheManager cacheManager = new CaffeineCacheManager(); //Caffeine配置 Caffeine<Object, Object> caffeine = Caffeine.newBuilder() //最后一次寫入后經過固定時間過期 .expireAfterWrite(10, TimeUnit.SECONDS) //緩存的最大條數 .maximumSize(1000); cacheManager.setCaffeine(caffeine); return cacheManager; }}
第三步,使用Cacheable注解獲取數據
@Servicepublic class CategoryService { //category是緩存名稱,#type是具體的key,可支持el表達式 @Cacheable(value = "category", key = "#type") public CategoryModel getCategory(Integer type) { return getCategoryByType(type); }private CategoryModel getCategoryByType(Integer type) { System.out.println("根據不同的type:" + type + "獲取不同的分類數據"); CategoryModel categoryModel = new CategoryModel(); categoryModel.setId(1L); categoryModel.setParentId(0L); categoryModel.setName("電器"); categoryModel.setLevel(3); return categoryModel; }}
調用categoryService.getCategory()方法時,先從caffine緩存中獲取數據,如果能夠獲取到數據則直接返回該數據,不會進入方法體。如果不能獲取到數據,則直接方法體中的代碼獲取到數據,然后放到caffine緩存中。
Spring中不錯的功能其實還有很多,比如:BeanPostProcessor、BeanFactoryPostProcessor、AOP、動態數據源、ImportSelector等等。
程序員如何避免陷入“內卷”、選擇什么技術最有前景,中國開發者現狀與技術趨勢究竟是什么樣?快來參與「2020?中國開發者大調查」,更有豐富獎品送不停!
?小米澄清「手機不再支持GMS」;蝦米音樂正式關停;《質量效應1》DLC 因源代碼損壞而移除 | 極客頭條?一行代碼沒寫,憑啥被尊為“第一位程序員”?
?程序員硬核“年終大掃除”,清理了數據庫 70GB 空間
?“我用 72 小時復刻了一個 ClubHouse”
版权声明:本站所有资料均为网友推荐收集整理而来,仅供学习和研究交流使用。
工作时间:8:00-18:00
客服电话
电子邮件
admin@qq.com
扫码二维码
获取最新动态