Prefacio

He estudiado la primavera estos días y el proceso de aprendizaje se siente particularmente vago. Es hora de comenzar a resumir y organizar. Empiece desde el primer día de aprendizaje. Después de aprender, las ventajas de la primavera, las API relacionadas con la primavera, la arquitectura de primavera y Algunas configuraciones básicas de resorte, etc.

1. ¿Qué es la primavera?

Spring toma IOC (Control Overturn) y AOP (Programación Orientada a Aspectos ) como el núcleo, y proporciona una pila completa (pila completa ) de muchas tecnologías de aplicaciones de nivel empresarial, como la capa de presentación (SpringMVC), la capa de persistencia (Spring JDBC) y la gestión de transacciones de la capa empresarial . ) Marco de código abierto Java ligero .

Ventajas :

Cómodo desacoplamiento y simplificación del desarrollo : (A través del contenedor IOC de Spring, las dependencias entre objetos se entregan a Spring para su control, evitando el acoplamiento entre programas causado por el proceso de codificación)

Soporte de programación AOP : (Spring proporciona funciones AOP para facilitar la programación orientada a aspectos. Muchas funciones que no son fáciles de implementar con OOP tradicional se pueden implementar fácilmente a través de AOP)

Soporte para transacciones declarativas : ( administre transacciones de manera flexible a través de métodos declarativos para proporcionar eficiencia y calidad de desarrollo)

Conveniente para la prueba del programa : (en primavera, puede usar el soporte de Spring para Junit4 para facilitar las operaciones de prueba del programa a través de anotaciones)

Facilitar la integración de varios marcos excelentes : (Spring no solo no excluye varios marcos excelentes de código abierto, sino que puede reducir la dificultad de usar varios marcos y proporcionar soporte para el uso de varios marcos)

Reducción del uso de la API de JavaEE : (Spring proporciona una capa de encapsulación simple para muchas API difíciles, y la encapsulación simple a través de Spring reduce en gran medida la dificultad de uso).

Dos, arquitectura de primavera

Tres archivos de configuración de primavera

1. La configuración básica del archivo Bean

Configuracion basica:

id: identificador único

clase: nombre de clase totalmente calificado

Configuración de rango:

singleton: valor predeterminado (singleton) ---> la instancia creada está en modo singleton, IOC se crea una vez y luego siempre existe

Prototipo: Multi-case ---> La instancia creada es un modelo multi-case. Cada vez que obtenemos un bean, IOC nos recreará un nuevo objeto

2. Tres formas básicas en que la primavera crea objetos

1. Ejecución de la construcción sin parámetros:

Crear UserDaoImpl
package com.james.dao.impl;
import com.james.dao.UserDao;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
/*实现Userdao接口(save()方法)*/
public class UserDaoImpl implements UserDao{
    public UserDaoImpl(){
        System.out.println("调用了无参的构造方法");
    }
    public void save() {
        System.out.println("执行了UserDaoImplements的save方法");
    }
}
Crear UserServiceImpl
package com.james.service.impl;
import com.james.dao.UserDao;
public class UserServiceImpl implements com.itheima.service.UserService {
    public void save() {
    }
}
Crear clase de prueba
package com.james;
import com.james.dao.UserDao;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class test {
    @Test
    public void save(){
        //从spring的IOC中获取userDao对象
        ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao=(UserDao)app.getBean("userDao");
        userDao.save();
    }
}
Escribir el archivo de configuración applicationContext.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.itheima.dao.impl.UserDaoImpl"></bean>
    <bean id="userService" class="com.itheima.service.impl.UserServiceImpl"></bean>
</beans>
Resultado de la ejecución: (El contenedor de primavera ha instanciado correctamente el objeto Bean)

:

2. Creación de instancias del método de fábrica estático: (entender)

Este método proporciona una fábrica estática para instanciar objetos, el método es el siguiente:

