¿Qué demonios son los frijoles de primavera?

Todavía tengo que encontrar una definición de alto nivel de frijoles Spring que pueda entender. Los veo referenciados a menudo en la documentación y los libros de Grails, pero creo que comprender lo que son sería beneficioso. Entonces, ¿qué son los frijoles de primavera? ¿Cómo se pueden usar? ¿Tienen algo que ver con la inyección de dependencia?

Los objetos que forman la columna vertebral de su aplicación y que son administrados por el contenedor Spring IoC * se denominan beans. Un bean es un objeto que se crea una instancia, se ensambla y, de lo contrario, se administra mediante un contenedor Spring IoC. Estos beans se crean con los metadatos de configuración que proporciona al contenedor, por ejemplo, en forma de <bean/>definiciones XML .

Más para aprender sobre los frijoles y el alcance de SpringSource :

Cuando crea una definición de bean, lo que realmente está creando es una receta para crear instancias reales de la clase definida por esa definición de bean. La idea de que una definición de bean es una receta es importante, porque significa que, al igual que una clase, puede tener muchas instancias de objetos creadas a partir de una sola receta.

Puede controlar no solo las diversas dependencias y valores de configuración que se deben conectar a un objeto creado a partir de una definición de bean particular, sino también el alcance de los objetos creados a partir de una definición de bean particular. Este enfoque es muy poderoso y le brinda la flexibilidad de elegir el alcance de los objetos que crea a través de la configuración en lugar de tener que 'hornear' el alcance de un objeto a nivel de clase Java. Los frijoles se pueden definir para implementarse en uno de varios ámbitos

* IoC: Inversión de control

Los beans Spring son solo objetos de instancia que son administrados por el contenedor Spring, es decir, son creados y conectados por el marco y se colocan en una "bolsa de objetos" (el contenedor) desde donde puede obtenerlos más tarde.

La parte del "cableado" es de lo que se trata la inyección de dependencia, lo que significa es que puedes decir "Necesitaré esto" y el marco seguirá algunas reglas para obtener la instancia adecuada.

Para alguien que no está acostumbrado a Spring, creo que el artículo de Wikipedia Spring tiene una buena descripción :

Central para Spring Framework es su contenedor de inversión de control, que proporciona un medio consistente de configurar y administrar objetos Java utilizando la reflexión. El contenedor es responsable de administrar los ciclos de vida de objetos de objetos específicos: crear estos objetos, llamar a sus métodos de inicialización y configurar estos objetos conectándolos entre sí.

Los objetos creados por el contenedor también se denominan objetos gestionados o beans . El contenedor se puede configurar cargando archivos XML o detectando anotaciones Java específicas en clases de configuración. Estas fuentes de datos contienen las definiciones de bean que proporcionan la información necesaria para crear los beans.

Los objetos se pueden obtener mediante la búsqueda de dependencias o la inyección de dependencias . La búsqueda de dependencia es un patrón en el que la persona que llama le pide al objeto contenedor un objeto con un nombre específico o de un tipo específico. La inyección de dependencia es un patrón en el que el contenedor pasa objetos por nombre a otros objetos, a través de constructores, propiedades o métodos de fábrica.

Primero déjanos entender Spring:

Spring es un marco ligero y flexible.

Analogía:

Bean: es un objeto que se crea, gestiona y destruye en Spring Container. Podemos inyectar un objeto en Spring Container a través de los metadatos (ya sea xml o anotación), que se llama inversión de control.

Analogía: supongamos que el agricultor tiene una tierra de cultivo que cultiva con semillas (o frijoles). Aquí, Farmer es Spring Framework, las tierras de cultivo son Spring Container, Beans son Spring Beans, Cultivar es Spring Processors.

Al igual que el ciclo de vida del frijol, los frijoles de primavera también tienen su propio ciclo de vida.

fuente img

La siguiente es la secuencia de un ciclo de vida del frijol en primavera:

• Instanciar: Primero, el contenedor Spring encuentra la definición del bean del archivo XML y crea una instancia del bean.

• Propiedades de relleno: mediante la inyección de dependencia, spring rellena todas las propiedades tal como se especifica en la definición del bean.

• Establecer nombre del bean: si el bean implementa la BeanNameAwareinterfaz, spring pasa la identificación del bean al setBeanName()método.

• Establecer fábrica de Bean: si Bean implementa la BeanFactoryAwareinterfaz, spring pasa la fábrica de bean al setBeanFactory()método.

• Preinicialización: también llamado proceso posterior del bean. Si hay algún BeanPostProcessors de bean asociado con el bean, Spring llama al postProcesserBeforeInitialization()método.

• Inicializar beans: si el bean se implementa IntializingBean, afterPropertySet()se llama a su método. Si el bean tiene declaración de método init, se llama al método de inicialización especificado.

• Post-Inicialización: - Si hay alguno BeanPostProcessorsasociado con el bean, se llamarán sus postProcessAfterInitialization()métodos.

• Listo para usar: ahora el bean está listo para usar por la aplicación

• Destruir: si el bean se implementa DisposableBean, llamará al destroy()método

Bueno, lo entendiste parcialmente. Debe adaptar los frijoles según sus necesidades e informar a Spring container para que lo administre cuando sea necesario, utilizando una metodología popularmente conocida como IoC ( Inversion of Control ) acuñada por Martin Fowler , también conocida como Dependency Injection (DI).

