搭建自己的SQLiteDataBase框架（五）

最新推荐文章于 2024-12-22 19:04:56 发布
原创 最新推荐文章于 2024-12-22 19:04:56 发布 · 514 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据库

本文介绍了一种在SQLite中实现一对多关系的方法，通过定义实体类及其对应的数据库表结构，展示了如何通过Java代码进行数据库的增删改查操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

搭建自己的SQLiteDataBase框架（五）

  • 一对多关系，同样也有两种关系，1，关联表存储对应关系，2，直接数据库操作增删改查
    此时实体类的对应模型如下：
@Table(name = "developer")
public class Developer implements Serializable {
    private static final long serialVersionUID = 1L;
    @Column(id = true)
    private String id;
    @Column
    private String name;
    @Column
    private int age;
    @Column(type = Column.ColumnType.SERIALIZABLE)
    private ArrayList<Skill> skills;
}

@Table(name = "company")
public class Company {
    @Column(id = true)
    private String id;
    @Column
    private String name;
    @Column
    private String url;
    @Column
    private String tel;
    @Column
    private String address;

    private String group;
    //添加一对多关系
    @Column(type = Column.ColumnType.TMANY,autoRefresh=true)
    private ArrayList<Developer> developers;
}

即：一个company可以对应多个developer,这个关系要理清

完善建表语句，相比之前变化略大：


    public static void createTable(SQLiteDatabase db, Class<?> clz) throws SQLException {
        System.out.println(getCreateTableStmt(clz));
        ArrayList<String> stmts = getCreateTableStmt(clz);
        for (String stmt : stmts) {
            db.execSQL(stmt);
        }
    }

    //建表语句,以Company为例说明
       private static ArrayList<String> getCreateTableStmt(Class<?> clz) {
        StringBuilder mColumnStmts = new StringBuilder();
        ArrayList<String> stmts = new ArrayList<String>();
        if (clz.isAnnotationPresent(Table.class)) {
            Field[] fields = clz.getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                if (fields[i].isAnnotationPresent(Column.class)) {
                    if (fields[i].getAnnotation(Column.class).type() == Column.ColumnType.TMANY) {
                    //建关联表语句，create table if not exists company_developers( pk1 TEXT,pk2 TEXT)
                        stmts.add("create table if not exists " + getAssociationTableName(clz, fields[i].getName()) + "(" + PK1 + " TEXT, " + PK2
                                + " TEXT)");
                    }
                    mColumnStmts.append(getOneColumnStmt(fields[i]));
                    mColumnStmts.append(",");
                }
            }
            if (mColumnStmts.length() > 0) {
                mColumnStmts.delete(mColumnStmts.length() - 2, mColumnStmts.length());
            }
        }
        // create table if not exists company (id TEXT primary key,...)
        stmts.add("create table if not exists " + getTableName(clz) + " (" + mColumnStmts + ")");
        return stmts;
    }


        //获取关联表 表名
        public static String getAssociationTableName(Class<?> clz, String association) {
        return getTableName(clz) + "_" + association;
    }

