Android的常用框架

最新推荐文章于 2024-05-23 09:23:37 发布

余小盖

最新推荐文章于 2024-05-23 09:23:37 发布

阅读量515

点赞数

分类专栏： Android随笔文章标签： android 软件框架 java

本文链接：https://blog.csdn.net/qq_41306318/article/details/105877617

版权

Android随笔专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1. 前言

每种编程语言都有其相应的框架，而Android也不例外；那么Android的框架到底有多少种，且其框架相应的特点与构成又是如何的呢？接下来，就让我们一起去学习一下Android的一些常用框架。

2. Android常用框架的构成图

我把我目前所知晓得的一些Android常用的框架以构成图的形式进行展示，从而使Android的常用框架可以更加清晰明了的展现出来，构成图如下：
Android常用框架

3. Android常用框架

通过以上的Android常用框架的构成图，我们可以晓得本篇博文主要对这七个常用框架进行相应的讲解。

3.1 图片加载

3.1.1 Universal Image Loader

3.1.1.1 添加依赖

Maven

<dependency>
    <groupId>com.nostra13.universalimageloader</groupId>
    <artifactId>universal-image-loader</artifactId>
    <version>1.9.5</version>
</dependency>

3.1.1.2 特点

1、多线程下载图片，图片可以来源于网络、文件系统、项目文件夹assets和drawable等；
2、支持随意的配置ImageLoader，例如线程池、图片下载器、内存缓存策略、硬盘缓存策略、图片显示选项以及其他的一些配置；
3、支持图片的内存缓存、文件系统缓存或者SD卡缓存；
4、支持图片下载过程的监听；
5、根据控件（ImageView）的大小对Bitmap进行裁剪，减少Bitmap占用过多的内存；
6、较好的控制图片的加载过程，例如暂停图片加载、重新开始加载图片，一般使用在ListView、GridView中，滑动过程中暂停加载图片，停止滑动的时候去加载图片；
7、提供在较慢的网络下对图片进行加载。

3.1.1.3 流程图

Android Universal Image Loader流程图

3.1.1.4 常用方法

3.1.1.4.1 配置ImageLoaderConfiguration

通过配置ImageLoaderConfiguration类来实现全局ImageLoader的实现情况；以下代码根据个人的需求进行相应的更改。

//获取缓存文件
File cacheDir = StorageUtils.getCacheDirectory(this);
//设置自定义缓存的目录
cacheDir = StorageUtils.getOwnCacheDirectory(this,"imageloader/Cache");
//初始化ImageLoad
ImageLoaderConfiguration config =newImageLoaderConfiguration.Builder(this)
.memoryCacheExtraOptions(480,800)//设置缓存图片的默认尺寸,一般取设备的屏幕尺寸
.diskCacheExtraOptions(480,800, null)
.threadPoolSize(3)// 线程池内加载的数量,default = 3
.threadPriority(Thread.NORM_PRIORITY-2)
.tasksProcessingOrder(QueueProcessingType.FIFO)
.denyCacheImageMultipleSizesInMemory()
.memoryCache(newLruMemoryCache(2*1024*1024))//自定义内存的缓存策略
.memoryCacheSize(2*1024*1024)
.memoryCacheSizePercentage(13)// default
.diskCache(newUnlimitedDiskCache(cacheDir))// default
.diskCacheSize(50*1024*1024)
.diskCacheFileCount(100)//缓存的文件数量
.diskCache(newUnlimitedDiskCache(cacheDir))//自定义缓存路径
.diskCacheFileNameGenerator(newHashCodeFileNameGenerator())// default
.imageDownloader(newBaseImageDownloader(this))// default
.imageDecoder(newBaseImageDecoder(true))// default
.defaultDisplayImageOptions(DisplayImageOptions.createSimple())// default
.writeDebugLogs()
.build();

3.1.1.4.2 加载图片

在使用ImageLoader进行图片加载的时候，先要实例化ImageLoader，在每个布局里面都要实例化后再使用。

protectedImageLoader imageLoader = ImageLoader.getInstance();

3.1.1.4.3 显示图片

1、加载一张网络图片

ImageLoader.getInstance().displayImage(imageUrl, imageView);

