开源项目之Android DataFramework（数据库框架）

最新推荐文章于 2023-02-15 11:45:00 发布
最新推荐文章于 2023-02-15 11:45:00 发布
阅读量6.6k 收藏 4
点赞数 2
分类专栏： android 移动平台
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/banketree/article/details/9106289
版权

DataFramework是Android的SQLite数据库框架，在程序中,可以通过编写一个xml文件创建,修改,删除数据库记录！项目如图：



项目不包含demo就7个目标文件，源码分析如下：

public class DataFramework { // 操作类，主要是操作成员DataFrameworkCore的
public class Entity { //实体类收集的信息从数据库中的记录
public class EntityCursor implements Cursor, Iterable<Entity> { //实例每行的集合
public abstract class EntityEditActivity extends Activity // 界面操作基础类
public class DataFrameworkCore { // 核心 操作数据库的封装
public class Field { //字段的封装
public class Table { //表的封装

核心源码如下：

public class DataFrameworkCore { // 核心 操作数据库的封装

	private final static int TYPESQL_INSERT = 0;
	private final static int TYPESQL_UPDATE = 1;
	private final static int TYPESQL_DELETE = 2;

	private String mPackage = "";

	private ArrayList<String> mLanguages = new ArrayList<String>();
	private String mCurrentLanguage;

	private SQLiteDatabase mDb;
	private DatabaseHelper mDbHelper;
	private ArrayList<Table> mTables; // 表的操作
	private String mDataBaseName = "";
	private int mDataBaseOldVersion = 0;
	private int mDataBaseVersion = 0;
	private Context mCtx;

	private boolean mSaveInitialValues = false;

	/**
	 * Constructor
	 */
	public DataFrameworkCore() {

	}

	private class DatabaseHelper extends SQLiteOpenHelper {

		DatabaseHelper() {
			super(mCtx, mDataBaseName, null, mDataBaseVersion);
		}

		@Override
		public void onCreate(SQLiteDatabase db) {
			try {
				System.out.println("(onCreate) CREATE TABLES");
				mDataBaseOldVersion = 0;

				ArrayList<Table> tables = mTables;
				int tableCount = tables.size();
				for (int i = 0; i < tableCount; i++)
					db.execSQL(tables.get(i).getSQLCreateTable());

				mSaveInitialValues = true;
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		@Override
		public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
			Log.w("TableDB", "Upgrading database from version " + oldVersion
					+ " to " + newVersion);
			mDataBaseOldVersion = oldVersion;

			ArrayList<Table> tables = mTables;
			int tableCount = tables.size();
			for (int i = 0; i < tableCount; i++) {
				Table t = tables.get(i);
				if (add(t.getNewInVersion(), oldVersion, newVersion)) {
					System.out.println("(onUpgrade) CREATE TABLE: "
							+ t.getName());
					db.execSQL(t.getSQLCreateTable());
				} else {
					ArrayList<Field> fields = t.getFields();
					int fieldCount = fields.size();
					for (int j = 0; j < fieldCount; j++) {
						Field f = fields.get(j);
						if (add(f.getNewInVersion(), oldVersion, newVersion)) {
							String sql = t.getSQLAddField(f);
							if (sql != null) {
								System.out
										.println("(onUpgrade) ADD FIELD: "
												+ t.getName() + "("
												+ f.getName() + ")");
								db.execSQL(sql);
							}
						}
					}

				}
			}
			mSaveInitialValues = true;
		}

		private boolean add(int version, int oldVersion, int newVersion) {
			if (version > oldVersion && version <= newVersion)
				return true;
			else
				return false;
		}
	}

