论spring事务下的消息发送

最新推荐文章于 2024-07-24 22:02:04 发布
最新推荐文章于 2024-07-24 22:02:04 发布
阅读量1.5k 收藏 5
点赞数 3
分类专栏： spring源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alex_xfboy/article/details/103086331
版权

最近一直疲于重构canal consumer的客户端，近期也会陆续分享下一些开发同学常见的问题。其实很多时候发现问题并快速的解决问题并不难，难得时候是否有引起你的深度思考。谈起spring事务下发MQ消息，一般人都是直接撸面条式的硬代码，也有些高级的玩法会采用spring的ApplicationEvent来拓展实现，而spring中的@TransactionEventListener则是最高端的玩法，其背后的原理并不复杂，采用了事务和回调。

而采用ApplicationEvent的拓展并非独创，思想源于spring-session-data-redis（它session的创建与销毁方面确实非常巧妙）,一般实现为：

@Data
public abstract class MQEvent<T extends MqMetaInfo> extends ApplicationEvent {
    private String topic;
    private String tags;
    private String keys;
    private T body;
    private boolean needBodyJSONSerialize;
    private boolean areYouOK = true;
}
public abstract class MQApplicationListener<T extends MQEvent> implements ApplicationListener<T> {
    @Override
    public void onApplicationEvent(T event) {
        if (event.isAreYouOK()) {
            if (Strings.isNullOrEmpty(event.getTopic())) {
                event.setTopic(getTopic());
            }
            if (StringUtils.isBlank(event.getTags())) {
                event.setTags(getTopic());
            }
            getRocketMQProducer().sendMessage(event.getTopic(), event.getTags(), event.getKeys(), event.isNeedBodyJSONSerialize() ? JSON.toJSONString(event.getBody()) : String.valueOf(event.getBody()));
        }
    }
    protected abstract String getTopic();
    protected abstract String getTag();
    protected abstract RocketMQProducerUtil getRocketMQProducer();
}
@Component
public class MQEventBus {
    @Autowired
    private ApplicationContext applicationContext;
    public void publishEvent(MQEvent event) {
        applicationContext.publishEvent(event);
    }
    public void publishEvents(MQEvent... events) {
        Assert.notNull(events, "publish Events is required.");
        Stream.of(events).forEach(x -> publishEvent(x));
    }
}
//通过API的MQEvent，MQApplicationListener来拓展
@Component
public class OrderMessageListener extends MQApplicationListener<OrderMessageListener.OrderCreateEvent> {
    @Value("${rocketmq.producer.orderCreateTopic:#{null}}")
    private String topic;
    @Value("${rocketmq.producer.orderCreateTag:#{null}}")
    private String tag;
    @Autowired
    private RocketMQProducerUtil rocketMQProducerUtil;
    @Override
    public RocketMQProducerUtil getRocketMQProducer() {
        return rocketMQProducerUtil;
    }
    @Override
    public String getTopic() {
        return topic;
    }
    @Override
    protected String getTag() {
        return tag;
    }
    public static class OrderCreateEvent extends MQEvent<ReqEccBmsOrderMessageVO> {
        public OrderCreateEvent(ReqEccBmsOrderMessageVO body) {
            this(null, null, body, true);
        }
        public OrderCreateEvent(String tags, String keys, ReqEccBmsOrderMessageVO body, boolean needBodyJSONSerialize) {
            super("OrderCreateEvent", null, tags, keys, body, needBodyJSONSerialize);
        }
    }
}
//示例代码1
@Transactional(rollbackFor = Exception.class)
public void saveOrder(List<BaseOrder> orders, List<BaseOrderDetail> orderDetails) {
    orderService.saveBatch(orders);
    orderDetailService.saveBatch(orderDetails);
    mqEventBus.publishEvent(...)
}

实现还比较简单吧，但还需要考虑2个问题：

  1. 是否需要大事务，一般情况下数据库操作和发MQ消息都会在spring事务中完成，见示例代码1。虽说这样的用法随处可见，但有个问题需要思考：mqEventBus.publishEvent()为同步阻塞时，换言之在这期间当前的事务不会提交的（这边不就是长事务么，说好的快进快出呢），假如publishEvent延迟严重，那mysql性能消耗就比较堪忧了；
  2. 同步还是异步，异步最大的好处在于对消息的生产者与消费进行解耦，属于关注点分离范畴，它的好处就在于可补偿，最终一致性，性能更好。

