设计模式 on F嘉阳

设计模式学习——行为型

Wed, 22 Jul 2020 16:50:17 +0800

模板方法模式

介绍

定义:定义了一个算法的骨架,并允许子类为一个或多个步骤提供实现

模板方法使得子类可以在不改变算法结构的情况下,重新定义算法的某些步骤

类型：行为型

适用场景

一次性实现一个算法的不变的部分,并将可变的行为留给子类来实现
各子类中公共的行为被提取出来并集中到一个公共父类中, 从而避免代码重复

优点

提高复用性
提高扩展性
符合开闭原则

缺点

类数目增加
增加了系统实现的复杂度
继承关系自身缺点,如果父类添加新的抽象方法,所有子类都要改一遍

分类和扩展

钩子方法
- 提供了默认的行为，子类可以在必要时进行扩展

相关设计模式

模板方法模式和工厂方法模式
- 工厂方法是模板方法的一种特殊实现
模板方法模式和策略模式
- 策略模式在于实现算法可以互相替换而不影响应用层，不改变算法流程
- 模板方法定义了一个算法的骨架，不明确的交给子类实现，可以改变算法流程

代码样例

类图

抽象课程

package top.fjy8018.designpattern.pattern.behavior.templatemethod;

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.mapping.MappedStatement;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Collection;

/**
 * 抽象课程
 * <p>
 * {@link java.util.AbstractList} 提供抽象List实现
 * 例如 {@link java.util.AbstractList#addAll(int, Collection)} 定义通过模板
 * {@link java.util.AbstractMap} 同理
 * <p>
 * {@link javax.servlet.http.HttpServlet#doGet(HttpServletRequest, HttpServletResponse)} 也是模板定义
 * {@link org.apache.ibatis.executor.BaseExecutor#doUpdate(MappedStatement, Object)} 等方法交由子类实现
 * 例如 {@link org.apache.ibatis.executor.SimpleExecutor#doUpdate(MappedStatement, Object)}
 *
 * @author F嘉阳
 * @date 2020/3/4 10:59
 */
@Slf4j
public abstract class ACourse {

 /**
 * 固定不变的行为
 * 定义模板，不允许子类覆盖，防止影响流程执行顺序
 */
 protected final void makeCourse() {
 this.makePPT();
 this.makeVideo();
 // 调用可选方法
 if (needWriteArticle()) {
 this.writeArticle();
 }
 this.packageCourse();
 }

 /**
 * 固定不变的行为
 * 满足所有子类需求
 */
 final void makePPT() {
 log.info("制作PPT");
 }

 final void makeVideo() {
 log.info("制作视频");
 }

 /**
 * 可选行为
 * <p>
 * 手记可写可不写，但写的手记的流程还是一致的，故也声明为final
 * 通过定义钩子方法，允许子类覆盖
 */
 final void writeArticle() {
 log.info("编写手记");
 }

 /**
 * 钩子方法，提供默认实现
 *
 * @return
 */
 protected boolean needWriteArticle() {
 return false;
 }

 /**
 * 必须实现的行为
 * 课程内容打包
 */
 abstract void packageCourse();
}

具体课程实现

package top.fjy8018.designpattern.pattern.behavior.templatemethod;

import lombok.extern.slf4j.Slf4j;

/**
 * 具体课程实现
 *
 * @author F嘉阳
 * @date 2020/3/4 11:05
 */
@Slf4j
public class JavaCourse extends ACourse {
 /**
 * 必须实现的行为
 * 课程内容打包
 */
 @Override
 void packageCourse() {
 log.info("提供Java学习课程源码");
 }
}

package top.fjy8018.designpattern.pattern.behavior.templatemethod;

import lombok.extern.slf4j.Slf4j;

/**
 * 具体课程实现
 * @author F嘉阳
 * @date 2020/3/4 11:06
 */
@Slf4j
public class VueCourse extends ACourse {

 private boolean needWriteArticleFlag = false;

 /**
 * 通过构造器开放给实例决定
 * @param needWriteArticleFlag
 */
 public VueCourse(boolean needWriteArticleFlag) {
 this.needWriteArticleFlag = needWriteArticleFlag;
 }

 /**
 * 必须实现的行为
 * 课程内容打包
 */
 @Override
 void packageCourse() {
 log.info("提供Vue学习课程源码");
 log.info("提供Vue学习课程多媒体素材");
 }

 /**
 * 钩子方法，提供默认实现
 *
 * @return
 */
 @Override
 protected boolean needWriteArticle() {
 return this.needWriteArticleFlag;
 }
}

测试

package top.fjy8018.designpattern.pattern.behavior.templatemethod;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * @author F嘉阳
 * @date 2020/3/4 11:08
 */
@Slf4j
class ACourseTest {

 @Test
 void makeJavaCourse() {
 ACourse javaCourse = new JavaCourse();
 javaCourse.makeCourse();
 }

 @Test
 void makeVueCourse() {
 ACourse vueCourse = new VueCourse(true);
 vueCourse.makeCourse();
 }
}

输出

11:27:56.942 [main] INFO top.fjy8018.designpattern.pattern.behavior.templatemethod.ACourse - 制作PPT
11:27:56.957 [main] INFO top.fjy8018.designpattern.pattern.behavior.templatemethod.ACourse - 制作视频
11:27:56.957 [main] INFO top.fjy8018.designpattern.pattern.behavior.templatemethod.JavaCourse - 提供Java学习课程源码


11:27:56.969 [main] INFO top.fjy8018.designpattern.pattern.behavior.templatemethod.ACourse - 制作PPT
11:27:56.969 [main] INFO top.fjy8018.designpattern.pattern.behavior.templatemethod.ACourse - 制作视频
11:27:56.969 [main] INFO top.fjy8018.designpattern.pattern.behavior.templatemethod.ACourse - 编写手记
11:27:56.969 [main] INFO top.fjy8018.designpattern.pattern.behavior.templatemethod.VueCourse - 提供Vue学习课程源码
11:27:56.969 [main] INFO top.fjy8018.designpattern.pattern.behavior.templatemethod.VueCourse - 提供Vue学习课程多媒体素材

迭代器模式

介绍

定义提供一种方法,顺序访问一个集合对象中的各个元素,而又不暴露该对象的内部表示

类型：行为型

适用场景

访问一个集合对象的内容而无需暴露它的内部表示
为遍历不同的集合结构提供一个统一的接口

优点

分离了集合对象的遍历行为

缺点

类的个数成对增加

相关设计模式

迭代器模式和访问者模式
- 访问者模式扩展开放的部分，再作用于对象的操作上
- 迭代器模式扩展开放的部分，再作用于对象的种类上

代码样例

迭代器一般使用现成的，而不会自己实现

类图

课程接口

package top.fjy8018.designpattern.pattern.behavior.iterator;

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * @author F嘉阳
 * @date 2020/3/4 14:49
 */
@AllArgsConstructor
@Getter
public class Course {

 private String name;

}

迭代器

package top.fjy8018.designpattern.pattern.behavior.iterator;

import java.util.ArrayList;

/**
 * JDK迭代器
 * {@link java.util.Iterator}
 * 集合内部类实现 {@link ArrayList.Itr#hasNext()}
 * 同时做了进一步扩展 {@link ArrayList.ListItr}
 *
 * mybatis中 {@link org.apache.ibatis.cursor.defaults.DefaultCursor}
 * 其持有游标迭代器对象 {@link org.apache.ibatis.cursor.defaults.DefaultCursor.CursorIterator}
 *
 * @author F嘉阳
 * @date 2020/3/4 14:49
 */
public interface CourseIterator {

 /**
 * 获取下一个课程
 *
 * @return
 */
 Course nextCourse();

 /**
 * 是否是最后一个课程
 * @return
 */
 boolean isLastCourse();
}

迭代器实现

package top.fjy8018.designpattern.pattern.behavior.iterator;

import lombok.extern.slf4j.Slf4j;

import java.util.List;

/**
 * @author F嘉阳
 * @date 2020/3/4 14:50
 */
@Slf4j
public class CourseIteratorImpl implements CourseIterator {

 private List courseList;

 private int position;

 private Course course;

 public CourseIteratorImpl(List courseList){
 this.courseList=courseList;
 }

 @Override
 public Course nextCourse() {
 log.info("返回课程,位置是: {}",position);
 course=(Course)courseList.get(position);
 position++;
 return course;
 }

 @Override
 public boolean isLastCourse(){
 if(position< courseList.size()){
 return false;
 }
 return true;
 }
}

对课程进行处理

package top.fjy8018.designpattern.pattern.behavior.iterator;

/**
 * 对课程进行处理
 *
 * @author F嘉阳
 * @date 2020/3/4 14:48
 */
public interface CourseAggregate {

 void addCourse(Course course);

 void removeCourse(Course course);

 /**
 * 获取课程迭代器
 * @return
 */
 CourseIterator getCourseIterator();
}

实现

package top.fjy8018.designpattern.pattern.behavior.iterator;

import java.util.ArrayList;
import java.util.List;

/**
 * @author F嘉阳
 * @date 2020/3/4 14:50
 */
public class CourseAggregateImpl implements CourseAggregate {

 private List courseList;

 public CourseAggregateImpl() {
 this.courseList = new ArrayList();
 }

 @Override
 public void addCourse(Course course) {
 courseList.add(course);
 }

 @Override
 public void removeCourse(Course course) {
 courseList.remove(course);
 }

 @Override
 public CourseIterator getCourseIterator() {
 return new CourseIteratorImpl(courseList);
 }
}

测试

package top.fjy8018.designpattern.pattern.behavior.iterator;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * @author F嘉阳
 * @date 2020/3/4 14:52
 */
@Slf4j
class CourseIteratorTest {

 @Test
 void nextCourse() {
 Course course1 = new Course("Java电商一期");
 Course course2 = new Course("Java电商二期");
 Course course3 = new Course("Java设计模式精讲");
 Course course4 = new Course("Python课程");
 Course course5 = new Course("算法课程");
 Course course6 = new Course("前端课程");


 CourseAggregate courseAggregate = new CourseAggregateImpl();

 courseAggregate.addCourse(course1);
 courseAggregate.addCourse(course2);
 courseAggregate.addCourse(course3);
 courseAggregate.addCourse(course4);
 courseAggregate.addCourse(course5);
 courseAggregate.addCourse(course6);

 log.info("-----课程列表-----");
 printCourses(courseAggregate);

 courseAggregate.removeCourse(course4);
 courseAggregate.removeCourse(course5);

 log.info("-----删除操作之后的课程列表-----");
 printCourses(courseAggregate);
 }

 public static void printCourses(CourseAggregate courseAggregate){
 CourseIterator courseIterator= courseAggregate.getCourseIterator();
 while(!courseIterator.isLastCourse()){
 Course course=courseIterator.nextCourse();
 log.info(course.getName());
 }
 }
}

输出

15:18:23.089 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorTest - -----课程列表-----
15:18:23.124 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorImpl - 返回课程,位置是: 0
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorTest - Java分布式
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorImpl - 返回课程,位置是: 1
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorTest - Java系统设计
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorImpl - 返回课程,位置是: 2
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorTest - Java设计模式精讲
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorImpl - 返回课程,位置是: 3
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorTest - Python课程
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorImpl - 返回课程,位置是: 4
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorTest - 算法课程
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorImpl - 返回课程,位置是: 5
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorTest - 前端课程
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorTest - -----删除操作之后的课程列表-----
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorImpl - 返回课程,位置是: 0
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorTest - Java分布式
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorImpl - 返回课程,位置是: 1
15:18:23.126 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorTest - Java系统设计
15:18:23.127 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorImpl - 返回课程,位置是: 2
15:18:23.127 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorTest - Java设计模式精讲
15:18:23.132 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorImpl - 返回课程,位置是: 3
15:18:23.132 [main] INFO top.fjy8018.designpattern.pattern.behavior.iterator.CourseIteratorTest - 前端课程

策略模式

介绍

定义：定义了算法家族,分别封装起来,让它们之间可以互相替换, 此模式让算法的变化不会影响到使用算法的用户。

例如有大量if…else的情况

类型：行为型

适用场景

系统有很多类，而他们的区别仅仅在于他们的行为不同
一个系统需要动态地在几种算法中选择一种

优点

开闭原则
避免使用多重条件转移语句
提高算法的保密性和安全性

缺点

客户端必须知道所有的策略类,并自行决定使用哪一个策略类。
产生很多策略类

相关设计模式

策略模式和工厂模式
策略模式和状态模式

代码样例

改造前——初级策略模式

无法避免if…else

类图

促销接口

package top.fjy8018.designpattern.pattern.behavior.strategy;

/**
 * 促销接口
 *
 * @author F嘉阳
 * @date 2020/3/4 15:37
 */
public interface PromotionStrategy {

 void doPromotion();
}

满减促销策略

package top.fjy8018.designpattern.pattern.behavior.strategy;

import lombok.extern.slf4j.Slf4j;

/**
 * 满减促销策略
 *
 * @author F嘉阳
 * @date 2020/3/4 15:38
 */
@Slf4j
public class ManJianPromotionStrategy implements PromotionStrategy {
 @Override
 public void doPromotion() {
 log.info("满减促销，满200-20");
 }
}

立减促销策略

package top.fjy8018.designpattern.pattern.behavior.strategy;

import lombok.extern.slf4j.Slf4j;

/**
 * 立减促销策略
 *
 * @author F嘉阳
 * @date 2020/3/4 15:39
 */
@Slf4j
public class LiJianPromotionStrategy implements PromotionStrategy{
 @Override
 public void doPromotion() {
 log.info("立减促销，课程价格直接减去配置的价格");
 }
}

返现促销策略

package top.fjy8018.designpattern.pattern.behavior.strategy;

import lombok.extern.slf4j.Slf4j;

/**
 * 返现促销策略
 *
 * @author F嘉阳
 * @date 2020/3/4 15:38
 */
@Slf4j
public class FanXianPromotionStrategy implements PromotionStrategy{
 @Override
 public void doPromotion() {
 log.info("返现促销，返回金额存放到用户余额中");
 }
}

测试

package top.fjy8018.designpattern.pattern.behavior.strategy;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * @author F嘉阳
 * @date 2020/3/4 15:46
 */
@Slf4j
class PromotionStrategyTest {

 @Test
 void existIfElse() {
 String promotionKey = "LIJIAN";
 PromotionActivity activity = null;
 if (StringUtils.equals(promotionKey,"LIJIAN")){
 // 方法和类本身线程安全
 activity= new PromotionActivity(new LiJianPromotionStrategy());
 }else if(StringUtils.equals(promotionKey,"MANJIAN")){
 activity = new PromotionActivity(new FanXianPromotionStrategy());
 }

 activity.executePromotionStrategy();
 }
}

输出

16:08:28.582 [main] INFO top.fjy8018.designpattern.pattern.behavior.strategy.LiJianPromotionStrategy - 立减促销，课程价格直接减去配置的价格

改造后——结合工厂和策略模式

类图

空促销策略

package top.fjy8018.designpattern.pattern.behavior.strategy;

import lombok.extern.slf4j.Slf4j;

/**
 * 空策略
 *
 * @author F嘉阳
 * @date 2020/3/4 16:16
 */
@Slf4j
public class EmptyPromotionStrategy implements PromotionStrategy {
 @Override
 public void doPromotion() {
 log.info("空促销策略");
 }
}

促销策略工厂

package top.fjy8018.designpattern.pattern.behavior.strategy;

import org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory;
import org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy;
import org.springframework.beans.factory.support.SimpleInstantiationStrategy;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.PathResource;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 促销策略工厂
 * <p>
 * {@link java.util.Comparator} 比较器，类似于抽象策略，有大量实现类，所有具体策略都要实现定义好的接口方法
 * 例如 {@link com.google.common.collect.ExplicitOrdering}
 * 应用层可以逐级传递比较器 {@link Arrays#sort(Object[], Comparator)}
 * {@link java.util.TreeMap#compare(Object, Object)} 利用内部的比较器处理
 * <p>
 * Spring资源策略抽象 {@link org.springframework.core.io.Resource}
 * 提供大量策略实现 {@link PathResource} {@link FileSystemResource}
 * <p>
 * {@link org.springframework.beans.factory.support.InstantiationStrategy} 初始化策略接口
 * 初始化具体策略实现 {@link SimpleInstantiationStrategy} {@link CglibSubclassingInstantiationStrategy}
 * 初始化策略在 {@link AbstractAutowireCapableBeanFactory} 中被使用
 *
 * @author F嘉阳
 * @date 2020/3/4 16:09
 */
public class PromotionStrategyFactory {

 private static Map<String, PromotionStrategy> STRATEGY_MAP = new ConcurrentHashMap<>();

 /**
 * 无促销
 */
 private static final PromotionStrategy NON_PROMOTION = new EmptyPromotionStrategy();

 static {
 STRATEGY_MAP.put(PromotionKey.FANXIAN, new FanXianPromotionStrategy());
 STRATEGY_MAP.put(PromotionKey.MANJIAN, new ManJianPromotionStrategy());
 STRATEGY_MAP.put(PromotionKey.LIJIAN, new LiJianPromotionStrategy());
 }

 /**
 * 禁止实例化
 */
 private PromotionStrategyFactory() {
 }

 /**
 * 开放获取策略的方法
 *
 * @param promotionKey
 * @return
 */
 public static PromotionStrategy getPromotionStrategy(String promotionKey) {
 PromotionStrategy strategy = STRATEGY_MAP.get(promotionKey);
 return strategy == null ? NON_PROMOTION : strategy;
 }

 /**
 * 常量定义
 */
 private interface PromotionKey {
 String LIJIAN = "LIJIAN";
 String FANXIAN = "FANXIAN";
 String MANJIAN = "MANJIAN";
 }
}

测试

package top.fjy8018.designpattern.pattern.behavior.strategy;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.junit.jupiter.api.Test;

/**
 * @author F嘉阳
 * @date 2020/3/4 15:46
 */
@Slf4j
class PromotionStrategyTest {

 @Test
 void nonIfElse() {
 String promotionKey = "LIJIAN";
 PromotionActivity activity = new PromotionActivity(PromotionStrategyFactory.getPromotionStrategy(promotionKey));
 activity.executePromotionStrategy();
 }
}

输出

16:08:28.582 [main] INFO top.fjy8018.designpattern.pattern.behavior.strategy.LiJianPromotionStrategy - 立减促销，课程价格直接减去配置的价格

解释器模式

介绍

定义：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
为了解释一种语言，而为语言创建的解释器
类型：行为型

适用场景（较少）

某个特定类型问题发生频率足够高

优点

语法由很多类表示,容易改变及扩展此语言

缺点

当语法规则数目太多时,增加了系统复杂度

相关设计模式

解释器模式和适配器模式

代码样例

类图

解释器

package top.fjy8018.designpattern.pattern.behavior.interpreter;

/**
 * 解释器
 * <p>
 * JDK 源码
 * {@link java.util.regex.Pattern} 正则解释器
 * {@link org.springframework.expression.spel.standard.SpelExpressionParser} Spring解释器
 *
 * @author F嘉阳
 * @date 2020/3/5 14:45
 */
public interface Interpreter {
 int interpret();
}

加法解释器

package top.fjy8018.designpattern.pattern.behavior.interpreter;

/**
 * 加法解释器
 *
 * @author F嘉阳
 * @date 2020/3/5 14:46
 */
public class AddInterpreter implements Interpreter {

 /**
 * 定义两个表达式
 */
 private Interpreter firstExpression, secondExpression;

 public AddInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
 this.firstExpression = firstExpression;
 this.secondExpression = secondExpression;
 }

 @Override
 public int interpret() {
 // 此时传入为NumberInterpreter类型，调interpret方法转int类型
 return this.firstExpression.interpret() + this.secondExpression.interpret();
 }

 @Override
 public String toString() {
 return "+";
 }
}

乘法解释器

package top.fjy8018.designpattern.pattern.behavior.interpreter;

/**
 * 乘法解释器
 *
 * @author F嘉阳
 * @date 2020/3/5 14:47
 */
public class MultiInterpreter implements Interpreter {

 private Interpreter firstExpression, secondExpression;

 public MultiInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
 this.firstExpression = firstExpression;
 this.secondExpression = secondExpression;
 }

 @Override
 public int interpret() {
 return this.firstExpression.interpret() * this.secondExpression.interpret();
 }

 @Override
 public String toString() {
 return "*";
 }
}

类型解释器

package top.fjy8018.designpattern.pattern.behavior.interpreter;

/**
 * @author F嘉阳
 * @date 2020/3/5 14:47
 */
public class NumberInterpreter implements Interpreter {
 private int number;

 public NumberInterpreter(int number) {
 this.number = number;
 }

 public NumberInterpreter(String number) {
 this.number = Integer.parseInt(number);
 }

 @Override
 public int interpret() {
 return this.number;
 }
}

操作工具类

package top.fjy8018.designpattern.pattern.behavior.interpreter;

/**
 * @author F嘉阳
 * @date 2020/3/5 14:47
 */
public class OperatorUtil {
 public static boolean isOperator(String symbol) {
 return (symbol.equals("+") || symbol.equals("*"));

 }

 public static Interpreter getExpressionObject(Interpreter firstExpression, Interpreter secondExpression, String symbol) {
 if (symbol.equals("+")) {
 return new AddInterpreter(firstExpression, secondExpression);
 } else if (symbol.equals("*")) {
 return new MultiInterpreter(firstExpression, secondExpression);
 }
 return null;
 }
}

自定义解释器实现

package top.fjy8018.designpattern.pattern.behavior.interpreter;

import lombok.extern.slf4j.Slf4j;

import java.util.Stack;

/**
 * @author F嘉阳
 * @date 2020/3/5 14:48
 */
@Slf4j
public class CustomExpressionParser {
 private Stack<Interpreter> stack = new Stack<Interpreter>();

 public int parse(String str) {
 String[] strItemArray = str.split(" ");
 for (String symbol : strItemArray) {
 if (!OperatorUtil.isOperator(symbol)) {
 Interpreter numberExpression = new NumberInterpreter(symbol);
 stack.push(numberExpression);
 log.info(String.format("入栈: %d", numberExpression.interpret()));
 } else {
 //是运算符号，可以计算
 Interpreter firstExpression = stack.pop();
 Interpreter secondExpression = stack.pop();
 log.info(String.format("出栈: %d 和 %d",
 firstExpression.interpret(), secondExpression.interpret()));
 Interpreter operator = OperatorUtil.getExpressionObject(firstExpression, secondExpression, symbol);
 log.info(String.format("应用运算符: %s", operator));
 int result = operator.interpret();
 NumberInterpreter resultExpression = new NumberInterpreter(result);
 stack.push(resultExpression);
 log.info(String.format("阶段结果入栈: %d", resultExpression.interpret()));
 }
 }
 int result = stack.pop().interpret();
 return result;

 }
}

测试

package top.fjy8018.designpattern.pattern.behavior.interpreter;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;

/**
 * @author F嘉阳
 * @date 2020/3/5 14:48
 */
@Slf4j
class InterpreterTest {

 @Test
 void interpret() {
 String myInterpreter = "6 100 11 + *";
 CustomExpressionParser expressionParser = new CustomExpressionParser();
 int result = expressionParser.parse(myInterpreter);
 log.info("解释器计算结果: " + result);
 }

 @Test
 void springTest() {
 org.springframework.expression.ExpressionParser parser = new SpelExpressionParser();
 Expression expression = parser.parseExpression("100 * 2 + 400 * 1 + 66");
 int result = (Integer) expression.getValue();
 log.info(String.valueOf(result));
 }
}

输出

14:52:28.086 [main] INFO top.fjy8018.designpattern.pattern.behavior.interpreter.GeelyExpressionParser - 入栈: 6
14:52:28.089 [main] INFO top.fjy8018.designpattern.pattern.behavior.interpreter.GeelyExpressionParser - 入栈: 100
14:52:28.089 [main] INFO top.fjy8018.designpattern.pattern.behavior.interpreter.GeelyExpressionParser - 入栈: 11
14:52:28.089 [main] INFO top.fjy8018.designpattern.pattern.behavior.interpreter.GeelyExpressionParser - 出栈: 11 和 100
14:52:28.090 [main] INFO top.fjy8018.designpattern.pattern.behavior.interpreter.GeelyExpressionParser - 应用运算符: +
14:52:28.090 [main] INFO top.fjy8018.designpattern.pattern.behavior.interpreter.GeelyExpressionParser - 阶段结果入栈: 111
14:52:28.090 [main] INFO top.fjy8018.designpattern.pattern.behavior.interpreter.GeelyExpressionParser - 出栈: 111 和 6
14:52:28.090 [main] INFO top.fjy8018.designpattern.pattern.behavior.interpreter.GeelyExpressionParser - 应用运算符: *
14:52:28.091 [main] INFO top.fjy8018.designpattern.pattern.behavior.interpreter.GeelyExpressionParser - 阶段结果入栈: 666
14:52:28.091 [main] INFO top.fjy8018.designpattern.pattern.behavior.interpreter.InterpreterTest - 解释器计算结果: 666


14:52:28.550 [main] INFO top.fjy8018.designpattern.pattern.behavior.interpreter.InterpreterTest - 666

观察者模式

介绍

定义：定义了对象之间的一对多依赖，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有依赖者（观察者）都会收到通知并更新

类型：行为型

适用场景

关联行为场景，建立一套触发机制

优点

观察者模式支持广播通信
观察者和被观察者之间建立一个抽象的耦合

缺点

使用要得当,要避免循环调用
观察者之间有过多的细节依赖、提高时间消耗及程序复杂度

代码样例——JDK观察者

类图

课程问题

package top.fjy8018.designpattern.pattern.behavior.observer;

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * 课程问题
 *
 * @author F嘉阳
 * @date 2020/3/5 15:23
 */
@Getter
@AllArgsConstructor
public class Question {

 private String username;

 private String content;

}

课程（被观察者）

package top.fjy8018.designpattern.pattern.behavior.observer;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.util.EventListener;
import java.util.Observable;
import java.util.Vector;

/**
 * 课程
 * 被观察者类
 *
 * {@link Observable} 使用 {@link Vector} 保证线程安全
 *
 * JDK源码
 * {@link java.awt.Event} 事件监听器
 * {@link javax.servlet.ServletRequestListener} HTTP请求事件监听器
 * 继承 {@link EventListener}，有大量实现，例如{@link org.springframework.beans.factory.parsing.ReaderEventListener}
 *
 * @author F嘉阳
 * @date 2020/3/5 15:23
 */
@Slf4j
@Getter
@AllArgsConstructor
public class Course extends Observable {

 private String courseName;

