android架构师之路——面向对象数据库

最新推荐文章于 2023-12-10 12:20:16 发布
最新推荐文章于 2023-12-10 12:20:16 发布
阅读量164 收藏
点赞数
分类专栏： android架构师之路 文章标签： 面向对象数据库 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010008118/article/details/97755600
版权

简介

  • BaseDaoFactory  数据库创建，初始化
  • IBaseDao 增删改查接口
  • BaseDao 增删改查具体的实现
  • User 增删改查的对象
  • DbField 数据库字段名字标注
  • DbTable 数据库表名注解

我们这里只要是学习对象型数据库实现原理，如果要直接使用，可以查看GreenDao直接使用

BaseDaoFactory
public class BaseDaoFactory {

    private static final BaseDaoFactory instance = new BaseDaoFactory();
    //定义建数据库的路劲
    private String sqliteDatabasePath;
    private SQLiteDatabase sqLiteDatabase;

    public static BaseDaoFactory getInstance() {
        return instance;
    }

    public BaseDaoFactory() {
        //新建数据库
        //数据库路径，建议创建在sdcard上面，即使卸载了，数据库依然存在
//        sqliteDatabasePath = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "zkq.db";
        sqliteDatabasePath = "data/data/com.example.db_project/zkq.db";
        sqLiteDatabase = SQLiteDatabase.openOrCreateDatabase(sqliteDatabasePath, null);
    }
    public <T> BaseDao<T> getBaseDao(Class<T> entityClass) {
        BaseDao baseDao = null;
        try {
            baseDao = BaseDao.class.newInstance();
            baseDao.init(sqLiteDatabase, entityClass);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return baseDao;
    }
}
BaseDao中

 initCacheMap方法，将数据库中的字段和传入的user字段匹配，如果数据库中的字段名字和user的变量名字相匹配，就存入cacheMap中，方便读取

getValues方法，将user中的字段读取出来，放回一个Map<String,String>

下面是BaseDao全部代码

public class BaseDao<T> implements IBaseDao<T> {

    private static final String TAG = "BaseDao";
    //持有数据库操作的引用
    private SQLiteDatabase sqLiteDatabase;

    //持有操作数据库所对应的java类型
    private Class<T> entityClass;

    //表名
    private String tableName;

    //定义一个缓存空间（key-字段名   value-成员变量）
    private HashMap<String, Field> cacheMap;

    //标记：用来表示是否做过初始化操作
    private boolean isInit = false;

    public void init(SQLiteDatabase sqLiteDatabase, Class<T> entityClass) {
        this.sqLiteDatabase = sqLiteDatabase;
        this.entityClass = entityClass;

        //可以根据传入的entityClass类型来建表，只需要建一次
        if(!isInit){
            //自动建表
            //取得表明
            if(entityClass.getAnnotation(DbTable.class) == null){
                //反射到类名
                this.tableName =  entityClass.getSimpleName();
            } else {
                //取得注解上的名字
                this.tableName =  entityClass.getAnnotation(DbTable.class).value();
            }

            //执行建表操作
            // create table if not exists tb_user(_id TEXT,name TEXT,password TEXT)
            //使用getCreateTableSql（） 生成sql语句
            String createTableSql = getCreateTableSql();
            Log.i(TAG, createTableSql);
            this.sqLiteDatabase.execSQL(createTableSql);
            cacheMap  = new HashMap<>();
            initCacheMap();
            isInit = true;
        }
    }

    /**
     * 初始化数据表字段
     * 将数据库中的字段和传入的user字段匹配，如果数据库中的字段名字和user的变量名字相匹配，就存入cacheMap中，方便读取
     */
    private void initCacheMap() {
        //1、取得所有字段名
        String sql = "select * from " + tableName + " limit 1, 0";  //空表
        Cursor cursor = sqLiteDatabase.rawQuery(sql, null);
        String[] columnNames = cursor.getColumnNames();
        //2、取所有的成员变量
        Field[] declaredFields = entityClass.getDeclaredFields();
        //把所有字段的访问权限打开
        for (Field f: declaredFields) {
            f.setAccessible(true);
        }

        //字段 跟  成员变量一一对应
        for(String columNage : columnNames){
            Field columnField = null;
            for(Field field : declaredFields){
                String fieldName = "";  //对象中的成员变量名字
                if(field.getAnnotation(DbField.class) != null){
                    fieldName = field.getAnnotation(DbField.class).value();
                } else {
                    fieldName = field.getName();
                }

                if(columNage.equals(fieldName)){  //匹配
                    columnField = field;
                    break;
                }
            }

            if(columnField != null){
                cacheMap.put(columNage, columnField);
            }
        }
    }

