Tabla de contenido
Preguntas clásicas de la entrevista:
4. Integración de Spring y contenedor web El proceso de integración de Spring y contenedor web
Prefacio:
Hoy, el editor le ofrece el conocimiento de un marco de código abierto. ¡Espero que después de leer este artículo mío, puedas mejorar tu capacidad de desarrollo!
Preguntas clásicas de la entrevista:
1. ¿Qué es la primavera? ¿Qué entiendes sobre la primavera?
En pocas palabras , Spring es un marco de contenedor liviano de inversión de control (IoC) y orientado a aspectos (AOP).
El marco Spring es un marco de aplicación de pila completa (full-stack) de código abierto y una implementación de contenedor de control de inversión para la plataforma Java, generalmente denominado directamente Spring. Fue creado por Rod Johnson, después de buscar en su información, es difícil imaginar que Rod Johnson haya estudiado música antes. En teoría, algunas funciones principales del marco se pueden usar en cualquier aplicación Java y también proporciona una gran cantidad de soporte extendido para aplicaciones web creadas en la plataforma Java Enterprise Edition. Spring no implementa directamente ningún modelo de programación, pero ha ganado popularidad en la comunidad Java, reemplazando esencialmente el modelo Enterprise JavaBeans (EJB) por completo.
Propósito: Resolver la complejidad del desarrollo de aplicaciones empresariales.
Función: utilice JavaBean básico en lugar de EJB y proporcione más funciones de aplicaciones empresariales
Como se muestra a continuación (funciones incluidas en Spring):
Acerca de IoC, introducción a AoP
Inversión de control (IoC): Spring gestiona las dependencias de objetos en una aplicación a través de un contenedor IoC. Transfiere la creación, ensamblaje y gestión de objetos al contenedor, y los desarrolladores solo necesitan centrarse en la implementación de la lógica empresarial.
Programación orientada a aspectos (AOP): Spring admite AOP, que puede separar las preocupaciones transversales (como el registro, la gestión de transacciones, etc.) de la lógica empresarial y mejorar la modularidad y la reutilización del código.
2. ¿Qué es el COI? ¿Qué entiendes sobre COI? ¿La importancia de IoC?
Entregar el derecho de crear instancias de objetos de los programadores al control del contenedor Spring
Beneficios: la separación de la lógica transversal y la lógica empresarial mejora la modularidad y la capacidad de mantenimiento del código.
Por ejemplo: Requisitos completados: agregue una interfaz de carga de archivos al cliente para realizar la función de carga de archivos. Después de usarla, el cliente siente que la velocidad de carga de archivos es demasiado lenta y solicita mejorar el rendimiento de esta función. Usamos IoC para facilitar Nuestras necesidades se añaden, cambian.
3. Tres métodos de inyección de IoC ( 1 , inyección establecida 2, inyección de construcción 3, ensamblaje automático )
3.1 Inyección de constructor
Inyección de constructor: inyecta objetos dependientes a través de constructores. Declare los parámetros del objeto dependiente en el constructor de la clase y proporcione el objeto dependiente correspondiente al configurar en el contenedor. Al crear una instancia de objeto, el contenedor pasará automáticamente el objeto dependiente al constructor para completar la inyección de dependencia.
Demostración de código:
package com.lya.ioc;
/**
* @author 程序猿-小李哥
* @site www.xiaolige.com
* @company 猪八戒有限集团
* @create 2023-08-15-14:42
*
* 用户更改信息的接口
*/
public interface UserService {
public void update();
}
Clase de implementación:
package com.lya.ioc.service.impl;
import com.lya.ioc.UserService;
/**
* @author 程序猿-小李哥
* @site www.xiaolige.com
* @company 猪八戒有限集团
* @create 2023-08-15-14:44
*/
public class UserServiceImpl1 implements UserService {
public void update() {
System.out.println("更改个人信息");
// System.out.println("上传头像功能");
}
}
Escriba un controlador (acción) para llamar y escribir un método de construcción parametrizado y sin parámetros
package web;
import com.lya.ioc.UserService;
import com.lya.ioc.service.impl.UserServiceImpl1;
/**
* @author 程序猿-小李哥
* @site www.xiaolige.com
* @company 猪八戒有限集团
* @create 2023-08-15-15:19
*/
public class UserAction {
private UserService userService = new UserServiceImpl1();
public String update(){
userService.update();
return "list";
}
}
Definir Bean: en el archivo spring.xml, puede utilizar elementos de configuración XML para definir el objeto Bean en la aplicación. Al configurar la ruta de clases y el constructor del Bean, el contenedor Spring puede crear y administrar el objeto Bean de acuerdo con la definición en el archivo de configuración.
Inyección de dependencia de configuración: el archivo spring.xml puede especificar la relación de dependencia entre Beans e inyectar el Bean dependiente (userService) en el Bean de destino (userAction) configurando la inyección del constructor para realizar la inyección de dependencia. Esto puede lograr el desacoplamiento entre objetos y mejorar la flexibilidad y capacidad de prueba del código.
<?xml version="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.xsd">
<bean class="com.ycxw.ioc.web.UserAction" id="userAction">
<constructor-arg name="userService" ref="userService"></constructor-arg>
</bean>
<bean class="com.ycxw.ioc.service.impl.UserServiceImpl1" id="userService"></bean>
</beans>3.2 Inyección del método setter
Inyecta objetos dependientes a través del método setter. Defina el método de establecimiento correspondiente en la clase y utilice el atributo o etiqueta correspondiente para especificar el objeto dependiente al configurar en el contenedor. Cuando se crea una instancia de objeto, el contenedor llamará al método de establecimiento correspondiente para inyectar el objeto dependiente en el objeto.
Código de muestra:
1. Modificar el controlador (acción)
public class UserAction { private UserService userService; private String uname; private int age; private List<String> hobby; public void test2() { System.out.println(this.uname); System.out.println(this.age); System.out.println(this.hobby); } public UserAction(String uname, int age) { super(); this.uname = uname; this.age = age; } public UserAction() { super(); }
2. Modificó el método de inyección de frijoles (propiedad).
<?xml version="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.xsd">
<bean class="com.ycxw.ioc.web.UserAction" id="userAction">
<property name="userService" ref="userService"></property>
<bean class="com.ycxw.ioc.service.impl.UserServiceImpl1" id="userService"></bean>
</beans>3.3 Inyección de interfaz (asignación automática)
3. Aquí, tenga en cuenta la diferencia entre byType y byName:
1. byType (cableado automático por tipo):
En el modo byType, el contenedor Spring encontrará el Bean correspondiente según el tipo de atributo y lo inyectará automáticamente en el atributo correspondiente.
Por ejemplo, si una propiedad es de tipo userService, el contenedor Spring encontrará un Bean que implementa la interfaz userService y lo inyectará en la propiedad.
Para utilizar el patrón byType, el tipo de propiedad del bean de destino debe coincidir con el tipo del otro bean y solo puede haber un bean coincidente en el contenedor.
2. byName (autoconexión por nombre):
En el modo byName, el contenedor Spring encontrará el Bean correspondiente según el nombre del atributo y lo inyectará automáticamente en el atributo correspondiente.
Por ejemplo, si una propiedad se llama myBean, el contenedor Spring buscará un bean llamado myBean y lo inyectará en la propiedad.
Para utilizar el patrón byName, el nombre de propiedad del bean de destino debe coincidir con el nombre del otro bean.
4. Integración de Spring y contenedor web
El proceso de integración de Spring y contenedor web
Por qué: El proceso de modelado requiere mucho tiempo
para resolver problemas:
1. El modelado es esencial
2. El modelado debe ejecutarse solo una vez
3. Después del modelado, se espera que cada servlet pueda obtener el objeto de contexto Spring ClassPathXmlApplicationContext
Cómo:
1. El método de inicialización del oyente
2. El contexto Spring debe almacenarse en el contexto Tomacat
DemoServlet:
package com.lya.ioc.demo; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.ycx.web.UserAction; @WebServlet("/springDemo") public class DemoServlet extends HttpServlet{ @Override public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { // ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml"); ClassPathXmlApplicationContext context =(ClassPathXmlApplicationContext) req.getServletContext().getAttribute("springContext"); UserAction userAction = (UserAction) context.getBean("userAction"); userAction.list(); super.service(req, res); } }
Configurar el monitoreo
package com.lya.ioc.listener;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.ycx.web.UserAction;
public class SpringLoadListener implements ServletContextListener{
@Override
public void contextInitialized(ServletContextEvent sce) {
System.out.println("初始化......");
// 拿到Spring的上下文
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
// 将Spring上文保存到Tomcat上下文中
ServletContext servletContext=sce.getServletContext();
servletContext.setAttribute("springContext", context);
}
}<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
version="3.1">
<display-name>Archetype Created Web Application</display-name>
<listener>
<listener-class>com.ycx.ioc.listener.SpringLoadListener</listener-class>
</listener>
</web-app>5. Resumen
1. La función de Spring
es un marco contenedor que se utiliza para integrar otros marcos de terceros.Hay dos componentes principales: COI y AOP.
2. El papel y
las características del COI: inyección de dependencia, inversión de controlInversión de control: el derecho a crear objetos y el derecho a nuevos objetos manualmente por parte de los programadores en el contenedor Spring
Ventajas: mantenimiento sencillo, aceptación del cambio
3.
Establecer la inyección en forma de inyección de dependencia.inyección constructora
montaje automático
4. Ensamblaje automático
por nombre: busque en el contexto Spring según la identificación del beanbyType: busque la clase de implementación de interfaz correspondiente en el contexto Spring de acuerdo con el atributo interfaz
5. Integración web y Spring