Aprendizaje rápido de primavera (1)

2. Independientemente de varios servidores de aplicaciones, las aplicaciones basadas en el marco Spring realmente pueden hacer realidad la promesa de escribir una vez y ejecutar en cualquier lugar.

3. El contenedor IoC de Spring reduce la complejidad del reemplazo de objetos comerciales y mejora el desacoplamiento entre componentes.

4. El soporte AOP de Spring permite la gestión centralizada de algunas tareas comunes como seguridad, transacciones, registros, etc., proporcionando así una mejor reutilización.

5. ORM y DAO de Spring proporcionan una buena integración con marcos de capa de persistencia de terceros y simplifican el acceso a la base de datos subyacente.

6. El alto grado de apertura de Spring no obliga a las aplicaciones a depender completamente de Spring. Los desarrolladores son libres de elegir parte o la totalidad del marco Spring.

Las ideas de primavera se proponen de la siguiente manera:

La relación entre BeanFactory y ApplicationContext :

1) BeanFactory es la interfaz inicial de Spring, llamada Spring's Bean factory, y ApplicationContext es una interfaz posterior y más avanzada, llamada contenedor Spring;

2) ApplicationContext amplía sus funciones basadas en BeanFactory, tales como: función de monitoreo, función de internacionalización, etc. La API de BeanFactory es de nivel más bajo, y la API de ApplicationContext es principalmente una encapsulación de estas API de bajo nivel;

3) La lógica y las funciones principales de la creación de Bean están encapsuladas en BeanFactory. ApplicationContext no solo hereda BeanFactory, sino que también mantiene referencias a BeanFactory dentro de ApplicationContext. Por lo tanto, ApplicationContext y BeanFactory tienen una relación de herencia y una relación de fusión.

4) El tiempo de inicialización de Bean es diferente: el BeanFactory original solo crea el Bean (carga extendida) cuando se llama a getBean por primera vez, mientras que ApplicationContext carga el archivo de configuración y crea una instancia e inicializa el Bean tan pronto como se crea el contenedor. .

Tres contextos de aplicación de uso común :

Solo en el entorno básico de Spring, las tres funciones ApplicationContext más utilizadas son las siguientes:

2. Explicación detallada de la configuración de SpringBean

Configuraciones comunes de Bean:

Configuración del alcance del bean:

Rangos	Descripción
único	Valor predeterminado, singleton
prototipo	Múltiples instancias
pedido	En el proyecto WEB, Spring crea un objeto Bean y lo almacena en el campo de solicitud.
sesión	En el proyecto WEB, Spring crea un objeto Bean y lo almacena en el dominio de la sesión.
sesión global	En proyectos WEB se aplica en el entorno Portlet, si no hay entorno Portlet la sesión global equivale a la sesión.

Carga diferida de frijoles:

Cuando lazy-init se establece en verdadero, se trata de una carga diferida. Es decir, cuando se crea el contenedor Spring, la instancia de Bean no se creará inmediatamente. Cuando se use, la instancia de Bean se creará y almacenará en el grupo singleton. , y el Bean se utilizará más adelante. Simplemente consígalo directamente del grupo singleton. Esencialmente, el Bean sigue siendo un singleton.

3.Código

3.1 Primeros pasos

Cree un proyecto maven e importe dependencias relacionadas

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.8</version>
    </dependency>

    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>RELEASE</version>
    </dependency>
</dependencies>

Cree un paquete y escriba las clases relacionadas UserDao y UserDaoImpl en el paquete.

UserDao：

public interface UserDao {
    public void save();
}

UserDaoImpl：

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("UserDao save method running....");
    }
}

Prueba:

public class UserDaoTest {
    @Test
    //法1：普通法
    public void test1() {
        UserDao userDao = new UserDaoImpl();
        userDao.save();
    }

    @Test
    public void test2() {
        ApplicationContext applicationContext = new
                ClassPathXmlApplicationContext("applicationContext.xml");
        //法2：
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        userDao.save();
        //法3：
        UserDao userDao2 = applicationContext.getBean("userDao", UserDao.class);
        userDao2.save();

    }

}

aplicaciónContext.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="userDao" class="com.gz.core.dao.UserDaoImpl" ></bean>

</beans>

Lo anterior es la introducción básica.

3.2Método de inyección de dependencia de beans

Los métodos de inyección de dependencia incluyen: método set y método de construcción. Cómo usarlos se muestra en el siguiente código.

Basado en el UserDao UserDaoImpl anterior, cree lo siguiente

Servicio de usuario:

public interface UserService {
    void save();
}

UserServiceImpl: Hay 2 formas de escribirlo

Colocar

public class UserServiceImpl implements UserService {

    private UserDao userDao;

@Override
    public void save() {
        userDao.save();
    System.out.println("-------- save();--------");
    }
    //构造set
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
        System.out.println("------setUserDao--------");
    }
}

Constructor

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    //构造方法

    //没有调用无参
    public UserServiceImpl() {
        System.out.println("-------UserServiceImpl----");
    }

    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
        System.out.println("-------UserServiceImpl(UserDao userDao)------------");
    }
@Override
    public void save() {
        userDao.save();
    System.out.println("-------- save();--------");
    }

}

Los archivos de configuración correspondientes applicationContext.xml :

Colocar:

<?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="userDao" class="com.gz.core.dao.UserDaoImpl" ></bean>

<bean id="userService" class="com.gz.core.service.UserServiceImpl">
         <!-- id配置的是beanname,没有配id,可用name的别名首个单词,没有name，可用class-->

          <property name="userDao" ref="userDao"/>

         <!-- ref为引用，引用dao中的id(id可以任意起)

          .一定注意这里的name是set方法的名称而不是属性名,
          spring是根据这个name做了首字母大写和拼接set字符串而找到的set方法
          ,并通过反射调用该方法对属性赋值, 再说一遍这不是属性名-->
      </bean>

</beans>

Constructor:

<?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="userDao" class="com.gz.core.dao.UserDaoImpl" ></bean>

  <bean id="userService" class="com.gz.core.service.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>

</beans>