Spring_day1

Spring es un marco de código abierto ligero de aplicación completa Java SE / EE en capas , con IoC (Inverse Of Control: control inverso) y AOP (Programación orientada a aspectos: programación orientada a aspectos) como núcleo , proporcionando una capa de presentación Spring MVC Con muchas tecnologías de aplicaciones de nivel empresarial, como Spring JDBC y gestión de transacciones de capa empresarial, también puede integrar muchos marcos de terceros y bibliotecas de clases bien conocidas en el mundo de código abierto, convirtiéndose gradualmente en el marco de código abierto más utilizado para aplicaciones empresariales Java EE.
arquitectura de primavera

Use el IOC de spring para resolver el acoplamiento del programa

La inversión de control (abreviada como IoC) es un principio de diseño en la programación orientada a objetos que se puede utilizar para reducir el acoplamiento entre códigos de computadora. La forma más común se llama inyección de dependencia (DI), y hay otra forma llamada búsqueda de dependencia. A través de la inversión de control, cuando se crea un objeto, una entidad externa que regula todos los objetos en el sistema pasa la referencia al objeto del que depende. También se puede decir que la dependencia se inyecta en el objeto.
Paso 1: Maven agrega coordenadas de primavera
Paso 2: crear una interfaz de capa empresarial y una clase de implementación

package cn.myp666.dao;

public interface UserDao {
    //模拟保存用户
    public void saveUser();
}


import cn.myp666.dao.UserDao;

public class UserDaoImpl implements UserDao {
    public void saveUser() {
        System.out.println("用户保存了");
    }
}

Paso 3: Cree un archivo xml de cualquier nombre (no chino) y configure dao en la ruta raíz de la clase

<?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="UserDaoImpl" class="cn.myp666.dao.impl.UserDaoImpl"></bean>
</beans>

Paso 4: prueba si la configuración es exitosa

package cn.myp666;

import cn.myp666.dao.impl.UserDaoImpl;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Client {
    public static void main(String[] args) {
        //1.使用 ApplicationContext 接口，就是在获取 spring 容器
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("Bean.xml");
        //2.根据 bean 的 id 获取对象
        UserDaoImpl daoImpl = ac.getBean("UserDaoImpl", UserDaoImpl.class);

        System.out.println(daoImpl);
    }
}

运行结果：
cn.myp666.dao.impl.UserDaoImpl@754ba872

Detalles de IOC basados en XML de Spring

Diagrama de clases de la fábrica en primavera

La diferencia entre BeanFactory y ApplicationContext

BeanFactory es la interfaz de nivel superior en el contenedor Spring.
ApplicationContext es su subinterfaz.
La diferencia entre BeanFactory y ApplicationContext:
- El momento en que se crea el objeto es diferente.
  - ApplicationContext: en cuanto se lee el archivo de configuración, el objeto se crea de forma predeterminada.
  - BeanFactory: Qué usar cuando crear objetos.

Clase de implementación de la interfaz ApplicationContext

ClassPathXmlApplicationContext ：
- Carga el archivo de configuración desde la ruta raíz de la clase (recomendado)
FileSystemXmlApplicationContext ：
- Carga el archivo de configuración desde la ruta del disco, y el archivo de configuración puede estar en cualquier parte del disco.
AnnotationConfigApplicationContext:
- Cuando usamos anotaciones para configurar objetos contenedor, necesitamos usar esta clase para crear contenedores spring. Se usa para leer anotaciones.

Detalles de etiquetas de bean y objetos gestionados en IOC

etiqueta de frijol

