Directorio de artículos
Introducción a Spring
Spring se deriva del núcleo del artículo "Expoer One-on-one j2ee development and Design".
Spring se lanzó en 2003:Los dos IOC y APO principales de Spring
Los datos de Spring, Spring Boot, Spring Cloud y Spring Framework ahora están lanzados. Todos estos se extienden desde Spring.
Spring es un marco de contenedor ligero de inversión de control (IOC) y orientado a aspectos (AOP).
-
Filosofía de diseño de Spring: hacer que la tecnología existente sea más fácil de usar (simplificar el desarrollo a nivel empresarial). Es una mezcolanza en sí misma, que integra el marco técnico existente.
-
SSH: struct2 + spring + hibernate
-
SSM: springMVC + spring + mybatis
(Spring es un agente de fusión)
Sitio web oficial de Spring: https://spring.io/projects/spring-framework#overview
Dirección de descarga oficial de Spring: https://maven.springframework.org/release/org/springframework/spring/
Documentación oficial de Spring: https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html
Dirección de GitHub: https://github.com/spring-project/spring-framework
Documentación de Spring Chinese: https://www.docs4dev.com/docs/zh/spring-framework/4.3.21.RELEASE/reference/spring-introduction.html
Ventajas de primavera:
- la primavera es un marco libre.
- Spring es un marco liviano y no invasivo (la situación original del código no cambiará después de la introducción de Spring).
- Inversión de control (IOC), Programación orientada a aspectos (AOP)
- Soporte de procesamiento de transacciones, soporte para integración de marco.
Desventajas de la primavera:
- La configuración es muy engorrosa.
Configurar el entorno de Spring
Manen depende de:
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
Primavera siete módulos
Ruta de aprendizaje de primavera
El desarrollo de Java moderno se basa en el desarrollo de primavera.
- Bota de primavera
- Es un andamio para un desarrollo rápido.
- Se puede desarrollar rápidamente un único microservicio basado en el arranque de primavera. (Solo un pequeño módulo)
- La convención en el desarrollo de las botas de primavera es mayor que la configuración
- Nube de primavera
- La nube de primavera se realiza mediante la bota de primavera del usuario.
Teoría del COI
Uso comercial anterior:
- Interfaz de capa de Dao
- Clase de implementación DaoImpl
- Interfaz de la capa de servicio
- Clase de implementación ServiceImpl
En el código que escribí antes, la capa de servicio llama a la capa dao para que esté codificada. Es decir, se crea una clase de dao fija para su uso en un método comercial. Esta forma de escribir es defectuosa y los cambios en las necesidades del usuario afectarán nuestro código. Si la cantidad de código de programa es grande, ¡el costo de modificarlo una vez es muy alto!
P.ej:
// 原来的代码
public interface UserDao {
void print();
}
public class UserDaoImpl implements UserDao{
@Override
public void print() {
System.out.println("使用了UserDao");
}
}
public interface UserService {
void userServicePring();
}
public class UserServiceImpl implements UserService{
private UserDaoImpl userDao;
@Override
public void userServicePring() {
userDao = new UserDaoImpl();
userDao.print();
}
}
public class MyTest {
public static void main(String[] args) {
UserService userService = new UserServiceImpl(userDao);
userService.userServicePring();
}
}
Si agregamos un UserDaoUseOracleImpl (usando Oracle para la conexión de la base de datos, el método es exactamente el mismo que UserDao), entonces debemos volver a modificar el código en UserServiceImpl , que es muy malo en este momento.
public class UserDaoUseOracleImpl implements UserDao{
@Override
public void print() {
System.out.println("使用了UserDaoUseOracle");
}
}
public class UserServiceImpl implements UserService{
private UserDaoUseOracleImpl userDao;
@Override
public void userServicePring() {
userDao = new UserDaoUseOracleImpl();
userDao.print();
}
}
Inyección dinámica (prototipo IOC)
Podemos usar set para lograr una inyección de valor dinámico, por lo que no es necesario modificar el código de la capa de servicio.
public interface UserDao {
void print();
}
public class UserDaoImpl implements UserDao{
@Override
public void print() {
System.out.println("使用了UserDao");
}
}
public class UserDaoUseOracleImpl implements UserDao{
@Override
public void print() {
System.out.println("使用了UserDaoUseOracle");
}
}
public interface UserService {
void userServicePring();
}
public class UserServiceImpl implements UserService{
private UserDao userDao;
@Override
public void userServicePring() {
userDao.print();
}
public void setUserDao(UserDao userDao){
this.userDao = userDao
}
}
public class MyTest {
public static void main(String[] args) {
UserService userService = new UserServiceImpl();
userService.setUserDao(new UserDaoImpl());
userService.userServicePring();
userService.setUserDao(new UserDaoUseOracleImpl())
userService.userServicePring();
}
}
- Antes, el programa creaba el objeto por iniciativa propia y el control estaba en el programa.
- Después de usar la inyección de set, el control está en manos del programador del usuario.
Este tipo de pensamiento resuelve esencialmente el problema: los programadores de negocios ya no necesitamos administrar la creación de objetos (creados por programadores de usuarios). Reduce el acoplamiento del sistema y puede centrarse más en la realización empresarial.
¡Este tipo de idea de inyección se usa ampliamente en la parte inferior de Spring! Permite a los programadores de usuarios crear objetos sin cambiar el código subyacente, lo que mejora la dinámica.
La esencia del COI: La inversión del control es una especie de pensamiento. Después del uso de la inversión del control, la creación de objetos se entrega a un tercero (la esencia de la inversión del control es que la forma de obtener objetos dependientes se invierte : originalmente el programa creaba objetos dependientes, y ahora es el usuario quien crea las dependencias. Objeto)
Hay muchas formas de implementar IOC, DI (inyección de dependencia) es solo una de ellas.
La inversión de control es una forma de generar objetos específicos a través de la descripción (XML o anotación) y a través de un tercero. Es el contenedor IOC que implementa la inversión de control en Spring, y su método de implementación es la inyección de dependencia (DI)
Por ejemplo, el pequeño ejemplo escrito antes: La clase Service es similar a un contenedor IOC, que genera objetos de servicio con diferentes funciones a través de la inyección de conjuntos.
Como se muestra arriba: Spring puede administrar objetos (componentes)
Hola primavera
Una simple demostración de primavera:
- Crea una clase de frijol
- Tenga en cuenta que Bean debe tener métodos set y get (porque la inyección de dependencia se inyecta usando métodos set)
public class Hello {
private String name;
public Hello() {
}
public Hello(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Hello{" +
"name='" + name + '\'' +
'}';
}
}
- Configurar el archivo de configuración de Bean xml (utilizado para configurar el objeto Bean)
- Un bean es equivalente a un objeto y el id es el nombre del objeto lógico. Este objeto se coloca en el contenedor de resortes y se maneja mediante el contenedor de resortes.
- Configúrelo en el contenedor de primavera y cree el objeto correspondiente basado en el xml en el contenedor.
<!-- beans.xml -->
<?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 id="hello1" class="com.qiu.pojo.Hello">
<property name="name" value="spring"/>
<!-- ref引用的是一个bean对象 -->
<property name="h" ref="hello2"/>
</bean>
<bean id="hello2" class="com.qiu.pojo.Hello">
</bean>
</beans>
- Utilice la clase ClassPathXmlApplicationContext para crear un contenedor de primavera
- El contenedor se genera a través de la configuración beans.xml, es decir, el contenedor posee y administra los objetos declarados en el archivo xml.
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Hello hello = (Hello) context.getBean("hello1");
System.out.println(hello.toString());
Esto se llama inversión de control: el objeto de programa tradicional es explícitamente nuevo fuera del programa, y el objeto se obtiene configurando el archivo xml usando el contenedor de resorte después de usar el resorte.El control está en manos del usuario y el negocio se puede modificar modificando el archivo xml sin modificar todo el código del sistema.
El objeto de programa tradicional es el programa en sí, por lo que el programa depende en gran medida del objeto específico.Si el código de objeto de todo el sistema debe cambiarse si se cambia el negocio, ¡esta es la encarnación de un alto acoplamiento!Ahora la gestión de objetos se realiza a través del contenedor Spring, Spring equivale a un puente entre el programa y el objeto, por lo que cambiar el objeto tiene un impacto mínimo en el programa. ¡Esta es la encarnación del desacoplamiento!
Cómo crea objetos el COI
Los objetos se crean automáticamente en el contenedor IOC y el tiempo de creación del objeto se realiza cuando se carga el archivo xml.La construcción sin parámetros del bean llamado al crear el objeto para crear el objeto.
Utilice la construcción parametrizada para crear Bean
Use la etiqueta de constructor constructor-arg (la etiqueta de propiedad se usa al asignar un valor a la propiedad, la construcción sin parámetros se llama al asignar un valor a la propiedad)En otras palabras, elija uno: usar propiedad es llamar sin parámetros y establecer para asignar; usar constructor-arg es llamar a una construcción parametrizada para crear un objeto.
class User{
private String name;
private Child child;
public User{
}
public User(String name, Child child){
this.name = name;
this.child = child;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Child getChild() {
return child;
}
public void setChild(Child child) {
this.child = child;
}
}
- Utilice subíndices para la asignación de construcción parametrizada
<beans>
<bean id="child" class="com.qiu.pojo.Child"></bean>
<!-- 使用下标进行有参构造 -->
<bean id="user" class="com.qiu.pojo.User">
<constructor-arg index="0" value="useruser"/>
<constructor-arg index="1" ref="child"/>
</bean>
</beans>
- Asignación de estructura de parámetros según el tipo
¡No recomendado para su uso! Si el constructor tiene varios parámetros con el mismo tipo de valor de parámetro, ¡no será reconocido!
<beans>
<bean id="child" class="com.qiu.pojo.Child"></bean>
<!-- 使用下标进行有参构造 -->
<bean id="user" class="com.qiu.pojo.User">
<constructor-arg type="java.lang.String" value="useruser"/>
<constructor-arg type="com.qiu.pojo.Child" ref="child"/>
</bean>
</beans>
- Asignación de estructura de parámetro por nombre de parámetro
<beans>
<bean id="child1" class="com.qiu.pojo.Child"></bean>
<!-- 使用下标进行有参构造 -->
<bean id="user" class="com.qiu.pojo.User">
<constructor-arg name="name" value="useruser"/>
<constructor-arg name="child" ref="child1"/>
</bean>
</beans>