2013年3月 总版技术专家分月排行榜第三
2014年5月 移动开发大版内专家分月排行榜第一2014年4月 移动开发大版内专家分月排行榜第一
2014年6月 移动开发大版内专家分月排行榜第一2014年3月 移动开发大版内专家分月排行榜第一
2014年11月 移动开发大版内专家分月排行榜第二2014年4月 移动开发大版内专家分月排行榜第二2014年2月 移动开发大版内专家分月排行榜第二
匿名用户不能发表回复！|
每天回帖即可获得10分可用分！小技巧：
你还可以输入10000个字符
(Ctrl+Enter)
请遵守CSDN，不得违反国家法律法规。
转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。老罗Android开发视频教程（7） - 服务器端JDBC编程
- 爱酷学习网，免费高清视频教程在线观看
Begin to Learn
Descritpion
JDBC是Java连接数据库的框架，在Android里内置的SQLite也需要JDBC连接数据库。
Update Completed
请输入正确的邮件（格式：xxx@xxx.xx）
必须填本条信息！上传时间：
56官方微信
扫一扫发现精彩SQL学习笔记之数据库专题（三）：Android下Sqlite数据库ORM框架之GreenDao详解
在大型项目中，android的数据库操作不可能再像第二篇文章那样，用最基础的API去实现各方面的操作，那样效率会十分的底下。那么，在android开发中，提拱了androrm，Ormlite,greenDao三个主流框架，博主三生有幸，再开发第一个项目的时候，就被逼着学习使用greenDao这个ORM框架。现在回过头看，greenDao似乎是三种框架中效率最高的，但是对于初学者来说，使用起来非常的不方面，因为官方是纯英文文档，例子也不够详细。博主那个时候真的是在前进中摸索，各种坎坷，网上的博文介绍的都不够详细，不能满足博主的需求，对于数据库的多表设计，网上的例子也都不够详细，而且大部分都是从官方文档直接copy过来，并不是自己写的，更不会有注释。对于新手不好上手。最近这段时间博主比较有时间，于是整理之前的笔记，在数据库专题来详细讲解一下greendao的使用。博主从零开始，一段一段代码自己敲，并配上注释，保证新手容易上手。熟练掌握greendao的使用。
GreenDao官网：/
GreenDao github下载地址：/greenrobot/greenDAO
GreenDao设计目的：最大性能，最快的Android ORM框架，易于使用的API，高度优化，最小内存的损耗
有兴趣的同学可以将完整的工程下载下来学习，看完后绝对可以掌握GreenDao的使用，可以直接拿去自己的项目工程里使用
示例代码下载地址：http://download.csdn.net/detail/victorfreedom/8353631
好了，废话说完了，接下来一步一步的开发一个使用greenDao的android项目工程。 一、新建一个JAVA工程，用于装载GreenDao类，生成Dao类文件。
在这个工程里面必须导入
greendao-generator.jar和freemarker.jar或者直接在下载下来的例子里面的de.greenrobot.daogenerator包内容导入
博主的项目结构如图：
接下来，我们来写Dao类文件的生成代码，详情请看代码：
package com.batways.apopo.
import de.greenrobot.daogenerator.DaoG
import de.greenrobot.daogenerator.E
import de.greenrobot.daogenerator.P
import de.greenrobot.daogenerator.S
import de.greenrobot.daogenerator.ToM
* @ClassName: TestCase
* @author victor_freedom (x_freedom_)
* @createddate
下午2:17:52
* @Description: TODO
public class TestCase {
// 数据库升级
private static int dbVersion = 1;
private String modelPackage = &com.example.freedomsql.bean&;
private Schema schema = new Schema(dbVersion, modelPackage);
public static void main(String[] args) throws Exception {
TestCase testCase = new TestCase();
testCase.init();
testCase.schema.enableKeepSectionsByDefault();
testCase.schema.enableActiveEntitiesByDefault();
new DaoGenerator().generateAll(testCase.schema,
&E:\\mayflygeek\\mayflygeekprojects\\FreedomSql\\src&);
public void init() {
// 定义一个实体
Entity OrderHeader = schema.addEntity(&OrderHeader&);
// 实现序列化接口
OrderHeader.implementsSerializable();
// 定义ID主键
OrderHeader.addIdProperty();
// 增加其他字段，这里可以定义很多类型，还可以指定属性
OrderHeader.addStringProperty(&orderName&).notNull();
//如果不想用上面的定义ID主键，还可以自己这样定义。
OrderHeader.addLongProperty(&orderId&).primaryKey().autoincrement();
//后面的实体定义和上面的差不多。就不在详细描述
Entity OrderItem = schema.addEntity(&OrderItem&);
OrderItem.implementsSerializable();
OrderItem.addIdProperty();
OrderItem.addStringProperty(&itemName&);
// 用于做多表设计使用
Property orderId = OrderItem.addLongProperty(&orderId&).getProperty();
Entity Student = schema.addEntity(&Student&);
Student.implementsSerializable();
Student.addIdProperty();
Student.addStringProperty(&studentName&);
// 增加一个字段，数据库升级
// Student.addDoubleProperty(&results&);
Entity Teacher = schema.addEntity(&Teacher&);
Teacher.implementsSerializable();
Teacher.addIdProperty();
Teacher.addStringProperty(&teacherName&);
Entity StudentTeacher = schema.addEntity(&StudentTeacher&);
Property teacherId = StudentTeacher.addLongProperty(&teacherId&)
.getProperty();
Property studentId = StudentTeacher.addLongProperty(&studentId&)
.getProperty();
// Entity Grade = schema.addEntity(&Grade&);
// Grade.implementsSerializable();
// Grade.addIdProperty();
// Grade.addStringProperty(&gradeName&);
// 树状结构，自身实现1对多
Entity Tree = schema.addEntity(&Tree&);
Tree.addIdProperty();
Tree.addStringProperty(&treeName&);
Property parentId = Tree.addLongProperty(&parentId&).getProperty();
Tree.addToOne(Tree, parentId).setName(&parent&);
Tree.addToMany(Tree, parentId).setName(&children&);
// 外键添加,1对多
OrderItem.addToOne(OrderHeader, orderId);
ToMany addToMany = OrderHeader.addToMany(OrderItem, orderId);
addToMany.setName(&orderItems&);
// greenDao不支持多对多的实现，但是我们可以 自定义实现多对多
StudentTeacher.addToOne(Student, studentId);
StudentTeacher.addToOne(Teacher, teacherId);
Student.addToMany(StudentTeacher, studentId)
.setName(&studentsteachers&);
Teacher.addToMany(StudentTeacher, teacherId)
.setName(&studentsteachers&);
二、Android工程中GreenDao的使用
首先需要导入对应的jar包。这个无需在详细说明。下载下来的例子里面有。
1、Android工程中代码生成的结构
1、DaoMaster,DaoSession的生成
& 这两个文件是最关键的两个文件，数据库的生成和表的操作都在这两个类里面。如果没有指定生成目录，会和实体文件一起生成在同一目录里面
2、实体类和对应Dao类的生成
这里以OrderHeader实体来说明，详情看代码：
package com.example.freedomsql.
import java.util.L
import com.example.freedomsql.bean.DaoS
import de.greenrobot.dao.DaoE
// THIS CODE IS GENERATED BY greenDAO, EDIT ONLY INSIDE THE &KEEP&-SECTIONS
// KEEP INCLUDES - put your custom includes here
// KEEP INCLUDES END
* Entity mapped to table ORDER_HEADER.
public class OrderHeader implements java.io.Serializable {
private String orderN
/** Used to resolve relations */
private transient DaoSession daoS
/** Used for active entity operations. */
private transient OrderHeaderDao myD
private List&OrderItem& orderI
// 如果设置了enableKeepSectionsByDefault();enableActiveEntitiesByDefault();这两个属性，那么我们可以再指定的区域内写入自定义代码，方便下次升级的时候不会被覆盖掉
// KEEP FIELDS - put your custom fields here
// KEEP FIELDS END
public OrderHeader() {
public OrderHeader(Long id) {
public OrderHeader(Long id, String orderName) {
this.orderName = orderN
/** called by internal mechanisms, do not call yourself. */
public void __setDaoSession(DaoSession daoSession) {
this.daoSession = daoS
myDao = daoSession != null ? daoSession.getOrderHeaderDao() :
public Long getId() {
public void setId(Long id) {
public String getOrderName() {
return orderN
public void setOrderName(String orderName) {
this.orderName = orderN
* To-many relationship, resolved on first access (and after reset). Changes
* to to-many relations are not persisted, make changes to the target
public List&OrderItem& getOrderItems() {
if (orderItems == null) {
if (daoSession == null) {
throw new DaoException(&Entity is detached from DAO context&);
OrderItemDao targetDao = daoSession.getOrderItemDao();
List&OrderItem& orderItemsNew = targetDao
._queryOrderHeader_OrderItems(id);
synchronized (this) {
if (orderItems == null) {
orderItems = orderItemsN
return orderI
* Resets a to-many relationship, making the next get call to query for a
* fresh result.
public synchronized void resetOrderItems() {
orderItems =
* Convenient call for {@link AbstractDao#delete(Object)}. Entity must
* attached to an entity context.
public void delete() {
if (myDao == null) {
throw new DaoException(&Entity is detached from DAO context&);
myDao.delete(this);
* Convenient call for {@link AbstractDao#update(Object)}. Entity must
* attached to an entity context.
public void update() {
if (myDao == null) {
throw new DaoException(&Entity is detached from DAO context&);
myDao.update(this);
* Convenient call for {@link AbstractDao#refresh(Object)}. Entity must
* attached to an entity context.
public void refresh() {
if (myDao == null) {
throw new DaoException(&Entity is detached from DAO context&);
myDao.refresh(this);
// KEEP METHODS - put your custom methods here
// KEEP METHODS END
这里需要特别注意的是，在使用getOrderItems（）拿到自己1对多的实体内容的时候，一定要记得resetOrderItems一下，不然由于缓存机制，会拿不到最新的实体内容。我们可以看到刚刚在test类中设置的内容都出现了，而且和Orderitem的1对多关系也得到了体现。在数据库操作的时候会变得非常的便捷
在看看Dao类
package com.example.freedomsql.
import android.database.C
import android.database.sqlite.SQLiteD
import android.database.sqlite.SQLiteS
import de.greenrobot.dao.AbstractD
import de.greenrobot.dao.P
import de.greenrobot.dao.internal.DaoC
import com.example.freedomsql.bean.OrderH
// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT.
* DAO for table ORDER_HEADER.
public class OrderHeaderDao extends AbstractDao&OrderHeader, Long& {
public static final String TABLENAME = &ORDER_HEADER&;
* Properties of entity OrderHeader.&br/&
* Can be used for QueryBuilder and for referencing column names.
public static class Properties {
public final static Property Id = new Property(0, Long.class, &id&, true, &_id&);
public final static Property OrderName = new Property(1, String.class, &orderName&, false, &ORDER_NAME&);
private DaoSession daoS
public OrderHeaderDao(DaoConfig config) {
super(config);
public OrderHeaderDao(DaoConfig config, DaoSession daoSession) {
super(config, daoSession);
this.daoSession = daoS
/** Creates the underlying database table. */
public static void createTable(SQLiteDatabase db, boolean ifNotExists) {
String constraint = ifNotExists? &IF NOT EXISTS &: &&;
db.execSQL(&CREATE TABLE & + constraint + &'ORDER_HEADER' (& + //
&'_id' INTEGER PRIMARY KEY ,& + // 0: id
&'ORDER_NAME' TEXT);&); // 1: orderName
/** Drops the underlying database table. */
public static void dropTable(SQLiteDatabase db, boolean ifExists) {
String sql = &DROP TABLE & + (ifExists ? &IF EXISTS & : &&) + &'ORDER_HEADER'&;
db.execSQL(sql);
/** @inheritdoc */
protected void bindValues(SQLiteStatement stmt, OrderHeader entity) {
stmt.clearBindings();
Long id = entity.getId();
if (id != null) {
stmt.bindLong(1, id);
String orderName = entity.getOrderName();
if (orderName != null) {
stmt.bindString(2, orderName);
protected void attachEntity(OrderHeader entity) {
super.attachEntity(entity);
entity.__setDaoSession(daoSession);
/** @inheritdoc */
public Long readKey(Cursor cursor, int offset) {
return cursor.isNull(offset + 0) ? null : cursor.getLong(offset + 0);
/** @inheritdoc */
public OrderHeader readEntity(Cursor cursor, int offset) {
OrderHeader entity = new OrderHeader( //
cursor.isNull(offset + 0) ? null : cursor.getLong(offset + 0), // id
cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1) // orderName
/** @inheritdoc */
public void readEntity(Cursor cursor, OrderHeader entity, int offset) {
entity.setId(cursor.isNull(offset + 0) ? null : cursor.getLong(offset + 0));
entity.setOrderName(cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1));
/** @inheritdoc */
protected Long updateKeyAfterInsert(OrderHeader entity, long rowId) {
entity.setId(rowId);
return rowId;
/** @inheritdoc */
public Long getKey(OrderHeader entity) {
if(entity != null) {
return entity.getId();
/** @inheritdoc */
protected boolean isEntityUpdateable() {
我们可以看到对应的表生成语句和字段绑定等都在这个类里面。其实这个类和之前哪篇文件说的Dao类一样，是操作数据库用的。增删改查全部靠这个类来实行。
2、使用greenDao在项目中操作数据库。
1、操作DaoMaster,DaoSession类编写
& & 之前说过，DaoMaster和DaoSession是非常关键的两个类，所以我们需要单独将他们两个类独立出来处理，新建一个GreenDao类来实现，详情看代码：
package com.example.freedomsql.
import android.content.C
import com.example.freedomsql.utils.C
* @ClassName: GreenDao
* @author victor_freedom (x_freedom_)
* @createddate
下午3:21:02
* @Description: TODO
public class GreenDao {
private static DaoMaster daoM
private static DaoSession daoS
* 获取DaoMaster实例
* @param context
public static DaoMaster getDaoMaster(Context context) {
if (daoMaster == null) {
DaoMaster.OpenHelper helper = new DaoMaster.DevOpenHelper(context,
Config.DB_NAME, null);
daoMaster = new DaoMaster(helper.getWritableDatabase());
return daoM
* 获取DaoSession实例
* @param context
public static DaoSession getDaoSession(Context context) {
if (daoSession == null) {
if (daoMaster == null) {
daoMaster = getDaoMaster(context);
daoSession = daoMaster.newSession();
return daoS
2、数据库增删改查接口类编写
& &在拿到两个非常重要的类之后，接下来就是对数据库操作的接口类的编写。我们以OrderHeader和OrderItem类来举例说明我们写先接口
package com.example.freedomsql.
import com.example.freedomsql.bean.OrderH
import com.example.freedomsql.bean.OrderI
import com.example.freedomsql.bean.S
import com.example.freedomsql.bean.T
public interface IOrderHeaderService {
* @Title: createOrder
* @Description: 创建一个订单
* @param order
public OrderHeader createOrder(OrderHeader order);
* @Title: updateOrder
* @Description: 更新一个订单
* @param orderHeader
public OrderHeader updateOrder(OrderHeader orderHeader);
* @Title: findOrderByName
* @Description: 根据名称查找订单
* @param orderName
public OrderHeader findOrderByName(String orderName);
* @Title: findOrderById
* @Description: 根据主键ID查找订单
* @param orderId
public OrderHeader findOrderById(long orderId);
* @Title: findOrderItemById
* @Description:根据主键ID查找订单明细
* @param orderItemId
public OrderItem findOrderItemById(long orderItemId);
* @Title: findOrderItemByName
* @Description: 根据名称查找订单明细
* @param orderItemName
public OrderItem findOrderItemByName(String orderItemName);
* @Title: createOrderItem
* @Description: 创建订单明细
* @param orderHeader
* @param name
public OrderItem createOrderItem(OrderHeader orderHeader, String name);
接下来写实现类：
package com.example.freedomsql.service.
import android.content.C
import com.example.freedomsql.bean.DaoS
import com.example.freedomsql.bean.GreenD
import com.example.freedomsql.bean.OrderH
import com.example.freedomsql.bean.OrderHeaderD
import com.example.freedomsql.bean.OrderI
import com.example.freedomsql.bean.OrderItemD
import com.example.freedomsql.service.IOrderHeaderS
* @ClassName: OrderHeaderService
* @author victor_freedom (x_freedom_)
* @createddate
下午3:26:41
* @Description: TODO
public class OrderHeaderService implements IOrderHeaderService {
private static DaoSession daoS
private static OrderHeaderS
private OrderHeaderDao orderHeaderD
private OrderItemDao orderItemD
private OrderHeaderService(OrderHeaderDao orderHeaderDao,
OrderItemDao orderItemDao) {
this.orderHeaderDao = orderHeaderD
this.orderItemDao = orderItemD
* @param context
public static OrderHeaderService getService(Context context) {
if (service == null) {
daoSession = GreenDao.getDaoSession(context);
service = new OrderHeaderService(daoSession.getOrderHeaderDao(),
daoSession.getOrderItemDao());
public OrderHeader createOrder(OrderHeader order) {
return orderHeaderDao.loadByRowId(orderHeaderDao.insert(order));
public OrderHeader updateOrder(OrderHeader orderHeader) {
orderHeaderDao.update(orderHeader);
return orderH
public OrderHeader findOrderByName(String orderName) {
OrderHeader orderHeader = orderHeaderDao.queryBuilder()
.where(OrderHeaderDao.Properties.OrderName.eq(orderName))
.unique();
return orderH
public OrderHeader findOrderById(long orderId) {
return orderHeaderDao.load(orderId);
public OrderItem findOrderItemById(long orderItemId) {
return orderItemDao.load(orderItemId);
public OrderItem findOrderItemByName(String orderItemName) {
return orderItemDao.queryBuilder()
.where(OrderItemDao.Properties.ItemName.eq(orderItemName))
.unique();
public OrderItem createOrderItem(OrderHeader orderHeader, String name) {
OrderItem orderItem = new OrderItem();
orderItem.setItemName(name);
orderItem.setOrderHeader(orderHeader);
return orderItemDao.load(orderItemDao.insert(orderItem));
我们可以看到，查询条件非常容易写，这里博主只写了些简单的查询条件，在where方法中是可以支持多条件限制查询的，查询方法非常的强大。还支持延迟lazy查询。但是使用延迟查询的话要记得close（）掉。我们可以将相关系的表文件的Dao文件写到一起，便于查询方法的编写。这里博主没有演示删除操作，其实也非常简单，API在Dao类里面，一看就懂的。
3、在主项目中的编写
1、接口位置的放置
这些接口，我们肯定是要做成全局变量的，那么，之前说过，全局变量的最好放置地方就是在Application中，参考代码如下
package com.example.
import android.app.A
import com.example.freedomsql.service.IClassS
import com.example.freedomsql.service.IOrderHeaderS
import com.example.freedomsql.service.impl.ClassS
import com.example.freedomsql.service.impl.OrderHeaderS
&* @ClassName: FreedomApplication
&* @author victor_freedom (x_freedom_)
&* @createddate
下午3:39:56
&* @Description: TODO
public class FreedomApplication extends Application {
public IClassService classS
public IOrderHeaderService orderHeaderS
public void onCreate() {
super.onCreate();
classService = ClassService.getService(getApplicationContext());
orderHeaderService = OrderHeaderService
.getService(getApplicationContext());
2、主Activity的编写
我们需要在这里生成一些数据来观察数据库：（那些 注释掉的东西是博主后面用来升级数据库使用的）
package com.example.
import android.app.A
import android.os.B
import com.example.freedomsql.bean.OrderH
import com.example.freedomsql.bean.S
import com.example.freedomsql.bean.StudentT
import com.example.freedomsql.bean.T
import com.example.freedomsql.service.IClassS
import com.example.freedomsql.service.IOrderHeaderS
public class MainActivity extends Activity {
private IClassService classS
private IOrderHeaderService orderHeaderS
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
classService = ((FreedomApplication) getApplication()).classS
orderHeaderService = ((FreedomApplication) getApplication()).orderHeaderS
initGreenDaoDB();
private void initGreenDaoDB() {
Teacher t1 = new Teacher();
t1.setTeacherName(&freedom&);
// t1.setTeacherName(&freedom2&);
classService.createTeacher(t1);
Teacher t2 = new Teacher();
t2.setTeacherName(&freedom1&);
// t2.setTeacherName(&freedom3&);
Student t3 = new Student();
t3.setStudentName(&victor&);
// t3.setStudentName(&victor2&);
Student t4 = new Student();
t4.setStudentName(&victor1&);
// t4.setStudentName(&victor3&);
classService.createTeacher(t1);
classService.createTeacher(t2);
classService.createStudent(t3);
classService.createStudent(t4);
StudentTeacher st1 = new StudentTeacher(t1.getId(), t3.getId());
StudentTeacher st2 = new StudentTeacher(t1.getId(), t4.getId());
StudentTeacher st3 = new StudentTeacher(t2.getId(), t3.getId());
StudentTeacher st4 = new StudentTeacher(t2.getId(), t4.getId());
classService.createStudentTeacher(st1);
classService.createStudentTeacher(st2);
classService.createStudentTeacher(st3);
classService.createStudentTeacher(st4);
OrderHeader order = new OrderHeader();
order.setOrderName(&订单1&);
// order.setOrderName(&订单3&);
OrderHeader order1 = new OrderHeader();
order1.setOrderName(&订单2&);
// order1.setOrderName(&订单4&);
orderHeaderService.createOrder(order);
orderHeaderService.createOrder(order1);
orderHeaderService.createOrderItem(order1, &明细1&);
orderHeaderService.createOrderItem(order1, &明细2&);
// orderHeaderService.createOrderItem(order1, &明细3&);
// orderHeaderService.createOrderItem(order1, &明细4&);
生成数据后如图所示：这里就只上传OrderHeader和OrderItem的图
好了，greenDao的操作基本讲解完毕，相信看了代码的同学基本上学会了如何使用GreenDao，以及多表结构的设计。博主这里就不演示那些查询方法了，都很简单，通俗易懂。接下来博主再讲讲再数据库升级中，如何保存原有数据。
3、使用GreenDao升级数据库
1、TestCase类文件修改
& & 数据库的升级，一般是在于字段的增加或者表的增加，这里，博主再一个实体中增加一个字段，又增加一个实体来演示
& & 首先，增加数据库版本号：
private static int dbVersion = 2;
& & 再在Student类中增加一个字段
// 增加一个字段，数据库升级
Student.addDoubleProperty(&results&);
& & 增加一个实体Grade
Entity Grade = schema.addEntity(&Grade&);
Grade.implementsSerializable();
Grade.addIdProperty();
Grade.addStringProperty(&gradeName&);
2、DaoMaster类的修改，这里我们只需要重写一下onUpgrade方法
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Log.i(&greenDAO&, &Upgrading schema from version & + oldVersion
+ & to & + newVersion + & by dropping all tables&);
//正常情况下，GreenDao默认升级的时候，将所有的表删除后再建，所以我们需要在这里处理
// dropAllTables(db, true);
// onCreate(db);
if (oldVersion == 1 && newVersion == 2) {
// 增加一个实体表
GradeDao.createTable(db, false);
// 修改Student表
db.execSQL(&ALTER TABLE 'STUDENT' ADD 'RESULTS' REAL&);
3、主Activity的修改，其他地方都不用修改了
对于主Activity，我们需要重新生成一些数据对比之前的数据即可
package com.example.
import android.app.A
import android.os.B
import com.example.freedomsql.bean.OrderH
import com.example.freedomsql.bean.S
import com.example.freedomsql.bean.StudentT
import com.example.freedomsql.bean.T
import com.example.freedomsql.service.IClassS
import com.example.freedomsql.service.IOrderHeaderS
public class MainActivity extends Activity {
private IClassService classS
private IOrderHeaderService orderHeaderS
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
classService = ((FreedomApplication) getApplication()).classS
orderHeaderService = ((FreedomApplication) getApplication()).orderHeaderS
initGreenDaoDB();
private void initGreenDaoDB() {
Teacher t1 = new Teacher();
// t1.setTeacherName(&freedom&);
t1.setTeacherName(&freedom2&);
classService.createTeacher(t1);
Teacher t2 = new Teacher();
// t2.setTeacherName(&freedom1&);
t2.setTeacherName(&freedom3&);
Student t3 = new Student();
// t3.setStudentName(&victor&);
t3.setStudentName(&victor2&);
Student t4 = new Student();
// t4.setStudentName(&victor1&);
t4.setStudentName(&victor3&);
classService.createTeacher(t1);
classService.createTeacher(t2);
classService.createStudent(t3);
classService.createStudent(t4);
StudentTeacher st1 = new StudentTeacher(t1.getId(), t3.getId());
StudentTeacher st2 = new StudentTeacher(t1.getId(), t4.getId());
StudentTeacher st3 = new StudentTeacher(t2.getId(), t3.getId());
StudentTeacher st4 = new StudentTeacher(t2.getId(), t4.getId());
classService.createStudentTeacher(st1);
classService.createStudentTeacher(st2);
classService.createStudentTeacher(st3);
classService.createStudentTeacher(st4);
OrderHeader order = new OrderHeader();
// order.setOrderName(&订单1&);
order.setOrderName(&订单3&);
OrderHeader order1 = new OrderHeader();
// order1.setOrderName(&订单2&);
order1.setOrderName(&订单4&);
orderHeaderService.createOrder(order);
orderHeaderService.createOrder(order1);
// orderHeaderService.createOrderItem(order1, &明细1&);
// orderHeaderService.createOrderItem(order1, &明细2&);
orderHeaderService.createOrderItem(order1, &明细3&);
orderHeaderService.createOrderItem(order1, &明细4&);
我们来看看运行前后的数据库Student表效果图对比
我们可以看到新生的字段也在，之前的数据也在
在看看新生成的Grade表
我们可以看到GRADE表也成功的生成了。整个数据库的数据都还保留着。
android如何兼容本地数据库 前一段时间做了公司的android项目，因为有些数据量较大，采用的本地的SQLite附加模式用的本地数据库，然后，最近android4.1更新，结果发现4.1不兼容。。用到本地数据库就报错，求大神解决。。
------最佳解决方案-------------------- 报什么错....
------其他解决方案-------------------- 数据库
android远程连接mySQL数据库失败，求救？？ 最近在做一个android查询mysql数据库服务器，用的是JDBC，但不知为何在建好的android项目里总是连接不上数据库。自己做的另一个java文件可以本地访问，也可以远程访问，就是建好的项目不行，检查了两天没解决，求高手指点。（功能清单上已经把internet的权限和单元测试配置好了）
public class GetData { p
android手机直连sqlserver数据库 有人做过这方面的实例吗？可以连接sqlserver数据库？
------解决方案-------------------- 不可以，大型数据库是不能在手机上运行的，只能用服务端在数据库读取，然后传递到手机上
------解决方案-------------------- 貌似手机端没有这么做的，虽然比较省事，一般的做法就是使用webservice
android 如何实现附加现有数据库？而不是每次安装的时候都创建 android如何实现附加现有数据库？而不是每次安装的时候都创建新的数据库。
最近做一个应用，在数据库中要内置很多数据，但有不想在每次安装的时候都重新创建数据库并插入数据，原因是插入数据时间较长，用户体验不好，所以特地想问问大家，有没有什么办法，让我一次吧数据库的内容都
SQLite一个数据库可以同时打开两张表吗？ 比如：
mDBH = new DatabaseHelper(this); db = mDBH.getWritableDatabase();
cur_db = db.query(TABLE_NAME, col, null, null, null, null, null); cur_db_2 = db.query(TABLE_NAME_2,
android联系人应用如何调到数据库操作的？ 比如说ContactSaveService怎么联系到ContactsProvider2的，通过哪些函数？
------最佳解决方案-------------------- 主要是通过获得ContentResolver类对数据库进行操作的
finalContentResolverresolver&n
关于sqlite破解问题 把数据存入到sqlite后，别人有办法破解看到sqlite的结构啊，数据什么的吗？ 如果有，请问怎么预防？重要字段加密？
求大神解答。
------解决方案--------------------
sqlite的数据库是不支持加密，任何sqlite工具都可以看到sqlite数据库的内容。
据说sqlite的作者提供付费版本的sqlite了，可以设密码。仅仅据说。
一个应用，有几千条纪录，想在应用中用SQLite，但不知要怎么做，请指点一下？ 一个应用，有几千条纪录，想在应用中用SQLite，但应用本身基本是查询，所以想在开发环境中就把数据导入数据库中，然后在Android应用中带上这个数据库文件，并使用查询功能。 请问：在Windows开发环境要安装什么软件才能使用SQLite？该怎么做呢？
------解决方案--------------------
Android数据存储之文件存储
关于文件存储，Activity提供了openFileOutput()方法可以用于把数据输出到文件中，具体的实现过程与在J2SE环境中保存数据到文件中是一样的。 文件可用来存放大量数据，如文本、图片、音频等。 默认位置：存放在/data/data/&package name&/files下。 下面根据个小例子来更好的理解文件存储： 阶段一：进行界面布局
Android之指南针学习
android 连接sqlite 问题 报错如下：
android.database.sqlite.SQLiteException: unable to open database file:
查询的时候没问题，插入的时候有问题，数据库是放在/data/data/net.gzcss.ydyw/databases/ 这个目录下面
Android学习09-----Android中数据的存储和访问 (1) By SharedPreferences
对于数据的存储操作而言， Android 中一共提供了五种方式： SharedPerferences 方式、文件存储方式、 SQLite 数据库存储、 ContentProvider 方式、网络存储；
SharedPerferences 提供了一些基础的信息保存
android之contentProvider的使用以及为其添加观察者（ContentObserver）
ContentProvider是用来实现不同应用程序之间数据的相互访问，不仅仅是可以访问数据库，像xml文件等都可以访问 为contentProvider设置观察者， 首先自定义观察者： class MyObserver extends ContentObserver {
开发android项目设计思路 要练习做一个android项目，才开始就难住了我，现在自己已经想好基本有哪些功能。但是，下一步该怎么做呢？设计思路是什么样的？用什么数据库比较好？javawb里用过mvc，那么android也有类似的东西吗？也需要考虑框架之类的东西吗？求高人相助。
------解决方案-------------------- 数据库的话本地是内嵌的sqlite3，远端
关于SQLite的菜鸟级提问~ 我想做通讯录，建了一个数据库，在新插入一个联系人的时候，我想先检测一下数据库里面有没有叫这个名字的联系人，没有的话再往数据库插入这个联系人，该怎么写代码呢？ 我知道这是个菜鸟问题……可是我还是不会…… 先谢谢大家啦！
------解决方案--------------------
我接触过通讯录方面的代码，我一直没找到特别好的方案。我是象楼上说的先查询一遍，看看
android之bitmap详解
主要介绍加载位图的5中方式：
package com.ghg.BitmapL import java.io.BufferedInputS import java.io.BufferedR import java.io.ByteArrayOutputS import java.io.FileInputS
如何查看android数据文件
eclipse中DDMS窗口
File Explorer
/data/data 目录下
在这个目录下，可以看到每个应用程序都有自己的目录，目录名就是应用程序在AndroidManifest.xml文件中定义的包。 在每个目录下，一般有这么几个子目录： databases : 存放数据库 cache : 存放缓
android邮件客户端一般用什么保存已经下载的数据 从邮件服务器下载邮件，邮件的内容保存到哪里，比如邮件标题，邮件内容，附件信息一般怎么保存。谁做个给点建议。
------解决方案--------------------
文件、数据库
Android之背景颜色小知识（笔记）
一、ListView的item背景（自定义颜色） 通常情况下，ListView的item背景用的是图片资源，下面跟大家分享一下使用颜色资源，即自定义一种颜色，当item聚焦、按压、选择的时候，可以显示我们自定义的颜色，好了废话不多说，直接分享代码： 1.首先在drawable目录下面新建一个list_item_color.xml，自定义我们需要的颜色 &l
SQLite执行sql语句出错。。。。。。。。。
String sql = &CREATE TABLE pic (_id INTEGRE PRIMARY KEY AUTOINCREMENT NOT NULL , fileName VARCHAR, description VARCHAR)&; db.execSQL(sql);
用的安卓sdk4.1
android之uriMathcer详解及使用
UriMatcher是一个工具类，主要是用于contentProvider中用于匹配URIS。
UriMatcher实际上相当于一棵树，实例化的UriMatcher对象，相当于树的根节点。
UriMatcher的实例化， UriMatcher matcher=newUriMatcher(UriMatcher.NO
Android 如何自定义共享库
一、开发者的难言之隐---讨厌的集成
在Android 实际开发过程中，每个供应商都会有自己专有的开发库如驱动程序、常用API的封装等。如何把这些用于开发的库无缝地集成到Android 框架中成为了开发者最为头痛的事，每添加一个新的库就需要把Android 框架翻个遍，寻找合适的地方放置自己的代码，到最后把 Android 的源码改得支
Android异步加载图片详解之方式一(3)
Utils.java如下: package cn.loadI import java.io.InputS import java.io.OutputS import android.graphics.B import android.graphics.BitmapF public clas
Android异步加载图片详解之方式二(2)
FileCache.java如下: .loadI import java.io.F import java.io.FileNotFoundE import java.io.FileOutputS import java.io.IOE import java
android学习笔记1
1.android的平台搭建 我安装的是最新的android的平台，至少目前为止是这这样，我安装的过程是参照下面的文本文档所介绍的步骤进行的。整个android的安装文件大概需要几个G现在上传不上来。
Android异步加载图片详解之方式一(1)
MainActivity.java如下: package cn. import java.util.ArrayL import android.app.A import android.os.B import android.view.V import android.view.
Android异步加载图片详解之方式一(2)
FileCache.java如下: package cn.loadI import java.io.F import android.content.C import android.net.U import android.os.E public class FileCache { pr
Android异步加载图片详解之方式二(1)
MainActivity.java如下: . import java.util.ArrayL import android.app.A import android.os.B import android.widget.ListV //解决的问题:
Android的文本和输入---复制和粘贴（四）
使用内容提供器来复制复杂的数据 内容提供器支持复制诸如数据库记录或文件流等复杂数据。要复制这样的数据，你就要把一个内容的URI放到剪贴板上。然后粘贴数据的应用程序重剪贴板上获取这个URI，并且使用它来获取数据库数据或文件流的描述符。 因为粘贴数据的应用程序只有数据的URI，所以它需要知道要或获取的数据的位置。你可以通过URI中的数据标识编码来提供
android学习笔记（五）
数据存储的分类
Shared Preferences，一个轻量级的存储的地方。我觉得这种方式存储那些以个位单位的数据比较方便。
File，最原始的数据存储方式，但是也是最方便的一种。
SQLite Databases： 我的理解是一个A
android重要包描述
android.app 提供高层的程序模型、提供基本的运行环境
android.content 包含各种对设备上的数据进行访问和发布的类
android.database 通过内容提供者浏览和操作数据库
android.graphics 底层的图形库,包含画布,颜色过滤,点,矩形.可以将他们绘制到荧幕上
Android系列之Android 命令行手动编译打包详解
http://blog168.chinaunix.net/space.php?uid=&do=blog&cuid=2322671
Android的文本和输入---复制和粘贴（六）
复制流化的数据 你可以复制和粘贴被流化的大文本和二进制数据。这种数据可以是以下形式： 1.保存在实际设备上的的文件； 2.来自套接字中的数据流； 3.保存在底层数据库系统中的大数据。 针对数据流的内容提供器使用一个文件描述对象（如AssetFileDescriptor，而不是Cursor对象）来提供对数据的访问
android ocr tess-two库使用
经过上一篇博客的编译操作后，新建一个测试工程，将编译好的Library以properties-&android-&add的方式将库添加到项目中，但在添加的Library前会有个红色的叉号，原因是ADT在windows上支持的不是很好（参考自：android添加库文件出错解决办法），现在已经可以运行了，但识别的结果差很多。 原图如下：
android添加权限说明
android.permission.ACCESS_CHECKIN_PROPERTIES //允许读写访问”properties”表在checkin数据库中，改值可以修改上传
android.permission.ACCESS_COARSE_LOCATION //允许一个程序访问CellID或WiFi热点来获取粗略的位置&nbsp
Android调用WCF出错情况
! XSOAp jar包的版本 2 服务端的问题：(1) 服务连接数据库的地址及用户名密码 (2) 服务程序内部错误，可以用SoapFault返回错误 (3)服务的发布错误 3 android客户端问题 (1)客户端程序如namespace urlacti
android JNI库中如何处理IO口操作? android JNI库中如何处理IO口操作?
Java 应用可调用 JNI库(.so), android\packages\apps\JNI(该目录下编出来的库) , 能不能操作 硬件平台上的IO口?
如何操作呢?
Android 基于Socket 的即时通信软件 YQ（源码下载）
Android 即时聊天工具 YQ
开发环境：Eclipse + JDK 1.7 + SDK 2.2 基于Socket的即时通信工具，类android版QQ，写的比较简单，有很多不足之处，适合新手参考。
源码已上传：
点击下载源码
&&带数据库and数据
深入浅出 - Android系统移植与平台开发（十四） - Sensor HAL框架分析之四
Sensor本地封装类SensorDevice
SensorDevice是在本地代码中SensorService对Sensor设备的抽象类型封装，它封装了传感器硬件的硬件操作，该类继承了Singleton类，通过getInstance方法获得单例模式设备操作对象： @frameworks/base/
Android之SharedPreferences小技巧
相信Android的这个最简单的存储方式大家都很熟悉了，但是有一个小小技巧，也许你没有用过，今天就跟大家分享一下，我们可以把SharedPreferences封装在一个工具类中，当我们需要写数据和读数据的时候，就可以直接通过工具类的set和get方法来完