Jumping with Try

重构 · horance · 于 发布 · 最后由 sidan001回复 · 505 次阅读
3

场景

以一个简化了的用户登录的鉴权流程,流程大体如下:

  • 首先尝试本站鉴权,如果失败,再尝试twiter的方式恢复;
  • 之后再进行Two Factor认证;

快速实现

按照流程定义,可以快速实现第一个版本。这段代码充满了很多的坏味道,职责不单一,复杂的异常分支处理,流程的脉络不够清晰等等,接下来我们尝试一种很特别的重构方式来改善设计。

public boolean authenticate(String id, String passwd) {
  User user = null;    
  try {
   user = login(id, passwd);
  } catch (AuthenticationException e) {
    try {
      user = twiterLogin(id, passwd);
    } catch (AuthenticationException et) {
      return false;
    }
  }

  return twoFactor(user);
}

解决思路

logintwiterLogin生产User对象,扮演生产者的角色;而twoFactor消费User对象,扮演消费者的角色。

最难处理的就是logintwiterLogin可能会存在异常处理。正常情况下它们生产User对象,而异常情况下,则抛出异常。

重构的思路在于将异常处理更加明晰化,让生产者与消费者之间的关系流水化。为此,可以将User对象,可能抛出的异常进行容器化,它们形成互斥关系,不能共生于这个世界。

容器化

public interface Try<T> {
  static <T, E extends Exception> 
  Try<T> trying(ExceptionalSupplier<T, E> s) {
    try {
      return new Success<>(s.get());
    } catch (Exception e) {
      return new Failure<>(e);
    }
  }

  boolean isFailure();

  default boolean isSuccess() {
    return !isFailure();
  }

  T get();
}

其中,SuccessFailure包内私有,对外不公开。

final class Success<T> implements Try<T> {
  private final T value;

  Success(T value) {
    this.value = value;
  }

  @Override
  public boolean isFailure() {
    return false;
  }

  @Override
  public T get() {
    return value;
  }
}
import java.util.NoSuchElementException;

final class Failure<T> implements Try<T> {
  private final Exception e;

  Failure(Exception e) {
    this.e = e;
  }

  @Override
  public boolean isFailure() {
    return true;
  }

  @Override
  public T get() {
    throw new NoSuchElementException("Failure.get");
  }
}

生产者

JDK8标准库中不一样,它能处理受检异常。

@FunctionalInterface
public interface ExceptionalSupplier<T, E extends Exception> {
  T get() throws E;
}

第一次重构

import static Try.trying;

public boolean authenticate(String id, String passwd) {
  Try<User> user = trying(() -> login(id, passwd));
  if (user.isFailure()) {
    user = trying(() -> twiterLogin(id, passwd));
  }

  return user.isSuccess() && twoFactor(user.get());
}

链式DSL

上述trying的应用,使用状态查询Try.isFailure/isSuccess方法显得有些笨拙,可以通过构造链式的DSL改善设计。

public interface Try<T> {
  ......

  <U> Try<U> recover(Function<Exception, Try<U>> f);
}
final class Success<T> implements Try<T> {
  ......

  @Override
  @SuppressWarnings("unchecked")
  public <U> Try<U> recover(Function<Exception, Try<U>> f) {
    return (Try<U>)this;
  }
}
final class Failure<T> implements Try<T> {
  private final Exception e;

  Failure(Exception e) {
    this.e = e;
  }

  @Override
  public <U> Try<U> recover(Function<Exception, Try<U>> f) {
    try {
      return f.apply(e);
    } catch (Exception e) {
      return new Failure<U>(e);
    }
  }
}

第二次重构

使用recover关键字,进一步地改善表达力。首先试图login生产一个User,如果失败从twiterLogin中恢复;最后由twoFactor消费User对象。

public boolean authenticate(String id, String passwd) {
  Try<User> user = trying(() -> login(id, passwd))
      .recover(e -> trying(() -> twiterLogin(id, passwd)));    

  return user.isSuccess() && twoFactor(user.get());
}

彻底链化

public interface Try<T> {
  ......

  default T getOrElse(T defaultValue) {
    return isSuccess() ? get() : defaultValue;
  }

  <U> Try<U> map(Function<T, U> f);
}
final class Success<T> implements Try<T> {
  ......

  @Override
  public <U> Try<U> map(Function<T, U> f) {
    try {
      return new Success<U>(f.apply(value));  
    } catch (Exception e) {
      return new Failure<U>(e);
    }
  }
}
final class Failure<T> implements Try<T> {
  ......

  @Override
  @SuppressWarnings("unchecked")
  public <U> Try<U> map(Function<T, U> f) {
    return (Try<U>)this;
  }
}

第三次重构

public boolean authenticate(String id, String passwd) {
  return trying(() -> login(id, passwd))
    .recover(e -> trying(() -> twiterLogin(id, passwd)))
    .map(user -> twoFactor(user))
    .getOrElse(false);
}

应用Scala

Java8 Lambda表达式() -> login(id, passwd)中空的参数列表颇让人费解,但这是Java8语言本身限制的,应用Scala表达力可进一步提高。

import scala.util.Try

def authenticate(id: String, passwd: String): Boolean = {
  Try(login(id, passwd))
    .recover{ case e: => twiterLogin(id, passwd) }
    .map(twoFactor)
    .getOrElse(false)
}

Try的本质

TryMonad的一个应用,使得异常的处理可以在流水线上传递。使用ScalaTry简化实现版本是这样的。

sealed abstract class Try[+T] {
  def isSuccess: Boolean
  def get: T
}

final case class Failure[+T](val exception: Throwable) extends Try[T] {
  def isSuccess: Boolean = false
  def get: T = throw exception
}


final case class Success[+T](value: T) extends Try[T] {
  def isSuccess: Boolean = true
  def get = value
}

object Try {
  def apply[T](r: => T): Try[T] = {
    try Success(r) catch {
      case NonFatal(e) => Failure(e)
    }
  }
}

「软件匠艺社区」旨在传播匠艺精神,通过分享好的「工作方式」和「习惯」以帮助程序员更加快乐高效地编程。
共收到 1 条回复
96
sidan001 · #1 ·

学到了👍

需要 登录 后回复方可回复, 如果你还没有账号你可以 注册 一个帐号。
相关话题
3
重构horance • 最后由 uxyheaven回复
2
3
horance • 最后由 leomustafa回复
5