WARNING: API ‘variant.getJavaCompiler()‘ is obsolete and has been replaced with ‘variant.getJavaCompileProvider()‘.
It will be removed at the end of 2019.

解决方法：
将gradle 从高版本还原到 3.2以下

dependencies {
      def room_version = "2.2.0-rc01"

      implementation "androidx.room:room-runtime:$room_version"
      annotationProcessor "androidx.room:room-compiler:$room_version" // For Kotlin use kapt instead of annotationProcessor

      // optional - Kotlin Extensions and Coroutines support for Room
      implementation "androidx.room:room-ktx:$room_version"

      // optional - RxJava support for Room
      implementation "androidx.room:room-rxjava2:$room_version"

      // optional - Guava support for Room, including Optional and ListenableFuture
      implementation "androidx.room:room-guava:$room_version"

      // Test helpers
      testImplementation "androidx.room:room-testing:$room_version"
    }

package com.loaderman.roomdemo.bean;

import androidx.annotation.NonNull;
import androidx.room.ColumnInfo;
import androidx.room.Entity;
import androidx.room.Ignore;
import androidx.room.Index;
import androidx.room.PrimaryKey;


//Entity: 表示数据库内的表.
@Entity(tableName = "user", indices = {@Index(value = {"name"}, unique = true)})//有些时候, 数据库中的某些域或几组域必须是唯一的. 你可以通过将注解@Index的unique属性设置为true, 强制完成唯一的属性.
public class User {

    @PrimaryKey(autoGenerate = true)//主键是否自动增长，默认为false
    private int id;
    @NonNull//  表示参数，成员变量或者方法返回值从不为null
    @ColumnInfo(name = "name")//指定数据库表的列名。
    private String name;
    //演示版本2，升级数据库版本用, 演示版本1注释掉即可
    private String phone;
    private int age;
    public User() {
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Ignore
    public User(String name, int age) {

        this.name = name;
        this.age = age;
    }

    @Ignore
    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    // getter  setter方法必须写
    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 int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name=‘" + name + ‘\‘‘ +
                ", phone=‘" + phone + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }
}

package com.loaderman.roomdemo.bean;

import androidx.room.ColumnInfo;
import androidx.room.Entity;
import androidx.room.ForeignKey;
import androidx.room.PrimaryKey;
//@ForeignKey注解定义它和实体User的关系
/*
* 外键非常强大, 因为它允许你指定做什么操作, 在引用实体更新的时候. 比如, 你可以告诉SQLite为用户删除所有的书,
* 在相应的User实例被删除时, 而该User被Book通过在@ForeignKey注解里面声明onDelete = CASCADE而关联.
* 备注: SQLite将@Insert(onConflict = REPLACE)作为REMOVE和REPLACE的集合来操作, 而非单独的UPDATE操作. 这个取代冲突值的方法能够影响你的外键约束.
 * */
@Entity(foreignKeys = @ForeignKey(entity = User.class,
        parentColumns = "id",
        childColumns = "user_id"))
public class Book {
    @PrimaryKey
    public int bookId;

    public String title;

    @ColumnInfo(name = "user_id")
    public int userId;
}

package com.loaderman.roomdemo.dao;

import androidx.lifecycle.LiveData;
import androidx.room.Dao;
import androidx.room.Delete;
import androidx.room.Insert;
import androidx.room.OnConflictStrategy;
import androidx.room.Query;
import androidx.room.Update;

import com.loaderman.roomdemo.bean.Book;
import com.loaderman.roomdemo.bean.User;

import java.util.List;

import io.reactivex.Flowable;

//DAO: 包含用于访问数据库的方法.
@Dao
public interface UserDao {
    // OnConflictStrategy.REPLACE表示如果已经有数据，那么就覆盖掉
    //数据的判断通过主键进行匹配，也就是uid，非整个user对象
    //返回Long数据表示，插入条目的主键值（id）


    @Query("SELECT * FROM user")
    List<User> getAllUsers();

