Recientemente, compré este libro introductorio de primavera: SpringInaction. Navegué más o menos y me sentí bastante bien. Solo un poco de comenzar. Los libros de Manning siguen siendo buenos. Aunque no me concentro en Manning como aquellos que solo leen libros de Manning, lo leo con reverencia y pasión. Una vez más, acepté los conceptos centrales de primavera como el COI, DI y AOP. Déjame hablar sobre mi opinión sobre IOC y DI primero.
COI (DI): De hecho, el concepto de la arquitectura de primavera central no es tan complicado, y no es tan oscuro como se describe en algunos libros. Todos los programadores de Java saben que cada lógica comercial en un programa Java requiere al menos dos o más objetos para colaborar. En general, cuando cada objeto usa su objeto de socio, debe usar una sintaxis como NewObject () para completar el trabajo de aplicación del objeto de socio. Encontrará que el acoplamiento entre objetos es alto. La idea del COI es: contenedores de primavera para realizar la creación y coordinación de estos objetos interdependientes. Los objetos solo necesitan tener una lógica de negocios en relación en sí. En este sentido, la responsabilidad de cómo un objeto obtiene su objeto de colaboración se invierte (COI, DI).
Esta es mi experiencia del COI de la primavera. Di es en realidad otra forma de decir COI. Di fue propuesto por primera vez por Martin Fowler en un artículo a principios de 2004. Concluyó: ¿Cuál es el control invertido? Es decir: la forma de obtener objetos dependientes se invierte.
Si aún no comprende este concepto central: aquí citamos una respuesta simple y fácil de entender que se encuentra en un blog llamado Bromon:
IOC y DI
Primero, quiero hablar sobre el COI (inversión de control, inversión de control). Este es el núcleo de la primavera, en todo momento. Para el marco de primavera, Spring es responsable de controlar el ciclo de vida de un objeto y la relación entre los objetos. ¿Qué quiere decir esto? Para dar un ejemplo simple, ¿cómo encontramos una novia? Una situación común es que vamos a todas partes para ver dónde tenemos mujeres hermosas y atractivas, y luego preguntamos sobre sus intereses, números de QQ, números de teléfono, números de IP, números de coeficiente intelectual ..., encontrar formas de conocerlas, darles lo que les gusta, y luego ... este proceso es complejo y profundo, y debemos diseñar y enfrentar cada enlace nosotros mismos. Lo mismo es cierto para el desarrollo tradicional del programa. En un objeto, si desea usar otro objeto, debe obtenerlo (nuevo solo o consultar uno de JNDI). Después de su uso, el objeto debe ser destruido (como la conexión, etc.), y el objeto siempre se combinará con otras interfaces o clases.
Entonces, ¿cómo lo hace el COI? Es un poco como encontrar una novia a través de una agencia matrimonial e presentar un tercero entre mi novia y yo: una agencia matrimonial. La agencia matrimonial administra mucha información sobre hombres y mujeres. Puedo proporcionar una lista a la agencia matrimonial y decirle qué tipo de novia quiero encontrar, como parecerme a Michelle Reis, tener una figura como Lin Xilei, cantar como Jay Chou, tener una velocidad como Carlos y tener una tecnología como Zidane. Luego, la agencia matrimonial proporcionará un MM de acuerdo con nuestros requisitos. Solo necesitamos enamorarnos y casarnos. Es simple y claro. Si los candidatos que nos dan no cumplen con los requisitos, lanzaremos una excepción. Todo el proceso ya no está controlado por mí, pero está controlado por una institución similar a un contenedor como una agencia matrimonial. Este es el método de desarrollo defendido por Spring. Todas las clases se registrarán en el contenedor de primavera para decirle a Spring lo que es y lo que necesita. Entonces Spring le dará lo que desea cuando el sistema se ejecute al nivel apropiado y, al mismo tiempo, le entregue otras cosas que lo necesitan. Todas las clases son creadas y destruidas por la primavera, lo que significa que el objeto que controla el ciclo de vida de un objeto ya no es el objeto que lo hace referencia, sino que resorte. Para un objeto específico, solía controlar otros objetos, pero ahora todos los objetos están controlados por el resorte, por lo que esto se llama inversión de control.
Uno de los puntos clave del COI es proporcionar dinámicamente un objeto con otros objetos que necesita durante la operación del sistema. Esto se logra a través de DI (dependencia de inyección). Por ejemplo, el objeto A necesita operar la base de datos. En el pasado, siempre escribimos código en A para obtener un objeto de conexión. Con Spring, solo necesitamos decirle a Spring que se necesita una conexión en A. En cuanto a cómo construir esta conexión y cuándo construirla, A no necesita saberlo. Cuando el sistema se está ejecutando, Spring creará una conexión en el momento apropiado y luego la inyectará en una inyección similar, completando así el control de la relación entre cada objeto. Una necesidad de confiar en la conexión para ejecutarse normalmente, y esta conexión se inyecta en A por primavera, y el nombre de la inyección de dependencia proviene de esto. Entonces, ¿cómo se implementa DI? Una característica importante después de Java 1.3 es la reflexión, que permite que el programa genere dinámicamente objetos, ejecute métodos de objetos y cambie las propiedades de los objetos al ejecutar. La primavera se inyecta a través de la reflexión. Para obtener información relacionada sobre la reflexión, consulte Javadoc.
Después de comprender los conceptos de COI y DI, todo se volverá simple y claro, y el resto del trabajo es solo acumular bloques en el marco de la primavera.
Aprendamos cómo funciona la primavera.
public static void main (String [] args) {ApplicationContext context = new FilesystemXMLApPlicationContext ("ApplicationContext.xml"); Animal animal = (animal) context.getBean ("animal"); animal.say (); }Debe estar familiarizado con este código, pero analicémoslo. Primero, ApplicationContext.xml
<bean id = "animal"> <propiedad name = "name" value = "kitty" /> < /bean>
Tiene una clase phz.springframework.test.cat
public class Cat implementa animal {name de cadena privada; public void Says () {System.out.println ("I Am" + Name + "!");} public void setName (name de cadena) {this.name = name;}}Implementó la interfaz phz.springframework.test.animal
Public Interface Animal {public void Says (); }Obviamente, el código anterior sale de IAMKITTY!
Entonces, ¿cómo lo hace la primavera?
A continuación, ¡escribamos una primavera para ver cómo funciona la primavera!
Primero, definimos una clase de frijoles, que se utiliza para almacenar propiedades propiedad de un frijol
/ * ID de bean */ ID de cadena privada; / * Clase Bean */ Tipo de cadena privada; / * Propiedad de bean */ private map <string, object> propiedades = new HashMap <String, Object> ();
Un frijol incluye ID, tipo y propiedades.
La próxima primavera comienza a cargar nuestro archivo de configuración y guarda la información de configuración en un hashmap. La clave de HashMap es la identificación del bean y el valor de HasMap es el frijol. Solo de esta manera podemos obtener la clase animal a través del método context.getBean ("animal"). Todos sabemos que Spirng puede inyectar tipos básicos y puede inyectar tipos como List and Map. A continuación, tomemos el mapa como ejemplo para ver cómo se guarda la primavera
La configuración del mapa puede ser como la siguiente
<bean id = "test"> <Property name = "testMap"> <Map> <Entry Key = "A"> <value> 1 </value> </etning> <Entrada Key = "B"> <valor> 2 </valor> </entry> </s map> </propers> </ bean>
¿Cómo guarda Spring la configuración anterior? El código es el siguiente:
if (beanProperty.Element ("map")! = null) {map <string, object> PropertiesMap = new HashMap <String, Object> (); Element PropertiesListMap = (Element) BeanProperty.Elements (). Get (0); Iterator <?> PropertiesIterator = PropertiesListMap.Elements (). Iterator (); while (PropertiesIterator.hasNext ()) {Element Vet = (Element) PropertIiesIterator.Next (); if (vet.getName (). Equals ("Entry")) {String Key = Vet.AttributeValue ("Key"); Iterator <?> ValuesIterator = vet.elements (). Iterator (); while (valueIterator.hasNext ()) {element value = (element) valueIterator.next (); if (value.getName (). Equals ("Value")) {PropertiesMap.put (key, value.gettext ()); } if (value.getName (). Equals ("ref")) {PropertiesMap.put (Key, new String [] {value.AttributeValue ("Bean")}); }}}} bean.getProperties (). Put (Name, PropertiesMap); }A continuación, vamos a la parte central. Veamos cómo la primavera es la inyección de dependencia. De hecho, la idea de inyección de dependencia también es muy simple. Se implementa a través del mecanismo de reflexión. Al instancias de una clase, inyecta los atributos de clase almacenados en HashMap en la clase reflejando el método establecido en la clase. Veamos cómo se hace.
Primero instanciar una clase, como esta
Public static object NewInStance (String className) {class <?> cls = null; object obj = null; try {cls = class.forname (classname); obj = cls.newinstance ();} catch (classnotFoundException e) {tirar nueva runtimeexception (e);} Catch (instantiationException e) {drogar new runtimeee (e); (IlegalAccessException e) {tirar nueva runtimeException (e);} return obj;}Luego inyecta las dependencias de esta clase en ella, como esta
public static void setProperty (object obj, name de cadena, valor de cadena) {class <? extiende objeto> clazz = obj.getClass (); try {String MethodName = returnSetMThodName (name); Method [] ms = clazz.getMethods (); for (método m: ms) {if (m.getName (). Equals (MethodName)) {si (m. M. M. M.getParametertyPes (). M.GetParametertyPes () [0]; setFieldValue (ClazzParametType.getName (), valor, m, obj); ruptura;}}}}} Catch (SecurityException e) {Drote New RuntimeException (e);} Catch (ilegalArgumentException e) {droga NewTimeException (e);} Catch (ilegalAceCess E) RuntimeException (e);}}Finalmente, nos devuelve una instancia de esta clase y podemos usarla. Tomemos el mapa como ejemplo para ver cómo se hace. El código que escribí es crear un hashmap e inyectar el hashmap en la clase que necesita ser inyectado, como este
if (valor instanceof map) {iterator <?> EntryIterator = ((map <?,?>) valor) .EntrySet (). iterator (); Map <string, object> map = new HashMap <String, Object> (); while (entryIterator.hasNext ()) {Entry <?,?> EntryMap = (Entry <?,?>) EntryIterator.next (); if (EntryMap.getValue () instanciaf string []) {map.put ((string) EntryMap.getKey (), getBean (((String []) EntryMap.getValue ()) [0])); }} Beanprocesser.setProperty (obj, propiedad, map); }Ok, entonces podemos usar Spring para crear la clase para nosotros. ¿No es difícil? Por supuesto, la primavera puede hacer más que esto. Este programa de ejemplo solo proporciona parte de la función de inyección de dependencia más central de Spring.
Este artículo ha hecho referencia a una gran cantidad de artículos y no puede agradecerle uno por uno. Gracias aquí juntos. Pido disculpas por su infracción de derechos de autor. ¡Espero que sea útil para todos!
Resumir
Lo anterior es todo el contenido de este artículo sobre la explicación detallada de los principios del COI de primavera, y espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a este sitio:
Una breve comprensión del COI, AOP y ejemplos de código de Spring
Introducción detallada a la implementación de simulación del COI de Spring
Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!