关于Android数据库orm工具库对比的几点思考（二）

最新推荐文章于 2024-09-14 15:55:09 发布
最新推荐文章于 2024-09-14 15:55:09 发布
阅读量293 收藏
点赞数
分类专栏： Android数据库 文章标签： android orm 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_28706365/article/details/52870480
版权

一、前言

上一篇详细解析了关于greenDao的具体用法，接下来的主角就是OrmLite，本篇博客将详细介绍ORMLite的简易用法。感兴趣的可以去官网查看，点击进入官网，它的英文全称是Object Relational Mapping，意思是对象关系映射；如果接触过Java EE开发的，一定知道Java Web开发就有一个类似的数据库映射框架——Hibernate。简单来说，就是我们定义一个实体类，利用这个框架，它可以帮我们吧这个实体映射到我们的数据库中，在Android中是SQLite，数据中的字段就是我们定义实体的成员变量。

二、OrmLite的介绍

ormlite-android
项目地址：https://github.com/j256/ormlite-android
文档介绍：http://ormlite.com/sqlite_java_android_orm.shtml

优点：

  • 轻量级
  • 使用简单，易上手
  • 封装完善
  • 文档全面

缺点：

  • 基于反射，效率较低
  • 缺少中文翻译文档

三、OrmLite的使用

（一）导入jar包到项目libs文件夹下

可以通过官方发布页面下载jar包，ORMLite release page，目前最新的是5.0。在android应用中使用，我们需要下载ormlite-android-5.0.jar和ormlite-core-5.0.jar两个文件。

（二）工程使用

配置model类
User类：

// 配置该User实体类对应的表名为orm_user，如果不加tableName="orm_user"属性，则表名为类名
@DatabaseTable(tableName = "orm_user")
public class User {

    // 配置字段名为id，并设为主键
    @DatabaseField(columnName = "id", generatedId = true)
    private int id;
    // 配置字段名为name，并且该字段不能为空
    @DatabaseField(columnName = "name", canBeNull = false)
    private String name;
    // 使用本身变量名为字段名
    @DatabaseField
    private int age;
    // 使用本身变量名为字段名，并且设置默认值
    @DatabaseField(defaultValue = "这个人很懒，什么也没说")
    private String desc;
    // 一个用户对应多篇文章，eager = true表示可以进行懒加载
    // 注：这里是一对多的关系，如果是1对1，我们要用@DatabaseField注解，还要指定(foreign = true)表示是一个外键
    @ForeignCollectionField(eager = true)
    public ForeignCollection<Article> articles;

    /**
     * @return the id
     */
    public int getId() {
        return id;
    }

    /**
     * @param id the id to set
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the age
     */
    public int getAge() {
        return age;
    }

    /**
     * @param age the age to set
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * @return the desc
     */
    public String getDesc() {
        return desc;
    }

    /**
     * @param desc the desc to set
     */
    public void setDesc(String desc) {
        this.desc = desc;
    }

    /**
     * @return the articles
     */
    public ForeignCollection<Article> getArticles() {
        return articles;
    }

    /**
     * @param articles the articles to set
     */
    public void setArticles(ForeignCollection<Article> articles) {
        this.articles = articles;
    }

    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", age=" + age + ", desc="
                + desc + "]";
    }
}

Article类：

// 配置该Article实体类对应的表名为orm_article，如果不加tableName="orm_article"属性，则表名为类名
@DatabaseTable(tableName = "orm_article")
public class Article {

    // 配置字段名为id，并设为主键
        @DatabaseField(columnName="id",generatedId=true)
        private int id;
        // 配置字段名为name，并且该字段不能为空
        @DatabaseField(columnName="uid",canBeNull = false)
        private int uid;
        // 使用本身变量名为字段名
        @DatabaseField
        private String title;
        // 使用本身变量名为字段名
        @DatabaseField
        private String content;
        // 使用本身变量名为字段名
        @DatabaseField
        private String date;

        // 外部对象字段，并指定这个字段的对象是一个外键，外键值是这个对象的id
        @DatabaseField(foreign = true, foreignAutoRefresh = true)
        private User mUser;

