Ich empfehle diesen Artikel nur für diejenigen zu lesen, die noch nicht mit Retrofit 2 gearbeitet haben. Schließlich werde ich in diesem Artikel alles so detailliert wie möglich beschreiben, damit jeder es versteht.
0. Projekterstellung
Hier ist alles so einfach wie möglich. Erstellen Sie ein neues Projekt in Android Studio und wählen Sie Leere Aktivität. Als nächstes müssen Sie eine Programmiersprache auswählen, wir haben sie Kotlin.
1. Fügen Sie Abhängigkeiten hinzu
Jetzt müssen wir alle erforderlichen Bibliotheken hinzufügen, also gehen wir zu build.gradle und fügen Folgendes hinzu:
dependencies {
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.5.0'
implementation 'com.squareup.picasso:picasso:2.71828'
//noinspection GradleCompatible
implementation 'com.android.support:design:28.0.0'
implementation 'com.github.d-max:spots-dialog:1.1@aar'
}
Wie Sie vielleicht bemerkt haben, haben wir hier alle erforderlichen Bibliotheken hinzugefügt, einschließlich des Dialogfelds "Spots-Fortschritt". Hier können Sie mehr darüber lesen . Dann müssen wir in build.gradle (Modul: app) Folgendes einfügen:
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
Es bleibt nur zu Manifesten zu gehen und die Erlaubnis zur Nutzung des Telefons hinzuzufügen
<uses-permission android:name="android.permission.INTERNET"/>
2. Hinzufügen von Datenklassen
Bevor wir zum zweiten Punkt übergehen, müssen wir herausfinden, woher die Daten stammen. Parse wird von hier aus sein.
Großartig, dann kopieren Sie den Inhalt dieser Website und gehen Sie hier. Hier fügen wir den zuvor kopierten Text von unserer Site ein. Nachdem wir auf den Baum geklickt haben, wurde uns eine Liste gegeben. Öffnen Sie sie. Jetzt sehen wir, dass wir 8 Objekte haben. Wenn jemand nicht versteht, zeige ich Ihnen einen Bildschirm:
Was Sie rechts sehen, ist unser Text, den wir kopiert haben, und was rechts bereits verarbeitete Daten sind.
Zurück zu Android Studio erstellen wir einen Ordner, nennen ihn Modell, erstellen eine Kotlin-Klasse und nennen ihn Film aus einer regulären Klasse. Wir transformieren die Datenklasse, fügen einfach Daten vor der Klasse hinzu und ersetzen die geschweiften Klammern durch Klammern. Dann geben wir die Variablen an, die wir bereits in Klammern haben Auf der Site ausspioniert, müssen die Variablen übrigens vom Typ nullable sein.
Vollständiger Code
data class Movie(
var name: String? = null,
var realname: String? = null,
var team: String? = null,
var firstapperance: String? = null,
var createdby: String? = null,
var publisher: String? = null,
var imageurl: String? = null,
var bio: String? = null
)
Wenn Sie sich fragen, warum der Ordner Model heißt, sage ich Ihnen Folgendes:
Model ist die Logik, die mit Anwendungsdaten verknüpft ist. Mit anderen Worten, dies sind POJOs, Klassen für die Arbeit mit einer API, einer Datenbank.
3. Erstellung des Kunden
Als Nächstes erstellen wir den Retrofit-Ordner. In dem Ordner erstellen wir ein Objekt und nennen es RetrofitClient. Anschließend erstellen wir eine Nachrüstvariable vom Typ Retrofit. Anschließend erstellen wir eine Funktion und nennen sie getCleint (baseUrl: String). Der Rückgabetyp ist Retrofit. Im Hauptteil der Funktion muss die Nachrüstung auf null überprüft werden. Wenn die Nachrüstung null ist, weisen wir der Nachrüstung Retrofit zu. Builder () hängt baseUrl mit dem Parameter baseUrl an, hängt dann die Methode addconverterFactory mit dem Parameter GsonConverterFactory.create () an und erstellt sie mit dem Parameter build ( ) und führen Sie die Nachrüstung auf einen Typ ungleich Null zurück
Vollständiger Code
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
object RetrofitClient {
private var retrofit: Retrofit? = null
fun getClient(baseUrl: String): Retrofit {
if (retrofit == null) {
retrofit = Retrofit.Builder()
.baseUrl(baseUrl)
.addConverterFactory(GsonConverterFactory.create())
.build()
}
return retrofit!!
}
}
Der Builder in Retrofit ist eine Instanz, die die Builder-Schnittstelle und die API verwendet, um die URL-Endpunktdefinition für HTTP-Vorgänge zu definieren
4. Arbeiten mit der Schnittstelle
Schnittstelle - wird benötigt, um abstrakte Klassen zu erstellen.
Erstellen Sie ein Interface-Paket darin. Wir fügen ein Interface hinzu und nennen es RetrofitServieces. Erstellen Sie eine Get-Anfrage in Klammern, schreiben Sie Anführungszeichen und geben Sie in Anführungszeichen den Zweig an, aus dem die Daten analysiert werden sollen. Das ist wunderbar. Zuvor sollte jedoch erwähnt werden , was eine GET- und eine POST-Anforderung sind.
GET - fordert Daten von einem bestimmten Ressourcen- ( Site- )
POST an - sendet Daten zur weiteren Verarbeitung an den Server.
Ok, jetzt müssen Sie eine getMovieList-Funktion erstellen, die einen Aufruf vom Typ MutableList zurückgeben sollte, und eine MutableList sollte sein Filmtyp
Vollständiger Code
import com.example.retrofitmarvel.Model.Movie
import retrofit2.Call
import retrofit2.http.*
interface RetrofitServices {
@GET("marvel")
fun getMovieList(): Call<MutableList<Movie>>
}
5. Allgemein
Jetzt müssen wir den Common-Ordner erstellen, in diesen Ordner ein Objekt einfügen und es Common nennen, eine Variable erstellen, BASE_URL nennen und darin den Link einfügen, über den wir die Daten analysieren, aber nicht den letzten Zweig einfügen, da wir von ihm Daten erhalten ... Wir erstellen die Variable retrofitServices, sie hat eine get () -Methode, wir weisen ihr RetrofitClient zu und erst dann vernetzen wir die Methode getClient mit dem Parameter RetrofitServices :: class.java an RetrofitClient
Vollständiger Code
import com.example.retrofitmarvel.Interface.RetrofitServices
import com.example.retrofitmarvel.Retrofit.RetrofitClient
object Common {
private val BASE_URL = "https://www.simplifiedcoding.net/demos/"
val retrofitService: RetrofitServices
get() = RetrofitClient.getClient(BASE_URL).create(RetrofitServices::class.java)
}
6. Layout
Gehen Sie zu activity_main.xml und fügen Sie dort RecyclerView hinzu
XML
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<androidx.recyclerview.widget.RecyclerView
android:id="@+id/recyclerMovieList"
android:layout_width="0dp"
android:layout_height="0dp"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>
Erstellen Sie im Layoutordner ein Elementlayout im Stammelement und geben Sie die CardView an
item_layout
<androidx.cardview.widget.CardView
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="wrap_content"
app:cardElevation="8dp"
android:layout_margin="8dp">
<androidx.constraintlayout.widget.ConstraintLayout
android:id="@+id/linearLayout"
android:layout_width="match_parent"
android:layout_height="167dp">
<ImageView
android:id="@+id/image_movie"
android:layout_width="0dp"
android:layout_height="100dp"
android:layout_marginEnd="8dp"
android:layout_marginRight="8dp"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toStartOf="@+id/txt_name"
app:layout_constraintHorizontal_bias="0.0"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.238" />
<TextView
android:id="@+id/txt_name"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginStart="192dp"
android:layout_marginLeft="192dp"
android:layout_marginTop="16dp"
android:text="name"
android:textColor="@android:color/black"
android:textSize="20sp"
android:textStyle="bold"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<TextView
android:id="@+id/txt_team"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginStart="196dp"
android:layout_marginLeft="196dp"
android:layout_marginTop="8dp"
android:text="team"
android:textColor="@android:color/black"
android:textSize="16sp"
android:textStyle="normal"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/txt_name" />
<TextView
android:id="@+id/txt_createdby"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginStart="184dp"
android:layout_marginLeft="184dp"
android:layout_marginTop="12dp"
android:text="createdby"
android:textColor="@android:color/black"
android:textSize="18sp"
android:textStyle="italic"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/txt_team" />
</androidx.constraintlayout.widget.ConstraintLayout>
</androidx.cardview.widget.CardView>
7. Adapter
Jetzt müssen wir ein Adapterpaket erstellen, in das wir eine Klasse einfügen und sie MyMovieAdapter nennen. Der
Adapter ist dafür verantwortlich, Daten aus einem Dataset abzurufen und View-Objekte basierend auf diesen Daten zu erstellen.
In der MyMovieAdapter-Klasse erstellen wir Variablen, die nur in dieser Klasse verfügbar sind. Private val movieList: MutableList vom Typ Movie und geben den Typ des Rückgabewerts an. RecyclerView.Adapter vom Typ MyMovieAdapter.MyViewHolder
Implementieren Sie Methoden, nämlich onCreateViewHolder, getItemCount und onBindView
Wir erstellen die MyViewHolder-Klasse, geben in dieser Klasse den Parameter itemView: View und den Rückgabetyp RecyclerView.ViewHolder an und fügen Variablen in den Hauptteil dieser Klasse ein, zum Beispiel:
val image: ImageView = itemView.image_movie image_movie wird aus item_layout gezeichnet
und daher geben wir für alle verbleibenden Ansichtselemente an.
Lassen Sie uns eine Bindefunktion mit einem listItem: Movie-Parameter erstellen. Hier können wir unsere Ansichtselemente anklickbar machen. Ich denke, Sie können das tun.
Als nächstes schreiben wir getItemCount () neu, um den Spaß zu überschreiben. GetItemCount () = movieList.size. Hier ist alles einfach, wir haben eine Funktion erstellt und movieList.size zurückgegeben. Alles, was bleibt, ist, sich mit onBindViewHolder und onCreateViewHolder zu befassen.
OnCreateViewHolder - erstellt ein neues ViewHolder-Objekt, wann immer das RecyclerView es benötigt.
onBindViewHolder - Nimmt ein ViewHolder-Objekt und legt die erforderlichen Daten für die entsprechende Zeile in der Ansichtskomponente fest
Jetzt analysieren wir den Fall mit dem Rückgabetyp MyViewHolder onCreateViewHolder.
Erstellen Sie eine Variable itemView, weisen Sie sie LayoutInflater.from (parent.context) .inflate (R.layout.item_layout, parent, false) zu und geben Sie MyViewHolder mit dem Parameter itemView zurück. Gehen Sie nun zu onBindViewHolder in dem Text, in dem wir die Variable listItem: Movie erstellen, und weisen Sie movieList [position] zu. Als nächstes hängen wir die Bindemethode mit den listItem-Parametern an Inhaber an. Als nächstes verwenden wir die Picasso-Bibliothek.
Picasso.get (). Load (movieList [position] .imageurl) .into (owner.image). Fügen Sie dann Inhaber.txt_name.text = movieList [Position] .name hinzu, und so machen wir es mit all unseren Ansichtselementen
Vollständiger Code
import android.content.Context
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import android.widget.TextView
import android.widget.Toast
import androidx.recyclerview.widget.RecyclerView
import com.example.retrofitmarvel.Model.Movie
import com.example.retrofitmarvel.R
import com.squareup.picasso.Picasso
import kotlinx.android.synthetic.main.item_layout.view.*
class MyMovieAdapter(private val context: Context,private val movieList: MutableList<Movie>):RecyclerView.Adapter<MyMovieAdapter.MyViewHolder>() {
class MyViewHolder(itemView: View): RecyclerView.ViewHolder(itemView){
val image: ImageView = itemView.image_movie
val txt_name: TextView = itemView.txt_name
val txt_team: TextView = itemView.txt_team
val txt_createdby: TextView = itemView.txt_createdby
fun bind(listItem: Movie) {
image.setOnClickListener {
Toast.makeText(it.context, " ${itemView.image_movie}", Toast.LENGTH_SHORT)
.show()
}
itemView.setOnClickListener {
Toast.makeText(it.context, " ${itemView.txt_name.text}", Toast.LENGTH_SHORT).show()
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MyViewHolder {
val itemView = LayoutInflater.from(parent.context).inflate(R.layout.item_layout, parent, false)
return MyViewHolder(itemView)
}
override fun getItemCount() = movieList.size
override fun onBindViewHolder(holder: MyViewHolder, position: Int) {
val listItem = movieList[position]
holder.bind(listItem)
Picasso.get().load(movieList[position].imageurl).into(holder.image)
holder.txt_name.text = movieList[position].name
holder.txt_team.text = movieList[position].team
holder.txt_createdby.text = movieList[position].createdby
}
}
8. Hauptaktivität
Ausgezeichnet! Nur ein bisschen links. Gehen Sie zunächst zu MainActivity. Wir erstellen Variablen. Um sie nicht vom Typ null zu deklarieren, deklarieren wir sie über lateinit var mService: RetrofitServices. Wir müssen drei weitere davon erstellen, nämlich: LinearLayoutManager, MyMovieAdapter, AlertDialog. Sie können sie anrufen, wie Sie wollen, es spielt keine Rolle. In der onCreate-Methode weisen wir RetrofitServices Common.retrofitServices zu. In der nächsten Zeile hängen wir setHasFixedSize (true) an unsere recyclerView an. Dank dieser Methode können wir unsere Liste optimieren und dann unserem layoutManager LinearLayoutManager (this) zuweisen.
Layout Manager- Dies ist die Sache, die für die Positionierung von View-Komponenten verantwortlich ist, die für den Benutzer nicht mehr sichtbar sind. Darüber hinaus ist alles genauso einfach an unseren ListenlayoutManager anzuhängen und weisen diesem bereits den LayoutManager zu. Ok, jetzt arbeite ich mit der SpotsDialog-Bibliothek. Wir geben die zuvor benannte Variable mit dem AlertDialog-Typ an, den wir SpotsDialog zuweisen. Wir hängen die Builder-Methode an. Danach fügen wir die setCancelablec-Methode mit dem true-Parameter hinzu. Wir müssen die setContext-Methode mit diesem Parameter anhängen und die Build-Methode anhängen.
Jetzt müssen wir eine neue Funktion außerhalb der onCreate-Methode erstellen, die als Funktion getAllMovieList bezeichnet wird. Im Hauptteil dieser Funktion müssen wir unseren Dialog angeben und die show () -Methode an ihn anhängen.
Anschließend müssen wir die getMovieList-Methode zu mService .enqueue hinzufügen (Objekt: Callback <MutableList> {)
Jetzt müssen wir Methoden implementieren, wir haben zwei davon onResponse und onFailure
und in onResponse, nämlich im Hauptteil dieser Methode, die wir adapter'y zuweisen
MyMovieAdapter(baseContext, response.body() as MutableList<Movie>)
Außerdem weisen wir adapter'y die Methode notifyDataSetChanged () zu. Wir fügen Adapter zu unserer Liste hinzu und weisen Adapter zu. dann weisen wir die dialog () -Methode dem Dialog zu. Dies bedeutet, dass unser Dialog nach dem Laden unserer Daten verschwindet.
Vollständiger Code
import android.app.AlertDialog
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.recyclerview.widget.LinearLayoutManager
import com.example.retrofitmarvel.Adapter.MyMovieAdapter
import com.example.retrofitmarvel.Common.Common
import com.example.retrofitmarvel.Interface.RetrofitServices
import com.example.retrofitmarvel.Model.Movie
import com.example.retrofitmarvel.R
import dmax.dialog.SpotsDialog
import kotlinx.android.synthetic.main.activity_main.*
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
class MainActivity : AppCompatActivity() {
lateinit var mService: RetrofitServices
lateinit var layoutManager: LinearLayoutManager
lateinit var adapter: MyMovieAdapter
lateinit var dialog: AlertDialog
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
mService = Common.retrofitService
recyclerMovieList.setHasFixedSize(true)
layoutManager = LinearLayoutManager(this)
recyclerMovieList.layoutManager = layoutManager
dialog = SpotsDialog.Builder().setCancelable(true).setContext(this).build()
getAllMovieList()
}
private fun getAllMovieList() {
dialog.show()
mService.getMovieList().enqueue(object : Callback<MutableList<Movie>> {
override fun onFailure(call: Call<MutableList<Movie>>, t: Throwable) {
}
override fun onResponse(call: Call<MutableList<Movie>>, response: Response<MutableList<Movie>>) {
adapter = MyMovieAdapter(baseContext, response.body() as MutableList<Movie>)
adapter.notifyDataSetChanged()
recyclerMovieList.adapter = adapter
dialog.dismiss()
}
})
}
}
Ausgezeichnet! In diesem Artikel haben wir gelernt, wie man mit Retrofit2 arbeitet und es in eine RecyclerView einfügt.