java - 您如何重写在 Java 8 中使用泛型和函数并仅使用面向对象的混合 oop 和函数式编程的代码？

Question

我遇到过这种设计，但我没有完全掌握在 Java 8 中混合面向对象编程和函数式编程。

我对混合两种语言范式很感兴趣，而且互联网上的大多数教程都很简单，所以我无法通过混合来找到有关大规模软件设计的示例。所以有了这个示例案例，我想我有机会挖掘它的某些案例。

在这种情况下，让我展示代码的相关部分。这段代码包含一个通用的 FetchUtils 类，它实现了一个自定义迭代器，但为了简洁起见，我删除了一些部分。

public class FetchUtils<R, MSGIN, MSGOUT> {
    public SomeClass<R> getSomething(MSGIN query,
                                Function<MSGIN, MSGOUT> queryFunc,
                                Function<MSGOUT, List<R>> getResultList) {

               //...
                        MSGOUT callResult = queryFunc.apply(query);
                        buffer = getResultList.apply(callResult);
               //...
               //return someThing;
            }
            //...    
}

在客户端中定义了一个函数和一个指向 getCustomer 的引用的 lambda 表达式。一个类的方法。从客户端到使用泛型类型的上述方法的实际调用正在发送这些功能。

public class CustomerResponse {
   //...
   public List<Customer> getCustomer() {
        if (thing == null) {
            thing = new ArrayList<Customer>();
        }
        return this.customers;
    }
   //...
}

public class MyClient {

   //...

   @Autowired
   private FetchUtils<Customer, CustomerRequest, CustomerResponse> fetchUtils;

   //...

   public SomeClass<Customer> fetch() {

      //...

      Function<CustomerRequest, CustomerResponse> requestFunc = q -> {
            try {
                return myService.doSomething(q);
            } catch (Exception ex) {
                throw new RuntimeException(ex);
            }
        };

      CustomerRequest query = new CustomerRequest(/*...*/);

      return fetchUtils.getSomething(query,
                                     requestFunc,
                                     r -> r.getCustomer());

      //...
   }
   //...
}

您如何仅使用面向对象的编程即不传递高阶函数并且仅使用动态调度甚至不使用泛型来重写此代码？

如果没有泛型，这种设计是否可行？

类型推断如何与这些泛型类型和函数一起工作？

这个设计是混合函数式和面向对象编程的一个可能的例子，或者你如何评估这个设计？

Answer 1

How do you rewrite this code only using object oriented programming i.e. without passing higher order functions and only using dynamic dispatch or even without generics?

class FuncImpl implements Function<CustomerRequest, CustomerResponse> {
    public CustomerResponse apply(CustomerResquest q) {
        try {
            return myService.doSomething(q);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }
}
Function<CustomerRequest, CustomerResponse> requestFunc = new FuncImpl();

class FuncImpl2 implements Function<CustomerResponse,List<Customer>> {
    public List<Customer> apply(CustomerResponse r) {
        return r.getCustomer();
    }
}

...
return fetchUtils.getSomething(query, requestFunc,new FuncImpl2());

Would this design be possible without generics?

当然，在任何地方强制执行具体类型。 (请参阅下面的类型推断并手工制作......)。

How type inference works here with these generic types and functionals?

泛型参数只是类型变量，所以你的例子很容易理解。
requestFun有类型 Function<CustomerRequest, CustomerResponse>那么编译器可以很容易地推断出 MSGIN是 CustomerRequest和 MSGOUT CustomerResponse .

对于 r -> r.getCustomer()编译器已经知道 MSGOUT是 CustomerResponse然后它查看 CustomerResponse输入并找到 getCustomer返回 List<Customer>因此 lambda 的类型为 Function<CustomerResponse,List<Customer>>然后 R是 List<Customer>

Is this design a possible example of mixing functional and object oriented programming or how do you evaluate this design?

是的，这是一个很好的例子。