2、加载一张网络图片并自定义配置

ImageLoader.getInstance().displayImage("图片地址",mImageView,mOptions);

3、加载一张图片并对图片的加载过程进行监听

ImageLoader.getInstance().displayImage("图片地址",mImageView2,mOptions, newImageLoadingListener() {
@Override
public voidonLoadingStarted(String imageUri,View view) {
//开始加载
}
@Override
public voidonLoadingFailed(String imageUri,View view,FailReason failReason) {
//加载失败
}
@Override
public voidonLoadingComplete(String imageUri,View view,Bitmap loadedImage) {
//加载完成
}
@Override
public voidonLoadingCancelled(String imageUri,View view) {
//取消加载
}
});

4、图片加载时候，带监听又带加载进度条的情况调用：

imageLoader.displayImage(imageUrl, imageView, options,newImageLoadingListener() {
@Override
publicvoidonLoadingStarted() {
//开始加载的时候执行
}
@Override
publicvoidonLoadingFailed(FailReason failReason) {
//加载失败的时候执行
}
@Override
publicvoidonLoadingComplete(Bitmap loadedImage) {
//加载成功的时候执行
}
@Override
publicvoidonLoadingCancelled() {
//加载取消的时候执行
},newImageLoadingProgressListener() {
@Override
publicvoidonProgressUpdate(String imageUri, View view,intcurrent,inttotal) {
//在这里更新 ProgressBar的进度信息
}
});

3.1.1.5 注意点

1、ImageLoaderConfiguration必须配置并且全局化的初始化这个配置ImageLoader.getInstance().init(config)，否则会出现错误提示；
2、ImageLoader是根据ImageView的height，width确定图片的宽高；

3.1.2 Picasso

3.1.2.1 添加依赖

Maven

<dependency>  
    <groupId>com.squareup.picasso</groupId>
    <artifactId>picasso</artifactId>
    <version>2.5.2</version>
</dependency>

3.1.2.2 简单的加载图片

Picasso使用的是链式编程，它至少需要三个参数才能完成基本地图像请求

with(Context context)——很多Android API都会去如此调用，这里也没有什么区别
load(String imageUrl)——应该加载哪个图像，大多数情况下，我们会使用String来代表一个url图像
into(ImageView targetImageView)——目标显示的ImageView
举个例子，就可以很容易明白，并且应用

ImageView targetImageView = (ImageView) findViewById(R.id.imageView);  
String internetUrl = "http://i.imgur.com/DvpvklR.png";

Picasso  
    .with(context)
    .load(internetUrl)
    .into(targetImageView);

3.1.2.3 常用方法

3.1.2.3.1 资源加载

int resourceId = R.mipmap.ic_launcher;

Picasso  
    .with(context)
    .load(resourceId)
    .into(imageViewResource);

3.1.2.3.2 文件加载

File file = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES), "Running.jpg");

Picasso  
    .with(context)
    .load(file)
    .into(imageViewFile);

3.1.2.3.3 Uri加载

Uri uri = resourceIdToUri(context, R.mipmap.future_studio_launcher);

Picasso  
    .with(context)
    .load(uri)
    .into(imageViewUri);

public static final String ANDROID_RESOURCE = "android.resource://";  
public static final String FOREWARD_SLASH = "/";

private static Uri resourceIdToUri(Context context, int resourceId) {  
    return Uri.parse(ANDROID_RESOURCE + context.getPackageName() + FOREWARD_SLASH + resourceId);
}

3.1.3 Glide

3.1.3.1 添加依赖

Maven

<dependency>
    <groupId>com.github.bumptech.glide</groupId>
    <artifactId>glide</artifactId>
    <version>4.11.0</version>
</dependency>

3.1.3.2 添加访问网络权限

<uses-permission android:name="android.permission.INTERNET" />

3.1.3.3 常用方法

3.1.3.3.1 加载图片到imageView

Glide.with(Context context).load(Strint url).into(ImageView imageView);

3.1.3.3.2 各种形式的图片加载到ImageView

// 加载本地图片
File file = new File(getExternalCacheDir() + "/image.jpg");
Glide.with(this).load(file).into(imageView);

