尝试在代码中动态切换spring的事务策略

最新推荐文章于 2024-04-11 17:14:38 发布
最新推荐文章于 2024-04-11 17:14:38 发布
阅读量139 收藏
点赞数
分类专栏： spring 文章标签： Spring Hibernate 配置管理 Bean AOP
用过spring的人都熟悉spring的事务管理机制，并且spring支持jta分布式事务，那么，我一直在想，能否在代码中动态的切换事务类型呢？如果当前要操作的多个表在同一个数据源上，就直接本地

事务好了，如果当前操作的表分别在不同的数据源上，就切换成spring里配置好的jta事务。也就是说，事务还是用spring的声明式事务，但是用代码手动的选取用哪一个，能不能这样呢？？
我做了个测试，在测试中，配置了两个spring配置文件，一个是使用本地事务，并且只有一个数据源，另一个是jta事务，并且有两个数据源，它们分别如下:

applicationContext-sys.xml(使用本地事务，并且只有一个数据源) 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

	<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath*:conf/jdbc.properties</value>
			</list>
		</property>
	</bean>

	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="${driverClassName}" />
		<property name="url" value="${url}" />
		<property name="username" value="${username}" />
		<property name="password" value="${password}" />
	</bean>
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					${dialect}
				</prop>
				<prop key="hibernate.default_batch_fetch_size">10</prop>
				<prop key="hibernate.max_fetch_depth">0</prop>
				<prop key="hibernate.show_sql">${show_sql}</prop>
			</props>
		</property>
		<property name="mappingDirectoryLocations">
			<list>
				<value>classpath*:/com/zhangweilin/po/</value>
			</list>
		</property>
	</bean>

	<bean id="txManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
		<property name="nestedTransactionAllowed" value="true" />
	</bean>

	<tx:annotation-driven transaction-manager="txManager" />

	<aop:config>
		<aop:pointcut id="commonServiceOperation"
			expression="execution(* com.zhangweilin.service.*Service.*(..))" />
		<aop:advisor pointcut-ref="commonServiceOperation"
			advice-ref="txAdvice" />
	</aop:config>

	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<tx:method name="init*" rollback-for="Exception" />
			<tx:method name="save*" rollback-for="Exception" />
			<tx:method name="create*" rollback-for="Exception" />
			<tx:method name="login*" rollback-for="Exception" />
			<tx:method name="add*" rollback-for="Exception" />
			<tx:method name="update*" rollback-for="Exception" />
			<tx:method name="modify*" rollback-for="Exception" />
			<tx:method name="delete*" rollback-for="Exception" />
			<tx:method name="remove*" rollback-for="Exception" />
			<tx:method name="clear*" rollback-for="Exception" />
			<tx:method name="register*" rollback-for="Exception" />
			<tx:method name="*" read-only="true" />
		</tx:attributes>
	</tx:advice>

	<!-- 
	<bean id="ehcacheManager"
		class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
		<property name="configLocation" value="/WEB-INF/classes/ehcache.xml" />
	</bean>
	 -->

	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    	<property name="dataSource" ref="dataSource"/>
	</bean>


	<bean id="dao" class="com.zhangweilin.core.DaoImpl">
		<property name="sessionFactory" ref="sessionFactory" />
		<property name="jdbcTemplate" ref="jdbcTemplate" />
	</bean> 
</beans>



另一个:applicationContext-test-jotm.xml(jta事务，并且有两个数据源) 


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

