Android 手写数据库框架

Posted 2023-02-03 study_zhxu

前言

在android开发中，一定会遇到数据库sqlit的操作的，如果你的项目中没有用到数据库那么说明你的项目很失败。

一般我们可以直接使用系统提供的sqlit操作完成数据库的操作，同时也可以使用现在比较多的数据库开源框架，比如GreenDAO OrmLitem等数据库框架，都是直接将对象映射到sqlit数据库的ORM框架。

在这篇文章中我们将自己动手写一个ORM框架，自定义一个属于我们自己的ORM数据库框架。

原理分析

在Android中无论我们如何对数据库进行封装，最终操作都离不开sqlit自身对数据的增删改操作，所以我们需要将这些操作封装在底层，上层只需要传入对象调用相关方法即可，不用去管底层是如何做的，包括表的创建等。

好，下面我们来看看分析的图

从图中我们也可以看出来，手写数据库框架的主要内容就在中间部分，主要的有BaseDaoFactory和BaseDao这两个类。

但是在这些之前我们还有两个地方需要关注，就是数据库表的生成。在常用的数据库框架中如GreenDAO和ORMLitem等都是通过注解来生成表和字段的，那么在我们的框架中当然也采用这种方式来完成，下面就来看看代码吧

特此声明，如果是Android studio用户，在使用该库时请关闭Instant Run功能，具体什么原因可以自己手动尝试

注解

生成表的注解

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

生成字段的注解

@Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface DbFiled 
        String value() ;
    

这些注解该如何使用呢？

@DbTable("tb_common_user")
    public class User 

        @DbFiled("tb_name")
        public String name ;

        @DbFiled("tb_password")
        public String password ;

        @DbFiled("tb_age")
        public String age ;

    

我们只需要在JavaBean类和变量上标注即可，这样就可以生成对应的表名和字段名，具体如何生成的，我们会在下面讲到，如果对注解知识不是特别了解，那就需要加强一下Java基础了哦。

既然知道了注解生成表和字段并且知道如何使用后，下面我们就来看看Dao层的代码吧

BaseDaoFactory

具体的代码如下

public class BaseDaoFactory    
        /** 数据库路径 */
        private String sqliteDatabasePath ;

        /** 操作数据库 */
        private SQLiteDatabase sqLiteDatabase ; 

        private static BaseDaoFactory instance = null ;

        public static BaseDaoFactory getInstance()
            if(instance == null)
                synchronized (BaseDaoFactory.class)
                    instance = new BaseDaoFactory() ;
                
            
            return instance ;
           

        private BaseDaoFactory()
            //获取数据库路径
            sqliteDatabasePath = Environment.getExternalStorageDirectory().getAbsolutePath()+"/user.db" ;
            //打开数据库
            openDatabase();
        

        /**
         * 获取DataHelper
         * @param clazz         BaseDao的子类字节码
         * @param entityClass   要存入对象的字节码
         * @param <T>
         * @param <M>
         * @return
         */
        public synchronized <T extends BaseDao<M>,M> T getDataHelper(Class<T> clazz,Class<M> entityClass)
            T dao = null ;
            //获取对象
            try 
                dao = clazz.newInstance() ;
                dao.init(entityClass,sqLiteDatabase) ;

             catch (InstantiationException e) 
                e.printStackTrace();
             catch (IllegalAccessException e) 
                e.printStackTrace();
               
            return dao;
        

        /**
         * 打开或创建数据库
         */
        private void openDatabase() 
            this.sqLiteDatabase = SQLiteDatabase.openOrCreateDatabase(sqliteDatabasePath,null) ;
           
    

BaseDaoFactory代码内容不是太多，好，接下来我们就具体分析吧。

可以看出BaseDaoFactory采用单例的方式，用来生成Dao对象的。主要方法有两个openDatabase()和getDataHelper()方法，openDatabase()方法是负责获取sqliteDatabase对象的，因为sqlit底层操作需要这个对象。

getDataHelper()中只做了两件事，创建爱你Dao层对象，并且调用dao的init()方法。所以要想使用Dao我们只需要调用getDataHelper()方法传入我们想要使用的Dao，BaseDaoFactory会帮我们生成。

其中getDataHelper需要两个泛型参数，可能会让人有些费解，那我们就来看看这些泛型参数的含义

public synchronized <T extends BaseDao<M>,M> T getDataHelper(Class<T> clazz,Class<M> entityClass)
        .....
    

因为在这个框架中，所有的Dao层都一个基类，就是BaseDao，所以通过

