Fatal编程技术网
  • java/
  • Java泛型api体系结构

Java泛型api体系结构

java generics interface

Java泛型api体系结构,java,generics,interface,Java,Generics,Interface,我正在实现一个异常处理的策略模式 public class GlobalExceptionHandler { private interface Strategy<T extends Exception> { ErrorResponse extract(T e); } private static class ResponseStatusStrategy implements Strategy<ResponseStatusExcep

我正在实现一个异常处理的策略模式

 public class GlobalExceptionHandler {

    private interface Strategy<T extends Exception> {
        ErrorResponse extract(T e);
    }

    private static class ResponseStatusStrategy implements Strategy<ResponseStatusException> {
        @Override
        public ErrorResponse extract(ResponseStatusException e) {
            return ErrorResponse.builder()
                    .status(e.getStatus())
                    .message(e.getReason())
                    .description(e.getReason())
                    .build();
        }
    }

    private static class IllegalStateStrategy implements Strategy<IllegalStateException> {
        @Override
        public ErrorResponse extract(IllegalStateException e) {
            return ErrorResponse.builder()
                    .status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .message(e.getMessage())
                    .description("")
                    .build();
        }
    }
    ....
有没有更有效、更漂亮的方法来实现这一点？这个想法暗示我甚至并没有使用接口方法：“从来并没有使用过方法提取（TE）”

如果有这样的API，那就太好了：

Exception ex = ....; // function param
if (ex instanceof ResponseStatusException) {
    errorResponse = new ResponseStatusStrategy().extract((ResponseStatusException) ex);
} else if (ex instanceof IllegalStateException) {
    errorResponse = new IllegalStateStrategy().extract((IllegalStateException) ex);
} else {
    errorResponse = new EmptyStrategy().extract(ex);
}

    Strategy<???> strategy;
    if (ex instanceof ResponseStatusException) {
        strategy = new ResponseStatusStrategy();
    } else if (ex instanceof IllegalStateException) {
        strategy = new IllegalStateStrategy();
    } else {
        strategy = new EmptyStrategy();
    }
    errorResponse = strategy.extract(ex);

战略；
如果（响应的实例除外）{
策略=新响应StatusStrategy（）；
}else if（IllegalStateException实例除外）{
战略=新的非法国家战略（）；
}否则{
策略=新的空策略（）；
}
errorResponse=策略提取（ex）；
您试图解决一个对象创建问题。您需要基于StatusException类的特定策略类对象。使用工厂模式创建一个新类，以返回正确的对象。下面是一些源于您的代码的虚拟代码

private interface Factory {
    Strategy buildStrategy(Exception e);
}
private static class FactoryImpl implements Factory {
    public Strategy buildStrategy(Exception e) {
        if (e instanceof IOException) {
            return new Strategy1();
        } else {
            return new EmptyStrategy();
        }
    }
}

private interface Strategy<T extends Exception> {
    String extract();
}
private static class Strategy1 implements Strategy<IOException> {
    @Override public String extract() {
        return "Strategy1";
    }
}
private static class EmptyStrategy implements Strategy<NamingException> {
    @Override public String extract() {
        return "EmptyStrategy";
    }
}

public static void main(String[] args) {
    var f = new FactoryImpl();
    System.out.println(f.buildStrategy(new IOException()).extract());
    System.out.println(f.buildStrategy(new NamingException()).extract());
}

专用接口工厂{
战略建设战略（例外e）；
}
私有静态类FactoryImpl实现工厂{
公共战略建筑战略（例外e）{
if（IOException的实例）{
返回新策略1（）；
}否则{
返回新的EmptyStrategy（）；
}
}
}
专用接口策略{
字符串提取（）；
}
私有静态类策略1实现该策略{
@重写公共字符串提取（）{
返回“策略1”；
}
}
私有静态类清空策略实现策略{
@重写公共字符串提取（）{
返回“清空策略”；
}
}
公共静态void main（字符串[]args）{
var f=新的FactoryImpl（）；
System.out.println（f.buildStrategy（newioexception（））.extract（））；
System.out.println（f.buildStrategy（newnamingexception（））.extract（））；
}
您试图解决一个对象创建问题。您需要基于StatusException类的特定策略类对象。使用工厂模式创建一个新类，以返回正确的对象。下面是一些源于您的代码的虚拟代码

private interface Factory {
    Strategy buildStrategy(Exception e);
}
private static class FactoryImpl implements Factory {
    public Strategy buildStrategy(Exception e) {
        if (e instanceof IOException) {
            return new Strategy1();
        } else {
            return new EmptyStrategy();
        }
    }
}

private interface Strategy<T extends Exception> {
    String extract();
}
private static class Strategy1 implements Strategy<IOException> {
    @Override public String extract() {
        return "Strategy1";
    }
}
private static class EmptyStrategy implements Strategy<NamingException> {
    @Override public String extract() {
        return "EmptyStrategy";
    }
}

public static void main(String[] args) {
    var f = new FactoryImpl();
    System.out.println(f.buildStrategy(new IOException()).extract());
    System.out.println(f.buildStrategy(new NamingException()).extract());
}

专用接口工厂{
战略建设战略（例外e）；
}
私有静态类FactoryImpl实现工厂{
公共战略建筑战略（例外e）{
if（IOException的实例）{
返回新策略1（）；
}否则{
返回新的EmptyStrategy（）；
}
}
}
专用接口策略{
字符串提取（）；
}
私有静态类策略1实现该策略{
@重写公共字符串提取（）{
返回“策略1”；
}
}
私有静态类清空策略实现策略{
@重写公共字符串提取（）{
返回“清空策略”；
}
}
公共静态void main（字符串[]args）{
var f=新的FactoryImpl（）；
System.out.println（f.buildStrategy（newioexception（））.extract（））；
System.out.println（f.buildStrategy（newnamingexception（））.extract（））；
}
您似乎根本没有理由使用策略模式。我建议你不要<代码>如果（例如IllegalStateException）{errorResponse=..}工作正常，您不必毫无理由地创建一大堆类。@MattTimmermans让我们假装我需要它。我想知道我将来如何用泛型解决这种情况。在策略模式合适的情况下，你不会有这个问题。@MattTimmermans是因为接口在这个模式中不是泛型的吗？是的，对于策略模式，你拥有的东西的类型是不变的，您对它们所做的是可变的或配置的。有时，当类型是无界的时，策略接口是泛型的，然后策略通常存储在
映射>
中。然而，关键的一点是，这些策略是可变的/配置的，然后实现是从您如何允许定义配置开始的。您似乎根本没有理由使用策略模式。我建议你不要<代码>如果（例如IllegalStateException）{errorResponse=..}工作正常，您不必毫无理由地创建一大堆类。@MattTimmermans让我们假装我需要它。我想知道我将来如何用泛型解决这种情况。在策略模式合适的情况下，你不会有这个问题。@MattTimmermans是因为接口在这个模式中不是泛型的吗？是的，对于策略模式，你拥有的东西的类型是不变的，您对它们所做的是可变的或配置的。有时，当类型是无界的时，策略接口是泛型的，然后策略通常存储在
映射>
中。然而，关键的一点是，这些策略是可变的/配置的，然后实现是从您如何允许定义配置开始的<代码>策略。替换
策略构建策略（例外e）与
策略您能提供您想要的代码外观吗？我仍在研究如何更新代码<代码>策略
。替换
策略构建策略（例外e）与
策略您能提供您想要的代码外观吗？我仍在研究如何更新代码。。