<!-- jotm配置 -->
	<bean id="mysqldatasource" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource">  
        <property name="dataSource">
        <!--内部XA数据源  -->
            <bean class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">  
                <property name="transactionManager" ref="jotm" />  
                <property name="driverName" value="com.mysql.jdbc.Driver" />  
                <property name="url" value="jdbc:mysql://172.16.18.75:3306/?useUnicode=true&characterEncoding=UTF-8" />  
            </bean>  
        </property>  
        <property name="user" value="root" />  
        <property name="password" value="123456" />  
    </bean>  


    <bean id="h2datasource" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource">  
        <property name="dataSource">
       	 <!--内部XA数据源    -->
            <bean class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">  
                <property name="transactionManager" ref="jotm" />  
                <property name="driverName" value="com.mysql.jdbc.Driver" />  
                <property name="url" value="jdbc:mysql://localhost:3306/pay?useUnicode=true&characterEncoding=UTF-8" />  
            </bean>  
        </property>  
        <property name="user" value="zwllxs" />  
        <property name="password" value="123456" />  
    </bean>  

    <bean id="sessionFactory1" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="dataSource" ref="mysqldatasource"/>  
        <property name="mappingDirectoryLocations">
			<list>
				<value>classpath*:/com/zhangweilin/po/</value>
			</list>
		</property>
        <property name="hibernateProperties">  
            <props>  
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</prop>  
                <prop key="hibernate.show_sql">true</prop>  
                <prop key="hibernate.jdbc.batch_size">50</prop>  
                <prop key="hibernate.cache.use_query_cache">true</prop>  
                <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>  
            </props>  
        </property>  
        <!-- 
	        <property name="jtaTransactionManager">  
	            <ref bean="jotm" />  
	        </property>
         -->  
    </bean>  

     <bean id="sessionFactory2" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
            <property name="dataSource" ref="h2datasource"/>  
            <property name="mappingDirectoryLocations">
				<list>
					<value>classpath*:/com/zhangweilin/po/</value>
				</list>
			</property>
            <property name="hibernateProperties">  
                <props>  
                    <prop key="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</prop>  
                    <prop key="hibernate.show_sql">true</prop>  
                    <prop key="hibernate.jdbc.batch_size">50</prop>  
                    <prop key="hibernate.cache.use_query_cache">true</prop>  
                    <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>  
                </props>  
            </property>  
             <!-- 
		        <property name="jtaTransactionManager">  
		            <ref bean="jotm" />  
		        </property>
	         -->  
    </bean>  


	<bean id="dao1" class="com.zhangweilin.core.DaoImpl">
		<property name="sessionFactory" ref="sessionFactory1" />
	</bean> 

	<bean id="dao2" class="com.zhangweilin.core.DaoImpl">
		<property name="sessionFactory" ref="sessionFactory2" />
	</bean> 

	<bean id="loginLogService2" class="com.zhangweilin.service.impl.LoginLogServiceImpl">
		<property name="dao" ref="dao1" />
	</bean>

	<bean id="articleService2" class="com.zhangweilin.service.impl.ArticleServiceImpl">
		<property name="dao" ref="dao2" />
		<property name="loginLogService" ref="loginLogService2" />
	</bean>

	<bean id="jotm" class="org.springframework.transaction.jta.JotmFactoryBean" />  
    <!-- jtatransactionmanager容器 -->  
    <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">  
        <property name="userTransaction" ref="jotm" />  
    </bean>  

     <tx:advice id="txAdvice2" transaction-manager="transactionManager">  
        <tx:attributes>  
            <tx:method name="add*" propagation="REQUIRED" />  
            <tx:method name="upd*" propagation="REQUIRED" />  
            <tx:method name="del*" propagation="REQUIRED" />  
			<tx:method name="*" read-only="true" />
        </tx:attributes>  
    </tx:advice>  

    <aop:config>  
        <aop:pointcut id="interceptorPointCuts" expression="execution(* com.zhangweilin.service.*Service.*(..))" />  
        <aop:advisor id="jotmAdvisor" advice-ref="txAdvice2" pointcut-ref="interceptorPointCuts" />  
    </aop:config> 
</beans>



再附上关键的service:
ArticleService.java: 

/**
 * 文章
 * @author zhangweilin
 *
 */
public interface ArticleService extends Service<Article>
{
    /**
     * 测试同时添加分布在不同库上的Article和LoginLog;
     * @param article
     * @throws Exception 
     */
    public void addArticle(Article article,String name) throws Exception;


    public void setName(String name);

    public String getName();
}


ArticleServiceImpl.java: 


/**
 * 文章
 * @author zhangweilin
 *
 */
