基础复习——内容共享——通过ContentProvider封装数据——通过ContentResolver访问数据...

约定不等于承诺〃 2023-09-28 21:27 71阅读 0赞

![d12ac96f7ee26e5383a8f028dc9c917e.png][]

![894d01e38e7e1bdd32bdbb1afd9de310.png][]

![04cf0bb9d6eb125ef3aea8da9ddea370.png][]

![f6cf363558d03f67f347fe30b0ae79ed.png][]

利用ContentProvider只实现服务端App的数据封装，如果客户端App想访问对方的内部数据，就要通过内容解析器ContentResolver访问。

内容解析器是客户端App操作服务端数据的工具，相对应的内容提供器是服务端的数据接口。

ContentResolver提供的方法与ContentProvider是一一对应的，比如query、insert、update、delete、getType等方法

![8980f47f0178384af96d2cea3a7ed864.png][]

==================================================================================================

0、前提，用户信息表信息： UserInfo

package com.example.myapplication.bean;
    
    public class UserInfo {
        public long rowid; // 行号
        public int xuhao; // 序号
        public String name; // 姓名
        public int age; // 年龄
        public long height; // 身高
        public float weight; // 体重
        public boolean married; // 婚否
        public String update_time; // 更新时间
        public String phone; // 手机号
        public String password; // 密码
    
        public UserInfo() {
            rowid = 0L;
            xuhao = 0;
            name = "";
            age = 0;
            height = 0L;
            weight = 0.0f;
            married = false;
            update_time = "";
            phone = "";
            password = "";
        }
    }

![5f7ea822cd93fc6090078715bff54bb6.png][]

1、编写用户信息表的数据库帮助器： UserDBHelper

