Android ActiveRecord getId（）方法返回NULL

嗨，我用它在本地数据库中存储一些数据，我得到了一个非常奇怪的行为。我已经创建了我的表，当我尝试使用getId（）检索元素的ID时，我得到一个空指针异常。。。但是，所有其他字段都存在，并且不为空

以前有人遇到过这种情况吗

下面是一些代码：

package ro.gebs.captoom.datamodel;

import java.io.Serializable;

import ro.gebs.captoom.database.CaptoomSQLiteHelper;

import com.activeandroid.Model;
import com.activeandroid.annotation.Column;
import com.activeandroid.annotation.Table;

@Table(name = CaptoomSQLiteHelper.TABLE_MILEAGE)
public class Mileage extends Model implements Serializable, Comparable<Mileage>{

    private static final long serialVersionUID = 1L;
    @Column(name = CaptoomSQLiteHelper.COLUMN_REMOTE_ID)
    private String folderId;
    @Column(name = CaptoomSQLiteHelper.COLUMN_START_DATE)
    private String startDate;
    @Column(name = CaptoomSQLiteHelper.COLUMN_END_DATE)
    private String endDate;
    @Column(name = CaptoomSQLiteHelper.COLUMN_DISTANCE)
    private String distance;
    @Column(name = CaptoomSQLiteHelper.COLUMN_CURRENCY)
    private String currency;
    @Column(name = CaptoomSQLiteHelper.COLUMN_UNIT)
    private String unit;
    @Column(name = CaptoomSQLiteHelper.COLUMN_PRICE)
    private String price;
    @Column(name = CaptoomSQLiteHelper.COLUMN_DETAILS)
    private String details;
    @Column(name = CaptoomSQLiteHelper.COLUMN_SYNC)
    private int isSynchronized;

    public Mileage(){
        super();
    }

    public Mileage(String folder_id, String start_date, String end_date, String distance, String currency, String unit, String price, String details, int synced){
        super();
        this.folderId = folder_id;
        this.startDate = start_date;
        this.endDate = end_date;
        this.distance = distance;
        this.currency = currency;
        this.unit = unit;
        this.price = price;
        this.details = details;
        this.setIsSynchronized(synced);
    }

    @Override
    public int compareTo(Mileage another) {
        return this.getId().compareTo(another.getId());
    }

    public String getFolderId() {
        return folderId;
    }

    public void setFolderId(String folderId) {
        this.folderId = folderId;
    }

    public String getStartDate() {
        return startDate;
    }

    public void setStartDate(String startDate) {
        this.startDate = startDate;
    }

    public String getEndDate() {
        return endDate;
    }

    public void setEndDate(String endDate) {
        this.endDate = endDate;
    }

    public String getDistance() {
        return distance;
    }

    public void setDistance(String distance) {
        this.distance = distance;
    }

    public String getCurrency() {
        return currency;
    }

    public void setCurrency(String currency) {
        this.currency = currency;
    }

    public String getUnit() {
        return unit;
    }

    public void setUnit(String unit) {
        this.unit = unit;
    }

    public String getDetails() {
        return details;
    }

    public void setDetails(String details) {
        this.details = details;
    }

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }

    public int getIsSynchronized() {
        return isSynchronized;
    }

    public void setIsSynchronized(int isSynchronized) {
        this.isSynchronized = isSynchronized;
    }

    @Override
    public String toString(){
        return this.details + "+++" + this.isSynchronized;
    }

}

