实现基于注解（Annotation）的数据库框架（五）最终的实战

前言#

经过对基础知识的学习和积累，终于到了最后的实战，自定义数据库框架。框架的使用方法是参考一些流行的数据库框架，例如Litepal。

正文#

首先，我们来梳理一下我们这个框架的流程图：

这里写图片描述

首先从数据库的初始化开始，我们先定义xml的解析格式：

    
    Test
    
    1

    
    
        com.lzp.sqlframedemo.bean.Student
    

里面包含了数据库的名称，版本号，和要建表的类的路径。

在SQLFrame框架中完成xml的解析，并完成数据库的创建。

/**
     * 初始化数据库
     */
    public static void initSQLite(Context context) throws SQLiteInitException {

        // 解析xml文件，获取数据库相关配置（名称，版本号，表）
        String databaseName = null;
        String version = null;
        ArrayList tables = new ArrayList<>();
        try {
            XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
            XmlPullParser parser = factory.newPullParser();
            // 读取指定的xml
            parser.setInput(context.getResources().getAssets().open("SQLFrame.xml"), "utf-8");

            // 在assets中读取xml 只能用open方法，否则会出现FileNotFound异常
//          parser = context.getResources().getAssets().openXmlResourceParser("SQLFrame.xml");

            int eventType = parser.getEventType();
            // 如果解析的表示不是文件的结束标签，循环读取这些标签
            while (eventType != XmlPullParser.END_DOCUMENT) {
                // 解析标签的名称
                String nodeName = parser.getName();
                switch (eventType) {
                    // 开始标签
                    case XmlPullParser.START_TAG:
                        // 数据库名称
                        if (nodeName.equals("name")) {
                            databaseName = parser.nextText();
                        }
                        // 数据库版本号
                        else if (nodeName.equals("version")) {
                            version = parser.nextText();
                        }
                        // 数据库的表
                        else if (nodeName.equals("item")) {
                            tables.add(parser.nextText());
                        }
                        break;
                    // 结束标签
                    case XmlPullParser.END_TAG:
                        break;

                    default:
                        break;
                }

                // 解析下一个标签
                eventType = parser.next();
            }
        } catch (XmlPullParserException | IOException e) {
            e.printStackTrace();
            // 抛出数据库初始化异常
            throw new SQLiteInitException("please check the SQLFrame.xml has defined right!!!");
        }

        // 检查是否设置了数据库名称和版本号，否则抛出数据库初始化异常
        if (databaseName == null || version == null) {
            throw new SQLiteInitException("please check the SQLFrame.xml has defined right!!!");
        }

        // 初始化数据库
        SQLFrameOpenHelper sqlFrameOpenHelper = new SQLFrameOpenHelper(context, databaseName, null, Integer.parseInt(version));
        sqLiteDatabase = sqlFrameOpenHelper.getWritableDatabase();
        // 循环建表
        for (String className : tables) {
            try {
                createTable(Class.forName(className));
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

通过反射创建表：

/**
     * 创建table
     *
     * @param clazz 通过参数类的注解，来创建指定的table
     */
    private static void createTable(Class clazz) {
        try {
            checkSqlInit();

            StringBuilder sql = new StringBuilder("create table if not exists ");

            // 先拿到table的名称
            Table table = clazz.getAnnotation(Table.class);
            sql.append(table.value());
            sql.append("(");

            // 获取所有要创建的table字段
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                Column column = field.getAnnotation(Column.class);
                if (column != null) {
                    sql.append(column.field());
                    sql.append(" ");
                    sql.append(column.type());
                    sql.append(",");
                }
            }
            // 把最后的逗号去掉
            sql.deleteCharAt(sql.length() - 1);
            sql.append(")");
            sqLiteDatabase.execSQL(sql.toString());
        } catch (SQLiteNotInitException e) {
            e.printStackTrace();
        }
    }

通过反射获取@Table，得到表的名称，再反射得到Class的被注解的属性，得到表要创建的字段和字段的属性。

里面的注释已经非常详细了，没有什么可说的了。

初始化操作一般都是建议在Application中的，所以自定义SQLFrameApplication：

package com.lzp.sqlframe.application;

import android.app.Application;

import com.lzp.sqlframe.sqllite.SQLUtil;
import com.lzp.sqlframe.sqllite.SQLiteInitException;

/**
 * Created by li.zhipeng on 2017/3/15.
 *
 *      自定义Application
 */

public class SQLFrameApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();

        try {
            SQLUtil.initSQLite(this);
        } catch (SQLiteInitException e) {
            e.printStackTrace();
        }
    }
}

下一步就是自定义注解，并定义一个基类，这个基类有继承的增删改查的方法，实现对某个类的对象的操作。

ok，先定义两个注解，@Table和@Column。

package com.lzp.sqlframe.annotation;

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

/**
 * Created by li.zhipeng on 2017/3/10.
 *
 *  数据库表注解
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
    String value(); // 不给默认值，如果不是设置默认是Bean的类名
}

package com.lzp.sqlframe.annotation;

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

/**
 * Created by li.zhipeng on 2017/3/10.
 *
 *      数据库表字段注解
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
    /**
     * 字段名称
     * */
    String field();

    /**
     * 字段类型
     * */
    String type();
}

注解已经写好了，接下来就是想办法实现刚才说的基类了，我们命名为SQLFrameBaseBean，因为仅仅是参考学习，所以我这里就只写了保存（save）方法，其他方法（修改，删除）的作为练习，留给大家。看一下代码：

package com.lzp.sqlframe.sqllite;

import com.lzp.sqlframe.annotation.Column;
import com.lzp.sqlframe.annotation.Table;

import java.lang.reflect.Field;
import java.util.ArrayList;

import static com.lzp.sqlframe.sqllite.SQLUtil.checkSqlInit;

/**
 * Created by li.zhipeng on 2017/3/13.
 * 

 * 要保存到数据库中的bean的基类
 */

public class SQLFrameBaseBean {

    /**
     * 保存一个对象
     */
    public void save() {
        try {
            checkSqlInit();

            StringBuilder sql = new StringBuilder("insert into ");

            // 先拿到table的名称
            Table table = getClass().getAnnotation(Table.class);
            sql.append(table.value());
            sql.append("(");

            // 获取class中所有的属性
            Field[] fields = getClass().getDeclaredFields();

            StringBuilder fieldStr = new StringBuilder();
            StringBuilder valueStr = new StringBuilder();

            ArrayList