复习android SQLiteOpenHelper

public class MyOpenHelper extends SQLiteOpenHelper {

    public static final int DATABASE_VERSION = 1;
    public static final String DATABASE_NAME = "FeedReader.db";

   public MyOpenHelper(Context context) {
      /**
      * 正常创建数据库
      * */
//    super(context, "dataceshi.db", null, 1);
        /**
        * 给数据库升级，同时，执行onUpgrade方法
        * 在数据库原有的表单上，再添加两个字段
        *
        * */
      super(context, "dataceshi.db", null, 5);


      Log.d("wangdong", "数据库构造执行了，创建数据库");
   }

   @Override
   public void onCreate(SQLiteDatabase db) {
       /*
       * 创建数据表单
       * */
       db.execSQL("create table industry(_id integer primary key autoincrement, "
                   + " industryid integer, val char,  name char)");

       /**
          *
          * 创建数据库表字段 create创建table表person自定义表明
            (_id一般都会指定id的但是要在前面加_  后面写的就是_id的属性了
            属性:integer整数  primary key是主要的重要的     autoincrement是自动生成自增
            分割符是逗号","   如果觉得字段很长回车时候一定要加+和空格符
          * */


        Log.d("wangdong", "数据库创建数据表单执行了");
   }

   /**
     * //让这个方法执行一必须版本升高，另外一点必须SQLiteDatabase db = openHelper.getWritableDatabase();才会执行
     * */
   @Override
   public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
      // TODO Auto-generated method stub
      String[] newColumnArr = new String[]{"sid integer","suid integer"};
      addColumn(db, newColumnArr, "industry");

        Log.d("wangdong", "数据库升级执行了");
   }
   
    /** 
     * 在表中添加字段方法 操作步骤： 1、先更改表名 2、创建新表,表名为原来的表名 3、复制数据 4、删除旧表 
     * 
     * @param db 
     *            数据库名 
     * @param newColumnArr 
     *            添加的新字段的表名数组 
     * @param oldTableName 
     *            旧表名，在方法内部将旧表名修改为 _temp_+oldTableName 
     */  
    private void addColumn(SQLiteDatabase db, String[] newColumnArr, String oldTableName) {  
         
        if (db == null || newColumnArr == null || newColumnArr.length < 1  
                || TextUtils.isEmpty(oldTableName)) {  
            // 数据库为空，新字段个数为0，添加字段后的字段数组个数为0，旧表名为空  
            return;  
        }  
  
        // 拿到旧表中所有的数据  
        Cursor cursor = db.rawQuery("select * from " + oldTableName, null);  
        if (cursor == null) {  
            // 如果游标为空  
            return;  
        }  
        // 拿到原来的表中所有的字段名  
        String[] oldColumnNames = cursor.getColumnNames();  
  
        // 更改原表名为临时表  
        String tempTableName = "_temp_" + oldTableName;
        /*改表名字*/
        db.execSQL(  
                "alter table " + oldTableName + " rename to " + tempTableName);  
  
        // 创建新表  
        if (oldColumnNames.length < 1) {  
            // 如果原来的表中字段个数为0  
            return;  
        }  
  
        // 创建一个线程安全的字符串缓冲对象，防止用conn多线程访问数据库时造成线程安全问题  
        StringBuffer createNewTableStr = new StringBuffer();  
        createNewTableStr  
                .append("create table if not exists " + oldTableName + "(");  
        for (int i = 0; i < oldColumnNames.length; i++) {  
            if (i == 0) {  
                createNewTableStr.append(oldColumnNames[i]  
                        + " integer primary key autoincrement,");  
            } else {  
                createNewTableStr.append(oldColumnNames[i] + ",");  
            }  
        }  
  
        for (int i = 0; i < newColumnArr.length; i++) {  
            if (i == newColumnArr.length - 1) {  
                // 最后一个  
                createNewTableStr.append(newColumnArr[i] + ")");  
            } else {  
                // 不是最后一个  
                createNewTableStr.append(newColumnArr[i] + ",");  
            }  
        }  
        
        db.execSQL(createNewTableStr.toString());  
  
        // 复制旧表数据到新表  
        StringBuffer copySQLStr = new StringBuffer();  
        copySQLStr.append("insert into " + oldTableName + " select *,");  
        // 有多少个新的字段，就要预留多少个' '空值给新字段  
        for (int i = 0; i < newColumnArr.length; i++) {  
            if (i == newColumnArr.length - 1) {  
                // 最后一个  
                copySQLStr.append("' ' from " + tempTableName);  
            } else {  
                // 不是最后一个  
                copySQLStr.append("' ',");  
            }  
        }  
         
        db.execSQL(copySQLStr.toString());  
  
        // 删除旧表  
        db.execSQL("drop table " + tempTableName);  
  
        // 关闭游标  
        cursor.close();  
    }  

}

