Continuam seriem articulorum continuatam, quae ad exsequendam usorum Fenestram utilitatum morem deditam sunt, adiuvare non possumus quin in TFTP (Trivialis Tabularii Protocol translatio) - simplex translationis protocollum.
Procedente tempore, theoriam breviter transeamus, codicem videas qui instrumenti functionis similis illi inquisitae est, et illam resolvere. More details - sub cut
Nolo informationes referentias effingo crustulum, nexus quibus tradito in fine articuli reperiri possunt, tantum dicam quod in suo nucleo, TFTP est simplicior variatio protocolli FTP, in qua accessus ditionis occasus habet. remoto, et re vera nihil hic nisi mandatum ad fasciculum recipiendum et transferendum. Attamen, ut ad exsequendam nostram deductionem paulo elegantiorem et ad hodiernas scripturae codicis principia accommodata, syntaxis aliquantulum mutata est - haec principia operandi non mutat, sed interfacies, IMHO, paulo magis logica fit ac componit aspectus positivos FTP et TFTP.
Praesertim cum incipiendo, clientis IP oratio servientis petit et portus in quo consuetudo TFTP aperta est (ob repugnantiam cum protocollo vexilli, opportunum duxi utentis facultatem portum deligendi relinquere), post quem. nexus incidit, ex quibus client unum e iussa mittere potest - accipere vel mittere, limam accipere vel mittere servo. Omnes fasciculi in modum binarii mittuntur ad logicam simpliciorem reddendam.
Ad protocollum deducendum, traditionaliter usus sum 4 classes;
- TFTPClient
- TFTPServer
- TFTPClientTester
- TFTPServerTester
Ob quod probationes classes tantum ad praecipuas debugging existunt, eas non resolvere, sed signum in promptuario erit, nexus cum fine articuli inveniri potest. Nunc classes principales intuebor.
TFTPClient
Negotium huius generis est cum servo remoto coniungere numero suo ip et portu, praeceptum legere ab input fluento (hoc in casu, tincidunt), parse illud, transfer ad ministratorem et, prout tibi placet. necesse est mittere vel recipere limam, transferre vel accipere.
Codicem ad clientem deducendum ad servo coniungendum et mandatum exspectandum ab input fluento simile hoc spectat. Plures variabilium globalium quae hic adhibitae sunt extra articulum in pleno textu programmatis describuntur. Ob eorum levitatem, non adfero ut articulum non onerem.
public void run(String ip, int port)
{
this.ip = ip;
this.port = port;
try {
inicialization();
Scanner keyboard = new Scanner(System.in);
while (isRunning) {
getAndParseInput(keyboard);
sendCommand();
selector();
}
}
catch (Exception e) {
System.out.println(e.getMessage());
}
}Transeamus ad modos in hoc codice truncos vocatos:
Tabella hic mittitur - scanner utens, documenta contenta in ordine bytes exhibemus, quae singillatim ad nervum scribimus, postquam eam claudimus et iterum aperimus (non solutionem manifestissimam, sed eam subsidiorum emissione spondet), post quam nuntium de felici translatione ostendimus.
private void put(String sourcePath, String destPath)
{
File src = new File(sourcePath);
try {
InputStream scanner = new FileInputStream(src);
byte[] bytes = scanner.readAllBytes();
for (byte b : bytes)
sout.write(b);
sout.close();
inicialization();
System.out.println("nDonen");
}
catch (Exception e) {
System.out.println(e.getMessage());
}
}Hoc fragmentum codicem describit retrieving data a servo. Omnia rursus levia sunt, primus tantum codicis caudex interest. Ut accurate intelligas quot bytes ex neruo exstent, scire debes quantum lima translata ponderat. Tabella amplitudo in calculonis ut diu integer repraesentatur, ideo 4 bytes hic accipiuntur, quae postea in unum numerum convertuntur. Hoc non admodum appropinquat Java, pro SI similior est, sed problema suum solvit.
Tunc omnia levia sunt - notum numerum bytes e nervum accipimus et eas ad fasciculum scribemus, post quem nuntium prosperum ostendimus.
private void get(String sourcePath, String destPath){
long sizeOfFile = 0;
try {
byte[] sizeBytes = new byte[Long.SIZE];
for (int i =0; i< Long.SIZE/Byte.SIZE; i++)
{
sizeBytes[i] = (byte)sin.read();
sizeOfFile*=256;
sizeOfFile+=sizeBytes[i];
}
FileOutputStream writer = new FileOutputStream(new File(destPath));
for (int i =0; i < sizeOfFile; i++)
{
writer.write(sin.read());
}
writer.close();
System.out.println("nDONEn");
}
catch (Exception e){
System.out.println(e.getMessage());
}
}Si aliud mandatum quam accipere vel positum in fenestra clientela initum est, munus showErroMessage vocabitur, significans initus esse falsa. Ob trivialitatem non citabo. Aliquanto plus interesting est munus recipiendi et scindendi in chorda input. Scanner in eam transeamus, unde lineam duobus spatiis separatam accipere speramus et continens mandatum, fontem inscriptionem et destinationem inscriptionis.
private void getAndParseInput(Scanner scanner)
{
try {
input = scanner.nextLine().split(" ");
typeOfCommand = input[0];
sourcePath = input[1];
destPath = input[2];
}
catch (Exception e) {
System.out.println("Bad input");
}
}Mittens mandatum, mandatum a scanner ad nervum initum transmittit ac mitti cogit
private void sendCommand()
{
try {
for (String str : input) {
for (char ch : str.toCharArray()) {
sout.write(ch);
}
sout.write(' ');
}
sout.write('n');
}
catch (Exception e) {
System.out.print(e.getMessage());
}
}Electrix est functio quae agendi progressionis determinat secundum chordas ingressae. Omnia hic non valde speciosa et cautela adhibita, non est optimus unus cum magnis exitibus extra codicem scandalum, sed praecipua ratio est huius absentiae in Java aliquorum rerum, sicut delegatorum in C#, munus indicibus ex C++, vel in saltem terribilis et terribilis gata, quae te permittit pulchre efficere. Si scias codicem paulo elegantiorem reddere, excipio reprehensionem in commentarios. Mihi videtur lexicon delegatum String-delegatum hic desiderare, sed delegatum non est.
private void selector()
{
do{
if (typeOfCommand.equals("get")){
get(sourcePath, destPath);
break;
}
if (typeOfCommand.equals("put")){
put(sourcePath, destPath);
break;
}
showErrorMessage();
}
while (false);
}
}TFTPServer
Munus ministrantis differt a functione clientis, et magna, nisi in mandatis, non a tincidunt, sed ex turpis. Methodi quaedam fere eadem sunt, ut non dicam, differentias tantum attingam.
Incipere, modus procursus adhibetur, qui portum recipit ut input et processus in notitia e nervum in ansa aeterna.
public void run(int port) {
this.port = port;
incialization();
while (true) {
getAndParseInput();
selector();
}
}Modus posuit, qui scribetToFileFromSocket methodum scribentem ad limam aperit et omnia inputa bytes e nervum scribit, nuntium ostendit ostendit perfectionem translationis cum scribentes complet.
private void put(String source, String dest){
writeToFileFromSocket();
System.out.print("nDonen");
};
private void writeToFileFromSocket()
{
try {
FileOutputStream writer = new FileOutputStream(new File(destPath));
byte[] bytes = sin.readAllBytes();
for (byte b : bytes) {
writer.write(b);
}
writer.close();
}
catch (Exception e){
System.out.println(e.getMessage());
}
}Modum adepto lima servo retrevit. Ut iam in sectione in parte huius programmatis, ut bene limam transferre debes cognoscendi eius magnitudinem, in longo integro conditam, sic illam in 4 bytes dividere, eas byte-byte transferre. ad nervum, deinde, in clientelam in numerum reducto et accepto, omnes bytes qui tabellam faciunt, ab input rivum ex tabella lego.
private void get(String source, String dest){
File sending = new File(source);
try {
FileInputStream readFromFile = new FileInputStream(sending);
byte[] arr = readFromFile.readAllBytes();
byte[] bytes = ByteBuffer.allocate(Long.SIZE / Byte.SIZE).putLong(sending.length()).array();
for (int i = 0; i<Long.SIZE / Byte.SIZE; i++)
sout.write(bytes[i]);
sout.flush();
for (byte b : arr)
sout.write(b);
}
catch (Exception e){
System.out.println(e.getMessage());
}
};
Modus getAndParseInput eadem est ac in cliente, sola differentia esse quod legat notitias e nervum quam ex tincidunt. Codex est in repositorio, sicut electrix.
Hoc in casu, initialization in codice separato ponitur, quia intra hanc exsecutionem, peracta translatione, facultates iterum dimittuntur et reducuntur - iterum ad tutelam contra memoriam effluo.
private void incialization()
{
try {
serverSocket = new ServerSocket(port);
socket = serverSocket.accept();
sin = socket.getInputStream();
sout = socket.getOutputStream();
}
catch (Exception e) {
System.out.print(e.getMessage());
}
}Summatim:
Nos modo scripsimus nostram variationem in notitia simplici translationis protocolli et figuratum quomodo operari debeat. In principio, Americam hic non inveni et multa nova non scripseram, sed articuli in Habre non erant similes, et cum pars scriberet seriem articulorum circa cmd utilitatum, impossibile erat eam attingere.
references:
Source: www.habr.com