程序员必看| mockito原理浅析

最新推荐文章于 2024-05-16 05:28:08 发布
最新推荐文章于 2024-05-16 05:28:08 发布
阅读量4.3k 收藏 13
点赞数 4
原文链接：https://github.com/luoxn28/warm/blob/master/java/mockito原理浅析.md
版权

戳蓝字「TopCoder」关注我们哦！

编者注：mockito是一个单测mock框架，上手简单，Java开发人员必备工具~

mockito官网：http://mockito.org，API文档：

http://docs.mockito.googlecode.com/hg/org/mockito/Mockito.html，

项目源码：https://github.com/mockito/mockito。

mockito基础

在写单元测试的过程中，我们往往会遇到要测试的类有很多依赖，这些依赖的类/对象/资源又有别的依赖，从而形成一个大的依赖树，要在单元测试的环境中完整地构建这样的依赖，是一件很困难的事情。因此需要mock数据隔离各种依赖，方便单测独立的代码逻辑。比如：

为了测试class A，需要隔离class C和class B，因此需要mock B和C，如下：

mock与stub：

stub也就是常说的打桩，针对某些入参返回自定义数据；mock也就是mock类，默认返回空数据（一般是null）。

常见的几个mockito注解：


   
   

    
    
@Spy 

    
    
Xxx$MockitoMock$10456154 -- 为null时默认注入mock对象 

    
    
Xxx$$EnhancerByCGLIB$$ab5d0f7d -- 非null时注入实际对象 

    
    
@Mock 

    
    
Xxx$MockitoMock$1251285143 -- （不管是否为null都）注入mock对象 

    
    
@InjectMocks 

    
    
InjectMocks创建这个类的对象并自动将标记@Mock、@Spy等注解的属性值注入到这个中

 

使用示例：


   
   

    
    
import org.junit.Test;

    
    
import org.junit.runner.RunWith;

    
    
import org.mockito.InjectMocks;

    
    
import org.mockito.Mock;

    
    
import org.mockito.Mockito;

    
    
import org.mockito.Spy;

    
    
import org.mockito.junit.MockitoJUnitRunner;

    
    
import javax.annotation.Resource;

    
    
/**

    
    
 * @author luoxiangnan

    
    
 * @date 2019-10-17

    
    
 */

    
    
@RunWith(MockitoJUnitRunner.class)

    
    
public class MockitoMain {

    
    
    public static interface DubboRemoteFacade {

    
    
        String world(String param);

    
    
    }

    
    
    public static interface DubboLocalFacade {

    
    
        String hello(String param);

    
    
    }

    
    
    public static class DubboLocalFacadeImpl implements DubboLocalFacade {

    
    
        @Resource

    
    
        private DubboRemoteFacade dubboRemoteFacade;

    
    
        @Override

    
    
        public String hello(String param) {

    
    
            return dubboRemoteFacade.world(param);

    
    
        }

    
    
    }

    
    
    @InjectMocks

    
    
    private DubboLocalFacadeImpl dubboLocalFacade;

    
    
    // @Spy方式一

    
    
//    @Spy

    
    
//    private DubboRemoteFacade dubboRemoteFacade;

    
    
    // @Spy方式二

    
    
//    @Spy

    
    
//    private DubboRemoteFacade dubboRemoteFacade = new DubboRemoteFacade() {

    
    
//        @Override

    
    
//        public String world(String param) {

    
    
//            return "default";

    
    
//        }

    
    
//    };

    
    
    @Mock

    
    
    private DubboRemoteFacade dubboRemoteFacade;

    
    
    @Test

    
    
    public void test() {

    
    
        Mockito.when(dubboRemoteFacade.world("aaa")).thenReturn("111");

    
    
        Mockito.when(dubboRemoteFacade.world("bbb")).thenReturn("222");

    
    
        /**

    
    
         * @Spy方式一   111   null

    
    
         * @Spy方式二   111   null

    
    
         * @Mock方式   111   null

    
    
         */

    
    
        System.out.println(dubboLocalFacade.hello("aaa"));

    
    
        System.out.println(dubboLocalFacade.hello("fasd")); // null

    
    
    }

    
    
}

