Arquivo protegido

eu ateh tentei salvar na base de dados… fiz alguns teste e os resultados foram o seguinte:

inclui 827 imagens com tamanho 800x600 199k formato jpg

o tamanho do backup gerado das imagens foi de 140MB (bem grande, pra ter uma ideia o da loja dah 5MB)

um select *from tabelaImagens; demorou 31 segundos enquanto um select em uma

tabela de dados comun com 29290 registros demora 2 segundos;

Ou trabalhar com um arquivo compactado (usando, talvez, as classes do pacote java.util.zip);

Ou renomear o nome/extensão do arquivo;

Ou trabalhar com criptografia usando CipherInputStream/CipherOutputStream;

package criptografia;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.CipherOutputStream;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;

public class CriptografarArquivo {
	
	/**
	 * Algoritmo/mode/Padding para criptografia
	 */
	private static final String ALGORITHM_MODE_PADDING = "DES/ECB/PKCS5Padding";

	/**
	 * Algorítmo de criptografia
	 */
	private static final String KEY_GEN = "DES";

	/**
	 * Nome do arquivo onde ficará armazenada a chave de segurança
	 * NÃO PERCA ESTE ARQUIVO, SOB PENA DE NÃO ABRIR MAIS OS ARQUIVOS EXISTENTES
	 */
	private static final String SECRET_FILE = "secret.cpt";
	
	/**
	 * Chave de segurança.
	 */
	private Key key = null; 
	
	private static CriptografarArquivo instance;
	
	static {
		instance = new CriptografarArquivo();
	}
	
	public static CriptografarArquivo getInstance() {
		return instance;
	}
	
	public CriptografarArquivo() {
		
		//Criar chave de criptografia
		final File f = new File(SECRET_FILE);
		f.setReadOnly();
		try {
			if (f.exists()) {
			    //Se o arquvivo que contêm a chave existir...
				final ObjectInputStream in = new ObjectInputStream(new FileInputStream(f));
			    //Obter a chave e fechar o arquivo
				key = (Key) in.readObject();
				in.close();
			} else {
			    //Caso não existir,
				// criar keygenerator
				KeyGenerator generator = KeyGenerator.getInstance(KEY_GEN);
				// inicializar Keygenerator
				generator.init(new SecureRandom());
				// gerando key
				key = generator.generateKey();
				// criando arquivo que armazenará a chave
				ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
				// escrevendo a chave no arquivo
				out.writeObject(key);
				// fechando
				out.close();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			f.setWritable(true);
		}
	}
		
	public InputStream getIn(File file) throws FileNotFoundException, InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException {
        final FileInputStream fileIn = new FileInputStream(file);
        return getIn(fileIn);
    }
	
	private InputStream getIn(final InputStream fileIn) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException {
        final Cipher cipher = Cipher.getInstance(ALGORITHM_MODE_PADDING);
        cipher.init(Cipher.DECRYPT_MODE, key);
        
        return new CipherInputStream(fileIn, cipher);
    }
	
	public OutputStream getOut(File file) throws FileNotFoundException, InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException {
        final FileOutputStream fileOut = new FileOutputStream(file);
        return getOut(fileOut);
    }
	
	private OutputStream getOut(final OutputStream fileOut) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException {
        final Cipher cipher = Cipher.getInstance(ALGORITHM_MODE_PADDING);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        
        return new CipherOutputStream(fileOut, cipher);
    }
}

package criptografia;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class TesteCriptografar {
	
	public TesteCriptografar(boolean ler, String fileName) throws Exception {
		CriptografarArquivo cripto = CriptografarArquivo.getInstance();
		
		File file = new File(fileName);
		
		try {
			if(ler){
				InputStream in = cripto.getIn(file);
				
				for(int caractere = in.read(); caractere != -1; caractere = in.read()) {
					System.out.print((char)caractere);
				}
				
				in.close();
				
			} else {
				OutputStream out = cripto.getOut(file);
			
				out.write("Mais teste".getBytes());
				out.flush();
				out.close();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//-r para ler, arquivo
		//uso leitura: TesteCriptografar -r [arquivo]
		//uso escrita: TesteCriptografar [arquivo]
		//Sem parametros: Equivalente a TesteCriptografar teste.arq
		//Apenas com -r:  Equivalente a TesteCriptografar -r teste.arq
		try {
			boolean ler = false; //Pre-definido para escrita
			
			String arquivo = "teste.arq";
			if(args != null && args.length > 0) {
				if(args[0].equalsIgnoreCase("-r")) {
					ler = true;
					if(args.length > 1) {
						arquivo = args[1];
					}
				} else {
					arquivo = args[0];
				}
			}
			new TesteCriptografar(ler, arquivo);
			
		} catch (Exception e) {
			//Para simplificar
			e.printStackTrace();
		}
		System.exit(0);
	}
}