hbase的基本封装

最新推荐文章于 2023-03-18 11:43:03 发布
最新推荐文章于 2023-03-18 11:43:03 发布
阅读量558 收藏 1
点赞数
分类专栏： java 文章标签： hbase java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011955252/article/details/101642060
版权

背景：目前在做项目的时候，需要使用hbase进行数据的查询，一些评论记录，消费数据，交易日志等数据都是存储在hbase中的，因为都是海量的数据。了解hbase的原理是必要的，因此必须要学习好 rowkey的设计，否则会出现热点问题。可以百度这个rowkey 的设计，比如一般使用：随机，md5，分桶，反转等基本的手段就可以了。还需要了解hadoop的hdfs，因为hbase的HFile存储在hadoop上。

接下来就是基本你的api的封装，用于业务的调用

package hbase.annotation;

import hbase.convertor.HbaseConvertor;
import hbase.convertor.SimpleHbaseConvertor;

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

@Retention(RetentionPolicy.RUNTIME)
@Target(value={ElementType.FIELD})
public @interface HbColumn {

    /**
     * 列名，一张hbase表中列名必须唯一，子类可以覆盖父类，为空表示与db一致
     * @return
     */
    String value() default "";

    String familyName() default "f";

    Class<? extends HbaseConvertor> convertClass() default SimpleHbaseConvertor.class ;

    String[] args() default {};


}

package hbase.condition;

public class HbaseQueryCond {

    private String startRowKey;

    private String endRowKey;

    private int limit=50;

    private int offset=0;

    private boolean needRevers;


    public String getStartRowKey() {
        return startRowKey;
    }

    public void setStartRowKey(String startRowKey) {
        this.startRowKey = startRowKey;
    }

    public String getEndRowKey() {
        return endRowKey;
    }

    public void setEndRowKey(String endRowKey) {
        this.endRowKey = endRowKey;
    }

    public int getLimit() {
        return limit;
    }

    public void setLimit(int limit) {
        this.limit = limit;
    }

    public int getOffset() {
        return offset;
    }

    public void setOffset(int offset) {
        this.offset = offset;
    }

    public boolean isNeedRevers() {
        return needRevers;
    }

    public void setNeedRevers(boolean needRevers) {
        this.needRevers = needRevers;
    }
}

package hbase.convertor;

public interface HbaseConvertor {

    byte[] toBytes(Object value,String[] args);

    Object toObject(Class<?> objectType,byte[] bytes,String[] args);
}

package hbase.convertor;

