Lambda函数编程的个人理解

Lambda函数编程

• 要用Lambda函数编程 就不要使用比较 简单的Lambda函数，
  例如

  Function<Integer,String> functional = o -> String.valueOf(o);
  Predicate<Integer> predicate = age -> age > 18
  

  可以尝试着使用复合Lambda函数编程组装的使用，并且运用至真实的项目中，接下来我会使用Function函数来梳理出如何组装自己想要的一种复合函数运用到业务中去

  例如

  public static void main(){
      Function<Function<String, CmsResult<Object>>, Function<Function<CmsResult<Object>, String>, Function<String, String>>>
              function2 = arg1 ->  arg2 -> arg3 -> arg2.apply(arg1.apply(arg3));
      
      String xx = function2.apply(cuFunction::forceLoginMsg).apply(x -> JSON.toJSONString(x)).apply("tf");
  }
  
  static CmsResult forceLoginMsg(String fileType){
      if (fileType.equals("tf")){
          return ResultUtil.error(9999, "tf");
      }else {
          return ResultUtil.error(9999, "tf000");
      }
  }
  

  上诉的代码对于有函数经验的同学来说不是问题，大致使用原生代码解释一下:

   public static void main(){
          CmsResult result = forceLoginMsg("tf");
          String xx = JSON.toJSONString(result);
      }
  
      static CmsResult forceLoginMsg(String fileType){
          if (fileType.equals("tf")){
              return ResultUtil.error(9999, "tf");
          }else {
              return ResultUtil.error(9999, "tf000");
          }
      }
  

  是的，你没看错，使用Lambda反而比较复杂化。但是你们却忽略了一个重要性，那就是lambda可以灵活的组合方式使用泛型，
  例如

  //Function<String, CmsResult<Object>> 中 <V,F> 都是可以根据自己的类型去推算的
  Function<Function<String, CmsResult<Object>>, Function<Function<CmsResult<Object>, String>, Function<String, String>>>
              function2 = arg1 ->  arg2 -> arg3 -> arg2.apply(arg1.apply(arg3));
    // 上诉代码是 将CmsResult类型转换为String类型，也可以直接灵活使用，将CmsResult变成其他类型，或者是其他类型变成String类型，具体需要根据自己的业务去推算。
  

  推算Lambda表达式时，只需要记住一点，那就是匿名内部类的方式实现的去推算，上诉代码推算过程如下代码所示

  public static void main(){
      Function<Function<String, CmsResult<Object>>, Function<Function<CmsResult<Object>, String>, Function<String, String>>> function2 =
              new Function<Function<String, CmsResult<Object>>, Function<Function<CmsResult<Object>, String>, Function<String, String>>>() {
                  @Override
                  public Function<Function<CmsResult<Object>, String>, Function<String, String>> apply(Function<String, CmsResult<Object>> arg1) {
                      return new Function<Function<CmsResult<Object>, String>, Function<String, String>>() {
                          @Override
                          public Function<String, String> apply(Function<CmsResult<Object>, String> arg2) {
                              return new Function<String, String>() {
                                  @Override
                                  public String apply(String arg3) {
                                      CmsResult<Object> apply = arg1.apply(arg3);
                                      String apply1 = arg2.apply(apply);
                                      return apply1;
                                      //可以一行代码表示：return arg2.apply(arg1.apply(arg3));
                                  }
                              };
                          }
                      };
                  }
              };
      String xx = function2.apply(cuFunction::forceLoginMsg).apply(x -> JSON.toJSONString(x)).apply("tf");
  }
  static CmsResult forceLoginMsg(String fileType){
      if (fileType.equals("tf")){
          return ResultUtil.error(9999, "tf");
      }else {
          return ResultUtil.error(9999, "tf000");
      }
  }
  

  最后展现一下，运用到真实项目的一个场景（运用在项目的策略模式下）
  如下（观赏就好，去除很多了代码，运用不起来）

  /**
   * @Description: 二级直接选择器
   **/
   public static  <V> V strategy(SpringStrategyContext.StrategyEnum en,String beanName){
      Function<
              Function<Map, V>,
              Function<
                      Function<SpringStrategyContext.StrategyEnum, Map>,
                      Function<SpringStrategyContext.StrategyEnum, V>
                      >
              > functionFunctionFunction = strategy();
      return functionFunctionFunction.apply(x -> (V) x.get(beanName)).apply(x -> allStrategyMap.get(x)).apply(en) ;
  }
  /**
   * @Description: 一级直接选择器（可根据一级直接选择器扩展二级选择器）
   **/
   public static <T  extends Enum,U,V> Function<Function<U,V>,Function<Function<T,U>,Function<T,V>>> strategy(){
      return x-> y -> z -> x.apply(y.apply(z));
  }
  
  /**
  * 此方法为示范调用
  **/
  CmsSubjectTypeService propertyService = SpringStrategyContext
              .strategy(SpringStrategyContext.StrategyEnum.subjectPropertyServiceMap
                      ,SpringStrategyContext.StrategySubjectPropertyFinal.SUBJECT + cmsSubject.getType());
  

  搞懂一种函数的使用变化推算，就可以融合其他的函数一起做组合，乃至是链条组合方式。这样的场景一般都是用在一套程序上的。单个使用没有任何意义