    /**
     * 建表的sql语句
     *
     * @return
     */

    private String getCreateTableSql() {
       //create table if not exists tb_user(_id TEXT,name TEXT,password TEXT,status INTEGER)
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("create table if not exists ");
        stringBuffer.append(tableName + "(");
        //反射得到所有的成员变量
        Field[] declaredFields = entityClass.getDeclaredFields();
        for (Field field : declaredFields) {
            Class type = field.getType();// 拿到成员的类型

            if(field.getAnnotation(DbField.class) != null){
                //通过注解获取
                if(type == String.class){
                    stringBuffer.append(field.getAnnotation(DbField.class).value() + " TEXT,");
                } else  if(type == Integer.class){
                    stringBuffer.append(field.getAnnotation(DbField.class).value() + " INTEGER,");
                }else  if(type == Long.class){
                    stringBuffer.append(field.getAnnotation(DbField.class).value() + " BIGINT,");
                }else  if(type == Double.class){
                    stringBuffer.append(field.getAnnotation(DbField.class).value() + " DOUBLE,");
                }else  if(type == byte[].class){
                    stringBuffer.append(field.getAnnotation(DbField.class).value() + " BLOB,");
                }else {
                    //不支持的类型
                    continue;
                }
            } else {
                //通过反射获取
                if(type == String.class){
                    stringBuffer.append(field.getName() + " TEXT,");
                } else  if(type == Integer.class){
                    stringBuffer.append(field.getName() + " INTEGER,");
                }else  if(type == Long.class){
                    stringBuffer.append(field.getName() + " BIGINT,");
                }else  if(type == Double.class){
                    stringBuffer.append(field.getName() + " DOUBLE,");
                }else  if(type == byte[].class){
                    stringBuffer.append(field.getName() + " BLOB,");
                }else {
                    //不支持的类型
                    continue;
                }
            }
        }

        if(stringBuffer.charAt(stringBuffer.length()  - 1) == ','){
            stringBuffer.deleteCharAt(stringBuffer.length()  - 1);
        }
        stringBuffer.append(")");
        return stringBuffer.toString();
    }

    @Override
    public long insert(T entity) {
        //1、准本好ContentValues中需要的数据
        Map<String, String> map = getValues(entity);
        //2、把数据转移到ContentValues
        ContentValues values = getContentValues(map);
        //3、开始插入
        long result = sqLiteDatabase.insert(tableName, null, values);
        return result;
    }



    /**
     *
     * @param map 成员变量的名字  成员变量的值
     * @return
     */
    private ContentValues getContentValues(Map<String, String> map) {
        ContentValues contentValues = new ContentValues();
        Set keys = map.keySet();
        Iterator<String> iterator = keys.iterator();
        while (iterator.hasNext()){
            String key = iterator.next();
            String value = map.get(key);
            if(value != null){
                contentValues.put(key, value);
            }
        }
        return contentValues;
    }


