代码改变世界

Android sqlite 操作类

2012-05-23 11:43  cczw  阅读(4306)  评论(1)  编辑  收藏  举报

简单介绍一下。该dao类继承了bean操作接口，当然也开放了sqlitedatebase类接口，你可以尽情使用其原生方法。

其中用到了 LangUtil类，是个反射操作类，主要是获取get set方法啊，成员变量列表啊什么。可以自己去实现，也可以去down一个。

说啥都没用，直接上代码，代码中的注释那是相当的全面。不完善的地方自己去优化。我是暂时不想优化了，

  1 package com.cczw.util;
  2 /**
  3  * @author awen
  4  * */
  5 import java.lang.reflect.Field;
  6 import java.lang.reflect.Method;
  7 import java.util.ArrayList;
  8 import java.util.List;
  9 
 10 import android.content.ContentValues;
 11 import android.content.Context;
 12 import android.database.Cursor;
 13 import android.database.sqlite.SQLiteDatabase;
 14 import android.database.sqlite.SQLiteOpenHelper;
 15 import android.util.Log;
 16 
 17 public class SqliteUtil {
 18     public static final String WEBVIEWCACHEDB="webviewCache.db";
 19 
 20     private static final String TAG = "SqliteUtil";
 21      private SQLiteOpenHelper helper=null;
 22      private SQLiteDatabase db=null;
 23 
 24     private String tableName=null;
 25     private String primaryKey=null;
 26     private ArrayList<String> colums=null; //（key）键的名称 
 27     private Class<?> adpater=null;
 28     private Field[] fields=null;
 29 
 30     /***/
 31     public SqliteUtil(Context context,String dbname){
 32         helper=new SQLiteOpenHelper(context, dbname, null, 1) {
 33             @Override
 34             public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 35                 //当打开数据库时传入的版本号与当前的版本号不同时会调用该方法。
 36             }
 37             @Override
 38             public void onCreate(SQLiteDatabase db) {
 39                 //当数据库被首次创建时执行该方法，一般将创建表等初始化操作在该方法中执行。
 40             }
 41         };
 42          //SQLiteDatabase对象
 43         db=helper.getWritableDatabase();
 44         colums=new ArrayList<String>();
 45     }
 46     /**关闭数据库操作*/
 47     public void close(){
 48         db.close();
 49         helper.close();
 50     }
 51     /**返回数据库对象，可以自主的使用一些原生方法*/
 52     public SQLiteDatabase getSqliteDB(){
 53         return db;
 54     }
 55     /**查看数据库中是否存在某表*/
 56     public boolean hasTable(String table_name)
 57     {
 58         boolean result = false;
 59         Cursor cur = null;
 60         try {
 61             String sql_table = "select count(*) as c from Sqlite_master    where type='table' and name ='"    + table_name.trim() + "'";
 62             cur = db.rawQuery(sql_table, null);
 63             if (cur.moveToNext()) {
 64                 int count = cur.getInt(0);
 65                 if (count > 0) {
 66                     result = true;
 67                 }
 68             }
 69             cur.close();
 70         } catch (Exception e) {
 71             return result;
 72         }
 73         return result;
 74     }
 75     /**设定table的名称，和其适配的javabean,如果该表不存在将根据这两个参数建立该表
 76      * @param tableName 数据表名称
 77      * @param adpater   该数据表对应的javabean  注意，避免使用基本数据类型和数组
 78      * @param PRIMARY    主键 ，没有则为null，该值只有创建表的时候管用
 79      * */
 80     public void setTables(String tableName,Class<?> adpater,String primaryKey){
 81         this.tableName=tableName;
 82         this.adpater=adpater;
 83         this.primaryKey=primaryKey;
 84         this.fields=LangUtil.getFields(adpater);
 85         if(!hasTable(tableName)){
 86             StringBuffer createSql = new StringBuffer("CREATE TABLE " + tableName + "(");
 87             for(int i=0,len=fields.length;i<len;i++){
 88                 Field f=fields[i];
 89                 String fieldName=f.getName();
 90                 String fieldType=getSqliteTypeClass(f.getType()).getSimpleName();
 91                 colums.add(fieldName);
 92                 createSql.append(" "+fieldName+" "+fieldType+" ");
 93                 if(fieldName.equals(primaryKey)){
 94                     createSql.append(" PRIMARY KEY  AUTOINCREMENT  NOT NULL ");
 95                 }
 96                 if(i<len-1){createSql.append(",");}
 97              }
 98             createSql.append(")");
 99             Log.d(TAG, "创建表："+createSql.toString());
100             db.execSQL(createSql.toString());
101         }else{
102             for(int i=0,len=fields.length;i<len;i++){
103                 colums.add(fields[i].getName());
104             }
105         }
106      }
107     /**删除数据库中的表*/
108     public void delTable(String tablename){
109         if(hasTable(tablename)){
110             db.execSQL("DROP TABLE "+tablename);
111         }
112     }
113     /**删除表中的所有数据*/
114     public void clearTable(String tablename){
115         if(hasTable(tablename)){
116             db.execSQL("delete from "+tablename);
117         }
118     }
119     /**通用查询接口,无返回值*/
120     public void query(String sql){
121         db.execSQL(sql);
122     }
123     /**增加记录,并返回增加记录的索引,否则返回-1
124      * @param  bean table表对应的bean
125      * @return long 插入字段的索引
126      * */
127     public long insertRow(Object bean){
128         Long ret=-1L;
129         if(bean!=null&&bean.getClass()==adpater){
130              ContentValues  cv=BeanAdpater(bean,false);
131              ret=db.insert(this.tableName, this.primaryKey, cv);
132         }else{
133             Log.d(TAG,"参数为空或者类型错误");
134         }
135         return ret;
136     }
137     /**根据查询条件返回数据表中的记录数组arrylist
138      * @param <E>
139      * @param condition 查询的条件语句,将补在全部查询sql语句之后
140      * */
141     @SuppressWarnings("unchecked")
142     public <E> List<E> getRows(String condition){
143         List<E> rows=new ArrayList<E>();
144         String sql="select * from "+this.tableName;
145         if(!("").equals(condition)&&condition!=null){
146             sql+=" "+condition;
147         }
148         Cursor cursor=db.rawQuery(sql, null);
149         Log.d(TAG, "select查询：数据总行数："+cursor.getCount()+"；列数:"+cursor.getColumnNames().length);
150         cursor.moveToFirst();
151         while(!cursor.isAfterLast()){
152             try {
153                 Object bean=getRow(cursor);
154                 rows.add((E) bean);
155             } catch (Exception e) {
156                 e.printStackTrace();
157             }
158             cursor.moveToNext();
159         }
160         cursor.close();
161         return rows;
162     }
163     
164     /**修改指定的bean记录,依据本类的bean类设置的主键的值，所以主键对应的成员变量的值必须存在*/
165     public void updateRow(Object bean){
166         if(bean!=null&&bean.getClass()==adpater){
167              ContentValues  cv=BeanAdpater(bean,true);
168              db.update(this.tableName, cv, this.primaryKey+"=?", new String[]{cv.getAsString(primaryKey)});
169         }else{
170             Log.d(TAG,"参数为空或者类型错误");
171         }
172     }
173     /**删除指定的bean记录，依据本类的bean类设置的主键的值，所以主键对应的成员变量的值必须存在*/
174     public void deleteRow(Object bean){
175         if(bean!=null&&bean.getClass()==adpater){
176              ContentValues  cv=BeanAdpater(bean,true);
177              db.delete(this.tableName, this.primaryKey+"=?", new String[]{cv.getAsString(primaryKey)});
178         }else{
179             Log.d(TAG,"参数为空或者类型错误");
180         }
181     }
182     /**bean 转换为 ContentValues
183      * @param covertPrimaryKey  返回的ContentValues中是否包含主键
184      * */
185     private ContentValues BeanAdpater(Object bean,boolean covertPrimaryKey){
186         ContentValues cv=new ContentValues();
187         Field[] fields=LangUtil.getFields(bean.getClass());
188         for(int i=0,len=fields.length;i<len;i++){
189             Field f=fields[i];
190             String fieldName=f.getName();
191             if(fieldName.equals(this.primaryKey)&&!covertPrimaryKey){
192                 continue;
193             }
194             Method getMethod = null;
195             try {
196                 getMethod =LangUtil.getGetter(bean.getClass(), fieldName);
197                 String returntype=getSqliteTypeClass(f.getType()).getSimpleName().toLowerCase();
198                 Object val=getMethod.invoke(bean);
199                 //Log.d(TAG,returntype+":"+fieldName+":"+val);
200                 if(val==null){continue;}
201                 if(returntype.equals("string")){
202                     cv.put(fieldName,(String)val);
203                 }else if(returntype.equals("character")){
204                     cv.put(fieldName,val.toString());
205                 }else if(returntype.equals("boolean")){
206                     cv.put(fieldName,(Boolean)val);
207                 }else if(returntype.equals("integer")){
208                     cv.put(fieldName,(Integer)val);
209                 }else if(returntype.equals("byte")){
210                     cv.put(fieldName,(Byte)val);
211                 }else if(returntype.equals("short")){
212                     cv.put(fieldName,(Short)val);
213                 }else if(returntype.equals("double")){
214                     cv.put(fieldName,(Double)val);
215                 }else if(returntype.equals("float")){
216                     cv.put(fieldName,(Float)val);
217                 }else if(returntype.equals("long")){
218                     cv.put(fieldName,(Long)val);
219                 }else{
220                     cv.putNull(fieldName);
221                 }
222             } catch (Exception e) {
223                 e.printStackTrace();
224             }
225         }
226         return cv;
227     }
228     /**获取当前指针所在位置的一行数据
229      * @throws InstantiationException 
230      * @throws IllegalAccessException */
231     private Object getRow(Cursor cursor) throws IllegalAccessException, InstantiationException{
232         Object bean=adpater.newInstance();
233         if(!cursor.isAfterLast()&&!cursor.isBeforeFirst()&&!cursor.isClosed()){
234             for(int i=0,len=cursor.getColumnCount();i<len;i++){
235                 String fieldName= cursor.getColumnName(i);
236                 String returntype=getSqliteTypeClass(fields[i].getType()).getSimpleName().toLowerCase();
237                 //Log.d(TAG, fieldName+"="+cursor.getString(i));
238                 String val=cursor.getString(i);
239                 if(val==null){continue;}
240                 Object oval=null;
241                 if(returntype.equals("string")){
242                     oval=val;
243                 }else if(returntype.equals("character")){
244                     oval=(val.charAt(0));
245                 }else if(returntype.equals("boolean")){
246                     oval=val.equals("1")?true:false;
247                 }else if(returntype.equals("integer")){
248                     oval=Integer.parseInt(val);
249                 }else if(returntype.equals("byte")){
250                     oval=Byte.parseByte(val);
251                 }else if(returntype.equals("short")){
252                     oval=Short.parseShort(val);
253                 }else if(returntype.equals("double")){
254                     oval=Double.parseDouble(val);
255                 }else if(returntype.equals("float")){
256                     oval=Float.parseFloat(val);
257                 }else if(returntype.equals("long")){
258                     oval=Long.parseLong(val);
259                 }
260                 LangUtil.setValue(bean, fieldName, oval);
261             }
262         }
263         return bean;
264     }
265     /**获取传入类型的非基本数据类型表示方式*/
266     private Class<?> getSqliteTypeClass(Class<?> classz){
267         return classz.isPrimitive()?LangUtil.getWrapperClass(classz):classz;
268     }
269 }