tutorial mvc framework español ejemplo anotaciones java xml spring

java - framework - spring mvc 4 tutorial español



¿De cuántas maneras existen para configurar el framework Spring? ¿Cuáles son las diferencias entre ellos técnicamente?(No pros o contras..) (7)

Estoy estudiando this libro (que recomendaría encarecidamente), y estoy confundido acerca de cómo los autores explican la forma en que se puede configurar Spring Framework.

Puedes ver algunos ejemplos de código que se utilizan en el libro here . (Están disponibles para todos ..) El código al que me refiero será el código del capítulo 2, si desea echarle un vistazo.

De todos modos, el libro indica que hay 3 formas de configurar el contenedor Spring .

Configuración basada en XML

Esto requerirá un archivo xml que se asemeja a algo como esto:

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" ...> <bean id="accountService" class="com.wiley.beginningspring.ch2.AccountServiceImpl"> <property name="accountDao" ref="accountDao"/> </bean> <bean id="accountDao" class="com.wiley.beginningspring.ch2.AccountDaoInMemoryImpl"> </bean> </beans>

Y luego, para arrancar Spring, el código que se utilizará será:

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/com/wiley/beginningspring/ch2/ch2-beans.xml");

No tengo ninguna confusión en este momento.

Configuración basada en Java

En este método de configuración, habrá una clase para la configuración de la siguiente manera:

@Configuration public class Ch2BeanConfiguration { @Bean public AccountService accountService() { AccountServiceImpl bean = new AccountServiceImpl(); bean.setAccountDao(accountDao()); return bean; } @Bean public AccountDao accountDao() { AccountDaoInMemoryImpl bean = new AccountDaoInMemoryImpl(); return bean; } }

y el código responsable de bootstrapping Spring se ve así:

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Ch2BeanConfiguration.class);

Así que hasta aquí, todo está claro para mí. (Tipo de ...) También me gustaría señalar que aquí tenemos una anotación que se llama @Configuration ...

Configuración basada en anotaciones

El último método de configuración disponible, explicado en el libro, es la configuración basada en anotación .

Hay un archivo xml como el que teníamos en la configuración basada en XML, pero uno mucho más pequeño:

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" ...> <context:component-scan base-package="com.wiley.beginningspring.ch2"/> </beans>

Todos los frijoles tienen anotaciones como:

@Component, @Service

etc.

Y todas las dependencias tienen las anotaciones:

@Autowired

Para que los frijoles puedan ser inyectados.

La forma en que Spring Framework arranca en este método de configuración es la siguiente:

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/ch2-beans.xml");

Aquí están mis preguntas:

¿Por qué la (así llamada) configuración basada en anotación utiliza ClassPathXmlApplicationContext pero no AnnotationConfigApplicationContext arriba? Este último parece ser mucho más apropiado para ser usado en una Configuración que tiene las palabras "Basado en anotaciones", ¿no es así?

La configuración basada en Java que se explica en el libro parece ser lo que debería llamarse Configuración basada en anotación .

Y la forma en que la configuración basada en anotaciones que se explica en el libro realmente me parece algo como: Configuración basada en XML con beans autowired. Ni siquiera tiene la anotación @Configuration, que tiene la "Configuración basada en Java".

¿De cuántas formas hay para configurar Spring framework?

Al principio, quiero agradecer a Ken Bekov por su respuesta más ingeniosa. He intentado improvisar su respuesta para que cualquiera pueda aprender más sobre esta área.

Definición de configuración:

Spring 4 contiene 3 formas de definir su configuración. Son

Ventajas de la anotación:

  1. Toda la information is in a single file (no es necesario abrir dos archivos para configurar un comportamiento determinado)

  2. Cuando la clase cambia, no need to modify the xml file

  3. Las anotaciones a menudo se dice que son más intuitivas y robustas cuando se vuelve a factorizar el código de la aplicación. También se benefician de una mejor guía IDE como la que proporciona el disfraz. Pero mezclan código de aplicación con preocupaciones de DI. Una aplicación se vuelve dependiente de un framework. La separación clara es casi imposible. Annotations are also limited when describing different injection behaviour at the same place (constructor, field) dependent on other circumstances (eg robot legs problem). Además, no permiten tratar las clases externas (código de biblioteca) como su propia fuente. Por lo tanto, se considera que se ejecutan más rápido que XML.

Ventajas del archivo xml:

  1. Clara separación entre el POJO y su comportamiento.

  2. Cuando no sabe qué POJO es responsable del comportamiento, es más fácil encontrar ese POJO (buscar en un subconjunto de archivos en lugar de todo el código fuente)

  3. XML tiene el único beneficio de un estilo declarativo que se define claramente separado del código de la aplicación en sí. Que se mantenga independiente de las preocupaciones de DI. Las desventajas son la verbosity , la poor re-factoring robustness poor re-factoring y a general runtime failure comportamiento a general runtime failure . Existe un soporte de herramientas general (XML) con poco beneficio en comparación con el soporte de IDE para, por ejemplo, Java. Además, este XML viene con una sobrecarga de rendimiento por lo que suele ser slower than code solutions .

