spring3学习笔记之（spring core 之DI 更多知识点（依赖检查和方法注入））

以你之姓@ 2023-10-16 21:38 35阅读 0赞

#### 依赖检查 ####

上一节介绍的自动装配，很可能发生没有匹配的Bean进行自动装配，如果此种情况发生，只有在程序运行过程中发生了空指针异常才能发现错误，如果能提前发现该多好啊，这就是依赖检查的作用。

依赖检查：用于检查Bean定义的属性都注入数据了，不管是自动装配的还是配置方式注入的都能检查，如果没有注入数据将报错，从而提前发现注入错误，只检查具有setter方法的属性。

Spring3+也不推荐配置方式依赖检查了，建议采用Java5+ @Required注解方式，测试时请将XML schema降低为2.5版本的，和自动装配中“autodetect”配置方式的xsd一样。

<?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
    </beans>

依赖检查有none、simple、object、all四种方式，接下来让我们详细介绍一下：

一、none：默认方式，表示不检查；

二、objects：检查除基本类型外的依赖对象，配置方式为：dependency-check="objects"，此处我们为HelloApiDecorator添加一个String类型属性“message”，来测试如果有简单数据类型的属性为null，也不报错；

注意由于我们没有注入bean需要的依赖“helloApi”，所以应该抛出异常UnsatisfiedDependencyException，表示没有发现满足的依赖：

package cn.javass.spring.chapter3;
    import java.io.IOException;
    import org.junit.Test;
    import org.springframework.beans.factory.UnsatisfiedDependencyException;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class DependencyCheckTest {
    @Test(expected = UnsatisfiedDependencyException.class)
    public void testDependencyCheckByObject() throws IOException {
    //将抛出异常
        new ClassPathXmlApplicationContext("chapter3/dependency-check-object.xml");
        }
    }

三、simple： 对基本类型进行依赖检查，包括数组类型，其他依赖不报错；配置方式为：dependency-check="simple"，以下配置中没有注入message属性，所以会抛出异常：

四、all ：对所以类型进行依赖检查，配置方式为：dependency-check="all"，如下配置方式中如果两个属性其中一个没配置将报错。

依赖检查也可以通过“<beans>”标签中default-dependency-check属性来指定全局依赖检查配置。

#### 方法注入 ####

所谓方法注入其实就是通过配置方式覆盖或拦截指定的方法，通常通过代理模式实现。Spring提供两种方法注入：查找方法注入和方法替换注入。

因为Spring是通过CGLIB动态代理方式实现方法注入，也就是通过动态修改类的字节码来实现的，本质就是生成需方法注入的类的子类方式实现。

在进行测试之前，我们需要确保将“com.springsource.cn.sf.cglib-2.2.0.jar”放到lib里并添加到“Java Build Path”中的Libararies中。否则报错，异常中包含“nested exception is java.lang.NoClassDefFoundError: cn/sf/cglib/proxy/CallbackFilter”

![Center][]

传统方式和Spring容器管理方式唯一不同的是不需要我们手动生成子类，而是通过配置方式来实现；其中如果要替换createPrinter()方法的返回值就使用查找方法注入；如果想完全替换sayHello()方法体就使用方法替换注入。 接下来让我们看看具体实现吧。

一、查找方法注入：又称为Lookup方法注入，用于注入方法返回结果，也就是说能通过配置方式替换方法返回结果。使用<lookup-method name="方法名" bean="bean名字"/>配置；其中name属性指定方法名，bean属性指定方法需返回的Bean。

方法定义格式：访问级别必须是public或protected，保证能被子类重载，可以是抽象方法，必须有返回值，必须是无参数方法，查找方法的类和被重载的方法必须为非final：

<public|protected> \[abstract\] <return-type> theMethodName(no-arguments);

因为“singleton”Bean在容器中只有一个实例，而“prototype”Bean是每次获取容器都返回一个全新的实例，所以如果“singleton”Bean在使用“prototype” Bean情况时，那么“prototype”Bean由于是“singleton”Bean的一个字段属性，所以获取的这个“prototype”Bean就和它所在的“singleton”Bean具有同样的生命周期，所以不是我们所期待的结果。因此查找方法注入就是用于解决这个问题。

1） 首先定义我们需要的类，Printer类是一个有状态的类，counter字段记录访问次数：

package cn.javass.spring.chapter3.bean;
    public class Printer {
        private int counter = 0;
        public void print(String type) {
            System.out.println(type + " printer: " + counter++);
        }
    }

HelloImpl5类用于打印欢迎信息，其中包括setter注入和方法注入，此处特别需要注意的是该类是抽象的，充分说明了需要容器对其进行子类化处理，还定义了一个抽象方法createPrototypePrinter用于创建“prototype”Bean，createSingletonPrinter方法用于创建“singleton”Bean，此处注意方法会被Spring拦截，不会执行方法体代码：

package cn.javass.spring.chapter3;
    import cn.javass.spring.chapter2.helloworld.HelloApi;
    import cn.javass.spring.chapter3.bean.Printer;
    public abstract class HelloImpl5 implements HelloApi {
        private Printer printer;
        public void sayHello() {
            printer.print("setter");
            createPrototypePrinter().print("prototype");
        }
        public abstract Printer createPrototypePrinter();
        public Printer createSingletonPrinter() {
            System.out.println("该方法不会被执行，如果输出就错了");
            return new Printer();
        }
        public void setPrinter(Printer printer) {
            this.printer = printer;
        }
    }