public class ArticleServiceImpl extends ServiceImpl<Article> implements ArticleService
{
    private LoginLogService loginLogService;
    private String name="张伟林";
    /**
     * @param loginLogService the loginLogService to set
     */
    public void setLoginLogService(LoginLogService loginLogService)
    {
        System.out.println("setLoginLogService: "+loginLogService);
        this.loginLogService = loginLogService;
    }
    @Override
    public void addArticle(Article article,String name) throws Exception
    {
         save(article);
         LoginLog loginLog=new LoginLog();
         loginLog.setAddress(name);
         loginLog.setAdmin(null);
         loginLog.setIp("11.11.11.11");
//         loginLog.setLoginTime(new Date());

         System.out.println(" 添加");
         loginLogService.save(loginLog);
         System.out.println("操作结束");
    }
    @Override
    public String getName()
    {
        System.out.println("getName: "+name);
        return this.name;
    }
    @Override
    public void setName(String name)
    {
        System.out.println("setName: "+name);
        this.name=name;

    }


再附上测试代码: 


package com.zhangweilin.test;

import java.util.Date;

import org.aopalliance.aop.Advice;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.orm.hibernate3.HibernateTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.jta.JtaTransactionManager;
import org.springframework.transaction.support.AbstractPlatformTransactionManager;

import com.zhangweilin.po.Article;
import com.zhangweilin.service.ArticleService;
import com.zhangweilin.service.LoginLogService;

/**
 * 测试在代码中动态切换spring的事务策略
 * @author wlzhang
 *
 */
public class TestServiceJotm
{
    private static BeanFactory fac;
    private static LoginLogService loginLogService2;
    private static ArticleService articleService;
    private static HibernateTransactionManager hibernateTransactionManager;
    private static PlatformTransactionManager platformTransactionManager;
    private static AbstractPlatformTransactionManager abstractPlatformTransactionManager;

    /**
     * 初始化环境
     */
    @BeforeClass
    public static void init()
    {
        try
        {

            fac = new ClassPathXmlApplicationContext("conf\\spring\\applicationContext*.xml");
            loginLogService2 = (LoginLogService) fac.getBean("loginLogService2");
            articleService = (ArticleService) fac.getBean("articleService2");

        }
        catch (Throwable t)
        {
            t.printStackTrace();
        }
    }

    /**
     * 尝试切换事务管理器
     */
    @Test
    public void testChangeTransactionManager()
    {
        //先测试单例效应
        System.out.println("articleService.name: "+articleService.getName());//第一次获取name值
        articleService.setName("伟林张");
        articleService = (ArticleService) fac.getBean("articleService2");
        System.out.println("articleService.name2: "+articleService.getName());//第二次获取name值,如果spring配置采用的单例，那么此获取的就是修改后的name值

        //尝试着切换事务管理器
        Object jotm=fac.getBean("jotm");
        System.out.println("jotm: "+jotm+" , "+jotm.getClass());

        Object interceptorPointCuts=fac.getBean("interceptorPointCuts");
        System.out.println("interceptorPointCuts: "+interceptorPointCuts+" , "+interceptorPointCuts.getClass());

        DefaultBeanFactoryPointcutAdvisor jotmAdvisor=(DefaultBeanFactoryPointcutAdvisor) fac.getBean("jotmAdvisor");
        System.out.println("jotmAdvisor: "+jotmAdvisor+" , "+jotmAdvisor.getClass());

        hibernateTransactionManager = (HibernateTransactionManager) fac.getBean("txManager");
        System.out.println("hibernateTransactionManager: "+hibernateTransactionManager);

        platformTransactionManager = (PlatformTransactionManager) fac.getBean("transactionManager");
        System.out.println("platformTransactionManager: "+platformTransactionManager);
        System.out.println("切换前");
        if (platformTransactionManager instanceof JtaTransactionManager)
        {
            System.out.println("当前事务: JtaTransactionManager");
            JtaTransactionManager jtaTransactionManager=(JtaTransactionManager) platformTransactionManager;
            System.out.println("转成jtaTransactionManager: "+jtaTransactionManager);
            System.out.println("准备切换");
            platformTransactionManager=hibernateTransactionManager;  //尝试将hibernate事务管理器赋给jta事务管理器
            System.out.println("尝试切换成功:platformTransactionManager: "+platformTransactionManager);

        }
        else if (platformTransactionManager instanceof HibernateTransactionManager)
        {
            System.out.println("当前事务: HibernateTransactionManager");
            HibernateTransactionManager jtaTransactionManager=(HibernateTransactionManager) platformTransactionManager;
            System.out.println("转成jtaTransactionManager: "+jtaTransactionManager);
        }

        System.out.println("切换后");
        platformTransactionManager = (PlatformTransactionManager) fac.getBean("transactionManager");
        System.out.println("platformTransactionManager: "+platformTransactionManager);
        if (platformTransactionManager instanceof JtaTransactionManager)
        {
            //在“切换”后，还是调用的这里。说明切换不成功
            System.out.println("当前事务: JtaTransactionManager");
            JtaTransactionManager jtaTransactionManager=(JtaTransactionManager) platformTransactionManager;
            System.out.println("转成jtaTransactionManager: "+jtaTransactionManager);
            System.out.println("准备切换");
            platformTransactionManager=hibernateTransactionManager;
            System.out.println("尝试切换成功");

        }
        else if (platformTransactionManager instanceof HibernateTransactionManager)
        {
            System.out.println("当前事务: HibernateTransactionManager");
            HibernateTransactionManager hibernateTransactionManager=(HibernateTransactionManager) platformTransactionManager;
            System.out.println("转成HibernateTransactionManager: "+hibernateTransactionManager);
        }

        //结果，切换引用是行不通的，而更改现有的单例对象的值是可以的
    }

