精华内容
下载资源
问答
  • ORMLite Android 该软件包提供了Android特定的功能。 您还需要下载软件包。 通过JDBC连接连接到SQL数据库的用户应下载软件包,而不是此Android软件包。 有关ORMLite的更多背景信息,请参见 。 有关更多信息,请...
  • 可以在主页上找到在线文档。 这是。 这是的 。 浏览上的代码。 Maven软件包通过发布 我已经发布了。 ORMLite易于使用,并提供以下功能: 只需添加即可设置类。 强大的抽象。 灵活的,可轻松构造简单和复杂的...
  • Android 快速开发系列 ORMLite jar包案例和文档 数据库快速开发,实现数据保存查询封装,非常实用高效
  • Android OrmLite

    2014-11-04 23:41:31
    OrmLite可以帮助我们将会数据库操作,不用自己去写SQL语句,而且设置它跟使用Sqlite一样的方式,它是一种关系型数据,我比较喜欢的就是它能够帮助我判断数据表项是更新还是创建等操作,不需要自己去写大量的SQL语句...

    OrmLite可以帮助我们将会数据库操作,不用自己去写SQL语句,而且设置它跟使用Sqlite一样的方式,它是一种关系型数据,我比较喜欢的就是它能够帮助我判断数据表项是更新还是创建等操作,不需要自己去写大量的SQL语句去判断,下面介绍一下它的使用文档以及一些基本的注意点:

    官方网址:http://ormlite.com/

    JavaDOC地址:http://ormlite.com/javadoc/ormlite-android/ 

    开发文档地址:http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite.html

    一、建立模型

    首先创建一个Model,作为一个数据表,在Android中我使用的是实现Parcelable,代码如下:

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    1. <span style="font-size:14px;">package com.jwzhangjie.capricorntv.bean;  
    2.   
    3. import com.j256.ormlite.field.DatabaseField;  
    4. import com.j256.ormlite.table.DatabaseTable;  
    5.   
    6. import android.os.Parcel;  
    7. import android.os.Parcelable;  
    8.   
    9. /** 
    10.  *  
    11.  * @author zj 包含视频的参数 视频的名字 "channel_id":9, "channel_name":"湖南卫视", 
    12.  *         "icon_url":"http://tv.togic.com:8080/ShowTimeService/images/182.png", 
    13.  *         "province":"湖南", "mode":"SD", "url": 
    14.  *         "http://live.gslb.letv.com/gslb?stream_id=hunan&tag=live&ext=m3u8&sign=live_tv&platid=10&splatid=1012&temporarykey=db7c39a0ee39ab2d4d2e781d5" 
    15.  *         , 
    16.  *         "second_url":["http://live-cdn.kksmg.com/channels/tvie/test/flv:500k" 
    17.  *         , 
    18.  *         "http://live.gslb.letv.com/gslb?stream_id=hunanHD_1800&tag=live&ext=m3u8&sign=live_tv&platid=10&splatid=1012&temporarykey=db7c39a0ee39ab2d4d2e781d5" 
    19.  *         , 
    20.  *         "http://pplive.shntv.cn/live/5/30/e9301e073cf94732a380b765c8b9573d.m3u8?type=ipad" 
    21.  *         ,"rtsp://rlive.tv189.cn/live/112"], "types":"2|0" 
    22.  */  
    23.   
    24. public class LiveItemBean implements Parcelable {  
    25.   
    26.     @Override  
    27.     public int describeContents() {  
    28.         return 0;  
    29.     }  
    30.   
    31.     public LiveItemBean() {  
    32.     }  
    33.   
    34.     private LiveItemBean(Parcel source) {  
    35.         readFromParcel(source);  
    36.     }  
    37.   
    38.     @DatabaseField(id = true)  
    39.     private int channel_id;  
    40.     @DatabaseField  
    41.     private String channel_name;  
    42.     @DatabaseField  
    43.     private String icon_url;  
    44.     @DatabaseField  
    45.     private String province;  
    46.     @DatabaseField  
    47.     private String mode;  
    48.     @DatabaseField  
    49.     private String url;  
    50.     @DatabaseField  
    51.     private String second_urls;  
    52.     private String[] second_url;  
    53.     @DatabaseField  
    54.     private String types;  
    55.   
    56.     private void readFromParcel(Parcel source) {  
    57.         channel_name = source.readString();  
    58.         icon_url = source.readString();  
    59.         province = source.readString();  
    60.         mode = source.readString();  
    61.         url = source.readString();  
    62.         second_urls = source.readString();  
    63.         second_url = (String[]) source.readArray(LiveItemBean.class  
    64.                 .getClassLoader());  
    65.         types = source.readString();  
    66.   
    67.     }  
    68.   
    69.     @Override  
    70.     public void writeToParcel(Parcel dest, int flags) {  
    71.         dest.writeInt(channel_id);  
    72.         dest.writeString(channel_name);  
    73.         dest.writeString(icon_url);  
    74.         dest.writeString(province);  
    75.         dest.writeString(mode);  
    76.         dest.writeString(url);  
    77.         dest.writeString(second_urls);  
    78.         dest.writeArray(second_url);  
    79.         dest.writeString(types);  
    80.     }  
    81.   
    82.     public static Creator<LiveItemBean> CREATOR = new Creator<LiveItemBean>() {  
    83.   
    84.         @Override  
    85.         public LiveItemBean createFromParcel(Parcel source) {  
    86.             return new LiveItemBean(source);  
    87.         }  
    88.   
    89.         @Override  
    90.         public LiveItemBean[] newArray(int size) {  
    91.             return new LiveItemBean[size];  
    92.         }  
    93.     };  
    94.   
    95.     public int getChannel_id() {  
    96.         return channel_id;  
    97.     }  
    98.   
    99.     public void setChannel_id(int channel_id) {  
    100.         this.channel_id = channel_id;  
    101.     }  
    102.   
    103.     public String getChannel_name() {  
    104.         return channel_name;  
    105.     }  
    106.   
    107.     public void setChannel_name(String channel_name) {  
    108.         this.channel_name = channel_name;  
    109.     }  
    110.   
    111.     public String getIcon_url() {  
    112.         return icon_url;  
    113.     }  
    114.   
    115.     public void setIcon_url(String icon_url) {  
    116.         this.icon_url = icon_url;  
    117.     }  
    118.   
    119.     public String getProvince() {  
    120.         return province;  
    121.     }  
    122.   
    123.     public void setProvince(String province) {  
    124.         this.province = province;  
    125.     }  
    126.   
    127.     public String getMode() {  
    128.         return mode;  
    129.     }  
    130.   
    131.     public void setMode(String mode) {  
    132.         this.mode = mode;  
    133.     }  
    134.   
    135.     public String getUrl() {  
    136.         return url;  
    137.     }  
    138.   
    139.     public void setUrl(String url) {  
    140.         this.url = url;  
    141.     }  
    142.   
    143.     public String getSecond_urls() {  
    144.         return second_urls;  
    145.     }  
    146.   
    147.     public void setSecond_urls(String second_urls) {  
    148.         this.second_urls = second_urls;  
    149.     }  
    150.   
    151.     public String[] getSecond_url() {  
    152.         return second_url;  
    153.     }  
    154.   
    155.     public void setSecond_url(String[] second_url) {  
    156.         this.second_url = second_url;  
    157.         StringBuffer buffer = new StringBuffer();  
    158.         int count = second_url.length;  
    159.         for (int i = 0; i < count; i++) {  
    160.             buffer.append(second_url[i]);  
    161.             if (i != count-1) {  
    162.                 buffer.append(";");  
    163.             }  
    164.         }  
    165.         second_urls = buffer.toString();  
    166.     }  
    167.   
    168.     public String getTypes() {  
    169.         return types;  
    170.     }  
    171.   
    172.     public void setTypes(String types) {  
    173.         this.types = types;  
    174.     }  
    175. }  
    176. </span>  

    我们分析上面的代码同时介绍一下与之相关的配置:

    1、是类名,这里我使用的数据表的名字是默认类的小写,当然你还可以指定表名字,使用@DatabaseTable(tableName = "liveitembeans"),

    2、主键,在上面的代码中有一行@DatabaseField(id = true)被注解对象就是主键,当然我们有时候使用的一个自增长的id,我们可以设置为@DatabaseField(generatedId = true)来实现,当然还有很多其他的注解配置我这里就不一一说明了,自己可以到官网可以查看找到自己需要的。

    二、创建DBHelper

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    1. <span style="font-size:14px;">package com.jwzhangjie.capricorntv.db;  
    2.   
    3. import android.content.Context;  
    4. import android.database.sqlite.SQLiteDatabase;  
    5.   
    6. import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;  
    7. import com.j256.ormlite.support.ConnectionSource;  
    8. import com.j256.ormlite.table.TableUtils;  
    9. import com.jwzhangjie.capricorntv.bean.LiveItemBean;  
    10.   
    11. public class DBHelper extends OrmLiteSqliteOpenHelper {  
    12.       
    13.     private static final String DATABASE_NAME = "jwzhangjie.db";  
    14.     private static final int DATABASE_VERSION = 1;  
    15.   
    16.     public DBHelper(Context context){  
    17.         super(context, DATABASE_NAME, null, DATABASE_VERSION);  
    18.     }  
    19.   
    20.     @Override  
    21.     public void onCreate(SQLiteDatabase sqLiteDatabase,  
    22.             ConnectionSource connectionSource) {  
    23.         try {  
    24.             TableUtils.createTable(connectionSource, LiveItemBean.class);  
    25.         } catch (Exception e) {  
    26.             e.printStackTrace();  
    27.         }  
    28.     }  
    29.   
    30.     @Override  
    31.     public void onUpgrade(SQLiteDatabase sqLiteDatabase,  
    32.             ConnectionSource connectionSource, int oldVer, int newVer) {  
    33.         try {  
    34.             TableUtils.dropTable(connectionSource, LiveItemBean.classtrue);  
    35.             onCreate(sqLiteDatabase, connectionSource);  
    36.         } catch (Exception e) {  
    37.             e.printStackTrace();  
    38.         }  
    39.     }  
    40.       
    41. }  
    42. </span>  
    上面使用TableUtils来创建和删除表,还有其他的功能例如清空表内容等

    三、创建操作工具

    接下来就是创建一个操作数据库的工具DAO

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    1. <span style="font-size:14px;">package com.jwzhangjie.capricorntv.uitls;  
    2.   
    3. import java.sql.SQLException;  
    4. import java.util.ArrayList;  
    5. import java.util.List;  
    6.   
    7. import android.content.Context;  
    8.   
    9. import com.j256.ormlite.dao.Dao;  
    10. import com.jwzhangjie.capricorntv.bean.LiveItemBean;  
    11. import com.jwzhangjie.capricorntv.db.DBHelper;  
    12.   
    13. public class DBUtils {  
    14.       
    15.     public static Dao<LiveItemBean, Integer> liveDao = null;  
    16.   
    17.     public DBUtils(Context context) {  
    18.         if (liveDao == null) {  
    19.             DBHelper dbHelper = new DBHelper(context);  
    20.             try {  
    21.                 liveDao = dbHelper.getDao(LiveItemBean.class);  
    22.             } catch (SQLException e) {  
    23.                 e.printStackTrace();  
    24.             }  
    25.         }  
    26.     }  
    27.   
    28.     /** 
    29.      * 插入直播数据,如果数据存在则进行更新 
    30.      *  
    31.      * @param liveItemBean 
    32.      */  
    33.     public void LiveCreate(LiveItemBean liveItemBean) {  
    34.         try {  
    35.             liveDao.createOrUpdate(liveItemBean);  
    36.         } catch (SQLException e) {  
    37.             e.printStackTrace();  
    38.         }  
    39.     }  
    40.   
    41.     /** 
    42.      * 连续进行插入,如果存在则更新 
    43.      */  
    44.     public void LiveCreates(List<LiveItemBean> lists) {  
    45.         try {  
    46.             for (LiveItemBean liveItemBean : lists) {  
    47.                 liveDao.createOrUpdate(liveItemBean);  
    48.             }  
    49.         } catch (Exception e) {  
    50.             e.printStackTrace();  
    51.         }  
    52.     }  
    53.       
    54.     /** 
    55.      * 查询所有的直播元素 
    56.      * @return 
    57.      */  
    58.     public List<LiveItemBean> getLiveItemBeans(){  
    59.         List<LiveItemBean> listsBeans = new ArrayList<LiveItemBean>();  
    60.         try {  
    61.             listsBeans = liveDao.queryForAll();  
    62.         } catch (SQLException e) {  
    63.             e.printStackTrace();  
    64.         }  
    65.         return listsBeans;  
    66.     }  
    67.   
    68. }  
    69. </span>  

    上面实现了创建和查询,在上面的有一个连续插入多个数据,还可以使用OrmLite提供的批处理任务方法如下:

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    1. <span style="font-size:14px;">/** 
    2.      * 连续进行插入,如果存在则更新 
    3.      */  
    4.     public void LiveCreates(final List<LiveItemBean> lists) {  
    5.         try {  
    6.             liveDao.callBatchTasks(new Callable<Void>() {  
    7.   
    8.                 @Override  
    9.                 public Void call() throws Exception {  
    10.                     for (LiveItemBean liveItemBean : lists) {  
    11.                         liveDao.createOrUpdate(liveItemBean);  
    12.                     }  
    13.                     return null;  
    14.                 }  
    15.             });  
    16.         } catch (Exception e) {  
    17.             e.printStackTrace();  
    18.         }  
    19.     }  
    20. </span>  
    查询除了用已有的接口,我们还可以使用sql语句来实现,比如:

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    1. // find out how many orders account-id #10 has  
    2.      GenericRawResults<String[]> rawResults =  
    3.        orderDao.queryRaw(  
    4.          "select count(*) from orders where account_id = 10");  
    5.      // there should be 1 result  
    6.      List<String[]> results = rawResults.getResults();  
    7.      // the results array should have 1 value  
    8.      String[] resultArray = results.get(0);  
    9.      // this should print the number of orders that have this account-id  
    10.      System.out.println("Account-id 10 has " + resultArray[0] + " orders"); 

    四、最后释放

    当我们应用退出时候,我们需要释放之前对象

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    1. OpenHelperManager.releaseHelper();  
    2.    dbHelper = null;  

    展开全文
  • android-ormlite

    2013-10-14 19:11:52
    文档很好的介绍了androidormlite技术,对ormlite的很多方法进行了详细的介绍,很不多的文档
  • Android著名的数据库开发操作辅助类框架ORMLite,包含所有的jar文件以及官方文档说明
  • Android OrmLite使用

    千次阅读 2014-04-15 15:37:25
    OrmLite可以帮助我们将会数据库操作,不用自己去写SQL语句,而且设置它跟使用Sqlite一样的方式,它是一种关系型数据,我比较喜欢的就是它能够帮助我判断数据表项是更新还是创建等操作,不需要自己去写大量的SQL语句...

    OrmLite可以帮助我们将会数据库操作,不用自己去写SQL语句,而且设置它跟使用Sqlite一样的方式,它是一种关系型数据,我比较喜欢的就是它能够帮助我判断数据表项是更新还是创建等操作,不需要自己去写大量的SQL语句去判断,下面介绍一下它的使用文档以及一些基本的注意点:

    官方网址:http://ormlite.com/

    JavaDOC地址:http://ormlite.com/javadoc/ormlite-android/ 

    开发文档地址:http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite.html

    一、建立模型

    首先创建一个Model,作为一个数据表,在Android中我使用的是实现Parcelable,代码如下:

    package com.jwzhangjie.capricorntv.bean;
    
    import com.j256.ormlite.field.DatabaseField;
    import com.j256.ormlite.table.DatabaseTable;
    
    import android.os.Parcel;
    import android.os.Parcelable;
    
    /**
     * 
     * @author zj 包含视频的参数 视频的名字 "channel_id":9, "channel_name":"湖南卫视",
     *         "icon_url":"http://tv.togic.com:8080/ShowTimeService/images/182.png",
     *         "province":"湖南", "mode":"SD", "url":
     *         "http://live.gslb.letv.com/gslb?stream_id=hunan&tag=live&ext=m3u8&sign=live_tv&platid=10&splatid=1012&temporarykey=db7c39a0ee39ab2d4d2e781d5"
     *         ,
     *         "second_url":["http://live-cdn.kksmg.com/channels/tvie/test/flv:500k"
     *         ,
     *         "http://live.gslb.letv.com/gslb?stream_id=hunanHD_1800&tag=live&ext=m3u8&sign=live_tv&platid=10&splatid=1012&temporarykey=db7c39a0ee39ab2d4d2e781d5"
     *         ,
     *         "http://pplive.shntv.cn/live/5/30/e9301e073cf94732a380b765c8b9573d.m3u8?type=ipad"
     *         ,"rtsp://rlive.tv189.cn/live/112"], "types":"2|0"
     */
    
    public class LiveItemBean implements Parcelable {
    
    	@Override
    	public int describeContents() {
    		return 0;
    	}
    
    	public LiveItemBean() {
    	}
    
    	private LiveItemBean(Parcel source) {
    		readFromParcel(source);
    	}
    
    	@DatabaseField(id = true)
    	private int channel_id;
    	@DatabaseField
    	private String channel_name;
    	@DatabaseField
    	private String icon_url;
    	@DatabaseField
    	private String province;
    	@DatabaseField
    	private String mode;
    	@DatabaseField
    	private String url;
    	@DatabaseField
    	private String second_urls;
    	private String[] second_url;
    	@DatabaseField
    	private String types;
    
    	private void readFromParcel(Parcel source) {
    		channel_name = source.readString();
    		icon_url = source.readString();
    		province = source.readString();
    		mode = source.readString();
    		url = source.readString();
    		second_urls = source.readString();
    		second_url = (String[]) source.readArray(LiveItemBean.class
    				.getClassLoader());
    		types = source.readString();
    
    	}
    
    	@Override
    	public void writeToParcel(Parcel dest, int flags) {
    		dest.writeInt(channel_id);
    		dest.writeString(channel_name);
    		dest.writeString(icon_url);
    		dest.writeString(province);
    		dest.writeString(mode);
    		dest.writeString(url);
    		dest.writeString(second_urls);
    		dest.writeArray(second_url);
    		dest.writeString(types);
    	}
    
    	public static Creator<LiveItemBean> CREATOR = new Creator<LiveItemBean>() {
    
    		@Override
    		public LiveItemBean createFromParcel(Parcel source) {
    			return new LiveItemBean(source);
    		}
    
    		@Override
    		public LiveItemBean[] newArray(int size) {
    			return new LiveItemBean[size];
    		}
    	};
    
    	public int getChannel_id() {
    		return channel_id;
    	}
    
    	public void setChannel_id(int channel_id) {
    		this.channel_id = channel_id;
    	}
    
    	public String getChannel_name() {
    		return channel_name;
    	}
    
    	public void setChannel_name(String channel_name) {
    		this.channel_name = channel_name;
    	}
    
    	public String getIcon_url() {
    		return icon_url;
    	}
    
    	public void setIcon_url(String icon_url) {
    		this.icon_url = icon_url;
    	}
    
    	public String getProvince() {
    		return province;
    	}
    
    	public void setProvince(String province) {
    		this.province = province;
    	}
    
    	public String getMode() {
    		return mode;
    	}
    
    	public void setMode(String mode) {
    		this.mode = mode;
    	}
    
    	public String getUrl() {
    		return url;
    	}
    
    	public void setUrl(String url) {
    		this.url = url;
    	}
    
    	public String getSecond_urls() {
    		return second_urls;
    	}
    
    	public void setSecond_urls(String second_urls) {
    		this.second_urls = second_urls;
    	}
    
    	public String[] getSecond_url() {
    		return second_url;
    	}
    
    	public void setSecond_url(String[] second_url) {
    		this.second_url = second_url;
    		StringBuffer buffer = new StringBuffer();
    		int count = second_url.length;
    		for (int i = 0; i < count; i++) {
    			buffer.append(second_url[i]);
    			if (i != count-1) {
    				buffer.append(";");
    			}
    		}
    		second_urls = buffer.toString();
    	}
    
    	public String getTypes() {
    		return types;
    	}
    
    	public void setTypes(String types) {
    		this.types = types;
    	}
    }
    

    我们分析上面的代码同时介绍一下与之相关的配置:

    1、是类名,这里我使用的数据表的名字是默认类的小写,当然你还可以指定表名字,使用@DatabaseTable(tableName = "liveitembeans"),

    2、主键,在上面的代码中有一行@DatabaseField(id = true)被注解对象就是主键,当然我们有时候使用的一个自增长的id,我们可以设置为@DatabaseField(generatedId = true)来实现,当然还有很多其他的注解配置我这里就不一一说明了,自己可以到官网可以查看找到自己需要的。

    二、创建DBHelper

    package com.jwzhangjie.capricorntv.db;
    
    import android.content.Context;
    import android.database.sqlite.SQLiteDatabase;
    
    import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;
    import com.j256.ormlite.support.ConnectionSource;
    import com.j256.ormlite.table.TableUtils;
    import com.jwzhangjie.capricorntv.bean.LiveItemBean;
    
    public class DBHelper extends OrmLiteSqliteOpenHelper {
    	
    	private static final String DATABASE_NAME = "jwzhangjie.db";
    	private static final int DATABASE_VERSION = 1;
    
    	public DBHelper(Context context){
    		super(context, DATABASE_NAME, null, DATABASE_VERSION);
    	}
    
    	@Override
    	public void onCreate(SQLiteDatabase sqLiteDatabase,
    			ConnectionSource connectionSource) {
    		try {
    			TableUtils.createTable(connectionSource, LiveItemBean.class);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    	@Override
    	public void onUpgrade(SQLiteDatabase sqLiteDatabase,
    			ConnectionSource connectionSource, int oldVer, int newVer) {
    		try {
    			TableUtils.dropTable(connectionSource, LiveItemBean.class, true);
    			onCreate(sqLiteDatabase, connectionSource);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	
    }
    
    上面使用TableUtils来创建和删除表,还有其他的功能例如清空表内容等

    三、创建操作工具

    接下来就是创建一个操作数据库的工具DAO

    package com.jwzhangjie.capricorntv.uitls;
    
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    
    import android.content.Context;
    
    import com.j256.ormlite.dao.Dao;
    import com.jwzhangjie.capricorntv.bean.LiveItemBean;
    import com.jwzhangjie.capricorntv.db.DBHelper;
    
    public class DBUtils {
    	
    	public static Dao<LiveItemBean, Integer> liveDao = null;
    
    	public DBUtils(Context context) {
    		if (liveDao == null) {
    			DBHelper dbHelper = new DBHelper(context);
    			try {
    				liveDao = dbHelper.getDao(LiveItemBean.class);
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    	/**
    	 * 插入直播数据,如果数据存在则进行更新
    	 * 
    	 * @param liveItemBean
    	 */
    	public void LiveCreate(LiveItemBean liveItemBean) {
    		try {
    			liveDao.createOrUpdate(liveItemBean);
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}
    	}
    
    	/**
    	 * 连续进行插入,如果存在则更新
    	 */
    	public void LiveCreates(List<LiveItemBean> lists) {
    		try {
    			for (LiveItemBean liveItemBean : lists) {
    				liveDao.createOrUpdate(liveItemBean);
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	
    	/**
    	 * 查询所有的直播元素
    	 * @return
    	 */
    	public List<LiveItemBean> getLiveItemBeans(){
    		List<LiveItemBean> listsBeans = new ArrayList<LiveItemBean>();
    		try {
    			listsBeans = liveDao.queryForAll();
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}
    		return listsBeans;
    	}
    
    }
    

    上面实现了创建和查询,在上面的有一个连续插入多个数据,还可以使用OrmLite提供的批处理任务方法如下:

    /**
    	 * 连续进行插入,如果存在则更新
    	 */
    	public void LiveCreates(final List<LiveItemBean> lists) {
    		try {
    			liveDao.callBatchTasks(new Callable<Void>() {
    
    				@Override
    				public Void call() throws Exception {
    					for (LiveItemBean liveItemBean : lists) {
    						liveDao.createOrUpdate(liveItemBean);
    					}
    					return null;
    				}
    			});
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    查询除了用已有的接口,我们还可以使用sql语句来实现,比如:

    // find out how many orders account-id #10 has
         GenericRawResults<String[]> rawResults =
           orderDao.queryRaw(
             "select count(*) from orders where account_id = 10");
         // there should be 1 result
         List<String[]> results = rawResults.getResults();
         // the results array should have 1 value
         String[] resultArray = results.get(0);
         // this should print the number of orders that have this account-id
         System.out.println("Account-id 10 has " + resultArray[0] + " orders");

    四、最后释放

    当我们应用退出时候,我们需要释放之前对象

    OpenHelperManager.releaseHelper();
    		dbHelper = null;
    



    展开全文
  • ORMLite是常用的一个ORM框架,...这儿是根据官方文档抽取来的android用法。一,添加依赖导入ormlite-core.jar和ormlite-android.jar:下载jar 或者build.gradle中添加: compile 'com.j256.ormlite:ormlite-android:5

    ORMLite是常用的一个ORM框架,她不止可以用在Android的sqlite数据库,也可以使用她操作其他常见的数据库。这儿是根据官方文档抽取来的android用法。

    一,添加依赖

    导入ormlite-core.jar和ormlite-android.jar:下载jar
    或者build.gradle中添加:

        compile 'com.j256.ormlite:ormlite-android:5.0'
        compile 'com.j256.ormlite:ormlite-core:5.0'

    二,创建Bean类

    1>类使用@DatabaseTable注解,标识一个表。
    2>成员变量使用 @DatabaseField 注解,表示表中的列。
    3>相关属性设置可以查询其依赖包中的DatabaseTable和Column注解类。持久化的数据类型可以查阅ORMLite官方文档或库源码。
    4>添加一个无参的构造函数。当执行查询返回结果时,ORMLite会使用Java反射构造函数创建对象。

    @DatabaseTable(tableName = "accounts")
    public class Account {
        //generatedId = true表示id主键自动生成
        @DatabaseField(generatedId = true)  
        private int id;
        //id = true表示这个列可以通过ID方法执行查询,更新,删除
        @DatabaseField(id = true)
        private String name;
        //canBeNull = false表示不可以为空
        @DatabaseField(canBeNull = false)
        private String password;
    
        public Account() {
            // ORMLite 需要一个无参构造器 
        }
    
        public Account(String name, String password) {
            this.name = name;
            this.password = password;
        }
    
        public int getId()  
        {  
            return id;  
        }  
        public void setId(int id)  
        {  
            this.id = id;  
        } 
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getPassword() {
            return password;
        }
        public void setPassword(String password) {
            this.password = password;
        }
    }

    三,创建数据库

    1>继承OrmLiteSqliteOpenHelper 创建database helper;
    2>在onCreate方法中调用TableUtils.createTable创建表,onUpgrade方法执行数据库更新。TableUtils类提供了一些创建和删除表的静态方法,参考源代码。

    public class DatabaseHelper extends OrmLiteSqliteOpenHelper {
        private static final String TABLE_NAME = "sqlite.db";
    
        public DatabaseHelper(Context context) {
            super(context, TABLE_NAME, null, 2);
        }
    
        @Override
        public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
    
            try {
                TableUtils.createTable(connectionSource, Bean.class);
            } catch (java.sql.SQLException e) {
                e.printStackTrace();
            }
    
        }
        @Override
        public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
    
        }
    }

    四,创建DAO

    在数据访问对象(Data Access Objects (DAO))类中隔离数据库操作,提供创建,删除,更新,等等操作。每个表都对应一个DAO,每个DAO有两个参数:使用DAO持久化数据的实体类和用来标示指定表中行的ID列,如果类中没设置ID列,可以把对象或null作为第二个参数。例如,在上面Account类中,“name”成员是ID列(id = true),所以ID列是字符串。
    创建DAO的最简单的方法是调用DaoManager.createDao(),这样如果它们被内部ORMLite功能需要,可以重复使用,而不是重新创建(创建DAO很消耗资源,应该尽可能重复利用):

    
    Dao<Account, String> accountDao =DaoManager.createDao(connectionSource, Account.class);
    Dao<Order, Integer> orderDao =DaoManager.createDao(connectionSource, Order.class);
    

    使用这种方式需要ConnectionSource参数,和实体类的Class对象,ConnectionSource参数可以通过OrmLiteSqliteOpenHelper的getConnectionSource()方法获得:

    ConnectionSource connectionSource = OrmLiteSqliteOpenHelper.getConnectionSource();

    如果想要一个更好的类层次结构,或者在DAO中需要添加较多的方法,可以定义一个接口,继承Dao接口,接口不是必须的,但这样做可以减少耦合:

    
    /** Account DAO ,具有字符串id (Account.name) */
    public interface AccountDao extends Dao<Account, String> {
        // 添加 DAO的方法
    }

    然后实现类继承BaseDaoImpl并实现上面定义的接口:

    
    /** JDBC implementation of the AccountDao interface. */
    public class AccountDaoImpl extends BaseDaoImpl<Account, String>implements AccountDao {
        // 这个构造器必须有
        public AccountDaoImpl(ConnectionSource connectionSource)
          throws SQLException {
            super(connectionSource, Account.class);
        }
    }

    要使用自定义DAO类的,需要到相应的实体类@DatabaseTable注解中添加daoClass参数:

    
    @DatabaseTable(daoClass = AccountDaoImpl.class)
    public class Account {
       …
    }

    也可以在DatabaseHelper中调用OrmLiteSqliteOpenHelper.getDao创建:

        private Dao<Account , Integer> accountDao;  
        public Dao<Account , Integer> getAccountDao() throws SQLException  
        {  
            if (AccountDao == null)  
            {  
                AccountDao = getDao(Account.class);  
            }  
            return accountDao;  
        }  

    五,运行时与SQL异常

    默认情况下,大多数的DAO方法都会抛出SQLException,大部分的异常继承RuntimeException,所以会需要大量的try … catch语句,出于这个原因,RuntimeExceptionDao包装了调用DAO方法会出现的运行时异常SQL exceptions:

    Dao<Account, String> dao = DaoManager.createDao(connectionSource, Account.class);
    RuntimeExceptionDao<Account, String> accountDao = new RuntimeExceptionDao<Account, String>(dao);

    或者直接使用其createDao方法:

    
    RuntimeExceptionDao<Account, String> accountDao =RuntimeExceptionDao.createDao(connectionSource, Account.class);

    在DatabaseHelper中可以调用OrmLiteSqliteOpenHelper.getRuntimeExceptionDao。

    六,使用DAO

    插入新的行到数据库:

    Account account = new Account();
    account.name = "Jim Coakley";
    accountDao.create(account);

    如果对象具有注解声明的id参数,那么我们就可以使用其ID在数据库中查找此对象:

    
    Account account = accountDao.queryForId(name);
    if (account == null) {
      account not found handling … 
    }

    如果改变对象的成员属性,必须调用update()将改变更新到数据库中:

    account.password = "_secret";
    accountDao.update(account);

    刷新对象

    如果数据空正使用的某个对象被其他实体改变,需要刷新这个对象,保证这个对象是实时的:

    accountDao.refresh(account);

    删除对象对应的数据库中的行,一旦对象已经从数据库中删除,您可以继续使用在内存中的该对象,但任何更新或刷新会失效:

    accountDao.delete(account);

    迭代

    该DAO本身也是一个迭代器,因此可以直接遍历数据库数据中表的行:

    // page through all of the accounts in the database
    for (Account account : accountDao) {
        System.out.println(account.getName());
    }

    这种方式必须遍历数据库中表的所有行,然后才会关闭潜在的sql对象。 如果没有通过循环遍历所有的行,
    ORMLite并不会关闭sql对象,数据库的连接会被弱化并且只有GC回收才会被关闭,这样会导致程序Bug,所以最好使用
    try…finally迭代器。以下for循环,是一个非常糟糕的代码:

    for (Account account : accountDao) {
        if (account.getName().equals("Bob Smith")) {
            // you can't return, break, or throw from here
            return account;
        }
    }

    也可以选择直接使用迭代器,因为for循环式并不总是最佳的。这样允许使用try…finally,达到一种更优化的代码:

     CloseableIterator<Account> iterator = accountDao.closeableIterator();
          try {
             while (iterator.hasNext()) {
                Account account = iterator.next();
                System.out.println(account.getName());
             }
          } finally {
             // close it at the end to close underlying SQL statement
             iterator.close();    
          }

    或者使用迭代包装器,for循环之后仍然可以关闭:

     CloseableWrappedIterable<Account> wrappedIterable =
           accountDao.getWrappedIterable();
           try {
              for (Account account : wrappedIterable) {
                  …
              }
           } finally {
              wrappedIterable.close();
       }

    七,使用OpenHelperManager

    DatabaseHelper可能在App或多个Activity的线程中被多次实例化使用,如果同时有多个对象,可能会出现过时的数据和意外的结果。所以建议使用OpenHelperManager管理DatabaseHelper的使用:

    private DatabaseHelper databaseHelper = null;
    
    private void releaseHelper() {
        if (databaseHelper != null) {
            OpenHelperManager.releaseHelper();
            databaseHelper = null;
        }
    }
    private DatabaseHelper getHelper() {
        if (databaseHelper == null) {
            databaseHelper =
                OpenHelperManager.getHelper(this, DatabaseHelper.class);
        }
        return databaseHelper;
    }

    还可以让Activity继承OrmLiteBaseActivity,OrmLiteBaseActivity对OpenHelperManager的使用做了进一步封装,还有OrmLiteBaseListActivity, OrmLiteBaseService, OrmLiteBaseTabActivity等,不过一般不这么做。但是可以在使用OpenHelperManager的时候拿来参考。
    然后通过databaseHelper操作数据库:

        Dao<Account, String> accountDao = getHelper().getAccountDao();
        Account account = new Account ();
        account.setName("one");
        account.setPassword("123");
        accountDao.create(account);

    八,ORMLite外键

    ORMLite支持外键的概念,既一个对象的一个或者多个属性保存在相同数据库中其他表中。比如数据库中有一个Order对象,每个Order对象都对应一个Account对象,然后就说Order(是一个表)对象的Account(也是一个表)成员有外键属性。id成员在表创建的时候会生成”account_id”列:

    @DatabaseTable(tableName = "orders")
    public class Order {
    
        @DatabaseField(generatedId = true)
        private int id;
    
        @DatabaseField(canBeNull = false, foreign = true)
        private Account account;
        …
    }

    当创建有外键属性成员的对象(Order)时,外键对象(Account)不会被自动创建(Account表不会自动创建)。如果外键对象(Account对象)在数据库中有generated id(Order对象有 id成员),应该在创建引用这个对象(Order对象有Account成员)的对象(Order对象)之前创建外键对象(Account表):

    Account account = new Account("Jim Coakley");
    accountDao.create(account);
    // 这时会创建一个account对象,并且设置generated ids
    
    // 现在用order设置account,创建并插入account表
    Order order = new Order("Jim Sanders", 12.34);
    order.setAccount(account);
    …
    orderDao.create(order);

    某些情况下如果希望外键自建,可以在外键(account)的注解中设置foreignAutoCreate参数。
    当你查询一个Order时,会获得一个account对象,这个对象只有id属性被设定了值,其他属性都是默认值(null, 0, false, etc.)。如果需要使用这个account对象的其他值,则必须调用accountDao类的refresh方法获得这个Account对象的属性:

    Order order = orderDao.queryForId(orderId);
    System.out.println("Account-id on the order should be set: " +
       order.account.id);
    // 此时 order.account.name为null
    System.out.println("But other fields on the account should not be set: "
       + order.account.name);
    
    // 用AccountDao刷新一下account
    accountDao.refresh(order.getAccount());
    System.out.println("Now the account fields will be set: " +
       order.account.name);

    也可以在注解中添加foreignAutoRefresh参数值设置自动刷新外键对象的数据。
    有不同的方式查询外键的参数值,比如查询匹配某个account的所有Order,通过ID参数的成员和account的name查询:

    // query for all orders that match a certain account
    List<Order> results =
      orderDao.queryBuilder().where().
        eq("account_id", account.getName()).query();

    也可以让ORMLite从该account中自动提取id获得:

    // ORMLite will extract and use the id field internally
    List<Order> results =
      orderDao.queryBuilder().where().
        eq("account_id", account).query();

    九,外键集合

    上面说了Account是Order的外键,如果一个Account对象对应多个Order对象,则可以将其以成员的形式通过 @ForeignCollectionField注解以以下形式添加到Account中去:

    public class Account {
        …
        @ForeignCollectionField(eager = false)
        ForeignCollection<Order> orders;
        …
    }

    成员类型只可以使用ForeignCollection< T> 或 Collection< T>。注解参数可以查阅库中的ForeignCollectionField类。
    当改变了Collection中的order时,需要调用update在数据库中更新它:

    for (Order order : account.orders()) {
       // 如果改变了order的某些成员
       order.setAmount(123);
       // 必须在数据库中更新account
       account.orders.update(order);
    }

    十,事务

    当对数据库有较多的执行动作时,用事务处理比较好,图个方便,下段代码摘自ormlite的事务使用

    private boolean doBatchInTransaction(final List<T> list, final int batchType) {
            boolean doBatch = false;
            ConnectionSource connectionSource = ormLiteDao.getConnectionSource();
            TransactionManager transactionManager = new TransactionManager(connectionSource);
            Callable<Boolean> callable = new Callable<Boolean>() {
                @Override
                public Boolean call() throws Exception {
                    return doBatch(list, batchType);
                }
            };
            try {
                doBatch = transactionManager.callInTransaction(callable);
            } catch (SQLException e) {
                LogUtil.e(e);
            }
            return doBatch;
        }
    
        private boolean doBatch(List<T> list, int batchType) {
            int result = 0;
            try {
                for (T t : list) {
                    switch (batchType) {
                        case DaoOperation.INSERT:
                            result += ormLiteDao.create(t);
                            break;
                        case DaoOperation.DELETE:
                            result += ormLiteDao.delete(t);
                            break;
                        case DaoOperation.UPDATE:
                            result += updateIfValueNotNull(t);
                            break;
                        default:
                            LogUtil.w("no this type.");
                            break;
                    }
                }
            } catch (SQLException e) {
                LogUtil.e(e);
            }
            return result == list.size();
        }

    十一,更新数据库

    更新app时,可能会修改现有的数据库,这时就需要在 创建的DatabaseHelper的onUpgrade方法中进行一些工作了。比如在表中增加一列,可以在onUpgrade方法中这么做:

    Dao<Account, Integer> dao = getHelper().getAccountDao();
    // 在表account中增加 "age" 列
    dao.executeRaw("ALTER TABLE `account` ADD COLUMN age INTEGER;");

    所有能做的就是重新命名表名和添加新列,不要重命名或删除列或更改列的属性。
    最常用的,是根据版本条件更改数据库:

    if (oldVersion < 2) {
      // we added the age column in version 2
      dao.executeRaw("ALTER TABLE `account` ADD COLUMN age INTEGER;");
    }
    if (oldVersion < 3) {
      // we added the weight column in version 3
      dao.executeRaw("ALTER TABLE `account` ADD COLUMN weight INTEGER;");
    }

    或者:

    dao.executeRaw(
        "ALTER TABLE `account` ADD COLUMN hasDog BOOLEAN DEFAULT 0;");
    dao.updateRaw("UPDATE `account` SET hasDog = 1 WHERE dogCount > 0;");

    这儿用到了数据库语句,可以查阅sqlite官方文档。

    更多请参考 ORMLite官方文档

    展开全文
  • 该压缩包包含ormlite开发jar包、源码包ormlite-android-4.43-sources.jar、API文档ormlite-android-4.43-javadoc.jar,以及ormliteandroid例子工程源码和一份官方教程ormlite.pdf
  • 前言  个人感觉android上sqlite已经比较好用,但是如果需要在android上像J2EE那样开发的话那么sqlite还是显得比较复杂,这个时候你当然可以选择一些android平台上...本系列主要是翻译ORMlite文档。  为什么翻译...

    前言

      个人感觉android上sqlite已经比较好用,但是如果需要在android上像J2EE那样开发的话那么sqlite还是显得比较复杂,这个时候你当然可以选择一些android平台上的ORM框架。ORM框架是做什么的,android平台上有哪些好用的ORM框架,这些问题你通通可以google得到你满意的结果,在此不做解释。本系列主要是翻译ORMlite文档。

      为什么翻译ORMlite?简单点说就是因为个人觉得ORMlite是android平台上不错的ORM框架,官方也提供了很多相关介绍。但是几乎没有看到有中文文档。为了更多人可以学习到这个框架所以决定把官方的文档翻译成中文。个人英语水平非常有限,但是本人会尽力,如果文中有不妥的翻译之处敬请告之。文档中的比较杂的内容就不在文档中进行翻译,比如参见xxx连接,这些没有意义。主要翻译的技术文档而非专业英语,但基本会保持原文档的内容。

    -------------------------------------------------------------------------------------

    1 获得开始

    1.1 下载ORMlite jar

     
     

    为了使用ORMLite,你需要下载相关的jar文件。ORMLite发布包是一个默认库,不过相关jar文件也可以通过网络从内部资源库里面获得。

    通过JDBC连接SQL 数据库的用户需要下载ormlite-jdbc-4.41.jar和ormlite-core-4.41.jar两个文件。在android应用中使用,你需要下载ormlite-android-4.41.jarormlite-core-4.41.jar两个文件。在有ORMlite后台实现的JDBC中或者是Android中你都需要ormlite-core发布包。ORMLite没有任何外部依赖,即使可能有你想用的其他选用包。

    1.2 配置class

    下面是个class通过使用ORMlite 注解配置持久化到数据的例子。@DatabaseTable 注解配置Access类到数据库名为accounts的表。@DatabaseField注解映射Account中的每个字段到数据库中相同名字的字段。

    一个字段需要配置成数据库中表的主键那么可以通过使用id=true 注解字段。并且,值得一提的是一个无参的构造器是必须的,这样的话通过查询可以返回一个对象。

     

    复制代码
    @DatabaseTable(tableName = "accounts")
    
    public class Account {
    
    @DatabaseField(id = true)
    
    private String name;
    
    @DatabaseField
    
    private String password;
    
    public Account() {
    
    // ORMLite needs a no-arg constructor
    
    }
    
    public Account(String name, String password) {
    
    this.name = name;
    
    this.password = password;
    
    }
    
    public String getName() {
    
    return name;
    
    }
    
    public void setName(String name) {
    
    this.name = name;
    
    }
    
    public String getPassword() {
    
    return password;
    
    }
    
    public void setPassword(String password) {
    
    this.password = password;
    
    }
    
    }
    复制代码

     

     

     


    1.3 配置 DAO

    一个典型的java隔离数据库操作的模式是用数据访问对象类(Data Access Objects,即DAO)。每个DAO提供增、删、改等操作。这中功能专注于处理一个单一持久化的类。一种简单的创建DAO的方式是使用DaoManager类的静态方法createDao。例如,为上面定义的Account类创建一个DAO你可以这样做:

     

    复制代码
    Dao<Account, String> accountDao =
    
    DaoManager.createDao(connectionSource, Account.class);
    
    Dao<Order, Integer> orderDao =
    
    DaoManager.createDao(connectionSource, Order.class);
    复制代码

     

     

     


    1.4 代码示例

    这个示例使用本地Java H2数据库,创建一个在内存中运行的测试数据库。如果你想把示例代码跑起来那么你需要下载并且添加H2 jar文件到你的classpath中。注意:android用户需要看本手册android部分具体的文档。

    代码执行下面几步:

    ①创建connection,这个connection可以操作数据库。

    ②为Account对象实例化一个DAO

    accounts数据库表已经创建过。如果这个表已经创建好的话那么这几步就不必要了。

     

    复制代码
    public class AccountApp {
    
    public static void main(String[] args) throws Exception {
    
    // this uses h2 by default but change to match your database
    
    String databaseUrl = "jdbc:h2:mem:account";
    
    // create a connection source to our database
    
    ConnectionSource connectionSource =
    
    new JdbcConnectionSource(databaseUrl);
    
    // instantiate the dao
    
    Dao<Account, String> accountDao =
    
    DaoManager.createDao(connectionSource, Account.class);
    
    // if you need to create the 'accounts' table make this call
    
    TableUtils.createTable(connectionSource, Account.class);
    
    Once we have congured our database objects, we can use them to persist an Account
    
    to the database and query for it from the database by its ID:
    
    // create an instance of Account
    
    Account account = new Account();
    
    account.setName("Jim Coakley");
    
    // persist the account object to the database
    
    accountDao.create(account);
    
    // retrieve the account from the database by its id field (name)
    
    Account account2 = accountDao.queryForId("Jim Coakley");
    
    System.out.println("Account: " + account2.getName());
    
    // close the connection source
    
    connectionSource.close();
    
    }
    
    }

    转载于:https://www.cnblogs.com/weixiao870428/p/3510822.html

    展开全文
  • Google开源的基于...压缩包里包含 ormlite-android-4.30.jar 及帮助文档ormlite-core-4.30.jar核心包 当然也支持在Java中的Jdbc中使用类似Hibernate Sqlite驱动包、ormlite-jdbc-4.45.jar 及帮助文档 测试用例
  • Android ORM框架之 ORMLite

    2015-03-19 00:26:30
    ORMLite这个框架恐怕是在ORM中被采用的比较多的一个。文档,实例i,源码都比较多,维护也不错。...在android应用中使用,我们需要下载ormlite-android-4.48.jar和ormlite-core-4.48.jar两个文件 工
  • android ormlite 模拟实现 联合主键 参考文档说明:http://blog.csdn.net/u013250921/article/details/18264555
  • android Ormlite数据库更新

    千次阅读 2015-03-19 14:20:25
    由于app中的数据库操作选择了ormlite,在发布新版本时数据库结构发生了变化,需要更新字段 查看官方文档,纪录下心得 创建数据库相关操作想必大家都知道,是在onCreate方法中实现 例如 TableUtils.createTable...
  • 官方文档的第四章原标题是Using With Android, 看过前面的文档友友,看到这里可能会有点晕乎,因为从一开始就在介绍ORMLiteAndroid中的介绍,但是到第四章还出现这个标题。这是因为,这个框架并不是Android中专用...
  • Ormlite框架是第三方对数据库操作的封装框架,它是一个非常轻量级的数据库操作框架,底层是根据反射机制来实现的。 优缺点 优点:文档较全面,社区活跃,有好的维护,使用简单,易上手 缺点:基于反射和注解的...
  • 总感觉用原始的SQLLiteHelper操作数据库有点麻烦,上网找了些android数据库orm框架,对比了一下,现在使用ormlite的人貌似挺多的,在网上找了ormlite官方文档,根据官方文档,今天写了个demo,主要是用户注册,用户...
  • 由于第二章是整个文档的核心,内容也很多,所以分次翻译。下一章的内容会继续本章接着翻译。 -------------------------------------------------------------------------------------   2 如何使用 这...
  • 前言  个人感觉android上sqlite已经比较好用,但是如果需要在android上像J2EE那样开发的话那么sqlite还是显得比较复杂,这个时候你当然可以选择一些android平台...本系列主要是翻译ORMlite文档。  为什么翻译ORMli
  • 简述: ORMlite是类似hibernate的对象映射框架,主要面向java语言,同时,是时下最流行的android面向数据库的的编程工具。 http://blog.csdn.net/sbvfhp/article/details/20460319 官方网站:http://ormlite.com/  ...
  • [图片说明](https://img-ask.csdn.net/upload/201611/26/1480152518_527671.png) 我使用了这样的查询,可是没有结果返回,我数据库是有数据的,初次接触OrmLite,网上搜了很多,都没有,到OrmLite官网上看文档也是...
  • 总感觉用原始的SQLLiteHelper操作数据库有点麻烦,上网找了些android数据库orm框架,对比了一下,现在使用ormlite的人貌似挺多的,在网上找了ormlite官方文档,根据官方文档,今天写了个demo,主要是用户注册,用户...
  • 本文会介绍学习框架基本...一,下载Jar包1,打开ORMLite官网(百度搜索即可)http://ormlite.com/sqlite_java_android_orm.shtml是不是看不懂?看不懂可以翻译啊~ 2,找文档一般网上的框架,都会提供文档供开发者使用
  • Android数据库ORMlite框架详解

    千次阅读 2015-12-19 15:41:27
    转至:... 前言 由于第二章是整个文档的核心,内容也很多,所以分次翻译。下一章的内容会继续本章接着翻译。 ----------------------------------------------------------------------------------
  • OrmLite是一个轻量级的ORM框架,面向JAVA语言。也是时下流行的Android的ORM框架...使用OrmLite,首先要在gradle配置依赖 compile 'com.j256.ormlite:ormlite-android:4.48'也可以去ormlite官网下载查看文档 http://or
  • ormlite是Java平台的一个ORM框架,支持JDBC链接,Spring和Android平台,在Android中使用包含两部分。简述: 优点: 1.轻量级;2.使用简单,易上手;3.封装完善;4.文档全面。缺点:1.基于反射,效率较低(本人还没有...

空空如也

空空如也

1 2 3 4 5 6
收藏数 101
精华内容 40
关键字:

ormliteandroid文档