// 加载应用资源
int resource = R.drawable.image;
Glide.with(this).load(resource).into(imageView);

// 加载二进制流
byte[] image = getImageBytes();
Glide.with(this).load(image).into(imageView);

// 加载Uri对象
Uri imageUri = getImageUri();
Glide.with(this).load(imageUri).into(imageView);

3.1.3.3.3 加载带有占位图

Glide.with(this).load(url).placeholder(R.drawable.loading).into(imageView);

占位图目的为在目的图片还未加载出来的时候，提前展示给用户的一张图片

3.1.3.3.4 加载失败放置占位符

Glide.with(this).load(url).placeholder(R.drawable.loading).error(R.drawable.error)
     .diskCacheStrategy(DiskCacheStrategy.NONE)//关闭Glide的硬盘缓存机制
     .into(imageView);

//DiskCacheStrategy.NONE： 表示不缓存任何内容。
//DiskCacheStrategy.SOURCE： 表示只缓存原始图片。
//DiskCacheStrategy.RESULT： 表示只缓存转换过后的图片（默认选项）。
//DiskCacheStrategy.ALL ： 表示既缓存原始图片，也缓存转换过后的图片。

3.1.3.3.5 加载指定格式的图片–指定为静止图片

Glide.with(this)
     .load(url)
     .asBitmap()//只加载静态图片，如果是git图片则只加载第一帧。
     .placeholder(R.drawable.loading)
     .error(R.drawable.error)
     .diskCacheStrategy(DiskCacheStrategy.NONE)
     .into(imageView);

3.1.3.3.6 加载动态图片

Glide.with(this)
     .load(url)
     .asGif()//加载动态图片，若现有图片为非gif图片，则直接加载错误占位图。
     .placeholder(R.drawable.loading)
     .error(R.drawable.error)
     .diskCacheStrategy(DiskCacheStrategy.NONE)
     .into(imageView);

3.1.3.3.7 加载指定大小的图片

Glide.with(this)
     .load(url)
     .placeholder(R.drawable.loading)
     .error(R.drawable.error)
     .diskCacheStrategy(DiskCacheStrategy.NONE)
     .override(100, 100)//指定图片大小
     .into(imageView);

3.1.3.3.8 关闭框架的内存缓存机制

Glide.with(this)
     .load(url)
     .skipMemoryCache(true)  //传入参数为false时，则关闭内存缓存。
     .into(imageView);

3.1.3.3.9 关闭硬盘的缓存

Glide.with(this)
     .load(url)
     .diskCacheStrategy(DiskCacheStrategy.NONE)     //关闭硬盘缓存操作
     .into(imageView);

//其他参数表示：
//DiskCacheStrategy.NONE： 表示不缓存任何内容。
//DiskCacheStrategy.SOURCE： 表示只缓存原始图片。
//DiskCacheStrategy.RESULT： 表示只缓存转换过后的图片（默认选项）。
//DiskCacheStrategy.ALL ： 表示既缓存原始图片，也缓存转换过后的图片。

3.2 数据解析

3.2.1 Gson

3.2.1.1 添加依赖

Maven

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.6</version>
</dependency>

3.2.1.2 Gson解析

json有两种数据类型：

一种是对象，object -> {key:value,key:value,...}
另一种是数组，array -> [value,value,...]array -> [value,value,...]

Gson在解析json的时候，大体上有2种类型，一种是直接在内存中生成object或array，通过手工指定key来获取值；另一种是借助javabean来进行映射获取值。

3.2.1.2.1 json是对象类型

当ajax传过来的json数据属于对象时，不论这个对象简单还是复杂，都可以轻松地把它们给解析出来。
ajax传过来的json数据：

var data_json =  {
        "sex": '男',
        "hobby":["baskte","tennis"],
        "introduce": {
            "name":"tom",
            "age":23
        }
    };

data: JSON.stringify(data_json),

Gson解析：

	BufferedReader reader = request.getReader();
    // 读取json数据
    StringBuffer buffer = new StringBuffer();
    String s;
    while ((s = reader.readLine()) != null) {
        buffer.append(s);
    }
    String json = buffer.toString();
    System.out.println("json:" + json);  

    // json解析器，解析json数据
    JsonParser parser = new JsonParser();
    JsonElement element = parser.parse(json);
    // json属于对象类型时
    if (element.isJsonObject()) {  
        JsonObject object = element.getAsJsonObject();  // 转化为对象

        // 1. value为string时，取出string
        String sex = object.get("sex").getAsString();                         System.out.println("sex:" + sex);

        // 2. value为array时，取出array
        JsonArray hobbies = object.getAsJsonArray("hobby");  // 
        for (int i = 0; i < hobbies.size(); i++) {
            String hobby = hobbies.get(i).getAsString();
            System.out.println("hobby:" + hobby);
        }

        // 3. value为object时，取出object
        JsonObject introduce = object.getAsJsonObject("introduce");
        String name = introduce.get("name").getAsString();
        int age = introduce.get("age").getAsInt();
        System.out.println("name:" + name+";age:" + age);
    }

3.2.1.2.2 json是数组类型

ajax传过来的json数据：

var data_json =  [
    "cake",
    2,
    {"brother":"tom","sister":"lucy"},
    ["red","orange"]
];

data: JSON.stringify(data_json),

Gson解析：

	BufferedReader reader = request.getReader();
    StringBuffer buffer = new StringBuffer();
    String s;
    while ((s = reader.readLine()) != null) {
        buffer.append(s);
    }
    String json = buffer.toString();
    System.out.println("json:"+json);

    // json解析器，解析json数据
    JsonParser parser = new JsonParser();
    JsonElement element = parser.parse(json);
    // json属于数组类型
    if (element.isJsonArray()) {  
        JsonArray array = element.getAsJsonArray();

        // 1. value为string时，取出string
        String array_1 = array.get(0).getAsString();
        System.out.println("array_1:"+array_1);

        // 2. value为int时，取出int
        int array_2 = array.get(1).getAsInt();
        System.out.println("array_2:"+array_2);

        // 3. value为object时，取出object
        JsonObject array_3 = array.get(2).getAsJsonObject();
        String brother = array_3.get("brother").getAsString();
        String sister = array_3.get("sister").getAsString();
        System.out.println("brother:"+brother+";sister:"+sister);

        // 4. value为array时，取出array
        JsonArray array_4 = array.get(3).getAsJsonArray();
        for (int i = 0; i < array_4.size(); i++) {
        System.out.println(array_4.get(i).getAsString());
        }
    }

3.2.2 Jackson

3.2.2.1 添加依赖

Maven

<dependency>
    <groupId>org.codehaus.jackson</groupId>
    <artifactId>jackson-core-asl</artifactId>
    <version>1.9.13</version>
</dependency>

3.2.2.2 Jackson注解

Jackson类库包含了很多注解，可以让我们快速建立Java类与json之间的关系。详细文档可以参考Jackson-Annotations

3.2.2.3 属性命名

@JsonProperty注解指定一个属性用于JSON映射，默认情况下映射的JSON属性与注解的属性名称相同，不过可以使用该注解的value值修改JSON属性名，该注解还有一个index属性指定生成json属性的顺序，如果有必要的话

3.2.2.4 属性包含

还有一些注解可以管理在映射json的时候包含或排除某些属性，下面介绍一下常用的几个

@JsonIgnore注解用于排除某个属性，这样该属性就不会被Jackson序列化和反序列化
@JsonIgnoreProperties注解是类注解。在序列化为json的时候，@JsonIgnoreProperties({"prop1", "prop2"})会忽略pro1和pro2两个属性。在从json反序列化为Java类的时候，@JsonIgnoreProperties(ignoreUnknown=true)会忽略所有没有Getter和Setter的属性。该注解在Java类和json不完全匹配的时候很有用
@JsonIgnoreType也是类注解，会排除所有指定类型的属性

3.2.2.5 序列化相关

@JsonPropertyOrder和@JsonProperty的index属性类似，指定属性序列化时的顺序
@JsonRootName注解用于指定json根属性的名称

3.2.2.6 json的处理方式

3.2.2.6.1 简单映射

用Lombok设置一个简单的Java类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Friend {
    private String nickname;
    private int age;
}