        /**
         * @return the id
         */
        public int getId() {
            return id;
        }

        /**
         * @param id the id to set
         */
        public void setId(int id) {
            this.id = id;
        }

        /**
         * @return the uid
         */
        public int getUid() {
            return uid;
        }

        /**
         * @param uid the uid to set
         */
        public void setUid(int uid) {
            this.uid = uid;
        }

        /**
         * @return the title
         */
        public String getTitle() {
            return title;
        }

        /**
         * @param title the title to set
         */
        public void setTitle(String title) {
            this.title = title;
        }

        /**
         * @return the content
         */
        public String getContent() {
            return content;
        }

        /**
         * @param content the content to set
         */
        public void setContent(String content) {
            this.content = content;
        }

        /**
         * @return the date
         */
        public String getDate() {
            return date;
        }

        /**
         * @param date the date to set
         */
        public void setDate(String date) {
            this.date = date;
        }

        /**
         * @return the mUser
         */
        public User getmUser() {
            return mUser;
        }

        /**
         * @param mUser the mUser to set
         */
        public void setmUser(User mUser) {
            this.mUser = mUser;
        }

        /* (non-Javadoc)
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
            return "Article [id=" + id + ", uid=" + uid + ", title=" + title
                    + ", content=" + content + ", date=" + date + "]";
        }
}

@DatabaseTable 注解中，tableName 参数是可选的，也就是这个类对应的表名。如果没有特别指出，那么这个类名将默认作为表名。对于类中的每个需要存储的成员变量，都需要添加@DatabaseField注解。

@DatabaseField 常用注解：

  • columnName 指定字段名,不指定则变量名作为字段名
  • canBeNull 字段是否能被分配null值。默认是true。如果你设置成false，那么你每次在数据库中插入数据是都必须为这个字段提供值。
  • dataType 指定字段的类型
  • defaultValue 当我们在表中创建新的记录时的一个字段的默认值。默认情况下是没有这个值的
  • width 字段的宽度，主要用于字符串字段。默认是0
  • id 这个字段是否是id，默认是false。在一个class中只有一个成变量可以有这个值。id字段是一条记录的唯一标识而且是必需的，只能在generatedId和 generatedIdSequence其中选一个。
  • generatedId 字段是否自动增加。默认为false。类中的一个成员变量设置了这个值，它告诉数据库每添加一条新记录都自动增加 id。当一个有generatedid的对象被创建时使用Dao.create()方法，数据库将为记录生成一个id，它会被返回并且被create方法设置进对象。
  • generatedIdSequence 序列编号的名字，这个值在生成的时候会被使用。和generatedId相似，但是你能够指定使用的序列名称。默认是没有的。
  • foreign 指定这个字段的对象是一个外键,外键值是这个对象的id
  • persisted 指定是否持久化此变量,默认true
  • foreignAutoCreate 外键不存在时是否自动添加到外间表中
  • foreignColumnName 外键字段指定的外键表中的哪个字段

还有一个外键的相关注解，这里也写下来供参考。

@ForeignCollectionField常用注解

  • eager 表示该集合是在初始化这个对象的时候,是否讲对象取出还是在遍历的时候才取出,默认false遍历的时候才取出,size()方法也会引起遍历
  • columnName
  • orderColumnName
  • foreignFieldName

（三）创建DB Helper

创建一个自己的DBHelper类，继承自OrmLiteSqliteOpenHelper，这个类可以在程序被安装时创建或者升级数据库，同时也可以提供一个DAO给其他的类使用。这个helper类需要实现onCreate(SQLiteDatabase sqliteDatabase, ConnectionSource connectionSource) 和onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion)方法。一个用于生成数据库，一个用于升级数据库。

继承OrmLiteSqliteOpenHelper类，自定义数据库辅助类DBHelper.class

public class DBHelper extends OrmLiteSqliteOpenHelper {
    /**
     * 数据库名字
     */
    private static final String DB_NAME = "ormlite.db";

    /**
     * 数据库版本
     */
    private static final int DB_VERSION = 1;

    /**
     * 用来存放Dao的Map集合，之所以创建Map集合，是为了方便对数据库资源的管理
     */
    private Map<String, Dao> daos = new HashMap<String, Dao>();