BaseDao

首先看看IBaseDao代码

IBaseDao代码如下

public interface IBaseDao<T> 
        /**
         * 插入一个对象到数据库
         * @param entity 要插入的对象
         * @return
         */
        public Long insert(T entity) ;

        /**
         * 更新
         * @param entity
         * @param where
         * @return
         */
        public int update(T entity ,T where) ;

        /**
         * 删除
         * @param where
         * @return
         */
        public int delete(T where);

        /**
         * 查询
         * @param where
         * @return
         */
        public List<T> query(T where) ;

        public List<T> query(T where,String orderBy,Integer startIndex,Integer limit) ;
    

BaseDao代码如下

public class BaseDao<T> implements IBaseDao<T> 

        /** 持有数据库操作类的引用 */
        private SQLiteDatabase database ;

        /** 保证实例化一次 */
        private boolean isInit = false ;

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

        /** 表名 */
        private String tableName ;

        /** 维护表名与成员变量的映射关系 */
        private HashMap<String,Field> cacheMap ;

        /** 初始化 */
        protected boolean init(Class<T> entity,SQLiteDatabase sqLiteDatabase)

            this.entityClass = entity ;
            if(!isInit)
                this.database = sqLiteDatabase ;
                //判断注解是否为null
                if(entity.getAnnotation(DbTable.class) == null)
                    this.tableName = entity.getClass().getSimpleName() ;
                else 
                    this.tableName = entity.getAnnotation(DbTable.class).value();
                

                //检查数据库是否打开
                if(!database.isOpen())
                    return false ;
                

                //执行sql语句创建表
                if(!TextUtils.isEmpty(createTable()))
                    database.execSQL(createTable());
                
                initCacheMap();

                isInit = true ;

            

            return isInit ;
        
        ........
    

通过init()方法我们可以看出来，之前定义的注解这这里得到了使用，通过传入的对象获取注解和值，然后得到表名。这里还调用了两个方法，createTable和initCacheMap方法。

createTable是创建表的方法具体代码如下

/**
     * 获取创建数据库表的sql
     * @return
     */
    private String createTable()

        HashMap<String,String> columMap = new HashMap<>();

        Field[] fields = entityClass.getFields();
        for(Field field : fields)
            field.setAccessible(true);
            DbFiled dbFiled = field.getAnnotation(DbFiled.class);
            if(dbFiled == null)
                columMap.put(field.getName(),field.getName());
            else 
                columMap.put(field.getName(),dbFiled.value());
            
        

        //创建数据库语句
        String sql = "create table if not exists "+ tableName + "(" ;
        Set<String> keys = columMap.keySet();
        StringBuilder sb = new StringBuilder() ;
        for(String key : keys)
            String value = columMap.get(key);
            sb.append(value).append(" varchar(20)").append(",");
        
        String s = sb.toString();
        s = s.substring(0,s.lastIndexOf(",")) + ")" ;
        //拼接sql语句
        sql = sql + s ;
        return sql ;
    

通过代码我们也可以看出来在createTable()方法中我们通过获取变量上的注解获取到表中的列名然后拼接成sql语句，然后调用这个sql语句创建表。

还有一个initCacheMap()方法代码如下

/** 维护映射关系 */
    private void initCacheMap() 
        Cursor cursor = null ;

        try 
            /**
             * map集合中
             * key  列名
             * map  变量对象
             *
             * 主要功能是找到列名对应的变量对象，便于后续的使用等
             */
            cacheMap = new HashMap<>();
            //1 第一步需要查询一遍表获取列名
            String sql = "select * from " + this.tableName ;
            cursor = database.rawQuery(sql, null);

            //获取表的列名数组
            String[] columnNames = cursor.getColumnNames();
            //获取Field数组
            Field[] columnFields = entityClass.getFields();

            for (Field field : columnFields) 
                field.setAccessible(true);
            

            //查找对应关系
            for (String colmunName : columnNames) 
                Field columField = null;
                for (Field field : columnFields) 
                    String fieldName = null;
                    //获取注解
                    DbFiled dbFiled = field.getAnnotation(DbFiled.class);
                    if (dbFiled != null) 
                        fieldName = dbFiled.value();
                     else 
                        fieldName = field.getName();
                    
                    //如果找到对应表的列名对应的成员变量
                    if (colmunName.equals(fieldName)) 
                        columField = field;
                        break;
                    
                
                //找到对应关系
                if (columField != null) 
                    cacheMap.put(colmunName, columField);
                
            
        catch (Exception e)

        finally 
            if(cursor != null)
                cursor.close() ;
        
    