接下来我们看下spring这块的实现，在Spring4.2以前：

刚刚讲过事务不会提交的问题也是可以解决的！可以在commit/rollback之后触发回调，关注TransactionSynchronization接口的afterCompletion方法即可，但使用它需要特别注意它会影响连接的释放（换言之，只有执行玩才会将会连结归还连接池，如果有大量耗时操作，那数据库的连接池就game over了）。

public interface TransactionSynchronization extends Flushable {

	/** Completion status in case of proper commit. */
	int STATUS_COMMITTED = 0;
	/** Completion status in case of proper rollback. */
	int STATUS_ROLLED_BACK = 1;
	/** Completion status in case of heuristic mixed completion or system errors. */
	int STATUS_UNKNOWN = 2;
	/**
	 * Suspend this synchronization.
	 * Supposed to unbind resources from TransactionSynchronizationManager if managing any.
	 * @see TransactionSynchronizationManager#unbindResource
	 */
	default void suspend() {
	}
	/**
	 * Resume this synchronization.
	 * Supposed to rebind resources to TransactionSynchronizationManager if managing any.
	 * @see TransactionSynchronizationManager#bindResource
	 */
	default void resume() {
	}

	/**
	 * Flush the underlying session to the datastore, if applicable:
	 * for example, a Hibernate/JPA session.
	 * @see org.springframework.transaction.TransactionStatus#flush()
	 */
	@Override
	default void flush() {
	}
	/**
	 * Invoked before transaction commit (before "beforeCompletion").
	 * Can e.g. flush transactional O/R Mapping sessions to the database.
	 */
	default void beforeCommit(boolean readOnly) {
	}

	/**
	 * Invoked before transaction commit/rollback.
	 * Can perform resource cleanup <i>before</i> transaction completion.
	 */
	default void beforeCompletion() {
	}