完善增删改查：

 public <T> void newOrUpdate(T t) {
        ContentValues contentValues = new ContentValues();
        try {
            String idValue = (String) id_field_.get(t);
            for (Field field : fields) {
                if (field.isAnnotationPresent(Column.class)) {
                    field.setAccessible(true);
                    Class<?> clz = field.getType();
                    if (clz == String.class) {
                        System.out.println("key:" + DBUtils.getColumnName(field) + ",value:" + field.get(t).toString());
                        contentValues.put(DBUtils.getColumnName(field), field.get(t).toString());
                    } else if (clz == int.class || clz == Integer.class) {
                        contentValues.put(DBUtils.getColumnName(field), field.getInt(t));
                    } else {
                        Column column = field.getAnnotation(Column.class);
                        Column.ColumnType columnType = column.type();
                        if (!TextUtils.isValidate(columnType.name())) {
                            throw new IllegalArgumentException("you should set  type to the special column:" + t.getClass().getSimpleName() + "." + field.getName());
                        }
                        if (columnType == Column.ColumnType.SERIALIZABLE) {
                            contentValues.put(DBUtils.getColumnName(field), SerializeUtil.serialize(field.get(t)));
                        } else if (columnType == Column.ColumnType.TONE) {
                            Object tone = field.get(t);
                            if (tone == null) {
                                continue;
                            }
                            if (column.autoRefresh()) {
                                // save object to related table
                                DBManager.getInstance().getDao(tone.getClass()).newOrUpdate(tone);

                            }
                            if (tone.getClass().isAnnotationPresent(Table.class)) {
                                String idName = DBUtils.getIDColumnName(tone.getClass());
                                Field id_field = tone.getClass().getDeclaredField(idName);
                                id_field.setAccessible(true);
                                contentValues.put(DBUtils.getColumnName(field), id_field.get(tone).toString());
                            }
                        } else if (columnType == Column.ColumnType.TMANY) {//添加一对多关系
                            List<Object> tmany = (List<Object>) field.get(t);
                            if (!TextUtils.isValidate(tmany)) {
                                continue;
                            }
                            //先清空再插入
                            String associationTable = DBUtils.getAssociationTableName(t.getClass(), field.getName());
                            delete(associationTable, "pk1=?", new String[]{idValue});
                            ContentValues assosiationValues = new ContentValues();
                            for (Object object : tmany) {
                                if (column.autoRefresh()) {
                                    DBManager.getInstance().getDao(object.getClass()).newOrUpdate(object);
                                }
                                assosiationValues.clear();
                                assosiationValues.put(DBUtils.PK1, idValue);
                                String idName = DBUtils.getIDColumnName(object.getClass());
                                Field idField = object.getClass().getDeclaredField(idName);
                                idField.setAccessible(true);
                                assosiationValues.put(DBUtils.PK2, idField.get(object).toString());
                                newOrUpdate(associationTable, assosiationValues);
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("newOrUpdate:" + e.toString());
        }
        newOrUpdate(mTableName, contentValues);
    }

        //删除关联数据
        public void delete(String id) {
        try {
            delete(mTableName, mIdName + "=?", new String[]{id});
            //delete related association data
            for (Field field : mForeignds) {
                delete(DBUtils.getAssociationTableName(clz, field.getName()), "pk1=?", new String[]{id});
            }
        } catch (Exception e) {
            System.out.println(e.toString());
        }
    }

    //
     public T queryById(String id) {
        Cursor cursor = rawQuery(mTableName, mIdName + "=?", new String[]{id});
        T t = null;
        if (cursor.moveToNext()) {
            try {
                t = clz.newInstance();
                for (Field field : fields) {
                    if (field.isAnnotationPresent(Column.class)) {
                        field.setAccessible(true);
                        Class<?> clazz = field.getType();
                        if (clazz == int.class || clazz == Integer.class) {
                            field.setInt(t, cursor.getInt(cursor.getColumnIndex(DBUtils.getColumnName(field))));
                        } else if (clazz == String.class) {
                            field.set(t, cursor.getString(cursor.getColumnIndex(DBUtils.getColumnName(field))));
                        } else {
                            // TONE columnType.newInstance -- setId--set to T (lazy load)
                            // Serializable deserializable to object --set to T (lazy load)
                            Column column = field.getAnnotation(Column.class);
                            Column.ColumnType columnType = column.type();
                            if (!TextUtils.isValidate(columnType.name())) {
                                throw new IllegalArgumentException("you should set  type to the special column:" + t.getClass().getSimpleName() + "." + field.getName());
                            }
                            if (columnType == Column.ColumnType.SERIALIZABLE) {
                                field.set(t, SerializeUtil.deserialize(cursor.getBlob(cursor.getColumnIndex(DBUtils.getColumnName(field)))));
                            } else if (columnType == Column.ColumnType.TONE) {
                                String idtone = cursor.getString(cursor.getColumnIndex(DBUtils.getColumnName(field)));
                                if (!TextUtils.isValidate(idtone)) {
                                    continue;
                                }
                                Object tone = null;
                                if (column.autoRefresh()) {
                                    //去数据库查询
                                    tone = DBManager.getInstance().getDao(field.getType()).queryById(idtone);
                                } else {
                                    tone = field.getType().newInstance();
                                    if (field.getType().isAnnotationPresent(Table.class)) {
                                        String idName = DBUtils.getIDColumnName(field.getType());
                                        Field id_field = field.getType().getDeclaredField(idName);
                                        id_field.setAccessible(true);
                                        id_field.set(tone, idtone);
                                    }
                                }
                                field.set(t, tone);
                            } else if (columnType == Column.ColumnType.TMANY) {//添加一对多关系
                                //获取List<T>中的T
                                Class realatedClass = (Class) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0];
                                Cursor tmanyCursor = db.rawQuery("select * from " + DBUtils.getAssociationTableName(clz, field.getName()) + " where " + DBUtils.PK1 + " =?", new String[]{id});
                                List list = new ArrayList();
                                String tmanyId = null;
                                Object tmany = null;
                                while (tmanyCursor.moveToNext()) {
                                    tmanyId = tmanyCursor.getString(tmanyCursor.getColumnIndex(DBUtils.PK2));
                                    if (column.autoRefresh()) {
                                        tmany = DBManager.getInstance().getDao(realatedClass).queryById(tmanyId);
                                    } else {
                                        tmany = realatedClass.newInstance();
                                        String idName = DBUtils.getIDColumnName(realatedClass);
                                        Field id_field = realatedClass.getDeclaredField(idName);
                                        id_field.setAccessible(true);
                                        id_field.set(tmany, tmanyId);
                                    }
                                    list.add(tmany);
                                }
                                if (!TextUtils.isValidate(list)) {
                                    continue;
                                }
                                field.set(t, list);
                            }

                        }

                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("queryById:" + e.toString());
            }
        }
        return t;
    }

测试一下：


 public void add() {
        Company company = new Company();
        company.setId("00001");
        company.setName("stay4it");
        company.setUrl("www.stay4it.com");
        company.setTel("10086");
        company.setAddress("Shanghai");
        Developer developer = new Developer();
        developer.setId("00001");
        developer.setName("Stay");
        developer.setAge(17);
        Skill skill = new Skill();
        skill.setName("coding");
        skill.setDesc("android");
        ArrayList<Skill> skills = new ArrayList<Skill>();
        skills.add(skill);
        developer.setSkills(skills);
        ArrayList<Developer> developers = new ArrayList<Developer>();
        developers.add(developer);
        company.setDevelopers(developers);
        DBManager.getInstance().getDao(Company.class).newOrUpdate(company);
    }

    public void queryCompanyById() {
        Company company = DBManager.getInstance().getDao(Company.class).queryById("00001");
        if (company != null) {
            System.out.println(company.toString());
        }
    }

看下日志输出：

11-17 11:18:43.812 26469-26469/project.charles.com.myapplication I/System.out: id:00001,name:stay4it,url:www.stay4it.com,tel:10086,address:Shanghai,developers[{"age":17,"id":"00001","name":"Stay","skills":[{"desc":"android","name":"coding"}]}]

接下来还有多对多的关系…

至此，DB框架的大体结构就成型了，后续就是在项目使用中的维护，扩展了，从简至繁，一步一步就构造出了一个简易的DB框架，如果只是轻量级使用SQLiteDataBase,自己搭建一个架子也就足够了

android框架搭建——封装一个属于自己的数据存储工具类（SQLite篇）
CZH
12-01 4337
当我们缓存本地的数据存在一对多（一个name对应多个values）的情况时，sharedPreferences已经无法胜任存储的工作了。此时我们需要使用SQLite来进行本地缓存。 直接使用SQlite进行存储时，每次执行插入，查询，删除操作都要写一大堆代码，很麻烦，所以我们对SQLite进行一下简单的封装，下面给出例子： 在这个例子中，我们要存储同学的姓名，年龄，指导老师，家庭地址，手机号等
强大的数据库ORM框架-GreenDao增删改查篇
老蒋也疯狂
12-11 4102
“前两篇博文分别阐述了如何去搭建一个GreenDao框架项目和剖析了项目中的相关源码，这让我们对GreenDao框架有了初步的了解以及如何去使用它，那么接下来就来了解GreenDao框架是如何能够在不接触SQL语句的情况下实现对本地数据库的增删改查。”由之前的博文可知，使用GreenDao框架对本地数据库的增删改查最终是通过GreenDao生成器自动生成的xxxDao类实现的(如PersonInfoDao、WorkInfoDao)，它们封装了大部分数据库操作方法，通常一张表就对应一个xxxDao类。
搭建自己的SQLiteDataBase框架（-）
charles_lun专栏
11-16 866
搭建自己的SQLiteDataBase框架（-）标签（空格分隔）： 未分类为了提升自身的技能，有些时候就不能总依赖第三方的开源，虽然那些大牛写出来的东西很好用，但是对自身技能包却没有多大提升。所以还是决定写一下自己的DB框架，虽然写的不好，但是会提高自己的数据库操作技能，同时还能锻炼架构能力，实现从0到1的渐变。废话不多说，直接开始吧。 需求分析 1. 建表 2. CRUD，即增
Android数据存储（三）——SQLiteDatabase 操作 SQLite
干燥的空气，湿润的呼吸
02-06 770
一、创建数据库 1、SQLiteOpenHelper Android 提供了SQLiteOpenHelper这个抽象类对数据库创建和升级，必须要重写onCreate()和onUpgrade()才行 这个类有两个重要实例方法，getReadableDatabase()和getWritableDatabase()，两者都能打开数据库【存在则打开，否则创建后打开】，并返回一个可供读写操作的对象。当数据库...
SQLite数据库的使用
dragon_cat_han的博客
03-13 412
Android中使用SQLite数据库需要借助SQLiteOpenHelper.通过继承SQLiteOpenHelper类来管理数据库。 一般定义自己的SQLiteOpenHelper时需要重写两个方法，onCreate()和onUpdate();以及构造函数。 public class MydatabaseHelper extends SQLiteOpenHelper { pr
python sqlite数据库一对多_python SQLite 数据库提速经验
weixin_30072453的博客
01-15 488
SQLite 特点是轻巧，依赖少，数据库就一个文件，打包即可提走。最近做一个应用，千万条数据，更新频繁，但处理方式很简单，首先直接用SQLite 处理，结果两分钟可以完成处理一次，这个还是太慢了。下面介绍 SQLite 优化提速的经验。后来用memory 数据库模式，先从file db 文件读取已保存数据，再把数据保存到memory 的sqlite 数据。下面是memory 的示例python c...
python sqlite数据库一对多_使用Python将多个类型插入到SQLite数据库中
weixin_36466165的博客
01-15 180
(一个月后)，两个步骤：1例如，将DAS lats lons times展平为一个长列表，比如18 long2生成“Insert into tablename xx(？)？,?,... 18个问号)，然后执行。在Test = 1def flatten( *args ):""" 1, (2,3), [4,5] -> [1 2 3 4 5] """# 1 level only SO [pyt...
083集-搭建项目框架-数据访问层
10-29
在本课程"083集-搭建项目框架-数据访问层"中，我们将深入探讨如何在Android应用程序开发中构建高效且可扩展的数据访问层。这一关键组件是任何项目框架的基础，因为它负责处理与数据库或远程服务器的数据交互。下面将...
【Python】python后端开发工程师--python基础，框架，数据库，消息队列等
suzimuyu99的博客
12-22 1536
2024面试经验总结
android连接数据库的增删查改 服务器学生搭建
08-08
这里提到的“服务器学生搭建”可能指的是学生自己搭建服务器环境的过程，这包括但不限于： - **选择合适的服务器**: 根据应用的需求选择云服务器或物理服务器。 - **安装必要的软件和服务**: 如Web服务器(Apache/...
MVP对SqLite的增删改查，其中集成了百度定位，侧滑删除。
05-26
MVP对SqLite的增删改查，其中集成了百度定位，侧滑删除，SQLite操作使用的AndBase，逻辑处理妥当，代码编写规范，是一个不错的Demo。
android sqlite 多对多,在SQLite中如何实现多对多的关系
weixin_39611043的博客
05-27 189
我正在创建一个具有多对多关系的SQLite数据库,我将其分解为两个一对多关系,并使用以下代码SQLiteManager: CREATE TABLE "main"."LESSONS"("LESSONID" INTEGER PRIMARY KEYNOT NULL , "MODULEID" INTEGER, FOREIGN KEY(MODULEID) REFERENCES MODULES(MODULE...
Adroid之SqliteDatabase学习笔记
GodV的博客
08-19 524
Android之SqliteDatabase数据库学习笔记 SqliteDatabase概述： 大家对sqlite数据库应该是比较了解的，他是一个轻量级的数据库，并且他只是一个嵌入式的数据库引擎，专门适合于资源有限的设备（如手机、PAD等）上存储适量的数据。那么android为我们提供了SqliteDatabase代表一个数据库（底层就是一个数据库文件），只要获取到这个对象，我们就可以对数据库进行
python sqlite数据库一对多_使用Python,SQLALchemy,Sqlite设置/插入多对多数据库
weixin_29302047的博客
02-09 331
我正在学习Python,作为第一个项目,我正在使用Twitter RSS提要,解析数据,并将数据插入到sqlite数据库中.我已经能够成功地将每个feed条目解析为内容变量(例如,“你应该买低……”),url变量(例如,u’http://bit.ly/HbFwL‘)和一个hashtag列表(例如#stocks’) ,”#stockmarket’,”#finance’,u’#money’,u’#mk...
python sqlite数据库一对多_Python：使用sqlite3进行多处理
weixin_36331429的博客
01-15 517
我有一个SQLite3数据库.我需要解析10000个文件.我从每个文件中读取一些数据,然后使用此数据查询数据库以获得结果.我的代码在单个进程环境中工作正常.但是在尝试使用多重处理池时出现错误.My approach without multiprocessing (works OK):1. Open DB connection object2. for f in files:foo(f, x1=x...
android sqlite 的创建与使用，sqlite自定义框架。
u013039687的博客
08-20 1250
文章为深度解析与高效运用sqlite数据库，提供完美的使用方法，高能的可移植性与可重用性，简单易上手，易操作。新手学习与运用，高手借鉴与批评。
java 反射 getDeclaredField和getField的区别
坚定目标，超越自我
02-23 3363
getDeclaredField是可以获取一个类的所有字段.  getField只能获取类的public 字段.  Java代码   public Field getDeclaredField(String name)          throws NoSuchFieldException, SecurityException {          checkM
数据库多对多关系示例 - 使用sqlite演示
bcbobo21cn的专栏
12-25 3104
多对多，可以理解为是一对多和多对一的组合；要实现多对多，一般都需要有一张中间表（也叫关联表），将两张表进行关联，形成多对多的形式； 例如： 老师表、班级表、课程表，中间表为：课程表； 如果sqlite数据库不显示列头；见此； https://blog.youkuaiyun.com/bcbobo21cn/article/details/111122445 张老师教一班和二班的语文； 赵老师教一班的物理和二班的数学； 这样就形成多对多； Microsoft Windows [版本 6.1...
DDL操作数据库
weixin_45701447的博客
09-09 871
一.什么是 sql sructured Query Language:结构化查询语言 定义了操作所有 关系型数据库的规则 。每一种数据库操作的方式存在不一样的地方称为方言. 二.sql 通用的语法 1.sql可以单行书写 也可以多行书写 以 分号 结尾 2.mysql 不区分大小写但是关键字 建议大写 三.sql分类 1.DDL:操作数据库和表 （1）操作数据库：CRUD C:创建 创建数据库 create database 数据库名称; create database if not exists 数据库名
基于Android的数据库开发思路
最新发布
01-14
具体来说，可以通过自定义的连接池框架来管理和分配 `SQLiteDatabase` 实例[^1]： ```java public class DatabaseConnectionPool { private static final int MAX_POOL_SIZE = 5; private Queue...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值