在initCacheMap()方法中就做了一件事，将列名和对应的变量对象存入到map集合中，在之后会使用到。

下面我们就来看看具体的数据库操作方法吧。

保存数据

首先insert方法代码如下

@Override
    public Long insert(T entity) 
        Map<String, String> map = getValues(entity);

        ContentValues values = getContentValues(map);
        long insert = database.insert(tableName, null, values);
        return insert;
    

通过代码我们可以看出来getValues()方法是将对象转换成Map集合，getContentValues()方法是将map集合转换成ContentValues，得到ContentValues对象后，我们就可以直接调用database.insert()方法插入数据了。

那我们来看看getValues()方法和getContentValues()方法吧

getValues()代码如下

/** 将对象转换成map集合 */
    private Map<String,String> getValues(T entity)
        /**
         * 集合
         * key 列名也是变量上的注解值
         * value 变量的具体值
         */
        HashMap<String,String> result = new HashMap<>() ;
        Iterator<Field> fieldIterator = cacheMap.values().iterator();
        //循环遍历映射表  遍历cacheMap得到列名和其对应的变量对象（cacheMap中存入的是列名和对象的映射）
        while(fieldIterator.hasNext())
            //得到成员变量
            Field colmunToField = fieldIterator.next();
            //定义变量用于存储变量上注解的值，也就是列名
            String cacheKey = null ;
            //定义变量用于存储变量的具体值
            String cacheValue = null ;
            //获取列名
            if(colmunToField.getAnnotation(DbFiled.class) != null)
                cacheKey = colmunToField.getAnnotation(DbFiled.class).value();
            else 
                cacheKey = colmunToField.getName();
            
            try 
                if(colmunToField.get(entity) == null)
                    continue;
                
                //得到具体的变量的值
                cacheValue = colmunToField.get(entity).toString();
             catch (IllegalAccessException e) 
                e.printStackTrace();
            
            result.put(cacheKey,cacheValue) ;
        
        return result ;
    

具体getValues()是如何将对象转换成Map集合的这里就不再多说了，代码中注释写的比较清楚，就是通过获取注解和反射获取变量的具体值。

getContentValues()方法代码如下

/**
     * 将map转换成ContentValues
     * @param map
     * @return
     */
    private ContentValues getContentValues(Map<String, String> map) 
        ContentValues values = new ContentValues() ;
        for(String key : map.keySet())
            values.put(key,map.get(key));
        
        return values;
    

这个方法就比较简单了，就是遍历map集合完成操作。

通过上面的分析基本上就可以理清楚思路了，也知道如何完成数据库表的创建和数据的保存了。接下来接看看数据的修改吧

修改数据

@Override
    public int update(T entity, T where) 
        int result = -1 ;
        //将修改的结果转换成Map集合
        Map<String, String> map = getValues(entity);
        //将修改的条件转换成Map集合
        Map<String, String> whereClause = getValues(where);
        //得到修改的条件语句
        Condition condition = new Condition(whereClause);

        ContentValues contentValues = getContentValues(map);
        result = database.update(tableName, contentValues, condition.getWhereClause(), condition.getWhereArgs());

        return result;
    

修改代码中除了使用了前面讲到了getValues()方法和getContentVlaues()方法外还用到了Condition。

Condition代码如下

/**
     * 封装修改的语句
     */
    class Condition 
        private String whereClause ;

        private String[] whereArgs ;

        public Condition(Map<String, String> whereClause) 
            ArrayList<String> list = new ArrayList<>() ;
            StringBuilder sb = new StringBuilder() ;

            sb.append("1=1") ;
            for(String key : whereClause.keySet())
                String value = whereClause.get(key);
                if(value != null)
                    //拼接条件查询语句
                    sb.append(" and ").append(key).append(" =?");
                    //查询条件
                    list.add(value);
                
            
            this.whereClause = sb.toString() ;
            this.whereArgs = list.toArray(new String[list.size()]);
        

        public String getWhereClause() 
            return whereClause;
        

        public String[] getWhereArgs() 
            return whereArgs;
        
    

Condition是一个队修改语句的封装，类中通过拼接和转换获取到修改的条件语句和参数。

删除数据

@Override
    public int delete(T where) 
        Map<String, String> map = getValues(where);
        Condition condition = new Condition(map) ;
        int result = database.delete(tableName, condition.getWhereClause(), condition.getWhereArgs());
        return result;
    