然后就可以处理json数据了。首先需要一个ObjectMapper对象，序列化和反序列化都需要它

		ObjectMapper mapper = new ObjectMapper();
        Friend friend = new Friend("yitian", 25);

        // 写为字符串
        String text = mapper.writeValueAsString(friend);
        // 写为文件
        mapper.writeValue(new File("friend.json"), friend);
        // 写为字节流
        byte[] bytes = mapper.writeValueAsBytes(friend);
        System.out.println(text);
        // 从字符串中读取
        Friend newFriend = mapper.readValue(text, Friend.class);
        // 从字节流中读取
        newFriend = mapper.readValue(bytes, Friend.class);
        // 从文件中读取
        newFriend = mapper.readValue(new File("friend.json"), Friend.class);
        System.out.println(newFriend);

程序结果如下。可以看到生成的JSON属性和Java类中定义的一致

{"nickname":"yitian","age":25}
Friend(nickname=yitian, age=25)

3.2.2.6.2 集合映射

除了使用Java类进行映射之外，我们还可以直接使用Map和List等Java集合组织json数据，在需要的时候可以使用readTree方法直接读取json中的某个属性值。需要注意的是从json转换为Map对象的时候，由于Java的类型擦除，所以类型需要我们手动用new TypeReference<T>给出

		ObjectMapper mapper = new ObjectMapper();
		
        Map<String, Object> map = new HashMap<>();
        map.put("age", 25);
        map.put("name", "yitian");
        map.put("interests", new String[]{"pc games", "music"});

        String text = mapper.writeValueAsString(map);
        System.out.println(text);

        Map<String, Object> map2 = mapper.readValue(text, new TypeReference<Map<String, Object>>() {
        });
        System.out.println(map2);

        JsonNode root = mapper.readTree(text);
        String name = root.get("name").asText();
        int age = root.get("age").asInt();

        System.out.println("name:" + name + " age:" + age);

程序结果如下

{"name":"yitian","interests":["pc games","music"],"age":25}
{name=yitian, interests=[pc games, music], age=25}
name:yitian age:25

3.3 数据库

3.3.1 OrmLite

3.3.1.1 添加依赖

Maven

<dependency>
    <groupId>com.j256.ormlite</groupId>
    <artifactId>ormlite-android</artifactId>
    <version>5.1</version>
</dependency>

3.3.1.2 创建项目中使用DatabaseHelper类

首先要简单说一下OrmLite框架中OrmLiteSqliteOpenHelper类，OrmLiteSqliteOpenHelper类继承了 SQLiteOpenHelper。所以，创建项目中的DatabaseHelper 类，要使该类继承OrmLite框架OrmLiteSqliteOpenHelper类来获得SQLiteHelper

3.3.1.3 方法说明

3.3.1.3.1 构造函数

public DatabaseHelper(Context context, String databaseName, SQLiteDatabase.CursorFactory factory, int databaseVersion) {
        super(context, databaseName, factory, databaseVersion);
        /**
         * 参数说明：
         * context：上下文。
         * databaseName： 数据库名。
         * factory： 游标实例，多数时候设置成NULL。
         * databaseVersion：数据库版本，当数据库版本升高时，会调用onUpgrade（）方法。
         */
        
}

3.3.1.3.2 创建数据库表

