android自己动手封装Sqllite数据库

废话:

android数据库框架现在特别多,比如greenDAO,litepal都是各个大神封装好的,有时候自己只知道用,却不知道实现原理,于是自己准备动手撸一个。此框架是面向对象式数据库框架设计

  • 对于用户而言,调用一句话就可以实现增删改查的代码才是好代码,基于这种考虑,我们的框架必不可少使用泛型、反射、注解、等操作,建议大家先了解一下这些java的基本操作。
  • 首先创建一个Bean类(模拟用户插入数据库的类)
//比如说User表  字段:id name password
public class User {
    private Integer id;
    private String name;
    private String password;
}
既然是创建表,用户想自定义自己的字段名称和表名,那么我们就用注解去标志,在创建表或字段的时候,如果有注解,那么就取注解中的名称,反之直接取bean中默认的字段名称。

新建表名的注解

/**
 *
 * 用来控制表名叫做什么的注解类
 */
@Target(ElementType.TYPE)//注解方法的
@Retention(RetentionPolicy.RUNTIME)//保留位置 必须运行时 执行过程 获取相关信息
public @interface DbTable {
    String value();
}
/**
 *
 * 用来控制字段名称叫做什么的注解类
 */
@Target(ElementType.FIELD)//注解方法的
@Retention(RetentionPolicy.RUNTIME)//保留位置 必须运行时 执行过程 获取相关信息
public @interface DbField {
    String value();
}

那么我们的Bean类 如果想自定义表名,和自定义一些字段名称,可以改成

@DbTable("tb_user")
public class User {
    @DbField("_id")
    private Integer id;
    private String name;
    private String password;
}

好了,接下来,我们提供一个顶层接口类,此类的意义在于,给用户提供整体功能的一个接口类 我们封装增、删、改、查的具体实现,用户只需调用想用的功能,传入一些定制化参数

/**
 * 封装操作功能的接口类
 */

public interface IBaseDao {
    long insert(T entity);

//    int delete(String where);
//
//    long update(T entity, String where);
//
//    List query(String where);
//
//    List query(String where, String orderBy, Integer startIndex, Integer limit);
//
//    List query(String sql);

}

然后,我们则实现insert操作。插入操作,我们必须先自动创建一个表,并且类中持有数据库的引用,对数据库操作,然后我们获取表名,字段,因为字段是外部传入,我们可以使用T泛型拿到,但是不灵活,此处我使用了Class拿到字节码进行操作 更方便。

/**
 * 1.完成自动建表功能
 */

public class BaseDao implements IBaseDao {
    //持有数据库的引用 对于数据库操作
    private SQLiteDatabase sqLiteDatabase;
    //表名
    private String tableNmae;
    //持有操作数据库所对应的java类型
    private Class entityClass;
    //标识:用来标识是否做过初始化操作
    private boolean isInit = false;

    //框架内部逻辑,最好不要提供构造方法给调用层调用
//    public BaseDao(SQLiteDatabase sqLiteDatabase, Class entityClass) {
//        this.sqLiteDatabase = sqLiteDatabase;
//        this.entityClass = entityClass;
//    }
    public boolean init(SQLiteDatabase sqLiteDatabase, Class entityClass) {
        this.sqLiteDatabase = sqLiteDatabase;
        this.entityClass = entityClass;
        //根据传入的entityClass来建立表,只需建立一次
        if (!isInit) {
            isInit = true;
            //自动建表
            //取到表名 判断表上有没有自定义注解类名
            if (entityClass.getAnnotation(DbTable.class) == null) {
                //反射到类名
                tableNmae = entityClass.getSimpleName();
            } else {
                //取注解上的名字
                tableNmae = entityClass.getAnnotation(DbTable.class).value();
            }
            if (!sqLiteDatabase.isOpen()) {
                return false;//数据库没打开 初始化失败
            }
            //执行建表操作
            //create table if not exists tb_user(_id integer,name varchar2(20),password varchar(20))
            //单独用个方法生成create命令
            String createTableSql = getCreateTableSql();
            sqLiteDatabase.execSQL(createTableSql);

        }

        return isInit;
    }
}


