Como ninguém sabe, corrigindo, alguns sabem… A programação agora passou a ser apenas um Hobby.
Não estou mais trabalhando com programação, tenho saudades do meu tempo de analista, snif snif.

Mas vamos ao assunto, afinal essa budega não foi feita para falar da minha vida pessoal e ela tão pouco interessa a você, eu sei

A tecnologia que venho apresentar e sugerir seu uso é o Objectify. Também vou deixar uma dica de um código que me facilitou bastante as coisas.

Mas para que serve? Da onde veio? Porque usar isso?

Então, vamos a mais história pessoal (hoje to me sentindo um blogueiro.. haha).
A um tempo venho projetando um sistema para uns controles pessoais, queria que fosse na web e ai surgiu um problema chato, CUSTOS R$$$ (falando nisso, já deu uma olhada nos anúncios? Grato)!
Foi querendo driblar esses CUSTOS que eu decidi utilizar o Google App Engine/J (GAE), que me disponibilizou um ambiente free.
Só que, o GAE não utiliza base de dados com a arquitetura SGBD a qual a maioria de nós estamos acostumados a trabalhar, ele utiliza uma arquitetura chamada BigTable, fazendo com que os frameworks de persistência sejam um pouco diferentes.

Ai você vai falar: Ah, mas você pode utilizar JPA com o GAE.
E eu respondo: Pelo meu uso, pelas minhas pesquisas, eu digo que o JPA no GAE é uma dor de cabeça do cão. As coisas tendem a não funcionar como o esperado.

E nessas pesquisas eu encontrei o Objectify, um framework de persistência de muito fácil instalação e bem simples de ser utilizado.

Como Instalar? Como utilizar?
Você pode encontrar todas essas informações no site oficial do projeto:
http://code.google.com/p/objectify-appengine/

E caso surgir alguma dúvida, pergunte aqui pra podermos trocar algumas experiências.

Então, quando você começar a utilizar o Objectify você vai ver que as relações entre as tabelas aqui não podem ser mapeadas assim:

 
public class Motor {
...
}
 
public class Carro {
...
private Motor motor;
...
}

Você precisa utilizar uma Key, no exemplo deveríamos utilizar Key motor.
A classe Carro agora ficaria assim:

public class Carro {
...
private Key<Motor> motor;
...
}

Com essa key você consegue recuperar a real instancia de Motor utilizando o método get(class, id).
Mas fica um tanto chato ter que fazer isso a toda hora. Então eu pensei e comecei a fazer isso nas minhas classes:

public class Carro {
...
private Key<Motor> motorId;
@Transiant private Motor motor;
 
public Motor getMotor() {
	if (this.motor == null && motorId != null) {
		Motor motor = new Motor();
		motor.setId(motorId.getId());
		this.motor = MotorDAO.get(motor.getClass(), motor.getId());
	}
	return this.motor;
}
 
public void setMotor(Motor motor) {
	this.motor = motor;
	if (motor != null && motor.getId() != null) {
		this.motorId = new Key<Motor>(Motor.class,
				motor.getId());
	}
}
...
}

E até agora tudo ta funcionando belezinha! Posso fazer referencia diretamente nas EL do JSF e zaz.

Então essa seria minha dica de hoje.

PS: Como minha aplicação ainda não esta em produção, tão pouco ta fazendo coisas complexas, pode ser que esse código passe a não funcionar, mas nada que um jeitinho brasileiro não resolva

É isso pessoal, espero que seja útil a você.
Abraço,
Vanio Meurer (vaninhO).

Para tal utilizaremos as classes URL e HTTPUrlConnection do pacote java.net.

Começamos criando uma instancia de URL, passando ao seu construtor uma String. Como visto no exemplo abaixo essa String é a própria URL que desejamos acessar.

java.net.URL url = new java.net.URL("http://www.vaniomeurer.com.br");

Detalhe que esse construtor pode lançar uma exception chamada MalformedURLException e essa mesma é uma exception verificada, então precisamos tratá-la no código, ficando assim nosso código:

