jmeter java请求

demo下载地址http://yun.baidu.com/share/link?shareid=4277735898&uk=925574576

1、引用jmeter的jar包

到jmeter的保存目录下lib这个文件夹除了自己加的jar包，全部添加到项目中，并build path

aaarticlea/png;base64,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" alt="" />

2、创建http请求类

http请求引用了这个jar包，javax.servlet-api-3.1.0.jar，项目写完的时候，要把这个jar包一起打包，这个部分可以自己实现

package com.milan.util;

import javax.servlet.ServletContext;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.commons.lang.StringUtils;
//import org.codehaus.jackson.map.ObjectMapper;
import java.lang.reflect.Method;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLDecoder;
import java.io.*;
import java.util.*;

/**
 *
 * HTTP 帮助类
 *
 */
public class HttpHelper
{
    /** URL 地址分隔符 */
    public static final String URL_PATH_SEPARATOR    = "/";
    /** HTTP URL 标识 */
    public static final String HTTP_SCHEMA            = "http";
    /** HTTPS URL 标识 */
    public static final String HTTPS_SCHEMA            = "https";
    /** HTTP 默认端口 */
    public static final int HTTP_DEFAULT_PORT        = 80;
    /** HTTPS 默认端口 */
    public static final int HTTPS_DEFAULT_PORT        = 443;
    /** 默认缓冲区大小 */
    private static final int DEFAULT_BUFFER_SIZE    = 4096;

    private static final String METHOD_GET = "GET";
    private static final String METHOD_POST = "POST";
    private static ServletContext servletContext;

    /** 获取 {@link ServletContext} */
    public static ServletContext getServletContext()
    {
        return servletContext;
    }

    private static final String defaultContentEncoding = "UTF-8";

    /** 向页面输出文本内容 */
    public final static void writeString(HttpURLConnection conn, String content, String charsetName) throws IOException
    {
        writeString(conn.getOutputStream(), content, charsetName);
    }

    /** 向页面输出文本内容 */
    public final static void writeString(HttpServletResponse res, String content, String charsetName) throws IOException
    {
        writeString(res.getOutputStream(), content, charsetName);
    }

