mina下传文件

mina上传文件
mina传输对象已经不是什么难事，一般啃半天代码就能搞定，但是传输文件似乎不是很容易，之前在论坛上求助过但是没有解决，还是靠自己啃代码解决了文件的上传和下载，以下只是随便测试写的代码供学习用（只是有很多朋友发邮件求代码思路这里我也就公布了，之前一直没有办法上网实在不好意思之前发邮件到 qyhdt@sina.com邮箱求解的朋友们，我在这里给你们答案了实在不好意思），希望与大家一起探讨mina更多的强大功能。对于mina我也是个初学者。
首先我们创建一个上传下载公共文件流线程类
Java代码  收藏代码

   1. package com.rose.common.frame.mina; 
   2.  
   3. import java.io.BufferedInputStream; 
   4. import java.io.BufferedOutputStream; 
   5. import java.io.IOException; 
   6. import java.io.InputStream; 
   7. import java.io.OutputStream; 
   8.  
   9. /**
  10.  * 用于mina 服务器上传下载
  11.  * 流处理线程公共类
  12.  * @author qiuy
  13.  *
  14.  */ 
  15. public class IoStreamThreadWork extends Thread{ 
  16.     public static final int BUFFER_SIZE = 1024*2; 
  17.      
  18.     private BufferedInputStream bis; 
  19.     private BufferedOutputStream bos; 
  20.      
  21.      
  22.     public BufferedInputStream getBis() { 
  23.         return bis; 
  24.     } 
  25.  
  26.     public void setBis(BufferedInputStream bis) { 
  27.         this.bis = bis; 
  28.     } 
  29.  
  30.     public BufferedOutputStream getBos() { 
  31.         return bos; 
  32.     } 
  33.  
  34.     public void setBos(BufferedOutputStream bos) { 
  35.         this.bos = bos; 
  36.     } 
  37.  
  38.     public IoStreamThreadWork(InputStream in, OutputStream os){ 
  39.         bis = new BufferedInputStream(in); 
  40.         bos = new BufferedOutputStream(os); 
  41.     } 
  42.     public synchronized void run() { 
  43.         byte[] bufferByte = new byte[BUFFER_SIZE]; 
  44.         int tempData = 0; 
  45.         try { 
  46.             while((tempData = bis.read(bufferByte)) != -1 ){ 
  47.                 bos.write(bufferByte, 0, tempData); 
  48.             } 
  49.             try { 
  50.                 bos.flush(); 
  51.             } catch (IOException e) { 
  52.                 e.printStackTrace(); 
  53.             } 
  54.         } catch (IOException e) { 
  55.             e.printStackTrace(); 
  56.         }finally{ 
  57.             try { 
  58.                 bos.close(); 
  59.                 bis.close(); 
  60.             } catch (IOException e) { 
  61.                 e.printStackTrace(); 
  62.             } 
  63.         } 
  64.     } 
  65. } 

