1
/**
2
 * 咖啡接口
3
 */
4
public interface Coffee {
5

6
    /**
7
     *  获取名字
8
     * @return
9
     */
10
    public String getName();
11

12
    /**
13
     * 加牛奶
14
     */
15
    public void addMilk();
16

17
    /**
18
     * 加糖
19
     */
20
    public void addSuqar();
21
}

1
/**
2
 * 拿铁咖啡
3
 */
4
public class LatteCoffee implements Coffee {
5
    /**
6
     *  获取名字
7
     * @return
8
     */
9
    @Override
10
    public String getName() {
11
        return "latteCoffee";
12
    }
13

14
    /**
15
     * 加牛奶
16
     */
17
    @Override
18
    public void addMilk() {
19
        System.out.println("LatteCoffee...addMilk...");
20
    }
21

22
    /**
23
     * 加糖
24
     */
25
    @Override
26
    public void addSuqar() {
27
        System.out.println("LatteCoffee...addSuqar...");
28
    }
29
}

1
/**
2
 * 美式咖啡
3
 */
4
public class AmericanCoffee implements Coffee {
5

6
    /**
7
     *  获取名字
8
     * @return
9
     */
10
    @Override
11
    public String getName() {
12
        return "americanCoffee";
13
    }
14

15
    /**
16
     * 加牛奶
17
     */
18
    @Override
19
    public void addMilk() {
20
        System.out.println("AmericanCoffee...addMilk...");
21
    }
22

23
    /**
24
     * 加糖
25
     */
26
    @Override
27
    public void addSuqar() {
28
        System.out.println("AmericanCoffee...addSuqar...");
29
    }
30
}

1
/**
2
 * 咖啡店类
3
 */
4
public class CoffeeStore {
5

6
    public static void main(String[] args) {
7
        Coffee coffee = orderCoffee("latte");
8
        System.out.println(coffee.getName());
9
    }
10
    /**
11
     * 根据类型选择不同的咖啡
12
     * @param type
13
     * @return
14
     */
15
    public static Coffee orderCoffee(String type){
16
        Coffee coffee = null;
17
        if("american".equals(type)){
18
            coffee = new AmericanCoffee();
19
        }else if ("latte".equals(type)){
20
            coffee = new LatteCoffee();
21
        }
22
        //添加配料
23
        coffee.addMilk();
24
        coffee.addSuqar();
25
        return coffee;
26
    }
27
}

1
if (loginReq.getType().equals("account")) {
2
            System.out.println("用户名密码登录");
3

4
            // 执行用户密码登录逻辑
5

6
            return new LoginResp();
7

8
        } else if (loginReq.getType().equals("sms")) {
9
            System.out.println("手机号验证码登录");
10

11
            // 执行手机号验证码登录逻辑
12

13
            return new LoginResp();
14
        } else if (loginReq.getType().equals("we_chat")) {
15
            System.out.println("微信登录");
16

17
            // 执行用户微信登录逻辑
18

19
            return new LoginResp();
20
        }
21
        LoginResp loginResp = new LoginResp();
22
        loginResp.setSuccess(false);
23
        System.out.println("登录失败");
24
        return loginResp;
25
}

1
/**
2
 * 抽象策略类
3
 */
4
public interface UserGranter{
5

6
  /**
7
   * 获取数据
8
   * @param loginReq 传入的参数
9
   *     0:账号密码
10
   *       1:短信验证
11
   *     2:微信授权
12
   * @return map值
13
   */
14
  LoginResp login(LoginReq loginReq);
15

16
}

1
/**
2
 *策略：账号登录
3
 */
4
@Component
5
public class AccountGranter implements UserGranter{
6

7
  @Override
8
  public LoginResp login(LoginReq loginReq) {
9
    System.out.println("策略:登录方式为账号登录");
10
    // TODO
11
    // 执行业务操作
12

13
    return new LoginResp();
14
  }
15

16
}
17
/**
18
 * 策略:短信登录
19
 */
20
@Component
21
public class SmsGranter implements UserGranter{
22

23
  @Override
24
  public LoginResp login(LoginReq loginReq)  {
25
    System.out.println("策略:登录方式为短信登录");
26
    // TODO
27
    // 执行业务操作
28

29
    return new LoginResp();
30
  }
31

32
}
33
/**
34
 * 策略:微信登录
35
 */