获取到了表名,建表之前,获取传入实体类所有成员变量类型。

    private String getCreateTableSql() {
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("create table if not exists ");
        stringBuffer.append(tableNmae + "(");
        //反射得到所有的成员变量
        Field[] fields = entityClass.getDeclaredFields();
        for (Field field : fields) {
            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();
        }
     

到此,此处我们的建表操作已经写好,但是如何提供给用户使用呢,那么我们将再写一个工厂类,用户调用工厂类,工厂类调用实现方法,则实现创表操作。

public class BaseDaoFactory {
    private static final BaseDaoFactory ourInstance = new BaseDaoFactory();

    public static BaseDaoFactory getOurInstance() {
        return ourInstance;
    }

    private SQLiteDatabase sqLiteDatabase;
    //定义建数据数据的路径
    //建议写在SD卡中 好处APP删了 下次安装 数据还在
    private String sqliteDatabasePath;

    private BaseDaoFactory() {
        //内置sd卡路径
        String sqlitePath = createSDCardOrOpenDir() + "/dao.db";
        if (sqlitePath == null) {
            //SD卡不存在
            return;
        }
        sqLiteDatabase = SQLiteDatabase.openOrCreateDatabase(sqlitePath, null);
    }

    public String createSDCardOrOpenDir() {
        if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
            // 创建一个文件夹对象,赋值为外部存储器的目录
            File sdcardDir = Environment.getExternalStorageDirectory();
            //得到一个路径,内容是sdcard的文件夹路径和名字
            String path = sdcardDir.getPath() + "/dbImage";
            File newpath = new File(path);
            if (!newpath.exists()) {
                //若不存在,创建目录,可以在应用启动的时候创建
                newpath.mkdirs();
            }
            return path;

        } else {
            return null;
        }

    }

    public  BaseDao getBaseDao(Class entityClass) {
        BaseDao baseDao = null;
        try {
            baseDao = BaseDao.class.newInstance();
            baseDao.init(sqLiteDatabase, entityClass);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return baseDao;
    }

//此处测试一下 测试

   BaseDao baseDao = BaseDaoFactory.getOurInstance().getBaseDao(User.class);
        Toast.makeText(this, "执行成功", Toast.LENGTH_SHORT);
  • CRUD操作 必不可少需要成员变量获取字段和值等,此处反射太耗时,我们整体写一个缓存参数,将成员变量和数据库的字段缓存起来,方便下次对对象操作可以直接从缓存里取数据
  //CacheMap  键值对  对应着 字段 》成员变量
  private HashMap cacheMap; 

  private void initCacheMap() {
        //获取所有列名 空表
        String sql = "select * from " + tableNmae + " limit 1,0";
        Cursor cursor = sqLiteDatabase.rawQuery(sql, null);
        String[] columnNames = cursor.getColumnNames();//获取所有字段名字
        //获取成员变量
        Field[] fields = entityClass.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);//把字段设置可写;
        }
        for (String columnName : columnNames) {//循环字段
            Field columField = null;
            for (Field field : fields) {//循环成员变量
                String fieldName = null;
                if (field.getAnnotation(DbField.class) != null) {
                    fieldName = field.getAnnotation(DbField.class).value();
                } else {
                    fieldName = field.getName();
                }
                if (fieldName.equals(columnName)) {//
                    columField = field;
                    break;
                }
            }
            cacheMap.put(columnName, columField);
        }

        //把字段和成员变量映射起来

    }

