InfluxDB ORM API封装

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量178 收藏 1
点赞数 1
分类专栏： 编程经验 文章标签： java db 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011519105/article/details/134047302
版权

InfluxDB ORM API封装

InfluxDB 是一个开源的分布式时序、时间和指标数据库，用于存储和检索数据。它是一个自定义的高性能存储引擎，具有时间戳索引和SQL类似的查询语言。
influxdb-client-java 是官方提供的 Java 客户端，但是它的 API 使用起来不是很方便，所以我对其进行了二次封装，使其使用起来更加方便。详细源码

依赖

<!-- https://mvnrepository.com/artifact/com.influxdb/influxdb-client-java -->
<dependency>
    <groupId>com.influxdb</groupId>
    <artifactId>influxdb-client-java</artifactId>
    <version>6.3.0</version>
</dependency>

配置

使用 InfluxDB 之前，需要先在 InfluxDB 中创建一个 bucket，然后创建一个 token，用于访问该 bucket。

spring:
  influx:
    url: http://localhost:8086
    org: xxx-org
    token: xxx
    bucket: xxx-bucket

注入 InfluxDBClient

import com.influxdb.client.InfluxDBClient;
import com.influxdb.client.InfluxDBClientFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class InfluxDbConfig {

    @Value("${spring.influx.url:''}")
    private String url;

    @Value("${spring.influx.org:''}")
    private String org;

    @Value("${spring.influx.token:''}")
    private String token;

    @Value("${spring.influx.bucket:''}")
    private String bucket;

    @Bean
    public InfluxDBClient influxDB(){
        InfluxDBClient client = InfluxDBClientFactory.create(url, token.toCharArray(), org, bucket);
        return client;
    }
}

注解