Papel:
- El objeto de configuración es creado por spring.
- Por defecto, llama al constructor sin parámetros en la clase. Si no hay un constructor sin parámetros, no se puede crear con éxito.
Propiedades:
- id：Proporcione un identificador único para el objeto en el contenedor. Se usa para obtener objetos.
- class：El nombre de clase completo de la clase especificada. Úselo para la reflexión para crear objetos. El constructor sin parámetros se llama por defecto.
- scope：Especifique el alcance del objeto.
  - singleton: el valor predeterminado, singleton.
  - prototipo: casos múltiples.
  - solicitud: en el proyecto WEB, Spring crea un objeto Bean y almacena el objeto en el campo de solicitud.
  - sesión: en el proyecto WEB, Spring crea un objeto Bean y almacena el objeto en el dominio de la sesión.
  - sesión global: proyecto web, la aplicación de portlets medio ambiente si no entorno de portlets. Así
    globalSession sesión equivalente.
- init-method：Especifique el nombre del método de inicialización en la clase.
- destroy-method：Especifica el nombre del método de destrucción en la clase.

El alcance y el ciclo de vida del frijol

Objeto Singleton: scope = "singleton"
- Una aplicación tiene solo una instancia de un objeto. Su alcance es toda la referencia.
- Ciclo de vida:
  - Nacen los objetos: cuando se carga la aplicación y se crea el contenedor, se crea el objeto.
  - El sujeto está vivo: mientras el contenedor esté presente, el sujeto estará vivo.
  - Muerte del objeto: cuando se desinstala la aplicación y se destruye el contenedor, se destruye el objeto.
Múltiples instancias: alcance = "prototipo"
- Cada vez que se accede a un objeto, se recrea una instancia de objeto.
- Ciclo de vida:
  - Nacimiento de objetos: cuando use objetos, cree nuevas instancias de objetos.
  - El objeto está vivo: mientras el objeto esté en uso, permanecerá vivo.
  - Muerte del objeto: cuando el objeto no se utiliza durante mucho tiempo, el recolector de basura de Java lo recoge.

Tres formas de instanciar frijoles

Usar el constructor sin parámetros predeterminado

<!--在默认情况下：
它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数，将会创建失败。-->
<bean id="accountService" class="cn.myp666.dao.UserDao.UserDaoImpl"/>

gestión de muelles fábrica estática-uso fábrica estática para crear objetos

/**
* 模拟一个静态工厂，创建业务层实现类
*/
public class StaticFactory {
	public static IAccountService createAccountService(){
		return new AccountServiceImpl();
	}
}

<!-- 此种方式是:
	使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器
	id 属性：指定 bean 的 id，用于从容器中获取
	class 属性：指定静态工厂的全限定类名
	factory-method 属性：指定生产对象的静态方法
-->
<bean id="accountService"
 
	class="cn.myp666.factory.StaticFactory"
 
	factory-method="createAccountService"></bean>

Fábrica de instancias de gestión de Spring: cree un objeto utilizando el método de fábrica de instancias

/**
* 模拟一个实例工厂，创建业务层实现类
* 此工厂创建对象，必须现有工厂实例对象，再调用方法
*/
public class InstanceFactory {
	public IAccountService createAccountService(){
		return new AccountServiceImpl();
	}
}

<!-- 此种方式是：
	先把工厂的创建交给 spring 来管理。
	然后在使用工厂的 bean 来调用里面的方法
	factory-bean 属性：用于指定实例工厂 bean 的 id。
	factory-method 属性：用于指定实例工厂中创建对象的方法。
-->
<bean id="instancFactory" class="cn.myp666.factory.InstanceFactory"></bean>

<bean id="accountService"
 
	factory-bean="instancFactory"
 
	factory-method="createAccountService"></bean>

Inyección de dependencia de Spring

El concepto de inyección de dependencia.

Inyección de dependencia: Inyección de dependencia. Es la implementación concreta del núcleo ioc del marco de primavera.
Cuando se escribió nuestro programa, se dio la creación del objeto a través de la inversión de control, pero era imposible que el código no tuviera dependencias.
El desacoplamiento Ioc solo reduce su dependencia, pero no la elimina. Por ejemplo: nuestra capa empresarial seguirá llamando a los métodos de la capa de persistencia.
La dependencia entre esta capa empresarial y la capa de persistencia, después de usar spring, permite que spring la mantenga.
En pocas palabras, es esperar a que el marco pase los objetos de la capa de persistencia a la capa empresarial sin tener que obtenerlos nosotros mismos.

