Spring源碼解析 Bean的實例化
更新時間：2022年07月07日 08:59:26 作者：? 碼農(nóng)參上? ?
這篇文章主要介紹了Spring源碼解析 Bean的實例化，文章圍繞主題展開詳細的內(nèi)容介紹沒具有一定的參考價值，需要的小伙伴可以參考一下
前言
我們來講一下Bean的實例化過程。這篇文章中，暫時不對Bean循環(huán)依賴的情況進行分析，因為比較復雜，會放在后面單獨的文章中進行分析。
準備工作
看下面這條語句AnnotationConfigApplicationContext類的refresh方法開始分析，從下面這條語句開始：
// Instantiate all remaining (non-lazy-init) singletons. finishBeanFactoryInitialization(beanFactory);
從官方的注釋可以看出，這里是用來完成所有非懶加載的bean的實例化過程。
我們先寫一個簡單的bean用于進行測試，其中的Dao也是一個交給spring管理的bean。spring會掃描到這個類，并添加到beanDefinitionMap和BeanDefinitionNames中：
@Component
public class MyService {
@Autowired
private Dao dao;
public void query(){
System.out.println("executing query method");
dao.query();
}
}看一下finishBeanFactoryInitialization中的代碼：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//如果bdMap中存在conversionService，則進行初始化
//該bean可用來提供數(shù)據(jù)的轉(zhuǎn)化功能
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
//初始化類型為LoadTimeWeaverAware的bean
//可用于AspectJ靜態(tài)織入過程
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
//銷毀之前在prepareBeanFactory()中生成的臨時ClassLoader
beanFactory.setTempClassLoader(null);
//在這凍結(jié)對BeanDefinition的修改
//防止spring在初始化的時候發(fā)生BeanDefinition的修改
beanFactory.freezeConfiguration();
beanFactory.preInstantiateSingletons();
}
這個方法中，前面都是在做一些準備工作，直到最后執(zhí)beanFactory的preInstantiateSingletons方法，才開始準備執(zhí)行非懶加載的bean的實例化過程。先看preInstantiateSingletons方法的前半段：
public void preInstantiateSingletons() throws BeansException {
if (logger.isDebugEnabled()) {
logger.debug("Pre-instantiating singletons in " + this);
}
//得到所有bean的名字
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
for (String beanName : beanNames) {
//做了合并父類的BeanDefinition的操作
//在會用xml配置bean時 有一個parent 屬性，可以繼承類名，作用域等
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//判斷是FactoryBean
if (isFactoryBean(beanName)) {
//如果是FactoryBean則加上 &
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else { //不是factoryBean的情況
getBean(beanName);
}
}
}
...首先從beanDefinitionNames的List中拿到所有的beanName，進行遍歷。之前講過DefaultListableBeanFactory內(nèi)部緩存了一個beanDefinitionMap的Map，和這個beanDefinitionNames的List，從這也可以看出，通過適當?shù)娜哂嗫梢砸欢ǔ潭壬蠝p少編碼中的工作量。
在對bean進行初始化前包含3個條件：不能為抽象類、單例bean、以及非懶加載。非常好理解不再多說，重點說明一下通過isFactoryBean方法判斷bean是否Factorybean。Factorybean是一個比較特殊的bean，并且受spring容器管理，看一下接口定義：
public interface FactoryBean<T> {
T getObject() throws Exception;
Class<?> getObjectType();
default boolean isSingleton() {
return true;
}
}如果一個類實現(xiàn)了FactoryBean接口，那個spring容器中會存在兩個對象，一個是getObject方法返回的對象，另一個是當前FactoryBean對象本身，并且用&添加在beanName前進行區(qū)分。舉個例子：
@Component
public class MyFactoryBean implements FactoryBean {
@Override
public Object getObject() throws Exception {
return new TestDao();
}
@Override
public Class<?> getObjectType() {
return TestDao.class;
}
}測試：
System.out.println(context.getBean("myFactoryBean"));
System.out.println(context.getBean("&myFactoryBean"));結(jié)果：
com.hydra.dao.TestDao@fbd1f6
com.hydra.factorybean.MyFactoryBean@1ce24091
對于FactoryBean的獲取，要在beanName前加上一個前綴&，然后會先判斷是否是SmartFactoryBean并且isEagerInit為true，如果是才調(diào)用getBean方法進行初始化。此處內(nèi)容略過，直接看重要的getBean方法：
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}此處為空方法，繼續(xù)調(diào)用doGetBean方法，從這開始為實例化bean的核心流程。
實例化bean
為了方便分析，我們將類與方法按照調(diào)用順訊進行編號，方便后面解析流程的分析。
1、AbstractBeanFactory 的 doGetBean方法
和以前一樣，非重點的內(nèi)容直接在代碼中用注釋解釋。
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
//先嘗試從spring容器中獲取一次，如果為空則實例化
Object sharedInstance = getSingleton(beanName);
//在調(diào)用getBean時，args為空
//如果不為空，那么意味著調(diào)用方不是希望獲取bean，而是創(chuàng)建bean
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
/*
* 如果是普通的單例bean，下面的方法會直接返回sharedInstance
* 但如果是FactoryBean 類型的，則需要getObject工廠方法獲得bean實例
* 如果想獲取FactoryBean本身，也不會做特別的處理
* */
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//如果當前線程已經(jīng)創(chuàng)建過了prototype類型的這個bean，拋出異常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 如果對spring沒有進行改造，這里默認 parentBeanFactory為空
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
//typeCheckOnly為false，添加到alreadyCreated Set集合當中，表示它已經(jīng)創(chuàng)建過
//防止重復創(chuàng)建
markBeanAsCreated(beanName);
}
//重點部分，創(chuàng)建singleton的bean，或創(chuàng)建新的prototype的bean
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 判斷當前bean是否有依賴，這里指的是使用depends-on的情況，需要先實例化依賴bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//注冊依賴關(guān)系
registerDependentBean(dep, beanName);
try {
//初始化被依賴bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
//在這才真正創(chuàng)建bean的實例
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
//真正創(chuàng)建功能的語句
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 創(chuàng)建 prototype 的實例
else if (mbd.isPrototype()) {
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//如果不是singleto和prototype,委托給相應(yīng)的實現(xiàn)類來處理
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
//拋出異常，代碼省略...
}
//類型檢查，正常則返回，異常則拋出
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}在創(chuàng)建bean前，首先調(diào)用了DefaultSingletonBeanRegistry的getSingleton方法，也就是說spring在初始化一個bean前先去嘗試獲取一次，判斷這個對象是否已經(jīng)被實例化好了，如果已經(jīng)存在就直接拿過來用。進入getSingleton方法，核心代碼：
Object singletonObject = this.singletonObjects.get(beanName);
看一下singletonObjects的定義：
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
這里提前劇透一下，這個Map就是用于存放實例化好的單例bean，并且從狹義上來說，可以說這個singletonObjects就是spring容器，并且它使用了ConcurrentHashMap，來保證并發(fā)操作的安全性。
因為我們的bean還處于創(chuàng)建階段，那么這一次是肯定不能從Map獲取到實例的，那么接著向下運行，看一下調(diào)用的createBean方法。
2、AbstractAutowireCapableBeanFactory 的 createBean方法
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
//確保 BeanDefinition 中的 Class 被加載
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 處理 lookup-method 和 replace-method 配置
// spring中把lookup-method 和 replace-method 統(tǒng)稱為method overrides
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//應(yīng)用后置處理器，如果后置處理器返回的bean不為空則直接返回
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {//調(diào)用doCreateBean創(chuàng)建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
//非重要代碼省略...
}
前面做了很長的鋪墊工作，但還是沒有創(chuàng)建bean，創(chuàng)建bean的工作被交給了doCreateBean方法完成。
3、AbstractAutowireCapableBeanFactory 的 doCreateBean方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
//BeanWrapper是一個包裝接口，真正實例化的是 BeanWrapperImpl
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//創(chuàng)建bean實例，并將實例包裹在 BeanWrapper 實現(xiàn)類對象中返回
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 使用BeanWrapper 產(chǎn)生一個原生對象
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//執(zhí)行后置處理器MergedBeanDefinitionPostProcessor
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
//用于處理循環(huán)依賴，后面單獨分析
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//執(zhí)行后置處理器
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
//到此為止，還是原生對象
Object exposedObject = bean;
try {
//賦值屬性,依賴，非常重要
populateBean(beanName, mbd, instanceWrapper);
//執(zhí)行后置處理器,變成代理對象，aop就是在這里完成的處理
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
//中間非重要代碼省略...
return exposedObject;
}這里面做了三個比較重要的工作：
- ①、調(diào)用
createBeanInstance方法創(chuàng)建bean實例 - ②、調(diào)用
populateBean進行屬性的填充，依賴注入就是在這里完成 - ③、調(diào)用
initializeBean，執(zhí)行各種后置處理器，執(zhí)行各種回調(diào)函數(shù)
我們按照順序，先接著講①中創(chuàng)建bean勢力的過程，等這個過程完了再回頭分析屬性填充和回調(diào)方法。
4、AbstractAutowireCapableBeanFactory 的 createBeanInstance方法
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
//確保加載了該class
Class<?> beanClass = resolveBeanClass(mbd, beanName);
//檢測一個類的訪問權(quán)限 spring默認情況下對于public的類是允許訪問的
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
/*
*如果工廠方法不為空，則通過工廠方法構(gòu)建bean對象
* factoryMethod基于xml，實際工作中很少使用
* */
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
/*
* 從spring的原始注釋可以知道這個是一個ShortCut，當多次構(gòu)建同一個bean時，可以使用這個ShortCut
* 這里的resolved和 mbd.constructorArgumentsResolved 將會在bean第一次實例化的過程中被設(shè)置
* */
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
//如果已經(jīng)解析了構(gòu)造方法的參數(shù)，則必須要通過一個帶參數(shù)構(gòu)造方法來實例
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
if (autowireNecessary) {
//通過構(gòu)造方法自動裝配的方式構(gòu)造bean對象
return autowireConstructor(beanName, mbd, null, null);
}
else {
//通過默認的無參構(gòu)造方法進行
return instantiateBean(beanName, mbd);
}
}
//spring目前不知道用什么方式實例化這個bean，所以先拿到所有的構(gòu)造方法
//由后置處理器決定返回哪些構(gòu)造方法
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
/*
* AUTOWIRE : 0-NO ,1-BY_NAME,2-BY_TYPE,3-CONSTRUCTOR
* 在這里mbd.getResolvedAutowireMode()取到的是0，就是NO
* */
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
//使用默認的無參構(gòu)造方法進行初始化
return instantiateBean(beanName, mbd);
}如果bean擁有多個構(gòu)造方法的話，會根據(jù)參數(shù)去判斷具體使用哪一個，具體內(nèi)容比較復雜，準備以后放在一篇單獨的文章中進行分析。如果只有無參構(gòu)造方法或不寫構(gòu)造方法的話，都會默認使用無參構(gòu)造方法進行實例化，這里暫時只對這種情況進行分析。
5、AbstractAutowireCapableBeanFactory 的 instantiateBean方法
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
getInstantiationStrategy().instantiate(mbd, beanName, parent),
getAccessControlContext());
}
else {
// getInstantiationStrategy得到類的實例化策略
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}這里通過getInstantiationStrategy得到類的實例化策略，默認情況下是得到一個反射的實例化策略。然后調(diào)用instantiate方法進行實例化。
6、SimpleInstantiationStrategy 的 instantiate方法
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
// 檢測bean配置中是否配置了lookup-method 或 replace-method
//如果配置了就需使用CGLIB構(gòu)建bean對象
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
final Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(
(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
}
else {
//得到默認構(gòu)造方法，即使沒有寫也會有一個
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
//使用構(gòu)造方法進行實例化
return BeanUtils.instantiateClass(constructorToUse);
}
else {
//使用CGLIB進行實例化
return instantiateWithMethodInjection(bd, beanName, owner);
}
}instantiateClass方法中，通過反射創(chuàng)建對象：
//設(shè)置構(gòu)造方法為可訪問 ReflectionUtils.makeAccessible(ctor); //反射創(chuàng)建對象 return (KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ? KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));
運行到這，實例化的過程就完成了，但是目前屬性還沒有注入，回到開頭我們舉的那個例子，其中還有一個Dao沒有被注入，下一篇文章，我們接下來分析屬性的注入。
到此這篇關(guān)于Spring源碼解析 Bean的實例化的文章就介紹到這了,更多相關(guān)Spring Bean實例化內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要介紹了Springboot集成RabbitMQ報錯及解決方案,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-07-07
解決mybatis-plus新增數(shù)據(jù)自增ID變無序問題
這篇文章主要介紹了解決mybatis-plus新增數(shù)據(jù)自增ID變無序問題，具有很好的參考價值，希望對大家有所幫助。2023-07-07
SpringBoot 使用@WebMvcTest測試MVC Web Controller
這篇文章主要介紹了SpringBoot 使用@WebMvcTest測試MVC Web Controller，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-11-11
java11新特性之集合轉(zhuǎn)換為數(shù)組的方法
Java11引入了一種將帶有泛型的集合轉(zhuǎn)換為帶有泛型的數(shù)組的簡單方法,本文通過實例代碼介紹java11新特性之集合轉(zhuǎn)換為數(shù)組的操作方法,感興趣的朋友跟隨小編一起看看吧2024-06-06
Spring AOP方法內(nèi)部調(diào)用不生效的解決方案
最近有個需求,統(tǒng)計某個方法的調(diào)用次數(shù),開始使用 Spring AOP 實現(xiàn),后來發(fā)現(xiàn)當方法被內(nèi)部調(diào)用時,切面邏輯將不會生效,所以本文就給大家介紹了Spring AOP方法內(nèi)部調(diào)用不生效的解決方案,需要的朋友可以參考下2025-01-01
這篇文章主要介紹了springboot相關(guān)面試題匯總詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-08-08
泛型是在Java?SE?1.5引入的的新特性，本質(zhì)是參數(shù)化類型，也就是說所操作的數(shù)據(jù)類型被指定為一個參數(shù)。這種參數(shù)類型可以用在類、接口和方法的創(chuàng)建中，分別稱為泛型類、泛型接口、泛型方法，本篇我們一起來學習泛型考古、泛型擦除、包裝類2022-03-03
RestTemplate發(fā)送請求時Cookie的影響及注意事項說明
這篇文章主要介紹了RestTemplate發(fā)送請求時Cookie的影響及注意事項說明，具有很好的參考價值，希望對大家有所幫助。2023-07-07
Java concurrency集合之ConcurrentSkipListMap_動力節(jié)點Java學院整理
這篇文章主要為大家詳細介紹了Java concurrency集合之ConcurrentSkipListMap的相關(guān)資料，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-06-06
Spring Boot 捕捉全局異常 統(tǒng)一返回值的問題
這篇文章主要介紹了Spring Boot 捕捉全局異常 統(tǒng)一返回值，本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下2020-06-06