包ro.gebs.captoom.datamodel；
导入java.io.Serializable；
导入ro.gebs.captoom.database.CaptoomSQLiteHelper；
导入com.activeandroid.Model；
导入com.activeandroid.annotation.Column；
导入com.activeandroid.annotation.Table；
@表（name=CaptoomSQLiteHelper.Table\u里程）
公共类里程扩展模型实现了可序列化、可比较的{
私有静态最终长serialVersionUID=1L；
@列（名称=CaptoomSQLiteHelper.Column\u REMOTE\u ID）
私有字符串folderId；
@列（名称=CaptoomSQLiteHelper.Column\u START\u DATE）
私有字符串起始日期；
@列（名称=CaptoomSQLiteHelper.Column\u END\u DATE）
私有字符串结束日期；
@列（名称=CaptoomSQLiteHelper.Column\u距离）
私有字符串距离；
@列（名称=CaptoomSQLiteHelper.Column\u货币）
私人字符串货币；
@列（名称=CaptoomSQLiteHelper.Column\u单位）
专用字符串单元；
@列（name=CaptoomSQLiteHelper.Column\u PRICE）
私人字符串价格；
@列（name=CaptoomSQLiteHelper.Column\u详细信息）
私有字符串详细信息；
@列（名称=CaptoomSQLiteHelper.Column\u SYNC）
私有int是同步的；
公共里程（）{
超级（）；
}
公共里程（字符串文件夹id、字符串开始日期、字符串结束日期、字符串距离、字符串货币、字符串单位、字符串价格、字符串详细信息、整数同步）{
超级（）；
this.folderId=文件夹\u id；
this.startDate=开始日期；
this.endDate=结束日期；
这个距离=距离；
这个。货币=货币；
这个。单位=单位；
这个价格=价格；
this.details=详细信息；
此.setIsSynchronized（已同步）；
}
@凌驾
公共整数比较（另一个里程）{
将这个.getId（）.compareTo返回到（另一个.getId（））；
}
公共字符串getFolderId（）{
返回folderId；
}
公共void setFolderId（字符串folderId）{
this.folderId=folderId；
}
公共字符串getStartDate（）{
返回起始日期；
}
公共无效设置开始日期（字符串开始日期）{
this.startDate=startDate；
}
公共字符串getEndDate（）{
返回结束日期；
}
公共无效setEndDate（字符串endDate）{
this.endDate=endDate；
}
公共字符串getDistance（）{
返回距离；
}
公共空隙设置距离（字符串距离）{
这个距离=距离；
}
公共字符串getCurrency（）{
返回货币；
}
公共无效设置货币（字符串货币）{
这个。货币=货币；
}
公共字符串getUnit（）{
返回单元；
}
公共无效设置单位（字符串单位）{
这个。单位=单位；
}
公共字符串getDetails（）{
退货详情；
}
公共无效集合详细信息（字符串详细信息）{
this.details=详细信息；
}
公共字符串getPrice（）{
退货价格；
}
公共无效设置价格（字符串价格）{
这个价格=价格；
}
public int getIsSynchronized（）{
返回同步；
}
公共无效集已同步（int已同步）{
this.isSynchronized=isSynchronized；
}
@凌驾
公共字符串toString（）{
返回this.details++++“+this.isSynchronized；
}
}

这就是我试图检索的地方：

package ro.gebs.captoom.database;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import ro.gebs.captoom.datamodel.Mileage;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;

import com.activeandroid.query.Select;

public class MileageDataSource {

    // sync variables
    public final int SYNC_ID = 0x7f020001;
    public final int NEW_NOT_SYNC_ID = 0x7f020011;

    // Database fields
    private SQLiteDatabase database;
    private CaptoomSQLiteHelper dbHelper;
    private String[] columnsMileage = { CaptoomSQLiteHelper.COLUMN_ID,
            CaptoomSQLiteHelper.COLUMN_START_DATE,
            CaptoomSQLiteHelper.COLUMN_END_DATE,
            CaptoomSQLiteHelper.COLUMN_DISTANCE,
            CaptoomSQLiteHelper.COLUMN_CURRENCY,
            CaptoomSQLiteHelper.COLUMN_UNIT, CaptoomSQLiteHelper.COLUMN_PRICE,
            CaptoomSQLiteHelper.COLUMN_DETAILS,
            CaptoomSQLiteHelper.COLUMN_SYNC,
            CaptoomSQLiteHelper.COLUMN_REMOTE_ID };

