1. Descripción general de la primavera
1.1 ¿Qué es la primavera?
Spring es un marco de código abierto ligero de Java EE actualmente convencional y uno de los marcos de trabajo más exitosos en el mundo de Java. Spring fue propuesto y fundado por el "Padre de Spring" Rod Johnson. Su propósito es simplificar la dificultad de desarrollo y el ciclo de desarrollo de las aplicaciones empresariales de Java.
Desde el lanzamiento oficial de Spring 1.0 en abril de 2004, Spring ha entrado en la quinta versión principal, que es lo que solemos llamar Spring 5.
Spring se ha visto favorecido desde sus inicios y ha sido considerado como la primera opción por los desarrolladores para el desarrollo de aplicaciones empresariales Java. Hoy, Spring se ha convertido en sinónimo de Java EE y el estándar de facto para crear aplicaciones Java EE.
Spring Framework no se limita al desarrollo del lado del servidor. Cualquier aplicación Java puede beneficiarse de Spring en términos de simplicidad, capacidad de prueba y bajo acoplamiento. Spring Framework también es una plataforma de superpegamento, además de proporcionar sus propias funciones, también brinda la capacidad de unir otras tecnologías y marcos.
Spring es un marco de contenedor ligero de inversión de control (IOC) y orientado a aspectos (AOP).
Describa específicamente Spring:
Ligero: Spring es liviano en términos de tamaño y sobrecarga. El marco completo de Spring se puede distribuir en un archivo JAR que tiene un tamaño de poco más de 1 MB. Y la sobrecarga de procesamiento requerida por Spring es insignificante. Además, Spring no es intrusivo: por lo general, los objetos en una aplicación Spring no dependen de las clases específicas de Spring. El Servlet que aprendimos antes es intrusivo, porque una clase de Java debe implementar o heredar la API de Servlet si quiere convertirse en un Servlet, pero Spring básicamente no lo hace.
Idea central:
Inversión de control: IOC (inversión de control).
Inyección de dependencia: DI (inyección de dependencia).
Programación orientada a aspectos: AOP (programación orientada a aspectos).
Contenedor: Spring contiene y administra la configuración y el ciclo de vida de los objetos de la aplicación, en el sentido de que es un contenedor, puede configurar cómo se crea cada uno de sus beans, basado en un prototipo configurable (prototipo), su bean puede crear un contenedor separado. instancia o generar uno nuevo cada vez que lo necesite, y cómo se relacionan entre sí.
Marco: Spring puede configurar y combinar componentes simples en aplicaciones complejas. En Spring, los objetos de aplicación se componen de forma declarativa, normalmente en un archivo XML. Spring también proporciona muchas funciones básicas (gestión de transacciones, integración de marco de persistencia, etc.), dejando el desarrollo de la lógica de la aplicación a usted.
Ventanilla única: sobre la base de IOC y AOP, puede integrar marcos de código abierto de varias aplicaciones empresariales y excelentes bibliotecas de clase de terceros (por ejemplo: trabajo colaborativo entre marcos Struts2 e Hibernate), Spring es un puente o gestión en el programa O bien, toda la aplicación depende de Spring para ejecutarse. De hecho, Spring también proporciona SpringMVC para la capa de presentación y SpringJDBC para la capa de persistencia.
1.1.1 El nacimiento y desarrollo de la primavera
Los primeros J2EE (plataforma Java EE) defendían el método de desarrollo con EJB como núcleo, pero este método de desarrollo tiene varias desventajas en el proceso de desarrollo real, como un uso complejo, código inflado, código intrusivo fuerte, ciclo de desarrollo largo y portabilidad difícil. Gran espera.
En su libro más vendido "Expert One-on-One J2EE Design and Development" editado en 2002, Rod Johnson analizó y negó las diversas estructuras infladas de EJB una por una, y las reemplazó de una manera más concisa.
En este libro, Rod Johnson muestra, a través de un apéndice de 30.000 líneas, cómo crear una aplicación Java escalable y de alta calidad sin usar EJB. En este apéndice, Rod Johnson ha escrito decenas de miles de líneas de código de infraestructura, incluidas muchas interfaces y clases Java reutilizables, como ApplicationContext, BeanFactory y más. El paquete raíz para estas clases se llama com.interface21, lo que significa: Esta es una referencia para el siglo XXI.
Este libro tuvo un impacto de gran alcance. Más tarde, Rod Johnson abrió el código fuente de com.interface21 y llamó a este nuevo marco "Primavera", lo que significa: La primavera es como un rayo de brisa primaveral, que barre el frío invierno de los entornos tradicionales. J2EE.
En febrero de 2003, se lanzó la versión 0.9 de Spring, que adoptó el protocolo de código abierto Apache 2.0; en abril de 2004, se lanzó oficialmente la versión 1.0 de Spring. Hasta ahora, Spring ha ingresado a la quinta versión principal, que es lo que a menudo llamamos Spring 5.
1.1.2 Sentido estrecho y amplio de primavera
En diferentes contextos, Primavera representa diferentes significados. A continuación, presentaremos Spring desde las perspectivas de "sentido amplio" y "sentido estricto".
Sitio web oficial: https://spring.io/
Spring en un sentido amplio: pila de tecnología Spring
Spring en un sentido amplio se refiere a la pila de tecnología Spring con Spring Framework como núcleo.
Después de más de diez años de desarrollo, Spring ya no es un marco de aplicación puro, sino que se ha convertido gradualmente en una tecnología madura compuesta de múltiples subproyectos (módulos) diferentes, como Spring Framework, Spring MVC, SpringBoot, Spring Cloud, Spring Data, Spring Security, etc., entre los que Spring Framework es la base de otros subproyectos.
Estos subproyectos cubren todo, desde el desarrollo de aplicaciones de nivel empresarial hasta la computación en la nube, y pueden ayudar a los desarrolladores a resolver varios problemas prácticos que surgen en el proceso de desarrollo de software, brindando a los desarrolladores una mejor experiencia de desarrollo.
| nombre del proyecto | describir |
|---|---|
| Datos de primavera | El módulo de acceso a datos provisto por Spring proporciona un buen soporte para JDBC y ORM. A través de él, los desarrolladores pueden utilizar una forma relativamente uniforme de acceder a los datos ubicados en diferentes tipos de bases de datos. |
| Lote de primavera | Un marco ligero para las tareas diarias de procesamiento por lotes en sistemas de nivel empresarial, que puede ayudar a los desarrolladores a desarrollar fácilmente aplicaciones de procesamiento por lotes sólidas y eficientes. |
| Seguridad de primavera | Anteriormente conocido como Acegi, es uno de los submódulos más maduros de Spring. Es un marco de autenticación y control de acceso personalizable. |
| móvil de primavera | Es una extensión de Spring MVC para simplificar el desarrollo de aplicaciones web móviles. |
| Bota de primavera | Es un nuevo marco proporcionado por el equipo de Spring. Proporciona algunas configuraciones listas para usar para Spring y bibliotecas de terceros, lo que puede simplificar el proceso de construcción y desarrollo de aplicaciones Spring. |
| Nube de primavera | Un marco de microservicio basado en Spring Boot. No es una tecnología determinada, sino una colección ordenada de una serie de soluciones o marcos de microservicios. Integra marcos de microservicios maduros y probados en el mercado, y los vuelve a empaquetar a través de la idea de Spring Boot, protegiendo y ajustando la configuración compleja y los principios de implementación, y finalmente proporciona a los desarrolladores un conjunto de herramientas simples, fáciles de entender y fáciles. -to-deploy Y un kit de desarrollo de sistemas distribuidos fácil de mantener. |
Muelle estrecho: marco de muelle
Spring en un sentido estricto se refiere específicamente a Spring Framework, al que generalmente nos referimos como Spring Framework.
Spring Framework es una solución liviana, integral y en capas para aplicaciones Java orientadas a aspectos. Es el núcleo y la base de la pila de tecnología Spring y se creó para resolver la complejidad del desarrollo de aplicaciones de nivel empresarial.
Spring tiene dos partes principales: IoC y AOP.
| centro | describir |
|---|---|
| COI | La abreviatura de Inverse of Control, traducida como "inversión de control", se refiere a entregar el proceso de creación de objetos a Spring para su gestión. |
| POA | La abreviatura de Programación Orientada a Aspectos, traducida como "programación orientada a aspectos". AOP se utiliza para encapsular el comportamiento público de múltiples clases y encapsular la lógica que no tiene nada que ver con el negocio pero que comúnmente llaman los módulos comerciales, para reducir la duplicación de código en el sistema y reducir el acoplamiento entre módulos. Además, AOP también resuelve algunos problemas a nivel del sistema, como registros, transacciones, permisos, etc. |
Spring es una tecnología de programación basada en beans que está cambiando profundamente el mundo del desarrollo de Java. Spring usa Java Beans simples y básicos para completar el trabajo que solo EJB podía hacer antes, haciendo que muchos códigos complejos sean elegantes y concisos, evitando el modo de desarrollo inflado e ineficiente de EJB, y facilitando enormemente el mantenimiento posterior y la actualización de proyectos y extensiones.
En el desarrollo real, las aplicaciones del lado del servidor suelen adoptar una arquitectura de tres niveles, que son la capa de presentación (web), la capa de lógica empresarial (servicio) y la capa de persistencia (dao).
Spring está comprometido con la solución de cada capa de la aplicación Java EE y brinda soporte técnico para cada capa.
En la capa de presentación brinda la integración de Spring MVC, Struts2 y otros frameworks;
en la capa de lógica de negocios brinda las funciones de administración de transacciones y registro de logs;
en la capa de persistencia también se pueden utilizar tecnologías como MyBatis, Hibernate y JdbcTemplate. integrarse para acceder a la base de datos.
Esto refleja plenamente que Spring es una solución integral, y Spring nunca hará cosas repetitivas para aquellas áreas que ya tienen mejores soluciones.
Desde el punto de vista del diseño, Spring Framework brinda a los programadores de Java un mayor grado de libertad y brinda buenas soluciones a problemas comunes en la industria. Por lo tanto, es muy bien recibido en la comunidad de código abierto y la mayoría de las empresas lo consideran un proyecto de Java. El marco preferente para el desarrollo.
1.1.3 Características de Spring Framework
El framework Spring tiene las siguientes características.
Desacoplamiento conveniente y desarrollo simplificado: Spring es una gran fábrica que puede entregar la creación de todos los objetos y el mantenimiento de las dependencias a la administración de Spring.
Integración conveniente de varios marcos excelentes: Spring no excluye varios marcos de código abierto excelentes y brinda soporte directo para varios marcos excelentes (como Struts2, Hibernate, MyBatis, etc.).
Reduzca la dificultad de usar la API de Java EE: Spring proporciona paquetes para algunas API (JDBC, JavaMail, llamadas remotas, etc.) que son muy difíciles de usar en el desarrollo de Java EE, lo que reduce en gran medida la dificultad de usar estas API.
Práctica prueba de programas: Spring es compatible con JUnit4 y los programas Spring se pueden probar fácilmente a través de anotaciones.
Soporte de programación AOP: Spring proporciona programación orientada a aspectos, que puede implementar fácilmente funciones como la interceptación de permisos y el monitoreo de operaciones de programas.
Soporte para transacciones declarativas: la gestión de transacciones se puede completar solo a través de la configuración, sin programación manual.
1.2 Arquitectura primaveral
El framework Spring es una arquitectura en capas, cada módulo puede existir de forma independiente o ser implementado en conjunto con otros módulos, su arquitectura se muestra en la siguiente figura:
Spring Core: El módulo Core es la biblioteca de clases principal de Spring. Todas las funciones de Spring dependen de esta biblioteca de clases. Core implementa principalmente funciones IOC, y todas las funciones de Sprign se realizan con la ayuda de IOC.
Spring AOP: el módulo AOP es la biblioteca AOP de Spring, que brinda soporte para la programación orientada a aspectos para objetos administrados por el contenedor Spring.
Spring DAO: Spring brinda soporte para JDBC, encapsula JDBC, permite que JDBC use recursos de Spring y proporciona administración de transacciones basada en el módulo AOP.
Spring ORM: el módulo ORM de Spring proporciona administración y soporte auxiliar para marcos ORM de uso común. Spring admite marcos de trabajo comúnmente utilizados como Hibernate, ibtas y jdo. Spring en sí no implementa ORM, sino que solo encapsula marcos ORM comunes y los administra.
Spring Context: el módulo Context proporciona un método de acceso Bean al estilo de un framework, y otros programas pueden acceder a los recursos Bean de Spring a través del Contexto. Se agregó soporte para internacionalización, propagación de eventos y validación, así como soporte para muchos servicios empresariales e integración de marco de plantilla.
Spring Web: El módulo WEB se basa en el módulo Contexto, proporcionando un contexto adecuado para las aplicaciones web. Además, también se proporciona la integración de Spring y otros marcos web (como Struts1, Struts2, JSF).
Spring Web MVC: el módulo WEB MVC proporciona a Spring un conjunto de implementaciones ligeras de MVC. Es una aplicación web con todas las funciones que se adapta a una gran cantidad de tecnologías de visualización, como JSP, Velocity y POI.
1.3 Comprender la inversión de control y la inyección de dependencia
IoC es la abreviatura de Inversion of Control, traducida como "inversion of control". No es una tecnología, sino una idea de diseño. Es una regla de programación orientada a objetos importante que puede guiarnos sobre cómo diseñar un programa mejor y débilmente acoplado.
Spring gestiona la creación de instancias y la inicialización de todos los objetos de Java a través del contenedor IoC y controla las dependencias entre los objetos. Llamamos Spring Bean a un objeto Java administrado por el contenedor IoC, que es indistinguible de un objeto Java creado con la palabra clave new.
El contenedor IoC es uno de los componentes centrales más importantes en el marco de Spring, que se ejecuta a través de todo el proceso de Spring desde el nacimiento hasta el crecimiento.
1.3.1 Entendimiento popular
Clase de dirección:
public class Address {
/**
* 在Address类中使用到了String类与Integer类
* 可以理解为，Address类依赖了String,Integer
*/
private String city; //城市
private String street; //街道
private Integer no; //门牌号
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
public Integer getNo() {
return no;
}
public void setNo(Integer no) {
this.no = no;
}
}Clase de persona:
public class Person {
/**
* Person类依赖了String, Integer, Address类
*/
private String name;
private Integer age;
private Address address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public void show(){
System.out.println("hello");
}
}prueba:
public class SpringTest {
@Test
public void testNewObject() {
//传统创建对象的方式：由代码编写者创建对象，对象的生命周期由程序员决定
//根据对象定义位置的不同，对象的生命周期也不相同
System.out.println("address对象的生命周期开始");
if (true) {
Address address = new Address();
//使用对象
address.setCity("郑州市");
address.setStreet("迎春路");
System.out.println(address.getCity());
//如果把创建Address对象的代码放在if语句块中,那么if执行结束,我们可以认为对象生命周期就结束了
}
//System.out.println(address); //定义在if中,在if外无法使用address
//如果Address对象放在test1()中,那么方法执行结束,我们可以认为对象生命周期就结束了
System.out.println("address对象的生命周期结束");
}
@Test
public void testIOC() {
/*
* 控制反转：IOC
* 将创建对象的权力转交给Spring，由Spring来负责对象的创建、销毁和管理
* 程序员无需创建对象，只需要从Spring容器中获取对象和使用对象即可
*/
}
@Test
public void testDI() {
Address address = new Address();
/*
* 首先我们理解什么是依赖：
* 在Address类中使用到了String类与Integer类
* 可以理解为，Address类依赖了String,Integer
*/
//那么为依赖类型的属性赋值，就叫做依赖注入
address.setCity("郑州市");
address.setStreet("迎春路");
address.setNo(18);
Person p = new Person();
//注入字面值
p.setName(new String("张三"));
p.setAge(new Integer(20));
//注入其他的对象
p.setAddress(address);
}
}1.3.2 Inversión de Control
En las aplicaciones Java tradicionales, si una clase quiere llamar a una propiedad o método en otra clase, generalmente crea este último objeto en su código a través de new Object() antes de realizar la transferencia de propiedad o método. Para facilitar la comprensión y la descripción, podemos referirnos al primero como "llamador" y al segundo como "llamado". En otras palabras, la persona que llama tiene el control sobre la creación del objeto llamado.
Pero en la aplicación Spring, el control de la creación de objetos Java está en manos del contenedor IOC, y los pasos generales son los siguientes.
1. Los desarrolladores definen objetos Java a través de archivos de configuración XML, anotaciones, clases de configuración Java, etc., como usar etiquetas <bean> en archivos de configuración XML, usar anotaciones @Component en clases Java, etc.
2. Cuando se inicia Spring, el contenedor IoC creará y administrará automáticamente estos objetos de acuerdo con la definición del objeto. Estos objetos creados y gestionados por el contenedor IOC se denominan Spring Beans.
3. Cuando queremos usar un Bean determinado, podemos obtenerlo directamente del contenedor IOC (por ejemplo, a través del método getBean() de ApplicationContext), sin crearlo manualmente a través del código (por ejemplo, la forma de new Object( )).
El mayor cambio provocado por IoC no es a nivel de código, sino un cambio de "transposición maestro-esclavo" a nivel ideológico. Originalmente, la persona que llama es la parte activa y tomará la iniciativa para crear cualquier recurso que quiera usar; pero en la aplicación Spring, el contenedor IOC tiene la iniciativa y la persona que llama se convierte en la parte pasiva, esperando pasivamente el IOC. contenedor Crea los objetos (Bean) que necesita.
Este proceso tiene una inversión de control en el nivel de responsabilidad, y la creación de objetos originalmente implementada por la persona que llama a través del código se invierte en el contenedor IOC para obtener ayuda. Por lo tanto, llamamos a este proceso "inversión de control" de Spring.
1.3.3 Inyección de dependencia
Después de comprender IoC, también debemos comprender otro concepto muy importante: la inyección de dependencia.
La Inyección de Dependencia (DI para abreviar) fue propuesta por Martin Fowler en 2004 al explicar la "Inversión de Control". Martin Fowler cree que el término "inversión de control" es muy oscuro y es imposible que las personas entiendan directamente "dónde está la inversión", por lo que sugiere usar "inyección de dependencia" en lugar de "inversión de control".
En la orientación a objetos, existe una relación llamada "dependencia" entre los objetos. En pocas palabras, una relación de dependencia es que un objeto necesita usar otro objeto, es decir, hay un atributo en el objeto y el atributo es un objeto de otra clase.
Por ejemplo, hay una clase Java llamada B cuyo código es el siguiente:
public class B {
String bid;
A a;
}Se puede ver en el código que hay un atributo de objeto a de tipo A en B, en este momento podemos decir que el objeto de B depende del objeto a. Y la inyección de dependencia se basa en esta "relación de dependencia".
Sabemos que la idea central de la inversión de control es que Spring es responsable de la creación de objetos. Durante el proceso de creación del objeto, Spring inyectará automáticamente el objeto del que depende en el objeto actual de acuerdo con la relación de dependencia, lo que se denomina "inyección de dependencia".
1.3.4 Cómo funcionan los COI
En el proceso de desarrollo de software de Java, existen relaciones de acoplamiento más o menos ciertas entre los objetos del sistema, entre los módulos y entre los sistemas de software y los sistemas de hardware.
Si el acoplamiento de un sistema es demasiado alto, causará problemas que son difíciles de mantener, pero el código sin acoplamiento difícilmente puede completar ningún trabajo, porque casi todas las funciones requieren la cooperación y la interdependencia entre los códigos para completarse. Por lo tanto, cuando diseñamos programas, la idea que mantenemos generalmente es minimizar el grado de acoplamiento sin afectar las funciones del sistema.
La capa inferior de IoC reduce al mínimo el grado de acoplamiento del código mediante el modo de fábrica, el mecanismo de reflexión de Java, el análisis XML y otras tecnologías. Los pasos principales son los siguientes.
1. En el archivo de configuración (como Bean.xml), configure cada objeto y las dependencias entre ellos
2. Podemos considerar el contenedor IoC como una fábrica, y el producto de esta fábrica es Spring Bean 3.
Cuando el contenedor comienza Estos archivos de configuración se cargarán y analizarán para obtener la información básica de los objetos y sus dependencias
4. IoC utiliza el mecanismo de reflexión de Java para generar los objetos correspondientes (es decir, Spring Beans) de acuerdo con los nombres de clase y convierte este objeto de acuerdo con las dependencias Inyectado en objetos que dependen de él.
Dado que la información básica del objeto y las dependencias entre los objetos están definidas en el archivo de configuración y no están estrechamente acopladas en el código, incluso si el objeto cambia, solo necesitamos modificarlo en el archivo de configuración en lugar de Modificar el código Java, que es el principio del desacoplamiento Spring IoC.
1.4 Crear entorno de desarrollo de Spring
1.4.1 Crear un proyecto Java
En el módulo básico de Spring, no hay contenido relacionado con la Web y no es necesario crear un proyecto JavaWEB, solo un proyecto Java.
1.4.2 Importar el paquete core jar
Paquetes básicos del framework Spring:
| nombre | efecto |
|---|---|
| primavera-core-xxxx.jar | Contiene las clases de herramientas básicas básicas del marco Spring, y otros componentes Spring deben usar las clases en este paquete, que es el núcleo básico de otros componentes. |
| frijoles-de-primavera-xxxx.jar | Utilizado por todas las aplicaciones, contiene todas las clases relacionadas con el acceso a archivos de configuración, la creación y administración de beans y la realización de operaciones de inversión de control (IoC) o inyección de dependencia (DI). |
| primavera-contexto-xxxx.jar | Spring proporciona servicios extendidos basados en funciones básicas de IoC y también brinda soporte para muchos servicios de nivel empresarial, como servicios de correo, programación de tareas, ubicación JNDI, integración EJB, acceso remoto, almacenamiento en caché y encapsulación de varios marcos de capa de vista. |
| primavera-expresión-xxxx.jar | Define el lenguaje de expresión de Spring. Cabe señalar que al desarrollar con Spring, además del paquete JAR que viene con Spring, se requiere un paquete JAR de terceros commons.logging para procesar la información de registro. |
Método 1: Importar paquete jar
Método 2: configuración de dependencia maven
<dependencies>
<!-- spring核心包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.3.18.RELEASE</version>
</dependency>
<!-- springbeans包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.3.18.RELEASE</version>
</dependency>
<!-- springcontext包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.18.RELEASE</version>
</dependency>
<!-- spring表达式包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>4.3.18.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>1.4.3 Escribir frijoles
HolaMundo.java
public class HelloWorld {
public String show() {
return "Hello Spring";
}
}1.4.4 Escribir archivos de configuración de Spring
applicationContext.xml es el nombre predeterminado y su función es configurar los objetos Bean que deben ser administrados por Spring en el contenedor SpringIOC.
La gestión de configuración de Spring se puede configurar mediante XML, y existe un concepto de espacio de nombres en XML. De hecho, es un poco similar al significado de las etiquetas.Después de dar un espacio de nombres, las etiquetas en el contexto de ese espacio de nombres se pueden usar en este archivo XML.
1. beans: el nodo raíz del archivo xml.
2. xmlns: es la abreviatura de XML NameSpace, porque los nombres de las etiquetas de los archivos XML están personalizados, las etiquetas escritas por uno mismo y definidas por otros probablemente se nombren repetidamente, pero las funciones son diferentes, por lo que es necesario crear un espacio de nombres. agregado Para distinguir este archivo xml de otros archivos xml, similar al paquete en java.
3. xmlns:xsi: significa que el archivo xml cumple con la especificación xml, y el nombre completo de xsi: la instancia del esquema xml se refiere a la especificación que deben cumplir los elementos definidos en el archivo de recursos del esquema utilizado en la aplicación específica. Es decir, qué estándares cumplen los elementos definidos en el archivo http://www.w3.org/2001/XMLSchema-instance.
4. xsi:schemaLocation: Se refiere a las normas que cumplen los elementos xml de este documento, todas estas normas son formuladas por el gobierno, puedes ingresar al sitio web que escribiste para ver los cambios de versión. La URL del xsd también puede ayudarlo a determinar si el código que está utilizando es legal.
<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring配置文件xml，采用schema约束规范（一个xml文件可以采用多个文件的规范） -->
<!--
xmlns：扩展当前xml的规范
xsi:schemaLocation：规范文件，成对出现
-->
<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.xsd">
<!-- 配置bean：将Java中类的对象托管给springIOC容器 -->
<bean id="helloworld" class="com.newcapec.bean.HelloWorld"></bean>
</beans>La diferencia entre esquema y DTD:
El esquema es la definición y descripción de la estructura del documento XML, y su función principal es restringir el documento XML y verificar la validez del documento XML. La función de DTD es definir los componentes básicos legales de XML, que utilizan una serie de elementos legales para definir la estructura del documento. Las diferencias entre ellos son las siguientes:
1. El esquema en sí también es un documento XML. La definición de DTD no tiene nada que ver con XML. El esquema tiene muchos beneficios en la comprensión y la aplicación práctica.
2. La estructura del documento DTD es "plana". Si define un documento XML complejo, es difícil comprender la relación de anidamiento entre cada elemento; el documento de esquema tiene una estructura sólida y la relación de anidamiento entre cada elemento es muy intuitivo.
3. DTD solo puede especificar que el elemento contiene texto y no puede definir el tipo específico de texto del elemento, como tipo de carácter, tipo entero, tipo de fecha, tipo personalizado, etc. Los esquemas son más fuertes que los DTD en este sentido.
4. El esquema apoya la descripción del orden de los nodos de elementos. DTD no proporciona una descripción de situaciones desordenadas. Para definir situaciones desordenadas, todas las situaciones deben estar ordenadas de manera exhaustiva. Schema puede usar xs:all para representar situaciones desordenadas.
5. Soporte para espacios de nombres. DTD no puede aprovechar los espacios de nombres XML y Schema satisface muy bien los espacios de nombres. Además, Schema también proporciona incluir e importar dos métodos para hacer referencia a espacios de nombres.
6. XML Schema no puede definir entidades como DTD y es más complicado que DTD, pero Xml Schema ahora es el estándar de la organización w3c y está reemplazando gradualmente a DTD.
Beneficios del esquema:
1. Cuando los usuarios de XML usan XML Schema, no necesitan volver a aprender a comprender XML Schema, lo que ahorra tiempo 2.
Dado que XML Schema en sí también es un tipo de XML, muchas herramientas de edición de XML, kits de desarrollo de API y análisis de sintaxis XML Los filtros se pueden aplicar directamente al esquema XML sin modificación.
3. Como aplicación de XML, XML Schema hereda naturalmente la autodescripción y la extensibilidad de XML, lo que hace que XML Schema sea más legible y flexible.
4. Dado que el formato es exactamente el mismo que XML, el esquema XML no solo se puede procesar como XML, sino que también se puede almacenar de la misma manera que el documento XML que describe, lo cual es conveniente para la administración.
5. La coherencia entre el esquema XML y el formato XML facilita el intercambio de esquemas entre sistemas de aplicaciones que utilizan XML como intercambio de datos.
6. XML tiene requisitos de legalidad muy altos. La descripción de XML en XML DTD se usa a menudo como base para verificar la legalidad de XML. Sin embargo, la legalidad de XML DTD en sí misma carece de un buen mecanismo de verificación y debe manejarse de forma independiente. XML Schema es diferente, tiene el mismo mecanismo de verificación de legalidad que XML.
1.4.5 Pruebas
@Test
public void testSpringIOC() {
//1、创建IOC容器ApplicationContext
//ClassPathXmlApplicationContext是ApplicationContext接口的实现类，该对象通过加载类路径下面的spring配置文件
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
//2、从容器中获取bean对象
/**
* Object getBean(String name)
* 参数name: 获取对象的名称，对象的唯一标识符，bean标签的id属性值
* 返回值Object: 对象
*/
Object obj = ac.getBean("helloworld");
System.out.println(obj instanceof HelloWorld);
HelloWorld helloWorld = (HelloWorld) obj;
String str = helloWorld.show();
System.out.println("方法的返回值为：" + str);
Object obj1 = ac.getBean("helloworld");
System.out.println(obj == obj1);
}Hay dos cosas a tener en cuenta sobre el código anterior:
-
La clase ClassPathXmlApplicationContext se usa al crear el objeto ApplicationContext.Esta clase se usa para cargar el archivo de configuración de Spring, crear e inicializar todos los objetos (Bean).
-
El método ApplicationContext.getBean() se usa para obtener el Bean, y el tipo de valor de retorno de este método es Object, que se convierte en un objeto de instancia de HelloWorld a través de la conversión de tipo obligatoria, y se llama al método show() que contiene.