Conecta los beans de una manera, para que no tenga que ocuparse de la creación de instancias o evaluar cualquier dependencia en el bean. Esto se conoce popularmente como el Principio de Hollywood .

Google es la mejor herramienta para explorar más sobre esto además de los enlaces con los que se inundaría aquí en esta pregunta. :)

Spring tiene el contenedor IoC que lleva la bolsa de frijoles; La creación, el mantenimiento y la eliminación son responsabilidad de Spring Container. Podemos poner el bean en Spring mediante Wiring y Auto Wiring. El cableado significa que lo configuramos manualmente en el archivo XML y "Auto Wiring" significa que colocamos las anotaciones en el archivo Java y luego Spring escanea automáticamente el contexto raíz donde está el archivo de configuración de Java, lo crea y lo coloca en la bolsa de Spring.

Aquí está el URI detallado donde obtuviste más información sobre Beans

Los frijoles de primavera son clases. En lugar de crear una instancia de una clase (usando new), obtiene una instancia como beanconversión a su tipo de clase desde el contexto de la aplicación, donde el bean es lo que configuró en la configuración del contexto de la aplicación. De esta manera, toda la aplicación mantiene una instancia de alcance único en toda la aplicación. Todos los beans se inicializan siguiendo su orden de configuración justo después de que se instancia el contexto de la aplicación. Incluso si no obtiene ningún bean en su aplicación, todas las instancias de beans ya se crearon el momento después de que creó el contexto de la aplicación.

• Los beans de Spring son solo instancias de objetos que son administradas por el contenedor Spring IOC.

• Spring IOC container lleva la bolsa de frijoles. La creación, el mantenimiento y la eliminación de frijoles son responsabilidad de Spring Container.

• Podemos poner el bean en Spring mediante Wiring y Auto Wiring.

• El cableado significa que lo configuramos manualmente en el archivo XML.

• El cableado automático significa que colocamos las anotaciones en el archivo Java, luego Spring escanea automáticamente el contexto raíz donde está el archivo de configuración de Java, lo crea y lo coloca en la bolsa de Spring.

Un Bean es un POJO (Objeto Java antiguo simple), que es administrado por el contenedor de primavera.

Los contenedores Spring crean solo una instancia del bean por defecto. Este bean se almacena en la memoria caché, por lo que todas las solicitudes del bean devolverán una referencia compartida al mismo bean.

La anotación @Bean devuelve un objeto que Spring registra como un bean en el contexto de la aplicación. La lógica dentro del método es responsable de crear la instancia.

¿Cuándo usamos la anotación @Bean?

Cuando la configuración automática no es una opción. Por ejemplo, cuando queremos conectar componentes de una biblioteca de terceros, porque el código fuente no está disponible, por lo que no podemos anotar las clases con @Component.

Un escenario en tiempo real podría ser que alguien quiera conectarse al bucket de Amazon S3. Debido a que la fuente no está disponible, tendría que crear un @bean.

@Bean
public AmazonS3 awsS3Client() {
    BasicAWSCredentials awsCreds = new BasicAWSCredentials(awsKeyId, accessKey);
    return AmazonS3ClientBuilder.standard().withRegion(Regions.fromName(region))
            .withCredentials(new AWSStaticCredentialsProvider(awsCreds)).build();
}

Fuente del código anterior -> https://www.devglan.com/spring-mvc/aws-s3-java

Porque mencioné la anotación @Component arriba.

@Component Indica que una clase anotada es un "componente". Dichas clases se consideran candidatos para la detección automática cuando se utiliza la configuración basada en anotaciones y el escaneo de rutas de clase.

La anotación de componentes registra la clase como un solo bean.

En Spring, los objetos que forman la columna vertebral de su aplicación y que son administrados por el contenedor Spring IoC se denominan beans. Un bean es simplemente un objeto que se crea una instancia, se ensambla y se gestiona de otro modo mediante un contenedor Spring IoC;

¡Para la primavera, todos los objetos son frijoles! El paso fundamental en Spring Framework es definir sus objetos como beans. Los beans no son más que instancias de objetos que crearía el framework spring al observar sus definiciones de clase. Estas definiciones básicamente forman los metadatos de configuración. Luego, el marco crea un plan para el que los objetos deben instanciarse, las dependencias que deben establecerse e inyectarse, el alcance de la instancia recién creada, etc., en función de estos metadatos de configuración.

Los metadatos se pueden suministrar en un archivo XML simple, como en el primer capítulo. Alternativamente, uno podría proporcionar los metadatos como Anotación o Configuración de Java.

Libro: Just Spring

La configuración XML de Spring está compuesta por Beans y Beans son básicamente clases. Son solo POJOs que usamos dentro de nuestro ApplicationContext. Se puede considerar que Beans de definición reemplaza la palabra clave new. Entonces, donde sea que esté usando la palabra clave new en su aplicación, algo como:

MyRepository myRepository =new MyRepository ();

Cuando usa esa palabra clave nueva que está en algún lugar, puede buscar eliminar esa configuración y colocarla en un archivo XML. Entonces codificaremos así:

<bean name="myRepository " 
      class="com.demo.repository.MyRepository " />

Ahora podemos simplemente usar Setter Injection / Constructor Injection. Estoy usando Setter Injection.

public class MyServiceImpl implements MyService {
    private MyRepository myRepository;
    public void setMyRepository(MyRepository myRepository)
        {
    this.myRepository = myRepository ;
        }
public List<Customer> findAll() {
        return myRepository.findAll();
    }
}