Resumo: Este artigo apresenta dois métodos para JavaBean implementar uploads de vários arquivos, usando o protocolo http e o protocolo ftp, respectivamente. Primeiro, ele descreve o formato básico de transferência de vários arquivos por meio do protocolo http e o processo detalhado de upload. Em seguida, apresenta brevemente o uso da classe ftpclient para implementar o upload de FTP e, finalmente, compara os dois métodos.
Palavras-chave: JavaBean, http, ftp, ftpclient
JavaBean é um componente de software baseado em Java. JSP fornece suporte completo para integração de componentes JavaBean em aplicações Web. Esse suporte não apenas reduz o tempo de desenvolvimento (você pode usar diretamente componentes existentes que foram testados e confiáveis, evitando desenvolvimento repetido), mas também traz mais escalabilidade para aplicativos JSP.
A função de upload de arquivo é muito comum no modelo de desenvolvimento baseado em B/S. Comparado com outras ferramentas de desenvolvimento, o suporte do JSP para upload de arquivos não é perfeito. Ele não requer a conclusão de componentes como o ASP, nem fornece suporte direto para upload de arquivos como o PHP. A forma como JSP implementa o upload de arquivos é a seguinte: use o método getInputStream() da classe ServletRequest para obter um fluxo de dados enviado pelo cliente ao servidor e, em seguida, processe esse fluxo de dados para analisar e obter os vários parâmetros e parâmetros passados para o servidor durante o upload dos dados do arquivo e, em seguida, armazene os dados do arquivo nele como um arquivo ou insira-os em um banco de dados. Normalmente as páginas JSP não lidam com a função de upload de arquivo, mas colocam essas funções em Servlets ou JavaBeans para implementação. Exemplos de uso de Servlet para concluir uploads de arquivos são apresentados em alguns livros relacionados a JSP. Aqui apresentarei como usar JeanBean para concluir uploads de arquivos. Existem duas maneiras de fazer upload de arquivos em JSP, nomeadamente protocolo HTTP e protocolo FTP. Existem grandes diferenças nos princípios de transmissão entre os dois. A seguir será apresentada uma breve introdução à sua implementação com base no código-fonte. Acredito que os leitores ganharão algo com isso. O programa a seguir foi depurado e aprovado. Ambiente de depuração: servidor window 2000 + Apache + tomcat4.0, ambiente de depuração JavaBean: JDK1.4 + Editplus.
Usar JavaBean em JSP para implementar a função de upload de arquivos baseada na Web geralmente requer a combinação de três tipos de arquivos. Esses três arquivos são respectivamente o arquivo de página HTML que fornece a interface, o arquivo JSP que completa a chamada para implementar a função de upload do JavaBean e o arquivo de classe Java que implementa o JavaBean. Abaixo vou me concentrar na parte JavaBean que usa protocolo HTTP e protocolo FTP para implementar a função de upload de arquivo.
1 Use o protocolo HTTP para fazer upload de vários arquivos
No passado, os formulários HTML não podiam fazer upload de arquivos, o que limitava um pouco as funções de algumas páginas da web. A especificação RFC1867 (ou seja, upload de arquivo baseado em formulário em HTML) estende o formulário e adiciona um elemento de formulário <input type=file>. Ao usar este elemento, o navegador gerará automaticamente uma caixa de entrada e um botão. A caixa de entrada permite ao usuário preencher o nome do arquivo local e o nome do caminho, e o botão permite que o navegador abra uma caixa de seleção de arquivo para o usuário. selecione um arquivo. A implementação específica do formulário é a seguinte:
<FORMMETHOD="POST" ACTION="*.jsp" ENCTYPE="multipart/form-data">
<INPUT TYPE="FILE" NAME="FILE1" SIZE="50"><BR>
<INPUT TYPE="ENVIAR" VALUE="Carregar">
</FORM>
Ao optar por colar o arquivo, insira diretamente o caminho absoluto do arquivo local. O valor do atributo de ação do formulário é *.jsp, o que significa que a solicitação (incluindo o arquivo carregado) será enviada para o. *..arquivo jsp. Neste processo, o upload de arquivos via HTTP é realmente implementado. O upload de arquivos do cliente para o servidor é suportado pela Common Gateway Interface (CGI) do protocolo HTTP. Este método de upload requer que o navegador e o WEBServer suportem Rfc1867. JavaBean obtém um fluxo de dados enviado pelo cliente ao servidor por meio do método getInputStream() da classe ServletRequest, analisa o formato do arquivo carregado e envia vários arquivos para o arquivo de destino no lado do servidor em sequência com base nos resultados da análise. A função do JavaBeande neste exemplo é implementada especificamente pela classe testUpload. A estrutura da classe TestUpload é a seguinte:
classe pública testUpload
{
testUpload público(){……}
public final void inicializar (configuração ServletConfig) lança ServletException
{m_application=config.getServletContext();
public void upload() lança testUploadException, IOException, ServletException
{…………}
privado void getDataSection(){………}
privado vazio getDataHeader(){………}
public int save (String destPathName)
lança SmartUploadException, IOException, ServletException
{…………}
…
}
Inicialize o ambiente de execução do Servlet através do método inicialize(). Use o método upload() para obter o fluxo de entrada, analisar o formato do arquivo carregado e atribuir os atributos de cada arquivo carregado a várias instâncias da classe Arquivo para processamento. Essas instâncias da classe Arquivo são gerenciadas pela classe Arquivos. A classe File chama seu método save () de acordo com os atributos de cada arquivo para enviar vários arquivos para o arquivo de destino no lado do servidor em sequência. O método upload() é a chave, utilizada para analisar o formato dos arquivos transmitidos pelo protocolo http1.1. Após o teste, obtemos o formato do arquivo de fluxo de transporte, que é útil para entender o método upload(). Por exemplo, carregue o arquivo Meus Documentostt.txt. O formato é o seguinte:
//Separador de arquivos
--------------------------7d226137250336
//Cabeçalho de informações do arquivo
Disposição do conteúdo: dados do formulário; "ARQUIVO1";
Tipo de conteúdo: texto/simples
//Conteúdo do arquivo fonte
criar informações da tabela (
imagem de conteúdo nula);
//Delimitador do próximo arquivo
--------------------------7d226137250336
Disposição do conteúdo: dados do formulário nome = "ARQUIVO2";
Tipo de conteúdo: aplicativo/octeto-stream
--------------------------------7d226137250336
A partir dos arquivos acima podemos ver que ao fazer upload de vários arquivos, o protocolo HTTP Todos são colocados no fluxo de entrada e diferenciados por determinados delimitadores. Na verdade, o método upload() visa analisar o arquivo acima e determinar o conteúdo do delimitador, o formato do conteúdo de cada arquivo, o nome do caminho completo do arquivo e o início e o fim dos dados reais do arquivo. Uma coisa a notar aqui é que o delimitador é aleatório, são todos caracteres antes do primeiro caractere de retorno de carro do arquivo de fluxo de transporte.
O processo de implementação do método Upload() é: primeiro envie o arquivo de fluxo de entrada para a matriz de bytes m_binArray, que é implementado por meio do código a seguir.
m_totalBytes=1024;totalLeitura=0;
for(; totalRead < m_totalBytes; totalRead += readBytes)
tentar
{m_request.getInputStream();
readBytes = m_request.getInputStream().read(m_binArray, totalRead, m_totalBytes - totalRead);
}catch(Exception e){ throw new SmartUploadException("Incapaz de fazer upload.");}
O método de leitura multibyte no loop é usado aqui. O loop acima lê dados continuamente até que o array seja preenchido. Se um arquivo puder ser totalmente recuperado, todos os bytes do arquivo também poderão ser recuperados. Mas como a velocidade da rede geralmente é muito mais lenta que a da CPU, é fácil para o programa limpar o buffer da rede antes que todos os dados cheguem. Na verdade, o método de leitura multibyte retornará 0 ao tentar ler dados de um buffer de rede temporariamente vazio, mas aberto, o que significa que não existem dados, mas o fluxo de rede não foi fechado. Nesse caso, o método de byte único impedirá a execução do programa em execução, portanto, o comportamento do método multibyte é melhor do que o do método read() de byte único. Em seguida, o array de bytes m_binArray será analisado. Primeiro encontre o delimitador; use o método getDataHeader() para retornar o valor do cabeçalho de informações do arquivo, a partir do qual o nome do caminho completo do arquivo de origem, a extensão do arquivo de origem e o formato do conteúdo do arquivo de origem são determinados usando getDataSection(); método para retornar os dados do conteúdo do arquivo e gravá-los As posições inicial e final dos dados do arquivo na matriz de bytes. Em seguida, gere uma instância da classe File e coloque o nome do caminho completo do arquivo, a extensão do arquivo de origem, o formato do conteúdo do arquivo de origem e as posições inicial e final dos dados de conteúdo do arquivo nos atributos da instância da classe File. Encontre o próximo delimitador e continue repetindo o processo acima até que a análise seja concluída.
2 Use o protocolo FTP para fazer upload de vários arquivos
O protocolo FTP é um protocolo usado para transferir arquivos na Internet. Ele estipula os padrões para transferência mútua de arquivos na Internet. A implementação desta função em java é realizada com a ajuda da classe FtpClient. Processo de implementação específico: primeiro estabeleça uma conexão com o servidor FTP; inicialize o método de transmissão de arquivo, incluindo ASCII e BINARY, envie o arquivo para o fluxo de entrada de arquivo FileInputStream; os dados são gravados no fluxo de saída TelnetOutputStream (use o método write para gravar os dados em um link de rede). Desta forma, um arquivo com o mesmo nome do arquivo de origem é copiado para o servidor. Neste exemplo, o JavaBean conclui o processo de upload do arquivo por meio de três métodos: connectServer(), upload() e closeConnect(). A implementação principal é a seguinte:
classe pública ftpUpload
{ String nome do arquivo;String nome do arquivo1;FtpClient ftpClient;
public void connectServer(string servidor,string usuário,string senha,string caminho)
{
//servidor: endereço IP do servidor FTP usuário: nome de usuário para efetuar login no servidor FTP;
//senha: a senha do nome de usuário para fazer login no servidor FTP path: o caminho no servidor FTP;
tente{ftpClient=new FtpClient();
ftpClient.openServer(servidor);
ftpClient.login(usuário, senha);
System.out.println("login bem sucedido!");
if (caminho.length()!=0) ftpClient.cd(caminho);
ftpClient.binary(); }catch (IOException ex) {System.out.println(ex);}
}
público void closeConnect()
{tente{ftpClient.closeServer();
}catch (IOException ex) {System.out.println(ex);}
}
upload público vazio()
{nomedoarquivo1=encontrarNomeDoArquivo(nomedoarquivo);
//Analise o nome do arquivo a partir do nome do arquivo e use-o como o nome do arquivo de destino O método específico não é fornecido.
tentar {
TelnetOutputStream os=ftpClient.put(nomedoarquivo1);
java.io.File file_in=new java.io.File(nome do arquivo);
FileInputStream é = novo FileInputStream (arquivo_in);
byte[] bytes=novo byte[1024];
interno c;
enquanto ((c=is.read(bytes))!=-1){ os.write(bytes,0,c });
is.close(); os.close();
} catch (IOException ex) {System.out.println (ex);}
}
}
connectServer() completa a função de estabelecer uma conexão com o servidor FTP, usa o método openServer(string server) do FtpClient para abrir o servidor FTP remoto e, em seguida, usa o método login(user, password) do FtpClient para fazer login no servidor. Existem duas maneiras de fazer login no servidor FTP remoto: uma é fazer login como usuário registrado e a outra é fazer login anonimamente. O primeiro exige que o usuário primeiro se registre como cliente do servidor. O servidor fornecerá ao usuário uma conta de login e senha e se conectará ao servidor com base na conta e senha. Este último exige que os usuários usem os nomes de usuário especiais "anônimo" e "convidado" sem se registrar para ter acesso restrito a arquivos públicos em hosts remotos. Muitos sistemas agora exigem que os usuários usem seus endereços de e-mail como senha. Por motivos de segurança, a maioria dos hosts FTP anônimos geralmente permitem apenas que usuários remotos baixem arquivos, mas não os carreguem. Isso dependerá das configurações do servidor FTP. Os usuários podem optar por usar dois métodos de acordo com as condições reais. Após o login, use o método binary() do FtpClient para inicializar o modo de transmissão para o modo byte. upload() completa a função de upload de arquivo. Crie o fluxo de entrada do arquivo FileInputStream do arquivo de origem, grave o fluxo de entrada na matriz de bytes e use o método write de TelnetOutputStream para gravar os dados na matriz de bytes em um link de rede. Como o TelnetOutputStream abre um arquivo no servidor FTP, os dados são gravados no arquivo de destino, completando assim o upload do arquivo. closeConnect() requer desconexão do servidor.
O acima é apenas o processo de upload de um único arquivo. Se houver vários arquivos, esse processo de upload pode ser chamado várias vezes. A partir dos dois métodos acima, podemos ver que usar o protocolo FTP para fazer upload de vários arquivos é relativamente simples e fácil de implementar. Usar o protocolo FTP para fazer upload de arquivos geralmente é um programa do lado do cliente, e as configurações de segurança do lado do servidor serão mais complicadas, enquanto usar o protocolo HTTP para fazer upload de arquivos é um aplicativo do lado do servidor, e as configurações de segurança serão relativamente simples; . E por meio de testes, descobriu-se que o método de upload FTP é dezenas ou até centenas de vezes mais rápido que o método de upload HTTP ao transmitir arquivos grandes, mas é um pouco mais lento que o método de upload HTTP ao transmitir arquivos menores que 1M. Portanto, ambos os métodos de transmissão têm as suas próprias vantagens. Os leitores são aconselhados a agir de acordo com as suas próprias circunstâncias. Se você tiver alguma dúvida ou precisar do código-fonte de outras partes, entre em contato comigo!