 /**
 * 产生问题
 * @param course
 * @param question
 */
 public void produceQuestion(Course course,Question question){
 log.info("{}在{}提交了一个问题",question.getUsername(),course.getCourseName());
 // 状态变化
 setChanged();
 // 通知观察者
 notifyObservers(question);
 }
}

老师实体（观察者）

package top.fjy8018.designpattern.pattern.behavior.observer;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.util.Observable;
import java.util.Observer;

/**
 * 老师实体
 *
 * 老师观察课程是否产生了新的问题
 * @author F嘉阳
 * @date 2020/3/5 15:24
 */
@Slf4j
@Getter
@AllArgsConstructor
public class Teacher implements Observer {

 private String teacherName;

 /**
 * This method is called whenever the observed object is changed. An
 * application calls an <tt>Observable</tt> object's
 * <code>notifyObservers</code> method to have all the object's
 * observers notified of the change.
 *
 * @param o the observable object.
 * @param arg an argument passed to the <code>notifyObservers</code>
 */
 @Override
 public void update(Observable o, Object arg) {
 Course course = (Course) o;
 Question question = (Question) arg;
 log.info("{}老师的{}课程接收到一个{}提交的问题，内容为：{}",
 teacherName,course.getCourseName(),question.getUsername(),question.getContent());
 }
}

测试

package top.fjy8018.designpattern.pattern.behavior.observer;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * @author F嘉阳
 * @date 2020/3/5 15:36
 */
@Slf4j
class TeacherTest {

 @Test
 void update() {
 Course course = new Course("Java设计模式");
 Teacher teacher = new Teacher("fjy8018");

 course.addObserver(teacher);

 // 业务逻辑
 Question question = new Question("fjy","问题内容XXX");

 course.produceQuestion(course,question);
 }
}

输出

15:38:34.437 [main] INFO top.fjy8018.designpattern.pattern.behavior.observer.Course - fjy在Java设计模式提交了一个问题
15:38:34.444 [main] INFO top.fjy8018.designpattern.pattern.behavior.observer.Teacher - fjy8018老师的Java设计模式课程接收到一个fjy提交的问题，内容为：问题内容XXX

代码样例——Guava监听器

package top.fjy8018.designpattern.pattern.behavior.observer.guava;

