AI 助理
文档备案控制台
开发者社区 数据库 文章 正文

Spring分布式事务在service中动态切换数据源

2018-02-28 2517
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

Spring分布式事务在service中动态切换数据源

项目采用的是struts2的+弹簧+ ibatis的架构，下面是关键部分代码：

applicationContext.xml中：

[html] 查看纯文本

  1. <？xml version = “1.0” encoding = “UTF-8” ？>
  2. < beans xmlns = “http://www.springframework.org/schema/beans”
  3.        xmlns：xsi = “http://www.w3.org/2001/XMLSchema-instance”
  4.        xmlns：context = “http://www.springframework.org/schema/context”
  5.        xmlns：aop = “http://www.springframework.org/schema/aop”
  6.        xmlns：tx = “http://www.springframework.org/schema/tx”
  7.        xsi：schemaLocation =“http://www.springframework.org/schema/beans
  8.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  9.            http://www.springframework.org/schema/context
  10.            http://www.springframework.org/schema/context/spring-context-2.5.xsd
  11.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
  12.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd“
  13.            default-autowire = “byName” default-lazy-init = “false” >
  15.     < context：component-scan base-package = “com.ssi。*” />
  16.     <！ - 属性文件读入 - >
  17.     < bean id = “propertyConfigurer” class = “org.springframework.beans.factory.config.PropertyPlaceholderConfigurer” >>
  18.         < property name = “locations” >
  19.             < list >
  20.                 < value > classpath *：jdbc.properties </ value >
  21.             </ list >
  22.         </ property >
  23.     </ bean >
  26.     <！ - 配置sqlMapclient - >
  27.     < bean id = “sqlMapClient” class = “org.springframework.orm.ibatis.SqlMapClientFactoryBean” >
  28.         < property name = “configLocation” value = “classpath：ibatis-sqlmap-config.xml” />
  29.         < property name = “dataSource” ref = “dataSource” />
  30.     </ bean >
  32.     < bean id = “sqlMapClient1” class = “org.springframework.orm.ibatis.SqlMapClientFactoryBean” >
  33.         < property name = “configLocation” value = “classpath：ibatis-sqlmap-config.xml” />
  34.         < property name = “dataSource” ref = “db1” />
  35.     </ bean >
  36.     < bean id = “sqlMapClient2” class = “org.springframework.orm.ibatis.SqlMapClientFactoryBean” >
  37.         < property name = “configLocation” value = “classpath：ibatis-sqlmap-config.xml” />
  38.         < property name = “dataSource” ref = “db2” />
  39.     </ bean >
  40.     < bean id = “sqlMapClientCenter” class = “org.springframework.orm.ibatis.SqlMapClientFactoryBean” >
  41.         < property name = “configLocation” value = “classpath：ibatis-sqlmap-config.xml” />
  42.         < property name = “dataSource” ref = “center” />
  43.     </ bean >
  45.     < bean id = “dynamicSqlMapClientDaoSupport” class = “com.ssi.dao.DynamicSqlClientDaoSupport” >>
  46.         < property name = “targetSqlMapClients” >
  47.             < map >
  48.                 < entry key = “db1” value-ref = “sqlMapClient1” />
  49.                 < entry key = “db2” value-ref = “sqlMapClient2” />
  50.                 < entry key = “center” value-ref = “sqlMapClientCenter” />
  51.             </ map >
  52.         </ property >
  53.         < property name = “defaultSqlMapClient” ref = “sqlMapClientCenter” />
  54.     </ bean >
  55.     < bean id = “ibatisDaoSupport” class = “com.ssi.dao.IbatisDaoSupport” parent = “dynamicSqlMapClientDaoSupport” > </bean >
  57.     < bean id = “userDao” class = “com.ssi.dao.impl.UserDaoImpl” parent = “ibatisDaoSupport” > </ bean >
  59.     <！ - 支持@AspectJ标记 - >
  60.     < aop：aspectj-autoproxy proxy-target-class = “true” />
  62.     <！ - 配置JTA的事务管理器 - >
  63.     < bean id = “atomikosTransactionManager” class = “com.atomikos.icatch.jta.UserTransactionManager” init-method = “init” destroy-method = “close” >
  64.         < property name = “forceShutdown” value = “true” />
  65.     </ bean >
  66.     < bean id = “atomikosUserTransaction” class = “com.atomikos.icatch.jta.UserTransactionImp” >
  67.         < property name = “transactionTimeout” value = “300” />
  68.     </ bean >
  69.     < bean id = “springTransactionManager” class = “org.springframework.transaction.jta.JtaTransactionManager”>
  70.         < property name = “transactionManager” ref = “atomikosTransactionManager” />
  71.         < property name = “userTransaction” ref = “atomikosUserTransaction” />
  72.     </ bean >
  73.     <！ - 配置通知 - >
  74.     < tx：advice id = “txAdvice” transaction-manager = “springTransactionManager” >
  75.         < tx：attributes >
  76.              < tx：method name = “*” rollback-for = “Exception，RuntimeException，com.ssi.exception.SystemException” propagation = “REQUIRED” />
  77.         </ tx：attributes >
  78.     </ tx：advice >
  82.     <！ - 以AspectJ方式定义AOP - >
  84.     < aop：config >
  85.         < aop：advisor pointcut = “execution（* com.ssi.service .. * Service *。*（..））” advice-ref = “txAdvice”/>
  86.     </ aop：config >
  89.     <！ - spring定时器任务开始 - >
  90.     < bean name = “job” class = “org.springframework.scheduling.quartz.JobDetailBean” >
  91.          < property name = “jobClass” >
  92.              < value > com.ssi.action.TimerAction </ value >
  93.          </ property >
  94.          < property name = “jobDataAsMap” >
  95.              < map >
  96.                   <！ - timeout属性设定了当服务器启动后过10秒钟首次调用你的JobAction - >
  97.                   < entry key = “timeout” >
  98.                      < value > 10 </ value >
  99.                   </ entry >
  100.              </ map >
  101.          </ property >
  102.     </ bean >
  103.     < bean id = “cronTrigger” class = “org.springframework.scheduling.quartz.CronTriggerBean” >
  104.          < property name = “jobDetail” >
  105.              < ref bean = “job” />
  106.          </ property >
  107.          < property name = “cronExpression” >
  108.              < 值> 0 53 15？* MON-FRI </ value >
  109.          </ property >
  110.     </ bean >
  111.     < bean class = “org.springframework.scheduling.quartz.SchedulerFactoryBean” autowire = “no” >
  112.          < property name = “triggers” >
  113.              < list >
  114.                  < ref local = “cronTrigger” />
  115.              </ list >
  116.          </ property >
  117.     </ bean >
  118.     <！ - spring定时器任务结束 - >
  120. </ beans >

 

[html] 查看纯文本

的applicationContext-datasource.xml

[html] 查看纯文本

  1. <？xml version = “1.0” encoding = “UTF-8” ？>
  2. < beans xmlns = “http://www.springframework.org/schema/beans”
  3.     xmlns：xsi = “http://www.w3.org/2001/XMLSchema-instance”
  4.     xmlns：aop = “http://www.springframework.org/schema/aop”
  5.     xmlns：tx = “http://www.springframework.org/schema/tx”
  6.     xsi：schemaLocation =“
  7.     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  8.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
  9.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd“ >
  11.     <！ - 指定春天配置中用到的属性文件 - >
  12.     < bean id = “propertyConfig” class = “org.springframework.beans.factory.config.PropertyPlaceholderConfigurer”>>
  13.         < property name = “locations” >
  14.             < list >
  15.                 < value > classpath：jdbc.properties </ value >
  16.             </ list >
  17.         </ property >
  18.     </ bean >
  19.     <！ - JTA数据源配置 - >
  20.     < bean id = “center” class = “com.atomikos.jdbc.AtomikosDataSourceBean” init-method = “init” destroy-method = “close” >
  21.         < property name = “uniqueResourceName” >
  22.             < 值> mysql / center </ value >
  23.         </ property >
  24.         < property name = “xaDataSourceClassName” >
  25.             < value > $ {jta.driver.className} </ value >
  26.         </ property >
  27.         < property name = “xaProperties” >
  28.             < 道具>
  29.                 < prop key = “url” > $ {center.jdbc.driver.url} </ prop >
  30.                 < prop key = “user” > $ {center.sql.user.name} </ prop >
  31.                 < prop key = “password” > $ {center.sql.user.password} </ prop >
  32.             </ 道具>
  33.         </ property >
  34.         < property name = “testQuery” value = “select 1” />
  35.         < property name = “poolSize” >
  36.             < value > $ {poolsize} </ value >
  37.         </ property >
  38.         < property name = “maxPoolSize” >
  39.             < value > $ {maxPoolSize} </ value >
  40.         </ property >
  41.         < property name = “borrowConnectionTimeout” > < value > $ {borrowConnectionTimeout} </ value > </ property >
  42.     </ bean >
  44.     < bean id = “db1” class = “com.atomikos.jdbc.AtomikosDataSourceBean” init-method = “init” destroy-method = “close”>
  45.         < property name = “uniqueResourceName” >
  46.             < value > mysql / db1 </ value >
  47.         </ property >
  48.         < property name = “xaDataSourceClassName” >
  49.             < value > $ {jta.driver.className} </ value >
  50.         </ property >
  51.         < property name = “xaProperties” >
  52.             < 道具>
  53.                 < prop key = “url” > $ {db1.jdbc.driver.url} </ prop >
  54.                 < prop key = “user” > $ {company.sql.user.name} </ prop >
  55.                 < prop key = “password” > $ {company.sql.user.password} </ prop >
  56.             </ 道具>
  57.         </ property >
  58.         < property name = “testQuery” value = “select 1” />
  59.         < property name = “poolSize” >
  60.             < value > $ {poolsize} </ value >
  61.         </ property >
  62.         < property name = “maxPoolSize” >
  63.             < value > $ {maxPoolSize} </ value >
  64.         </ property >
  65.         < property name = “borrowConnectionTimeout” > < value > $ {borrowConnectionTimeout} </ value > </ property >
  66.     </ bean >
  67.     < bean id = “db2” class = “com.atomikos.jdbc.AtomikosDataSourceBean” init-method = “init” destroy-method = “close”>
  68.         < property name = “uniqueResourceName” >
  69.             < value > mysql / db2 </ value >
  70.         </ property >
  71.         < property name = “xaDataSourceClassName” >
  72.             < value > $ {jta.driver.className} </ value >
  73.         </ property >
  74.         < property name = “xaProperties” >
  75.             < 道具>
  76.                 < prop key = “url” > $ {db2.jdbc.driver.url} </ prop >
  77.                 < prop key = “user” > $ {company.sql.user.name} </ prop >
  78.                 < prop key = “password” > $ {company.sql.user.password} </ prop >
  79.             </ 道具>
  80.         </ property >
  81.         < property name = “testQuery” value = “select 1” />
  82.         < property name = “poolSize” >
  83.             < value > $ {poolsize} </ value >
  84.         </ property >
  85.         < property name = “maxPoolSize” >
  86.             < value > $ {maxPoolSize} </ value >
  87.         </ property >
  88.         < property name = “borrowConnectionTimeout” > < value > $ {borrowConnectionTimeout} </ value > </ property >
  89.     </ bean >
  91.     < bean id = “dataSource” class = “com.ssi.datasource.DynamicDataSource” >
  92.         < property name = “targetDataSources” >
  93.             < map key-type = “java.lang.String” >
  94.                 < entry key = “db1” value-ref = “db1” />
  95.                 < entry key = “db2” value-ref = “db2” />
  96.                 < entry key = “center” value-ref = “center” />
  97.             </ map >
  98.         </ property >
  99.         < property name = “defaultTargetDataSource” ref = “center” />
  100.     </ bean >
  101. </ beans >

 

DynamicSqlClientDaoSupport.java

[java] 查看纯文本

  1. 包 com.ssi.dao;
  3. import  java.util.Map;
  5. import  javax.sql.DataSource;
  7. import  org.springframework.beans.factory.InitializingBean;
  8. import  org.springframework.dao.support.DaoSupport;
  9. import  org.springframework.orm.ibatis.SqlMapClientTemplate;
  10. import  org.springframework.util.Assert;
  12. import  com.ibatis.sqlmap.client.SqlMapClient;
  13. import  com.ssi.datasource.DbContextHolder;
  15. 公共类 DynamicSqlClientDaoSupport  扩展 DaoSupport  实现 InitializingBean {
  17.     私人 SqlMapClientTemplate sqlMapClientTemplate =  新的 SqlMapClientTemplate（）;
  18.     私人 地图<String，SqlMapClient> targetSqlMapClients;
  19.     私人 SqlMapClient的defaultSqlMapClient;
  20.     private boolean  externalTemplate =  false ;
  23.     / **
  24.      *设置此DAO使用的JDBC数据源。
  25.      *不需要：SqlMapClient可能携带共享数据源。
  26.      * @see #setSqlMapClient
  27.      * /
  28.     public final void  setDataSource（DataSource dataSource）{
  29.         如果 （！this .externalTemplate）{
  30.         这个.sqlMapClientTemplate.setDataSource（dataSource）;
  31.         }
  32.     }
  34.     / **
  35.      *返回此DAO使用的JDBC数据源。
  36.      * /
  37.     public final  DataSource getDataSource（）{
  38.         返回这个.sqlMapClientTemplate.getDataSource（）;
  39.     }
  41.     / **
  42.      *设置iBATIS数据库层SqlMapClient使用。
  43.      *这个或者“sqlMapClientTemplate”是必需的。
  44.      * @see #setSqlMapClientTemplate
  45.      * /
  46.     public final void  setSqlMapClient（SqlMapClient sqlMapClient）{
  47.         如果 （！this .externalTemplate）{
  48.             这个.sqlMapClientTemplate.setSqlMapClient（sqlMapClient）;
  49.         }
  50.     }
  52.     / **
  53.      *返回该模板使用的iBATIS数据库层SqlMapClient。
  54.      * /
  55.     public final  SqlMapClient getSqlMapClient（）{
  56.         返回这个.sqlMapClientTemplate.getSqlMapClient（）;
  57.     }
  59.     / **
  60.      *明确地为此DAO设置SqlMapClientTemplate，
  61.      *作为指定SqlMapClient的替代方法。
  62.      * @see #setSqlMapClient
  63.      * /
  64.     public final void  setSqlMapClientTemplate（SqlMapClientTemplate sqlMapClientTemplate）{
  65.         Assert.notNull（sqlMapClientTemplate，  “SqlMapClientTemplate不能为空” ）;
  66.         这个.sqlMapClientTemplate = sqlMapClientTemplate;
  67.         这个.externalTemplate =  true ;
  68.     }
  70.     / **
  71.      *返回此DAO的SqlMapClientTemplate，
  72.      *用SqlMapClient预先初始化或明确设置。
  73.      * /
  74.     public final  SqlMapClientTemplate getSqlMapClientTemplate（）{
  75.       字符串dbtype = DbContextHolder.getDbType（）;
  76.       if （targetSqlMapClients！= null && targetSqlMapClients.containsKey（dbtype））{
  77.           SqlMapClient sqlMapClient = targetSqlMapClients.get（dbtype）;
  78.           sqlMapClientTemplate =  新的 SqlMapClientTemplate（sqlMapClient）;
  79.       }
  80.       返回这个.sqlMapClientTemplate;
  81.     }
  83.     @覆盖
  84.     protected final void  checkDaoConfig（）{
  85.         如果 （！this .externalTemplate）{
  86.             这个.sqlMapClientTemplate.afterPropertiesSet（）;
  87.         }
  88.     }
  90.     public  Map <String，SqlMapClient> getTargetSqlMapClients（）{
  91.         返回 targetSqlMapClients;
  92.     }
  94.     public void  setTargetSqlMapClients（Map <String，SqlMapClient> targetSqlMapClients）{
  95.         这个.targetSqlMapClients = targetSqlMapClients;
  96.     }
  98.     public  SqlMapClient getDefaultSqlMapClient（）{
  99.         返回 defaultSqlMapClient;
  100.     }
  102.     public void  setDefaultSqlMapClient（SqlMapClient defaultSqlMapClient）{
  103.         这个.defaultSqlMapClient = defaultSqlMapClient;
  104.     }
  105. }

