关于spring中的依赖性注入的几种方法的见解
IOC（inversion of Control）：
是一种反转资源的获取方向，是容器主动提供组件获取的资源，而并非是自己创建。 组件所要做的就是选择一种方式来接收这个资源。
DI(Dependency injection)：
组件以一些先定义好方式（例如setter方法）来接受来自容器的资源的注入
自认为是一种反射的机制。
注入演示
ioc：
二：配置bean
基于xml文件的注入
中的一些bean的一些注意的事项和细节有代码的形式来呈现：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
<!-- 配置一个 bean -->
<bean id="helloWorld" class="com.liusir.beans.HelloWorld">
</bean>
<!-- 配置一个 bean -->
<bean id="helloWorld2" class="com.liusir.beans.HelloWorld">
<!-- 为属性赋值 -->
<!-- 通过属性注入: 通过 setter 方法注入属性值 -->
<property name="user" value="Tom"></property>
</bean>
<!-- 通过构造器注入属性值 -->
<bean id="helloWorld3" class="com.liusir.beans.HelloWorld">
<!-- 要求: 在 Bean 中必须有对应的构造器. -->
<constructor-arg value="Mike"></constructor-arg>
</bean>
<!-- 若一个 bean 有多个构造器, 如何通过构造器来为 bean 的属性赋值 -->
<!-- 可以根据 index 和 value 进行更加精确的定位. (了解) -->
<bean id="car" class="com.liusir.beans.Car">
<constructor-arg value="KUGA" index="1"></constructor-arg>
<constructor-arg value="ChangAnFord" index="0"></constructor-arg>
<constructor-arg value="250000" type="float"></constructor-arg>
</bean>
<bean id="car2" class="com.liusir.beans.Car">
<constructor-arg value="ChangAnMazda"></constructor-arg>
<!-- 若字面值中包含特殊字符, 则可以使用 DCDATA 来进行赋值. (了解) -->
<constructor-arg>
<value><![CDATA[<ATARZA>]]></value>
</constructor-arg>
<constructor-arg value="180" type="int"></constructor-arg>
</bean>
<!-- 配置 bean -->
<bean id="dao5" class="com.liusir.ref.Dao"></bean>
<bean id="service" class="com.liusir.ref.Service">
<!-- 通过 ref 属性值指定当前属性指向哪一个 bean! -->
<property name="dao" ref="dao5"></property>
</bean>
<!-- 声明使用内部 bean -->
<bean id="service2" class="com.liusir.ref.Service">
<property name="dao">
<!-- 内部 bean, 类似于匿名内部类对象. 不能被外部的 bean 来引用, 也没有必要设置 id 属性 -->
<bean class="com.liusir.ref.Dao">
<property name="dataSource" value="c3p0"></property>
</bean>
</property>
</bean>
<bean id="dao2" class="com.liusir.ref.Dao">
<!-- 为 Dao 的 dataSource 属性赋值为 null, 若某一个 bean 的属性值不是 null, 使用时需要为其设置为 null(了解) -->
<property name="dataSource"><null/></property>
</bean>
<!-- 装配集合属性 -->
<bean id="user" class="com.liusir.beans.User">
<property name="userName" value="Jack"></property>
<property name="cars">
<!-- 使用 list 元素来装配集合属性 -->
<list>
<ref bean="car"/>
<ref bean="car2"/>
</list>
</property>
</bean>
<!-- 声明集合类型的 bean -->
<util:list id="cars">
<ref bean="car"/>
<ref bean="car2"/>
</util:list>
<bean id="user2" class="com.liusir.beans.User">
<property name="userName" value="Rose"></property>
<!-- 引用外部声明的 list -->
<property name="cars" ref="cars"></property>
</bean>
<bean id="user3" class="com.liusir.beans.User"
p:cars-ref="cars" p:userName="Titannic"></bean>
<!-- bean 的配置能够继承吗 ? 使用 parent 来完成继承 -->
<bean id="user4" parent="user" p:userName="Bob"></bean>
<bean id="user6" parent="user" p:userName="维多利亚"></bean>
<!-- 测试 depents-on -->
<bean id="user5" parent="user" p:userName="Backham" depends-on="user6"></bean>
<util:properties>
<prop key="liusir" >
</prop>
</util:properties>
<!--用的是 util的独立的部分 可一再beans中共享 -->
<util:map>
<entry key="liusir" value-ref="car1"></entry>
<entry key="liudi" value-ref="car2"></entry>
</util:map>
<util:properties>
<prop key="name"> liusir</prop>
<prop key="user">lsiduf</prop>
</util:properties>
</beans>
在ioc容器中需要实例化在spring中
：ApplicationContext
//1. 创建 Spring 的 IOC 容器
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
//2. 从 IOC 容器中获取 bean 的实例
HelloWorld helloWorld = (HelloWorld) ctx.getBean("helloWorld3");
在ioc容器中获取bean的方法有
有两种注入的方式
第一种是属性注入
第二种是构造器注入
注入的细节在上面的基于xml文件的注入代码中已经呈现
--------------------------------------------------------------
关于使用xml配置中的自动专配的问题
第一点: byType
第二点: byName
--------------------------------------------------------------
继承bean的配置
<bean id="car" class="com.liusir.autowire.Car">
<property name="company" value="aodi"></property>
<property name="brand" value="beijing"></property>
<property name="maxSpeed" value="240"></property>
<property name="price" value="50000"></property>
</bean>
<!--继承相当于其中的属性归为及有，并且可以进行覆盖 -->
<bean id="user" abstract="true">
<property name="name" value="liudi" ></property>
</bean>
<bean id="user2" autowire="byType" class="com.liusir.extend.User" parent="user">
</bean>
-------------------------------------------------------------
使用外部的属性文件
<context:property-placeholder location="classpath:db.properties"/>
<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="${jdbc.user}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="driverClass" value="${jdbc.driverClass}"></property>
<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
<property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>
<property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
</bean>
--------------------------------------------------------------------------------
通过工厂方法进行注入
第一种：静态的工厂方法
bean类:
package com.liusir.Factory;
import java.util.HashMap;
import java.util.Map;
public class staticFactory {
private static Map<String,Car> cars=new HashMap<>();
static {
cars.put("audi",new Car("audi",30000.0f));
cars.put("baoma", new Car("baoma",40000.f));
}
public static Car getcar(String name) {
return cars.get(name);
}
}
xml 配置文件：
<!-- 静态的工厂方法 -->
<bean id="car" class="com.liusir.Factory.staticFactory" factory-method="getcar">
<constructor-arg value="audi"></constructor-arg>
</bean>
第二种实例工厂方法
bean类
package com.liusir.Factory;
import java.util.HashMap;
import java.util.Map;
public class InstanceFactory {
private Map<String, Car> cars = null;
public InstanceFactory() {
cars = new HashMap<>();
cars.put("audi", new Car("audi", 30000.0f));
cars.put("baoma", new Car("baoma", 40000.f));
}
public Car getcar(String name) {
return cars.get(name);
}
}
xml配置文件：
<!-- 配置工厂实例 -->
<bean id="instanceFactory" class="com.liusir.Factory.InstanceFactory" ></bean>
<!-- 实例的工厂方法 来配置bean -->
<bean id="car2" factory-bean="instanceFactory" factory-method="getcar">
<constructor-arg value="baoma"></constructor-arg>
</bean>
第三种是factorybean
bean 类：
package com.liusir.Factory;
import org.springframework.beans.factory.FactoryBean;
public class CarFactoryBean implements FactoryBean{
private String brand;
public void setBrand(String brand) {
this.brand = brand;
}
@Override
public Car getObject() throws Exception {
return new Car(brand,500000f);
}
@Override
public Class<?> getObjectType() {
// TODO Auto-generated method stub
return Car.class;
}
@Override
public boolean isSingleton() {
// TODO Auto-generated method stub
return true;
}
}
xml文件的配置:
<!-- 通过factorybean来配置 -->
<bean id="car3" class="com.liusir.Factory.CarFactoryBean">
<property name="brand" value="BWM"></property>
</bean>
第四种是泛型依赖注入
用到的细节有
<context:component-scan base-package="com.liusir.annotation"
> </context:component-scan>
其中隐含的几个细节的方法
用源码来解释一番：
<!-- exclude-filter:子节点指定排除那些指定的表达式组件 -->
<!-- include-filter:表达式指定包含那些指定的表达式组建use-default-filters配合来使用 -->
<!--
<context:component-scan
base-package="com.liusir.annotation" use-default-filters="false">
<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Respository" />
-->
<!--
<context:include-filter type="annotation"
expression="com.liusir.annotation.Controllar.ControllerTest" />
-->
<!--
<context:include-filter type="assignable"
expression="com.liusir.annotation.Controllar.ControllerTest" />
-->
@autowired 自动装配
package com.liusir.annotation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import com.liusir.annotation.Controllar.ControllerTest;
//自动装配
/*
* bean之间的联系 ： 可以有两种方式
* >用Autowired:如果是多个bean，则属性名字要保持一致
* >用Autowired Qualifiter：是表示bean的名称
*/
@Component
public class ObjectTest {
@Autowired
@Qualifier("controllerTest")
private ControllerTest controllerTest;
public void test() {
controllerTest.test();
}
}
扫一扫
1594
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
