flex mina2.0 AMF3实例(转)

/**
* 类功能描述:通讯服务器
* 类创建人:
* 创建时间：
*/
import java.io.IOException;
import java.net.InetSocketAddress;
import org.apache.mina.core.service.IoAcceptor;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import common.AMF3CodecFactory;
public class ServerMain {
private static final int socketPORT = 10012;
public ServerMain(){
//创建服务端连接
final IoAcceptor acceptor = new NioSocketAcceptor();
//创建日志过滤器进行日志处理
acceptor.getFilterChain().addLast(“logger”, new LoggingFilter());
//创建AMF3编解码过滤器编解码
acceptor.getFilterChain().addLast(“codec”,new ProtocolCodecFilter(new AMF3CodecFactory()));
acceptor.getSessionConfig().setReadBufferSize(2048);
//设置Session空闲时间
acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 60);
//设置消息处理类
acceptor.setHandler(new MessageManage());
try {
//绑定监听端口
acceptor.bind(new InetSocketAddress(socketPORT));
} catch (IOException e) {
System.out.println(“服务器错误:” +e.toString()+e.getMessage());
}
System.out.println(“服务器已启动端口为:” + socketPORT);
}
}
/**
* 类功能描述:通讯服务器FLEX843端口认证解决跨域沙箱安全
* 类创建人:
* 创建时间：
*/
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class AttestationServer implements Runnable {
private ServerSocket server;
private BufferedReader reader;
private BufferedWriter writer;
private static final String securityXml = “<?xml version=’1.0′?>”
+ “<cross-domain-policy> ”
+ “<allow-access-from domain=’*’ to-ports=’10012′/>”
+ “</cross-domain-policy> “;
public AttestationServer() {
createServerSocket(843);
new Thread(this).start();
}
private void createServerSocket(int port) {
try {
server = new ServerSocket(port);
} catch (IOException e) {
System.exit(0);
}
}
public void run() {
while (true) {
Socket client = null;
try {
client = server.accept();
InputStreamReader input = new InputStreamReader(client.getInputStream(), “UTF-8″);
reader = new BufferedReader(input);
OutputStreamWriter output = new OutputStreamWriter(client.getOutputStream(), “UTF-8″);
writer = new BufferedWriter(output);
StringBuilder sb = new StringBuilder();
int request = 0;
while ((request = reader.read()) != -1) {
if (request != ‘\0′) {
sb.append((char) request);
} else
break;
}
String message = sb.toString();
if (message.indexOf(“<policy-file-request/>”) >= 0) {
writer.write(securityXml + “\0″);
writer.flush();
}
client.close();
} catch (Exception e) {
e.printStackTrace();
try {
if (client != null) {
client.close();
client = null;
}
} catch (IOException ex) {
ex.printStackTrace();
} finally {
System.gc();
}
}
}
}
}


package common;
/**
* 类功能描述:AMF3编解码工厂
* 类创建人:
* 创建时间：
*/
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFactory;
import org.apache.mina.filter.codec.ProtocolDecoder;
import org.apache.mina.filter.codec.ProtocolEncoder;
public class AMF3CodecFactory implements ProtocolCodecFactory {
private ProtocolEncoder encoder;
private ProtocolDecoder decoder;
public AMF3CodecFactory() {
encoder = new AMF3Encoder();
decoder = new AMF3Decoder();
}
public ProtocolDecoder getDecoder(IoSession session) throws Exception {
return decoder;
}
public ProtocolEncoder getEncoder(IoSession session) throws Exception {
return encoder;
}
}
package common;
/**
* 类功能描述:对传入消息转解码
* 类创建人:
* 创建时间：
*/
import java.io.DataInputStream;
import java.util.HashMap;
import java.util.zip.InflaterInputStream;
import flex.messaging.io.SerializationContext;
import flex.messaging.io.amf.ASObject;
import flex.messaging.io.amf.Amf3Input;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.CumulativeProtocolDecoder;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;
public class AMF3Decoder extends CumulativeProtocolDecoder {
private SerializationContext context = new SerializationContext();
private final Amf3Input amfin;
public AMF3Decoder() {
amfin = new Amf3Input(context);
}
protected boolean doDecode(IoSession session, IoBuffer in,ProtocolDecoderOutput out) throws Exception {
in.position(0);
amfin.setInputStream(new InflaterInputStream(new DataInputStream(in.asInputStream())));
Object message = amfin.readObject();
if(message instanceof ASObject){
HashMap<?, ?> msgMap = (HashMap<?, ?>) message;
out.write(msgMap);
in.free();
return true;
}
return false;
}
}
package common;
/**
* 类功能描述:对传出消息转装码
* 类创建人:
* 创建时间：
*/
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.zip.Deflater;
import entity.MessageInfo;
import flex.messaging.io.SerializationContext;
import flex.messaging.io.amf.Amf3Output;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.AttributeKey;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolEncoder;
import org.apache.mina.filter.codec.ProtocolEncoderOutput;
public class AMF3Encoder implements ProtocolEncoder {
private final AttributeKey DEFLATER = new AttributeKey(getClass(), “deflater”);
private static int buffersize = 2048;
private final SerializationContext context = new SerializationContext();
private final Amf3Output amfout;

public AMF3Encoder() {
amfout = new Amf3Output(context);
}
public void encode(IoSession session, Object message,ProtocolEncoderOutput out) throws Exception {
if(message instanceof MessageInfo){
MessageInfo messageinfo = (MessageInfo)message;//返回封装的消息对象
IoBuffer buffer;
ByteArrayOutputStream stream = new ByteArrayOutputStream();
amfout.setOutputStream(stream);
amfout.writeObject(messageinfo);
amfout.flush();
byte bytes[] = compress(session,stream.toByteArray());
buffer = IoBuffer.allocate(bytes.length,false);
buffer.put(bytes);
buffer.flip();
out.write(buffer);
buffer.free();
}
}

private byte[] compress(IoSession session,byte[] inputs){
Deflater deflater = (Deflater)session.getAttribute(DEFLATER);
if(deflater == null){
deflater = new Deflater();
session.setAttribute(DEFLATER,deflater);
}
deflater.reset();
deflater.setInput(inputs);
deflater.finish();
byte outputs[] = new byte[0];
ByteArrayOutputStream stream = new ByteArrayOutputStream(inputs.length);
byte[] bytes = new byte[buffersize];
int value;
while(!deflater.finished()){
value = deflater.deflate(bytes);
stream.write(bytes,0, value);
}
outputs = stream.toByteArray();
try {
stream.close();
} catch (IOException e) {
e.printStackTrace();
}
return outputs;
}

public void dispose(IoSession session) throws Exception {
amfout.close();
}
}
/**
* 类功能描述:通讯消息处理
* 类创建人:
* 创建时间：
*/
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;
import common.MessageType;
import common.UserListManage;
import entity.MessageInfo;
import entity.UserInfo;
public class MessageManage extends IoHandlerAdapter {
/**
* 方法功能描述: 消息处理
* 参数: IoSession session 接收到的消息所属IoSession
* Object message 接收的消息
* 返回值: void
*/
public void messageReceived(IoSession session, Object message)throws Exception {
HashMap<?,?> msgMap=(HashMap<?,?>)message;
}
}