Java/Scala 상호 운용성 실습 1: 기본 작업

Java Bean

Java Bean에는 수정 가능한 속성에 해당하는 getter 및 setter 메서드가 있다는 특징이 있습니다(최종 속성에는 getter 메서드만 있음). Java로 정의된 객체는 Scala에서도 그대로 사용할 수 있습니다. Scala에서 Java Bean을 정의하는 것은 약간 다릅니다.

사실 Java Bean은 Java와 마찬가지로 Scala에서도 정의할 수 있습니다.

// Scala中默认为public访问权限，包括属性和方法class Person {
  // 下划线在这里是一个占位符，它代码相应属性对应类型的默认值
  private var id: Int = _ 
  private var name: String = _;  def getId: Int = id;  def setId(id: Int) {    this.id = id
  }  def getName: String = name;  def setName(name: String) {    this.name = name;
  }
}

이렇게 작성하면 Java와 구문이 약간 다른 점을 제외하면 정의 방법은 실제로 동일합니다. . 그러나 실제로 Scala는 getter 및 setter 함수를 자동으로 생성하는 주석을 제공합니다.

import scala.beans.BeanPropertyclass Person {  @BeanProperty
  var id: Int = _  @BeanProperty
  var name: String = _  @BeanProperty
  val createdAt: LocalDateTime = _
}

기존 클래스를 사용하는 것 외에도 케이스 클래스를 사용하여 Scala에서 POJO를 정의할 수도 있습니다.

case class SignRequest(@BeanProperty
                       account: String = null,                       @BeanProperty
                       password: String = null,                       @BeanProperty
                       captcha: String = null,                       @BeanProperty
                       var smsCode: String = null)

케이스 클래스의 기본 생성자가 선언한 매개변수는 SignRequest의 서명 역할도 하며 val입니다(Java의 공개 최종과 유사). 여기서 계정, 비밀번호 및 보안 문자는 getter 기능만 생성합니다. 그리고 smsCode는 var로 장식되어 있기 때문에 getter 및 setter 함수를 생성합니다.

Java에서는 사용할 수 없는 기능인 매개변수 기본값이 있습니다. C++, Python, ES6+와 마찬가지로 Scala 매개변수도 기본값으로 설정할 수 있습니다. Java Bean 사양에서는 클래스에 빈 매개변수가 있는 기본 생성자가 있어야 하며 케이스 클래스의 기본 생성자의 모든 매개변수가 기본값으로 설정된 경우 이 클래스를 인스턴스화할 때 빈 기본 생성자를 갖는 것과 동일합니다. .

Java 표시의 호출 케이스 클래스: com/hualongdata/springstarter/data/repository/UserRepositoryImpl.java.

주석 기반 종속성 주입

Spring 개발에서 종속성 주입은 매우 일반적으로 사용되는 기능입니다. 속성 기반 주석 주입은 Java와 Scala 모두에서 동일합니다. 그러나 생성자 기반 종속성 주입은 Scala에서 다소 특별합니다.

class SignController @Autowired()(userService: UserService,
                                  webUtils: WebUtils,
                                  hlTokenComponent: HlTokenComponent) {
  ......
}

Scala에서는 단일 주석이 생성자에 대해 작동할 때 메서드 호출과 같은 형식이 필요합니다. 자동 연결(). 그리고 Scala에서는 기본 생성자를 클래스 이름 뒤의 괄호 안에 정의해야 하므로 주석은 클래스 이름 뒤와 기본 생성자의 왼쪽 대괄호 앞에 있어야 합니다.

주입된 구성 요소에 대한 비공개 최종 액세스 권한도 있는 기본 생성자에서 주입된 구성 요소를 사용하는 것이 Scala에서는 더 나은 방법입니다. 동일한 효과를 얻으려면 더 많은 Java 코드가 필요합니다.

public SignController {
    private final UserService userService;
    private final WebUtils webUtils;
    private final HlTokenComponent hlTokenComponent;

    public SignController(UserService userService, WebUtils webUtils, HlTokenComponent hlTokenComponent) {
        this.userService = userService;
        this.webUtils = webUtils;
        this.hlTokenComponent = hlTokenComponent;
    }
}

보시다시피 Scala 버전은 코드가 적고 더 간결해 보입니다.

주석 매개변수

배열 매개변수

