关于mina的文件上传代码示例

先我们创建一个上传下载公共文件流线程类

Java代码 



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;
  

  

  

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代码 



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;
  

  

  

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代码 



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;
  

  

  

  

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();   

    }   

}