1. Descripción general de COI y DI
IOC (Inversión de control): la idea es invertir la dirección de adquisición de recursos. El método tradicional de búsqueda de recursos requiere que el componente inicie una solicitud al contenedor para encontrar el recurso. En respuesta, el contenedor devuelve el recurso de manera oportuna. Después de que se aplica el COI, el contenedor toma la iniciativa Para enviar recursos al componente que administra, todo lo que el componente tiene que hacer es elegir una forma adecuada de aceptar el recurso. Este comportamiento también se llama una forma pasiva de búsqueda.
DI (Inyección de dependencias): otra forma de expresar IOC: es decir, el componente acepta la inyección de recursos de contenedores como métodos predefinidos (por ejemplo, métodos setter). En comparación con IOC, este tipo de expresión es más directa.
2. Configuración de frijol
Método de configuración de Bean: por nombre completo de clase (reflexión), por método de fábrica (método de fábrica estático y método de fábrica de instancia), FactoryBean.
2.1 Spring configura las características de Bean a través del nombre completo de la clase (reflexión):
1. Basado en el archivo xml,
2. Reflejado por el nombre completo de la clase,
3. Confiando en el contenedor IOC,
4. Inyección de dependencia: inyección de atributos, inyección de constructor
Configuración de frijol basada en archivo xml
<bean id="helloworld" class="com.java.spring.HelloWorld">
<property name="name" value="koala"></property>
</bean>
id: el nombre del bean, que debe ser único en el contenedor IOC.
2.2 Configurar Bean a través del método de fábrica
2.2.1 Configure Bean llamando a la fábrica estática
Llamar a un método de fábrica estático para crear un bean es encapsular el proceso de creación de objetos en un método estático. Cuando el cliente necesita el objeto, solo necesita llamar al método estático sin preocuparse por los detalles de la creación del objeto.
Para declarar un bean creado por un método estático, debe especificar la clase que posee el método factory en el atributo de clase del bean, y especificar el nombre del método factory en el atributo factory-method. Finalmente, use el elemento <constrctor-arg> para el método Pasar parámetros del método.
Código de muestra:
Car.java
package com.java.spring.factory;
public class Car {
private String brand;
private double price;
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Car(String brand, double price) {
super();
this.brand = brand;
this.price = price;
}
@Override
public String toString() {
return "Car [brand=" + brand + ", price=" + price + "]";
}
}
StaticCarFactory.java
package com.java.spring.factory;
import java.util.HashMap;
import java.util.Map;
public class StaticCarFactory {
private static Map<String,Car> cars=new HashMap<String,Car>();
static{
cars.put("audi",new Car("audi",300000.00));
cars.put("ford",new Car("ford",400000.00));
}
//静态工厂方法
public static Car getCar(String name){
return cars.get(name);
}
}
Configure en beans-factory.xml:
<bean id="car1" class="com.java.spring.factory.StaticCarFactory" factory-method="getCar">
<constructor-arg value="audi"></constructor-arg>
</bean>
Instanciar frijol en el método principal:
package com.java.spring.factory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args){
ApplicationContext ctx=new ClassPathXmlApplicationContext("beans-factory.xml");
Car car1=(Car) ctx.getBean("car1");
System.out.println(car1);
}
}
Salida después de correr:
Car [brand=audi, price=300000.0]
El método de fábrica estático es llamar directamente al método estático de una clase para devolver la instancia de Bean. En el código anterior, la instancia de Bean se configura de acuerdo con el método de fábrica estático public static Car getCar (nombre de cadena).
2.2.2 Crear Bean llamando al método de fábrica de instancias
Método de fábrica de instancias: el proceso de creación de objetos se encapsula en otro método de instancia de objetos. Cuando el cliente necesita solicitar un objeto, solo necesita llamar al método de instancia sin preocuparse por los detalles de creación de objetos.
Para declarar el bean creado por el método de fábrica de instancias:
- Especifique el bean que posee el método factory en el atributo factory-bean del bean;
- Especifique el nombre del método de fábrica en el atributo factory-method;
- Use el elemento construtor-arg para pasar los parámetros del método para el método de fábrica;
InstanceCarFactory.java
package com.java.spring.factory;
import java.util.HashMap;
import java.util.Map;
public class InstanceCarFactory {
private static Map<String,Car> cars=null;
public InstanceCarFactory() {
cars=new HashMap<String,Car>();
cars.put("Audi",new Car("Audi",300000.00));
cars.put("Ford",new Car("Ford",400000.00));
}
public Car getCar(String brand){
return cars.get(brand);
}
}
Configure en beans-factory.xml:
//配置工厂的实例
<bean id="carFactory" class="com.java.spring.factory.InstanceCarFactory"></bean>
//通过实例工厂方法来配置bean
<bean id="car2" factory-bean="carFactory" factory-method="getCar">
<constructor-arg value="Ford"></constructor-arg>
</bean>
2.3 Implemente la interfaz FactoryBean para configurar Bean en el contenedor Spring IOC
Hay dos tipos de Beans en Spring, uno es Bean ordinario, el otro es Bean de fábrica, que es FactoryBean. El Bean Factory es diferente del Bean ordinario, el objeto que devuelve no es una instancia de la clase especificada, devuelve el Bean de fábrica El objeto devuelto por el método getObject.
package com.java.spring.FactoryBean;
import org.springframework.beans.factory.FactoryBean;
public class CarFactoryBean implements FactoryBean{
private String brand;
public void setBrand(String brand){
this.brand=brand;
}
@Override
//FactoryBean返回的实例
public Car getObject() throws Exception {
return new Car(brand,500000.00);
}
@Override
//FactoryBean返回的实例是否为单例
public boolean isSingleton() {
return false;
}
@Override
//FactoryBean返回的类型
public Class getObjectType() {
return Car.class;
}
}
Configure en beans-factory.xml:
<bean id="car3" class="com.java.spring.FactoryBean.CarFactoryBean">
<property name="brand" value="BWM"></property>
</bean>
Instanciar en el método principal:
Object car3= ctx.getBean("car3");
3. Obtener frijol
La implementación del contenedor IOC más comúnmente utilizada proporcionada por Spring es ApplicationContext. La clase de implementación principal de ApplicationContext ClassPathXmlApplicationContext carga los archivos de configuración de la ruta de clase.
Cree el objeto IOC de Spring:
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
Obtenga Bean del contenedor IOC: llame al método getBean () de ApplicationContext.
HelloWorld helloWorld=(HelloWorld) ctx.getBean("helloworld");
4. Inyección de dependencia de primavera
4.1 Inyección de atributos
La inyección de propiedad consiste en inyectar el valor de propiedad u objeto dependiente de Bean a través del método setter. El uso del elemento <property>, el uso del atributo name para especificar el nombre del atributo del bean y el atributo value o el subnodo <value> para especificar el valor del atributo son los métodos de inyección más comunes.
Por ejemplo:
<bean id="helloworld" class="com.java.spring.HelloWorld">
<property name="name" value="koala"></property>
</bean>
4.2 Método de construcción inyección
Mediante el método de construcción para inyectar el valor del atributo Bean o el objeto dependiente, se garantiza que la instancia de Bean se pueda usar después de la creación de instancias. La inyección de constructor declara atributos en el elemento <constructor-arg>, y no hay ningún atributo de nombre en <constructor-arg>.
Car.java
package com.java.spring;
public class Car {
private String brand;
private String corp;
private double price;
private int maxSpeed;
public Car(String brand, String corp, double price) {
super();
this.brand = brand;
this.corp = corp;
this.price = price;
}
public Car(String brand, String corp, int maxSpeed) {
super();
this.brand = brand;
this.corp = corp;
this.maxSpeed = maxSpeed;
}
@Override
public String toString() {
return "Car [brand=" + brand + ", corp=" + corp + ", price=" + price + ", maxSpeed=" + maxSpeed + "]";
}
}
4.2.1 Parámetros coincidentes por índice
Establecer en XML:
<bean id="car" class="com.java.spring.Car">
<constructor-arg value="Audi" index="0"></constructor-arg>
<constructor-arg value="上海" index="1"></constructor-arg>
<constructor-arg value="500000.0000" index="2"></constructor-arg>
</bean>
Obtenga la instancia de Bean en el método principal:
package com.java.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args){
//1.创建spring的IOC对象
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
//2.从IOC容器中获取bean实例
Car car=(Car) ctx.getBean("car");
System.out.println(car);
}
}
Salida después de correr:
Car [brand=Audi, corp=上海, price=500000.0, maxSpeed=0]
4.2.2 Parámetros coincidentes por tipo
Establecer en XML:
<bean id="car2" class="com.java.spring.Car">
<constructor-arg value="Audi" type="String"></constructor-arg>
<constructor-arg value="长春一汽" type="String"></constructor-arg>
<constructor-arg value="240" type="int"></constructor-arg>
</bean>
También puede usar el nodo secundario <valor> </ value> para asignar valores:
<bean id="car2" class="com.java.spring.Car">
<constructor-arg value="Audi" type="String"></constructor-arg>
<constructor-arg value="长春一汽" type="String"></constructor-arg>
<constructor-arg type="int">
<value>240</value>
</constructor-arg>
</bean>
Obtenga la instancia de Bean en el método principal:
package com.java.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args){
//1.创建spring的IOC对象
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
//2.从IOC容器中获取bean实例
Car car=(Car) ctx.getBean("car2");
System.out.println(car);
}
}
Salida después de correr:
Car [brand=Audi, corp=长春一汽, price=0.0, maxSpeed=240]
5. Referencia otros frijoles
5.1 referencia de referencia
Los beans que componen una aplicación a menudo necesitan colaborar entre sí para completar la función de la aplicación. Para permitir que los beans accedan entre sí, debe especificar una referencia al bean en el archivo de configuración del bean. En el archivo de configuración del bean, puede especificar una referencia al bean a través del elemento <ref> o el atributo ref para el atributo del bean o el parámetro constructor.
Crear una nueva clase de persona Person.java
package com.java.spring;
public class Person {
private String name;
private int age;
private Car car;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
}
}
Configure en xml: (El valor del valor solo puede ser un valor literal, es decir, el tipo de datos básico y su clase de encapsulación, String y otros tipos, valor no literal de Car, debe hacer referencia a otros beans a través de ref)
<bean id="person" class="com.java.spring.Person">
<property name="name" value="Tom"></property>
<property name="age" value="23"></property>
<property name="car" ref="car"></property>
</bean>
Obtenga la instancia de Bean en el método principal:
Person person=(Person) ctx.getBean("person");
Salida después de correr:
Person [name=Tom, age=23, car=Car [brand=Audi, corp=上海, price=500000.0, maxSpeed=0]]
5.2 Frijoles internos
Cuando la instancia de Bean solo se usa para un atributo específico, se puede declarar como un Bean interno. La declaración interna del bean está contenida directamente en el elemento <property> o <constructor-arg>, y no es necesario establecer ningún atributo de identificación o nombre. Los beans internos no se pueden usar en ningún otro lugar.
Para lograr las funciones anteriores, configure en XML:
<bean id="person1" class="com.java.spring.Person">
<property name="name" value="Tom"></property>
<property name="age" value="23"></property>
<property name="car">
<bean class="com.java.spring.Car">
<constructor-arg value="Audi" index="0"></constructor-arg>
<constructor-arg value="长春一汽" index="1"></constructor-arg>
<constructor-arg value="500000.0000" index="2"></constructor-arg>
</bean>
</property>
</bean>
6. Asignación de atributos en cascada
Al igual que Struts, Hiberante y otros marcos, Spring admite la configuración de propiedades en cascada.
<bean id="car" class="com.java.spring.Car">
<constructor-arg value="Audi" index="0"></constructor-arg>
<constructor-arg value="上海" index="1"></constructor-arg>
<constructor-arg value="500000.0000" index="2"></constructor-arg>
</bean>
<bean id="person" class="com.java.spring.Person">
<property name="name" value="Tom"></property>
<property name="age" value="23"></property>
<property name="car" ref="car"></property>
<property name="car.price" value="300000.0000"></property>
</bean>
La premisa del uso de la asignación de atributos en cascada es que el precio en el automóvil debe tener el método setPrice ().
Salida después de correr:
[name=Tom, age=23, car=Car [brand=Audi, corp=上海, price=300000.0, maxSpeed=0]]
7. Configuración de los atributos de la colección.
En Spring, se puede usar un conjunto de etiquetas xml integradas (por ejemplo: <list>, <set> o <map>) para configurar los atributos de la colección.
7.1 Para configurar propiedades de tipo java.util.List, debe especificar la etiqueta <list>, que contiene algunos elementos. Estas etiquetas pueden especificar valores constantes simples a través de <valor> y referencias a otros beans a través de <ref>. Especifique la definición del bean incorporado a través de <bean>. Especifique elementos vacíos con <null />. Incluso puedes insertar otras colecciones. La definición de matriz es la misma que Lista, y todos usan <lista>.
Código de muestra:
Person.java
package com.java.spring;
import java.util.List;
public class Person {
private String name;
private int age;
private List<Car> cars;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public List<Car> getCars() {
return cars;
}
public void setCars(List<Car> cars) {
this.cars = cars;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", cars=" + cars + "]";
}
}
Configurar en xml:
<bean id="person" class="com.java.spring.Person">
<property name="name" value="Tom"></property>
<property name="age" value="23"></property>
<property name="cars">
<list>
<ref bean="car"/>
<ref bean="car2"/>
</list>
</property>
</bean>
Obtenga la instancia de Bean en el método principal:
Person person=(Person) ctx.getBean("person");
Salida después de correr:
Person [name=Tom, age=23, cars=[Car [brand=Audi, corp=上海, price=500000.0, maxSpeed=0],
Car [brand=Audi, corp=长春一汽, price=0.0, maxSpeed=240]]]
7.2 Configure java.util.Set necesita usar la etiqueta <set>, el método para definir elementos es el mismo que List.
7.3 Java.util.Map se define mediante la etiqueta <map>. Se pueden usar múltiples <entry> como subetiquetas en la etiqueta <map>. Cada entrada contiene una clave y un valor, y la clave debe definirse en la etiqueta <key>. Debido a que no hay restricciones en los tipos de claves y valores, puede especificar libremente los elementos <value>, <ref>, <bean> o <null> para ellos. Puede definir la clave y el valor de Map como el atributo de <entry>: las constantes simples se definen utilizando key y value; la referencia de Bean se define mediante los atributos key-ref y value-ref.
Person.java
package com.java.spring;
import java.util.Map;
public class Person {
private String name;
private int age;
private Map<String,Car> cars;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Map<String,Car> getCars() {
return cars;
}
public void setCars(Map<String,Car> cars) {
this.cars = cars;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", cars=" + cars + "]";
}
}
Configurar en xml:
<bean id="person" class="com.java.spring.Person">
<property name="name" value="Tom"></property>
<property name="age" value="23"></property>
<property name="cars">
<map>
<entry key="A" value-ref="car"></entry>
<entry key="B" value-ref="car2"></entry>
</map>
</property>
</bean>
Obtenga la instancia de Bean en el método principal:
Person person=(Person) ctx.getBean("person");
Salida después de correr:
Person [name=Tom, age=23, cars={A=Car [brand=Audi, corp=上海, price=500000.0, maxSpeed=0],
B=Car [brand=Audi, corp=长春一汽, price=0.0, maxSpeed=240]}]
7.4 Use <props> para definir java.util.Properties. Esta etiqueta usa múltiples <prop> s como subetiquetas. Cada etiqueta <prop> debe definir un atributo clave.
DataSource.java
package com.java.spring;
import java.util.Properties;
public class DataSource {
private Properties properties;
public Properties getProperties() {
return properties;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
@Override
public String toString() {
return "DataSource [properties=" + properties + "]";
}
}
Configurar en xml:
<bean id="datasource" class="com.java.spring.DataSource">
<property name="properties">
<props>
<prop key="user">root</prop>
<prop key="password">1234</prop>
<prop key="jdbcUrl">jdbc:mysql:///test</prop>
<prop key="driverClass">com.mysql.jdbc.Driver</prop>
</props>
</property>
</bean>
Obtenga la instancia de Bean en el método principal:
package com.java.spring;
import java.util.Properties;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args){
//1.创建spring的IOC对象
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
//2.从IOC容器中获取bean实例
DataSource datasource= (DataSource) ctx.getBean(DataSource.class);
System.out.println(datasource);
}
}
Salida después de correr:
DataSource [properties={driverClass=com.mysql.jdbc.Driver, user=root, password=1234, jdbcUrl=jdbc:mysql:///test}]
8. Utilice el esquema de utilidad para definir la colección.
Cuando se usa una etiqueta de colección básica para definir una colección, la colección no se puede definir como un bean independiente, lo que da como resultado que otros beans no puedan hacer referencia a la colección, por lo que la colección no se puede compartir entre diferentes beans. La solución a este problema es utilizar las etiquetas de colección en el esquema de utilidades para definir beans de colección independientes. Debe tenerse en cuenta que la definición del esquema de utilidades debe agregarse al elemento raíz <beans>. Antes de usarlo, primero debe importar el espacio de nombres de la utilidad. El método de importación es el siguiente:
Código de muestra:
Configurar en xml:
<util:list id="cars">
<ref bean="car"/>
<ref bean="car2"/>
</util:list>
Puedes hacer referencia en otro Bean:
<bean id="person" class="com.java.spring.Person">
<property name="name" value="Tom"></property>
<property name="age" value="23"></property>
<property name="cars" ref="cars"></property>
</bean>
9. Usa el espacio de nombres p
Para simplificar la configuración de archivos XML, cada vez más archivos XML usan atributos en lugar de información de configuración de subelementos. Spring ha introducido un nuevo espacio de nombres p desde la versión 2.5. Puede configurar los atributos del bean a través de los atributos del elemento <bean>. Antes de usar, importe el espacio de nombres p como el espacio de nombres de utilidades. Este método de configuración es más conciso que el método de configuración tradicional.
<bean id="person" class="com.java.spring.Person" p:age="24" p:name="Tom" p:cars-ref="cars"></bean>
wx busca "koala programador", concéntrate en el campo de java, ¡un número público que crece contigo!
