关于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. public class IoStreamThreadWork extends Thread{   
11.     public static final int BUFFER_SIZE = 1024*2;   
12.        
13.     private BufferedInputStream bis;   
14.     private BufferedOutputStream bos;   
15.        
16.        
17.     public BufferedInputStream getBis() {   
18.         return bis;   
19.     }   
20.   
21.     public void setBis(BufferedInputStream bis) {   
22.         this.bis = bis;   
23.     }   
24.   
25.     public BufferedOutputStream getBos() {   
26.         return bos;   
27.     }   
28.   
29.     public void setBos(BufferedOutputStream bos) {   
30.         this.bos = bos;   
31.     }   
32.   
33.     public IoStreamThreadWork(InputStream in, OutputStream os){   
34.         bis = new BufferedInputStream(in);   
35.         bos = new BufferedOutputStream(os);   
36.     }   
37.     public synchronized void run() {   
38.         byte[] bufferByte = new byte[BUFFER_SIZE];   
39.         int tempData = 0;   
40.         try {   
41.             while((tempData = bis.read(bufferByte)) != -1 ){   
42.                 bos.write(bufferByte, 0, tempData);   
43.             }   
44.             try {   
45.                 bos.flush();   
46.             } catch (IOException e) {   
47.                 e.printStackTrace();   
48.             }   
49.         } catch (IOException e) {   
50.             e.printStackTrace();   
51.         }finally{   
52.             try {   
53.                 bos.close();   
54.                 bis.close();   
55.             } catch (IOException e) {   
56.                 e.printStackTrace();   
57.             }   
58.         }   
59.     }   
60. }  

写一个服务器端

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

再写一个客户端

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. public class MinaFileClient extends StreamIoHandler{   
21.     IoSession session;   
22.     public void setSession(IoSession session) {   
23.         this.session = session;   
24.     }   
25.     public IoSession getSession() {   
26.         return session;     
27.     }   
28.     @Override  
29.     protected void processStreamIo(IoSession session, InputStream in,   
30.             OutputStream out) {   
31.         //客户端发送文件   
32.             File sendFile = new File("F:\\ttt.pdf");   
33.             FileInputStream fis = null;   
34.             try {   
35.                 fis = new FileInputStream(sendFile);   
36.                    
37.             } catch (FileNotFoundException e) {   
38.                 e.printStackTrace();   
39.             }   
40.             //放入线程让其执行   
41.              //客户端一般都用一个线程实现即可 不用线程池   
42.             new IoStreamThreadWork(fis,out).start();   
43.             return;   
44.     }   
45.        
46.     public void createClienStream(){   
47.         int port = 8888;   
48.         String local = "127.0.0.1";   
49.            
50.         NioSocketConnector connector = new NioSocketConnector();   
51.         DefaultIoFilterChainBuilder chain = connector.getFilterChain();   
52.         ObjectSerializationCodecFactory factory = new ObjectSerializationCodecFactory();   
53.         factory.setDecoderMaxObjectSize(Integer.MAX_VALUE);   
54.         factory.setEncoderMaxObjectSize(Integer.MAX_VALUE);   
55.         chain.addLast("logging", new LoggingFilter());//用于打印日志可以不写   
56.         connector.setHandler(new MinaFileClient());   
57.         ConnectFuture connectFuture = connector.connect(new InetSocketAddress(local,port));   
58.         connectFuture.awaitUninterruptibly();//写上这句为了得到下面的session 意思是等待连接创建完成 让创建连接由异步变同步   
59.         //后来表明我开始的想法不行 动态依旧不能做到   
60. //      @SuppressWarnings("unused")   
61. //      IoSession session = connectFuture.getSession();   
62. //      setSession(session);   
63.     }   
64.     public static void main(String[] args) {   
65.         MinaFileClient client = new MinaFileClient();   
66.         client.createClienStream();   
67.     }   
68. }