Revisión de primavera

• Sitio web oficial: http://spring.io/
• Dirección de descarga oficial: https://repo.spring.io/libs-release-local/org/springframework/spring/
• GitHub: https://github.com/spring-projects

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.4</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.4</version>
</dependency>

ventaja:

• Spring es un contenedor de código abierto y marco gratuito.
• 2.Spring es un marco ligero, no intrusivo.
• 3. Inversión de control IoC, Aop presencial
• 4. Soporte para cosas, soporte para marcos

Composición : El marco Spring es una arquitectura en capas que consta de 7 módulos bien definidos. El módulo Spring se basa en el contenedor principal, que define la forma de crear, configurar y administrar beans.

• Contenedor principal : el contenedor principal proporciona las funciones básicas del marco Spring. El componente principal del contenedor central es BeanFactory, que es la realización del patrón de fábrica. BeanFactory utiliza el modelo de inversión de control (IOC) para separar las especificaciones de configuración y dependencia de la aplicación del código de la aplicación real.

• Contexto de Spring : el contexto de Spring es un archivo de configuración que proporciona información de contexto al marco de Spring. El contexto de Spring incluye servicios empresariales como JNDI, EJB, correo electrónico, internacionalización, funciones de verificación y programación.

• Spring AOP : a través de las funciones de administración de la configuración, el módulo Spring AOP integra directamente funciones de programación orientadas a aspectos en el marco Spring. Por lo tanto, puede hacer que el marco Spring administre fácilmente cualquier objeto que admita AOP. El módulo Spring AOP proporciona servicios de gestión de transacciones para objetos en aplicaciones basadas en Spring. Al utilizar Spring AOP, puede integrar la gestión de transacciones declarativas en su aplicación sin depender de los componentes.

• Spring DAO : la capa de abstracción JDBC DAO proporciona una jerarquía de excepciones significativa que se puede usar para administrar el manejo de excepciones y los mensajes de error lanzados por diferentes proveedores de bases de datos. La jerarquía de excepciones simplifica el manejo de errores y reduce en gran medida la cantidad de código de excepción que debe escribirse (como abrir y cerrar conexiones). Las excepciones orientadas a JDBC de Spring DAO siguen la jerarquía general de excepciones de DAO.

• Spring ORM : Spring Framework inserta varios marcos ORM, proporcionando así herramientas relacionales de objetos ORM, incluyendo JDO, Hibernate e iBatis SQL Map. Todos estos siguen la transacción general de Spring y la jerarquía de excepciones DAO.

• Módulo Spring Web : el módulo de contexto web está construido sobre el módulo de contexto de la aplicación para proporcionar contexto para las aplicaciones basadas en la web. Por lo tanto, el marco de Spring admite la integración con Jakarta Struts. El módulo web también simplifica el trabajo de procesar solicitudes de varias partes y vincular parámetros de solicitud a objetos de dominio.

• Spring MVC framework : MVC framework es una implementación MVC con todas las funciones para crear aplicaciones web. A través de la interfaz de estrategia, el marco MVC se vuelve altamente configurable MVC se adapta a una gran cantidad de tecnologías de visualización, incluidas JSP, Velocity, Tiles, iText y POI.
  

Spring Boot 与 Spring Cloud

• Spring Boot
  1), un conjunto de andamios de configuración rápida,
  2), puede desarrollar rápidamente un único microservicio basado en Spring Boot;
  3), ¡la convención es mayor que la configuración!
• Spring Cloud
  1), Spring Cloud se basa en Spring Boot;
  2), Spring Boot se enfoca en un solo individuo de microservicio que es rápido y fácil de integrar,
  3) Spring Cloud se enfoca en el marco de gobierno de servicio global;
  4), Spring Boot usa Las restricciones son mejores que el concepto de configuración. Se han seleccionado muchos esquemas de integración para usted. ¿Puede configurarlo sin configuración?
  5) Una gran parte de Spring Cloud se implementa en base a Spring Boot. Spring Boot puede salir de Spring
  Cloud y usar el desarrollo proyectos de forma independiente, pero Spring Cloud es inseparable de Spring Boot, que es una relación de dependencia.
  6) SpringBoot juega un papel en la conexión de lo anterior y lo siguiente en SpringClound.Si desea aprender SpringCloud, debe aprender SpringBoot.

Derivación de la teoría de IoC

En el pasado, escribimos procesos comerciales y creamos un maven sin soporte web, que no es diferente de escribir código Java.

1. Interfaz UserDao
2. Clase de implementación UserDaoImpl
3. Interfaz empresarial
UserService 4. Clase de implementación empresarial UserServiceImpl

//UserDao
public interface UserDao {
    void getUser();
}

//UserDaoImpl
public class UserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("默认获取用户的数据");
    }
}

//UserService
public interface UserService {
    void getUser();
}

/**
 * 业务层调dao层了，我要用它。  组合的概念，我们要用它就直接new出来就行
 */
//UserviceImpl
public class UserServiceImpl implements UserService{

//    private UserDao userDao = new UserDaoImpl();

    private  UserDao userDao = new UserDaoMysqlImpl();

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

//测试
public class MyTest {
    public static void main(String[] args) {

        // 实际调用的是业务层，dao层他们不需要接触
        UserServiceImpl userService = new UserServiceImpl();

        userService.getUser();

    }
}

/**
 * 但是如果我们在增加一个实现，那客户就要改service代码，如果用户又要增加实现，又要改代码，不方便，
 */
//新增实现类
public class UserDaoMysqlImpl implements UserDao{

