క్యూలు మరియు JMeter: ప్రచురణకర్త మరియు చందాదారులతో భాగస్వామ్యం

హలో, హబ్ర్! ఇది నా సీక్వెల్ మునుపటి ప్రచురణ, దీనిలో నేను JMeterని ఉపయోగించి క్యూలలో సందేశాలను ఉంచే ఎంపికల గురించి మాట్లాడతాను.

మేము పెద్ద ఫెడరల్ కంపెనీ కోసం డేటా బస్సును తయారు చేస్తున్నాము. వివిధ అభ్యర్థన ఫార్మాట్‌లు, రూపాంతరాలు, క్లిష్టమైన రూటింగ్. పరీక్ష కోసం, మీరు క్యూలో చాలా సందేశాలను పంపాలి. మానవీయంగా ప్రతి చిరోప్రాక్టర్ నిర్వహించలేని నొప్పి.

పరిచయం

నేను మొదట ఈ నొప్పిని భరించవలసి వచ్చినప్పటికీ. ఇదంతా RFHUtilతో ప్రారంభమైంది. శక్తివంతమైన, కానీ ఇబ్బందికరమైన మరియు భయానకంగా: బాగా, మీకు రస్ తెలుసు.

కొన్ని సందర్భాల్లో అనివార్యమైనది, కానీ క్రియాశీల ఉపయోగం విషయంలో క్రమంగా తగ్గుతుంది.
దానితో అనుకూలమైన పరీక్ష అసాధ్యం.

JMeterతో ప్రతిదీ సులభంగా మారింది. మాస్టరింగ్ మరియు అలవాటు పడిన మొదటి దశ తర్వాత, సంతోషకరమైన పరీక్ష కోసం ఆశ ప్రారంభమైంది.

నేను JMS పబ్లిషర్ మరియు JMS సబ్‌స్క్రైబర్ నమూనాలను చురుకుగా ఉపయోగిస్తాను. JMS పాయింట్-టు-పాయింట్ కాకుండా, ఈ జత ఉపయోగించడానికి మరింత సౌకర్యవంతంగా అనిపించింది. ఉదాహరణకు, JMS సెలెక్టర్‌లోని సబ్‌స్క్రైబర్‌తో మీరు వేరియబుల్‌ను పేర్కొనవచ్చు, కానీ పాయింట్-టు-పాయింట్‌తో మీరు చేయలేరు (లేదా ఈ పద్ధతి చాలా స్పష్టంగా లేదు).

నమూనాలను సిద్ధం చేస్తోంది

JMS పబ్లిషర్

• సెటప్ - ప్రతి నమూనా. అపాచీ సిఫార్సు క్యూలు/టాపిక్‌లు వేరియబుల్స్ ద్వారా పేర్కొనబడితే ఈ ఎంపికను ఉపయోగించండి.
• గడువు (మిసె) = 120000. విఫలమైతే, పరీక్ష అభ్యర్థనలు 2 నిమిషాల తర్వాత క్యూ నుండి అదృశ్యమవుతాయి.
• నాన్-పెర్సిస్టెంట్ డెలివరీ మోడ్‌ని ఉపయోగించాలా? - నిజం. IBM వాదనలుఅకస్మాత్తుగా వైఫల్యం సంభవించినప్పుడు, ప్రసారం చేయబడిన సందేశాల యొక్క విశ్వసనీయమైన సంరక్షణను నిరంతర మోడ్ నిర్ధారిస్తుంది. మరియు నాన్-పెర్సిస్టెంట్ మోడ్‌లో వేగంగా మార్పిడి. పరీక్ష ప్రయోజనాల కోసం, వేగం మరింత ముఖ్యమైనది.

ప్రతి పబ్లిషర్‌లో నేను సబ్‌స్క్రైబర్ JMS సెలెక్టర్‌లో ఉపయోగించే jms ప్రాపర్టీని సెట్ చేసాను. ప్రతి సమర్పణ కోసం, వినియోగదారు పారామితుల పరీక్ష ప్రణాళిక మూలకంలో యాదృచ్ఛిక విలువ ఉత్పత్తి చేయబడుతుంది:

ఈ విధంగా మీరు సరైన సందేశం చదవబడిందని నిర్ధారించుకోవచ్చు.

ముందుగా కాన్ఫిగర్ చేయబడిన JMS పబ్లిషర్ యొక్క చివరి "ఖాళీ":

JMS సబ్‌స్క్రైబర్

• సెటప్ - ప్రతి నమూనా. బాగా, మీరు అర్థం.
• గడువు ముగిసింది (మిసె) = 100000. 100 సెకన్ల నిరీక్షణ తర్వాత అభ్యర్థన క్యూలో రాకపోతే, ఏదో తప్పు జరిగింది.
• నమూనాల మధ్య ఆగిపోవాలా? - నిజం.

JMS సెలెక్టర్ - చాలా సౌకర్యవంతంగా ఉంటుంది విషయం. చివరి JMS సబ్‌స్క్రైబర్:

ప్రసారం చేయబడిన సందేశాలలో సిరిలిక్ వర్ణమాలతో ఎలా వ్యవహరించాలి. JMeterలో, డిఫాల్ట్‌గా, ప్రూఫ్ రీడింగ్ తర్వాత, అది వంకరగా ప్రదర్శించబడుతుంది. దీన్ని నివారించడానికి మరియు ఎల్లప్పుడూ మరియు ప్రతిచోటా గొప్ప మరియు శక్తివంతమైన వాటిని ఆస్వాదించడానికి, మీరు వీటిని చేయాలి:

1. JMeter “లాంచర్”కి JVM ఆర్గ్యుమెంట్‌ని జోడించండి:

   -Dfile.encoding=UTF-8

