Cómo estudio Spring Framework (la ayuda para principiantes es el trabajo de los principiantes)

Buenas tardes

Me propuse el objetivo de aprender el framework Spring para el lenguaje Java. Durante el estudio, decidí comprobar por mí mismo el algoritmo de aprendizaje de Richard Feynman: organizar, simplificar y entrenar a otro. En general, comencé a grabar una serie de lecciones cortas para principiantes en el trabajo en primavera. Para aquellos que quieran repetir, presenté el código fuente .

Lección 01. Entendiendo IoC

Entonces, reunamos a los poetas, que compongan y nos lean sus poemas.

Primero, declare la interfaz que genera los versos src \ main \ java \ spring \ interfaces \ Lyricist.java:

package spring.intarfaces; public interface Lyricist { public String Generate(); } 

Implementamos esta interfaz en la clase src \ main \ java \ spring \ impls \ Mayakovsky.java :

 package spring.impls; import spring.intarfaces.Lyricist; public class Mayakovsky implements Lyricist { @Override public String Generate() { return " \r\n" + " \r\n" + " \r\n" + "   ?"; } } 

Escribiremos que crearemos un objeto Mayakovsky específico en el archivo de configuración xr src \ main \ resources \ ApplicationContext.xml :

 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="LyricistBean1" class="spring.impls.Mayakovsky"/> </beans> 

Identificación asociada LyricistBean1 con el nombre de la clase Mayakovsky. Casi todo está listo, solo falta la clase de llamada src \ main \ java \ spring \ main \ Start.java :

 package spring.main; import org.springframework.context.ApplicationContext; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import spring.intarfaces.Lyricist; public class Start { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml"); Lyricist lyr1 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr1.Generate()); ((ConfigurableApplicationContext) context).close();//    } } 

En la clase Start, leemos nuestro archivo de configuración, creamos una instancia del poeta llamado bean LyricistBean1. Tengo una copia del poeta Mayakovsky. La función Generate () nos devolvió cadenas inmortales:

Y tu
juego nocturno
podría
en una flauta de tubo de drenaje?

Lección 02. Seleccionar una instancia para crear a través del archivo de configuración

Digamos que un amigo nos ayudó y proporcionó otra implementación de nuestra interfaz Lrricist src \ main \ java \ spring \ impls \ Poushkin.java :

 package spring.impls; import spring.intarfaces.Lyricist; public class Poushkin implements Lyricist { @Override public String Generate() { return "   :\r\n" + "   ,\r\n" + "  ,\r\n" + "   ."; } } 

En el archivo de configuración ApplicationContext.xml, cambie Mayakovsky a Poushkin.

Ejecute el programa Obtenemos un resultado completamente diferente sin reconstruir :

Recuerdo un momento maravilloso
Apareciste ante mi
Como una visión fugaz
Como un genio de pura belleza.

Lección 03. Frijoles en el código, no en el archivo de configuración

Supongamos que no nos gusta dar la elección de la clase de poeta que estamos creando en manos del destino en el archivo de configuración.

Cambiar la clase Poushkin.java

1. Agregar biblioteca de importación importaciones org.springframework.stereotype.Component;
2. Ponga la anotación Componente ("LyricistBean1") antes de la declaración de clase

Así que le dijimos a Spring que queríamos ver a Poushkin en la forma del primer poeta, y no a otra persona.

Queda por corregir ligeramente el archivo de configuración ApplicationContext.xml:

1. Agregue el contexto del espacio de nombres: xmlns: context = " www.springframework.org/schema/context ";

2. Eliminar la línea innecesaria: />

3. Agregue un comando en lugar de él para agregar automáticamente contenedores de todas las clases ubicadas en el directorio spring.impls al programa:

<context: component-scan base-package = "spring.impls" />

Como resultado, el archivo ApplicationContext.xml debería verse así:

 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd"> <context:component-scan base-package="spring.impls"/> </beans> 

Empezamos Obtenemos el mismo resultado que en la lección anterior.

Lección 04. Clase de configuración

Vamos a deshacernos del archivo xml por completo.

Todos los ajustes también pueden estar en la clase java. A veces es conveniente.

Agregue una clase de configuración especial src \ main \ java \ spring \ main \ LyricistConfiguration.java a nuestro programa:

 package spring.main; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; @ComponentScan(basePackages = { "spring.impls" }) @Configuration public class LyricistConfiguration { } 

@ComponentScan muestra en qué directorio buscar beans.
@Configuration informa que nuestra clase es especial, configuración.

Eso es todo, el archivo xml ya no es necesario. Queda por informar esta noticia a nuestra clase principal:

1. Compleméntelo con la importación de importación necesaria org.springframework.context.annotation.AnnotationConfigApplicationContext;
2. Reemplazar la línea de creación de contexto
   ApplicationContext context = new AnnotationConfigApplicationContext (LyricistConfiguration.class);

Como resultado, el archivo principal src \ main \ java \ spring \ main \ Start.java debería verse así:

 package spring.main; import org.springframework.context.ApplicationContext; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import spring.intarfaces.Lyricist; public class Start { public static void main(String[] args) { ApplicationContext context = new AnnotationConfigApplicationContext(LyricistConfiguration.class); Lyricist lyr1 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr1.Generate()); ((ConfigurableApplicationContext) context).close();//    } } 

Todo comienza y todavía produce líneas inmortales de Pushkin. Todo funciona Pero ya sin xml.

Lección 05. Singleton y prototipo

Explore las capacidades del archivo de configuración. Por lo tanto, regresemos al proyecto desde la segunda lección. Intentemos crear dos instancias de la clase Poushkin en Start.java y asegurémonos de que el gran poeta sea el mismo:

  Lyricist lyr1 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr1.Generate()); System.out.println(lyr1.hashCode()); Lyricist lyr2 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr2.Generate()); System.out.println(lyr2.hashCode()); 

Y los versos son iguales, y el código hash cae. Todo esta bien.

Agregue a nuestro proyecto un ciudadano simple que no escribe versos src \ main \ java \ spring \ impls \ SimpleMan.java :

 package spring.impls; import spring.intarfaces.Lyricist; public class SimpleMan implements Lyricist { @Override public String Generate() { return "  ,   "; } } 

Registre la clase en el archivo de configuración (inmediatamente después del primer bin)

  <bean id="LyricistBean2" class="spring.impls.SimpleMan"/> 

Estamos tratando de crear

  Lyricist lyr1 = context.getBean("LyricistBean2", Lyricist.class); System.out.println(lyr1.Generate()); System.out.println(lyr1.hashCode()); Lyricist lyr2 = context.getBean("LyricistBean2", Lyricist.class); System.out.println(lyr2.Generate()); System.out.println(lyr2.hashCode()); 

El ciudadano es el mismo todo el tiempo. El desorden ...

Cambie el registro del bean en el archivo de configuración agregando la palabra mágica scope = "prototype"

Como resultado, el archivo src \ main \ resources \ ApplicationContext.xml se verá así:

 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="LyricistBean1" class="spring.impls.Poushkin" scope="singleton"/> <bean id="LyricistBean2" class="spring.impls.SimpleMan" scope="prototype"/> </beans> 

Ahora todo está bien. Los ciudadanos son diferentes cada vez. Pero Pushkin siempre está solo.

Las personas atentas notaron que la configuración scope = "singleton" se agregó en el primer bin, pero esta configuración se usa de manera predeterminada, por lo que no puede escribirla.

Eso es todo por hoy. Si esta publicación pasa por moderación, y tengo tiempo y energía, habrá una continuación sobre AOP, JDBC, transacciones, MVC y otra sabiduría.

Saludos, Vladimir