    /**
     * 数据库连接对象
     */
    private AndroidConnectionSource connectionSource;

    /**
     * 单例对象
     */
    private static DBHelper instance;

    /**
     * <p>Title: DBHelper</p>
     * <p>Description: 构造方法</p>
     *
     * @param context         上下文资源
     * @param databaseName    数据库名称
     * @param factory         游标工厂
     * @param databaseVersion 数据库版本
     */
    public DBHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }

    /**
     * @param context
     * @return DBHelper
     * @Title: getHelper
     * @Description: TODO(使用单例模式获取数据库对象)
     */
    public static synchronized DBHelper getHelper(Context context) {
        if (instance == null) {
            synchronized (DBHelper.class) {
                if (instance == null) {
                    instance = new DBHelper(context);
                }
            }
        }
        return instance;
    }

    /**
     * @param cls
     * @return dao
     * @Title: getDao
     * @Description: TODO(通过类名获得指定的Dao，并将取得的Dao放入Map集合)
     */
    public synchronized Dao getDao(Class cls) throws SQLException {
        Dao dao = null;
        // 获得类名
        String className = cls.getSimpleName();
        // 判断类名是否为空
        if (!className.equals("") || !className.equals(null)) {
            // 如果不为空则获取Dao对象
            dao = super.getDao(cls);
            // 将Dao对象放入Map集合
            daos.put(className, dao);
        } else {
            return null;
        }
        return dao;
    }

    /* (non-Javadoc)
     * @see com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper#onCreate(android.database.sqlite.SQLiteDatabase, com.j256.ormlite.support.ConnectionSource)
     */
    @Override
    public void onCreate(SQLiteDatabase sqliteDatabase, ConnectionSource connectionSource) {
        // 创建操作
        try {
            // 创建用户表
            TableUtils.createTable(connectionSource, User.class);
            // 创建文章表
            TableUtils.createTable(connectionSource, Article.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /* (non-Javadoc)
     * @see com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper#onUpgrade(android.database.sqlite.SQLiteDatabase,
                com.j256.ormlite.support.ConnectionSource, int, int)
     */
    @Override
    public void onUpgrade(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource, int oldVersion,
                          int newVersion) {
        // 更新操作
        try {
            // 更新用户表
            TableUtils.dropTable(connectionSource, User.class, true);
            // 更新文章表
            TableUtils.dropTable(connectionSource, Article.class, true);
            onCreate(sqLiteDatabase, connectionSource);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * @Title: close
     * @Description: TODO(释放资源)
     */
    public void close() {
        super.close();
        for (String key : daos.keySet()) {
            Dao dao = daos.get(key);
            // 释放Dao资源
            dao = null;
        }
    }
}

（四）创建DAO

public class UserDao {
    private Dao<User, Integer> userDao;
    private DBHelper dbHelper;

    /**
     *
     * <p>Title: UserDao</p>
     * <p>Description: 构造方法</p>
     * @param context  上下午资源对象
     */
    public UserDao(Context context) {
        try {
            // 使用单例模式
            dbHelper = DBHelper.getHelper(context);
            userDao = dbHelper.getDao(User.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * @Title: add
     * @Description: TODO(添加用户)
     * @param  user
     * @return void
     */
    public void add(User user) {
        try {
            userDao.create(user);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * @Title: delete
     * @Description: TODO(根据ID删除单条记录)
     * @param  id
     * @return void
     */
    public void delete(int id) {
        try {
            userDao.deleteById(id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     *
     * @Title: update
     * @Description: TODO(更新单条记录)
     * @param  user
     * @return void
     */
    public void update(User user) {
        try {
            userDao.createOrUpdate(user);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * @Title: queryForId
     * @Description: TODO(根据ID查询单条记录)
     * @param  id
     * @return User
     */
    public User queryForId(int id) {
        User user = null;
        try {
            user = userDao.queryForId(id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return user;
    }

    /**
     * @Title: queryForAll
     * @Description: TODO(查询所有记录)
     * @return List<User>
     */
    public List<User> queryForAll() {
        List<User> mUsers = new ArrayList<User>();
        try {
            mUsers = userDao.queryForAll();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return mUsers;
    }
}

DAO里的主要方法：

  • create 插入一条数据
  • createIfNotExists 如果不存在则插入
  • createOrUpdate 如果指定id则更新
  • queryForId 更具id查找
  • update 查找出数据
  • delete 删除数据
  • queryBuilder() 创建一个查询生成器:进行复杂查询
  • deleteBuilder() 创建一个删除生成器,进程复杂条件删除
  • updateBuilder() 创建修条件生成器,进行复杂条件修改

（五）数据增删改查

public class MainActivity extends Activity implements OnClickListener {

    private TextView tv_show;      // 控制台显示文本
    private Button btn_add;          // 新增
    private Button btn_query;          // 查询
    private Button btn_update;          // 更新
    private Button btn_delete;          // 删除
    private User user;
    private UserDao userDao;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        userDao = new UserDao(this);
        // 实例化控件
        init();
        // 设置监听事件
        setListener();
    }

    /**
     * @param
     * @return void
     * @Title: init
     * @Description: TODO(实例化控件)
     */
    private void init() {
        tv_show = (TextView) findViewById(R.id.tv_show);
        btn_add = (Button) findViewById(R.id.btn_add);
        btn_query = (Button) findViewById(R.id.btn_query);
        btn_update = (Button) findViewById(R.id.btn_update);
        btn_delete = (Button) findViewById(R.id.btn_delete);
    }

    /**
     * @param
     * @return void
     * @Title: setListener
     * @Description: TODO(设置监听事件)
     */
    private void setListener() {
        btn_add.setOnClickListener(this);
        btn_query.setOnClickListener(this);
        btn_update.setOnClickListener(this);
        btn_delete.setOnClickListener(this);
    }

    /* (non-Javadoc)
     * @see android.view.View.OnClickListener#onClick(android.view.View)
     */
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            // 新增操作
            case R.id.btn_add:
                add();
                break;
            // 查询操作
            case R.id.btn_query:
                query();
                break;
            // 更新操作
            case R.id.btn_update:
                update();
                break;
            // 删除操作
            case R.id.btn_delete:
                delete();
                break;

            default:
                break;
        }
    }

    /**
     * @param
     * @return void
     * @Title: add
     * @Description: TODO(添加数据)
     */
    private void add() {
        for (int i = 1; i <= 10; i++) {
            user = new User();
            user.setName("Alonez_" + i);   // 设置姓名
            user.setAge(10 + i);        // 设置年龄
            userDao.add(user);
        }
        tv_show.setText("新增了" + userDao.queryForAll().size() + "位用户\n第1位用户名为：" +
                userDao.queryForAll().get(0).getName() +
                "\n" + "第" + userDao.queryForAll().size() + "位用户名为：" +
                "" + userDao.queryForAll().get(userDao.queryForAll().size() - 1).getName());
    }

    /**
     * @param
     * @return void
     * @Title: query
     * @Description: TODO(查询数据)
     */
    private void query() {
        user = userDao.queryForId(5);
        tv_show.setText("第5位用户ID：" + user.getId() + "\n"
                + "第5位用户姓名：" + user.getName() + "\n"
                + "第5位用户年龄：" + user.getAge() + "\n"
                + "第5位用户描述：" + user.getDesc());
    }

    /**
     * @param
     * @return void
     * @Title: update
     * @Description: TODO(更新操作)
     */
    private void update() {
        user = new User();
        user.setId(5);
        user.setName("我是第5位用户");
        user.setAge(77);
        user.setDesc("啦啦啦，德玛西亚");
        userDao.update(user);

        user = userDao.queryForId(5);
        tv_show.setText("第5位用户ID：" + user.getId() + "\n"
                + "第5位用户姓名：" + user.getName() + "\n"
                + "第5位用户年龄：" + user.getAge() + "\n"
                + "第5位用户描述：" + user.getDesc());
    }

    /**
     * @param
     * @return void
     * @Title: delete
     * @Description: TODO(删除操作)
     */
    private void delete() {
        userDao.delete(1);
        tv_show.setText("数据库还有" + userDao.queryForAll().size() + "位用户");
    }
}

布局文件：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.sence.testormlite.MainActivity"
    android:orientation="vertical">

    <TextView
        android:id="@+id/tv_show"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:layout_marginTop="17dp"
        android:text="显示文本"/>

    <Button
        android:id="@+id/btn_add"
        android:layout_marginTop="40dp"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="创建十条数据"/>
    <Button
        android:id="@+id/btn_query"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="查询一条数据"/>
    <Button
        android:id="@+id/btn_update"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="更新一条数据"/>
    <Button
        android:id="@+id/btn_delete"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="删除一条数据"/>
</LinearLayout>

这章内容到这里就要结束了，后期还会继续更其他数据库框架的内容，当然最后会作一期对比总结版，じゃ、みんな、さようなら。

Jsence
关注
专栏目录
Android ORMLite ForeignCollection关联外部集合
Zhang Phil
07-15 4208
 《Android ORMLite ForeignCollection关联外部集合》    Android ORMLite ForeignCollection关联外部集合的功能，适合层级比较深，数据模型互相渗透、交叉的数据结构或集合。尤其方便解决复杂数据模型。简单期间，我们暂时以 班级 学生 这样的数据模型为例加以说明。一个班级里面有若干学生(一对多，11）。 在Android ORM
Ormlite 基本使用（关联表）
黄孝果的博客
04-10 861
建立Bean类 UserBean表 import com.j256.ormlite.dao.ForeignCollection; import com.j256.ormlite.field.DatabaseField; import com.j256.ormlite.field.ForeignCollectionField; import com.j256.ormlite.table.Dat...
Android 数据库框架ormlite 使用精要，【2021Android最新学习路线
m0_64319298的博客
11-22 275
import java.io.Serializable; import com.j256.ormlite.dao.ForeignCollection; import com.j256.ormlite.field.DatabaseField; import com.j256.ormlite.field.ForeignCollectionField; import com.j256.ormlite.table.DatabaseTable; /** 套餐 @author wwj_748 */ @Da
ormlite的一对多详解
Sanjay的专栏
10-10 3497
我们先看下怎么用，再在后面详细解说我们演示的是平常消费的每个人可以下多个订单的案例。 **一个账号（Account）** 创建 **多个订单（order）** 的一对多关系； 1. 使用演示Account account = new Account("Jim Coakley"); accountDao.create(account); //我们需要先保存账号，使我们的account有唯一的ID
关于Android数据库orm工具库对比的几点思考（三）
进击的Sence
10-21 418
一、前言在我正式接触到Android数据库orm框架的时候，我有把github上的所有优秀的orm数据库项目都撸了一遍，保留了几个自己感兴趣并且适用于现在的项目中，这些框架中，有些在我前两篇博文中已经提到过，但是今天厉害了，我要介绍一个文件式数据库——Realm，一个简便的数据库。 二、Realm的简介移动端的数据库，适用于 Phone、Tablet、Wearable，支持 ORM，线程安全、支持
关于Android数据库orm工具库对比的几点思考（四）
进击的Sence
10-21 940
一、ActiveAndroid的简介ActiveAndroid Android Sqlite orm 的 db 工具类 项目地址：https://github.com/pardom/ActiveAndroid 文档介绍：https://github.com/pardom/ActiveAndroid/wiki/_pagesActiveAndroid算是一个轻量级的ORM框架，简单地通过如save
Android ORM 数据库的使用
04-03
为了优化，可以考虑以下几点： - 只在必要的时候进行数据库操作，避免频繁读写。 - 使用查询缓存，减少对数据库的访问。 - 对大数据量的操作，考虑分批处理。 总的来说，ActiveAndroid提供了一种高效且简洁的...
android-orm:适用于Android的简单ORM实现
05-14
Android ORM（对象关系映射）是一种技术，它允许...对于初学者来说，这是一个了解Android数据库操作和ORM概念的好起点；对于有经验的开发者，它可以作为一个参考，以便在实际项目中实现更高效、更灵活的数据库管理。
Android-ORM-benchmark,android orm框架的性能比较.zip
09-24
6. **SugarORM**：SugarORM致力于简化Android数据库操作，只需要继承一个基类，就可以实现对数据库的操作，非常适合小型项目。 "Android-ORM-benchmark"项目可能包含了这些框架的性能测试，对比了它们在插入、查询...
Android 数据库框架ormlite(一)
jin广越的博客
02-15 1021
2017开篇博客, 近日使用ormlite做数据库管理遇到了问题，尤其是在做一对多的需求时，这里我使用文件夹和文件作为俩个数据库表举例。基本使用Android studio引入：compile 'com.j256.ormlite:ormlite-android:4.48' compile 'com.j256.ormlite:ormlite-core:4.48'最好到官网查看最新包版本: http:/
【Android - 框架】之ORMLite的使用
ITGungnir
11-24 1143
Android中有很多操作SQLite数据库的框架，现在最常见、最常用的是ORMLite和GreenDAO。ORMLite相比与GreenDAO来说是一个轻量级的框架，而且学习成本相对较低。所以这个帖子中先介绍ORMLite，下个帖子再介绍GreenDAO。         要使用ORMLite，首先需要导入ORMLite的依赖：在build.gradle中加入以下代码： co
ormlite框架使用
asd997484085的博客
02-14 469
http://www.jianshu.com/p/05782b598cf0 http://blog.csdn.net/baidu_26994091/article/details/51893798 关键字： @DatabaseTable表名：如@DatabaseTable(tableName = "run_train_report")如果不指定名字，在Android中会以类名作为表名
GreenDao 3.X之基本使用
热门推荐
行云间
08-15 1万+
在 GreenDao 3.X之注解已经了解到GreenDao 3.0的改动及注解。对于数据库的操作，无异于增删改查等四个操作。下面我们将了解GreenDao 3.X如何使用？ AbstractDao     所有的自动生成的XXDao都是继承于AbstractDao，此类中基本上封装了所有的增删改操作，包括数据库的事务操作。常用的API如下： void attachEntity(T en
数据库框架-ormlite和测试框架-junit
zsr0526的博客
03-15 959
安卓中数据库框架-ormlite 以及 单元测试框架-junit
ORMLite框架 的使用方法---给你的数据库操作插上翅膀
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
10-07 223
Java编程精选点击右侧关注，免费入门到精通！来源：Android开发中文站https://mp.weixin.qq.com/s/HSodc_0AGHsDE25fF4KP...
Yii2学习之DAO和Query
小刚的博客
08-17 9782
简单介绍上节介绍了AR类，是以面向对象的方式操作数据库，yii2还提供了一套统一的数据库访问层API（Data Access Objects）,可以以SQL语句方式操作数据库表，能完成AR类的任何操作，但是相对与AR使用DAO需要写大量的sql语句，如果你的sql语句很复杂，会在后续工作中很难维护，所以一般建议还是使用AR类。但是不管DAO还是AR他们都是通过Query基类创建sql语句（AR类通过
【Android】【Bug】使用OSmdroid绘制轨迹断裂问题
最新发布
每天不是在写bug就是在写bug的路上
09-14 837
使用OSmdroid绘制轨迹断裂问题
Android 内置应用裁剪
Framework-coder的博客
09-13 157
参考 AOSP 中 PRODUCT_PACKAGES 配置的方式，自定义一个“PRODUCT_PACKAGES_REMOVE”配 置选项。用户可根据自身项目的需要，将需裁剪的 APK 名称（无需 .apk 后缀) 都添加到“PRODUCT_PACKAGES_REMOVE”项下，从而做到一次性全部裁剪。此方法省去了查找目标 APK 的编译.mk 文件的时间，提高了工作效率。补丁如下：从以上补丁可以发现，只要是添加在“PRODUCT_PACKAGES_REMOVE”配置项下的 APK 都将被裁剪。
Android连接MySQL数据库实战
为了在Android应用中安全地使用JDBC，有几个关键点需要注意： - 确保JDBC驱动兼容Android环境，因为不是所有的JDBC驱动都适合在移动设备上运行。 - 连接操作应在新的线程中进行，避免阻塞UI线程，否则可能会引发`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值