    /** 向页面输出文本内容 */
    public final static void writeString(OutputStream os, String content, String charsetName) throws IOException
    {
        PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, charsetName));

        pw.write(content);
        pw.flush();
        pw.close();
    }

    /** 向页面输出字节内容 */
    public final static void writeBytes(HttpURLConnection conn, byte[] content) throws IOException
    {
        writeBytes(conn.getOutputStream(), content);
    }

    /** 向页面输出字节内容 */
    public final static void writeBytes(HttpServletResponse res, byte[] content) throws IOException
    {
        writeBytes(res.getOutputStream(), content);
    }

    /** 向页面输出字节内容 */
    public final static void writeBytes(OutputStream os, byte[] content) throws IOException
    {
        BufferedOutputStream bos = new BufferedOutputStream(os);

        bos.write(content);
        bos.flush();
        bos.close();
    }

    /** 读取页面请求的文本内容 */
    public final static String readString(HttpURLConnection conn, boolean escapeReturnChar, String charsetName) throws IOException
    {
        return readString(conn.getInputStream(), escapeReturnChar, charsetName);
    }

    /** 读取页面请求的字节内容 */
    public final static String readString(HttpServletRequest request, boolean escapeReturnChar, String charsetName) throws IOException
    {
        return readString(request.getInputStream(), escapeReturnChar, charsetName);
    }

    /** 读取页面请求的文本内容 */
    public final static String readString(InputStream is, boolean escapeReturnChar, String charsetName) throws IOException
    {
        StringBuilder sb = new StringBuilder();
        BufferedReader rd = new BufferedReader(new InputStreamReader(is, charsetName));

        try
        {
            if(escapeReturnChar)
            {
                for(String line = null; (line = rd.readLine()) != null;)
                    sb.append(line);
             }
            else
            {
                int count        = 0;
                char[] array    = new char[DEFAULT_BUFFER_SIZE];

                while((count = rd.read(array)) != -1)
                    sb.append(array, 0, count);
            }
        }
        finally
        {
            rd.close();
        }

        return sb.toString();
    }

    /** 读取页面请求的字节内容 */
    public final static byte[] readBytes(HttpURLConnection conn) throws IOException
    {
        return readBytes(conn.getInputStream(), conn.getContentLength());
    }

    /** 读取页面请求的字节内容 */
    public final static byte[] readBytes(HttpServletRequest request) throws IOException
    {
        return readBytes(request.getInputStream(), request.getContentLength());
    }

    /** 读取页面请求的字节内容 */
    public final static byte[] readBytes(InputStream is) throws IOException
    {
        return readBytes(is, 0);
    }

    /** 读取页面请求的字节内容 */
    public final static byte[] readBytes(InputStream is, int length) throws IOException
    {
        byte[] array = null;

        if(length > 0)
        {
            array = new byte[length];

            int read    = 0;
            int total    = 0;

            while((read = is.read(array, total, array.length - total)) != -1)
                total += read;
        }
        else
        {
            List<byte[]> list    = new LinkedList<byte[]>();
            byte[] buffer        = new byte[DEFAULT_BUFFER_SIZE];

            int read    = 0;
            int total    = 0;

            for(; (read = is.read(buffer)) != -1; total += read)
            {
                byte[] e = new byte[read];
                System.arraycopy(buffer, 0, e, 0, read);
                list.add(e);
            }

            array = new byte[total];

            int write = 0;
            for(byte[] e : list)
            {
                System.arraycopy(e, 0, array, write, e.length);
                write += e.length;
            }
        }

        return array;
    }

    /** 置换常见的 XML 特殊字符 */
    public final static String regulateXMLStr(String src)
    {
        String result = src;
        result = result.replaceAll("&", "&amp;");
        result = result.replaceAll("\"", "&quot;");
        result = result.replaceAll("'", "&apos;");
        result = result.replaceAll("<", "&lt;");
        result = result.replaceAll(">", "&gt;");

        return result;
    }

    /** 置换常见的 HTML 特殊字符 */
    public final static String regulateHtmlStr(String src)
    {
        String result = src;
        result = result.replaceAll("&", "&amp;");
        result = result.replaceAll("\"", "&quot;");
        result = result.replaceAll("<", "&lt;");
        result = result.replaceAll(">", "&gt;");
        result = result.replaceAll("\r\n", "<br/>");
        result = result.replaceAll(" ", "&nbsp;");

        return result;
    }

    /** 确保 URL 路径的前后存在 URL 路径分隔符 */
    public static final String ensurePath(String path, String defPath)
    {
        if(StringUtils.isEmpty(path))
            path = defPath;
        if(!path.startsWith(URL_PATH_SEPARATOR))
            path = URL_PATH_SEPARATOR + path;
        if(!path.endsWith(URL_PATH_SEPARATOR))
            path = path + URL_PATH_SEPARATOR;

        return path;
    }

    /** 获取 {@link HttpServletRequest} 的指定属性值 */
    @SuppressWarnings("unchecked")
    public final static <T> T getRequestAttribute(HttpServletRequest request, String name)
    {
        return (T)request.getAttribute(name);
    }

    /** 设置 {@link HttpServletRequest} 的指定属性值 */
    public final static <T> void setRequestAttribute(HttpServletRequest request, String name, T value)
    {
        request.setAttribute(name, value);
    }

    /** 删除 {@link HttpServletRequest} 的指定属性值 */
    public final static void removeRequestAttribute(HttpServletRequest request, String name)
    {
        request.removeAttribute(name);
    }

    /** 获取 {@link HttpSession} 的指定属性值 */
    @SuppressWarnings("unchecked")
    public final static <T> T getSessionAttribute(HttpSession session, String name)
    {
        return (T)session.getAttribute(name);
    }

    /** 设置 {@link HttpSession} 的指定属性值 */
    public final static <T> void setSessionAttribute(HttpSession session, String name, T value)
    {
        session.setAttribute(name, value);
    }

    /** 删除 {@link HttpSession} 的指定属性值 */
    public final static void removeSessionAttribute(HttpSession session, String name)
    {
        session.removeAttribute(name);
    }

    /** 销毁 {@link HttpSession} */
    public final static void invalidateSession(HttpSession session)
    {
        session.invalidate();
    }

    /** 获取 {@link ServletContext} 的指定属性值 */
    @SuppressWarnings("unchecked")
    public final static <T> T getApplicationAttribute(String name)
    {
        return (T)getApplicationAttribute(servletContext, name);
    }

    /** 获取 {@link ServletContext} 的指定属性值 */
    @SuppressWarnings("unchecked")
    public final static <T> T getApplicationAttribute(ServletContext servletContext, String name)
    {
        return (T)servletContext.getAttribute(name);
    }

    /** 设置 {@link ServletContext} 的指定属性值 */
    public final static <T> void setApplicationAttribute(String name, T value)
    {
        setApplicationAttribute(servletContext, name, value);
    }

    /** 设置 {@link ServletContext} 的指定属性值 */
    public final static <T> void setApplicationAttribute(ServletContext servletContext, String name, T value)
    {
        servletContext.setAttribute(name, value);
    }

    /** 删除 {@link ServletContext} 的指定属性值 */
    public final static void removeApplicationAttribute(String name)
    {
        removeApplicationAttribute(servletContext, name);
    }

    /** 删除 {@link ServletContext} 的指定属性值 */
    public final static void removeApplicationAttribute(ServletContext servletContext, String name)
    {
        servletContext.removeAttribute(name);
    }

    /** 获取 {@link HttpServletRequest} 的指定请求参数值，并去除前后空格 */
    public final static String getParam(HttpServletRequest request, String name)
    {
        String param = getParamNoTrim(request, name);
        if(param != null) return param = param.trim();

        return param;
    }

    /** 获取 {@link HttpServletRequest} 的指定请求参数值 */
    public final static String getParamNoTrim(HttpServletRequest request, String name)
    {
        return request.getParameter(name);
    }

    /** 获取 {@link HttpServletRequest} 的参数名称集合 */
    public final static List<String> getParamNames(HttpServletRequest request)
    {
        List<String> names        = new ArrayList<String>();
        Enumeration<String> en    = request.getParameterNames();

        while(en.hasMoreElements())
            names.add(en.nextElement());

        return names;
    }

    /** 获取 {@link HttpServletRequest} 的指定请求参数值集合 */
    public final static List<String> getParamValues(HttpServletRequest request, String name)
    {
        String[] values = request.getParameterValues(name);
        return values != null ? Arrays.asList(values) : null;
    }

    /** 获取 {@link HttpServletRequest} 的所有参数名称和值 */
    public final static Map<String, String[]> getParamMap(HttpServletRequest request)
    {
        return request.getParameterMap();
    }

    /** 获取 {@link HttpSession} 对象，如果没有则进行创建。 */
    public final static HttpSession getSession(HttpServletRequest request)
    {
        return getSession(request, true);
    }

    /** 获取 {@link HttpSession} 对象，如果没有则根据参数决定是否创建。 */
    public final static HttpSession getSession(HttpServletRequest request, boolean create)
    {
        return request.getSession(create);
    }

    /** 创建 {@link HttpSession} 对象，如果已存在则返回原对象。 */
    public final static HttpSession createSession(HttpServletRequest request)
    {
        return getSession(request);
    }

    /** 获取所有 {@link Cookie} */
    public final static Cookie[] getCookies(HttpServletRequest request)
    {
        return request.getCookies();
    }

    /** 获取指定名称的 {@link Cookie} */
    public final static Cookie getCookie(HttpServletRequest request, String name)
    {
        Cookie cookie = null;
        Cookie[] cookies = request.getCookies();

        if(cookies != null)
        {
            for(Cookie c : cookies)
            {
                if(c.getName().equals(name))
                {
                    cookie = c;
                    break;
                }
            }
        }

        return cookie;
    }

    /** 获取指定名称的 {@link Cookie} 值，失败返回 null */
    public final static String getCookieValue(HttpServletRequest request, String name)
    {
        String value = null;
        Cookie cookie = getCookie(request, name);

        if(cookie != null)
            value = cookie.getValue();
            if (value != null) {
                try {
                    value = URLDecoder.decode(value, "UTF-8");
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
            }
        return value;
    }

    /** 添加 {@link Cookie} */
    public final static void addCookie(HttpServletResponse response, Cookie cookie)
    {
        response.addCookie(cookie);
    }

    /** 添加 {@link Cookie} */
    public final static void addCookie(HttpServletResponse response, String name, String value)
    {
        addCookie(response, new Cookie(name, value));
    }

    /** 获取 URL 的  BASE 路径 */
    public final static String getRequestBasePath(HttpServletRequest request)
    {
        String scheme        = request.getScheme();
        int serverPort        = request.getServerPort();
        StringBuilder sb    = new StringBuilder(scheme).append("://").append(request.getServerName());

        if    (!(
                (scheme.equals(HTTP_SCHEMA) && serverPort == HTTP_DEFAULT_PORT) ||
                (scheme.equals(HTTPS_SCHEMA) && serverPort == HTTPS_DEFAULT_PORT)
            ))
                sb.append(":").append(request.getServerPort());

            sb.append(request.getContextPath()).append("/");

        return sb.toString();
    }

    /** 获取 URL 地址在文件系统的绝对路径,
     *
     * Servlet 2.4 以上通过 request.getServletContext().getRealPath() 获取,
     * Servlet 2.4 以下通过 request.getRealPath() 获取。
     *
     */
    @SuppressWarnings("deprecation")
    public final static String getRequestRealPath(HttpServletRequest request, String path)
    {
        if(servletContext != null)
            return servletContext.getRealPath(path);
        else
        {
            try
            {
                Method m = request.getClass().getMethod("getServletContext");
                ServletContext sc = (ServletContext)m.invoke(request);
                return sc.getRealPath(path);
            }
            catch(Exception e)
            {
                return request.getRealPath(path);
            }
        }
    }

    /** 获取发送请求的客户端浏览器所在的操作系统平台 */
    public final static String getRequestUserAgentPlatform(HttpServletRequest request)
    {
        int index        = 1;
        String platform    = null;
        String agent    = request.getHeader("user-agent");

        if(StringUtils.isNotEmpty(agent))
        {
            int i                = 0;
            StringTokenizer st    = new StringTokenizer(agent, ";");

            while(st.hasMoreTokens())
            {
                String token = st.nextToken();

                if(i == 0)
                {
                    if(token.toLowerCase().indexOf("compatible") != -1)
                        index = 2;
                }
                else if(i == index)
                {
                    int sep = token.indexOf(")");

                    if(sep != -1)
                        token = token.substring(0, sep);

                    platform = StringUtils.trimToEmpty(token);

                    break;
                }

                ++i;
            }
        }

        return platform;
    }

    /** 设置 HTTP 的 'Content-Type' 响应头 */
    public final static void setContentType(HttpServletResponse response, String contentType, String encoding)
    {
        StringBuilder sb = new StringBuilder(contentType);

        if(encoding != null)
            sb.append(";charset=").append(encoding);

        response.setContentType(sb.toString());
    }

    /** 禁止浏览器缓存当前页面 */
    public final static void setNoCacheHeader(HttpServletResponse response)
    {
        response.setHeader("Pragma", "No-cache");
        response.setHeader("Cache-Control", "no-cache");
        response.setDateHeader("Expires", 0);
    }

    /** 检查请求是否来自非 Windows 系统的浏览器 */
    public final static boolean isRequestNotComeFromWidnows(HttpServletRequest request)
    {
        String agent = request.getHeader("user-agent");

        if(StringUtils.isNotEmpty(agent))
            return agent.toLowerCase().indexOf("windows") == -1;

        return false;
    }
    /**
     * 发送GET请求
     * @param url
     * @return
     * @throws IOException
     */
    public final static HttpRespons sendGet(String url) throws IOException{
        return send(url,METHOD_GET,new HashMap(),null);
    }
    public final static HttpRespons sendGet(String url, Map<String,String> params) throws IOException{
        return send(url,METHOD_GET,params,null);
    }
    public final static HttpRespons sendGet(String url, Map<String,String> params,Map<String,String> properties) throws IOException{
        return send(url,METHOD_GET,params,properties);
    }
    public final static HttpRespons sendPost(String url) throws IOException{
        return send(url,METHOD_POST,new HashMap(),null);
    }
    public final static HttpRespons sendPost(String url,Map<String,String> params) throws IOException{
        return send(url,METHOD_POST,params,null);
    }
    public final static HttpRespons sendPost(String url, Map<String,String> params,Map<String,String> properties) throws IOException{
        return send(url,METHOD_POST,params,properties);
    }
    /**
     * 发送POST请求
     * @param urlStr 请求地址
     * @param send   发送数据包
     * @return
     * @throws IOException
     */
    public final static HttpRespons sendPost(String urlStr,String send,Map<String,String> headers) throws IOException{
        return send(urlStr,METHOD_POST,send,headers);
    }
    public final static HttpRespons send(String urlStr,String method,String send,Map<String, String> headers) throws IOException{
        HttpURLConnection conn = null;
        URL url = new URL(urlStr);
        conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod(method);
        conn.setDoOutput(true);
        conn.setDoInput(true);
        conn.setUseCaches(false);
        if(headers != null){
            for (String key : headers.keySet()) {
                conn.addRequestProperty(key, headers.get(key));
            }
        }
        conn.getOutputStream().write(send.getBytes());
        conn.getOutputStream().flush();
        conn.getOutputStream().close();
        return makeRespons(urlStr,conn);
    }
    private final static HttpRespons send(String urlStr,String method,Map<String, String> params, Map<String, String> propertys)
            throws IOException{
        HttpURLConnection conn = null;
        if(METHOD_GET.equals(method) && params !=null && !params.isEmpty()){
            StringBuffer param = new StringBuffer();
            int i = 0;
            for (String key : params.keySet()) {
                if (i == 0)
                    param.append("?");
                else
                    param.append("&");
                param.append(key).append("=").append(params.get(key));
                i++;
            }
            urlStr += param;
        }
        URL url = new URL(urlStr);
        conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod(method);
        conn.setDoOutput(true);
        conn.setDoInput(true);
        conn.setUseCaches(false);
        if(propertys != null && !propertys.isEmpty()){
            for (String key : propertys.keySet()) {
                conn.addRequestProperty(key, propertys.get(key));
            }
        }
        if(METHOD_POST.equals(method) && params != null){
            StringBuffer param = new StringBuffer();
            for (String key : params.keySet()) {
                param.append("&");
                param.append(key).append("=").append(params.get(key));
            }
            conn.getOutputStream().write(param.toString().getBytes());
            conn.getOutputStream().flush();
            conn.getOutputStream().close();
        }
        return makeRespons(urlStr,conn);
    }
    private final static HttpRespons makeRespons(String urlString,HttpURLConnection urlConnection)throws IOException{
        HttpRespons httpResponser = new HttpRespons();
        try {
            InputStream in = urlConnection.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(
                    new InputStreamReader(in,"utf-8"));
            httpResponser.contentCollection = new Vector<String>();
            StringBuffer temp = new StringBuffer();
            String line = bufferedReader.readLine();
            while (line != null) {
                httpResponser.contentCollection.add(line);
                temp.append(line).append("\r\n");
                line = bufferedReader.readLine();
            }
            bufferedReader.close();  

            String ecod = urlConnection.getContentEncoding();  

            if (ecod == null){
                ecod = defaultContentEncoding;
            }

            httpResponser.urlString = urlString;  

            httpResponser.defaultPort = urlConnection.getURL().getDefaultPort();
            httpResponser.file = urlConnection.getURL().getFile();
            httpResponser.host = urlConnection.getURL().getHost();
            httpResponser.path = urlConnection.getURL().getPath();
            httpResponser.port = urlConnection.getURL().getPort();
            httpResponser.protocol = urlConnection.getURL().getProtocol();
            httpResponser.query = urlConnection.getURL().getQuery();
            httpResponser.ref = urlConnection.getURL().getRef();
            httpResponser.userInfo = urlConnection.getURL().getUserInfo();  

            httpResponser.content = new String(temp.toString().getBytes(), "utf-8");
            httpResponser.contentEncoding = ecod;
            httpResponser.code =  urlConnection.getResponseCode();
            httpResponser.message = urlConnection.getResponseMessage();
            httpResponser.contentType = urlConnection.getContentType();
            httpResponser.method = urlConnection.getRequestMethod();
            httpResponser.connectTimeout = urlConnection.getConnectTimeout();
            httpResponser.readTimeout = urlConnection.getReadTimeout();

            return httpResponser;
        } catch (IOException e) {
            throw e;
        } finally {
            if (urlConnection != null)
                urlConnection.disconnect();
        }
    }
    /**
     * 将请求中的json内容转为Map
     * @param request
     * @return
     * @throws IOException
     */
//    public static Map parseRequestJson(HttpServletRequest request) throws IOException{
//
//        String str = readString(request, true, request.getCharacterEncoding());
//        ObjectMapper mapper = new ObjectMapper();
//        return mapper.readValue(str,HashMap.class);
//    }
}