    private boolean isOpen;

    public MileageDataSource(Context context) {
        setDbHelper(new CaptoomSQLiteHelper(context));
        isOpen = false;
    }

    public void open() {
        if (!isOpen) {
            isOpen = true;
        }
    }

    public void close() {
        if (isOpen) {
            isOpen = false;
        }
    }

    public Mileage createMileage(String folder_id, String start_date,
            String end_date, String distance, String currency, String unit,
            String price, String details) {
        Mileage newMileage = new Mileage(folder_id, start_date, end_date,
                distance, currency, unit, price, details, NEW_NOT_SYNC_ID);
        newMileage.save();
        return newMileage;
    }

    public Mileage updateMileage(long id, String folder_id, String start_date,
            String end_date, String distance, String currency, String unit,
            String price, String details) {
        Mileage r = this.getMileageByID(id);
        System.out.println("This mileage ID is the problem!!" + r.getId());
        r.setFolderId(folder_id);
        r.setStartDate(start_date);
        r.setEndDate(end_date);
        r.setDistance(distance);
        r.setCurrency(currency);
        r.setUnit(unit);
        r.setPrice(price);
        r.setDetails(details);
        r.setIsSynchronized(NEW_NOT_SYNC_ID);
        r.save();
        return r;
    }

    public void syncMileage(Mileage r) {
        r.setIsSynchronized(SYNC_ID);
        r.save();
    }

    public Mileage getMileageByID(long id) {
        Mileage r = new Mileage();
        ArrayList<Mileage> allMileages = this.selectAllMileages();
        for (int i = 0; i < allMileages.size(); i++) {
            System.out.println("in getmileageby id:"
                    + allMileages.get(i).getId());
            if (allMileages.get(i).getId() == id) {

                r = allMileages.get(i);
            }
        }
        return r;
    }

    public ArrayList<Mileage> selectAllMileages() {
        ArrayList<Mileage> allReceipts = new ArrayList<Mileage>();

        List<Mileage> selMileages = new Select().from(
                ro.gebs.captoom.datamodel.Mileage.class).execute();
        allReceipts.addAll(selMileages);

        return allReceipts;
    }

    public ArrayList<Mileage> findMileagessByDate(String myDate, long folder_id) {
        ArrayList<Mileage> allMileages = new ArrayList<Mileage>();
        List<Mileage> selMileages = new Select()
                .from(ro.gebs.captoom.datamodel.Mileage.class)
                .where(CaptoomSQLiteHelper.COLUMN_END_DATE + "='" + myDate
                        + "' AND " + CaptoomSQLiteHelper.COLUMN_REMOTE_ID
                        + " = " + folder_id).execute();
        allMileages.addAll(selMileages);
        return allMileages;
    }

    public ArrayList<Mileage> selectMileagesFromFolder(long folder_id) {
        ArrayList<Mileage> allMiles = new ArrayList<Mileage>();

        List<Mileage> selMiles = new Select()
                .from(ro.gebs.captoom.datamodel.Mileage.class)
                .where(CaptoomSQLiteHelper.COLUMN_REMOTE_ID + "=="
                        + String.valueOf(folder_id)).execute();
        allMiles.addAll(selMiles);

        return allMiles;
    }

    public int getUnsyncedMileagesCount(long folder_id) {
        List<Mileage> selReceipts = new Select()
                .from(ro.gebs.captoom.datamodel.Mileage.class)
                .where(CaptoomSQLiteHelper.COLUMN_REMOTE_ID + "=="
                        + String.valueOf(folder_id) + " AND "
                        + CaptoomSQLiteHelper.COLUMN_SYNC + "=="
                        + String.valueOf(NEW_NOT_SYNC_ID)).execute();
        return selReceipts.size();
    }