Personalizar una clase de fábrica
package com.james.factory;
import com.james.dao.UserDao;
import com.james.dao.impl.UserDaoImpl;
public class StaticFactory {
    public static UserDao createUserDao(){
        return new UserDaoImpl();
    }
}
Archivo de configuración

En el código anterior : la clase de implementación UserDaoImplement correspondiente especifica su clase de fábrica correspondiente StaticFactory, y el atributo de método de fábrica informa al contenedor de primavera que llame al método createUserDao de la clase de fábrica para obtener una instancia de UserDaoImpl .

3. Creación de instancias de métodos comunes de fábrica (comprender)

Clase de fábrica personalizada
package com.james.factory;
import com.james.dao.UserDao;
import com.james.dao.impl.UserDaoImpl;
public class NormalFactory {
    public  UserDao createUserDao(){
        return new UserDaoImpl();
    }
}
Archivo de configuración

En el código anterior: primero configure un bean de fábrica de instancia, y luego configure el bean que necesita ser instanciado En el bean con el id de userDao, use el atributo factory-bean para especificar una fábrica de instancias, y el valor del atributo corresponde al valor del atributo id de la fábrica de instancias, usando factory El atributo -method determina el uso del método createBean de la fábrica.

Inyección de dependencia de Three Bean

La inyección de dependencias es una estrategia de desacoplamiento en el marco Spring, llamada DI o IOC (Inversión de control). Existen principalmente métodos de conjunto y métodos de restricción (métodos de construcción), de modo que las clases se organizan en forma de archivos de configuración. .

Por ejemplo, si classB se usa en classA, si el código está escrito, es nuevo y una classB, y la forma de inyección de dependencia es escribir dos en applicationContext.xml
<bean id="id1" class="A"><property name="B" ref="id2"></bean>
<bean id="id2" class="B"></bean>
Es decir, no es necesario escribir en el lugar donde se necesita nuevo en la clase A.

Dos formas de lograr la inyección de dependencia:

Método de construcción:

método de configuración:

Tipo de datos de inyección de dependencia de bean

1) Tipo de datos común

2) Tipo de datos de referencia

Los dos primeros se han reflejado en el método de construcción y el método establecido de inyección de dependencia.

3) Tipo de datos de colección (tipo de matriz, colección de lista, colección de conjuntos, colección de doble columna)

package com.james.Service.impl;
import lombok.Data;
import java.util.List;
import java.util.Map;
import java.util.Set;
@Data
public class UserService {
    private String[] hobbies;
    private List<Object> games;
    private Set<Object> names;
    private Map<String, Object> map;
    private Properties prop;

    public void setProp(Properties prop) {
        this.prop = prop;
    }
    public void setHobbies(String[] hobbies) {
        this.hobbies = hobbies;
    }
    public void setGames(List<Object> games) {
        this.games = games;
    }
    public void setNames(Set<Object> names) {
        this.names = names;
    }
    public void setMap(Map<String, Object> map) {
        this.map = map;
    }
}

Archivo de configuración:

<?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">
    <beans>
        <bean id="userService" class="com.itheima.Service.impl.UserServiceImpl">
            <!--bean类型的依赖注入之数组类型-->
            <property name="games">
                <list>
                    <value>LOL</value>
                    <value>王者荣耀</value>
                </list>
            </property>
            <!--bean类型的依赖注入值list类型-->
            <property name="hobbies">
                <array>
                    <value>抽烟</value>
                    <value>喝酒</value>
                    <value>烫头</value>
                </array>
            </property>
            <!--bean类型的依赖注入之set类型-->
            <property name="names">
                <set>
                    <value>James</value>
                    <value>Danny</value>
                </set>
            </property>
            <!--bean类型的依赖注入之map类型-->
            <property name="map">
                <map>
                    <entry key="one" value="破鞋"/>
                    <entry key="two" value="一匹马"/>
                </map>
            </property>

            <property name="prop">
                <props>
                    <prop key="a">A</prop>
                    <prop key="b">B</prop>
                </props>
            </property>
        </bean>
    </beans>

</beans>

[Primavera] Introducción al resumen de primavera