package com.example.myapplication.database;
    
    import android.annotation.SuppressLint;
    import android.content.ContentValues;
    import android.content.Context;
    import android.database.Cursor;
    import android.database.sqlite.SQLiteDatabase;
    import android.database.sqlite.SQLiteOpenHelper;
    import android.util.Log;
    import com.example.myapplication.bean.UserInfo;
    import java.util.ArrayList;
    import java.util.List;
    
    @SuppressLint("DefaultLocale")
    public class UserDBHelper extends SQLiteOpenHelper
    {
        private static final String TAG = "UserDBHelper";
        private static final String DB_NAME = "user.db"; // 数据库的名称
        private static final int DB_VERSION = 1; // 数据库的版本号
        private static UserDBHelper mHelper = null; // 数据库帮助器的实例
        private SQLiteDatabase mDB = null; // 数据库的实例
        public static final String TABLE_NAME = "user_info"; // 表的名称
    
    
        private UserDBHelper(Context context)
        {
            super(context, DB_NAME, null, DB_VERSION);
        }
    
        private UserDBHelper(Context context, int version)
        {
            super(context, DB_NAME, null, version);
        }
    
        // 利用单例模式获取数据库帮助器的唯一实例
        public static UserDBHelper getInstance(Context context, int version)
        {
            if (version > 0 && mHelper == null)
            {
                mHelper = new UserDBHelper(context, version);
            }
            else if (mHelper == null)
            {
                mHelper = new UserDBHelper(context);
            }
            return mHelper;
        }
    
        // 打开数据库的读连接
        public SQLiteDatabase openReadLink()
        {
            if (mDB == null || !mDB.isOpen())
            {
                mDB = mHelper.getReadableDatabase();
            }
    
            return mDB;
        }
    
        // 打开数据库的写连接
        public SQLiteDatabase openWriteLink()
        {
            if (mDB == null || !mDB.isOpen())
            {
                mDB = mHelper.getWritableDatabase();
            }
    
            return mDB;
        }
    
        // 关闭数据库连接
        public void closeLink()
        {
            if (mDB != null && mDB.isOpen())
            {
                mDB.close();
                mDB = null;
            }
        }
    
        // 创建数据库，执行建表语句
        public void onCreate(SQLiteDatabase db)
        {
            Log.d(TAG, "onCreate");
            String drop_sql = "DROP TABLE IF EXISTS " + TABLE_NAME + ";";
            Log.d(TAG, "drop_sql:" + drop_sql);
            db.execSQL(drop_sql);
            String create_sql = "CREATE TABLE IF NOT EXISTS " + TABLE_NAME + " ("
                    + "_id INTEGER PRIMARY KEY  AUTOINCREMENT NOT NULL,"
                    + "name VARCHAR NOT NULL," + "age INTEGER NOT NULL,"
                    + "height LONG NOT NULL," + "weight FLOAT NOT NULL,"
                    + "married INTEGER NOT NULL," + "update_time VARCHAR NOT NULL"
                    //演示数据库升级时要先把下面这行注释
                    + ",phone VARCHAR" + ",password VARCHAR"
                    + ");";
    
            Log.d(TAG, "create_sql:" + create_sql);
    
            db.execSQL(create_sql); // 执行完整的SQL语句
        }
    
        // 修改数据库，执行表结构变更语句
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
        {
            Log.d(TAG, "onUpgrade oldVersion=" + oldVersion + ", newVersion=" + newVersion);
    
            if (newVersion > 1)
            {
                //Android的ALTER命令不支持一次添加多列，只能分多次添加
                String alter_sql = "ALTER TABLE " + TABLE_NAME + " ADD COLUMN " + "phone VARCHAR;";
                Log.d(TAG, "alter_sql:" + alter_sql);
                db.execSQL(alter_sql);
                alter_sql = "ALTER TABLE " + TABLE_NAME + " ADD COLUMN " + "password VARCHAR;";
                Log.d(TAG, "alter_sql:" + alter_sql);
                db.execSQL(alter_sql);
            }
        }
    
        // 根据指定条件删除表记录
        public int delete(String condition)
        {
            // 执行删除记录动作，该语句返回删除记录的数目
            return mDB.delete(TABLE_NAME, condition, null);
        }
    
    
        // 删除该表的所有记录
        public int deleteAll()
        {
            // 执行删除记录动作，该语句返回删除记录的数目
            return mDB.delete(TABLE_NAME, "1=1", null);
        }
    
    
        // 往该表添加一条记录
        public long insert(UserInfo info)
        {
            List<UserInfo> infoList = new ArrayList<UserInfo>();
            infoList.add(info);
            return insert(infoList);
        }
    
        // 往该表添加多条记录
        public long insert(List<UserInfo> infoList)
        {
            long result = -1;
    
            for (int i = 0; i < infoList.size(); i++)
            {
                UserInfo info = infoList.get(i);
                List<UserInfo> tempList = new ArrayList<UserInfo>();
    
                // 如果存在同名记录，则更新记录
                // 注意条件语句的等号后面要用单引号括起来
                if (info.name != null && info.name.length() > 0)
                {
                    String condition = String.format("name='%s'", info.name);
                    tempList = query(condition);
    
                    if (tempList.size() > 0)
                    {
                        update(info, condition);
                        result = tempList.get(0).rowid;
                        continue;
                    }
    
                }
    
                // 如果存在同样的手机号码，则更新记录
                if (info.phone != null && info.phone.length() > 0)
                {
                    String condition = String.format("phone='%s'", info.phone);
                    tempList = query(condition);
    
                    if (tempList.size() > 0)
                    {
                        update(info, condition);
                        result = tempList.get(0).rowid;
                        continue;
                    }
                }
    
                // 不存在唯一性重复的记录，则插入新记录
                ContentValues cv = new ContentValues();
    
                cv.put("name", info.name);
                cv.put("age", info.age);
                cv.put("height", info.height);
                cv.put("weight", info.weight);
                cv.put("married", info.married);
                cv.put("update_time", info.update_time);
                cv.put("phone", info.phone);
                cv.put("password", info.password);
    
                // 执行插入记录动作，该语句返回插入记录的行号
                result = mDB.insert(TABLE_NAME, "", cv);
    
                if (result == -1)  // 添加成功则返回行号，添加失败则返回-1
                {
                    return result;
                }
            }
    
            return result;
        }
    
        // 根据条件更新指定的表记录
        public int update(UserInfo info, String condition)
        {
            ContentValues cv = new ContentValues();
            cv.put("name", info.name);
            cv.put("age", info.age);
            cv.put("height", info.height);
            cv.put("weight", info.weight);
            cv.put("married", info.married);
            cv.put("update_time", info.update_time);
            cv.put("phone", info.phone);
            cv.put("password", info.password);
            // 执行更新记录动作，该语句返回更新的记录数量
            return mDB.update(TABLE_NAME, cv, condition, null);
        }
    
        public int update(UserInfo info)
        {
            // 执行更新记录动作，该语句返回更新的记录数量
            return update(info, "rowid=" + info.rowid);
        }
    
        // 根据指定条件查询记录，并返回结果数据列表
        public List<UserInfo> query(String condition)
        {
            String sql = String.format("select rowid,_id,name,age,height,weight,married,update_time," +
                    "phone,password from %s where %s;", TABLE_NAME, condition);
    
            Log.d(TAG, "query sql: " + sql);
    
            List<UserInfo> infoList = new ArrayList<UserInfo>();
    
            // 执行记录查询动作，该语句返回结果集的游标
            Cursor cursor = mDB.rawQuery(sql, null);
    
            // 循环取出游标指向的每条记录
            while (cursor.moveToNext())
            {
                UserInfo info = new UserInfo();
                info.rowid = cursor.getLong(0); // 取出长整型数
                info.xuhao = cursor.getInt(1); // 取出整型数
                info.name = cursor.getString(2); // 取出字符串
                info.age = cursor.getInt(3);
                info.height = cursor.getLong(4);
                info.weight = cursor.getFloat(5); // 取出浮点数
                //SQLite没有布尔型，用0表示false，用1表示true
                info.married = (cursor.getInt(6) == 0) ? false : true;
                info.update_time = cursor.getString(7);
                info.phone = cursor.getString(8);
                info.password = cursor.getString(9);
                infoList.add(info);
            }
    
            cursor.close(); // 查询完毕，关闭数据库游标
    
            return infoList;
        }
    
        // 根据手机号码查询指定记录
        public UserInfo queryByPhone(String phone)
        {
            UserInfo info = null;
            List<UserInfo> infoList = query(String.format("phone='%s'", phone));
    
            if (infoList.size() > 0)
            {
                info = infoList.get(0);
            }
    
            return info;
        }
    
    }

