Mijn Java Twitter Client

De afgelopen weken heb ik mij nog eens met Java beziggehouden. Vooral met de bedoeling om eigenlijk eens een deftige applicatie te schrijven. Zo from scratch, met de bedoeling een standalone Desktop applicatie te schrijven voor Twitter. Puur uit interesse, puur om bij te leren en om in Swing te spelen.

Nadat ik de Twitter API had doorgenomen ben ik meteen aan de slag gegaan. Het resultaat is een applicatie die ik tweetMe heb genoemd (dat stiekem een verwijzing naar de film Feed is).

tweetMe, a twitter Desktop application

Zoals je ziet is de UI opgebouwd uit een aantal tabs. Eerst wordt er een component gegenereerd. Dit gebeurt door een XML feed uit te lezen via een DOM parser van Java. Dan worden de elementen met waarden in een Array geplaatst, bestaande uit verschillende HashMap‘s die door heel de applicatie wordt doorgegeven. Zo wordt er een Component gebouwd dat dan meegegeven wordt aan de specifieke tab. Het component moet telkens er van tab veranderd wordt volledig terug worden opgebouwd. Weer feed lezen, weer parsen en doorgeven en dan netjes HTML weergeven.

So far so good, het updaten naar Twitter werkt en het geformatteerd weergeven van de feeds ook. Dramatischer is dat dat laatste proces acht à tien seconden in beslag neemt. Onbegonnen werk dus, er schort duidelijk iets aan mijn manier van werken. En toch begrijp ik niet waarom dat het zo lang duurt.

Nu ja, er zal heus wel een andere manier zijn om zo’n dingen aan te pakken. Ik beschouw dit als een leerproces, zoals ik al zei. Ik kijk wel eens naar XUL of Adobe Air, zulke zaken zijn meer ontworpen om Internet applicaties te ontwikkelen. Java is een mature technologie die bovendien nog platform onafhankelijk is, maar Java lijkt heel onstabiel en zwaar te zijn. Niet alleen bij het bouwen van deze applicatie werd mij dat duidelijk, maar ook bij het gebruiken van het belachelijk onstabiele ArgoUML, een modelleer tool geschreven in Java.

Dus ja, de ontwikkeling zal niet verder worden gezet wat mij betreft of u moest afkomen met wat tips of sturingen. Ik zou dan heel dankbaar zijn en u zou eeuwige roem krijgen. Echt waar.

5 thoughts on “Mijn Java Twitter Client”

  1. Is het wel nodig om telkens die component opnieuw op te bouwen als er van tabblad gewisseld wordt? Is het niet mogelijk om met iedere tabblad een object te associeren en dit enkel te vernieuwen als het echt nodig is?

    Show us the code! 😛

  2. Goh, dat kan ik inderdaad overwegen om dat eruit te halen. Ik kan dan het verversen van de pagina op de achtergrond laten gebeuren om de x seconden, er mee rekening houdend dat er dan 8 seconden verloren gaan, want die issue blijft.

    Dit is de functie om een tab te laden.

    
    private void loadTab(int n) {
    		// publictimeline
    		if(n == 0) {
    			tabbedPane.removeTabAt(n);
    	        JComponent publicTimelinePanel = makeTextPanel(1);
    	        publicTimelinePanel.setPreferredSize(new Dimension(500, 300));
    	}
    }
    
    

    Dit is de functie om het component te creëren.

    
    protected JComponent makeTextPanel(int tweetCase) {
            TweetMe tm = new TweetMe();
            Map[] hash;
            JEditorPane panel = new JEditorPane("text/html", "");
            panel.setPreferredSize(new Dimension(500, 500));
            panel.setEditable(false);
        	switch(tweetCase) {
        		case 1:    			
        			hash = tm.getPublicTimeline();
    			    StringBuffer sb = new StringBuffer();    			
        			sb.append("");
    			    for(int i=0; i");
        				// Create new array
        				String[] entryRecord = new String[hash[i].entrySet().size()]; 
    	    			for(Map.Entry entry : hash[i].entrySet()) {
    	    				
    	    				String key = entry.getKey();
    	    				String value = entry.getValue();	    			
    	    			       
    	    				if(key == "screen_name") {
    	    					
    	    					entryRecord[0] = entry.getValue(); 
    	    				} else if(key == "text") {
    	    					
    	    					entryRecord[1] = entry.getValue();
    	    				} else if(key == "profile_image_url") {
    	
    	    					entryRecord[2] = entry.getValue();
    	    					
    	    					try {
    	    						java.net.URL imageURL = new URL(value);
    	    						img = new ImageIcon(imageURL);
    	    					} catch(MalformedURLException e) {
    	    						e.printStackTrace();
    	    					}
    	    				} else if(key == "created_at") {
    	    					entryRecord[3] = formatDate(entry.getValue());
    	    				}
    	    				
    	    			}
    	    			// Append it to the Stringbuffer
    	    			
    	    			sb.append("");
    	    			sb.append("");
    	    			sb.append("");
        			}
    			    sb.append("
    " + entryRecord[0] + "
    "+ entryRecord[1]+ " " + entryRecord[3] + "
    "); panel.setText(sb.toString()); break; } return panel;

    Tja, wordt daar maar is wijzer van 🙂

  3. Als je het verversen om de x seconden laat gebeuren, kan dit toch zonder delay? Enkel de eerste keer moet je wachten. Nadien kan dit toch in een aparte thread gebeuren en de boel renderen als het volledig geladen is.

  4. Gegoogled naar “Java Twitter Client” en kwam op deze site. Zelf ook van plan om dit als leerproces te maken.

    Iedergeval bedankt voor de tips en de schematische weergave hoe jij het gedaan hebt 😀

Leave a Reply

Your email address will not be published. Required fields are marked *