	/**
	 * Invoked after transaction commit. Can perform further operations right
	 * <i>after</i> the main transaction has <i>successfully</i> committed.
	 */
	default void afterCommit() {
	}
	/**
	 * Invoked after transaction commit/rollback.
	 * Can perform resource cleanup <i>after</i> transaction completion.
	 * <p><b>NOTE:</b> The transaction will have been committed or rolled back already,
	 * but the transactional resources might still be active and accessible. 
	 */
	default void afterCompletion(int status) {
	}
}
//示例代码
@Transactional(rollbackFor = Exception.class)
public void saveOrder (List < BaseOrder > orders, List < BaseOrderDetail > orderDetails){
    orderService.saveBatch(orders);
    orderDetailService.saveBatch(orderDetails);
    if (TransactionSynchronizationManager.isActualTransactionActive()) {
        TransactionSynchronizationManager.registerSynchronization(
                new TransactionSynchronizationAdapter() {
                    @Override
                    public void afterCommit() {
                        mqEventBus.publishEvent(...)
                    }
                });
    } else {
        mqEventBus.publishEvent(...)
    }
}
//源码分析
public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager, Serializable {
	@Override
	public final void commit(TransactionStatus status) throws TransactionException {
		if (status.isCompleted()) {
			throw new IllegalTransactionStateException(
					"Transaction is already completed - do not call commit or rollback more than once per transaction");
		}

		DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
		if (defStatus.isLocalRollbackOnly()) {
			if (defStatus.isDebug()) {
				logger.debug("Transactional code has requested rollback");
			}
			processRollback(defStatus, false);
			return;
		}

		if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
			if (defStatus.isDebug()) {
				logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
			}
			processRollback(defStatus, true);
			return;
		}
		//真正开始提交事务
		processCommit(defStatus);
	}
	/**
	 * Process an actual commit.
	 * Rollback-only flags have already been checked and applied.
	 * @param status object representing the transaction
	 * @throws TransactionException in case of commit failure
	 */
	private void processCommit(DefaultTransactionStatus status) throws TransactionException {
		try {
			boolean beforeCompletionInvoked = false;

			try {
				boolean unexpectedRollback = false;
				prepareForCommit(status);
				triggerBeforeCommit(status);
				triggerBeforeCompletion(status);
				beforeCompletionInvoked = true;

				if (status.hasSavepoint()) {
					if (status.isDebug()) {
						logger.debug("Releasing transaction savepoint");
					}
					unexpectedRollback = status.isGlobalRollbackOnly();
					status.releaseHeldSavepoint();
				}
				else if (status.isNewTransaction()) {
					if (status.isDebug()) {
						logger.debug("Initiating transaction commit");
					}
					unexpectedRollback = status.isGlobalRollbackOnly();
					doCommit(status);//执行事务提交
				}
				else if (isFailEarlyOnGlobalRollbackOnly()) {
					unexpectedRollback = status.isGlobalRollbackOnly();
				}

				// Throw UnexpectedRollbackException if we have a global rollback-only
				// marker but still didn't get a corresponding exception from commit.
				if (unexpectedRollback) {
					throw new UnexpectedRollbackException(
							"Transaction silently rolled back because it has been marked as rollback-only");
				}
			}
			catch (UnexpectedRollbackException ex) {
				// can only be caused by doCommit
				triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
				throw ex;
			}
			catch (TransactionException ex) {
				// can only be caused by doCommit
				if (isRollbackOnCommitFailure()) {
					doRollbackOnCommitException(status, ex);
				}
				else {
					triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
				}
				throw ex;
			}
			catch (RuntimeException | Error ex) {
				if (!beforeCompletionInvoked) {
					triggerBeforeCompletion(status);
				}
				doRollbackOnCommitException(status, ex);
				throw ex;
			}）
			// Trigger afterCommit callbacks, with an exception thrown there
			// propagated to callers but the transaction still considered as committed.
			try {
				triggerAfterCommit(status);
			}
			finally {
				//执行的回调（发消息）
				triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
			}
		}
		finally {
			//此次归还connection
			cleanupAfterCompletion(status);
		}
	}
	private void cleanupAfterCompletion(DefaultTransactionStatus status) {
		status.setCompleted();
		if (status.isNewSynchronization()) {
			TransactionSynchronizationManager.clear();
		}
		if (status.isNewTransaction()) {//此次非常重要，会调用子类DataSourceTransactionManager的doCleanupAfterCompletion
			doCleanupAfterCompletion(status.getTransaction());
		}
		if (status.getSuspendedResources() != null) {
			if (status.isDebug()) {
				logger.debug("Resuming suspended transaction after completion of inner transaction");
			}
			Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
			resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
		}
	}
}
public class DataSourceTransactionManager extends AbstractPlatformTransactionManager
		implements ResourceTransactionManager, InitializingBean {
	@Override
	protected void doCleanupAfterCompletion(Object transaction) {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;

		// Remove the connection holder from the thread, if exposed.
		if (txObject.isNewConnectionHolder()) {//释放连接
			TransactionSynchronizationManager.unbindResource(obtainDataSource());
		}

		// Reset connection.
		Connection con = txObject.getConnectionHolder().getConnection();
		try {
			if (txObject.isMustRestoreAutoCommit()) {
				con.setAutoCommit(true);
			}
			DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel());
		}
		catch (Throwable ex) {
			logger.debug("Could not reset JDBC Connection after transaction", ex);
		}

		if (txObject.isNewConnectionHolder()) {
			if (logger.isDebugEnabled()) {
				logger.debug("Releasing JDBC Connection [" + con + "] after transaction");
			}
			//释放连接
			DataSourceUtils.releaseConnection(con, this.dataSource);
		}
		//清理资源
		txObject.getConnectionHolder().clear();
	}
}

从Spring4.2开始，引入了@TransactionEventListener，它的原理与上面是类似的，只不过用法上更加简单更友好。首先借助了@TransactionalEventListener 注解（你可以认为她是@EventListener 的派生类），借助了EventListenerMethodProcessor 的针对每个方法生成一个ApplicationListenerMethodTransactionalAdapter 对象，而回掉实现的也比较巧妙！

回调的对象是TransactionSynchronizationEventAdapter（是TransactionSynchronization的一个实现类），每次调用onApplicationEvent时先实例化一个TransactionSynchronizationEventAdapter并通过TransactionSynchronizationManager.registerSynchronization添加，而ApplicationListenerMethodTransactionalAdapter既是ApplicationEvent的Listener，又是TransactionSynchronization真正被调用的类（业务方法）。

