在《springAOP之代理模式》中說了代理模式，包含靜態代理和動態代理，在動態代理模式中又分為JDK動態代理和CGlib動態代理，今天重點來看JDK動態代理。

一、概述

說到JDK動態代理就必須想到JDK動態代理要求有一個統一的接口，那為什麼要有接口，下面會說到，下面看我的接口類，

package cn.com.jdk.proxy;

public interface Subject {

    void sayHello(String a);
}

接口類很簡單就是一個簡單的方法定義。下面看實際的接口的實現類SubjectImpl，

package cn.com.jdk.proxy;

public class SubjectImpl implements Subject {

    @Override
    public void sayHello(String a) {
        // TODO Auto-generated method stub

        System.out.println("hello:"+a);
    }

}

實現類簡單的事項了Subject接口，進行了打印操作。下面看代理類

package cn.com.jdk.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class JDKProxy implements InvocationHandler {
    private SubjectImpl si;
    //此屬性不用管
    private String a;
/**
 * proxy  JDK動態生成的代理類的實例
 * method 目標方法的Method對象     Class.forName("cn.com.jdk.proxy.Subject").getMethod("sayHello", new Class[] { Class.forName("java.lang.String") });
 * args   目標方法的參數                       new Object[] { paramString }
 */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("before");
        //使用反射的放式調用si（被代理類）目標方法
        Object o=method.invoke(si, args);
        System.out.println("after");
        return o;
    }
    public JDKProxy(SubjectImpl si,String a) {
        this.si=si;
        this.a=a;
    }

}

上面是代理類的實現，在代理類中含義被代理類的一個引用，且提供了響應的構造方法。下面具體的使用，

package cn.com.jdk.proxy;

import java.lang.reflect.Proxy;

public class ProxyTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //進行此項設置，可以在項目的com/sun/proxy目錄下找到JDK動態生成的代理類的字節碼文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        SubjectImpl si=new SubjectImpl();
        
        Subject subject=(Subject)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), new JDKProxy(si,"111"));
        subject.sayHello("tom");

    }

}

上面是使用的代碼，通過Proxy類的newProxyInstance方法獲得一個Subject的實例，調用sayHello方法，下面看執行結果

before
hello:tom
after

可以看到執行了sayHello方法，且打印了before和after，這不正是代理類中invoke方法的執行嗎，看下面

很神奇的一件事，我們不光調用了sayHello方法，實現了打印，而且在加入了自己的打印方法，這不正是AOP的增強功能嗎。這一切是怎麼發生的那，下面細細說來。

二、詳述

上面，我們又複習了JDK動態代理的內容，以及演示了如何使用JDK動態代理，下面我們要看這是怎麼實現的，先從測試的下面這段代碼說起，也是最重要的代碼，JDK動態代理的精華都在這句代碼里，

Subject subject=(Subject)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), new JDKProxy(si,"111"));

這句代碼是調用了Proxy類的newProxyInstance方法，此方法的入參如下，

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

 一共三個參數，一個是ClassLoader，這裏傳入的是被代理對象的類加載器；一個是Class，這裏傳入的是被代理對象所實現的接口；一個是InvocationHandler，這裏傳入的是代理類，代理類實現了InvocationHandler接口。

 1、newProxyInstance方法

下面看newProxyInstance方法的定義，

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
          //1、使用代理類的類加載器和其所實現的接口，動態生成代理類
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //2、返回JDK生成的代理類的構造方法，該構造方法的參數為
            //  InvocationHandler
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //3、返回該構造方法的一個實例，也就是使用InvocationHandler為參數的構造方法利用反射的機制返回一個實例。
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

該方法中有三步比較重要，上面的註釋已經標出。

1.1、getProxyClass0(loader, intfs)方法

該方法便是上面的第一步，這一步的作用是JDK返回一個代理類的實例，方法上的註釋如下，

/*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);

註釋直譯過來是查找或者生成指定的代理類，這裡有兩層意思，一個是查找，第二個是生成，由此可以想到這個方法中應該有緩存，下面看方法的具體定義，

/**
     * Generate a proxy class.  Must call the checkProxyAccess method
     * to perform permission checks before calling this.
     */
    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }

這個方法很簡單，判斷了接口的數量，大於65535便拋異常，接口的數量大於65535的可能性不大。最後調用了proxyClassCache的get方法，首先看proxyClassCache，從字面上理解是代理類的緩存，看其定義，

