Android架构设计01-数据库框架

最新推荐文章于 2024-05-08 08:22:24 发布
最新推荐文章于 2024-05-08 08:22:24 发布
阅读量1.8k 收藏 4
点赞数
分类专栏： Android开源框架 文章标签： 数据库 架构设计 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SImple_a/article/details/69945873
版权

文章目录

1 使用场景

涉及到数据库的操作，一般的都是使用第三方的框架，如GreeoDao,OrmLitem等。或者是直接利用SQLiteOpenHelper来完成数据库的增删改查以及数据库升级。那么对于这种写法，一般都比较繁琐。操作如下：

DBHelper dbHelper = new DBHelper(this);
SQLiteDatabase sqLiteDatabase = dbHelper.getWritableDatabase();
sqLiteDatabase.execSQL("create table if not exists tb_weichat(name varchar(20),password varchar(10))");
ContentValues contentValues  = new ContentValues();
contentValues.put("user_name","张三");
contentValues.put("password","123456");
sqLiteDatabase.beginTransaction();
int scheduleID = -1;
dbHelper.insert("schedule",null,values);
dbHelper.setTransctionSuccessful();

使用框架实现

User user = new User("张三", "20122425");
baseDao.insert(user);

可以看出使用框架和之前相比省了很多行代码。操作更简单。

2 用到的知识点

泛型
注解
反射
数据库语句拼接

用到的设计的模式
单例模式
简单工厂模式
模板方法模式

3 类图

这里写图片描述

4 具体实现

4.1 IBaseDao 定义数据库访问接口
public interface IBaseDao<T> {
    /**
     * 数据库插入操作
     * @param entity
     * @return
     */
    Long insert(T entity);

    /**
     * 数据库删除
     * @param where
     * @return
     */
    int delete(T where);

    /**
     * 数据库更改操作
     * @param entity
     * @param where
     * @return
     */
    int updata(T entity,T where);

    /**
     * 数据库查询操作
     * @param where
     * @return
     */
    List<T> query(T where);

}

这个借口约束了数据库行为，数据库中有增删改查功能。

4.2 BaseDao 实现数据库操作
public abstract class BaseDao<T> implements IBaseDao<T> {

    //只能初始化一次
    private boolean isInit = false;

    //被插入数据库的实体
    private Class<T> mEntityClass;

    private SQLiteDatabase mSqLiteDatabase;

    //表名
    private String tableName;

    /**
     * 用来维护表与实体的对应关系
     * key:   表的列名
     * value: entity的Field名
     */
    private HashMap<String, Field> cacheMap;

    /**
     * @param entityClass    要出入数据库的实体类
     * @param sqLiteDatabase 数据库管理的对象
     */
    public synchronized boolean init(Class<T> entityClass, SQLiteDatabase sqLiteDatabase) {
        if (!isInit) {
            mEntityClass = entityClass;
            mSqLiteDatabase = sqLiteDatabase;

            if (mEntityClass.getAnnotation(DbTable.class) != null) {
                //注解DbTable的值为表名
                tableName = entityClass.getAnnotation(DbTable.class).value();
            } else {
                //如果没有注解，对应的类名为表名
                tableName = entityClass.getSimpleName();
            }

            //创建表
            if (!TextUtils.isEmpty(createTable())) {
                sqLiteDatabase.execSQL(createTable());
            }

            cacheMap = new HashMap<>();
            initCacheMap();
            isInit = true;
        }
        return isInit;
    }

    /**
     * 初始化cacheMap,
     * 将表的列明和对应的entity的成员变量名字赋值给该cacheMap
     */