删除代码比较简单，也是调用了getValues()方法将条件对象转换成Map集合，然后通过Condition将集合装换成删除的条件语句和参数。

查询数据

@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) 

        Map<String, String> map = getValues(where);
        String limitStr = null ;
        if(startIndex != null && limit != null)
            limitStr = startIndex + " , " + limit ;
        

        Condition condition = new Condition(map) ;
        Cursor cursor = database.query(tableName, null, condition.getWhereClause(), condition.getWhereArgs(), null, null, orderBy, limitStr);
        List<T> result = getResult(cursor,where);

        return result;
    

首先上面两个方法主要的是第二个，在代码中首先根据条件获取到了cursor对象，然后通过getResult()方法和cursor得到了最终对象集合

getResult代码如下

/** 获取查询结果 */
    private List<T> getResult(Cursor cursor, T where) 
        List<T> list = new ArrayList<>() ;

        //定义变量用于接收查询到的数据
        T item ;
        while(cursor.moveToNext())
            try 
                //通过反射初始化对象
                item = (T) where.getClass().newInstance();


                //下面循环对变量名进行赋值
                /**
                 * cacheMap中缓存的是
                 * key      列名
                 * value    成员变量名
                 *
                 */
                for(String key : cacheMap.keySet()) 
                    //得到数据库表中的列名
                    String columnName = key;
                    //然后通过列名获取游标的位置
                    int columnIndex = cursor.getColumnIndex(columnName);
                    //获取到对象中的成员变量名称
                    Field field = cacheMap.get(key);
                    //获取成员变量的类型
                    Class type = field.getType();

                    //反射方式给item中的变量赋值
                    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 == 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;
    

首先我们知道数据库中查询到的内容都在cursor中，所以我们只需要遍历cursor就可以获取到我们想要的内容，因为cursor中获取到的值需要赋值给对象，所以我们手动创建了T类型的对象，因为这个对象不确定，所以我们通过泛型表示。在之前的initCacheMap()方法中我们已经获取到了对象内部的变量名和表中的列名，所以可以通过反射获取到变量的类型，并对其进行赋值。

这样就完成了对变量的赋值了，最后将对象存入到list集合中然后返回。

OK完成

使用

上面将框架的各个知识点讲完了还没有具体的使用呢，所以接下里我们就来使用我们手撸的框架

User类代码如下

@DbTable("tb_common_user")
    public class User 

        @DbFiled("tb_name")
        public String name ;

        @DbFiled("tb_password")
        public String password ;

        @DbFiled("tb_age")
        public String age ;

    

UserDao代码如下

public class UserDao extends BaseDao<User> 
    

MainActivity代码如下

public class MainActivity extends AppCompatActivity 

        @Override
        protected void onCreate(Bundle savedInstanceState) 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        

        //保存
        public void save(View view)

            Random random = new Random() ;

            UserDao userDao = BaseDaoFactory.getInstance().getDataHelper(UserDao.class, User.class);
            User user = new User();
            user.name = "lilei" ;
            user.password = "abc" ;
            user.age = random.nextInt() % 2 == 0 ? "男" : "女" ;
            userDao.insert(user);
        

        //更新
        public void update(View view)
            UserDao userDao = BaseDaoFactory.getInstance().getDataHelper(UserDao.class, User.class);

            //更新条件
            User where = new User() ;
            where.name = "lilei" ;

            //更新为
            User user = new User() ;
            user.name = "hanmeimei" ;
            userDao.update(user,where);
        

        //删除
        public void delete(View view)
            UserDao userDao = BaseDaoFactory.getInstance().getDataHelper(UserDao.class, User.class);

            //删除条件
            User where = new User() ;
            where.name = "hanmeimei";
            userDao.delete(where);
        

        //查询
        public void query(View view)
            UserDao userDao = BaseDaoFactory.getInstance().getDataHelper(UserDao.class, User.class);

            User where = new User() ;
            where.name = "lilei" ;
            where.age = "女" ;
            List<User> query = userDao.query(where);

            for(User user : query)
                System.out.println("name:"+user.name+",age:"+user.age+",password:"+user.password);
            
        
    

好了结果我就不展示了，一遍通过。

总结

通过上面的讲解，发现手写一个数据库其实也不是很难，当然这个框架有很多的不足的地方，但是至少让我们了解了如何手动撸一个自己的数据库框架，了解了数据库框架的原理。之后如果有什么想法当然可以在此基础上再添加。

最后代码地址https://github.com/studyzhxu/zhxuSqlit

QQ交流群

微信公众号：Android在路上，欢迎关注