![0ab24674e1728c1f80141b790b2c58b5.png][]

2、编写内容提供器的基础字段类：UerInfoContent

package com.example.myapplication.provider;
    
    import android.net.Uri;
    import android.provider.BaseColumns;
    import com.example.myapplication.database.UserDBHelper;
    
    public class UserInfoContent implements BaseColumns
    {
        // 这里的名称必须与AndroidManifest.xml里的android:authorities保持一致
        public static final String AUTHORITIES = "com.example.chapter07.provider.UserInfoProvider";
    
    
        //  内容提供器的外部表名
        public static final String TABLE_NAME = UserDBHelper.TABLE_NAME;
    
    
        // 访问内容提供器的URI
        public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITIES + "/user");
    
    
        // 下面是该表的各个字段名称
        public static final String USER_NAME = "name";
        public static final String USER_AGE = "age";
        public static final String USER_HEIGHT = "height";
        public static final String USER_WEIGHT = "weight";
        public static final String USER_MARRIED = "married";
    
    
        // 默认的排序方法
        public static final String DEFAULT_SORT_ORDER = "_id desc";
    }

![214a0c12ed190a45917a9a4273b8aed9.png][]

3、通过右键菜单，创建内容提供器：UserInfoProvider

package com.example.myapplication.provider;
    
    import android.content.ContentProvider;
    import android.content.ContentUris;
    import android.content.ContentValues;
    import android.content.UriMatcher;
    import android.database.Cursor;
    import android.database.sqlite.SQLiteDatabase;
    import android.net.Uri;
    import com.example.myapplication.database.UserDBHelper;
    
    public class UserInfoProvider extends ContentProvider
    {
        private final static String TAG = "UserInfoProvider";
    
        private UserDBHelper userDB; // 声明一个用户数据库的帮助器对象
    
        public static final int USER_INFO = 1; // Uri匹配时的代号
    
        public static final UriMatcher uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
    
        static { // 往Uri匹配器中添加指定的数据路径
            uriMatcher.addURI(UserInfoContent.AUTHORITIES, "/user", USER_INFO);
        }
    
        // 创建ContentProvider时调用，可在此获取具体的数据库帮助器实例
        @Override
        public boolean onCreate()
        {
            userDB = UserDBHelper.getInstance(getContext(), 1);
            return true;
        }
    
        // 插入数据
        @Override
        public Uri insert(Uri uri, ContentValues values)
        {
            if (uriMatcher.match(uri) == USER_INFO)   // 匹配到了用户信息表
            {
                // 获取SQLite数据库的写连接
                SQLiteDatabase db = userDB.getWritableDatabase();
    
                // 向指定的表插入数据，返回记录的行号
                long rowId = db.insert(UserInfoContent.TABLE_NAME, null, values);
    
                if (rowId > 0)   // 判断插入是否执行成功
                {
                    // 如果添加成功，就利用新记录的行号生成新的地址
                    Uri newUri = ContentUris.withAppendedId(UserInfoContent.CONTENT_URI, rowId);
                    // 通知监听器，数据已经改变
                    getContext().getContentResolver().notifyChange(newUri, null);
                }
    
                db.close(); // 关闭SQLite数据库连接
            }
    
            return uri;
        }
    
        // 根据指定条件删除数据
        @Override
        public int delete(Uri uri, String selection, String[] selectionArgs)
        {
            int count = 0;
    
            if (uriMatcher.match(uri) == USER_INFO)   // 匹配到了用户信息表
            {
                // 获取SQLite数据库的写连接
                SQLiteDatabase db = userDB.getWritableDatabase();
                // 执行SQLite的删除操作，并返回删除记录的数目
                count = db.delete(UserInfoContent.TABLE_NAME, selection, selectionArgs);
                db.close(); // 关闭SQLite数据库连接
            }
            return count;
        }
    
        // 根据指定条件查询数据库
        @Override
        public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)
        {
            Cursor cursor = null;
    
            if (uriMatcher.match(uri) == USER_INFO)   // 匹配到了用户信息表
            {
                // 获取SQLite数据库的读连接
                SQLiteDatabase db = userDB.getReadableDatabase();
                // 执行SQLite的查询操作
                cursor = db.query(UserInfoContent.TABLE_NAME,
                        projection, selection, selectionArgs, null, null, sortOrder);
                // 设置内容解析器的监听
                cursor.setNotificationUri(getContext().getContentResolver(), uri);
            }
            return cursor; // 返回查询结果集的游标
        }
    
        // 获取Uri支持的数据类型，暂未实现
        @Override
        public String getType(Uri uri)
        {
            throw new UnsupportedOperationException("Not yet implemented");
        }
    
        // 更新数据，暂未实现
        @Override
        public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs)
        {
            throw new UnsupportedOperationException("Not yet implemented");
        }
    }

