Java使用builder模式+注解实现命令模式

业务场景：

　　项目中需要对数据进行异步分发推送，由于业务类型比较多，又考虑到不能影响现有的功能和代码耦合问题，所以考虑了一下设计模式；

好处：代码耦合度低，便于命令集的管理以及统一事件的处理，异步执行，不影响原有的业务；

缺点：没有考虑线程池的策略问题，需要自己定义（可以考虑如果线程达到最大限度后由原有的线程处理自己的业务或是加入队列机制、开启新的线程去监听队列并执行）

 

1、新建注解类

package com.test.util.Broker;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface CommandBroker {
    BrokerFactory.CommandEnum command() default BrokerFactory.CommandEnum.NONE; 
}

2、新建BrokerFactory类

package com.test.util.Broker;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Method;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BrokerFactory {
    private final static Logger logger = LoggerFactory.getLogger(BrokerFactory.class);
    ThreadLocal<TaskCommand>  local= new ThreadLocal<TaskCommand> ();
    static ExecutorService executor = Executors.newCachedThreadPool();
    private BrokerFactory(){}
    
    /**
     * 支持的哪些命令
     * @author Administrator
     *
     */
    public static enum CommandEnum{
        TEST1,TEST2,TEST3,NONE;
    }
    /**
     * 单例模式
     * @author Administrator
     *
     */
    static enum BrokerFactoryEnum{
        INSTANCE;
        private BrokerFactory brokerFactory;
        private BrokerFactoryEnum(){
            brokerFactory = new BrokerFactory();
        }
        public BrokerFactory get(){
            return brokerFactory;
        }
    }
    
    public static BrokerFactory buildBroker(){
        return BrokerFactoryEnum.INSTANCE.get();
    }
    
    public static void shutDownTask(){
        try {
            if(!executor.isTerminated()){
                executor.shutdown();
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    //创建命令
    public BrokerFactory builderCommand(BrokerFactory.CommandEnum comd){
        TaskCommand b = new Broker();
        b.comd=comd;
        local.set(b);
        return this;
    }
    //设置参数
    public BrokerFactory params(Object obj){
        TaskCommand comm= local.get();
        if(comm == null){
            throw new RuntimeException("先执行builderCommand方法");
        }
        comm.params(obj);
        local.set(comm);
        return this;
    }

    /**
     * 设置回调
     * @param call
     * @return
     */
    public BrokerFactory call(TaskCommand.BackCall call){
        TaskCommand comm= local.get();
        if(comm == null){
            throw new RuntimeException("先执行builderCommand方法");
        }
        comm.call=call;
        local.set(comm);
        return this;
    }

    //执行
    public void execute(){
        TaskCommand comm= local.get();
        if(comm == null){
            throw new RuntimeException("先执行builderCommand方法");
        }
        if(comm != null){
            executor.submit(new BrokerTask(comm));
        }
        local.remove();
    }
    
    public static abstract class TaskCommand {
        private Object paras;
        protected BrokerFactory.CommandEnum comd;
        public BackCall call;
        public final  void  execute(){
            Method[] declaredMethods = this.getClass().getDeclaredMethods();
            for(Method m : declaredMethods){
                try {
                    CommandBroker cb=m.getAnnotation(CommandBroker.class);
                    if(null != cb  && cb.command().equals(this.comd)){
                        if(null != m.getParameterTypes() && m.getParameterTypes().length>0){
                            throw new RuntimeException("不支持传入参数，可以从父类中获取params");
                        }
                        if (null == getParams()){
                            logger.info("###BrokerFactory执行参数为空...");
                            return ;
                        }
　　　　　　　　　　　　　　　　//这里可以加入统一的事件处理（执行前后通知或异常的处理，记录操作日志）
                        m.invoke(this);
                        if (null != call)
                            call.call(this);
                        return ;
                    }
                } catch (Exception e) {
                    logger.error("###BrokerFactory执行任务异常:{}",e.fillInStackTrace());
                }
            }
        }
        public final void params(Object paras){
            this.paras=paras;
        }
        public final Object getParams(){
            return this.paras;
        }
        //回调
        public interface BackCall{
            void call(TaskCommand command);
        }
    }
    
    private class BrokerTask implements Runnable{
        public TaskCommand command;
        public BrokerTask(TaskCommand command){
            this.command=command;
        }
        
        @Override
        public void run() {
            command.execute();
        }
    }161 }

3、新建Broker类

package com.test.util.Broker;

/**
 * 数据推送指令集
 * @author Administrator
 *
 */
public class Broker extends TaskCommand{ 49     /**
     * TEST1
     */
    @CommandBroker(command=BrokerFactory.CommandEnum.TEST1)
    public void test1Commander(){
　　　　　　　Object paras = getParams();//获取参数
        do something... 85     }
    /**
     * TEST2
     */
    @CommandBroker(command=BrokerFactory.CommandEnum.TEST2)
    public void test2Commander(){
　　　　　　　Object paras = getParams();
        do something...108     }

    /**
     * TEST3
     */
    @CommandBroker(command=BrokerFactory.CommandEnum.TEST3)
    public void test3Commander(){
　　　　　　Object paras = getParams();
      do something...197     }212 }

 

用法：

BrokerFactory.buildBroker()
        .builderCommand(BrokerFactory.CommandEnum.TEST1)
        .params("1").execute();
        
        BrokerFactory.buildBroker()
        .builderCommand(BrokerFactory.CommandEnum.TEST2)
        .params("1").execute();