/* @since 4.2
 * @see EventListenerMethodProcessor
 */
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface EventListener {
	@AliasFor("classes")
	Class<?>[] value() default {};
	@AliasFor("value")
	Class<?>[] classes() default {};
	/**
	 * Spring Expression Language (SpEL) attribute used for making the
	 * event handling conditional.
	 * <p>Default is {@code ""}, meaning the event is always handled.
	 * <p>The SpEL expression evaluates against a dedicated context that
	 * provides the following meta-data:
	 * <ul>
	 * <li>{@code #root.event}, {@code #root.args} for
	 * references to the {@link ApplicationEvent} and method arguments
	 * respectively.</li>
	 * <li>Method arguments can be accessed by index. For instance the
	 * first argument can be accessed via {@code #root.args[0]}, {@code #p0}
	 * or {@code #a0}. Arguments can also be accessed by name if that
	 * information is available.</li>
	 * </ul>
	 */
	String condition() default "";
}
 /*
 * @since 4.2
 */
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@EventListener
public @interface TransactionalEventListener {
	/**
	 * Phase to bind the handling of an event to.
	 * <p>The default phase is {@link TransactionPhase#AFTER_COMMIT}.
	 * <p>If no transaction is in progress, the event is not processed at
	 * all unless {@link #fallbackExecution} has been enabled explicitly.
	 */
	TransactionPhase phase() default TransactionPhase.AFTER_COMMIT;
	/**
	 * Whether the event should be processed if no transaction is running.
	 */
	boolean fallbackExecution() default false;
	@AliasFor(annotation = EventListener.class, attribute = "classes")
	Class<?>[] value() default {};
	@AliasFor(annotation = EventListener.class, attribute = "classes")
	Class<?>[] classes() default {};
	String condition() default "";
}
//示例代码
@Component
public class OrderMessageListener  {
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void hanldeOrderCreatedEvent(OrderCreateEvent event) {
        ...
    }
}
@Transactional(rollbackFor = Exception.class)
public void saveOrder(List<BaseOrder> orders, List<BaseOrderDetail> orderDetails) {
    orderService.saveBatch(orders);
    orderDetailService.saveBatch(orderDetails);
    mqEventBus.publishEvent(...)
}
/* @since 4.2
*/
public interface EventListenerFactory {
}
//SmartInitializingSingleton是bean生命周期里很重要的拓展，所有单例bean都初始化完成以后， 容器会回调该接口的方法
public class EventListenerMethodProcessor implements SmartInitializingSingleton, ApplicationContextAware {
	@Override
	public void afterSingletonsInstantiated() {
        ...
	}
}
//很明显，这个是Listener的工厂类
public class TransactionalEventListenerFactory implements EventListenerFactory, Ordered {
	@Override
	public boolean supportsMethod(Method method) {
		return AnnotatedElementUtils.hasAnnotation(method, TransactionalEventListener.class);
	}

	@Override
	public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {
		return new ApplicationListenerMethodTransactionalAdapter(beanName, type, method);
	}

}
//源码解析
/**
* 它就是一个ApplicationListener的实现类，其实Event啥都不判断，最终还是调用的applicationContext.publishEvent
*/
class ApplicationListenerMethodTransactionalAdapter extends ApplicationListenerMethodAdapter {

	private final TransactionalEventListener annotation;


	public ApplicationListenerMethodTransactionalAdapter(String beanName, Class<?> targetClass, Method method) {
		super(beanName, targetClass, method);
		TransactionalEventListener ann = AnnotatedElementUtils.findMergedAnnotation(method, TransactionalEventListener.class);
		if (ann == null) {
			throw new IllegalStateException("No TransactionalEventListener annotation found on method: " + method);
		}
		this.annotation = ann;
	}


