目标
1.掌握策略模式和责任链模式的使用场景
2.通过学习策略模式来消除程序中大量的if…else和switch语句
3.掌握策略模式和委派模式的结合使用
4.深刻理解责任链模式和建造者模式的结合应用
策略模式定义
策略模式又叫政策模式,它是将定义的算法家族 分别封装起来,让它们之间可以相互替换,从而让算法的变化不会影响到使用算法的用户。
可以避免多冲分支的if…else…和switch语句
属于行为型模式
策略模式的应用场景
1.假如系统中有很多类,而它们之间的区别仅在于它们的行为不同。
2.一个系统需要动态的在几中算法中选择一种
3.需要屏蔽算法规则
// 假如某个商品不同的时期有不同的优惠,平时的写法
public class Test {
public static void main(String[] args) {
String promotion = "Empty";
if("Empty".equals(promotion)){
System.out.println("当前无优惠");
//todo something
}else if ("九折".equals(promotion)){
System.out.println("九折优惠");
//todo something
}
}
}
策略模式进行优化
//优化1
//创建一个优惠处理接口
public interface IPromotionStrategy {
void doPromotion();
}
//无优惠处理类
public class EmptyStrategy implements IPromotionStrategy{
@Override
public void doPromotion() {
System.out.println("没有优惠");
//todo
}
}
//返现优惠处理类
public class CashBackStrategy implements IPromotionStrategy{
@Override
public void doPromotion() {
System.out.println("返现优惠,返回支付宝");
//todo
}
}
//团购优惠处理类
public class GroupByStrategy implements IPromotionStrategy{
@Override
public void doPromotion() {
System.out.println("团购优惠,5人成团");
//todo
}
}
public class Test {
public static void main(String[] args) {
String promotion = "Empty";
IPromotionStrategy promotionStrategy = null;
if("Empty".equals(promotion)){
System.out.println("当前无优惠");
promotionStrategy = new EmptyStrategy();
}else if ("团购".equals(promotion)){
System.out.println("九折优惠");
promotionStrategy = new GroupByStrategy();
}
}
}
发现同样没有解决问题,缺少一个上下文来承接 每种优惠的算法逻辑和去除if...else...
public class PromotionActivity {
private IPromotionStrategy strategy;
public PromotionActivity(IPromotionStrategy strategy) {
this.strategy = strategy;
}
public void execute(){
strategy.doPromotion();
}
}
public class Test {
public static void main(String[] args) {
String promotion = "Empty";
PromotionActivity promotionStrategy = null;
if("Empty".equals(promotion)){
promotionStrategy = new PromotionActivity(new EmptyStrategy());
}else if ("团购".equals(promotion)){
promotionStrategy = new PromotionActivity(new GroupBuyStrategy());
}
}
}
算法问题解决了 if...else..如何解决呢
使用静态工厂初始化所有的策略类
// An highlighted block
//创建一个策略工厂
public class PromotionStrategyFactory {
private static Map<String,IPromotionStrategy> PROMOTIONS = new HashMap<>();
//工厂初始化所有的策略类
static {
PROMOTIONS.put(PromotionKey.EMPTY,new EmptyStrategy());
PROMOTIONS.put(PromotionKey.GROUPBUY,new GroupBuyStrategy());
PROMOTIONS.put(PromotionKey.CASHBACK,new CashBackStrategy());
}
private static final IPromotionStrategy EMPTY = new EmptyStrategy();
public PromotionStrategyFactory() {
}
//根据客户端传入的key获取具体策略
public static IPromotionStrategy getPromotionStrategy(String promotionKey){
IPromotionStrategy promotionStrategy = PROMOTIONS.get(promotionKey);
return promotionStrategy == null ? EMPTY : promotionStrategy;
}
//内部类定义策略种类
private interface PromotionKey{
String EMPTY = "EMPTY";
String GROUPBUY = "GROUPBUY";
String CASHBACK = "CASHBACK";
}
//返回客户端所有的策略
public static Set<String> getPromotionKey(){
return PROMOTIONS.keySet();
}
}
public class Test {
public static void main(String[] args) {
//供客户端选择
Set<String> promotionKeys = PromotionStrategyFactory.getPromotionKey();
//传入进来
String promotion = "GROUPBUY";
IPromotionStrategy promotionStrategy = PromotionStrategyFactory.getPromotionStrategy(promotion);
promotionStrategy.doPromotion();
}
}
策略模式在源码中的体现
InstantiationStrategy
策略模式的优点
1.策略模式符合开闭原则
2.避免使用多重条件转移语句,如if…else…语句、switch语句
3.使用策略模式可以提高算法的保密性和安全性
策略模式的缺点
1.客户端必需知道所有的策略,并且自行决定使用哪一个策略
2.代码中会禅城非常多的策略类,增加维护难度
责任链模式的定义
责任链模式是将链中每一个节点看做是一个对象,每个节点处理的请求均不同,且内部自动维护一个下一节点对象。当一个请求从链式的首端发出时,会沿着链的路径依次传递给每一个节点对象,直至有对象处理这个请求为止。
属于行为型模式
责任链模式的使用场景
1.一个对象可以处理同一请求,但具体由哪个对象处理则在运行时动态决定
2.在不明确指定接受者的情况下,向多个对象中的一个提交一个请求
3.可动态指定一组对象处理请求
优化案例
// An highlighted block
@Data
public class Member {
private String loginName;
private String loginPass;
private String roleName;
public Member(String loginName, String loginPass) {
this.loginName = loginName;
this.loginPass = loginPass;
}
}
public class MemberService {
public void login(String loginName,String loginPass){
if("".equals(loginName) || "".equals(loginPass)){
System.out.println("用户名和密码为空");
return;
}
System.out.println("用户名和密码不为空,可以往下执行");
Member member = checkExists(loginName,loginPass);
if(null == member){
System.out.println("用户不存在");
return;
}
System.out.println("登录成功!");
if(!"管理员".equals(member.getRoleName())){
System.out.println("您不是管理员,没有操作权限");
return;
}
System.out.println("允许操作");
}
private Member checkExists(String loginName,String loginPass){
Member member = new Member(loginName,loginPass);
member.setRoleName("管理员");
return member;
}
public static void main(String[] args) {
MemberService service = new MemberService();
service.login("zhangsan","666");
}
}
上方逻辑主要是有三部分 参数校验、登录校验、用户权限校验
优化
//
public abstract class Handler {
protected Handler next;
//形成一个链向下传播
public void next(Handler next){ this.next = next;}
//子类去实现具体的处理逻辑
public abstract void doHandler(Member member);
}
//校验逻辑
public class ValidateHandler extends Handler {
public void doHandler(Member member) {
if("".equals(member.getLoginName()) || "".equals(member.getLoginPass())){
System.out.println("用户名和密码为空");
return;
}
System.out.println("用户名和密码不为空,可以往下执行");
next.doHandler(member);
}
}
//登录校验
public class LoginHandler extends Handler {
public void doHandler(Member member) {
System.out.println("登录成功!");
member.setRoleName("管理员");
next.doHandler(member);
}
}
//用户权限校验
public class AuthHandler extends Handler {
public void doHandler(Member member) {
if(!"管理员".equals(member.getRoleName())){
System.out.println("您不是管理员,没有操作权限");
return;
}
System.out.println("允许操作");
}
}
//service层
public class MemberService {
public void login(String loginName,String loginPass){
Handler validateHandler = new ValidateHandler();
Handler loginHandler = new LoginHandler();
Handler authHandler = new AuthHandler();
validateHandler.next(loginHandler);
loginHandler.next(authHandler);
validateHandler.doHandler(new Member(loginName,loginPass));
}
}
public class Test {
public static void main(String[] args) {
MemberService memberService = new MemberService();
memberService.login("zhangsan","666");
}
}
有时候一些节点并不分前后的执行顺序,如何将他们形成链式结构呢,联想到StringBuilder的 append()方法
就是使用建造者模式实现的
优化
// Handler处理类
public abstract class Handler<T> {
protected Handler next;
public void next(Handler next){ this.next = next;}
//每个节点来实现不同的处理逻辑
public abstract void doHandler(Member member);
//内部类来构建链表结构
public static class Builder<T>{
private Handler<T> head;
private Handler<T> tail;
public Builder<T> addHandler(Handler handler){
//do{
//将头节点和尾结点都指向第一个传入进来的handler
if (this.head == null) {
this.head = this.tail = handler;
return this;
}
//第二个传入进来的节点放到第一个节点后面然后将 后传入的赋值给tail
this.tail.next(handler);
this.tail = handler;
// }while (false);//真正框架中,如果是双向链表,会判断是否已经到了尾部
return this;
}
public Handler<T> build(){
return this.head;
}
}
}
//校验参数
public class ValidateHandler extends Handler {
public void doHandler(Member member) {
if("".equals(member.getLoginName()) || "".equals(member.getLoginPass())){
System.out.println("用户名和密码为空");
return;
}
System.out.println("用户名和密码不为空,可以往下执行");
next.doHandler(member);
}
}
//登录
public class LoginHandler extends Handler {
public void doHandler(Member member) {
System.out.println("登录成功!");
member.setRoleName("管理员");
if(null != next) {
next.doHandler(member);
}
}
}
//权限校验
public class AuthHandler extends Handler {
public void doHandler(Member member) {
if(!"管理员".equals(member.getRoleName())){
System.out.println("您不是管理员,没有操作权限");
return;
}
System.out.println("允许操作");
}
}
//service层
public class MemberService {
public void login(String loginName,String loginPass){
Handler.Builder builder = new Handler.Builder();
builder.addHandler(new ValidateHandler())
.addHandler(new LoginHandler())
.addHandler(new AuthHandler());
builder.build().doHandler(new Member(loginName,loginPass));
}
}
//测试
public class Test {
public static void main(String[] args) {
MemberService memberService = new MemberService();
memberService.login("zhangsan","666");
}
}
可以根据实际业务来处理每个节点处理完成之后是否需要终止
责任链模式在源码中的体现
Filter类中的doFilter(xx,xx,FilterChain chain)
ChannelHandler类
责任链模式的优点
1.将请求与处理解耦
2.请求处理者(节点对象)只需要关注自己感兴趣的请求进行处理即可,对于不感兴趣的请求,直接转发给下一级节点对象;
3.具备链式传递处理请求的功能,请求发送者无需知晓链路结构,只需要等待请求处理结果
4.链路结构灵活,可以通过改变链路结构动态的新增或删减责任
5.易于扩展的请求处理类(节点),符合开闭原则
责任链模式的缺点
1.责任链太长或者处理时间过长,会影响整体性能
2.如果节点对象存在循环引用时,会造成死循环,导致系统崩溃