天天看點
傳回

SpringBoot項目使用Scala進行Web開發

Scala是一門多範式的程式設計語言，一種類似Java的程式設計語言，設計初衷是實作可伸縮的語言并內建面向對象程式設計。Scala把Erlang風格的基于actor的并發帶進了JVM，開發者可以利用Scala的actor模型在JVM上設計具伸縮性的并發應用程式，它會自動獲得多核心處理器帶來的優勢，而不必依照複雜的Java線程模型來編寫程式，接下來就介紹一下如何在SpringBoot架構中使用Scala來進行簡單的Web開發，對scala不了解的建議先去學習基礎哦

一、導入依賴 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.gjing.project</groupId>
    <artifactId>scala-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>scala-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--加入Scala依賴庫-->
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.13.1</version>
        </dependency>

        <dependency>
            <groupId>cn.gjing</groupId>
            <artifactId>tools-starter-swagger</artifactId>
            <version>1.3.0</version>
        </dependency>
        <dependency>
            <groupId>cn.gjing</groupId>
            <artifactId>tools-common</artifactId>
            <version>1.2.7</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!--加入Scala的編譯插件，否則無法進行編譯-->
            <plugin>
                <groupId>org.scala-tools</groupId>
                <artifactId>maven-scala-plugin</artifactId>
                <version>2.15.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

通過上面我們可以發現，和建立Java版本的SpringBoot項目沒啥不同，隻是引入了

scala-library

這個我們之前沒引入的包，同時增加了對

scala

編譯的插件

二、配置YML檔案 

server:
  port: 8080
spring:
  application:
    name: scala-demo
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/demo?characterEncoding=utf8&useSSL=false
    username: root
    password: root
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      maximum-pool-size: 5
      minimum-idle: 1
      idle-timeout: 30000
      connection-timeout: 30000
  jpa:
    database: mysql
    hibernate:
      ddl-auto: update
    # 設定創表引擎為Innodb，不然預設為MyiSam
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect

swagger:
  base-package: com.gjing.project.scala.controller
  title: scala學習的demo

三、建立實體類 

import javax.persistence._

import scala.beans.BeanProperty

/**
 * @author Gjing
 **/
@Entity
@Table(name = "scala_customer")
class Customer {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @BeanProperty
  var id:Integer = _

  @BeanProperty
  var customerName:String = _

  def this(customerName:String){
    this()
    this.customerName = customerName
  }

  override def toString: String = s"Customer($id,$customerName)"
}

這塊和我們用

java

開發沒啥不同，隻是

@BeanProperty

注解會幫我們生成

get

和

set

四、Repository層 

import com.gjing.project.scala.entity.Customer
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository

/**
 * @author Gjing
 **/
@Repository
trait CustomerRepository extends JpaRepository[Customer, Integer] {
  /**
   * 通過使用者名查詢
   * @param name 使用者名
   * @return Customer
   */
  def findByCustomerName(name:String) : Customer
}

這裡和

JAVA

不同的是泛型采用的是

[]

中括号，這點要注意

五、Service層 

import cn.gjing.tools.common.result.PageResult
import com.gjing.project.scala.entity.Customer
import com.gjing.project.scala.exceptions.MyServiceException
import com.gjing.project.scala.repository.CustomerRepository
import javax.annotation.Resource
import org.springframework.data.domain.Pageable
import org.springframework.stereotype.Service

/**
 * @author Gjing
 **/
@Service
class CustomerService @Resource()(customerRepository: CustomerRepository) {
  /**
   * 儲存使用者
   *
   * @param name 使用者名
   */
  def saveCustomer(name: String): Unit = {
    var customer = customerRepository.findByCustomerName(name)
    if (customer != null) {
      throw MyServiceException("添加失敗，使用者已存在")
    }
    customer = new Customer(name)
    customerRepository.save(customer)
  }