Mockito主要就是通过Stub打桩，通过方法名加参数来准确的定位测试桩然后返回预期的值。看到上面代码中的 Mockito.when(dubboRemoteFacade.world("aaa")).thenReturn("111")，不知道小伙伴有没有这样的疑问？

Mockito.when消费的是方法的返回值，对方法内部并不感知，那么它是如何来准确通过方法名+参数的条件来打桩的。

其实，Mock本质上是一个Proxy代理模式的应用。如果Mockito.when传入的是一个普通对象的方法，那么只消费方法返回值是无法完成对该方法打桩的。所以Mockito本质上就是在代理对象调用方法前，用stub的方式设置其返回值，然后在真实调用时，用代理对象返回起预设的返回值。

再分析mockito原理之前，我们先看下mockito用于创建代理类（生成字节码）的工具---bytebuddy，了解下bytebuddy之后对于下面分析mockito原理会很有帮助。

bytebuddy

Byte Buddy是致力于解决字节码操作和 instrumentation API 的复杂性的开源框架。Byte Buddy 所声称的目标是将显式的字节码操作隐藏在一个类型安全的领域特定语言背后。通过使用 Byte Buddy，任何熟悉 Java 编程语言的人都有望非常容易地进行字节码操作。

Byte Buddy是一个较高层级的抽象的字节码操作工具，相较于ASM而言。其实吧，Byte Buddy 本身也是基于 ASM API 实现的。更多资料请参考：https://www.infoq.cn/article/Easily-Create-Java-Agents-with-ByteBuddy

如下的示例展现了如何生成一个简单的类，这个类是 Object 的子类，并且重写了 toString 方法，用来返回“Hello World!”。与原始的 ASM 类似，“intercept”会告诉 Byte Buddy 为拦截到的指令提供方法实现：


   
   

    
    
Class<?> dynamicType = new ByteBuddy()

    
    
        .subclass(Object.class)

    
    
        .method(ElementMatchers.named("toString"))

    
    
        .intercept(FixedValue.value("Hello World!"))

    
    
        .make()

    
    
        .load(Object.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)

    
    
        .getLoaded();

    
    
        

    
    
System.out.println(dynamicType.getSimpleName());

    
    
// 输出：Object$ByteBuddy$cmpHDO82

 

比如我们想看下上述示例中生成的动态类到底长什么样子，可以调用方法 net.bytebuddy.dynamic.DynamicType#saveIn 来将生成的class保存成class文件（可在debug时再watcher中调用saveIn方法），然后在IDEA中进行查看，如下所示：


   
   

    
    
//

    
    
// Source code recreated from a .class file by IntelliJ IDEA

    
    
// (powered by Fernflower decompiler)

    
    
//

    
    
package net.bytebuddy.renamed.java.lang;

    
    
public class Object$ByteBuddy$cmpHDO82 {

    
    
    public String toString() {

    
    
        return "Hello World!";

    
    
    }

    
    
    public Object$ByteBuddy$cmpHDO82() {

    
    
    }

    
    
}

 

mockito原理

关于mockito原理的分析，主要分析下Mockito.mock流程和Mockito.when流程，测试代码如下（为了方便调试，使用Mockito.mock而不是注解方式生成Mock代理类）：


   
   

    
    
@RunWith(MockitoJUnitRunner.class)

    
    
public class MockitoMain {

    
    
    public static interface DubboRemoteFacade {

    
    
        String world(String param);

    
    
    }

    
    
    @Test

    
    
    public void test() {

    
    
        DubboRemoteFacade remoteFacade = Mockito.mock(DubboRemoteFacade.class);

    
    
        Mockito.when(remoteFacade.world("aaa")).thenReturn("111");

    
    
        Mockito.when(remoteFacade.world("bbb")).thenReturn("222");

    
    
        System.out.println(remoteFacade.world("aaa")); // 111

    
    
        System.out.println(remoteFacade.world("ccc")); // null

    
    
    }

    
    
}

调用Mockito.mock生成mock代理类，首先是生成对应代理类class，如果多次调用Mockito.mock生成同样的mock代理类，肯定不会多次生成对应代理类class，而是在第一次生成之后保存到cache中，后续直接获取即可，对应代码如下：


   
   

    
    
