spring 0.4.7

Rust microservice framework like spring boot in java
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

## Compile-time dependency inject

spring-rs provides a special Component - [Service](https://docs.rs/spring/latest/spring/plugin/service/index.html), which supports injecting dependent components at compile time.

Like the following example, `UserService` only needs to derive the `Service` trait. In order to distinguish the injected dependencies, you need to specify whether the dependency is a Component or a Config through the attribute macros `#[inject(component)]` and `#[inject(config)]`.

```rust
use spring_sqlx::ConnectPool;
use spring::config::Configurable;
use spring::plugin::service::Service;
use serde::Deserialize;

#[derive(Clone, Configurable, Deserialize)]
#[config_prefix = "user"]
struct UserConfig {
    username: String,
    project: String,
}

#[derive(Clone, Service)]
struct UserService {
    #[inject(component)]
    db: ConnectPool,
    #[inject(config)]
    config: UserConfig,
}

#[derive(Clone, Service)]
struct UserWithOptionalComponentService {
    #[inject(component)]
    db: Option<ConnectPool>, // If ConnectPool does not exist, inject None
    #[inject(config)]
    config: UserConfig,
}
```

For the complete code, see [`dependency-inject-example`](https://github.com/spring-rs/spring-rs/tree/master/examples/dependency-inject-example).

> Service also supports grpc mode and can be used in conjunction with the [spring-grpc](https://spring-rs.github.io/docs/plugins/spring-grpc/) plug-in

## Nested dependency inject

spring-rs supports multi-level dependency injection. For example, if `UserService` depends on `OtherService`, and `OtherService` depends on `DatabaseService`, then when you inject `UserService`, `OtherService` and `DatabaseService` will be automatically injected.

```rust
use spring::plugin::LazyComponent;
use spring::plugin::service::Service;

#[derive(Clone, Service)]
struct DatabaseService {
    // ...
}
#[derive(Clone, Service)]
struct OtherService {
    #[inject(component)]
    db: DatabaseService,
}
#[derive(Clone, Service)]
struct UserService {
    #[inject(component)]
    other_service: OtherService,
}
```

For the complete code, see [`nested-dependency-inject-example`](https://github.com/spring-rs/spring-rs/tree/master/examples/nested-dependency-inject-example).

## Circular dependency inject

When two services reference each other, Rust's type system prevents direct circular dependencies. To solve this, you can use `LazyComponent<T>` to break the circular dependency.

```rust
use spring::plugin::LazyComponent;
use spring::plugin::service::Service;

#[derive(Clone, Service)]
struct UserService {
    #[inject(component)] // It's optional to use #[inject] in this case
    other_service: LazyComponent<OtherService>,  // ✅ Lazy resolution
}

#[derive(Clone, Service)]
struct OtherService {
    #[inject(component)]
    user_service: UserService,  // ✅ Direct injection OK
    // And you can also make this lazy if needed
    // user_service: LazyComponent<UserService>,
}
```

This allows `UserService` to hold a lightweight reference to `OtherService` that is only resolved when needed. To access the actual component, call `.get()`.

Both sides of the circular dependency can be lazy if needed, but only one side needs to be lazy, so choose the less frequently accessed service to be lazy.

It's not necessary to use the `#[inject]` attribute with `LazyComponent<T>`, as it is automatically detected. 
Internally, this type is just a wrapper around `Arc<RwLock<...>>`, making it thread-safe.


For the complete code, see [`circular-dependency-injection-example`](https://github.com/spring-rs/spring-rs/tree/master/examples/circular-dependency-injection-example)