@RestController
@RequestMapping(Array("/sign"))
class SignController @Autowired()(userService: UserService,
  ......

스칼라에서는 주석이 달린 배열 매개변수에 하나의 요소만 설정할 때 Java와 같은 문자열, 배열이 될 수 없습니다. 명시적으로 정의해야 합니다.

매개변수 값은 상수여야 합니다

Scala에서는 주석의 매개변수가 낮은 값인 경우 @RequestMapping(Array(Constants.API_BASE + "/sign" )) 이러한 양식은 불법입니다. @RequestMapping(Array("/aip/sign"))

가변 길이 매개변수

Scala에서 가변 길이 매개변수는 별표(*)로 정의됩니다. 코드는 다음과 같습니다.

def log(format: String, value: String*)

그러나 이렇게 정의된 변수 매개변수는 Java에서 액세스할 수 없습니다. 왜냐하면 Scala 기본 구현의 값 유형은 Seq[Any]이고 변수는 Java의 매개변수 유형은 실제로 위의 배열(String[])입니다. 이 문제를 해결하는 것은 매우 간단합니다. 함수 정의 앞에 scala.annotation.varargs 주석을 추가하면 Scala가 Java 구현을 사용하여 가변 길이 매개변수를 구현하게 됩니다.

컬렉션 라이브러리

Scala有自己的一套集合库实现： scala.collection，分为不可变集合scala.collection.immutable和可变集合scala.collection.mutable。两者都实现了很多高阶函数，可以简化日常编程，同时Scala中推荐使用不可变集合。

Java集合到Scala集合

Scala提供了scala.collection.JavaConverters来转换Java集合到Scala集合：

import scala.collection.JavaConverters._  /**
    * 根据sheet名获取sheet所有单元格
    *
    * @param workbook  Excel [[Workbook]]对象
    * @param sheetName sheet 名
    * @return 返回所有有效单元格可迭代二维列表
    */
  def getSheetCells(workbook: Workbook, sheetName: String): Iterable[Iterable[RichCell]] = {
      workbook.getSheet(sheetName)
        .asScala
        .map(row => row.asScala.map(cell => new RichCell(cell)))
  }

workbook.getSheet方法返回的Sheet类型是实现了java.lang.Iterable接口的可迭代类型。为了使用Scala集合上提供的map高阶函数，我们需要把Java集合转换成Scala集合。可以通过在Java集合上调用.asScala函数来将其转换成Scala集合，这里运用了Scala里的隐式转换特性来实现。

Scala集合到Java集合

接下来我们看另外一个函数：

  @varargs
  def getSheets(workbook: Workbook, sheetNames: String*): java.util.List[Sheet] = {
    sheets(workbook, sheetNames: _ *).asJava
  }

这个函数实现的功能是根据传入的一个或多个Sheet名字从Excel里获取Sheet列表。sheets函数返回的是一个Scala集合：Seq[Sheet]，通过getSheets代理函数将其转换成Java集合，通过在Seq[Sheet]上调用.asJava方法来实现自动转换。同样的，这里也运用了Scala的隐式转换特性。

Java代码中做集合转换

之前的例子都是在Scala代码中实现的，通过隐式转换这一特性我们发现做Java/Scala集合的相互转换是非常方便的。但在Java代码中做两者的转换就不那么直观了，因为Java没有隐式转换这一特性，我们需要显示的调用代码来先生成包装类，再调用.asScala或.asJava方法来转换集合类型：

import scala.collection.JavaConverters$;import scala.collection.mutable.Buffer;    public static void demo() {
        List<String> list = Arrays.asList("dd", "dd");        // Java List 到 Scala Buffer
        Buffer<String> scalaBuffer = JavaConverters$.MODULE$.asScalaBufferConverter(list).asScala();        // Scala Buffer 到 Java List
        List<String> javaList = JavaConverters$.MODULE$.bufferAsJavaListConverter(scalaBuffer).asJava();
    }

为Java和Scala同时提供API

当在项目中混用Java和Scala语言时，有个问题不得不重视。提供的API是用Java还是Scala来实现？实现的API是优先考虑兼容Java还是Scala？

对于API的实现，用Java或Scala均可。若使用Java实现，在Scala中调用是基本无压力的。而使用Scala实现时，为了兼容Java你可能不得不作一些折中。一个常用的方式是：使用Scala或Java来实现API，而再用Java或Scala来实现一个封装层（代理）作兼容。比如：Spark、Akka……，它们使用Scala来实现API，但提供了包装的Java API层。

一个好的实践是把Scala API放到scalaapi包路径（或者反之把Java API放到javaapi包路径）。

若我们只提供一个API，那就要尽量同时支持Java和Scala方便的 调用。比如使用@varargs注解来修饰变长参数。

对于参数需要集合类型，或返回值为集合类型的函数。我们除了使用上一节提供的JavaConverters来做自动/手动转换以外，也可以通过装饰器形式来提供Java或Scala专有的API。这里，我推荐Scala API函数名直接使用代表操作的名词/动词实现，而Java API在之前加上：get、set、create等前缀进行修饰。

def sheets(workbook: Workbook, sheetNames: String*): Seq[Sheet] = {
    sheetNames.map(sheetName => workbook.getSheet(sheetName))
  }  @varargs
  def getSheets(workbook: Workbook, sheetNames: String*): java.util.List[Sheet] = {
    sheets(workbook, sheetNames: _ *).asJava
  }

这里sheets和getSheets实现相同的功能，区别是第一个是Scala API，第二个是Java API。

结语

本文较详细的介绍了Java/Scala的互操作性，以上示例都来自作者及团队的实际工作。

这篇文章简单介绍了一些基础的Java/Scala互操作方法，接下来的文章将介绍些高级的互操作：Future、Optional/Option、lamdba函数、类与接口等。