Moja klasa bazy danych aplikacji

@Database(entities = {Detail.class}, version = Constant.DATABASE_VERSION)
public abstract class AppDatabase extends RoomDatabase {

    private static AppDatabase INSTANCE;

    public abstract FavoritesDao favoritesDao();

    public static AppDatabase getAppDatabase(Context context) {
        if (INSTANCE == null) {
            INSTANCE =
                    Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, Constant.DATABASE).allowMainThreadQueries().build();

                    //Room.inMemoryDatabaseBuilder(context.getApplicationContext(),AppDatabase.class).allowMainThreadQueries().build();
        }
        return INSTANCE;
    }

    public static void destroyInstance() {
        INSTANCE = null;
    }
}

Gradle lib:

 compile "android.arch.persistence.room:runtime:+"   
 annotationProcessor "android.arch.persistence.room:compiler:+"

A kiedy zapytam na przykład, poda ten błąd, AppDatabase_Impl nie istnieje w mojej klasie aplikacji

public class APp extends Application {

    private boolean appRunning = false;

    @Override
    public void onCreate() {
        super.onCreate();
        AppDatabase.getAppDatabase(this); //--AppDatabase_Impl does not exist

    }   

}

Dla osób pracujących z Kotlin , spróbuj zmienić annotationProcessorsię kaptw aplikacjachbuild.gradle

na przykład:

// Extensions = ViewModel + LiveData
implementation "android.arch.lifecycle:extensions:1.1.0"
kapt "android.arch.lifecycle:compiler:1.1.0"
// Room
implementation "android.arch.persistence.room:runtime:1.0.0"
kapt "android.arch.persistence.room:compiler:1.0.0"

pamiętaj również o dodaniu tej wtyczki

apply plugin: 'kotlin-kapt'