try {
   java.net.URL url = new java.net.URL("http://www.vaniomeurer.com.br");
}catch (java.net.MalformedURLException e){
   System.out.println("Erro ao criar URL. Formato inválido.");
}

Existem alguns outros construtores para a classe java.net.URL, porem esse é o mais comum.

Depois que já temos a nossa URL, precisamos acessá-la. O Java já traz uma classe que nos abstrai muitos detalhes de baixo nível do protocolo HTTP. A classe é a java.net.HTTPURLConnection e usamos como a seguir:

java.net.HTTPURLConnection urlConnection = (java.net.HTTPURLConnection) url.openConnection();

Como o método retorna uma URLConnection abstrata, precisamos fazer o cast para nossa HTTPURLConnection, pois estamos tratando de uma transação HTTP.

Novamente precisamos tratar uma exception, nesse caso o método openConnection da URL pode retornar uma IOException, então modificando e juntando os códigos temos:

try {
   java.net.URL url = new java.net.URL("http://www.vaniomeurer.com.br");
   java.net.HTTPURLConnection urlConnection = (java.net.HTTPURLConnection) url.openConnection();
} catch (java.net.MalformedURLException e){
   System.out.println("Erro ao criar URL. Formato inválido.");
} catch (java.io.IOExcetpion e2) {
   System.out.println("Erro ao acessar URL.");
}

Sabendo que a classe MalformedURLException herda IOException poderíamos ter tratado somente a exception IOExceptin, mas deixei assim para que o erro fique mais especifico.

Tendo aberta a conexão precisamos pegar as informações, para isso abrimos a stream de input assim:

java.io.BufferedReader in = new java.io.BufferedReader(new java.ioInputStream(urlConnection.getInputStream()));

Também temos disponível o stream de Output, que pode ser conseguido através do método getOutputStream.
Com o stream de entrada (input), basta percorrermos o stream para mostrarmos a página HTML.

String line = null;
 
while( (line = in.readLine()) != null ){
   System.out.println(line);
}

Conforme fizemos, vamos ler linha por linha a página HTML e exibir na tela. Poderíamos ter usado qualquer outro leitor de streams.
Pronto, lemos uma página HTML utilizando Java.
Precisamos agora fechar a conexão e os streams abertos.

in.close();
urlConnection.disconnect();

IMPORTANTE: precisamos sempre fechar os streams antes da conexão, caso contrario lançaríamos uma exception!

O código completo ficaria assim:

package br.com.vaniomeurer.exemplos
 
import java.net.URL;
import java.net.HTTPURLConnection;
import java.net.MalformedURLException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
 
public class AcessarURL {
 
   public static void main(String args[]) {
 
      if (args.length == 0) {
         System.out.println("Não foi especificado nenhuma URL.");
         // Fechando aplicação.
         System.exit(1);
      }
 
      // Pegando a url passada como parametro.
      String urlName = args[0];
 
      try {
 
         URL url = new URL(urlName);
         HTTPURLConnection urlConnection = (HTTPURLConnection) url.openConnection();
         BufferedReader in = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));
 
         String line = null;
 
         while( (line = in.readLine()) != null ){
            System.out.println(line);
         }
 
         in.close();
         urlConnection.disconnect();
 
      } catch (MalformedURLException e){
         System.out.println("Erro ao criar URL. Formato inválido.");
         System.exit(1);
      } catch (IOException e2) {
         System.out.println("Erro ao acessar URL.");
         System.exit(1);
      }
 
   }
 
}

Compilando e executando o comando “java br.com.vaniomeurer.exemplos.AcessarURL http://www.vaniomeurer.com.br” teríamos impresso o código HTML desse site.

Espero que esse mini tutorial seja útil a alguém, como estou em uma máquina que não tem o JDK não pude compilar para testar, mas logo o faço e edito caso algo esteja errado.

Até, Vânio Meurer (vaninhO)