IbatisDaoSupport.java

[java] 查看纯文本

  1. 包 com.ssi.dao;
  3. import  java.io.Serializable;
  4. import  java.sql.SQLException;
  5. import  java.util.List;
  6. import  java.util.Map;
  8. import  org.apache.commons.logging.Log;
  9. import  org.apache.commons.logging.LogFactory;
  10. import  org.springframework.orm.ibatis.SqlMapClientCallback;
  12. import  com.ibatis.sqlmap.client.SqlMapExecutor;
  13. @SuppressWarnings （“未选中” ）
  14. 公共类 IbatisDaoSupport <实体>  扩展 DynamicSqlClientDaoSupport  实现 IEntityDao <实体> {
  16.     受保护的最终 日志日志= LogFactory.getLog（getClass（））;
  19.     公共 实体get（String sqlId，Serializable id）{
  20.         return  （Entity）getSqlMapClientTemplate（）。queryForObject（sqlId，id）;
  21.     }
  22.     公共 实体getByParamMap（字符串sqlId，对象参数）{
  23.         return  （Entity）getSqlMapClientTemplate（）。queryForObject（sqlId，param）;
  24.     }
  25.     public  Object save（String sqlId，Object o）{
  26.         返回 getSqlMapClientTemplate（）。insert（sqlId，o）;
  27.     }
  28.     public  Object batchSave（final  String sqlId，final  List <Entity> entityList）  throws  Exception {
  29.         //执行回调   
  30.         返回 getSqlMapClientTemplate（）。execute（新的 SqlMapClientCallback（）{
  31.             //实现回调接口   
  32.             公共 对象doInSqlMapClient（SqlMapExecutor执行器）  throws  SQLException {
  33.                 //开始批处理   
  34.                 executor.startBatch（）;
  35.                 for  （Entity entity：entityList）{
  36.                     executor.insert（sqlId，entity）;
  37.                 }
  38.                 return  executor.executeBatch（）;
  39.             }
  41.         }）;
  43.     }
  44.     public  Integer remove（String sqlId，Object o）{
  45.         返回 getSqlMapClientTemplate（）。delete（sqlId，o）;
  47.     }
  49.     public  Integer removeById（String sqlId，Serializable id）{
  50.         返回 getSqlMapClientTemplate（）。delete（sqlId，id）;
  51.     }
  53.     public  Integer update（String sqlId，Object o）{
  54.         返回 getSqlMapClientTemplate（）。update（sqlId，o）;
  56.     }
  57.     public  long totalCount（String sqlId，Object o）{
  58.         return  （Long）getSqlMapClientTemplate（）。queryForObject（sqlId，o）;
  59.     }
  60.     public  List <Entity> pagedList（String sqlId，Map <String，Object> map，int  pageSize，  int  pageNum）{
  61.         int  start =（pageNum -  1 ）* pageSize;
  62.         map.put（“开始” ，开始）;
  63.         map.put（“pageSize” ，pageSize）;
  64.         List <Entity> list = getSqlMapClientTemplate（）。queryForList（sqlId，map）;
  65.         退货 清单;
  66.     }
  67.     public  List <Entity> list（String sqlId，Object o）{
  68.         返回 getSqlMapClientTemplate（）。queryForList（sqlId，o）;
  69.     }
  70.     public  List <Entity> list（String sqlId）{
  71.         返回 getSqlMapClientTemplate（）。queryForList（sqlId）;
  72.     }
  74. }

 