2. గ్రూవీ లైన్‌తో సబ్‌స్క్రైబర్‌కు JSR223 పోస్ట్‌ప్రాసెసర్‌ని జోడించండి:

   prev.setDataEncoding("UTF-8")

వచనాన్ని పంపండి

సోమరితనం ఎంపిక. తాజాగా వ్రాసిన పరీక్షలను డీబగ్గింగ్ చేయడానికి అనుకూలం. లేదా మీరు కనీసం ఏదైనా చిన్నదాన్ని పంపవలసి వచ్చినప్పుడు. ఎంపికను ఎంచుకోండి సందేశ మూలం - Textarea మరియు సందేశం యొక్క భాగాన్ని టెక్స్ట్ బ్లాక్‌లో ఉంచండి:

ఫైల్ బదిలీ

అత్యంత సాధారణ ఎంపిక. చాలా దృశ్యాలకు అనుకూలం. ఎంపికను ఎంచుకోండి సందేశ మూలం - ఫైల్ నుండి మరియు ఫీల్డ్‌లోని సందేశానికి మార్గాన్ని సూచించండి ఫైల్ - ఫైల్ పేరు:

ఫైల్‌ను టెక్స్ట్ ఫీల్డ్‌కి బదిలీ చేస్తోంది

అత్యంత బహుముఖ ఎంపిక. చాలా దృశ్యాలకు అనుకూలం + రెండవ పంపే ఎంపిక లేని JMS పాయింట్-టు-పాయింట్‌లో ఉపయోగించవచ్చు:

బైట్ శ్రేణిని దాటుతోంది

అత్యంత క్లిష్టమైన ఎంపిక. వక్రీకరణ, SMS మరియు గందరగోళం లేకుండా బైట్ వరకు అభ్యర్థనల తప్పుగా ఖచ్చితమైన ప్రసారాన్ని తనిఖీ చేయడానికి అనుకూలం. మీరు డిఫాల్ట్ JMeterలో దీన్ని చేయలేరు. ఇక్కడ నేను దీని గురించి ఖచ్చితంగా చెప్పాను.

కాబట్టి నేను డౌన్‌లోడ్ చేయాల్సి వచ్చింది మూలాలు మరియు సవరించండి వద్ద JMS సబ్‌స్క్రైబర్.

పద్ధతిలో భర్తీ చేయబడింది extractContent(..) లైన్:

buffer.append(bytesMessage.getBodyLength() + " bytes received in BytesMessage");

పై:

byte[] bytes = new byte[(int) bytesMessage.getBodyLength()];
bytesMessage.readBytes(bytes);
try {
	buffer.append(new String(bytes, "UTF-8"));
} catch (UnsupportedEncodingException e) {
	throw new RuntimeException(e);
}

మరియు JMeterని పునర్నిర్మించారు.

JSR223 నమూనాలను జోడించడం మాత్రమే మిగిలి ఉంది. మొదటిది యాదృచ్ఛిక బైట్‌లను కలిగి ఉన్న DAT ఫైల్‌ని సృష్టించడానికి ప్రచురణకర్త/చందాదారు జంట ముందు ఉంటుంది:

import org.apache.commons.lang3.RandomUtils;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

vars.put("PATH_TO_BYTES", "C:temprandomBytes.dat");
File RESULT_FILE = new File(vars.get("PATH_TO_BYTES"));
byte[] arr = RandomUtils.nextBytes((int)(Math.random()*10000));
        try {
            FileOutputStream fos = new FileOutputStream(RESULT_FILE);
            fos.write(arr);
            fos.close();
        } catch (IOException e) {
            System.out.println("file not found");
        }

రెండవది - స్క్రిప్ట్ చివరిలో, ఫైల్‌ను తొలగిస్తుంది:

import java.io.File;

File RESULT_FILE = new File(vars.get("PATH_TO_BYTES"));
RESULT_FILE.delete();

మరియు పబ్లిషర్‌లోని ఫైల్‌కి పాత్‌ను జోడించడం మర్చిపోవద్దు:

మరియు సబ్‌స్క్రైబర్ కోసం JSR223 అసెర్షన్‌లో చెక్ - గ్రహీత క్యూలో వచ్చే వాటితో సోర్స్ బైట్‌లను సరిపోల్చండి:

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;

Path path = Paths.get(vars.get("PATH_TO_BYTES"), new String[0]);
byte[] originalArray = Files.readAllBytes(path);
byte[] changedArray = ctx.getPreviousResult().getResponseData();
System.out.println(changedArray.length);

if (Arrays.equals(originalArray, changedArray))
	{
     	SampleResult.setResponseMessage("OK");

	} else {
	   SampleResult.setSuccessful(false);
     	   SampleResult.setResponseMessage("Comparison failed");
	   SampleResult.setResponseData("Bytes have changed","UTF-8");
     	   IsSuccess=false;
	}

తీర్మానం

నేను ప్రతిరోజు ఆచరణలో ఉపయోగించే క్యూలకు సందేశాలను పంపడానికి నాలుగు మార్గాలను వివరించాను. ఈ సమాచారం మీ జీవితాన్ని సులభతరం చేస్తుందని నేను ఆశిస్తున్నాను. కొనసాగింపుగా, ఒక చివర క్యూ మరియు మరొక వైపు డేటాబేస్ లేదా ఫైల్ సిస్టమ్ ఉన్న ఎక్స్ఛేంజ్‌ని పరీక్షించడంలో నా అనుభవం గురించి మాట్లాడాలనుకుంటున్నాను.

మీ సమయాన్ని ఆదా చేసుకోండి. మరియు మీ దృష్టికి ధన్యవాదాలు.

మూలం: www.habr.com