![ebe466679976d4fd40a080eb889ccadb.png][]

![226245642e0f8bd2a4b5640c73939dfd.png][]

![87fd698c06d5c3e8af6f69d608616277.png][]

![7f7f4e7e6a2e958477caf134b0934353.png][]

写数据：

布局：

![ee8c6bd7c2f65cf1c10726a909e9cd7f.png][]

代码：

package com.example.myapplication;
    
    import android.annotation.SuppressLint;
    import android.content.ContentValues;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.EditText;
    import androidx.appcompat.app.AppCompatActivity;
    import com.example.myapplication.bean.UserInfo;
    import com.example.myapplication.provider.UserInfoContent;
    
    @SuppressLint("DefaultLocale")
    public class ContentWriteActivity extends AppCompatActivity implements View.OnClickListener
    {
        private static final String TAG = "ContentWriteActivity";
        private EditText et_name;
        private EditText et_age;
        private EditText et_height;
        private EditText et_weight;
    
        @Override
        protected void onCreate(Bundle savedInstanceState)
        {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_content_write);
    
            et_name = findViewById(R.id.et_name);
            et_age = findViewById(R.id.et_age);
            et_height = findViewById(R.id.et_height);
            et_weight = findViewById(R.id.et_weight);
    
            findViewById(R.id.btn_add_user).setOnClickListener(this);
        }
    
        @Override
        public void onClick(View v)
        {
    
            if (v.getId() == R.id.btn_add_user)
            {
                UserInfo user = new UserInfo();
                user.name = et_name.getText().toString();
                user.age = Integer.parseInt(et_age.getText().toString());
                user.height = Integer.parseInt(et_height.getText().toString());
                user.weight = Float.parseFloat(et_weight.getText().toString());
                addUser(user); // 添加一条用户记录
            }
    
        }
    
        // 添加一条用户记录
        private void addUser(UserInfo user)
        {
            ContentValues name = new ContentValues();
            name.put("name", user.name);
            name.put("age", user.age);
            name.put("height", user.height);
            name.put("weight", user.weight);
            name.put("married", 0);
            name.put("update_time", DateUtil.getNowDateTime(""));
    
            // 通过内容解析器往指定Uri添加用户信息
            getContentResolver().insert(UserInfoContent.CONTENT_URI, name);
    
            ToastUtil.show(this, "成功添加用户信息");
    
        }
    
    }