/**
 * 
 * @author lykj
 *第一次执行的时候需要，
 * openHelper = new MyOpenHelper(context);
          SQLiteDatabase db = openHelper.getWritableDatabase();
        都放到方法中，构造不流，
        但是要是让数据库的 onUpgrade执行 必须db = openHelper.getWritableDatabase();执行，
      所以测试的时候就放到了构造中，这问题以后想法解决
 */
public class OpinionDao implements IDao{
   private  SQLiteOpenHelper openHelper;
    private Context context;
    
    public OpinionDao(Context context) {
       if (context == null) {
          throw new IllegalArgumentException("参数Context不允许为null！！！");
       }
          this.context = context;
       //如果数据库不存在，先创建数据库，再获取可读可写的数据库对象，如果数据库存在，就直接打开
           openHelper = new MyOpenHelper(context);
       //为了升级数据库方法执行，添加的，如果不升级可以注释掉
//        SQLiteDatabase db = openHelper.getWritableDatabase();
//     db.close();
        }
    
   @Override
   public long insert(Industry opinion) {
           
           
           SQLiteDatabase db = openHelper.getWritableDatabase();
           
           ContentValues values = new ContentValues();
           values.put("industryid", opinion.getId());
           values.put("name", opinion.getDesc());
           values.put("val", opinion.getValuse());

           long id = db.insert("industry", null, values);
           db.close();
           return id;
       }

   @Override
   public int delete(long id) {
//         SQLiteOpenHelper openHelper = new MyOpenHelper(context);
           SQLiteDatabase db = openHelper.getWritableDatabase();
           int affectedRows = db.delete("industry", "industryid=?", new String[] { id + "" });
           db.close();
           return affectedRows;
       }

   @Override
   public int update(Industry opinion) {
//         SQLiteOpenHelper openHelper = new MyOpenHelper(context);
           SQLiteDatabase db = openHelper.getWritableDatabase();
           ContentValues values = new ContentValues();
           values.put("industryid", opinion.getId());
           values.put("name", opinion.getDesc());
           values.put("val", opinion.getValuse());


           int affectedRows = db.update("industry", values , "industryid=?", new String[] { opinion.getId() + "" });
           db.close();
           return affectedRows;
       }

    @Override
    public List query(String whereClause, String[] whereArgs, String orderBy) {
//         SQLiteOpenHelper openHelper = new MyOpenHelper(context);
           SQLiteDatabase db = openHelper.getWritableDatabase();
           List opinions = new ArrayList();
           Cursor c = db.query("industry", null, whereClause, whereArgs, null, null, orderBy);
           if(c.moveToFirst()) {
               for(; !c.isAfterLast(); c.moveToNext()) {
                   Industry opinion = new Industry();
                   opinion.setId(c.getInt(c.getColumnIndex("industryid")));
                   opinion.setDesc(c.getString(c.getColumnIndex("name")));
                   opinion.setValuse(c.getString(c.getColumnIndex("val")));


                   opinions.add(opinion);
               }
           }
           db.close();
           return opinions;
       }

    public String[] getTag(String whereClause, String[] whereArgs, String orderBy) {
//         SQLiteOpenHelper openHelper = new MyOpenHelper(context);
           SQLiteDatabase db = openHelper.getWritableDatabase();
           List tagList = new ArrayList();
           Cursor c = db.query("industry", null, whereClause, whereArgs, null, null, orderBy);
           if(c.moveToFirst()) {
               for(; !c.isAfterLast(); c.moveToNext()) {

                  String tag=c.getString(c.getColumnIndex("name"));

                   tagList.add(tag);
               }
           }
           c.close();
           db.close();
           return tagList.toArray(new String[]{});
       }



