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 beanDefins = new ArrayList();

Map sigletons = new HashMap();

/**

* 完成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 nsMap = new HashMap();

nsMap.put("ns", "http://www.springframework.org/schema/beans");//加入命名空间

XPath xsub = document.createXPath("//ns:beans/ns:bean");//创建beans/bean的查询路径

xsub.setNamespaceURIs(nsMap);//设置命名空间

List 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 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文件的配置

"1.0" encoding="UTF-8"?>

"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">



      "collectionService" class="com.gaoyuan.service.impl.CollectionServiceImpl">

       "sets">



       set1

       set2

       set3





       "lists">



       list1

       list2

       list3





       "properties">



       "pro1">pro1

       "pro2">pro2

       "pro3">pro3





       "maps">



       "map1" value="map-1"/>

       "map2" value="map-2"/>

       "map3" value="map-3"/>

测试代码：

（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）.测试代码：

Spring学习笔记（二）-依赖注入详解

1.依赖注入

你可能感兴趣的:(Spring学习笔记（二）-依赖注入详解)