Mybatis插件擴展及與Spring整合原理分析
前言
前面幾篇文章分析了Mybatis的核心原理，但模塊較多，沒有一一分析，更多的需要讀者自己下來研究。不過Mybatis的插件擴展機制還是非常重要的，像PageHelper就是一個擴展插件，熟悉其擴展原理，才能更好的針對我們的業(yè)務作出更合適的擴展。另外，現(xiàn)在Mybatis都是和Spring/SpringBoot一起使用，那么Mybatis又是如何與它們進行整合的呢？一切答案盡在本文之中。
正文
插件擴展
1. Interceptor核心實現(xiàn)原理
熟悉Mybatis配置的都知道，在xml配置中我們可以配置如下節(jié)點：
<plugins> <plugin interceptor="org.apache.ibatis.builder.ExamplePlugin"> <property name="pluginProperty" value="100"/> </plugin> </plugins>
這個就是插件的配置，那么自然而然的這個節(jié)點就會在解析xml的時候進行解析，并將其添加到Configuration中。細心的讀者應該還記得下面這段代碼，在XMLConfigBuilderl類中：
private void parseConfiguration(XNode root) {
try {
//issue #117 read properties first
//解析<properties>節(jié)點
propertiesElement(root.evalNode("properties"));
//解析<settings>節(jié)點
Properties settings = settingsAsProperties(root.evalNode("settings"));
loadCustomVfs(settings);
//解析<typeAliases>節(jié)點
typeAliasesElement(root.evalNode("typeAliases"));
//解析<plugins>節(jié)點
pluginElement(root.evalNode("plugins"));
//解析<objectFactory>節(jié)點
objectFactoryElement(root.evalNode("objectFactory"));
//解析<objectWrapperFactory>節(jié)點
objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
//解析<reflectorFactory>節(jié)點
reflectorFactoryElement(root.evalNode("reflectorFactory"));
settingsElement(settings);//將settings填充到configuration
// read it after objectFactory and objectWrapperFactory issue #631
//解析<environments>節(jié)點
environmentsElement(root.evalNode("environments"));
//解析<databaseIdProvider>節(jié)點
databaseIdProviderElement(root.evalNode("databaseIdProvider"));
//解析<typeHandlers>節(jié)點
typeHandlerElement(root.evalNode("typeHandlers"));
//解析<mappers>節(jié)點
mapperElement(root.evalNode("mappers"));
} catch (Exception e) {
throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
}
}
其中pluginElement就是解析插件節(jié)點的：
private void pluginElement(XNode parent) throws Exception {
if (parent != null) {
//遍歷所有的插件配置
for (XNode child : parent.getChildren()) {
//獲取插件的類名
String interceptor = child.getStringAttribute("interceptor");
//獲取插件的配置
Properties properties = child.getChildrenAsProperties();
//實例化插件對象
Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
//設置插件屬性
interceptorInstance.setProperties(properties);
//將插件添加到configuration對象，底層使用list保存所有的插件并記錄順序
configuration.addInterceptor(interceptorInstance);
}
}
}
從上面可以看到，就是根據(jù)配置實例化為Interceptor對象，并添加到InterceptorChain中，該類的對象被Configuration持有。Interceptor包含三個方法：
//執(zhí)行攔截邏輯的方法 Object intercept(Invocation invocation) throws Throwable; //target是被攔截的對象，它的作用就是給被攔截的對象生成一個代理對象 Object plugin(Object target); //讀取在plugin中設置的參數(shù) void setProperties(Properties properties);
而InterceptorChain只是保存了所有的Interceptor，并提供方法給客戶端調(diào)用，使得所有的Interceptor生成代理對象：
public class InterceptorChain {
private final List<Interceptor> interceptors = new ArrayList<>();
public Object pluginAll(Object target) {
for (Interceptor interceptor : interceptors) {
target = interceptor.plugin(target);
}
return target;
}
public void addInterceptor(Interceptor interceptor) {
interceptors.add(interceptor);
}
public List<Interceptor> getInterceptors() {
return Collections.unmodifiableList(interceptors);
}
}
可以看到pluginAll就是循環(huán)去調(diào)用了Interceptor的plugin方法，而該方法的實現(xiàn)一般是通過Plugin.wrap去生成代理對象：
public static Object wrap(Object target, Interceptor interceptor) {
//解析Interceptor上@Intercepts注解得到的signature信息
Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
Class<?> type = target.getClass();//獲取目標對象的類型
Class<?>[] interfaces = getAllInterfaces(type, signatureMap);//獲取目標對象實現(xiàn)的接口
if (interfaces.length > 0) {
//使用jdk的方式創(chuàng)建動態(tài)代理
return Proxy.newProxyInstance(
type.getClassLoader(),
interfaces,
new Plugin(target, interceptor, signatureMap));
}
return target;
}
其中getSignatureMap就是將@Intercepts注解中的value值解析并緩存起來，該注解的值是@Signature類型的數(shù)組，而這個注解可以定義class類型、方法、參數(shù)，即攔截器的定位。而getAllInterfaces就是獲取要被代理的接口，然后通過JDK動態(tài)代理創(chuàng)建代理對象，可以看到InvocationHandler就是Plugin類，所以直接看invoke方法，最終就是調(diào)用interceptor.intercept方法：
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
//獲取當前接口可以被攔截的方法
Set<Method> methods = signatureMap.get(method.getDeclaringClass());
if (methods != null && methods.contains(method)) {//如果當前方法需要被攔截，則調(diào)用interceptor.intercept方法進行攔截處理
return interceptor.intercept(new Invocation(target, method, args));
}
//如果當前方法不需要被攔截，則調(diào)用對象自身的方法
return method.invoke(target, args);
} catch (Exception e) {
throw ExceptionUtil.unwrapThrowable(e);
}
}
這里的插件實現(xiàn)思路是通用的，即這個interceptor我們可以用來擴展任何對象的任何方法，比如對Map的get進行攔截，可像下面這樣實現(xiàn)：
@Intercepts({
@Signature(type = Map.class, method = "get", args = {Object.class})})
public static class AlwaysMapPlugin implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
return "Always";
}
@Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
}
}
然后在使用Map時先用插件對其包裝，這樣拿到的就是Map的代理對象。
Map map = new HashMap(); map = (Map) new AlwaysMapPlugin().plugin(map);
2. Mybatis的攔截增強
因為我們可以對Mybatis擴展任意多個的插件，所以它使用InterceptorChain對象來保存所有的插件，這是責任鏈模式的實現(xiàn)。那么Mybatis到底會攔截哪些對象和哪些方法呢？回憶上篇文章我們就可以發(fā)現(xiàn)Mybatis只會對以下4個對象進行攔截：
Executor：
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
......省略
//通過interceptorChain遍歷所有的插件為executor增強，添加插件的功能
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
StatementHandler
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
//創(chuàng)建RoutingStatementHandler對象，實際由statmentType來指定真實的StatementHandler來實現(xiàn)
StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
return statementHandler;
}
ParameterHandler
public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
return parameterHandler;
}
ResultSetHandler
public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
ResultHandler resultHandler, BoundSql boundSql) {
ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
return resultSetHandler;
}
而具體要攔截哪些對象和哪些方法則是由@Intercepts和@Signature指定的。
以上就是Mybatis擴展插件的實現(xiàn)機制，讀者可據(jù)此自行分析下PageHelper的實現(xiàn)原理。另外需要注意，我們在進行自定義插件開發(fā)時，尤其要謹慎。因為直接關系到操作數(shù)據(jù)庫，如果對插件的實現(xiàn)原理不透徹，很有可能引發(fā)難以估量的后果。
Mybatis與Spring整合原理
前面的示例都是單獨使用Mybatis，可以看到需要創(chuàng)建SqlSessionFactory和SqlSession對象，然后通過SqlSession去創(chuàng)建Mapper接口的代理對象，所以在與Spring整合時，顯而易見的，我們就需要考慮以下幾點：
- 什么時候創(chuàng)建以及怎么創(chuàng)建SqlSessionFactory和SqlSession？
- 什么時候創(chuàng)建以及怎么創(chuàng)建代理對象？
- 如何將Mybatis的代理對象注入到IOC容器中？
- Mybatis怎么保證和Spring在同一個事務中并且使用的是同一個連接？
那么如何實現(xiàn)以上幾點呢？下文基于mybatis-spring-1.3.3版本分析。
1. SqlSessionFactory的創(chuàng)建
熟悉Spring源碼的（如果不熟悉，可以閱讀我之前的Spring系列源碼）都知道Spring最重要的那些擴展點：
- BeanDefinitionRegistryPostProcessor：Bean實例化前調(diào)用
- BeanFactoryPostProcessor：Bean實例化前調(diào)用
- InitializingBean：Bean實例化后調(diào)用
- FactoryBean：實現(xiàn)該接口代替Spring管理一些特殊的Bean
其它還有很多，以上列舉出來的就是Mybatis集成Spring所用到的擴展點。首先我們需要實例化SqlSessionFactory，而實例化該對象在Mybatis里實際上就是去解析一大堆配置并封裝到該對象中，所以我們不能簡單的使用<bean>標簽來配置，為此Mybatis實現(xiàn)了一個類SqlSessionFactoryBean（這個類我們在以前使用整合包時都會配置），之前XML中的配置都以屬性的方式放入到了該類中：
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource" /> <property name="typeAliasesPackage" value="com.enjoylearning.mybatis.entity" /> <property name="mapperLocations" value="classpath:sqlmapper/*.xml" /> </bean>
進入這個類，我們可以看到它實現(xiàn)了InitializingBean和FactoryBean接口，實現(xiàn)第一個接口的作用就是在該類實例化后立即去執(zhí)行配置解析的階段：
public void afterPropertiesSet() throws Exception {
notNull(dataSource, "Property 'dataSource' is required");
notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
"Property 'configuration' and 'configLocation' can not specified with together");
this.sqlSessionFactory = buildSqlSessionFactory();
}
具體的解析就在buildSqlSessionFactory方法中，這個方法比較長，但不復雜，這里就不貼代碼了。而實現(xiàn)第二接口的作用就在于Spring獲取該類實例時實際上會通過getObject方法返回SqlSessionFactory的實例，通過這兩個接口就完成了SqlSessionFactory的實例化。
2. 掃描Mapper并創(chuàng)建代理對象
在整合之后我們除了要配置SqlSessionFactoryBean外，還要配置一個類：
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="basePackage" value="com.enjoylearning.mybatis.mapper" /> </bean>
這個類的作用就是用來掃描Mapper接口的，并且這個類實現(xiàn)了BeanDefinitionRegistryPostProcessor和InitializingBean，這里實現(xiàn)第二個接口的作用主要是校驗有沒有配置待掃描包的路徑：
public void afterPropertiesSet() throws Exception {
notNull(this.basePackage, "Property 'basePackage' is required");
}
主要看到postProcessBeanDefinitionRegistry方法：
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
if (this.processPropertyPlaceHolders) {
processPropertyPlaceHolders();
}
ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
scanner.setAddToConfig(this.addToConfig);
scanner.setAnnotationClass(this.annotationClass);
scanner.setMarkerInterface(this.markerInterface);
scanner.setSqlSessionFactory(this.sqlSessionFactory);
scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
scanner.setResourceLoader(this.applicationContext);
scanner.setBeanNameGenerator(this.nameGenerator);
scanner.registerFilters();
scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
}
這里創(chuàng)建了一個掃描類，而這個掃描類是繼承自Spring的ClassPathBeanDefinitionScanner，也就是會將掃描到的類封裝為BeanDefinition注冊到IOC容器中去：
public int scan(String... basePackages) {
int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
doScan(basePackages);
// Register annotation config processors, if necessary.
if (this.includeAnnotationConfig) {
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
}
public Set<BeanDefinitionHolder> doScan(String... basePackages) {
Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
if (beanDefinitions.isEmpty()) {
logger.warn("No MyBatis mapper was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
} else {
processBeanDefinitions(beanDefinitions);
}
return beanDefinitions;
}
private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
GenericBeanDefinition definition;
for (BeanDefinitionHolder holder : beanDefinitions) {
definition = (GenericBeanDefinition) holder.getBeanDefinition();
if (logger.isDebugEnabled()) {
logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName()
+ "' and '" + definition.getBeanClassName() + "' mapperInterface");
}
// the mapper interface is the original class of the bean
// but, the actual class of the bean is MapperFactoryBean
definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59
definition.setBeanClass(this.mapperFactoryBean.getClass());
definition.getPropertyValues().add("addToConfig", this.addToConfig);
boolean explicitFactoryUsed = false;
if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
explicitFactoryUsed = true;
} else if (this.sqlSessionFactory != null) {
definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
explicitFactoryUsed = true;
}
if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
if (explicitFactoryUsed) {
logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
}
definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
explicitFactoryUsed = true;
} else if (this.sqlSessionTemplate != null) {
if (explicitFactoryUsed) {
logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
}
definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
explicitFactoryUsed = true;
}
if (!explicitFactoryUsed) {
if (logger.isDebugEnabled()) {
logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
}
definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
}
}
}
你可能會好奇，在哪里生成的代理對象？只是將Mapper接口注入到IOC有什么用呢？其實關鍵代碼就在definition.setBeanClass(this.mapperFactoryBean.getClass())，這句代碼的作用就是將每一個Mapper接口都轉(zhuǎn)為MapperFactoryBean類型。
為什么要這么轉(zhuǎn)呢？進入這個類你會發(fā)現(xiàn)它也是實現(xiàn)了FactoryBean接口的，所以自然而然的又是利用它來創(chuàng)建代理實現(xiàn)類對象：
public T getObject() throws Exception {
return getSqlSession().getMapper(this.mapperInterface);
}
3. 如何整合Spring事務
Mybatis作為一個ORM框架，它是有自己的數(shù)據(jù)源和事務控制的，而Spring同樣也會配置這兩個，那么怎么將它們整合到一起呢？而不是在Service類調(diào)用Mapper接口時就切換了數(shù)據(jù)源和連接，那樣肯定是不行的。
在使用Mybatis時，我們可以在xml中配置TransactionFactory事務工廠類，不過一般都會使用默認的JdbcTransactionFactory，而當與Spring整合后，默認的事務工廠類改為了SpringManagedTransactionFactory?；氐絊qlSessionFactoryBean讀取配置的方法，在該方法中有下面這樣一段代碼：
if (this.transactionFactory == null) {
this.transactionFactory = new SpringManagedTransactionFactory();
}
configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));
上面默認創(chuàng)建了SpringManagedTransactionFactory，同時還將我們xml中ref屬性引用的dataSource添加到了Configuration中，這個工廠會創(chuàng)建下面這個事務控制對象：
public Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit) {
return new SpringManagedTransaction(dataSource);
}
而這個方法是在DefaultSqlSessionFactory獲取SqlSession時會調(diào)用：
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
Transaction tx = null;
try {
final Environment environment = configuration.getEnvironment();
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
final Executor executor = configuration.newExecutor(tx, execType);
return new DefaultSqlSession(configuration, executor, autoCommit);
} catch (Exception e) {
closeTransaction(tx); // may have fetched a connection so lets call close()
throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
這就保證使用的是同一個數(shù)據(jù)源對象，但是怎么保證拿到的是同一個連接和事務呢？關鍵就在于SpringManagedTransaction獲取連接是怎么實現(xiàn)的：
public Connection getConnection() throws SQLException {
if (this.connection == null) {
openConnection();
}
return this.connection;
}
private void openConnection() throws SQLException {
this.connection = DataSourceUtils.getConnection(this.dataSource);
this.autoCommit = this.connection.getAutoCommit();
this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"JDBC Connection ["
+ this.connection
+ "] will"
+ (this.isConnectionTransactional ? " " : " not ")
+ "be managed by Spring");
}
}
這里委托給了DataSourceUtils獲取連接：
public static Connection getConnection(DataSource dataSource) throws CannotGetJdbcConnectionException {
try {
return doGetConnection(dataSource);
}
catch (SQLException ex) {
throw new CannotGetJdbcConnectionException("Could not get JDBC Connection", ex);
}
}
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
Assert.notNull(dataSource, "No DataSource specified");
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
conHolder.requested();
if (!conHolder.hasConnection()) {
logger.debug("Fetching resumed JDBC Connection from DataSource");
conHolder.setConnection(dataSource.getConnection());
}
return conHolder.getConnection();
}
// Else we either got no holder or an empty thread-bound holder here.
logger.debug("Fetching JDBC Connection from DataSource");
Connection con = dataSource.getConnection();
if (TransactionSynchronizationManager.isSynchronizationActive()) {
logger.debug("Registering transaction synchronization for JDBC Connection");
// Use same Connection for further JDBC actions within the transaction.
// Thread-bound object will get removed by synchronization at transaction completion.
ConnectionHolder holderToUse = conHolder;
if (holderToUse == null) {
holderToUse = new ConnectionHolder(con);
}
else {
holderToUse.setConnection(con);
}
holderToUse.requested();
TransactionSynchronizationManager.registerSynchronization(
new ConnectionSynchronization(holderToUse, dataSource));
holderToUse.setSynchronizedWithTransaction(true);
if (holderToUse != conHolder) {
TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
}
}
return con;
}
看到ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource)這段代碼相信熟悉Spring源碼的已經(jīng)知道了，這個我在分析Spring事務源碼時也講過，通過DataSource對象拿到當前線程綁定的ConnectionHolder，這個對象是在Spring開啟事務的時候存進去的。至此，關于Spring和Mybatis的整合原理我們就個搞清楚了，至于和SpringBoot的整合，讀者可自行分析。最后，我再分享一個小擴展知識。
4. FactoryBean的擴展知識
很多讀者可能不知道這個接口有什么作用，其實很簡單，當我們有某個類由Spring實例化比較復雜，想要自己控制它的實例化時，就可以實現(xiàn)該接口。而實現(xiàn)該接口的類首先會被實例化并放入一級緩存，而當我們依賴注入我們真正想要的類時（如Mapper接口的代理類），就會從一級緩存中拿到FactoryBean實現(xiàn)類的實例，并判斷是否實現(xiàn)了FactoryBean接口，如果是就會調(diào)用getObject方法返回我們真正想要的實例。
那如果我們確實想要拿到的就是FactoryBean實現(xiàn)類的實例該怎么辦呢？只需要在傳入的beanName前面加上“&”符號即可。
總結
本篇分析了Mybatis如何擴展插件以及插件的實現(xiàn)原理，但如非必要，切忌擴展插件，如果一定要，那么一定要非常謹慎。另外還結合Spirng的擴展點分析了Mybatis和Spring的整合原理，解決了困在我心中已久的一些疑惑，相信那也是大多數(shù)讀者的疑惑，好好領悟這部分內(nèi)容非常有利于我們自己對Spring進行擴展。
相關文章
這篇文章主要介紹了MAC下基于maven使用IDEA走讀TestNG源碼，本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2021-06-06
這篇文章主要介紹了Java函數(shù)式編程(六)：Optional,本文是系列文章的第6篇,其它文章請參閱本文底部的相關文章,需要的朋友可以參考下2014-09-09
這篇文章主要介紹了java socket的正確關閉姿勢，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-06-06
這篇文章主要介紹了關于ReentrantLock的原理解析，文章通過代碼示例介紹的非常詳細，具有一定的參考價值,需要的朋友可以參考下2023-07-07
本文主要介紹了SpringBoot的三大開發(fā)工具，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2022-02-02
Java中數(shù)組容器(ArrayList)設的計與實現(xiàn)
本篇文章主要跟大家介紹我們最常使用的一種容器ArrayList、Vector的原理，并且自己使用Java實現(xiàn)自己的數(shù)組容器MyArrayList，讓自己寫的容器能像ArrayList那樣工作,感興趣的可以了解一下2022-07-07
java存儲以及java對象創(chuàng)建的流程(詳解)
下面小編就為大家?guī)硪黄猨ava存儲以及java對象創(chuàng)建的流程(詳解)。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-05-05
使用maven項目pom.xml文件配置打包功能和靜態(tài)資源文件自帶版本號功能
在Maven項目中,通過pom.xml文件配置打包功能,可以控制構建過程,生成可部署的包,同時,為了緩存控制與版本更新,可以在打包時給靜態(tài)資源文件如JS、CSS添加版本號,這通常通過插件如maven-resources-plugin實現(xiàn)2024-09-09
Springboot使用@WebListener?作為web監(jiān)聽器的過程解析
這篇文章主要介紹了Springboot使用@WebListener作為web監(jiān)聽器的過程，本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下2023-08-08
這篇文章主要介紹了springboot整合mqtt客戶端示例分享的相關資料,需要的朋友可以參考下2023-07-07