import com.google.common.eventbus.Subscribe;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * Guava事件监听器
 * {@link EventBus} 使用内部对象 {@link SubscriberRegistry} 内部使用 {@link ConcurrentMap} 存储订阅者
 * 同时使用 {@link CopyOnWriteArraySet} 保证线程安全和订阅者唯一
 * 故{@link com.google.common.eventbus.Subscriber}
 * 重写了 {@link com.google.common.eventbus.Subscriber#equals(Object)}
 * 和 {@link com.google.common.eventbus.Subscriber#hashCode()} 方法
 *
 * @author F嘉阳
 * @date 2020/3/5 15:56
 */
@Slf4j
public class GuavaEvent {

 @Subscribe
 public void subscribe(String str) {
 // 业务逻辑
 log.info("执行订阅方法，传入参数是：{}", str);
 }
}

测试

package top.fjy8018.designpattern.pattern.behavior.observer;

import com.google.common.eventbus.EventBus;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import top.fjy8018.designpattern.pattern.behavior.observer.guava.Course;
import top.fjy8018.designpattern.pattern.behavior.observer.guava.GuavaEvent;

/**
 * @author F嘉阳
 * @date 2020/3/5 15:58
 */
@Slf4j
class GuavaEventTest {

 @Test
 void subscribe() {
 EventBus eventBus = new EventBus();
 GuavaEvent event = new GuavaEvent();
 // 注册
 eventBus.register(event);
 eventBus.post("提交事件的内容");
 }
}

输出

16:24:27.716 [main] INFO top.fjy8018.designpattern.pattern.behavior.observer.GuavaEvent - 执行订阅方法，传入参数是：提交事件的内容

备忘录模式

介绍

定义：保存一个对象的某个状态，以便在适当的时候恢复对象。（类似历史记录存储）

“后悔药”

类型：行为型

适用场景

保存及恢复数据相关业务场景
后悔的时候，即想恢复到之前的状态

优点

为用户提供一种可恢复机制
存档信息的封装

缺点

资源占用

相关设计模式

备忘录模式和状态模式

代码样例

类图

文章

package top.fjy8018.designpattern.pattern.behavior.memento;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * 文章，字段不宜过多，否则导致过大内存占用
 *
 * @author F嘉阳
 * @date 2020/3/6 17:00
 */
@Data
@AllArgsConstructor
public class Article {

 private String title;

 private String content;

 private String imgs;

 /**
 * 保存
 * @return
 */
 public ArticleMemento saveToMemento() {
 ArticleMemento articleMemento = new ArticleMemento(this.title,this.content,this.imgs);
 return articleMemento;
 }

 /**
 * 撤销
 * @param articleMemento
 */
 public void undoFromMemento(ArticleMemento articleMemento) {
 this.title = articleMemento.getTitle();
 this.content = articleMemento.getContent();
 this.imgs = articleMemento.getImgs();
 }
}

文章备忘录（快照）

package top.fjy8018.designpattern.pattern.behavior.memento;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.ToString;
import org.springframework.binding.message.StateManageableMessageContext;

/**
 * 文章备忘录（快照）
 * 快照不需要set方法，只能通过构造器注入
 *
 * Spring工作流中源码 {@link StateManageableMessageContext#createMessagesMemento()}
 *
 * @author F嘉阳
 * @date 2020/3/6 17:03
 */
@Getter
@ToString
@AllArgsConstructor
public class ArticleMemento {

 private String title;

 private String content;

 private String imgs;
}

备忘录核心，栈实现管理者

package top.fjy8018.designpattern.pattern.behavior.memento;

import java.util.Stack;

/**
 * 保存一个对象的某个状态，以便在适当的时候恢复对象
 *
 * @author F嘉阳
 * @date 2020/3/6 17:04
 */
public class ArticleMementoManager {

 /**
 * 使用栈特性实现动作撤销
 */
 private final Stack<ArticleMemento> ARTICLE_MEMENTO_STACK = new Stack<ArticleMemento>();

 public ArticleMemento getMemento() {
 ArticleMemento articleMemento= ARTICLE_MEMENTO_STACK.pop();
 return articleMemento;
 }

 public void addMemento(ArticleMemento articleMemento)
 {
 ARTICLE_MEMENTO_STACK.push(articleMemento);
 }
}

测试

package top.fjy8018.designpattern.pattern.behavior.memento;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

/**
 * @author F嘉阳
 * @date 2020/3/6 17:07
 */
@Slf4j
class ArticleMementoTest {

 @Test
 void getTitle() {
 ArticleMementoManager articleMementoManager = new ArticleMementoManager();

 Article article= new Article("如影随行的设计模式A","手记内容A","手记图片A");
 // 存档
 ArticleMemento articleMemento = article.saveToMemento();

 articleMementoManager.addMemento(articleMemento);
 log.info("标题:"+article.getTitle()+" 内容:"+article.getContent()+" 图片:"+article.getImgs()+" 暂存成功");

 log.info("手记完整信息:"+article);
 
 log.info("修改手记start");

 article.setTitle("如影随行的设计模式B");
 article.setContent("手记内容B");
 article.setImgs("手记图片B");

 log.info("修改手记end");

 log.info("手记完整信息:"+article);

 articleMemento = article.saveToMemento();
 articleMementoManager.addMemento(articleMemento);
 
 article.setTitle("如影随行的设计模式C");
 article.setContent("手记内容C");
 article.setImgs("手记图片C");

 log.info("暂存回退start");
 // 取档
 log.info("回退出栈1次");
 articleMemento = articleMementoManager.getMemento();
 article.undoFromMemento(articleMemento);

 log.info("回退出栈2次");
 articleMemento = articleMementoManager.getMemento();
 article.undoFromMemento(articleMemento);

 log.info("暂存回退end");
 log.info("手记完整信息:"+article);
 }
}

输出

17:33:51.154 [main] INFO top.fjy8018.designpattern.pattern.behavior.memento.ArticleMementoTest - 标题:如影随行的设计模式A 内容:手记内容A 图片:手记图片A 暂存成功
17:33:51.169 [main] INFO top.fjy8018.designpattern.pattern.behavior.memento.ArticleMementoTest - 手记完整信息:Article(title=如影随行的设计模式A, content=手记内容A, imgs=手记图片A)
17:33:51.169 [main] INFO top.fjy8018.designpattern.pattern.behavior.memento.ArticleMementoTest - 修改手记start
17:33:51.169 [main] INFO top.fjy8018.designpattern.pattern.behavior.memento.ArticleMementoTest - 修改手记end
17:33:51.169 [main] INFO top.fjy8018.designpattern.pattern.behavior.memento.ArticleMementoTest - 手记完整信息:Article(title=如影随行的设计模式B, content=手记内容B, imgs=手记图片B)
17:33:51.169 [main] INFO top.fjy8018.designpattern.pattern.behavior.memento.ArticleMementoTest - 暂存回退start
17:33:51.169 [main] INFO top.fjy8018.designpattern.pattern.behavior.memento.ArticleMementoTest - 回退出栈1次
17:33:51.169 [main] INFO top.fjy8018.designpattern.pattern.behavior.memento.ArticleMementoTest - 回退出栈2次
17:33:51.169 [main] INFO top.fjy8018.designpattern.pattern.behavior.memento.ArticleMementoTest - 暂存回退end
17:33:51.169 [main] INFO top.fjy8018.designpattern.pattern.behavior.memento.ArticleMementoTest - 手记完整信息:Article(title=如影随行的设计模式A, content=手记内容A, imgs=手记图片A)

命令模式

介绍

定义：将请求封装成对象,以便使用不同的请求

特点：命令模式解决了应用程序中对象的职责以及它们之间的通信方式

类型：行为型

适用场景

请求调用者和请求接收者需要解耦,使得调用者和接收者不直接交互
需要抽象出等待执行的行为

优点

降低耦合
容易扩展新命令或者一组命令

缺点

命令的无限扩展会增加类的数量，提高系统实现复杂度

相关设计模式

命令模式和备忘录模式

代码样例

类图

命令抽象

package top.fjy8018.designpattern.pattern.behavior.command;

/**
 * 命令抽象
 * <p>
 * Java相关源码 {@link Runnable} 可理解为命令抽象
 * 其实现类为具体的命令
 *
 * @author F嘉阳
 * @date 2020/7/21 15:58
 */
public interface Command {
 void execute();
}

操作视频

package top.fjy8018.designpattern.pattern.behavior.command;

import lombok.AllArgsConstructor;

/**
 * 关闭视频命令
 *
 * @author F嘉阳
 * @date 2020/7/21 15:58
 */
@AllArgsConstructor
public class CloseCourseVideoCommand implements Command {
 private final CourseVideo courseVideo;

 @Override
 public void execute() {
 courseVideo.close();
 }
}

打开视频命令

package top.fjy8018.designpattern.pattern.behavior.command;

import lombok.AllArgsConstructor;

/**
 * 打开视频命令
 *
 * @author F嘉阳
 * @date 2020/7/21 15:58
 */
@AllArgsConstructor
public class OpenCourseVideoCommand implements Command {
 private final CourseVideo courseVideo;

 @Override
 public void execute() {
 courseVideo.open();
 }
}

关闭视频命令

package top.fjy8018.designpattern.pattern.behavior.command;

import lombok.AllArgsConstructor;

/**
 * 关闭视频命令
 *
 * @author F嘉阳
 * @date 2020/7/21 15:58
 */
@AllArgsConstructor
public class CloseCourseVideoCommand implements Command {
 private final CourseVideo courseVideo;

 @Override
 public void execute() {
 courseVideo.close();
 }
}

命令执行人

package top.fjy8018.designpattern.pattern.behavior.command;

import java.util.ArrayList;
import java.util.List;

/**
 * 命令执行人
 *
 * @author F嘉阳
 * @date 2020/7/21 15:58
 */
public class Staff {
 /**
 * 保证执行顺序
 */
 private final List<Command> commandList = new ArrayList<Command>();

 public void addCommand(Command command) {
 commandList.add(command);
 }

 public void executeCommands() {
 for (Command command : commandList) {
 command.execute();
 }
 commandList.clear();
 }

}

测试

package top.fjy8018.designpattern.pattern.behavior.command;

import org.junit.jupiter.api.Test;

/**
 * @author F嘉阳
 * @date 2020/7/21 16:02
 */
class CommandTest {

 @Test
 void doTest() {
 CourseVideo courseVideo = new CourseVideo("Java设计模式精讲");
 OpenCourseVideoCommand openCourseVideoCommand = new OpenCourseVideoCommand(courseVideo);
 CloseCourseVideoCommand closeCourseVideoCommand = new CloseCourseVideoCommand(courseVideo);

 Staff staff = new Staff();

 staff.addCommand(openCourseVideoCommand);
 staff.addCommand(closeCourseVideoCommand);

 staff.executeCommands();
 }
}

输出

Java设计模式精讲课程视频开放
Java设计模式精讲课程视频关闭

中介者模式

介绍

定义：定义一个封装一组对象如何交互的对象

特点：通过使对象明确地相互引用来促进松散耦合,并允许独立地改变它们的交互

适用场景

系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解
交互的公共行为，如果需要改变行为则可以增加新的中介者类

优点

将一对多转化成了一对一、降低程序复杂度
类之间解耦

缺点

中介者过多,导致系统复杂

相关设计模式

中介者模式和观察者模式

代码样例

类图

学习群组（中介者）

package top.fjy8018.designpattern.pattern.behavior.mediator;

import java.util.Date;
import java.util.Timer;

/**
 * 学习群组（中介者）
 * <p>
 * jdk源码 {@link Timer#schedule(java.util.TimerTask, Date)} 多个方法重载
 * 都是调用{@link Timer#sched(java.util.TimerTask, long, long)} 实现的，由底层方法进行整体协调
 *
 * @author F嘉阳
 * @date 2020/7/21 16:20
 */
public class StudyGroup {

 public static void showMessage(User user, String message) {
 System.out.println(new Date().toString() + " [" + user.getName() + "] : " + message);
 }
}

用户

package top.fjy8018.designpattern.pattern.behavior.mediator;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @author F嘉阳
 * @date 2020/7/21 16:20
 */
@Data
@AllArgsConstructor
public class User {
 private String name;

 public void sendMessage(String message) {
 // 只和中介者交互
 StudyGroup.showMessage(this, message);
 }
}

测试

package top.fjy8018.designpattern.pattern.behavior.mediator;

import org.junit.jupiter.api.Test;

/**
 * @author F嘉阳
 * @date 2020/7/21 16:25
 */
class MediatorTest {

 @Test
 void doTest() {
 User fjy = new User("F嘉阳");
 User tom = new User("Tom");

 fjy.sendMessage(" Hey! Tom! Let's learn Design Pattern");
 tom.sendMessage("OK! F嘉阳");
 }
}

输出

Tue Jul 21 16:47:03 CST 2020 [F嘉阳] : Hey! Tom! Let's learn Design Pattern
Tue Jul 21 16:47:03 CST 2020 [Tom] : OK! F嘉阳

责任链模式

介绍

定义：为请求创建一个接收此次请求对象的链

类型：行为型

适用场景

一个请求的处理需要多个对象当中的一个或几个协作处理

优点

请求的发送者和接收者(请求的处理)解耦
责任链可以动态组合

缺点

责任链太长或者处理时间过长,影响性能
责任链有可能过多

相关设计模式

责任链模式和状态模式

代码样例

类图

模拟二级审批场景

package top.fjy8018.designpattern.pattern.behavior.chainofresponsibility;

import javax.servlet.FilterChain;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

/**
 * 模拟二级审批场景
 * <p>
 * 审批抽象
 * <p>
 * java 过滤器实现 {@link javax.servlet.Filter#doFilter(ServletRequest, ServletResponse, FilterChain)}
 * 实现 {@link FilterChain#doFilter(ServletRequest, ServletResponse)} 接口的组成一条过滤器链
 * 所有子类通过调用 chain.doFilter(request, response) 实现链式传递
 * <p>
 * SpringSecurity过滤器链实现也类似
 *
 * @author F嘉阳
 * @date 2020/7/21 16:59
 */
public abstract class Approver {
 /**
 * 责任链核心：包含与自身相同的类型对象
 */
 protected Approver approver;

 /**
 * 设置下一个节点，组成链条
 *
 * @param approver
 */
 public void setNextApprover(Approver approver) {
 this.approver = approver;
 }

 /**
 * 交由子类实现
 *
 * @param course
 */
 public abstract void deploy(Course course);
}

手记审批

package top.fjy8018.designpattern.pattern.behavior.chainofresponsibility;

import org.apache.commons.lang3.StringUtils;

/**
 * 手记审批
 *
 * @author F嘉阳
 * @date 2020/7/21 16:59
 */
public class ArticleApprover extends Approver {
 @Override
 public void deploy(Course course) {
 if (StringUtils.isNotEmpty(course.getArticle())) {
 System.out.println(course.getName() + "含有手记,批准");
 // 是否为末尾
 if (approver != null) {
 // 执行下一个处理链
 approver.deploy(course);
 }
 } else {
 System.out.println(course.getName() + "不含有手记,不批准,流程结束");
 return;
 }
 }
}

视频审批

package top.fjy8018.designpattern.pattern.behavior.chainofresponsibility;

import org.apache.commons.lang3.StringUtils;

/**
 * 视频审批
 *
 * @author F嘉阳
 * @date 2020/7/21 16:59
 */
public class VideoApprover extends Approver {
 @Override
 public void deploy(Course course) {
 if (StringUtils.isNotEmpty(course.getVideo())) {
 System.out.println(course.getName() + "含有视频,批准");
 if (approver != null) {
 approver.deploy(course);
 }
 } else {
 System.out.println(course.getName() + "不含有视频,不批准,流程结束");
 return;
 }
 }
}

课程

package top.fjy8018.designpattern.pattern.behavior.chainofresponsibility;

import lombok.Data;

/**
 * 课程
 *
 * @author F嘉阳
 * @date 2020/7/21 16:59
 */
@Data
public class Course {
 private String name;

 private String article;

 private String video;
}

测试

package top.fjy8018.designpattern.pattern.behavior.chainofresponsibility;

import org.junit.jupiter.api.Test;

/**
 * @author F嘉阳
 * @date 2020/7/21 15:06
 */
class ChainofResponsibilityTest {

 @Test
 void doTest() {
 Approver articleApprover = new ArticleApprover();
 Approver videoApprover = new VideoApprover();

 Course course = new Course();
 course.setName("Java设计模式");
 course.setArticle("Java设计模式的手记");
 course.setVideo("Java设计模式的视频");

 articleApprover.setNextApprover(videoApprover);

 articleApprover.deploy(course);
 }
}

输出

Java设计模式含有手记,批准
Java设计模式含有视频,批准

访问者模式

介绍

定义：封装作用于某数据结构(如List/set/Map等)中的各元素的操作

特性：可以在不改变各元素的类的前提下定义作用于这些元素的操作

类型：行为型

适用场景

一个数据结构如(List/set/Map等)包含很多类型对象
数据结构与数据操作分离

优点

增加新的操作很容易即增加一个新的访问者

缺点

增加新的数据结构困难
具体元素变更比较麻烦

相关设计模式

访问者模式和迭代器模式

代码样例

类图

课程抽象

package top.fjy8018.designpattern.pattern.behavior.visitor;

import lombok.Data;

/**
 * @author F嘉阳
 * @date 2020/7/22 10:20
 */
@Data
public abstract class Course {
 private String name;

 public abstract void accept(IVisitor visitor);

}

实战课

package top.fjy8018.designpattern.pattern.behavior.visitor;

import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * 实战课，包含价格
 *
 * @author F嘉阳
 * @date 2020/7/22 10:20
 */
@Data
@EqualsAndHashCode(callSuper = true)
public class CodingCourse extends Course {
 private int price;

 @Override
 public void accept(IVisitor visitor) {
 visitor.visit(this);
 }
}

免费课

package top.fjy8018.designpattern.pattern.behavior.visitor;

/**
 * 免费课
 *
 * @author F嘉阳
 * @date 2020/7/22 10:20
 */
public class FreeCourse extends Course {

 /**
 * 接受策略
 *
 * @param visitor
 */
 @Override
 public void accept(IVisitor visitor) {
 visitor.visit(this);
 }
}

访问者

package top.fjy8018.designpattern.pattern.behavior.visitor;

/**
 * 封装操作数据结构的方法
 *
 * @author F嘉阳
 * @date 2020/7/22 10:20
 */
public interface IVisitor {

 void visit(FreeCourse freeCourse);

 void visit(CodingCourse codingCourse);
}

访问者核心实现

package top.fjy8018.designpattern.pattern.behavior.visitor;

/**
 * 访问者
 * 核心：对不同类型产生不同的操作行为
 * <p>
 * jdk源码 {@link java.nio.file.FileVisitor} 实现对文件的访问
 * spring源码 {@link org.springframework.beans.factory.config.BeanDefinitionVisitor} 遍历Bean具体属性并填充
 *
 * @author F嘉阳
 * @date 2020/7/22 10:20
 */
public class Visitor implements IVisitor {

 /**
 * 访问免费课程，打印所有免费课程名称
 *
 * @param freeCourse
 */
 @Override
 public void visit(FreeCourse freeCourse) {
 System.out.println("免费课程:" + freeCourse.getName());
 }

 /**
 * 访问实战课程，打印所有实战课程名称及价格
 *
 * @param codingCourse
 */
 @Override
 public void visit(CodingCourse codingCourse) {
 System.out.println("实战课程:" + codingCourse.getName() + " 价格:" + codingCourse.getPrice() + "元");
 }

}

测试

package top.fjy8018.designpattern.pattern.behavior.visitor;

import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @author F嘉阳
 * @date 2020/7/22 16:19
 */
class VisitorTest {

 @Test
 void visit() {
 List<Course> courseList = new ArrayList<>();

 FreeCourse freeCourse = new FreeCourse();
 freeCourse.setName("SpringMVC数据绑定");

 CodingCourse codingCourse = new CodingCourse();
 codingCourse.setName("Java设计模式精讲");
 codingCourse.setPrice(299);
 // 数组组装
 courseList.add(freeCourse);
 courseList.add(codingCourse);

 for (Course course : courseList) {
 course.accept(new Visitor());
 }
 }
}

输出

免费课程:SpringMVC数据绑定
实战课程:Java设计模式精讲 价格:299元

状态模式

介绍

定义：允许一个对象在其内部状态改变时改变它的行为

类型：行为型

适用场景

一个对象存在多个状态(不同状态下行为不同),且状态可相互转换

优点

将不同的状态隔离
把各种状态的转换逻辑,分布到 State的子类中,减少相互间依赖
增加新的状态非常简单

缺点

状态多的业务场景导致类数目增加,系统变复杂

相关设计模式

状态模式和享元模式

代码样例

类图

视频播放状态转换场景

package top.fjy8018.designpattern.pattern.behavior.state;

import javax.faces.lifecycle.Lifecycle;

/**
 * 视频播放状态转换场景
 * <p>
 * {@link Lifecycle#execute(javax.faces.context.FacesContext)} 该方法通过外部状态控制改变行为
 * {@link javax.faces.webapp.FacesServlet} 状态控制
 *
 * @author F嘉阳
 * @date 2020/7/22 15:20
 */
public abstract class CourseVideoState {
 /**
 * 视频上下文
 */
 protected CourseVideoContext courseVideoContext;

 public void setCourseVideoContext(CourseVideoContext courseVideoContext) {
 this.courseVideoContext = courseVideoContext;
 }

 public abstract void play();

 public abstract void speed();

 public abstract void pause();

 public abstract void stop();

}

视频上下文

package top.fjy8018.designpattern.pattern.behavior.state;

/**
 * 视频上下文
 *
 * @author F嘉阳
 * @date 2020/7/22 15:20
 */
public class CourseVideoContext {

 /**
 * 存储当前状态
 */
 private CourseVideoState courseVideoState;

 /**
 * 结合享元模式设置为内存共享
 */
 public final static PlayState PLAY_STATE = new PlayState();
 public final static StopState STOP_STATE = new StopState();
 public final static PauseState PAUSE_STATE = new PauseState();
 public final static SpeedState SPEED_STATE = new SpeedState();

 public CourseVideoState getCourseVideoState() {
 return courseVideoState;
 }

 public void setCourseVideoState(CourseVideoState courseVideoState) {
 this.courseVideoState = courseVideoState;
 // 把自己本身设置到实例上下文中
 this.courseVideoState.setCourseVideoContext(this);
 }
 public void play(){
 this.courseVideoState.play();
 }

 public void speed(){
 this.courseVideoState.speed();
 }

 public void stop(){
 this.courseVideoState.stop();
 }

 public void pause(){
 this.courseVideoState.pause();
 }
}

各状态实现

package top.fjy8018.designpattern.pattern.behavior.state;

/**
 * @author F嘉阳
 * @date 2020/7/22 15:20
 */
public class PlayState extends CourseVideoState {

 @Override
 public void play() {
 System.out.println("正常播放课程视频状态");
 }

 @Override
 public void speed() {
 super.courseVideoContext.setCourseVideoState(CourseVideoContext.SPEED_STATE);
 }

 @Override
 public void pause() {
 super.courseVideoContext.setCourseVideoState(CourseVideoContext.PAUSE_STATE);
 }

 @Override
 public void stop() {
 super.courseVideoContext.setCourseVideoState(CourseVideoContext.STOP_STATE);
 }
}

package top.fjy8018.designpattern.pattern.behavior.state;

/**
 * @author F嘉阳
 * @date 2020/7/22 15:20
 */
public class PauseState extends CourseVideoState {

 @Override
 public void play() {
 super.courseVideoContext.setCourseVideoState(CourseVideoContext.PLAY_STATE);
 }

 @Override
 public void speed() {
 super.courseVideoContext.setCourseVideoState(CourseVideoContext.SPEED_STATE);
 }

 @Override
 public void pause() {
 System.out.println("暂停播放课程视频状态");
 }

 @Override
 public void stop() {
 super.courseVideoContext.setCourseVideoState(CourseVideoContext.STOP_STATE);
 }
}

package top.fjy8018.designpattern.pattern.behavior.state;

/**
 * @author F嘉阳
 * @date 2020/7/22 15:20
 */
public class SpeedState extends CourseVideoState {
 @Override
 public void play() {
 super.courseVideoContext.setCourseVideoState(CourseVideoContext.PLAY_STATE);
 }

 @Override
 public void speed() {
 System.out.println("快进播放课程视频状态");
 }

 @Override
 public void pause() {
 super.courseVideoContext.setCourseVideoState(CourseVideoContext.PAUSE_STATE);
 }

 @Override
 public void stop() {
 super.courseVideoContext.setCourseVideoState(CourseVideoContext.STOP_STATE);
 }
}

package top.fjy8018.designpattern.pattern.behavior.state;

/**
 * @author F嘉阳
 * @date 2020/7/22 15:20
 */
public class StopState extends CourseVideoState {
 @Override
 public void play() {
 super.courseVideoContext.setCourseVideoState(CourseVideoContext.PLAY_STATE);
 }

 @Override
 public void speed() {
 System.out.println("ERROR 停止状态不能快进!!");
 }

 @Override
 public void pause() {
 System.out.println("ERROR 停止状态不能暂停!!");
 }

 @Override
 public void stop() {
 System.out.println("停止播放课程视频状态");
 }
}

测试

package top.fjy8018.designpattern.pattern.behavior.state;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * @author F嘉阳
 * @date 2020/7/22 16:19
 */
class PlayStateTest {

 @Test
 void play() {
 CourseVideoContext courseVideoContext = new CourseVideoContext();
 courseVideoContext.setCourseVideoState(new PlayState());

 System.out.println("当前状态:"+courseVideoContext.getCourseVideoState().getClass().getSimpleName());
 courseVideoContext.pause();

 System.out.println("当前状态:"+courseVideoContext.getCourseVideoState().getClass().getSimpleName());

 courseVideoContext.speed();

 System.out.println("当前状态:"+courseVideoContext.getCourseVideoState().getClass().getSimpleName());

 courseVideoContext.stop();

 System.out.println("当前状态:"+courseVideoContext.getCourseVideoState().getClass().getSimpleName());

 courseVideoContext.speed();
 }
}

输出

当前状态:PlayState
当前状态:PauseState
当前状态:SpeedState
当前状态:StopState
ERROR 停止状态不能快进!!

设计模式学习——结构型

Wed, 04 Mar 2020 10:44:04 +0800

外观模式

介绍

又叫门面模式,提供了一个统一的接口,用来访问子系统中的一群接口

外观模式定义了一个高层接口,让子系统更容易使用

类型：结构型

适用场景：

子系统越来越复杂,增加外观模式提供简单调用接口
构建多层系统结构,利用外观对象作为每层的入口,简化层间调用

优点：

简化了调用过程，无需了解深入子系统，防止带来风险。
减少系统依赖、松散耦合
更好的划分访问层次
符合迪米特法则，即最少知道原则

缺点：

增加子系统、扩展子系统行为容易引入风险
不符合开闭原则

代码样例

改造前

类图

package top.fjy8018.designpattern.pattern.structural.facade.before;

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * 外观模式又叫门面模式,提供了一个统一的接口,用来访问子系统中的一群接口
 * 积分礼物
 *
 * @author F嘉阳
 * @date 2020/2/28 10:33
 */
@Getter
@AllArgsConstructor
public class PointGift {
 private String name;
}

子系统一：积分校验子系统

package top.fjy8018.designpattern.pattern.structural.facade.before;

import lombok.extern.slf4j.Slf4j;

/**
 * 积分校验子系统
 *
 * @author F嘉阳
 * @date 2020/2/28 10:34
 */
@Slf4j
public class QualifyService {

 /**
 * 模拟积分校验逻辑
 * @param pointGift
 * @return
 */
 public boolean isAvalible(PointGift pointGift){
 log.info("校验礼物 {} 通过，积分校验通过，库存通过",pointGift.getName());
 return true;
 }
}

子系统二：积分支付校验子系统

package top.fjy8018.designpattern.pattern.structural.facade.before;

import lombok.extern.slf4j.Slf4j;

/**
 * 积分支付校验子系统
 *
 * @author F嘉阳
 * @date 2020/2/28 10:37
 */
@Slf4j
public class PointPaymentService {

 public boolean pay(PointGift pointGift){
 // 扣减积分逻辑
 log.info("支付礼物 {} 积分成功",pointGift.getName());
 return true;
 }
}

子系统三：物流子系统

package top.fjy8018.designpattern.pattern.structural.facade.before;

import lombok.extern.slf4j.Slf4j;

/**
 * 物流子系统
 *
 * @author F嘉阳
 * @date 2020/2/28 10:39
 */
@Slf4j
public class ShippingService {

 /**
 * 返回物流运单号
 *
 * @param pointGift
 * @return
 */
 public String shipGift(PointGift pointGift){
 // 物流系统对接逻辑
 log.info("礼物 {} 进入物流系统",pointGift.getName());
 return "123456";
 }
}

外观类——礼物兑换逻辑

package top.fjy8018.designpattern.pattern.structural.facade.before;

import lombok.extern.slf4j.Slf4j;

/**
 * 外观类——礼物兑换逻辑
 *
 * 该服务定义了与各个子系统交互的逻辑，业务系统无需知道与内部子系统的交互逻辑，符合迪米特法则
 * @author F嘉阳
 * @date 2020/2/28 10:44
 */
@Slf4j
public class GiftExchangeService {

 private PointPaymentService pointPaymentService;

 private QualifyService qualifyService;

 private ShippingService shippingService;

 public void setPointPaymentService(PointPaymentService pointPaymentService) {
 this.pointPaymentService = pointPaymentService;
 }

 public void setQualifyService(QualifyService qualifyService) {
 this.qualifyService = qualifyService;
 }

 public void setShippingService(ShippingService shippingService) {
 this.shippingService = shippingService;
 }

 /**
 * 系统交互逻辑
 *
 * @param pointGift
 */
 public void giftExchange(PointGift pointGift){
 if (qualifyService.isAvalible(pointGift)){
 // 资格校验通过
 if (pointPaymentService.pay(pointGift)){
 // 如果积分支付成功
 String shippingOrderNo = shippingService.shipGift(pointGift);
 log.info("物流系统下单成功，订单号为{}",shippingOrderNo);
 }
 }
 }
}

测试

package top.fjy8018.designpattern.pattern.structural.facade.before;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

/**
 * @author F嘉阳
 * @date 2020/2/28 10:53
 */
@Slf4j
class GiftExchangeServiceTest {

 @Test
 void giftExchange() {
 PointGift pointGift = new PointGift("手环");
 // 注入服务
 GiftExchangeService exchangeService = new GiftExchangeService();
 exchangeService.setPointPaymentService(new PointPaymentService());
 exchangeService.setQualifyService(new QualifyService());
 exchangeService.setShippingService(new ShippingService());
 // 兑换
 exchangeService.giftExchange(pointGift);
 }
}

执行结果

10:56:55.639 [main] INFO top.fjy8018.designpattern.pattern.structural.facade.before.QualifyService - 校验礼物 手环 通过，积分校验通过，库存通过
10:56:55.652 [main] INFO top.fjy8018.designpattern.pattern.structural.facade.before.PointPaymentService - 支付礼物 手环 积分成功
10:56:55.652 [main] INFO top.fjy8018.designpattern.pattern.structural.facade.before.ShippingService - 礼物 手环 进入物流系统
10:56:55.652 [main] INFO top.fjy8018.designpattern.pattern.structural.facade.before.GiftExchangeService - 物流系统下单成功，订单号为123456

改造后

改造点很简单，只要将应用层注入的类在逻辑层注入即可

package top.fjy8018.designpattern.pattern.structural.facade;

import lombok.extern.slf4j.Slf4j;

/**
 * 外观类——礼物兑换逻辑
 * <p>
 * 该服务定义了与各个子系统交互的逻辑，业务系统无需知道与内部子系统的交互逻辑，符合迪米特法则
 *
 * @author F嘉阳
 * @date 2020/2/28 10:44
 */
@Slf4j
public class GiftExchangeService {

 private PointPaymentService pointPaymentService = new PointPaymentService();

 private QualifyService qualifyService = new QualifyService();

 private ShippingService shippingService = new ShippingService();

 /**
 * 系统交互逻辑
 *
 * @param pointGift
 */
 public void giftExchange(PointGift pointGift) {
 if (qualifyService.isAvalible(pointGift)) {
 // 资格校验通过
 if (pointPaymentService.pay(pointGift)) {
 // 如果积分支付成功
 String shippingOrderNo = shippingService.shipGift(pointGift);
 log.info("物流系统下单成功，订单号为{}", shippingOrderNo);
 }
 }
 }
}

业务层

package top.fjy8018.designpattern.pattern.structural.facade;

import lombok.extern.slf4j.Slf4j;
import org.apache.catalina.connector.Request;
import org.apache.catalina.connector.RequestFacade;

/**
 * 外观类——礼物兑换逻辑
 * <p>
 * 该服务定义了与各个子系统交互的逻辑，业务系统无需知道与内部子系统的交互逻辑，符合迪米特法则
 *
 * 源码：
 * {@link org.springframework.jdbc.support.JdbcUtils} 对数据库相关的操作进行封装
 * {@link org.apache.ibatis.session.Configuration#newMetaObject(Object)} 对创建对象的方法进行封装
 * {@link RequestFacade} 其定义了操作HTTPRequest的公用方法 {@link Request} 在Request中都用该外观类操作
 * 其他类似逻辑：
 * {@link org.apache.catalina.connector.ResponseFacade}
 * {@link org.apache.catalina.session.StandardSessionFacade}
 *
 *
 * @author F嘉阳
 * @date 2020/2/28 10:44
 */
@Slf4j
public class GiftExchangeService {

 private PointPaymentService pointPaymentService = new PointPaymentService();

 private QualifyService qualifyService = new QualifyService();

 private ShippingService shippingService = new ShippingService();

 /**
 * 系统交互逻辑
 *
 * @param pointGift
 */
 public void giftExchange(PointGift pointGift) {
 if (qualifyService.isAvalible(pointGift)) {
 // 资格校验通过
 if (pointPaymentService.pay(pointGift)) {
 // 如果积分支付成功
 String shippingOrderNo = shippingService.shipGift(pointGift);
 log.info("物流系统下单成功，订单号为{}", shippingOrderNo);
 }
 }
 }
}

类图

此时业务层无需关心子系统，只和外观类通信

装饰器模式

介绍

定义：在不改变原有对象的基础之上，将功能附加到对象上

提供了比继承更有弹性的替代方案（扩展原有对象功能）

类型：结构型

适用场景

扩展一个类的功能或给一个类添加附加职责
动态的给一个对象添加功能，这些功能可以再动态的撤销

优点

继承的有力补充,比继承灵活,不改变原有对象的情况下给一个对象扩展功能
通过使用不同装饰类以及这些装饰类的排列组合,可以实现不同效果
符合开闭原则

缺点

会出现更多的代码,更多的类,增加程序复杂性
动态装饰时,多层装饰时会更复杂

相关设计模式

装饰者模式和代理模式
装饰者模式和适配器模式

代码样例

改造前

类图

Battercake

package top.fjy8018.designpattern.pattern.structural.decorator.before;

/**
 * @author F嘉阳
 * @date 2018-09-27 16:56
 */
public class Battercake {
 protected String getDesc() {
 return "煎饼";
 }

 protected int cost() {
 return 8;
 }
}

BattercakeWithEgg

package top.fjy8018.designpattern.pattern.structural.decorator.before;

/**
 * 不使用装饰器则只能通过类继承扩展功能，可能引起类爆炸
 *
 * @author F嘉阳
 * @date 2018-09-27 16:59
 */
public class BattercakeWithEgg extends Battercake {
 @Override
 protected String getDesc() {
 return super.getDesc() + " 加一个鸡蛋";
 }

 @Override
 protected int cost() {
 return super.cost() + 1;
 }
}

BattercakeWithEggSausage

package top.fjy8018.designpattern.pattern.structural.decorator.before;

/**
 * @author F嘉阳
 * @date 2018-09-27 17:00
 */
public class BattercakeWithEggSausage extends BattercakeWithEgg {
 @Override
 protected String getDesc() {
 return super.getDesc() + " 加一根香肠";
 }

 @Override
 protected int cost() {
 return super.cost() + 2;
 }
}

测试

package top.fjy8018.designpattern.pattern.structural.decorator;

@Slf4j
class BattercakeTest {

 /**
 * 通过继承扩展灵活度低，无法自由组合
 */
 @Test
 void before() {
 Battercake battercake = new Battercake();
 log.info(battercake.getDesc() + " 销售价格:" + battercake.cost());

 Battercake battercakeWithEgg = new BattercakeWithEgg();
 log.info(battercakeWithEgg.getDesc() + " 销售价格:" + battercakeWithEgg.cost());


 Battercake battercakeWithEggSausage = new BattercakeWithEggSausage();
 log.info(battercakeWithEggSausage.getDesc() + " 销售价格:" + battercakeWithEggSausage.cost());
 }
}

输出

14:42:18.640 [main] INFO top.fjy8018.designpattern.pattern.structural.decorator.BattercakeTest - 煎饼 销售价格:8
14:42:18.652 [main] INFO top.fjy8018.designpattern.pattern.structural.decorator.BattercakeTest - 煎饼 加一个鸡蛋 销售价格:9
14:42:18.652 [main] INFO top.fjy8018.designpattern.pattern.structural.decorator.BattercakeTest - 煎饼 加一个鸡蛋 加一根香肠 销售价格:11

改造后

类图

所有类的抽象

package top.fjy8018.designpattern.pattern.structural.decorator.after;

/**
 * 装饰器模式按照业务场景一般有两层抽象，
 * 一层是所有类的抽象，一层是所有装饰器的抽象，
 * 所有装饰器的抽象可以为实现类提供实现额外功能的能力
 *
 * @author F嘉阳
 * @date 2018-09-27 17:02
 */
public abstract class AbstractBattercake {
 public abstract String getDesc();

 public abstract int cost();
}

所有装饰器的抽象

package top.fjy8018.designpattern.pattern.structural.decorator.after;

/**
 * @author F嘉阳
 * @date 2018-09-27 17:05
 */
public abstract class AbstractBattercakeDecorator extends AbstractBattercake {

 private AbstractBattercake abstractBattercake;

 /**
 * 通过构造器注入待装饰对象
 *
 * @param abstractBattercake
 */
 public AbstractBattercakeDecorator(AbstractBattercake abstractBattercake) {
 this.abstractBattercake = abstractBattercake;
 }

 /**
 * 实现类可以提供额外能力
 */
 protected abstract void doSomething();

 @Override
 public String getDesc() {
 return this.abstractBattercake.getDesc();
 }

 @Override
 public int cost() {
 return this.abstractBattercake.cost();
 }
}

package top.fjy8018.designpattern.pattern.structural.decorator.after;

/**
 * Servlet源码：{@link javax.servlet.http.HttpServletRequestWrapper}
 * JDK源码：IO类：{@link java.io.BufferedReader} {@link java.io.BufferedInputStream}
 * Spring源码:{@link org.springframework.cache.transaction.TransactionAwareCacheDecorator}
 * mybatis源码：{@link org.apache.ibatis.cache.decorators.LruCache}
 *
 * @author F嘉阳
 * @date 2018-09-27 17:04
 */
public class ABattercake extends AbstractBattercake {
 @Override
 public String getDesc() {
 return "煎饼";
 }

 @Override
 public int cost() {
 return 8;
 }
}

package top.fjy8018.designpattern.pattern.structural.decorator.after;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2018-09-27 17:08
 */
@Slf4j
public class EggBattercake extends AbstractBattercakeDecorator {

 public EggBattercake(AbstractBattercake abstractBattercake) {
 super(abstractBattercake);
 }

 @Override
 protected void doSomething() {
 log.info("EggBattercake doSomething...");
 }

 @Override
 public String getDesc() {
 return super.getDesc() + " 加一个鸡蛋";
 }

 @Override
 public int cost() {
 return super.cost() + 1;
 }
}

package top.fjy8018.designpattern.pattern.structural.decorator.after;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2018-09-27 17:10
 */
@Slf4j
public class SausageBattercake extends AbstractBattercakeDecorator {
 public SausageBattercake(AbstractBattercake abstractBattercake) {
 super(abstractBattercake);
 }

 @Override
 protected void doSomething() {
 log.info("SausageBattercake doSomething...");
 }

 @Override
 public String getDesc() {
 return super.getDesc() + " 加一根香肠";
 }

 @Override
 public int cost() {
 return super.cost() + 2;
 }
}

测试

package top.fjy8018.designpattern.pattern.structural.decorator;

@Slf4j
class BattercakeTest {

 @Test
 void after() {
 // 自由组合装饰
 AbstractBattercake battercake = new EggBattercake(new SausageBattercake(new ABattercake()));
 log.info(battercake.getDesc() + " 销售价格:" + battercake.cost());

 AbstractBattercake battercake2 = new EggBattercake((new ABattercake()));
 log.info(battercake2.getDesc() + " 销售价格:" + battercake2.cost());
 }
}

输出

14:42:18.660 [main] INFO top.fjy8018.designpattern.pattern.structural.decorator.BattercakeTest - 煎饼 加一根香肠 加一个鸡蛋 销售价格:11
14:42:18.660 [main] INFO top.fjy8018.designpattern.pattern.structural.decorator.BattercakeTest - 煎饼 加一个鸡蛋 销售价格:9

适配器模式

介绍

定义将一个类的接口转换成客户期望的另一个接口

使原本接口不兼容的类可以一起工作

类型：结构型

适用场景

不是软件设计阶段考虑的设计模式,是随着软件维护,由于不同产品、不同厂家造成功能类似而接口不相同情况下的解决方案
已经存在的类,它的方法和需求不匹配时(方法结果相同或相似)

优点

能提高类的透明性和复用,现有的类复用但不需要改变
目标类和适配器类解耦,提高程序扩展性
符合开闭原则

缺点

适配器编写过程需要全面考虑,可能会增加系统的复杂性
增加系统代码可读的难度

分类与扩展

对象适配器
类适配器

相关设计模式

适配器模式和外观模式

代码样例——电源适配器

类图

220V

package top.fjy8018.designpattern.pattern.structural.adapter.poweradapter;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2018-10-09 16:24
 */
@Slf4j
public class AC220 {
 public int output() {
 int output = 220;
 log.info(this.getClass().getSimpleName() + "output:" + output + "V");
 return output;
 }
}

package top.fjy8018.designpattern.pattern.structural.adapter.poweradapter;

/**
 * @author F嘉阳
 * @date 2018-10-09 16:25
 */
public interface DC5 {
 int output();
}

适配器

package top.fjy8018.designpattern.pattern.structural.adapter.poweradapter;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2018-10-09 16:25
 */
@Slf4j
public class Adapter implements DC5 {

 private AC220 ac220 = new AC220();

 @Override
 public int output() {
 int output220 = ac220.output();
 // 变压器模拟
 int output5 = output220 / 44;
 log.info("{} 输入{}V,输出{}V", this.getClass().getSimpleName(), output220, output5);
 return output5;
 }
}

测试

package top.fjy8018.designpattern.pattern.structural.adapter.poweradapter;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class AdapterTest {

 @Test
 void output() {
 AC220 ac220 = new AC220();
 ac220.output();

 DC5 dc5 = new Adapter();
 dc5.output();
 }
}

输出

14:58:14.719 [main] INFO top.fjy8018.designpattern.pattern.structural.adapter.poweradapter.AC220 - AC220output:220V
14:58:14.729 [main] INFO top.fjy8018.designpattern.pattern.structural.adapter.poweradapter.AC220 - AC220output:220V
14:58:14.729 [main] INFO top.fjy8018.designpattern.pattern.structural.adapter.poweradapter.Adapter - Adapter 输入220V,输出5V

代码样例——类适配器

类图

目标类实现接口

package top.fjy8018.designpattern.pattern.structural.adapter.classadapter;

/**
 * 目标类实现接口
 *
 * @author F嘉阳
 * @date 2018-10-09 16:05
 */
public interface Target {
 void request();
}

被适配对象

package top.fjy8018.designpattern.pattern.structural.adapter.classadapter;

import lombok.extern.slf4j.Slf4j;

/**
 * 适配器模式：
 * 类适配器模式
 * 被适配对象
 *
 * @author F嘉阳
 * @date 2018-10-09 16:04
 */
@Slf4j
public class Adaptee {

 public void adapteeRequest() {
 log.info("adapteeRequest...");
 }
}

package top.fjy8018.designpattern.pattern.structural.adapter.classadapter;

/**
 * 适配器模式：将一个类的接口转换成客户希望的另一个接口。适配器模式让那些接口不兼容的类可以一起工作
 *
 * JDK源码：{@link javax.xml.bind.annotation.adapters.XMLAdapter}
 * spring源码：{@link jdk.internal.org.objectweb.asm.commons.AdviceAdapter}
 * {@link org.springframework.web.servlet.HandlerAdapter}
 * JPA源码：{@link org.springframework.orm.jpa.JpaVendorAdapter}
 *
 * @author F嘉阳
 * @date 2018-10-09 16:07
 */
public class Adapter extends Adaptee implements Target {
 @Override
 public void request() {
 // ... 新增业务逻辑
 super.adapteeRequest();
 }
}

目标类具体实现

package top.fjy8018.designpattern.pattern.structural.adapter.classadapter;

import lombok.extern.slf4j.Slf4j;

/**
 * 目标类具体实现
 *
 * @author F嘉阳
 * @date 2018-10-09 16:06
 */
@Slf4j
public class ConcreteTarget implements Target {

 @Override
 public void request() {
 log.info("ConcreteTarget...");
 }
}

测试

package top.fjy8018.designpattern.pattern.structural.adapter.classadapter;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

@Slf4j
class AdapterTest {

 /**
 * 通过适配器实现调用新接口将具体实现转发到旧类中实现
 */
 @Test
 void request() {
 Target newTarget = new ConcreteTarget();
 newTarget.request();

 Target adapter = new Adapter();
 adapter.request();
 }
}

输出

15:05:50.583 [main] INFO top.fjy8018.designpattern.pattern.structural.adapter.classadapter.ConcreteTarget - ConcreteTarget...
15:05:50.601 [main] INFO top.fjy8018.designpattern.pattern.structural.adapter.classadapter.Adaptee - adapteeRequest...

代码样例——对象适配器

类图

Target、Adaptee、ConcreteTarget都与类适配器一致、Adapter修改如下

package top.fjy8018.designpattern.pattern.structural.adapter.objectadapter;

/**
 * 适配器模式：将一个类的接口转换成客户希望的另一个接口。适配器模式让那些接口不兼容的类可以一起工作
 *
 * @author F嘉阳
 * @date 2018-10-09 16:07
 */
public class Adapter implements Target {

 /**
 * 将继承改成组合方式，降低耦合度
 */
 private Adaptee adaptee = new Adaptee();

 @Override
 public void request() {
 // ... 新增业务逻辑
 adaptee.adapteeRequest();
 }
}

测试

package top.fjy8018.designpattern.pattern.structural.adapter.objectadapter;

import org.junit.jupiter.api.Test;

class AdapterTest {

 @Test
 void request() {
 Target newTarget = new ConcreteTarget();
 newTarget.request();

 Target adapter = new Adapter();
 adapter.request();
 }
}

输出

15:10:00.866 [main] INFO top.fjy8018.designpattern.pattern.structural.adapter.objectadapter.ConcreteTarget - ConcreteTarget...
15:10:00.876 [main] INFO top.fjy8018.designpattern.pattern.structural.adapter.objectadapter.Adaptee - adapteeRequest...

享元模式

介绍

定义：提供了减少对象数量从而改善应用所需的对象结构的方式

运用共享技术有效地支持大量细粒度的对象

类型：结构型

适用场景

常常应用于系统底层的开发,以便解决系统的性能问题
系统有大量相似对象、需要缓冲池的场景。

优点

减少对象的创建，降低内存中对象的数量，降低系统的内存，提高效率
减少内存之外的其他资源占用

缺点

关注内/外部状态、关注线程安全问题
使系统、程序的逻辑复杂化

分类与扩展

内部状态
外部状态

相关设计模式

享元模式和代理模式
享元模式和单例模式

代码样例

类图

package top.fjy8018.designpattern.pattern.structural.flyweight;

/**
 * 享元模式：利用共享的方式来支持大量细粒度的对象，这些对象一部分内部状态是相同的。
 * JDK源码：{@link Integer#valueOf(int)} {@link Integer.IntegerCache}
 * 其他类型同理 {@link Long#valueOf(long)} {@link Boolean#valueOf(boolean)} {@link Byte#valueOf(byte)} {@link Character#valueOf(char)}
 * Apache源码：连接池{@link org.apache.commons.pool2.impl.GenericObjectPool#returnObject(Object)},连接池配置 {@link org.apache.commons.pool2.impl.GenericObjectPoolConfig}
 *
 * @author F嘉阳
 * @date 2018-10-14 16:13
 */
public interface Employee {
 void report();
}

员工工厂类

package top.fjy8018.designpattern.pattern.structural.flyweight;

import lombok.extern.slf4j.Slf4j;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 员工工厂类
 *
 * @author F嘉阳
 * @date 2018-10-14 16:15
 */
@Slf4j
public class EmployeeFactory {
 private static final Map<String, Employee> EMPLOYEE_MAP = new ConcurrentHashMap<>();

 public static Employee getEmployee(String department) {
 Manager manager = (Manager) EMPLOYEE_MAP.get(department);
 // 如果在对象池中不存在，则新建对象
 if (manager == null) {
 manager = new Manager(department);
 log.warn("创建{}部门经理", department);
 String content = "报告内容……";
 log.warn("创建报告，内容为:{}", content);
 manager.setContent(content);
 EMPLOYEE_MAP.put(department, manager);
 }
 return manager;
 }
}

package top.fjy8018.designpattern.pattern.structural.flyweight;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2018-10-14 16:16
 */
@Slf4j
public class Manager implements Employee {

 private String content;

 private String department;

 /**
 * 内部状态
 */
 private String title = "部门经理";

 public Manager(String department) {
 this.department = department;
 }

 public void setContent(String content) {
 this.content = content;
 }

 @Override
 public void report() {
 log.info("{}{}，汇报内容：{}", department, title, content);
 }
}

测试

package top.fjy8018.designpattern.pattern.structural.flyweight;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

@Slf4j
class EmployeeTest {

 private static final String departments[] = {"RD", "QA", "PM", "BD"};

 @Test
 void report() {
 for (int i = 0; i < 10; i++) {
 String department = departments[(int) (Math.random() * departments.length)];
 Employee employee = EmployeeFactory.getEmployee(department);
 employee.report();
 }
 }
}

输出

15:47:51.177 [main] WARN top.fjy8018.designpattern.pattern.structural.flyweight.EmployeeFactory - 创建PM部门经理
15:47:51.187 [main] WARN top.fjy8018.designpattern.pattern.structural.flyweight.EmployeeFactory - 创建报告，内容为:报告内容……
15:47:51.188 [main] INFO top.fjy8018.designpattern.pattern.structural.flyweight.Manager - PM部门经理，汇报内容：报告内容……
15:47:51.188 [main] WARN top.fjy8018.designpattern.pattern.structural.flyweight.EmployeeFactory - 创建BD部门经理
15:47:51.188 [main] WARN top.fjy8018.designpattern.pattern.structural.flyweight.EmployeeFactory - 创建报告，内容为:报告内容……
15:47:51.188 [main] INFO top.fjy8018.designpattern.pattern.structural.flyweight.Manager - BD部门经理，汇报内容：报告内容……
15:47:51.188 [main] INFO top.fjy8018.designpattern.pattern.structural.flyweight.Manager - BD部门经理，汇报内容：报告内容……
15:47:51.188 [main] WARN top.fjy8018.designpattern.pattern.structural.flyweight.EmployeeFactory - 创建RD部门经理
15:47:51.188 [main] WARN top.fjy8018.designpattern.pattern.structural.flyweight.EmployeeFactory - 创建报告，内容为:报告内容……
15:47:51.188 [main] INFO top.fjy8018.designpattern.pattern.structural.flyweight.Manager - RD部门经理，汇报内容：报告内容……
15:47:51.188 [main] WARN top.fjy8018.designpattern.pattern.structural.flyweight.EmployeeFactory - 创建QA部门经理
15:47:51.188 [main] WARN top.fjy8018.designpattern.pattern.structural.flyweight.EmployeeFactory - 创建报告，内容为:报告内容……
15:47:51.188 [main] INFO top.fjy8018.designpattern.pattern.structural.flyweight.Manager - QA部门经理，汇报内容：报告内容……
15:47:51.188 [main] INFO top.fjy8018.designpattern.pattern.structural.flyweight.Manager - RD部门经理，汇报内容：报告内容……
15:47:51.188 [main] INFO top.fjy8018.designpattern.pattern.structural.flyweight.Manager - QA部门经理，汇报内容：报告内容……
15:47:51.188 [main] INFO top.fjy8018.designpattern.pattern.structural.flyweight.Manager - BD部门经理，汇报内容：报告内容……
15:47:51.188 [main] INFO top.fjy8018.designpattern.pattern.structural.flyweight.Manager - RD部门经理，汇报内容：报告内容……
15:47:51.188 [main] INFO top.fjy8018.designpattern.pattern.structural.flyweight.Manager - BD部门经理，汇报内容：报告内容……

由此可见，在初次创建部门经理后都无需重新创建，后续的汇报可以直接从对象池里直接获取s

组合模式

介绍

定义：将对象组合成树形结构以表示“部分-整体”的层次结构

组合模式使客户端对单个对象和组合对象保持一致的方式处理

类型：结构型

适用场景

希望客户端可以忽略组合对象与单个对象的差异时
处理一个树形结构时

优点

清楚地定义分层次的复杂对象,表示对象的全部或部分层次
让客户端忽略了层次的差异,方便对整个层次结构进行控制
简化客户端代码

缺点

使设计变得更加抽象
限制类型时会较为复杂

相关设计模式

组合模式和访问者模式

代码样例

类图

课程抽象类

package top.fjy8018.designpattern.pattern.structural.composite;

import java.awt.*;
import java.util.Collection;
import java.util.Map;

/**
 * 课程抽象类
 * 抽象组件应当多加考虑，哪些参数需要，哪些不需要
 *
 * JDK组合模式源码
 * {@link java.awt.Container#add(Component)} 增加一个父类操作
 * {@link java.util.HashMap#putAll(Map)}
 * {@link java.util.ArrayList#addAll(Collection)}
 *
 * Mybatis源码
 * {@link org.apache.ibatis.scripting.xmltags.SqlNode} 公共接口
 * 实现：{@link org.apache.ibatis.scripting.xmltags.MixedSqlNode}
 *
 * @author F嘉阳
 * @date 2020/2/28 16:19
 */
public abstract class CatalogComponent {

 public void add(CatalogComponent catalogComponent) {
 throw new UnsupportedOperationException("不支持添加操作");
 }

 public void remove(CatalogComponent catalogComponent) {
 throw new UnsupportedOperationException("不支持删除操作");
 }

 public String getName(CatalogComponent catalogComponent) {
 throw new UnsupportedOperationException("不支持获取名称操作");
 }

 public Double getPrice(CatalogComponent catalogComponent) {
 throw new UnsupportedOperationException("不支持获取价格操作");
 }

 public void print() {
 throw new UnsupportedOperationException("不支持获取打印操作");
 }
}

课程

package top.fjy8018.designpattern.pattern.structural.composite;

import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;

/**
 * 课程
 * 重写抽象类需要充分考虑业务逻辑
 *
 * @author F嘉阳
 * @date 2020/2/28 16:24
 */
@Slf4j
@AllArgsConstructor
public class Course extends CatalogComponent {

 private String name;

 private Double price;

 @Override
 public String getName(CatalogComponent catalogComponent) {
 return this.name;
 }

 @Override
 public Double getPrice(CatalogComponent catalogComponent) {
 return this.price;
 }

 @Override
 public void print() {
 log.info("课程名称：{}，价格：{}",name,price);
 }
}

课程目录

package top.fjy8018.designpattern.pattern.structural.composite;

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;

/**
 * 课程目录
 * 可以添加目录节点
 *
 * @author F嘉阳
 * @date 2020/2/28 16:34
 */
@Slf4j
public class CourseCatalog extends CatalogComponent{

 private List<CatalogComponent> items = new ArrayList<>();

 private String name;

 public CourseCatalog(String name) {
 this.name = name;
 }

 @Override
 public void add(CatalogComponent catalogComponent) {
 items.add(catalogComponent);
 }

 @Override
 public void remove(CatalogComponent catalogComponent) {
 items.remove(catalogComponent);
 }

 @Override
 public void print() {
 log.info("课程目录名称：{}",name);
 items.forEach(CatalogComponent::print);
 }
}

测试

package top.fjy8018.designpattern.pattern.structural.composite;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * @author F嘉阳
 * @date 2020/2/28 16:37
 */
@Slf4j
class CatalogComponentTest {

 @Test
 void add() {
 // 将课程与课程目录都认为是同一个类型，进行统一处理
 CatalogComponent linuxCourse = new Course("Linux课程",35.0);
 CatalogComponent windowsCourse = new Course("windows课程",61.0);
 CatalogComponent macOsCourse = new Course("macOs课程",20.0);

 CatalogComponent springCourse = new Course("spring课程",55.0);
 CatalogComponent servletCourse = new Course("servlet课程",11.0);

 // 课程目录
 CatalogComponent javaCourseCatalog = new CourseCatalog("java课程目录");
 CatalogComponent schoolCourseCatalog = new CourseCatalog("学校课程主目录");

 javaCourseCatalog.add(springCourse);
 javaCourseCatalog.add(servletCourse);

 // 既可以添加课程，也可以添加目录
 schoolCourseCatalog.add(linuxCourse);
 schoolCourseCatalog.add(windowsCourse);
 schoolCourseCatalog.add(macOsCourse);
 schoolCourseCatalog.add(javaCourseCatalog);

 schoolCourseCatalog.print();
 }
}

输出

09:24:29.687 [main] INFO top.fjy8018.designpattern.pattern.structural.composite.CourseCatalog - 课程目录名称：学校课程主目录
09:24:29.691 [main] INFO top.fjy8018.designpattern.pattern.structural.composite.Course - 课程名称：Linux课程，价格：35.0
09:24:29.693 [main] INFO top.fjy8018.designpattern.pattern.structural.composite.Course - 课程名称：windows课程，价格：61.0
09:24:29.694 [main] INFO top.fjy8018.designpattern.pattern.structural.composite.Course - 课程名称：macOs课程，价格：20.0
09:24:29.694 [main] INFO top.fjy8018.designpattern.pattern.structural.composite.CourseCatalog - 课程目录名称：java课程目录
09:24:29.694 [main] INFO top.fjy8018.designpattern.pattern.structural.composite.Course - 课程名称：spring课程，价格：55.0
09:24:29.694 [main] INFO top.fjy8018.designpattern.pattern.structural.composite.Course - 课程名称：servlet课程，价格：11.0

桥接模式

介绍

定义：将抽象部分与它的具体实现部分分离,使它们都可以独立地变化

通过组合的方式建立两个类之间联系,而不是继承

类型：结构型

适用场景

抽象和具体实现之间增加更多的灵活性
一个类存在两个(或多个)独立变化的维度,且这两个(或多个) 维度都需要独立进行扩展
不希望使用继承,或因为多层继承导致系统类的个数剧增

优点

分离抽象部分及其具体实现部分
提高了系统的可扩展性
符合开闭原则
符合合成复用原则

缺点

增加了系统的理解与设计难度
需要正确地识别出系统中两个独立变化的维度

相关设计模式

桥接模式和组合模式
桥接模式和适配器模式

代码样例

类图

桥接模式核心在于将抽象与实现通过组合模式连接，使抽象和实现都可以自由扩展

银行账号——行为接口

package top.fjy8018.designpattern.pattern.structural.bridge;

import java.sql.Driver;
import java.sql.DriverManager;

/**
 * 银行账号——行为接口
 *
 * JDBC 为操作不同的数据库提供了同一个{@link java.sql.Connection} 连接
 * 由MySQL或Oracle连接驱动实现相关接口操作数据库
 *
 * {@link java.sql.Driver}
 * {@link DriverManager} 中的 {@link java.sql.DriverInfo}
 * 实现对 {@link java.sql.Driver} 的具体封装
 *
 * JDBC 实现的 {@link com.mysql.cj.jdbc.Driver} 初始化时调 {@link DriverManager#registerDriver(Driver)}
 *
 * @author F嘉阳
 * @date 2020/2/29 9:55
 */
public interface Account {

 /**
 * 打开一个账号
 *
 * @return
 */
 Account openAccount();

 /**
 * 查看账号类型
 */
 void showAccountType();
}

抽象银行

package top.fjy8018.designpattern.pattern.structural.bridge;

import lombok.AllArgsConstructor;

/**
 * 抽象银行
 * 组合账户接口，交由子类实现具体的行为
 *
 * @author F嘉阳
 * @date 2020/2/29 10:05
 */
@AllArgsConstructor
public abstract class Bank {

 protected Account account;

 /**
 * 打开一个账户
 * 该方法定义与接口相同，方法名称可以不同
 * 当前抽象类的openAccount方法需要委托给Account接口openAccount方法实现
 * 当前类为抽象类，委托给接口的实现类执行，体现抽象与实现分离
 * @return
 */
 abstract Account openAccount();
}

活期账户

package top.fjy8018.designpattern.pattern.structural.bridge;

import lombok.extern.slf4j.Slf4j;

/**
 * 活期账户
 *
 * @author F嘉阳
 * @date 2020/2/29 9:58
 */
@Slf4j
public class SavingAccount implements Account {
 /**
 * 打开一个账号
 *
 * @return
 */
 @Override
 public Account openAccount() {
 log.info("打开活期账户");
 return new SavingAccount();
 }

 /**
 * 查看账号类型
 */
 @Override
 public void showAccountType() {
 log.info("这是一个活期账户");
 }
}

定期账户

package top.fjy8018.designpattern.pattern.structural.bridge;

import lombok.extern.slf4j.Slf4j;

/**
 * 定期账户
 *
 * @author F嘉阳
 * @date 2020/2/29 9:57
 */
@Slf4j
public class DepositAccount implements Account{
 /**
 * 打开一个账号
 *
 * @return
 */
 @Override
 public Account openAccount() {
 log.info("打开定期账户");
 return new DepositAccount();
 }

 /**
 * 查看账号类型
 */
 @Override
 public void showAccountType() {
 log.info("这是一个定期账户");
 }
}

广州银行实现

package top.fjy8018.designpattern.pattern.structural.bridge;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2020/2/29 10:09
 */
@Slf4j
public class GCBBank extends Bank {

 public GCBBank(Account account) {
 super(account);
 }

 /**
 * 打开一个账户
 * 该方法定义与接口相同，方法名称可以不同
 * 当前抽象类的openAccount方法需要委托给Account接口openAccount方法实现
 * 当前类为抽象类，委托给接口的实现类执行，体现抽象与实现分离
 *
 * @return
 */
 @Override
 Account openAccount() {
 log.info("打开广州银行账户");
 // 委托
 account.openAccount();
 return account;
 }
}

工商银行实现

package top.fjy8018.designpattern.pattern.structural.bridge;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2020/2/29 10:11
 */
@Slf4j
public class ICBCBank extends Bank {

 public ICBCBank(Account account) {
 super(account);
 }

 /**
 * 打开一个账户
 * 该方法定义与接口相同，方法名称可以不同
 * 当前抽象类的openAccount方法需要委托给Account接口openAccount方法实现
 * 当前类为抽象类，委托给接口的实现类执行，体现抽象与实现分离
 *
 * @return
 */
 @Override
 Account openAccount() {
 log.info("打开工商银行账户");
 // 委托
 account.openAccount();
 return account;
 }
}

测试

package top.fjy8018.designpattern.pattern.structural.bridge;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * @author F嘉阳
 * @date 2020/2/29 14:30
 */
@Slf4j
class AccountTest {

 @Test
 void openAccount() {
 Bank gcbBank = new GCBBank(new DepositAccount());
 Account gcbAccount = gcbBank.openAccount();
 gcbAccount.showAccountType();

 Bank icbcBank = new ICBCBank(new SavingAccount());
 Account icbcAccount = icbcBank.openAccount();
 icbcAccount.showAccountType();
 }
}

输出

14:36:13.478 [main] INFO top.fjy8018.designpattern.pattern.structural.bridge.GCBBank - 打开广州银行账户
14:36:13.488 [main] INFO top.fjy8018.designpattern.pattern.structural.bridge.DepositAccount - 打开定期账户
14:36:13.489 [main] INFO top.fjy8018.designpattern.pattern.structural.bridge.DepositAccount - 这是一个定期账户
14:36:13.489 [main] INFO top.fjy8018.designpattern.pattern.structural.bridge.ICBCBank - 打开工商银行账户
14:36:13.489 [main] INFO top.fjy8018.designpattern.pattern.structural.bridge.SavingAccount - 打开活期账户
14:36:13.489 [main] INFO top.fjy8018.designpattern.pattern.structural.bridge.SavingAccount - 这是一个活期账户

代理模式

介绍

定义：为其他对象提供一种代理,以控制对这个对象的访问

代理对象在客户端和目标对象之间起到中介的作用

类型：结构型

适用场景

保护目标对象
增强目标对象

优点

代理模式能将代理对象与真实被调用的目标对象分离
一定程度上降低了系统的耦合度，扩展性好
保护目标对象
增强目标对象

缺点

代理模式会造成系统设计中类的数目增加
在客户端和目标对象增加一个代理对象，会造成请求处理速度变慢
增加系统的复杂度

分类与扩展

静态代理
- 显式在业务实现类新增代理类实现代理功能，在代理类中对同名的业务方法进行增强和包装
CGLib代理
- 可以代理类
- 代理类对象时，CGLib会生成代理类的子类，覆盖对应的方法
- 由于利用了继承和重写的特性，若类或者方法被标识为final，则无法进行代理
动态代理
- 无法代理类，可以代理接口
- 若增强的对象新增了一个方法，而接口中不包含该新增方法，则无法进行增强
- 对类的代理是在使用时动态创建了一个代理类的class文件，该class文件被字节码引擎执行，被代理类进行方法调用

Spring代理选择

当Bean有实现接口时, Spring就会用JDK的动态代理
当Bean没有实现接口时, Spring使用CGLib
可以强制使用 Cglib
- 在Spring配置中加入<aop: aspectj- autoproxy proxy-target-dass="true"/>
参考资料： https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html

代理速度对比

CGLib：基于ASM字节码生成，比反射效率高
JDK动态代理
速度对比：万次执行的情况下，JDK7与JDK8的动态代理性能比CGLib速度快20%左右

相关设计模式

代理模式和装饰者模式
代理模式和适配器模式

代码样例——Spring 分库代理实现

自定义数据源上下文

package top.fjy8018.designpattern.pattern.structural.proxy.db;

/**
 * 数据源上下文
 *
 * @author F嘉阳
 * @date 2020/2/29 16:27
 */
public class DataSourceContextHolder {
 /**
 * 存放数据源Bean Name
 */
 private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

 /**
 * 配置哪个数据库，则动态数据源线程就会获取到哪个数据库
 * @param dbType
 */
 public static void setDBType(String dbType){
 CONTEXT_HOLDER.set(dbType);
 }

 public static String getDBType(){
 return CONTEXT_HOLDER.get();
 }

 /**
 * 清除，防止内存泄漏
 */
 public static void clear(){
 CONTEXT_HOLDER.remove();
 }
}

定义动态数据源

package top.fjy8018.designpattern.pattern.structural.proxy.db;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * Spring分库实现
 *
 * @author F嘉阳
 * @date 2020/2/29 16:26
 */
public class DynamicDataSource extends AbstractRoutingDataSource {

 /**
 * 动态获取数据库
 * @return 当前线程所属数据源
 */
 @Override
 protected Object determineCurrentLookupKey() {
 return DataSourceContextHolder.getDBType();
 }
}

多数据源配置

<bean id="dataSource" class="top.fjy8018.designpattern.pattern.structural.proxy.db.DynamicDataSource">
	<property name="targetDataSources">
		<map key-type="java.lang.String">
			<entry value-ref="db0" key="db0"></entry>
			<entry value-ref="db1" key="db1"></entry>
		</map>
	</property>
	<property name="defaultTargetDataSource" ref="db0"></property>
</bean>


<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	<property name="dataSource" ref="dataSource" />
</bean>

代码样例——静态代理

类图

订单

package top.fjy8018.designpattern.pattern.structural.proxy;

import lombok.Getter;
import lombok.Setter;

/**
 * 订单
 *
 * @author F嘉阳
 * @date 2020/2/29 16:12
 */
@Getter
@Setter
public class Order {

 private Object orderInfo;

 private Integer userId;
}

DAO层

package top.fjy8018.designpattern.pattern.structural.proxy;

/**
 * DAO层——与业务无关
 * 仿mybatis
 *
 * @author F嘉阳
 * @date 2020/2/29 16:15
 */
public interface IOrderDao {

 int insert(Order order);
}

package top.fjy8018.designpattern.pattern.structural.proxy;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2020/2/29 16:17
 */
@Slf4j
public class IOrderDaoImpl implements IOrderDao {
 @Override
 public int insert(Order order) {
 log.info("DAO层添加订单记录成功");
 return 1;
 }
}

订单服务层

package top.fjy8018.designpattern.pattern.structural.proxy;

/**
 * 订单服务层
 *
 * @author F嘉阳
 * @date 2020/2/29 16:14
 */
public interface IOrderService {

 /**
 * 保存订单
 * @param order
 * @return 保存的行数
 */
 int save(Order order);
}

package top.fjy8018.designpattern.pattern.structural.proxy;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2020/2/29 16:16
 */
@Slf4j
public class IOrderServiceImpl implements IOrderService {

 /**
 * 模拟Spring注入
 */
 private IOrderDao orderDao = new IOrderDaoImpl();

 /**
 * 保存订单
 *
 * @param order
 * @return 保存的行数
 */
 @Override
 public int save(Order order) {
 log.info("Service层调用DAO层添加订单记录成功");
 return orderDao.insert(order);
 }
}

静态代理类

package top.fjy8018.designpattern.pattern.structural.proxy.staticproxy;

import lombok.extern.slf4j.Slf4j;
import top.fjy8018.designpattern.pattern.structural.proxy.IOrderService;
import top.fjy8018.designpattern.pattern.structural.proxy.IOrderServiceImpl;
import top.fjy8018.designpattern.pattern.structural.proxy.Order;
import top.fjy8018.designpattern.pattern.structural.proxy.db.DataSourceContextHolder;

/**
 * 静态代理实现分库
 *
 * @author F嘉阳
 * @date 2020/2/29 16:20
 */
@Slf4j
public class OrderServiceStaticProxy {

 /**
 * 模拟Spring注入
 */
 private IOrderService orderService = new IOrderServiceImpl();

 private static final String DB = "db";

 /**
 * 对源方法增强
 *
 * @param order
 * @return
 */
 public int save(Order order) {
 beforeMethod();

 // 通过用户ID对2取模分库
 Integer userId = order.getUserId();
 int dbRouter = userId % 2;
 log.info("静态代理分配到【db{}】处理数据", dbRouter);

 // 设置DataSource
 DataSourceContextHolder.setDBType(DB + String.valueOf(dbRouter));

 afterMethod();

 return orderService.save(order);
 }

 private void beforeMethod() {
 log.info("静态代理before code");
 }

 private void afterMethod() {
 log.info("静态代理after code");
 }
}

测试

package top.fjy8018.designpattern.pattern.structural.proxy.staticproxy;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import top.fjy8018.designpattern.pattern.structural.proxy.Order;

import static org.junit.jupiter.api.Assertions.*;

/**
 * @author F嘉阳
 * @date 2020/2/29 17:17
 */
@Slf4j
class OrderServiceStaticProxyTest {

 @Test
 void save() {
 Order order1 = new Order();
 order1.setUserId(1);
 Order order2 = new Order();
 order2.setUserId(2);

 OrderServiceStaticProxy proxy = new OrderServiceStaticProxy();
 proxy.save(order1);
 proxy.save(order2);
 }
}

输出


17:20:36.012 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.staticproxy.OrderServiceStaticProxy - 静态代理before code
17:20:36.022 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.staticproxy.OrderServiceStaticProxy - 静态代理分配到【db1】处理数据
17:20:36.024 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.staticproxy.OrderServiceStaticProxy - 静态代理after code
17:20:36.024 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.IOrderServiceImpl - Service层调用DAO层添加订单记录成功
17:20:36.024 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.IOrderDaoImpl - DAO层添加订单记录成功
17:20:36.024 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.staticproxy.OrderServiceStaticProxy - 静态代理before code
17:20:36.024 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.staticproxy.OrderServiceStaticProxy - 静态代理分配到【db0】处理数据
17:20:36.024 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.staticproxy.OrderServiceStaticProxy - 静态代理after code
17:20:36.024 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.IOrderServiceImpl - Service层调用DAO层添加订单记录成功
17:20:36.024 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.IOrderDaoImpl - DAO层添加订单记录成功

代码样例——动态代理

类图

动态代理类

package top.fjy8018.designpattern.pattern.structural.proxy.dynamic;

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.binding.MapperProxy;
import org.springframework.aop.framework.ProxyFactoryBean;
import top.fjy8018.designpattern.pattern.structural.proxy.Order;
import top.fjy8018.designpattern.pattern.structural.proxy.db.DataSourceContextHolder;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 动态代理实现分库
 * 动态代理适用场景更加广泛，可以实现通用分库逻辑
 * <p>
 * {@link ProxyFactoryBean#getObject()} 代理工厂类
 * {@link org.springframework.aop.framework.JdkDynamicAopProxy} spring AOP实现，对动态代理封装
 * {@link org.springframework.aop.framework.CglibAopProxy} Cglib 对类进行代理增强
 * {@link org.apache.ibatis.binding.MapperProxyFactory#newInstance(MapperProxy)} 实现mapper代理
 * 实际封装在 {@link MapperProxy#invoke(Object, Method, Object[])}
 * 其获取的方法利用了享元模式 {@link MapperProxy#cachedMapperMethod(Method)}
 *
 * @author F嘉阳
 * @date 2020/3/3 11:00
 */
@Slf4j
public class OrderServiceDynamicProxy implements InvocationHandler {

 private Object target;

 private static final String DB = "db";

 public OrderServiceDynamicProxy(Object target) {
 this.target = target;
 }

 /**
 * 绑定目标对象
 *
 * @return
 */
 public Object bind() {
 Class clazz = target.getClass();
 return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
 }

 /**
 * 代理
 *
 * @param proxy 代理对象，一般不调用该参数
 * @param method 要被增强的方法对象
 * @param args 方法参数
 * @return
 * @throws Throwable
 */
 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 // 参数传递
 Object argObject = args[0];
 beforeMethod(argObject);
 // object是要被增强的方法的返回值
 Object object = method.invoke(target, args);
 afterMethod();
 return object;
 }

 /**
 * 前置增强方法
 *
 * @param args 方法参数
 */
 private void beforeMethod(Object args) {
 int userId = 0;
 // 对参数取模
 log.info("动态代理，before code");
 if (args instanceof Order) {
 Order order = (Order) args;
 userId = order.getUserId();
 }
 int dbRouter = userId % 2;
 log.info("动态代理分配到【db{}】处理数据", dbRouter);

 // 设置DataSource
 DataSourceContextHolder.setDBType(DB + dbRouter);
 }

 private void afterMethod() {
 log.info("动态代理after code");
 }
}

测试类

package top.fjy8018.designpattern.pattern.structural.proxy.dynamic;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import top.fjy8018.designpattern.pattern.structural.proxy.IOrderService;
import top.fjy8018.designpattern.pattern.structural.proxy.IOrderServiceImpl;
import top.fjy8018.designpattern.pattern.structural.proxy.Order;

/**
 * @author F嘉阳
 * @date 2020/3/3 15:54
 */
@Slf4j
class OrderServiceDynamicProxyTest {

 @Test
 void invoke() {
 Order order1 = new Order();
 order1.setUserId(1);
 Order order2 = new Order();
 order2.setUserId(2);

 // 动态代理直接代理接口
 IOrderService proxy = (IOrderService) new OrderServiceDynamicProxy(new IOrderServiceImpl()).bind();
 proxy.save(order1);
 proxy.save(order2);
 }
}

输出

15:57:57.234 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.dynamic.OrderServiceDynamicProxy - 动态代理，before code
15:57:57.238 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.dynamic.OrderServiceDynamicProxy - 动态代理分配到【db1】处理数据
15:57:57.248 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.IOrderServiceImpl - Service层调用DAO层添加订单记录成功
15:57:57.248 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.IOrderDaoImpl - DAO层添加订单记录成功
15:57:57.248 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.dynamic.OrderServiceDynamicProxy - 动态代理after code
15:57:57.248 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.dynamic.OrderServiceDynamicProxy - 动态代理，before code
15:57:57.248 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.dynamic.OrderServiceDynamicProxy - 动态代理分配到【db0】处理数据
15:57:57.248 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.IOrderServiceImpl - Service层调用DAO层添加订单记录成功
15:57:57.248 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.IOrderDaoImpl - DAO层添加订单记录成功
15:57:57.248 [main] INFO top.fjy8018.designpattern.pattern.structural.proxy.dynamic.OrderServiceDynamicProxy - 动态代理after code

动态代理源码分析

Proxy类

package java.lang.reflect;

public class Proxy implements java.io.Serializable {
 // 反射调用开始
	@CallerSensitive
 public static Object newProxyInstance(ClassLoader loader,
 Class<?>[] interfaces,
 InvocationHandler h)
 throws IllegalArgumentException
 {
 Objects.requireNonNull(h);

 final Class<?>[] intfs = interfaces.clone();
 final SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 // 合法性检查
 checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
 }

 /*
 * 动态生成代理类
 */
 Class<?> cl = getProxyClass0(loader, intfs);

 /*
 * 实例化并返回新创建的类实例对象
 */
 try {
 if (sm != null) {
 checkNewProxyPermission(Reflection.getCallerClass(), cl);
 }

 final Constructor<?> cons = cl.getConstructor(constructorParams);
 final InvocationHandler ih = h;
 if (!Modifier.isPublic(cl.getModifiers())) {
 AccessController.doPrivileged(new PrivilegedAction<Void>() {
 public Void run() {
 cons.setAccessible(true);
 return null;
 }
 });
 }
 return cons.newInstance(new Object[]{h});
 } catch (IllegalAccessException|InstantiationException e) {
 throw new InternalError(e.toString(), e);
 } catch (InvocationTargetException e) {
 Throwable t = e.getCause();
 if (t instanceof RuntimeException) {
 throw (RuntimeException) t;
 } else {
 throw new InternalError(t.toString(), t);
 }
 } catch (NoSuchMethodException e) {
 throw new InternalError(e.toString(), e);
 }
 }
 
 private static void checkProxyAccess(Class<?> caller,
 ClassLoader loader,
 Class<?>... interfaces)
 {
 // 安全校验
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 ClassLoader ccl = caller.getClassLoader();
 if (VM.isSystemDomainLoader(loader) && !VM.isSystemDomainLoader(ccl)) {
 sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
 }
 ReflectUtil.checkProxyPackageAccess(ccl, interfaces);
 }
 }
 
 // 生成代理类
 private static Class<?> getProxyClass0(ClassLoader loader,
 Class<?>... interfaces) {
 // 若一个类中的接口数量超过限制则报错
 if (interfaces.length > 65535) {
 throw new IllegalArgumentException("interface limit exceeded");
 }

 // 从代理类缓存中读取
 return proxyClassCache.get(loader, interfaces);
 }
}

从代理类缓存中读取实现

package java.lang.reflect;

final class WeakCache<K, P, V> {
 	public V get(K key, P parameter) {
 Objects.requireNonNull(parameter);

 expungeStaleEntries();

 Object cacheKey = CacheKey.valueOf(key, refQueue);

 // 使用并发包
 ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
 if (valuesMap == null) {
 ConcurrentMap<Object, Supplier<V>> oldValuesMap
 = map.putIfAbsent(cacheKey,
 valuesMap = new ConcurrentHashMap<>());
 if (oldValuesMap != null) {
 valuesMap = oldValuesMap;
 }
 }

 Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
 Supplier<V> supplier = valuesMap.get(subKey);
 Factory factory = null;

 while (true) {
 if (supplier != null) {
 // 循环获取，直到获取成功才返回
 V value = supplier.get();
 if (value != null) {
 return value;
 }
 }
 // 若首次创建则通过工厂类创建对应的类
 if (factory == null) {
 factory = new Factory(key, parameter, subKey, valuesMap);
 }

 if (supplier == null) {
 supplier = valuesMap.putIfAbsent(subKey, factory);
 if (supplier == null) {
 supplier = factory;
 }
 } else {
 if (valuesMap.replace(subKey, supplier, factory)) {
 supplier = factory;
 } else {
 supplier = valuesMap.get(subKey);
 }
 }
 }
 }
}

断点查看执行情况

设计模式学习——创建型

Fri, 28 Feb 2020 15:26:43 +0800

简单工厂

介绍

定义由一个工厂对象决定创建出哪一种产品类的实例

类型：创建型,但不属于GOF23种设计模式

工厂类负责创建的对象比较少
客户端(应用层)只知道传入工厂类的参数，对于如何创建对象(逻辑)不关心
只需要传入一个正确的参数,就可以获取你所需要的对象而无须知道其创建细节

缺点

工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，违背开闭原则

代码样例

类图

package top.fjy8018.designpattern.pattern.creational.simplefactory;

import ch.qos.logback.classic.LoggerContext;

import java.util.Calendar;

/**
 * 简单工厂
 * JDK样例 {@link Calendar#getInstance()} 其调用的 {@link Calendar#createCalendar} 就是简单工厂的体现
 * 日志框架样例 {@link org.slf4j.LoggerFactory#getLogger(String)} -> {@link LoggerContext#getLogger(String)}
 *
 * @author F嘉阳
 * @date 2018-09-23 16:13
 */
public abstract class AbstractVideo {
 public abstract void produce();
}

package top.fjy8018.designpattern.pattern.creational.simplefactory;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2018-09-23 16:13
 */
@Slf4j
public class JavaAbstractVideo extends AbstractVideo {
 @Override
 public void produce() {
 log.info("生产Java视频");
 }
}

package top.fjy8018.designpattern.pattern.creational.simplefactory;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2018-09-23 16:14
 */
@Slf4j
public class PythonAbstractVideo extends AbstractVideo {
 @Override
 public void produce() {
 log.info("生产Python视频");
 }
}

package top.fjy8018.designpattern.pattern.creational.simplefactory;

/**
 * @author F嘉阳
 * @date 2018-09-23 16:16
 */
public class VideoFactory {

 /**
 * 由工厂负责创建类，业务层无需关心具体实现
 * 其缺点是不符合开闭原则，即如果具体实现类扩展后，工厂类也必须修改
 *
 * @param type
 * @return
 */
 public AbstractVideo getVideo(String type) {
 switch (type) {
 case "Java":
 return new JavaAbstractVideo();
 case "Python":
 return new PythonAbstractVideo();
 default:
 return null;
 }
 }

 /**
 * 通过反射在一定程度弥补简单工厂不足（开闭原则）
 *
 * @param c
 * @return
 */
 public AbstractVideo getVideo(Class c) {
 AbstractVideo video = null;
 try {
 video = (AbstractVideo) Class.forName(c.getName()).newInstance();
 } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
 e.printStackTrace();
 }
 return video;
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.simplefactory;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class AbstractVideoTest {

 /**
 * 不使用简单工厂，则业务层需要引入具体的实现类
 */
 @Test
 void before() {
 AbstractVideo video = new JavaAbstractVideo();
 video.produce();
 }

 /**
 * 使用简单工厂后业务层无需导入具体的实现类，即不关心具体实现过程
 */
 @Test
 void after() {
 VideoFactory factory = new VideoFactory();
 AbstractVideo video = factory.getVideo("Java");
 video.produce();
 }

 /**
 * 通过传递类名方式改进扩展性问题
 */
 @Test
 void improve() {
 VideoFactory factory = new VideoFactory();
 AbstractVideo video = factory.getVideo(JavaAbstractVideo.class);
 video.produce();
 }
}

工厂方法

介绍

定义：定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类工厂方法让类的实例化推迟到子类中进行

类型：创建型

特点：

创建对象需要大量重复的代码
客户端(应用层)不依赖于产品类实例如何被创建、实现等细节
一个类通过其子类来指定创建哪个对象

优点：

用户只需要关心所需产品对应的工厂,无须关心创建细节
加入新产品符合开闭原则,提高可扩展性

缺点：

类的个数容易过多,增加复杂度
增加了系统的抽象性和理解难度

代码样例

类图

package top.fjy8018.designpattern.pattern.creational.factorymethod;

/**
 * 工厂方法
 *
 * @author F嘉阳
 * @date 2018-09-23 16:13
 */
public abstract class AbstractVideo {
 public abstract void produce();
}

package top.fjy8018.designpattern.pattern.creational.factorymethod;

import sun.misc.Launcher;

import java.util.Collection;

/**
 * 定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中
 * 工厂方法抽象类，只提供契约，对于已知的逻辑可以提供默认实现
 * <p>
 * 提高产品与产品族的拓展性
 * <p>
 * JDK源码样例1：{@link java.net.URLStreamHandlerFactory#createURLStreamHandler(String)} -> {@link Launcher.Factory#createURLStreamHandler(String)}
 * JDK源码样例2：{@link Collection#iterator()}
 *
 * @author F嘉阳
 * @date 2018-09-23 16:16
 */
public abstract class AbstractVideoFactory {
 public abstract AbstractVideo getVideo();
}

package top.fjy8018.designpattern.pattern.creational.factorymethod;

/**
 * @author F嘉阳
 * @date 2018-09-23 20:11
 */
public class JavaAbstractVideoFactory extends AbstractVideoFactory {
 @Override
 public AbstractVideo getVideo() {
 return new JavaVideo();
 }
}

package top.fjy8018.designpattern.pattern.creational.factorymethod;

import lombok.extern.slf4j.Slf4j;

/**
 * 具体的产品
 *
 * @author F嘉阳
 * @date 2018-09-23 16:13
 */
@Slf4j
public class JavaVideo extends AbstractVideo {
 @Override
 public void produce() {
 log.info("生产Java视频");
 }
}

package top.fjy8018.designpattern.pattern.creational.factorymethod;

/**
 * @author F嘉阳
 * @date 2018-09-23 20:11
 */
public class PythonAbstractVideoFactory extends AbstractVideoFactory {
 @Override
 public AbstractVideo getVideo() {
 return new PythonVideo();
 }
}

package top.fjy8018.designpattern.pattern.creational.factorymethod;

import lombok.extern.slf4j.Slf4j;

/**
 * 具体的产品
 *
 * @author F嘉阳
 * @date 2018-09-23 16:14
 */
@Slf4j
public class PythonVideo extends AbstractVideo {
 @Override
 public void produce() {
 log.info("生产Python视频");
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.factorymethod;

import org.junit.jupiter.api.Test;

class AbstractVideoFactoryTest {

 @Test
 void getVideo() {
 AbstractVideoFactory factory = new JavaAbstractVideoFactory();
 factory.getVideo().produce();
 }
}

抽象工厂

介绍

定义:抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口

无须指定它们具体的类

类型：创建型

适用场景

客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码
提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现

优点：

具体产品在应用层代码隔离,无须关心创建细节
将一个系列的产品族统一到一起创建

缺点：

规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口
增加了系统的抽象性和理解难度

抽象工程与普通工厂区分

使用抽象工厂易于扩展产品族

其与工厂方法区别为：抽象工厂关心产品族，工厂方法关系产品等级

代码样例

类图

package top.fjy8018.designpattern.pattern.creational.abstractfactory;

/**
 * 工厂方法
 *
 * @author F嘉阳
 * @date 2018-09-23 16:13
 */
public abstract class AbstractVideo {
 public abstract void produce();
}

package top.fjy8018.designpattern.pattern.creational.abstractfactory;

/**
 * 工厂方法
 *
 * @author F嘉阳
 * @date 2018-09-23 16:13
 */
public abstract class AbstractArticle {
 public abstract void produce();
}

package top.fjy8018.designpattern.pattern.creational.abstractfactory;

/**
 * 抽象工厂：抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个<strong>产品族</strong>中的产品对象
 * 使用抽象工厂易于扩展产品族
 * 但抽象工厂不适于新增产品等级，即新增video同级的产品
 * 其与工厂方法区别为：抽象工厂关心产品族，工厂方法关系产品等级
 *
 * JDK源码样例：{@link java.sql.Connection} 该类的实现类都属于同一个产品族
 *
 * @author F嘉阳
 * @date 2018-09-23 22:43
 */
public interface CourseFactory {
 AbstractVideo video();

 AbstractArticle article();
}

package top.fjy8018.designpattern.pattern.creational.abstractfactory;

import lombok.extern.slf4j.Slf4j;

/**
 * 具体的产品
 *
 * @author F嘉阳
 * @date 2018-09-23 16:13
 */
@Slf4j
public class JavaArticle extends AbstractArticle {
 @Override
 public void produce() {
 log.info("生产Java文章");
 }
}

package top.fjy8018.designpattern.pattern.creational.abstractfactory;

import lombok.extern.slf4j.Slf4j;

/**
 * 具体的产品
 *
 * @author F嘉阳
 * @date 2018-09-23 16:13
 */
@Slf4j
public class JavaVideo extends AbstractVideo {
 @Override
 public void produce() {
 log.info("生产Java视频");
 }
}

package top.fjy8018.designpattern.pattern.creational.abstractfactory;

import lombok.extern.slf4j.Slf4j;

/**
 * 具体的产品
 *
 * @author F嘉阳
 * @date 2018-09-23 16:13
 */
@Slf4j
public class PythonArticle extends AbstractArticle {
 @Override
 public void produce() {
 log.info("生产Python文章");
 }
}

package top.fjy8018.designpattern.pattern.creational.abstractfactory;

import lombok.extern.slf4j.Slf4j;

/**
 * 具体的产品
 *
 * @author F嘉阳
 * @date 2018-09-23 16:14
 */
@Slf4j
public class PythonVideo extends AbstractVideo {
 @Override
 public void produce() {
 log.info("生产Python视频");
 }
}

package top.fjy8018.designpattern.pattern.creational.abstractfactory;

/**
 * 从一个产品工厂生产出来的产品一定属于同一个族
 *
 * @author F嘉阳
 * @date 2018-09-23 22:46
 */
public class JavaCourseFactory implements CourseFactory {
 @Override
 public AbstractVideo video() {
 return new JavaVideo();
 }

 @Override
 public AbstractArticle article() {
 return new JavaArticle();
 }
}

package top.fjy8018.designpattern.pattern.creational.abstractfactory;

/**
 * 从一个产品工厂生产出来的产品一定属于同一个族
 *
 * @author F嘉阳
 * @date 2018-09-23 22:46
 */
public class PythonCourseFactory implements CourseFactory {
 @Override
 public AbstractVideo video() {
 return new PythonVideo();
 }

 @Override
 public AbstractArticle article() {
 return new PythonArticle();
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.abstractfactory;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class CourseFactoryTest {

 @Test
 void test() {
 CourseFactory factory = new JavaCourseFactory();
 factory.article().produce();
 factory.video().produce();
 }
}

建造者

介绍

定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示

用户只需指定需要建造的类型就可以得到它们,建造过程及细节不需要知道

类型：创建型

适用场景

如果一个对象有非常复杂的内部结构(很多属性)
想把复杂对象的创建和使用分离

优点：

封装性好,刨建和使用分离
扩展性好、建造类之间独立、一定程度上解耦

缺点：

产生多余的 Builder对象
产品内部发生变化,建造者都要修改,成本较大

代码样例

类图

package top.fjy8018.designpattern.pattern.creational.builder;

/**
 * 建造者抽象类
 *
 * @author F嘉阳
 * @date 2018-09-25 17:15
 */
public abstract class AbstractCourseBuilder {
 public abstract void courseName(String courseName);

 public abstract void coursePPT(String coursePPT);

 public abstract void courseVideo(String courseVideo);

 /**
 * question & answer
 */
 public abstract void courseQA(String courseQA);

 public abstract BCourse build();
}

package top.fjy8018.designpattern.pattern.creational.builder;

/**
 * 实体类
 *
 * @author F嘉阳
 * @date 2018-09-25 17:13
 */
public class BCourse {
 private String courseName;
 private String coursePPT;
 private String courseVideo;
 /**
 * question & answer
 */
 private String courseQA;

 public String getCourseName() {
 return courseName;
 }

 public void setCourseName(String courseName) {
 this.courseName = courseName;
 }

 public String getCoursePPT() {
 return coursePPT;
 }

 public void setCoursePPT(String coursePPT) {
 this.coursePPT = coursePPT;
 }

 public String getCourseVideo() {
 return courseVideo;
 }

 public void setCourseVideo(String courseVideo) {
 this.courseVideo = courseVideo;
 }

 public String getCourseQA() {
 return courseQA;
 }

 public void setCourseQA(String courseQA) {
 this.courseQA = courseQA;
 }

 @Override
 public String toString() {
 return "BCourse{" +
 "courseName='" + courseName + '\'' +
 ", coursePPT='" + coursePPT + '\'' +
 ", courseVideo='" + courseVideo + '\'' +
 ", courseQA='" + courseQA + '\'' +
 '}';
 }
}

package top.fjy8018.designpattern.pattern.creational.builder;

/**
 * 教练->建造课程
 *
 * @author F嘉阳
 * @date 2018-09-25 18:54
 */
public class Coach {

 private AbstractCourseBuilder builder;

 public Coach(AbstractCourseBuilder builder) {
 this.builder = builder;
 }

 public BCourse createCourse(String courseName, String coursePPT, String courseVideo, String courseQA) {
 builder.courseName(courseName);
 builder.coursePPT(coursePPT);
 builder.courseVideo(courseVideo);
 builder.courseQA(courseQA);
 return builder.build();
 }
}

package top.fjy8018.designpattern.pattern.creational.builder;

/**
 * 建造者实现类
 *
 * @author F嘉阳
 * @date 2018-09-25 17:17
 */
public class CourseBuilder extends AbstractCourseBuilder {

 private BCourse course = new BCourse();

 @Override
 public void courseName(String courseName) {
 course.setCourseName(courseName);
 }

 @Override
 public void coursePPT(String coursePPT) {
 course.setCoursePPT(coursePPT);
 }

 @Override
 public void courseVideo(String courseVideo) {
 course.setCourseVideo(courseVideo);
 }

 @Override
 public void courseQA(String courseQA) {
 course.setCourseQA(courseQA);
 }

 @Override
 public BCourse build() {
 return course;
 }
}

链式调用

package top.fjy8018.designpattern.pattern.creational.builder.chain;

import com.google.common.collect.ImmutableSet;
import org.apache.ibatis.builder.xml.XMLConfigBuilder;
import org.apache.ibatis.parsing.XNode;

import java.io.Reader;

/**
 * 实体类
 * 当只需要构建一个对象时，可以使用建造者，如果构建多个对象或者一类对象，则使用工厂方法或者抽象工厂
 *
 * 用静态内部类建造者，实现链式调用（推荐）
 *
 * JDK源码样例：{@link StringBuilder#append(int)} 和 {@link StringBuffer#append(int)} 区别在于后者对所有append方法加上同步关键字
 * guava源码样例：不可变集合 {@link ImmutableSet.Builder#build()}
 * Spring源码样例：{@link org.springframework.beans.factory.support.BeanDefinitionBuilder}
 * mybatis源码样例：{@link org.apache.ibatis.session.SqlSessionFactoryBuilder#build(Reader)} 封装了读XML的操作
 * 实际调用的是{@link XMLConfigBuilder#parseConfiguration(XNode)} 解析XML节点，将复杂的XML解析过程一次建造完成
 *
 *
 * @author F嘉阳
 * @date 2018-09-25 17:13
 */
public class BuCourse {
 private String courseName;
 private String coursePPT;
 private String courseVideo;
 /**
 * question & answer
 */
 private String courseQA;

 /**
 * 构造器接受静态内部类
 *
 * @param builder
 */
 public BuCourse(BuCourseBuilder builder) {
 this.courseName = builder.courseName;
 this.coursePPT = builder.coursePPT;
 this.courseVideo = builder.courseVideo;
 this.courseQA = builder.courseQA;

 }

 @Override
 public String toString() {
 return "BCourse{" +
 "courseName='" + courseName + '\'' +
 ", coursePPT='" + coursePPT + '\'' +
 ", courseVideo='" + courseVideo + '\'' +
 ", courseQA='" + courseQA + '\'' +
 '}';
 }

 public static class BuCourseBuilder {
 private String courseName;
 private String coursePPT;
 private String courseVideo;
 private String courseQA;

 public BuCourseBuilder courseName(String courseName) {
 this.courseName = courseName;
 return this;
 }

 public BuCourseBuilder coursePPT(String coursePPT) {
 this.coursePPT = coursePPT;
 return this;
 }

 public BuCourseBuilder courseVideo(String courseVideo) {
 this.courseVideo = courseVideo;
 return this;
 }

 public BuCourseBuilder courseQA(String courseQA) {
 this.courseQA = courseQA;
 return this;
 }

 /**
 * 传递静态内部类返回目标对象
 *
 * @return
 */
 public BuCourse build() {
 return new BuCourse(this);
 }

 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.builder;

import com.google.common.collect.ImmutableSet;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import top.fjy8018.designpattern.pattern.creational.builder.chain.BuCourse;

import java.util.Set;

@Slf4j
class CourseBuilderTest {

 @Test
 void coachBuild() {
 Coach coach = new Coach(new CourseBuilder());
 BCourse course = coach.createCourse("Java课程", "课程PPT", "课程视频", "课程问答");
 log.info(course.toString());
 }

 @Test
 void chainBuild() {
 BuCourse course = new BuCourse.BuCourseBuilder()
 .courseName("Java课程")
 .coursePPT("课程PPT")
 .courseVideo("课程视频")
 .courseQA("课程问答")
 .build();
 log.info(course.toString());
 }

 /**
 * 不可变集合源码测试
 */
 @Test
 void ImmutableSetBuild() {
 Set<String> set = ImmutableSet.<String>builder().add("f").add("j").add("y").build();
 log.info(set.toString());
 }
}

单例模式

介绍

定义:保证一个类仅有一个实例,并提供一个全局访问点

适用场景

想确保任何情况下都绝对只有一个实例

优点

在內存里只有一个实例,减少了内存开销
可以避免对资源的多重占用
设置全局访问点,严格控制访问

缺点

没有接口，扩展困难

重点

私有构造器
线程安全
延迟加载
序列化和反序列化安全
反射

代码样例

懒汉单例——线程不安全

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;

/**
 * 懒汉式单例：延迟加载（线程不安全）
 *
 * @author F嘉阳
 * @date 2018-09-24 10:29
 */
@Slf4j
public class LazySingleton {
 private static LazySingleton lazySingleton = null;

 /**
 * 单例模式构造器必须是屏蔽的
 */
 private LazySingleton() {
 }

 /**
 * 线程不安全
 *
 * @return
 */
 public static LazySingleton getInstance() {
 if (lazySingleton == null) {
 log.debug("LazySingleton实例化");
 lazySingleton = new LazySingleton();
 }
 return lazySingleton;
 }

 /**
 * 线程不安全验证
 *
 * @return
 */
 public static LazySingleton getInstance2() throws InterruptedException {
 if (lazySingleton == null) {
 // 使用线程等待模拟复杂实例化过程，让多线程同时进入该方法
 Thread.sleep(1000);
 log.debug("LazySingleton实例化");
 lazySingleton = new LazySingleton();
 }
 return lazySingleton;
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

@Slf4j
class LazySingletonTest {

 /**
 * 懒汉式注重延迟加载，当使用时才实例化
 * 可以使用多线程测试方法或者通过多线程Debug方式测试
 */
 @Test
 void getInstanceOneThread() {
 LazySingleton lazySingleton = LazySingleton.getInstance();

 }

 @Test
 void getInstanceMutilThread() throws InterruptedException {

 Thread thread1 = new Thread(new MyRunnable());
 Thread thread2 = new Thread(new MyRunnable());

 thread1.start();
 thread2.start();

 Thread.sleep(3000);
 log.debug("finish");

 }

 private class MyRunnable implements Runnable {
 @Override
 public void run() {
 LazySingleton lazySingleton = null;
 try {
 lazySingleton = LazySingleton.getInstance2();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 log.info(" " + lazySingleton);
 }
 }
}

懒汉单例——线程安全

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;

/**
 * 懒汉式单例：延迟加载（线程安全）
 *
 * @author F嘉阳
 * @date 2018-09-24 10:29
 */
@Slf4j
public class LazySingletonSynchronized {
 private static LazySingletonSynchronized lazySingleton = null;

 /**
 * 单例模式构造器必须是屏蔽的
 */
 private LazySingletonSynchronized() {
 log.debug(LazySingletonSynchronized.class.getSimpleName() + "构造器实例化");
 }

 /**
 * synchronized确保线程安全
 * synchronized用于静态方法是对class文件加锁，用于普通方法则是对堆内存中的实例方法加锁
 * synchronized(LazySingletonSynchronized.class)与在方法名上加锁效果一致
 *
 * @return
 */
 public static LazySingletonSynchronized getInstance() {
 synchronized (LazySingletonSynchronized.class) {
 if (lazySingleton == null) {
 log.debug("LazySingletonSynchronized实例化");
 lazySingleton = new LazySingletonSynchronized();
 }
 }
 return lazySingleton;
 }

 /**
 * 线程安全验证
 *
 * @return
 */
 public synchronized static LazySingletonSynchronized getInstance2() throws InterruptedException {
 if (lazySingleton == null) {
 // 使用线程等待模拟复杂实例化过程，让多线程同时进入该方法
 Thread.sleep(1000);
 log.debug("LazySingletonSynchronized实例化");
 lazySingleton = new LazySingletonSynchronized();
 }
 return lazySingleton;
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

@Slf4j
class LazySingletonSynchronizedTest {

 @Test
 void getInstance() {
 LazySingletonSynchronized.getInstance();
 }

 @Test
 void getInstance2() throws InterruptedException {
 Thread thread1 = new Thread(new LazySingletonSynchronizedTest.MyRunnable());
 Thread thread2 = new Thread(new LazySingletonSynchronizedTest.MyRunnable());

 thread1.start();
 thread2.start();

 Thread.sleep(3000);
 log.debug("finish");
 }

 private class MyRunnable implements Runnable {
 @Override
 public void run() {
 LazySingletonSynchronized lazySingleton = null;
 try {
 lazySingleton = LazySingletonSynchronized.getInstance2();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 log.info(" " + lazySingleton);
 }
 }
}

懒汉单例——双重校验锁（线程安全）

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;

/**
 * 懒汉式单例：延迟加载（双重校验锁保证线程安全）
 *
 * @author F嘉阳
 * @date 2018-09-24 10:29
 */
@Slf4j
public class LazyDoubleCheckSingleton {
 /**
 * volatile确保内存可见性，同时禁止指令重排
 * volatile会增加一定的汇编代码：
 * 1. 将当前处理器缓存行的数据写回系统内存
 * 2. 写回系统内存后使其他处理器缓存的地址无效，迫使其他处理器从共享内存中同步最新数据
 */
 private volatile static LazyDoubleCheckSingleton lazySingleton = null;

 /**
 * 单例模式构造器必须是屏蔽的
 */
 private LazyDoubleCheckSingleton() {
 }

 /**
 * 双重校验锁确保线程安全
 * 存在指令重排序导致的隐患
 *
 * @return
 */
 public static LazyDoubleCheckSingleton getInstance() {
 // 首次检查
 if (lazySingleton == null) {
 synchronized (LazyDoubleCheckSingleton.class) {
 // 再次检查，在此处加锁比对方法加锁开销更小，因为如果首次检查不为空则直接返回
 if (lazySingleton == null) {
 log.debug("LazyDoubleCheckSingleton实例化");
 lazySingleton = new LazyDoubleCheckSingleton();
 // 实例化包含三个过程，这三个过程可能由于指令重排序导致执行顺序打乱
 // 但Java底层只保证三个过程在单线程内顺序一致
 // 1.分配内存
 // 2.初始化
 // 3.LazyDoubleCheckSingleton对象指向刚分配的内存地址
 }
 }
 }
 return lazySingleton;
 }

 /**
 * 线程安全验证
 *
 * @return
 */
 public static LazyDoubleCheckSingleton getInstance2() throws InterruptedException {
 if (lazySingleton == null) {
 // 使用线程等待模拟复杂实例化过程，让多线程同时进入该方法
 Thread.sleep(1000);
 synchronized (LazyDoubleCheckSingleton.class) {
 // 再次检查，在此处加锁比对方法加锁开销更小，因为如果首次检查不为空则直接返回
 if (lazySingleton == null) {
 log.debug("LazyDoubleCheckSingleton实例化");
 lazySingleton = new LazyDoubleCheckSingleton();
 }
 }
 }
 return lazySingleton;
 }
}

静态内部类——延迟加载

原理

JVM在类初始化时会加锁，使用初始化锁可以同步多个线程对一个类的初始化，确保了线程安全类初始化时机

一. 主动引用

虚拟机规范中并没有强制约束何时进行加载，但是规范严格规定了有且只有下列五种情况必须对类进行初始化（加载、验证、准备都会随之发生）：

遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类没有进行过初始化，则必须先触发其初始化。最常见的生成这 4 条指令的场景是： (1) 使用 new 关键字实例化对象的时候； (2) 读取或赋值一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）的时候； (3) 以及调用一个类的静态方法的时候。 (4) 使用一个类的非常量静态成员 (5) 若一个类是顶级类，且该类有嵌套的断言语句（少见）
使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行初始化，则需要先触发其初始化。
当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类；
当使用JDK 1.7 的动态语言支持时，如果一个java.lang.invoke.MethodHandle 实例最后的解析结果为 REF_getStatic, REF_putStatic, REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化；

二. 被动引用

以上 5 种场景中的行为称为对一个类进行主动引用。除此之外，所有引用类的方式都不会触发初始化，称为被动引用。被动引用的常见例子包括：

通过子类引用父类的静态字段，不会导致子类初始化。 System.out.println(SubClass.value); // value 字段在 SuperClass 中定义
通过数组定义来引用类，不会触发此类的初始化。该过程会对数组类进行初始化，数组类是一个由虚拟机自动生成的、直接继承自 Object的子类，其中包含了数组的属性和方法。 SuperClass[] sca = new SuperClass[10];
常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。 System.out.println(ConstClass.HELLOWORLD);

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;

/**
 * 懒汉单例：静态内部类实现（线程安全）
 * 使用静态内部类可以屏蔽类实例化的重排序,因为非构造线程不允许看到指令重排序
 *
 * @author F嘉阳
 * @date 2018-09-24 13:11
 */
@Slf4j
public class StaticInnerClassSingleton {
 /**
 * 私有构造器是单例必须的
 */
 private StaticInnerClassSingleton() {
 log.debug(StaticInnerClassSingleton.class.getSimpleName() + "构造器实例化");
 }

 /**
 * 开发单例入口
 *
 * @return
 */
 public static StaticInnerClassSingleton getInstance() {
 log.debug(StaticInnerClassSingleton.class.getSimpleName() + "内部类实例化");
 return InnerClass.staticInnerClassSingleton;
 }

 /**
 * 静态内部类
 */
 private static class InnerClass {
 private static StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
 }
}

恶汉单例

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;

import java.io.Serializable;

/**
 * 单例模式：饿汉式（类加载时初始化）
 * 优点：写法简单，类加载时初始化，线程安全
 * 缺点：若类不被使用则会造成内存浪费
 *
 * JDK源码样例：{@link Runtime} 其实例在类加载时实例化并通过{@link Runtime#getRuntime()} 获取
 *
 * @author F嘉阳
 * @date 2018-09-24 15:38
 */
@Slf4j
public class HungrySingleton implements Serializable {
 /**
 * 类加载时初始化
 * 声明final（可选），只有在类加载时初始化才能声明为final，故懒汉式不能声明为final
 */
 private static final HungrySingleton HUNGRYSINGLETON;

 static {
 log.debug(HungrySingleton.class.getSimpleName() + "静态块实例化");
 HUNGRYSINGLETON = new HungrySingleton();
 }

 /**
 * 该构造器会在反射攻击时调用
 */
 private HungrySingleton() {
 log.debug(HungrySingleton.class.getSimpleName() + "构造器实例化");
 }

 public static HungrySingleton getInstance() {
 return HUNGRYSINGLETON;
 }
}

恶汉单例——克隆攻击防御

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;

import java.io.Serializable;

/**
 * 单例模式：饿汉式
 * 克隆攻击改进
 * 要么不要实现克隆接口，要么不要调用父类的克隆实现，转而自己实现克隆方法
 *
 * @author F嘉阳
 * @date 2018-09-24 15:38
 */
@Slf4j
public class HungrySingletonCloneableImprove implements Serializable, Cloneable {

 private static final HungrySingletonCloneableImprove HUNGRYSINGLETON;

 static {
 log.debug(HungrySingletonCloneableImprove.class.getSimpleName() + "静态块实例化");
 HUNGRYSINGLETON = new HungrySingletonCloneableImprove();
 }

 private HungrySingletonCloneableImprove() {
 if (HUNGRYSINGLETON != null) {
 throw new RuntimeException("单例模式禁止反射调用");
 }
 log.debug(HungrySingletonCloneableImprove.class.getSimpleName() + "构造器实例化");
 }

 public static HungrySingletonCloneableImprove getInstance() {
 return HUNGRYSINGLETON;
 }

 @Override
 protected Object clone() throws CloneNotSupportedException {
 return HUNGRYSINGLETON;
 }

 /**
 * 解决序列化攻击问题
 *
 * @return
 */
 private Object readResolve() {
 log.debug("序列化获取对象");
 return HUNGRYSINGLETON;
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Method;

/**
 * 单例模式克隆攻击
 *
 * @author F嘉阳
 * @date 2018-09-25 22:40
 */
@Slf4j
class SingletonCloneAttack {

 /**
 * 改进前
 */
 @Test
 void before() throws Exception {
 // 正常方式获取单例
 HungrySingletonReflectImprove instance = HungrySingletonReflectImprove.getInstance();
 Method method = instance.getClass().getDeclaredMethod("clone");
 // 由于原本的访问权限为protect，故要改变访问权限
 method.setAccessible(true);
 // 克隆实例
 HungrySingletonReflectImprove instance2 = (HungrySingletonReflectImprove) method.invoke(instance);
 // 验证
 log.info(Integer.toHexString(instance.hashCode()));
 log.info(Integer.toHexString(instance2.hashCode()));
 // 返回false，克隆攻击成功
 log.info(String.valueOf(instance == instance2));
 }

 /**
 * 改进后
 */
 @Test
 void after() throws Exception {
 // 正常方式获取单例
 HungrySingletonCloneableImprove instance = HungrySingletonCloneableImprove.getInstance();
 Method method = instance.getClass().getDeclaredMethod("clone");
 // 由于原本的访问权限为protect，故要改变访问权限
 method.setAccessible(true);
 // 克隆实例
 HungrySingletonCloneableImprove instance2 = (HungrySingletonCloneableImprove) method.invoke(instance);
 // 验证
 log.info(Integer.toHexString(instance.hashCode()));
 log.info(Integer.toHexString(instance2.hashCode()));
 // 返回false，克隆攻击成功
 log.info(String.valueOf(instance == instance2));
 }
}

单例模式序列化攻击

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * 单例模式序列化攻击
 */
@Slf4j
class SingletonSerializableAttackTest {

 private static final String FILE_NAME = "tmp/singleton_obj.dat";

 @BeforeEach
 void init() {
 File dir = new File("tmp");
 boolean mkdir = false;
 if (!dir.exists()) {
 mkdir = dir.mkdir();
 if (mkdir) {
 log.debug("文件夹新建成功");
 } else {
 log.error("文件夹新建失败");
 }
 }

 File file = new File(FILE_NAME);
 file.deleteOnExit();
 }

 /**
 * 枚举类序列化攻击
 * 原因：{@link ObjectInputStream#readEnum(boolean)} 中对枚举的执行过程是2000 - 2007行
 * 通过枚举的类和名称来获取对象实例，因为枚举的名称在枚举中唯一，所以没有实例化的动作，保证了单例可靠性
 *
 * @throws IOException
 */
 @Test
 void EnumInstanceGetInstance() throws Exception {

 EnumInstance singleton = EnumInstance.getInstance();
 singleton.setData(new Object());

 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_NAME));
 oos.writeObject(singleton);

 ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME));
 EnumInstance newInstance = (EnumInstance) ois.readObject();

 log.info("写入前：" + singleton.getData());
 log.info("读出后：" + newInstance.getData());
 // 此处结果为false，说明是两个不同的对象
 log.info(String.valueOf(newInstance.getData() == singleton.getData()));

 oos.close();
 ois.close();
 }

 /**
 * 通过序列化测试写入和读出后是否属于同一个对象
 * 根据单例模式原则，永远只有一个实例化的对象
 *
 * @throws IOException
 */
 @Test
 void getInstanceBefore() throws IOException, ClassNotFoundException {

 HungrySingleton hungrySingleton = HungrySingleton.getInstance();
 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_NAME));
 oos.writeObject(hungrySingleton);

 ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME));
 HungrySingleton newInstance = (HungrySingleton) ois.readObject();

 log.info("写入前：" + hungrySingleton);
 log.info("读出后：" + newInstance);
 // 此处结果为false，说明是两个不同的对象
 log.info(String.valueOf(newInstance == hungrySingleton));

 oos.close();
 ois.close();
 }

 @Test
 void getInstanceAfter() throws IOException, ClassNotFoundException {
 HungrySingletonSerializableImprove before = HungrySingletonSerializableImprove.getInstance();
 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_NAME));
 oos.writeObject(before);

 ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME));
 HungrySingletonSerializableImprove after = (HungrySingletonSerializableImprove) ois.readObject();

 log.info("写入前：" + before);
 log.info("读出后：" + after);
 // 此处结果为true，说明是同一个对象
 log.info(String.valueOf(before == after));

 oos.close();
 ois.close();
 }
}

懒汉单例——反射攻击

测试类

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/**
 * 单例模式反射攻击
 */
@Slf4j
class SingletonReflectAttack {
 /**
 * 修复前懒汉式反射攻击
 * 由于反射攻击足够强大，对于非类加载时实例化的单例模式，是无法彻底防止反射攻击的
 *
 * @throws NoSuchMethodException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws InstantiationException
 */
 @Test
 void lazySingletonGetInstanceBefore() throws Exception {
 Class clazz = LazySingletonSynchronized.class;
 Constructor constructor = clazz.getDeclaredConstructor();
 // 打开访问权限
 constructor.setAccessible(true);
 // 通过反射获取实例
 LazySingletonSynchronized reflectInstance = (LazySingletonSynchronized) constructor.newInstance();
 // 通过正常方式获取
 LazySingletonSynchronized instance = LazySingletonSynchronized.getInstance();

 // 判断是否同一个对象
 log.info("反射方式：" + reflectInstance);
 log.info("正常方式：" + instance);
 // 此处结果为false，说明是两个不同的对象
 log.info(String.valueOf(reflectInstance == instance));
 }
}

懒汉单例——线程安全、反射攻击防御1

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;

/**
 * 懒汉式单例：延迟加载（线程安全）
 *
 * @author F嘉阳
 * @date 2018-09-24 10:29
 */
@Slf4j
public class LazySingletonSynchronizedReflectImprove1 {
 private static LazySingletonSynchronizedReflectImprove1 lazySingleton = null;

 /**
 * 单例模式构造器必须是屏蔽的
 * 对于非类加载时实例化的单例该方法防止反射攻击无效
 * 因为当反射先执行，则会实例化一个或者N个对象
 * 当正常方式获取单例时，又会实例化多一个对象
 */
 private LazySingletonSynchronizedReflectImprove1() {
 if (lazySingleton != null) {
 throw new RuntimeException("单例模式禁止反射调用");
 }
 log.debug(LazySingletonSynchronizedReflectImprove1.class.getSimpleName() + "构造器实例化");
 }

 /**
 * synchronized确保线程安全
 * synchronized用于静态方法是对class文件加锁，用于普通方法则是对堆内存中的实例方法加锁
 * synchronized(LazySingletonSynchronized.class)与在方法名上加锁效果一致
 *
 * @return
 */
 public static LazySingletonSynchronizedReflectImprove1 getInstance() {
 synchronized (LazySingletonSynchronizedReflectImprove1.class) {
 if (lazySingleton == null) {
 log.debug(LazySingletonSynchronizedReflectImprove1.class.getSimpleName() + "实例化");
 lazySingleton = new LazySingletonSynchronizedReflectImprove1();
 }
 }
 return lazySingleton;
 }

 /**
 * 线程安全验证
 *
 * @return
 */
 public synchronized static LazySingletonSynchronizedReflectImprove1 getInstance2() throws InterruptedException {
 if (lazySingleton == null) {
 // 使用线程等待模拟复杂实例化过程，让多线程同时进入该方法
 Thread.sleep(1000);
 log.debug(LazySingletonSynchronizedReflectImprove1.class.getSimpleName() + "实例化");
 lazySingleton = new LazySingletonSynchronizedReflectImprove1();
 }
 return lazySingleton;
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/**
 * 单例模式反射攻击
 */
@Slf4j
class SingletonReflectAttack {
 /**
 * 用构造器防止单例模式被反射攻击
 * 失败！
 *
 * @throws NoSuchMethodException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws InstantiationException
 */
 @Test
 void lazySingletonGetInstanceAfter1() throws Exception {
 Class clazz = LazySingletonSynchronizedReflectImprove1.class;
 Constructor constructor = clazz.getDeclaredConstructor();
 // 打开访问权限
 constructor.setAccessible(true);
 // 通过反射获取实例
 LazySingletonSynchronizedReflectImprove1 reflectInstance = (LazySingletonSynchronizedReflectImprove1) constructor.newInstance();
 // 通过正常方式获取
 LazySingletonSynchronizedReflectImprove1 instance = LazySingletonSynchronizedReflectImprove1.getInstance();

 // 判断是否同一个对象
 log.info("反射方式：" + reflectInstance);
 log.info("正常方式：" + instance);
 // 此处结果为false，说明是两个不同的对象
 log.info(String.valueOf(reflectInstance == instance));
 }
}

懒汉单例——线程安全、反射攻击防御2

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;

/**
 * 懒汉式单例：延迟加载（线程安全）
 *
 * @author F嘉阳
 * @date 2018-09-24 10:29
 */
@Slf4j
public class LazySingletonSynchronizedReflectImprove2 {
 private static LazySingletonSynchronizedReflectImprove2 lazySingleton = null;

 /**
 * 是否能实例化标志
 * 若能实例化，则为{@code true}
 */
 private static boolean flag = true;

 /**
 * 单例模式构造器必须是屏蔽的
 */
 private LazySingletonSynchronizedReflectImprove2() {
 if (!flag) {
 throw new RuntimeException("单例模式禁止反射调用");
 }
 flag = false;
 log.debug(LazySingletonSynchronizedReflectImprove2.class.getSimpleName() + "构造器实例化");
 }

 /**
 * synchronized确保线程安全
 * synchronized用于静态方法是对class文件加锁，用于普通方法则是对堆内存中的实例方法加锁
 * synchronized(LazySingletonSynchronized.class)与在方法名上加锁效果一致
 *
 * @return
 */
 public static LazySingletonSynchronizedReflectImprove2 getInstance() {
 synchronized (LazySingletonSynchronizedReflectImprove2.class) {
 if (lazySingleton == null) {
 log.debug(LazySingletonSynchronizedReflectImprove2.class.getSimpleName() + "实例化");
 lazySingleton = new LazySingletonSynchronizedReflectImprove2();
 }
 }
 return lazySingleton;
 }

 /**
 * 线程安全验证
 *
 * @return
 */
 public synchronized static LazySingletonSynchronizedReflectImprove2 getInstance2() throws InterruptedException {
 if (lazySingleton == null) {
 // 使用线程等待模拟复杂实例化过程，让多线程同时进入该方法
 Thread.sleep(1000);
 log.debug(LazySingletonSynchronizedReflectImprove2.class.getSimpleName() + "实例化");
 lazySingleton = new LazySingletonSynchronizedReflectImprove2();
 }
 return lazySingleton;
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/**
 * 单例模式反射攻击
 */
@Slf4j
class SingletonReflectAttack {
 /**
 * 用标识位防止单例模式被反射攻击
 * 失败！
 *
 * @throws NoSuchMethodException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws InstantiationException
 */
 @Test
 void lazySingletonGetInstanceAfter2() throws Exception {
 Class clazz = LazySingletonSynchronizedReflectImprove2.class;
 Constructor constructor = clazz.getDeclaredConstructor();
 // 打开访问权限
 constructor.setAccessible(true);

 // 首先通过正常方式获取
 LazySingletonSynchronizedReflectImprove2 instance = LazySingletonSynchronizedReflectImprove2.getInstance();

 // 通过反射修改成员变量
 Field flag = clazz.getDeclaredField("flag");
 // 修改访问权限
 flag.setAccessible(true);
 flag.set(clazz, true);

 // 通过反射获取实例
 LazySingletonSynchronizedReflectImprove2 reflectInstance = (LazySingletonSynchronizedReflectImprove2) constructor.newInstance();

 // 判断是否同一个对象
 log.info("反射方式：" + reflectInstance);
 log.info("正常方式：" + instance);
 // 此处结果为false，说明是两个不同的对象
 log.info(String.valueOf(reflectInstance == instance));
 }
}

恶汉单例——反射攻击防御

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;

import java.io.Serializable;

/**
 * 单例模式：饿汉式
 * 反射攻击改进
 * 对于在类加载时进行初始化的单例，可以用该方法解决反射攻击问题
 *
 * @author F嘉阳
 * @date 2018-09-24 15:38
 */
@Slf4j
public class HungrySingletonReflectImprove implements Serializable, Cloneable {

 private static final HungrySingletonReflectImprove HUNGRYSINGLETON;

 static {
 log.debug(HungrySingletonReflectImprove.class.getSimpleName() + "静态块实例化");
 HUNGRYSINGLETON = new HungrySingletonReflectImprove();
 }

 private HungrySingletonReflectImprove() {
 if (HUNGRYSINGLETON != null) {
 throw new RuntimeException("单例模式禁止反射调用");
 }
 log.debug(HungrySingletonReflectImprove.class.getSimpleName() + "构造器实例化");
 }

 @Override
 protected Object clone() throws CloneNotSupportedException {
 return super.clone();
 }

 public static HungrySingletonReflectImprove getInstance() {
 return HUNGRYSINGLETON;
 }

 /**
 * 解决序列化攻击问题
 *
 * @return
 */
 private Object readResolve() {
 log.debug("序列化获取对象");
 return HUNGRYSINGLETON;
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/**
单例模式反射攻击
 */
@Slf4j
class SingletonReflectAttack {

 /**
 * 修复前饿汉式攻击
 *
 * @throws NoSuchMethodException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws InstantiationException
 */
 @Test
 void hungrySingletonGetInstanceBefore() throws Exception {
 Class clazz = HungrySingletonSerializableImprove.class;
 Constructor constructor = clazz.getDeclaredConstructor();
 // 打开访问权限
 constructor.setAccessible(true);
 // 通过反射获取实例
 HungrySingletonSerializableImprove reflectInstance = (HungrySingletonSerializableImprove) constructor.newInstance();
 // 通过正常方式获取
 HungrySingletonSerializableImprove instance = HungrySingletonSerializableImprove.getInstance();

 // 判断是否同一个对象
 log.info("反射方式：" + reflectInstance);
 log.info("正常方式：" + instance);
 // 此处结果为false，说明是两个不同的对象
 log.info(String.valueOf(reflectInstance == instance));
 }

 /**
 * 修复后饿汉式攻击
 *
 * @throws NoSuchMethodException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws InstantiationException
 */
 @Test
 void hungrySingletonGetInstanceAfter() throws Exception {
 Class clazz = HungrySingletonReflectImprove.class;
 Constructor constructor = clazz.getDeclaredConstructor();
 // 打开访问权限
 constructor.setAccessible(true);
 // 通过反射获取实例，此处抛出异常
 HungrySingletonReflectImprove reflectInstance = (HungrySingletonReflectImprove) constructor.newInstance();
 // 通过正常方式获取
 HungrySingletonReflectImprove instance = HungrySingletonReflectImprove.getInstance();

 // 判断是否同一个对象
 log.info("反射方式：" + reflectInstance);
 log.info("正常方式：" + instance);
 log.info(String.valueOf(reflectInstance == instance));
 }
}

静态内部类——反射攻击防御

package top.fjy8018.designpattern.pattern.creational.singleton;


import lombok.extern.slf4j.Slf4j;

/**
 * 懒汉单例：静态内部类实现（线程安全）
 * 反射攻击改进
 *
 * @author F嘉阳
 * @date 2018-09-24 13:11
 */
@Slf4j
public class StaticInnerClassSingletonReflectImprove {
 /**
 * 私有构造器是单例必须的
 */
 private StaticInnerClassSingletonReflectImprove() {
 if (InnerClass.staticInnerClassSingleton != null) {
 throw new RuntimeException("单例模式禁止反射调用");
 }
 log.debug(StaticInnerClassSingletonReflectImprove.class.getSimpleName() + "构造器实例化");
 }

 /**
 * 开发单例入口
 *
 * @return
 */
 public static StaticInnerClassSingletonReflectImprove getInstance() {
 log.debug(StaticInnerClassSingletonReflectImprove.class.getSimpleName() + "内部类实例化");
 return InnerClass.staticInnerClassSingleton;
 }

 /**
 * 静态内部类
 * <p>
 * 原理：
 * <strong>JVM在类初始化时会加锁，使用初始化锁可以同步多个线程对一个类的初始化，确保了线程安全</strong>
 * 类初始化时机
 * 一. 主动引用
 * 虚拟机规范中并没有强制约束何时进行加载，但是规范严格规定了有且只有下列五种情况必须对类进行初始化（加载、验证、准备都会随之发生）：
 * 1. 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类没有进行过初始化，则必须先触发其初始化。
 * 最常见的生成这 4 条指令的场景是：
 * (1) 使用 new 关键字实例化对象的时候；
 * (2) 读取或赋值一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）的时候；
 * (3) 以及调用一个类的静态方法的时候。
 * (4) 使用一个类的非常量静态成员
 * (5) 若一个类是顶级类，且该类有嵌套的断言语句（少见）
 * <p>
 * 2. 使用 {@link java.lang.reflect} 包的方法对类进行反射调用的时候，如果类没有进行初始化，则需要先触发其初始化。
 * 3. 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
 * 4. 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类；
 * 5. 当使用 JDK 1.7 的动态语言支持时，如果一个 {@link java.lang.invoke.MethodHandle}
 * 实例最后的解析结果为 REF_getStatic, REF_putStatic, REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化；
 * <p>
 * 二. 被动引用
 * 以上 5 种场景中的行为称为对一个类进行主动引用。除此之外，所有引用类的方式都不会触发初始化，称为被动引用。被动引用的常见例子包括：
 * <p>
 * 1. 通过子类引用父类的静态字段，不会导致子类初始化。
 * System.out.println(SubClass.value); // value 字段在 SuperClass 中定义
 * 2. 通过数组定义来引用类，不会触发此类的初始化。该过程会对数组类进行初始化，数组类是一个由虚拟机自动生成的、直接继承自 {@link Object} 的子类，其中包含了数组的属性和方法。
 * SuperClass[] sca = new SuperClass[10];
 * 3. 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
 * System.out.println(ConstClass.HELLOWORLD);
 */
 private static class InnerClass {
 private static StaticInnerClassSingletonReflectImprove staticInnerClassSingleton = new StaticInnerClassSingletonReflectImprove();
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/**
单例模式反射攻击
 */
@Slf4j
class SingletonReflectAttack {

 /**
 * 修复前懒汉式攻击
 *
 * @throws NoSuchMethodException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws InstantiationException
 */
 @Test
 void staticInnerClassSingletonGetInstanceBefore() throws Exception {
 Class clazz = StaticInnerClassSingleton.class;
 Constructor constructor = clazz.getDeclaredConstructor();
 // 打开访问权限
 constructor.setAccessible(true);
 // 通过反射获取实例
 StaticInnerClassSingleton reflectInstance = (StaticInnerClassSingleton) constructor.newInstance();
 // 通过正常方式获取
 StaticInnerClassSingleton instance = StaticInnerClassSingleton.getInstance();

 // 判断是否同一个对象
 log.info("反射方式：" + reflectInstance);
 log.info("正常方式：" + instance);
 // 此处结果为false，说明是两个不同的对象
 log.info(String.valueOf(reflectInstance == instance));
 }

 /**
 * 修复后懒汉式攻击
 *
 * @throws NoSuchMethodException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws InstantiationException
 */
 @Test
 void staticInnerClassSingletonGetInstanceAfter() throws Exception {
 Class clazz = StaticInnerClassSingletonReflectImprove.class;
 Constructor constructor = clazz.getDeclaredConstructor();
 // 打开访问权限
 constructor.setAccessible(true);
 // 通过反射获取实例
 StaticInnerClassSingletonReflectImprove reflectInstance = (StaticInnerClassSingletonReflectImprove) constructor.newInstance();
 // 通过正常方式获取
 StaticInnerClassSingletonReflectImprove instance = StaticInnerClassSingletonReflectImprove.getInstance();

 // 判断是否同一个对象
 log.info("反射方式：" + reflectInstance);
 log.info("正常方式：" + instance);
 log.info(String.valueOf(reflectInstance == instance));
 }
}

枚举单例（effective java最佳实践）

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;

/**
 * 枚举单例模式（effective Java推荐）
 * 枚举类天生可序列化，有效防止序列化攻击
 * <p>
 * 通过反编译可知：
 * 1. 枚举类的通过final修饰，不能被继承
 * 2. 其构造器私有，不能被调用，如果通过反射强制调用，在newInstance方法中会抛出异常
 * 3. 枚举变量声明为final和static
 * 4. 枚举变量通过静态块实例化（类似饿汉式），所以线程安全
 *
 * @author F嘉阳
 * @date 2018-09-24 20:30
 */
@Slf4j
public enum EnumInstance {
 /**
 * 单例枚举
 */
 INSTANCE {
 @Override
 protected void logTest() {
 log.info(EnumInstance.class.getSimpleName() + "打印输出");
 }
 };

 public static EnumInstance getInstance() {
 return INSTANCE;
 }

 /**
 * 目标实例化对象
 */
 private Object data;

 public Object getData() {
 return data;
 }

 public void setData(Object data) {
 this.data = data;
 }

 // 提供外部访问方法入口
 protected abstract void logTest();
}

测试类

package top.fjy8018.designpattern.pattern.creational.singleton;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class EnumInstanceTest {

 @Test
 void logTest() {
 EnumInstance instance = EnumInstance.getInstance();
 instance.logTest();
 }
}

反射攻击测试

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/**
单例模式反射攻击
 */
@Slf4j
class SingletonReflectAttack {

 /**
 * 枚举单例反射攻击
 * 枚举类只有一个构造器 {@link Enum#Enum(String, int)}
 * 由于{@link Constructor#newInstance(Object...)} 416行指明枚举类不允许反射实例化，强制实例化会抛{@link IllegalArgumentException}
 * 从底层保证了枚举类无法被反射攻击
 *
 * @throws NoSuchMethodException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws InstantiationException
 */
 @Test
 void enumInstanceGetInstance() throws Exception {
 Class clazz = EnumInstance.class;
 // 由于枚举类没有无参构造器，需要指定参数
 Constructor constructor = clazz.getDeclaredConstructor(String.class, int.class);

 // 打开访问权限
 constructor.setAccessible(true);
 // 通过反射获取实例
 EnumInstance reflectInstance = (EnumInstance) constructor.newInstance("fjy", 123);
 // 通过正常方式获取
 EnumInstance instance = EnumInstance.getInstance();

 // 判断是否同一个对象
 log.info("反射方式：" + reflectInstance.getData());
 log.info("正常方式：" + instance.getData());
 // 此处结果为false，说明是两个不同的对象
 log.info(String.valueOf(reflectInstance.getData() == instance.getData()));
 }
}

容器单例——HashMap

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.config.AbstractFactoryBean;

import java.awt.*;
import java.util.HashMap;
import java.util.Map;

/**
 * 基于容器（集合）实现单例
 * 适用于类加载时有多个对象需要实例化场景
 *
 * JDK源码样例：{@link Desktop#getDesktop()}
 * 其{@link sun.awt.AppContext} 通过{@link HashMap}实现，使用同步保证单例线程安全
 * Spring 源码样例：{@link AbstractFactoryBean#getObject()} 在156行判断当前类是否已经实例化
 * 若没有实例化则在{@link AbstractFactoryBean#getEarlySingletonInstance()}中通过代理方式实例化对象
 *
 * @author F嘉阳
 * @date 2018-09-24 22:31
 */
@Slf4j
public class ContainerSingleton {
 private static Map<String, Object> instancesMap = new HashMap<>();

 private ContainerSingleton() {
 }

 public static void putInstance(String key, Object instance) {
 if (StringUtils.isNotBlank(key) && instance != null) {
 if (!instancesMap.containsKey(key)) {
 instancesMap.put(key, instance);
 }
 }
 }

 public static Object getInstance(String key) {
 return instancesMap.get(key);
 }

 /**
 * 线程安全测试
 *
 * @param key
 * @param instance
 */
 public static void putInstance2(String key, Object instance) throws InterruptedException {
 if (StringUtils.isNotBlank(key) && instance != null) {
 if (!instancesMap.containsKey(key)) {
 Thread.sleep(1000);
 log.debug("放入实例：" + instance);
 instancesMap.put(key, instance);
 }
 }
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

@Slf4j
class ContainerSingletonTest {

 /**
 * 直接使用{@link java.util.HashMap} 只会放入一个值，但后面放的值会覆盖首次放入的值
 *
 * @throws InterruptedException
 */
 @Test
 void getInstanceHashMapUnsafe() throws InterruptedException {
 Thread thread1 = new Thread(new MyHashMapRunnable());
 Thread thread2 = new Thread(new MyHashMapRunnable());

 thread1.start();
 thread2.start();

 Thread.sleep(2000);
 log.debug("finish");
 }

 private class MyHashMapRunnable implements Runnable {
 @Override
 public void run() {
 try {
 ContainerSingleton.putInstance2("object", new Object());
 // 等待其他线程放入对象后取值
 Thread.sleep(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 Object singleton = ContainerSingleton.getInstance("object");
 log.info(" " + singleton);
 }
 }

 private class MyHashtableRunnable implements Runnable {
 @Override
 public void run() {
 try {
 ContainerSingletonHashtable.putInstance2("object", new Object());
 // 等待其他线程放入对象后取值
 Thread.sleep(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }

 Object singleton = ContainerSingletonHashtable.getInstance("object");
 log.info(" " + singleton);
 }
 }
}

容器单例——Hashtable（不推荐）

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.util.Hashtable;
import java.util.Map;

/**
 * 基于容器（集合）实现单例（线程不安全）
 * {@link Hashtable} 实现（不建议）
 *
 * @author F嘉阳
 * @date 2018-09-24 22:31
 */
@Slf4j
public class ContainerSingletonHashtable {
 private static Map<String, Object> instancesMap = new Hashtable<>();

 private ContainerSingletonHashtable() {
 }

 public static void putInstance(String key, Object instance) {
 if (StringUtils.isNotBlank(key) && instance != null) {
 if (!instancesMap.containsKey(key)) {
 instancesMap.put(key, instance);
 }
 }
 }

 public static Object getInstance(String key) {
 return instancesMap.get(key);
 }

 /**
 * 线程安全测试
 *
 * @param key
 * @param instance
 */
 public static void putInstance2(String key, Object instance) throws InterruptedException {
 if (StringUtils.isNotBlank(key) && instance != null) {
 if (!instancesMap.containsKey(key)) {
 Thread.sleep(1000);
 log.debug("放入实例：" + instance);
 instancesMap.put(key, instance);
 }
 }
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

@Slf4j
class ContainerSingletonTest {
 /**
 * 使用{@link java.util.Hashtable} {@link java.util.concurrent.ConcurrentHashMap}可以控制并发，只会放入一个值，但后面放的值会覆盖首次放入的值，效果实际同{@link java.util.HashMap}
 * 对于Hashtable，在一定程度保证线程安全，但影响了性能
 * 对于ConcurrentHashMap，由于使用了静态的ConcurrentHashMap，并直接操作了map，也不是绝对线程安全
 *
 * @throws InterruptedException
 */
 @Test
 void getInstanceHashtableUnsafe() throws InterruptedException {
 Thread thread1 = new Thread(new MyHashtableRunnable());
 Thread thread2 = new Thread(new MyHashtableRunnable());

 thread1.start();
 thread2.start();

 Thread.sleep(2000);
 log.debug("finish");
 }

 private class MyHashMapRunnable implements Runnable {
 @Override
 public void run() {
 try {
 ContainerSingleton.putInstance2("object", new Object());
 // 等待其他线程放入对象后取值
 Thread.sleep(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 Object singleton = ContainerSingleton.getInstance("object");
 log.info(" " + singleton);
 }
 }

 private class MyHashtableRunnable implements Runnable {
 @Override
 public void run() {
 try {
 ContainerSingletonHashtable.putInstance2("object", new Object());
 // 等待其他线程放入对象后取值
 Thread.sleep(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }

 Object singleton = ContainerSingletonHashtable.getInstance("object");
 log.info(" " + singleton);
 }
 }
}

ThreadLocal（伪）单例

package top.fjy8018.designpattern.pattern.creational.singleton;

import org.apache.ibatis.executor.ErrorContext;

/**
 * 基于{@link ThreadLocalInstance} 的（伪）单例模式，只能保证线程内单例唯一（空间换时间思想）
 *
 * mybatis源码样例：{@link ErrorContext#instance()} 返回通过ThreadLocal实现的单例对象LOCAL
 *
 * @author F嘉阳
 * @date 2018-09-25 16:24
 */
public class ThreadLocalInstance {
 private static ThreadLocal<ThreadLocalInstance> instanceThreadLocal = new ThreadLocal<ThreadLocalInstance>() {
 @Override
 protected ThreadLocalInstance initialValue() {
 return new ThreadLocalInstance();
 }
 };

 private ThreadLocalInstance() {
 }

 /**
 * 其基于{@link java.lang.ThreadLocal.ThreadLocalMap}实现，维护线程隔离，故不用指定key
 *
 * @return
 */
 public static ThreadLocalInstance getInstance() {
 return instanceThreadLocal.get();
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.singleton;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

@Slf4j
class ThreadLocalInstanceTest {

 /**
 * {@link ThreadLocal} 只能保证在同一个线程中单例安全
 *
 * @throws InterruptedException
 */
 @Test
 void getInstance() throws InterruptedException {
 // 在主线程中取
 for (int i = 0; i < 5; i++) {
 ThreadLocalInstance instance = ThreadLocalInstance.getInstance();
 log.info(" " + instance);
 }

 Thread thread1 = new Thread(new ThreadLocalInstanceTest.MyRunnable());
 Thread thread2 = new Thread(new ThreadLocalInstanceTest.MyRunnable());

 thread1.start();
 thread2.start();

 Thread.sleep(2000);
 log.debug("finish");
 }

 private class MyRunnable implements Runnable {
 @Override
 public void run() {
 ThreadLocalInstance instance = null;
 try {
 instance = ThreadLocalInstance.getInstance();
 } catch (Exception e) {
 e.printStackTrace();
 }
 log.info(" " + instance);
 }
 }
}

原型模式

介绍

定义：指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象

不需要知道任何创建的细节，不调用构造函数

类型：创建型

适用场景

类初始化消耗较多资源
new产生的一个对象需要非常繁琐的过程（数据准备、访问权限等)
构造函数比较复杂
循环体中生产大量对象时

优点

原型模式性能比直接new一个对象性能高
简化创建过程

缺点

必须配备克隆方法
对克隆复杂对象或对克隆出的对象进行复杂改造时，容易引入风险
深拷贝、浅拷贝要运用得当

代码样例

改进前

类图

package top.fjy8018.designpattern.pattern.creational.prototype.before;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;

/**
 * 原型模式：使用原型实例指定待创建对象的类型，并且通过<strong>复制</strong>这个原型来创建新的对象
 * 适用于初始化对象复杂的场景
 * <p>
 * 邮件
 *
 * @author F嘉阳
 * @date 2018-09-25 20:39
 */
@Slf4j
@Getter
@Setter
public class BMail {

 private String name;
 private String emailAddress;
 private String content;

 public BMail() throws InterruptedException {
 // 模拟调用构造器需要复杂过程
 Thread.sleep(100);
 log.debug(this.getClass().getSimpleName() + "构造器调用");
 }

 @Override
 public String toString() {
 return "AMail{" +
 "name='" + name + '\'' +
 ", emailAddress='" + emailAddress + '\'' +
 ", content='" + content + '\'' +
 '}';
 }
}

package top.fjy8018.designpattern.pattern.creational.prototype.before;

import lombok.extern.slf4j.Slf4j;
import top.fjy8018.designpattern.pattern.creational.prototype.before.BMail;

import java.text.MessageFormat;

/**
 * 邮件发送类
 *
 * @author F嘉阳
 * @date 2018-09-25 20:42
 */
@Slf4j
public class BMailUtil {
 public static void sendEmail(BMail mail) {
 String content = "向{0}同学,邮件地址:{1},邮件内容:{2}发送邮件成功";
 log.info(MessageFormat.format(content, mail.getName(), mail.getEmailAddress(), mail.getContent()));
 }

 public static void saveOriginMail(BMail mail) {
 log.info("存储Mail记录，originMailContent：{}", mail.getContent());
 }
}

改进后

类图

package top.fjy8018.designpattern.pattern.creational.prototype.after;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;

/**
 * 原型模式：使用原型实例指定待创建对象的类型，并且通过<strong>复制</strong>这个原型来创建新的对象
 * 适用于初始化对象复杂的场景
 * <p>
 * 邮件
 *
 * @author F嘉阳
 * @date 2018-09-25 20:39
 */
@Slf4j
@Getter
@Setter
public class AMail implements Cloneable {

 private String name;
 private String emailAddress;
 private String content;

 public AMail() throws InterruptedException {
 // 模拟调用构造器需要复杂过程
 Thread.sleep(100);
 log.debug(this.getClass().getSimpleName() + "构造器调用");
 }

 /**
 * 带上父类toString方法查看是否为同一个对象
 *
 * @return
 */
 @Override
 public String toString() {
 return "AMail{" +
 "name='" + name + '\'' +
 ", emailAddress='" + emailAddress + '\'' +
 ", content='" + content + '\'' +
 '}';
 }

 /**
 * 调用克隆函数不需要调用构造器以此加快实例化速度
 *
 * @return
 * @throws CloneNotSupportedException
 */
 @Override
 public Object clone() throws CloneNotSupportedException {
 return super.clone();
 }
}

package top.fjy8018.designpattern.pattern.creational.prototype.after;

import lombok.extern.slf4j.Slf4j;

import java.text.MessageFormat;

/**
 * 邮件发送类
 *
 * @author F嘉阳
 * @date 2018-09-25 20:42
 */
@Slf4j
public class AMailUtil {
 public static void sendEmail(AMail mail) {
 String content = "向{0}同学,邮件地址:{1},邮件内容:{2}发送邮件成功";
 log.info(MessageFormat.format(content, mail.getName(), mail.getEmailAddress(), mail.getContent()));
 }

 public static void saveOriginMail(AMail mail) {
 log.info("存储Mail记录，originMailContent：{}", mail.getContent());
 }
}

测试类

package top.fjy8018.designpattern.pattern.creational.prototype.before;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import top.fjy8018.designpattern.pattern.creational.prototype.after.AMail;
import top.fjy8018.designpattern.pattern.creational.prototype.after.AMailUtil;

import java.util.Date;

@Slf4j
class BMailTest {

 private long start;

 @BeforeEach
 void init() {
 start = System.currentTimeMillis();
 }

 @AfterEach
 void destory() {
 log.debug("耗时{}ms", System.currentTimeMillis() - start);
 }

 /**
 * 每次实例化对象，耗时长——耗时613ms
 *
 * @throws Exception
 */
 @Test
 void before() throws Exception {
 BMail mail = new BMail();
 mail.setContent("原始正文");
 for (int i = 0; i < 5; i++) {
 // 初始化临时发送邮件对象，防止原始正文被最后一个对象覆盖
 BMail tempMail = new BMail();
 tempMail.setName("学员" + i);
 tempMail.setContent("正文" + i);
 tempMail.setEmailAddress("地址" + i);
 BMailUtil.sendEmail(tempMail);
 }
 // 本意希望在发送完所有邮件后保存开始的正文
 BMailUtil.saveOriginMail(mail);

 }

 /**
 * 调用克隆方法（浅拷贝，因为没有对每个属性实现克隆方法），显然速度更快——耗时110ms
 *
 * @throws Exception
 */
 @Test
 void after() throws Exception {
 AMail mail = new AMail();
 mail.setContent("原始正文");
 // 通过hashCode查看是否为同一个对象
 log.debug(Integer.toHexString(mail.hashCode()));
 for (int i = 0; i < 5; i++) {
 // 初始化临时发送邮件对象，防止原始正文被最后一个对象覆盖
 AMail tempMail = (AMail) mail.clone();
 tempMail.setName("学员" + i);
 tempMail.setContent("正文" + i);
 tempMail.setEmailAddress("地址" + i);
 AMailUtil.sendEmail(tempMail);
 log.debug(Integer.toHexString(tempMail.hashCode()));
 }
 // 本意希望在发送完所有邮件后保存开始的正文
 AMailUtil.saveOriginMail(mail);
 }
}

深克隆实现

改进前

package top.fjy8018.designpattern.pattern.creational.prototype.clone;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;

import java.util.Date;

/**
 * 原型模式：使用原型实例指定待创建对象的类型，并且通过<strong>复制</strong>这个原型来创建新的对象
 * 适用于初始化对象复杂的场景
 * <p>
 * 邮件
 *
 * @author F嘉阳
 * @date 2018-09-25 20:39
 */
@Slf4j
@Getter
@Setter
public class CMailBefore implements Cloneable {

 private String name;
 private Date date;
 private String content;

 public CMailBefore() throws InterruptedException {
 // 模拟调用构造器需要复杂过程
 Thread.sleep(100);
 log.debug(this.getClass().getSimpleName() + "构造器调用");
 }

 /**
 * 带上父类toString方法查看是否为同一个对象
 *
 * @return
 */
 @Override
 public String toString() {
 return "CMailBefore{" +
 "name='" + name + '\'' +
 ", date=" + date +
 ", content='" + content + '\'' +
 '}';
 }

 /**
 * 调用克隆函数不需要调用构造器以此加快实例化速度
 * 通过调用每个属性的克隆方法实现深克隆
 *
 * @return
 * @throws CloneNotSupportedException
 */
 @Override
 public Object clone() throws CloneNotSupportedException {
 return super.clone();
 }
}

改进后

package top.fjy8018.designpattern.pattern.creational.prototype.clone;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.cache.CacheKey;

import java.util.ArrayList;
import java.util.Date;

/**
 * 原型模式：使用原型实例指定待创建对象的类型，并且通过<strong>复制</strong>这个原型来创建新的对象
 * 适用于初始化对象复杂的场景
 * <p>
 * 邮件——深克隆实现
 *
 * JDK源码样例：{@link ArrayList#clone()} 通过元素拷贝实现
 * mybatis源码样例：{@link CacheKey#clone()} 通过重新初始化一个对象再进行数组拷贝实现
 *
 * @author F嘉阳
 * @date 2018-09-25 20:39
 */
@Slf4j
@Getter
@Setter
public class CMailAfter implements Cloneable {

 private String name;
 /**
 * String类型本身是不可变，不需要重新实现深克隆
 */
 private Date date;
 private String content;

 public CMailAfter() throws InterruptedException {
 // 模拟调用构造器需要复杂过程
 Thread.sleep(100);
 log.debug(this.getClass().getSimpleName() + "构造器调用");
 }

 /**
 * 带上父类toString方法查看是否为同一个对象
 *
 * @return
 */
 @Override
 public String toString() {
 return "CMailAfter{" +
 "name='" + name + '\'' +
 ", date=" + date +
 ", content='" + content + '\'' +
 '}';
 }

 /**
 * 调用克隆函数不需要调用构造器以此加快实例化速度
 * 通过调用每个属性的克隆方法实现深克隆
 *
 * @return
 * @throws CloneNotSupportedException
 */
 @Override
 public Object clone() throws CloneNotSupportedException {
 CMailAfter mail = (CMailAfter) super.clone();
 // 单独对Date进行克隆
 mail.date = (Date) date.clone();
 return mail;
 }
}

集合类实现

改进前

package top.fjy8018.designpattern.pattern.creational.prototype.clone;

import lombok.Getter;
import lombok.Setter;

import java.util.Date;
import java.util.List;

/**
 * 对集合类原型模式实现
 *
 * @author F嘉阳
 * @date 2018-09-25 22:59
 */
@Getter
@Setter
public class ListCloneBefore implements Cloneable {
 private String name;
 private List<Date> dateList;

 @Override
 public String toString() {
 return "ListCloneBefore{" +
 "name='" + name + '\'' +
 ", dateList=" + dateList +
 '}';
 }

 @Override
 protected Object clone() throws CloneNotSupportedException {
 return super.clone();
 }
}

改进后

package top.fjy8018.designpattern.pattern.creational.prototype.clone;

import lombok.Getter;
import lombok.Setter;
import org.apache.ibatis.cache.CacheKey;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 对集合类原型模式实现
 *
 * @author F嘉阳
 * @date 2018-09-25 22:59
 */
@Getter
@Setter
public class ListCloneAfter implements Cloneable {
 private String name;
 private List<Date> dateList;

 @Override
 public String toString() {
 return "ListCloneBefore{" +
 "name='" + name + '\'' +
 ", dateList=" + dateList +
 '}';
 }

 /**
 * 重新实现集合类属性值拷贝方法，模仿{@link CacheKey#clone()}
 *
 * @return
 * @throws CloneNotSupportedException
 */
 @Override
 protected Object clone() throws CloneNotSupportedException {
 ListCloneAfter newInstance = (ListCloneAfter) super.clone();
 newInstance.setDateList(new ArrayList<>(this.dateList));
 return newInstance;
 }
}

设计模式学习——原则

Wed, 22 Jan 2020 09:25:00 +0800

开闭原则

介绍

定义：一个软件实体如类、模块和函数应该对扩展开放,对修改关闭

用抽象构建框架,用实现扩展细节

优点：提高软件系统的可复用性及可维护性

代码样例

类图

课程接口

package top.fjy8018.designpattern.principle.openclose;

import java.math.BigDecimal;

/**
 * 课程接口
 * 对于面向接口编程，接口应当是稳定的
 * 根据开闭原则，在此体现为对接口的增加和修改时关闭的，因为会导致所有实现类的变化
 * 而对课程类的扩展（extend）是开放的
 *
 * @author F嘉阳
 * @date 2018-09-18 16:28
 */
public interface Course {
 /**
 * 获取课程ID
 *
 * @return
 */
 Integer getId();

 /**
 * 获取课程名称
 *
 * @return
 */
 String getName();

 /**
 * 获取课程价格
 *
 * @return
 */
 BigDecimal getPrice();
}

课程实现类

package top.fjy8018.designpattern.principle.openclose;

import java.math.BigDecimal;

/**
 * 课程实现类
 *
 * @author F嘉阳
 * @date 2018-09-18 16:30
 */
public class JavaCourse implements Course {
 private Integer id;

 private String name;

 private BigDecimal price;

 public JavaCourse(Integer id, String name, BigDecimal price) {
 this.id = id;
 this.name = name;
 this.price = price;
 }

 @Override
 public Integer getId() {
 return this.id;
 }

 @Override
 public String getName() {
 return this.name;
 }

 @Override
 public BigDecimal getPrice() {
 return this.price;
 }

 @Override
 public String toString() {
 return "JavaCourse{" +
 "id=" + id +
 ", name='" + name + '\'' +
 ", price=" + price.setScale(2, BigDecimal.ROUND_HALF_UP) +
 '}';
 }
}

Java课程促销类

package top.fjy8018.designpattern.principle.openclose;

import java.math.BigDecimal;

/**
 * Java课程促销
 * 根据开闭原则：对于扩展是开放的，对于修改是关闭的
 * 故通过继承方式实现
 *
 * @author F嘉阳
 * @date 2018-09-18 16:43
 */
public class JavaDiscountCourse extends JavaCourse {

 public JavaDiscountCourse(Integer id, String name, BigDecimal price) {
 super(id, name, price);
 }

 @Override
 public Integer getId() {
 return super.getId();
 }

 @Override
 public String getName() {
 return super.getName();
 }

 /**
 * 实现打折价格逻辑
 *
 * @return
 */
 public BigDecimal getDistcountPrice() {
 // BigDecimal推荐使用String构造器，防止精度转换问题
 return super.getPrice().multiply(new BigDecimal("0.8"));
 }

 /**
 * 根据里氏替换原则：父类实现的方法不应该覆盖
 * 获取原价
 *
 * @return
 */
 @Override
 public BigDecimal getPrice() {

 return super.getPrice();
 }

 @Override
 public String toString() {
 return super.toString();
 }
}

测试类

package top.fjy8018.designpattern.principle.openclose;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import java.io.PrintStream;
import java.math.BigDecimal;


/**
 * 开闭原则单元测试
 *
 * 由于底层通过加锁实现，故生产环境严禁使用{@link PrintStream#println(String)}
 */
@Slf4j
class JavaCourseTest {

 /**
 * 普通情况
 */
 @Test
 public void normal() {
 Course javaCourse = new JavaCourse(1, "Java课程", new BigDecimal("99"));
 log.info("课程Id：{},课程名称：{},价格：{}", javaCourse.getId(), javaCourse.getName(), javaCourse.getPrice());
 }

 /**
 * 促销打折情况
 */
 @Test
 public void discount() {
 Course course = new JavaDiscountCourse(1, "Java课程", new BigDecimal("99"));
 JavaDiscountCourse javaCourse = (JavaDiscountCourse) course;
 log.info("课程Id：{},课程名称：{},原价：{},折后价格：{}",
 javaCourse.getId(), javaCourse.getName(), javaCourse.getPrice(),
 javaCourse.getDistcountPrice().setScale(2, BigDecimal.ROUND_HALF_UP));
 }

}

依赖倒置原则

介绍

定义：高层模块不应该依赖低层模块，二者都应该依赖其抽象

抽象不应该依赖细节；细节应该依赖抽象

针对接口编程，不要针对实现编程

优点：可以减少类间的耦合性、提高系统稳定性，提高代码可读性和可维护性，可降低修改程序所造成的风险

代码样例

改造前

package top.fjy8018.designpattern.principle.dependenceinversion.before;

import lombok.extern.slf4j.Slf4j;

/**
 * 低层模块（模块被调用方）
 * <p>
 * 此时如果要加一个课程，必须修改该类
 * 而对低层模块的修改应该尽量避免
 *
 * @author F嘉阳
 * @date 2018-09-18 17:14
 */
@Slf4j
public class Student {

 public void studyJavaCourse() {
 log.info("学习Java课程");
 }

 public void studyPythonCourse() {
 log.info("学习Python课程");
 }

 public void studyVueCourse() {
 log.info("学习Vue课程");
 }
}

测试类

package top.fjy8018.designpattern.principle.dependenceinversion.before;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * 依赖倒置实现前单元测试
 * 高层模块（模块调用方）
 */
class StudentTest {

 /**
 * 此时存在的问题：
 * 如果高层模块要学多一门课程
 * 则低层模块{@link Student} 也要对应修改，即存在高层模块依赖低层模块，面向具体实现类编程
 */
 @Test
 public void study() {
 Student student = new Student();
 student.studyJavaCourse();
 student.studyPythonCourse();
 student.studyVueCourse();
 }
}

改造后

类图

抽象学习课程接口

package top.fjy8018.designpattern.principle.dependenceinversion.after;

/**
 * 学习课程接口
 * 接口作为抽象存在，成为一个契约
 * 面向抽象编程比面向具体实现细节编程实现简单，灵活度高
 *
 * @author F嘉阳
 * @date 2018-09-18 17:19
 */
public interface DCourse {
 void study();
}

具体学习过程接口，java课程

package top.fjy8018.designpattern.principle.dependenceinversion.after;

import lombok.extern.slf4j.Slf4j;

/**
 * 课程都面向接口，满足依赖倒置原则：高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象
 *
 * @author F嘉阳
 * @date 2018-09-18 17:19
 */
@Slf4j
public class JavaDCourse implements DCourse {
 @Override
 public void study() {
 log.info("学习Java课程");
 }
}

Python课程

package top.fjy8018.designpattern.principle.dependenceinversion.after;

import lombok.extern.slf4j.Slf4j;

/**
 * 所有课程实现类后面都不应该修改，添加新课程则增加新实现类，满足开闭原则
 *
 * @author F嘉阳
 * @date 2018-09-18 17:19
 */
@Slf4j
public class PythonDCourse implements DCourse {
 @Override
 public void study() {
 log.info("学习Python课程");
 }
}

Vue课程

package top.fjy8018.designpattern.principle.dependenceinversion.after;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2018-09-18 17:19
 */
@Slf4j
public class VueDCourse implements DCourse {
 @Override
 public void study() {
 log.info("学习Vue课程");
 }
}

三种注入方式——参数注入

package top.fjy8018.designpattern.principle.dependenceinversion.after;

/**
 * @author F嘉阳
 * @date 2018-09-18 17:20
 */
public class Student {

 /**
 * 具体学习哪个课程，交给高层模块通过参数注入
 *
 * @param course 课程
 */
 public void studyCourse(DCourse course) {
 course.study();
 }
}

测试类

package top.fjy8018.designpattern.principle.dependenceinversion.after;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * 依赖倒置接口方法实现后单元测试
 * 高层模块
 */
class StudentTest {

 /**
 * 修改后高层不依赖低层模块{@link Student}的实现
 * 此时如果高层模块要学多一门课程
 * 则不需要修改Student，直接增加一个实现{@link DCourse} 的接口课程即可
 * 实现了高层模块与低层模块的解耦
 */
 @Test
 void study() {
 Student student = new Student();
 student.studyCourse(new JavaDCourse());
 student.studyCourse(new PythonDCourse());
 student.studyCourse(new VueDCourse());
 }
}

三种注入方式——参数注入

package top.fjy8018.designpattern.principle.dependenceinversion.after;

/**
 * 构造器注入课程
 *
 * @author F嘉阳
 * @date 2018-09-18 17:40
 */
public class Student2 {

 private DCourse dCourse;

 public Student2(DCourse dCourse) {
 this.dCourse = dCourse;
 }

 /**
 * 具体学习哪个课程，交给高层模块通过构造器注入
 */
 public void studyCourse() {
 dCourse.study();
 }
}

测试类

package top.fjy8018.designpattern.principle.dependenceinversion.after;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * 依赖倒置构造器实现实现后单元测试
 * 高层模块
 */
class Student2Test {

 @Test
 void study() {
 Student2 student = new Student2(new JavaDCourse());
 student.studyCourse();
 }
}

三种注入方式——setter注入

package top.fjy8018.designpattern.principle.dependenceinversion.after;

/**
 * Setter注入课程
 *
 * @author F嘉阳
 * @date 2018-09-18 17:40
 */
public class Student3 {

 private DCourse dCourse;

 public Student3() {
 }

 /**
 * 具体学习哪个课程，交给高层模块通过构造器注入
 */
 public void studyCourse() {
 dCourse.study();
 }

 public void setdCourse(DCourse dCourse) {
 this.dCourse = dCourse;
 }
}

测试类

package top.fjy8018.designpattern.principle.dependenceinversion.after;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * 依赖倒置Setter实现实现后单元测试
 * 高层模块
 */
class Student3Test {

 @Test
 void study() {
 Student3 student = new Student3();
 student.setdCourse(new JavaDCourse());
 student.studyCourse();

 student.setdCourse(new PythonDCourse());
 student.studyCourse();

 student.setdCourse(new VueDCourse());
 student.studyCourse();
 }
}

单一职责原则

介绍

定义:不要存在多于一个导致类变更的原因

一个类/接口/方法只负责一项职责

优点:降低类的复杂度、提高类的可读性提高系统的可维护性、降低变更引起的风险

代码样例

改造前

类单一职责

package top.fjy8018.designpattern.principle.singleresponsibility.before;

import lombok.extern.slf4j.Slf4j;

/**
 * 单一职责：一个类应该只有一个发生变化的原因
 *
 * @author F嘉阳
 * @date 2018-09-22 10:35
 */
@Slf4j
public class Bird {
 /**
 * 当前类有两个职责：走和飞
 * 没有使用单一职责当业务变更必须修改代码，带来风险
 *
 * @param name
 */
 public void mainMoveMode(String name) {
 if ("鸵鸟".equals(name)) {
 log.info("{}用脚走", name);
 } else {
 log.info("{}用翅膀飞", name);
 }
 // 当边界值越来越多（承担更多职责）的时候变更变得更加困难
 }
}

方法单一职责

package top.fjy8018.designpattern.principle.singleresponsibility.before;

/**
 * 方法单一职责
 *
 * @author F嘉阳
 * @date 2018-09-22 10:57
 */
public class Method {
 private String name;
 private Integer age;

 /**
 * 此时该方法承担两个职责：更新名字和年龄
 *
 * @param name
 * @param age
 */
 public void updateUserInfo(String name, Integer age) {
 this.name = name;
 this.age = age;
 }

 /**
 * 承担多个职责，同时包含可变参数，即不一定更新哪些属性
 *
 * @param name
 * @param properties
 */
 public void updateProperties(String name, String... properties) {
 // TODO 更新用户名和属性
 }
}

接口单一职责

package top.fjy8018.designpattern.principle.singleresponsibility.before;

/**
 * 接口单一职责
 * 当前接口承担多个职责
 *
 * @author F嘉阳
 * @date 2018-09-22 10:43
 */
public interface SCourse {
 /**
 * 课程信息相关职责
 */
 String getCourseName();

 byte[] getCourseVideo();

 /**
 * 课程管理相关职责
 */
 void paid();

 void studyCourse();
}

改造后

类单一职责

package top.fjy8018.designpattern.principle.singleresponsibility.after;

import lombok.extern.slf4j.Slf4j;

/**
 * 当前类只承担一个职责：飞
 *
 * @author F嘉阳
 * @date 2018-09-22 10:40
 */
@Slf4j
public class FlyBird {
 public void mainMoveMode(String name) {
 log.info("{}用翅膀飞", name);
 }
}

package top.fjy8018.designpattern.principle.singleresponsibility.after;

import lombok.extern.slf4j.Slf4j;

/**
 * 当前类只承担一个职责：走
 *
 * @author F嘉阳
 * @date 2018-09-22 10:40
 */
@Slf4j
public class WalkBird {
 public void mainMoveMode(String name) {
 log.info("{}用脚走", name);
 }
}

方法单一职责

package top.fjy8018.designpattern.principle.singleresponsibility.after;

/**
 * 方法单一职责
 *
 * @author F嘉阳
 * @date 2018-09-22 10:57
 */
public class Method {
 private String name;
 private Integer age;

 /**
 * 此时该方法承担一个职责：更新名字
 *
 * @param name
 */
 public void updateUserName(String name) {
 this.name = name;
 }

 /**
 * 只更新年龄
 *
 * @param age
 */
 public void updateUserAge(Integer age) {
 this.age = age;
 }

 /**
 * 对于有布尔值的方法也建议拆分
 *
 * @param name
 * @param bool
 */
 public void updateProperties(String name, boolean bool) {
 if (bool) {
 // TODO
 } else {
 // TODO
 }
 this.name = name;
 }
}

接口单一职责

类图

课程管理相关

package top.fjy8018.designpattern.principle.singleresponsibility.after;

/**
 * 只承担课程管理相关职责
 *
 * @author F嘉阳
 * @date 2018-09-22 10:46
 */
public interface CourseManagement {
 void paid();

 void studyCourse();
}

课程信息相关

package top.fjy8018.designpattern.principle.singleresponsibility.after;

/**
 * 一个接口变更，只对一个实现类有影响，对其他接口无关
 * 只承担课程信息相关职责
 *
 * @author F嘉阳
 * @date 2018-09-22 10:45
 */
public interface CourseInfo {
 String getCourseName();

 byte[] getCourseVideo();
}

课程实现类

package top.fjy8018.designpattern.principle.singleresponsibility.after;

import lombok.extern.slf4j.Slf4j;

/**
 * 课程实现类
 * 接口实现单一职责后可以通过实现类多重实现的方式组合
 *
 * @author F嘉阳
 * @date 2018-09-22 10:46
 */
@Slf4j
public class CourseImpl implements CourseInfo, CourseManagement {
 @Override
 public String getCourseName() {
 return "设计模式课程";
 }

 @Override
 public byte[] getCourseVideo() {
 return new byte[0];
 }

 @Override
 public void paid() {
 log.info("支付成功");
 }

 @Override
 public void studyCourse() {
 log.info("学习课程");
 }
}

测试类

package top.fjy8018.designpattern.principle.singleresponsibility.before;

import org.junit.jupiter.api.Test;
import top.fjy8018.designpattern.principle.singleresponsibility.after.FlyBird;
import top.fjy8018.designpattern.principle.singleresponsibility.after.WalkBird;

import static org.junit.jupiter.api.Assertions.*;

class BirdTest {

 /**
 * 没有使用单一职责情况
 */
 @Test
 void mainMoveModeBefore() {
 Bird bird = new Bird();
 bird.mainMoveMode("大雁");
 // 业务变更
 bird.mainMoveMode("鸵鸟");
 }

 /**
 * 使用单一职责后
 * 不同职责调用交由应用层负责
 */
 @Test
 void mainMoveModeAfter() {
 FlyBird flyBird = new FlyBird();
 flyBird.mainMoveMode("大雁");
 WalkBird walkBird = new WalkBird();
 walkBird.mainMoveMode("鸵鸟");
 }
}

介绍

定义:用多个专门的接口,而不使用单一的总接口, 客户端不应该依赖它不需要的接口

一个类对一个类的依赖应该建立在最小的接口上建立单一接口,不要建立庞大臃肿的接口

尽量细化接口,接口中的方法尽量少

注意适度原则,一定要适度

优点:符合我们常说的高内聚低耦合的设计思想，从而使得类具有很好的可读性、可扩展性和可维护性。

代码样例

改造前

类图

接口

package top.fjy8018.designpattern.principle.interfacesegregation.before;

/**
 * 接口隔离原则：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上
 * 旧版：一个接口承担过多功能，使得实现类对有些不需要的方法也必须实现
 *
 * @author F嘉阳
 * @date 2018-09-22 11:40
 */
public interface IAnimalAction {
 void eat();

 void fly();

 void swim();
}

实现类

package top.fjy8018.designpattern.principle.interfacesegregation.before;

/**
 * @author F嘉阳
 * @date 2018-09-22 11:41
 */
public class Bird implements IAnimalAction {
 @Override
 public void eat() {

 }

 @Override
 public void fly() {

 }

 @Override
 public void swim() {
 // 不需要的接口，但被迫实现
 }
}

package top.fjy8018.designpattern.principle.interfacesegregation.before;

/**
 * @author F嘉阳
 * @date 2018-09-22 11:44
 */
public class Dog implements IAnimalAction {
 @Override
 public void eat() {

 }

 @Override
 public void fly() {
 // 不需要的接口，但被迫实现
 }

 @Override
 public void swim() {

 }
}

改造后

类图

接口

package top.fjy8018.designpattern.principle.interfacesegregation.after;

/**
 * 隔离接口方法，但注意适度，不是越少越好
 *
 * @author F嘉阳
 * @date 2018-09-22 11:42
 */
public interface IEatAction {
 void eat();
}

package top.fjy8018.designpattern.principle.interfacesegregation.after;

/**
 * @author F嘉阳
 * @date 2018-09-22 11:43
 */
public interface IFlyAction {
 void fly();
}

package top.fjy8018.designpattern.principle.interfacesegregation.after;

/**
 * @author F嘉阳
 * @date 2018-09-22 11:43
 */
public interface ISwimAction {
 void swim();
}

实现类

package top.fjy8018.designpattern.principle.interfacesegregation.after;

/**
 * 实现类可以实现需要的接口
 *
 * @author F嘉阳
 * @date 2018-09-22 11:43
 */
public class Bird implements IFlyAction, IEatAction {
 @Override
 public void eat() {

 }

 @Override
 public void fly() {

 }
}

package top.fjy8018.designpattern.principle.interfacesegregation.after;

/**
 * 接口隔离注重接口方法之间的关系
 * 单一职责关心类、方法、接口承担的职责，即一个接口只要职责单一就不关系方法之间的关系
 *
 * @author F嘉阳
 * @date 2018-09-22 11:44
 */
public class Dog implements IEatAction, ISwimAction {
 @Override
 public void eat() {

 }

 @Override
 public void swim() {

 }
}

迪米特原则

介绍

定义:一个对象应该对其他对象保持最少的了解。又叫最少知道原则

尽量降低类与类之间的耦合

优点:降低类之间的耦合

特点：

强调只和朋友交流,不和陌生人说话
朋友:
- 出现在成员变量、方法的输入、输出参数中的类称为成员朋友类，而出现在方法体内部的类不属于朋友类。

代码样例

类图

package top.fjy8018.designpattern.principle.demeter;

import lombok.extern.slf4j.Slf4j;

import java.util.List;

/**
 * 迪米特法则（Law of Demeter）又叫作最少知识原则（Least Knowledge Principle 简写LKP），
 * 就是说一个对象应当对其他对象有尽可能少的了解
 * 和朋友交流，不和陌生人说话
 * 朋友指的是出现在类成员变量、方法参数、返回值的对象
 *
 * @author F嘉阳
 * @date 2018-09-22 17:02
 */
@Slf4j
public class Boss {

 /**
 * 此处朋友为{@link TeamLeader},{@link DCourse}不是类成员变量、方法参数、返回值的对象，所以不应该在类内引用
 * 即当前类知道的应该尽可能少
 *
 * @param teamLeader
 */
 public void commandCheckNumber(TeamLeader teamLeader) {
 List courses = teamLeader.checkNumberOfCourses();
 log.info("课程的数量是：{}", courses.size());
 }
}

package top.fjy8018.designpattern.principle.demeter;

/**
 * @author F嘉阳
 * @date 2018-09-22 17:04
 */
public class DCourse {
}

package top.fjy8018.designpattern.principle.demeter;

import java.util.ArrayList;
import java.util.List;

/**
 * @author F嘉阳
 * @date 2018-09-22 17:04
 */
public class TeamLeader {

 /**
 * {@link DCourse}作为方法返回值，属于“朋友”
 *
 * @return
 */
 public List<DCourse> checkNumberOfCourses() {
 List<DCourse> courseList = new ArrayList<DCourse>();
 for (int i = 0; i < 20; i++) {
 courseList.add(new DCourse());
 }
 return courseList;
 }
}

测试类

package top.fjy8018.designpattern.principle.demeter;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class BossTest {

 @Test
 void commandCheckNumber() {
 Boss boss = new Boss();
 boss.commandCheckNumber(new TeamLeader());
 }
}

里氏替换原则

介绍

定义: 如果对每一个类型为T1的对象o1,都有类型为T2的对象o2,使得以T1定义的所有程序P在所有的对象o1都替换成2时, 程序P的行为没有发生变化,那么类型T2是类型T1的子类型。

定义扩展: 一个软件实体如果适用一个父类的话那一定适用于其子类,所有引用父类的地方必须能透明地使用其子类的对象,子类对象能够替换父类对象,而程序逻辑不变。

引申意义:子类可以扩展父类的功能,但不能改变父类原有的功能。

含义1:子类可以实现父类的抽象方法但不能覆盖父类的非抽象方法。
含义2:子类中可以增加自己特有的方法。

代码样例——类级别

改造前

类图

package top.fjy8018.designpattern.principle.liskovsubstitution.classdemo.before;

/**
 * 里氏替换原则：如果对每一个类型为S的对象o1，都有类型为T的对象o2，使得以T定义的所有程序P在所有的对象o1都代换为o2，程序P的行为没有发生变化，那么类型S是类型T的子类型
 * 即：所有使用父类对象的地方替换成子类对象依然正常运行
 *
 * @author F嘉阳
 * @date 2018-09-22 20:01
 */
public class Rectangle {
 private long length;
 private long width;

 public long getLength() {
 return length;
 }

 public void setLength(long length) {
 this.length = length;
 }

 public long getWidth() {
 return width;
 }

 public void setWidth(long width) {
 this.width = width;
 }
}

package top.fjy8018.designpattern.principle.liskovsubstitution.classdemo.before;

/**
 * @author F嘉阳
 * @date 2018-09-22 20:03
 */
public class Square extends Rectangle {
 private long sideLength;

 @Override
 public long getLength() {
 return sideLength;
 }

 /**
 * 覆盖了父类的实现，不满足里氏替换原则
 *
 * @param length
 */
 @Override
 public void setLength(long length) {
 this.sideLength = length;
 }

 @Override
 public long getWidth() {
 return sideLength;
 }

 @Override
 public void setWidth(long width) {
 this.sideLength = width;
 }
}

改造后

类图

package top.fjy8018.designpattern.principle.liskovsubstitution.classdemo.after;

/**
 * 通过四边形接口连接，防止继承泛滥
 *
 * @author F嘉阳
 * @date 2018-09-22 20:11
 */
public interface Quadrangle {
 long getWidth();

 long getLength();
}

package top.fjy8018.designpattern.principle.liskovsubstitution.classdemo.after;

/**
 * @author F嘉阳
 * @date 2018-09-22 20:03
 */
public class ASquare implements Quadrangle {
 private long sideLength;

 @Override
 public long getWidth() {
 return sideLength;
 }

 @Override
 public long getLength() {
 return sideLength;
 }

 public void setLength(long sideLength) {
 this.sideLength = sideLength;
 }
}

package top.fjy8018.designpattern.principle.liskovsubstitution.classdemo.after;

/**
 * 里氏替换原则：如果对每一个类型为S的对象o1，都有类型为T的对象o2，使得以T定义的所有程序P在所有的对象o1都代换为o2，程序P的行为没有发生变化，那么类型S是类型T的子类型
 * 即：所有使用父类对象的地方替换成子类对象依然正常运行
 *
 * @author F嘉阳
 * @date 2018-09-22 20:01
 */
public class ARectangle implements Quadrangle {
 private long length;

 private long width;

 @Override
 public long getWidth() {
 return width;
 }

 public void setWidth(long width) {
 this.width = width;
 }

 @Override
 public long getLength() {
 return length;
 }

 public void setLength(long length) {
 this.length = length;
 }
}

测试类

package top.fjy8018.designpattern.principle.liskovsubstitution.classdemo.before;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import top.fjy8018.designpattern.principle.liskovsubstitution.classdemo.after.ARectangle;
import top.fjy8018.designpattern.principle.liskovsubstitution.classdemo.after.Quadrangle;

@Slf4j
class SquareTest {

 /**
 * resize要求传入父类对象，对长宽进行设置
 *
 * @param rectangle
 */
 public static void resize(Rectangle rectangle) {
 while (rectangle.getWidth() <= rectangle.getLength()) {
 rectangle.setWidth(rectangle.getWidth() + 1);
 log.info("width:{} length:{}", rectangle.getWidth(), rectangle.getLength());
 if (rectangle.getWidth() > 50 || rectangle.getLength() > 50) {
 log.error("方法溢出");
 break;
 }
 }
 log.info("resize方法结束 width:{} length:{}", rectangle.getWidth(), rectangle.getLength());
 }

 public static void resize(Quadrangle quadrangle) {
 while (quadrangle.getWidth() <= quadrangle.getLength()) {
// quadrangle.setWidth(quadrangle.getWidth()+1);报错，原有方法已经不能正确运行，说明原有方法设计存在问题
 log.info("width:{} length:{}", quadrangle.getWidth(), quadrangle.getLength());
 if (quadrangle.getWidth() > 50 || quadrangle.getLength() > 50) {
 log.error("方法溢出");
 break;
 }
 }
 log.info("resize方法结束 width:{} length:{}", quadrangle.getWidth(), quadrangle.getLength());
 }

 @Test
 void before() {
 // 是长方形时业务正常运行
 Rectangle rectangle = new Rectangle();
 rectangle.setWidth(10);
 rectangle.setLength(20);
 resize(rectangle);
 // 使用之类替换父类对象，业务无法运行，方法溢出
 Square square = new Square();
 square.setLength(40);
 resize(square);
 }

 @Test
 void after() {
 // 通过里氏替换原则改造后
 ARectangle aRectangle = new ARectangle();
 aRectangle.setLength(20);
 aRectangle.setWidth(10);

 }
}

代码样例——方法级别

改造前

package top.fjy8018.designpattern.principle.liskovsubstitution.method.input.before;

import lombok.extern.slf4j.Slf4j;

import java.util.Map;


/**
 * @author F嘉阳
 * @date 2018-09-23 11:29
 */
@Slf4j
class Base {

 public void method(Map map) {
 log.info("父类被执行");
 }
}

package top.fjy8018.designpattern.principle.liskovsubstitution.method.input.before;

import lombok.extern.slf4j.Slf4j;

import java.util.HashMap;

/**
 * @author F嘉阳
 * @date 2018-09-23 11:30
 */
@Slf4j
class Child extends Base {

 public void method(HashMap map) {
 log.info("子类HashMap入参方法被执行");
 }

}

改造后

package top.fjy8018.designpattern.principle.liskovsubstitution.method.input.after;

import lombok.extern.slf4j.Slf4j;

import java.util.HashMap;

/**
 * @author F嘉阳
 * @date 2018-09-23 11:29
 */
@Slf4j
class Base {

 public void method(HashMap map) {
 log.info("父类被执行");
 }
}

package top.fjy8018.designpattern.principle.liskovsubstitution.method.input.after;

import lombok.extern.slf4j.Slf4j;

import java.util.HashMap;
import java.util.Map;

/**
 * 里氏替换原则要求方法入参必须比父类范围更宽，返回值必须比父类更窄
 *
 * @author F嘉阳
 * @date 2018-09-23 11:30
 */
@Slf4j
class Child extends Base {

 /**
 * 方法重写，入参必须等于父类或者比父类范围更宽
 * 而返回值比父类更窄已经交由IDE判断，若不符合，则编译不通过
 *
 * @param map
 */
 @Override
 public void method(HashMap map) {
 log.info("子类HashMap入参方法被执行");
 }

 /**
 * 方法重写，是子类额外的方法
 *
 * @param map
 */
 public void method(Map map) {
 log.info("子类Map入参方法被执行");
 }


}

测试类

package top.fjy8018.designpattern.principle.liskovsubstitution.method.input.after;

import org.junit.jupiter.api.Test;

import java.util.HashMap;

class ChildTest {

 @Test
 void before() {

 }

 @Test
 void after() {
 Child child = new Child();
 // 此时希望调用子类重写的方法，若子类没重写，则应执行父类的方法
 child.method(new HashMap());
 }
}

合成(组合)聚合复用原则

介绍

定义:尽量使用对象组合/聚合,而不是继承关系达到软件复用的目的

聚合hasA和组合 contains-A

优点:可以使系统更加灵活,降低类与类之间的耦合度,一个类的变化对其他类造成的影响相对较少

何时使用合成/聚合、继承

聚合has-A、组合 contains-A继承is-A

代码样例

改造前

类图

package top.fjy8018.designpattern.principle.compositionaggregation.before;

/**
 * 合成复用原则：要尽量使用组合，尽量不要使用继承
 *
 * @author F嘉阳
 * @date 2018-09-23 15:50
 */
public class DBConnection {
 public String getConnection() {
 return "MySQL数据库连接";
 }
}

package top.fjy8018.designpattern.principle.compositionaggregation.before;

import lombok.extern.slf4j.Slf4j;

/**
 * 直接使用继承，属于聚合关系，业务变更困难
 *
 * @author F嘉阳
 * @date 2018-09-23 15:51
 */
@Slf4j
public class ProductDao extends DBConnection {

 public void addProduct() {
 log.info("使用{}", super.getConnection());
 }
}

改造后

类图

package top.fjy8018.designpattern.principle.compositionaggregation.after;

/**
 * 合成复用原则：要尽量使用组合，尽量不要使用继承
 *
 * @author F嘉阳
 * @date 2018-09-23 15:50
 */
public abstract class ADBConnection {
 public abstract String getConnection();
}

package top.fjy8018.designpattern.principle.compositionaggregation.after;

import lombok.extern.slf4j.Slf4j;

/**
 * @author F嘉阳
 * @date 2018-09-23 15:51
 */
@Slf4j
public class AProductDao {

 private final ADBConnection connection;

 /**
 * 通过构造器注入，解除继承关系，同时符合里氏替换原则和开闭原则
 *
 * @param connection
 */
 public AProductDao(ADBConnection connection) {
 this.connection = connection;
 }

 public void addProduct() {
 log.info("使用{}", connection.getConnection());
 }
}

package top.fjy8018.designpattern.principle.compositionaggregation.after;

/**
 * @author F嘉阳
 * @date 2018-09-23 15:56
 */
public class MysqlConnection extends ADBConnection {
 @Override
 public String getConnection() {
 return "MySQL数据库连接";
 }
}

package top.fjy8018.designpattern.principle.compositionaggregation.after;

/**
 * @author F嘉阳
 * @date 2018-09-23 15:57
 */
public class OracleConnection extends ADBConnection {
 @Override
 public String getConnection() {
 return "Oracle数据库连接";
 }
}

测试类

package top.fjy8018.designpattern.principle.compositionaggregation.before;

import org.junit.jupiter.api.Test;
import top.fjy8018.designpattern.principle.compositionaggregation.after.AProductDao;
import top.fjy8018.designpattern.principle.compositionaggregation.after.MysqlConnection;
import top.fjy8018.designpattern.principle.compositionaggregation.after.OracleConnection;

import static org.junit.jupiter.api.Assertions.*;

class ProductDaoTest {

 @Test
 void before() {
 ProductDao productDao = new ProductDao();
 productDao.addProduct();
 }

 @Test
 void after() {
 // 变更交由业务层决定
 AProductDao productDao1 = new AProductDao(new MysqlConnection());
 productDao1.addProduct();
 AProductDao productDao2 = new AProductDao(new OracleConnection());
 productDao2.addProduct();
 }
}