Mensagens enviadas por: Wonder

Bibliografias
- Java para a Web com Servlets, JSP e EJB
- Aprenda em 21 dias J2EE

começe fazendo um curso de java/OO(caelum) e depois vai atraz de material na internet ou melhor em livros como:
- Java Como Programar.
- Aprenda java em 21 dias
- Core java 2 vol I
- Core java 2 vol II
- ...

http://java.sun.com/j2ee/1.4/docs/tutorial/doc/index.html

no servidor que gera os email...

segue abaixo...

legal vou começar a implementar colocando todos os mailing como copia oculta.

alguem sabe se existe alguma restrição sobre a quantidade de mailing que eu posso enviar como copia oculta?

Tenho uma aplicação web com mailing 2000 registro. quando vou mandar esses email o servidor da pau.

eu estava fazendo assim, mais o servidor não consegue enviar todos os mailing, o mesmo da um erro de "out of memory"

mas como eu disse o servidor não consegue alocar tantos objetos na memoria e toda vez que esse mailing era enviado o mesmo dava pau

dei um pequena melhorada no codigo e fiz assim, criei um atributo na tabela de mailing p/ armazenar o news Letter enviado, para fazer um busca menor e somente os mailing não enviado, com isso o codigo ficaria assim:

ao termino do envio dos 50 mailing eu chamo a mesma pagina para terminar o processamento

mesmo assim a solução esta sobrecaregando o servidor, alguem tem uma receita magica para resolver esse tipo de problema?

Obrigado...

A lista simplesmente encadeada é a mais básica de todas as estrutura de dados. Uma lista simplesmente encadeada é uma seqüência de objetos alocados dinamicamente, cada qual fazendo referencia ao seu sucessor na lista. Apesar de simplicidade obvia, existem diversas variações de implementação

A figura (b) ilustra o esquema de lista simplesmente encadeada que escolhemos para implementação. São Utilizados duas estrutura inter-relacionada. Os elementos da lista são representados com o uso de instâncias da classe LinkedList.Element, que compreende dois campos, datum e next. O primeiro é empregado para fazer referência aos objetos da lista; o ultimo é um ponteiro para o elemento seguinte da lista. A estrutura principal é uma instância da classe LinkedList, que também compreende dois campos, head e tail, que se referem ao primeiro e ultimo elemento da lista, respectivamente

package datastruct;

/**
 * Title: Data Struct
 * Description: Data Struct
 * Copyright: Copyright (c) 2004
 * Company: www.woniz.com
 * @author Wonder Alexandre Luz Alves
 * @version 1.0
 * 
 * 
 * Implementação de uma lista simplesmente encadeada
 */

public class LinkedList {
     /**
      * referencia para o primeiro elemento da lista
      */
     protected Element head;

/**
      * referencia para o ultimo elemento da lista
      */
     protected Element tail;

/**
      * contrutor vazio
      */
     public LinkedList() {
     }

/**
      * metodo que esvazia uma lista ligadas
      */
     public void purge() {
          head = null; //referencia do incio da lista
          tail = null; //referencia do final da lista
     }

/**
      * metodo de acesso ao Elemento do inicio da lista
      * @return Element - retorna o primeiro elemento da lista
      */
     public Element getHead() {
          return head;
     }

/**
      * metodo de acesso ao ultimo elemento da lista
      * @return Element - ultimo elemento da lista
      */
     public Element getTail() {
          return tail;
     }

/**
      * retorna true se a lista for vazia e false se não
      * @return retorna true se a lista for vazia e false se não
      */
     public boolean isEmpty() {
          return (head == null);
     }

/**
      * pega o dado do primeiro elemento da lista
      * @return retorna o dado do primeiro elemento da lista
      */
     public Object getFirst() {
          if (head == null)
               throw new NullPointerException();
          return head.datum;
     }

/**
      * pega o dado do ultimo elemento da lista
      * @return retorna o dado do ultimo elemento da lista
      */
     public Object getLast() {
          if (tail == null)
               throw new NullPointerException();
          return tail.datum;
     }

/**
      * inicializando a lista ligada
      * @param item
      */
     public void prepend(Object item) {
          Element tmp = new Element(item, head);
          if (tmp == null)
               tail = tmp;
          head = tmp;
     }

/**
      * inserindo um novo elemento no final da lista
      * @param item
      */
     public void append(Object item) {
          Element tmp = new Element(item, null);
          if (head == null)
               head = tmp;
          else
               tail.next = tmp;
          tail = tmp;
     }

/**
      * esvazia a lista e preenche a mesma com uma outra lista preenchida
      * @param list
      */
     public void assign(LinkedList list) {
          if (list != this) {
               purge();
               for (Element ptr = list.head; ptr != null; ptr = ptr.next) {
                    append(ptr.datum);
               }
          }
     }

/**
      * retirando um elemento da lista
      * @param item
      */
     public void extract(Object item) {
          Element ptr = head;
          Element prevPtr = null;
          while (ptr != null && ptr.datum != item) {
               prevPtr = ptr;
               ptr = ptr.next;
          }
          if (ptr == null) {
               throw new NullPointerException();
          }
          if (ptr == head)
               head = ptr.next;
          else
               prevPtr.next = ptr.next;
          if (ptr == tail)
               tail = prevPtr;
     }

/**
 *
 * Title: Data Struct
 * Description: Data Struct
 * Copyright: Copyright (c) 2004
 * Company: www.woniz.com
 * @author Wonder Alexandre Luz Alves
 * @version 1.0
 * {@docroot} class interna para representar os elementos de uma lista encadeadas
 */
 public final class Element {

/**
           * atributo para armazenar os dados da lista
           */
          private Object datum;

/**
           * referencia para o proximo elemento da lista
           */
          private Element next;

/**
           * Contrutor da class
           * @param datum
           * @param next
           */
          public Element(Object datum, Element next) {
               this.datum = datum;
               this.next = next;
          }

/**
 * metodo que pega os dados da lista
 * @return <Object> retorna os dados da lista
 */
 public Object getDatum() {
 return datum;
 }

/**
 * metodo que pega o proximo Elemento
 * @return <Element> retorna o proximo elemento da lista
 */
 public Element getNext() {
 return next;
 }

/**
           * metodo que insere um objeto depois de um elemento arbitrario da lista
           * @param item
           */
          public void insertAfter(Object item) {
               next = new Element(item, next);
               if (tail == this)
                    tail = next;
          }

/**
           * metodo que insere um objeto antes de um elemento arbitrario da lista
           * @param item
           */
          public void insertBefore(Object item) {
               Element tmp = new Element(item, this);
               if (this == head)
                    head = tmp;
               else {
                    Element prevPtr = head;
                    while (prevPtr != null && prevPtr.next != this)
                         prevPtr = prevPtr.next;
                    prevPtr.next = tmp;
               }
          }

} /* fim da class interna */

}

baixe o fonte da classe LinkedList

CertificaoJava.com.br

http://www.guj.com.br/user.story.get.chain?page=1&story.id=447

faz assim:

tenta o usario defualt do sql server : "sa" e password : ""(vazio)

Warley estava errado essa duas linhas:

primeira linha:

a sintaxe da class estava errado

segunda linha

127.0.0.1 = locahost - sua maquina local
1433 - portal default do sql server
ai fica: 127.0.0.1:1433 ip local + porta do sql server

Pessoal gostaria de saber quais são as ferramentas que auxilia o desenvolvimento com hibernate.

tipo uma ferramenta que possa fazer engenharia reversa de um banco de dados e gera os arquivos de configurações e os ObjectValues

Obrigado Wonder

[Oi]

Estou desenvolvendo um administrador de conteudo, aonde tenho um formulario de cadastro de dados, no qual tem uma textArea.

quando eu digito o conteudo pelo teclado e salvo, não tenho nenhum probelma, mas quando eu copio e colo um texto que tem acentos ele aparece com ums caracteres estranho no banco de dados.

Alguem conhece alguma classe que tenha um metodo para fazer uma encode desse texto ou como posso resolver esse problema?

obrigado pela atenção....

segue abaixo um metodo p/ enviar email

public static void enviar(String subject, String to, String from, String mensagem){
try{
Properties mailProps = new Properties();
mailProps.put("mail.smtp.host", "smtp2.locaweb.com.br");
Session mailSession = Session.getDefaultInstance(mailProps, null);
InternetAddress destinatario = new InternetAddress(to);
InternetAddress remetente = new InternetAddress(from);
Message message = new MimeMessage(mailSession);
message.setFrom(remetente);
message.setRecipient(Message.RecipientType.TO, destinatario);
message.setSubject(subject);
message.setContent(mensagem.toString(), "text/html");
Transport.send(message);
}catch(AddressException ae){
System.out.println("Error: Endereço invalido");
}
catch(MessagingException me) {
me.printStackTrace();
}
}

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