	@Override
	public void onApplicationEvent(ApplicationEvent event) {
        //这里是精髓，向当前的TransactionSynchronizationManager中注入synchronizations（TransactionSynchronization）
		if (TransactionSynchronizationManager.isSynchronizationActive()) {
			TransactionSynchronization transactionSynchronization = createTransactionSynchronization(event);
			TransactionSynchronizationManager.registerSynchronization(transactionSynchronization);
		}
		else if (this.annotation.fallbackExecution()) {
			if (this.annotation.phase() == TransactionPhase.AFTER_ROLLBACK && logger.isWarnEnabled()) {
				logger.warn("Processing " + event + " as a fallback execution on AFTER_ROLLBACK phase");
			}
			processEvent(event);
		}
		else {
			// No transactional event execution at all
			if (logger.isDebugEnabled()) {
				logger.debug("No transaction is active - skipping " + event);
			}
		}
	}

	private TransactionSynchronization createTransactionSynchronization(ApplicationEvent event) {
		return new TransactionSynchronizationEventAdapter(this, event, this.annotation.phase());
	}

	//一个TransactionSynchronization的实例，等待被回调
	private static class TransactionSynchronizationEventAdapter extends TransactionSynchronizationAdapter {

		private final ApplicationListenerMethodAdapter listener;

		private final ApplicationEvent event;

		private final TransactionPhase phase;

		public TransactionSynchronizationEventAdapter(ApplicationListenerMethodAdapter listener,
				ApplicationEvent event, TransactionPhase phase) {

			this.listener = listener;
			this.event = event;
			this.phase = phase;
		}

		@Override
		public int getOrder() {
			return this.listener.getOrder();
		}

		@Override
		public void beforeCommit(boolean readOnly) {
			if (this.phase == TransactionPhase.BEFORE_COMMIT) {
				processEvent();
			}
		}

		@Override
		public void afterCompletion(int status) {
			if (this.phase == TransactionPhase.AFTER_COMMIT && status == STATUS_COMMITTED) {
				processEvent();
			}
			else if (this.phase == TransactionPhase.AFTER_ROLLBACK && status == STATUS_ROLLED_BACK) {
				processEvent();
			}
			else if (this.phase == TransactionPhase.AFTER_COMPLETION) {
				processEvent();
			}
		}

		protected void processEvent() {
			this.listener.processEvent(this.event);
		}
	}

}
/**
* 处理xml上的实现，在<tx:annotation-driven/>时触发，基本上支持spring 2.0，就注入了这个bean TransactionalEventListenerFactory
*/
class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {
	/**
	 * Parses the {@code <tx:annotation-driven/>} tag. Will
	 * {@link AopNamespaceUtils#registerAutoProxyCreatorIfNecessary register an AutoProxyCreator}
	 * with the container as necessary.
	 */
	@Override
	@Nullable
	public BeanDefinition parse(Element element, ParserContext parserContext) {
		registerTransactionalEventListenerFactory(parserContext);
		String mode = element.getAttribute("mode");
		if ("aspectj".equals(mode)) {
			// mode="aspectj"
			registerTransactionAspect(element, parserContext);
			if (ClassUtils.isPresent("javax.transaction.Transactional", getClass().getClassLoader())) {
				registerJtaTransactionAspect(element, parserContext);
			}
		}
		else {
			// mode="proxy"
			AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
		}
		return null;
	}
	//开始注入TransactionalEventListenerFactory Listener
	private void registerTransactionalEventListenerFactory(ParserContext parserContext) {
		RootBeanDefinition def = new RootBeanDefinition();
		def.setBeanClass(TransactionalEventListenerFactory.class);
		parserContext.registerBeanComponent(new BeanComponentDefinition(def,
				TransactionManagementConfigUtils.TRANSACTIONAL_EVENT_LISTENER_FACTORY_BEAN_NAME));
	}
}
/**
* spring boot中也同样比较简单
*/
@Configuration
public abstract class AbstractTransactionManagementConfiguration implements ImportAware {
	@Bean(name = TransactionManagementConfigUtils.TRANSACTIONAL_EVENT_LISTENER_FACTORY_BEAN_NAME)
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public static TransactionalEventListenerFactory transactionalEventListenerFactory() {
		return new TransactionalEventListenerFactory();
	}
}

spring在设计工业上有太多太多需要我们学习的地方，比如注解的派生性、接口的生命周期及回调，很多时候你会发现其实context包变动很小，却可以支持很多方面的拓展，开闭原则用到了极致。