![70f2c93051b458c27171e434663e4671.png][]

![a792e28c23f46cc60ecc04622b0aacfd.png][]

读数据：

布局：

![9284d41a6e01769920c9e802c4c17104.png][]

代码：

package com.example.myapplication;
    
    import androidx.appcompat.app.AppCompatActivity;
    import android.annotation.SuppressLint;
    import android.database.Cursor;
    import android.graphics.Color;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.LinearLayout;
    import android.widget.TextView;
    import com.example.myapplication.bean.UserInfo;
    import com.example.myapplication.util.Utils;
    import com.example.myapplication.provider.UserInfoContent;
    import java.util.ArrayList;
    import java.util.List;
    
    @SuppressLint("DefaultLocale")
    public class ContentReadActivity extends AppCompatActivity implements View.OnClickListener
    {
        private static final String TAG = "ContentReadActivity";
    
        private TextView tv_desc;
        private LinearLayout ll_list; // 用户信息列表的线性布局
    
        @Override
        protected void onCreate(Bundle savedInstanceState)
        {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_content_read);
    
    
            findViewById(R.id.btn_delete).setOnClickListener(this);
    
            tv_desc = findViewById(R.id.tv_desc);
            ll_list = findViewById(R.id.ll_list);
    
            showAllUser(); // 显示所有的用户记录
        }
    
        // 显示所有的用户记录
        @SuppressLint("Range")
        private void showAllUser()
        {
            List<UserInfo> userList = new ArrayList<UserInfo>();
    
            // 通过内容解析器从指定Uri中获取用户记录的游标
            Cursor cursor = getContentResolver().query(UserInfoContent.CONTENT_URI, null, null, null, null);
    
            // 循环取出游标指向的每条用户记录
            while (cursor.moveToNext())
            {
                UserInfo user = new UserInfo();
                user.name = cursor.getString(cursor.getColumnIndex(UserInfoContent.USER_NAME));
                user.age = cursor.getInt(cursor.getColumnIndex(UserInfoContent.USER_AGE));
                user.height = cursor.getInt(cursor.getColumnIndex(UserInfoContent.USER_HEIGHT));
                user.weight = cursor.getFloat(cursor.getColumnIndex(UserInfoContent.USER_WEIGHT));
                userList.add(user); // 添加到用户信息列表
            }
    
            cursor.close(); // 关闭数据库游标
    
            String contactCount = String.format("当前共找到%d个用户", userList.size());
    
            tv_desc.setText(contactCount);
    
            ll_list.removeAllViews(); // 移除线性布局下面的所有下级视图
    
            for (UserInfo user : userList)  // 遍历用户信息列表
            {
                String contactDesc = String.format("姓名为%s，年龄为%d，身高为%d，体重为%f\n", user.name, user.age, user.height, user.weight);
                TextView tv_contact = new TextView(this); // 创建一个文本视图
                tv_contact.setText(contactDesc);
                tv_contact.setTextColor(Color.BLACK);
                tv_contact.setTextSize(17);
    
                int pad = Utils.dip2px(this, 5);
    
                tv_contact.setPadding(pad, pad, pad, pad); // 设置文本视图的内部间距
    
                ll_list.addView(tv_contact); // 把文本视图添加至线性布局
    
            }
        }
    
        @Override
        public void onClick(View v)
        {
            if (v.getId() == R.id.btn_delete)
            {
                getContentResolver().delete(UserInfoContent.CONTENT_URI, "1=1", null);
    
                showAllUser();
    
                ToastUtil.show(this, "已删除所有记录");
            }
        }
    }