a apresentação do projeto EasyFaces como escrevi no post anterior ocorreu no dia 23/11.
A mesma foi realizada para a defesa do nosso grau de Bacharel em Sistemas de Informação pela Universidade do Sul de Santa Catarina (UNISUL).
Fomos orientados pelo professor Edjandir Correa Costa (MSc.), nossa banca foi composta pelos Srs. Max Roberto Pereira (Dr.), Luiz Alfredo Soares Garcindo (Dr.) e Cássio Nandi Citadim.

Acho que a apresentação ficou bem legal, você pode conferir no video abaixo:

EasyFaces – Pacote de Componentes JSF from EasyFaces on Vimeo.

Os slides tambem estão dispostos a seguir:

Já recebemos alguns contatos pelo site, alguns parabenizando e outros reportando algum tipo de comportamento inesperado. Todos serão considerados e quando necessário corrigidos nas versões posteriores.

Vale ressaltar que é de suma importância que você de seu feedback sobre o projeto, para sabermos por onde seguir e facilitarmos a vida de mais alguns desenvolvedores (como nós)

Não esquecendo também que a idéia é liberar o código fonte do projeto para que mais pessoas também possam ajudar no desenvolvimento e amadurecimento do projeto.

Acho que seria isso, agradeço pelas mensagens de apoio e com o decorrer do projeto venho postar as novidades por aqui.

Vânio Meurer (vaninh0)

Você pode conferir todo o conteúdo do EasyFaces no site www.easyfaces.com.br, lá você vai encontrar desde o download a demonstração “instantânea” de cada componente.

Visite e confira!

Ah… quase ia esquecendo, dia 23/11 estaremos apresentando nosso TCC, torçam por nós.

Vânio Meurer (vaninhO)

estava lendo o novo portal desenvolvimento de jogos, o Ponto V, que os colegas Vinicius Godoy Mendonça e Bruno Crivelari Sanches estão escrevendo e no post Pintando no Java 2D surgiu um desafio de desenhar o fantasminha do PacMan com Java2D.

Abaixo minha solução do desafio, não fico muito bonitinho, mas ta ai o código fonte que criei.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.QuadCurve2D;
import java.awt.geom.Rectangle2D;
 
import javax.swing.JFrame;
 
/**
 * Pintando fantasminha do PacMan com Java 2D.
 * @author Vânio Meurer
 * @since 10/11/2009 11:38:12
 */
public class FantasmaPacMan extends JFrame {
 
	private static final long serialVersionUID = 8366583475473482894L;
 
	private final static int TAMANHO_X = 100;
	private final static int TAMANHO_Y = 50;
	private final static int TAMANHO_X_PATA = 20;
	private final static int TAMANHO_Y_PATA = 50;
	private final static int DISTANCIA_X_PATA = 6;
	private final static int RAIO_OLHO = 13;
	private final static int RAIO_OLHO_CRISTALINO = 5;
	private final static int DISTANCIA_X_OLHOS = (RAIO_OLHO<<1)+10;
 
	public FantasmaPacMan() {
 
		super("Fantasminha Pac Man");
		this.setSize(300, 300);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setLocationRelativeTo(null);
 
	}
 