为了区分不同实例的相同指标，如cpu0和cpu1等相同的指标，需要在 Measurement 上添加前、后缀，如：cpu_measure_0、cpu_measure_1，从而实现区分。
为了自动化实现这个功能，需要在 Measurement 上添加前、后缀注解，如：


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * measurement 前缀
 * 与 @Measurement 拼接 动态的 measurement
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface MeasurementPrefix {
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * measurement 后缀
 * 与 @Measurement 拼接 动态的 measurement
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface MeasurementSuffix {
}

ORM 工具类

完成POJO与InfluxDB的转换，包括前后缀的拼接，以及常用的 Query、Write 等操作。

import com.influxdb.annotations.Column;
import com.influxdb.annotations.Measurement;
import com.influxdb.client.InfluxDBClient;
import com.influxdb.client.WriteApiBlocking;
import com.influxdb.client.domain.WritePrecision;
import com.influxdb.client.write.Point;
import com.influxdb.query.FluxRecord;
import com.influxdb.query.FluxTable;
import com.sme.smebackend.influx.MeasurementPrefix;
import com.sme.smebackend.influx.MeasurementSuffix;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.time.Instant;
import java.time.OffsetDateTime;
import java.util.List;
import java.util.Map;
import java.util.Objects;

@Slf4j
public class InfluxDBUtil {
    public static String measurementName(Object o) {
        Class clazz = o.getClass();

        // 获取 @Measurement
        Measurement meaAnno = (Measurement) clazz.getAnnotation(Measurement.class);
        if (null == meaAnno) {
            return null;
        }

        String measurement = meaAnno.name();

        // 获取 @MeasurementPrefix 字段的值
        String prefix = getFieldValueByAnno(o, MeasurementPrefix.class);

        // 获取 @MeasurementSuffix 字段的值
        String suffix = getFieldValueByAnno(o, MeasurementSuffix.class);

        if (null != prefix) {
            measurement = prefix + "_" + measurement;
        }

        if (null != suffix) {
            measurement = measurement + "_" + suffix;
        }

        return measurement;
    }

    @Nullable
    private static String getFieldValueByAnno(Object o, Class annoClazz) {
        Class clazz = o.getClass();
        String val = null;

        for (Field field : clazz.getDeclaredFields()) {
            Annotation anno = field.getAnnotation(annoClazz);
            if (null != anno) {
                try {
                    field.setAccessible(true);
                    val = (String) field.get(o);
                } catch (IllegalAccessException e) {
                    log.error("failed to get value of field: {}", field.getName(), e);
                }
            }
        }

        return val;
    }

    /**
     * 将 @Measurement 注解的对象转换为 Influxdb Point 对象
     */
    public static Point measurement2Point(Object o) {
        String measurement = measurementName(o);
        if (null == measurement) {
            return null;
        }

        Class clazz = o.getClass();

        // 遍历所有的 @Column 字段
        Point point = Point.measurement(measurement);
        for (Field field : clazz.getDeclaredFields()) {
            Column colAnno = field.getAnnotation(Column.class);
            MeasurementPrefix prefixAnno = field.getAnnotation(MeasurementPrefix.class);
            MeasurementSuffix suffixAnno = field.getAnnotation(MeasurementSuffix.class);
            if (null == colAnno || null != suffixAnno || null != prefixAnno) {
                continue;
            }

            try {
                field.setAccessible(true);

                String name = colAnno.name();
                boolean tag = colAnno.tag();
                if (tag) {
                    point.addTag(field.getName(), (String) field.get(o));
                } else {
                    if (Objects.equals("time", name)) {
                        point.time((Instant) field.get(o), WritePrecision.MS);
                    } else {
                        point.addField(field.getName(), (long) field.get(o));
                    }
                }
            } catch (IllegalAccessException e) {
                log.error("failed to get value of field: {}", field.getName(), e);
            }
        }

        return point;
    }

    /**
     * 写入
     */
    public static void write(InfluxDBClient influxDB, Object measurement) {
        WriteApiBlocking w = influxDB.getWriteApiBlocking();
        Point point = measurement2Point(measurement);
        if (null == point) {
            return;
        }

        w.writePoint(point);
    }

    /**
     * 查询某个 measurement 的某个字段
     */
    public static <T> List<T> query1d(InfluxDBClient influxDB,
                                      String bucket,
                                      String measurement, Class<T> clazz) {
        return query1d(influxDB, bucket, measurement, null, clazz);
    }

    public static <T> List<T> query1d(InfluxDBClient influxDB,
                                      String bucket,
                                      String measurement, List<String> fields, Class<T> clazz) {
        String query = baseQ(bucket, measurement, fields, "-1d");
        return doQuery(influxDB, clazz, query);
    }

    private static <T> List<T> doQuery(InfluxDBClient influxDB, Class<T> clazz, String query) {
        List<FluxTable> ts = influxDB.getQueryApi().query(query);
        List<T> res = InfluxDBUtil.fluxTable2Pojo(ts, clazz);
        return res;
    }

    @NotNull
    private static String baseQ(String bucket, String measurement, List<String> fields, String start) {
        String query = "from(bucket: \"" + bucket + "\")" +
                " |> range(start: " + start + ")" +
                " |> filter(fn: (r) => r._measurement == \"" + measurement + "\")";

        if (!J.empty(fields)) {
            query += " |> filter(fn: (r) => ";

            for (int i = 0; i < fields.size(); i++) {
                String field = fields.get(i);
                if (i == 0) {
                    query += " r._field == \"" + field + "\"";
                } else {
                    query += " or r._field == \"" + field + "\"";
                }
            }

            query += ")";
        }
        return query;
    }

    /**
     * 聚合查询
     */
    public static String aggrQ(String bucket, String measurement, List<String> fields,
                               String start, String every) {
        String query = baseQ(bucket, measurement, fields, start);
        query += " |> aggregateWindow(every: " + every + ", fn: mean, createEmpty: true)";
        return query;
    }

    public static <T> List<T> queryAggr(InfluxDBClient influxDB,
                                        String bucket, String measurement, Class<T> clazz,
                                        String start, String every) {
        String query = aggrQ(bucket, measurement, null, start, every);
        return doQuery(influxDB, clazz, query);
    }

    /**
     * 通用聚合查询
     */
    public static <T> List<T> queryAggr(InfluxDBClient influxDB,
                                        String bucket, String measurement, List<String> fields, Class<T> clazz,
                                        String start, String every) {
        String query = aggrQ(bucket, measurement, fields, start, every);
        return doQuery(influxDB, clazz, query);
    }

    /**
     * 查询某个 measurement 的某个字段， 整 5 min 的数据，如 10:20， 10:25， 10:30
     */
    public static <T> List<T> queryBy5Min(InfluxDBClient influxDB,
                                          String bucket,
                                          String measurement, Class<T> clazz) {
        return queryBy5Min(influxDB, bucket, measurement, null, clazz);
    }

    public static <T> List<T> queryBy5Min(InfluxDBClient influxDB,
                                          String bucket,
                                          String measurement, List<String> fields, Class<T> clazz) {
        return queryAggr(influxDB, bucket, measurement, fields, clazz, "-1d", "5m");
    }

    public static <T> List<T> queryBy1Min(InfluxDBClient influxDB,
                                          String bucket,
                                          String measurement, Class<T> clazz) {
        return queryBy1Min(influxDB, bucket, measurement, null, clazz);
    }

    public static <T> List<T> queryBy1Min(InfluxDBClient influxDB,
                                          String bucket,
                                          String measurement, List<String> fields, Class<T> clazz) {
        return queryAggr(influxDB, bucket, measurement, fields, clazz, "-1d", "1m");
    }

    /**
     * 查询某个 measurement 的某个字段， 整点数据，如 10:00， 11:00， 12:00
     */
    public static <T> List<T> queryByHour(InfluxDBClient influxDB,
                                          String bucket,
                                          String measurement, Class<T> clazz) {
        return queryByHour(influxDB, bucket, measurement, null, clazz);
    }

    public static <T> List<T> queryByHour(InfluxDBClient influxDB,
                                          String bucket,
                                          String measurement, List<String> fields, Class<T> clazz) {
        return queryAggr(influxDB, bucket, measurement, fields, clazz, "-7d", "1h");
    }

    /**
     * 查询某个 measurement 的某个字段， 整天数据，如 2021-01-01 00:00:00， 2021-01-02 00:00:00
     */
    public static <T> List<T> queryByDay(InfluxDBClient influxDB,
                                         String bucket,
                                         String measurement, Class<T> clazz) {
        return queryByDay(influxDB, bucket, measurement, null, clazz);
    }

    public static <T> List<T> queryByDay(InfluxDBClient influxDB,
                                         String bucket,
                                         String measurement, List<String> fields, Class<T> clazz) {
        return queryAggr(influxDB, bucket, measurement, fields, clazz, "-1M", "1d");
    }

    /**
     * 删除一个月前的数据
     */
    public static void deleteBeforeOneMonth(InfluxDBClient influxDB, String bucket, String org, String measurement) {
        OffsetDateTime now = OffsetDateTime.now();

        influxDB.getDeleteApi().delete(
                now.minusYears(2), now.minusMonths(1),
                String.format("_measurement=\"%s\"", measurement),
                bucket, org
        );
    }

    /**
     * 删除所有数据
     */
    public static void deleteAll(InfluxDBClient influxDB, String bucket, String org, String measurement) {
        OffsetDateTime now = OffsetDateTime.now();

        influxDB.getDeleteApi().delete(
                now.minusYears(100), now,
                String.format("_measurement=\"%s\"", measurement),
                bucket, org
        );
    }

    /**
     * 将 FluxTable 转化为 pojo list
     */
    @SneakyThrows
    public static <T> List<T> fluxTable2Pojo(List<FluxTable> tables, Class<T> clazz) {
        List<T> ts = J.list();

        for (FluxTable tab : tables) {
            List<FluxRecord> recs = tab.getRecords();
            for (int i = 0; i < recs.size(); i++) {
                FluxRecord r = recs.get(i);

                T t = null;
                if (i > ts.size() - 1) {
                    t = clazz.newInstance();
                    ts.add(t);
                } else {
                    t = ts.get(i);
                }

                record2Pojo(r, t);
            }
        }

        return ts;
    }

    /**
     * 将 {@link FluxRecord } 转化为 pojo 对象
     */
    public static <T> T record2Pojo(FluxRecord record, T t) {
        try {
            Class clazz = t.getClass();

            Map<String, Object> recordValues = record.getValues();

            String recordField = record.getField();
            Object value = record.getValue();

            Field[] fileds = clazz.getDeclaredFields();
            for (Field field : fileds) {
                Column colAnno = field.getAnnotation(Column.class);

                MeasurementPrefix prefixAnno = field.getAnnotation(MeasurementPrefix.class);
                MeasurementSuffix suffixAnno = field.getAnnotation(MeasurementSuffix.class);
                if (null == colAnno || null != suffixAnno || null != prefixAnno) {
                    continue;
                }

                field.setAccessible(true);

                String colName = colAnno.name();

                if (Objects.equals("time", colName)) {
                    field.set(t, record.getTime());
                } else if (Objects.equals(colName, recordField)) {
                    if (null == value) {
                        continue;
                    }
                    String type = field.getType().getName();

                    if (colName.equals("writeSectTotal")) {
                        System.out.println("writeSectTotal");
                    }

                    if ((type.equals("long") || type.equals("java.lang.Long"))
                            && value instanceof Double) {
                        field.set(t, ((Double) value).longValue());
                    } else if ((type.equals("int") || type.equals("java.lang.Integer"))
                            && value instanceof Double) {
                        field.set(t, ((Double) value).intValue());
                    } else {
                        field.set(t, value);
                    }

                } else {
                    Object v = recordValues.get(field.getName());
                    if (null != v) {
                        field.set(t, v);
                    }
                }
            }

            return t;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 将 {@link FluxRecord } 转化为 pojo 对象
     */
    public static <T> T record2Pojo(FluxRecord record, Class<T> clazz) {
        try {
            T t = clazz.newInstance();

            Map<String, Object> recordValues = record.getValues();

            String recordField = record.getField();
            Object value = record.getValue();

            for (Field field : clazz.getDeclaredFields()) {
                Column colAnno = field.getAnnotation(Column.class);

                MeasurementPrefix prefixAnno = field.getAnnotation(MeasurementPrefix.class);
                MeasurementSuffix suffixAnno = field.getAnnotation(MeasurementSuffix.class);
                if (null == colAnno || null != suffixAnno || null != prefixAnno) {
                    continue;
                }

                field.setAccessible(true);

                String colName = colAnno.name();

                if (Objects.equals("time", colName)) {
                    field.set(t, record.getTime());
                } else if (Objects.equals(colName, recordField)) {
                    field.set(t, value);
                } else {
                    Object v = recordValues.get(field.getName());
                    if (null != v) {
                        field.set(t, v);
                    }
                }
            }

            return t;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }
}

以上的工具是我在使用 InfluxDB 时，总结出来的一些常用的方法，可以直接拿来使用，大大简化了 InfluxDB 的使用。

coder_kkx
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
spring-influxdb-orm:Spring InfluxDB ORM
05-26
弹簧流入数据库 用法 基本用法 ApplicationContext.xml <? xml version = " 1.0 " encoding = " UTF-8 " ?> < beans xmlns = " http://www.springframework.org/schema/beans " xmlns : xsi = " http://www.w3.org/2001/XMLSchema-instance " xmlns : influxdb = " http://www.vgerbot.com/schema/influxdb " xsi : schemaLocation = " http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spri
influxable:用于InfluxDB的轻量级Python ORM ODM客户端
05-04
易流的 用于InfluxDB的轻量级Python ORM / ODM /客户端 目录 联系 测量 简单的测量 实例化 询问 保存数据 自动生成测量 易受干扰的命令 易渗透的API 易流类 InfluxDBApi类 连接等级 测量等级 属性 InfluxDBResponse 序列化器 原始查询 查询类别 查询聚合功能 查询选择器功能 查询转换功能 InfluxDB管理员 例外情况 测验 配套 版本控制 贡献者 学分 参考 执照 笔记 该项目目前正在开发中。 下一个版本将添加更好的文档和测试脚本。 创世记 我在InfluxDB上从事过一个项目。 我需要为InfluxDB构建API，并插入Python库（scipy，pandas等）。 这就是为什么我决定创建此存储库以便平滑地处理InfluxDB并操纵Python对象的原因。 变更日志 1.3.0 为GROUP BY标签说明添
influxDB 1.8.4 + Tick 全栈 + C# 客户端 Window 版本
02-28
influxDB是一个开源的时序数据库，使用GO语言开发
goorm：goorm自用封装包（仿照laravel）
03-03
古尔姆 goorm自用封装包（仿照laravel） :candy: 将库添加到您的$ GOPATH / src go get github.com/xxgail/goorm 目前实现的方法有： 初始化 NewTable（“表名”，db）：初始化方法db目前只有* sql.DB 查询 查询条件 Select（fields ... string）：选择细分 Where（map [string] interface {}）：哪里进行多重查询 WhereCompare（字段字符串，比较字符串，值接口{}）：where比较查询 WhereIN（字段字符串，作用域[] interface {}） WhereNotIn（字段字符串，范围[] interface {}） WhereBetween（字段字符串，左字符串，右字符串） WhereNull（fields ... string）：选择为空细分
Android数据库ORM封装
06-29
Android 数据库操作简单封装
时序数据库php,influxdb-orm v1.0.1 发布，时序数据库 InfluxDB 的 PHP ORM
weixin_39984403的博客
03-11 117
介绍一个用于InfluxDB时序数据库的ORM，终结没有InfluxDBORM的时代。常用操作一把梭，支持php-fpm、Swoole环境，一键轻松切换。可以用于所有传统框架、所有Swoole框架中！Composer本项目可以使用composer安装，遵循psr-4自动加载规则，在你的composer.json中加入下面的内容:{"require": {"yurunsoft...
python对象关系映射_python实现influxdb的orm对象关系映射模型
weixin_39939276的博客
12-08 207
对于数据库操作的时候，我个人特别的倾向于用ORM这种对象映射模型， 可以让你最舒服的操作数据库，另外也可以最简单的实现数据库… 比如我写后端服务的时候，如果用mysqldb，那么想当的蛋疼… 来来回回的折腾的，在大量的参数下，很有可能会出各种各样的低级的问题… 如果你用python的peewee这种基于mysqldb的orm模型，那么会想当干练的操作mysql数据库。在github...
一个用于 InfluxDB 时序数据库的 ORM，终结没有 InfluxDB ORM 的时代
07-06
一个用于 InfluxDB 时序数据库的 ORM，终结没有 InfluxDB ORM 的时代。常用操作一把梭，支持 php-fpm、Swoole 环境，一键轻松切换。可以用于所有传统框架、所有 Swoole 框架中！
【数据库】时序数据库InfluxDB 性能测试和为什么时序数据库更快、时序数据库应用场景
bandaoyu的note
04-03 3577
CPU 内存 带宽 版本号 4核 16G 1Gbit/s Ubuntu 4.8.4-2ubuntu1~14.04.3 写入测试：60万/s 测试结论：最大的吞吐量为每秒写入60万条数据。这之后，每秒发送的points再多，吞吐量也不会增加，同时CPU利用率已达90%。 查询测试：600/s 原文：https://www.yinyubo.cn/www...
C# +influxdb时序数据库 通过aggregateWindow 函数缩减采样
lhdisme的博客
07-20 989
C# +influxdb时序数据库 通过aggregateWindow 函数缩减采样
C# 读写influxdb时序数据库+解析json格式的数据
weixin_39448579的博客
05-28 5034
之前因为数据量过大，尝试各种存储方式，运用到了influxdb，发现对于C#使用这些第三方数据存储，真的是不太友好。哎。 重振C#荣光，我辈义不容辞！ 先下载好influxdb（不会真的有人不会吧？） 运行influxd，启动服务端 启动成功后 (接下来的操作只是为了添加一点数据) 启动客服端，运行influx，可以百度下influxdb的用法 创建一个数据库test，查看数据库 然后直接插入一条数据 接下来就是在C#中如何使用了 先添加一个辅助类 HttpHelper using System;
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 766
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 834
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1756
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 1035
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
PageHelper实现分页查询
m0_63849044的博客
04-24 1075
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
C语言案例——输出 Fibonacci 数列（斐波那契数列）的前 40 项
悟道子HD
04-25 465
输出 Fibonacci 数列（斐波那契数列）的前 40 项 #include void main() { int a[40]= {1,1}; int i; printf( "%12d%12d",a[0],a[1]); for(i=2; i
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 330
待更新。
迭代器模式
LuckFairyLuckBaby的博客
04-23 704
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
ORM封装 asp.net
09-11
ORM（对象关系映射）是一种编程技术，它将数据库中的数据映射到面向对象的编程语言中，使开发人员能够使用对象和类来操作数据库而不是使用传统的SQL语句。ASP.NET是一种用于构建Web应用程序的开发框架。在ASP.NET中，ORM封装是指将ORM技术应用于ASP.NET开发中，以简化数据库操作和提高开发效率。 在ASP.NET中，有许多可用于封装ORM的工具和框架。其中一个受欢迎的ORM框架是SqlSugar。SqlSugar是一个轻量级的.NET ORM，它提供了高性能的数据库操作和查询功能，支持多种数据库，如SQL Server、MySQL、Oracle等。通过使用SqlSugar，开发人员可以通过面向对象的方式来操作数据库，而无需编写繁琐的SQL语句。 使用SqlSugar进行ORM封装，开发人员可以通过定义实体类来映射数据库表，并使用简单的方法和属性来进行增删改查等操作。SqlSugar提供了丰富的API和查询语法，使开发人员能够灵活地进行数据库操作，同时还提供了一些高级功能，如事务管理、缓存、分页等。 总之，ORM封装是在ASP.NET开发中使用ORM技术来简化数据库操作的一种方法，而SqlSugar是一种常用的轻量级.NET ORM框架，可以帮助开发人员提高开发效率和代码质量。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值