36
 @Component
37
public class WeChatGranter implements UserGranter{
38

39
  @Override
40
  public LoginResp login(LoginReq loginReq)  {
41
    System.out.println("策略:登录方式为微信登录");
42
    // TODO
43
    // 执行业务操作
44

45
    return new LoginResp();
46
  }
47
}

1
login:
2
  types:
3
    account: accountGranter
4
    sms: smsGranter
5
    we_chat: weChatGranter

1
@Getter
2
@Setter
3
@Configuration
4
@ConfigurationProperties(prefix = "login")
5
public class LoginTypeConfig {
6

7
    private Map<String,String> types;
8

9
}

1
/**
2
 * 操作策略的上下文环境类 工具类
3
 * 将策略整合起来 方便管理
4
 */
5
@Component
6
public class UserLoginFactory implements ApplicationContextAware {
7

8
    private static Map<String, UserGranter> granterPool = new ConcurrentHashMap<>();
9

10
    @Autowired
11
    private LoginTypeConfig loginTypeConfig;
12

13
    /**
14
     * 从配置文件中读取策略信息存储到map中
15
     * {
16
     * account:accountGranter,
17
     * sms:smsGranter,
18
     * we_chat:weChatGranter
19
     * }
20
     *
21
     * @param applicationContext
22
     * @throws BeansException
23
     */
24
    @Override
25
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
26
        loginTypeConfig.getTypes().forEach((k, y) -> {
27
            granterPool.put(k, (UserGranter) applicationContext.getBean(y));
28
        });
29
    }
30

31
    /**
32
     * 对外提供获取具体策略
33
     *
34
     * @param grantType 用户的登录方式，需要跟配置文件中匹配
35
     * @return 具体策略
36
     */
37
    public UserGranter getGranter(String grantType) {
38
        UserGranter tokenGranter = granterPool.get(grantType);
39
        return tokenGranter;
40
    }
41

42
}

1
@Service
2
public class UserService {
3

4
    @Autowired
5
    private UserLoginFactory factory;
6

7
    public LoginResp login(LoginReq loginReq) {
8

9
        UserGranter granter = factory.getGranter(loginReq.getType());
10
        if (granter == null) {
11
            LoginResp loginResp = new LoginResp();
12
            loginResp.setSuccess(false);
13
            return loginResp;
14
        }
15
        LoginResp loginResp = granter.login(loginReq);
16
        return loginResp;
17
    }
18
}

1
/**
2
 * 抽象处理者
3
 */
4
public abstract class Handler {
5

6
    protected Handler nextHander;
7

8
    public void setNext(Handler handler) {
9
        this.nextHander = handler;
10
    }
11

12
    /**
13
     * 处理过程
14
     * 需要子类进行实现
15
     */
16
    public abstract void process(OrderInfo order);
17
}
18
/**
19
 * 计算金额
20
 */
21
public class OrderAmountCalcuate extends Handler {
22
    @Override
23
    public void process(OrderInfo order) {
24
        System.out.println("计算金额-优惠券、VIP、活动打折");
25
        nextHander.process(order);
26
    }
27

28
}/**
29
 * 补充订单信息
30
 */
31
public class OrderFill extends Handler {
32
    @Override
33
    public void process(OrderInfo order) {
34
        System.out.println("补充订单信息");
35
        nextHander.process(order);
36
    }
37

38
}
39

40
// 串成一条链条
41
public class Application {
42

43
    public static void main(String[] args) {
44
        //检验订单
45
        Handler orderValidition = new OrderValidition();
46
        //补充订单信息
47
        Handler orderFill = new OrderFill();
48
        //订单算价
49
        Handler orderAmountCalcuate = new OrderAmountCalcuate();
50
        //订单落库
51
        Handler orderCreate = new OrderCreate();
52

53
        //设置责任链路
54
        orderValidition.setNext(orderFill);
55
        orderFill.setNext(orderAmountCalcuate);
56
        orderAmountCalcuate.setNext(orderCreate);
57

58
        //开始执行
59
        orderValidition.process(new OrderInfo());
60
    }
61

62
}