用多态性替换 switch-case

Question

我知道已经有类似的问题，但是看着它们我仍然对如何设计我的代码有一些疑问。我有一项服务允许User 注册/登录/更新/删除。问题是 User 是一个抽象类型，它包含数据 typeOfUser，基于该数据应该调用实际的 registration / update / delete 方法，现在我在switch-case 块。我想用更好的设计来代替它。

UserController.java

public class UserController {

    public UserDto register(UserDto user) {
        switch(user.getTypeOfUser()) {
        case DRIVER: return driverService.register(user);
        case CUSTOMER: return customerService.register(user);
        // ...
        }
    } 

    public UserDto update(UserDto user) {
        switch(user.getTypeOfUser) {
        case DRIVER: return driverService.update((DriverDto) user);
        case CUSTOMER: return customerService.update((CustomerDto) user);
        // ...
        }
    }

    public UserDto login(long userId) {
        loginService.login(userId);

        UserBO user = userService.readById(userId);

        switch(user.getTypeOfUser) {
        case DRIVER: return DriverDto.fromBO((DriverBO) user);
        case CUSTOMER: return CustomerDto.fromBO((CustomerBO) user);
        // ...
        }
    }

    // ...
}

我知道可以使用Visitor 之类的模式，但我真的需要在Enum 本身中添加注册/登录/更新/删除的方法吗？我真的不清楚如何做到这一点，感谢任何帮助。

Answer 1

我想用更好的设计来代替它。

替换switch 语句并利用多态性 的第一步是确保每个操作都有一个合同（读取方法签名），而不管用户类型如何.以下步骤将解释如何实现这一点：

第 1 步：定义一个通用接口来执行所有操作

interface UserService {
    public UserDto register(UserDto user);
    public UserDto update(UserDto user);
    public UserDto login(UserDto user)
}

第 2 步：让 UserController 将 UserService 作为依赖项

public class UserController {
     
    private UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    public UserDto register(UserDto user) {
       userService.register(user);
    } 

    public UserDto update(UserDto user) {
        userService.update(user);
        
    }

    public UserDto login(long userId) {
        userService.login(user);
    }
      
}

第 3 步：创建子类来处理以 CustomerDto 和 CustomerBO 作为依赖项的不同类型的用户

class CustomerService implements UserService {
    private CustomerDto userDto;
    private CustomerBO userBO;
    
    public CustomerService(UserDto userDto,UserBO userBo) {
          this.userDto = (CustomerDto)userDto;
          this.userBO= (CustomerBO)userBo;
    }

    //implement register,login and update methods to operate on userDto and userBo
}

以类似的方式实现DriverService 类，分别依赖于DriverBo 和DriverDto 对象。

第 4 步：实现一个运行时工厂，决定将哪个服务传递给 UserController：

public UserControllerFactory {
    public static void createUserController(UserDto user) {
       if(user.getTypeOfUser().equals(CUSTOMER)) { 
           return new UserController(new CustomerService(user));
       } else if(user.getTypeOfUser().equals(DRIVER)) {
           return new UserController(new DriverService(user));
       }
    }
 
}

第五步调用工厂创建用户控制器

UserDto user = someMethodThatCreatesUserDto(();
UserController controller = UserControllerFactory.createUserController(user);
controller.register();
controller.update();
controller.login();

上述方法的优点是 switch/if-else 语句被完全移回单个类，即工厂。

Answer 2

你会想要这样的：

public abstract class User {
    abstract void register();
    abstract void update();
    abstract void login();

    // maybe some more common non-abstract methods
}

任何类型的 User 都会有一个扩展此抽象类的类，因此必须实现其所有抽象方法，如下所示：

public class Driver extends User {
    public void register() {
        // do whatever a driver does when register...
    }
    public void update() {
        // do whatever a driver does when update...
    }
    public void login() {
        // do whatever a driver does when login...
    }
}

public class Customer extends User {
    public void register() {
        // do whatever a customer does when register...
    }
    public void update() {
        // do whatever a customer does when update...
    }
    public void login() {
        // do whatever a customer does when login...
    }
}

这样，您就可以避免使用任何 switch case 代码。例如，您可以有一个Users 数组，它们中的每一个都将使用new Driver() 或new Customer() 进行实例化。然后，例如，如果您正在迭代这个数组并执行所有 Users login() 方法，每个用户的 login() 将根据其特定类型被调用 ==> 不需要 switch-case，不需要强制转换需要！

Answer 3

非常简单的示例（仅适用于 DriverDto 和 CustomerDto 的不同登录逻辑）-我已从字段 typeOfUser 辞职（因为在我的解决方案中没有必要）-我不确定这在您的解决方案中是否可行：

public abstract class UserDto {
    // put some generic data & methods here
}

public class CustomerDto extends UserDto {

    private String customerName;

    public String getCustomerName() {
        return customerName;
    }

    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }
}

public class DriverDto extends UserDto {

    private String driverName;

    public String getDriverName() {
        return driverName;
    }

    public void setDriverName(String driverName) {
        this.driverName = driverName;
    }
}

public class ThisIsServiceOrDelegateToOtherServices {

    public void login(CustomerDto customer) {
        String name = customer.getCustomerName();
        System.out.println(name);
        // work on name here
    }

    public void login(DriverDto customer) {
        String name = customer.getDriverName();
        System.out.println(name);
        // work on name here
    }

}

用法：

public static void main(String... args) {
    //demo data
    CustomerDto customer = new CustomerDto();
    customer.setCustomerName("customerName");
    DriverDto driver = new DriverDto();
    driver.setDriverName("driverName");
    // usage
    ThisIsServiceOrDelegateToOtherServices service = new ThisIsServiceOrDelegateToOtherServices();
    service.login(customer);
    service.login(driver);
}

Answer 4

如果您确实需要 UserDTO 中的 TypeOfUser-enum，那么您可以使用服务扩展您的枚举。所以你创建了一个 TypeOfUserService 接口。 CustomerService 和 DriverService 将从该服务继承：

    public interface TypeOfUserService {
       public void register(UserDTO user);
       // ...
    }

    public class CustomerService implements TypeOfUserService {
       @Override
       public void register(UserDTO user) {
         // ...
       }
    }

    public class DriverService implements TypeOfUserService {
       @Override
       public void register(UserDTO user) {
         // ...
       }
    }

然后你在你的 TypeOfUser 枚举中创建你的注册、更新等方法：

public enum TypeOfUser {

  DRIVER(new DriverService()), 
  CUSTOMER(new CustomerService());

  private TypeOfUserService typeOfUserService;

  TypeOfUser(TypeOfUserService typeOfUserService) {
    this.typeOfUserService = typeOfUserService;
  }

  public static void register(String typeOfUser, UserDTO user) {
     TypeOfUser.valueOf(typeOfUser).typeOfUserService.register(user);
  } 
  // ...

 }

然后您可以通过以下方式调用注册方法：

    class UserController() {
      public UserDto register(UserDto user) { 
        TypeOfUser.register(user.getTypeOfUser, user);
      }
    }