  /**
   * 分頁查詢
   *
   * @param pageable 分頁對象
   * @return
   */
  def pageCustomer(pageable: Pageable): PageResult[java.util.List[Customer]] = {
    val page = customerRepository.findAll(pageable)
    return PageResult.of(page.getContent, page.getTotalPages, page.getSize, page.getTotalElements, page.getNumber)
  }

  /**
   * 更新使用者名
   * @param id 使用者id
   * @param name 使用者名
   */
  def updateCustomer(id: Integer, name: String): Unit = {
    val customer = customerRepository.findById(id).orElseThrow(() => MyServiceException("更新失敗，使用者不存在"))
    customer.setCustomerName(name)
    customerRepository.saveAndFlush(customer)
  }

  /**
   * 删除指定使用者
   * @param id 使用者id
   */
  def deleteCustomer(id:Integer): Unit = {
    val customer = customerRepository.findById(id).orElseThrow(() => MyServiceException("删除失敗，使用者不存在"))
    customerRepository.delete(customer)
  }
}

有意思的是，在scala中依賴注入是寫在類名上的

六、Controller層 

import cn.gjing.tools.common.annotation.NotEmpty
import cn.gjing.tools.common.result.PageResult
import com.gjing.project.scala.entity.Customer
import com.gjing.project.scala.service.CustomerService
import io.swagger.annotations.{Api, ApiImplicitParam, ApiImplicitParams, ApiOperation}
import javax.annotation.Resource
import org.springframework.data.domain.PageRequest
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation._

/**
 * @author Gjing
 **/
@RestController
@Api(tags = Array("使用者的相關功能"))
class CustomerController @Resource()(customerService:CustomerService){
  @PostMapping(Array("/customer"))
  @ApiOperation("添加使用者")
  @ApiImplicitParam(name = "customerName",value = "使用者名",dataType = "String",required = true,paramType = "query")
  @NotEmpty
  def saveCustomer(customerName:String): ResponseEntity[String] ={
    customerService.saveCustomer(customerName)
    ResponseEntity.ok("添加成功")
  }

  @GetMapping(Array("/customer_page"))
  @ApiOperation("分頁查詢")
  @ApiImplicitParams(Array(
    new ApiImplicitParam(name = "page",value = "頁數",required = true,dataType = "int",paramType = "query"),
    new ApiImplicitParam(name = "size",value = "條數",required = true,dataType = "int",paramType = "query"),
  ))
  def pageCustomer(page:Integer,size:Integer): ResponseEntity[PageResult[java.util.List[Customer]]]={
    ResponseEntity.ok(customerService.pageCustomer(PageRequest.of(page, size)))
  }


  @NotEmpty
  @PutMapping(Array("/customer"))
  @ApiOperation("更新使用者")
  @ApiImplicitParams(Array(
    new ApiImplicitParam(name = "id",value = "使用者ID",required = true,dataType = "int",paramType = "query"),
    new ApiImplicitParam(name = "name",value = "使用者名",required = true,dataType = "String",paramType = "query")
  ))
  def updateCustomer(id:Integer,name:String): ResponseEntity[String] = {
    customerService.updateCustomer(id, name)
    ResponseEntity.ok("修改成功")
  }

  @DeleteMapping(Array("/customer/{id}"))
  @ApiOperation("删除使用者")
  def deleteCustomer(id:Integer): ResponseEntity[String] = {
    customerService.deleteCustomer(id)
    ResponseEntity.ok("删除成功")
  }
}

這樣我們一個簡單的Scala版本的Web項目就寫好啦，隻需要啟動就可以試着運作啦，本文的源代碼位址：

scala-demo

，有任何不清楚的可以在評論區回複哈

java 關系型資料庫 scala spring項目使用web java什麼資料類型 java資料結構處理 java資料庫資料類型 java行資料
上一篇: 帶你“找對象”--Java記憶體分析 | 帶你學《Java面向對象程式設計》之二
下一篇: MVP一周精選 20191129： 用技術實作商業價值，用技術實作人生價值！

繼續閱讀