package com.rose.common.frame.mina;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
* 用于mina 服务器上传下载
* 流处理线程公共类
* @author qiuy
*
*/
public class IoStreamThreadWork extends Thread{
public static final int BUFFER_SIZE = 1024*2;

private BufferedInputStream bis;
private BufferedOutputStream bos;


public BufferedInputStream getBis() {
return bis;
}

public void setBis(BufferedInputStream bis) {
this.bis = bis;
}

public BufferedOutputStream getBos() {
return bos;
}

public void setBos(BufferedOutputStream bos) {
this.bos = bos;
}

public IoStreamThreadWork(InputStream in, OutputStream os){
bis = new BufferedInputStream(in);
bos = new BufferedOutputStream(os);
}
public synchronized void run() {
byte[] bufferByte = new byte[BUFFER_SIZE];
int tempData = 0;
try {
while((tempData = bis.read(bufferByte)) != -1 ){
bos.write(bufferByte, 0, tempData);
}
try {
bos.flush();
} catch (IOException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
bos.close();
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}


写一个服务器端
Java代码  收藏代码

   1. package com.rose.common.frame.mina; 
   2.  
   3. import java.io.File; 
   4. import java.io.FileNotFoundException; 
   5. import java.io.FileOutputStream; 
   6. import java.io.IOException; 
   7. import java.io.InputStream; 
   8. import java.io.OutputStream; 
   9. import java.net.InetSocketAddress; 
  10. import java.util.concurrent.ArrayBlockingQueue; 
  11. import java.util.concurrent.ThreadPoolExecutor; 
  12. import java.util.concurrent.TimeUnit; 
  13.  
  14. import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder; 
  15. import org.apache.mina.core.session.IoSession; 
  16. import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory; 
  17. import org.apache.mina.filter.logging.LoggingFilter; 
  18. import org.apache.mina.handler.stream.StreamIoHandler; 
  19. import org.apache.mina.transport.socket.nio.NioSocketAcceptor; 
  20.  
  21. /**
  22.  * @author qiuy
  23.  * 文件传输服务器
  24.  */ 
  25. public class MinaFileServer extends StreamIoHandler{ 
  26.     public static final int PORT = 8888; 
  27.     @Override 
  28.     public void sessionOpened(IoSession session) { 
  29.         System.out.println("客户端连接了:"+session.getRemoteAddress()); 
  30.         super.sessionOpened(session); 
  31.     } 
  32.  
  33.     protected void processStreamIo(IoSession session, InputStream in,OutputStream out) { 
  34.         //设定一个线程池 
  35.         //参数说明：最少数量3，最大数量6 空闲时间 3秒 
  36.         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3, 6, 3,TimeUnit.SECONDS,  
  37.                 //缓冲队列为3 
  38.                 new ArrayBlockingQueue<Runnable>(3), 
  39.                 //抛弃旧的任务 
  40.                 new ThreadPoolExecutor.DiscardOldestPolicy()); 
  41.         FileOutputStream fos = null; 
  42.         File receiveFile = new File("e:\\test.pdf"); 
  43.         try { 
  44.             fos = new FileOutputStream(receiveFile); 
  45.         } catch (FileNotFoundException e1) { 
  46.             e1.printStackTrace(); 
  47.         } 
  48.         //将线程放入线程池 当连接很多时候可以通过线程池处理 
  49.         threadPool.execute(new IoStreamThreadWork(in,fos)); 
  50.         //直接启动线程 连接很少可以选用下面 
  51. //      new IoStreamThreadWork(in,fos).start(); 
  52.     } 
  53.      
  54.     public void createServerStream(){ 
  55.         //建立一个无阻塞服务端socket 用nio 
  56.         NioSocketAcceptor acceptor = new NioSocketAcceptor(); 
  57.         //创建接收过滤器 也就是你要传送对象的类型 
  58.         DefaultIoFilterChainBuilder chain = acceptor.getFilterChain(); 
  59.         //===========过滤器创建好了就开始设定============ 
  60.          
  61.         //设定 对象传输工厂 
  62.         ObjectSerializationCodecFactory factory = new ObjectSerializationCodecFactory(); 
  63.         //设定传输最大值 
  64.         factory.setDecoderMaxObjectSize(Integer.MAX_VALUE);// 设定后服务器可以接收大数据 
  65.         factory.setEncoderMaxObjectSize(Integer.MAX_VALUE); 
  66.         chain.addLast("logging", new LoggingFilter());//这个用于打印日志 可以不写 
  67.         //设定服务端消息处理器 
  68.         acceptor.setHandler(new MinaFileServer()); 
  69.         InetSocketAddress inetSocketAddress = null; 
  70.         try { 
  71.             inetSocketAddress = new InetSocketAddress(8888); 
  72.             acceptor.bind(inetSocketAddress); 
  73.         } catch (IOException e) { 
  74.             // TODO Auto-generated catch block 
  75.             e.printStackTrace(); 
  76.         } 
  77.         System.out.println("文件服务器已经开启："+8888); 
  78.     } 
  79.     public static void main(String[] args) { 
  80.         MinaFileServer server = new MinaFileServer(); 
  81.         server.createServerStream(); 
  82.     } 
  83. } 

package com.rose.common.frame.mina;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.handler.stream.StreamIoHandler;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;

/**
* @author qiuy
* 文件传输服务器
*/
public class MinaFileServer extends StreamIoHandler{
public static final int PORT = 8888;
@Override
public void sessionOpened(IoSession session) {
System.out.println("客户端连接了:"+session.getRemoteAddress());
super.sessionOpened(session);
}

protected void processStreamIo(IoSession session, InputStream in,OutputStream out) {
//设定一个线程池
//参数说明：最少数量3，最大数量6 空闲时间 3秒
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3, 6, 3,TimeUnit.SECONDS,
//缓冲队列为3
new ArrayBlockingQueue<Runnable>(3),
//抛弃旧的任务
new ThreadPoolExecutor.DiscardOldestPolicy());
FileOutputStream fos = null;
File receiveFile = new File("e:\\test.pdf");
try {
fos = new FileOutputStream(receiveFile);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
}
//将线程放入线程池 当连接很多时候可以通过线程池处理
threadPool.execute(new IoStreamThreadWork(in,fos));
//直接启动线程 连接很少可以选用下面
//new IoStreamThreadWork(in,fos).start();
}

public void createServerStream(){
//建立一个无阻塞服务端socket 用nio
NioSocketAcceptor acceptor = new NioSocketAcceptor();
//创建接收过滤器 也就是你要传送对象的类型
DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
//===========过滤器创建好了就开始设定============

//设定 对象传输工厂
ObjectSerializationCodecFactory factory = new ObjectSerializationCodecFactory();
//设定传输最大值
factory.setDecoderMaxObjectSize(Integer.MAX_VALUE);// 设定后服务器可以接收大数据
factory.setEncoderMaxObjectSize(Integer.MAX_VALUE);
chain.addLast("logging", new LoggingFilter());//这个用于打印日志 可以不写
//设定服务端消息处理器
acceptor.setHandler(new MinaFileServer());
InetSocketAddress inetSocketAddress = null;
try {
inetSocketAddress = new InetSocketAddress(8888);
acceptor.bind(inetSocketAddress);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("文件服务器已经开启："+8888);
}
public static void main(String[] args) {
MinaFileServer server = new MinaFileServer();
server.createServerStream();
}
}


再写一个客户端
Java代码  收藏代码

   1. package com.rose.common.frame.mina; 
   2.  
   3. import java.io.File; 
   4. import java.io.FileInputStream; 
   5. import java.io.FileNotFoundException; 
   6. import java.io.InputStream; 
   7. import java.io.OutputStream; 
   8. import java.net.InetSocketAddress; 
   9.  
  10. import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder; 
  11. import org.apache.mina.core.future.ConnectFuture; 
  12. import org.apache.mina.core.session.IoSession; 
  13. import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory; 
  14. import org.apache.mina.filter.logging.LoggingFilter; 
  15. import org.apache.mina.handler.stream.StreamIoHandler; 
  16. import org.apache.mina.transport.socket.nio.NioSocketConnector; 
  17.  
  18.  
  19. /**
  20.  * @author qiuy
  21.  * 文件传输客户端 
  22.  */ 
  23. public class MinaFileClient extends StreamIoHandler{ 
  24.     IoSession session; 
  25.     public void setSession(IoSession session) { 
  26.         this.session = session; 
  27.     } 
  28.     public IoSession getSession() { 
  29.         return session;   
  30.     } 
  31.     @Override 
  32.     protected void processStreamIo(IoSession session, InputStream in, 
  33.             OutputStream out) { 
  34.         //客户端发送文件 
  35.             File sendFile = new File("F:\\ttt.pdf"); 
  36.             FileInputStream fis = null; 
  37.             try { 
  38.                 fis = new FileInputStream(sendFile); 
  39.                  
  40.             } catch (FileNotFoundException e) { 
  41.                 e.printStackTrace(); 
  42.             } 
  43.             //放入线程让其执行 
  44.              //客户端一般都用一个线程实现即可 不用线程池 
  45.             new IoStreamThreadWork(fis,out).start(); 
  46.             return; 
  47.     } 
  48.      
  49.     public void createClienStream(){ 
  50.         int port = 8888; 
  51.         String local = "127.0.0.1"; 
  52.          
  53.         NioSocketConnector connector = new NioSocketConnector(); 
  54.         DefaultIoFilterChainBuilder chain = connector.getFilterChain(); 
  55.         ObjectSerializationCodecFactory factory = new ObjectSerializationCodecFactory(); 
  56.         factory.setDecoderMaxObjectSize(Integer.MAX_VALUE); 
  57.         factory.setEncoderMaxObjectSize(Integer.MAX_VALUE); 
  58.         chain.addLast("logging", new LoggingFilter());//用于打印日志可以不写 
  59.         connector.setHandler(new MinaFileClient()); 
  60.         ConnectFuture connectFuture = connector.connect(new InetSocketAddress(local,port)); 
  61.         connectFuture.awaitUninterruptibly();//写上这句为了得到下面的session 意思是等待连接创建完成 让创建连接由异步变同步 
  62.         //后来表明我开始的想法不行 动态依旧不能做到 
  63. //      @SuppressWarnings("unused") 
  64. //      IoSession session = connectFuture.getSession(); 
  65. //      setSession(session); 
  66.     } 
  67.     public static void main(String[] args) { 
  68.         MinaFileClient client = new MinaFileClient(); 
  69.         client.createClienStream(); 
  70.     } 
  71. } 

package com.rose.common.frame.mina;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;

import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.handler.stream.StreamIoHandler;
import org.apache.mina.transport.socket.nio.NioSocketConnector;


/**
* @author qiuy
* 文件传输客户端
*/
public class MinaFileClient extends StreamIoHandler{
IoSession session;
public void setSession(IoSession session) {
this.session = session;
}
public IoSession getSession() {
return session; 
}
@Override
protected void processStreamIo(IoSession session, InputStream in,
OutputStream out) {
//客户端发送文件
File sendFile = new File("F:\\ttt.pdf");
FileInputStream fis = null;
try {
fis = new FileInputStream(sendFile);

} catch (FileNotFoundException e) {
e.printStackTrace();
}
//放入线程让其执行
//客户端一般都用一个线程实现即可 不用线程池
new IoStreamThreadWork(fis,out).start();
return;
}

public void createClienStream(){
int port = 8888;
String local = "127.0.0.1";

NioSocketConnector connector = new NioSocketConnector();
DefaultIoFilterChainBuilder chain = connector.getFilterChain();
ObjectSerializationCodecFactory factory = new ObjectSerializationCodecFactory();
factory.setDecoderMaxObjectSize(Integer.MAX_VALUE);
factory.setEncoderMaxObjectSize(Integer.MAX_VALUE);
chain.addLast("logging", new LoggingFilter());//用于打印日志可以不写
connector.setHandler(new MinaFileClient());
ConnectFuture connectFuture = connector.connect(new InetSocketAddress(local,port));
connectFuture.awaitUninterruptibly();//写上这句为了得到下面的session 意思是等待连接创建完成 让创建连接由异步变同步
//后来表明我开始的想法不行 动态依旧不能做到
//@SuppressWarnings("unused")
//IoSession session = connectFuture.getSession();
//setSession(session);
}
public static void main(String[] args) {
MinaFileClient client = new MinaFileClient();
client.createClienStream();
}
}


ok以上就可以实现客户端上传文件到服务器端 要是读者朋友想看看效果
代码拷贝后 在自己的f盘下放一个ttt.pdf然后运行服务器端，再运行客户端这样在你的e盘下会多出一个叫test.pdf文件。如果要用到具体工程中请自行封装一下代码。
参考：mina的API，网上相关资料。