![660ed13ef03e6de3cf8b2751df8c5866.png][]

![84bd2f9c97fe6b16daba55926f89a6db.png][]

![47ea9d4c8a0eb0bcbe611523dea584c0.png][]

Utils

package com.example.myapplication.util;
    
    import android.content.Context;
    
    public class Utils {
        // 根据手机的分辨率从 dp 的单位 转成为 px(像素)
        public static int dip2px(Context context, float dpValue) {
            // 获取当前手机的像素密度(1个dp对应几个px)
            float scale = context.getResources().getDisplayMetrics().density;
            return (int) (dpValue * scale + 0.5f); // 四舍五入取整
        }
    
        // 根据手机的分辨率从 px(像素) 的单位 转成为 dp
        public static int px2dip(Context context, float pxValue) {
            // 获取当前手机的像素密度(1个dp对应几个px)
            float scale = context.getResources().getDisplayMetrics().density;
            return (int) (pxValue / scale + 0.5f); // 四舍五入取整
        }
    
    }

![008a4398eb48bd6903c28d345db7efd8.png][]

ToastUtil

package com.example.myapplication.util;
    
    import android.content.Context;
    import android.widget.Toast;
    
    public class ToastUtil {
    
        public static void show(Context ctx, String desc) {
            Toast.makeText(ctx, desc, Toast.LENGTH_SHORT).show();
        }
    }

![f7a313c15296f0e7c2aa5e87a9f00430.png][]

DateUtil