    /**
     * 切换事务管理器失败，尝试切换 Advisor
     */
    @Test
    public void testChangeAdvisor()
    {
        DefaultBeanFactoryPointcutAdvisor jotmAdvisor=(DefaultBeanFactoryPointcutAdvisor) fac.getBean("jotmAdvisor");
        System.out.println("jotmAdvisor: "+jotmAdvisor+" , "+jotmAdvisor.getClass());
        System.out.println("jotmAdvisor: "+jotmAdvisor.getAdviceBeanName());

        jotmAdvisor.setAdviceBeanName("txAdvice");
        jotmAdvisor=(DefaultBeanFactoryPointcutAdvisor) fac.getBean("jotmAdvisor");
        System.out.println("jotmAdvisor: "+jotmAdvisor.getAdviceBeanName());//adviceBeanName名被更改了，。幻想着切换事务的可行性增大了
//        Advice advice=jotmAdvisor.getAdvice();
    }

    /**
     * 先不做切换的数据操作,完全符合自己预期
     * @throws Exception
     */
    @Test
    public void testArticleService() throws Exception
    {
        System.out.println("articleService: "+articleService);

        Article article=new Article();
        article.setAddTime(new Date());
        article.setContent("太好了");
        article.setTitle("jotm测试下");
        article.setType(20);

        articleService.addArticle(article,"上海");
    }