	public static void main(String[] args) {
 
		final FantasmaPacMan fpm = new FantasmaPacMan();
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				fpm.setVisible(true);
			}
		});
 
	}
 
	@Override
	public void paint(Graphics g) {
		super.paint(g);
 
		Graphics2D g2d = (Graphics2D) g.create();
 
		g2d.setPaint(Color.BLACK);
		g2d.fillRect(0, 0,this.getSize().width, this.getSize().height);
 
		pintarFantasma(g2d, Color.RED, 50, 50);
 
		pintarFantasma(g2d, Color.MAGENTA, 85, 150);
 
 
	}
 
	public void pintarFantasma(Graphics2D g2d, Color color, int x, int y) {
		g2d.setPaint(color);
		g2d.fill(new Ellipse2D.Float(x, y, TAMANHO_X, TAMANHO_Y));
		g2d.fill(new Rectangle2D.Float(x,y+(TAMANHO_Y>>1),TAMANHO_X, TAMANHO_Y>>1));
 
		int xBkp = x;
 
		g2d.fill(new QuadCurve2D.Float(x, y+TAMANHO_Y, x+(TAMANHO_X_PATA>>1), y+TAMANHO_Y+TAMANHO_Y_PATA, x+TAMANHO_X_PATA, y+TAMANHO_Y));
		x = x+TAMANHO_X_PATA+DISTANCIA_X_PATA;
		g2d.fill(new QuadCurve2D.Float(x, y+TAMANHO_Y, x+(TAMANHO_X_PATA>>1), y+TAMANHO_Y+TAMANHO_Y_PATA, x+TAMANHO_X_PATA, y+TAMANHO_Y));
		x = x+TAMANHO_X_PATA+DISTANCIA_X_PATA;
		g2d.fill(new QuadCurve2D.Float(x, y+TAMANHO_Y, x+(TAMANHO_X_PATA>>1), y+TAMANHO_Y+TAMANHO_Y_PATA, x+TAMANHO_X_PATA, y+TAMANHO_Y));
		x = x+TAMANHO_X_PATA+DISTANCIA_X_PATA+1;
		g2d.fill(new QuadCurve2D.Float(x, y+TAMANHO_Y, x+(TAMANHO_X_PATA>>1), y+TAMANHO_Y+TAMANHO_Y_PATA, x+TAMANHO_X_PATA, y+TAMANHO_Y));
 
		x = xBkp;
 
		g2d.setPaint(Color.WHITE);
		g2d.fill(new Ellipse2D.Float((x+(TAMANHO_X/3))-RAIO_OLHO,y+(TAMANHO_Y>>1)-RAIO_OLHO,RAIO_OLHO<<1,RAIO_OLHO<<1));
		g2d.setPaint(Color.BLUE);
		g2d.fill(new Ellipse2D.Float((x+(TAMANHO_X/3))-RAIO_OLHO_CRISTALINO,y+(TAMANHO_Y>>1)-RAIO_OLHO_CRISTALINO,RAIO_OLHO_CRISTALINO<<1,RAIO_OLHO_CRISTALINO<<1));
		g2d.setPaint(Color.WHITE);
		g2d.fill(new Ellipse2D.Float((x+(TAMANHO_X/3))-RAIO_OLHO + DISTANCIA_X_OLHOS,y+(TAMANHO_Y>>1)-RAIO_OLHO,RAIO_OLHO<<1,RAIO_OLHO<<1));
		g2d.setPaint(Color.BLUE);
		g2d.fill(new Ellipse2D.Float((x+(TAMANHO_X/3))-RAIO_OLHO_CRISTALINO + DISTANCIA_X_OLHOS,y+(TAMANHO_Y>>1)-RAIO_OLHO_CRISTALINO,RAIO_OLHO_CRISTALINO<<1,RAIO_OLHO_CRISTALINO<<1));
 
	}
 
}

Ao executar a classe temos:

Visite o site deles e tente resolver você também.

Até, Vânio Meurer (vaninhO)

Buenas caros leitores, como estão? Espero que bem.

Hoje vim postar uma classe que fiz e ficou maneira, pelo menos eu achei.

Estava estudando a classe java.io.RandomAccessFile, onde nela é possível ler e escrever em arquivos sem ter de utilizar um BufferedReader e um BufferedWriter (ou quaisquer outras duas classes para leitura e escrita), e me deparei com um “problema”, na verdade não é um problema, mas não gostei do que acontecia.

Quando eu estava lendo o arquivo, no meio dele eu queria escrever algum texto, usei todos os métodos e todos sobrescreviam o texto seguinte (o mesmo efeito do botão insert).
Exemplo do que acontecia:

“Esse é um texto exemplo que estou utilizando,
maneiro”