    // LiveData是可以被观察到的数据持有类。它里面缓存或持有了最新的数据。当数据改变时会通知它的观察者。
    // LiveData是可以感知生命周期的。UI组件只是观察相关数据，不会停止或恢复观察。
    // LiveData自动管理所有这些，因为它在观察时意识到相关的生命周期状态变化。
    @Query("SELECT * FROM user")
    LiveData<List<User>> getAllUser();

    @Query("SELECT * FROM user WHERE id=:id")
    User getUser(int id);

    @Query("SELECT * FROM user WHERE name=:name")
    User getUser(String name);

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    List<Long> insert(User... users);

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    Long insert(User user);

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    List<Long> insert(List<User> userLists);

    @Update
    int update(User... users);

    @Update()
    int updateAll(User... user);

    @Update()
    int updateAll(List<User> user);

    @Delete
    int delete(User user);

    @Delete
    int deleteAll(List<User> users);

    @Delete
    int deleteAll(User... users);

    //返回RxJava2中的Publisher和Flowable.
    @Query("SELECT * from user where name = :name LIMIT 1")
    Flowable<User> getUserByName(String name);


    //多表查询
    @Query("SELECT * FROM book "
            + "INNER JOIN user ON user.id = book.user_id "
            + "WHERE   user.id = :userName")
    List<Book> findBooksByUserName(String userName);

}

package com.loaderman.roomdemo.dao;

import android.content.Context;

import androidx.room.Database;
import androidx.room.Room;
import androidx.room.RoomDatabase;
import androidx.room.TypeConverters;
import androidx.room.migration.Migration;
import androidx.sqlite.db.SupportSQLiteDatabase;

import com.loaderman.roomdemo.Converters;
import com.loaderman.roomdemo.bean.Book;
import com.loaderman.roomdemo.bean.User;
//注解指定了database的表映射实体数据以及版本等信息 推荐使用单例模式
@Database(entities = { User.class, Book.class }, version = 2,exportSchema = true)
//添加@TypeConverters注解到AppDatabase类上, 之后Room就能够在AppDatabase中定义的每一个实体和DAO上使用这个转换器.
@TypeConverters({Converters.class})
public abstract class AppDatabase extends RoomDatabase {

    public static final Migration MIGRATION_1_2 = new Migration(1, 2) {
        @Override
        public void migrate(SupportSQLiteDatabase database) {
            database.execSQL("ALTER TABLE user ADD COLUMN phone TEXT ");
        }
    };

    public abstract UserDao getUserDao();
}

package com.loaderman.roomdemo.bean;

import androidx.room.ColumnInfo;
import androidx.room.Embedded;
import androidx.room.Entity;
import androidx.room.PrimaryKey;
/*
 创建嵌套对象有些时候, 在数据库逻辑中, 你想将一个实体或者POJO表示为一个紧密联系的整体,
 即使这个对象包含几个域. 在这些情况下, 你能够使用@Embedded注解来表示一个对象,
 而你想将这个对象分解为表内的子域. 然后你可以查询这些嵌套域, 就像你查询其它的独立列一样.
 这个表表示UserInfo对象包含如下几列: id, firstName, street, state, city和post_code.
 备注: 嵌套的域同样可以包含其它的嵌套域.
 如果实体拥有多个相同类型的嵌套域, 你可以通过设置prefix属性保留每一列唯一. 然后Room给嵌套对象的每一个列名的起始处添加prefix设置的给定值
*/
@Entity
public class UserInfo {
    @PrimaryKey
    public int id;

    public String firstName;

    @Embedded
    public Address address;
}

 class Address {
    public String street;
    public String state;
    public String city;

    @ColumnInfo(name = "post_code")
    public int postCode;
}

package com.loaderman.roomdemo;

import androidx.room.TypeConverter;

import java.sql.Date;
//类型转换器
public class Converters {
    @TypeConverter
    public static Date revertDate(long value) {
        return new Date(value);
    }

    @TypeConverter
    public static long converterDate(Date value) {
        return value.getTime();
    }
}