public void onCreate(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource) { 
        /**
         * 在该方法中进行创建表操作
         * 使用OrmLite 框架的 TableUtils.createTable进行创建表操作。
         *eg.
         */
         
        try {
            TableUtils.createTable(connectionSource, UserInfo.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
}

3.3.1.3.3 数据库版本提升更新方法

public void onUpgrade(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource, int i, int i1) { 
    //在该方法中进行更新操作
}

3.3.1.4 创建数据库表对应的 Bean

Bean 类中的变量对应数据库中的字段，在 Bean 中使用注解方式进行设置。
实例代码如下：

@DatabaseTable(tableName = "tb_user_info")
public class UserInfo {

    @DatabaseField(generatedId = true)
    private int userId;
    @DatabaseField(columnName = "name")
    private String name;
    @DatabaseField(columnName = "addr")
    private String addr;
    @DatabaseField(columnName = "sex")
    private String sex;
    
    // 对应字段的set 和 get 方法
}

3.3.1.5 获取操作数据库对应表的 Bean 的 Dao

在OrmLite 框架中，操作数据是通过对应Bean的Dao 实现的
Dao 的获取方式：对应Bean是通过OrmLiteSqliteOpenHelper类中**getDao(Class clazz)**方法获取。
实例代码如下：

public class UserDao {

    private DatabaseHelper helper;

    public Dao<UserInfo,Integer> getUserDao(Context context) throws SQLException {
        helper = new DatabaseHelper(context);
        return helper.getDao(UserInfo.class);
    }
}

3.3.1.6 通过 Dao 对数据库进行简单增、删、改、查操作

UserDao mDao = new UserDao();

3.3.1.6.1 增

try {
        UserInfo u1 = new UserInfo("zhangsan","beijng","nan");
        mDao.getUserDao(mContext).create(u1);
} catch (SQLException e) {
         e.printStackTrace();
}

3.3.1.6.2 删

//修改和删除要通过id 进行操作
UserInfo u4 = new UserInfo("zhangsan","北京","女");
u4.setUserId(4);

UserInfo u3 = new UserInfo("招商","beijng","女");
u3.setUserId(3);
try {
    Collection<UserInfo> collection = new ArrayList<UserInfo>();
    collection.add(u4);
    collection.add(u3);
    mDao.getUserDao(mContext).delete(collection);
} catch (SQLException e) {
    e.printStackTrace();
}

3.3.1.6.3 改

UserInfo u4 = new UserInfo("updateMan","北京","女");
u4.setUserId(4);

try {
    mDao.getUserDao(mContext).update(u4);
} catch (SQLException e) {
     e.printStackTrace();
}

3.3.1.6.4 查

try {
List<UserInfo> infos =  mDao.getUserDao(mContext).queryForAll();
    for(UserInfo info : infos){
        //在此处使用TextView进行显示
        mUserText.append("\n" + info.toString() + "\n");
    }
} catch (SQLException e) {
    e.printStackTrace();
}

3.3.2 GreenDao

3.3.2.1 添加依赖

Maven

<dependency>
    <groupId>org.greenrobot</groupId>
    <artifactId>greendao</artifactId>
    <version>3.2.2</version>
</dependency>

3.3.2.2 优点

通常我们在使用GreenDao的时候，我们只需定义数据模型，GreenDao框架将创建数据对象(实体)和DAO(数据访问对象)，能够节省部分代码
不向性能妥协，使用了GreenDao，大多数实体可以以每秒几千个实体的速率进行插入，更新和加载
GreenDao支持加密数据库来保护敏感数据
微小的依赖库，GreenDao的关键依赖库大小不超过100kb
如果需要，实体是可以被激活的。而活动实体可以透明的解析关系（我们要做的只是调用getter即可），并且有更新、删除和刷新方法，以便访问持久性功能
GreenDao允许您将协议缓冲区(protobuf)对象直接保存到数据库中。如果您通过protobuf通话到您的服务器，则不需要另一个映射。常规实体的所有持久性操作都可以用于protobuf对象。所以，相信这是GreenDao的独特之处
自动生成代码，我们无需关注实体类以及Dao,因为GreenDao已经帮我们生成了
开源有兴趣的同学可以查看源码，深入去了解机制

3.3.2.3 GreenDao对外提供的核心类简介

3.3.2.3.1 DaoMaster

DaoMaster保存数据库对象（SQLiteDatabase）并管理特定模式的Dao类。它具有静态方法来创建表或将他们删除。其内部类OpenHelper和DevOpenHelper是在SQLite数据库中创建模式的SQLiteOpenHelper实现

3.3.2.3.2 DaoSession

管理特定模式的所有可用Dao对象，您可以使用其中一个getter方法获取。DaoSession还为实体提供了一些通用的持久性方法，如插入，加载，更新，刷新和删除。最后，DaoSession对象也跟踪一个身份范围

3.3.2.3.3 Dao层

数据访问对象(Dao)持续存在并查询实体。对于每个实体，GreenDao生成一个Dao,它比DaoSession有更多的持久化方法，例如：count,loadAll和insertInTx

3.3.2.3.4 实体

持久对象，通常实体是使用标准Java属性(如POJO或JavaBean)来表示数据库的对象

3.3.2.4 GreenDao的使用

3.3.2.4.1 核心步骤

//1.创建数据库
//数据库的名字，高版本手机必须以db结尾
DaoMaster.DevOpenHelper devOpenHelper = new DaoMaster.DevOpenHelper(MyApp.getMyApp(), "student.db");
//2.获取读写对象
DaoMaster daoMaster = new DaoMaster(devOpenHelper.getWritableDatabase());
//3.获取管理器类
DaoSession daoSession = daoMaster.newSession();
//4.获取表对象
studentDao = daoSession.getStudentDao();
daoSession.clear(); // 清除整个session，没有缓存对象返回

3.3.2.4.2 完整步骤

import android.app.Application;
import android.database.sqlite.SQLiteDatabase;
import com.example.greendao.db.DaoMaster;
import com.example.greendao.db.DaoSession;

public class BaseApp extends Application {
    private static BaseApp sInstance;
    private DaoMaster.DevOpenHelper mHelper;
    private DaoMaster mDaoMaster;
    private DaoSession mDaoSession;
    @Override
    public void onCreate() {
        super.onCreate();
        //本类对象
        sInstance=this;
        //创建数据库以及创建数据表
        setDatabase();
    }
    private void setDatabase() {
         //1.创建数据库
        mHelper = new DaoMaster.DevOpenHelper(this, "mydb", null);
        //2.获取读写对象
        SQLiteDatabase db = mHelper.getWritableDatabase();
        db.disableWriteAheadLogging();
        //3.获取管理器类
        mDaoMaster = new DaoMaster(db);
        //4.获取表对象
        mDaoSession=mDaoMaster.newSession();
    }
    public static BaseApp getInstance(){
        return sInstance;
    }
    public DaoSession getDaoSession(){
        return mDaoSession;
    }
}

3.3.2.4.3 插入数据

private void insert() {
        //插入一条数据,相同主键的数据只能插入一次
        //一般不会使用insert,一般使用insertInTx
        beanDao.insert(new Bean(...));
        //插入或替换多条数据
        //插入或者替换,如果没有,插入,如果有,替换
        beanDao.insertOrReplaceInTx(beans);
        ArrayList<Bean> list = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            list.add(new Bean(null, "张三" + i, "" + i));
        }
        //插入多条数据
        beanDao.insertInTx(list);
}

3.3.2.4.4 删除数据

private void delete() {
        //根据key删除数据
        beanDao.deleteByKey(6L);
        //删除某条数据
        beanDao.delete(bean);
        //删除所有数据
        beanDao.deleteAll();
        //删除多条数据
        beanDao.deleteInTx();
}

3.3.2.4.5 修改数据

private void update() {
        //修改指定的数据
        Bean bean = new Bean(3L, "李四", "66");
        beanDao.update(bean);
        //修改多条数据
        beanDao.updateInTx();
}

3.3.2.4.6 查询数据

private void query() {
        //查询所有数据
        List<Bean> list = beanDao.queryBuilder().list();
        tv.setText(list.toString());
        //模糊查询
        List<Bean> list = beanDao.queryBuilder().where(BeanDao.Properties.Name.like("%3%")).list();
        tv.setText(list.toString());
        //条件查询
        //精确查询
        Bean bean = beanDao.queryBuilder().where(BeanDao.Properties.Id.eq(12)).unique();
        tv.setText(bean.toString());
        //区间查询
        //gt 大于 大于5
        List<Bean> list = beanDao.queryBuilder().where(BeanDao.Properties.Id.gt(10)).list();
}

余小盖

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android的常用框架

前言每种编程语言都有其相应的框架，而Android也不例外；那么Android的框架到底有多少种，且其框架相应的特点与构成又是如何的呢？接下来，就让我们一起去学习一下Android的一些常用框架。Android框架的构成图我把我目前所知晓得的一些Android常用的框架以构成图的形式进行展示，从而使Android的常用框架可以更加清晰明了的展现出来，如下构成图：缓存...
复制链接

扫一扫