Tentei escrever “não é” antes da palavra “Maneiro” e o que aconteceu?
O texto ficou assim:

“Esse é um texto exemplo que estou utilizando,
não éro”

Só que eu queria que ficasse assim:

“Esse é um texto exemplo que estou utilizando,
não é maneiro”

Então fui pesquisar como fazer e para minha surpresa a classe RandomAccessFile não “estica” o arquivo para inserir algo, você precisa fazer isso manualmente.

Como fazer?

Precisamos aumentar o tamanho do arquivo, mover o texto a partir de onde queremos escrever até o fim do arquivo e escrever o que desejamos no ponto onde movemos.

Fácil não? Até é, mas é meio chato.

E é por isso que estou aqui distribuindo a classe utilitária que criei para essa função, prazer RandomAccessFilePlus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249

package br.com.vaniomeurer.io;
 
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.io.RandomAccessFile;
 
/**
 * Classe que lê e escreve em um arquivo. Utiliza a java.io.RandomAccessFile
 * porem com essa classe os caracteres escritos não sobrescrevem os caracteres
 * posteriores (efeito insert).
 * 
 * 
 * @author Vânio Meurer
 * @since 09/11/2009 16:01:13
 * @version 1.0.0
 */
public class RandomAccessFilePlus implements DataOutput, DataInput {
 
	private RandomAccessFile raf;
	private String lineSeparator;
 
	/**
	 * Construtor padrão.
	 * 
	 * @param raf
	 *            Utilize uma RandomAccessFile com acesso a escrita ("rw") caso
	 *            desejar escrever.
	 */
	public RandomAccessFilePlus(RandomAccessFile raf) {
		this.raf = raf;
		lineSeparator = (String) java.security.AccessController
				.doPrivileged(new sun.security.action.GetPropertyAction(
						"line.separator"));
	}
 
	/**
	 * Quebra de linha no arquivo.
	 * 
	 * @throws IOException
	 */
	public void newLine() throws IOException {
		writeBytes(lineSeparator);
	}
 
	public void write(int arg0) throws IOException {
		int length = String.valueOf(arg0).length();
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(length, filePointer);
		raf.write(arg0);
		backToPosition(filePointer + length, b);
	}
 
	public void write(byte[] arg0) throws IOException {
		int length = arg0.length;
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(length, filePointer);
		raf.write(arg0);
		backToPosition(filePointer + length, b);
	}
 
	public void write(byte[] arg0, int arg1, int arg2) throws IOException {
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(arg2, filePointer);
		raf.write(arg0, arg1, arg2);
		backToPosition(filePointer + arg2, b);
	}
 
	public void writeBoolean(boolean arg0) throws IOException {
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(1, filePointer);
		raf.writeBoolean(arg0);
		backToPosition(filePointer + 1, b);
	}
 
	public void writeByte(int arg0) throws IOException {
		int length = String.valueOf(arg0).length();
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(length, filePointer);
		raf.writeByte(arg0);
		backToPosition(filePointer + length, b);
	}
 
	public void writeBytes(String arg0) throws IOException {
		int length = arg0.length();
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(length, filePointer);
		raf.writeBytes(arg0);
		backToPosition(filePointer + length, b);
	}
 
	public void writeChar(int arg0) throws IOException {
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(2, filePointer);
		raf.writeChar(arg0);
		backToPosition(filePointer + 2, b);
	}
 
	public void writeChars(String arg0) throws IOException {
		int length = arg0.length() << 1;
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(length, filePointer);
		raf.writeChars(arg0);
		backToPosition(filePointer + length, b);
	}
 
	public void writeDouble(double arg0) throws IOException {
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(8, filePointer);
		raf.writeDouble(arg0);
		backToPosition(filePointer + 8, b);
	}
 
	public void writeFloat(float arg0) throws IOException {
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(4, filePointer);
		raf.writeFloat(arg0);
		backToPosition(filePointer + 4, b);
	}
 
