[Java] Due domande completamente scorrelate

[71104]

aaaaaaaaaaaaaaaaaaaaaaaaaaaa
lora :D

1) qual è la maniera più semplice di ottenere i dati (in modo completamente raw) che un server web mi restituisce quando gli chiedo un URL? ad esempio, gli chiedo la home di Google e voglio ottenere il codice HTML. devo aprire una HttpURLConnection? che debbo farci? praticamente ho solo bisogno di una classe che da un URL mi faccia automaticamente una richiesta HTTP sintatticamente corretta e della risposta del server mi restituisca i dati togliendoci gli headers.

2) in una finestra devo disegnare un grafico; ho exteso la classe Canvas derivando una mia classe nella quale ho sovrascritto i metodi paint e update. in questo grafico devono essere disegnati vari elementi: prima uno sfondo che occupa tutta l'area, e poi sopra di esso varie altre cose. c'è modo di far si' che il tutto sia double-buffered senza che mi tenga io il mio buffer? attualmente utilizzo una BufferedImage sulla quale disegno da dentro il metodo paint, e solo dopo che ho disegnato tutto chiamo il metodo drawImage del Graphics che mi arriva come parametro di paint. c'è modo di ottenere lo stesso risultato eliminando la BufferedImage intermedia?

[andbin]

1) qual è la maniera più semplice di ottenere i dati (in modo completamente raw) che un server web mi restituisce quando gli chiedo un URL?Se parti da un URL, chiama openConnection() per avere un URLConnection. Imposta su questo eventuali property con setRequestProperty() (es. lo "User-Agent"), dopodiché con getInputStream() ottieni un InputStream. Leggi i byte .... e fai quello che vuoi. Nota che lo stream è solo dei dati veri e propri, non degli header (che puoi sempre ottenere con gli altri metodi).

Per il 2) non ti saprei dire adesso, dovrei documentarmi.

[71104]

ah, andbin... un vero toccasana per la mia pigrizia nel cercare informazioni nella documentazione Java :asd:
grazie mille intanto per la prima :)

[PGI-Bis]

Usa JPanel al posto di Canvas, scrivi il codice che disegna il grafico nel metodo paintComponent anzichè in paint e, se vuoi, invoca setDoubleBuffered(true) sul JPanel (ma i componenti Swing dovrebbero già essere DoubleBuffered).

Altrimenti con Canvas hai la possibilità di disegnare tramite il suo BufferStrategy (che ti permette di gestire il numero di buffer) ma, in questo caso, devi creare un ciclo di rendering autonomo da quello dell'EDT.

[71104]

Usa JPanel al posto di Canvas, scrivi il codice che disegna il grafico nel metodo paintComponent anzichè in paint e, se vuoi, invoca setDoubleBuffered(true) sul JPanel (ma i componenti Swing dovrebbero già essere DoubleBuffered).

Altrimenti con Canvas hai la possibilità di disegnare tramite il suo BufferStrategy (che ti permette di gestire il numero di buffer) ma, in questo caso, devi creare un ciclo di rendering autonomo da quello dell'EDT. ok; non è escluso che opterò per la soluzione del JPanel, ma mi interessa capire a fondo cosa dovrei fare nel caso del Canvas. io nella documentazione di Canvas avevo già notato la presenza di un metodo createBufferStrategy; ho provato a fare, al termine di tutta l'inizializzazione del componente, una chiamata a createBufferStrategy(2), senza però cambiare il codice di paint e update, e come risultato non cambiava nulla: flickerava come se non avessi fatto la chiamata. e invece come avrei dovuto fare di preciso?

[PGI-Bis]

Il caso d'uso tipico somiglia a questo:

while(true) {
BufferStrategy bs = canvas.getBufferStrategy();
//un kilo e due di while, vedi documentazione
Graphics2D g = (Graphics2D)bs.getDrawGraphics();
//disegni su g, come faresti nel paint
bs.show();
}

E lo mandi in esecuzione con un Thread ad hoc. Se il disegno nel canvas è interattivo devi creare un meccanismo per "comunicare" le richieste al motore di rendering. Di solito si usa una "pipeline" (che è una coda svuotabile in un colpo, per parlare come mangiamo) e il ciclo diventerebbe:

while(true) {
Collection<OperazioneDisegno> ops = drainPipe();
BufferStrategy bs = canvas.getBufferStrategy();
Graphics2D g = (Graphics2D)bs.getDrawGraphics();
//eccetera
for(OperazioneDisegno op : ops) op.draw(g);
bs.show();
}

Parallelamente definiresti un metodo che ti consenta di accodare le operazioni di disegno nella pipeline:

public void pushOp(OperazioneDisegno op) {
pipe.push(op);
}

Il metodo drainPipe sarebbe una cosa del genere:

public Collection<OperazioneDisegno> drainPipe() {
return pipe.drain();
}

Qui è "pipe" (ipotetica pipeline) a definire i punti di sincronizzazione per garantire la consistenza delle letture/scritture inter Thread.

Se il disegno complessivo è stateful (cioè una mutazione dell'immagine deve avvenire solo in conseguenza di una certa mutazione di stato) allora puoi modificare il metodo drainPipe in modo tale che esso restituisca il "drain" precedente fintantochè non sia rilevata la mutazione dello stato di interesse:


private boolean flushPipe;

public synchronized void flush() {
flushPipe = true;
}

public synchronized Collection<OperazioniDisegno> drainPipe() {
if(flushPipe) {
flushPipe = false;
currentDrain = pipe.drain();
}
return currentDrain;
}

Qui potresti delegare l'intera sincronizzazione all'oggetto che usa la pipe. Insomma, malefatte di questo genere. Paint e update diventano superflui. Si tratta ovviamente di disegno "nudo e crudo": BufferStrategy è l'animale di livello più basso nella catena alimentare Swing/AWT. Massime prestazioni, zero comodità.

[71104]

chiarissimo grazie! in effetti è decisamente meglio usare un JPanel: inutile complicarsi la vita a dover gestire un altro thread (come se già ne avessi pochi poi... ^^' ). grazie ancora.

[71104]

perfetto!! l'ho appena sistemato: refactoring facile, breve ed indolore :D
non chiedevo di meglio