UserDaoImpl.java：

[java] 查看纯文本

  1. 包 com.ssi.dao.impl;
  3. import  org.springframework.stereotype.Repository;
  6. import  com.ssi.dao.IUserDao;
  7. import  com.ssi.dao.IbatisDaoSupport;
  8. import  com.ssi.model.User;
  9. @Repository （“userDAO的” ）
  10. 公共类 UserDaoImpl  扩展 IbatisDaoSupport <用户>  实现 IUserDao {
  11.     公共 整数addUser（用户用户）  抛出 异常{
  12.         返回 （整数）  这个.save（“User.insert” ，用户）;
  13.     }
  14. }

 

UserServiceImpl.java

[java] 查看纯文本

  1. 包 com.ssi.service.impl;
  3. import  javax.annotation.Resource;
  5. import  org.springframework.stereotype.Service;
  7. import  com.ssi.dao.IUserDao;
  8. import  com.ssi.datasource.DbContextHolder;
  9. import  com.ssi.model.User;
  10. import  com.ssi.service.IUserService;
  13. @Service （“userService” ）
  14. 公共类 UserServiceImpl  实现 IUserService {
  15.     @Resource private  IUserDao userDao;
  16.     / **
  17.      *测试在服务中切换数据源异常是否回滚
  18.      * /
  19.     公共无效 addUser（用户用户）  抛出 异常{
  20.         DbContextHolder.setDbType（“db1” ）;
  21.         userDao.addUser（用户）;
  22.         DbContextHolder.setDbType（“db2” ）;
  23.         user.setUserName（“user2” ）;
  24.         userDao.addUser（用户）;
  25.         DbContextHolder.setDbType（“center” ）;
  26.         user.setUserName（“user3” ）;
  27.         userDao.addUser（用户）;
  28.         //System.out.println(1/0）;
  29.     }
  30. }

 