	public void writeInt(int arg0) throws IOException {
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(4, filePointer);
		raf.writeInt(arg0);
		backToPosition(filePointer + 4, b);
	}
 
	public void writeLong(long arg0) throws IOException {
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(8, filePointer);
		raf.writeLong(arg0);
		backToPosition(filePointer + 8, b);
	}
 
	public void writeShort(int arg0) throws IOException {
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(2, filePointer);
		raf.writeShort(arg0);
		backToPosition(filePointer + 2, b);
	}
 
	public void writeUTF(String arg0) throws IOException {
		int length = arg0.length();
		long filePointer = raf.getFilePointer();
		byte[] b = increaseFile(length, filePointer);
		raf.writeUTF(arg0);
		raf.write(b);
	}
 
	private byte[] increaseFile(int length, long filePointer)
			throws IOException {
		byte[] b = new byte[(int) (raf.length() - filePointer)];
		raf.readFully(b);
		raf.setLength(raf.length() + length);
		raf.seek(filePointer);
		return b;
	}
 
	private void backToPosition(long position, byte[] b) throws IOException {
		raf.write(b);
		raf.seek(position);
	}
 
	public boolean readBoolean() throws IOException {
		return raf.readBoolean();
	}
 
	public byte readByte() throws IOException {
		return raf.readByte();
	}
 
	public char readChar() throws IOException {
		return raf.readChar();
	}
 
	public double readDouble() throws IOException {
		return raf.readDouble();
	}
 
	public float readFloat() throws IOException {
		return raf.readFloat();
	}
 
	public void readFully(byte[] arg0) throws IOException {
		raf.readFully(arg0);
	}
 
	public void readFully(byte[] arg0, int arg1, int arg2) throws IOException {
		raf.readFully(arg0, arg1, arg2);
	}
 
	public int readInt() throws IOException {
		return raf.readInt();
	}
 
	public String readLine() throws IOException {
		return raf.readLine();
	}
 
	public long readLong() throws IOException {
		return raf.readLong();
	}
 
	public short readShort() throws IOException {
		return raf.readShort();
	}
 
	public String readUTF() throws IOException {
		return raf.readUTF();
	}
 
	public int readUnsignedByte() throws IOException {
		return raf.readUnsignedByte();
	}
 
	public int readUnsignedShort() throws IOException {
		return raf.readUnsignedShort();
	}
 
	public int skipBytes(int arg0) throws IOException {
		return raf.skipBytes(arg0);
	}
 
	public void close() throws IOException {
		raf.close();
	}
 
	public void seek(long pos) throws IOException {
		raf.seek(pos);
	}
 
	/**
	 * Getter RandomAccessFile
	 * 
	 * @return
	 */
	public RandomAccessFile getRAF() {
		return raf;
	}
 
	/**
	 * Setter RandomAccessFile
	 * 
	 * @param raf
	 */
	public void setRAF(RandomAccessFile raf) {
		this.raf = raf;
	}
}

Aqui uma classe que faz o teste que comentei acima:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package br.com.vaniomeurer.io;
 
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
 
/**
 * Classe que faz um teste simples na classe RandomAccessFilePlus.
 * 
 * @author Vânio Meurer
 * @since 09/11/2009 16:49:08
 */
public class RandomAccessFilePlusTest {
 
	public static void main(String[] args) throws IOException {
 
		File file = new File("D:/texto.txt");
		RandomAccessFilePlus rafp = new RandomAccessFilePlus(
				new RandomAccessFile(file, "rw"));
		// Leu a primeira linha
		System.out.println(rafp.readLine());
		// Escreveu 'não é'
		rafp.writeBytes("não é ");
		// Movendo o ponteiro ao inicio
		rafp.seek(0);
 
		// Lendo o arquivo completo
		String linha = null;
		while ((linha = rafp.readLine()) != null) {
			System.out.println(linha);
		}
 
		// Fechando arquivo
		rafp.close();
 
	}
 
}

O arquivo texto.txt originalmente continha o texto:

