1. Inyección de dependencia (DI)
La inyección de dependencia suena muy profunda, pero de hecho es: asignar valores a los atributos. Hay dos métodos en total. El primero es en forma de parámetros del constructor, y el otro está en forma de método de configuración.
1 inyección de constructor
1 inyección usando el constructor
Método de inyección usando XML
A. Orden de parámetros
<constructor-arg index = "0"> <value> zhang san </alue> </ constructor-arg>
<constructor-arg index = "1"> <value> 56 </value> </ constructor-arg>
B. Tipo de parámetro
<constructor-arg type = "java.lang.integer"> <value> 56 </value> </ constructor-arg>
<constructor-arg type = "java.lang.string"> <value> zhang san </value> </constructor-arg>
Ejemplos específicos
Si desea inyectar parámetros en una clase de persona ahora, el estudiante es otra clase.
Persona de clase pública {private String PID; nombre de cadena privada; estudiante privado; Persona pública (String PID, estudiante de estudiante) {this.pid = pid; this.student = estudiante; } Public Person (String pid, name de cadena) {this.pid = pid; this.name = name; }}Configurar ApplicationContext.xml. Si no se realiza una configuración de parámetros, se informará un error y el constructor correspondiente no se puede encontrar. Si los parámetros correspondientes están configurados, el constructor correspondiente debe declararse en la clase.
<? 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" "" "" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"> <bean id = "persona"> <! de un constructor en la clase persona es la marca de ángulo del parámetro. El valor de tipo del parámetro. Si es una propiedad básica, use esta referencia de asignación para consultar el tipo de asignación-> <constructor-arg index = "0" type = "java.lang.string" valor = "aaa"> </ constructor-arg> <constructor-arg index = "1" ref = "estudiante"> </structor-arg> </ beon> <bean id = "persona1"> <product name "PiD" PiD "" PiD " value = "1"> </property> </reme> <bean id = "estudiante"> </le bean> </les>
Escriba la clase de prueba DIXMLConstructortest y realice la depuración del punto de interrupción. Encontrará que de acuerdo con los parámetros de configuración, el constructor ingresado es persona (String PID, estudiante de estudiante)
public class dixmlConstructortest {@Test public void test1 () {applicationContext context = new ClassPathXMLApPlicationContext ("ApplicationContext.xml"); Persona persona = (persona) context.getBean ("persona"); }}2 inyección utilizando el método de establecimiento de propiedades
Método de inyección usando XML:
A. Inyección de frijoles simples Los frijoles simples incluyen dos tipos: tipo de embalaje y cadena
<bean id = "Personservice"> <!-Tipo básico, Tipo de cadena-> <Property Name = "Age" Value = "20"> </Property> <Property Name = "Name" Value = "Zhang Wuji"> </Property> </Bean>
B. Cita otros frijoles
<bean id = "persona" /> <bean id = "Personservice"> <Property Name = "Person" Ref = "Person" /> < /Bean>
1.1 Colección de la lista de ensamblaje
<Property name = "Lists"> <list> <value> list1 </value> <value> list2 </value> <ref bean = "persona"/> </list> </property>
1.2 colección de conjuntos de ensamblaje
<Property name = "sets"> <set> <value> list1 </value> <value> list2 </valor> <ref bean = "persona"/> </set> </property>
1.3 Mapa de ensamblaje
<Property Name = "Maps"> <Map> <Entrada Key = "01"> <valor> MAP01 </value> </entry> <Entrada Key = "02"> <valor> MAP02 </value> </etning> </s map> </propers>
El valor de <ing entry> en el mapa es el mismo que el de <ist> y <set>, que puede hacer cualquier elemento de atributo válido. Cabe señalar que el valor clave debe ser cadena.
1.4 Propiedades de ensamblaje
<Property Name = "Props"> <Props> <Prop Key = "01"> PROP1 </PR> <PROP KEY = "02"> PROP2 </prop> </props> </property>
Ejemplos específicos
1. Cree dos objetos persona y estudiante
paquete xgp.spring.demo; import java.util.list; import java.util.map; import java.util.properties; import java.util.set; Public Class Person {private String pid; nombre de cadena privada; estudiante privado; listas de listas privadas; Conjuntos privados; mapa de mapa privado; Propiedades de propiedades privadas; objeto privado [] objetos; persona public () {System.out.println ("nueva persona"); } // omitir métodos getter y setter} paquete xgp.spring.demo; public class Student {public student () {System.out.println ("nuevo estudiante"); } public void Says () {System.out.println ("estudiante"); }}Configurar el archivo ApplicationContext.xml
<? 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" "" "" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"> <!-Poner la persona y el alumno en el contenedor de primavera de la propiedad utilizada para describir el valor de la propiedad de la clase de la persona es una propiedad general es un valor. Si la propiedad es un tipo de referencia, use ref para asignar valor-> <bean id = "persona" init-method = "init" lazy-init = "true"> <propiedad name = "pid" value = "1"> </property> <Property name = "name" value "wang ermazi"> </spertity <property name = "estudiante" ref = "estudiante"> </propiedad> <propiéSe name = "lists"> <sale list1 <sal value1 <sale Name1 </value1 </////list. <valor> list2 </value> <ref bean = "Student"/> </propiety> <Property Name = "Sets"> <set> <value> set1 </value> <value> set2 </value> <ref Bean = "Student"/> </set> </Property> <Property Name = "Map"> <Map> <Key de entrada = "Entrada1"> <Valor> Map1 </value> <//valor> <Entrada de la entrada = " Bean = "Student"/> </Entry> </pperty </Property> <Property Name = "Propiedades"> <Props> <!-No se requiere un tipo de referencia requerido-> <proping key = "prop1"> prop1 </prop> <prop2 "prop2"> prop2 </prop> </props> </propial> <property name = "objetos"> <List> <list> </bean> <bean id = "student"> </bean> </beans>
Escribe una clase de prueba DixmlSetterTest
package xgp.spring.test;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import xgp.spring.demo.Person;public class DIXMLSetterTest { /** * What does spring container do: * 1. ¿Qué hace el contenedor de primavera? (1) Inicie el contenedor de primavera* (2) Cree un objeto para los dos frijoles de persona y alumno* (3) Analice el atributo de nombre de la propiedad, emplome el método setter, analice el valor* atributos de la propiedad de la propiedad, pase los parámetros al método Setter y use la tecnología de reflexión para asignar valores al objeto. * (4) Extraiga el objeto del contenedor de resorte y llame al método del objeto. * 2. ¿Cuál es la orden de ejecución de los contenedores de resorte? */ @Test public void test1 () {applicationContext context = new ClassPathXMLApPlicationContext ("ApplicationContext.xml"); Persona persona = (persona) context.getBean ("persona"); System.out.println (persona.getpid ()); System.out.println (persona.getName ()); System.out.println (persona.getLists ()); System.out.println (persona.getSets ()); System.out.println (persona.getmap ()); System.out.println (persona.getObjects (). Longitud); }}/*1 Wang Wu [List1, List2, xgp.spring.demo.student@76a9b9c] [set1, set2, xgp.spring.demo.student@76a9b9c] {entry1 = map1, entry2 = MAP2} 2*/ La orden de ejecución de los contenedores de primavera
1. Todos son configuraciones predeterminadas
2. Establezca estudiante (Lazy-Init = True)
3. Establecer persona (Lazy-Init = True)
Resumir
Hay dos métodos para inyectar parámetros. El constructor debe escribir el constructor correspondiente, el setter debe generar el método establecido correspondiente y se escribe el constructor predeterminado.
2.5 La importancia de COI y DI
Después de aprenderlos, ¿cuál es el significado de descubrirlo? Escribamos un ejemplo de un sistema de gestión de documentos para ilustrar los requisitos. Ver la figura a continuación
1. Escribir interfaz de documento
Documento de interfaz pública {public void read (); Public void write ();}2. Escribir clases de implementación WordDocument, ExcelDocument, PDFDocument
Public Class WordDocument Documents {public void read () {System.out.println ("Word Read"); } public void write () {System.out.println ("Word Write"); }}3. Escribe un sistema de documentos.
Public Class DocumentManager {Documento privado Documento; public void setDocument (documento de documento) {this.document = document; } public documentManager () {} public DocumentManager (documento de documento) {super (); this.document = document; } public void read () {this.document.read (); } public void write () {this.document.write (); }}4. Escribe una clase de documento de clase de prueba
/*** Usando IOC y DI, puede lograr una programación completa orientada a la interfaz** /public class DocumentTest { /*** Document Document = New WordDocument (); * Esta línea de código no es una programación completamente orientada a la interfaz, porque una clase específica aparece en el lado derecho del signo igual*/ @test public void testDocument_NoSpring () {document Document = new WordDocument (); DocumentManager DocumentManager = new DocumentManager (documento); documentManager.read (); documentManager.write (); } /*** En el lado del código, no sé quién implementa el documento. Esto está determinado por el archivo de configuración de Spring * <bean id = "documentManager"> <!-El documento es una interfaz-> <propiedad name = "document"> <!-WordDocument es una clase de implementación, asignada a la interfaz del documento-> <ref bean = "pdfDocument"/> </property> </bean> */@test public boid testDocument_spring () {apelationconteteNtextExtExtExtExtExtExtExtExtExtExtExtExtExtExtExtExtExt. ClasspathxmLapplicationContext ("ApplicationContext.xml"); DocumentManager documentManager = (documentManager) context.getBean ("DocumentManager"); documentManager.read (); documentManager.write (); }}De lo anterior, podemos ver la diferencia entre no aplicar la primavera y la aplicación de la primavera
< <propiedad name = "document"> <!-WordDocument es una clase de implementación, asignada a la interfaz del documento-> <ref Bean = "PDFDocument"/> </Property> </Bean>
El uso de Spring solo requiere la configuración del objeto <ref bean = ""> correspondiente en la aplicación de la aplicación, sin prestar atención a las clases de implementación específicas e implementar una programación completa orientada a la interfaz. Es por eso que Spring puede integrarse con tantas herramientas.
Structs2 de simulación de instancia de 2.6 MVC2
Descripción del requisito
Crear un directorio de proyecto
codificación:
1. Cree una capa DAO para establecer una interfaz PERSONDAOO e implementar una clase PERSONDAOMPL
Interfaz pública PERSONDAOO {public void savePerson ();} public class PersondaoImpl implementa Personondao {@Override public void Saveperson () {System.out.println ("Save Person"); }}2. Establezca una capa de servicio, interfaz de servicio Personas y clase de implementación de personas con servicio de personas
interfaz pública Personservice {public void savePerson ();} public class PersonserviceImpl implementa el servicio de personas {PERSONDAUNA PERSONDAUNDAUNDAUNA; public void setPersondao (PERSONDAOO PERSONDARA) {this.persondao = perseDaoo; } @Override public void saveperson () {this.persondao.saveperson (); }}3. Crear acción, clase de personaje
CLASE PÚBLICA PersonAction {Personas privadas de servicio Personas; public void setPersonService (Personservice Personservice) {this.personService = Personservice; } public void saveperson () {this.personService.saveperson (); }}4. Configurar ApplicationContext.xml
<
5. Escribir clase de prueba TestMvc
clase pública mvctest {@Test public void testMvc () {applicationContext context = new ClassPathXMLApPlicationContext ("ApplicationContext.xml"); PersonAction PersonAction = (PersonAction) context.getBean ("PersonAction"); PersonAction.SavePerson (); // Save Person}}El ejemplo anterior muestra claramente la programación orientada a la interfaz de Spring. La capa de servicio solo necesita llamar a la interfaz de la capa DAO, pero no necesita prestar atención a la clase de implementación de la capa DAO, y la acción solo necesita llamar a la interfaz del servicio, pero no necesita prestar atención a la clase de implementación del servicio.
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.