/**
     * a cache of proxy classes
     */
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

是一個WeakCache對象實例，看下該構造方法，

/**
     * Construct an instance of {@code WeakCache}
     *
     * @param subKeyFactory a function mapping a pair of
     *                      {@code (key, parameter) -> sub-key}
     * @param valueFactory  a function mapping a pair of
     *                      {@code (key, parameter) -> value}
     * @throws NullPointerException if {@code subKeyFactory} or
     *                              {@code valueFactory} is null.
     */
    public WeakCache(BiFunction<K, P, ?> subKeyFactory,
                     BiFunction<K, P, V> valueFactory) {
        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
        this.valueFactory = Objects.requireNonNull(valueFactory);
    }

看了該類的構造方法后，回到proxyClassCache.get(loader, interfaces)方法的調用，我們已經知道proxyClassCache是WeakCache的一個實例，那麼get方法如下，

 /**
     * Look-up the value through the cache. This always evaluates the
     * {@code subKeyFactory} function and optionally evaluates
     * {@code valueFactory} function if there is no entry in the cache for given
     * pair of (key, subKey) or the entry has already been cleared.
     *
     * @param key       possibly null key
     * @param parameter parameter used together with key to create sub-key and
     *                  value (should not be null)
     * @return the cached value (never null)
     * @throws NullPointerException if {@code parameter} passed in or
     *                              {@code sub-key} calculated by
     *                              {@code subKeyFactory} or {@code value}
     *                              calculated by {@code valueFactory} is null.
     */
    public V get(K key, P parameter) {
        Objects.requireNonNull(parameter);

        expungeStaleEntries();

        Object cacheKey = CacheKey.valueOf(key, refQueue);

        // lazily install the 2nd level valuesMap for the particular cacheKey
        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {
            ConcurrentMap<Object, Supplier<V>> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

        // create subKey and retrieve the possible Supplier<V> stored by that
        // subKey from valuesMap
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;

        while (true) {
            if (supplier != null) {
                // supplier might be a Factory or a CacheValue<V> instance
                V value = supplier.get();
                if (value != null) {
                    return value;
                }
            }
            // else no supplier in cache
            // or a supplier that returned null (could be a cleared CacheValue
            // or a Factory that wasn't successful in installing the CacheValue)

            // lazily construct a Factory
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }

            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    // successfully installed Factory
                    supplier = factory;
                }
                // else retry with winning supplier
            } else {
                if (valuesMap.replace(subKey, supplier, factory)) {
                    // successfully replaced
                    // cleared CacheEntry / unsuccessful Factory
                    // with our Factory
                    supplier = factory;
                } else {
                    // retry with current supplier
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }

 上面是WeakCache的get方法，這個方法暫時不作說明，後面會詳細介紹WeakCache類，請參見《JDK動態代理之WeakCache 》。這裏只需記住該get方法會返回一個代理類的實例即可。那麼此代理類是如何定義的那？

1.1.1、$Proxy0.class代理類

這個代理類是JDK動態生成的，其命名規則為以“$”開頭+Proxy+“從0開始的序列”。上面在測試的時候，我們加入了下面這行代碼，

//進行此項設置，可以在項目的com/sun/proxy目錄下找到JDK動態生成的代理類的字節碼文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

註釋中寫到可以生成代理類的字節碼文件，下面是使用反編譯工具過來的java代碼，

package com.sun.proxy;

import cn.com.jdk.proxy.Subject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy
  implements Subject
{
  private static Method m1;
  private static Method m3;
  private static Method m2;
  private static Method m0;
 //參數為InvocationHandler的構造方法
  public $Proxy0(InvocationHandler paramInvocationHandler)
    throws 
  {
   //調用父類Proxy的構造方法，在父類的構造方法中會初始化h屬性
    super(paramInvocationHandler);
  }

  public final boolean equals(Object paramObject)
    throws 
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
//實現的Subject的sayHello方法
  public final void sayHello(String paramString)
    throws 
  {
    try
    {
      //調用h的invoke方法，這裏的h指的是實現了InvocationHandler的類
      //調用其中的invoke方法，在本例中是調用JDKProxy類中的invoke方
      //法
      this.h.invoke(this, m3, new Object[] { paramString });
      return;
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final String toString()
    throws 
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final int hashCode()
    throws 
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("cn.com.jdk.proxy.Subject").getMethod("sayHello", new Class[] { Class.forName("java.lang.String") });
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
    }
    throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
  }
}

上面是反編譯過來的JDK生成的代理類的代碼，包含了一個使用InvocationHandler作為參數的構造方法，以及實現了Subject接口的sayHello方法。上面註釋中寫到該構造方法調用了其父類Proxy的構造方法，下面看其父類Proxy的構造方法，

protected Proxy(InvocationHandler h) {
        Objects.requireNonNull(h);
        this.h = h;
    }

把InvocationHandler的值賦給了h，h的定義如下，

protected InvocationHandler h;

那麼在生成的代理類中自然會繼承該屬性，所以在代理類中的sayHello中使用下面的方法調用，

public final void sayHello(String paramString)
    throws 
  {
    try
    {
      this.h.invoke(this, m3, new Object[] { paramString });
      return;
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

上面的this.h便是其父類的h屬性。在上面的this.h.invoke中的m3是怎麼來的那，看下面，

 static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("cn.com.jdk.proxy.Subject").getMethod("sayHello", new Class[] { Class.forName("java.lang.String") });
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
    }
    throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
  }

在該類的靜態代碼塊中給出了4個屬性。

1.2、getConstructor(constructorParams)方法

在上面的getProxyClass0方法中我們知道該方法會返回一個JDK生成代理類的Class對象，此類的定義便是上面的$Proxy0.class類。其定義在上面已經分析過。getConstructor方法要返回一個以constructorParams為參數的構造方法，

@CallerSensitive
    public Constructor<T> getConstructor(Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException {
        checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
        return getConstructor0(parameterTypes, Member.PUBLIC);
    }

調用了getConstuctor0方法返回一個public的構造方法，

private Constructor<T> getConstructor0(Class<?>[] parameterTypes,
                                        int which) throws NoSuchMethodException
    {
        Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC));
        for (Constructor<T> constructor : constructors) {
            if (arrayContentsEq(parameterTypes,
                                constructor.getParameterTypes())) {
                return getReflectionFactory().copyConstructor(constructor);
            }
        }
        throw new NoSuchMethodException(getName() + ".<init>" + argumentTypesToString(parameterTypes));
    }