布道
关注
专栏目录
深入理解 Spring 事务：入门、使用、原理
m0_71777195的博客
08-27 342
Spring 事务是复杂一致性业务必备的知识点，掌握好 Spring 事务可以让我们写出更好地代码。这篇文章我们将介绍 Spring 事务的诞生背景，从而让我们可以更清晰地了解 Spring 事务存在的意义。接着，我们会介绍如何快速使用 Spring 事务。接着，我们会介绍 Spring 事务的一些特性，从而帮助我们更好地使用 Spring 事务。最后，我们会总结一些 Spring 事务常见的问题，避免大家踩坑。Spring 事务 - 思维导图。...
SpringCloud微服务架构中分布式事务解决方案，一次性给你说到烂
m0_64205765的博客
11-15 2289
一致性：分布式环境下，多个节点的数据是否强一致。 可用性：分布式服务能一直保证可用状态。当用户发出一个请求后，服务能在有限时间内返回结果。 分区容忍性：特指对网络分区的容忍性。 举例：Cassandra、Dynamo 等，默认优先选择 AP，弱化 C;HBase、MongoDB 等，默认优先选择 CP，弱化 A。 BASE 理论 核心思想： 基本可用( Basically Available)：指分布式系统在出现故障时，允许损失部分的可用性来保证核心可用； 软状态( So.
Spring第49篇：手把手带你实现事务消息
chenzoff的专栏
06-06 379
1、讨论一下消息投递的5种方式2、带你手写代码，实现事务消息的投递
使用监听器实现在事务提交后发送消息
qq_36804701的博客
11-15 3530
用rocketmq构造事件中心 之前说了用消息队列实现了事件中心（不知道算不算），现在虽然换成rabbitmq了但是原理是一样的，这时候就出现了一个问题，就是消息消费的时候，之前的事务还没提交就会有错误。比如编辑机器名称，发送机器编辑事件，在消费消息时把用到机器名称的地方修改机器名称（我们称为冗余字段，这样就减少了关联查询）。但是机器编辑的事务还没有提交。 @Resource Machine...
03 事务消息
weixin_39563769的博客
12-13 2544
当事务消息发送至broker的时候，如果没有提交,那么消息对于consumer来说是不可见的，mqserver接受到消息后,会通知producer,已经接受到消息.那么此时的producer会先执行一次本地事务，本地事务执行之后,才会向mqserver发送commit或者rollback； 当mqserver接受到commit的时候，consumer才可以消费消息.如果是rollback的时候，那么mqserver会删除broker中的消息. 如果本地消息执行失败或者其他原因没有向mqserver进行确认.
Spring系列第48篇：通过Spring事务实现MQ中的事务消息
GitHub质检员
08-31 235
好了，今天的内容就到此就讲完了，我们一块来总结回顾一下，你需要重点掌握的内容。1、消息投递的5种方式的推演，要熟练掌握其优缺点2、方式4中事务消息的代码实现，需要大家掌握消息服务使用频率挺高的，通常作为系统中的基础服务使用，大家可以尝试一下开发一个独立的消息服务，提供给其他服务使用。
Spring 框架事件收发功能的使用 (一) 基本使用 @EventListener
云逸 Dean的专栏
07-11 1658
Spring 框架事件收发功能的使用教学 (一) 基本使用 1. 概述 Spring 框架时间收发功能本系列的文章总共分为三部分。 第一部分：为大家介绍如何用 Spring 来进行事件收发，如何让 Spring 的事件收发变为异步进行的，Spring 又是如何实现异步收发的。 第二部分：为大家介绍如何在事务的各个节点去触发监听器的执行，以及基于事务的事件监听器在异步配置下失效的原因。 第三部分：...
计算机专业论文 （SpringBoot/SpringCloud+Vue+MySql）
最新发布
weixin_70367240的博客
07-24 1244
计算机专业本科论文，旅游网，springboot/springcloud+vue+mysql 需要源码dd
Spring、Spring MVC、Spring Boot
weixin_46007295的博客
03-17 1016
Spring、Spring MVC、Spring Boot
【观察者模式】publishevent 事件监听
Mr.J
12-06 984
注：文章皆为个人纪录，可用性请以最终结果为准，若有错还请大佬们指出，谢谢！ 使用场景： 在业务流程处理中，经常需要做业务的解耦，比方说在注册功能中，只关心注册的主流程，而注册成功后会做发放积分券之类的副流程，副流程业务也属于注册的一部分，此时就需要将注册的主流程与发放积分券的副流程进行解耦。 注意： 事件监听处理在代码中为同步的串行执行，不要理解为异步处理，目的只是为了进行 业务的解耦与代码的解耦 步骤一：定义事件 1.1 定义事件的基类（MyBaseEve...
spring事务提交前后操作
zhaokuner的专栏
03-08 1768
希望在spring 事务提交后对缓存操作，如果提交失败就不要提交缓存 //这个放在事务方法操作中 TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() { @Override public void aft...
如何将一个操作“绑定到数据库事务上”
weixin_33967071的博客
09-20 577
摘要spring-cache简介基本机制事务上下文中的问题将操作绑定到数据库事务上spring-cache的相关实现TransactionSynchronizationManager和TransactionSynchronizationAdapter事务相关操作注册与回调流程其它应用摘要在开发中，我们常常会遇到（或者需要）把一些操作“绑定到数据库事务上”。也就是说，如果数据库...
Transaction silently rolled back because it has been marked as rollback-only Spring事务嵌套问题
weixin_42268839的博客
07-25 324
事务嵌套问题。
SpringBoot动态定时任务的实现
m0_65403567的博客
12-16 1655
1. Spring 定时任务的简单实现 在Spring Boot中使用定时任务，只需要@EnableScheduling开启定时任务支持，在需要调度的方法上添加@Scheduled注解。这样就能够在项目中开启定时调度功能了，支持通过cron、fixedRate、fixedDelay等灵活的控制执行周期和频率。 1.1 缺点 周期一旦指定，想要更改必须要重启应用 1.2 需求 热更新定时任务的执行周期，基于cron表达式并支持外部存储，如数据库，nacos等 最小改造兼容现有的定时任务(仅需添加一个
TransactionSynchronizationManager
wuchengran的博客
12-24 3511
1、需要在事务提交过后进行某一项或者某一系列的业务操作时候我们就可以使用TransactionSynchronizationManager，通过spring的aop机制将需要进行后置业务处理的操作，提交给spring的处理机制，并且切入到事务处理的后面。 2、事务结束后再执行某些业务：TransactionSynchronizationManager.registerSynchronization。 3、运用实例 应用场景是当订单成功之后，发送一条消息到 MQ 当中去。由于事务是...
Spring 源码分析衍生篇十三 ：事务扩展机制 TransactionSynchronization
猫吻鱼的博客
01-13 5481
一、前言 二、TransactionSynchronizationManager TransactionSynchronizationManager 事务同步管理器。Spring 在事务过程中通过此类来管理事务。 TransactionSynchronizationManager 中保存的是各个线程中的事务信息。 public abstract class TransactionSynchronizationManager { //线程上下文中保存着【线程池对象：ConnectionHolde
观察者模式Spring之publishEvent事件处理
热门推荐
jike11231的博客
05-19 1万+
一、使用场景 这个一般什么时候使用，我们一般是在不同的bean直接进行信息传递，比如我们beanA的事件处理完后，需要beanB进行处理一些业务逻辑的时候这种情况就一般可以使用publish-event解决。 二、原理 ApplicationContext中的事件处理是通过ApplicationEvent类和ApplicationListener接口来提供的，通过ApplicationContext的publishEvent()方法发布到ApplicationListener;。 一个事件模型有三个组成部分
Spring的事件通知机制探究（publish-event）
珈凝的博客
12-15 2358
背景 项目中用到了spring的事件发布，在用完之后，对其中的原理和实现做一些了解和记录。 DEMO 首先新建一个事件 public class DemoEvent extends ApplicationEvent { private Demo demo; public TestEvent(Demo demo) { super(demo); this.demo = demo; } public Demo getDemo(){
Spring与ActiveMQ消息发送示例与配置详解
相比于直接操作ActiveMQ API，SpringJMS提供了模板类，使得发送和接收消息变得更为直观，同时它还处理了资源管理和事务管理等细节，提升了开发效率。 2. Maven依赖： - `spring-jms`：这是Spring提供的用于JMS支持...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值