DynamicDataSource.java：

[java] 查看纯文本

  1. public class  DynamicDataSource  extends  AbstractRoutingDataSource {
  3.     静态 记录仪日志= Logger.getLogger（DynamicDataSource。类）;
  5.     protected  Object determineCurrentLookupKey（）{
  6.         返回 DbContextHolder.getDbType（）;
  7.     }
  9. }

DbContextHolder.java：

[java] 查看纯文本

  1. 公共类 DbContextHolder {
  2.     private static final  ThreadLocal contextHolder =  new  ThreadLocal（）;
  4.     public static void  setDbType（String dbType）{
  5.         contextHolder.set（DBTYPE）;
  6.     }
  8.     public static  String getDbType（）{
  9.         return  （String）contextHolder.get（）;
  10.     }
  12.     public static void  clearDbType（）{
  13.         contextHolder.remove（）;
  14.     }
  16. }

三个数据库：dbcenter，db1，db2表结构均相同

脚本：

[sql] 查看纯文本

  1. DROP TABLE  IF EXISTS`tb_user`;
  3. CREATE TABLE  `tb_user`（
  4.   `id`  int （11）  NOT NULL  AUTO_INCREMENT，
  5.   `userName`  varchar （20）  DEFAULT NULL ，
  6.   ` 密码`  VARCHAR （60）  DEFAULT NULL ，
  7.   PRIMARY KEY  （`id`）
  8. ）ENGINE = InnoDB  DEFAULT  CHARSET = utf8;

单元测试：

