Skip to main content

rbatis_plus_extension/service/
service_impl.rs

1// Source: mybatis-plus-extension/.../service/ServiceImpl.java
2
3use super::i_service::IService;
4use async_trait::async_trait;
5use rbatis::executor::Executor;
6use rbatis::Error;
7use rbatis_plus_core::conditions::query::QueryWrapper;
8use rbatis_plus_core::conditions::update::UpdateWrapper;
9use rbatis_plus_core::page::Page;
10use serde::de::DeserializeOwned;
11use serde::Serialize;
12use std::marker::PhantomData;
13
14/// Service 实现基类(对标 Java `ServiceImpl<M, T>`)。
15///
16/// 提供 `IService<T>` trait 的默认实现,基于 rbatis `Executor` 执行数据库操作。
17///
18/// - `E` — Executor 类型(`RBatis`、`RBatisConnExecutor`、`RBatisTxExecutor` 等)
19/// - `T` — 实体类型
20///
21/// # 对应 Java
22///
23/// - `com.baomidou.mybatisplus.extension.service.impl.ServiceImpl<M, T>`
24///
25/// # Example
26///
27/// ```ignore
28/// use rbatis_plus_extension::service::{ServiceImpl, IService};
29///
30/// struct UserService {
31///     inner: ServiceImpl<rbatis::RBatis, User>,
32/// }
33///
34/// impl UserService {
35///     pub fn new(rb: rbatis::RBatis) -> Self {
36///         Self {
37///             inner: ServiceImpl::new(rb, "sys_user"),
38///         }
39///     }
40/// }
41/// ```
42pub struct ServiceImpl<E, T>
43where
44    E: Executor + Send + Sync + Clone + 'static,
45    T: Serialize + DeserializeOwned + Send + Sync,
46{
47    /// 数据库执行器。
48    executor: E,
49    /// 表名。
50    table_name: String,
51    /// 主键列名(默认 "id")。
52    id_column: String,
53    /// 实体类型幽灵标记。
54    _phantom: PhantomData<T>,
55}
56
57impl<E, T> ServiceImpl<E, T>
58where
59    E: Executor + Send + Sync + Clone + 'static,
60    T: Serialize + DeserializeOwned + Send + Sync,
61{
62    /// 创建 ServiceImpl 实例。
63    ///
64    /// # 参数
65    /// - `executor`: 数据库执行器(RBatis / ConnExecutor / TxExecutor)
66    /// - `table_name`: 数据库表名
67    pub fn new(executor: E, table_name: impl Into<String>) -> Self {
68        Self {
69            executor,
70            table_name: table_name.into(),
71            id_column: "id".to_string(),
72            _phantom: PhantomData,
73        }
74    }
75
76    /// 设置主键列名(默认 "id")。
77    pub fn with_id_column(mut self, column: impl Into<String>) -> Self {
78        self.id_column = column.into();
79        self
80    }
81
82    /// 获取表名。
83    pub fn table_name(&self) -> &str {
84        &self.table_name
85    }
86
87    /// 获取主键列名。
88    pub fn id_column(&self) -> &str {
89        &self.id_column
90    }
91
92    /// 获取执行器引用。
93    pub fn executor(&self) -> &E {
94        &self.executor
95    }
96
97    /// 内部:从 Value Map 中提取主键值。
98    fn extract_id(map: &rbs::Value, id_column: &str) -> rbs::Value {
99        if let rbs::Value::Map(m) = map {
100            for (k, v) in m {
101                if let rbs::Value::String(col_name) = k {
102                    if col_name == id_column {
103                        return v.clone();
104                    }
105                }
106            }
107        }
108        rbs::Value::Null
109    }
110
111    /// 内部:将 rbs::Value 解码为 Vec<T>。
112    fn decode_rows(value: rbs::Value) -> Result<Vec<T>, Error> {
113        match value {
114            rbs::Value::Array(arr) => {
115                let mut result = Vec::with_capacity(arr.len());
116                for item in arr {
117                    let row: T = rbs::from_value(item)?;
118                    result.push(row);
119                }
120                Ok(result)
121            }
122            _ => Ok(Vec::new()),
123        }
124    }
125
126    /// 内部:从 Value Map 中提取 u64 总数。
127    fn extract_count(value: &rbs::Value) -> u64 {
128        match value {
129            rbs::Value::Map(map) => {
130                for (_, v) in map {
131                    match v {
132                        rbs::Value::U64(n) => return *n,
133                        rbs::Value::I64(n) => return *n as u64,
134                        rbs::Value::U32(n) => return *n as u64,
135                        rbs::Value::I32(n) => return *n as u64,
136                        _ => {}
137                    }
138                }
139                0
140            }
141            rbs::Value::U64(n) => *n,
142            rbs::Value::I64(n) => *n as u64,
143            _ => 0,
144        }
145    }
146}
147
148#[async_trait]
149impl<E, T> IService<T> for ServiceImpl<E, T>
150where
151    E: Executor + Send + Sync + Clone + 'static,
152    T: Serialize + DeserializeOwned + Send + Sync,
153{
154    /// 插入一条记录(对标 Java `ServiceImpl.save()`)。
155    async fn save(&self, entity: &T) -> Result<bool, Error> {
156        let map = rbs::to_value(entity)?;
157        let (cols, placeholders, values) = Self::build_insert_params(&map, &self.id_column);
158        let sql = format!(
159            "INSERT INTO {} ({}) VALUES ({})",
160            self.table_name, cols, placeholders
161        );
162        let result = self.executor.exec(&sql, values).await?;
163        Ok(result.rows_affected > 0)
164    }
165
166    /// 插入或更新(根据 ID 判断)(对标 Java `ServiceImpl.saveOrUpdate()`)。
167    async fn save_or_update(&self, entity: &T) -> Result<bool, Error> {
168        let map = rbs::to_value(entity)?;
169        let id = Self::extract_id(&map, &self.id_column);
170        if !matches!(id, rbs::Value::Null) {
171            let (set_clause, values) = Self::build_update_params(&map, &self.id_column);
172            let sql = format!(
173                "UPDATE {} SET {} WHERE {} = ?",
174                self.table_name, set_clause, self.id_column
175            );
176            let mut all_values = values;
177            all_values.push(id);
178            let result = self.executor.exec(&sql, all_values).await?;
179            if result.rows_affected > 0 {
180                return Ok(true);
181            }
182        }
183        self.save(entity).await
184    }
185
186    /// 根据 ID 删除(对标 Java `ServiceImpl.removeById()`)。
187    async fn remove_by_id(&self, id: &rbs::Value) -> Result<bool, Error> {
188        let sql = format!("DELETE FROM {} WHERE {} = ?", self.table_name, self.id_column);
189        let result = self.executor.exec(&sql, vec![id.clone()]).await?;
190        Ok(result.rows_affected > 0)
191    }
192
193    /// 根据条件删除(对标 Java `ServiceImpl.remove(Wrapper)`)。
194    async fn remove(&self, wrapper: &QueryWrapper, table_name: &str) -> Result<bool, Error> {
195        let where_clause = wrapper.inner.build_where();
196        let sql = format!("DELETE FROM {}{}", table_name, where_clause);
197        let result = self.executor.exec(&sql, wrapper.params().to_vec()).await?;
198        Ok(result.rows_affected > 0)
199    }
200
201    /// 根据 ID 更新(对标 Java `ServiceImpl.updateById()`)。
202    async fn update_by_id(&self, entity: &T) -> Result<bool, Error> {
203        let map = rbs::to_value(entity)?;
204        let id = Self::extract_id(&map, &self.id_column);
205        let (set_clause, values) = Self::build_update_params(&map, &self.id_column);
206        let sql = format!(
207            "UPDATE {} SET {} WHERE {} = ?",
208            self.table_name, set_clause, self.id_column
209        );
210        let mut all_values = values;
211        all_values.push(id);
212        let result = self.executor.exec(&sql, all_values).await?;
213        Ok(result.rows_affected > 0)
214    }
215
216    /// 根据条件更新(对标 Java `ServiceImpl.update(Wrapper)`)。
217    async fn update(
218        &self,
219        wrapper: &UpdateWrapper,
220        table_name: &str,
221    ) -> Result<bool, Error> {
222        let sql = wrapper.build_update_sql(table_name);
223        let result = self.executor.exec(&sql, wrapper.params().to_vec()).await?;
224        Ok(result.rows_affected > 0)
225    }
226
227    /// 根据 ID 查询(对标 Java `ServiceImpl.getById()`)。
228    async fn get_by_id(&self, id: &rbs::Value) -> Result<Option<T>, Error> {
229        let sql = format!(
230            "SELECT * FROM {} WHERE {} = ? LIMIT 1",
231            self.table_name, self.id_column
232        );
233        let value = self.executor.query(&sql, vec![id.clone()]).await?;
234        let rows = Self::decode_rows(value)?;
235        Ok(rows.into_iter().next())
236    }
237
238    /// 根据条件查询列表(对标 Java `ServiceImpl.list(Wrapper)`)。
239    async fn list(&self, wrapper: &QueryWrapper, table_name: &str) -> Result<Vec<T>, Error> {
240        let sql = wrapper.build_select_sql(table_name);
241        let value = self.executor.query(&sql, wrapper.params().to_vec()).await?;
242        Self::decode_rows(value)
243    }
244
245    /// 根据条件查询单条(对标 Java `ServiceImpl.getOne(Wrapper)`)。
246    async fn get_one(
247        &self,
248        wrapper: &QueryWrapper,
249        table_name: &str,
250    ) -> Result<Option<T>, Error> {
251        let sql = format!("{} LIMIT 1", wrapper.build_select_sql(table_name));
252        let value = self.executor.query(&sql, wrapper.params().to_vec()).await?;
253        let rows = Self::decode_rows(value)?;
254        Ok(rows.into_iter().next())
255    }
256
257    /// 查询总数(对标 Java `ServiceImpl.count(Wrapper)`)。
258    async fn count(&self, wrapper: &QueryWrapper, table_name: &str) -> Result<u64, Error> {
259        let sql = wrapper.build_count_sql(table_name);
260        let value = self.executor.query(&sql, wrapper.params().to_vec()).await?;
261        Ok(Self::extract_count(&value))
262    }
263
264    /// 分页查询(对标 Java `ServiceImpl.page(Wrapper, Page)`)。
265    async fn page(
266        &self,
267        wrapper: &QueryWrapper,
268        table_name: &str,
269        page_no: u64,
270        page_size: u64,
271    ) -> Result<Page<T>, Error> {
272        // 先查询总数
273        let total = self.count(wrapper, table_name).await?;
274
275        // 再查询分页数据
276        let offset = (page_no - 1) * page_size;
277        let sql = format!(
278            "{} LIMIT {}, {}",
279            wrapper.build_select_sql(table_name),
280            offset,
281            page_size
282        );
283        let value = self.executor.query(&sql, wrapper.params().to_vec()).await?;
284        let records = Self::decode_rows(value)?;
285
286        Ok(Page::new(records, total, page_no, page_size))
287    }
288}
289
290impl<E, T> ServiceImpl<E, T>
291where
292    E: Executor + Send + Sync + Clone + 'static,
293    T: Serialize + DeserializeOwned + Send + Sync,
294{
295    /// 构建 INSERT 参数(列名、占位符、值列表)。
296    fn build_insert_params(map: &rbs::Value, id_column: &str) -> (String, String, Vec<rbs::Value>) {
297        let mut cols = Vec::new();
298        let mut placeholders = Vec::new();
299        let mut values = Vec::new();
300
301        if let rbs::Value::Map(m) = map {
302            for (k, v) in m {
303                if let rbs::Value::String(col_name) = k {
304                    // 跳过 null 的自增主键
305                    if col_name == id_column && matches!(v, rbs::Value::Null) {
306                        continue;
307                    }
308                    cols.push(col_name.clone());
309                    placeholders.push("?".to_string());
310                    values.push(v.clone());
311                }
312            }
313        }
314
315        (cols.join(", "), placeholders.join(", "), values)
316    }
317
318    /// 构建 UPDATE SET 参数(set 子句、值列表,不含主键)。
319    fn build_update_params(map: &rbs::Value, id_column: &str) -> (String, Vec<rbs::Value>) {
320        let mut set_parts = Vec::new();
321        let mut values = Vec::new();
322
323        if let rbs::Value::Map(m) = map {
324            for (k, v) in m {
325                if let rbs::Value::String(col_name) = k {
326                    if col_name == id_column {
327                        continue; // 主键放在 WHERE 中
328                    }
329                    set_parts.push(format!("{} = ?", col_name));
330                    values.push(v.clone());
331                }
332            }
333        }
334
335        (set_parts.join(", "), values)
336    }
337}