本文目录
- java文件怎么传输
- java如何实现文件上传
- java怎么把文件传输到服务器
- java怎么把文件传输到file
- JAVA 传输文件
- 用Java实现在两台电脑之间的文件传输
- Java 文件传输
- java传输大文件
- JAVA实现文件夹传输
- java中怎样上传文件
java文件怎么传输
你是什么手机？？
一般都是直接进应用的，如果不是就得进下载文件的文件夹，还有一些手机在传输的无文件夹，还有一些国产机和山寨机用不了Java，得用.mrp文件！
java如何实现文件上传
public static int transFile(InputStream in, OutputStream out, int fileSize) {
int receiveLen = 0;
final int bufSize = 1000;
try {
byte buf = new byte[bufSize];
int len = 0;
while(fileSize - receiveLen 》 bufSize)
{
len = in.read(buf);
out.write(buf, 0, len);
out.flush();
receiveLen += len;
System.out.println(len);
}
while(receiveLen 《 fileSize)
{
len = in.read(buf, 0, fileSize - receiveLen);
System.out.println(len);
out.write(buf, 0, len);
receiveLen += len;
out.flush();
}
} catch (IOException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
return receiveLen;
}
这个方法从InputStream中读取内容，写到OutputStream中。
那么发送文件方，InputStream就是FileInputStream，OutputStream就是Socket.getOutputStream.
接受文件方，InputStream就是Socket.getInputStream,OutputStream就是FileOutputStream。
就OK了。 至于存到数据库里嘛，Oracle里用Blob。搜索一下，也是一样的。从Blob能获取一个输出流。
java怎么把文件传输到服务器
String realpath = ServletActionContext.getServletContext().getRealPath(“/upload“) ;//获取服务器路径
String targetFileName = uploadFileName;
for (int i = 0; i 《 upload.length; i++) {
File target = new File(realpath, targetFileName[i]);
FileUtils.copyFile(upload[i], target);
//这是一个文件复制类copyFile()里面就是IO操作，如果你不用这个类也可以自己写一个IO复制文件的类
}
其中private File upload;// 实际上传文件
private String uploadContentType; // 文件的内容类型
private String uploadFileName; // 上传文件名
这三个参数必须这样命名，因为文件上传控件默认是封装了这3个参数的，且在action里面他们应有get，set方法
java怎么把文件传输到file
common-fileupload是jakarta项目组开发的一个功能很强大的上传文件组件
下面先介绍上传文件到服务器（多文件上传）：
import javax.servlet.*;
import javax.servlet.
这样就实现了上传文件至数据库
JAVA 传输文件
//以前写的一个文件传输的小程序，有客户端和服务器端两部分，服务器可//以一直运行，客户端传输完一个后退出，当然你也可以根据你的需要改。
//服务器端可以支持多个客户端同时上传，用到了多线程
/**
* 文件传输，客户端
* @aurth anyx
*/
//package per.anyx.ftp;
import java.net.*;
import java.io.*;
public class FtpClient{
public static void main(String args){
if(args.length != 3){
System.out.println(“Usage: FtpClient host_add host_port src_file“);
System.exit(0);
}
File file = new File(args);
if(!file.exists() || !file.isFile()){
System.out.println(“File \““ + args + “\“ does not exist or is not a normal file.“);
System.exit(0);
}
Socket s = null;
FileInputStream in = null;
OutputStream out = null;
try{
s = new Socket(args, Integer.parseInt(args));
in = new FileInputStream(file);
out = s.getOutputStream();
byte buffer = new byte[1024*8];
int len = -1;
System.out.println(“File tansfer statr...“);
while((len=in.read(buffer)) != -1){
out.write(buffer, 0, len);
}
System.out.println(“File tansfer complete...“);
}catch(Exception e){
System.out.println(“Error: “ + e.getMessage());
System.exit(1);
}finally{
try{
if(in != null) in.close();
if(out != null) out.close();
if(s != null) s.close();
}catch(Exception e){}
}
}
}
/**
* 文件传输，服务器端
* @aurth anyx
*/
//package per.anyx.ftp;
import java.net.*;
import java.io.*;
public class FtpServer{
public static void main(String args){
if(args.length != 1){
System.out.println(“Usage: FtpServer server_port“);
System.exit(0);
}
ServerSocket ss = null;
try{
ss = new ServerSocket(Integer.parseInt(args));
System.out.println(“FtpServer start on port ...“ + args);
while(true){
Socket s = ss.accept();
new FtpThread(s).start();
System.out.println(s.getInetAddress().getHostAddress() + “ connected.“);
}
}catch(Exception e){
System.out.println(“Error: “ + e.getMessage());
}finally{
try{
if(ss != null) ss.close();
}catch(Exception e){}
}
}
}
class FtpThread extends Thread{
Socket s;
long fileName = 0;
public FtpThread(Socket s){
this.s = s;
}
public void run(){
FileOutputStream out = null;
InputStream in = null;
File file = null;
do{
file = new File(““ + (fileName++));
}while(file.exists());
try{
out = new FileOutputStream(file);
in = s.getInputStream();
byte buffer = new byte[1024*8];
int len = -1;
while((len=in.read(buffer)) != -1){
out.write(buffer, 0, len);
}
}catch(Exception e){
System.out.println(“Error: “ + e.getMessage());
}finally{
try{
if(in != null) in.close();
if(out != null) out.close();
if(s != null) s.close();
System.out.println(s.getInetAddress().getHostAddress() + “ connect closed..“);
}catch(Exception e){}
}
}
}
用Java实现在两台电脑之间的文件传输
使用Socket可以做到，不过直接编程一般都是在局域网内，如果要在不同局域网间通信，需要使用一台有公网IP的服务器，可以电脑A和电脑B同时连接服务器，然后A向服务器传递文件，服务器再将文件转发电脑B。也可以使用打洞的方式使A、B互联，此时服务器的作用是辅助打洞。A、B向服务器发送信息后socket不要关闭（假设使用10989端口），同时使用Serversocket绑定监听相同的端口（监听10989端口）。在java中有参数可以做到，具体方法请自行百度。服务器获取到A、B的外网地址和端口，将A的外网地址信息发送给B、将B的外网地址信息发送给A。然后使用A没有关闭的Socket向B发送一组信息（此时连接会失败，但是B的路由表上已经记录了A的信息），发送后A向服务器发送消息，服务器告诉B A已经发送消息。然后B使用未关闭的socket向A发送消息，就和A上监听的ServerSocket取得连接了。之后就可以互相传递数据。
Java 文件传输
byte
buf
=
new
byte;
//read是输入流中的一个方法，判断流中是否还有数据，c!=-1就意味着流中无数据，所以应跳出循环,跟溢出没关系
while((c
=
fis.read(buf))!
=-1){
fos.write(buf,o,c);//读一字节写一字节
}
java传输大文件
package sockettest;
import java.io.*;
import java.net.*;
import java.lang.Thread;
public class Client extends Thread{
private char buffer=new char;
private Socket socket=null;
private String localIP=““;
private String farIP=““;
private int localPort=8765;
private int farPort=0;
private InputStream inKeyboard=System.in;
private InputStreamReader readKeyboard=new InputStreamReader(inKeyboard);
private BufferedReader getKeyboard=new BufferedReader(readKeyboard); //得到键盘输入的数据
private InputStream in=null;
private FileInputStream inFile=null;
private InputStreamReader inRead=null;
private BufferedReader read=null;
private OutputStream out=null;
private FileOutputStream outFile=null;
private OutputStreamWriter outWrite=null;
private BufferedWriter write=null;
private int timeout=30000;
public void clearBuffer(){
for(int i=0;i《buffer.length;i++)
buffer[i]=0;
}
public Client()throws Exception {
socket=new Socket();
}
public Client(String ip,int port)throws Exception{
socket=new Socket(ip,port);
localIP=socket.getLocalAddress().getHostAddress();
localPort=socket.getLocalPort();
}
public void bind(String ip,int port)throws Exception{ //绑定工作
SocketAddress serverAddr=new InetSocketAddress(ip,port);
socket.bind(serverAddr);
localIP=socket.getLocalAddress().getHostAddress();
localPort=socket.getLocalPort();
}
public void setTimeout(int time)throws Exception{
timeout=time;
socket.setSoTimeout(timeout);
}
public void begin()throws Exception{ //开始输入输出的变更封装
in=socket.getInputStream();
inRead=new InputStreamReader(in);
read=new BufferedReader(inRead);
out=socket.getOutputStream();
outWrite=new OutputStreamWriter(out);
write=new BufferedWriter(outWrite);
}
public void writeFromKeyboard()throws Exception{ //使用键盘的输入写到套接字连接 :限制每次128个字节
String s=““;
s=getKeyboard.readLine();
write.write(s);
write.flush();
}
public void writeFromFile(String filePath,long off,int len)throws Exception{ //将文件里的内容写到套接字连接，参数：文件，开始，长度
inFile=new FileInputStream(filePath);
InputStreamReader i=new InputStreamReader(inFile);
BufferedReader r=new BufferedReader(i);
r.skip(off);
char data=new char[len];
int num=r.read(data);
r.close();
write.write(data,0,num);
write.flush();
}
public String readToPrint()throws Exception{ //读取套接字连接里的内容，显示到屏幕 ：限制1024个字节
clearBuffer();
int num=read.read(buffer);
String s=String.valueOf(buffer,0,num);
return s;
}
public void readToFile(String filePath,boolean on)throws Exception{ //将读取的数据写到套接字连接中 参数：文件名， true(添加)
outFile=new FileOutputStream(filePath,on);
OutputStreamWriter o=new OutputStreamWriter(outFile);
BufferedWriter w=new BufferedWriter(o);
clearBuffer();
int num=read.read(buffer);
String s=String.valueOf(buffer,0,num);
w.write(s);
w.flush();
}
public void closeLink()throws Exception{ //关闭当前套接字连接
socket.close();
}
public String getLocalIP()throws Exception{ //返回本地地址
return localIP;
}
public int getLocalPort()throws Exception{ //返回本地端口
return localPort;
}
public String getFarIP()throws Exception{ //返回远程主机地址
farIP=socket.getInetAddress().getHostAddress();
return farIP;
}
public int getFarPort()throws Exception{ //返回远程主机端口
farPort=socket.getPort();
return farPort;
}
public void setBufferSize(int size){
buffer=new char[size];
}
}
---------------------------------------------------
package sockettest;
import java.io.*;
import java.net.*;
import java.lang.Thread;
public class Server extends Thread{
private char buffer=new char;
private ServerSocket server=null;
private Socket socket=null;
private String localIP=““;
private String farIP=““;
private int localPort=8765;
private int farPort=0;
private InputStream inKeyboard=System.in;
private InputStreamReader readKeyboard=new InputStreamReader(inKeyboard);
private BufferedReader getKeyboard=new BufferedReader(readKeyboard); //得到键盘输入的数据
private InputStream in=null;
private FileInputStream inFile=null;
private InputStreamReader inRead=null;
private BufferedReader read=null;
private OutputStream out=null;
private FileOutputStream outFile=null;
private OutputStreamWriter outWrite=null;
private BufferedWriter write=null;
private int timeout=30000;
public void clearBuffer(){
for(int i=0;i《buffer.length;i++)
buffer[i]=0;
}
public Server(String ip,int port) throws Exception{ //参数：服务器地址 端口
SocketAddress serverAddr=new InetSocketAddress(ip,port);
server=new ServerSocket();
server.bind(serverAddr);
server.setSoTimeout(timeout);
}
public Server()throws Exception{
SocketAddress serverAddr=new InetSocketAddress(“127.0.0.1“,8765);
server=new ServerSocket();
server.bind(serverAddr);
server.setSoTimeout(timeout);
}
public void bind(String ip,int port)throws Exception{ //绑定工作
SocketAddress serverAddr=new InetSocketAddress(ip,port);
server.bind(serverAddr);
}
public void accept()throws Exception{ //开始侦听端口
socket= server.accept();
localIP=socket.getLocalAddress().getHostAddress();
localPort=socket.getLocalPort();
}
public void setTimeout(int time)throws Exception{
timeout=time;
server.setSoTimeout(timeout);
}
public void begin()throws Exception{ //开始输入输出的变更封装
in=socket.getInputStream();
inRead=new InputStreamReader(in);
read=new BufferedReader(inRead);
out=socket.getOutputStream();
outWrite=new OutputStreamWriter(out);
write=new BufferedWriter(outWrite);
}
public void writeFromKeyboard()throws Exception{ //使用键盘的输入写到套接字连接 :限制每次128个字节
String s=““;
s=getKeyboard.readLine();
write.write(s);
write.flush();
}
public void writeFromFile(String filePath,long off,int len)throws Exception{ //将文件里的内容写到套接字连接，参数：文件，开始，长度
inFile=new FileInputStream(filePath);
InputStreamReader i=new InputStreamReader(inFile);
BufferedReader r=new BufferedReader(i);
r.skip(off);
char data=new char[len];
int num=r.read(data);
r.close();
write.write(data,0,num);
write.flush();
}
public String readToPrint()throws Exception{ //读取套接字连接里的内容，显示到屏幕 ：限制1024个字节
clearBuffer();
int num=read.read(buffer);
String s=String.valueOf(buffer,0,num);
return s;
}
public void readToFile(String filePath,boolean on)throws Exception{ //将读取的数据写到套接字连接中 参数：文件名， true(添加)
outFile=new FileOutputStream(filePath,on);
OutputStreamWriter o=new OutputStreamWriter(outFile);
BufferedWriter w=new BufferedWriter(o);
clearBuffer();
int num=read.read(buffer);
String s=String.valueOf(buffer,0,num);
w.write(s);
w.flush();
}
public void closeLink()throws Exception{ //关闭当前套接字连接
socket.close();
}
public void closeServer()throws Exception{ //关闭套接字服务器
server.close();
}
public String getLocalIP()throws Exception{ //返回本地地址
return localIP;
}
public int getLocalPort()throws Exception{ //返回本地端口
return localPort;
}
public String getFarIP()throws Exception{ //返回远程主机地址
farIP=socket.getInetAddress().getHostAddress();
return farIP;
}
public int getFarPort()throws Exception{ //返回远程主机端口
farPort=socket.getPort();
return farPort;
}
public void setBufferSize(int size){
buffer=new char[size];
}
}
JAVA实现文件夹传输
//这是一个传输的程序.下面是两个程序,一个名为MyClient,
//是客户端.另一个名为MyServer,为服务器端.这两个程序实现的
//是将客户端的e盘名为“1“的文件夹里的所有内容传输到服务器端
//的e盘名为“2“的文件夹里.运行时,一定要先运行MyServer,否则会
//出错.这个程序我用两台电脑在局域网里运行过多次,一切正常,速度
//在600KB/s左右.如果运行MyServer后,再运行MyClient时,出现错误
//建议再运行一下.因为它们可能在建立连接时由于网络连接不好而
//未能连接成功而出错.程序是肯定没有问题的.
import java.io.*;
import java.net.*;
public class MyClient
{
Socket client;
boolean flag=true;
FileInputStream fis;//此输入流负责读取本机上要传输的文件
DataOutputStream dos;//此输出流负责向另一台电脑(服务器端)传输数据
DataInputStream dis;//此输入流负责读取另一台电脑的回应信息
public static void main(String args)
{
new MyClient().ClientStart();
}
public void ClientStart()
{
try
{
client=new Socket(“192.168.2.101“,30000);//服务器端的IP,(这个只是在局域网内的)我的是这个,你的根据实际而定
//client=new Socket(“localhost“,30000);
System.out.println(“已连接“);
dos=new DataOutputStream(client.getOutputStream());
dis=new DataInputStream(client.getInputStream());
transmit(new File(“e:\\1\\“));
String s=“/]00“;//提示传输完毕的标记
byte b=s.getBytes();
dos.write(b,0,s.length());
dos.flush();
}
catch(IOException e)
{
System.out.println(“Error“);
}
}
public void transmit(File f)throws IOException//这是传输的核心,而且将被递归
{
byte b;
String ts;
int ti;
for(File f1:f.listFiles())
{ //首先通过if语句判断f1是文件还是文件夹
if(f1.isDirectory()) //fi是文件夹,则向服务器端传送一条信息
{
ts=“/]0f“+(f1.getPath().replace(“e:\\1\\“,““));//“/]0f“用于表示这条信息的内容是文件夹名称
b=ts.getBytes();
dos.write(b);
dos.flush();
dis.read();
transmit(f1);//由于f1是文件夹(即目录),所以它里面很有可能还有文件或者文件夹,所以进行递归
}
else
{
fis=new FileInputStream(f1);
ts=“/]0c“+(f1.getPath().replace(“e:\\1\\“,““));//同上,表示这是一个文件的名称
b=ts.getBytes();
dos.write(b);
dos.flush();
dis.read();
dos.writeInt(fis.available());//传输一个整型值,指明将要传输的文件的大小
dos.flush();
dis.read();
b=new byte;
while(fis.available()》0)//开始传送文件
{
ti=fis.read(b);
dos.write(b,0,ti);
dos.flush();
}
dos.flush();
fis.close();
dis.read();
}
}
}
}
import java.io.*;
import java.net.*;
public class MyServer
{
ServerSocket server=null;
Socket client=null;
boolean flag=true;
DataInputStream dis;
DataOutputStream dos;
FileOutputStream fos;
public static void main(String args)
{
new MyServer().ServerStart();
}
public void ServerStart()
{
try
{
server=new ServerSocket(30000);
System.out.println(“端口号:“+server.getLocalPort());
client=server.accept();
System.out.println(“连接完毕“);
dis=new DataInputStream(client.getInputStream());
dos=new DataOutputStream(client.getOutputStream());
String answer=“g“;
byte ans=answer.getBytes();
byte b=new byte;
int ti;
new File(“e:\\2“).mkdirs();
while(flag)
{
ti=dis.read(b);
dos.write(ans);
String select=new String(b,0,ti);
if(select.contains(“/]0f“))
{
File f=new File(“e:\\2\\“+(select.replace(“/]0f“,““)));
System.out.println(“creat directory“);
f.mkdirs();
}
else if(select.contains(“/]0c“))
{
fos=new FileOutputStream(“e:\\2\\“+(select.replace(“/]0c“,““)));
String cs;
boolean cflag=true;
int tip=dis.readInt();
dos.write(ans);
while(tip》0)
{
ti=dis.read(b,0,(tip》1000?1000:tip));
tip=tip-ti;
cs=new String(b,0,4);
fos.write(b,0,ti);
}
fos.flush();
fos.close();
dos.write(ans);
}
else if(select.contains(“/]00“))
{
flag=false;
}
}
dis.close();
client.close();
server.close();
}
catch(IOException e)
{
System.out.println(“Error“);
}
}
}
java中怎样上传文件
Java代码实现文件上传
FormFile file=manform.getFile();
String newfileName = null;
String newpathname=null;
String fileAddre=“/numUp“;
try {
InputStream stream = file.getInputStream();// 把文件读入
String filePath = request.getRealPath(fileAddre);//取系统当前路径
File file1 = new File(filePath);//添加了自动创建目录的功能
((File) file1).mkdir();
newfileName = System.currentTimeMillis()
+ file.getFileName().substring(
file.getFileName().lastIndexOf(’.’));
ByteArrayOutputStream baos = new ByteArrayOutputStream();
OutputStream bos = new FileOutputStream(filePath + “/“
+ newfileName);
newpathname=filePath+“/“+newfileName;
System.out.println(newpathname);
// 建立一个上传文件的输出流
System.out.println(filePath+“/“+file.getFileName());
int bytesRead = 0;
byte buffer = new byte;
while ((bytesRead = stream.read(buffer, 0, 8192)) != -1) {
bos.write(buffer, 0, bytesRead);// 将文件写入服务器
}
bos.close();
stream.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
