java - sincrono - Mejores prácticas de programación asincrónica

programacion asincrona python

Question

Recientemente escribí mi primera aplicación para Android, que tenía aproximadamente entre 8,000 y 10,000 líneas de código. Una cosa que continuamente obstaculizó mi uso de patrones de diseño normales fue el uso intensivo de llamadas asincrónicas de Android (apertura de diálogos, actividades, etc.). Debido a esto, mi código rápidamente comenzó a buscar "spaghetti", y finalmente comencé a sentir aversión al mirar ciertas clases.

¿Existen patrones de diseño específicos o metodologías de programación que son para sistemas como estos que cualquiera podría recomendar? ¿Hay alguna sugerencia para escribir código asíncrono manejable?

Answer 1

¿Qué hay de usar el patrón de controlador de vista de modelo?

Al menos tienes que aislar en el "modelo" (objeto o conjunto de objetos) todo el estado y su administración lógica, y tener en una clase separada (tal vez la clase de Actividad) todo lo relacionado con las vistas, oyentes, devoluciones de llamada, ...)

Answer 2

Desde una perspectiva amateur, no espero que mi primer intento sea una aplicación limpia y lista para producción. Termino con spaghetti, fettucini e incluso código de ravioles a veces. En ese momento, trato de volver a pensar qué es lo que más me disgusta del código, y buscar una mejor alternativa:

• Repensa tus clases para describir mejor tus objetos,
• mantener el código en cada método al mínimo,
• evitar dependencias a variables estáticas en cualquier lugar que pueda,
• utilice hilos para tareas costosas, no los use para procedimientos rápidos,
• separe la UI de la lógica de la aplicación (guárdela en sus clases)
• mantenga los campos privados en cualquier lugar que pueda: será útil cuando quiera cambiar su clase,
• iterar a través de estos hasta que te guste el código

Uno de los errores más comunes que he visto en los métodos asíncronos es utilizar una variable estática dentro de un ciclo que crea uno o más subprocesos, sin considerar que el valor puede cambiar en otro subproceso. Evita la estática!

Como señala OceanBlue, puede no quedar claro a partir de esto que las variables final static no crean ningún peligro, sino variables públicas estáticas que pueden cambiar. No es un problema con la estática en sí, sino con la idea de que tendrán un valor y luego descubrirán que el valor ha cambiado. Puede ser difícil detectar dónde estaba el problema. Los ejemplos típicos serían un contador de clics o un valor de temporizador, cuando podría haber hecho clic en más de una vista o más de un temporizador.

Espero que recibas sugerencias de personas con mucha más experiencia que yo. ¡Buena suerte!

Answer 3

Si manejar su UI es su mayor preocupación, entonces querrá dominar la codificación controlada por eventos. Las ideas detrás de la codificación basada en eventos están detrás de todos los sistemas modernos de IU, y son útiles en todo tipo de cosas (no solo en la IU).

La manera más fácil de pensarlo cuando aprendí fue simplemente tratar cada componente y evento como si fuera autónomo. Todo lo que debe preocuparse es el objeto del evento pasado a su método de evento. Si estás acostumbrado a escribir aplicaciones que se ejecutan básicamente de principio a fin, es un cambio de mentalidad, pero la práctica te llevará allí muy rápidamente.

Answer 4

• Usa variables globales

Si no quiere desordenar su código con Intent.putExtra() simples de Intent.putExtra() y gestiona esto para cada Activity única, tendrá que usar variables globales dentro de la aplicación. Extienda la Application y almacene los datos que necesite mientras su aplicación esté activa. Para implementarlo realmente, use esta excelente respuesta . Esto hará que las dependencias entre actividades desaparezcan. Por ejemplo, supongamos que necesita un "nombre de usuario" para su aplicación durante el ciclo de vida de la aplicación; esta es una excelente herramienta para eso. No es necesario realizar Intent.putExtra() sucias de Intent.putExtra() .

• Usa estilos

Un error común al hacer la primera aplicación de Android es que uno generalmente comienza a escribir las vistas XML. Los archivos XML llegarán (sin problema y muy rápido) a muchas líneas de código. Aquí puede tener una solución donde solo usa el atributo de style para implementar un comportamiento específico. Por ejemplo, considere esta pieza de código:

values ​​/ styles.xml :

<style name="TitleText">
    <item name="android:layout_height">wrap_content</item>
    <item name="android:layout_width">wrap_content</item>
    <item name="android:textSize">18sp</item>
    <item name="android:textColor">#000</item>
    <item name="android:textStyle">bold</item>   