import com.alibaba.fastjson.JSON;
import com.sun.org.apache.xpath.internal.operations.Bool;
import org.apache.hadoop.hbase.util.Bytes;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SimpleHbaseConvertor implements HbaseConvertor {

    @Override
    public byte[] toBytes(Object value, String[] args) {
        if(value==null){
            return null;
        }
        if(value.getClass()==byte[].class){
            return (byte[]) value;
        }
        if(value.getClass()==String.class){
            return Bytes.toBytes((String)value);
        }
        if(value.getClass()==Integer.class){
            return Bytes.toBytes((Integer)value);
        }
        if(value.getClass()==Long.class){
            return Bytes.toBytes((Long)value);
        }
        if(value.getClass()==Short.class){
            return Bytes.toBytes((Short)value);
        }
        if(value.getClass()==Boolean.class){
            return Bytes.toBytes((Boolean)value);
        }
        if(value.getClass()==Double.class){
            return Bytes.toBytes((Double)value);
        }
        if(value.getClass()==Float.class){
            return Bytes.toBytes((Float)value);
        }
        if(value.getClass()== Date.class){
            String date=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format((Date)value);
            return Bytes.toBytes(date);
        }
        if(value.getClass()== Map.class){
            String mapjson= JSON.toJSONString((Map)value);
            return Bytes.toBytes(mapjson);
        }
        if(value.getClass()== List.class){
            String listjson= JSON.toJSONString((List)value);
            return Bytes.toBytes(listjson);
        }
        throw new RuntimeException("SimpleHbaseConvertor,不支持类型的转换"+value.getClass());
    }

    @Override
    public Object toObject(Class<?> objectType, byte[] bytes, String[] args) {
        if(bytes==null){
            return null;
        }
        if(objectType==byte[].class){
            return bytes;
        }
        if(objectType==String.class){
            return  Bytes.toString(bytes);
        }
        if(objectType==Integer.class || objectType==Integer.TYPE){
            return  Bytes.toInt(bytes);
        }
        if(objectType==Long.class || objectType==Long.TYPE){
            return  Bytes.toLong(bytes);
        }
        if(objectType== Boolean.class||objectType== Boolean.TYPE){
            return  Bytes.toBoolean(bytes);
        }
        if(objectType==Double.class || objectType==Double.TYPE){
            return  Bytes.toDouble(bytes);
        }
        if(objectType==Short.class || objectType==Short.TYPE){
            return  Bytes.toShort(bytes);
        }
        if(objectType==Float.class || objectType==Float.TYPE){
            return  Bytes.toFloat(bytes);
        }
        if(objectType==Date.class){
            String date=Bytes.toString(bytes);
            try {
                return  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(date);
            } catch (ParseException e) {
            }
        }
        if(objectType==Map.class || objectType== HashMap.class){
            String mapBytes=Bytes.toString(bytes);
            return JSON.parseObject(mapBytes,Map.class);
        }
        if(objectType==List.class){
            String listBytes=Bytes.toString(bytes);
            return JSON.parseObject(listBytes,List.class);
        }
        throw new RuntimeException("SimpleHbaseConvertor,不支持类型的转换"+objectType);
    }
}

package hbase.model;

public class BaseHbaseDo {

    private String rowKey;

    public String getRowKey() {
        return rowKey;
    }

    public void setRowKey(String rowKey) {
        this.rowKey = rowKey;
    }
}

package hbase.model;

import hbase.annotation.HbColumn;

public class CommentDo extends BaseHbaseDo {
    @HbColumn
    private String id;

    @HbColumn
    private String comment;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String comment) {
        this.comment = comment;
    }
}

package hbase.model;

import org.apache.hadoop.hbase.client.HTableInterface;

public interface HbaseDataSource {

    public HTableInterface getHTable(String storeName,String tableName);

}

package hbase;

import hbase.annotation.HbColumn;
import hbase.condition.HbaseQueryCond;
import hbase.convertor.HbaseConvertor;
import hbase.model.BaseHbaseDo;
import hbase.model.HbaseDataSource;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.*;

public abstract class HbaseBaseDAO<T extends BaseHbaseDo> {

    private HbaseDataSource hbaseDataSource;

    private Map<String,Column> columnMap;

    private Map<Class<? extends HbaseConvertor>,HbaseConvertor> convertorClassMap;

    public void init() throws InstantiationException, IllegalAccessException {
        convertorClassMap=new HashMap<>();
        columnMap=parseHabseDOClass(getHbaseDOClass());
    }

