插件里使用@Transactional注解实现事务

https://github.com/atlascommunity/jira-plugins-groovy这款插件的做法 

jira的ao模块，默认是不支持@Transactional注解，如果需要使用事务，可以显式声明事务：

import com.atlassian.jira.transaction.Transaction;

import com.atlassian.jira.transaction.Txn;

 

 

    Transaction txn = Txn.begin();

    try {

        ...

        txn.commit();

        ...

    } finally {

        txn.finallyRollbackIfNotCommitted();

但是这样，稍显麻烦，最近查看了一款官方开源插件（https://github.com/atlascommunity/jira-plugins-groovy），这款插件里面是通过注解的方式实现事务的，实现方式如下

需要在pom文件里，增加aop支持，添加位置：

 

代码：

<Import-Package>

                           <!-- imports -->

                           org.springframework.osgi.*;resolution:="optional",

                           org.eclipse.gemini.blueprint.*;resolution:="optional",

                           <!-- spring imports -->

                           org.springframework.aop,

                           org.springframework.core,

                           <!-- jira stuff -->

                           com.atlassian.jira.plugin.webfragment.conditions,

                           com.atlassian.jira.issue.customfields.searchers,

                           com.atlassian.jira.jql.operand,

                           <!-- required for spring lifecycle annotations -->

                           <!--javax.annotation,-->

                           <!-- exclude stuff for querydsl pocketknife -->

                           !net.sf.cglib.proxy,

                           !org.jvnet.hudson.annotation_indexer,

                           <!-- everything else -->

                           *;resolution:=optional

                       </Import-Package>

                       <Require-Bundle>org.apache.felix.framework</Require-Bundle>

 

另外，需要增加几个类：

ProxiedBeanPostProcessor 折叠源码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

package com.shdsd.plugin.organizationPro.util.spring;   import com.shdsd.plugin.organizationPro.util.AnnotationUtil; import com.shdsd.plugin.organizationPro.util.PluginInfo; import org.aopalliance.intercept.Interceptor; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.aop.framework.ProxyFactory; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor;   import java.lang.annotation.Annotation;   public class ProxiedBeanPostProcessor implements BeanPostProcessor {     private final Logger logger = LoggerFactory.getLogger(ProxiedBeanPostProcessor.class);       private final Class<? extends Annotation> annotationClass;     private final Interceptor interceptor;       public ProxiedBeanPostProcessor(Class<? extends Annotation> annotationClass, Interceptor interceptor) {         this.annotationClass = annotationClass;         this.interceptor = interceptor;     }       public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {         return o;     }       public Object postProcessAfterInitialization(Object bean, String name) throws BeansException {         try {             Class<?> beanClass = bean.getClass();               //ignore 3rd party beans             // PluginInfo.PLUGIN_KEY是插件的包的根路径，一般是groupId + arctifactId             if (beanClass.getCanonicalName().startsWith(PluginInfo.PLUGIN_KEY)) {                 if (AnnotationUtil.isAnnotated(annotationClass, beanClass)) {                     ProxyFactory proxyFactory = new ProxyFactory(bean);                     proxyFactory.addAdvice(interceptor);                       return proxyFactory.getProxy(ProxiedBeanPostProcessor.class.getClassLoader());                 }                 else return bean;             }         } catch (Exception e) {             logger.warn("Unable to process bean {} - {}", name, bean, e);         }         return bean;     }   }

TransactionalInterceptor 折叠源码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

package com.shdsd.plugin.organizationPro.util.tx;     import com.atlassian.activeobjects.tx.Transactional; import com.atlassian.jira.transaction.Transaction; import com.atlassian.jira.transaction.Txn; import com.shdsd.plugin.organizationPro.util.AnnotationUtil; import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation;   import java.lang.annotation.Annotation; import java.lang.reflect.InvocationTargetException;   public final class TransactionalInterceptor implements MethodInterceptor {     public static final Class<? extends Annotation> ANNOTATION_CLASS = Transactional.class;       @Override     public Object invoke(MethodInvocation invocation) throws Throwable {         if (AnnotationUtil.isAnnotated(ANNOTATION_CLASS, invocation.getMethod())) {             return executeInTransaction(invocation);         } else {             return invocation.proceed();         }     }       private Object executeInTransaction(MethodInvocation invocation) throws Throwable {         Transaction transaction = Txn.begin();         try {             Object result = invocation.proceed();               transaction.commit();               return result;         } catch (InvocationTargetException e) {             throw e.getTargetException();         } finally {             transaction.finallyRollbackIfNotCommitted();         }     } }

 

TransactionalAnnotationProcessor 折叠源码

1 2 3 4 5 6 7 8 9 10 11

package com.shdsd.plugin.organizationPro.util.tx;   import com.shdsd.plugin.organizationPro.util.spring.ProxiedBeanPostProcessor; import org.springframework.stereotype.Component;   @Component public final class TransactionalAnnotationProcessor extends ProxiedBeanPostProcessor {     public TransactionalAnnotationProcessor() {         super(TransactionalInterceptor.ANNOTATION_CLASS, new TransactionalInterceptor());     } }

然后，就可以在service的方法上使用@Transactional注解了

 

 

 

 

react页面js不用加AJS.params.loggedInUser判断了，统一后台加，并且登录后会自动跳转