tutorial para aplicaciones web

Hola yo creo solo aplicaciones de escritorio en java con ide Netbeans, alguien tiene un tutorial o un manual para crear aplicaciones web.

Porfavor

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.

Chachareando web

Hace tiempo me tocó capacitar a unos chavos para que aprendieran a usar conceptos básicos de Spring. Últimamente le he estado agregando una interfaz web para así tener el cascaron completo de lo que seria un proyecto base. La intensión es que se descargue y de ahí se comience desarrollar la lógica de negocio.

El código está publicado en GitHub quizás te interese echarle un lente.

Las carpetas que ahí vas a encontrar son:

  • ChachareandoGit: Es el proyecto de persistencia, está con Spring JDBC
  • basureando-beans: Solo tiene los beans que son utilizados en todas los proyectos
  • basureando-service: Es el proyecto que expone servicios para que puedan ser consumidos por diferentes clientes
  • basureando-web: Proyecto web con Spring MVC- Spring Security (procuro realizar todas las peticiones con json)
  • database: Contiene el script de creación de la DB que ocupa el proyecto (actualizado para postgre, para mysql se necesita actualizar)

Por cierto, tiene dependencia con el proyecto javadabadoo-util.

Imagen de avefenix_x

Proyecto muy interesante.

Siempre me he preguntado por que usar interfaces en todas las capas y casi una interface por cada clase que se usa. y no usar intefaces globales para estandarizar las clases que por lo regular queremos que hagan una labor semejante.
Que beneficio tenemos de usar interfaces.. de esa manera? en cuanto al rendimiento ...

Saludos.

Imagen de ezamudio

rendimiento?

El beneficio de usar interfaces, desde el punto de vista de rendimiento, es nulo.

El definir interfaces y programar contra interfaces en vez de contra clases no se hace por desempeño en la ejecución de las aplicaciones, sino para facilitar el desarrollo de las mismas.

Interfaces

Muy útil para clasificar un objeto como un tipo pero sin que el comportamiento sea igual a otro objeto del mismo tipo. En mi proyecto (por ejemplo) tengo definida una interface Dao y de ella se complementan otras interfaces.

<debraye>
Un poco fuera de tema pero relacionado: Por qué Interfaces y no herencia?
Por ejemplo, un DAO de cajón tienes que puedes guardar y leer datos, la interfaz te permite indicar que los objetos que la implementen pueden ser clasificados como tipo Dao pero sus métodos tienen diferente comportamiento.

Indicamos que podemos de escribir y leer información

public interface Dao<T> {

        int writeData(T elemento);

        T readData(int id);

}

Aqui podemos persistir en base de datos

public class AlgunDao implements Dao<AlgunBean> {

        public int writeData(AlgunBean elemento) {
                // INSERT INTO...
        }

        public AlgunBean readData(int id) {
                // SELECT FROM
        }

}

Aqui podemos serializar un objeto en el filesystem

public class OtroDao implements Dao<OtroBean> {

        public int writeData(OtroBean elemento) {
                // FileIO.write(...
        }

        public OtroBean readData(int id) {
                // FileIO.read(...
        }

}

Como anteriormente vimos, la interface nos indica qué comportamiento tenemos pero no define cual es el comportamiento. Dentro de los patrones de diseño se emplea un termino muy importante que dice Composición sobre herencia. Imagina que nuestra interface fuera una clase concreta, o mejor aun, una clase abstracta.

public abstract class Dao<T> {

    public abstract int writeData(T elemento);

    public abstract T readData(int id);
}

de esa forma nuestra "implementación" es

class AlgunDao extends Dao<AlgunBean> {

        public int writeData(AlgunBean elemento) {
                // INSERT INTO...
        }

        public AlgunBean readData(int id) {
                // SELECT FROM
        }
}

public class OtroDao extends Dao<OtroBean> {

        public int writeData(OtroBean elemento) {
                // FileIO.write(...
        }

        public OtroBean readData(int id) {
                // FileIO.read(...
        }

}

La pregunta es: Si quiero agregar comportamientos a OtroDao para que ademas de escribir y leer también pueda modificar y eliminar ¿Cómo le hago? Si hubieramos utilizado interfaces es muy sencillo

public class OtroDao implements Dao<OtroBean>, ComplementDao<OtroBean> {

        ...// los metodos de Dao<T>

        public int updateData(OtroBean elemento) {
                // FileIO.modify(...
        }

        public OtroBean deleteData(int id) {
                // FileIO.delete(...
        }

En el mejor de los casos con herencia hacemos que ComplementDao<T> sea abstracto y que herede de Dao. Entonces decimos que tres clases están fuertemente ligadas. Ademas de que si en una clase solo defines métodos concretos ya no es una clase, es una interface y por lo tanto debe tratarse como tal. La herencia es para que conserva propiedades y comportamientos concretos, si esto no sucede entonces no es herencia.
</debraye>

El hecho de utilizar diferentes interfaces y no una global es que no todas las clases tienen exactamente la misma definición de comportamientos. Si se definiera una global con todos los métodos posibles, tendrías comportamientos de sobra lo cual no serviría de mucho para determinar un tipo de objeto.