na górę pliku build.gradle na poziomie aplikacji i wyczyść go i przebuduj (zgodnie z https://codelabs.developers.google.com/codelabs/android-room-with-a-view/#6 )

Jeśli w Android Studio wystąpią błędy podczas wklejania kodu lub podczas procesu kompilacji, wybierz opcję Kompiluj> Wyczyść projekt. Następnie wybierz opcję Kompiluj> Odbuduj projekt, a następnie skompiluj ponownie.

AKTUALIZACJA

Jeśli przeprowadziłeś migrację do androidx

def room_version = "2.2.3" // check latest version from docs

implementation "androidx.room:room-runtime:$room_version"
kapt "androidx.room:room-compiler:$room_version"

Po prostu użyj

apply plugin: 'kotlin-kapt'

w aplikacji build.gradle

I trzymaj oba w zależnościach

annotationProcessor "android.arch.persistence.room:compiler:$rootProject.roomVersion"
kapt "android.arch.persistence.room:compiler:$rootProject.roomVersion"

EDYTOWAĆ

W nowszej wersji nie trzeba dodawać obu zależności na raz. Po prostu użyj, miej nadzieję, że zadziała.

kapt 'android.arch.persistence.room:compiler:1.1.1'

Miałem ten błąd, kiedy chybiłem

@Database(entity="{<model.class>})

Upewnij się, że model jednostki określony w powyższej adnotacji odnosi się do konkretnej klasy modelu, a także upewnij się, że niezbędna adnotacja:

@Entity(tableName = "<table_name>" ...)

jest odpowiednio zdefiniowany i byłbyś dobry

jeśli używasz klas kotlin do implementacji bazy danych, użyj

apply plugin: 'kotlin-kapt'

i

kapt "android.arch.persistence.room:compiler:1.1.1"

w twoim pliku ocen, to zadziała.

Nie chodzi tylko o aktualizację zależności. Upewnij się, że wszystkie zależności Room mają tę samą wersję.

implementation 'android.arch.persistence.room:rxjava2:1.1.0-alpha2'
implementation 'android.arch.persistence.room:runtime:1.1.0-alpha2'
annotationProcessor "android.arch.persistence.room:compiler:1.1.0-alpha2"

W powyższym przykładowym fragmencie wszystkie moje zależności Room mają tę samą wersję 1.1.0-alpha2

Dla programistów Kotlin

Użyj tego:

implementation "android.arch.persistence.room:runtime:1.0.0"
kapt "android.arch.persistence.room:compiler:1.0.0"

I dodaj apply plugin: 'kotlin-kapt'na górę poziomu aplikacji build.gradle.

Dla programistów Java

implementation "android.arch.persistence.room:runtime:1.0.0"
annotationProcessor "android.arch.persistence.room:compiler:1.0.0"

Spotkałem się z tym problemem, ponieważ zapomniałem o trafnych zależnościach

implementation "android.arch.lifecycle:extensions:$archLifecycleVersion"
implementation "android.arch.persistence.room:runtime:$archRoomVersion"
annotationProcessor "android.arch.lifecycle:compiler:$archLifecycleVersion"
annotationProcessor "android.arch.persistence.room:compiler:$archRoomVersion"

po dodaniu annotationProcessor i przebudowie go problem został rozwiązany.

Spotykam się z problemem, bo zapominam o @Daoadnotacji

@Dao
public interface SearchHistoryDao {
    @Query("SELECT * FROM search_history")
    List<SearchHistory> getAll();

    @Insert
    void insertAll(SearchHistory... histories);

    @Delete()
    void delete(SearchHistory history);
}

Oficjalny samouczek dotyczący pokoju

upewnij się, że dodano poprawną zależność dla pokoju w pliku build.gradle

ext {
   roomVersion = '2.1.0-alpha06'
}

// Room components
implementation "androidx.room:room-runtime:$rootProject.roomVersion"
implementation "androidx.room:room-ktx:$rootProject.roomVersion"
kapt "androidx.room:room-compiler:$rootProject.roomVersion"
androidTestImplementation "androidx.room:room-testing:$rootProject.roomVersion"

A poniżej linii u góry

apply plugin: 'kotlin-kapt'

Pytanie jest dość stare, ale natknąłem się na to dzisiaj i żadna z udzielonych odpowiedzi mi nie pomogła. W końcu udało mi się to rozwiązać, zauważając, że dokumentacja google faktycznie jest nadal adoptowana do Javy, a nie domyślnie Kotlina, w rzeczywistości dodali komentarz, który zignorowałem

W przypadku Kotlina użyj kapt zamiast annotationProcessor

Więc zamiast

annotationProcessor "androidx.room:room-compiler:$room_version"

Jeśli rozwijasz się z Kotlinem, powinieneś użyć:

    kapt "androidx.room:room-compiler:$room_version"

Miałem ten sam problem. Zaimplementowałem kilka klas i interfejs, jak oficjalnie powiedziano w nowym przykładowym projekcie stworzonym przez Android Studio: https://developer.android.com/training/data-storage/room/

Wszystkie powyższe rozwiązania nie pomogły, potrzebne pliki _Impl zgodnie z moją klasą bazy danych nie zostały wygenerowane przez Room. Wreszcie wykonanie kompilacji gradle clean w terminalu dało mi wskazówkę prowadzącą do rozwiązania:

„ostrzeżenie: katalog eksportu schematu nie jest dostarczany do procesora adnotacji, więc nie możemy wyeksportować schematu. Możesz albo podać room.schemaLocationargument procesora adnotacji LUB ustawić exportSchema na false.”

Dodałem parametr exportSchema = false w klasie bazy danych

@Database(entities = arrayOf(User::class), version = 1, exportSchema = false)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

A potem zadziałało, znalazłem te dwa wygenerowane pliki w module aplikacji w obszarze generatedJava:

• AppDatabase_Impl
• User replace_Impl

Nie rozumiem tego zachowania, ponieważ mówi się, że parametr jest opcjonalny, patrz https://stackoverflow.com/a/44645943/3258117

Użyj następującego linku do gradle:

compile 'android.arch.persistence.room:runtime:1.0.0-alpha9'
annotationProcessor 'android.arch.persistence.room:compiler:1.0.0-alpha9'

Musisz stworzyć diffretn singloton class i pobrać bazę danych aplikacji od takich osób:

RoomDB.java

public class RoomDB {

private static RoomDB INSTANCE;

public static AppDatabase getInstance(Context context) {
    if (INSTANCE == null) {
        INSTANCE =
                Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, Constant.DATABASE).allowMainThreadQueries().build();

                //Room.inMemoryDatabaseBuilder(context.getApplicationContext(),AppDatabase.class).allowMainThreadQueries().build();
    }
    return INSTANCE;
}

public static void destroyInstance() {
    INSTANCE = null;
}

App.java

public class App extends Application {

private boolean appRunning = false;

@Override
public void onCreate() {
    super.onCreate();
    RoomDB.getInstance(this); //This will provide AppDatabase Instance
}

W moim przypadku testowałem łączność z bazą danych pokoi i umieściłem klasę testującą w katalogu, który utworzyłem, w folderze AndroidTest. Przeniosłem go z katalogu niestandardowego, a potem działał całkiem dobrze.

Przyszło mi do głowy to samo zjawisko.

następujący

implementation "android.arch.persistence.room:runtime:1.1.1"

Dodanie powoduje kolejny błąd kompilacji, ale śledzi przyczynę w dzienniku.

W moim przypadku wystąpił błąd w implementacji SQL. Po naprawieniu kompilacja przebiegła pomyślnie.

Możesz więc chcieć sprawdzić implementację całej biblioteki pokoju, zamiast patrzeć na rozbitych mieszkańców.

Problem jest bardziej związany z poprawną biblioteką, która nie jest zawarta w kompilacji Gradle. Miałem podobny problem i dodałem brakujący

testImplementation "android.arch.persistence.room:testing:$room_version

Zmiana zależności w moim pliku gradle nie pomogła mi w naprawieniu błędu. Przegapiłem tę adnotację bazy danych w klasie, w której zainicjowano bazę danych pokoju, co było przyczyną tego problemu.

@Database (entity = [UserModel :: class], wersja = 1)

Upewnij się, że model jednostki określony w powyższej adnotacji odnosi się do określonej klasy modelu

Dla mnie Android Studio automatycznie aktualizuje zależności, gdy tylko dołączysz dowolny import związany z bazą danych Room. Ale zgodnie z https://developer.android.com/jetpack/androidx/releases/room#declaring_dependencies , musisz zaktualizować kilka. Oto jak wygląda moja baza kodu:

AppDatabase.kt

import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase

@Database(entities = arrayOf(MyEntity::class), version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun myDAO(): MyDAO

    companion object {
        @Volatile private var instance: AppDatabase? = null
        private val LOCK = Any()

        operator fun invoke(context: Context)= instance ?: synchronized(LOCK){
            instance ?: buildDatabase(context).also { instance = it}
        }

        private fun buildDatabase(context: Context) = Room.databaseBuilder(context,
            AppDatabase::class.java, "db-name.db")
            .build()
    }
}

Zaktualizuj plik build.gradle zgodnie z jedną z odpowiedzi:

apply plugin: 'kotlin-kapt' // this goes with other declared plugin at top
dependencies { // add/update the following in dependencies section
    implementation 'androidx.room:room-runtime:2.2.3'
//    annotationProcessor 'androidx.room:room-compiler:2.2.3' // remove this and use the following
    kapt "androidx.room:room-compiler:2.2.3"

}

Zsynchronizuj gradle i powinieneś być gotowy.

Czytając przykład tutaj: Przykład pokoju

Naprawiłem ten błąd, używając poprawnej (chyba tak) adnotacjiProcessorFile, w następujący sposób:

annotationProcessor "android.arch.persistence.room:compiler:<latest_version>"

Ponadto zaktualizowałem do 2.2.0 zarówno w wersji Room, jak w wersji Lifecycle.

Po zsynchronizowaniu graddle mogłem rozpocząć pracę z Room.

Więc powodzenia! I niech kod będzie z tobą!

W mojej aplikacji kotlin właśnie dodałem następujący wiersz na górze mojego pliku build.gradle:

apply plugin: 'kotlin-kapt'

I następujący wiersz w sekcji zależności:

kapt "androidx.room:room-compiler:2.2.5"

Mam nadzieję, że to rozwiąże Twój problem.

Nie w przypadku OP, ale dzieje się tak również wtedy, gdy omyłkowo użyjesz implementacji zamiast procesora adnotacji w ten sposób:

implementation "android.arch.persistence.room:compiler:x.x.x"

Zamiast tego:

annotationProcessor "android.arch.persistence.room:compiler:x.x.x"