跳转到主要内容
版本：v2.2.0-0.13.1

示例

本指南提供了全面的示例，展示插件如何转换您的代码以及不同配置的效果。

基本转换示例​

简单函数转换​

import love.forte.plugin.suspendtrans.annotation.*


class ApiService {
    @JvmBlocking
    @JvmAsync
    suspend fun fetchData(): String {
        delay(1000)
        return "Data fetched successfully"
    }
}

接口和实现示例​

带有挂起函数的接口​

import love.forte.plugin.suspendtrans.annotation.*


@JvmBlocking
@JvmAsync
interface UserRepository {

    suspend fun findById(id: String): User?


    suspend fun save(user: User): User

    @JvmBlocking(asProperty = true)
    suspend fun count(): Long
}

实现类​

@JvmBlocking
@JvmAsync
class UserRepositoryImpl : UserRepository {

    override suspend fun findById(id: String): User? {
        delay(100)
        return User(id, "John Doe")
    }


    override suspend fun save(user: User): User {
        delay(200)
        return user.copy(id = generateId())
    }

    @JvmBlocking(asProperty = true)
    override suspend fun count(): Long {
        delay(50)
        return 42L
    }


    suspend fun deleteById(id: String): Boolean {
        delay(150)
        return true
    }
}

JavaScript 示例​

基本 JS Promise 转换​

import love.forte.plugin.suspendtrans.annotation.JsPromise

class ApiClient {
    @JsPromise
    suspend fun fetchUser(id: String): User {
        delay(500)
        return User(id, "Jane Doe")
    }

    @JsPromise
    suspend fun updateUser(user: User): User {
        delay(300)
        return user
    }
}

属性示例​

属性生成​

class ConfigService {
    @JvmBlocking(asProperty = true)
    suspend fun serverUrl(): String {
        delay(10)
        return "https://api.example.com"
    }

    @JvmBlocking(asProperty = true)
    @JvmAsync
    suspend fun timeout(): Int {
        delay(5)
        return 30000
    }
}

MarkName 示例​

自定义函数名称​

class PaymentService {
    @JvmBlocking(markName = "processPaymentSync")
    suspend fun processPayment(amount: Double): PaymentResult {
        delay(2000)
        return PaymentResult.Success(amount)
    }
    
    @JsPromise(markName = "calculateTaxAsync")
    suspend fun calculateTax(amount: Double): Double {
        delay(100)
        return amount * 0.1
    }
}

复杂类示例​

功能完整的服务类​

源代码：

import love.forte.plugin.suspendtrans.annotation.*

@JvmBlocking
@JvmAsync
class OrderService : CoroutineScope {
    override val coroutineContext = SupervisorJob() + Dispatchers.IO

    suspend fun createOrder(order: Order): Order {
        validateOrder(order)
        delay(500) // 模拟数据库操作
        return order.copy(id = generateOrderId(), status = OrderStatus.CREATED)
    }

    suspend fun findOrder(id: String): Order? {
        delay(200)
        return mockDatabase.find(id)
    }

    @JvmBlocking(asProperty = true)
    suspend fun orderCount(): Long {
        delay(100)
        return mockDatabase.count()
    }

    suspend fun updateOrderStatus(id: String, status: OrderStatus): Order? {
        delay(300)
        return mockDatabase.updateStatus(id, status)
    }

    private suspend fun validateOrder(order: Order) {
        delay(50)
        if (order.items.isEmpty()) {
            throw IllegalArgumentException("Order must have at least one item")
        }
    }
}

编译结果：

提示

从反编译结果简化而来。

import love.forte.plugin.suspendtrans.annotation.*
import kotlin.jvm.JvmSynthetic

@JvmBlocking
@JvmAsync
class OrderService : CoroutineScope {
    override val coroutineContext = SupervisorJob() + Dispatchers.IO

    @Api4J
    val orderCountBlocking: Long
        get() = runInBlocking { orderCount() }

    @JvmSynthetic
    suspend fun createOrder(order: Order): Order {
        validateOrder(order)
        delay(500)
        return order.copy(id = generateOrderId(), status = OrderStatus.CREATED)
    }

    @Api4J
    fun createOrderAsync(order: Order): java.util.concurrent.CompletableFuture<out Order> =
        runInAsync(block = { createOrder(order) }, scope = this)

    @Api4J
    fun createOrderBlocking(order: Order): Order = runInBlocking { createOrder(order) }

    @JvmSynthetic
    suspend fun findOrder(id: String): Order? {
        delay(200)
        return mockDatabase.find(id)
    }

    @Api4J
    fun findOrderAsync(id: String): java.util.concurrent.CompletableFuture<Order?> =
        runInAsync(block = { findOrder(id) }, scope = this)

    @Api4J
    fun findOrderBlocking(id: String): Order? = runInBlocking { findOrder(id) }

    @JvmSynthetic
    @JvmBlocking
    suspend fun orderCount(): Long {
        delay(100)
        return mockDatabase.count()
    }

    @Api4J
    fun orderCountAsync(): java.util.concurrent.CompletableFuture<Long> =
        runInAsync(block = { orderCount() }, scope = this)

    @JvmSynthetic
    suspend fun updateOrderStatus(id: String, status: OrderStatus): Order? {
        delay(300)
        return mockDatabase.updateStatus(id, status)
    }

    @Api4J
    fun updateOrderStatusAsync(id: String, status: OrderStatus): java.util.concurrent.CompletableFuture<Order?> =
        runInAsync(block = { updateOrderStatus(id, status) }, scope = this)

    @Api4J
    fun updateOrderStatusBlocking(id: String, status: OrderStatus): Order? =
        runInBlocking { updateOrderStatus(id, status) }

    private suspend fun validateOrder(order: Order) {
        delay(50)
        if (order.items.isEmpty()) {
            throw IllegalArgumentException("Order must have at least one item")
        }
    }
}

从 Java 使用​

从 Java 调用生成的函数​

public class JavaClient {
    private final OrderService orderService = new OrderService();

    public void demonstrateUsage() {
        // 使用阻塞变体
        Order order = new Order(/* ... */);
        Order createdOrder = orderService.createOrderBlocking(order);

        Long count = orderService.getOrderCountBlocking();

        // 使用异步变体
        CompletableFuture<Order> futureOrder = orderService.createOrderAsync(order);
        futureOrder.thenAccept(result -> {
            System.out.println("Order created: " + result.getId());
        });

        CompletableFuture<Order> findFuture = orderService.findOrderAsync("order-123");
        Order foundOrder = findFuture.join(); // 阻塞等待
    }
}

从 JavaScript 使用​

从 JavaScript 调用生成的函数​

// 假设已导入 Kotlin/JS 模块
const apiClient = new ApiClient();

// 使用基于 Promise 的变体
apiClient.fetchUserAsync("user-123")
    .then(user => {
        console.log("User fetched:", user.name);
        return apiClient.updateUserAsync(user);
    })
    .then(updatedUser => {
        console.log("User updated:", updatedUser.name);
    })
    .catch(error => {
        console.error("Error:", error);
    });

// 使用 async/await
async function handleUser() {
    try {
        const user = await apiClient.fetchUserAsync("user-456");
        const updatedUser = await apiClient.updateUserAsync(user);
        console.log("Process completed:", updatedUser);
    } catch (error) {
        console.error("Error:", error);
    }
}