XML y enlace basado en anotación:

  1. http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#beans-annotation-config
  2. Anotaciones vs XML, ventajas y desventajas.
  3. Inyección de la dependencia de Java: XML o anotaciones
  4. ¿La configuración basada en anotaciones de primavera vs xml?
  5. Configuración xml versus configuración basada en anotación

Enlace basado maravilloso:

  1. https://objectpartners.com/2016/01/12/using-groovy-based-spring-configuration/
  2. http://blog.andresteingress.com/2014/02/14/grails-java-based-spring-config/

Definición de frijol:

Hay 2 formas de frijol Definición:

Escaneando classpath:

Para xml-config será <context:component-scan base-package="..."/> , para java-config - @ComponentScan anotación, para ctx.''component-scan''(...) Groovy ctx.''component-scan''(...) .

Inyección de dependencia:

En la configuración basada en xml, dependency injection se puede hacer manualmente en xml , o usando annotations (@Autowire, @Required, etc.). En ese caso es necesario definir <context:annotation-config/>

Pregunta respuesta:

P1: ¿Por qué la (así llamada) Configuración basada en anotación está usando ClassPathXmlApplicationContext pero no AnnotationConfigApplicationContext arriba?

Respuesta: Es una configuración basada en xml con definición de bean basada en anotación.

Contexto de la aplicación:

  1. ApplicationContext

AnnotationConfigApplicationContext:

1. AnnotationConfigApplicationContext y contexto principal

ClassPathXmlApplicationContext:

  1. http://www.tutorialspoint.com/spring/spring_applicationcontext_container.htm
  2. http://www.mkyong.com/spring3/spring-3-hello-world-example/

P2: La configuración basada en Java que se explica en el libro parece ser lo que debería llamarse Configuración basada en anotación.

Respuesta: Tienes razón en ese caso. La configuración basada en Java usa anotaciones y se llama configuración basada en anotaciones. Pero la anotación es una parte única de Java, nada más.

Pero, ¿tenemos que entender detalladamente cómo esta jerarquía viene del xml a la anotación y, por último, a la base?

Una alternativa a las configuraciones de XML se proporciona mediante la configuración basada en anotaciones que se basa en los metadatos de bytecode para cablear los componentes en lugar de las declaraciones de corchetes angulares. En lugar de usar XML para describir el cableado de un bean, el desarrollador mueve la configuración a la clase del componente mediante el uso de anotaciones en la clase, método o declaración de campo correspondiente. Como se mencionó en la sección llamada “Ejemplo: el RequiredAnnotationBeanPostProcessor” , el uso de un BeanPostProcessor junto con las anotaciones es un medio común para extender el contenedor Spring IoC. Por ejemplo, Spring 2.0 introdujo la posibilidad de imponer las propiedades requeridas con la anotación @Required .

Spring 2.5 hizo posible seguir el mismo enfoque general para impulsar la inyección de dependencia de Spring. Esencialmente, la anotación @Autowired proporciona las mismas capacidades que se describen en la Sección 6.4.5, “Colaboradores de Auto cableado” pero con un control más preciso y una aplicabilidad más amplia.

Spring 2.5 también agregó soporte para anotaciones JSR-250 como @PostConstruct y @PreDestroy .

Spring 3.0 agregó soporte para las anotaciones JSR-330 (Inyección de dependencia para Java) contenidas en el paquete @Inject como @Inject y @Named . Los detalles sobre esas anotaciones se pueden encontrar en la sección correspondiente.

P3: ¿De cuántas formas hay para configurar Spring Framework?

Respuesta:

Theoretically, 3 formas de describir la configuración y 2 formas de definir beans. Convierte 3 * 2 = 6 formas de configurar Spring Framework (por defecto). Todas estas formas se pueden utilizar en combinación unas con otras.

But Actually, en una sola palabra, podemos configurar Spring Framework mediante el uso de XML o annotations .

Déjame mostrar primero diferente en la codificación primero:

  1. XML: debe registrar su bean bean dentro del archivo de contexto xml utilizando <bean/>

  2. Configuración de Java: tiene que usar @Configuration y @Bean para registrar su bean en contexto.

  3. Anotación: usar @Component y sus amigos es realmente común, se podría usar con otros 2 usando:

    1. en xml usando <context:component-scan/>
    2. en la configuración de java usando @ComponentScan

¿Por qué usó ClassPathXmlApplicationContext porque usó xml para configurar el análisis de componentes pero si usó @ComponentScan entonces seguramente usará AnnotationConfigApplicationContext