// net.bytebuddy.TypeCache#findOrInsert

    
    
public Class<?> findOrInsert(ClassLoader classLoader, T key, Callable<Class<?>> lazy) {

    
    
    Class<?> type = find(classLoader, key);

    
    
    if (type != null) {

    
    
        // 已缓存直接返回

    
    
        return type;

    
    
    } else {

    
    
        return insert(classLoader, key, lazy.call());

    
    
    }

    
    
}

    
    
// org.mockito.internal.creation.bytebuddy.TypeCachingBytecodeGenerator#mockClass

    
    
public <T> Class<T> mockClass(final MockFeatures<T> params) {

    
    
    try {

    
    
        ClassLoader classLoader = params.mockedType.getClassLoader();

    
    
        return (Class<T>) typeCache.findOrInsert(classLoader,

    
    
                new MockitoMockKey(params.mockedType, params.interfaces, params.serializableMode, params.stripAnnotations),

    
    
                new Callable<Class<?>>() {

    
    
                    @Override

    
    
                    public Class<?> call() throws Exception {

    
    
                        // 动态生成代理类class

    
    
                        return bytecodeGenerator.mockClass(params);

    
    
                    }

    
    
                }, BOOTSTRAP_LOCK);

    
    
    } catch (IllegalArgumentException exception) {

    
    
        //

    
    
    }

    
    
}

 

动态生成代理类class对应方法：

org.mockito.internal.creation.bytebuddy.BytecodeGenerator#mockClass，如下：


   
   

    
    
public <T> Class<? extends T> mockClass(MockFeatures<T> features) {

    
    
    String name = nameFor(features.mockedType);

    
    
    DynamicType.Builder<T> builder =

    
    
            byteBuddy.subclass(features.mockedType)

    
    
                     .name(name)

    
    
                     .ignoreAlso(isGroovyMethod())

    
    
                     .annotateType(features.stripAnnotations

    
    
                         ? new Annotation[0]

    
    
                         : features.mockedType.getAnnotations())

    
    
                    // 方法处理器 DispatcherDefaultingToRealMethod

    
    
                     .implement(new ArrayList<Type>(features.interfaces))

    
    
                     .method(matcher)

    
    
                       .intercept(to(DispatcherDefaultingToRealMethod.class))

    
    
                       .transform(withModifiers(SynchronizationState.PLAIN))

    
    
                       .attribute(features.stripAnnotations

    
    
                           ? MethodAttributeAppender.NoOp.INSTANCE

    
    
                           : INCLUDING_RECEIVER)

    
    
                     .method(isHashCode())

    
    
                       .intercept(to(MockMethodInterceptor.ForHashCode.class))

    
    
                     .method(isEquals())

    
    
                       .intercept(to(MockMethodInterceptor.ForEquals.class))

    
    
                     .serialVersionUid(42L)

    
    
                     .defineField("mockitoInterceptor", MockMethodInterceptor.class, PRIVATE)

    
    
                     .implement(MockAccess.class)

    
    
                       .intercept(FieldAccessor.ofBeanProperty());

    
    
    if (features.serializableMode == SerializableMode.ACROSS_CLASSLOADERS) {

    
    
        builder = builder.implement(CrossClassLoaderSerializableMock.class)

    
    
                         .intercept(to(MockMethodInterceptor.ForWriteReplace.class));

    
    
    }

    
    
    if (readReplace != null) {

    
    
        builder = builder.defineMethod("readObject", void.class, Visibility.PRIVATE)

    
    
                .withParameters(ObjectInputStream.class)

    
    
                .throwing(ClassNotFoundException.class, IOException.class)

    
    
                .intercept(readReplace);

    
    
    }

    
    
    ClassLoader classLoader = new MultipleParentClassLoader.Builder()

    
    
        .append(features.mockedType)

    
    
        .append(features.interfaces)

    
    
        .append(currentThread().getContextClassLoader())

    
    
        .append(MockAccess.class, DispatcherDefaultingToRealMethod.class)

    
    
        .append(MockMethodInterceptor.class,

    
    
            MockMethodInterceptor.ForHashCode.class,

    
    
            MockMethodInterceptor.ForEquals.class).build(MockMethodInterceptor.class.getClassLoader());

    
    
    if (classLoader != features.mockedType.getClassLoader()) {

    
    
        assertVisibility(features.mockedType);

    
    
        for (Class<?> iFace : features.interfaces) {

    
    
            assertVisibility(iFace);

    
    
        }

    
    
        builder = builder.ignoreAlso(isPackagePrivate()

    
    
            .or(returns(isPackagePrivate()))

    
    
            .or(hasParameters(whereAny(hasType(isPackagePrivate())))));

    
    
    }

    
    
    return builder.make()

    
    
                  .load(classLoader, loader.resolveStrategy(features.mockedType, classLoader, name.startsWith(CODEGEN_PACKAGE)))

    
    
                  .getLoaded();

    
    
}

 

