Point d'enfouissement d'Android
Dans les projets Android au niveau de l'entreprise, le suivi est une technologie importante utilisée pour collecter des données sur le comportement des utilisateurs à des fins d'analyse et d'amélioration des produits. Ce qui suit est une solution enterrée courante utilisée dans le développement de projets Android au niveau de l'entreprise :
-
Définir les événements enterrés : tout d'abord, déterminez les événements clés qui doivent être enterrés, tels que les visites de pages, les clics sur des boutons, les soumissions de données, etc. Définissez un identifiant ou un nom unique pour chaque événement.
-
Insertion de code enterré : insérez du code enterré à la position de code des événements clés afin que le code enterré soit déclenché lorsque l'événement se produit. Vous pouvez insérer manuellement du code enterré dans le code ou insérer automatiquement du code enterré à l'aide de technologies telles que l'AOP (programmation orientée aspect).
-
Collecte et stockage des données : dans le code intégré, collectez les données d'événement pertinentes, telles que le type d'événement, l'horodatage, le nom de la page, le nom du bouton, etc. Stockez ces données dans une base de données locale ou envoyez-les au serveur pour stockage.
-
Téléchargement et analyse des données : téléchargez régulièrement les données cachées stockées localement sur le serveur pour analyse. Vous pouvez utiliser une bibliothèque de requêtes réseau pour envoyer des données au serveur et utiliser des outils d'analyse de données côté serveur pour le traitement et l'analyse.
-
Affichage et visualisation des données : utilisez des outils d'analyse de données pour afficher visuellement les données cachées et générer des résultats d'analyse de données sous forme de rapports, de graphiques, etc., afin que l'équipe de développement ou l'équipe commerciale puisse effectuer l'analyse des données et prendre des décisions.
-
Confidentialité et conformité : lors du suivi, assurez-vous du respect des réglementations et politiques pertinentes en matière de protection de la vie privée et de conformité des données. Assurer la sécurité et la confidentialité des données des utilisateurs et fournir l’autorisation et la notification nécessaires aux utilisateurs.
-
Stratégie d'optimisation des points enterrés : en fonction des besoins commerciaux réels et des résultats de l'analyse des données, optimisez la stratégie des points enterrés, augmentez ou ajustez les points enterrés des événements clés et améliorez la précision et l'utilité des données.
Il convient de noter que le plan d'intégration spécifique peut varier en fonction des exigences du projet, de l'architecture technique et de la situation réelle de l'équipe. Par conséquent, lors de la mise en œuvre de la solution de points cachés, un développement personnalisé doit être effectué en fonction des conditions spécifiques du projet et des facteurs tels que les performances, la stabilité, la sécurité et l'expérience utilisateur doivent être pris en compte.
Données enterrées et exemples de code pour télécharger des données enterrées
Une classe d'outils qui définit les événements masqués, y compris l'identifiant, le nom, les attributs et d'autres informations de l'événement
public class TrackEventUtils {
public static final String EVENT_PAGE_VIEW = "page_view";
public static final String EVENT_BUTTON_CLICK = "button_click";
// 其他事件定义...
// 获取页面访问事件
public static TrackEvent getPageViewEvent(String pageName) {
TrackEvent event = new TrackEvent(EVENT_PAGE_VIEW);
event.addProperty("page_name", pageName);
// 其他属性...
return event;
}
// 获取按钮点击事件
public static TrackEvent getButtonClickEvent(String buttonName) {
TrackEvent event = new TrackEvent(EVENT_BUTTON_CLICK);
event.addProperty("button_name", buttonName);
// 其他属性...
return event;
}
// 其他事件获取方法...
}
Définir la classe d'entité des événements enterrés, y compris le type d'événement, les attributs et d'autres informations
public class TrackEvent {
private String eventType;
private Map<String, Object> properties;
public TrackEvent(String eventType) {
this.eventType = eventType;
this.properties = new HashMap<>();
}
public String getEventType() {
return eventType;
}
public void addProperty(String key, Object value) {
properties.put(key, value);
}
public Map<String, Object> getProperties() {
return properties;
}
}
Utilisez le framework Retrofit pour télécharger les données de points enterrés sur le chemin correspondant
1. Ajoutez la dépendance Retrofit au fichier build.gradle du projet :
implementation 'com.squareup.retrofit2:retrofit:2.x.x'
implementation 'com.squareup.retrofit2:converter-gson:2.x.x' // 如果要使用 Gson 解析器
2. Créez une instance Retrofit et définissez l'interface API :
public interface TrackApiService {
@POST("/track")
Call<Void> sendTrackEvent(@Body TrackEvent event);
}
3. Modifiez la classe TrackManager et utilisez Retrofit pour envoyer des requêtes réseau :
public class TrackManager {
private static final String API_ENDPOINT = "https://your-api-endpoint.com";
private static TrackManager instance;
private Context context;
private TrackApiService apiService;
private TrackManager(Context context) {
this.context = context.getApplicationContext();
// 创建 Retrofit 实例
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(API_ENDPOINT)
.addConverterFactory(GsonConverterFactory.create()) // 使用 Gson 解析器
.build();
// 创建 API Service
apiService = retrofit.create(TrackApiService.class);
}
public static synchronized TrackManager getInstance(Context context) {
if (instance == null) {
instance = new TrackManager(context);
}
return instance;
}
public void trackEvent(TrackEvent event) {
// 发送网络请求
Call<Void> call = apiService.sendTrackEvent(event);
call.enqueue(new Callback<Void>() {
@Override
public void onResponse(Call<Void> call, Response<Void> response) {
// 处理服务器响应...
}
@Override
public void onFailure(Call<Void> call, Throwable t) {
// 处理请求失败...
}
});
}
}
4. Expliquez les annotations dans Retrofit dans le code ci-dessus et l'interface TrackApiService que nous avons définie ci-dessus. Dans Retrofit, TrackApiServicec'est une interface utilisée pour définir les méthodes de requête réseau. @POST("/track")Il s'agit d'une annotation qui signifie envoyer une requête POST au chemin spécifié "/track".
@Body TrackEvent eventest une autre annotation utilisée pour spécifier le contenu du corps de la requête. Il indique à Retrofit d' TrackEventenvoyer l'objet au serveur en tant que corps de la requête.
L’explication spécifique est la suivante :
-
@POST("/track"): Indique que la méthode POST sera utilisée pour envoyer la requête vers le chemin "/track". Ce chemin est le chemin défini par votre backend API pour recevoir les événements masqués. -
Call<Void>: indique que Retrofit renverra unCallobjet pour exécuter de manière asynchrone les requêtes réseau et traiter les réponses.VoidIndique que le contenu du corps de la réponse est vide. -
sendTrackEvent(@Body TrackEvent event): Il s'agit d'une définition de méthode utilisée pour envoyer des événements cachés.@BodyL'annotation indique queTrackEventl'objet est envoyé en tant que corps de la requête.TrackEventIl s'agit d'une classe que vous définissez, qui contient les données d'événements masquées envoyées au serveur.
Prises ensemble, les méthodes TrackApiServicede l'interface sendTrackEventdéfinissent une requête pour envoyer un événement enterré au chemin spécifié via la méthode POST et TrackEventenvoient l'objet au serveur en tant que corps de la requête.
Vous pouvez modifier cette interface en fonction des besoins réels et ajouter d'autres méthodes et paramètres de requête en fonction de vos besoins.
Dans Retrofit, @Bodyles annotations sont utilisées pour envoyer des objets au serveur en tant que corps de la requête. Cela signifie que vous pouvez envoyer une instance de n'importe quelle classe Java comme corps de requête, sans vous limiter à une classe ou un type de données spécifique.
Lorsque vous utilisez @Bodyl'annotation, Retrofit sérialise automatiquement l'objet spécifié dans le format du corps de la demande, tel que JSON ou d'autres formats. Il enverra ensuite la demande au serveur en utilisant les informations d'en-tête de demande appropriées.
Par conséquent, vous pouvez créer votre propre classe Java qui représente les données qui doivent être envoyées et les envoyer au serveur en tant que corps de la requête. De cette façon, vous pouvez définir et envoyer différents types de données en fonction des besoins réels.
Veuillez vous assurer que lors de l'utilisation @Bodyd'annotations, le serveur peut analyser et traiter correctement le format du corps de la requête. Habituellement, vous devez effectuer le traitement et l'analyse correspondants côté serveur pour garantir que les objets Java que vous envoyez peuvent être correctement reçus et traités.
Remarque : Retrofit créera dynamiquement la classe d'implémentation de l'interface, vous n'avez pas besoin d'écrire manuellement la classe d'implémentation. Lorsque vous créez une instance d'une interface à l'aide de Retrofit, celle-ci génère une classe proxy au moment de l'exécution pour gérer les requêtes réseau réelles. Par conséquent, vous n’avez pas besoin d’implémenter manuellement TrackApiServiceles méthodes dans l’interface.
Utiliser des requêtes asynchrones ou synchrones
L'utilisation enqueuede la méthode est un moyen courant d'effectuer des requêtes réseau de manière asynchrone. Elle exécutera la requête réseau dans un thread d'arrière-plan et rappellera la méthode correspondante une fois la requête terminée.
Retrofit prend en charge les méthodes de requête réseau synchrones et asynchrones. Si vous souhaitez utiliser des requêtes synchrones, vous pouvez utiliser executedes méthodes pour exécuter les requêtes, mais il convient de noter que l'exécution de requêtes réseau sur le thread principal Android provoquera un blocage et peut provoquer des erreurs ANR (Application Not Responding), il est donc recommandé de exécuter dans un thread d'arrière-plan Requête synchrone.
Le fait qu'une interface soit asynchrone ou synchrone est généralement déterminé par la définition de l'interface et l'implémentation du serveur. En règle générale, les requêtes réseau sont effectuées de manière asynchrone pour éviter de bloquer le thread principal. Dans Retrofit, par défaut, les méthodes d'interface seront traitées comme des requêtes asynchrones et vous devez utiliser enqueuela méthode pour effectuer des requêtes asynchrones.
Si vous souhaitez exécuter une requête synchrone, vous pouvez définir l'exécuteur approprié (Executor) lors de la création de Retrofit pour contrôler la manière dont la requête est exécutée. Par exemple, vous pouvez utiliser OkHttple client pour créer une instance Retrofit et configurer un exécuteur personnalisé pour effectuer des requêtes synchrones.
// 创建 OkHttpClient 实例
OkHttpClient okHttpClient = new OkHttpClient.Builder()
.build();
// 创建 Retrofit 实例，并指定 OkHttp 客户端
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://api.example.com")
.addConverterFactory(GsonConverterFactory.create())
.client(okHttpClient) // 设置自定义的 OkHttpClient
.build();
// 创建 TrackApiService 实例
TrackApiService trackApiService = retrofit.create(TrackApiService.class);
// 创建同步请求执行器
ExecutorService executor = Executors.newSingleThreadExecutor();
// 执行同步请求
try {
Response<Void> response = executor.submit(() -> trackApiService.sendTrackEvent(event)).get();
// 请求成功的处理逻辑
} catch (ExecutionException | InterruptedException e) {
// 请求失败的处理逻辑
}
// 关闭执行器
executor.shutdown();
Dans cet exemple, nous OkHttpcréons une OkHttpClientinstance personnalisée à l'aide du client et la transmettons au générateur de Retrofit. Ensuite, nous avons créé une ExecutorServiceinstance et utilisé submitla méthode pour effectuer des requêtes réseau. En appelant getla méthode pour obtenir Responsel'objet, nous pouvons obtenir le résultat de la requête de manière synchrone.
Il convient de noter que les requêtes synchrones doivent toujours être exécutées dans le thread approprié pour éviter de bloquer le thread principal. Dans cet exemple, nous utilisons un exécuteur monothread pour effectuer des requêtes synchrones et arrêter l'exécuteur une fois la requête terminée.
Pour résumer, Retrofit propose deux méthodes, asynchrone et synchrone, pour effectuer des requêtes réseau. La méthode à utiliser dépend de vos besoins et de votre implémentation côté serveur. En général, il est recommandé d'utiliser des requêtes asynchrones pour éviter de bloquer le thread principal, à moins que vous ne sachiez exactement que vous devez effectuer des requêtes synchrones et les exécuter sur le thread approprié. Si une requête synchrone est utilisée, même si la méthode d'exécution est utilisée, le sous-thread doit être démarré manuellement pour appeler la méthode d'exécution. S'il s'agit d'une requête asynchrone, la méthode de mise en file d'attente de Retrofit peut être utilisée, et ce n'est pas nécessaire pour démarrer manuellement le sous-thread vous-même.
Comment le serveur décide-t-il si l'interface est une requête asynchrone ou une requête synchrone ?
1. Côté serveur, décider si l'interface est une requête synchrone ou une requête asynchrone est déterminé par la logique de mise en œuvre côté serveur. Normalement, le serveur définira sa méthode d'exécution pour chaque interface, notamment si elle est synchrone ou asynchrone. Ceci est généralement accompli grâce à des mécanismes spécifiques fournis par un framework côté serveur ou un langage de programmation. Par exemple, dans certains frameworks de serveur, des mécanismes de traitement asynchrone (tels que la programmation asynchrone basée sur le rappel, Future/Promise, les coroutines, etc.) peuvent être utilisés pour gérer les requêtes asynchrones. Pour les requêtes synchrones, les opérations de blocage peuvent être effectuées directement dans le procédé de traitement des requêtes. Par conséquent, pour déterminer si l'interface spécifique est une requête synchrone ou asynchrone, vous devez vous référer au document de l'interface du serveur ou communiquer avec le développeur du serveur pour comprendre les détails de sa conception et de sa mise en œuvre. enqueueSelon les exigences du serveur, vous pouvez choisir d'utiliser la méthode ou executela méthode de Retrofit pour envoyer la demande en conséquence .
2. Dans le code côté serveur, la manière de décider si l'interface est synchrone ou asynchrone dépend de la structure du serveur et du langage de programmation utilisé. Voici un exemple de code courant montrant comment définir des interfaces synchrones et asynchrones dans différents environnements :
a.Node.js (en utilisant le framework Express) :
// 异步接口
app.get('/async', (req, res) => {
someAsyncOperation((data) => {
res.send(data);
});
});
// 同步接口
app.get('/sync', (req, res) => {
const result = someSyncOperation();
res.send(result);
});
b.Java (en utilisant le framework Spring) :
// 异步接口
@GetMapping("/async")
public CompletableFuture<String> asyncEndpoint() {
return CompletableFuture.supplyAsync(() -> {
// 异步操作
return "Async response";
});
}
// 同步接口
@GetMapping("/sync")
public String syncEndpoint() {
// 同步操作
return "Sync response";
}
Ces exemples montrent simplement comment définir des interfaces synchrones et asynchrones dans différents environnements. En pratique, l'implémentation spécifique dépend des fonctionnalités et des mécanismes du framework serveur et du langage de programmation utilisé. Par conséquent, vous devez comprendre comment définir et gérer les interfaces synchrones et asynchrones conformément à la documentation de la structure de serveur et du langage de programmation spécifiques que vous utilisez.
Notes d'étude sur Android
Article sur l'optimisation des performances Android : Article sur les principes sous-jacents du framework Android : Article sur le véhicule Android : Notes d'étude sur la sécurité inversée Android : Article audio et vidéo Android : Article sur le compartiment de la famille Jetpack (y compris Compose) : Notes d'analyse du code source OkHttp : Article Kotlin : Article Gradle : Article Flutter : Huit corps de connaissances sur Android : Notes de base sur Android : Questions d'entretien Android des années précédentes : Les dernières questions d'entretien Android en 2023 : Exercices d'entretien pour le poste de développement de véhicules Android : Questions d'entretien audio et vidéo :https://qr18.cn/FVlo89https://qr18.cn/AQpN4Jhttps://qr18.cn/F05ZCMhttps://qr18.cn/CQ5TcLhttps://qr18.cn/Ei3VPDhttps://qr18.cn/A0gajphttps://qr18.cn/Cw0pBDhttps://qr18.cn/CdjtAFhttps://qr18.cn/DzrmMBhttps://qr18.cn/DIvKmahttps://qr18.cn/CyxarUhttps://qr21.cn/CaZQLohttps://qr18.cn/CKV8OZhttps://qr18.cn/CgxrRyhttps://qr18.cn/FTlyCJhttps://qr18.cn/AcV6Ap