[java] 查看纯文本

  1. 公共类 JunitTest {
  2.     public  ApplicationContext cxt;
  3.     @测试
  4.     公共无效的 init（）  抛出 异常{
  5.         cxt =  new  ClassPathXmlApplicationContext（new  String [] { “applicationContext.xml” ，“applicationContext-datasource.xml” }）;
  6.         testInsertUser（）;
  8.     }
  11.     私人无效 testInsertUser（）  抛出 异常{
  12.         IUserService userService =（IUserService）cxt.getBean（“userService” ）;
  13.         用户用户=  新 用户（）;
  14.         user.setUserName（“user1” ）;
  15.         user.setPassword（“0” ）;
  16.         userService.addUser（用户）;
  17.     }
  19.     私人无效 testInsertUser2（）  抛出 异常{
  21. }
文章标签：
Java
Spring
关系型数据库
MySQL
数据库
定位技术
数据安全/隐私保护
数据格式
XML
数据库连接
关键词：
Spring分布式
Spring分布式事务
Spring service
Spring动态
Spring数据源
幸运券发放
目录
相关文章
阿里云云原生
|
5月前
|
人工智能 Java Nacos
基于 Spring AI Alibaba + Nacos 的分布式 Multi-Agent 构建指南
本文将针对 Spring AI Alibaba + Nacos 的分布式多智能体构建方案展开介绍，同时结合 Demo 说明快速开发方法与实际效果。
阿里云云原生
4296 84
HELLO程序员
|
6月前
|
存储 安全 Java
管理 Spring 微服务中的分布式会话
在微服务架构中，管理分布式会话是确保用户体验一致性和系统可扩展性的关键挑战。本文探讨了在 Spring 框架下实现分布式会话管理的多种方法，包括集中式会话存储和客户端会话存储（如 Cookie），并分析了它们的优缺点。同时，文章还涵盖了与分布式会话相关的安全考虑，如数据加密、令牌验证、安全 Cookie 政策以及服务间身份验证。此外，文中强调了分布式会话在提升系统可扩展性、增强可用性、实现数据一致性及优化资源利用方面的显著优势。通过合理选择会话管理策略，结合 Spring 提供的强大工具，开发人员可以在保证系统鲁棒性的同时，提供无缝的用户体验。
HELLO程序员
140 0
啦啦啦191
|
7月前
|
监控 Java API
Spring Boot 3.2 结合 Spring Cloud 微服务架构实操指南 现代分布式应用系统构建实战教程
Spring Boot 3.2 + Spring Cloud 2023.0 微服务架构实践摘要 本文基于Spring Boot 3.2.5和Spring Cloud 2023.0.1最新稳定版本，演示现代微服务架构的构建过程。主要内容包括： 技术栈选择：采用Spring Cloud Netflix Eureka 4.1.0作为服务注册中心，Resilience4j 2.1.0替代Hystrix实现熔断机制，配合OpenFeign和Gateway等组件。 核心实操步骤： 搭建Eureka注册中心服务 构建商品
啦啦啦191
1161 3
一枚后端工程狮
|
5月前
|
负载均衡 Java API
《深入理解Spring》Spring Cloud 构建分布式系统的微服务全家桶
Spring Cloud为微服务架构提供一站式解决方案，涵盖服务注册、配置管理、负载均衡、熔断限流等核心功能，助力开发者构建高可用、易扩展的分布式系统，并持续向云原生演进。
一枚后端工程狮
993 4
阿里云云原生
|
10月前
|
人工智能 负载均衡 Java
Spring AI Alibaba 发布企业级 MCP 分布式部署方案
本文介绍了Spring AI Alibaba MCP的开发与应用，旨在解决企业级AI Agent在分布式环境下的部署和动态更新问题。通过集成Nacos，Spring AI Alibaba实现了流量负载均衡及节点变更动态感知等功能。开发者可方便地将企业内部业务系统发布为MCP服务或开发自己的AI Agent。文章详细描述了如何通过代理应用接入存量业务系统，以及全新MCP服务的开发流程，并提供了完整的配置示例和源码链接。未来，Spring AI Alibaba计划结合Nacos3的mcp-registry与mcp-router能力，进一步优化Agent开发体验。
阿里云云原生
3368 14
dufadayang
|
存储 Java 关系型数据库
在Spring Boot中整合Seata框架实现分布式事务
可以在 Spring Boot 中成功整合 Seata 框架，实现分布式事务的管理和处理。在实际应用中，还需要根据具体的业务需求和技术架构进行进一步的优化和调整。同时，要注意处理各种可能出现的问题，以保障分布式事务的顺利执行。
dufadayang
1372 160
互联网课堂
|
资源调度 Java 调度
Spring Cloud Alibaba 集成分布式定时任务调度功能
定时任务在企业应用中至关重要，常用于异步数据处理、自动化运维等场景。在单体应用中，利用Java的`java.util.Timer`或Spring的`@Scheduled`即可轻松实现。然而，进入微服务架构后，任务可能因多节点并发执行而重复。Spring Cloud Alibaba为此发布了Scheduling模块，提供轻量级、高可用的分布式定时任务解决方案，支持防重复执行、分片运行等功能，并可通过`spring-cloud-starter-alibaba-schedulerx`快速集成。用户可选择基于阿里云SchedulerX托管服务或采用本地开源方案（如ShedLock）
互联网课堂
487 1
别惹CC
|
存储 Java 文件存储
🗄️Spring Boot 3 整合 MinIO 实现分布式文件存储
本文介绍了如何基于Spring Boot 3和MinIO实现分布式文件存储。随着应用规模扩大，传统的单机文件存储方案难以应对大规模数据和高并发访问，分布式文件存储系统成为更好的选择。文章详细讲解了MinIO的安装、配置及与Spring Boot的整合步骤，包括Docker部署、MinIO控制台操作、Spring Boot项目中的依赖引入、配置类编写及工具类封装等内容。最后通过一个上传头像的接口示例展示了具体的开发和测试过程，强调了将API操作封装成通用工具类以提高代码复用性和可维护性的重要性。
别惹CC
2492 7
🗄️Spring Boot 3 整合 MinIO 实现分布式文件存储
蓝易云
|
存储 NoSQL Java
使用lock4j-redis-template-spring-boot-starter实现redis分布式锁
通过使用 `lock4j-redis-template-spring-boot-starter`，我们可以轻松实现 Redis 分布式锁，从而解决分布式系统中多个实例并发访问共享资源的问题。合理配置和使用分布式锁，可以有效提高系统的稳定性和数据的一致性。希望本文对你在实际项目中使用 Redis 分布式锁有所帮助。
蓝易云
959 5
蓝易云
|
缓存 NoSQL Java
Spring Boot中的分布式缓存方案
Spring Boot提供了简便的方式来集成和使用分布式缓存。通过Redis和Memcached等缓存方案，可以显著提升应用的性能和扩展性。合理配置和优化缓存策略，可以有效避免常见的缓存问题，保证系统的稳定性和高效运行。
蓝易云
451 3

热门文章

最新文章

  • 1
    重磅发布！AI 驱动的 Java 开发框架：Spring AI Alibaba
  • 2
    SpringCloud Alibaba - Nacos 作为配置中心 & 读取Properties配置信息
  • 3
    （七）整合spring cloud云服务架构 - common-service 项目构建过程
  • 4
    SpringBoot集成jsp
  • 5
    Spring Boot实现无感刷新Token机制
  • 6
    微服务学习笔记九 Spring Cloud Config本地配置中心
  • 7
    spring boot 登录注册 demo （四） -- 体验小结
  • 8
    实现Java Spring Boot FCM推送教程
  • 9
    Spring Boot自动配置原理、实战
  • 10
    Spring对PDF文档操作
  • 1
    大模型分布式推理：张量并行与流水线并行技术
    1421
  • 2
    基于 Spring AI Alibaba + Nacos 的分布式 Multi-Agent 构建指南
    4296
  • 3
    《聊聊分布式》BASE理论 分布式系统可用性与一致性的工程平衡艺术
    446
  • 4
    《聊聊分布式》ZooKeeper与ZAB协议：分布式协调的核心引擎
    507
  • 5
    《聊聊分布式》分布式系统基石：深入理解CAP理论及其工程实践
    996
  • 6
    《聊聊分布式》从单体到分布式：电商系统架构演进之路
    402
  • 7
    《聊聊分布式》分布式系统核心概念
    711
  • 8
    《深入理解Spring》Spring Cloud 构建分布式系统的微服务全家桶
    993
  • 9
    优化分布式采集的数据同步：一致性、去重与冲突解决的那些坑与招
    288
  • 10
    【分布式能源选址与定容】光伏、储能双层优化配置接入配电网研究（Matlab代码实现）
    405

    • 相关课程

    更多
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • 分布式文件存储系统技术及实现
  • 分布式协调系统 Zookeeper 快速入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 高并发分布式缓存Redis6.0
  • 基于社区的分布式 风险感知模型
  • 如何利用Redisson分布式化传统Web项目
    • 下一篇
    5月安全新品播课（1）|混合云下割裂的Web安全管理挑战如何破？