Neste post, veremos como utilizar o LIMIT e o OFFSET para paginar resultados de uma SQL.

A cláusula LIMIT é utilizada para limitar o número de resultados de uma SQL. Então, se sua SQL retornar 1000 linhas, mas você quer apenas as 10 primeiras, você deve executar uma instrução mais ou menos assim:

SELECT coluna FROM tabela LIMIT 10;

Agora, vamos supor que você quer somente os resultados de 11 a 20. Com a instrução OFFSET fica fácil, basta proceder da seguinte forma:

SELECT coluna FROM tabela LIMIT 10 OFFSET 10;

O comando OFFSET indica o início da leitura, e o LIMIT o máximo de registros a serem lidos. Para os registros de 60 a 75, por exemplo:

SELECT coluna FROM tabela LIMIT 15 OFFSET 60;

Com este recurso, fica fácil paginar os resultados de uma SQL e mostrar ao usuário apenas a página, ao invés de retornar todos os registros da tabela. Uma tabela com 2000 registros, por exemplo, fica muito melhor mostrar ao usuário de 10 em 10, por exemplo, e diminui a carga no banco de dados, melhorando a sua performance.

Referência:

http://www.petefreitag.com/item/451.cfm

Espero ter ajudado.

Abraço!

Este post tem como objetivo apresentar a API de criptografia já presente na liguagem java, mais precisamente no pacote java.security.

Existem basicamente dois tipos de algoritmos de criptografia:

• Os de duas vias (aquele em que é possível descriptografar)
• Os de uma via (os que não há como descriptografar, pois o o cálculo matemático efetuado não permite, a partir do valor fim, retornar ao valor inicial).

Os algoritmos de uma via podem ser chamados de Message Digests, e são extremamente eficientes para armazenamento de senhas – e são estas funções que veremos neste post.

Message Digest

A API do Java implementa dois algoritmos de Message Digest:

• MD5 (Message-Digest algorithm 5)
• SHA (Secure Hash Algorithm)

Em java, temos uma classe MessageDigest que implementa estes algoritmos. Para termos uma instância desta classe, devemos proceder da seguinte forma:

//message digest para MD5
MessageDigest md = MessageDigest.getInstance("MD5");

//message digest para SHA
MessageDigest md = MessageDigest.getInstance("SHA-1");

Após selecionar o algoritmo desejado (passando através do método getInstance), podemos proceder da seguinte forma para criptografar uma String:

String s = "senha aqui";
MessageDigest md = MessageDigest.getInstance("SHA-1");
md.update( s.getBytes() );
byte[] hash = md.digest();
StringBuffer hexString = new StringBuffer();
for (int i = 0; i < hash.length; i++) {
     if ((0xff & hash[i]) < 0x10)
          hexString.append( "0" + Integer.toHexString((0xFF & hash[i])));
     else
	  hexString.append(Integer.toHexString(0xFF & hash[i]));
}
String criptografado = hexString.toString();

Claro que devemos tratar devidamente as exceções (como por exemplo NoSuchAlgorithmException), mas no grosso é o código acima mesmo:

O método update() recebe o que deve ser critografado (em array de bytes) e o método digest() efetua a criptografia, retornando um array de bytes.

O for percorre os bytes e vai pegando os seus valores e convertendo para String – concatenando os valores com a classe StringBuilder.

Bom, finalizo aqui um exemplo básico de criptografia com MessageDigest.

Quanto a criptografia de duas vias, tem um ótimo post no Blog do Ricardo Giaviti. Segue abaixo o link:

http://www.ricardogiaviti.com.br/2010/07/usando-criptografia-em-java/

Espero ter ajudado!

Abraço

Quando temos um sistema que trabalha com imagens, documentos ou algum tipo de arquivo, temos várias formas de tratar este tipo de funcionalidade. As duas formas mais comuns são:

- Salvar o arquivo em disco (file system) e sua localização no banco de dados (como varchar);

- Salvar o arquivo inteiro dentro do banco de dados.

Existem muita discussão em cima destas duas soluções, então, vou postar aqui os prós e os contras de cada uma delas:
File System – Vantagens

