android 优秀的框架安卓xui框架

转载

智能探索者 2024-05-12 18:53:29

文章标签 android 优秀的框架 ide android 加载 文章分类 Android 移动开发

xUtils简介

xUtils是基于Afinal开发的目前功能比较完善的一个Android开源框架，最近又发布了xUtil3.0，在增加新功能的同时又提高了框架的性能，下面来看看官方（https://github.com/wyouflf/xUtils3）对xUtils3的介绍：

xUtils包含了很多实用的android工具；
xUtils支持超大文件(超过2G)上传，更全面的http请求协议支持(11种谓词)，拥有更加灵活的ORM，更多的事件注解支持且不受混淆影响；
xUtils 最低兼容Android 4.0 (api level 14)；
xUtils3变化较多所以建立了新的项目不在旧版(github.com/wyouflf/xUtils)上继续维护, 相对于旧版本：

HTTP实现替换HttpClient为UrlConnection, 自动解析回调泛型, 更安全的断点续传策略；
支持标准的Cookie策略, 区分domain, path；
事件注解去除不常用的功能, 提高性能；
数据库api简化提高性能, 达到和greenDao一致的性能；
图片绑定支持gif(受系统兼容性影响, 部分gif文件只能静态显示), webp; 支持圆角, 圆形, 方形等裁剪, 支持自动旋转。

目前xUtils主要有四大模块：

ViewUtils模块：

android中的ioc（控制倒转）框架，完全注解方式就可以进行UI，资源和事件绑定；
新的事件绑定方式，使用混淆工具混淆后仍可正常工作；
目前支持常用的20种事件绑定，参见ViewCommonEventListener类和包com.lidroid.xutils.view.annotation.event。

HttpUtils模块：

支持同步，异步方式的请求；
支持大文件上传，上传大文件不会oom；
支持GET，POST，PUT，MOVE，COPY，DELETE，HEAD，OPTIONS，TRACE，CONNECT请求；
下载支持301/302重定向，支持设置是否根据Content-Disposition重命名下载的文件；
返回文本内容的请求(默认只启用了GET请求)支持缓存，可设置默认过期时间和针对当前请求的过期时间。

BitmapUtils模块：

加载bitmap的时候无需考虑bitmap加载过程中出现的oom和android容器快速滑动时候出现的图片错位等现象；
支持加载网络图片和本地图片；
内存管理使用lru算法，更好的管理bitmap内存；
可配置线程加载线程数量，缓存大小，缓存路径，加载显示动画等…

DbUtils模块:

android中的orm（对象关系映射）框架，一行代码就可以进行增删改查；
支持事务，默认关闭；
可通过注解自定义表名，列名，外键，唯一性约束，NOT NULL约束，CHECK约束等（需要混淆的时候请注解表名和列名）；
支持绑定外键，保存实体时外键关联实体自动保存或更新；
自动加载外键关联实体，支持延时加载；
支持链式表达查询，更直观的查询语义，参考下面的介绍或sample中的例子。

项目中快速配置xUtils3

Eclipse用户导入最新jar包和so文件，下载链接添加网络访问权限

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

在Application中初始化xUtils

@Override
    public void onCreate() {
        super.onCreate();
        x.Ext.init(this);
        x.Ext.setDebug(true); //是否输出debug日志，开启debug会影响性能。
    }

xUtils3功能介绍

ViewUtils注解模块的使用

完全注解方式就可以进行UI绑定和事件绑定。
无需findViewById和setClickListener等。

1）Activity的注解的使用如下：

@ContentView(R.layout.activity_main)
public class MainActivity extends Activity {
    @ViewInject(R.id.button1)
    private Button button1;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        x.view().inject(this);
        ...
    }
}

2）Fragment的注解的使用如下：

@ContentView(R.layout.fragment_http)
public class HttpFragment extends Fragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        return x.view().inject(this, inflater, container);
    }
    @Override
    public void onViewCreated(View v, Bundle savedInstanceState) {
        super.onViewCreated(v, savedInstanceState);
    }
}

3）ViewHolder的注解的使用如下：

public class MyAdapter extends BaseAdapter{
         ImageOptions options = new ImageOptions.Builder().setFadeIn(true).build();

        @Override
        public int getCount() {
            return listUrl.size();
        }

        @Override
        public String getItem(int position) {
            return listUrl.get(position);
        }