	public void open(Context context, String namePackage,
			ArrayList<Table> tables) throws XmlPullParserException, IOException { // 打开一个数据库
		try {
			if (tables.size() == 0) {
				mPackage = namePackage;
				mTables = tables;
				mCtx = context;
				int idTables = context.getResources().getIdentifier(
						namePackage + ":xml/tables", null, null);

				if (idTables != 0) {
					XmlResourceParser x = mCtx.getResources().getXml(idTables);
					int eventType = x.getEventType();
					Table currentTable = new Table("");
					Field currentField = new Field("");
					while (eventType != XmlPullParser.END_DOCUMENT) {

						if (eventType == XmlPullParser.START_TAG) {
							if (x.getName().equals("database")) {
								mDataBaseName = x.getAttributeValue(null,
										"name");
								mDataBaseVersion = Integer.parseInt(x
										.getAttributeValue(null, "version"));
								if (x.getAttributeValue(null, "languages") != null) {
									boolean isFirst = true;
									StringTokenizer tokens = new StringTokenizer(
											x.getAttributeValue(null,
													"languages"), "|");
									while (tokens.hasMoreTokens()) {
										String token = tokens.nextToken();
										mLanguages.add(token);
										if (isFirst) {
											mCurrentLanguage = token;
											isFirst = false;
										}
										if (Locale.getDefault().getLanguage()
												.equals(token))
											mCurrentLanguage = token;
									}
									System.out
											.println("Lenguaje por defecto usado en la base de datos: "
													+ mCurrentLanguage);
								}
							} else if (x.getName().equals("table")) {
								currentTable = new Table(x.getAttributeValue(
										null, "name"));
								if (x.getAttributeValue(null, "to-string") != null)
									currentTable.setToString(x
											.getAttributeValue(null,
													"to-string"));
								if (x.getAttributeValue(null, "backup") != null) {
									if (x.getAttributeValue(null, "backup")
											.equals("no"))
										currentTable.setBackup(false);
								}
								if (x.getAttributeValue(null, "new-in-version") != null) {
									currentTable.setNewInVersion(Integer
											.parseInt(x.getAttributeValue(null,
													"new-in-version")));
								}
							} else if (x.getName().equals("field")) {
								currentField = new Field(x.getAttributeValue(
										null, "name"));
								if (x.getAttributeValue(null, "type") != null)
									currentField.setType(x.getAttributeValue(
											null, "type"));
								if (x.getAttributeValue(null, "foreign-table") != null)
									currentField.setForeignTable(x
											.getAttributeValue(null,
													"foreign-table"));
								if (x.getAttributeValue(null, "obligatory") != null) {
									if (x.getAttributeValue(null, "obligatory") == "true")
										currentField.setObligatory(true);
								}
								if (x.getAttributeValue(null, "size") != null)
									currentField.setSize(Integer.parseInt(x
											.getAttributeValue(null, "size")));
								if (x.getAttributeValue(null, "default") != null)
									currentField
											.setTextDefault(x
													.getAttributeValue(null,
															"default"));
								if (x.getAttributeValue(null, "new-in-version") != null) {
									currentField.setNewInVersion(Integer
											.parseInt(x.getAttributeValue(null,
													"new-in-version")));
								}
								currentTable.addField(currentField);
							}
						}

						if (eventType == XmlPullParser.END_TAG) {
							if (x.getName().equals("table")) {
								tables.add(currentTable);
							}
						}

						eventType = x.next();
					}
					x.close();

				} else {

					System.out
							.println("=========================================");
					System.out
							.println("No se ha encontrado el archivo tables.xml");
					System.out
							.println("=========================================");

				}

			}

			mSaveInitialValues = false;

			mDbHelper = new DatabaseHelper();
			mDb = mDbHelper.getWritableDatabase();

			if (mSaveInitialValues)
				saveInitialValues();

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void close() { // 关闭
		mDbHelper.close();
	}

	public void saveInitialValues() throws XmlPullParserException, IOException { // 插入一条数据
		try {
			for (int i = mDataBaseOldVersion + 1; i <= mDataBaseVersion; i++) {
				int idInitialValues = mCtx.getResources().getIdentifier(
						mPackage + ":xml/initialvalues_v" + i, null, null);
				if (idInitialValues != 0) {
					XmlResourceParser x = mCtx.getResources().getXml(
							idInitialValues);
					insertXML(x);
				}
			}

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void backup(String file) throws XmlPullParserException, IOException { //备份
		backup(file, false);
	}

	public void backup(String file, boolean forceBackup)
			throws XmlPullParserException, IOException { // 备份
		File f = new File(file);
		if (f.exists())
			f.delete();
		FileOutputStream fOut = new FileOutputStream(file);
		OutputStreamWriter osw = new OutputStreamWriter(fOut);

		osw.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<values>\n");

		List<Table> tables = mTables;
		int tableCount = tables.size();
		System.out.println("tablas: " + tables.size());

		for (int i = 0; i < tableCount; i++) {
			Table t = tables.get(i);

			if (t.isBackup() || forceBackup) {

				String tableName = t.getName();

				System.out.println("tabla: " + tableName);

				String[] aux = t.getFieldsToArray();
				Cursor c = getDB().query(tableName, aux, null, null, null,
						null, null);

				c.moveToFirst();

				ArrayList<Field> fields = t.getFields();
				int fieldCount = fields.size();

				while (!c.isAfterLast()) {
					osw.append("<row table=\""
							+ tableName
							+ "\" id=\""
							+ c.getString(c
									.getColumnIndex(DataFramework.KEY_ID))
							+ "\">\n");

					for (int j = 0; j < fieldCount; j++) {
						Field field = fields.get(j);
						if (c.getString(c.getColumnIndex(field.getName())) != null)
							osw.append("<field name=\""
									+ field.getName()
									+ "\" value=\""
									+ c.getString(
											c.getColumnIndex(field.getName()))
											.replace("\"", """)
									+ "\" />\n");
					}

					osw.append("</row>\n");
					c.moveToNext();

				}
				c.close();

			}

		}

		osw.append("</values>\n");

		osw.flush();

		osw.close();

	}

	public void restore(String file) throws XmlPullParserException, IOException {
		try { // 还原
			XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
			XmlPullParser x = (XmlPullParser) factory.newPullParser();
			x.setInput(new FileReader(file));
			insertXML(x);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private void insertXML(XmlPullParser x) throws XmlPullParserException,
			IOException { // 根据xml的规则插入数据
		try {

			int eventType = x.getEventType();

			Entity currenEntity = null;
			int typesql = TYPESQL_INSERT;

			while (eventType != XmlPullParser.END_DOCUMENT) {

				if (eventType == XmlPullParser.START_TAG) {
					if (x.getName().equals("row")) {

						currenEntity = null;

						if (x.getAttributeValue(null, "table") != null) {
							long id = -1;
							if (x.getAttributeValue(null, "action") != null) {
								if (x.getAttributeValue(null, "action").equals(
										"update")) {
									typesql = TYPESQL_UPDATE;
								} else if (x.getAttributeValue(null, "action")
										.equals("delete")) {
									typesql = TYPESQL_DELETE;
								} else {
									typesql = TYPESQL_INSERT;
								}
							} else {
								typesql = TYPESQL_INSERT;
							}

							if (x.getAttributeValue(null, "id") != null) {
								id = Long.parseLong(x.getAttributeValue(null,
										"id"));
							}

							if (typesql == TYPESQL_INSERT) {
								currenEntity = new Entity(x.getAttributeValue(
										null, "table"));
								if (id > 0)
									currenEntity.setForceId(id);
							} else if (typesql == TYPESQL_UPDATE) {
								if (id > 0)
									currenEntity = new Entity(
											x.getAttributeValue(null, "table"),
											id);
							} else {
								if (id > 0)
									currenEntity = new Entity(
											x.getAttributeValue(null, "table"),
											id);
							}
						}

					}

					if (x.getName().equals("field")) {
						if (x.getAttributeValue(null, "lang") != null) {
							if ((x.getAttributeValue(null, "name") != null)
									&& (x.getAttributeValue(null, "value") != null)) {
								if (currenEntity != null)
									currenEntity.setMultilanguageValue(
											x.getAttributeValue(null, "name"),
											x.getAttributeValue(null, "lang"),
											x.getAttributeValue(null, "value"));
							}
						} else {
							if ((x.getAttributeValue(null, "name") != null)
									&& (x.getAttributeValue(null, "value") != null)) {
								if (currenEntity != null) {
									if (x.getAttributeValue(null, "value") != null) {
										currenEntity.setValue(
												x.getAttributeValue(null,
														"name"),
												x.getAttributeValue(null,
														"value").replace(
														""", "\""));
									}
								}
							}
						}
					}

				}

				if (eventType == XmlPullParser.END_TAG) {
					if (x.getName().equals("row")) {
						if (currenEntity != null) {
							if (typesql == TYPESQL_DELETE) {
								currenEntity.delete();
							} else {
								currenEntity.save();
							}
						}
					}
				}

				eventType = x.next();
			}

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public SQLiteDatabase getDB() { // 获得数据库
		return mDb;
	}

	public Context getContext() { // 获得句柄
		return mCtx;
	}

	public String getPackage() { // 获取包
		return mPackage;
	}

	public void setForceLanguage(String lang) { //
		if (mLanguages.contains(lang))
			mCurrentLanguage = lang;
	}

	public ArrayList<String> getLanguages() { // 获取支持的语言组
		return mLanguages;
	}

	public String getCurrentLanguage() { // 获得当前语言
		return mCurrentLanguage;
	}

}

如何使用它们呢？它们有什么规范吗？

xml的规范如下，分别有database、tables、field、表值！

tables.xml 规范
demo1:
<database name="notes_db" version="1">
  <table name="notes" to-string="%title%">
    <field name="title" obligatory="true" type="text" size="128"/>
    <field name="body" obligatory="true" type="text"/>
    <field name="category_id" type="foreign-key" foreign-table="categories" />
  </table>
  <table name="categories" to-string="%name%">
    <field name="name" obligatory="true" type="name" size="128"/>
  </table>
 </database>
demo2:
<database name="notes_db" version="2">
  <table name="notes" to-string="%title%">
    <field name="title" obligatory="true" type="text" size="128"/>
    <field name="body" obligatory="true" type="text"/>
    <field name="category_id" type="foreign-key" foreign-table="categories" />
    <field name="importance_id" type="foreign-key" foreign-table="importance" new-in-
version="2" />
  </table>
  <table name="categories" to-string="%name%">
    <field name="name" obligatory="true" type="name" size="128"/>
  </table>
  <table name="importance" to-string="%name%" new-in-version="2">
    <field name="name" obligatory="true" type="name" size="128"/>
  </table>
 </database>
字段以及字段值
<values>
  <row table="categories" id="1">
    <field name="name" value="Sin categoria" />
  </row>
  <row table="categories" id="2">
    <field name="name" value="Familia" />
  </row>
  <row table="categories" id="3">
    <field name="name" value="Amigos" />
  </row>  
</values>
数据库语言xml规范以及操作如下： 

<database name="nombre_db" version="1" languages="es|en|de">
<field name="titulo" obligatory="true" type="multilanguage" /> //多种语言操作
DataFramework.getInstance().setForceLanguage("en"); //实例
如何它们使用？ 

//初始化
try {
    DataFramework.getInstance().open(this, "com.tu.paquete"); 
} catch (Exception e) {
    e.printStackTrace();
}
//不使用了就关闭它
 DataFramework.getInstance().close();
Entity 的使用如下： 

创建一个新的记录
Entity ent = new Entity("categoria");
ent.setValue("nombre", "Coche");
ent.save();

修改记录
Entity ent = new Entity("categoria", 3);
ent.setValue("nombre", "Motocicleta");
ent.save();

删除一条记录
Entity ent = new Entity("categoria", 3);
ent.delete();

浏览表
List<Entity> categories = DataFramework.getInstance().getEntityList("personal", 

"categoria_id = 3", "fecha asc");

Iterator iter = categories.iterator();
while (iter.hasNext()) {
  Entity ent = (Entity)iter.next();
  System.out.println(ent.getString("nombre"));
}

从数据库中的数据装入一个微调
private Spinner mCategory;
private List<Entity> categories;
...
categories = DataFramework.getInstance().getEntityList("categories", "", "position asc");
ArrayAdapter<Entity> adapter = new ArrayAdapter<Entity>(this, 
android.R.layout.simple_spinner_item, categories);
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
mCategory.setAdapter(adapter);

好了，来看一个实例： 

public class Ejemplo extends ListActivity { //主界面
        private RowEjemploAdapter adapter;
        public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        try {
            DataFramework.getInstance().open(this, "com.tu.paquete");
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        setContentView(R.layout.main);
        adapter = new RowEjemploAdapter(this, DataFramework.getInstance().getEntityList("categories"));
        setListAdapter(adapter);
        }
        
    @Override
        protected void onListItemClick(ListView l, View v, int position, long id) {
                super.onListItemClick(l, v, position, id); 
                Toast.makeText(this, "Id: " + adapter.getItem(position).getId(), Toast.LENGTH_LONG).show();
        }
        
    @Override
    protected void onDestroy() {
        super.onDestroy();
        DataFramework.getInstance().close();
    }  
}

public class RowEjemploAdapter extends BaseAdapter { //适配器
    private Context mContext;
    private List<Entity> elements;
         
    public RowEjemploAdapter (Context mContext, List<Entity> elements)
    {
        this.mContext = mContext;
        this.elements = elements;
    }
        public int getCount() {
                return elements.size();
        }
        public Entity getItem(int position) {
                return (Entity)elements.get(position);
        }
        public long getItemId(int position) {
                return position;
        }
        public View getView(int position, View convertView, ViewGroup parent) {
                Entity item = elements.get(position);
                View v = View.inflate(mContext, R.layout.row, null);
                TextView lTitle = (TextView)v.findViewById(R.id.name);
                lTitle.setText(item.getString("name"));
                return v;
        }
}

Main.xml 布局

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
        <ListView
                android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                android:id="@id/android:list"/>
        <TextView
                android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                android:id="@id/android:empty"
                android:text="@string/no_items"
                android:gravity="center_vertical|center_horizontal" />
</RelativeLayout>
row.xml  xml赋值 

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="wrap_content" android:layout_height="wrap_content" android:orientation="vertical"> <TextView android:layout_height="wrap_content" android:layout_width="wrap_content" android:text="nombre" android:id="@+id/name"/></LinearLayout>

既然是数据库操作，当然也支持sql语句，如下规范经测试也行。

db.execSQL("CREATE TEMPORARY TABLE __"
                + DB_TABLE
                + " (_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR UNIQUE, times_used int(3) DEFAULT(0),"
                + " selected BOOLEAN DEFAULT(0), updated_at LONG DEFAULT(0), color INTEGER DEFAULT(0)); "
                + "INSERT INTO __" + DB_TABLE + " SELECT _id, name, times_used, selected, updated_at, color FROM " + DB_TABLE + ";"
                + "DROP TABLE " + DB_TABLE + ";"
                + "CREATE TABLE "
                + DB_TABLE
                + " (_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR UNIQUE, times_used int(3) DEFAULT(0),"
                + " selected BOOLEAN DEFAULT(0), updated_at LONG DEFAULT(0), color INTEGER DEFAULT(0));"
                + "INSERT INTO " + DB_TABLE + " SELECT _id, name, times_used, selected, updated_at, color FROM __" + DB_TABLE + ";"
                + "DROP TABLE __" + DB_TABLE + ";");


介绍完毕，欢迎使用，项目下载！


半棵树
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android DataFramework数据库框架
06-16
DataFramew是Android的SQLite数据库框架，在程序中,可以通过编写一个xml文件创建,修改,删除数据库记录！
Android Framework 记录之一
xiaoheliushuiya
06-04 1106
简介 之前的研究太偏向应用层功能实现了，很多原理不了解没有深究，现在研究framework框架层了。 记录 1、下载源码，目录如下： 2、Android系统的层次如下： 3、项目目录简单分析如下： 4、telphony目录 文件 描述 CellIdentityCdma //描述电信通信标识 CellIdentityGsm...
Android开源的数据库框架
weixin_30659829的博客
07-11 272
　　平常进行Android数据库开发时，都是使用原生的API，即SQLiteDatabase。但，使用系统的API开发时，尤其是SQL语句的书写时经常出现一些问题，因此便出现了许多针对数据库开发的开源框架，例：LiteOrm、GreenDao、Realm等。本篇文章主要是介绍Android中常用的几个数据库框架，以便了解。 　　声明：在每个框架前都有对应的原文出处。一、LiteOrm:　　 ...
AndroidDataFramework(数据库开源框架使用)
lijianqun的专栏
11-01 443
DataFramework 是Android的SQLite数据库框架，在程序中,可以通过编写一个xml文件创建,修改,删除数据库记录！ 没必要啰嗦啥，先看项目结构    第一步：下载DataFramework库，链接我就不写了，自己动手丰衣足食。 第二步：在Eclipse中创建一个项目（如AndyGo） ，导入【第一步】下载的库文件，该库只包含7个文件【见上图】，
LitePal：一开源的android数据库框架
o417082034的博客
09-16 470
在写项目的时候遇到了数据库的相关操作，Android 提供的数据库的创建和使用感觉有点小复杂，想着有没有比较好的轮子–框架或者工具类可以使用，结果发现了litepal，一个类似于hibernate，面向对象的方式对数据库进行开发。在万物皆对象的世界，使用起来觉得太爽了。 LitePal是一款开源的android数据库框架（https://github.com/LitePalFramework/Li...
Android Litepal数据库开源框架使用
07-02
Litepal简单使用增删改查、升级数据表等功能
Android SQLite数据库框架greenDAO 源码
10-26
greenDAO是一个可以帮助Android开发者快速将Java对象映射到SQLite数据库的表单中的ORM解决方案，通过使用一个简单的面向对象API，开发者可以对Java对象进行存储、更新、删除和查询。
Android开源数据库框架LitePal的应用分析.pdf
09-21
Android开源数据库框架LitePal的应用分析.pdf
WMRouter：美团外卖Android开源路由框架
01-27
WMRouter是一款Android路由框架，基于组件化的设计思路，功能灵活，使用也比较简单。WMRouter最初用于解决美团外卖C端App在业务演进过程中的实际问题，之后逐步推广到了美团其他App，因此我们决定将其开源，希望更多...
Android 开源框架源码解读.txt
04-26
第5章 LeakCanary内存泄漏框架解析和相关面试题分析 第6章 butterknife依赖注入框架源码解析 第8章 eventbus异步框架源码解析 第9章 dagger2依赖注入框架源码解析 第10章 rxjava异步框架源码解析 第11章 ...
深入Android Framework开发（入门篇）
06-22
广大的Android应用开发者是不是对Android系统充满着好奇，是不是很想学习Android系统开发，可惜自己学习难度又太大，本课程将手把手教你学Android Framework开发，带你走进Android系统开发的殿堂，全课程以实战为主，让你自己动手可以定制自己喜欢的Android系统，让你的Android职业道路越走越顺。 学完本课程能让你学会如下知识点: -学习Framework背景及它的巨大作用 -Android源码环境搭建及让自己系统第一次跑起来 -学习Frameowork开发的一些必要基础知识 -学习怎么进行Android源码定位分析，实例：Activity启动流程源码分析 -实战开发Frameowork项目--去除第三方应用入口广告页
Amigos_Project_2
02-24
Amigos_Project_2
emotion-classification:基于 EEG 情感分类的依赖最大化特征选择
07-11
情绪分类 基于 EEG 情绪分类的依赖最大化特征选择。 该项目已作为 IIT 德里 2014 年秋季学期神经网络课程的一部分完成。 主管：Jayadeva博士 作者 Rishi Dua T Veeranjaneya Ashok 安装 安装 Python 和 scikit 将 DEAP 数据集（cPickle 预处理）复制到 data/raw 文件夹 运行脚本.sh 文档 请参阅 docs/readme.pdf 贡献 源代码： : 执照 该项目是根据 MIT 许可条款获得许可的。 有关详细信息，请参阅 LICENSE.txt
Android Framework框架
一叶知秋的博客
06-02 733
选自《Android内核剖析》    Framework定义了客户端组件和服务端组件功能及接口。包含3个主要部分：服务端，客户端和Linux驱动。 (一）服务端    服务端主要包含两个重要类，分别是WindowManagerService(Wms)和ActivityManagerService(Ams)。Wms的作用是为所有的应用程序分配窗口，并管理这些窗口。包括分配窗口大小，调节
【Spark分布式内存计算框架——Spark SQL】4. DataFrame（上）
CSDNGuoYuying的博客
02-15 316
而右侧的DataFrame却提供了详细的结构信息，使得Spark SQL可以清楚地知道该数据集中包含哪些列，每列的名称和类型各是什么。使得Spark SQL得以洞察更多的结构信息，从而对藏于DataFrame背后的数据源以及作用于DataFrame之上的变换进行针对性的优化，最终达到大幅提升运行时效率。在Spark中，DataFrame是一种以RDD为基础的分布式数据集，类似于传统数据库中的二维表格。1）、分布式的数据集，并且以列的方式组合的，相当于具有schema的RDD；第三步、读取雇员信息数据。
DataFrame学习
qq_24920947的博客
09-03 314
Series类型： https://blog.csdn.net/brucewong0516/article/details/79196902 DataFrame： https://www.yiibai.com/pandas/python_pandas_dataframe.html 数据帧(DataFrame)是二维数据结构，即数据以行和列的表格方式排列。 数据帧(DataFrame)的功...
数据框体Dataframe的基本使用
weixin_38094100的博客
04-05 210
文章目录一、 什么是DF 数据框体？二、动手实战环节实战1:创建数据框架DF(字典创建法)实战2:创建数据框架DF(CSV创建法)实战3:行列式访问实战4:DF的常规操作实战5:索引键的使用： 什么是DF 数据框体 一、 什么是DF 数据框体？ DataFrame是一种表格型数据结构，它含有一组有序的列，每列可以 是不同的值。DataFrame既有行索引，也有列索引，它可以看作是由 Series组成的字典，不过这些Series公用一个索引。 DataFrame的创建有多种方式，不过最重要的还是根据dict进
mybatis数据库框架
RollingInTheDeepc的博客
06-18 582
mybatis数据库框架 mybatis架构设计 mybatis主配置文件(sqlMapConfig.xml) - SqlMapConfig配置文件为mybatis的主配置文件 配置项 配置内容 mapper映射文件 加载所有的映射文件到主配置文件中 插件配置 如mybatis的分页插件的配置 别名配置 别名配置主要是用...
什么是CoreData FrameWork ?
henry_sea的专栏
08-18 2232
备注下：以后要深究 http://www.apple.com.cn/developer/iphone/library/documentation/iPhone/Conceptual/iOs_TechOverview/CoreServicesLayer/CoreServicesL
flutter开源项目玩android
最新发布
11-23
flutter是一个开源的跨平台移动应用开发框架，它允许开发者使用单一的代码库来构建适配于Android和iOS平台的应用程序。对于想要玩转Android开发的开发者来说，使用flutter可以带来许多便利和效率。 首先，flutter采用了响应式UI框架，可以轻松构建漂亮的用户界面。开发者可以使用丰富的widget库来创建各种各样的交互组件，从而快速构建出符合Android平台设计规范的应用界面。 其次，flutter提供了丰富的插件系统，可以轻松接入Android原生的功能和第三方SDK。开发者可以通过插件来调用Android平台的各种系统功能，例如相机、地理位置、传感器等，同时也可以集成各种第三方服务，如支付、地图、社交等，从而拓展应用的功能。 此外，flutter还支持热重载功能，开发者可以在不重新启动应用的情况下快速修改代码并实时查看效果。这大大提高了开发效率，省去了频繁编译和安装的时间，让开发者更加专注于应用的逻辑和交互设计。 总的来说，通过使用flutter开发Android应用，开发者可以获得更快的开发速度、更好的用户界面体验和更高的性能表现，从而更加轻松、快捷地玩转Android开发。Flutter的开源特性也为开发者提供了更多的灵活性和自由度，使他们能够更好地发挥创造力，构建出更加优秀的Android应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值