       /**
       *  SQLite数据库 增删改查
       *
       *  //增加数据
       public void insert(){

       //       db.execSQL("insert into person (name, salary, phone)values(?, ?, ?)", new Object[]{"小志的老婆[1]", "13000", 138438});
       //       db.execSQL("insert into person (name, salary, phone)values(?, ?, ?)", new Object[]{"小志的儿子", 14000, "13888"});
       db.execSQL("insert into person (name, salary, phone)values(?, ?, ?)", new Object[]{"小志", 14000, "13888"});
       //insert删person数据表中(某某,某某,某某,)数据对应的只values值(?是占位符,?,?)",new一个Object集合{对应要增加的值});
       }
       //删除数据
       public void delete(){
       db.execSQL("delete from person where name = ?", new Object[]{"小志"});
       //如果是"delete from person"就是把整个表里的数据都删除
       //where就是删除的条件     name  = ?", new一个Object集合{对应数据});
       }
       //修改数据
       public void update(){
       db.execSQL("update person set phone = ? where name = ?", new Object[]{186666, "小志的儿子"});
       //update修改数据表set设置phone=?  如果没有where条件的话会把表中phone都会改了
       //所以添加判断where条件是哪一个是表中"小志的儿子"
       }
       //查询数据
       public void select(){
       Cursor cursor = db.rawQuery("select name, salary from person", null);
       //查询不能用execSQL要不就没有返回值了,
       //查询是用rawQuery方法,("查询名字name和逗号分开表中的工资salary from person表
       //这是查询表中所有的名字和工资,person后面没有where条件,也没有用站位符,第二参数就为null了
       //用这个方法有个返回是Cursor和Resultset返回集一样,里面是返回要查的所有数据


       while(cursor.moveToNext()){//moveToNext()是如果成功移到下一行返回true没有移到就是false了

       //getString(int colunmnIndex);counmnIndex是查询后的列索引
       //如果是两个数据就是0,1对应查询字符串select name对应0,salary对应1 from person
       //如果是三个就是数据0,1,2 对应也是一一对应
       //"select *, salary from person"那么0就对应是person表中_id 要注意了
       //这样就有不确定了.cursor.getColumnIdex("name")这方法就可以指定要查询的列名了


       //通过列索引获取列的值
       String name = cursor.getString(cursor.getColumnIndex("name"));//这样就可以确定这要查询name的值
       String salary = cursor.getString(1);//这个就普通获取salary了最好用getColumnIndex
       System.out.println(name + ";" + salary);
       }
       }
       *
       *
       * */



       /**  SQL数据库的API   增删改查
       *
       *  //增加数据
       public void insertApi(){
       //把要插入的数据全部封装至ContentValues对象
       ContentValues values = new ContentValues();
       values.put("name", "游天龙");//添加时候是键值对
       values.put("phone", "15999");
       values.put("salary", 16000);
       db.insert("person", null, values);//null这个是仅当参数3不是有效数据(为null或者没有封装数据)时需要填写，否则，该参数直接使用null即可
       //返回值：新增加的记录的ID，如果增加失败，则返回-1
       }
       //删除数据
       public void deleteApi(){
       int i = db.delete("person", "name = ? and _id = ?", new String[]{"小志的儿子", "3"});
       System.out.println(i);//如果成功就是返回被删除的影响的行数
       //返回值：受影响的行的数量，如果删除失败或者没有删除数据，则返回0
       }
       //修改数据
       public void updateApi(){
       ContentValues values = new ContentValues();
       values.put("salary", 26000);
       int i = db.update("person", values, "name = ?", new String[]{"游天龙"});

       System.out.println(i);
       //返回值：受影响的行的数量
       }
       //查询数据
       public void selectApi(){
       Cursor cursor = db.query("person", null, null, null, null, null, null, null);
       while(cursor.moveToNext()){
       String name = cursor.getString(cursor.getColumnIndex("name"));
       String phone = cursor.getString(cursor.getColumnIndex("phone"));
       String salary = cursor.getString(cursor.getColumnIndex("salary"));
       System.out.println(name + ";" + phone + ";" + salary);
       }
       }

       *
       *
       *
       * */


       /**
       *  事务
         就是比如张三给李四转钱,转入成功就一起成功.失败就一起失败---就这样一个事物

       public void transaction(){
       try{
       //开启事务
       db.beginTransaction();
       ContentValues values = new ContentValues();
       values.put("salary", 12000);
       db.update("person", values, "name = ?", new String[]{"小志"});

       values.clear();//清空一下防止携带上一个数据
       values.put("salary", 16000);
       db.update("person", values, "name = ?", new String[]{"小志的儿子"});

       int i = 3/0;//假设出现异常
       //设置  事务执行成功
       db.setTransactionSuccessful();
       }
       finally{
       //关闭事务，同时提交，如果已经设置事务执行成功，那么sql语句就生效了，反之，sql语句回滚
       db.endTransaction();
       }

       //数据库事物说明:db.beginTransaction();开启事务;
       // 执行要操作的事件两个方法
       //设置事物执行成功db.setTransactionSuccessful();
       //db.endTransaction();关闭事务，同时提交，如果已经设置事务执行成功，那么sql语句就生效了，反之，sql语句回滚

       //try- 开启事物---执行两个方法一旦出错   就不会执行 设置 事物成功
       - --catch---finally(必须执行)那么关闭事物,同时上交(如果已经设置事务执行成功，那么sql语句就生效了，反之，sql语句回滚)
       //所以事物就用了三个方法就是db.beginTransaction()开启事务,判断要做事情是否做成,
       成了就设置db.setTransactionSuccessful()反之不设置,最后执行db.endTransaction();
       关闭并提交,来判定事物成功或是失败了,如果成功了那么sql语句就生效了，反之，sql语句回滚
       }

       *
       * */



}

 

 