        @Override
        public long getItemId(int position) {
            return position;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            ViewHolder holder=null;
            if(convertView == null){
                convertView=LayoutInflater.from(BitmapUtilsActivity.this).inflate(R.layout.itemone, null);
                holder = new ViewHolder();
                x.view().inject(holder,convertView);
                convertView.setTag(holder);
            } else {
                holder=(ViewHolder) convertView.getTag();
            }
            x.image().bind(holder.image, getItem(position), options);           
            return convertView;
        }

        class ViewHolder{
            @ViewInject(R.id.image)
            private ImageView image;
        }

4）为按钮设置点击事件

@ViewInject(R.id.button1)
private Button button1;
...
@Override
protected void onCreate(Bundle savedInstanceState) {
    ...
}
/**
 * 用注解的方式为按钮添加点击事件，方法声明必须为private
 * type默认View.OnClickListener.class，故此处可以简化不写
 */
@Event(type = View.OnClickListener.class,value = R.id.button1)
private void testHttpUtils(View v){
    Intent it = new Intent(MainActivity.this, HttpUtilsActivity.class);
    startActivity(it);
}
/**
 * 长按事件
 */
@Event(type = View.OnLongClickListener.class,value = R.id.button2)
private boolean testOnLongClickListener(View v){
    Toast.makeText(this,"testOnLongClickListener",Toast.LENGTH_SHORT).show();
    return true;
}

/**
 * 同时为多个按钮添加点击事件，type用默认
 */
@Event(value = {R.id.button1, R.id.button2, R.id.button3})
    private void getEvent(View view){
        switch(view.getId()){
        case R.id.button1:
            Intent it1 = new Intent(MainActivity.this, HttpUtilsActivity.class);
            startActivity(it1);
            break;
        case R.id.button2:
            Intent it2 = new Intent(MainActivity.this, BitmapUtilsActivity.class);
            startActivity(it2);
            break;
        case R.id.button3:
            Intent it3 = new Intent(MainActivity.this, DbUtilsActivity.class);
            startActivity(it3);
            break;
        }
    }

注意： 1. 使用IOC必须全部为私有，不然无效，这里就不做演示了，不信你可以把用到IOC框架的注解的成员变量及方法全部换成public ,那么全部会无效，当然除了ContentView例外。 2. 所有用到IOC成员变量，使用的时候，必须在x.view().inject(this)后，如果写在前面，那么程序会崩溃。

HttpUtils网络模块的使用

xUtils3网络模块大大方便了在实际开发中网络模块的开发，xUtils3网络模块大致包括GET请求、POST请求、上传文件、下载文件等功能，下面将做一一说明： 1）GET请求

@Event(R.id.get)
private void get(View v){
    final ProgressDialog progressDialog = new ProgressDialog(getActivity());
    progressDialog.setMessage("请稍候...");
    RequestParams params = new RequestParams("http://weather.51wnl.com/weatherinfo/GetMoreWeather");
    params.addQueryStringParameter("cityCode","101020100");
    params.addQueryStringParameter("weatherType","0");
    Callback.Cancelable cancelable = x.http().get(params, new Callback.CommonCallback<String>() {
        @Override
        public void onSuccess(String result) {
            Toast.makeText(HttpUtilsActivity.this, result, Toast.LENGTH_SHORT).show();
            progressDialog.cancel();
        }
        //请求异常后的回调方法
        @Override
        public void onError(Throwable ex, boolean isOnCallback) {
        }
        //主动调用取消请求的回调方法
        @Override
        public void onCancelled(CancelledException cex) {
        }
        @Override
        public void onFinished() {
            progressDialog.cancel();
        }
    });
    //主动调用取消请求
//    cancelable.cancel();
}

2）POST请求

@Event(R.id.post)
private void post(View v){
    RequestParams params = new RequestParams("http://61.129.89.191/SoarAPI/api/SoarTopic");
    params.addParameter("topicId","1002");
    params.addParameter("maxReply","-1");
    params.addParameter("reqApp","1"); //添加请求参数
    params.addBodyParameter("username","abc"); //添加一个请求体
    params.addHeader("head","android"); //添加一个请求头
    x.http().post(params, new Callback.CommonCallback<String>() {
        @Override
        public void onSuccess(String result) {
             MainActivity.showlog("onSuccess-->result="+result);
             Toast.makeText(HttpUtilsActivity.this, result, Toast.LENGTH_SHORT).show();         
        }
        @Override
        public void onError(Throwable ex, boolean isOnCallback) {
        }
        @Override
        public void onCancelled(CancelledException cex) {
        }
        @Override
        public void onFinished() {
        }
    });
}

3）上传文件

@Event(R.id.btn_test3)
    private void upload(View v){
        RequestParams params = new RequestParams("http://192.168.1.112:8080/TopNews_WebProject/UploadFileServlet");
        params.setMultipart(true);
        //这里可以进行多文件上传
        params.addBodyParameter("file",new File("/sdcard/temp/file.jpg"));
        params.addBodyParameter("photo",new File("/sdcard/temp/file0.jpg"),"image/jpeg","hx.jpg");//还传入文件类型和新文件名
        x.http().post(params, new Callback.CommonCallback<String>() {
            @Override
            public void onSuccess(String result) {
                MainActivity.showlog("onSuccess-->result="+result);
                Toast.makeText(HttpUtilsActivity.this, result, Toast.LENGTH_SHORT).show();
            }
            @Override
            public void onError(Throwable ex, boolean isOnCallback) {
                MainActivity.showlog("onError-->Throwable="+ex.getMessage());
            }
            @Override
            public void onCancelled(CancelledException cex) {
                MainActivity.showlog("onCancelled-->CancelledException="+cex.getMessage());
            }
            @Override
            public void onFinished() {
                MainActivity.showlog("onFinished");
            }
        });
    }

4）下载文件这里以下载图片为例进行说明（带下载进度提示），图片下载完成后，自动加载到ImageView。

@Event(R.id.download)
private void download(View v){
    String url = editText.getText().toString();
    RequestParams params = new RequestParams(url);
    //自定义保存路径
    params.setSaveFilePath("/sdcard/temp/");
    //自动为文件命名
    params.setAutoRename(true);
    x.http().post(params, new Callback.ProgressCallback<File>() {
        @Override
        public void onSuccess(File result) {
             try {
                    Bitmap bm = BitmapFactory.decodeStream(new FileInputStream(file));
                    image.setImageBitmap(bm);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                }
        }
        @Override
        public void onError(Throwable ex, boolean isOnCallback) {
        }
        @Override
        public void onCancelled(CancelledException cex) {
        }
        @Override
        public void onFinished() {
        }
        //网络请求之前回调
        @Override
        public void onWaiting() {
        }
        //网络请求开始的时候回调
        @Override
        public void onStarted() {
        }
        //下载的时候不断回调的方法
        @Override
        public void onLoading(long total, long current, boolean isDownloading) {
            //当前进度和文件总大小
            progressBar.setMax((int)total);
            progressBar.setProgress((int)current); 
        }
    });
}

5）直接返回Json对象可以看到上面onSuccess回调返回的都是String，你再仔细看一下发现Callback.CommonCallback接口是支持泛型的，那么怎么让他直接返回对象呢？两个步骤：

泛型参数T写成对象类
对象类注解使用parser将返回的Json字符串解析为对象

看对象类bean文件写法：

@HttpResponse(parser = JsonResponseParser.class)
public class Weather implements Serializable {
    private static final long serialVersionUID = 1L;
    public WeatherInfo weatherinfo;
}

定义JsonResponseParser解析类：

public class JsonResponseParser implements ResponseParser {
    //检查服务器返回的响应头信息
    @Override
    public void checkResponse(UriRequest request) throws Throwable {
    }