    @Override
    public void getUser() {
        System.out.println("Mysql获取用户数据");
    }
}

La segunda forma: antes, usábamos la nueva forma, y ​​cuando es difícil escribir, usamos la forma set () , de la siguiente manera:

/**
 * 业务层调dao层了，我要用它。  组合的概念，我们要用它就直接new出来就行
 */
public class UserServiceImpl implements UserService{

    //private UserDao userDao = new UserDaoImpl();
    // 第一种
    // private  UserDao userDao = new UserDaoMysqlImpl();

    //第二种实现方式
    private UserDao userDao;
    // 使用set进行动态实现值的注入
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

//第二种，直接使用set
public class MyTest {
    public static void main(String[] args) {

        // 实际调用的是业务层，dao层他们不需要接触
        // UserServiceImpl userService = new UserServiceImpl();

        //第二种方式：set()
        UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(new UserDaoMysqlImpl());

        userService.getUser();

    }
}

En nuestro negocio anterior, las necesidades del usuario pueden afectar nuestro código original y necesitamos modificar la implementación del código original de acuerdo con las necesidades del usuario. Si la cantidad de código de usuario es muy grande, el costo de modificarlo una vez es muy caro.

• Antes, el programa creaba objetos activamente y el control estaba en manos del programador.
• Después de usar la inyección fija, el programa ya no está activo, sino que se vuelve pasivo.

Este tipo de pensamiento resuelve esencialmente el problema, y ​​los programadores ya no gestionamos la creación de objetos.

COI

Inversión de Control IoC (Inversión de Control) es una idea de diseño. DI (Inyección de Dependencia) es una forma de implementar IoC. En programas sin IoC, utilizamos la programación orientada a objetos, la creación de objetos y las dependencias entre objetos Completamente difícil- codificado en el programa, la creación del objeto es controlada por el programa mismo, y la creación del objeto se transfiere a un tercero después de la inversión de control. Personalmente creo que la llamada inversión de control es: la forma de obtener objetos dependientes se invierte.

La inversión de control es una forma de producir u obtener objetos específicos a través de la descripción (XML o anotación) y a través de un tercero . Es el contenedor de IoC que implementa la inversión de control en Spring, y su método de implementación es Dependency Injection (DI).

3. Primer proyecto de primavera de HelloSpring

Spring Quick Start
Inyecte atributos de tipo común a través del método set y cree objetos

Crear proyecto, clase pojo

public class Hello {

    private String str;

    public String getStr(){
        return str;
    }
    public void setStr(String str){
        this.str = str;
    }

    @Override
    public String toString(){
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

Beans.xml es applicationcontext.xml, y el marco en sí va al sitio web oficial para encontrarlo, y la prueba no tiene sentido.

<?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">

    <!--1、bean就是java对象 , 由Spring创建和管理
        2、使用spring来创建对象，在Spring这些都称为Bean
        3、对象也new好了，我们可以直接使用它了

        类型 变量名 = new 类型（）；
        Hello hello = new Hello();

        id = 变量名
        class = new 的对象
        property 相当于给对象中的属性设置一个值
        -->
    <bean id="hello" class="com.fengbin.pojo.Hello">
        <!-- 此处调用setName方法为name属性赋值-->
        <property name="str" value="Spring"/>
    </bean>
</beans>

Creemos una prueba MyTest

// 测试
public class MyTest {
    public static void main(String[] args) {
        /*  官网中配置文件是可以配置多个的
            ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");
        */
        // 获取spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        // 我们的对象现在都在Spring中的管理了，我们要使用，直接去里面取出来就可以了
        Hello hello = (Hello) context.getBean("hello");//我们现在可没有new出来hello
        System.out.println( hello.toString());
    }
}

Pensamiento:

¿Quién creó el objeto Hello? El objeto Hello fue creado por Spring.

¿Cómo se establecen las propiedades del objeto Hello? Las propiedades del objeto Hello las establece el contenedor Spring.

Este proceso se llama inversión de control:

Control: Quién controla la creación de objetos, los objetos de las aplicaciones tradicionales se crean bajo el control del propio programa, después de usar Spring, los objetos son creados por Spring

Inversión: el programa en sí no crea un objeto, sino que se convierte en un objeto receptor pasivo.

Inyección de dependencia: Utiliza el método set para inyectar. El núcleo es el método set. Si se elimina el método set () en la clase, entonces reportaremos un error al configurar la etiqueta <bean , de la siguiente manera:

IOC es una especie de idea de programación, desde la programación activa hasta la recepción pasiva
es que si está alojado en primavera, habrá algunos signos, como sigue, haga clic para saltar, podemos usarlo directamente; si no hay hoja, significa que el frijol no ha sido registrado,

Plan de modificación 1:
agregamos un archivo de configuración de Spring beans.xml en el proyecto spring-01-ioc1, de la siguiente manera:

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="mysqlImpl" class="com.fengbin.dao.UserDaoMysqlImpl"></bean>

    <bean id="UserServiceImpl" class="com.fengbin.service.UserServiceImpl">
        <!-- 普通字段我们用value，ref引向一个bean,就是我们要引向spring容器中创建好的对象
             ref : 引用spring容器中创建好的对象
             value： 具体的值，基本数据类型
        -->
        <property name="userDao" ref="mysqlImpl"></property>
    </bean>

</beans>

De esta manera, la prueba original no necesita el nuevo objeto.

// 原先的测试如下： 
public class MyTest {
    public static void main(String[] args) {

        // 实际调用的是业务层，dao层他们不需要接触
        // UserServiceImpl userService = new UserServiceImpl();

        //第二种方式：set()
        UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(new UserDaoMysqlImpl());

        userService.getUser();

    }
}

Esto es a lo que queremos cambiar. La operación directa es la siguiente: