Mensagens enviadas por: renatoes

Boa tarde ds311072,

No PostgreSQL, você pode utilizar o tipo bytea para armazenar as fotos. Dê uma pesquisada no google, existem vários sites explicando como proceder (busque pela função lo_import também, encontra-se muita coisa).

Quanto ao procedimento de exibir as imagens no Java, nunca fiz nada semelhante (utilizei PostgreSQL para uma aplicação em PHP). Dê uma pesquisada pela Sun, com certeza haverá alguma fonte por lá

[]'s

Boa tarde cleber_zeh,

Os valores do objeto Data instanciado dentro da classe Funcionário não são setados (você apenas instanciou o objeto). Ao instanciar um novo objeto Data na função main, você está modificando um objeto fora do escopo do objeto Funcionário, não dentro.
Para ficar mais claro, o que você deve fazer é:

package Banco;

public class Funcionario {

String funcionario;
	String departamento;
	double salariobase;
	String dataentrada; 
	String rg;
	boolean on_empresa;
	boolean bonifica;
	boolean naobonifica;
	double  admissao;

Data dataDeEntrada = new Data ();

/*
         * Aqui você configura os valores da data para um objeto Funcionário, mas não faz muito sentido, pois todos os funcionários teriam a mesma data de entrada.
         */
	 dataDeEntrada.dia = 10;
         dataDeEntrada.mes = 01;
         dataDeEntrada.ano = 2008;

void valor (double salario) {
                       salariobase += salario + salariobase; 
		
		}
        
		
		
		void bonifica(double valoraumemto) {
	               if (this.admissao >= 3) {
	     	          salariobase = valoraumemto + salariobase;
		   } else {
			  valoraumemto = 0;
		}

}

void demite(String demitir) {
	                if (demitir  == "s" ) {
	     	              System.out.print("funcionario foi demitido ");
			
		} else {
			System.out.print("Funcionario no quado de trabalhadores da empresa ");
		
		
        } 	
		}
		  void mostra(){
		 
			System.out.println("Nome: " + this.funcionario);
		  	System.out.print(" salario: " + this.salariobase);
		  	System.out.print("Tempo empresa: " + this.admissao);
		  	System.out.println("Dia: " + this.dataDeEntrada.dia);
		  	System.out.println("Mês: " + this.dataDeEntrada.mes);
		  	System.out.println("Ano: " + this.dataDeEntrada.ano);
		  
		  	
		  
		  }
		
}

Não sei se é o enfoque do exercício, mas pesquise um pouco mais sobre orientação a objetos e métodos setters (configuram atributos e/ou outros objetos que compõem um objeto) e getters (recuperam estes atributos).

[]'s

Bom dia cleber_zeh,

Por favor, poste seu código entre as tags que são disponíveis na hora do post para torná-lo mais legível. O Mantu explica como neste post:
http://www.guj.com.br/posts/list/50115.java

Bom dia cleber_zeh,

Já trabalhei um pouco com o banco Matisse, dê uma olhada e veja se atende suas necessidades:
http://www.matisse.com/developers/documentation/
Lembrando apenas que a utilização do banco para fins comerciais deve ser paga, leia aqui para saber de outros sistemas que sejam gratuitos:
http://www.odbms.org/vendors.html

[]'s

renatoes wrote:Boa tarde fabfodao,

Dê uma lida na documentação fornecida pela Sun, irá lhe ajudar bastante :
http://java.sun.com/docs/books/tutorial/uiswing/components/table.html

Abraços

Boa tarde fabfodao, você poderá tra

Dê uma lida na documentação fornecida pela Sun, irá lhe ajudar bastante

:
http://java.sun.com/docs/books/tutorial/uiswing/components/table.html

Abraços

Boa noite rolemberg,

Através da busca do site recuperei alguns posts sobre Portlets, veja se eles podem te ajudar:
http://www.guj.com.br/jforum.java?module=search&action=search&search_keywords=portlets&match_type=all&search_forum=&sort_by=relevance

Dê também uma procurada no google, encontrei alguns sites que falam sobre Portlet e Java (não sei se para o nível iniciante, mas de qualquer forma já é uma discussão

).

[]'s

Google In

http://www.google.com.br/search?hl=pt-BR&q=JSF+and+Struts&meta=

Google Out
Divirta-se

[]'s

Boa noite fabfodao,

De acordo com o reportado, você deve declarar um bloco catch para uma possível SQLException (no caso, antes do ClassNotFoundException).
Dê uma olhada neste link, irá ajudá-lo

http://java.sun.com/docs/books/tutorial/jdbc/basics/complete.html

[]'s

Boa tarde marcosbrandao,

Se seu servidor do banco utilizar distribuições Linux considere utilizar a ferramenta crontab.
Fiz uma aplicação teste que realiza basciamente a mesma tarefa que a sua, adicionei ela para ser gerenciada pelo crontab e tudo funcionou muito bem.
Seguem alguns links sobre o crontab:

http://pt.wikipedia.org/wiki/Crontab
http://www.devin.com.br/eitch/crontab/

Basta procurar no bom e velho google

[]'s

Boa noite bsatrianim

Dê uma pesquisada pelo google, muitos links aparecerão. Seguem alguns:
http://www.javafree.org/javabb/viewtopic.jbb?t=3400
http://www.javafree.org/javabb/viewtopic.jbb?t=5950
http://www.javafree.org/javabb/viewtopic.jbb?t=8905

[]'s

Boa tarde Borborema

Estou postando alguns links que possam te auxiliar:

http://en.wikipedia.org/wiki/Triple_DES
http://www.gta.ufrj.br/~natalia/SSH/triple.html
http://www.java2s.com/Code/Java/Security/TripleDES.htm

O Google é seu amigo, fique amigo dele também

[]'s

Vou postar o código, creio que facilitará a explicação do Vini

/*
 * SynchronizedContador.java
 *
 * Criado em 3 de Dezembro de 2007, 10:16
 *
 * Propósito: Implementar a classe utiliza pelas threads para recuperar o valor do contador
 * e escrever no arquivo.
 */

package desafio3;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.concurrent.Callable;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * @author Renato
 */
public class ThreadContadora implements Callable<Boolean>{
    
    //Condição de suspensão da thread
    private Condition suspensao;
    //Indica se a thread está suspensa
    private boolean suspenso;
    //Lock compartilhado para bloquear o acesso de outras threads (o que causaria InterruptedException)
    private Lock lock;
    //Contador compartilhado das threads
    private SynchronizedContador contador;
    //FileWriter compartilhado das threads
    private FileWriter fileWriter;
    //Nome de cada thread
    private String nome;
    
    /**
     * Construtor da classe ThreadContadora
     * @param nome - nome da thread
     *        fileWriter - objeto FileWriter compartilhado pelas threads
     *        lock - objeto Lock compartilhado pelas threads
     *        contador - objeto SynchronizedContador compartilhado pelas threads
     */
    public ThreadContadora(String nome, FileWriter fileWriter, Lock lock, SynchronizedContador contador){
      
        this.nome = nome;
        this.lock = lock;
        this.contador = contador;
        this.fileWriter = fileWriter;
    }
    
    /**
     * Overload do método call, chamado na execução das threads
     */
    public Boolean call() throws Exception {
        
        int c = contador.incrementa();
       
        while(c != -1){
            
            //Loop de permissão para escrever no arquivo e ler o valor do contador
            try{
                Thread.sleep(1000);
                lock.lock();
                try{
                    while(suspenso) suspensao.await();
                }finally{
                    lock.unlock();
                }
            }catch(InterruptedException e){
                e.printStackTrace();
            }finally{
                try {
                    fileWriter.write(String.format("%s: count = %d\n",nome,c));
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
                c = contador.incrementa();
            }
            
            }
            return true;
    }
 }

/*
 * Main.java
 *
 * Criado em 3 de Dezembro de 2007, 10:16
 *
 * Propósito: Inicializar a aplicação
 */

package desafio3;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.Future;

/**
 * @author Renato
 */
public class Main {
    
    public static void main(String[] args){
        
        //Inicializa os objetos compartilhados
        SynchronizedContador contador = new SynchronizedContador();
        Lock lock = new ReentrantLock(true);
        FileWriter fileWriter = null;
        
        try {
            fileWriter = new FileWriter(new File("teste.txt"), true);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        
        //Inicializa o executor de threads e as threads
        ExecutorService app = Executors.newFixedThreadPool(10);
        
        ThreadContadora thread1 = new ThreadContadora("Thread1",fileWriter, lock,contador);
        ThreadContadora thread2 = new ThreadContadora("Thread2",fileWriter, lock,contador);
        ThreadContadora thread3 = new ThreadContadora("Thread3",fileWriter, lock,contador);
        ThreadContadora thread4 = new ThreadContadora("Thread4",fileWriter, lock,contador);
        ThreadContadora thread5 = new ThreadContadora("Thread5",fileWriter, lock,contador);
        ThreadContadora thread6 = new ThreadContadora("Thread6",fileWriter, lock,contador);
        ThreadContadora thread7 = new ThreadContadora("Thread7",fileWriter, lock,contador);
        ThreadContadora thread8 = new ThreadContadora("Thread8",fileWriter, lock,contador);
        ThreadContadora thread9 = new ThreadContadora("Thread9",fileWriter, lock,contador);
        ThreadContadora thread10  = new ThreadContadora("Thread10",fileWriter, lock,contador);
       
        //Executa as threads, e armazena o resultado da finalização da thread
        ArrayList<Future<Boolean>> resultados = new ArrayList<Future<Boolean>>();
        
        try{
            resultados.add(app.submit(thread1));
            resultados.add(app.submit(thread2));
            resultados.add(app.submit(thread3));
            resultados.add(app.submit(thread4));
            resultados.add(app.submit(thread5));
            resultados.add(app.submit(thread6));
            resultados.add(app.submit(thread7));
            resultados.add(app.submit(thread8));
            resultados.add(app.submit(thread9));
            resultados.add(app.submit(thread10));
        }catch( Exception e){
            e.printStackTrace();
        }
        
        
        //Utiliza o método Future.get para determinar a finalização das threads
        for(Future<Boolean> f: resultados){
            try {
                if(f.get() == true);
            } catch (ExecutionException ex) {
                ex.printStackTrace();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
        
        //Fecha o executor e o FileWriter
        app.shutdown();
        try{
            fileWriter.close();
        }catch(Exception e){
            e.printStackTrace();
        }
            
    }
        
}

Qualquer outra sugestão por favor repassem no fórum
[]'s

Valeu Vini

Vou fazer as alterações aqui

Boa tarde,

Fiz uma aplicação teste, que cria 20 threads e escrevem um valor em um arquivo.

O objeto app é um ExecutorService. Pelo que li na API da classe, invocar o método shutdown inicia a finalização das threads, mas não necessariamente as finaliza. Como vocês podem notar, fiz um while que indicasse, através do métod isTerminated (este sim indica que as threads foram finalizadas), a finalização das threads. Minha dúvida é se existe alguma forma de sinalizar a finalização, uma vez que preciso fechar o stream do arquivo (criado pelo objeto FileWriter).

Agradeço desde já,

Notícias, artigos e o maior fórum brasileiro sobre Java