    /**
     * 转换result为resultType类型的对象
     *
     * @param resultType  返回值类型(可能带有泛型信息)
     * @param resultClass 返回值类型
     * @param result      字符串数据
     * @return
     * @throws Throwable
     */
    @Override
    public Object parse(Type resultType, Class<?> resultClass, String result) throws Throwable {
        return new Gson().fromJson(result, resultClass);
    }
}

使用：

RequestParams params = new RequestParams("http://weather.51wnl.com/weatherinfo/GetMoreWeather");
            params.addQueryStringParameter("cityCode","101020100");
            params.addQueryStringParameter("weatherType","0");
            Callback.Cancelable cancelable = x.http().get(params, new Callback.CommonCallback<Weather>() {
                public void onSuccess(Weather result) {
                    super.onSuccess(result);
                    Toast.makeText(HttpUtilsActivity.this, result.weatherinfo.toString(), Toast.LENGTH_SHORT).show();
                    MainActivity.showlog(result.weatherinfo.toString());
                }
                @Override
                public void onError(Throwable ex, boolean isOnCallback) {}
                @Override
                public void onCancelled(CancelledException cex) {}
                @Override
                public void onFinished() {}
            });

6）HttpUtils封装这里我对HttpUtils的四个方法进行了封装，使用起来更加方便

public class XUtil {
    /**
     * 发送get请求
     * @param <T>
     */
    public static <T> Cancelable Get(String url,Map<String,String> map,CommonCallback<T> callback){
        RequestParams params=new RequestParams(url);
        if(null!=map){
            for(Map.Entry<String, String> entry : map.entrySet()){
                params.addQueryStringParameter(entry.getKey(), entry.getValue());
            }
        }
        Cancelable cancelable = x.http().get(params, callback);
        return cancelable;
    }