“Esse é um texto exemplo que estou utilizando,
maneiro”

Depois de executado a classe de teste ficou assim:

“Esse é um texto exemplo que estou utilizando,
não é maneiro”

Porque eu não herdei a classe RandomAccessFile? Porque a classe RandomAccessFile possui métodos finais e eu não poderia sobrescreve-los.

Por hoje seria isso mesmo, no futuro pretendo lançar algum jarzinho com algumas classes utilitarias que crio de vez em quando, porem acabo excluindo-as.

Até, Vânio Meurer (vaninhO)

Vocês já ouviram falar de “Easter Egg’s” (Ovos de Páscoa)? (wiki)

Eles são bem comuns em jogos, porem agora começaram a surgir em páginas da web.
Como assim? Easter Eggs em páginas? Exatamente.
Segue abaixo alguns exemplos e como visualizar os easter eggs:

A “senha” padrão para todos os sites é pressionar as teclas direcionais na seguinte seqüência:
cima, cima, baixo, baixo, esquerda, direita, esquerda, direita
e em seguida pressionar as teclas:
b, a

Alguns sites que você pode fazer:

http://www.jquery.com
http://www.google.com.br/reader/
http://www.vaniomeurer.com.br (sim, também coloquei um easter egg aqui!)
http://www.theglobeandmail.com

Nesse último você precisa fazer algumas coisinhas a mais, são elas:
Assim que completar a “senha”, vai abrir um alert de javascript, você pressiona o botão OK e em seguida pressiona as teclas SHIFT + SPACE simultaneamente, vai surgir uma espécie de console, digite “contra” (sem aspas) e veja o resultado.

Caso você digite a “senha” e nada acontecer, tente dar reload na página e antes de fazer qualquer coisa, digite a “senha”.

Aqui nessa página certifique-se que o foco não está no applet do post Projeto Inicial de Jogo em Java, caso estiver, clique na página (fora do applet) para que você possa digitar a “senha”.

OBS: aparentemente os easter eggs não estão funcionando no Internet Explorer versão 6.

Hoje o post foi bem incomum, mas é divertidinho
Vânio Meurer (vaninh0)

O jogo ainda não está finalizado, mas decidi postar o código mesmo que incompleto para os leitores que tiverem a vontade de desenvolver um game possam ter algo de onde começar.

Antes de postar o source, teste o jogo logo a baixo, fiz uma versão em JApplet para demonstrar o jogo em funcionamento.

O Jogo

O seu navegador não suporta Java Applets.

Você pode mover um personagem com as direcionais do teclado e o outro com os botões A, S, D e W. Caso não consiga mover o personagem de um refresh na página.

Nota-se que o jogo é bem simples, mas já é um começo. (temos tratamento de colisão, descrecimo de life, mapa e etc.)

Source Code

Para baixar o source code do projeto clique aqui.

Basta importar no eclipse para visualizar.

Por hoje seria isso, caso você tiver alguma dúvida sobre o código, deixe um comentário que eu terei prazer em ajudar.

Vânio Meurer (vaninhO)