    public ArrayList<Mileage> selectUnsyncedMileages() {
        ArrayList<Mileage> allMileages = new ArrayList<Mileage>();

        List<Mileage> selReceipts = new Select()
                .from(ro.gebs.captoom.datamodel.Mileage.class)
                .where(CaptoomSQLiteHelper.COLUMN_SYNC + "=="
                        + String.valueOf(NEW_NOT_SYNC_ID)).execute();
        allMileages.addAll(selReceipts);

        return allMileages;
    }

    public String[] getColumnsFolder() {
        return columnsMileage;
    }

    public void setColumnsFolder(String[] columnsFolder) {
        this.columnsMileage = columnsFolder;
    }

    public CaptoomSQLiteHelper getDbHelper() {
        return dbHelper;
    }

    public void setDbHelper(CaptoomSQLiteHelper dbHelper) {
        this.dbHelper = dbHelper;
    }

    public SQLiteDatabase getDatabase() {
        return database;
    }

    public void setDatabase(SQLiteDatabase database) {
        this.database = database;
    }


}

包ro.gebs.captoom.database；
导入java.util.ArrayList；
导入java.util.HashSet；
导入java.util.Iterator；
导入java.util.List；
导入java.util.Set；
导入ro.gebs.captoom.datamodel.milines；
导入android.content.Context；
导入android.database.sqlite.SQLiteDatabase；
导入com.activeandroid.query.Select；
公共级里程数据源{
//同步变量
公共最终整数同步_ID=0x7f020001；
公共最终int NEW_NOT_SYNC_ID=0x7f020011；
//数据库字段
专用数据库；
私有CaptoomSQLiteHelper dbHelper；
私有字符串[]columnsMileage={CaptoomSQLiteHelper.COLUMN\u ID，
CaptoomSQLiteHelper.COLUMN\u开始日期，
CaptoomSQLiteHelper.COLUMN\u END\u DATE，
CaptoomSQLiteHelper.COLUMN\u距离，
CaptoomSQLiteHelper.COLUMN\u货币，
captoomsqliteheloper.COLUMN\u单位，captoomsqliteheloper.COLUMN\u价格，
CaptoomSQLiteHelper.COLUMN_详细信息，
CaptoomSQLiteHelper.COLUMN\u同步，
CaptoomSQLiteHelper.COLUMN_REMOTE_ID}；
私有布尔等参；
公共里程数据源（上下文）{
setDbHelper（新的CaptoomSQLiteHelper（上下文））；
isOpen=假；
}
公开作废{
如果（！isOpen）{
isOpen=真；
}
}
公众假期结束（）{
if（等参线）{
isOpen=假；
}
}
公共里程创建里程（字符串文件夹id、字符串开始日期、，
字符串结束日期、字符串距离、字符串货币、字符串单位、，
字符串价格、字符串详细信息）{
里程新里程=新里程（文件夹id、开始日期、结束日期、，
距离、货币、单位、价格、详细信息、新的\u非同步\u ID）；
newmilies.save（）；
返回新里程；
}
公共里程更新里程（长id、字符串文件夹id、字符串开始日期、，
字符串结束日期、字符串距离、字符串货币、字符串单位、，
字符串价格、字符串详细信息）{
里程r=此.getMileageByID（id）；
System.out.println（“这个里程ID就是问题所在！！”+r.getId（））；
r、 setFolderId（文件夹id）；
r、 设置开始日期（开始日期）；
r、 setEndDate（结束日期）；
r、 设置距离（距离）；
r、 设定货币（c
    public ArrayList<Mileage> selectAllMileages() {
           ArrayList<Mileage> allReceipts = new ArrayList<Mileage>();

           List<Mileage> selMileages = new Select().all().from(  //put all() between
            ro.gebs.captoom.datamodel.Mileage.class).execute();
           allReceipts.addAll(selMileages);

          return allReceipts;
     }