public void socketServer() {
// 创建一个socket连接
NioSocketConnector connector = new NioSocketConnector();
// 消息核心处理器
connector.setHandler(new MinaClientHanlder());
// 设置链接超时时间
connector.setConnectTimeoutCheckInterval(30);
// 获取过滤器链
DefaultIoFilterChainBuilder chain = connector.getFilterChain();
ProtocolCodecFilter filter =
new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8")));
// 添加编码过滤器 处理乱码、编码问题
chain.addLast("objectFilter", filter);
// 连接服务器，知道端口、地址
ConnectFuture cf = connector.connect(new InetSocketAddress(App.address, App.bindPort));
// 等待连接创建完成
cf.awaitUninterruptibly();
if (cf.isConnected()) {
App.isConnected = true;
System.out.println("等待连接断开");
// 等待连接断开
cf.getSession().getCloseFuture().awaitUninterruptibly();
} else {
System.out.println("连接断开");
App.isConnected = false;
}
System.out.println("----dispose");
connector.dispose();
System.out.println("dispose----");
}
public boolean connect(CallBack cb) {
// 创建一个socket连接
connector = new NioSocketConnector();
// 设置链接超时时间
connector.setConnectTimeoutMillis(3000);
// 获取过滤器链
DefaultIoFilterChainBuilder filterChain = connector.getFilterChain();
// 添加编码过滤器 处理乱码、编码问题
filterChain.addLast(
"codec",
new ProtocolCodecFilter(
new TextLineCodecFactory(
Charset.forName("UTF-8"),
LineDelimiter.WINDOWS.getValue(),
LineDelimiter.WINDOWS.getValue())));
/*
* // 日志 LoggingFilter loggingFilter = new LoggingFilter();
* loggingFilter.setMessageReceivedLogLevel(LogLevel.INFO);
* loggingFilter.setMessageSentLogLevel(LogLevel.INFO);
* filterChain.addLast("loger", loggingFilter);
*/
// 消息核心处理器
connector.setHandler(new MyIoHandlerAdapter(context, cb));
// 连接服务器，知道端口、地址
future = connector.connect(new InetSocketAddress("10.80.1.212", 9000));
// // 等待连接创建完成
return true;
}
public static void main(String[] args) throws Exception {
// 创建服务器端连接器
SocketAcceptor acceptor = new NioSocketAcceptor();
acceptor.setReuseAddress(true);
// 获取默认过滤器
DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
// 设置加密过滤器
SslFilter sslFilter = new SslFilter(BogusSslContextFactory.getInstance(true));
// 设置客户连接时需要验证客户端证书
sslFilter.setNeedClientAuth(true);
chain.addLast("sslFilter", sslFilter);
// 设置编码过滤器和按行读取数据模式
chain.addLast(
"codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
// 设置事件处理器
acceptor.setHandler(new TLSServerHandler());
// 服务绑定到此端口号
acceptor.bind(new InetSocketAddress(PORT));
logger.debug("服务器在 [PORT] 等待连接...", PORT);
}
public static void main(String args[]) throws IOException {
// 创建一个非阻塞的Server端socket 用NIO
SocketAcceptor acceptor = new NioSocketAcceptor();
// 创建接收数据的过滤器
DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
// 设定这个过滤器一行一行的(/r/n)的读取数据
chain.addLast("myChin", new ProtocolCodecFilter(new TextLineCodecFactory()));
// 设定服务器端的消息处理器 new 一个对象
acceptor.setHandler(new SamplMinaServerHandler());
// 服务器绑定的端口
int bindport = 9988;
// 绑定端口，启动服务器
acceptor.bind(new InetSocketAddress(bindport));
System.out.println("start ok,listen on:=" + bindport);
}
private void appendIoFiltersToChain(
List<IoFilter> filters, DefaultIoFilterChainBuilder filterChain) {
if (filters != null && filters.size() > 0) {
for (IoFilter ioFilter : filters) {
filterChain.addLast(ioFilter.getClass().getCanonicalName(), ioFilter);
}
}
}
/**
* Title:
*
* <p>Desc:初始化客户端信息
*
* @param message
* @throws UnsupportedEncodingException
*/
public TongbuClient(Object message, String url, int port) {
chain.addLast("logging", new LoggingFilter()); // 添加日志过滤器
chain.addLast("myChin", new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
if (message instanceof String) {
connector.setHandler(new ClientHandler((String) message));
} else if (message instanceof CommEntity) {
connector.setHandler(new ClientHandler((CommEntity) message));
}
connector.setConnectTimeoutMillis(10000);
SocketSessionConfig cfg = connector.getSessionConfig();
cfg.setUseReadOperation(true);
IoSession session =
connector.connect(new InetSocketAddress(url, port)).awaitUninterruptibly().getSession();
ReadFuture readFuture = session.read();
readFuture.awaitUninterruptibly();
this.info = (CommResultInfo) readFuture.getMessage();
session.close(true);
session.getService().dispose();
}
private CommandMinaClient() throws java.net.ConnectException {
NioSocketConnector connector = new NioSocketConnector();
// 创建接收数据的过滤器
DefaultIoFilterChainBuilder chain = connector.getFilterChain();
// 设定这个过滤器将以对象为单位读取数据
ProtocolCodecFilter filter = new ProtocolCodecFilter(new ObjectSerializationCodecFactory());
// 设定服务器端的消息处理器:一个SamplMinaServerHandler对象,
chain.addLast("objectFilter", filter);
// 设定服务器端的消息处理器:一个 SamplMinaServerHandler 对象,
connector.setHandler(new CommandMinaClientHanlder());
// Set connect timeout.
connector.setConnectTimeoutCheckInterval(30);
// 连结到服务器:
ConnectFuture cf = connector.connect(new InetSocketAddress("159.226.95.156", 9900));
// Wait for the connection attempt to be finished.
cf.awaitUninterruptibly();
session = cf.getSession();
}
public void start(final String transCode) throws IOException {
acceptor = new NioSocketAcceptor();
DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
chain.addLast("logger", new LoggingFilter());
DefaultMessageCodecFactory messageCodecFactory = createMessageCodecFactory();
DefaultProtocolCodecFactory protocolCodecFactory = new DefaultProtocolCodecFactory();
DefaultProtocolDecoder protocolDecoder = new DefaultProtocolDecoder();
protocolDecoder.setMessageCodecFactory(messageCodecFactory);
protocolCodecFactory.setProtocolDecoder(protocolDecoder);
DefaultProtocolEncoder encoder = new DefaultProtocolEncoder();
encoder.setMessageCodecFactory(messageCodecFactory);
protocolCodecFactory.setProtocolEncoder(encoder);
chain.addLast("protocol", new ProtocolCodecFilter(protocolCodecFactory));
acceptor.setHandler(
new IoHandlerAdapter() {
@Override
public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
logger.error("error.", cause);
session.close(false);
}
@Override
public void messageReceived(IoSession session, Object message) throws Exception {
logger.info("handler get message:" + message);
System.out.println("handler get message:" + message);
session.write(createResponse(transCode));
session.close(false);
}
});
// new ProtocolIoHandler()
// acceptor.setHandler((ProtocolIoHandler)beanFactory.getBean("protocolIoHandler"));
acceptor.bind(new InetSocketAddress(port));
}
public MemoryMonitor() throws IOException {
// 创建UDP数据包NIO
NioDatagramAcceptor acceptor = new NioDatagramAcceptor();
// 设置filter
DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
chain.addLast(
"codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
chain.addLast("logger", new LoggingFilter());
// NIO设置底层IOHandler 把服务器的本身传入
acceptor.setHandler(new MemoryMonitorHandler());
// 设置是否重用地址？ 也就是每个发过来的udp信息都是一个地址？
DatagramSessionConfig dcfg = acceptor.getSessionConfig();
dcfg.setReuseAddress(true);
// 绑定端口地址
acceptor.bind(new InetSocketAddress(PORT));
logger.debug("UDPServer listening on port " + PORT);
}
public MemoryMonitor() throws IOException {
NioDatagramAcceptor acceptor = new NioDatagramAcceptor();
acceptor.setHandler(new MemoryMonitorHandler(this));
DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
chain.addLast("logger", new LoggingFilter());
DatagramSessionConfig dcfg = acceptor.getSessionConfig();
dcfg.setReuseAddress(true);
frame = new JFrame("Memory monitor");
tabbedPane = new JTabbedPane();
tabbedPane.add("Welcome", createWelcomePanel());
frame.add(tabbedPane, BorderLayout.CENTER);
clients = new ConcurrentHashMap<SocketAddress, ClientPanel>();
frame.pack();
frame.setLocation(300, 300);
frame.setVisible(true);
acceptor.bind(new InetSocketAddress(PORT));
System.out.println("UDPServer listening on port " + PORT);
}
public void init() {
// Create TCP/IP connector.
connector = new NioSocketConnector();
// 创建接收数据的过滤器
DefaultIoFilterChainBuilder chain = connector.getFilterChain();
// 自动重连
chain.addLast(
"reConnect",
new IoFilterAdapter() {
public void sessionClosed(NextFilter nextFilter, IoSession session) throws Exception {
logger.error("连接被关闭：" + getServerInfo());
scheduleConnect();
}
});
// 设定这个过滤器将一行一行(/r/n)的读取数据
chain.addLast("protocolCodecFilter", new ProtocolCodecFilter(new TextLineCodecFactory()));
// 设定服务器端的消息处理器:一个MinaClientHandler对象,
connector.setHandler(ioHandler);
// Set connect timeout.
connector.setConnectTimeoutMillis(30 * 1000);
doConnnect();
}
