SpringIOC refresh()初始化代碼實例
更新時間：2020年03月06日 14:17:39 作者：FFStayF
這篇文章主要介紹了SpringIOC refresh()初始化代碼實例,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下
finishBeanFactoryInitialization(beanFactory)：初始化不需要延遲實例化的單例bean
/* org/springframework/context/support/AbstractApplicationContext.java:870 */
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {//初始化容器的conversionService
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));
}
//如果沒有任何一個類似PropertyPlaceholderConfigurer bean處理器
//默認(rèn)一個嵌入式值解析器，主要是為了解析屬性值例如數(shù)據(jù)庫連接中${password}等屬性解析
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 先實例化LoadTimeWeaverAware相關(guān)的beans，以便盡早轉(zhuǎn)換，AOP相關(guān)
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
//刪除臨時類加載器，停止臨時類加載器進(jìn)行類型匹配
beanFactory.setTempClassLoader(null);
//拷貝beandefinitionNames到frozenBeanDefinitionNames
beanFactory.freezeConfiguration();
// 實例化所有不需要延遲初始化的單例bean
beanFactory.preInstantiateSingletons();
}
beanFactory.preInstantiateSingletons()：實例化所有不需要延遲初始化的單例bean
/* org/springframework/beans/factory/support/DefaultListableBeanFactory.java:885 */
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
//拷貝beanDefinitionNames副本，考慮到遍歷中其他線程可能修改beandefinitionNames
// ArrayList類型遍歷時規(guī)避fast-fail，實現(xiàn)fast-safe
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
//當(dāng)bean存在parentBean時的繼承關(guān)系
//① bean不存在parentBean時，創(chuàng)建一個new RootBeanDefinition(beandefinition)返回。
//② bean存在parentBean時，支持繼承關(guān)系
// 需要先創(chuàng)建parentBean的new RootBeanDefinition(parentBeanDefinition)
// 然后用beandefinition覆蓋parentBean的RootBeanDefinition的相關(guān)屬性并返回。superBean.overrideFrom(subBean);
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//用mergedLocalBeanDefinition判斷是否需要初始化
//篩選不是抽象類且不是延遲實例化的單例進(jìn)行初始化
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
//工廠Bean beanName=&beanName
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 {
//不是工廠bean 直接初始化
getBean(beanName);
}
}
}
//SmartInitializingSingleton類型的單例初始化后的回調(diào)
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
getBean(beanName):Bean初始化
/* org/springframework/beans/factory/support/AbstractBeanFactory.java:414 */
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//如果是aliaName，解析成beanName
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
//檢查單例緩存中是否存在bean的實例化對象、初始化對象 （涉及循環(huán)依賴解決，需要先分清出Bean的兩個階段實例化、初始化）
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
if (isPrototypeCurrentlyInCreation(beanName)) {
//多例bean正在初始化時拋出異常
//由于多例bean，每調(diào)用一次getBean就會創(chuàng)建一個實例，
//所以通過ThreadLocal打標(biāo)，來避免單個線程的重復(fù)創(chuàng)建
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = getParentBeanFactory();
//父容器不為空，用父容器初始化
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
//alreadyCreated容器記錄已經(jīng)被實例化的beanName，
//這里將beanName添加到alreadyCreated
markBeanAsCreated(beanName);
}
try {
//重新獲取mergedLocalBeanDefinition（bean與parentBean合并）
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//檢查mbd不是抽象類
checkMergedBeanDefinition(mbd, beanName, args);
//創(chuàng)建bean單例之前，需要保證先bean所依賴的Bean單例已創(chuàng)建，
//這里的依賴對應(yīng)@dependsOn聲明的依賴，這個注解不常用，這里也會出現(xiàn)一種循環(huán)依賴場景，與我們平常討論的引用循環(huán)依賴不同
//@dependsOn(value = "b") class A;@dependsOn(value = "a") class B
//如果出現(xiàn)這種循環(huán)依賴 會直接拋出異常 啟動失敗
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)系到dependentBeanMap容器中
registerDependentBean(dep, beanName);
try {
//實例化依賴的bean 這里就是常見循環(huán)依賴地點 A依賴B B依賴A
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
if (mbd.isSingleton()) {
//單例Bean創(chuàng)建 先取緩存，沒有才createBean
sharedInstance = getSingleton(beanName, () -> {
try {
//創(chuàng)建Bean實例
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
//多例Bean創(chuàng)建 直接createbean
Object prototypeInstance = null;
try {
//正在創(chuàng)建bean打標(biāo)prototypesCurrentlyInCreation
//與上面isPrototypeCurrentlyInCreation()聯(lián)合
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//正在創(chuàng)建bean打標(biāo)prototypesCurrentlyInCreation刪除標(biāo)記
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
//自定義scope初始化、scope.get()
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);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
//getBean(beanName,requiredType)時檢查創(chuàng)建的實例是否需要的類型，容器初始化時不會走進(jìn)里面
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.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
sharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args);}:單例初始化，這個方法比較簡單，主要關(guān)注下和循壞依賴相關(guān)的邏輯
/* org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java:201 */
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//循環(huán)依賴相關(guān)：初始化前先singletonsCurrentlyInCreation.add(beanName)
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//lamda表達(dá)式：其實是調(diào)用createBean(beanName, mbd, args):Bean初始化
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//循環(huán)依賴相關(guān)：初始化后singletonsCurrentlyInCreation.remove(beanName)
afterSingletonCreation(beanName);
}
if (newSingleton) {
//初始化完后
//this.singletonObjects.put(beanName, singletonObject);放入到單例容器中
//this.singletonFactories.remove(beanName);清空循環(huán)依賴相關(guān)的兩個打標(biāo)
//this.earlySingletonObjects.remove(beanName);
//this.registeredSingletons.add(beanName);放入單例beanName容器中
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
createBean(beanName, mbd, args)：初始化實例,這個表方法注意一下，初始化實例前，留機(jī)會給BeanPostProcessor初始化代理類直接返回代理類初始化實例
/* org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java:467 */
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
//確保beanclass確實被解析了，若合并出錯，重新定義bean定義
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
//校驗需要重寫方法是否全部重寫，并且會給重寫方法是否重載打標(biāo)
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//resolveBeforeInstantiation方法是調(diào)用BeanPostProcessor處理器
//后續(xù)研究一下BeanPostProcessor
//這里是給AOP相關(guān)BeanPostProcessor處理器生成代理類實例的機(jī)會，直接生成初始化代理類實例返回
//會面研究AOP時發(fā)現(xiàn)，proxy object不是在這里初始化，這里只是提供一個機(jī)會
//proxy object具體是在的下面doCreateBean時里先創(chuàng)建target object
//然后通過后置處理器的后置方法初始化的
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 {
//初始化實例
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
doCreateBean(beanName,mbdToUse,args):beanClass實例化（即earlysingleton，注意不是初始化）然后DI完成初始化
/* org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java:549 */
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//反射調(diào)用beanClass的構(gòu)造方法創(chuàng)建實例并包裝成beanwrapper--
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
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.
//允許MergedBeanDefinitionPostProcessors后置管理器修改rootBeandefinition
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//循環(huán)依賴相關(guān)邏輯：
//this.singletonFactories.put(beanName, singletonFactory);
//將實例化bean、beanName組裝成singletonFactory裝入singletonFactories容器
//this.earlySingletonObjects.remove(beanName);
//刪除earlySingletonObjects中beanName
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
//創(chuàng)建實例
Object exposedObject = bean;
try {
//實例初始化 就是在這里面實現(xiàn)依賴注入DI的:
//具體是調(diào)用AutowiredAnnotationBeanPostProcessor.postProcessProperties
populateBean(beanName, mbd, instanceWrapper);//調(diào)用Bean后置管理器前置方法BeanPostProcessor.postProcessBeforeInitialization
//instanceof aware接口，setBeanName setBeanClassLoader setBeanFactory
//調(diào)用Bean后置管理器后置方法BeanPostProcessor.postProcessAfterInitialization
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
//...
return exposedObject;
}
populateBean(beanName, mbd, instanceWrapper)：依賴注入DI執(zhí)行時機(jī)
/* org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java:1381 */
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
//...
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//這里調(diào)用AutowiredAnnotationBeanPostProcessor.postProcessProperties()
//完成注解自動注入（DI）
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
DI結(jié)束，bean初始化基本結(jié)束了。然后就是bean初始化的BeanPostProcessor執(zhí)行前置后置方法
BeanPostProcessor前置后置方法：一些很重要架構(gòu)都需要依靠實現(xiàn)，例如AOP動態(tài)代理產(chǎn)生代理對象
AnnotationAwareAspectJAutoProxyCreator.postProcessAfterInitialization
/* org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition) */
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//調(diào)用所有BeanPostProcessor前置方法BeanPostProcessor.postProcessBeforeInitialization
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//調(diào)用所有BeanPostProcessor前置方法BeanPostProcessor.postProcessAfterInitialization
//例如AOP代理對象就是這里初始化的,AnnotationAwareAspectJAutoProxyCreator.postProcessAfterInitialization
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。
相關(guān)文章
這篇文章主要介紹了Java 注解的原理實例詳解的相關(guān)資料,需要的朋友可以參考下2016-12-12
SpringBoot實現(xiàn)本地上傳文件到resources目錄
Java后端項目上傳文件是一個很常見的需求，這篇文章主要為大家介紹了SpringBoot如何實現(xiàn)本地上傳文件到resources目錄永久保存下載，需要的可以參考一下2023-07-07
這篇文章主要介紹了java兩種單例模式用法,結(jié)合實例形式對比分析了java實現(xiàn)單例模式的兩種常見技巧,需要的朋友可以參考下2016-08-08
SpringBoot調(diào)用service層的三種方法
在Spring?Boot中,我們可以通過注入Service層對象來調(diào)用Service層的方法,Service層是業(yè)務(wù)邏輯的處理層,它通常包含了對數(shù)據(jù)的增刪改查操作,本文給大家介紹了SpringBoot調(diào)用service層的三種方法,需要的朋友可以參考下2024-05-05
Hibernate的持久對象在數(shù)據(jù)庫數(shù)據(jù)操作中有著重要作用,這里我們就來深入解析Java的Hibernate框架中的持久對象,首先必須從理解持久化對象的生命周期開始:2016-07-07
這篇文章主要介紹了使用java NIO及高速緩沖區(qū)寫入文件過程解析,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2019-09-09
這篇文章主要為大家詳細(xì)介紹了java實現(xiàn)模擬微信紅包算法，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2020-11-11
Spring中獲取Bean對象的三種注入方式與兩種注入方法詳解
平常的Java開發(fā)中程序員在某個類中需要依賴其它類的方法,下面這篇文章主要給大家介紹了關(guān)于Spring中獲取Bean對象的三種注入方式與兩種注入方法的相關(guān)資料,文中通過圖文介紹的非常詳細(xì),需要的朋友可以參考下2023-03-03
SpringBoot整合Dubbo框架,實現(xiàn)RPC服務(wù)遠(yuǎn)程調(diào)用
Dubbo是一款高性能、輕量級的開源Java RPC框架，它提供了三大核心能力：面向接口的遠(yuǎn)程方法調(diào)用，智能容錯和負(fù)載均衡，以及服務(wù)自動注冊和發(fā)現(xiàn)。今天就來看下SpringBoot整合Dubbo框架的步驟2021-06-06
使用Java實現(xiàn)文件流轉(zhuǎn)base64
這篇文章主要為大家詳細(xì)介紹了如何使用Java實現(xiàn)文件流轉(zhuǎn)base64效果,文中的示例代碼講解詳細(xì),感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下2024-03-03