AppletViewer

Question

से एक रीलोड और पुनरारंभ को सही ढंग से संभालना जब मेरा एप्लेट स्वच्छ वातावरण से पहली बार शुरू होता है, तो चीजें काम करती हैं जिस तरह से मैं उन्हें उम्मीद करता हूं। मैं दो धागे पैदा करता हूं, एक सामान्य प्रसंस्करण के लिए, और ग्राफिक्स के लिए एक। मैं घटना प्रेषण धागे से सभी जीयूआई हेरफेर कॉल करता हूँ। स्टार्ट/स्टॉप को एप्लेट व्यूअर से सही तरीके से संभाला जाता है, लेकिन पुनरारंभ/पुनः लोड नहीं होता है। मेरे पास drawCanvas नामक कैनवास है जो मेरे एप्लेट के सामग्री फलक में एकमात्र घटक है, और मैं इसे आकर्षित करने के लिए डबल बफरिंग का उपयोग करता हूं।

मैं यहाँ समस्या पर ध्यान दें:

public void start() { 
    /* ... some stuff */ 
    executeOnEDTAndWait( 
     new Thread() { 
      @Override 
      public void run() { 
       /* ... more stuff ... */ 
       setupDrawCanvas(); 

       if(drawCanvas.isDisplayable()) { 
        drawCanvas.createBufferStrategy(2); 
        /* ... some more stuff */ 
       } else { 
        /* This is where it runs into difficulties */ 
       } 
    /* ... */ 

कहाँ setupDrawCanvas इस तरह परिभाषित किया गया है:

private void setupDrawCanvas() { 
    setVisible(false); 
    setIgnoreRepaint(true); 

    getContentPane().removeAll(); 

    drawCanvas = new Canvas(); 

    drawCanvas.setName("drawCanvas"); 
    drawCanvas.setSize(
    newDrawCanvasDimension.width, 
    newDrawCanvasDimension.height); 
    drawCanvas.setIgnoreRepaint(true); 

    getContentPane().add(drawCanvas); 

    getContentPane().setVisible(true); 
    drawCanvas.setVisible(true); 
    setVisible(true); 
} 

इसके अलावा, यहाँ के माध्यम से destroy()

public void destroy() { 
    /* .. some stuff .. */ 

    /* dispose of drawCanvas */ 
    drawCanvas.setVisible(false); 
    if(drawCanvas.getBufferStrategy() != null) { 
     drawCanvas.getBufferStrategy().dispose(); 
    } 

    /* reset and disable the applet's GUI */ 
    setVisible(false); 
    getContentPane().removeAll(); 
    removeAll(); 

    /* .. some more stuff */ 

पहली बार में प्रासंगिक कोड है सब कुछ ठीक काम करता है। जब मैं appletviewer से पुनरारंभ करता हूं, तो पहले stop() कहा जाता है जो मेरे सभी धागे प्रतीक्षा राज्यों में प्रवेश करने का कारण बनता है। फिर destroy() कहा जाता है जो मेरे सभी धागे को फिर से जगाता है और ईडीटी पर अपने विगेट्स को साफ करने और सेट सेट करने योग्य (झूठा) करने के लिए उन्हें बाहर निकलने देता है और invokeAndWait() करता है। तो नष्ट होने के बाद appletviewer कॉल इनिट/फिर से शुरू होता है और प्रक्रिया पहले की तरह दोहराती है, सिवाय इसके कि ऊपर दिए गए क्षेत्र में start() में विफल रहता है।

कोई चीज जो मैंने देखा है जो मेरे लिए बहुत कम समझ में बनाया है कि अगर मैं एप्लेट appletviewer का उपयोग कर क्लोन और फिर क्लोन पुनः लोड, सब कुछ है जब मैं पुनः आरंभ या क्लोन पहली बार फिर से लोड करने का प्रयास किया अपेक्षा के अनुरूप काम होता था, लेकिन दूसरी बार एक अपवाद के साथ दुर्घटनाग्रस्त हो जाएगा।

इस समस्या को डीबग करने का प्रयास करते समय मैंने कुछ और देखा है कि appletviewer और एक ब्राउज़र एक्ट पूरी तरह से अलग-अलग मेरे एप्लेट के मेजबान के रूप में; वे एक ही परिस्थितियों में init() और start() पर भी कॉल नहीं करते हैं। साथ ही, पुनरारंभ करें और पुनः लोड करें stop() ->destroy() ->init() ->start() पर निष्पादन वातावरण में सूक्ष्म संशोधन के साथ।

तो मेरा सवाल यह है कि पुनरारंभ करने और फिर से लोड करने के संचालन का महत्व क्या है (यानी जब उनका उपयोग किया जाता है) और क्या यह एक समस्या है कि मेरे एप्लेट एप्लेटवियर में विफल होने पर विफल रहता है?

Answer 1

अच्छा प्रश्न। इस प्रश्न का उत्तर देने के लिए हमें पहले जावा कोड के ब्लॉक को समझने की आवश्यकता है। हमारे पास एक अज्ञात, स्थैतिक ब्लॉक है जो कन्स्ट्रक्टर से पहले निष्पादित किया जाएगा।

package com.test; 

import java.applet.Applet; 
import java.awt.*; 

public class AppletTest extends Applet { 
    { 
     System.out.println("I m Anonymous block"); 
    } 

    static { 
     System.out.println("I m static block"); 
    } 

    public AppletTest() 
    { 
     System.out.println("I m constructor"); 
    } 

    public void init() 
    { 
     System.out.println("init"); 
    } 

    public void start() 
    { 
     System.out.println("start"); 
    } 

    public void stop() 
    { 
     System.out.println("stop"); 
    } 

    public void destroy() 
    { 
     System.out.println("destory"); 
    } 

    public void paint(Graphics g) 
    { 
     g.drawString("test Applet",10,10); 
    } 
} 

मंगलाचरण:

<applet code="AppletTest.class" height=300 width=300></applet> 

जब इस वर्ग appletviewer का उपयोग कर आप अंतर नोट कर सकते हैं चल रहा है। एप्लेट पहली बार के लिए चल रहा है जबकि एप्लेट पुनः आरंभ कर मिल जाएगा

I m static block 
    I m Anonymous block 
    I m constructor 
    init 
    start 

-

stop 
destory 
init 
start 

और एप्लेट पुनः लोड

stop 
destory 
I m Anonymous block 
I m constructor 
init 
start 

अपने दूसरे प्रश्न के लिए पर, एप्लेट की गारंटी नहीं देता विभिन्न ओएस, नेटवर्क और हार्डवेयर घटकों पर एक ही आउटपुट।