package com.example.myapplication.util;
    
    import android.annotation.SuppressLint;
    import android.text.TextUtils;
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Date;
    
    @SuppressLint("SimpleDateFormat")
    public class DateUtil 
    {
        // 获取当前的日期时间
        public static String getNowDateTime(String formatStr)
        {
            String format = formatStr;
    
            if (TextUtils.isEmpty(format))
            {
                format = "yyyyMMddHHmmss";
            }
    
            SimpleDateFormat sdf = new SimpleDateFormat(format);
    
            return sdf.format(new Date());
        }
    
        // 获取当前的时间
        public static String getNowTime()
        {
            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
            return sdf.format(new Date());
        }
    
        // 获取当前的时间(精确到毫秒)
        public static String getNowTimeDetail()
        {
            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");
            return sdf.format(new Date());
        }
    
        public static String formatDate(long time)
        {
            Date date = new Date(time);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            return sdf.format(date);
        }
    
        public static String getDate(Calendar calendar) {
            Date date = calendar.getTime();
            // 创建一个日期格式化的工具
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            // 将当前日期时间按照指定格式输出格式化后的日期时间字符串
            return sdf.format(date);
        }
    
        public static String getMonth(Calendar calendar) {
            Date date = calendar.getTime();
            // 创建一个日期格式化的工具
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
            // 将当前日期时间按照指定格式输出格式化后的日期时间字符串
            return sdf.format(date);
        }
    
        public static Date formatString(String strTime) {
            Date date = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            try {
                date = sdf.parse(strTime);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return date;
        }
    
    }

![6c8cff1424ed1a20c24499736a0e042a.png][]

![b3554ac237bd7729cb7e88f0cc3f895e.png][]

![3d9f2bd8593e6728902e9321b974c9b6.png][]

![3184385466f68452295f02e718630a1e.png][]

========================================================================================================

![6b94f643daafd4191765ec4ae00bf532.png][]

![18bb445f6721b65c09a9a72002955f9f.png][]

![58b376311171dac61e8d39f2b1a64fa7.png][]

![c177a4077f3988f060ff1e9328fddd5c.png][]

![ab707c3b24a6cc2b032cd474fd7faa7b.png][]

![2a3a110ab3fcde171489ac4c65b2246e.png][]

![6b5b144b287defb68e231bed992ea37d.png][]

![1b0419d307dbe5a3d4c858cf0f90b7e8.png][]

![e5b04431000c0f6bdcd31ecc1555a070.png][]

![f03c5fd515cef02a39d4b1d74a8a0d8d.png][]

![a38eade353125e5a504c0621f00b7aef.png][]

![69e0f9e3201c1ade032b22dd315f84ec.png][]

[d12ac96f7ee26e5383a8f028dc9c917e.png]: https://img-blog.csdnimg.cn/img_convert/d12ac96f7ee26e5383a8f028dc9c917e.png
[894d01e38e7e1bdd32bdbb1afd9de310.png]: https://img-blog.csdnimg.cn/img_convert/894d01e38e7e1bdd32bdbb1afd9de310.png
[04cf0bb9d6eb125ef3aea8da9ddea370.png]: https://img-blog.csdnimg.cn/img_convert/04cf0bb9d6eb125ef3aea8da9ddea370.png
[f6cf363558d03f67f347fe30b0ae79ed.png]: https://img-blog.csdnimg.cn/img_convert/f6cf363558d03f67f347fe30b0ae79ed.png
[8980f47f0178384af96d2cea3a7ed864.png]: https://img-blog.csdnimg.cn/img_convert/8980f47f0178384af96d2cea3a7ed864.png
[5f7ea822cd93fc6090078715bff54bb6.png]: https://img-blog.csdnimg.cn/img_convert/5f7ea822cd93fc6090078715bff54bb6.png
[0ab24674e1728c1f80141b790b2c58b5.png]: https://img-blog.csdnimg.cn/img_convert/0ab24674e1728c1f80141b790b2c58b5.png
[214a0c12ed190a45917a9a4273b8aed9.png]: https://img-blog.csdnimg.cn/img_convert/214a0c12ed190a45917a9a4273b8aed9.png
[ebe466679976d4fd40a080eb889ccadb.png]: https://img-blog.csdnimg.cn/img_convert/ebe466679976d4fd40a080eb889ccadb.png
[226245642e0f8bd2a4b5640c73939dfd.png]: https://img-blog.csdnimg.cn/img_convert/226245642e0f8bd2a4b5640c73939dfd.png
[87fd698c06d5c3e8af6f69d608616277.png]: https://img-blog.csdnimg.cn/img_convert/87fd698c06d5c3e8af6f69d608616277.png
[7f7f4e7e6a2e958477caf134b0934353.png]: https://img-blog.csdnimg.cn/img_convert/7f7f4e7e6a2e958477caf134b0934353.png
[ee8c6bd7c2f65cf1c10726a909e9cd7f.png]: https://img-blog.csdnimg.cn/img_convert/ee8c6bd7c2f65cf1c10726a909e9cd7f.png
[70f2c93051b458c27171e434663e4671.png]: https://img-blog.csdnimg.cn/img_convert/70f2c93051b458c27171e434663e4671.png
[a792e28c23f46cc60ecc04622b0aacfd.png]: https://img-blog.csdnimg.cn/img_convert/a792e28c23f46cc60ecc04622b0aacfd.png
[9284d41a6e01769920c9e802c4c17104.png]: https://img-blog.csdnimg.cn/img_convert/9284d41a6e01769920c9e802c4c17104.png
[660ed13ef03e6de3cf8b2751df8c5866.png]: https://img-blog.csdnimg.cn/img_convert/660ed13ef03e6de3cf8b2751df8c5866.png
[84bd2f9c97fe6b16daba55926f89a6db.png]: https://img-blog.csdnimg.cn/img_convert/84bd2f9c97fe6b16daba55926f89a6db.png
[47ea9d4c8a0eb0bcbe611523dea584c0.png]: https://img-blog.csdnimg.cn/img_convert/47ea9d4c8a0eb0bcbe611523dea584c0.png
[008a4398eb48bd6903c28d345db7efd8.png]: https://img-blog.csdnimg.cn/img_convert/008a4398eb48bd6903c28d345db7efd8.png
[f7a313c15296f0e7c2aa5e87a9f00430.png]: https://img-blog.csdnimg.cn/img_convert/f7a313c15296f0e7c2aa5e87a9f00430.png
[6c8cff1424ed1a20c24499736a0e042a.png]: https://img-blog.csdnimg.cn/img_convert/6c8cff1424ed1a20c24499736a0e042a.png
[b3554ac237bd7729cb7e88f0cc3f895e.png]: https://img-blog.csdnimg.cn/img_convert/b3554ac237bd7729cb7e88f0cc3f895e.png
[3d9f2bd8593e6728902e9321b974c9b6.png]: https://img-blog.csdnimg.cn/img_convert/3d9f2bd8593e6728902e9321b974c9b6.png
[3184385466f68452295f02e718630a1e.png]: https://img-blog.csdnimg.cn/img_convert/3184385466f68452295f02e718630a1e.png
[6b94f643daafd4191765ec4ae00bf532.png]: https://img-blog.csdnimg.cn/img_convert/6b94f643daafd4191765ec4ae00bf532.png
[18bb445f6721b65c09a9a72002955f9f.png]: https://img-blog.csdnimg.cn/img_convert/18bb445f6721b65c09a9a72002955f9f.png
[58b376311171dac61e8d39f2b1a64fa7.png]: https://img-blog.csdnimg.cn/img_convert/58b376311171dac61e8d39f2b1a64fa7.png
[c177a4077f3988f060ff1e9328fddd5c.png]: https://img-blog.csdnimg.cn/img_convert/c177a4077f3988f060ff1e9328fddd5c.png
[ab707c3b24a6cc2b032cd474fd7faa7b.png]: https://img-blog.csdnimg.cn/img_convert/ab707c3b24a6cc2b032cd474fd7faa7b.png
[2a3a110ab3fcde171489ac4c65b2246e.png]: https://img-blog.csdnimg.cn/img_convert/2a3a110ab3fcde171489ac4c65b2246e.png
[6b5b144b287defb68e231bed992ea37d.png]: https://img-blog.csdnimg.cn/img_convert/6b5b144b287defb68e231bed992ea37d.png
[1b0419d307dbe5a3d4c858cf0f90b7e8.png]: https://img-blog.csdnimg.cn/img_convert/1b0419d307dbe5a3d4c858cf0f90b7e8.png
[e5b04431000c0f6bdcd31ecc1555a070.png]: https://img-blog.csdnimg.cn/img_convert/e5b04431000c0f6bdcd31ecc1555a070.png
[f03c5fd515cef02a39d4b1d74a8a0d8d.png]: https://img-blog.csdnimg.cn/img_convert/f03c5fd515cef02a39d4b1d74a8a0d8d.png
[a38eade353125e5a504c0621f00b7aef.png]: https://img-blog.csdnimg.cn/img_convert/a38eade353125e5a504c0621f00b7aef.png
[69e0f9e3201c1ade032b22dd315f84ec.png]: https://img-blog.csdnimg.cn/img_convert/69e0f9e3201c1ade032b22dd315f84ec.png