Así que para mí lo considero como 2 formas de inicializar la configuración xml o java del contexto spring y Annotation es una opción que podría ser utilizada por cualquiera de ellos o no ser utilizada en absoluto.

La forma más fácil de entender esto es mirar en la larga historia del marco cómo se desarrolló.

  • Configuración basada en XML - esto estuvo allí desde el principio - versión 1 - vea javadoc para ClassPathXmlApplicationContext . Esto fue alrededor de marzo de 2004, el momento de J2EE 1.4, que tenía una configuración xml HUGE y Spring fue una gran simplificación (también XML, pero más simple). Esto usa XML para todo, incluida la especificación del cableado automático, o qué dependencias van a donde directamente (su ref = ejemplo "accoundDao").

  • Configuración basada en anotaciones - en Spring 2.5 - esto fue una reacción a Java EE 5, se introdujeron nuevas @Autowired como @Autowired , todavía había alguna configuración de contexto en los archivos XML - por lo general, definiría qué paquetes se analizarían y el resto de ellos Se hizo automáticamente basado en anotaciones, de ahí el nombre.

  • La configuración basada en Java vino con Spring 3, fue mejorada en versiones posteriores. Esto es cuando se introdujeron AnnotationConfigApplicationContext y la anotación de configuración - potencialmente podría eliminar XML por completo -> configuración basada en java. Aunque esto se volvió práctico solo más tarde con la versión 4+, debido a la gran cantidad de etiquetas xml helper para aop, jdbc, etc.

Además de estos 3 (2 en realidad como 1 y 2 usan la misma clase ApplicationContext), hay otras formas de crear un contexto:

Las tres formas de configurar el framework Spring no están destinadas a ser mutuamente excluyentes. En realidad, mi conjetura es que en promedio encontrarás al menos dos de ellos usados ​​juntos.

La configuración basada en anotaciones es la menos probable que se use de forma independiente, simplemente porque se basa en metadatos que están inherentemente dispersos en todo el código fuente.

El AnnotationConfigApplicationContext puede usarse para iniciar un contexto basado en anotaciones puras , pero deberá pasar todas sus clases anotadas como @Component o derivadas, en lugar de pasar una sola (o un par de) la clase @Configuration -annotated ( es) - lo que no suele ser práctico.

Si bien esto es prácticamente lo mismo que enumerar de forma estática los beans en la configuración de XML o Java, el hecho de que tenga que hacer esto en el código cuando cree el contexto de la aplicación en sí lo hace menos útil, ya que no puede beneficiarse de varias formas inteligentes de activar automáticamente el contexto de una aplicación (en contextos web y así sucesivamente).

Es por eso que probablemente querrá tener los metadatos del gráfico de objetos completos reunidos de una sola vez, y eso solo se puede lograr con XML o con la configuración basada en Java , que se basa en metadatos "centralizados" que describen todo el gráfico de objetos.

Para los enfoques basados ​​tanto en XML como en Java, estos "metadatos centralizados" ( <beans> o @Configuration ) se pueden definir de forma estática (con definiciones <bean> o @Bean ) o dinámicamente (usando <component-scan> o @ComponentScan ) . Entonces, es razonable decir que estos dos enfoques son solo formatos diferentes con casi las mismas capacidades que pueden beneficiarse de la configuración basada en anotaciones para recopilar los metadatos "descentralizados".

No exactamente. Hay dos formas de configurar el framework Spring. Las dos herramientas básicas de configuración para el framework Spring son:

  • Archivos XML (fuera de archivos java)
  • Anotaciones basadas en Java (5 +) (dentro de archivos java)

Ambos pueden ser utilizados para:

  • configure un contexto de aplicación (lo que significa agregar beans): los constructores de contextos de aplicación concretos aceptan archivos xml, paquetes para analizar o clases con nombre directamente para cargar
  • reinicie el contexto de una aplicación en el caso de una aplicación web - usando web.xml vs usando una clase que implementa WebApplicationInitializer

Y por último pero no menos importante:

  • puede escanear anotaciones de un archivo de configuración xml usando <context:component-scan/>
  • puede cargar un archivo xml desde un bean de configuración anotado usando @import

La segunda forma llamada Configuración basada en Java en su libro, es una anotación particular @Configuration . Una clase comentada normalmente será un bean en el contexto de la aplicación, pero también puede declarar otros beans con la anotación @Bean en un método. Esa es la razón por la que esas clases generalmente se cargan directamente en lugar de escanearse el bean.

La tercera forma, llamada Configuración basada en anotación , es simplemente una mezcla de los dos modos, donde se utiliza la configuración XML en un nivel superior y solo se analizan los paquetes para buscar beans adicionales.