</style>

layout / main.xml :

Ahora, si tiene, digamos, dos TextView y ambos deben tener el mismo comportamiento, haga que usen el estilo TitleText . Código de muestra:

<!--- ... -->
<TextView
   android:id="@+id/textview_one"
   style="@style/TitleText" 
/>

<TextView
   android:id="@+id/textview_two" 
   style="@style/TitleText" 
/>
<!--- ... -->

Simple y no es necesario duplicar el código. Si realmente desea profundizar en este tema en particular, consulte Trucos de diseño: creación de componentes de interfaz de usuario reutilizables .

• Use cadenas

Este punto es breve, pero creo que es importante mencionarlo. Otro error que pueden cometer los desarrolladores es omitir strings.xml y simplemente escribir mensajes UI (y nombres de atributos) dentro del código (donde lo necesitará). Para hacer que su aplicación sea más fácil de mantener; solo defina mensajes y atributos en el archivo strings.xml .

• Crear y usar una clase de herramienta global

Cuando escribí mi primera aplicación, simplemente escribí (y dupliqué) los métodos donde los necesitaba. ¿El resultado? Una gran cantidad de métodos que tenían el mismo comportamiento entre varias actividades. Lo que aprendí es hacer una clase de herramienta. Por ejemplo, supongamos que debe realizar solicitudes web en todas sus actividades. En ese caso, omita definirlos dentro de la Activity real y cree un método estático para ello. Código de muestra:

public final class Tools {

    private Tools() {
    }

    public static final void sendData(String url, 
              String user, String pass) {
        // URLConnections, HttpClients, etc...
    }

}

Ahora, puede usar este código a continuación en su Activity que necesita enviar datos hacia un servidor:

Tools.sendData("www.www.www", "user", "pass");

Sin embargo, entiendes el punto. Use este "patrón" donde lo necesite , evitará que se estropee su código.

• Deje que las clases personalizadas definan el comportamiento donde el usuario necesita interactuar con su aplicación

Este es probablemente el punto más útil. Para definir " donde el usuario necesita interactuar con su aplicación " digamos que tiene un Menu , cuyo comportamiento es muy largo en términos de líneas, ¿por qué mantenemos los cálculos del Menu en la misma clase? Cada pequeño elemento hará que su clase de Activity una pieza dolorosa de código más largo; su código se verá como "spaghetti". Por ejemplo, en lugar de tener algo como esto:

@Override
public boolean onPrepareOptionsMenu(Menu menu) {
    MenuItem item;
    item = menu.findItem(R.id.menu_id_one);
    if (aBooleanVariable) {
        item.setEnabled(true);
    } else {
        item.setEnabled(false);
    }
    // More code...
    return super.onPrepareOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(MenuItem i) {
    // Code, calculations...
    // ...
    // ...
    return super.onOptionsItemSelected(i);
}

rediseñarlo a algo como esto:

private MyCustomMenuInstance mMenuInstance;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);        
    setContentView(R.layout.main);

    mMenuInstance = new MyCustomMenuInstance();
}  

@Override
public boolean onPrepareOptionsMenu(Menu menu) {
    mMenuInstance.onPrepareOptionsMenu(menu);
    return super.onPrepareOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(MenuItem i) {
    mMenuInstance.onOptionsItemSelected(i);
    return super.onOptionsItemSelected(i);
}

Por ejemplo, MyCustomMenuInstance :

public class MyCustomMenuInstance { 

    // Member fields..

    public MyCustomMenuInstance() {
        // Init stuff.
    }

    public void onPrepareOptionsMenu(Menu menu) {
        // Do things..
        // Maybe you want to modify a variable in the Activity 
        // class? Well, pass an instance as an argument and create
        // a method for it in your Activity class.
    }

    public void onOptionsItemSelected(MenuItem i) {
        // Do things..
        // Maybe you want to modify a variable in the Activity 
        // class? Well, pass an instance as an argument and create
        // a method for it in your Activity class.
    }

}

Ya ves a dónde va esto. Puede aplicar esto a muchas cosas, por ejemplo, onClick , onClickListener , onCreateOptionsMenu , la lista es larga. Para conocer más "mejores prácticas", puede ver algunas aplicaciones de muestra de Google here . Busque cómo han implementado las cosas de una manera agradable y correcta.

Ultima palabra; Mantenga limpio su código, nombre sus variables y métodos de una manera lógica y especialmente de manera correcta. Siempre, siempre entienda dónde se encuentra en su código, eso es muy importante.