上面的方法會返回一個public的構造方法。

回到最初的調用，我們看getConstructor方法的參數是constructorParams，此屬性定義如下，

/** parameter types of a proxy class constructor */
    private static final Class<?>[] constructorParams =
        { InvocationHandler.class };

是一個Class數組，其類型為InvocationHandler。這樣便可以知道是通過代理類的Class對象返回其構造方法cons。有了構造方法下面便是通過構造方法生成實例。

1.3、cons.newInstance(new Object[]{h})方法

此方法便是通過構造方法返回一個代理類的實例。

 

上面分析了Proxy的newProxyInstance方法，此方法最終會返回一個代理類的實例，會經過下面幾個步驟，

從上面的步驟，我們知道在獲得代理類的構造方法時，是獲得其參數為InvocationHandler的構造方法，所以肯定要實現InvocationHandler接口，在本例中便是JDKProxy類，這個類實現了這個接口。值開篇我們講到JDK動態代理必須要有統一的接口，從上面的步驟中我們知道在生成代理類的Class對象時使用了兩個參數，一個ClassLoader，另一個是接口，這裏就是為什麼要有統一的接口，因為在生成代理類的Class對象中需要接口，所以被代理類必須要有一個接口。

2、方法調用

這裏的方法調用，便是對應使用方法中的下面這行代碼，

subject.sayHello("tom");

在上面的分析中獲得了一個代理類的實例，即下面這行代碼，

Subject subject=(Subject)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), new JDKProxy(si,"111"));

通過使用被代理類的類加載器、被代理類所實現的接口、實現了InvocationHandler接口的類的實例三個參數，返回了一個代理類的實例。上面已經詳細分析過。此代理類的實例繼承了Proxy，實現了Subject接口。其sayHello方法如下，