上述方法虽然逻辑挺复杂的，但是实质上和bytebuddy示例代码原理是一样的，这里指定了方法处理器 DispatcherDefaultingToRealMethod，为了查看这里bytebuddy生成的动态class到底长什么样，再debug时手动执行saveIn方法将动态class保存成class文件，如下图：

class文件内容如下：


   
   

    
    
//

    
    
// Source code recreated from a .class file by IntelliJ IDEA

    
    
// (powered by Fernflower decompiler)

    
    
//

    
    
package com.xxx;

    
    
import org.mockito.internal.creation.bytebuddy.MockAccess;

    
    
import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor;

    
    
import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.DispatcherDefaultingToRealMethod;

    
    
import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.ForEquals;

    
    
import org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.ForHashCode;

    
    
public class MockitoMain$DubboRemoteFacade$MockitoMock$294263869 implements DubboRemoteFacade, MockAccess {

    
    
    private static final long serialVersionUID = 42L;

    
    
    private MockMethodInterceptor mockitoInterceptor;

    
    
    public boolean equals(Object var1) {

    
    
        return ForEquals.doIdentityEquals(this, var1);

    
    
    }

    
    
    public String toString() {

    
    
        return (String)DispatcherDefaultingToRealMethod.interceptSuperCallable(this, this.mockitoInterceptor, cachedValue$f4wbfO7z$4cscpe1, new Object[0], new MockitoMain$DubboRemoteFacade$MockitoMock$294263869$auxiliary$ZDMmVEQX(this));

    
    
    }

    
    
    public int hashCode() {

    
    
        return ForHashCode.doIdentityHashCode(this);

    
    
    }

    
    
    protected Object clone() throws CloneNotSupportedException {

    
    
        return DispatcherDefaultingToRealMethod.interceptSuperCallable(this, this.mockitoInterceptor, cachedValue$f4wbfO7z$7m9oaq0, new Object[0], new MockitoMain$DubboRemoteFacade$MockitoMock$294263869$auxiliary$3zC3uoDC(this));

    
    
    }

    
    
    public String world(String param) {

    
    
        return (String)DispatcherDefaultingToRealMethod.interceptAbstract(this, this.mockitoInterceptor, (Object)null, cachedValue$f4wbfO7z$e78iil2, new Object[]{var1});

    
    
    }

    
    
    public void setMockitoInterceptor(MockMethodInterceptor var1) {

    
    
        this.mockitoInterceptor = var1;

    
    
    }

    
    
    public MockMethodInterceptor getMockitoInterceptor() {

    
    
        return this.mockitoInterceptor;

    
    
    }

    
    
    public MockitoMain$DubboRemoteFacade$MockitoMock$294263869() {

    
    
    }

    
    
}

 

到这里为止，一个mockito的动态代理类就创建OK了，我们也看到了代理类的方法处理器为DispatcherDefaultingToRealMethod；下面开始分析下Mockito.when流程，由于代理类的方法处理器为DispatcherDefaultingToRealMethod，所以以下示例代码的分析也需要从类DispatcherDefaultingToRealMethod开始：


   
   

    
    
// org.mockito.internal.creation.bytebuddy.MockMethodInterceptor.DispatcherDefaultingToRealMethod#interceptAbstract

    
    