    /**
     * Advisor看起来貌似切换成功了，所以正式尝试切换事务来增加数据，测试中保证让数据库端一个表不能正常插入数据，以测试事务的一致性
     */
    @Test
    public void testChangeTrancation()
    {
        DefaultBeanFactoryPointcutAdvisor jotmAdvisor=(DefaultBeanFactoryPointcutAdvisor) fac.getBean("jotmAdvisor");

        System.out.println("使用默认事务:jta事务");

        Article article=new Article();
        article.setAddTime(new Date());
        article.setContent("使用默认事务:jta事务太好了");
        article.setTitle("使用默认事务:jta事务_jotm测试下");
        article.setType(20);

        try
        {
            articleService.addArticle(article,"使用默认事务:jta事务_上海");
        }
        catch (Exception e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        jotmAdvisor.setAdviceBeanName("txAdvice2");  //尝试以更改adviceBeanName的方式修改指定的事务
        jotmAdvisor=(DefaultBeanFactoryPointcutAdvisor) fac.getBean("jotmAdvisor");
        System.out.println("事务已切换，使用本地事务");


        article=new Article();
        article.setAddTime(new Date());
        article.setContent("事务已切换，使用本地事务_事务太好了");
        article.setTitle("事务已切换，使用本地事务_jotm测试下");
        article.setType(20);

        try
        {
            articleService.addArticle(article,"事务已切换，使用本地事务_上海");
        }
        catch (Exception e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        /**
         *  切换事务失败，事务的一致性并没有符合自己的预期。经过查询文档，关于setAdviceBeanName方法的描述如下，
         *  Specify the name of the advice bean that this advisor should refer to. 
            An instance of the specified bean will be obtained on first access of this advisor&apos;s advice. This advisor will only ever obtain at most one single instance of 

the advice bean, caching the instance for the lifetime of the advisor. 
         *  只在第一次访问时才创建，之后不能更改,哎，杯具
         */ 


    }



不知道有谁能提供更好的测试方案，如果有在代码中切换spring里的事务的方案更好
zwllxs
关注
专栏目录
Spring Boot 中文参考指南
分享技术干货和灵感、推荐新书和好玩的项目、分享Java面试题
02-08 8446
虽然Spring Boot 3.x第一个GA版本出来了，但一段时间内市面上依然还会以2.X版本为主，而2.7.8 是最后一个2.x的GA版本
如何实现动态切换多个数据源? 结合环境变量、配置文件、数据库、消息队列以及API接口等方面来详细阐述动态切换数据源的方法。
AI天才研究院
07-28 1115
2019年是一个转折点，由于疫情原因，很多公司都在筹备或者进行远程办公等工作。这时，在设计应用的时候就需要考虑如何实现动态切换多个数据源的问题。本文将结合环境变量、配置文件、数据库、消息队列以及API接口等方面来详细阐述动态切换数据源的方法。2019年是一个特殊的年份，无论是经济、科技还是社会方面的巨变，都充满着新的机遇和挑战。面对这些变化带来的新任务，许多企业都必须快速且灵活地应对。许多公司可能会采用微服务架构或分布式系统来解决业务拆分和系统扩展的问题。
Spring内部调用事务不生效的解决方式一
磊杰的博客
09-22 484
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by Fernflower decompiler) // package org.springframework.aop.framework; import org.springframework.core.NamedThreadLocal; public abstract class AopContext { private static .
Spring分布式事务在service中动态切换数据源
hi_kevin的专栏
08-08 1万+
Spring分布式事务在service中无法切换数据源 项目采用的是struts2+spring+ibatis架构，下面是关键部分代码： applicationContext.xml： <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001
spring添加事务控制
dear_Alice_moon的专栏
10-04 364
本文转载：     原文地址：  spring添加事务控制                       
spring多数据源+事物管理
赶路人儿
02-05 2941
1、使用了spring的aop思想，实现了动态数据源的切换。 2、spring的数据管理，是基于数据源的，所以如果要实现动态数据源切换，而且在同一个数据源中保证事务是起作用的话，就需要注意二者的顺序问题，即：在事物起作用之前就要把数据源切换回来。          举一个例子：web开发常见是三层结构：controller、service、dao。一般事务都会在service层加的，如
spring配置多数据源涉及事务无法切换解决方案（绝对有效）
qq_37061442的博客
09-03 5万+
最近在做的项目需要操作两个数据源，并且是一个service需要同时调用两个数据源，刚开始按照网上说的配置通过切面操作AbstractRoutingDataSource这个类，发现单独去调用每一个数据源可以灵活切换，后来涉及事务一个service调用两个数据源就发现动态数据源无法切换了，琢磨了很久，终于找到原因。 问题根源： spring涉及事务的代码调用顺序: service注解上@tran...
Spring一些基础问题整理
热门推荐
张彦峰的博客
04-07 169万+
Spring相关高频面试题整理
浅谈SpringAop动态代理
asdsa_df的博客
04-11 1080
在Spring中，自定义生成动态代理的方式主要涉及两个方面：选择代理接口: 当使用JDK动态代理时，需要确保业务类实现了一个或多个接口，因为JDK动态代理是基于接口进行代理的。如果业务类没有实现任何接口，那么Spring会使用CGLib动态代理作为默认的代理方式。配置AOP代理细节: 通过Spring的配置（XML或注解），可以指定如何创建代理对象。这些配置包括切面（Aspect）、切点（Pointcut）和通知（Advice）。
二、SPI机制&Mybatis&Spring事务&MySQL(浅尝一下)
show_x的博客
06-03 483
后端常见技术深度解析，后续会有详细的篇章去介绍，这里可以浅尝一下，有个体感。 经验之谈
Spring Cloud中TCC分布式事务的基本原理
在分布式环境中，TCC分布式事务可以保证各个服务之间的数据一致性和事务可靠性。 ## 1.2 TCC分布式事务的重要性 随着微服务架构的流行，越来越多的业务系统被拆分为多个服务，每个服务负责特定的功能模块。这种...
spring无事务的数据源切换,和带事务的数据源切换
chaoyue1397的博客
04-07 7942
最近在配置spring框架时需要使用多数据源,其中遇到一些问题,特此记录 无事务数据源切换 见 http://blog.csdn.net/shadowsick/article/details/8878448  主要说一下带事务数据源切换的配置 首先在spring-database.xml中配置两个数据源(默认数据源),和应用的切面
spring整合mybatis动态切换数据源+事务管理
qq_42160456的博客
11-09 1576
*公司因为业务需要，需要把同一份服务的数据根据不同标识分别存放到两个数据库中（数据结构一样），刚开始为了尽快满足需求，使用了个简版（代码切换数据源），闲下来以后实在觉得太low，查看了一些demo以后，整理出来了适合自己项目的配置。话不多说，上步骤。* ...
Spring实现多数据源配置以及切换，并解决加入事务控制出现切换失败的问题
m0_37837382的博客
07-23 5495
1.多数据源的配置：     应用场景：（1）数据作读写分离，配置读库和写库。（2） 同步其他数据源数据库数据到项目默认的数据库对应表中，例如通过定时任务同步更新和修改操作 这里主要介绍的是通过Spring AOP，加上注解的方式，在进行Service方法的访问前，先通过前置通知Before，执行数据源切换操作，然后再执行dao层代码，进行数据库的相关操作。  一.xml相关配置操作： ...
2025年软考高级 - 信息系统项目管理师考试备考全攻略
11-09
2025年软考高级 - 信息系统项目管理师考试备考全攻略
MySQL 5.7从入门到精通 第23章 新闻发布系统数据库设计 共6页.pptx
最新发布
11-09
【课程大纲】 第1章 初始MySQL 共19页.pptx 第2章 MySQL的安装与配置 共14页.pptx 第3章 数据库的基本操作 共11页.pptx 第4章 数据表的基本操作 共26页.pptx 第5章 数据类型和运算符 共17页.pptx 第6章 MySQL函数 共76页.pptx 第7章 查询数据 共48页.pptx 第8章 插入、更新与删除数据 共10页.pptx 第9章 索引 共11页.pptx 第10章 存储过程和函数 共19页.pptx 第11章 视图 共20页.pptx 第12章 触发器 共11页.pptx 第13章 用户管理 共25页.pptx 第14章 数据备份与还原 共21页.pptx 第15章 MySQL日志 共22页.pptx 第16章 性能优化 共18页.pptx 第17章 MySQL Workbench5.2 的使用 共15页.pptx 第18章 MySQL Replication 共27页.pptx 第19章 MySQL Cluster 共49页.pptx 第20章 MySQL管理利器——MySQL Utilities 共5页.pptx 第21章 读写分离的利器——MySQL Proxy 共5页.pptx 第22章 PHP操作MySQL数据库 共7页.pptx 第23章 新闻发布系统数据库设计 共6页.pptx 第24章 论坛管理系统数据库设计 共6页.pptx
高分springboot毕设+vue的游戏创意工坊与推广平台的设计与实现_orv论文-Java源码.zip
11-09
本项目是一个基于Spring Boot和Vue的游戏创意工坊与推广平台的设计与实现。该项目旨在为游戏开发者和玩家提供一个集中的平台，使他们能够分享创意、展示作品并获取反馈。平台的核心功能包括游戏创意的提交与管理、游戏作品的展示与评价、用户间的互动交流以及推广活动的组织与管理。 在技术实现上，后端采用Spring Boot框架，利用其快速开发和部署的特点，确保系统的稳定性和高效性。前端则使用Vue.js，以其灵活的数据绑定和组件化开发方式，为用户提供流畅的交互体验。数据库设计充分考虑了数据的安全性和扩展性，以支持大量用户和作品的存储需求。 此外，项目还集成了多种实用工具和插件，如用户认证、权限管理、文件存储等，以提升平台的整体功能和用户体验。通过这个项目，用户不仅能够锻炼自己的编程技能，还能深入了解游戏开发和运营的全过程。
考研助手--论文.zip
11-09
基于SSM的毕业设计源码
C# AutoCAD DWG打印成PDF 代码
11-09
自己写的转PDF代码，调试，可用。
Spring框架中的JTA事务管理与POJO声明性事务
"本文主要探讨了如何在Spring框架中实现事务的暂停，特别是当使用JTA作为后台事务策略时，如何让POJO类利用Spring的声明性事务管理。文章通过分析Spring的事务管理特性，展示了Spring如何与J2EE服务器（如BEA ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值