TL / DR: solo hay 2 formas de configurar un contexto de aplicación en el marco de Spring:

  • archivos de configuración xml
  • anotaciones java

y se pueden mezclar

Pero cada bean solo puede ser declarado de 3 maneras:

  • de un archivo xml
  • con una anotación @Bean dentro de un @Configuration anotado @Configuration
  • directamente con un @Component (o cualquiera de las anotaciones especializadas @Controller , @Service , etc.)

Ahora para sus preguntas precisas:

¿Por qué la (así llamada) configuración basada en anotación utiliza ClassPathXmlApplicationContext pero no AnnotationConfigApplicationContext arriba?

Debido a que ApplicationContext se inicializa primero desde un archivo de configuración xml. El análisis de paquetes se produce más tarde con la ayuda de las etiquetas <context:scan ...> . Usted utiliza un AnnotationConfigApplicationContext si lo inicializa directamente desde las clases de configuración o mediante el análisis de paquetes.

La configuración basada en Java que se explica en el libro parece ser lo que debería llamarse Configuración basada en anotación.

Lo llaman Java Based porque no necesita xml, por lo que la configuración solo usa Java

No he echado un vistazo al libro, pero sus suposiciones son realmente correctas.

Para iniciar una aplicación Spring y tener todos los beans instanciados por el marco usando beans configurados XML, debe usar un ClassPathXmlApplicationContext.

Hay 2 formas de configurar los frijoles en primavera:

1) Beans XML 2) Enfoque de anotación

Básicamente, los beans XML se usaron en la primavera 2.5-3 y el enfoque de anotaciones se usa más en la primavera 4.

@Bean // is a way to create a bean. It is the equalivant of the beans tag in XML. @Configuration // is a way to tell the Spring container that this class is a list of configuration beans

Primavera tiene 2 contenedores de primavera:

1) BeanFactory 2) ApplicationContext

Un BeanFactory es el contenedor más simple y solo acepta un archivo de configuración. Un ApplicationContext es el contenedor Spring más avanzado y se usa en aplicaciones empresariales ya que acepta una gran variedad de archivos de configuración, tiene integración JNDI, integración EJB y admite la internacionalización de mensajes.

Espero que eso ayude.

Para evitar confusiones, debemos entender que la definición de configuración y la definición de bean son dos cosas diferentes . Hay tres formas de definir la configuración, disponibles en Spring 4 por defecto:

  • configuración basada en xml , cuando describe la configuración en un archivo xml;
  • configuración basada en java , cuando la configuración es de clase Java, marcada con anotaciones específicas;
  • configuración basada en groovy , cuando la configuración es un archivo con código Groovy;

Y hay dos formas de agregar definición de bean a la aplicación:

  • Configuración dentro de la definición de bean, cuando se agregan beans manualmente por declaración en la configuración correcta.

    En este caso la definición se basará en el tipo de configuración. Para xml-config será la etiqueta <bean/> , para la configuración basada en java - método con anotación @Bean y beans {...} construcción para Groovy.

  • definición de bean basada en anotación , cuando se marcan las clases de bean con anotaciones específicas (como @Component , @Service , @Controller , etc.). Este tipo de configuración utiliza la exploración de classpath .

    En este caso, debe especificar la directiva para explorar classpath. Para xml-config será <context:component-scan base-package="..."/> , para java-config - @ComponentScan anotación, para ctx.''component-scan''(...) Groovy ctx.''component-scan''(...) .

Como puede ver, puede usar configuraciones y definiciones de beans en diferentes combinaciones.

Tenga en cuenta que si utiliza una configuración basada en xml, puede elegir un método para impulsar la inyección de dependencias: manualmente en xml, o mediante anotaciones ( @Autowire , @Required , etc.). En el último caso, debe definir <context:annotation-config/> . Pero no hay que confundir definición de frijol y control de inyección de dependencia.

Ahora, en base a este punto de vista, intentemos responder sus preguntas:

¿Por qué la (así llamada) configuración basada en anotación utiliza ClassPathXmlApplicationContext pero no AnnotationConfigApplicationContext arriba?

El autor del libro mezcla conceptos. En realidad, esta es una configuración basada en XML con una definición de bean basada en anotación.

La configuración basada en Java que se explica en el libro parece ser lo que debería llamarse Configuración basada en anotación.

Tienes razón: la configuración basada en Java realmente utiliza activamente las anotaciones, y podría llamarse basada en la anotación. Pero la anotación es una parte de Java. Además, este es un término tradicional, especificado en la documentación .

¿De cuántas formas hay para configurar Spring framework?

Entonces, de manera predeterminada, tenemos tres formas de describir la configuración y dos formas de definir beans. Eso da vuelta a seis formas de configurar Spring Framework (por defecto). Pero, por supuesto, todas estas formas pueden usarse en combinación unas con otras.