Caso você queira estudar também, segue o link do tutorial da Sun sobre Bitwise e Shift (http://java.sun.com/docs/books/tutorial/java/nutsandbolts/op3.html).

O que fiz foi um empacotador de duas variáveis ints para uma variável short. Essas classes seriam úteis por exemplo num jogo 2D online onde as coordenadas x e y são empacotadas para mais rápido trafegar na internet.

O empacotador:

package br.com.vaniomeurer.blog.tuning;
 
/**
 *
 * <strong>Copyright © 2009 Vânio Meurer.</strong>
 
 *
 * EmpacotadorCoordenadas
 Classe que empacota dois ints de valor no máximo
 * 127 em um short. Bom tuning para transferência de dados pela internet por
 * exemplo.
 *
 * @author <a href="http://www.vaniomeurer.com.br">Vanio Meurer</a>
 * @since 21/09/2009
 */
public class EmpacotadorCoordenadas {
 
	/**
	 * Método que empacota os dois ints em um short.
	 *
	 * @param x
	 *            Parâmetro do eixo X com o valor máximo de 127.
	 * @param y
	 *            Parâmetro do eixo Y com o valor máximo de 127.
	 * @return um short com os dois int's empacotados.
	 */
	public static short empacotar(int x, int y) {
 
		System.out.println("Empacotando coordenadas...");
 
		// Verificando tamanho máximo das coordenadas
		if (x > 127 || y > 127) {
			throw new IllegalArgumentException(
					"Valor(es) maior(es) que o permitido. (127)");
		}
 
		short pacote = 0;
		// Setando X
		pacote = (short) ((x << 7) | pacote);
		// Setando Y
		pacote = (short) (y | pacote);
 
		return pacote;
	}
 
	/**
	 * Método que desempacota um short e retorna um array de ints.
	 *
	 * @param pacote
	 *            o short que esta empacotando os dois ints.
	 * @return Um array das posições desempacotadas. A posição 1 corresponde ao
	 *         eixo X e a 2 ao eixo Y.
	 */
	public static int[] desempacotar(short pacote) {
 
		System.out.println("Desempacotando coordenadas...");
 
		int coordenadas[] = new int[2];
		// Pegando Y (0x7F == 127)
		coordenadas[1] = pacote & 0x7F;
		// Pegando X
		coordenadas[0] = (pacote >> 7);
 
		return coordenadas;
	}
 
}

Testando o empacotador:

package br.com.vaniomeurer.blog.tuning;
 
/**
 *
 * <strong>Copyright © 2009 Vânio Stang Meurer.</strong>
 
 *
 * TestEmpacotadorCoordenadas
 Teste simples da classe
 * EmpacotadorCoordenadas.
 *
 * @author <a href="http://www.vaniomeurer.com.br">Vanio Meurer</a>
 * @since 21/09/2009
 */
public class TestEmpacotadorCoordenadas {
 
	public static void main(String[] args) {
 
		// Criando duas coordenadas quaisquer.
		int x = 5, y = 10;
 
		// Empacotando coordenadas.
		short pacote = EmpacotadorCoordenadas.empacotar(x, y);
		System.out.println("Valor do pacote: " + pacote);
 
		// Limpando as coordenadas.
		x = 0;
		y = 0;
		// Desempacotando coordenadas.
		int[] coordenadas = EmpacotadorCoordenadas.desempacotar(pacote);
		x = coordenadas[0];
		y = coordenadas[1];
 
		System.out.println("Valor de X: " + x + "\nValor de Y: " + y);
 
	}
 
}

Saída:

Empacotando coordenadas…
Valor do pacote: 650
Desempacotando coordenadas…
Valor de X: 5
Valor de Y: 10

No futuro caso haja interesse posso fazer um post tutorial de shift e manipulação de bits.
Até,
Vânio Meurer (vaninho)

Eu sempre tive interesse em desenvolver algum tipo de jogo, mas nunca tive tempo. Há algum tempo atrás sobrou um tempinho entre o projeto de TCC, trabalho e alguns FreeLancer e comecei a desenvolver um pequeno jogo em 2D. Foi realmente muito produtivo, consegui montar o mapa, fazer o boneco mover com animação, um life que decrementava quando o personagem andava em espinhos e etc.

Como o que eu mais gosto em jogos é o desafio, o multiplayer, a disputa entre duas pessoas, decidi criar um servidor para meu jogo e torna-lo multiplayer. Ai resolvi pesquisar mais sobre o desenvolvimento de games e tudo mais e encontrei esse site que venho divulgar agora.

Killer Game Programming in Java
Esse site na verdade é um livro que foi publicado na web. É muito interessante pois tem atualizações muito recentes, outra coisa que notei foi o código, que na minha opinião ficou muito bem escrito.

Bom… por hoje é somente esse excelente material que queria divulgar, aproveitem.
Vânio Meurer (vaninhO)