Mina上传文件的服务端实现

实现步骤：

   1.建立一个无阻塞服务端socket 用nio
        NioSocketAcceptor acceptor = new NioSocketAcceptor();
   2.创建接收过滤器 也就是你要传送对象的类型
        DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();

   3.设定 对象传输工厂
   4.设定传输最大值
        factory.setDecoderMaxObjectSize(Integer.MAX_VALUE);// 设定后服务器可以接收大数据
        factory.setEncoderMaxObjectSize(Integer.MAX_VALUE);
        chain.addLast("logging", new LoggingFilter());// 这个用于打印日志 可以不写
  5.设定服务端消息处理器, 将线程放入线程池 当连接很多时候可以通过线程池处理
        threadPool.execute(new IoStreamThreadWork(in, fos));

package cn.org.handler;

/**
 * mina上传文件的服务端
 * @author changyaobin
 *
 */
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;

import cn.org.util.IoStreamThreadWork;

/**
 * @author changyaobin
 */
public class MinaFileServer extends StreamIoHandler {
	public static final int PORT = 8888;
	public static final String PATH="F:\\test1\\";
	public static final String SUFFIX=".mp3";
	@Override
	public void sessionOpened(IoSession session) {
		System.out.println("客户端连接了:" + session.getRemoteAddress());
		super.sessionOpened(session);
	}
	@Override
	protected void processStreamIo(IoSession session, InputStream in,
			OutputStream out) {
		// 设定一个线程池
		// 参数说明：最少数量3，最大数量6 空闲时间 3秒  timeUnit 时间单位
		ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3, 6, 3,
				TimeUnit.SECONDS,
				// 缓冲队列为3
				new ArrayBlockingQueue<Runnable>(3),
				// 抛弃旧的任务
				new ThreadPoolExecutor.DiscardOldestPolicy());
		FileOutputStream fos = null;
		
		String filePath=Thread.currentThread().getName()+System.currentTimeMillis();
		File receiveFile = new File(PATH+filePath+SUFFIX);
		try {
			System.out.println(filePath);
			fos = new FileOutputStream(receiveFile);
		} catch (FileNotFoundException e1) {
			e1.printStackTrace();
		}
		// 将线程放入线程池 当连接很多时候可以通过线程池处理
		threadPool.execute(new IoStreamThreadWork(in, fos));
	}

	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(PORT);
			acceptor.bind(inetSocketAddress);
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println("文件服务器已经开启：" + PORT);
	}
	
}

接下来，编写IoStreamThreadWork类处理文件接收

package cn.org.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

  
/** 
 * 用于mina 服务器上传下载 
 * 流处理线程公共类 
 * @author changyaobin
 * 
 */  
public class IoStreamThreadWork extends Thread{  
    public static final int BUFFER_SIZE = 1024*1000;  
    private static final int fileHeadCheckSiteStart = 30;//此处代表字节
    private static final int fileHeadCheckSiteLength = 2;//此处代表字节
	private static String path = "resources";
    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;  
        StringBuffer hexs = new StringBuffer(); 
        DecodeFile decodeFile = null;
        try {  
        	while((tempData = bis.read(bufferByte)) != -1 ){  
                bos.write(bufferByte, 0, tempData);  
                //转储为16进制字符串数组
                //注：字节转换为16进制字符串，1个字节变两个16进制字符串
                String[] hexTemps = Bytes2AllType.bytes2Hexs(bufferByte, 0, tempData);
                for (String str : hexTemps) {
					hexs.append(str);
				}
            }  

            try {  
                bos.flush();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        } catch (InstantiationException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} catch (IllegalAccessException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}finally{  
            try {  
                bos.close();  
                bis.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}