1.依赖注入
有两种注入方式：
（1）.bean.xml中的配置：（这是方式一的注入）
（2）.对应的java代码
1）.首先是定义DAO层接口：
2）.接口实现类
3）.业务层接口
4）.业务层实现类（重点来了，业务层要用DAO层方法，用依赖注入实现）
看上面的代码，和之前没有使用spring时的对比，可以很明显看出，没有new BeanDao的实现类，而只是将其定义为业务层实现类的属性，并且给提供了set和get方法（备注，必须提供给set和get方法，因为spring解析完bean.xml文件之后，得给属性（BeanDao）赋值【也就是将在spring容器中找到的对应的实例赋给此处的属性】，所以必须得提供），在其业务层实现类中的方法中就直接可以调用dao层的方法了。
5）.测试代码看配置是否成功：
（3）.使用内部bean的方式注入（上面截图的方式2）
Bean.xml的配置如下：
（4）.基本类的注入就直接看上面的截图就好了，如果想代码实现的话，记得给字段提供set，get方法。
（5）依赖注入的原理（spring是如何实现）
package com.gaoyuan.junit.test;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.beanutils.ConvertUtils;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
/**
* 模拟spring是如何读取beans.xml文件的
* @author G_yuan
*
*/
public class ClassPathXMLApplicationContextByME {
List<BeanDefinition> beanDefins = new ArrayList<BeanDefinition>();
Map<String,Object> sigletons = new HashMap<String,Object>();
/**
* 完成bean的实例化
* @param fileName
* @throws ClassNotFoundException
* @throws IllegalAccessException
* @throws Exception
*/
private void instanceBean() throws Exception{
for(BeanDefinition be :beanDefins){
if(be.getClazz()!=null && !"".equals(be.getClazz().trim()) ){
sigletons.put(be.getId(), Class.forName(be.getClazz()).newInstance());
}
}
}
/**
* 类初始化时的要加载xml文件和实例化xml文件中配置的bean
* @param fileName
* @throws Exception
*/
public ClassPathXMLApplicationContextByME(String fileName) throws Exception{
this.readXML(fileName);
this.instanceBean();
this.injectObject();
}
/**
* 注入方法
*/
private void injectObject() {
for(BeanDefinition beanDefinition :beanDefins){
Object bean = sigletons.get(beanDefinition.getId());
if(bean !=null){
try {
//得到bean类的属性
PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
//循环读取xml文件得到的property属性
for(PropertyDefinition propertyDefinition : beanDefinition.getPropertys()){
//循环类的属性值与读取xml文件中得到的属性值进行对比,如果一致，取得setter方法进行注入
for(PropertyDescriptor properdesc : ps){
if(propertyDefinition.getName().equals(properdesc.getName())){
Method setter = properdesc.getWriteMethod();//获得属性的setter方法
if(setter!=null){
Object value = null;
if(propertyDefinition.getRef()!=null && !"".equals(propertyDefinition.getRef().trim())){
value = sigletons.get(propertyDefinition.getRef());
}else{
//此处是基本类型值的注入，用到了Apache的commons-beanutils-1.8.0.jar，用下面的方法可以
//将从property文中读取的值转换成java类做需要的类型
value = ConvertUtils.convert(propertyDefinition.getValue(),properdesc.getPropertyType());
}
setter.setAccessible(true);//如果属性的setter方法是private，将setter的setAccessible方法设置成true，对权限没有控制
setter.invoke(bean, value);//吧引用对象注入给属性
}
break;
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
/**
* 读取xxxBean.xml文件
* @param fileName
*/
private void readXML(String fileName) {
SAXReader saxReader = new SAXReader();
Document document = null;
try {
URL xmlPath = this.getClass().getClassLoader().getResource(fileName);
document = saxReader.read(xmlPath);
Map<String , String> nsMap = new HashMap<String, String>();
nsMap.put("ns", "http://www.springframework.org/schema/beans");//加入命名空间
XPath xsub = document.createXPath("//ns:beans/ns:bean");//创建beans/bean的查询路径
xsub.setNamespaceURIs(nsMap);//设置命名空间
List<Element> beans = xsub.selectNodes(document); //获取文档下的所有bean节点
for(Element element : beans){
String id = element.attributeValue("id");//获取id属性值
String clazz = element.attributeValue("class");//获取class属性值
BeanDefinition beanDefinition = new BeanDefinition(id, clazz);
XPath propertysub = element.createXPath("ns:property");
propertysub.setNamespaceURIs(nsMap);//设置命名空间
List<Element> propertys = propertysub.selectNodes(element);
for(Element property : propertys){
String propertyName = property.attributeValue("name");
String propertyRef = property.attributeValue("ref");
PropertyDefinition propertyDefinition = new PropertyDefinition(propertyName,propertyRef);
beanDefinition.getPropertys().add(propertyDefinition);
}
beanDefins.add(beanDefinition);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 模拟ClassPathXmlApplicationContext中的getBean()方法。
* @param beanName
* @return
*/
public Object getBean(String beanName){
return this.sigletons.get(beanName);
}
}
（6）.集合的注入
1）.CollectionServiceImpl.java代码：
2）.CollectionService接口的定义：
3）.bean.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-2.5.xsd">
<!--集合的注入 -->
<bean id="collectionService" class="com.gaoyuan.service.impl.CollectionServiceImpl">
<property name="sets">
<set>
<value>set1</value>
<value>set2</value>
<value>set3</value>
</set>
</property>
<property name="lists">
<list>
<value>list1</value>
<value>list2</value>
<value>list3</value>
</list>
</property>
<property name="properties">
<props>
<prop key="pro1">pro1</prop>
<prop key="pro2">pro2</prop>
<prop key="pro3">pro3</prop>
</props>
</property>
<property name="maps">
<map>
<entry key="map1" value="map-1"/>
<entry key="map2" value="map-2"/>
<entry key="map3" value="map-3"/>
</map>
</property>
</bean>
</beans>
测试代码：
（7）.构造器注入
1）.PersonServiceImpl.java代码
2）.benDao和上面的一致，就不写了。
3）.bean.xml的配置
（8）.注解的注入
注解在xml文件中需要加的命名空间和xsd
xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
（9）.注解的与原理
1）.编写一个注解类：ItcastResource.java
package com.gaoyuan.junit.test;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//指定注解的信息保存在什么地方，如果指定保存在运行期时，在源代码中也存在注解，在编译后的class文件中也存在注解，运行期也会把注解信息加载进去
@Retention(RetentionPolicy.RUNTIME)
//表示注解可以标注在什么地方，比如是字段上，还是类型上，还是属性上，也就是所说的在set方法上，还是类上面等。下面的例子是标注在字段和属性上。
@Target({ElementType.FIELD,ElementType.METHOD})
public @interface ItcastResource {
//因为注解可以指定name属性，所以此注解中需要有个name属性
public String name() default "";
}
2）.编写处理注解的处理器方法：
/**
* 注解的原理（注解的处理器方法）
*/
private void annotationInject() {
for(String beanName : sigletons.keySet() ){
Object bean = sigletons.get(beanName);
if(bean!=null){
try {
//得到bean类的属性
PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
for(PropertyDescriptor properdesc : ps){
Method setter = properdesc.getWriteMethod();//获取到属性的setter方法
//判断这个属性方法上是否有自己编写的注解（ItcastResource）
if(setter !=null && setter.isAnnotationPresent(ItcastResource.class)){
ItcastResource resource = setter.getAnnotation(ItcastResource.class); // 取得注解对象
//因为用注解的方式进行注入时，可以在@XXX后面加name属性，此处判断的name的值就是，如果直接在后面写了name的值时，直接判断name的值在
//spring容器中是否有与之对应的实例存在，如果存在直接注入
Object value = null;
if(resource.name()!=null && !"".equals(resource.name())){
String name = resource.name();
value = sigletons.get(name);
}else{
//如果写注解时没有提供name属性值，那就通过得到的类的属性的名字去spring中寻找实例。
value = sigletons.get(properdesc.getName());
if(value == null){
//如果根据类的属性名字还没有找到的话，就遍历spring容器中所有的实例，与从上面得到的bean类的属性的类型进行匹配
for(String key : sigletons.keySet()){
if(properdesc.getPropertyType().isAssignableFrom(sigletons.get(key).getClass())){
value = sigletons.get(key);
break;
}
}
}
}
setter.setAccessible(true);//如果属性的setter方法是private，将setter的setAccessible方法设置成true，对权限没有控制
setter.invoke(bean, value);//把引用对象注入给属性
}
}
//上面是在属性上面写注解之后的处理，下面写当注解写在字段上面时的处理方法。
Field[] fields = bean.getClass().getDeclaredFields(); //得到所有的字段
for(Field field : fields){
if(field.isAnnotationPresent(ItcastResource.class)){
//说明字段上有注解
ItcastResource resource = field.getAnnotation(ItcastResource.class);
Object value = null;
if(resource.name()!=null && !"".equals(resource.name())){
//说明注解上有name属性
value = sigletons.get(resource.name());
}else{
//value的值直接从用字段的名字从spring中找
value = sigletons.get(field.getName());
if(value == null){
for(String key : sigletons.keySet()){
if(field.getType().isAssignableFrom(sigletons.get(key).getClass())){
value = sigletons.get(key);
break;
}
}
}
}
field.setAccessible(true);//如果属性的setter方法是private，将setter的setAccessible方法设置成true，对权限没有控制
field.set(bean, value);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
3）.在其他java文件中利用自己写的注解
（10）.自动装配
自动装配时，不需要在java代码中写其他东西，直接在bean.xml文件中配置即可，配置方法既是上面截图。
（11）.通过在classpath自动扫描方式把组件纳入spring容器中管理：
1).bean.xml
2）.xxxxserviceImpl.java（service层代码）
3）..xxxDaoImpl.java（dao层代码）
4）.测试代码：
