逻辑层基类

一、引言

该类是针对于ThinkPHP6及以上的版本，php版本要求7.4以上。继承该类就可以自由调用该类里面的方法。

二、调用

// 情况1：调用本模型
在继承基类的`__construct()`方法里面就传入的模型，例如
public function __construct()
{
    parent::__construct(User::class);
}
则要操作该模型，则只需要通过$this来调用，例如
$user = $this->detail($uid);

// 情况2：调用其他模型
需通过`self::instance(模型名称)`方式调用，例如
$take = self::instance(MerchantTake::class)->detail([
    ['uid', '=', $up_uid],
    ['audit_status', '=', 1]
]);

三、类

位置：app\common\logic\BaseLogic.php

<?php
namespace app\common\logic;
use think\facade\Db;
use think\facade\Log;

/**
 * 逻辑基类
 */
abstract class BaseLogic {
    private $error;
    private $model;

    /**
     * 初始化
     * @param string|null $model
     */
    public function __construct(?string $model = null)
    {
        $model && $this->model = new $model();
    }

    /**
     * 设置模型
     * @param $model string 模型
     * @return static
     */
    public static function instance(string $model)
    {
        $instance = new static();
        $instance->model = new $model();
        return $instance;
    }
    /**
     * 事务操作
     * @param $callback callable 回调函数
     * @param $type int 事务操作提交方式:0=代码无异常时提交事务,1=业务逻辑返回值不为false时提交事务
     * @return bool|mixed|null
     */
    public function transaction(callable $callback,int $type = 1)
    {
        // 回调方法返回值不为false才会提交
        if ($type) {
            $model = $this->model;
            $model->startTrans();
            try {
                $result = null;
                if (is_callable($callback))
                    $result = call_user_func_array($callback, [$model]);
                if ($result)
                    $model->commit();
                else
                    $model->rollback();
                return $result;
            } catch (\Exception $e) {
                $model->rollback();
                $this->writeLog($e->getMessage() ." || 文件：{$e->getFile()} || 行数：{$e->getLine()} || 追踪：{$e->getTraceAsString()}","error");
                return $this->setError($e->getMessage());
            }
        }
        // 回调方法无异常才会提交
        else {
            return Db::transaction($callback);
        }
    }

    /**
     * 删除
     * @param $map array|callable 若是数组类型，则必须是主键集，例如：[1,2,3,4]；若是回调函数，则里面是更新条件
     * @return bool|mixed|null
     */
    public function destroy($map)
    {
        return $this->transaction(function () use ($map) {
            $this->model::destroy($map);
            return true;
        });
    }
    /**
     * 单条更新
     * @param $map int|array 更新条件
     * @param $data array 更新的数据
     * @return bool|mixed|null 返回更新后的模型对象
     */
    public function edit($map,array $data)
    {
        $detail = $this->detail($map);
        if (!$detail) {
            return $this->setError('查无可用数据');
        }
        foreach ($data as $key=>$vlaue) {
            $detail->{$key} = $vlaue;
        }
        $detail->save();
        return $detail;
    }
    /**
     * 批量更新（通过条件）
     * @param $data array 更新的数据
     * @param $map int|array 更新条件
     * @return bool|mixed|null 返回模型的对象实例
     */
    public function update(array $data,$map)
    {
        return $this->model->update($data,$this->buildMap($map));
    }
    /**
     * 批量添加 或 批量更新（通过主键）
     * @param $data array 添加/更新的数据
     * @return bool|mixed|null 返回创建后的模型对象
     */
    public function saveAll(array $data)
    {
        return $this->model::saveAll($data);
    }
    /**
     * 创建
     * @param $data array 添加的数据
     * @return bool|mixed|null 返回创建后的模型对象
     */
    public function create(array $data)
    {
        return $this->model::create($data);
    }
    /**
     * 增加值
     * @param $map
     * @param $field string 字段
     * @param $value float 数值
     * @return mixed
     */
    public function inc($map,string $field,float $value = 1)
    {
        return $this->model->where($this->buildMap($map))->inc($field,$value)->update();
    }
    /**
     * 减少值
     * @param $map
     * @param $field string 字段
     * @param $value float 数值
     * @return mixed
     */
    public function dec($map,string $field,float $value = 1)
    {
        return $this->model->where($this->buildMap($map))->inc($field,$value)->update();
    }
    /**
     * 全部列表
     * @param $map
     * @param $field string|array 字段
     * @param $with
     * @param $order
     * @return mixed
     */
    public function all($map,$field='*',$with = null,$order = null)
    {
        return $this->model->field($field ?: $this->pk())
            ->with($with)
            ->where($this->buildMap($map))
            ->order($order ?: [$this->pk()=>'desc'])
            ->select();
    }
    /**
     * 获取列表
     * @param $map
     * @param $field string|array 字段
     * @param $with null|array 关联模型
     * @param $page int 当前页
     * @param $limit int 每页条数
     * @param $order null|array 排序
     * @return mixed
     */
    public function list($map,$field='*',?array $with = null,int $page = 1,int $limit = 10,$order = null)
    {
        return $this->model->field($field ?: $this->pk())
            ->with($with)
            ->where($this->buildMap($map))
            ->page($page,$limit)
            ->order($order ?: [$this->pk()=>'desc'])
            ->select();
    }

