Usando Caché Objects e Java
por Equipe Linha de Código

O Caché fornece uma pacote de classes que trabalha em conjunto com as classes Java geradas pelo parser do Arquiteto de Objetos. Estas classes fornecem a infraestrutura necessária para os objetos instanciados no ambiente Java se comunicarem com os objetos armazenados no servidor Caché.

Estas classes estão empacotadas no arquivo CacheJava.jar. Este arquivo pode ser encontrado no sub-diretório /java, dentro do direrório de instalação do Caché.

Certifique-se que este arquivo está na variável de ambiente CLASSPATH antes de compilar ou executar suas aplicações.

No Unix:

CLASSPATH=/usr/local/cachesys/java/CacheJava.jar:$CLASSPATH
export CLASSPATH

No Windows:

set CLASSPATH=c:\cachesys\java\CacheJava.jar;%CLASSPATH%

Conectando ao Servidor

Para trabalhar com os objetos Caché, uma aplicação Java precisa inicialmente estabelecer uma conexão com o servidor de objetos Caché. Criamos então uma fábrica de objetos.

//java code
final String connectionStr = “cn_iptcp:127.0.0.1[1972]:USER”;
ObjectFactory factory = new ObjectFactory(connectionStr, “_SYSTEM”, “SYS”);

A fábrica de objetos aloca uma licensa do servidor Caché. Devemos sempre fechar a fábrica de objetos para liberar recursos do servidor.

//java code
factory.close();

Criando instâncias de objetos em Java

Com uma fábrica de objetos conectada ao servidor Caché, podemos criar instâncias das classes Caché. Passamos a referência da fábrica de objetos como parâmetro no construtor da classe. O construtor pode disparar uma CachéException caso algum problema seja encontrado. Por exemplo, uma ClassAccessException será disparada se tentarmos criar uma instância de uma classe que não foi definida no servidor Caché.

//java code
Book book = new Book(factory);

Criamos assim um novo objeto a partir da classe “Book”, com todos os seus atributos foram inicializados com os valores default definidos na classe. Este objeto ainda não foi armazenado no servidor Caché. Podemos constatar isso verificando o valor do Oid deste objeto.

//java code
boolean isNull = book._getOid().isNullOid();
System.out.println(isNull);

Para amarzenar este novo objeto no servidor Caché, devemos chamar o seu método _save(). Novamente, este método pode disparar uma exception caso algum problema seja encontrado. Por exemplo, uma ValidationFailedException pode ser disparada se o valor de um atributo do objeto violar alguma regra de integridade.

A cada objeto armazenado no servidor Caché é atribuido um Oid único. Por default, o Oid armazena um valor inteiro, mas podemos utilizar qualquer outra classe como identificador dos objetos. Não é aconselhavel modificar o tipo do Oid. Fica muito mais fácil deixar o Caché gerenciar o “número de série” dos objetos; e utilizar atributos com semântica como identificadores não é uma boa metodologia. Podemos ter acesso ao identificador de cada objeto através do método _getOid().

Quando a referência para um objeto não é mais necessária, chamamos o seu método _close(). Isso libera o compartilhamento do objeto no servidor Caché.

Se a conexão com o servidor Caché não for mais necessária, devemos fechar a fábrica de objetos, conforme descrito anteriormente.

Um exemplo completo:

O programa abaixo abre uma fábrica de objetos, cria uma nova instância da classe “Book” e armazena este objeto no servidor Caché. Para executar este exemplo, você precisa compilar também o código Book.java, criado pelo Caché a partir da definição da classe.

//java code
import COM.intersys.objects.*;
public class AddBook {
static final String connectionStr = "cn_iptcp:127.0.0.1[1972]:User";
public static void main(String[] args) {
//verifica parametros
if (args.length != 3) {
System.out.println("Use AddBook title author isbn");
System.exit(1);
}
ObjectFactory factory = null;
try {
//cria fábrica de objetos conectada com o servidor Caché
factory = new ObjectFactory(connectionStr, "_SYSTEM", "SYS");
//cria um novo objeto
Book book = new Book(factory);
//altera seus atributos
book.settitle(args[0]);
book.setauthor(args[1]);
book.setisbn(args[2]);
//salva o objeto no servidor Caché
book._save();
//libera compartilhamento do objeto
book._close();
}
catch (Exception ex) {
System.out.println("error:" + ex.getMessage());
ex.printStackTrace();
}
finally {
try {
//fecha fábrica de objetos
factory.close(true);
}
catch (Exception ex) {
ex.printStackTrace();
}
}
}
} //AddBook

Código fonte: AddBook.java

Note que a fábrica é fechada no bloco finally, garantido que o recurso seja sempre explicitamente liberado. O método close() recebe como parâmetro o valor booelano true, indicando que todos os objetos criados pela fábrica também devem ser fechados.

Recuperando objetos

A fábrica de objetos também é utilizada para recuperar objetos armazenados no servidor Caché. Todo objeto persistente no Caché possui métodos construtores que recebem como parâmetros uma fábrica de objetos e um identificador. Este identificador pode ser um valor inteiro, uma String ou um Oid.

Se a classe usa o identificador default oferecido pelo servidor Caché, podemos usar tanto um valor inteiro como uma String para endereçar o objeto. Se a classe usa um identificador definido pelo usuáiro, devemos criar um Oid para encapsular o identificador.

O exemplo abaixo mostra como podemos recuperar uma instância da classe “Book”, utilizando uma fábrica de objetos já conectada ao servidor Caché.

//java code
int id = 1326;
Book book = new Book(factory, id);

O construtor pode disparar uma CacheException se houver algum problema de comunicação com o servidor, ou se o a instância especificada não existir.

Um exemplo completo:

O programa abaixo abre uma fábrica de objetos e recupera uma instância da classe “Book”, previamente armazena no servidor Caché.

//java code
import COM.intersys.objects.*;
public class GetBookInfo {
static final String connectionStr = "cn_iptcp:127.0.0.1[1972]:User";
public static void main(String[] args) {
//verifica parametros
if (args.length != 1) {
System.out.println("Use GetBookInfo id");
System.exit(1);
}
ObjectFactory factory = null;
try {
//cria fábrica de objetos conectada com o servidor Caché
factory = new ObjectFactory(connectionStr, "SYSTEM", "_SYS");
//abre um objeto
Book book = new Book(factory, args[0]);
//imprime seus atributos
System.out.println(book.gettitle());
System.out.println(book.getauthor());
System.out.println(book.getisbn());
//libera compartilhamento do objeto
book._close();
}
catch (Exception ex) {
System.out.println("error:" + ex.getMessage());
ex.printStackTrace();
}
finally {
try {
//fecha fábrica de objetos
factory.close(true);
}
catch (Exception ex) {
ex.printStackTrace();
}
}
}
} //GetBookInfo

Código fonte: GetBookInfo.java

É importante notar que um objeto Java não tem acesso direto aos atributos públicos declarados em uma classe Caché. A manipulação destas variáveis é feita apenas através de métodos de acesso, no estilo getXYZ() e setXYZ().

Da mesma forma, quando chamamos um método Java, o seu código não é executado na máquina virtual Java local. O código Java é apenas uma casca que se comunica com o servidor Caché e invoca a execução de seu método espelho. O código do método é executado na runtime do servidor Caché.