public interface IDao {
     /**
     * 增加数据
     * @param t 数据对象
     * @return 数据在数据表中的记录id，如果增加失败，则返回-1
     */
    long insert(T t);

    /**
     * 删除数据
     * @param id 被删除的数据的id
     * @return 受影响的行的数量
     */
    int delete(long id);

    /**
     * 修改数据
     * @param t 数据对象，该对象中必须包含数据的id
     * @return 受影响的行的数量
     */
    int update(T t);

    /**
     * 查询数据
     * @param whereClause where子句
     * @param whereArgs where子句中各?对应的值，如果where子句中没有?，则该参数可以为null
     * @param orderBy order by子句
     * @return 数据的List集合
     */
    List query(String whereClause, String[] whereArgs, String orderBy);

}

public class Industry implements Serializable{

   /**
    * 
    */
   private static final long serialVersionUID = 1L;
   
   private  int id;
    private String valuse;
    private String desc;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getValuse() {
        return valuse;
    }

    public void setValuse(String valuse) {
        this.valuse = valuse;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

}

 

public class SQLitedbActivity extends AppCompatActivity {


    private OpinionDao dao;
    private List opinions;
    private TextView tv;
    private String json = "[{\"desc\":\"电商\",\"id\":1,\"value\":\"E_COMMERCE\"}," +
            "{\"desc\":\"社交\",\"id\":2,\"value\":\"SOCIAL_NETWORK\"}," +
            "{\"desc\":\"硬件\",\"id\":5,\"value\":\"INTELLIGENT_HARDWARE\"}," +
            "{\"desc\": \"文娱传媒\",\"id\": 6,\"value\": \"MEDIA\"}," +
            "{\"desc\":\"工具\",\"id\":7,\"value\":\"SOFTWARE\"}," +
            "{\"desc\":\"消费生活\",\"id\":8,\"value\":\"CONSUMER_LIFESTYLE\"}," +
            "{\"desc\":\"金融\",\"id\":9,\"value\":\"FINANCE\"}," +
            "{\"desc\":\"医疗健康\",\"id\":10,\"value\":\"MEDICAL_HEALTH\"}," +
            "{\"desc\":\"企业服务\",\"id\":11,\"value\":\"SERVICE_INDUSTRIES\"}," +
            "{\"desc\":\"旅游\",\"id\":12,\"value\":\"TRAVEL_OUTDOORS\"}," +
            "{\"desc\":\"房产家居\",\"id\":13,\"value\":\"PROPERTY_AND_HOME_FURNISHINGS\"}," +
            "{\"desc\":\"教育\",\"id\":15,\"value\":\"EDUCATION_TRAINING\"}," +
            "{\"desc\":\"汽车交通\",\"id\":16,\"value\":\"AUTO\"},{\"desc\":\"物流\",\"id\":19,\"value\":\"LOGISTICS\"}," +
            "{\"desc\":\"人工智能\",\"id\":21,\"value\":\"AI\"},{\"desc\": \"无人机\",\"id\": 22,\"value\":\"UAV\"},{\"desc\":\"机器人\",\"id\": 23,\"value\":\"ROBOT\"}," +
            "{\"desc\":\"农业\",\"id\":21,\"value\":\"FARMING\"},{\"desc\":\"VR·AR\",\"id\": 24,\"value\":\"VR_AR\"}," +
            "{\"desc\":\"AR/VR\",\"id\":22,\"value\":\"AR_VR\"},{\"desc\":\"体育（包含户外）\",\"id\":23,\"value\":\"SPORTS\"},{\"desc\":\"共享经济\",\"id\":43,\"value\":\"SHARE_BUSINESS\"}," +
            "{\"desc\":\"出海\",\"id\":46,\"value\":\"CHU_HAI\"},{\"desc\":\"消费升级\",\"id\":47,\"value\":\"CONSUME\"}]";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_sqlitedb);
        tv=(TextView)findViewById(R.id.tv);
        /**
         *  创建数据库
         * 如果 需要升级数据库的话
         * 在MyoopenHelper 升级 同时这里就会直接执行了
         * */
        dao = new OpinionDao(this);
    }




    /**
     * 点击这个按钮是插入数据
     *
     * */
    public void Dianji(View v){
        try {
            JSONArray array = new JSONArray(json);
            for (int i = 0; i < array.length(); i++) {
                final JSONObject temp = (JSONObject) array.get(i);
                final Industry dustry = new Industry();
                dustry.setValuse(temp.getString("value"));
                dustry.setId(temp.getInt("id"));
                dustry.setDesc(temp.getString("desc"));
                long insert = dao.insert(dustry);
                tv.setText(insert + "");
            }

        } catch (JSONException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}