1 características básicas de primavera
Spring es un marco de código abierto muy activo; Es un marco que construye sistemas Javaee de múltiples capas basados en el núcleo, y su objetivo principal es simplificar el desarrollo empresarial.
Spring administra su código de manera no invasiva. Spring aboga por la "intrusión mínima", lo que significa que puede instalar o desinstalar el resorte en el momento apropiado, y Spring hace que Java sea brillante. (Principio de apertura y cierre), aquí está el principio de cierre.
2. Herramientas necesarias para desarrollar la primavera
(Aquí seleccionamos primero Spring 2.5 y luego 3.0)
2.1 paquete de jarra de primavera
Descargue la primavera en http://www.springsource.org/download, luego descomprima, busque el siguiente archivo jar en el directorio de descompresión y copie a classpath
"La biblioteca de clase central de la primavera es dist/spring.jar bajo Dist en el documento de primavera
"La biblioteca de terceros presentada es todo el documento de primavera bajo Lib/Jakarta-Commons/Commons-Logging.Jar
"Si se utiliza la programación de aspecto (AOP), los siguientes archivos JAR Lib/Suppej/SuppeJweaver.jar y SuppeJrt.jarlib/CGlib/Cglib-Nodep-2.1_3.Jar también se requieren
―Si usa las anotaciones en JSR-250, como@Resource/@Postconstruct/@Predestroy, el siguiente archivo JAR lib/J2ee/Common-Annotations.jar también se requiere
Nota: JSR (solicitud de especificación Java) se refiere a una solicitud formal para agregar una especificación técnica estandarizada a JCP (proceso comunitario Java). Cualquiera puede enviar una JSR (solicitud de especificación Java) para agregar nuevas API y servicios a la plataforma Java. JSR se ha convertido en un estándar importante en el mundo de Java
2.2 Archivo de configuración de resorte
Por defecto, es el archivo ApplicationContext.xml. Se pueden crear muchos archivos XML, y esto generalmente se configura en proyectos. (Creado en el directorio SRC)
3 Explicación detallada de las funciones básicas de la primavera
3.1 Springioc
Inversión de control de primavera: entrega la creación, inicialización, destrucción y otras tareas de objetos al contenedor de resorte. Controla el ciclo de vida de un objeto por el contenedor de resorte.
paso:
•A. Comience el contenedor de primavera
1. Encuentre archivos de configuración en classpath para instanciar el contenedor
La copia del código es la siguiente: ApplicationContext CTX = new ClassPathXMLApPlicationContext (new String [] {"ApplicationContext.xml"});
Puede buscar archivos XML en todo el ClassPath
* Carga de esta manera. Debe colocar el archivo de configuración de Spring en la ruta classpath del proyecto actual
* La ruta ClassPath se refiere al directorio SRC del proyecto actual, que es la ubicación de almacenamiento del archivo de origen Java.
2. Encuentre archivos de configuración en la ruta del sistema de archivos para instanciar el contenedor
El archivo de configuración de Spring puede especificar múltiples archivos de configuración y se puede pasar a través de matrices de cadenas.
Nota: Use el primer método para iniciar el contenedor a menudo
•B. Extraer objetos del contenedor de primavera
Estructura del contenedor de primavera:
3.2 Alias
<Beans> <alias name = "persona" alias = "p" /// alias es un alias, puede obtener la persona frijol a través de la p. <bean name = "Person"/> </beans>
Con tal configuración, se puede lograr el efecto de nombrar en un solo lugar y usar diferentes nombres en múltiples lugares.
3.3 Contenedor de resorte Objetos internos
1 Cómo crear un objeto
1.1 sin constructor de parámetros
<bean id = "helloworld"> </le bean>
1.2 Método de fábrica estática
<bean id = "helloworld2"
fábrica-Method = "GetInstance"> </bean>
1.3 Método de fábrica de ejemplo
<bean id = "helloworldFactory"> </reme>
<bean id = "helloworld3" factory-bean = "helloworldFactory" factory-metory = "getInStance"> </bean>
Solo recuerda el concepto. El primer método es el más utilizado, pero al integrarse con otras herramientas, se utiliza el modelo de fábrica de instancias.
Ejemplo :
Configurar 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"> <!-Ponga una clase en un contenedor de primavera, la clase se llama bean-> <!-n. -> <bean id = "helloworld"> </reme> <! ------------------------------- --------------------------------------------------------------------------------------------------- fábrica-metod = "getInstance" > </bean> <! ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ -----------------------------------------------------------
Crear clase de entidad HelloWorld
paquete com.itheima10.spring.createObject; public class HelloWorld {public void hello () {System.out.println ("Hello"); }}Establecer una fábrica estática HelloworldFactory
paquete com.itheima10.spring.createObject.method; public class HellowOrldFactory {public static static Helloworld getInstance () {System.out.println ("Método estático"); devolver New Helloworld (); }}Establecer una fábrica física HelloWorldFactory2
paquete com.itheima10.spring.createObject.method; public class HellowOrldFactory2 { / *** El objeto de fábrica debe crearse antes de que el método se pueda llamar* @return* / public helloworld getInStance () {return New Helloworld (); }}Método de prueba de escritura createObjectMethodTest
paquete com.itheima10.spring.createObject.method; import org.junit.test; import org.springframework.context.applicationContext; import og.springframework.context.support.classpathxmlaPplicationContext;/** * It está bien a ver el segundo y la tercera generación de métodos de generación CreateObjectMethodTest { / *** Por defecto, el contenedor Spring llama al constructor predeterminado de una clase para crear un objeto* / @Test public void testCreateObject_default () {ApplicationContext context = new ClassPathXMLAplaPLAdContext ("ApplicationContext.xml"); HelloWorld Helloworld = (HelloWorld) context.getBean ("HelloWorld"); Helloworld.hello (); }/*** Crear un objeto usando una fábrica estática* <bean id = "helloworld2" factory-method = "getInstance"> </reme> lo que hace el contenedor de primavera: el método getInstance se llama usar la clase helloworldFactory*/@test public void testCreateObject_staticFactory () ClasspathxmLapplicationContext ("ApplicationContext.xml"); HelloWorld Helloworld = (HelloWorld) context.getBean ("HelloWorld2"); Helloworld.hello (); }/*** El método de fábrica de instancia crea un objeto* <bean id = "helloworldfactory"*> </ bean>* <bean id = "helloworld3" fábrica-bean = "helloworldfactory" factory-method = "getInstance"> </bean> qué hacer dentro del spring: 1. Cree un objeto de helloworldfactory 2. @Test public void testCreateObject_InstanceFactory () {ApplicationContext context = new ClassPathXMLApPlicationContext ("ApplicationContext.xml"); HelloWorld Helloworld = (HelloWorld) context.getBean ("HelloWorld3"); Helloworld.hello (); }}2 alcance del objeto
El alcance de un objeto tiene dos propiedades: singleton y prototipo. Singleton significa singleton
2.1 Singleton (valor predeterminado)
En cada contenedor de COI de primavera, solo hay una instancia de objeto (compartida).
2.2 Prototipo
Permitir que los frijoles se instanciaran varias veces (cree una instancia una vez que se use). La primavera no puede ser responsable de todo el ciclo de vida de un prototipo de frijol. Esto significa que es responsabilidad del cliente ser claro sobre el prototipo de objetos alcanzados y liberar los recursos costosos que tienen cualquier prototipo de frijol.
<bean id = "helloworld" scope = "singleton"> </reme>
<bean id = "helloworld" scope = "prototype"> </bean>
Crear clase Helloworld
public class HelloWorld {public List <String> lists = new ArrayList <String> (); public HelloWorld () {System.out.println ("nueva instancia"); } public void hello () {System.out.println ("Hello"); }}Crear una clase de prueba Scopetest
paquete com.itheima10.spring.scope; importar org.junit.test; import org.springframework.context.applicationContext; import og.springframework.context.support.classpathxmlapplicationContextExt; public class scopetest { /*** Put a Bean en el contenedor de primavera, el valor predeterminado* es un valor de ClassalTon. El contenedor de primavera y esta clase es un singleton, entonces las propiedades en la clase se compartirán*/ @Test public void testCreateObject_scope_default () {ApplicationContext context = new ClassPathXMLApPlicationContext ("ApplicationContext.xml"); HelloWorld Hello1 = (HelloWorld) context.getBean ("HelloWorld"); hello1.lists.add ("aaaa"); hello2 = (HelloWorld) context.getBean ("Helloworld"); hello2.lists.add ("bbbb"); System.out.println (helloworld.lists.size ()); // 2, y solo emite una nueva instancia}/** * Si el archivo de configuración de Spring es el siguiente: * <bean id = "helloworld" scope = "prototype"> </reme>, entonces el contenedor de primavera creará múltiples objetos para */@test public void testCreateObject_scope_prototype () {applicattext Context = new New New New New New NEWNEW ClasspathxmLapplicationContext ("ApplicationContext.xml"); HelloWorld Hello1 = (HelloWorld) context.getBean ("HelloWorld"); hello1.lists.add ("aaaa"); hello2 = (HelloWorld) context.getBean ("Helloworld"); hello2.lists.add ("bbbb"); System.out.println (helloworld.lists.size ()); // 1, y solo emite una nueva instancia}}3 Tiempo de inicialización
Carga perezosa: de forma predeterminada, el bean se inicializará cuando comience el contenedor, pero podemos especificar la línea de entrada de lazada = "verdadero" del nodo de frijol para retrasar la inicialización del bean. En este momento, el frijol se inicializará solo si el frijol se recupera por primera vez. como:
<bean id = "xxx" lazy-init = "true"/>
Si desea aplicar la inicialización tardía a todos los frijoles, puede establecer la ineficaz predeterminada = "verdadero" en los frijoles raíz, de la siguiente manera:
<beans predettion lazy-init = "true" ...>
Spring instancia a todos los frijoles singleton por adelantado al inicio de forma predeterminada. La instancia temprana significa que, como parte de la inicialización, el ApplicationContext crea y configura automáticamente todos los frijoles singleton. Esto suele ser algo bueno. Porque de esta manera se pueden descubrir cualquier error en la configuración de inmediato.
Lazy-INIT es falsa, el contenedor de primavera informará un error cuando se inicie (una mejor manera)
Lazy-INIT es verdadera, y el contenedor de primavera cometerá un error al llamar a la clase.
Configurar ApplicationContext.xml
<bean id = "helloworld" scope = "prototype"> </bean> </beans>
Crear clase de prueba createObjectWhentest
paquete com.itheima10.spring.createObject.when; import org.junit.test; import org.springframework.context.applicationContext; import org.springframework.context.support.classpathxmlaPpicationContext; public classwetwhentest { /*** ordenar* 1. HelloWorld object* 3. Object calling method* * <bean id="helloWorld"></bean> <bean id="helloWorld2"></bean> Because two beans are declared in the spring container, the spring container needs to create two objects: If struts2, hibernate, and spring containers are integrated, if an error occurs in the spring configuration file, an error will be reported when the tomcat container is started, and the error will se exhibirá particularmente temprano. Si un frijol almacena una gran cantidad de datos, este método no es bueno y los datos pueden estar atascados en la memoria demasiado temprano. Si un bean no es un singleton, no importa cómo esté configurado, el objeto debe crearse cuando es un context.getBean*/ @test public void testCreateObject_when_default () {ApplicationContext context = new ClassPathXMLApplicationContext ("ApplicationContext.xml"); context.getBean ("Helloworld"); } /*** <bean id = "helloworld" lazyinit = "true"> </reme>* orden* 1. Comience el contenedor de primavera* 2. context.getBean* 3. Llame a la función del constructor para crear un objeto* Descripción: Si Struts2, Hibernate, los contenedores de primavera están integrados, si se produce un error en el archivo de configuración de primavera, solo se informará cuando se utilizará el bean. Si un bean almacena una gran cantidad de datos, es necesario cargar datos cuando es necesario*/ @Test public void testCreateObject_when_lazy () {applicationContext context = new ClassPathXMLApPlicationContext ("ApplicationContext.xml"); context.getBean ("Helloworld"); }}4 init, destruir métodos
Cuando la primavera inicializa los frijoles o destruye frijoles, a veces se requiere algo de procesamiento, por lo que la primavera puede llamar a los dos métodos de ciclo de vida del frijol al crear y desmontar los frijoles. Puede especificar un método para operar.
<bean id = "foo" class = "... foo" init-Method = "Setup" Decoration-Method = "Tavepdown"/>
Llame al método Init-Method cuando FOO se cargue en el contenedor de resorte. Llamar al método de implementación cuando Foo se elimina del contenedor (Scope = Singleton Valid)
Escribiendo Helloworld
public class HelloWorld {public HelloWorld () {System.out.println ("nueva instancia"); } public void init () {System.out.println ("init"); } public void destruir () {System.out.println ("destruir"); } public void hello () {System.out.println ("Hello"); }}Escribir clase de prueba initDestroyTest
paquete com.itheima10.spring.ioc.initdestroy; import org.junit.test; import org.springframework.context.applicationContext; import og.springframework.context.support.classpathxmlaPplicationContext; public classy Class 1. Inicie el contenedor Spring* 2. Crear objeto Helloworld* 3. Ejecutar el método de init* Ejecución automática dentro del contenedor Spring* 4. Método de llamadas de objetos* 5. El método de destrucción solo se puede ejecutar cuando el contenedor de resorte está cerrado: el bean es un singleton* Este método también se llama internamente por el contenedor de primavera*:* Si el contenedor de primavera también se llama el contenedor de primavera. * En el contenedor de primavera, solo si un frijol es un singleton, el contenedor de primavera es responsable de la creación, inicialización y destrucción de objetos* Si un frijol no es un singleton, el contenedor de primavera solo es responsable de la creación y la inicialización*/ @Test public Void testInitDestroy () {Aplicación Contexttext = New ClassPathXMlapPlationContextationContextExt ("ApplicationConteNtext (" Aplicación ("Aplicación ("); HelloWorld Helloworld = (HelloWorld) context.getBean ("HelloWorld"); Helloworld.hello (); ClasspathxmLapplicationContext ApplicationContext = (ClassPathXMLApPlicationContext) context; ApplicationContext.Close (); }} Diagrama de secuencia de ejecución:
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.