Explicación detallada del principio del COI de implementación simple de la primavera

InversionOfControl (abreviado como COI)

En pocas palabras, cuando necesite un objeto, no necesita nuevo manualmente, pero otros contenedores le proporcionarán; La primavera es un contenedor de COI.

Por ejemplo:

En primavera, a menudo necesita ensamblar un DAO en el servicio y, en general, usar anotación de @autowired: similar a la siguiente

 ServiceImpl de clase pública {@autowired dao dao; public void getData () {dao.getData (); }

Si usa DAO directamente sin inicialización, se informará una excepción de puntero nulo. El método en primavera es cargar las clases requeridas para usted a través de la reflexión.

Aquí hay un ejemplo que simula DI y IOC de Spring

Primero escriba dos anotaciones para simular la primavera:

 La anotación de la entidad representa el @servicio @target (elementtype.type) de spring // class @Retention (retentionPolicy.runtime) public @interface entity {} representa el @autowrid @target (elementtype.field) de spring // @retention (retentionPolicy.runtime) del método // solo público @interface {} {}

Después de establecer la anotación, se crean dos clases:
La clase de lluvia representa la necesidad de obtener datos meteorológicos (base de datos o servidor) de otros lugares.

 Public Class Rain {public void Rain () {System.out.println ("Raining"); // Lo escribí directamente por conveniencia}}

La clase meteorológica representa los datos meteorológicos obtenidos

 @EntityPublic Clase Weather {@Resources Rain Rain; // Aquí viene la lluvia public void weather_rain () {Rain.rain (); }

La siguiente es la inyección directa a través de la reflexión:

Primero, itere a través del nombre del paquete especificado: este paso se omite primero.

Primero, cree una lista para simular el contenedor de frijol Spring, y luego se inicializarán todas las clases inicializadas con anotaciones de entidad.

 public class weather_reflect {list <sect> objectList; // Simule Spring Container public Weather_reflect () {ObjectList = New ArrayList <Sectus> ();} // De hecho, la mejor manera aquí es encontrar la clase con Annotaciones primero, juzgar las anotaciones de entidad y luego pasarlas en. lanza classNotFoundException, ilegalAccessException, instanticiationException, nosuchmethodexception, invocationTargetException {class <?> clazz = object.getClass (); if (clazz.isannotationPresent (entity.class)) {// juzga si tiene la variedad de anotaciones de entidad [] campos = Cields (Campo Field: Fields) {if (field.isannotationPresent (recursos.class)) {// juzga si class <?> RainClass = class.forname (field.gettype (). GetName (), false, thread.currentThread (). GetContextClassLoader ()); // First Load the Rain Class RainObjectList.Add (objeto); // Finalmente guarde el clima asignado en el contenedor}}}}} Lista pública <ject> returnList () {return ObjectList; // Devuelve el contenedor para uso futuro}

Finalmente, es simular el uso del controlador directamente

 Public Class WeatherPrediction {public static void main (string args []) lanza classnotFoundException, nosuchmethodexception, instanticiationException, ilegalAccessException, invocationTargetException {weatherPrediction weatherPrediction = new WeatherPrediction ();; Se informará una excepción de puntero nulo, y el contenedor asigna la variable de lluvia a ella, por lo que puede generar normalmente}/* simular el proceso de inicio de resorte. De hecho, puedes escribir una clase por separado. Este paso es lo que debe hacer el contenedor, y no necesitamos preocuparnos por ello*/Public Object SpringDo () lanza ClassNotFoundException, NosuchMethodException, InvocationTargetException, InstanciationException, ILEGALACSException {weather_reflect weather_reflect = new_reflect (); // Weathere Weather cuando comienza el clima (); ////////nalupado y luego el clima y luego el clima a la clase y luego el clima a la clase y el clima a la clase y luego el clima a la clasificación y el clima a la clase y luego el clima, y luego el clima, y luego el clima, y luego el clima, y el clima, y el clima. weather_reflect.get_ref (weather); // nueva operación de las variables en su clase y colóquelas en el objeto del contenedor objeto = weather_reflect.returnList (). get (0); return Object;} Abra la salida: está lloviendo

No hay una nueva operación en la lluvia en la precedencia del tiempo, pero se puede usar. Este debería ser el ejemplo del COI más simple para simular Spring. Por supuesto, el contenedor del COI de Spring es mucho más poderoso que este, como se debe considerar la seguridad de los subprocesos, y se requieren varios detalles.

Resumir

Lo anterior es toda la explicación detallada de este artículo sobre la simple implementación del principio del COI de Spring, espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a este sitio:

Explicación detallada de los principios de Spring IOC

Una breve comprensión del COI, AOP y ejemplos de código de Spring

Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!