    public void put(T hbaseDo) throws IllegalAccessException {
        HTableInterface table=null;
        try {
            hbaseDataSource.getHTable(getStoreName(),getTableName());

        Put put=new Put(Bytes.toBytes(hbaseDo.getRowKey()));
        for(Column column:columnMap.values()){
            putColumn(put,column,hbaseDo);
        }

            table.put(put);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(table!=null){
                try {
                    table.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    public void put(List<T> hbaseDos) throws IllegalAccessException {
        HTableInterface table=null;
        table=hbaseDataSource.getHTable(getStoreName(),getTableName());
        List<Put> puts=new ArrayList<>();
        for(T hbaseDo:hbaseDos){
            Put put=new Put(Bytes.toBytes(hbaseDo.getRowKey()));
            for(Column column:columnMap.values()){
                putColumn(put,column,hbaseDo);
            }
            puts.add(put);
        }
        try {
            table.put(puts);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(table!=null){
                try {
                    table.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public T get(String rowKey) throws InstantiationException, IllegalAccessException {
        HTableInterface table=null;
        try {
        table=hbaseDataSource.getHTable(getStoreName(),getTableName());
        Get get=new Get(Bytes.toBytes(rowKey));

            Result result=table.get(get);
            return parseResult(result);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            if(table!=null){
                try {
                    table.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public List<T> batchget(List<String> rowKeyList) throws IOException, IllegalAccessException, InstantiationException {
        if(CollectionUtils.isEmpty(rowKeyList)){
            return Collections.emptyList();
        }
        HTableInterface table=null;
        table=hbaseDataSource.getHTable(getStoreName(),getTableName());
        List<Get> getList=new ArrayList<>();
        for(String rowKey:rowKeyList){
            Get get=new Get(Bytes.toBytes(rowKey));
            getList.add(get);
        }
        Result[] results=table.get(getList);
        return parseResultList(results);
    }

    public List<T> scan(HbaseQueryCond hbaseQueryCond) throws IOException {
        if(hbaseQueryCond==null){
            return  Collections.emptyList();
        }
        ResultScanner rs=null;
        HTableInterface table=null;
        try {
        table=hbaseDataSource.getHTable(getStoreName(),getTableName());
        rs=table.getScanner(buildScan(hbaseQueryCond));

            return buildResultScanner(rs);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            if(table!=null){
                table.close();
            }
        }
    }


    public List<T> pageScan(HbaseQueryCond cond){
        if(cond==null){
            return  Collections.emptyList();
        }
        ResultScanner rs=null;
        HTableInterface table=null;
        try {
            table=hbaseDataSource.getHTable(getStoreName(),getTableName());
            rs=table.getScanner(buildPageScan(cond));

            return buildResultScanner(rs);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            if(table!=null){
                try {
                    table.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }


    public void delete(String rowKey) throws IOException {
        HTableInterface table=null;
        try {
            table = hbaseDataSource.getHTable(getStoreName(), getTableName());
            Delete delete=new Delete(Bytes.toBytes(rowKey));
            table.delete(delete);
        }catch (Exception e){
            if(table!=null){
                table.close();
            }
        }
    }

    private List<T> parseResultScanner(ResultScanner rs,int limit) throws InstantiationException, IllegalAccessException {
        List<T> hbaseDoList=new ArrayList<>();
        int count=0;
        for(Result result:rs){
            T hbaseDo=parseResult(result);
            if(hbaseDo!=null){
                hbaseDoList.add(hbaseDo);
                count++;
            }
            if(count>=limit){
                break;
            }
        }

        return  hbaseDoList;
    }

    private List<T> buildResultScanner(ResultScanner rs) throws InstantiationException, IllegalAccessException {
        List<T> hbaseDOList=new ArrayList<>();
        if(rs==null){
            return  Collections.emptyList();
        }
        for(Result result:rs){
             T hbaseDo=parseResult(result);
            hbaseDOList.add(hbaseDo);
        }
        return hbaseDOList;
    }

    private Scan buildScan(HbaseQueryCond cond){
        Scan scan=new Scan();
        if(!StringUtils.isEmpty(cond.getStartRowKey())){
            scan.setStartRow(Bytes.toBytes(cond.getStartRowKey()));
        }
        if(!StringUtils.isEmpty(cond.getEndRowKey())){
            scan.setStopRow(Bytes.toBytes(cond.getEndRowKey()));
        }
        scan.setBatch(1000);
        return scan;
    }

    public Scan buildPageScan(HbaseQueryCond cond){
        Scan scan=new Scan();
        if(!StringUtils.isEmpty(cond.getStartRowKey())){
            scan.setStartRow(Bytes.toBytes(cond.getStartRowKey()));
        }
        if(!StringUtils.isEmpty(cond.getEndRowKey())){
            scan.setStopRow(Bytes.toBytes(cond.getEndRowKey()));
        }
        if(cond.getLimit()>200){
            scan.setCaching(200);
        }
        scan.setCaching(cond.getLimit()+1);
        scan.setBatch(1000);
        return scan;

    }
    private T parseResult(Result result) throws IllegalAccessException, InstantiationException {
        if(result.isEmpty()){
            return null;
        }
        T hbaseDo=getHbaseDOClass().newInstance();
        for(Column column:columnMap.values()){
            byte[] bytes=result.getValue(Bytes.toBytes(column.familyName),Bytes.toBytes(column.columnName));
            if(bytes!=null){
                Object value=column.hbaseConvertor.toObject(column.field.getType(),bytes,column.args);
                column.field.set(hbaseDo,value);
            }
        }
        hbaseDo.setRowKey(Bytes.toString(result.getRow()));
        return hbaseDo;
    }


    private List<T> parseResultList(Result[] results) throws InstantiationException, IllegalAccessException {
        List<T> hbaseDoList=new ArrayList<>();
        if(results==null||results.length==0){
            return hbaseDoList;
        }
        for(Result result:results){
            T hbaseDo=parseResult(result);
            if(hbaseDo!=null){
                hbaseDoList.add(hbaseDo);
            }
        }
        return hbaseDoList;

    }
    private void putColumn(Put put,Column column,T hbaseDo) throws IllegalAccessException {
        Object doValue=column.field.get(hbaseDo);
        if(doValue!=null){
            byte[] valueBytes=column.hbaseConvertor.toBytes(doValue,column.args);
            if(valueBytes!=null){
                put.add(Bytes.toBytes(column.familyName),Bytes.toBytes(column.columnName),valueBytes);
            }
        }

    }

    protected abstract  String getStoreName();

    protected abstract String getTableName();


    private Map<String,Column> parseHabseDOClass(Class<?> clazz) throws IllegalAccessException, InstantiationException {
        if(clazz.getSuperclass()==null){
            return Collections.emptyMap();
        }
        Map<String,Column> columnMap=new HashMap<>();
        columnMap.putAll(parseHabseDOClass(clazz.getSuperclass()));

        Field[] fields=clazz.getDeclaredFields();
        for(Field field:fields){
            Column column=buildColumn(field);
            if(column!=null){
                columnMap.put(column.columnName,column);
            }
        }
        return columnMap;
    }

    private Column buildColumn(Field field) throws InstantiationException, IllegalAccessException {
        HbColumn hbColumn=field.getAnnotation(HbColumn.class);
        if(hbColumn!=null){
            field.setAccessible(true);
            Column column=new Column();
            column.field=field;
            if(StringUtils.isEmpty(hbColumn.value())){
                column.columnName=field.getName();
            }else{
                column.columnName=hbColumn.value();
            }
            column.familyName=hbColumn.familyName();
            column.args=hbColumn.args();
            column.hbaseConvertor=getConvert(hbColumn.convertClass());
            return column;
        }
        return null;
    }

    private HbaseConvertor getConvert(Class<? extends HbaseConvertor> convertorClass) throws IllegalAccessException, InstantiationException {
        if(convertorClassMap.containsKey(convertorClass)){
            return convertorClassMap.get(convertorClass);
        }
        HbaseConvertor convertor=convertorClass.newInstance();
        convertorClassMap.put(convertorClass,convertor);
        return convertor;

    }
    protected abstract Class<T> getHbaseDOClass();

    private static class Column{
        String columnName;
        String familyName;
        Field field;
        HbaseConvertor hbaseConvertor;
        String[] args;
    }
}

package hbase;

import hbase.model.CommentDo;

import java.util.List;

public interface HbaseCommentDAO  {

    public void insert(CommentDo commentDo);

    List<CommentDo> queryById(List<String> ids);
}

package hbase;

import hbase.model.CommentDo;

import java.io.IOException;
import java.util.List;

public class HbaseCommentDAOImpl extends HbaseBaseDAO<CommentDo> implements HbaseCommentDAO {


    @Override
    public void insert(CommentDo commentDo) {
        try {
            put(commentDo);
        } catch (IllegalAccessException e) {
        }
    }

    @Override
    public List<CommentDo> queryById(List<String> ids) {
        try {
            return batchget(ids);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return null;
    }


    @Override
    protected String getStoreName() {
        return null;
    }

    @Override
    protected String getTableName() {
        return null;
    }

    @Override
    protected Class<CommentDo> getHbaseDOClass() {
        return CommentDo.class;
    }
}

 

红豆和绿豆
关注
专栏目录
【Hbase 06】spark读写Hbase数据库以及Hbase util工具常用方法类封装（java和scala版本）
Alex的博客
06-03 1100
Spark处理的数据有很多是存放在HBase数据库中的，所以，我们需要学会如何读写HBase数据库。版本依赖支持关系请看博主的上一篇文章，Hbase的版本很重要，别整差了。
Hbase简介与基本原理
lilygg的博客
05-14 4149
一、Hbase简介 HBase（Hadoop Database）是一个开源的非关系型的分布式数据库，运行于HDFS文件系统之上，可以容错地存储海量稀疏的数据。 HBase是一个高可靠、高性能、面向列、可伸缩、实时读写的分布式数据库，主要用来存储非结构化和半结构化的松散数据。 HBase的目标是处理非常庞大的表，可以通过水平扩展的方式，利用廉价计算机集群处理由超过10亿行数据和数百万列元素组成的数据表。 划重点： HBase是基于列存储的，主要用来存储非结构化和半结构化的松散数据，适合大数据的.
详解spring封装hbase的代码实现
08-30
本篇文章主要介绍了详解spring封装hbase的代码实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
hbase的基本crud封装
03-13
hbase的基本crud封装 配置的hbase数据路径因个人而异,看自己的来设置配置
hbase(一)封装hbase一些方法
m0_48624662的博客
07-17 361
为方便后续代码 将hbase客户端操作的一些方法进行封装,如下: 1.获取一个hbase连接对象 2.获取一个hbase连接对象的admin 3.通过table名字获取一个hbase连接对象的table对象 4.展示table数据 5.创建一个namespace package com.hjm.hbase.utils; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.*; import o
HBase封装easy-hbase设计实现
weixin_33832340的博客
04-01 121
为什么80%的码农都做不了架构师？>>> ...
HBase封装类
哈利路亚的收藏夹
08-22 1163
最近需要用到HBase数据库。但是文件数据库
封装hbase以便java调用
04-23
NULL 博文链接：https://alleyz.iteye.com/blog/2254738
HBase新版本Java API编程实战及基本操作方法封装
热门推荐
至道
05-14 2万+
我的HBase版本是0.98 首先说明一下，如果用eclipse操作hbase时，如果报Unknown host错误，找不到主机，是因为你没有配IP地址的映射 方法是 找到你的系统盘里面的C:\Windows\System32\drivers\etc下的hosts文件，打开，增加一个映射 加一个映射 192.168.52.140 master话不多说，直接看代码，注释很详细 import
java hbase封装_hbasejavaapi封装
weixin_30639241的博客
03-04 177
java面向对象编程类的封装接口和基本类库练习题_从业资格考试_资格考试/认证_...java封装对象_计算机软件及应用_IT/计算机_专业资料。package cn.itcast.introspector; import java.io.BufferedReader; /* 需求: 编写一个工厂方法根据配置文件的......类的继承与封装《JAVA程序设计》课程实验报告 一、 实验题目 类的继承...
Hbase学习——对表操作进行封装
weixin_45890771的博客
11-08 2166
本文对以下内容进行介绍 1、封装连接 2、封装操作对象 3、封装命名空间的创建 4、封装表的创建 5、封装插入数据的操作 6、封装获取数据的操作 7、对以上6个函数进行操作检验（hbase创建命名空间、创建表、插入数据、查询数据） 1、封装连接 //封装连接 public static Connection GetConnection() throws IOException { Configuration conf = HBaseConfigurat
java hbase封装_HBase API——封装成工具类Utils | 学步园
weixin_42305634的博客
03-01 297
前面介绍了HBase的常用API并给出了实例：HBase之Java API为了便于以后使用，把对HBase表的常见CRUD操作，封装在一个类HBaseUtil里面，实现为：import java.io.IOException;import java.util.HashMap;import org.apache.hadoop.hbase.HColumnDescriptor;import org.ap...
封装一个简单的HBaseUtil
JiajunBernoulli的博客
07-13 306
文章目录前言Meaven依赖私有属性构造方法代码演示表格操作判断是否存在新建表格删除表格数据操作添加或者修改一条数据多条数据 前言 HBase作为一个面向列族的数据库，和一般的数据库不同，没法用JDBC封装的那套util，便重新封装了个HBase自己的util供项目使用。 Meaven依赖 注意修改成自己的版本，可以去https://mvnrepository.com/artifact/org.a...
Hbase编程封装实例
qq_33366098的博客
08-12 530
 1. HbaseConfiguration      关系：org.apache.hadoop.hbase.HBaseConfiguration      作用：通过此类可以对HBase进行配置     2.HBaseAdmin      关系：org.apache.hadoop.hbase.client.HBaseAdmin      作用：提供一个接口来管理HBase数据库中的表信息。它提供...
Hbase API常用操作的简单封装
qq_37312857的博客
03-21 151
工具类HbaseUtil： /** * hbase操纵工具类 */ public class HbaseUtil { //ThreaLocal private static ThreadLocal<Connection> connHolder = new ThreadLocal<Connection>(); private HbaseU...
Hbase JavaAPI的简单封装
leiro486592的博客
08-09 1009
在学习使用Hbase的时候，因为Hbase中存放的是byte数组。所以大部分的输入类型都是byte数组格式的。这样方便了存储其它大型文件，但是对于初学者的我们来讲就是十分不友好的。因此，我在这里对一些东西做了简单的二次封装，提高了学习的效率。这样，我们可以有更多的时间去考虑如何利用Hbase来设计业务逻辑，降低学习的难度。同时，这里做的一些封装，也可以为以后开发的时候封装工具做一个前瞻性的探索。 ...
HBase常用服务调用封装
农村外出务工男的博客
01-24 741
一、前言       生产刚刚接入HBase，应用对其数据的获取的几种方式如get，scan，scan range进行了相关服务封装 二、服务封装     package com.hbase.sources; import java.io.IOException; import java.util.ArrayList; import java.util.Date;
JDBC超详细封装教程
最新发布
weixin_48991399的博客
03-18 2391
​ JDBC（Java Database Connectivity）是什么？它是一种规范，SUN公司要求数据库公司必须按照JDBC规范实现对应数据库Java代码，提供数据库的相关资源给java程序。在JDBC出来之前，各种数据库提供给java程序数据的方法各式各样，可以说，JDBC极大地方便了我们java开发程序员，目前和java配合最好的数据库是Oracle和MySQL数据库。
HBase 大吞吐系统HTablePool和HTable使用技巧
MrTitan的专栏
05-07 1万+
这2周主要将项目中写hbase的模块中原来的异步hbaseclient改写成了使用hbase原生的HTable对象。大概总结下改写过程中和hj，xingchao发现的问题和解决方法。   1.HTablePool的基本使用方式： 由于HTable对象不是线程安全的，因此HBase提供HTablePool来支持多线程写入hbase，多线程同时从HTablePool中取出HTable并写入是安全
HBase工具类操作与链接获取指南
2. HBase表操作：HBase工具类可能会封装对HBase表的基本操作，例如创建表、删除表、列出所有表、检查表是否存在等。这些操作是进行数据操作前的基本准备工作。 3. 数据操作：除了表级别的操作，数据级别的CRUD...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值