    /**
     * 获取条数
     * @param $map
     * @return mixed
     */
    public function count($map)
    {
        return $this->model
            ->where($this->buildMap($map))
            ->count();
    }
    /**
     * 获取详情
     * @param $map
     * @param $with null|array 关联模型
     * @param $order null|array 排序
     * @return mixed
     */
    public function detail($map,?array $with = null,$order = null)
    {
        return $this->model->with($with)->where($this->buildMap($map))->order($order ?: [$this->pk()=>'desc'])->find();
    }
    /**
     * 求和
     * @param $map
     * @param $field string 字段
     * @return mixed
     */
    public function sum($map,string $field)
    {
        return $this->model->where($this->buildMap($map))->sum($field);
    }
    /**
     * 获取平均值
     * @param $map
     * @param $field string 字段
     * @return mixed
     */
    public function avg($map,string $field)
    {
        return $this->model->where($this->buildMap($map))->avg($field);
    }
    /**
     * 获取最大值
     * @param $map
     * @param $field string 字段
     * @return mixed
     */
    public function max($map,string $field)
    {
        return $this->model->where($this->buildMap($map))->max($field);
    }
    /**
     * 获取最小值
     * @param $map
     * @param $field string 字段
     * @return mixed
     */
    public function min($map,string $field)
    {
        return $this->model->where($this->buildMap($map))->min($field);
    }
    /**
     * 获取某个列值
     * @param $map
     * @param $field null|string 字段
     * @return mixed
     */
    public function column($map,?string $field = null)
    {
        return $this->model->where($this->buildMap($map))->column($field ?: $this->pk());
    }
    /**
     * 获取某个值
     * @param $map
     * @param $field null|string 字段
     * @return mixed
     */
    public function value($map,$field = null)
    {
        return $this->model->where($this->buildMap($map))->value($field ?: $this->pk());
    }

    /**
     * 生成清空数据的SQL语句
     * @param array $exclude 要排除的表，即不清空数据的表
     * @return string
     */
    public function getTruncateSql(array $exclude = [])
    {
        $tables = $this->getTables();
        $list = array_filter($tables,function ($table) use ($exclude){
            if (in_array($table,$exclude)) {
                return false;
            }
            foreach ($exclude as $item) {
                if (strpos($item, '*') !== false) {
                    $prefix = strstr($item, '*', true);// 第三个参数设为true，表示返回*之前的部分
                    if (substr($table, 0, strlen($prefix)) === $prefix) {
                        return false;
                    }
                }
            }
            return true;
        });
        return implode(PHP_EOL,array_map(function ($item){
            return "TRUNCATE {$item};";
        },$list));
    }
    /**
     * 获取所有表名
     * @return array
     */
    public function getTables()
    {
        $tables = Db::query('SHOW TABLES');
        $tableNames = [];
        foreach ($tables as $table) {
            $tableNames[] = current($table);
        }
        return $tableNames;
    }
    /**
     * 获取表注释
     * @return mixed
     */
    public function getTableComment()
    {
        $table = $this->model->getTable();
        $database = Db::query("SELECT DATABASE()")[0]['DATABASE()'];
        $info = Db::query("SELECT TABLE_NAME,TABLE_COMMENT FROM information_schema.`TABLES` WHERE TABLE_NAME = '{$table}' AND TABLE_SCHEMA = '{$database}'");
        return $info[0]['TABLE_COMMENT'];
    }

    /**
     * 获取表字段
     * @param $only_field bool false=只取表字段（一维数组）,true=表字段所有信息（二维数组）
     * @return mixed
     */
    public function getTableFields(bool $only_field = true)
    {
        $table = $this->model->getTable();
        $result = Db::query("show full columns from {$table}");
        if (!$only_field) {
            return $result;
        }
        $data = [];
        foreach ($result as $item) {
            $data[] = $item['Field'];
        }
        return $data;
    }

    /**
     * 处理查询条件
     * @param $map
     * @return mixed
     */
    protected function buildMap($map)
    {
        $map = is_numeric($map) ? [[$this->pk(),'=',$map]] : $map;
        return $map;
    }

    /**
     * 获取主键
     * @return mixed
     */
    protected function pk()
    {
        return $this->model->getPk();
    }
    /**
     * 获取最后执行的SQL语句
     * @return mixed
     */
    public function getLastSql()
    {
        return $this->model->getLastSql();
    }
    /**
     * 获取模型
     * @return mixed
     */
    protected function getModel()
    {
        return $this->model;
    }

    /**
     * 记录日志
     * @param $message
     * @param $level
     * @return void
     */
    public function writeLog($message,$level = 'info')
    {
        is_array($message) || is_object($message) && $message = json_encode($message,JSON_UNESCAPED_UNICODE);
        Log::record($message,$level);
    }
    /**
     * 获取异常
     * @return mixed
     */
    public function getError()
    {
        return $this->error;
    }
    /**
     * 设置异常
     * @param $message
     * @return false
     */
    protected function setError($message)
    {
        $this->error = $message;
        return false;
    }
}