引言:为什么选择 Scala 与 React 的组合?
在现代 Web 开发领域,全栈应用的构建越来越注重性能、类型安全和开发效率。Scala 作为一门运行在 JVM 上的函数式编程语言,以其强大的类型系统和并发模型著称;而 React 作为前端领域的霸主,以其组件化和声明式 UI 范式改变了我们构建用户界面的方式。将这两者结合,可以创建出既稳健又高性能的全栈应用。
这种组合的优势在于:
类型安全
:Scala 的强类型系统可以延伸到 API 层,减少前后端数据传输错误
高性能
:Scala 的非阻塞 I/O 和 React 的虚拟 DOM 优化确保了应用的高效运行
代码复用
:可以共享类型定义和业务逻辑
可维护性
:清晰的架构分离和强大的类型系统使代码更易维护
第一部分:技术栈选择与架构设计
1.1 后端技术栈选择
对于 Scala 后端,我们有多种选择:
推荐栈:
框架
:Play Framework 或 Akka HTTP
JSON 处理
:Play JSON 或 Circe
数据库访问
:Slick 或 Doobie(函数式 JDBC 层)
构建工具
:sbt 或 Mill
示例项目结构:
backend/
├── build.sbt
├── project/
├── src/
│ ├── main/
│ │ ├── scala/
│ │ │ ├── controllers/
│ │ │ ├── models/
│ │ │ ├── services/
│ │ │ └── Main.scala
│ │ └── resources/
│ └── test/
1.2 前端技术栈选择
推荐栈:
框架
:React 18+(使用 Hooks)
状态管理
:Zustand 或 Jotai(轻量级)
构建工具
:Vite 或 Webpack
类型安全
:TypeScript(强烈推荐)
HTTP 客户端
:Axios 或 Fetch API
示例项目结构:
frontend/
├── public/
├── src/
│ ├── components/
│ ├── pages/
│ ├── hooks/
│ ├── types/
│ ├── services/
│ ├── App.tsx
│ └── main.tsx
├── package.json
└── vite.config.ts
1.3 全栈架构设计
推荐架构模式:
前后端分离
:通过 RESTful API 或 GraphQL 通信
类型共享
:使用 Scala 生成 TypeScript 类型定义
认证授权
:JWT Token + Refresh Token 机制
错误处理
:统一的错误响应格式
第二部分:后端实现(Scala)
2.1 使用 Play Framework 构建 REST API
首先,创建一个基本的 Play Framework 项目:
// build.sbt
name := “scala-react-app”
version := “1.0”
lazy val root = (project in file(“.”))
.enablePlugins(PlayScala)
.settings(
libraryDependencies ++= Seq(
guice,
“com.typesafe.play” %% “play-json” % “2.9.4”,
“org.postgresql” % “postgresql” % “42.5.4”,
“com.typesafe.slick” %% “slick” % “3.4.1”,
“com.typesafe.slick” %% “slick-hikaricp” % “3.4.1”
)
)
定义数据模型:
// app/models/User.scala
package models
import play.api.libs.json._
case class User(id: Long, name: String, email: String)
object User {
implicit val userFormat: OFormat[User] = Json.format[User]
}
创建 Repository 层:
// app/repositories/UserRepository.scala
package repositories
import models.User
import slick.jdbc.PostgresProfile.api._
import scala.concurrent.{ExecutionContext, Future}
class UserRepository(db: Database)(implicit ec: ExecutionContext) {
class UserTable(tag: Tag) extends Table[User](tag, “users”) {
def id = column[Long](“id”, O.PrimaryKey, O.AutoInc)
def name = column[String](“name”)
def email = column[String](“email”)
def * = (id, name, email) <> (User.tupled, User.unapply)
}
private val users = TableQuery[UserTable]
def findAll(): Future[Seq[User]] = db.run(users.result)
def findById(id: Long): Future[Option[User]] =
db.run(users.filter(_.id === id).result.headOption)
def create(user: User): Future[User] =
db.run((users returning users) += user)
def update(id: Long, user: User): Future[Int] =
db.run(users.filter(_.id === id).update(user))
def delete(id: Long): Future[Int] =
db.run(users.filter(_.id === id).delete)
}
创建 Controller:
// app/controllers/UserController.scala
package controllers
import javax.inject._
import play.api.mvc._
import play.api.libs.json._
import models.User
import repositories.UserRepository
import scala.concurrent.ExecutionContext
@Singleton
class UserController @Inject()(
cc: ControllerComponents,
userRepo: UserRepository
)(implicit ec: ExecutionContext) extends AbstractController(cc) {
def list() = Action.async {
userRepo.findAll().map { users =>
Ok(Json.toJson(users))
}
}
def get(id: Long) = Action.async {
userRepo.findById(id).map {
case Some(user) => Ok(Json.toJson(user))
case None => NotFound(Json.obj(“error” -> “User not found”))
}
}
def create() = Action.async(parse.json) { request =>
request.body.validate[User].map { user =>
userRepo.create(user).map { createdUser =>
Created(Json.toJson(createdUser))
}
}.recoverTotal { _ =>
Future.successful(BadRequest(Json.obj(“error” -> “Invalid JSON”)))
}
}
def update(id: Long) = Action.async(parse.json) { request =>
request.body.validate[User].map { user =>
userRepo.update(id, user).map { count =>
if (count > 0) Ok(Json.obj(“status” -> “updated”))
else NotFound(Json.obj(“error” -> “User not found”))
}
}.recoverTotal { _ =>
Future.successful(BadRequest(Json.obj(“error” -> “Invalid JSON”)))
}
}
def delete(id: Long) = Action.async {
userRepo.delete(id).map { count =>
if (count > 0) Ok(Json.obj(“status” -> “deleted”))
else NotFound(Json.obj(“error” -> “User not found”))
}
}
}
配置路由:
# conf/routes
GET /api/users controllers.UserController.list()
GET /api/users/:id controllers.UserController.get(id: Long)
POST /api/users controllers.UserController.create()
PUT /api/users/:id controllers.UserController.update(id: Long)
DELETE /api/users/:id controllers.UserController.delete(id: Long)
2.2 使用 Akka HTTP 构建轻量级 API
如果你更喜欢轻量级的解决方案,Akka HTTP 是个不错的选择:
// build.sbt
libraryDependencies ++= Seq(
“com.typesafe.akka” %% “akka-http” % “10.5.0”,
“com.typesafe.akka” %% “akka-stream” % “2.8.0”,
“com.typesafe.akka” %% “akka-actor-typed” % “2.8.0”,
“de.heikoseeberger” %% “akka-http-play-json” % “1.40.0”
)
主应用:
// src/main/scala/Main.scala
import akka.actor.typed.ActorSystem
import akka.actor.typed.scaladsl.Behaviors
import akka.http.scaladsl.Http
import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.model._
import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
import spray.json.DefaultJsonProtocol._
import scala.concurrent.ExecutionContextExecutor
import scala.io.StdIn
object WebServer {
// 定义数据模型
case class User(id: Long, name: String, email: String)
// JSON 格式化
implicit val userFormat = jsonFormat3(User)
// 模拟数据存储
var users = Seq(
User(1, “Alice”, “alice@example.com”),
User(2, “Bob”, “bob@example.com”)
)
def main(args: Array[String]): Unit = {
implicit val system: ActorSystem[Nothing] = ActorSystem(Behaviors.empty, “ScalaReactApp”)
implicit val executionContext: ExecutionContextExecutor = system.executionContext
val route =
pathPrefix(“api” / “users”) {
concat(
// GET /api/users
get {
complete(users)
},
// GET /api/users/:id
path(LongNumber) { id =>
get {
users.find(_.id == id) match {
case Some(user) => complete(user)
case None => complete(StatusCodes.NotFound -> Json.obj(“error” -> “User not found”))
}
}
},
// POST /api/users
post {
entity(as[User]) { user =>
users = users :+ user
complete(StatusCodes.Created -> user)
}
},
// PUT /api/users/:id
path(LongNumber) { id =>
put {
entity(as[User]) { updatedUser =>
users = users.map { u =>
if (u.id == id) updatedUser.copy(id = id) else u
}
complete(updatedUser)
}
}
},
// DELETE /api/users/:id
path(LongNumber) { id =>
delete {
users = users.filterNot(_.id == id)
complete(StatusCodes.OK -> Json.obj(“status” -> “deleted”))
}
}
)
}
val bindingFuture = Http().newServerAt(“localhost”, 8080).bind(route)
println(s”Server online at http://localhost:8080/\nPress RETURN to stop…”)
StdIn.readLine()
bindingFuture
.flatMap(_.unbind())
.onComplete(_ => system.terminate())
}
}
2.3 配置 CORS(跨域资源共享)
在前后端分离开发中,CORS 配置至关重要:
Play Framework 配置 CORS:
// app/Filters.scala
import play.api.mvc._
import play.filters.cors.CORSFilter
import javax.inject.Inject
class Filters @Inject() (corsFilter: CORSFilter) extends HttpFilters {
override def filters = Seq(corsFilter)
}
// conf/application.conf
play.filters.cors {
allowedOrigins = [“http://localhost:3000”]
allowedHttpMethods = [“GET”, “POST”, “PUT”, “DELETE”, “OPTIONS”]
allowedHttpHeaders = [“Accept”, “Content-Type”, “Authorization”]
exposedHeaders = [“Authorization”]
}
Akka HTTP 配置 CORS:
// 添加 CORS 支持
import akka.http.scaladsl.server.directives.RespondWithDirectives
import akka.http.scaladsl.model.headers._
import akka.http.scaladsl.server.Directive0
object CORSHandler {
private val corsHeaders = List(
`Access-Control-Allow-Origin`.*,
`Access-Control-Allow-Methods`(GET, POST, PUT, DELETE, OPTIONS),
`Access-Control-Allow-Headers`(“Accept”, “Content-Type”, “Authorization”),
`Access-Control-Expose-Headers`(“Authorization”)
)
def addCORSHeaders: Directive0 = respondWithHeaders(corsHeaders)
}
第三部分:前端实现(React + TypeScript)
3.1 项目初始化
使用 Vite 创建 React + TypeScript 项目:
npm create vite@latest scala-react-frontend — –template react-ts
cd scala-react-frontend
npm install
npm install axios
3.2 类型定义
创建类型定义文件,确保前后端类型一致:
// src/types/user.ts
export interface User {
id: number;
name: string;
email: string;
}
export interface ApiError {
error: string;
}
export interface ApiResponse
data?: T;
error?: string;
loading: boolean;
}
3.3 API 服务层
创建统一的 API 服务层:
// src/services/api.ts
import axios, { AxiosInstance, AxiosResponse, AxiosError } from ‘axios’;
import { User, ApiError } from ‘../types/user’;
class ApiService {
private client: AxiosInstance;
constructor(baseURL: string) {
this.client = axios.create({
baseURL,
timeout: 10000,
headers: {
‘Content-Type’: ‘application/json’,
},
});
// 请求拦截器
this.client.interceptors.request.use(
(config) => {
const token = localStorage.getItem(‘authToken’);
if (token) {
config.headers.Authorization = `Bearer ${token}`;
}
return config;
},
(error) => Promise.reject(error)
);
// 响应拦截器
this.client.interceptors.response.use(
(response) => response,
(error: AxiosError
if (error.response?.status === 401) {
// 处理未授权
localStorage.removeItem(‘authToken’);
window.location.href = ‘/login’;
}
return Promise.reject(error);
}
);
}
// 用户相关 API
async getUsers(): Promise
const response = await this.client.get
return response.data;
}
async getUser(id: number): Promise
const response = await this.client.get
return response.data;
}
async createUser(user: Omit
const response = await this.client.post
return response.data;
}
async updateUser(id: number, user: User): Promise
const response = await this.client.put
return response.data;
}
async deleteUser(id: number): Promise
await this.client.delete(`/api/users/${id}`);
}
}
// 导出单例实例
export const apiService = new ApiService(‘http://localhost:8080’);
3.4 自定义 Hooks
创建自定义 Hooks 来处理 API 调用:
// src/hooks/useUsers.ts
import { useState, useEffect, useCallback } from ‘react’;
import { apiService } from ‘../services/api’;
import { User, ApiResponse } from ‘../types/user’;
export function useUsers(): ApiResponse
const [data, setData] = useState
const [loading, setLoading] = useState
const [error, setError] = useState
const fetchUsers = useCallback(async () => {
try {
setLoading(true);
setError(null);
const users = await apiService.getUsers();
setData(users);
} catch (err) {
const message = err instanceof Error ? err.message : ‘Failed to fetch users’;
setError(message);
} finally {
setLoading(false);
}
}, []);
useEffect(() => {
fetchUsers();
}, [fetchUsers]);
return { data, loading, error };
}
export function useUser(id: number): ApiResponse
const [data, setData] = useState
const [loading, setLoading] = useState
const [error, setError] = useState
const fetchUser = useCallback(async () => {
try {
setLoading(true);
setError(null);
const user = await apiService.getUser(id);
setData(user);
} catch (err) {
const message = err instanceof Error ? err.message : ‘Failed to fetch user’;
setError(message);
} finally {
setLoading(false);
}
}, [id]);
useEffect(() => {
if (id) fetchUser();
}, [id, fetchUser]);
return { data, loading, error };
}
3.5 React 组件实现
用户列表组件:
// src/components/UserList.tsx
import React from ‘react’;
import { useUsers } from ‘../hooks/useUsers’;
import { User } from ‘../types/user’;
const UserList: React.FC = () => {
const { data: users, loading, error } = useUsers();
if (loading) return
;
if (error) return
;
return (
User List
| ID | Name | Actions | |
|---|---|---|---|
| {user.id} | {user.name} | {user.email} |
);
};
export default UserList;
用户表单组件:
// src/components/UserForm.tsx
import React, { useState, useEffect } from ‘react’;
import { apiService } from ‘../services/api’;
import { User } from ‘../types/user’;
interface UserFormProps {
userId?: number;
onSubmit?: () => void;
}
const UserForm: React.FC
const [formData, setFormData] = useState
name: ”,
email: ”
});
const [loading, setLoading] = useState
const [error, setError] = useState
useEffect(() => {
if (userId) {
loadUser();
}
}, [userId]);
const loadUser = async () => {
try {
setLoading(true);
const user = await apiService.getUser(userId);
setFormData({ name: user.name, email: user.email });
} catch (err) {
setError(‘Failed to load user’);
} finally {
setLoading(false);
}
};
const handleChange = (e: React.ChangeEvent
const { name, value } = e.target;
setFormData(prev => ({ …prev, [name]: value }));
};
const handleSubmit = async (e: React.FormEvent) => {
e.preventDefault();
setLoading(true);
setError(null);
try {
if (userId) {
await apiService.updateUser(userId, { …formData, id: userId });
} else {
await apiService.createUser(formData);
}
onSubmit?.();
} catch (err) {
setError(‘Failed to save user’);
} finally {
setLoading(false);
}
};
return (
);
};
export default UserForm;
3.6 状态管理(使用 Zustand)
对于更复杂的状态管理,推荐使用 Zustand:
// src/store/userStore.ts
import { create } from ‘zustand’;
import { apiService } from ‘../services/api’;
import { User } from ‘../types/user’;
interface UserState {
users: User[];
loading: boolean;
error: string | null;
fetchUsers: () => Promise
createUser: (user: Omit
updateUser: (id: number, user: User) => Promise
deleteUser: (id: number) => Promise
}
export const useUserStore = create
users: [],
loading: false,
error: null,
fetchUsers: async () => {
set({ loading: true, error: null });
try {
const users = await apiService.getUsers();
set({ users });
} catch (error) {
set({ error: ‘Failed to fetch users’ });
} finally {
set({ loading: false });
}
},
createUser: async (user) => {
set({ loading: true, error: null });
try {
const newUser = await apiService.createUser(user);
set(state => ({ users: […state.users, newUser] }));
} catch (error) {
set({ error: ‘Failed to create user’ });
} finally {
set({ loading: false });
}
},
updateUser: async (id, user) => {
set({ loading: true, error: null });
try {
const updatedUser = await apiService.updateUser(id, user);
set(state => ({
users: state.users.map(u => u.id === id ? updatedUser : u)
}));
} catch (error) {
set({ error: ‘Failed to update user’ });
} finally {
set({ loading: false });
}
},
deleteUser: async (id) => {
set({ loading: true, error: null });
try {
await apiService.deleteUser(id);
set(state => ({
users: state.users.filter(u => u.id !== id)
}));
} catch (error) {
set({ error: ‘Failed to delete user’ });
} finally {
set({ loading: false });
}
}
}));
3.7 主应用组件
// src/App.tsx
import React from ‘react’;
import { BrowserRouter as Router, Routes, Route } from ‘react-router-dom’;
import UserList from ‘./components/UserList’;
import UserForm from ‘./components/UserForm’;
import ‘./App.css’;
const App: React.FC = () => {
return (
Scala + React Full-Stack App
This is a full-stack application using Scala and React.
Welcome
} />