    /**
     * 发送post请求
     * @param <T>
     */
    public static <T> Cancelable Post(String url,Map<String,Object> map,CommonCallback<T> callback){
        RequestParams params=new RequestParams(url);
        if(null!=map){
            for(Map.Entry<String, Object> entry : map.entrySet()){
                params.addParameter(entry.getKey(), entry.getValue());
            }
        }
        Cancelable cancelable = x.http().get(params, callback);
        return cancelable;
    }


    /**
     * 上传文件
     * @param <T>
     */
    public static <T> Cancelable UpLoadFile(String url,Map<String,File> map,CommonCallback<T> callback){
        RequestParams params=new RequestParams(url);
        if(null!=map){
            for(Entry<String, File> entry : map.entrySet()){
                params.addBodyParameter(entry.getKey(), entry.getValue());
            }
        }
        params.setMultipart(true);
        Cancelable cancelable = x.http().get(params, callback);
        return cancelable;
    }

    /**
     * 下载文件
     * @param <T>
     */
    public static <T> Cancelable DownLoadFile(String url,String filepath,CommonCallback<T> callback){
        RequestParams params=new RequestParams(url);
        //设置断点续传
        params.setAutoResume(true);
//      params.setAutoRename(true);
        params.setSaveFilePath(filepath);
        Cancelable cancelable = x.http().get(params, callback);
        return cancelable;
    }
}

使用封装类：

String url="http://weather.51wnl.com/weatherinfo/GetMoreWeather";
        if (useEnclosure) {
            Map<String,String> map=new HashMap<String,String>();
            map.put("cityCode", "101020100");
            map.put("weatherType", "0");
            //这里我用的自定义MyCallBack类，实现了Callback.CommonCallback接口，可以不用重写CommonCallback全部的回调方法，更加方便
            XUtil.Get(url, map, new MyCallBack<Weather>(){
                @Override
                public void onSuccess(Weather result) {
                    super.onSuccess(result);
                    Toast.makeText(HttpUtilsActivity.this, result.weatherinfo.toString(), Toast.LENGTH_SHORT).show();
                    MainActivity.showlog(result.weatherinfo.toString());
                }

                @Override
                public void onError(Throwable ex, boolean isOnCallback) {
                    super.onError(ex, isOnCallback);
                    MainActivity.showlog(ex.getMessage());
                }
            });

BitmapUtils图片模块的使用

现在我们需要设置两个权限，如下：

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

xUtils3图片模块，重点在于加载图片的4个bind方法，loadDrawable与loadFile用法和ImageOptions用法。 1）首先获取ImageView控件

@ViewInject(R.id.image01)
ImageView image01;
@ViewInject(R.id.image02)
ImageView image02;
@ViewInject(R.id.image03)
ImageView image03;
...

2）得到网络图片的地址

String[] urls={
    "http://img.android.com/a.jpg"，
    "http://img.android.com/b.jpg"
    "http://img.android.com/c.jpg"
    ...
};

3）xUtils3显示网络图片方法setPic()如下：

private void setPic() {
    /**
     * 通过ImageOptions.Builder().set方法设置图片的属性
     */
    ImageOptions options = new ImageOptions.Builder().setFadeIn(true).build(); //淡入效果
    //ImageOptions.Builder()的一些其他属性：
    //.setCircular(true) //设置图片显示为圆形
    //.setSquare(true) //设置图片显示为正方形
    //setCrop(true).setSize(200,200) //设置大小
    //.setAnimation(animation) //设置动画
    //.setFailureDrawable(Drawable failureDrawable) //设置加载失败的动画
    //.setFailureDrawableId(int failureDrawable) //以资源id设置加载失败的动画
    //.setLoadingDrawable(Drawable loadingDrawable) //设置加载中的动画
    //.setLoadingDrawableId(int loadingDrawable) //以资源id设置加载中的动画
    //.setIgnoreGif(false) //忽略Gif图片
    //.setParamsBuilder(ParamsBuilder paramsBuilder) //在网络请求中添加一些参数
    //.setRaduis(int raduis) //设置拐角弧度
    //.setUseMemCache(true) //设置使用MemCache，默认true

    /**
     * 加载图片的4个bind方法
     */
    x.image().bind(image01, urls[0]);
    x.image().bind(image02, urls[1], options);
    x.image().bind(image03, urls[2], new Callback.CommonCallback<Drawable>() {
        @Override
        public void onSuccess(Drawable result) {
        }
        @Override
        public void onError(Throwable ex, boolean isOnCallback) {
        }
        @Override
        public void onCancelled(CancelledException cex) {
        }
        @Override
        public void onFinished() {
        }
    });
    x.image().bind(image04, urls[3], options, new Callback.CommonCallback<Drawable>() {
        @Override
        public void onSuccess(Drawable result) {
        }
        @Override
        public void onError(Throwable ex, boolean isOnCallback) {
        }
        @Override
        public void onCancelled(CancelledException cex) {
        }
        @Override
        public void onFinished() {
        }
    });

    /**
     * loadDrawable()方法加载图片
     */
    Callback.Cancelable cancelable = x.image().loadDrawable(urls[0], options, new Callback.CommonCallback<Drawable>() {
        @Override
        public void onSuccess(Drawable result) {
            image03.setImageDrawable(result);
        }
        @Override
        public void onError(Throwable ex, boolean isOnCallback) {
        }
        @Override
        public void onCancelled(CancelledException cex) {
        }
        @Override
        public void onFinished() {
        }
    });
    //主动取消loadDrawable()方法
    //cancelable.cancel();

    /**
     * loadFile()方法
     * 应用场景：当我们通过bind()或者loadDrawable()方法加载了一张图片后，
     * 它会保存到本地文件中，那当我需要这张图片时，就可以通过loadFile()方法进行查找。
     * urls[0]：网络地址
     */
    x.image().loadFile(urls[0],options,new Callback.CacheCallback<File>(){
        @Override
        public boolean onCache(File result) {
            //在这里可以做图片另存为等操作
            Log.i("JAVA","file："+result.getPath()+result.getName());
            return true; //相信本地缓存返回true
        }
        @Override
        public void onSuccess(File result) {
            Log.i("JAVA","file");
        }
        @Override
        public void onError(Throwable ex, boolean isOnCallback) {
        }
        @Override
        public void onCancelled(CancelledException cex) {
        }
        @Override
        public void onFinished() {
        }
    });
}

3）xUtils3显示本地图片方法：

// 加载本地图片
x.image().bind(img, "assets://test.gif", imageOptions);
x.image().bind(img, "/sdcard/test.gif", imageOptions);
x.image().bind(img, "file:///sdcard/test.gif", imageOptions);
x.image().bind(img, new File("/sdcard/test.gif").toURI().toString(), imageOptions);

DbUtils数据库模块的使用

把以下几个问题搞清楚，基本上就覆盖了DbUtils的全部用法了：

如何创建数据库和删除数据库
如何创建删除一张表
如何对表进行增删查改操作
如何建立一表对一表，多表对一表，多表对多表的外键操作

1）创建数据库和删除数据库首先进行配置DaoConfig：

/**
 * DaoConfig配置
 * /
        DbManager.DaoConfig daoConfig = new DbManager.DaoConfig()
                //设置数据库名，默认xutils.db
                .setDbName("watson.db")
                //设置是否允许事务，默认true
                //.setAllowTransaction(true)
                //设置数据库路径，默认安装程序路径下
                .setDbDir(new File(Environment.getExternalStorageDirectory().getAbsolutePath()))
                //设置数据库的版本号
                .setDbVersion(1)    
                //设置数据库更新的监听
                .setDbUpgradeListener(new DbManager.DbUpgradeListener() {
                    @Override
                    public void onUpgrade(DbManager db, int oldVersion, int newVersion) {
                        MainActivity.showlog("数据库版本更新了！oldVersion="+oldVersion+" newVersion="+newVersion);
                    }
                });

然后获取到DbManager：

DbManager db = x.getDb(daoConfig);

DbManager这个类主要做以下几件事情:

1.getDaoConfig 获取数据库的配置信息
2.getDatabase 获取数据库实例
3.saveBindingId saveOrUpdate save 插入数据的3个方法(保存数据)
4.replace 只有存在唯一索引时才有用慎重
5.delete操作的4种方法(删除数据)
6.update操作的2种方法(修改数据)
7.find操作6种方法(查询数据)
8.dropTable 删除表
9.addColumn 添加一列
10.dropDb 删除数据库

其实在这个时候数据库就已经创建了，因为我们还没有添加表，所以这时候数据库中只有一个默认的表android_metadata

android 优秀的框架安卓xui框架_android

那么删除数据库的操作呢？

//删除数据库
@Event(R.id.del_db)
private void delDB(View v) throws DbException {
    db.dropDb();
}

经测试发现此方法并不能删除db文件，只是把数据库中所有的表全部删除。

2）创建表和删除表创建表之前需要先创建对象，看一下bean文件写法吧：

@Table(name = "studentinfo")
public class StudentInfo {
    /**
     * name = "id"：数据库表中的一个字段
     * isId = true：是否是主键
     * autoGen = true：是否自动增长
     * property = "NOT NULL"：添加约束
     */

    @Column(name = "id", isId = true, autoGen = true, property = "NOT NULL")
    private int id;
    @Column(name = "name")
    private String name;
    @Column(name = "age")
    private int age;

    //默认的构造方法必须写出，如果没有，这张表是创建不成功的
    public StudentInfo() {}

    public StudentInfo(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "[id:"+id+" name:"+name+" age:"+age+"]";
    }
}

一个表对应的实体bean需要注意以下几点:

在类名上面加入@Table标签，标签里面的属性name的值就是以后生成的数据库的表的名字。
实体bean里面的属性需要加上@Column标签，这样这个标签的name属性的值会对应数据库里面的表的字段。
实体bean里面的普通属性，如果没有加上@Column标签就不会在生成表的时候在表里面加入字段。
实体bean中必须有一个主键，如果没有主键，表以后不会创建成功，@Column(name = “id”, isId = true, autoGen = true, property = “NOT NULL”)这个属性name的值代表的是表的主键的标识，isId这个属性代表的是该属性是不是表的主键，autoGen代表的是主键是否是自增长，如果不写autoGen这个属性，默认是自增长的属性。property是添加约束条件，这里不能为空。
默认的构造方法必须写出，如果没有，这张表是创建不成功的

那么具体我们什么时候创建表呢？数据库里面表的创建时间，只有在你对数据库里面的操作涉及到这张表的操作时，会先判断当前的表是否存在，如果不存在，才会创建一张表，如果存在，才会进行相应的CRUD操作。

3）对表进行增删查改（CRUD）操作只要我们想进行一张表的CRUD操作，必须先拿到DbManager这个对象。

插入操作

private void createTable() {
        StudentInfo student = new StudentInfo("watson", 28);
        try {
            db.save(student);
            //db.saveOrUpdate(student);
            //db.saveBindingId(student);
        } catch (DbException e) {
            e.printStackTrace();
        }
    }

3种插入操作所需要的参数都是一个实体bean。save和saveOrUpdate的区别就是当一个实体里面的主键一样时如果使用saveOrUpdate会将当前主键对应的这条数据进行替换，而如果你使用了save就会报错。saveBindingId主要是存进去的数据如果当前表有主键会和主键进行绑定关联。

当你执行完这个方法后，你会看到数据库里面studentinfo表里面多了一条数据.

android 优秀的框架安卓xui框架_android 优秀的框架_02

如果你想在表里一次插入多列呢？当然也是可以做到的：

private void insertInfo() {
        //用集合向studentinfo表中插入多条数据
        ArrayList<StudentInfo> studentInfos = new ArrayList<StudentInfo>();
        studentInfos.add(new StudentInfo("zhangsan", 20));
        studentInfos.add(new StudentInfo("lisi", 21));
        studentInfos.add(new StudentInfo("wangwu", 22));
        studentInfos.add(new StudentInfo("zhaoliu", 23));
        studentInfos.add(new StudentInfo("qianqi", 24));
        studentInfos.add(new StudentInfo("sunba", 25));
        //db.save()方法不仅可以插入单个对象，还能插入集合
        try {
            db.save(studentInfos);
            //db.saveOrUpdate(studentInfos);
            //db.saveBindingId(studentInfos);
        } catch (DbException e) {
            e.printStackTrace();
        }
    }

android 优秀的框架安卓xui框架_android 优秀的框架_03

查询操作

1.findById的使用该方法主要是通过主键的值来进行查找表里面的数据。需求：查找上方studentinfo表里面id为3的数据

private void query(){
        try {
            StudentInfo student = db.findById(StudentInfo.class, "3");
            MainActivity.showlog("student:"+student.toString());
        } catch (DbException e) {
            e.printStackTrace();
        }
    }

android 优秀的框架安卓xui框架_加载_04

2.findFirst的使用该方法主要是返回当前表里面的第一条数据。需求：查找上方studentinfo表里面的第一条数据

private void query() {
        try {
            StudentInfo student = db.findFirst(StudentInfo.class);
            MainActivity.showlog("student:"+student.toString());
        } catch (DbException e) {
            e.printStackTrace();
        }
    }

android 优秀的框架安卓xui框架_android 优秀的框架_05

3.findAll的使用该方法主要是返回当前表里面的所有数据。需求:查找studentinfo表里面的所有数据

private void query() {
        try {
            List<StudentInfo> students = db.findAll(StudentInfo.class);
            MainActivity.showlog("students:"+students.toString());
        } catch (DbException e) {
            e.printStackTrace();
        }
    }

android 优秀的框架安卓xui框架_加载_06

4.selector的使用该方法主要是用来进行一些特定条件的查找。需求：查找studentinfo表里面age大于22小于26的学生数据

private void query() {
        try {
            List<StudentInfo> students = db.selector(StudentInfo.class).where("age", ">", 22).and("age", "<", "26").findAll();
            for(StudentInfo student:students){
                MainActivity.showlog("student:"+student.toString());
            }
        } catch (DbException e) {
            e.printStackTrace();
        }
    }

android 优秀的框架安卓xui框架_android 优秀的框架_07

5.findDbModelFirst的使用该方法返回一个DbModel对象，那么该对象是什么呢？DbModel本质就是一个key为当前表的字段，value为当前某条记录的值的一个HashMap。注意sqlInfo对象创建的构造参数只需要传入一个sql语句即可。需求：查找person表中第一条数据的那个人的name和age各是多少

private void query() {
        try {
            DbModel model = db.findDbModelFirst(new SqlInfo("select * from studentinfo"));
            MainActivity.showlog("name:"+model.getString("name"));
            MainActivity.showlog("age:"+model.getString("age"));
        } catch (DbException e) {
            e.printStackTrace(); 
        }
    }

android 优秀的框架安卓xui框架_android_08

6.findDbModelAll的用法该方法的用途就是返回满足sqlInfo信息的所有数据的字段的一个集合。需求：查找studentinfo表中年龄age大于24里面的所有人的姓名

private void query() {
        try {
            List<DbModel> models = db.findDbModelAll(new SqlInfo("select * from studentinfo where age > 24"));
            for(DbModel model : models){
                MainActivity.showlog("name:"+model.getString("name"));
            }
        } catch (DbException e) {
            e.printStackTrace();
        }
    }

android 优秀的框架安卓xui框架_android_09

上面基本把查询的6种方式都说了一遍，当然上面的6种需求不一定完全用上面的查询方法可以查出结果，我这么查询的目的主要是带领大家熟悉一下XUtils3的6种查询方法是如何使用的，会了上面的6种方法，我相信你的查询不会有太大问题，至于复杂的查询无非就是sql语句的基本功力了。

修改操作

修改一共有2种方法: 第一种：需求：我们把上面studentinfo表中id为1的这条记录的age修改为25岁

private void update() {
        try{
            StudentInfo student = db.findById(StudentInfo.class, 1);
            student.setAge(25);
            db.update(student, "age");
        }catch(Exception e){
            e.printStackTrace();
        }
    }

通过方法，我们知道首先要通过DBManager通过查找的方法先找到id为1的这个实体bean，如果你对里面的哪个字段需要修改，只需要重新set这个属性的值，然后调用DBManager.update方法，第一个参数是需要修改的实体，第二个参数是对应的属性。

android 优秀的框架安卓xui框架_android_10

第二种: 需求：将studentinfo表中age为25的学生的name都变成mike

private void update() {
        try {
            List<StudentInfo> students = db.findAll(StudentInfo.class);
            for(StudentInfo student : students){
                student.setName("mike");
                db.update(student, WhereBuilder.b("age", "=", "25"), "name");
                MainActivity.showlog("修改成功");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

android 优秀的框架安卓xui框架_android_11

修改数据一共就2种方法，基本都是需要一个实体bean对象去进行操作的，上面的第二种方法无非就是在修改数据时，多了一个限制条件，这样修改数据显得灵活一些。上面第二种update的方法的参数简单介绍一下：第一个参数:实体bean对象第二个参数:一个WhereBuilder对象，主要是通过静态b方法去构造一个where条件语句第三个参数:需要修改的字段名，如果你的需求是修改了2个或者更多个字段，只需要在后面加上相应的参数即可。例如这里每个学生还有分数score这列。而第二种方法我不止修改name还需要修改score统一为100分，参考如下

private void update() {
        try {
            List<StudentInfo> students = db.findAll(StudentInfo.class);
            for(StudentInfo student : students){
                student.setName("mike");
                student.setScore(100);
                db.update(student, WhereBuilder.b("age", "=", "25"), "name", "score");
                MainActivity.showlog("修改成功");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

删除操作

1.deleteById的用法该方法主要是根据表的主键进行单条记录的删除需求：删除上方person表中id为5的记录

private void delete() {
        try {
            db.deleteById(StudentInfo.class, 5);
            MainActivity.showlog("删除成功");
        } catch (DbException e) {
            e.printStackTrace();
        }
    }

android 优秀的框架安卓xui框架_android 优秀的框架_12

2.delete(Object entity)的用法该方法主要是根据实体bean进行对表里面的一条或多条数据进行删除需求：删除表中第一条name为mike这条信息的记录

private void delete() {
        try {
            StudentInfo student = db.selector(StudentInfo.class).where("name", "=", "mike").findFirst();
            db.delete(student);
        } catch (DbException e) {
            e.printStackTrace(); 
        }
    }

android 优秀的框架安卓xui框架_加载_13

3.delete(Class<\?> entityType) 该方法主要是用来删除表格里面的所有数据，但是注意：表还会存在，只是表里面数据没有了

private void delete() {
        try {
            db.delete(StudentInfo.class);
            MainActivity.showlog("删除成功");           
        } catch (DbException e) {
            e.printStackTrace(); 
        }
    }

4.delete(Class<\?> entityType, WhereBuilder whereBuilder) 该方法主要是根据where语句的条件进行删除操作需求：将studentinfo表中age为24并且name为qianqi的信息删除

private void delete() {
        try {
            db.delete(StudentInfo.class, WhereBuilder.b("age", "=", "24").and("name", "=", "qianqi"));
        } catch (DbException e) {
            e.printStackTrace();
        }
    }

5.dropTable(Class<\?> entityType) 该方法是用来删除指定的表

private void delete() {
        try {
            db.dropTable(StudentInfo.class);
        } catch (DbException e) {
            e.printStackTrace();
        }
    }

6.dropDb() 该方法是用来删除数据库

private void delete() {
        try {
            db.dropDb();
        } catch (DbException e) {
            e.printStackTrace();
        }
    }

经测试发现此方法并不能删除db文件，只是把数据库中所有的表全部删除。

其他方法1.addColumn(Class<\?> entityType, String column) 需求：在上方表中加入一个score字段 StudentInfo的实体代码如下:

@Table(name = "studentinfo")
public class StudentInfo {
    /**
     * name = "id"：数据库表中的一个字段
     * isId = true：是否是主键
     * autoGen = true：是否自动增长
     * property = "NOT NULL"：添加约束
     */

    @Column(name = "id", isId = true, autoGen = true, property = "NOT NULL")
    private int id;
    @Column(name = "name")
    private String name;
    @Column(name = "age")
    private int age;
    @Column(name = "score")
    private int score;

    public StudentInfo(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //默认的构造方法必须写出，如果没有，这张表是创建不成功的
    public StudentInfo() {}

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "[id:"+id+" name:"+name+" age:"+age+" score:"+score+"]";
    }
}

private void addColumn() {
        try {
            db.addColumn(StudentInfo.class, "score");
        } catch (DbException e) {
            e.printStackTrace();
        }
    }

执行完addColumn方法，我们看到studentinfo表里面多了一个score字段。

android 优秀的框架安卓xui框架_ide_14

总结：上面主要介绍了XUtils3的数据库模块，包括如何创建数据库，如何创建表，如何给表进行添加一列，如何对表进行增删查改的操作。说了这么多，相信大家肯定对XUtils3的数据库模块有了一个基本的理解，至于一表对一表，多表对一表，多表对多表等等这类需求，无非就是在某个表里面加入一个字段，或者创建一个第三方表用来维护表与表之间的关系，这种类型的例子我就不举例说明了，原因是那些需求都离不开上面的增删查改的方法，我相信你只要把上面的方法完全会用，你的XUtils3的数据库模块的基本使用就不会有问题了。

Demo下载地址

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。