package com.milan.util;

import java.util.Vector;

/**
 * 响应对象
 *
 */
public class HttpRespons {
    String urlString;

    int defaultPort;

    String file;  

    String host;  

    String path;  

    int port;  

    String protocol;  

    String query;  

    String ref;  

    String userInfo;  

    String contentEncoding;  

    String content;  

    String contentType;  

    int code;  

    String message;  

    String method;  

    int connectTimeout;  

    int readTimeout;  

    Vector<String> contentCollection;

    public String getUrlString() {
        return urlString;
    }

    public void setUrlString(String urlString) {
        this.urlString = urlString;
    }

    public int getDefaultPort() {
        return defaultPort;
    }

    public void setDefaultPort(int defaultPort) {
        this.defaultPort = defaultPort;
    }

    public String getFile() {
        return file;
    }

    public void setFile(String file) {
        this.file = file;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getProtocol() {
        return protocol;
    }

    public void setProtocol(String protocol) {
        this.protocol = protocol;
    }

    public String getQuery() {
        return query;
    }

    public void setQuery(String query) {
        this.query = query;
    }

    public String getRef() {
        return ref;
    }

    public void setRef(String ref) {
        this.ref = ref;
    }

    public String getUserInfo() {
        return userInfo;
    }

    public void setUserInfo(String userInfo) {
        this.userInfo = userInfo;
    }

    public String getContentEncoding() {
        return contentEncoding;
    }

    public void setContentEncoding(String contentEncoding) {
        this.contentEncoding = contentEncoding;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getContentType() {
        return contentType;
    }

    public void setContentType(String contentType) {
        this.contentType = contentType;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public int getConnectTimeout() {
        return connectTimeout;
    }

    public void setConnectTimeout(int connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

    public int getReadTimeout() {
        return readTimeout;
    }

    public void setReadTimeout(int readTimeout) {
        this.readTimeout = readTimeout;
    }

    public Vector<String> getContentCollection() {
        return contentCollection;
    }

    public void setContentCollection(Vector<String> contentCollection) {
        this.contentCollection = contentCollection;
    } 

}

3、创建 java请求类

java请求类需要继承AbstractJavaSamplerClient类和实现Serializable接口。

package com.milan.test;

import java.io.IOException;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

import org.apache.jmeter.config.Arguments;
import org.apache.jmeter.protocol.java.sampler.AbstractJavaSamplerClient;
import org.apache.jmeter.protocol.java.sampler.JavaSamplerContext;
import org.apache.jmeter.samplers.SampleResult;

import com.milan.util.HttpHelper;

public class JavaRequestTest extends AbstractJavaSamplerClient implements
        Serializable {

    // 设置默认值
    public Arguments getDefaultParameters() {
        Arguments params = new Arguments();
        params.addArgument("url", "http://www.baidu.com");
        params.addArgument("kw", "你好");
        return params;
    }

    public SampleResult runTest(JavaSamplerContext arg0) {
        SampleResult sr = new SampleResult();
        sr.setSampleLabel("java请求测试-MiLan");
        sr.sampleStart();//
        // http请求
        String strReturn = "";
        try {
            strReturn = Send(arg0);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 设置返回值
        sr.setResponseData(strReturn, null);
        sr.setDataType(SampleResult.TEXT);

        System.out.println(strReturn);
        sr.setSuccessful(true);
        sr.sampleEnd();
        return sr;
    }
    // http请求
    private String Send(JavaSamplerContext arg0) throws IOException {
        String url = arg0.getParameter("url", "http://www.baidu.com");
        String kw = arg0.getParameter("kw", "MiLan");
        Map<String, String> map = new HashMap<String, String>();
        map.put("kw", kw);
        return HttpHelper.sendGet(url, map).getContent();

    }
}

4、生成jar包

生成jar包的时候，不能选择jmeter的jar包。只能选择自己有用到的jar包。刚才用到了javax.servlet-api-3.1.0.jar，所以要把这个jar包一起打包。

需要用fatjar打包，不然可能找不到引用jar包的类。不知道怎么用fatjar打包的，可以参考http://www.cnblogs.com/milanmi/p/4651904.html

aaarticlea/png;base64,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" alt="" />

生成jar包后，把jar包拷贝到jmeter的lib/ext目录

5、运行jmeter

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,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" alt="" />