• Talvez uma das vantagens seja a facilidade de salvar em disco. Basta mandar escrever em um diretório em específico e pronto.

• Outra vantagem seria a facilidade de acesso aos arquivos para backup: basta ir no diretório onde eles estão e mandar compactar tudo .

File System – Desvantagens

• Uma das desvantagens é o desacoplamento do banco de dados com o arquivo em si. Se você excluir a entidade referente ao arquivo, por exemplo, terá de ir no diertório para excluir o arquivo manualmente. Da mesma forma que a leitura do arquivo não pode ser feita apenas utilizando um JOIN na tabela de arquivos: será necessário, além do SELECT no banco, acessar o arquivo em disco.

• Segurança: o arquivo pode ser facilmente encontrado (ou até mesmo excluído) no disco. Além disso, a aplicação terá de ter permissão de leitura/escrita no diretório em questão – o que pode ser um problema se tratando de aplicações web.

Banco de Dados – Vantagens

• O que é desvantagem em File System se torna vantagem em se tratando de banco de dados. O arquivo pode ser facilmente relacionado a outros registros de outras tabelas. Podem ser recuperados através de JOIN e excluídos com relacionamentos do tipo CASCADE.

• Outra vantagem é que todos os dados estão armazenado em um único local. O backup do banco de dados já contém os arquivos, e a migração do banco de dados para outro local é mais fácil, pois não implica em diretórios e permissões.

Banco de Dados – Desvantagens

• Uma das desvantagens seria a performance do banco de dados. Na verdade esta é uma desvantagem “questionável”, pois depende muito do hardware, SGBD e carga de usuários. Grandes aplicações (picasaweb, flickr, youtube) utilizam banco de dados para armazenar arquivos – o que torna esta desvantagem passível de questionamento.

• O backup da base de dados pode ser muito grande (se tiver 1gb de imagens, o backup do banco irá ficar com toda esta carga). Normalmente backups de bancos de dados são armazenados em uma máquina diferente da que etá rodando o SGBD, o que pode ser problemático para arquivos muito grandes.

A estratégia depende muito do problema em questão. De qualquer forma, irei explicar aqui como utilizar a estratégia de salvar arquivos diretamente no banco de dados.

Preparando o Banco de Dados

No banco de dados Posrgres, temos a seguinte tabela (e sequência):

CREATE TABLE arquivo (
    id integer NOT NULL,
    nome character varying,
    arquivo bytea,
    CONSTRAINT pk_arquivo PRIMARY KEY (id)
);
CREATE SEQUENCE seq_arquivo INCREMENT 1 START 1;

O campo do tipo BYTEA representa um array de bytes, e nesta coluna iremos armazenar os nossos arquivos.

Enviando o arquivo para o banco de dados

Para armazenar um arquivo (File) em java, podemos fazer da seguinte forma:

