En primer lugar, para aprender a inyectar frijoles en primavera, primero debe comprender qué es la inyección de dependencia. La inyección de dependencia se refiere a: deja que la clase de llamadas inyecte la dependencia de la clase de implementación de la clase de implementación de una determinada interfaz sea inyectado por un tercero para eliminar la dependencia de la clase de llamadas de la clase de implementación de una interfaz determinada.
Los métodos de inyección de dependencia apoyados en contenedores de resorte incluyen principalmente inyección de propiedad, inyección de constructor e inyección del método de fábrica. A continuación, presentaremos estos tres métodos de inyección de dependencia y sus métodos de configuración específicos en detalle.
1. Inyección de atributos
La inyección de atributos significa inyectar el valor de atributo o el objeto dependiente del bean a través del método setxxx (). Dado que el método de inyección de atributos es selectivo y flexible, también es el método de inyección más utilizado en el desarrollo real.
Spring primero llamará al constructor predeterminado del bean para instanciar el objeto Bean y luego llamará al método Establecer a través del método reflejado para inyectar el valor de la propiedad.
La inyección de la propiedad requiere que el Bean proporcione un constructor predeterminado y debe proporcionar un método establecido para las propiedades que deben inyectarse.
Consejos: el llamado constructor predeterminado, es decir, un constructor sin parámetros. Si no hay un constructor personalizado en la clase, el sistema (JVM) generará automáticamente un constructor predeterminado sin parámetros. Si el constructor con parámetros se personaliza explícitamente en la clase, el sistema no generará automáticamente el constructor predeterminado y debe agregar manualmente un constructor sin parámetros.
El siguiente es un ejemplo para demostrar el método de inyección de propiedad de los frijoles en primavera:
Escribe una clase de usuario:
paquete com.kevin.bean;/** * Crear un método de inyección de propiedad de prueba de clase de clase * @Author Kevin * */Public Class User {private String UserName; public String getUsername () {return UserName; } public void setUsername (String UserName) {this.Username = username; }}Archivo de configuración:
<? xml versión = "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/scoans/spring-ste http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-definiciones de bean aquí-> <!-objeto de configuración-> <bean id =" user "> <name de propiedad =" name de la propiedad "> <<son value> </frijoles>
Entre ellos, cada valor de propiedad corresponde a una etiqueta de propiedad, y el valor de la propiedad del nombre es el nombre de la propiedad en la clase. En la clase de implementación de Bean, tiene el método de implementación correspondiente setUsername ().
Consejos: Spring solo verificará si el frijol contiene un método Setter y no hace requisitos específicos para si existen variables de atributo correspondientes. Sin embargo, de acuerdo con las reglas convencionales, debemos establecer las variables de atributo correspondientes para ello.
Especificaciones de nombres para <Property> Etiquetas en primavera:
En términos generales, los nombres de variables de atributos Java comienzan con letras minúsculas, pero teniendo en cuenta algunas abreviaturas inglesas con significados especiales, los granos Java también permiten nombres de variables que comienzan con letras mayúsculas. Pero los siguientes dos puntos deben ser cumplidos:
Para los métodos de inyección de atributos, las garantías solo se pueden proporcionar en el archivo de configuración artificialmente, pero las garantías no se pueden proporcionar a nivel de sintaxis. En este momento, debe usar la inyección de constructor para cumplir mejor los requisitos.
2. Inyección del constructor
La inyección del constructor es otro método de inyección de uso común además de la inyección de atributos. Puede garantizar que algunas propiedades necesarias se establezcan cuando los frijoles están instanciados y se pueden usar después de la instancia.
El requisito previo para usar inyección de constructor es que el bean debe proporcionar un constructor con argumentos.
Para la inyección de constructor, los archivos de configuración se pueden usar de las siguientes maneras:
【Método de entrada de parámetros de coincidencia por tipo】
Escribir código de frijoles:
paquete com.kevin.bean;/** * Escribir la prueba de frijoles para que coincida con los parámetros por tipo * @author Kevin * */public class Person {private String Name; edad de entero privado; public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public Integer GetAge () {return Age; } public void setAge (edad entera) {this.age = edad; }}Escribir archivos de configuración:
<? xml versión = "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/scoans/spring-ste http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-definiciones de frijoles aquí-> <!-Objeto de configuración-> <bean id =" persona "> <constructor-arg type =" string " </constructor-arg> <constructor-arg type = "entero"> <value> 20 </value> </ constructor-arg> </beans>
Los archivos de configuración de Spring adoptan estrategias de configuración que son independientes del orden de las etiquetas de los elementos, por lo que la certeza de la información de configuración puede garantizarse hasta cierto punto.
Luego, cuando los parámetros de tipo múltiple del constructor en un frijol son los mismos, es fácil causar confusión al coincidir los parámetros de acuerdo con el tipo. En este momento, se necesita otro método: parámetros coincidentes según el índice.
【Parámetros de coincidencia según el índice】
Escribir código de frijoles:
paquete com.kevin.bean;/** * Escribir pruebas y parámetros de frijoles en el método de índice * @author Kevin * */public class Student {private String Name; género de cadena privada; puntaje doble privado; estudiante público (nombre de cadena, género de cadena, doble puntaje) {super (); this.name = name; this.gender = género; this.score = stork; }}El archivo de configuración se escribe de la siguiente manera:
<? xml versión = "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/scoans/spring-ste http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Definiciones de bean aquí-> <!-Objeto de configuración-> <bean id =" estudiante "> <constructor-arg index =" 0 " value = "Kevin"> </constructor-arg> <constructor-arg index = "1" value = "masculino"> </ constructor-arg> <constructor-arg index = "2" value = "66"> </ constructor-arg> </ bean> </ beans>
Consejos: durante la inyección de propiedades, Spring determina el atributo de configuración y el método Setter correspondiente de acuerdo con las especificaciones de Java Bean, y utiliza el mecanismo de reflexión de Java para llamar al método Setter del atributo para completar la inyección de propiedad. Sin embargo, el mecanismo de reflexión de Java no recuerda el nombre del parámetro del constructor, por lo que no podemos configurar el constructor formulando el nombre del parámetro del constructor, por lo que solo podemos completar indirectamente la inyección de propiedad del constructor a través del tipo de parámetro y el índice.
【Tipo de uso combinado y parámetros de coincidencia de índice】
En algunos archivos de configuración complejos, el tipo y el índice deben usarse simultáneamente para completar la inyección de parámetros del constructor. Aquí hay un ejemplo para demostrar.
Escribe frijoles:
paquete com.kevin.bean;/** * Escribir pruebas de frijoles para usar los parámetros de coincidencia de tipo e índice * @author Kevin * */public class maestro {private String Name; dirección de cadena privada; salario doble privado; edad privada int; profesor público (nombre de cadena, dirección de cadena, salario doble) {super (); this.name = name; this.address = dirección; this.salary = salario; } profesor público (nombre de cadena, dirección de cadena, int age) {super (); this.name = name; this.address = dirección; this.age = edad; }}En esta clase, hay dos constructores sobrecargados, y todos tienen tres parámetros. En este caso, el uso de los métodos de tipo e índice no puede completar los requisitos. En este momento, ambas propiedades deben usarse al mismo tiempo.
Archivo de configuración:
<? xml versión = "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/scoans/spring-ste http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-definiciones de bean aquí-> <!-Objeto de configuración-> <bean id =" maestro "> <constructor-arg índice =" 0 "type" string " <value> Kevin </value> </structor-arg> <constructor-arg index = "1" type = "string"> <alon valor> China </value> </structor-arg> <constructor-arg index = "2" type = "int"> <valor> 20 </value> </ constructor-arg> </ behor> </arrones>
Puede ver que el enfoque está realmente en el tipo del tercer parámetro, por lo que especificamos el índice y el tipo en el archivo de configuración, para que Spring pueda saber qué constructor inyectar el parámetro.
Consejos: Agregue a nuestro archivo de configuración, hay un problema de ambigüedad. El contenedor de primavera se puede iniciar normalmente y no informará un error. Usará aleatoriamente un constructor coincidente para instanciar el bean. El usuario puede no necesitar el constructor seleccionado al azar, por lo que debemos tener cuidado de evitar esta ambigüedad al programar.
【Parámetros de coincidencia a través de su propio tipo de reflexión】
Si el tipo del parámetro del constructor de frijoles es discernible, ya que el mecanismo de reflexión de Java puede obtener el tipo de parámetro del constructor, incluso si la inyección del constructor no proporciona información de tipo e índice, Spring aún puede completar la inyección de información del constructor. Por ejemplo, en el siguiente ejemplo, se puede distinguir el tipo de parámetro del constructor de la clase Administrador.
Clase de gerente de escritura:
paquete com.kevin.bean;/** * Escriba una prueba de frijoles para que coincida con los argumentos a través de su propio tipo de reflexión * @author Kevin * */public class Manager {Nombre de cadena privada; salario doble privado; persona privada; Public Manager (nombre de cadena, salario doble, persona persona) {super (); this.name = name; this.salary = salario; this.person = persona; }}Escribir archivos de configuración:
<? xml versión = "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/scoans/spring-ste http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Definiciones de bean aquí-> <!-Objeto de configuración-> <bean id =" gerente "> <ronstructor-arg> </value <value> </constructor-arg> <constructor-arg> <ref bean = "user"/> </ constructor-arg> <constructor-arg> <ref bean = "persona"/> </ constructor-arg> </reras>
Los métodos anteriores pueden implementar la inyección de parámetros del constructor, pero para evitar la ocurrencia de problemas, se recomienda utilizar el índice y el tipo explícito para configurar la información de entrada de parámetros del constructor.
3. Inyección de método de fábrica
El método de fábrica es un patrón de diseño que a menudo se usa en aplicaciones y también es el método principal para implementar la idea de inversión de control y diseño de una sola instancia. La clase de fábrica es responsable de crear una o más instancias de clase de fábrica. El método de clase de fábrica generalmente devuelve la instancia de clase de destino en forma de interfaz o variable de clase abstracta.
La clase de fábrica bloquea los pasos de instancia de la clase de destino externamente, y la persona que llama ni siquiera tiene que especificar cuál es la clase de destino específica. Debido a que los contenedores de primavera proporcionan la funcionalidad de los métodos de fábrica en los métodos de marco y están abiertos a los desarrolladores de manera transparente. Por lo tanto, rara vez es necesario escribir métodos de ingeniería manualmente. Sin embargo, los métodos de ingeniería aún se encontrarán en algunos sistemas heredados o biblioteca de terceros. En este momento, el método de inyección de fábrica de primavera se puede usar para inyectar resorte.
Los métodos de inyección de fábrica de primavera se pueden dividir en estática y no estática.
【Método de fábrica no estática】
Algunos métodos de fábrica no son estatales y deben instanciarse antes de que se puedan llamar métodos de fábrica. El siguiente es un ejemplo para demostrar.
Escribir clase de fábrica:
paquete com.kevin.factorybean;/** * Escribir pruebas de clase de fábrica inyección de método de fábrica no estática * @author Kevin * */public class BookFactory {public Book Buybook () {book book = new Book (); book.setName ("Piense en Java"); libro de regreso; }}Escritura de archivos de configuración:
<? xml versión = "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/scoans/spring-ste http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Bean Definiciones aquí-> <!-Objeto de configuración-> <bean id =" bookfactory "> <///<///</" bean id = "" FECNES Factory-Method = "Buybook"> </rano> </reras>
Dado que el método de fábrica de BookFactory no es estático, primero debe definir un frijol de la clase de fábrica y luego referirse a la instancia de fábrica de frijoles a través de la propiedad de fábrica. Luego, el método de fábrica correspondiente se usa para especificar el método de fábrica correspondiente.
【Método de fábrica estática】
Muchos métodos de clase de fábrica son estáticos, lo que significa que los métodos de clase de fábrica pueden llamarse sin crear instancias de clase de fábrica. Por lo tanto, los métodos de ingeniería estática son más convenientes y concisos que los métodos de fábrica no estáticos. El siguiente es un ejemplo para demostrar el método de fábrica estática.
Escribir clase de fábrica:
paquete com.kevin.factorybean;/** * Escribir la clase de clase de fábrica Inyección del método de fábrica estática * @author Kevin * */public class CarFactory {public static Car createCar () {Car car = new Car (); Car.SetBrand ("Lamborghini"); coche de regreso; }}Escribir archivos de configuración:
<? xml versión = "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/scoans/spring-ste http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-definiciones de bean aquí-> <!-objeto de configuración-> <bean id =" car "factory-method-method =" createCar "
Resumir
Spring proporciona tres métodos de inyección opcionales, pero en las aplicaciones reales, no hay un estándar unificado para qué método de inyección debemos elegir. Aquí hay algunas razones para referirse a:
Razón de la inyección del constructor:
Propiedades Razón de inyección:
De hecho, Spring nos proporciona tantos métodos para inyectar parámetros, por lo que estos métodos deben tener sus propios razones. Cada método tiene ventajas únicas en un determinado tema. Solo necesitamos elegir el método apropiado de acuerdo con nuestras necesidades de uso específicas, pero la inyección del método de fábrica generalmente no se recomienda.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.