并且将初始化操作 放入init方法中。

  • Insert方法定义
    在顶层接口中,定义一个insert(T entity)方法 在BaseDao去实现
    普通插入方法: sqLiteDatabase.insert(tableNmae,null,contentValues)
    contentValues对应的则是插入对象的数据。
    封装思路:第一步先从cacheMap获取数据 并且将值传入一个MAP,然后将MAP再封装到ContentValues,此处之所以不直接用cacheMAp封装到ContentValues,因为后面会时常用到Map。
 private Map getValues(T entity) {
        Map resultMap = new HashMap<>();
        //获取传入类的key  values
        Iterator iterator = cacheMap.values().iterator();
        while (iterator.hasNext()) {
            Field field = iterator.next();
            try {
                Object object = field.get(entity);//获取成员变量的值
                String value = object.toString();
                if (object == null) {
                    continue;
                }
                String key = null;
                //获取key
                if (field.getAnnotation(DbField.class)!= null) {
                    key = field.getAnnotation(DbField.class).value();
                } else {
                    key = field.getName();
                }
                if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(value)) {
                    resultMap.put(key, value);
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return resultMap;
    }

   private ContentValues getContentValues(Map map) {
        ContentValues contentValues = new ContentValues();
        Set keys = map.keySet();
        Iterator iterator = keys.iterator();
        while (iterator.hasNext()) {
            String key = iterator.next();
            String value = map.get(key);
            if (value != null) {
                contentValues.put(key, value);
            }
        }
        return contentValues;

    }

BaseDao实现类就可以

    public long insert(T entity) {
        Map map = getValues(entity);
        ContentValues contentValues = getContentValues(map);
        long result = sqLiteDatabase.insert(tableNmae, null, contentValues);
        return result;
    }

测试:

   public void insertObject(View view) {
        BaseDao baseDao = BaseDaoFactory.getOurInstance().getBaseDao(Person.class);
        baseDao.insert(new Person("lcx",24));
        Toast.makeText(this, "执行成功", Toast.LENGTH_SHORT).show();
    }

这是插入操作,接下来 我们可以进行 修改+删除操作

  • 修改
    正常修改操作:
sqLiteDatabase.update(tableNmae,contentvalues,"name=?",new String[] {"lcx"})

那么我们定义一个方法

 public long update(T entity, T where) {}

entity 传入修改的对象
where 代表修改的条件

tatableNmae获取得到,contentvalues也可以获取到,通过cacheMap获取缓存的成员变量,再通过成员获取传入entity的值,最后封装到ContentValues,
和insert一个道理,然后具体条件,我们将定义一个内部类,写个构造,传入修改的MAp值,这样我们就可以得到 “name=?" 和条件的值

 public class Condition {
        private String whereCause;
        private String[] whereArgs;

        public Condition(Map whereCause) {
            ArrayList arrayList = new ArrayList();
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("1=1");
            //取所有字段值
            Set keys = whereCause.keySet();
            Iterator iterator = keys.iterator();
            while (iterator.hasNext()) {
                String key = (String) iterator.next();
                String value = whereCause.get(key);
                if (value != null) {
                    stringBuilder.append(" and " + key + "=?");
                    arrayList.add(value);
                }
            }
            this.whereCause = stringBuilder.toString();
            this.whereArgs = (String[]) arrayList.toArray(new String[arrayList.size()]);
        }

        ;

最后我们的修改操作代码 是这样的

public long update(T entity, T where) {
//        UPDATE Person SET FirstName = 'Fred' WHERE LastName = 'Wilson'
//        sqLiteDatabase.update(tableNmae,contentvalues,"name=?",new String[] {"lcx"})
      long result = -1;
      Map map = getValues(entity);
      ContentValues contentValues = getContentValues(map);
      //定义内部类  用来拼接修改参数及条件
      Map whereCause = getValues(where);
      Condition condition = new Condition(whereCause);
      sqLiteDatabase.update(tableNmae, contentValues, condition.whereCause, condition.whereArgs);
      return result;
  }
  • 删除
    既然修改出来了 删除就更简单啦
    @Override
    public long delete(T where) {
//        sqLiteDatabase.delete(tableNmae,whrerClause,whereArgs);
        Map map = getValues(where);
        Condition condition = new Condition(map);
        long result = sqLiteDatabase.delete(tableNmae, condition.whereCause, condition.whereArgs);
        return result;

  • 查询
    查询的话 相比较删除和修改稍微复杂一些,因为涉及查询到的数据动态转化集合对象。
    正常查询
 sqLiteDatabase.query(tableName,null,"id=?",new String[],null,null,orderBy,"1,5");

封装:

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

    @Override
    public List query(T where, String orderBy, Integer startIndex, Integer limit) {
        //        sqLiteDatabase.query(tableName,null,"id=?",new String[],null,null,orderBy,"1,5");
        Map map = getValues(where);
        String limitString = null;
        if (startIndex != null && limit != null) {
            limitString = startIndex + " , " + limit;
        }
        Condition condition = new Condition(map);

        Cursor cursor = sqLiteDatabase.query(tableNmae, null, condition.whereCause, condition.whereArgs, null, null, orderBy, limitString);
        //定义一个用来解析游标的方法
        List result = getResult(cursor, where);
        return result;
    }

主要涉及到对象转换。
循环查询出的游标,实例化传入对象,然后获取缓存的所有Map 字段-成员变量,然后循环,得到数据库字段,获取字段在游标位置,获取成员变量,通过成员变量获取属性,判断并进入对应各个属性,动态设置Field的值。最后将对象添加集合 并返回集合数据

 //obj是用来表示User类的结构
    private List getResult(Cursor cursor, T obj) {
        ArrayList list = new ArrayList();
        Object item = null;
        while (cursor.moveToNext()) {
            try {
                item = obj.getClass().newInstance();//new User();
                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();
                    Class type = field.getType();

                    if (columnIndex != -1) {
                        if (type == String.class) {
                            field.set(item, cursor.getString(columnIndex));//set(Object obj, Object value) : 向obj对象的这个Field设置新值value
                        } 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();
            }
        }
        cursor.close();
        return list;
    }

此处,CURD 雏形已成,扩展一下,将工厂类生产BaseDao的扩展下,传入俩泛型,M代表传入的User对象 T代表BaseDao,为了更灵活调用。

  public  ,M> T  getBaseDao(Class daoClass,Class entityClass){
        BaseDao baseDao=null;
        try {
            baseDao=daoClass.newInstance();
            baseDao.init(sqLiteDatabase,entityClass);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return (T)baseDao;
    }

记得测试下


public class MainActivity extends AppCompatActivity {

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

    public void insertObject(View view) {
        IBaseDao baseDao = BaseDaoFactory.getOurInstance().getBaseDao(BaseDaoNewImpl.class, User.class);
        baseDao.insert(new User(6, "abcd", "123"));
        Toast.makeText(this, "执行成功!", Toast.LENGTH_SHORT).show();
    }


    private static final int REQUEST_EXTERNAL_STORAGE = 1;
    private static String[] PERMISSIONS_STORAGE = {
            "android.permission.READ_EXTERNAL_STORAGE",
            "android.permission.WRITE_EXTERNAL_STORAGE"};


    public static void verifyStoragePermissions(Activity activity) {

        try {
            //检测是否有写的权限
            int permission = ActivityCompat.checkSelfPermission(activity,
                    "android.permission.WRITE_EXTERNAL_STORAGE");
            if (permission != PackageManager.PERMISSION_GRANTED) {
                // 没有写的权限,去申请写的权限,会弹出对话框
                ActivityCompat.requestPermissions(activity, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void updateObject(View view) {
        BaseDaoNewImpl baseDao = BaseDaoFactory.getOurInstance().getBaseDao(BaseDaoNewImpl.class, User.class);
        //update tb_user where name='jett' set password='1111'
        User user = new User();
        user.setName("abcd");
        User where = new User();
        where.setId(6);
        baseDao.update(user, where);
        Toast.makeText(this, "执行成功!", Toast.LENGTH_SHORT).show();
    }

    public void deleteObject(View view) {
        BaseDao baseDao = BaseDaoFactory.getOurInstance().getBaseDao(BaseDaoNewImpl.class, User.class);
        User where = new User();
        where.setName("abcd");
        where.setId(6);
        baseDao.delete(where);
    }

    public void queryObject(View view) {
        BaseDaoNewImpl baseDao = BaseDaoFactory.getOurInstance().getBaseDao(BaseDaoNewImpl.class, User.class);
        User where = new User();
        where.setName("abcd");
        List list = baseDao.query(where);
        Log.i("jett", "listsize=" + list.size());
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i) + " i=" + i);
        }
    }
}

数据库Demo:链接:https://pan.baidu.com/s/1SHTcCgzXpFkNd-ZHRrmZgg 密码:hohw

  • 多用户分库

接下来,我们设计一个多用户分库功能。就是说每一个用户数据库都是独立的,这些大厂设计都是这样的,每一个用户对应不同数据库。

首先 为了方便BaseDao不生成多个实例,我们把原本生成数据库实例的方法改下

////设计一个数据库连接池                                                                                       
private Map hashMap = Collections.synchronizedMap(new HashMap());  

 public , M> T getBaseDao(Class daoClass, Class entityClass) {      
     BaseDao baseDao = null;                                                                   
     try {                                                                                     
         if (hashMap.get(daoClass.getSimpleName()) != null) {                                  
             return (T) hashMap.get(daoClass.getSimpleName());                                 
         }                                                                                     
         baseDao = BaseDao.class.newInstance();                                                
         baseDao.init(sqLiteDatabase, entityClass);                                            
         hashMap.put(daoClass.getSimpleName(), baseDao);                                       
     } catch (InstantiationException e) {                                                      
         e.printStackTrace();                                                                  
     } catch (IllegalAccessException e) {                                                      
         e.printStackTrace();                                                                  
     }                                                                                         
     return (T) baseDao;                                                                       
 }                                                                                             

分库的实现步骤

  • 获取当前登录用户 以及重写一个插入方法(此方法可在新用户登录时候调用 把其余用户状态设置离线状态 新用户为在线状态)
public class UserDao extends BaseDao {
    @Override
    public long insert(User entity) {
        //查询表中所有的用户记录
        List list = query(new User());
        User where = null;
        for (User user : list) {
            where = new User();
            where.setId(user.getId());
            user.setStatus(0);
            Log.i("lcx", "用户" + user.getName() + "更改为未登录状态");
            update(user, where);
        }
        Log.i("lcx", "用户" + entity.getName() + "登录");
        entity.setStatus(1);
        return super.insert(entity);
    }

    /**
     * 得到当前的登录用户
     */
    public User getCurrLoginUser() {
        User user = new User();
        user.setStatus(1);
        List list = query(user);
        if (list.size() > 0) {
            return list.get(0);
        }
        return null;
    }
}
  • 定义一个枚举类 用来产生当前用户的数据库地址
用于产生私有数据库在存放位置
 /**
 * 用于产生私有数据库在存放位置
 */
public enum PrivateDataBaseEnums {
    database("");
    private String value;

    PrivateDataBaseEnums(String value) {

    }

    //用于产生路径
    public String getValue() {
        UserDao userDao = BaseDaoFactory.getOurInstance().getBaseDao(UserDao.class, User.class);
        if (userDao != null) {
            User currUser = userDao.getCurrLoginUser();
            if (currUser != null) {
                File sdcardDir = Environment.getExternalStorageDirectory();
                //得到一个路径,内容是sdcard的文件夹路径和名字
                String path = sdcardDir.getPath() + "/dbImage";
                File file = new File(path);
//                File file = new File("/data/data/com.example.a48608.ls4_databaseframework_20180307");
                if (!file.exists()) {
                    file.mkdirs();
                }
                ///data/data/com.example.a48608.ls4_databaseframework_20180307/n0003_login.db
                return file.getAbsolutePath() + "/" + currUser.getId() + "_login.db";
            }
        }
        return null;
    }
}
  • 定义一个工厂类 生产具体用户的数据库信息
    //这个用来生成不同对象的数据库地址
    public , M> T getSubDao(Class daoClass, Class entityClass) {
        BaseDao baseDao=null;
        if(hashMap.get(PrivateDataBaseEnums.database.getValue())!=null){
            return (T) hashMap.get(PrivateDataBaseEnums.database.getValue());
        }
        Log.i("jett","生成数据库文件的位置:"+PrivateDataBaseEnums.database.getValue());
        subSqliteDatabase=SQLiteDatabase.openOrCreateDatabase(PrivateDataBaseEnums.database.getValue(),null);
        try {
            baseDao=daoClass.newInstance();
            baseDao.init(subSqliteDatabase,entityClass);
            hashMap.put(PrivateDataBaseEnums.database.getValue(),baseDao);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return (T) baseDao;
    }

测试

 BaseDao userDao;

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

/*模拟用户登录的  此处的insert是UserDao的insert  就是说把当前用户User为在线状态 其余为离线状态**/
   public void clickLogin(View view) {
        //服务器传回的信息
        User user = new User();
        user.setName("张三" + (++i));
        user.setPassword("123456");
        user.setId("N00" + i);
        //数据插入
        userDao.insert(user);
        Toast.makeText(this, "执行成功!", Toast.LENGTH_SHORT).show();

    }
/*执行这一步之前 我们已经知道了 当前用户,也已经实例化了UserDAO,那么根据这两点 执行枚举方法 得到当前用户数据库地址,然后打开或者创建当前用户数据库, 并且初始化。  接下来进行一个新增动作  就可以查看当前用户的数据库插入的表数据*/
 public void clickSubInsert(View view) {
        Photo photo = new Photo();
        photo.setPath("data/data/my.jpg");
        photo.setTime(new Date().toString());
        PhotoDao photoDao =  BaseDaoSubFactory.getOurInstance().getSubDao(PhotoDao.class, Photo.class);
        photoDao.insert(photo);
        Toast.makeText(this, "执行成功!", Toast.LENGTH_SHORT).show();
    }

你可能感兴趣的:(android自己动手封装Sqllite数据库)