工厂模式小小心得

梦里梦外; 2022-06-16 01:50 147阅读 0赞

面向接口而非实现编程

### 接口和抽象类的区别 ###

1、接口中定义的方法访问权限自动被声明为public，也只能为public。

2、抽象类可以不用实现接口中的方法

3、一个子类只能继承一个父类，但可以实现多个接口

4、抽象类中可以拥有自己的成员变量和非抽象的方法，接口中只能存在常量和抽象方法。

5、抽象类是"is-a"关系，接口是"has-a"关系，通过接口与抽象类实现多态。

//如果一个行为比较模糊，就设计为接口;而门的开关是确定的功能，设计为接口和抽象类都可以
    abstract Class Door{
        void open();
        void close();
    }
    interface Alarm{
        void alarm();
    }
    Class AlarmDoor extends Door implements Alarm{
        void open(){}
        void close(){}
        void alarm(){}
    }

### 简单工厂(静态工厂) ###

三种实现方式

//简单工厂第一种方式获取执行策略
    public class DisruptorStrategyFactory {
    
        private static IBusinessStrategy getStrategy(String messageType) {
            if (SECONDHAND_CAR.equals(messageType)) {
                return new SecondhandCarEstimateStrategy();
            } else if (LOAN_CONFIRM.equals(messageType)) {
                return new LoanConfirmSuccessStrategy();
            } else if (MESSAGETYPE_MAIL_LOG.equals(messageType)) {
                return new WebsiteMailStrategy();
            } else if (CAR_PROCESS_LOG.equals(messageType)) {
                return new CarApproveStrategy();
            } else if (PUSH_MSG_2_CLS_APP.equals(messageType)) {
                return new PushMsg2ClsAppStrategy();
            }
            return null;
        }
    
        //静态方法，所以也叫静态工厂
        public static IBusinessStrategy getStrategyInstance(String messageType) throws Exception {
            return getStrategy(messageType);
        }
    
    }

//简单工厂第二种方式，获取执行策略
    public class DisruptorStrategyFactory {
        private static final Map<String, IBusinessStrategy> strategyMap = new HashMap<>();
        static {
            strategyMap.put(SECONDHAND_CAR, new SecondhandCarEstimateStrategy());
            strategyMap.put(LOAN_CONFIRM, new LoanConfirmSuccessStrategy());
            strategyMap.put(MESSAGETYPE_MAIL_LOG, new WebsiteMailStrategy());
            strategyMap.put(CAR_PROCESS_LOG, new CarApproveStrategy());
            strategyMap.put(PUSH_MSG_2_CLS_APP, new PushMsg2ClsAppStrategy());
    
        }
    
        public static IBusinessStrategy getStrategyInstance(String messageType) throws Exception {
            return strategyMap.get(messageType);
        }
    
    }

//简单工厂第三种方式，获取执行策略
    public class DisruptorStrategyFactory {
        
        //每种strategy都注入到bean容器中（名字要按照规律来取），取的时候直接取
        public static IBusinessStrategy getStrategyInstance(String messageType) throws Exception {
            CarApproveStrategy carApproveStrategy = (CarApproveStrategy) SpringBeanUtil.getBean(messageType+"Strategy")
            return CarApproveStrategy;
        }
    
    }

简单工厂虽然有多处if/else判断，违背了开闭原则，但这样的代码在大多数情况下不需要改动，也是可以接受的。

### 工厂方法 ###

为每种Strategy创建一个工厂，这种方式反而让代码更复杂了。

### 抽象工厂模式 ###

![Center][]

抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。应对产品族概念而生，增加新的产品线很容易，但是如果要增加新的产品却很难。

参考：[http://www.cnblogs.com/java-my-life/archive/2012/03/28/2418836.html][http_www.cnblogs.com_java-my-life_archive_2012_03_28_2418836.html]

### 应用 ###

public interface LoanTask {
    	/**
    	 * 发送消息使用
    	 */
    	 static String MESSAGE_STATUS = "MESSAGE_STATUS";
    	
    	 void doSomething();
    }

public class AbstractLoanTask implements LoanTask {
    	private Logger logger = Logger.getLogger(AbstractLoanTask.class);
    	public Thread task = new Thread("Task") {
    
    		private boolean isRun = true;
    
    		@Override
    		public void run() {
    			while (isRun) {
    				logger.debug(this.getName() + " Running!");
    				doLoan();
    			}
    		}
    
    		public void stopThread() {
    			isRun = false;
    		}
    
    	};
    
    	public AbstractLoanTask() {
    		task.start();
    		logger.debug("线程启动！");
    	}
    
    	@Override
    	public void doSomething() {
    		logger.debug("AbstractTask开始");
    	}
    }

public class UserTask extends AbstractLoanTask {
        private Logger logger = Logger.getLogger(UserTask.class);
    
        public UserTask() {
            super();
            task.setName("UserTask");
        }
        @Override
        public void doSomething() {
    	logger.debug("--------userTask executing----------");
        }   
    }

public class NoticeTask extends AbstractLoanTask {
    	private Logger logger = Logger.getLogger(NoticeTask.class);
    
    	public NoticeTask() {
    		super();
    		task.setName("NoticeTask");
    	}
    
    	@Override
    	public void doSomething() {
    		logger.debug("--------noticeTask executing----------");
    	}
    }

[Center]: /images/20220616/f71cf23cbe2246a49becbec7d7626f5d.png
[http_www.cnblogs.com_java-my-life_archive_2012_03_28_2418836.html]: http://www.cnblogs.com/java-my-life/archive/2012/03/28/2418836.html