    private void initCacheMap() {
        String sql = "select * from " + this.tableName + " limit 1,0";
        Cursor cursor = null;
        try {


            cursor = mSqLiteDatabase.rawQuery(sql, null);

            //表的列名数组
            String[] columnsName = cursor.getColumnNames();

            //entitiy的Field数组
            Field[] fields = mEntityClass.getFields();

            //防止私有属性无法访问
            for (Field field : fields) {
                field.setAccessible(true);
            }

            //遍历列名
            for (String columnName : columnsName) {
                //遍历成员变量
                for (Field field : fields) {
                    String fieldName = null;
                    if (field.getAnnotation(DbField.class) != null) {
                        fieldName = field.getAnnotation(DbField.class).value();
                    } else {
                        fieldName = field.getName();
                    }

                    if (field != null && columnName.equals(fieldName)) {
                        cacheMap.put(columnName, field);
                        break;
                    }

                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != cursor) {
                cursor.close();
            }
        }
    }

    //=============================================插入
    @Override
    public Long insert(T entity) {
        Map<String, String> map = getValue(entity);
        ContentValues contentValues = getContentValues(map);
        Long reslt = mSqLiteDatabase.insert(tableName, null, contentValues);
        return reslt;
    }

    //=============================================删除
    @Override
    public int delete(T where) {
        int result = -1;

        Map whereClause = getValue(where);
        Condition condition = new Condition(whereClause);

        result = mSqLiteDatabase.delete(tableName, condition.getWhereClause(), condition.getWhereArgs());
        return result;
    }

    //=============================================更新
    @Override
    public int updata(T entity, T where) {
        int result = -1;
        Map whereClause = getValue(where);
        Map values = getValue(entity);

        Condition condition = new Condition(whereClause);
        ContentValues contentValues = getContentValues(values);

        result = mSqLiteDatabase.update(tableName, contentValues, condition.getWhereClause(), condition.getWhereArgs());
        return result;
    }

    //=============================================更新
    @Override
    public List<T> query(T where) {

        return query(where, null, null, null);
    }

    private List<T> query(T where, String orderBy, Integer startIndex, Integer limit) {
        Map map = getValue(where);
        String limitString = null;
        if (startIndex != null && limit != null) {
            limitString = startIndex + " , " + limit;
        }

        Condition condition = new Condition(map);
        Cursor cursor = mSqLiteDatabase.query(tableName, null, condition.getWhereClause(), condition.getWhereArgs(), null, null, orderBy, limitString);

        List<T> result = getResult(where, cursor);
        cursor.close();
        return result;
    }

	/**
     * 将查询的结果返回
     * @param where  表中每条数据对应的实体类
     * @param cursor  查询结果返回的cursor对象
     * @return  返回所有的查询结果
     */
    protected List<T> getResult(T where, Cursor cursor) {
        ArrayList list = new ArrayList();
        Object item;
        //先遍历表中的所有行
        while (cursor.moveToNext()) {
            try {
                //根据一行 创建一个实例
                item = where.getClass().newInstance();
                Iterator iterator = cacheMap.entrySet().iterator();
                while (iterator.hasNext()) {
                    Map.Entry entry = (Map.Entry) iterator.next();

                    //得到列名
                    String columnName = (String) entry.getKey();

                    //根据列名 得出列的位置
                    Integer columnIndex = cursor.getColumnIndex(columnName);

                    Field field = (Field) entry.getValue();

                    //获取Field的类型
                    Class type = field.getType();

                    //判断Field的类型
                    if (columnIndex != -1) {
                        if (type == String.class) {
                            //根据反射进行赋值
                            field.set(item, cursor.getString(columnIndex));
                        } else if (type == Double.class) {
                            field.set(item, cursor.getDouble(columnIndex));
                        } else if (type == Integer.class) {
                            field.set(item, cursor.getInt(columnIndex));
                        } else if (type == Long.class) {
                            field.set(item, cursor.getLong(columnIndex));
                        } else if (type == Byte.class) {
                            field.set(item, cursor.getBlob(columnIndex));
                            //不支持类型
                        } else {
                            continue;
                        }
                    }
                }

                list.add(item);
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return list;
    }

    ;

    /**
     * 把map转成contentValues
     * key:列名   value：Field值
     *
     * @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 columnName = iterator.next();
            String value = map.get(columnName);

            if (!TextUtils.isEmpty(columnName) && !TextUtils.isEmpty(value)) {
                contentValues.put(columnName, value);
            }

        }
        return contentValues;
    }

    ;


    /**
     * 用map 来存储entity的属性值 key为对应属性的注解值
     * key:"user_name"   vlaue:"张三"
     *
     * @param entity
     * @return
     */
    private Map<String, String> getValue(T entity) {
        Map<String, String> map = new HashMap<>();
        Iterator<Field> fieldIterator = cacheMap.values().iterator();

        while (fieldIterator.hasNext()) {
            Field field = fieldIterator.next();

            String key = null; //列名
            String value = null; //field值

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

            try {
                if (field.get(entity) == null) {
                    continue;
                }
                value = field.get(entity).toString();
                if (value != null) {
                    map.put(key, value);
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

        }
        return map;
    }

    class Condition {
        /**
         * 条件语句
         * name=?&&password=?
         */
        private String whereClause;

        private String[] whereArgs;

        public Condition(Map<String, String> whereClause) {
            ArrayList list = new ArrayList();
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(" 1=1 ");


            Set keySet = whereClause.keySet();
            Iterator<String> iterator = keySet.iterator();
            while (iterator.hasNext()) {
                String key = iterator.next();
                String value = whereClause.get(key);
                if (key != null) {

                    //拼接条件语句  1=1 and name =？ and password =?
                    stringBuilder.append(" and " + key + " =?");

                    list.add(value);
                }
            }

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

        public String getWhereClause() {
            return whereClause;
        }

        public String[] getWhereArgs() {
            return whereArgs;
        }
    }


    /**
     * 每个Dao的建的表各不相同，所以此方法留给子类实现
     *
     * @return 建表的字符串语句
     */
    public abstract String createTable();
}

这个类也是这个框架的核心内容。首先看这个方法

init(Class entityClass, SQLiteDatabase sqLiteDatabase)
这个方法做了这几件事情：

初始化每一条数据对应的实体类。

  mEntityClass = entityClass;

初始化SQLiteDataBase对象

mSqLiteDatabase = sqLiteDatabase;

初始化表名

if (mEntityClass.getAnnotation(DbTable.class) != null) {
                //注解DbTable的值为表名
                tableName = entityClass.getAnnotation(DbTable.class).value();
            } else {
                //如果没有注解，对应的类名为表名
                tableName = entityClass.getSimpleName();
            }

创建表 这里的createTalbe方法是抽象方法，也是BaseDao子类唯一需要重写的方法。也就是说BaseDao的子类除了建表语句不同之外，其他的方法都是一样的。

 if (!TextUtils.isEmpty(createTable())) {
                sqLiteDatabase.execSQL(createTable());
            }

初始化cacheMap

cacheMap = new HashMap<>();
            initCacheMap();

cacheMap用来维护表的数据和实体类的对应关系。
key:表的列名。如user_name
value: entity的Field。如User类中的String name的name变量。

initCacheMap()
这个方法是用来给cacheMap赋值的。

首先用cursor来获取一个表的列名数组

cursor = mSqLiteDatabase.rawQuery(sql, null);
String[] columnsName = cursor.getColumnNames();

获取entity中的成员变量数组

Field[] fields = mEntityClass.getFields();

在把根据列名找到对应的实体类中的成员变量

for (String columnName : columnsName) {
                //遍历成员变量
                for (Field field : fields) {
                    String fieldName = null;
                    if (field.getAnnotation(DbField.class) != null) {
                        fieldName = field.getAnnotation(DbField.class).value();
                    } else {
                        fieldName = field.getName();
                    }

                    if (field != null && columnName.equals(fieldName)) {
	                    //没找到一个对应 就添加到cacheMap中
                        cacheMap.put(columnName, field);
                        break;
                    }

                }
            }

getValue(T entity)
这个方法用来把一个实体类的中所有的成员变量封装到一个map中。
map的key:entity的Field注解名，也就是列名；
map的value:entity的Field的value;
用cacheMap去迭代表的所有列的数据。当列名对应的Field的value不是null的时候，将此列名和value作为一个entry添加到map中。

getContentValues(Map< String, String> map)
这个方法用来把map(key:列名，value:Field的值)转化为contentValue。

内部类Condition
这个内部类是用来拼接条件语句。当在构造方法中传入一个entity后，把这个entity的Field的名作为拼接条件的查询语句，Field的value作为条件语句的值。它有两个成员变量

whereClause:用来拼接条件语句。如：and name =？
whereArgs:条件语句的值的数组。如：”张三“

getResult(T where, Cursor cursor)
这个方法是用来根据需要
查询的条件
和表中的所有数据 来返回所有符合条件的对象集合。

4.3 UserDao

具体的数据库访问类。

public class UserDao extends BaseDao {
    @Override
    public String createTable() {
        return "create table if not exists tb_weichat(name varchar(20),password varchar(10))";
    }
}

这个类只是重写了建表语句的方法。也就是每当需要建一张表就要写一个此类。

注解：

4.4 DbField
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DbField {
    String value();
}

修饰成员变量。value对应表的列名。

注解:

4.5 DbTable
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DbTable {
    String value();
}

修饰类。对应表名。

4.6 User
@DbTable("tb_weichat")
public class User {

    @DbField("name")
    public String name;

    @DbField("password")
    public String password;

    public User() {
    }

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

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

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

这个类是表的每一条数据对应的实体类。也就是说每个User对应一个UserDao。每个UserDao对应一张表。而每个User对应一条表的数据。

4.7 BaseDaoFactory
public class BaseDaoFactory {

    //单例
    private static BaseDaoFactory instance = new BaseDaoFactory();

    //数据库的存储路径
    private String sqliteDataPath;

    private SQLiteDatabase sqLiteDatabase;

    private BaseDaoFactory() {
        //随便起了个名字，比如叫微信的数据库
        sqliteDataPath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/weichat.db";
        openSqliteDataBase();
    }

    public static BaseDaoFactory getInstance() {
        return instance;
    }

    private void openSqliteDataBase() {
        sqLiteDatabase = SQLiteDatabase.openOrCreateDatabase(sqliteDataPath,null);
    }

    /**
     * 构建一个BaseDao的子类
     * @param entity 插入数据库的实体类
     * @param dao   BaseDao的子类
     * @param <T>
     * @param <M>
     * @return
     */
    public synchronized  <T,M extends BaseDao<T>> BaseDao<T> constructDao(Class<T> entity,Class<M> dao){
        BaseDao baseDao = null;
        try {
            baseDao = dao.newInstance();
            baseDao.init(entity,sqLiteDatabase);

        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return baseDao;
    }
}

这个类用来构建一个具体的BaseDao对象。这个类是单例的。全局只有一个此类的对象。构建了BaseDao对象并隐藏了具体的实现细节。

4.8 MainActivity
public class MainActivity extends AppCompatActivity {
    private IBaseDao baseDao;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        baseDao = BaseDaoFactory.getInstance().constructDao(User.class, UserDao.class);
    }

    public void insert(View view) {
        User user = new User("张三", "20122425");
        baseDao.insert(user);
    }

    public void delete(View view){
        User where = new User();
        where.setName("李四");
        baseDao.delete(where
        );
    }

    public void update(View view){
        User user = new User("李四","1352284");

        User where = new User();
        where.setName("张三");

        baseDao.updata(user,where);
    }

    public void query(View view){
        User user = new User();
        user.setName("李四");
        List<User> list = baseDao.query(user);
        Log.i("Main","查询到"+list.size()+"条数据");
    }
}

点击下载源码

小 黄 鸡
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android端数据库设计与实现
Biewenwsm的博客
05-21 937
Android实现数据库功能
Android之 常用数据库框架整理
qq_29848853的博客
05-11 3636
常用数据库框架整理
2024年最全最新Android系统框架详细解读+资料分享，2024年最新面试必备资料
2401_84564025的博客
05-08 944
作为一名从事Android的开发者，很多人最近都在和我吐槽Android是不是快要凉了？而在我看来这正是市场成熟的表现，所有的市场都是温水煮青蛙，永远会淘汰掉不愿意学习改变，安于现状的那批人，希望所有的人能在大浪淘沙中留下来，因为对于市场的逐渐成熟，平凡并不是我们唯一的答案！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化学习资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！
Android数据库设计
only
05-28 1411
 <br />一、SQLITE数据库字段类型<br />　　NULL: 表示一个NULL值<br />　　INTEGER: 用来存储一个整数,根据大小可以使用1,2,3,4,6,8位来存储.<br />　　REAL: IEEE 浮点数<br />　　TEXT: 按照字符串来存储<br />　　BLOB: 按照二进制值存储,不做任何改变.<br />      id自增长字段：id integer primary key autoincrement<br />二、SQLITE的CRUD操作<br />inse
Android 数据库开发实战（简单易懂+DEMO）
卜大爷的博客
08-26 2万+
本文将介绍Android中数据库的使用，及示例展示数据库的增删改查等操作方法。
Android数据库建库建表的几种方法
m0_64114170的博客
05-05 2240
方法一：SQLite数据库的建立 SQLiteDatabase database; public UserDao(Context context){ //1.1建库 database=context.openOrCreateDatabase("user.db",Context.MODE_PRIVATE,null); //1.2建表 String sql="create table if not exists usertb(_id i
Android Jetpack架构组件-Room升级
01-03
在Android中使用任何一种数据库框架，少不了应用的迭代和数据库的升级，那么Room的该如何正确的升级？ 一、Room数据库升级 第一步：增加version数据，及版本号增加 @Database(entities = [Cheese::class, User::...
Android操作系统的架构设计分析
09-03
Android操作系统是目前全球最受欢迎的移动操作系统之一，其架构设计独特且高效，主要由四个层次构成：Linux内核驱动、C/C++框架、Java框架以及Java应用程序。这些层次共同协作，为开发者提供了丰富的功能和良好的...
指纹- Android-框架
03-01
Android 指纹识别框架架构主要包括以下几个部分： 1. 指纹识别守护进程（Fingerprint Daemon）：负责指纹识别的核心逻辑，包括指纹图像采集、预处理、特征提取和特征匹配。 2. 硬件抽象层（HAL）：提供了对指纹...
使用Clean + MVVM架构开发的Android News应用-Android开发
05-26
Clean-MVVM-NewsApp一个使用Clean + MVVM体系结构构建的Android应用程序。 在应用程序中使用的组件中精选。 Kotlin-作为一种编程语言。 LiveData-生命周期感知的Observable Clean-MVVM-NewsApp一个使用Clean + MVVM...
毕业设计-基于Android的旅游攻略app
最新发布
05-20
对于基于Android的旅游攻略App的毕业设计项目，以下是一些建议和步骤，以帮助你顺利进行项目开发： 1. **需求分析**： - 确定目标用户群体，例如热爱旅游的学生、上班族、退休人士等。 - 明确App需要提供的核心...
android 数据库表结构更新步骤
03-22
android 数据库表接口更新；更新老版本程序中表的接口添加删减字段
android 数据库及设计模式
08-07
android 数据库和设计模式 最新发布资料eoe社区，附件资料齐全
安卓数据库设计
07-01
安卓数据库设计
[Android]数据库表设计
weixin_44417042的博客
06-24 366
缓存表 司机sessionid和临时信息映射表[HASH] 司机临时状态表 Key：online-driver-[sessionid] 注意，orderid是在web应用服务器分配自动分配司机给一个用户给该司机，时生成一个订单号，格式为orderid-xxxx-xxx-xxx-xxx-xxxx 乘客sessionid和临时信息映射表[HASH] 乘客临时状态表 Key：key: online-user-[sessionid] 临时订单表[HASH] key:orderid-xxxx-xxx-xxx-
Android数据库框架设计一
杨的博客
06-08 4381
前言Android开发中我们或多或少都会接触到数据库。Android中提供了一个占用内存极小的关系型数据库-SQLite。虽然Android系统中提供了许多操作SQLite的API，但是我们还是需要手动去编写SQL语句，这经常会出现一些莫名其妙的问题。所以便出现了许多ORM（对象关系映射）框架。其中比较著名的有GreenDao、OrmLite、Litepal等。    常用的数据框架:数据库框架访...
4、Android 主流数据库框架
lanxuan1993的博客
03-21 2127
百度安全验证 Android使用Room数据库框架_wzl_show的博客-CSDN博客_android数据库框架room Android：ROOM数据库框架 - 知乎 Android数据库框架——Room_zyzoeshanghai的博客-CSDN博客_android 轻量级数据库框架 安卓轻量级数据库框架-GreenDao3.2.2集成方案_BY-91的博客-CSDN博客_android轻量级数据库框架 带大家熟悉Android全新的Room数据库框架_徐福记456的博客-CSDN博客_roo
Android数据库（SQLite）设计的几个要点
yhthu
03-29 5702
一、数据读写效率与分表策略 在设计数据库的时候，需要充分考虑后续读写数据的时间复杂度，特别是在频繁提取数据库数据用于作图等应用中。提高数据库查询效率最直接的办法就是合理设计查询条件，避免查询耗时随着数据量增大线性增加。 在设计数据库时，应该按照软件系统的数据类型对数据进行分类存储管理。以包含用户基本信息和扩展信息为例进行说明，并且假定其扩展信息是需要被频繁访问的数据。采取的方案应该至少包括两个
【Android 数据库框架总结，总有一个适合你！】
热门推荐
da_caoyuan的博客
03-11 5万+
一：OrmLite 简述: 优点： 1.轻量级；2.使用简单，易上手；3.封装完善；4.文档全面。缺点：1.基于反射，效率较低（本人还没有觉得效率低）；2.缺少中文翻译文档 jar包 地址：http://ormlite.com/releases/ 集成方法：把jar包复制到as的libs文件夹下，并且引用jar包即可 用于学习的相关博客： 我的博客 总结：比较好的一个数据库开源框架。不...
Android程序开发初级教程-水滴整理分享-永久免费(完整版).doc
12-02
教程提供了一个详细的架构模型，介绍了Android的应用框架、Dalvik虚拟机、集成的浏览器、优化的图形库、SQLite数据库以及多媒体支持等功能组件。 教程重点介绍了Android的应用框架，这是Android开发的核心部分。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值