    /**
     * 将entity的字段放入到map中
     * @param entity
     * @return
     */
    private Map<String, String> getValues(T entity) {
        HashMap<String, String> map = new HashMap<>();
        //返回的是所有的成员变量
        Iterator<Field> iterator = cacheMap.values().iterator();
        while (iterator.hasNext()){
            Field field = iterator.next();
            field.setAccessible(true);

            try {
                //获取对象的属性的值
                Object obj = field.get(entity);
                if(obj == null){
                    continue;
                }

                String value = obj.toString();

                String key  = "";
                if(field.getAnnotation(DbField.class) != null){
                    key = field.getAnnotation(DbField.class).value();
                } else {
                    key = field.getName();
                }

                if(!TextUtils.isEmpty(key) && !TextUtils.isEmpty(value)){
                    map.put(key, value);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        return map;
    }

    @Override
    public int update(T entity, T where) {

        int result = -1;
        //1、准本好ContentValues中需要的数据
        Map<String, String> values = getValues(entity);
        ContentValues contentValues = getContentValues(values);

        //条件map
        Map<String, String> values1 = getValues(where);

        Condition condition = new Condition(values1);

        result = sqLiteDatabase.update(tableName, contentValues, condition.whereClause, condition.whereArgs);
        return result;
    }

    @Override
    public int delete(T where) {
        int result = -1;
        //1、准本好ContentValues中需要的数据
        Map<String, String> values = getValues(where);
        Condition condition = new Condition(values);
        result = sqLiteDatabase.delete(tableName, condition.whereClause, condition.whereArgs);
        return result;
    }

    @Override
    public List<T> query(T where) {
        return query(where, null, null, null);
    }

    @Override
    public List<T> query(T where, String orderBy, Integer startIndex, Integer limit) {
//        sqLiteDatabase.query(tableName, null, "id = ?",
//                new String[], null. null, orderBy, "1, 5");
        //1、准本好ContentValues中需要的数据
        Map<String, String> values = getValues(where);

        String limitString = "";   //"2,6"
        if(startIndex != null && limit != null){
            limitString = startIndex + " , " + limit;
        }

        Condition condition = new Condition(values);

        Cursor query = sqLiteDatabase.query(tableName, null, condition.whereClause,
                condition.whereArgs, null, orderBy, limitString);

        List<T> result = getResult(query, where);  //游标  --- 》 javabean  --- list<javabaen>
        return result;
    }

    private List<T> getResult(Cursor query, T where) {
        ArrayList list = new ArrayList();
        Object item = null;
        while (query.moveToNext()){
            try {
                item = where.getClass().newInstance();  //因为不知道 new  ? , 所以通过反射方式
                //cacheMap  (字段---成员变量的名字)
                Iterator<Map.Entry<String, Field>> iterator = cacheMap.entrySet().iterator();
                while (iterator.hasNext()){
                    Map.Entry<String, Field> entry = iterator.next();
                    //取列名
                    String columnName = entry.getKey();

                    //以列名拿到列名在游标中的位置
                    int columnIndex = query.getColumnIndex(columnName);

                    Field value = entry.getValue();   //id
                    Class<?> type = value.getType();  //Integer
                    if(columnIndex != -1){  //columnName = "age"
                        if(type==String.class){
                            value.set(item,query.getString(columnIndex));//setid(1)
                        }else if(type==Double.class){
                            value.set(item,query.getDouble(columnIndex));
                        }else if(type==Integer.class){
                            value.set(item,query.getInt(columnIndex));
                        }else if(type==Long.class){
                            value.set(item,query.getLong(columnIndex));
                        }else if(type==byte[].class){
                            value.set(item,query.getBlob(columnIndex));
                        }else{
                            continue;
                        }
                    }
                }
                list.add(item);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        query.close();
        return list;
    }

    private class Condition {
        private String whereClause;  //1=1 and password = ？  --- >password = ？
        private String[] whereArgs;

        /**
         * new Person(1, "alan", "123")
         * @param whereCasue
         */
        public Condition(Map<String, String> whereCasue ) {
            ArrayList list = new ArrayList();  //whereArgs里面的内容存入的list
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("1=1");
            //取得所有成员变量的名字
            Set<String> keys = whereCasue.keySet();
            Iterator<String> iterator = keys.iterator();
            while (iterator.hasNext()){
                String key = iterator.next();
                String value = whereCasue.get(key);
                if(value != null){
                    stringBuffer.append(" and " + key + "=?");
                    list.add(value);
                }
            }

            this.whereClause = stringBuffer.toString();
            this.whereArgs = (String[]) list.toArray(new String[list.size()]);
        }
    }
}

User代码

/**
 * 如果没有设置DbTable 数据库表名就是tb_user
 * 设置了DbTable，数据库表名就是User
 */
@DbTable("tb_user")
public class User {
    /**
     * 如果没有设置DbField 数据库保存的就是id
     * 设置了DbField，数据库字段就是_id
     */
    @DbField("_id")
    private String id;
    private String name;
    private String password;

    public User() {
    }

    public User(String id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
DbTable代码
/**
 * 表名
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DbTable {
    String value();
}
DbField代码
/**
 * 字段名
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DbField {
    String value();
}

在mainActivity中具体使用

    /**
     * 插入
     * @param view
     */
    public void insert(View view) {
        BaseDao baseDao = BaseDaoFactory.getInstance().getBaseDao(User.class);
        baseDao.insert(new User("1", "zhangsan", "111111"));
        baseDao.insert(new User("2", "lisi", "222222"));
        baseDao.insert(new User("3", "wangwu", "333333"));
        baseDao.insert(new User("4", "zhaoliu", "444444"));
        baseDao.insert(new User("5", "liqi", "555555"));
    }

    /**
     * 修改
     * @param view
     */
    public void clickUpdate(View view) {
        BaseDao baseDao = BaseDaoFactory.getInstance().getBaseDao(User.class);
        User user = new User("5","liqi","666666");
        User where = new User("5","","");
        baseDao.update(user,where);
    }

    /**
     * 删除
     * @param view
     */
    public void clickDelete(View view) {
        BaseDao baseDao = BaseDaoFactory.getInstance().getBaseDao(User.class);
        User where = new User("2","","");
        baseDao.delete(where);
    }

    /**
     * 查询
     * @param view
     */
    public void clickSelect(View view) {
        BaseDao baseDao = BaseDaoFactory.getInstance().getBaseDao(User.class);
        User user = new User();
        List<User> users = baseDao.query(user);
        for (User user1 : users) {
            Log.e(TAG,user1.toString());
        }
    }

demo下载

zkq49099
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 安卓超级强劲的轻量级数据库ObjectBox，快的飞起
2401_84149765的博客
04-15 349
对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，从来都是我们去适应环境，而不是环境来适应我们！当你有了学习线路，学习哪些内容，也知道以后的路怎么走了，理论看多了总要实践的最后，互联网不存在所谓的寒冬，只是你没有努力罢了！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！码讲义、实战项目、讲解视频，并且会持续更新！**如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）
直接保存对象到数据库Demo
12-02
使用开源项目db4o实现在Android中直接保存对象到数据库的Demo
Android-一个简单的面向对象的Android的轻量级数据库框架
08-12
一个简单的面向对象的轻量级数据库框架，简化了Android开发中操作数据库的繁琐过程，将面向过程的业务逻辑封装，完全的零Sql语句。
android 开发面向对象,android 面向对象数据库编程
weixin_28716217的博客
05-26 135
面向对象数据库编程我们先看看操作示例我们可以看到这里操作数据库只是引用了一个对象IBaseDao baseDao = BaseDaoFactory.getInstance().getBaseDao(Person.class);Person person = new Person();person.name = "熊大";person.setPassword(123456l);baseDao.ins...
Android 面向对象式数据库架构设计1
hongxue8888的博客
07-23 198
文章目录1 BaseDaoFactory2 IBaseDao3 两个注解4 javabean-User5 BaseDao5.1 实现IBaseDao接口5.2 创建表生成创建表的sql语句initCacheMap5.3 实现插入5.4 更新5.5 删除5.5 查询6 BaseDao的扩展 greenDao的流程图： 下面代码展示了数据库的使用： BaseDao baseDao = BaseDa...
android 对象数据库中,解析嵌套的JSON对象，并存储在数据库中的Android
weixin_42407617的博客
05-26 255
我只是试图让存储在我的JSON文件中的值，并将其保存到SQLite数据库：解析嵌套的JSON对象，并存储在数据库中的Android这是我的JSON文件：{"list": {"meta": {"count": 132,"start": 0,"type": "resource-list"},"resources": [{"resource": {"classname": "Quote","fields...
android对象数据库使用范例
junjianzhang的专栏
04-13 297
在项目中对数据库的操作是最基本的，对数据库的封装也有很多方法，其中比较推荐的是对象数据库的封装比较赞，基本原理是每个表持有一个单例，使用非常方便。如下提供一个范例，项目需要依赖一个对象数据库的lib. public class AccountDbProvider { EntityManager entityManager; public AccountDbProvid
Android开发-面向对象的数据库Db4o.doc
06-02
在Android开发中，Db4o提供了一种替代传统关系型数据库如SQLite的方式，尤其是在面对面向对象编程时，它解决了对象关系映射（ORM）带来的复杂性和性能问题。 Android是一个基于Linux内核的移动开发平台，由Google...
系统架构师学习教程——专业指导教程
02-25
自学软考时用到的资料，希望能帮助走向架构师的同学。
架构之路—— 穿行在产品和业务之间.pdf
11-07
架构之路—— 穿行在产品和业务之间 这个是高清pdf文字版本，可以复制内容的
Android : Room 数据库的基本用法 —简单应用_一_入门
最新发布
javaGHui的博客
12-10 5489
Android : Room 数据库的基本用法 —简单应用_一_入门
关于JAVA Entity entity = entityClass.getAnnotation(Entity.class);
evilcry2012的专栏
08-06 1117
关于JAVA Entity entity = entityClass.getAnnotation(Entity.class); 2013-08-31 15:50匿名 | 浏览 1663 次 protected String entityName(Class entityClass) { String entityName = entityClass.getSimpleName()
java自定义注解实践
iteye_16204的博客
08-29 144
  ²  背景 最近在为公司的技术改造做准备，我设计了一个提高Web开发效率的技术框架，为了增加框架的友好性和易用性，决定采用注解来代替配置文件，于是我查询了很多的资料，进行整理和学习。     ²  概念 注解是JDK5引入的新特性，最初衍生自代码注释，但现在早已经超出了注释的范畴，以至于我很惶恐，不敢使用注释这个词汇来描述他，尽管现有的很多资料里仍然称其为注释。如果说反射使得很多技...
Android 架构之数据库搭建
qq_30382601的博客
07-15 637
前言 你还在苦恼的写SQL么？你还在为数据库升级而烦恼么？你还在因查询数据而写繁琐不可用的代码么？ 在这，这些都将不复存在！在本篇中，将会让你一点一滴从无到有创建一个不再为数据库而烦恼的框架。 在开始之前我们先欣赏一下本章实现的最终效果 如图所示： 对应的model，可直接成为表结构，不再写对应的 Create table xxx对应的SQL了 对应model的Dao层，里面封装了数据表的基本操作（增删改查） 对应的增删改查操作，再也不用SQL了，全用对象处理 接下来开始实战了 1、先创建对应相关操作
Android 数据库开发实战（简单易懂+DEMO）
卜大爷的博客
08-26 2万+
本文将介绍Android中数据库的使用，及示例展示数据库的增删改查等操作方法。
private用法 java_关于android开发中如何正确使用Private Services安全用法及代码示例...
weixin_30366015的博客
02-21 928
一、注意事项1、显式设置exported属性为false。@b@2、安全处理收到的intent，确认其真实性。@b@3、敏感数据可以在同一个应用中发送和请求。二、原代码示例1.AndroidManifest.xml@b@@b@@b@@b@@b@@b@@b@@b@@b@...
Android 判断SQLite数据库中是否存在某一个表格： CREATE TABLE IF NOT EXISTS
热门推荐
haiross的专栏
11-13 5万+
初始化SQL脚本 安装软件时要初始化数据库，通常的需求是新建表、索引、视图、存储过程等对象，插入初始数据。Oracle没有drop table if exists或create table if not exists语法，所以需要自己处理。第一种情况：如果表存在，先删除再建立。begin   for x in (select table_name from all_tables wh
java反射获取注解id,通过反射获取注解（Annotation）
weixin_39836530的博客
03-13 420
以下实例，定义一个注解。通过反射获取。主要功能：为所注解过的参数和方法附加一些信息可以获取。定义注解。import java.lang.annotation.*;@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时可以通过反射获取到@Target({ElementType.FIELD, ElementType.METHOD})/...
数据库权限系统设计：通向架构师之路
本资源是一份关于"通向架构师道路：基于数据库的权限系统设计"的教程，重点讲解如何在IT领域构建一个基础且灵活的权限管理系统。课程内容主要包括以下几个部分： 1. 权限系统设计基础：介绍了一个基本的基于数据库...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值