public final void sayHello(String paramString)
    throws 
  {
    try
    {
      this.h.invoke(this, m3, new Object[] { paramString });
      return;
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

上面已經分析過，this.h是InvocationHandler的實例，這裏便是new JDKProxy(si,”111″)，m3是m3 = Class.forName(“cn.com.jdk.proxy.Subject”).getMethod(“sayHello”, new Class[] { Class.forName(“java.lang.String”) });下面看JDKProxy中的invoke方法，

@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("before");
        //使用反射的放式調用目標方法
        Object o=method.invoke(si, args);
        System.out.println("after");
        return o;
    }

此方法的三個參數分別為代理類的實例、Method對象（sayHello），調用sayHello時的參數，所以要調用被代理類的sayHello方法，需要這樣寫：method.invoke(si,args)，即調用被代理類（SubjectImpl）的sayHello方法，參數為args（tom）。下面是一個簡單的方法調用過程，

三、總結

本文分析了JDK動態代理的簡單使用方法及背後的原理，有不當之處歡迎指正，感謝！

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※教你寫出一流的銷售文案?

※超省錢租車方案

※FB行銷專家,教你從零開始的技巧

1.簡介

Jmeter官網對邏輯控制器的解釋是：“Logic Controllers determine the order in which Samplers are processed.”。

意思是說，邏輯控制器可以控制採樣器(samplers)的執行順序。由此可知，控制器需要和採樣器一起使用，否則控制器就沒有什麼意義了。放在控制器下面的所有的採樣器都會當做一個整體，執行時也會一起被執行。

JMeter邏輯控制器可以對元件的執行邏輯進行控制，除僅一次控制器外，其他可以嵌套別的種類的邏輯控制器。

2.邏輯控制器分類

JMeter中的Logic Controller分為兩類：
（1）控制測試計劃執行過程中節點的邏輯執行順序，如：Loop Controller、If Controller等；
（2）對測試計劃中的腳本進行分組、方便JMeter統計執行結果以及進行腳本的運行時控制等，如：Throughput Controller、Transaction Controller。

3.預覽邏輯控制器 

首先我們來看一下JMeter的邏輯控制器，路徑：線程組（用戶）->添加->邏輯控制器（Logic Controller）；我們可以清楚地看到JMeter5中共有17個邏輯控制器，如下圖所示：

如果上圖您看得不是很清楚的話，宏哥總結了一個思維導圖，關於JMeter5的邏輯控制器類型，如下圖所示： 

 通過以上的了解，我們對邏輯控制器有了一個大致的了解和認識。下面宏哥就給小夥伴或則童鞋們分享講解一些通常在工作中會用到的邏輯控制器。 

4.常用邏輯控制器詳解

　　這一小節，宏哥就由上而下地詳細地講解一下常用的邏輯控制器。

4.1Interleave Controller

交替控制器，顧名思義是：互相交替，其節點下的取樣器交替執行。根據被控制器觸發執行次數，去依次執行控制器下的子節點<邏輯控制器、採樣器>。被觸發執行可以由線程組的線程數、循環次數、邏輯控制器觸發。

1、我們先來看看這個Interleave Controller長得是啥樣子，路徑：線程組 > 添加 > 邏輯控制器 > 交替控制器，如下圖所示： 

2、關鍵參數說明如下：

Name：名稱，可以隨意設置，甚至為空；

Comments：註釋，可隨意設置，可以為空；

Ignore sub-controller blocks：忽略子控制器，即子控制器失效，由交替控制器接管。

勾選后，會無視節點下的所有控制器<交替控制器、隨機控制器例外>，將每個取樣器作為一個單獨字節點執行
不勾選忽略子控制器，交替執行時，節點下次一級每個取樣器、邏輯控制器都認為是一個單獨子節點來交替執行。

Interleave across threads: 勾選此項，則交替控制器下的請求將應用至所有線程和循環中迭代。如有四個請求，三個線程，兩輪循環，那麼第一輪三個線程分別運行請求1，請求2，請求3，第二輪循環的三個線程運行請求4，請求1，請求2。

允許跨線程交替執行，勾選后，當線程組線程數大於1時，當前線程首次執行會根據線程數順序進行交替，後續執行按自己所屬線程的上一個次的執行的位置交替，如： 交替控制器下由A B C D  E 5個接口， 設置線程組 線程數3個，循環4次，則最終執行結果為  線程1執行 A B C D 線程2執行 B C D E 線程3執行 C D E A 。

 4.1.1簡單實例

1、首先在交替控制器下添加3個取樣器 訪問博客園首頁、訪問北京宏哥的博客園首頁和訪問北京宏哥的JMeter系列文章，線程組下添加一個取樣器 訪問度娘，與交替控制器同層級，線程組設置循環次數為2，如下圖所示：

2、配置好以後，運行JMeter，然後查看結果樹（循環兩次，每次只執行交替控制器里一個取樣器），如下圖所示：

4.1.2複雜實例

宏哥這裏講解的複雜使用，就是將交替控制器嵌套使用，來看看執行結果，從而更進一步的理解和學習交替控制器。

1、創建一個父交替控制器：北京宏爸，其下兩個子交替控制器：北京宏哥 和 北京宏弟，子交替控制器下面分別添加2個取樣器：訪問度娘 和 訪問博客園首頁，設置線程組循環次數10，如下圖所示：

2、配置好以後，運行JMeter，然後查看結果樹（ 從結果可以看出，先交替子控制器的樣例，再交替父控制器下的樣例。大家明白了吧），如下圖所示：

4.1.3忽略子控制器塊

　　在交替控制器的設置界面，有這樣一個選項，是否忽略子控制器，所以這裏一般也是交替控制器作為父級控制器時使用的選項，這裏的子控制器一般指非交替控制器的其他控制器 （如果子控制器也是交替控制器，該項實際和交替控制器的嵌套效果一樣了）

1、下面，我們在交替器下添加一個循環控制器，設置循環次數 2，線程組循環次數設置為 3，設置交替器 勾選 忽略子控制器，如下圖所示：

循環控制器：

線程組：

交替控制器：

2、 配置好以後，運行JMeter，然後查看結果樹（ 從結果可以看出，循環控制器沒有執行2次，只執行了1次），如下圖所示：

3、下面，我們再把交替控制器中 忽略子控制器 去掉勾選，其他設置不變，如下圖所示：

4、配置好以後，點擊“保存”，運行JMeter，然後查看結果樹（ 從結果可以看出，循環控制器執行2次，然後再執行 訪問度娘-哥弟 取樣器這樣交替執行了3次），如下圖所示：

綜上所述：以控制器為1個小單元，交替執行。

4.2Once Only Controller

在每個線程內，該控制器下的內容只會被執行一遍，無論循環多少次，都只執行一遍。<嵌套在循環控制器之內時是個例外，每個線程組循環都會被執行一遍>。

此控制器通常用於控制需要登錄的請求，測試過程中，我們往往都只需要登錄一次，獲取到對應的登錄信息后即可執行後續相關的請求，而不是每執行一個請求都登錄一次，如將login請求放入僅一次控制器，則在線程組循環運行期間，不論循環次數設置為多少次，login請求都將僅在第一次執行時運行

 1、我們先來看看這個Once Only Controller長得是啥樣子，路徑：線程組 > 添加 > 邏輯控制器 > 僅一次控制器，如下圖所示：

2、關鍵參數說明如下：

Name：名稱，可以隨意設置，甚至為空；

Comments：註釋，可隨意設置，可以為空。

4.2.1實例

宏哥這裏以博客園發布文章為例，說一下測試場景：正常邏輯是我們需要一次登錄博客園然後多次發布文章；而不是發布一次文章就需要登錄一次博客園。以此為例添加測試腳本。

1、按照上邊的測試場景，宏哥添加測試腳本，如下圖所示：

 2、配置好以後，點擊“保存”，運行JMeter，然後查看結果樹（ 從結果可以看出，一次登錄博客園然後多次發布文章；而不是發布一次文章就需要登錄一次博客園），如下圖所示：

4.2.2紅色字體實戰舉例 

<嵌套在循環控制器之內時是個例外，每個線程組循環都會被執行一遍>。

1、保持上邊的測試樹結構，然後將 僅一次控制器 用鼠標拖到 循環控制器 裡邊，如下圖所示：

 2、配置好以後，點擊“保存”，運行JMeter，然後查看結果樹（ 從結果可以看出，宏哥設置了3個線程，每個線程都登錄一次博客園），如下圖所示：

4.3Random Controller

隨機控制器節點下的元件隨機運行，與交替控制器不一樣的是節點下的元件運行順序不定。

 1、我們先來看看這個Random Controller長得是啥樣子，路徑：線程組 > 添加 > 邏輯控制器 >  隨機控制器，如下圖所示：

2、關鍵參數說明如下：

Name：名稱，可以隨意設置，甚至為空；

Comments：註釋，可隨意設置，可以為空；

Ignore sub-controller blocks：忽略子控制器，即子控制器失效，由隨機控制器接管，類似交替控制器。

4.3.1簡單實例 

1、創建測試計劃，隨機控制下添加三個請求，控制器外一個請求，線程4個；如下圖所示：

2、配置好以後，點擊“保存”，運行JMeter，然後查看結果樹（ 從結果可以看出，宏哥設置了4個線程，每個線程都要訪問一次北京宏哥的Jmeter系列文章，但是控制器下邊的取樣器的訪問卻是隨機訪問一個），如下圖所示：

4.3.2隨機嵌套循環-不忽略子控制器

1、按照小標題的內容，創建測試計劃，如下圖所示：

2、配置好以後，點擊“保存”，運行JMeter，然後查看結果樹（ 從結果可以看出，宏哥設置了3個線程，隨機選擇隨機控制器下的兩個循環控制器），如下圖所示：

4.3.3隨機嵌套循環-忽略子控制器

1、按照小標題的內容，創建測試計劃，如下圖所示：

2、配置好以後，點擊“保存”，運行JMeter，然後查看結果樹（ 從結果可以看出，宏哥設置了3個線程，循環控制器也失效了，每次都隨機選擇一個取樣器執行），如下圖所示：

4.3.4隨機嵌套交替-忽略子控制器

1、按照小標題的內容，創建測試計劃，如下圖所示：

2、配置好以後，點擊“保存”，運行JMeter，然後查看結果樹（ 從結果可以看出，宏哥設置了10次循環，交替控制器也失效了，每次都隨機選擇一個取樣器執行），如下圖所示：

4.4Random Order Controller

隨機順序控制器其節點下的原件隨機執行，不過每個元件只執行一次。

當控制器被觸發時，將控制器下的所有子節點順序打亂執行一遍，執行一遍；執行一遍，不是執行一個。

注意：是將子節點的順序打亂，而非請求的順序打亂，子節點可以是其他邏輯控制器。

隨機控制器與隨機順序控制器名字十分接近，但兩者還是有着明顯的區別，可參考  上邊介紹的隨機控制器。

隨機控制器為每次只執行節點下的一個子節點，隨機順序控制器是將節點下的所有子節點都正常執行，只是將執行順序打亂

1、我們先來看看這個Random Order Controller長得是啥樣子，路徑：線程組 > 添加 > 邏輯控制器 > 隨機順序控制器，如下圖所示： 

2、關鍵參數說明如下：

Name：名稱，可以隨意設置，甚至為空；

Comments：註釋，可隨意設置，可以為空。

4.4.1實例

1、創建測試計劃，如下圖所示： 

2、配置好以後，點擊“保存”，運行JMeter，然後查看結果樹（ 從結果可以看出，宏哥設置了3次循環，每次循環把所有的子節點都執行了），如下圖所示： 

4.5Recording Controller

其錄製控制器，顧名思義是錄製的時候會用到。實際上它是一個位置，當我們用JMeter代理進行錄製時，錄製的腳本默認放在此控制器的節點下面。沒有實際的邏輯作用，我們用簡單控制器也可以代替它。由於這個沒有用到過，這裏宏哥就不做詳細介紹了，如果後期用到的話，宏哥會單獨寫一篇關於錄製控制器的文章給小夥伴或童鞋們來答疑解惑。

1、我們先來看看這個Recording Controller長得是啥樣子，路徑：線程組 > 添加 > 邏輯控制器 > 錄製控制器，如下圖所示： 

2、關鍵參數說明如下：

Name：名稱，可以隨意設置，甚至為空；

Comments：註釋，可隨意設置，可以為空；

Forever：勾選上這一項表示一直循環下去。

5.小結

 

 好了，今天關於邏輯控制器的上篇就講解到這裏，這一篇主要介紹了 Interleave Controller、Once Only Controller、Random Controller 、 Random Order Controller和Recording Controller。

 

您的肯定就是我進步的動力。如果你感覺還不錯，就請鼓勵一下吧！記得隨手點波  推薦  不要忘記哦！！！

別忘了點 推薦 留下您來過的痕迹

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※超省錢租車方案

※別再煩惱如何寫文案,掌握八大原則!

※回頭車貨運收費標準

※教你寫出一流的銷售文案?

※FB行銷專家,教你從零開始的技巧