栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

scala隐式转换在流式调用中的应用

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

scala隐式转换在流式调用中的应用

前言

关于流式调用,熟悉Java的小伙伴可能第一时间都会想到Java8关于stream相关的API,类似这种的代码list.stream().map(item->item+1).colletion(Collector::toList),流式调用带给我们的直接感受是代码量的减少。但是由于Java的特性导致一旦流式代码过长或者封装的不好会导致可读性急剧下降。这里我想要分享一个scala中基于隐式转换的流式调用,来帮助我们将结构更清晰化,聚焦核心代码逻辑的应用。

示例

以下我会用一个简单的代码片段来比较java和scala中流式调用的异同,以及隐式转换给我带来了什么便利。

Java版本

这里我实现加减乘除的流式调用作为例子。在java中一个封装好的流式调用可能如下所示,这里可以看到我需要生命一个类来承载我的流式方法,并且需要提供一个获取结果的方法,每次流式调用返回的都是一个EnrichInteger对象,只有最终获取结果时会返回真正需要的对象类型。其实这里和上面stream list.stream().map(item->item+1).collet(Collector::toList)的用法是类似的,stream的转换算子每次返回的也是stream流,最终通过一个生成结果的方法来获取对应的数据类型。

public class JavaTest {
    public static void main(String[] args) {
        int a = 10;
        final int result = new EnrichInteger(a)
                .add(10)
                .divide(2)
                .multiple(3)
                .minus(5)
                .getInt();
        System.out.println(result);
    }

    static class EnrichInteger {
        private int self;

        public EnrichInteger(int self) {
            this.self = self;
        }

        public EnrichInteger add(int value) {
            self = self + value;
            return this;
        }

        public EnrichInteger minus(int value) {
            self = self - value;
            return this;
        }

        public EnrichInteger divide(int value) {
            self = self / value;
            return this;
        }

        public EnrichInteger multiple(int value) {
            self = self * value;
            return this;
        }

        public int getInt() {
            return this.self;
        }
    }
}
scala版本

由于scala有隐式转换,在scala中的流式调用会更优雅,去除了没必要的封装。这里可以看到我既不需要手动创建EnrichInt对象也不需要在获取结果时通过执行一个get方法来获取对应的对象类型,这里就是一个隐式转换会自动将int转换成EnrichInt对象,最终也是会将EnrichInt自动转换成int。这种用法在Spark提供的DataFrame系列API中随处可见,相比于显式的new对象,这种流式调用回归了流的本质,并且让代码流程更优雅。

object ScalaTest {
  def main(args: Array[String]): Unit = {
    val a = 10
    val result = a.add(10)
      .divide(2)
      .multiple(3)
      .minus(5)
    println(result)
  }

  implicit class EnrichInt(val self: Int) {

    def add(value: Int): Int = {
      self + value
    }

    def minus(value: Int): Int = {
      self - value
    }

    def divide(value: Int): Int = {
      self / value
    }

    def multiple(value: Int): Int = {
      self * value
    }
  }
}
Java中做不到的优雅流式方法,而通过隐式转换可以做到

实际应用中我们经常会有这样的逻辑,在进入一个方法时,我们会先判断入参是否合法吗,不合法就直接抛异常,java代码大致如下:

public void test(int a){
	if (a <= 0) {
		throw new IllegalArguementException("value can't be less than 0.");
	}
	.......
}

但是当我们想要让它变成流逝调用时,它会变得很奇怪,大概变成这样子。实际上你只会觉得很蠢,直接调用一个check()方法就行了对吧。

public class JavaTest {
    public static void main(String[] args) {
        int a = 10;
        // 做参数业务逻辑的检查
        new EnrichInteger(a).check();
        // check(); 通常我们会直接执行check()方法而不是封装一层
        // 检查通过进行后续逻辑
        int result = a/10;
        System.out.println(result);
    }

    static class EnrichInteger {
        private final int self;

        public void check() {
            if (self <= 0) {
                throw new IllegalArgumentException("value can't be less than 0.");
            }
        }

        public EnrichInteger(int self) {
            this.self = self;
        }
    }
}

那么到scala中我们应用隐式调用能怎么让它变得优雅呢,可以看到在我的主逻辑里面我可以很清晰的整理整个方法的逻辑流程,减少了主逻辑中的非核心代码,当我们需要在主逻辑中强调核心流程,可以将一些分支流程通过隐式转换的方式分装到隐式类中。

object ScalaTest {
  def main(args: Array[String]): Unit = {
    val result = a
	  .check()
      .add(10)
      .divide(2)
      .multiple(3)
      .minus(5)
    println(result)
  }

  implicit class EnrichInt(val self: Int) {

    def add(value: Int): Int = {
      self + value
    }

    def minus(value: Int): Int = {
      self - value
    }

    def divide(value: Int): Int = {
      self / value
    }

    def multiple(value: Int): Int = {
      self * value
    }

    def check(): Int = {
      if (self <= 0) {
        throw new IllegalArgumentException("self must be more than 0.")
      }
      self
    }
  }
}
隐式转换流式调用的实际应用[DataFrame]

在大数据项目中,我们经常会使用DataFrame来操作数据,并且因为DataFrame的API并不是非常丰富,我们不得不自己进行一些封装。下面我举例说明隐式转换对于代码可读性的提高。
这是一段多表join的逻辑,多表join的时候大部分场景是join一些维度表需要拿到某个有用的信息,这是将他们都写到了一起,我们很难知道主流程到底是在干嘛,这时候如果我们能将主流程和这些获取维度信息的代码分开,会让我们这一长段代码的目的变得很清晰。

def getUserGmv():DataFrame = {
	val userDf = readTableUser()
	     .select("id","name","saleType")
	
	// 用户下单记录
	val hist = readTableHist().select("id","gmv","price")
	
	// 获取用户等级
	val userLevelDf = readTableUserLevel().select("id","level")
	
	userDf.join(userLevelDf, Seq("id"))
	.join(hist, Seq("id"))
	.select("id","gmv","price","level")
} 

下面我稍微改造一下这段代码,将其获取维度信息的代码抽离到隐式转换类中,我们能很清晰的看懂这段逻辑是在干嘛了,因为它的非主分支代码已经被剥离开来了。尤其是当代码逻辑越复杂时,理清楚什么是主分支,会让我们的代码可读性大大提高,减少流水账代码。

def getUserGmv():DataFrame = {
	val userDf = readTableUser()
	      .select("id","name","saleType")
	      .enrichWithUserLevel()
	val hist = readTableHist().select("id","gmv","price")
	userDf
	.join(hist, Seq("id"))
	.select("id","gmv","price","level")
}
implicit class ImplicitEnrichUserLevel(val userDf:DataFrame){
	
	def enrichWithUserLevel():DataFrame={
		// 获取用户等级
		val userLevelDf = readTableUserLevel().select("id","level")
		userDf.join(userLevelDf, Seq("id"))
		.select(userDf("*"),userLevelDf("level"))
	}
}
总结

scala中隐式转换能帮助我们让代码变得更整洁,但是注意不要利用隐式转换做太多逻辑哦,尤其是主逻辑尽量不要放隐式类中,会导致主逻辑分散,合理使用隐式转换会让你的代码变得非常优雅,丝滑。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/936643.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号