Android sqlite 操作类

简单介绍一下。该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 }