Inyección de constructor

Como su nombre lo indica, es usar el constructor en la clase para asignar valores a las variables miembro. Tenga en cuenta que la operación de asignación no la hacemos nosotros mismos, sino que a través del método de configuración, deje que el marco de trabajo de Spring nos inyecte. El código específico es el siguiente:

<!-- 使用构造函数的方式，给 service 中的属性传值
	要求：
		类中需要提供一个对应参数列表的构造函数。
	涉及的标签：
		constructor-arg
	属性：
		index:指定参数在构造函数参数列表的索引位置
		type:指定参数在构造函数中的数据类型
		name:指定参数在构造函数中的名称 用这个找给谁赋值
		=======上面三个都是找给谁赋值，下面两个指的是赋什么值的==============
		value:它能赋的值是基本数据类型和 String 类型
		ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean
-->
<bean id="accountService" class="cn.myp666.service.impl.AccountServiceImpl">
	<constructor-arg name="name" value="张三"></constructor-arg>
	<constructor-arg name="age" value="18"></constructor-arg>
	<constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>
<bean id="now" class="java.util.Date"></bean>

establecer método de inyección

<!-- 通过配置文件给 bean 中的属性传值：使用 set 方法的方式
	涉及的标签：
		property
	属性：
		name：找的是类中 set 方法后面的部分
		ref：给属性赋值是其他 bean 类型的
		value：给属性赋值是基本数据类型和 string 类型的
实际开发中，此种方式用的较多。
-->
<bean id="accountService" class="cn.myp666.service.impl.AccountServiceImpl">
	<property name="name" value="test"></property>
	<property name="age" value="21"></property>
	<property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>

Inyectar propiedades de colección

Como su nombre lo indica, es para pasar valores a los miembros de la colección en la clase. También utiliza el método de inyección de método establecido, excepto que los tipos de datos de las variables son todas las colecciones. Introducimos matrices de inyección, Lista, Conjunto, Mapa, Propiedades aquí. El código específico es el siguiente:

<!-- 注入集合数据
	List 结构的：
		array,list,set
	Map 结构的
		map,entry,props,prop
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<!-- 在注入集合数据时，只要结构相同，标签可以互换 -->
<!-- 给数组注入数据 -->
<property name="myStrs">
	<set>
		<value>AAA</value>
		<value>BBB</value>
		<value>CCC</value>
	</set>
</property>
<!-- 注入 list 集合数据 -->
<property name="myList">
	<array>
		<value>AAA</value>
		<value>BBB</value>
		<value>CCC</value>
	</array>
</property>
<!-- 注入 set 集合数据 -->
<property name="mySet">
	<list>
		<value>AAA</value>
		<value>BBB</value>
		<value>CCC</value>
	</list>
</property>
<!-- 注入 Map 数据 -->
<property name="myMap">
	<props>
		<prop key="testA">aaa</prop>
		<prop key="testB">bbb</prop>
	</props>
</property>
<!-- 注入 properties 数据 -->
<property name="myProps">
	<map>
		<entry key="testA" value="aaa"></entry>
		<!--使用value标签或value都行 -->
		<entry key="testB">
			<value>bbb</value>
		</entry>
	</map>
</property>

</bean>

Takeda

Publicado 94 artículos originales · elogiado 0 · visitas 2097

carta privada preocupaciones

Use el IOC de spring para resolver el acoplamiento del programa

Detalles de IOC basados ​​en XML de Spring

La diferencia entre BeanFactory y ApplicationContext

Clase de implementación de la interfaz ApplicationContext

Detalles de etiquetas de bean y objetos gestionados en IOC

etiqueta de frijol

El alcance y el ciclo de vida del frijol

Tres formas de instanciar frijoles

Inyección de dependencia de Spring

El concepto de inyección de dependencia.

Inyección de constructor

establecer método de inyección

Inyectar propiedades de colección

Supongo que te gusta

Detalles de IOC basados en XML de Spring