2） 开始配置了，配置文件在（resources/chapter3/lookupMethodInject.xml），其中“prototypePrinter”是“prototype”Printer，“singletonPrinter”是“singleton”Printer，“helloApi1”是“singleton”Bean，而“helloApi2”注入了“prototype”Bean：

3）测试代码如下：

package cn.javass.spring.chapter3;
    import org.junit.Test;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import cn.javass.spring.chapter2.helloworld.HelloApi;
    public class MethodInjectTest {
    @Test
    public void testLookup() {
    ClassPathXmlApplicationContext context =
    new ClassPathXmlApplicationContext("chapter3/lookupMethodInject.xml");
            System.out.println("=======singleton sayHello======");
            HelloApi helloApi1 = context.getBean("helloApi1", HelloApi.class);
            helloApi1.sayHello();
            helloApi1 = context.getBean("helloApi1", HelloApi.class);
            helloApi1.sayHello();
            System.out.println("=======prototype sayHello======");
            HelloApi helloApi2 = context.getBean("helloApi2", HelloApi.class);
            helloApi2.sayHello();
            helloApi2 = context.getBean("helloApi2", HelloApi.class);
            helloApi2.sayHello();
    }}

其中“helloApi1”测试中，其输出结果如下：

=======singleton sayHello======
    setter printer: 0
    prototype printer: 0
    singleton printer: 0
    setter printer: 1
    prototype printer: 0
    singleton printer: 1

首先“helloApi1”是“singleton”，通过setter注入的“printer”是“prototypePrinter”，所以它应该输出“setter printer:0”和“setter printer:1”；而“createPrototypePrinter”方法注入了“prototypePrinter”，所以应该输出两次“prototype printer:0”；而“createSingletonPrinter”注入了“singletonPrinter”，所以应该输出“singleton printer:0”和“singleton printer:1”。

而“helloApi2”测试中，其输出结果如下：

=======prototype sayHello======
    setter printer: 0
    prototype printer: 0
    singleton printer: 2
    setter printer: 0
    prototype printer: 0
    singleton printer: 3

首先“helloApi2”是“prototype”，通过setter注入的“printer”是“prototypePrinter”，所以它应该输出两次“setter printer:0”；而“createPrototypePrinter”方法注入了“prototypePrinter”，所以应该输出两次“prototype printer:0”；而“createSingletonPrinter”注入了“singletonPrinter”，所以应该输出“singleton printer:2”和“singleton printer:3”。

大家是否注意到“createSingletonPrinter”方法应该输出“该方法不会被执行，如果输出就错了”，而实际是没输出的，这说明Spring拦截了该方法并使用注入的Bean替换了返回结果。

方法注入主要用于处理“singleton”作用域的Bean需要其他作用域的Bean时，采用Spring查找方法注入方式无需修改任何代码即能获取需要的其他作用域的Bean。

**二、替换方法注入**：也叫“MethodReplacer”注入，和查找注入方法不一样的是，他主要用来替换方法体。通过首先定义一个MethodReplacer接口实现，然后如下配置来实现：

<replaced-method name="方法名" replacer="MethodReplacer实现">
    <arg-type>参数类型</arg-type>
    </replaced-method>”

1）首先定义MethodReplacer实现，完全替换掉被替换方法的方法体及返回值，其中reimplement方法重定义方法 功能，参数obj为被替换方法的对象，method为被替换方法，args为方法参数；最需要注意的是不能再 通过“method.invoke(obj, new String\[\]\{"hehe"\});” 反射形式再去调用原来方法，这样会产生循环调用；如果返回值类型为Void，请在实现中返回null：

package cn.javass.spring.chapter3.bean;
    import java.lang.reflect.Method;
    import org.springframework.beans.factory.support.MethodReplacer;
    public class PrinterReplacer implements MethodReplacer {
        @Override
        public Object reimplement(Object obj, Method method, Object[] args)   throws Throwable {
            System.out.println("Print Replacer");
            //注意此处不能再通过反射调用了,否则会产生循环调用，知道内存溢出
            //method.invoke(obj, new String[]{"hehe"});
            return null;
        }
    }

2）配置如下，首先定义MethodReplacer实现，使用< replaced-method >标签来指定要进行替换方法，属性name指定替换的方法名字，replacer指定该方法的重新实现者，子标签< arg-type >用来指定原来方法参数的类型，必须指定否则找不到原方法：

<bean id="replacer" class="cn.javass.spring.chapter3.bean.PrinterReplacer"/>
    <bean id="printer" class="cn.javass.spring.chapter3.bean.Printer">
    <replaced-method name="print" replacer="replacer">
            <arg-type>java.lang.String</arg-type>
        </replaced-method>
    </bean>

3）测试代码将输出“Print Replacer ”，说明方法体确实被替换了：

@Test
    public void testMethodReplacer() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("chapter3/methodReplacerInject.xml");
        Printer printer = context.getBean("printer", Printer.class);
        printer.print("我将被替换");
    }

[Center]: https://img-blog.csdn.net/20150522011223638?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvemhvdXpoaXdlbmdhbmc=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center