public boolean insertFile( File f ){
    Connection c = this.getConnection();//busca uma conexao com o banco
    try {
        PreparedStatement ps = c.prepareStatement("INSERT INTO arquivo( id, nome, arquivo ) VALUES ( nextval('seq_arquivo'), ?, ? )");

        //converte o objeto file em array de bytes
        InputStream is = new FileInputStream( f );
        byte[] bytes = new byte[(int)f.length() ];
        int offset = 0;
        int numRead = 0;
        while (offset < bytes.length
               && (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0) {
            offset += numRead;
        }

        ps.setString( 1, f.getName() );
        ps.setBytes( 2, bytes );
        ps.execute();
        ps.close();
        c.close();
        return true;

    } catch (SQLException ex) {
        ex.printStackTrace();
    } catch (IOException ex) {
        ex.printStackTrace();
    }
    return false;
}

Entendendo o método: primeiro, convertemos o arquivo para um array de bytes (byte []). Depois, utilizamos o setBytes do PreparedStatement para armazenar o arquivo na coluna especificada.

E pronto: ao utilizar este método, guardamos o nome e o arquivo em si em uma tabela no banco de dados.

Recuperando o arquivo do banco de dados

Para recuperar o arquivo do banco de dados e salvar ele em disco (File) em java, podemos fazer da seguinte forma:

public File getFile( int id ){
    Connection c = this.getConnection();//busca uma conexao com o banco
    File f = null;
    try {
        PreparedStatement ps = c.prepareStatement("SELECT id, nome, arquivo FROM arquivo WHERE id = ?");
        ps.setInt(1, id);
        ResultSet rs = ps.executeQuery();
        if ( rs.next() ){
            byte [] bytes = rs.getBytes("arquivo");
            String nome = rs.getString("nome");

            //converte o array de bytes em file
            f = new File( "/local_a_ser_salvo/" + nome );
            FileOutputStream fos = new FileOutputStream( f);
            fos.write( bytes );
            fos.close();
        }
        rs.close();
        ps.close();
        c.close();
        return f;
} catch (SQLException ex) {
ex.printStackTrace();
}
catch (IOException ex) {
ex.printStackTrace();
}
return null;
}

O procedimento é o inverso: retorna o valor da coluna em array de bytes e cria um arquivo em disco a partir destes bytes.

Claro que este é um exemplo simples: em cenários mais “profissionais”, o arquivo recuperado nem precisa ser salvo em disco: pode ser mantido em memória (byte array) e enviado para a tela “renderizar” o arquivo.

Abraço!

Referência: http://imar.spaanjaars.com/414/storing-uploaded-files-in-a-database-or-in-the-file-system-with-aspnet-20

Praticamente todos que trabalham com desenvolvimento, de uma forma ou de outra, acabam tendo que manipular arquivos, sejam eles de texto, planilhas ou gerar relatórios.
Neste post explicarei como manipular arquivos com Java, bem como escrever e ler arquivos no formato de texto (txt).

A manipulação de arquivos em Java acontece de forma simples e rápida, pois a linguagem dispõe de classes que executam praticamente todas as operações necessárias para tanto.

java.io.File

A classe File representa um arquivo ou diretório no sistema operacional. Importante saber que apenas REPRESENTA, não significa que o arquivo ou diretório realmente exista.

Para instanciar um objeto do tipo File:

File arquivo = new File( "/home/hallan/nome_do_arquivo.txt" );

Com o objeto instanciado, é possível fazer algumas verificações, como por exemplo se o arquivo ou diretório existe:

//verifica se o arquivo ou diretório existe
boolean existe = arquivo.exists();

Caso não exista, é possível criar um arquivo ou diretório:

//cria um arquivo (vazio)
arquivo.createNewFile();

//cria um diretório
arquivo.mkdir();

caso seja um diretório, é possível listar seus arquivos e diretórios através do método listFiles(), que retorna um vetor de File:

//caso seja um diretório, é possível listar seus arquivos e diretórios
File [] arquivos = arquivo.listFiles();

É possível também excluir o arquivo ou diretório através do método delete(). Uma observação importante é que, caso seja um diretório, para poder excluir, este tem de estar vazio:

//exclui o arquivo ou diretório
arquivo.delete();

java.io.FileWriter e java.io.BufferedWriter

As classes FileWriter e BufferedWriter servem para escrever em arquivos de texto.

A classe FileWriter serve para escrever diretamente no arquivo, enquanto a classe BufferedWriter, além de ter um desempenho melhor, possui alguns métodos que são independentes de sistema operacional, como quebra de linhas.

Para instanciar um objeto do tipo FileWriter:

//construtor que recebe o objeto do tipo arquivo
FileWriter fw = new FileWriter( arquivo );

//construtor que recebe também como argumento se o conteúdo será acrescentado
//ao invés de ser substituído (append)
FileWriter fw = new FileWriter( arquivo, true );

A criação do objeto BufferedWriter:

//construtor recebe como argumento o objeto do tipo FileWriter
BufferedWriter bw = new BufferedWriter( fw );

Com o bufferedwriter criado, agora é possível escrever conteúdo no arquivo através do método write():

//escreve o conteúdo no arquivo
bw.write( "Texto a ser escrito no txt" );

//quebra de linha
bw.newLine();

Após escrever tudo que queria, é necessário fechar os buffers e informar ao sistema que o arquivo não está mais sendo utilizado:

//fecha os recursos
bw.close();
fw.close();

java.io.FileReader e java.io.BufferedReader

As classes FileReader e BufferedReader servem para ler arquivos em formato texto.

A classe FileReader recebe como argumento o objeto File do arquivo a ser lido:

//construtor que recebe o objeto do tipo arquivo
FileReader fr = new FileReader( arquivo );

A classe BufferedReader, fornece o método readLine() para leitura do arquivo:

//construtor que recebe o objeto do tipo FileReader
BufferedReader br = new BufferedReader( fr );

Para ler o arquivo, basta utilizar o método ready(), que retorna se o arquivo tem mais linhas a ser lido, e o método readLine(), que retorna a linha atual e passa o buffer para a próxima linha:

//equanto houver mais linhas
while( br.ready() ){
//lê a proxima linha
String linha = br.readLine();

//faz algo com a linha
}

Da mesma forma que a escrita, a leitura deve fechar os recursos:

br.close();
fr.close();

Agora, o código completo de escrita e leitura do arquivo:

public static void main(String[] args) {

File arquivo = new File("/home/hallan/nome_do_arquivo.txt");

try {

if (!arquivo.exists()) {
//cria um arquivo (vazio)
arquivo.createNewFile();
}

//caso seja um diretório, é possível listar seus arquivos e diretórios
File[] arquivos = arquivo.listFiles();

//escreve no arquivo
FileWriter fw = new FileWriter(arquivo, true);

BufferedWriter bw = new BufferedWriter(fw);

bw.write("Texto a ser escrito no txt");

bw.newLine();

bw.close();
fw.close();

//faz a leitura do arquivo
FileReader fr = new FileReader(arquivo);

BufferedReader br = new BufferedReader(fr);

//equanto houver mais linhas
while (br.ready()) {
//lê a proxima linha
String linha = br.readLine();

//faz algo com a linha
System.out.println(linha);
}

br.close();
fr.close();

} catch (IOException ex) {
ex.printStackTrace();
}

}

Abraço!

Neste post explicarei como utilizar as classes java.util.Date, java.util.GregorianCalendar e java.text.SimpleDateFormat.

java.util.Date

A Classe java.util.Date serve para armazenar uma data em específico. É uma classe simples, e muitos componentes de bibliotecas e Frameworks utilizam esta classe.

Para instanciar uma nova data, basta utilizar o comando:

Date data = new Date();

Não esquecendo, claro, de importar a Classe.

A data é instanciada com a data atual do computador.

O problema é quando é necessário alterar a data para um dia, mês ou ano em específico. Os métodos setMonth, setDate e setYear estão depreciados, pois o ano é acrescentado automaticamente a 1900.

Isto funcionava muito bem antes do ano 2000, pois se fosse para setar o ano para 1997, bastava fazer um setYear( 97 ). Agora para 2006, é necessário fazer um setYear( 106 ). Não é muito bonito.

O ideal é usar a classe GregorianCalendar que implementa o calendário gregoriano, como veremos mais a frente.

java.text.SimpleDateFormat

A classe java.text.SimpleDateFormat é uma classe utilitária que serve para converter tanto de String para Date quanto de Date para String. Muito útil quando tem que transformar um campo digitado pelo usuário para Date ou mostrar uma data em um formato em específico.

Para utilizar a classe

//instancia o objeto passando no construtor a máscara da data
SimpleDateFormat sdf = new SimpleDateFormat( "dd/MM/yyyy" );

//Para converter de String para Date:
java.util.Date data = sdf.parse("21/04/2011");

//converter de Date para String
String data = sdf.format( data );

java.util.GregorianCalendar

Quando é necessário efetuar operações com datas, a classe Date já não serve muito bem. A classe GregorianCalendar, além de ajustar alguns problemas que ocorrem com a classe Date, serve para efetuar operações mais complexas com datas.

Para instanciar um objeto do tipo GregorianCalendar:

//construtor sem argumentos
GregorianCalendar data = new GregorianCalendar();

Da mesma forma que um Date, o GregorianCalendar vem como padrão a data atual do sistema.

Um outro construtor da classe permite passar o ano, mês e dia da data:

//construtor que recebe o ano, mes e dia
GregorianCalendar data2 = new GregorianCalendar( 2011, 0, 1 );

Um detalhe importante é que o mês vai de 0 (janeiro) a 11 (dezembro).

Métodos de manipulação de data:

data.set( campo, valor )

Este método seta o valor de um campo específico. Os campos são constantes da classe, conforme abaixo:

//altera o dia para 1
data.set( GregorianCalendar.DAY_OF_MONTH , 1);

//altera o mês para abril
data.set( GregorianCalendar.MONTH , 3);

//altera o ano para 2012
data.set( GregorianCalendar.YEAR , 2012);

data.get( campo )

Este método retorna um campo específico da data. Os campos são as mesmas constantes listadas no exemplo do método set acima:

int dia = data.get( GregorianCalendar.DAY_OF_MONTH );
int mes = data.get( GregorianCalendar.MONTH );

data.add( campo, valor )

Este método adiciona um valor a um campo. Exemplo:

//adiciona 2 meses a data atual
data.add( GregorianCalendar.MONTH , 2);

data.before( outraData ) e data.after( outraData )

Este método verifica se uma data é anterior ou posterior a outra data.

Exemplo:

//construtor sem argumentos
GregorianCalendar data = new GregorianCalendar();

//construtor que recebe o ano, mes e dia
GregorianCalendar data2 = new GregorianCalendar( 2011, 0, 1 );

if ( data.after( data2 ) ){
 //caso a data seja após a data 2, entra neste IF
}

Convertendo entre Date e GregorianCalendar

Para converter um objeto de Date para GregorianCalendar:

//objeto do tipo Date
Date date = new Date();

//cria o GregorianCalendar e utiliza o método setTime
GregorianCalendar gc = new GregorianCalendar();
gc.setTime( date );

Para converter um objeto de GregorianCalenda para Date:

Date date = gc.getTime();

O método getTime() do GregorianCalendar retorna um objeto do tipo Date.

Resolvendo operações de dias, meses e anos entre datas

Tanto as classes Date como GregorianCalendar possuem métodos para retornar a data em milissegundos passados desde a data de 1/jan/1970.

Na classe Date, o método se chama getTime;
Em GregorianCalendar, o método se chama getTimeInMillis;

A partir disto, é possível calcular, em milissegundos, a diferença entre uma data e outra., para então converter para dias, meses, anos e etc.

Exemplo com GregorianCalendar:

long milissegundos = gc.getTimeInMillis() - gc2.getTimeInMillis();
long dias = milissegundos / (24*60*60*1000);

Mas o que significa esses números?

É que a diferença é em milissegundos. Para chegar a dias, é necessário dividir por milissegundos (1000), por segundos (60), por minutos (60) e por horas (24).

Espero ter ajudado.

Abraço!

Neste post, tentarei explicar o que é são Frameworks,  e exemplificar alguns dos mais comuns para JEE.

Existem muitas definições do que é um Framework. As mais clássicas:

• “A framework is a set of classes that embodies an abstract design for solutions to a family of related problems” [Johnson and Foot, 1988]
• “A framework is a set of objetcts that collaborate to carry out a set of responsabilities for an application subsystem domain” [Damian, 1991]
• “A framework is an architecture developed with the objective to obtain the maximum reuse, represented as a group of abstract and concrete classes, with a great potetnial specialization” [Mattsson, 1996]

Podemos dizer então que um Framework consiste em um conjunto de classes e/ou objetos (ou uma arquitetura) já desenvolvidos que tem como objetivo obter o máximo da reutilização, e que tem como responsabilidade prover uma solução para um conjunto de problemas.

O conjunto de classes de um Framework deve ser flexível e extensível para permitir a construção de várias aplicações com pouco esforço, especificando apenas as particularidades de cada aplicação.

Pode-se dizer ainda que Frameworks são projetos reutilizáveis de todo ou parte de um sistema de software, descrito por um conjunto de classes abstratas e a forma como as instâncias destas classes se relacionam.

Um bom Framework pode reduzir o custo do desenvolvimento de uma aplicação, por uma ordem de grandeza, pois permite a reutilização de design e código.

Diferença entre Frameworks e Bibliotecas de Classes

Uma biblioteca de classe (lib) consiste em uma coleção de sub-rotinas ou classes prontas, que tem como objetivo a reutilização de código.

Uma biblioteca se preocupa apenas em oferecer implementação de funcionalidades, enquanto o Framework define a reutilização de uma arquitetura (pattern) completo.

Ao utilizar uma biblioteca, o desenvolvedor define com as classes irão interagir. Em um Framework, as relações entre as classes já estão definidas: é o desenvolvedor que se adapta ao padrão (design) que já foi proposto pelo Framework.

Diferença entre Frameworks e Design Patterns

Um Design Pattern (ou Padrão de Projeto) descreve como uma solução deve ser implementada para resolver determinado problema. Desta forma, um Design Pattern não possui código, possui apenas um modelo de arquitetura a ser seguido.

Um design pattern é mais abstrato que um Framework, justamente pela ausência de código.

Uma Framework, em sua implementação, pode seguir um ou mais Padrões de Projeto

Frameworks Conceituais

O conceito de Framework aqui descrito se refere a Framewroks Computacionais. Existem também os Frameworks Conceituais, que é um conjunto de conceitos usado para resolver um problema de um domínio específico.

Como exemplos de Frameworks Conceituais para governança de TI, temos o  COBIT e o ITIL.

Exemplos de Frameworks

Hibernate: Amplamente utilizado para persistência de dados e mapeamento objeto-relacional;

Java Server Faces: Utilizado para desenvolvimento de interfaces gráficas em aplicações Java EE;

Struts: Utilizado para auxiliar a implementar o modelo MVC em aplicações Java EE;

JUnit: Utilizado para realização de testes unitários;

Flex: utilizado para desenvolver interfaces gráficas sobre a plataforma Adobe Flash.

Estes são apenas alguns exemplos de vários Frameworks existentes.

Fico por aqui.

Abraço!

Referências:

http://st-www.cs.illinois.edu/users/johnson/frameworks.html

http://st-www.cs.illinois.edu/users/droberts/evolve.html

http://www.dsc.ufcg.edu.br/~jacques/cursos/map/html/frame/oque.htm

Á ética na área de TI é dificultada por vários fatores. Um deles, talvez o mais agravante, é o fato de que qualquer pessoa poder trabalhar na área, inclusive pessoas sem um curso superior.  Outro problema grave é que no Brasil não existe um código de ética oficial como em outras áreas, por exemplo:  medicina e direito.

A promiscuidade e falta de confiança nos profissionais de TI está intimamente ligada a falta de ética na nossa área.

Por não ser uma profissão regulamentada, não existe nenhum órgão que efetivamente seja responsável por fiscalizar e zelar pelo bom desempenho profissional na nossa área.

Desta forma, está na mão de cada um, por em prática a ética profissional.

Infelizmente, hoje, é muito comum na área da computação um profissional praticar um ato desonesto ou desonrado sobre algum cliente, sistema ou até mesmo sobre outro profissional.

A área da computação está presente hoje em praticamente todas as outras áreas de conhecimento. Normalmente, um profissional de TI possui um conhecimento muito grande sobre um negócio ou problema, tem acesso a informações sigilosas e, não raro, existe uma grande dependência da nossa área por parte dos profissionais de outras áreas.

Por consequência, atitudes como quebra de sigilo, revelação de dados de negócio de uma empresa para outra concorrente, pirataria,  e todo tipo de má conduta é algo comum na área da computação.

Existem algumas sociedades que já discutiram e até mesmo elencaram uma série de “imperativos” considerados como uma boa prática para o bom profissionalismo para a área de TI. Talvez o mais expressivo seja a ACM (Association for Computer Machinery), sociedade americana que propôs um Código de Ética e Conduta Profissional, em 16/10/1992.

Todo profissional da área de TI deveria ao menos ter conhecimento deste código de ética. Não só isso: todo profissional deveria praticar os imperativos propostos por este código de ética.

Alguns dos imperativos propostos:

1 – CONSIDERAÇÕES ÉTICAS FUNDAMENTAIS

1.1 – Contribuir para a sociedade e bem-estar do ser humano

O maior valor da computação é o seu potencial de melhorar o bem-estar do indivíduo e da sociedade como um todo. Assim, profissionais da computação devem estar comprometidos a desenvolver, expandir e usar a sua ciência para o benefício da humanidade, minimizando as conseqüências negativas dos sistemas de computação, incluindo ameaças à saúde e segurança. Um profissional da computação que projeta e desenvolve sistemas deve estar alerta e alertar os outros para qualquer dano ao ambiente local ou global.

1.2- Evitar de prejudicar outros.

Este princípio proíbe o uso da tecnologia se esta resultar em dano a: usuários, estado, empregados, empregadores. Ações nocivas incluem destruição ou modificação intencional de arquivos e programas que conduzam a séria perda de recursos ou gasto desnecessário de recursos humanos como o tempo e esforço requeridos para eliminar “virus” de sistemas. Para minimizar a possibilidade de prejudicar outros indiretamente, os profissionais da computação devem minimizar problemas operacionais usando padrões para projetar e testar sistemas.

1.3- Ser honesto e digno de confiança.

O profissional honesto não deve fazer declarações falsas ou queixas depreciativas sobre um sistema ou projeto de sistema. Um profissional da computação deve ser honesto a respeito de suas próprias qualificações e sobre quaisquer circunstâncias que possam levar a conflitos de interesses.

1.4- Ser imparcial e realizar ações sem discriminação.

Os valores de igualdade, tolerância, respeito pelos outros, e os princípios de justiça igualitária governam este ítem. Discriminações na base de qualquer característica social como raça, sexo, religião, idade, invalidez ou origem não será tolerada. Em uma sociedade justa, todos os indivíduos devem ter igualdade de oportunidades e de benefícios do uso de recursos computacionais, a despeito de suas características.

1.5- Honrar direitos de propriedade incluido copyrights e patentes.

Violação de copyrights, patentes, acordos de licenciamento é proibida por lei na maioria das circunstâncias. Mesmo não havendo proteção, estas violações são contrárias ao comportamento profissional.

1.6- Conceder créditos apropriados para propriedades intelectuais.

Profissionais da computação são obrigados a proteger a integridade da propriedade intelectual. Especificamente, não é permitido usar idéias de outros ou obter créditos por trabalho de outros, mesmo em casos onde o trabalho não está explicitamente protegido por qualquer meio, incluindo copyright e patente.

1.7- Acessar recursos computacionais e de comunicação somente quando autorizado.

Indivíduos e organizações têm o direito de restringir o acesso aos seus sistemas, desde que nao viole o ítem 1.4. Ninguém deve entrar ou usar sistemas, softwares ou arquivos de outros sem permissão. Sempre deve ser obtida a aprovação antes de usar recursos, incluindo canais de comunicação, arquivos, periféricos e tempo de máquina.

1.8- Respeitar a privacidade de outros.

É responsabilidade dos profissionais manter a privacidade e integridade de dados de indivíduos. Isto inclui tomar precauções para assegurar a precisão dos dados, como também protegê-los de acesso acidental a indivíduos não autorizados. Devem ser planejados procedimentos para permitir aos indivíduos rever seus registros e corrigir imprecisões. Este imperativo implica que somente a quantidade necessária de informações pessoais deve ser armazenada em um sistema, que o período de retenção e eliminação para estas informações devem ser claramente definidas e cumpridas e que informações pessoais obtidas para um propósito específico não podem ser usada para outros fins sem o consentimento do indivíduo.

1.9- Honrar a confidencialidade.

O princípio da honestidade se estende a questões de confidencialidade de informações sempre que alguém faz uma promessa explícita de honrar a confidencialidade ou, implicitamente, quando informações privadas não diretamente relacionadas às obrigações de alguém se tornam disponíveis.

Outros imperativos adicionais, sobre liderança e concordância com o código também são propostos.

Alguns exemplos simples de falta de ética profissional na área de TI:

• Enganar ou tirar vantagem de alguém que não seja da área: dizer que não é possível fazer algo que na realidade é, explicação errônea sobre algo, venda de algo que não é necessário dizendo que é, entre outros;
• Quebra de sigilo: sair de uma empresa para outra e fornecer dados ou levar informações da empresa antiga, dar acesso a informações sigilosas para terceiros;
• Discriminação: não fornecer informações sobre computação para pessoas por julgar que as mesmas não vão entender. Será ela que não entende ou você que não sabe explicar?
• Pirataria: Sem maiores explicações. A pirataria hoje é tão comum quanto beber água. O que você faria se um software ou serviço criado por você fosse pirateado por ai?
• Conceder créditos apropriados: não reconhecer um esforço de alguém da equipe, ou pior: tomar para si uma idéia ou esforço de outro colega de trabalho;
• Prejudicar os outros: sair de uma empresa sem dar nenhum suporte às antigas responsabilidades, ou até pior: excluir arquivos ou códigos de sistemas de forma proposital.

Isso tudo sem contar casos onde pessoas infectam computadores com vírus de forma proposital, invadem sistemas ou sites, entre outros crimes computacionais.

A aderência do código da ACM ou qualquer outro similar, hoje, é voluntária. Cabe a cada um agir de acordo com o seu caráter.

Referências:

http://www.acm.org/about/code-of-ethics

http://ia.ucpel.tche.br/~lpalazzo/Aulas/CS/Codigo%20de%20Etica%20e%20Conduta%20Profissional%20da%20ACM.htm

http://www.sied.com.br/sys/prof_arquivos/A%20%C3%A9tica%20do%20profissional%20da%20inform%C3%A1tica.htm

Este post parte da premissa que o leitor ja esteja familiarizado com o JAAS (post anterior), e serve apenas para o container Tomcat.

Antes de tudo, a estrutura do JAAS em um banco de dados deverá haver uma tabela ou view com a seguinte estrutura:

- uma coluna contendo o login;

- uma coluna contendo a role;

Para o exemplo, vamos chamar esta tabela de tabela_roles.

Deverá também haver uma outra tabela ou view com:

- uma coluna contendo o login;

- uma coluna contendo a senha;

Esta tabela será a tabela_usuarios.

A partir desta estrutura, é possível utilizar o JAAS com banco de dados, configurando o arquivo context.xml, incluindo a seguinte tag:

<Realm className="org.apache.catalina.realm.JDBCRealm" debug="99"
driverName="nome_do_driver"
connectionURL="jdbc:url_da_conexao?user=user_banco&amp;password=senha_banco"
userTable="tabela_usuarios"
userNameCol="nome_coluna_login"
userCredCol="nome_coluna_senha"
userRoleTable="tabela_roles"
roleNameCol="nome_coluna_role"/>

Um ponto importante é que a coluna de login deverá ter o mesmo nome, nas duas tabelas.

Espero ter ajudado.

Abraço!

• Número e Nome do caso de uso
• Descrição
• Atores envolvidos
• Pré-condição
• Pós-condição
• Fluxo de tarefas

Número e Nome do caso de uso
Serve para identificar o caso de uso. Normalmente, adotam-se padrões como CSU ou UC como siglas. Exemplo: UC 01 – Manter Usuário

Descrição
Descreve a função e o resultado final de um Caso de Uso., sem detalhar muito. Exemplo: “Este caso de uso serve para cadastrar um novo usuário”.

Atores envolvidos
O ator é quem interage com o sistema, iniciando o caso de uso. Exemplo: Administrador do Sistema.

Pré-condição
Condições que precisam ser verdadeiras no início do caso de uso. Uma pré-condição não atendida impede o início do caso de uso.
Exemplo: “O usuário deve estar logado no sistema”.

Pós-condição
Condições que precisam ser verdadeiras no final do caso de uso. Pode ser um outro caso de uso.
Exemplo: “Após o fim do caso de uso, o sistema deve enviar um e-mail ao administrador informando o ocorrido”.

Fluxo de Tarefas
Descreve a sequência em que as ações devem ser executadas.
Podem haver fluxos de tarefas principal, alternativo e exceção.
Exemplo:

1. O usuário clica no botão “Cadastrar”
2. O sistema mostra os dados para cadastro
3. O usuário preenche os dados de cadastro
4. O usuário clica no botão “Cadastrar”
5. O caso de uso é finalizado.

Uma apresentação muito interessante e bem completa sobre casos de uso pode ser visualizada logo abaixo:

Espero ter ajudado.
Abraço,

Link: FlexStyle Explorer

Abraço!