public static Object interceptAbstract(@This Object mock, // 当前代理类

    
    
                                       @FieldValue("mockitoInterceptor") MockMethodInterceptor interceptor, // 方法拦截器

    
    
                                       @StubValue Object stubValue, // stub值，这里为null

    
    
                                       @Origin Method invokedMethod, // 当前调用方法

    
    
                                       @AllArguments Object[] arguments) /* 方法入参 */ throws Throwable {

    
    
    if (interceptor == null) {

    
    
        return stubValue;

    
    
    }

    
    
    return interceptor.doIntercept(

    
    
            mock,

    
    
            invokedMethod,

    
    
            arguments,

    
    
            RealMethod.IsIllegal.INSTANCE

    
    
    );

    
    
}

 

从方法interceptAbstract的入参可看出，当前方法调用的上下文信息基本都有了，基于这些信息会创建一个InterceptedInvocation对象，来表示一次方法调用，代码如下：


   
   

    
    
public static InterceptedInvocation createInvocation(Object mock, Method invokedMethod, Object[] arguments, RealMethod realMethod, MockCreationSettings settings, Location location) {

    
    
    return new InterceptedInvocation(

    
    
        new MockWeakReference<Object>(mock),

    
    
        createMockitoMethod(invokedMethod, settings),

    
    
        arguments,

    
    
        realMethod,

    
    
        location,

    
    
        SequenceNumber.next() // 每个InterceptedInvocation对象都有一个唯一序号

    
    
    );

    
    
}

 

方法调用时首先根据InterceptedInvocation对象查找对应的stub（StubbedInvocationMatcher），如果找到则使用该stub返回特定值，否则返回默认值（一般为null）。


   
   

    
    
// org.mockito.internal.handler.MockHandlerImpl#handle

    
    
public Object handle(Invocation invocation) throws Throwable {

    
    
    if (invocationContainer.hasAnswersForStubbing()) {

    
    
        // stubbing voids with doThrow() or doAnswer() style

    
    
        InvocationMatcher invocationMatcher = matchersBinder.bindMatchers(

    
    
                mockingProgress().getArgumentMatcherStorage(),

    
    
                invocation

    
    
        );

    
    
        invocationContainer.setMethodForStubbing(invocationMatcher);

    
    
        return null;

    
    
    }

    
    
    VerificationMode verificationMode = mockingProgress().pullVerificationMode();

    
    
    InvocationMatcher invocationMatcher = matchersBinder.bindMatchers(

    
    
            mockingProgress().getArgumentMatcherStorage(),

    
    
            invocation

    
    
    );

    
    
    // 校验当前mockito当前处理状态，比如执行了两次 Mockito.when()，由于第一次Mockito.when()没有调用thenReturn

    
    
    // 所以第二次会报异常，就是这里判断的，MockitoProgress中有一个字段stubbingInProgress记录当前正在处理的Mockito代码信息

    
    
    // 对应类LocationImpl

    
    
    mockingProgress().validateState();

    
    
    // 校验，比如timers/nerver/atLeast校验等

    
    
    if (verificationMode != null) {

    
    
        // We need to check if verification was started on the correct mock

    
    
        // - see VerifyingWithAnExtraCallToADifferentMockTest (bug 138)

    
    
        if (((MockAwareVerificationMode) verificationMode).getMock() == invocation.getMock()) {

    
    
            VerificationDataImpl data = createVerificationData(invocationContainer, invocationMatcher);

    
    
            verificationMode.verify(data);

    
    
            return null;

    
    
        } else {

    
    
            // this means there is an invocation on a different mock. Re-adding verification mode

    
    
            // - see VerifyingWithAnExtraCallToADifferentMockTest (bug 138)

    
    
            mockingProgress().verificationStarted(verificationMode);

    
    
        }

    
    
    }

    
    
    // prepare invocation for stubbing

    
    
    // 打桩准备，保存当前invocation信息，ongoingStubbing保存到ThreadLocal中

    
    
    invocationContainer.setInvocationForPotentialStubbing(invocationMatcher);

    
    
    OngoingStubbingImpl<T> ongoingStubbing = new OngoingStubbingImpl<T>(invocationContainer);

    
    
    mockingProgress().reportOngoingStubbing(ongoingStubbing);

    
    
    // look for existing answer for this invocation

    
    
    // 根据invocation匹配对应的stub，匹配规则是 class相同+方法签名相同+入参匹配

    
    
    StubbedInvocationMatcher stubbing = invocationContainer.findAnswerFor(invocation);

    
    
    notifyStubbedAnswerLookup(invocation, stubbing);

    
    
    // 返回默认值或者返回自定义返回值

    
    
    if (stubbing != null) {

    
    
        stubbing.captureArgumentsFrom(invocation);

    
    
        return stubbing.answer(invocation);

    
    
    } else {

    
    
        Object ret = mockSettings.getDefaultAnswer().answer(invocation);

    
    
        DefaultAnswerValidator.validateReturnValueFor(invocation, ret);

    
    
        //Mockito uses it to redo setting invocation for potential stubbing in case of partial mocks / spies.

    
    
        //Without it, the real method inside 'when' might have delegated to other self method

    
    
        //and overwrite the intended stubbed method with a different one.

    
    
        //This means we would be stubbing a wrong method.

    
    
        //Typically this would led to runtime exception that validates return type with stubbed method signature.

    
    
        invocationContainer.resetInvocationForPotentialStubbing(invocationMatcher);

    
    
        return ret;

    
    
    }

    
    
}

 

第一次进行方法调用时 invocationContainer.findAnswerFor 返回为null，当执行了Mockito.when并添加了自定义返回值之后，再次执行方法调用， invocationContainer.findAnswerFor 返回就是非null，然后由stub返回自定义值。

到这里为止，我们了解了方法的调用流程，但是还没有看到 StubbedInvocationMatcher 是什么时候添加到Mockito中的，这就是thenReturn内的逻辑了（OngoingStubbing<String> o1 = Mockito.when(remoteFacade.world("aaa")).thenReturn("111")，注意thenReturn和thenAnswer底层逻辑是一样的），代码如下：


   
   

    
    
public OngoingStubbing<T> thenReturn(T value) {

    
    
    return thenAnswer(new Returns(value));

    
    
}

    
    
public OngoingStubbing<T> thenAnswer(Answer<?> answer) {

    
    
    invocationContainer.addAnswer(answer);

    
    
    return new ConsecutiveStubbing<T>(invocationContainer);

    
    
}

    
    
public void addAnswer(Answer answer) {

    
    
     // 移除最近一次方法调用保存的invocation信息

    
    
    registeredInvocations.removeLast();

    
    
    //

    
    
    addAnswer(answer, false);

    
    
}

    
    
public StubbedInvocationMatcher addAnswer(Answer answer, boolean isConsecutive) {

    
    
    Invocation invocation = invocationForStubbing.getInvocation();

    
    
    mockingProgress().stubbingCompleted();

    
    
    if (answer instanceof ValidableAnswer) {

    
    
        ((ValidableAnswer) answer).validateFor(invocation);

    
    
    }

    
    
    synchronized (stubbed) {

    
    
        if (isConsecutive) {

    
    
            // 连续方式

    
    
            stubbed.getFirst().addAnswer(answer);

    
    
        } else {

    
    
            // 非连续

    
    
            stubbed.addFirst(new StubbedInvocationMatcher(invocationForStubbing, answer));

    
    
        }

    
    
        return stubbed.getFirst();

    
    
    }

    
    
}

 

将打桩的自定义返回值添加到stubbed中之后，就可以在方法调用中根据方法+入参从stubbed中匹配自定义的返回值。这里有一个连续方式和非连续方式，是什么意思呢，连续方式就是说，针对同一个方法的多次调用，可以按照顺序自定义不同的返回值，如果调用次数超过了自定义返回值个数，默认后续以最后一个自定义返回值为准，示例代码如下：


   
   

    
    
DubboRemoteFacade remoteFacade = Mockito.mock(DubboRemoteFacade.class);

    
    
Mockito.when(remoteFacade.world("aaa")).thenReturn("111").thenReturn("222"); // 连续方式

    
    
System.out.println(remoteFacade.world("aaa")); // 111

    
    
System.out.println(remoteFacade.world("aaa")); // 222

    
    
//System.out.println(remoteFacade.world("aaa")); // 222，如果再调用一次的话

 

到这里为止mockito的原理大致就分析完了，最后稍微总结下：

mockito是一个基于bytebuddy生成mock类（也就是代理类）的框架，常用于单测中。针对stub（打桩）原理，是借助于在执行方法调用时保存当前方法调用上下文到某个字段（org.mockito.internal.stubbing.InvocationContainerImpl#invocationForStubbing字段），然后将打桩信息+对应的函数调用上下文信息保存到stub有序列表中，后续执行方法调用会从stub列表中匹配对应的桩信息并返回，如果没有则返回默认值，通常是null。

注意：目前mockito针对类的注入还仅限于往@InjectMocks修饰的类中注入，而不能往@Spy注入，如果能支持往@Spy类中注入，则在多层次类关系的测试场景中会很方便，当然由于mockito目前只专注于类隔离模式下的mock测试，不支持支持往@Spy类中注入也是说得过去的。

 推荐阅读 


欢迎小伙伴 关注【TopCoder】 阅读更多精彩好文。

luoxn28
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
从代理模式到mockito原理
robert的专栏
05-09 1578
代理模式回顾 代理模式的定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。 抽象角色Subject：通过接口或抽象类声明真实角色实现的业务方法。 代理角色Proxy：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。 真实角色RealSubject：实现抽象角色，定义真实角色所要实现的业务逻辑，...
Mockito 实现原理（1）：基本原理
倪琛的博客
06-03 1461
最近开始读 Mockito 的源码，还挺有意思。先简单说说它的基本原理吧！（注：本系列基于 Mockito 4.6.1 源码）Mockito 最基本的用法就是 mock 一个对象，然后在调用其方法时返回指定结果。以一段最简单的代码为例： 这个效果是如何实现的呢？事实上，Mockito 提供了不止一种方法来实现上面的 mock 效果。在 中定义了一个 接口： 这个接口有好多个实现类。目前我执行时发现，默认用的是 这个实现，所以下面就讨论该实现的具体步骤。第一行调用 时， 首先会做的就是创建一个 moc
Mockito使用和实现原理解析
qq_27886773的博客
01-10 417
mockito原理解析
2023单元测试利器Mockito框架详解(超详细~)
u011250186的博客
12-17 272
前言 Mockito 是当前最流行的 单元测试 Mock 框架。采用 Mock 框架，我们可以 虚拟 出一个 外部依赖，降低测试 组件 之间的 耦合度，只注重代码的 流程与结果，真正地实现测试目的。 正文 什么是Mock Mock 的中文译为仿制的，模拟的，虚假的。对于测试框架来说，即构造出一个模拟/虚假的对象，使我们的测试能顺利进行下去。 Mock 测试就是在测试过程中，对于某些 不容易构造（如 HttpServletRequest 必须在 Servlet 容器中才能构造出来）或者不容易获取 比较
Mock 模拟测试简介及 Mockito 使用入门
2401_84140776的博客
05-16 1121
Mockito 是一个简单的流行的 Mock 框架。它能够帮我们创建 Mock 对象，保持单元测试的独立性。使用它只需要在 Maven 中添加依赖即可。
Mockito原理剖析——基本原理、@Spy、@Mock、插桩顺序
lidelin10的博客
04-18 3368
文章目录Mock的基本原理Mock和Spy区别调用方法的行为使用场景实例Stubbing插桩顺序的问题插桩先行插桩后行总结Reference Mock的基本原理 通过生成子类的方式，拦截具体的方法调用，将方法调用转发至Mock的桩代码，从而实现方法返回值或者方法执行体的自定义。 Mock和Spy 区别 Mock和Spy的基本区别——在没有进行任何方法调用Mock的情况下，Mock根据全局配置根据方法调用返回值类型返回一个默认值，不会进行具体的方法调用；而Spy对象会默认调用真实的方法。 调用方法的行为
Mockito简单使用及原理分析
seasonLai的博客
06-06 1万+
springboot+junit+mockito做单元测试，真香
java 测试工具 - mockito 原理模拟
~~简~~
09-16 251
package cn.java.test.mockito_mock; import java.io.Serializable; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.LinkedList; import java.util.Queue; import java.util.concurr...
PyPI 官网下载 | mockito-1.0.9.tar.gz
01-13
Mockito 是一个流行的模拟框架，主要在Java生态系统中使用，但它也有Python版本。在这个场景中，我们关注的是Python库"mockito-1.0.9.tar.gz"，它可以从PyPI（Python Package Index）官方网站下载。PyPI是Python...
Mockito+Junit5测试方法实践
06-12
内容概要：参考Mockito官方API文档，实践框架每个特性。 适合人群：Mockito入门人员以及想全面熟悉Mockito特性的人员，做到了开箱即用。 能学到什么：“Mockito 4.6.0 + Junit 5”的组合编程。 使用建议：使用前安装...
Java mockito单元测试实现过程解析
09-07
首先，让我们看一个简单的例子，有一个名为 `ItemService` 的接口，它有一个方法 `getItemNameUpperCase`，该方法根据传入的 `itemId` 从 `ItemRepository` 获取一个 `Item` 对象，并将其名称转换为大写。...
概述 Mockito
11-30
关 于 Mockito 的 概 述
SpringBoot项目中使用Mockito的示例代码
08-25
SpringBoot项目中使用Mockito的示例代码 在Spring Boot项目中使用Mockito是非常有用的，它可以帮助我们更好地进行单元测试和集成测试。在本文中，我们将通过示例代码来介绍如何在Spring Boot项目中使用Mockito， ...
Mockito加junit
最新发布
05-28
Mockito加junit
Mockito的使用及原理浅析
一群专业码农的笔记本
06-26 2818
Mockito的使用及原理浅析 在微服务横行的年代，一个服务可能依赖了若干个其它服务，而这些被依赖的服务，又极可能依赖了别的服务，于是构成了一个复杂的依赖链。而日常开发中，经常会苦恼于某某上游接口没数据而所使得UT达不到预期的目标，所兴现在已经有了多种Mock Toolkit，很好的解决了这一痛点。比较常用的有EasyMock,JMockit,Mockito,PowerMock等，而本文主要介绍Mockito的简单使用，并对其实现原理进行简单分析 Mockito的使用 通常情况下，我们会在UT里使用@Moc
Mockito-1.6原理浅析
weixin_33719619的博客
02-04 192
2019独角兽企业重金招聘Python工程师标准>>> ...
Mockito教程-简单使用
Ricky
06-19 2970
概述实战一.maven依赖<dependency> <groupId>org.mockito</groupId> <artifactId>mockito-all</artifactId> <version>1.10.19</version> </dependency><dependency> <groupId>junit</groupId> <artifact
基于Java的单元测试框架Mockito
bai_pd的博客
10-28 1255
基于Java的单元测试框架Mockito
Mockito实现原理探析 -- Mockito.when(...).thenReturn(...)的一个简化实现
热门推荐
JamesDoctor的专栏
11-24 2万+
Mockito是一套非常强大的测试框架，被广泛的应用于Java程序的unit test中，而在其中被使用频率最高的恐怕要数"Mockito.when(...).thenReturn(...)"了。那这个用起来非常便捷的"Mockito.when(...).thenReturn(...)"，其背后的实现原理究竟为何呢？为此，笔者实现了一个简单的MyMockito，来帮助帮助大家理解"Mockito.when(...).thenReturn(...)"的核心实现原理。
mockito架构原理
05-19
Mock 是一款 Java 测试框架，主要用于模拟对象来进行单元测试。其架构原理主要分为三个部分：核心 API、反射 API 和字节码 API。 1. 核心 API：Mockito 核心 API 提供了一些基本的方法，如 mock()、verify() 等，用于模拟对象和验证行为。 2. 反射 API：Mockito 使用反射机制来创建和操作被模拟的对象。通过反射 API，Mockito 可以检查对象的类型、获取对象的属性和方法等。 3. 字节码 API：Mockito 使用字节码 API 来增强被模拟的对象。通过字节码 API，Mockito 可以在运行时动态地创建代理对象，使其具备模拟对象的行为。 总体来说，Mockito 的核心原理就是通过反射和字节码技术来创建模拟对象，并通过核心 API 来模拟对象的行为，以实现单元测试的目的。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值