正文
javanio代码实例 java 代码
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
求java nio网络编程的小例子，要求客户端一直与服务器保持连接
import java.awt.*;
import java.awt.event.*;
import java.io.IOException;
import java.net.*;
import java.io.*;
public class chatClient extends Frame {
/**
* @param args
*/
TextField tfTxT=new TextField();
TextArea taContent=new TextArea();
Socket s=null;
DataOutputStream dos=null;
DataInputStream dis=null;
private boolean bConnected =false;
public static void main(String[] args) {
new chatClient().lunachFrame();
}
private class RecvThread implements Runnable{
public void run() {
try{
while(bConnected){
String str=dis.readUTF();
taContent.setText(taContent.getText()+str+'\n');
}
}catch(IOException e){
e.printStackTrace();
}
}
}
public void lunachFrame(){
this.setLocation(400, 300);
this.setSize(300,300);
//this.setLayout(new FlowLayout());
this.add(tfTxT,"South");
this.add(taContent,"North");
pack();
tfTxT.addActionListener(new TFListener());
this.addWindowListener(new WindowClose());
this.setVisible(true);
connect();
new Thread(new RecvThread()).start();
}
public void connect(){
try {
s= new Socket("127.0.0.1",8888);
dos =new DataOutputStream(s.getOutputStream());
dis =new DataInputStream(s.getInputStream());
System.out.println("connected!");
bConnected=true;
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public void disconnect(){
try {
dos.close();
s.close();
} catch (Exception e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
}
class WindowClose extends WindowAdapter{
@Override
public void windowClosing(WindowEvent e) {
// TODO 自动生成方法存根
System.exit(0);
disconnect();
}
}
private class TFListener implements ActionListener{
public void actionPerformed(ActionEvent e) {
String str=tfTxT.getText().trim();//trim去掉两边空格
//taContent.setText(str);
tfTxT.setText("");
try {
dos.writeUTF(str);
dos.flush();
//dos.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
======================================
import java.io.IOException;
import java.net.*;
import java.io.*;
import java.util.*;
public class ChatServer {
ListClient clients=new ArrayListClient();
Client c=null;
public static void main(String[] args){
new ChatServer().start();
}
public void start(){
boolean started=false;
ServerSocket ss=null;
DataInputStream dis=null;
try{
ss=new ServerSocket(8888);
started =true;
}catch(Exception e)
{
e.printStackTrace();
}
try{
while(started){
Socket s=ss.accept();
c=new Client(s);//启动线程,实行run()方法
System.out.println("a client connected!");
new Thread(c).start();//启动start方法,循环.start是Thread中的方法与这上面的start无关
clients.add(c);
//dis.close();
}
} catch (Exception e) {
//e.printStackTrace();
}
finally{
try {
ss.close();
} catch (IOException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
}
}
class Client implements Runnable{
private Socket s;
private DataInputStream dis =null;
private boolean bConnected =false;
private DataOutputStream dos=null;
public Client(Socket s){
this.s=s;
try {
dis=new DataInputStream(s.getInputStream());
dos =new DataOutputStream(s.getOutputStream());
bConnected =true;
} catch (IOException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
}
public void send(String str)throws Exception{
dos.writeUTF(str);
}
public void run() {
try{
while(bConnected){
String str = dis.readUTF();
System.out.println(str);
for(int i=0;iclients.size();i++){
c=clients.get(i);
c.send(str);
}
/*for(IteratorClient it=clients.iterator();it.hasNext();){
Client c=it.next();
c.send(str);
}*/
}
}catch(SocketException e){
clients.remove(this);
System.out.println("客户下线了");
}
catch(EOFException e){
System.out.println("Client closed");
}
catch (Exception e){
//e.printStackTrace();
}
finally{
try {
if(dis !=null) dis.close();
if(dos !=null) dos.close();
if(s!=null) s.close();
} catch (Exception e1) {
// TODO 自动生成 catch 块
//e1.printStackTrace();
}
}
}
}
}
第一个是客户端,
第二个是server端
相关问答
Q1: 怎么为JAVA NIO或Netty程序设置网络通信代理？
服务端
// 设置一个处理客户端消息和各种消息事件的类(Handler)bootstrap.setPipelineFactory(newChannelPipelineFactory() { @Override publicChannelPipeline getPipeline()throwsException { returnChannels.pipeline( newObjectDecoder(ClassResolvers.cacheDisabled(this .getClass().getClassLoader())), newObjectServerHandler()); }});
客户端
// 设置一个处理服务端消息和各种消息事件的类(Handler)
bootstrap.setPipelineFactory(newChannelPipelineFactory() { @Override publicChannelPipeline getPipeline()throwsException { returnChannels.pipeline(newObjectEncoder(), newObjectClientHandler()); }});
要传递对象，自然要有一个被传递模型，一个简单的Pojo，当然，实现序列化接口是必须的。
/** * @author lihzh * @alia OneCoder * @blog */public class Command implementsSerializable { privatestaticfinallongserialVersionUID = 7590999461767050471L; privateString actionName; publicString getActionName() { returnactionName; } publicvoidsetActionName(String actionName) { this.actionName = actionName; }}
服务端和客户端里，我们自定义的Handler实现如下：
ObjectServerHandler .java
/** * 对象传递服务端代码 * * @author lihzh * @alia OneCoder * @blog */public class ObjectServerHandler extendsSimpleChannelHandler { /** * 当接受到消息的时候触发 */ @Override publicvoidmessageReceived(ChannelHandlerContext ctx, MessageEvent e) throwsException { Command command = (Command) e.getMessage(); // 打印看看是不是我们刚才传过来的那个 System.out.println(command.getActionName()); }}
ObjectClientHandler .java
/** * 对象传递，客户端代码 * * @author lihzh * @alia OneCoder * @blog */public class ObjectClientHandler extendsSimpleChannelHandler { /** * 当绑定到服务端的时候触发，给服务端发消息。 * * @author lihzh * @alia OneCoder */ @Override publicvoidchannelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) { // 向服务端发送Object信息 sendObject(e.getChannel()); } /** * 发送Object * * @param channel * @author lihzh * @alia OneCoder */ privatevoidsendObject(Channel channel) { Command command =newCommand(); command.setActionName("Hello action."); channel.write(command); } }
启动后，服务端正常打印结果：Hello action.
简单梳理一下思路：
通过Netty传递，都需要基于流，以ChannelBuffer的形式传递。所以，Object - ChannelBuffer.
Netty提供了转换工具，需要我们配置到Handler。
样例从客户端 - 服务端，单向发消息，所以在客户端配置了编码，服务端解码。如果双向收发，则需要全部配置Encoder和Decoder。
这里需要注意，注册到Server的Handler是有顺序的，如果你颠倒一下注册顺序：
bootstrap.setPipelineFactory(newChannelPipelineFactory() {
@Override publicChannelPipeline getPipeline()throwsException { returnChannels.pipeline(newObjectServerHandler(), newObjectDecoder(ClassResolvers.cacheDisabled(this .getClass().getClassLoader())) ); }});
结果就是，会先进入我们自己的业务，再进行解码。这自然是不行的，会强转失败。至此，你应该会用Netty传递对象了吧。
Q2: java nio 非阻塞读写具体应该怎么操作，能否给个例子程序
package com.java.xiong.Net17;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.Channel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
public class NServer {
// 用于检测所有的Channel状态的selector
private Selector selector = null;
static final int PORT = 30000;
// 定义实现编码、解码的字符串集对象
private Charset charse = Charset.forName("GBK");
public void init() throws IOException {
selector = Selector.open();
// 通过open方法来打开一个未绑定的ServerSocketChannel是咧
ServerSocketChannel server = ServerSocketChannel.open();
InetSocketAddress isa = new InetSocketAddress("127.0.0.1", PORT);
// 将该ServerSocketChannel绑定到指定的IP地址
server.bind(isa);
// 设置serverSocket已非阻塞方式工作
server.configureBlocking(false);
// 将server注册到指定的selector对象
server.register(selector, SelectionKey.OP_ACCEPT);
while (selector.select() 0) {
// 一次处理selector上的每个选择的SelectionKey
for (SelectionKey sk : selector.selectedKeys()) {
// 从selector上已选择的Kye集中删除正在处理的SelectionKey
selector.selectedKeys().remove(sk);
// 如果sk对应的Channel包含客户端的连接请求
if (sk.isAcceptable()) {
// 调用accept方法接收连接，产生服务器段的SocketChennal
SocketChannel sc = server.accept();
// 设置采用非阻塞模式
sc.configureBlocking(false);
// 将该SocketChannel注册到selector
sc.register(selector, SelectionKey.OP_READ);
}
// 如果sk对应的Channel有数据需要读取
if (sk.isReadable()) {
// 获取该SelectionKey对银行的Channel，该Channel中有刻度的数据
SocketChannel sc = (SocketChannel) sk.channel();
// 定义备注执行读取数据源的ByteBuffer
ByteBuffer buff = ByteBuffer.allocate(1024);
String content = "";
// 开始读取数据
try {
while (sc.read(buff) 0) {
buff.flip();
content += charse.decode(buff);
}
System.out.println("读取的数据：" + content);
// 将sk对应的Channel设置成准备下一次读取
sk.interestOps(SelectionKey.OP_READ);
}
// 如果捕获到该sk对银行的Channel出现了异常，表明
// Channel对应的Client出现了问题，所以从Selector中取消
catch (IOException io) {
// 从Selector中删除指定的SelectionKey
sk.cancel();
if (sk.channel() != null) {
sk.channel().close();
}
}
// 如果content的长度大于0,则连天信息不为空
if (content.length() 0) {
// 遍历selector里注册的所有SelectionKey
for (SelectionKey key : selector.keys()) {
// 获取该key对应的Channel
Channel targerChannel = key.channel();
// 如果该Channel是SocketChannel对象
if (targerChannel instanceof SocketChannel) {
// 将读取到的内容写入该Channel中
SocketChannel dest = (SocketChannel) targerChannel;
dest.write(charse.encode(content));
}
}
}
}
}
}
}
public static void main(String [] args) throws IOException{
new NServer().init();
}
}
Q3: java nio 开发实例
首先了解下所谓的java nio是个什么东西！
传统的并发型服务器设计是利用阻塞型网络I/O 以多线程的模式来实现的 然而由
于系统常常在进行网络读写时处于阻塞状态 会大大影响系统的性能 自Java 开始引入
了NIO(新I/O) API 通过使用非阻塞型I/O 实现流畅的网络读写操作 为开发高性能并发
型服务器程序提供了一个很好的解决方案 这就是java nio
首先来看下传统的阻塞型网络 I/O的不足
Java 平台传统的I/O 系统都是基于Byte（字节）和Stream（数据流）的 相应的I/O 操
作都是阻塞型的 所以服务器程序也采用阻塞型I/O 进行数据的读 写操作 本文以TCP
长连接模式来讨论并发型服务器的相关设计 为了实现服务器程序的并发性要求 系统由一
个单独的主线程来监听用户发起的连接请求 一直处于阻塞状态 当有用户连接请求到来时
程序都会启一个新的线程来统一处理用户数据的读 写操作
这种模式的优点是简单 实用 易管理 然而缺点也是显而易见的 由于是为每一个客
户端分配一个线程来处理输入 输出数据 其线程与客户机的比例近似为 随着线程
数量的不断增加 服务器启动了大量的并发线程 会大大加大系统对线程的管理开销 这将
成为吞吐量瓶颈的主要原因 其次由于底层的I/O 操作采用的同步模式 I/O 操作的阻塞管
理粒度是以服务于请求的线程为单位的 有可能大量的线程会闲置 处于盲等状态 造成I/O
资源利用率不高 影响整个系统的性能
对于并发型服务器 系统用在阻塞型I/O 等待和线程间切换的时间远远多于CPU 在内
存中处理数据的时间 因此传统的阻塞型I/O 已经成为制约系统性能的瓶颈 Java 版本
后推出的NIO 工具包 提供了非阻塞型I/O 的异步输入输出机制 为提高系统的性能提供
了可实现的基础机制
NIO 包及工作原理
针对传统I/O 工作模式的不足 NIO 工具包提出了基于Buffer（缓冲区） Channel（通
道） Selector（选择器）的新模式 Selector（选择器） 可选择的Channel（通道）和
SelectionKey（选择键）配合起来使用 可以实现并发的非阻塞型I/O 能力
NIO 工具包的成员
Buffer（缓冲器）
Buffer 类是一个抽象类 它有 个子类分别对应于七种基本的数据类型 ByteBuffer
CharBuffer DoubleBuffer FloatBuffer IntBuffer LongBuffer 和ShortBuffer 每一个Buffer
对象相当于一个数据容器 可以把它看作内存中的一个大的数组 用来存储和提取所有基本
类型(boolean 型除外)的数据 Buffer 类的核心是一块内存区 可以直接对其执行与内存有关
的操作 利用操作系统特性和能力提高和改善Java 传统I/O 的性能
Channel（通道）
Channel 被认为是NIO 工具包的一大创新点 是(Buffer)缓冲器和I/O 服务之间的通道
具有双向性 既可以读入也可以写出 可以更高效的传递数据 我们这里主要讨论
ServerSocketChannel 和SocketChannel 它们都继承了SelectableChannel 是可选择的通道
分别可以工作在同步和异步两种方式下（这里的可选择不是指可以选择两种工作方式 而是
指可以有选择的注册自己感兴趣的事件） 当通道工作在同步方式时 它的功能和编程方法
与传统的ServerSocket Socket 对象相似 当通道工作在异步工作方式时 进行输入输出处
理不必等到输入输出完毕才返回 并且可以将其感兴趣的（如 接受操作 连接操作 读出
操作 写入操作）事件注册到Selector 对象上 与Selector 对象协同工作可以更有效率的支
持和管理并发的网络套接字连接
Selector（选择器）和SelectionKey（选择键）
各类 Buffer 是数据的容器对象 各类Channel 实现在各类Buffer 与各类I/O 服务间传输
数据 Selector 是实现并发型非阻塞I/O 的核心 各种可选择的通道将其感兴趣的事件注册
到Selector 对象上 Selector 在一个循环中不断轮循监视这各些注册在其上的Socket 通道
SelectionKey 类则封装了SelectableChannel 对象在Selector 中的注册信息 当Selector 监测
到在某个注册的SelectableChannel 上发生了感兴趣的事件时 自动激活产生一个SelectionKey
对象 在这个对象中记录了哪一个SelectableChannel 上发生了哪种事件 通过对被激活的
SelectionKey 的分析 外界可以知道每个SelectableChannel 发生的具体事件类型 进行相应的
处理
NIO 工作原理
通过上面的讨论 我们可以看出在并发型服务器程序中使用NIO 实际上是通过网络事
件驱动模型实现的 我们应用Select 机制 不用为每一个客户端连接新启线程处理 而是将
其注册到特定的Selector 对象上 这就可以在单线程中利用Selector 对象管理大量并发的网
络连接 更好的利用了系统资源 采用非阻塞I/O 的通信方式 不要求阻塞等待I/O 操作完
成即可返回 从而减少了管理I/O 连接导致的系统开销 大幅度提高了系统性能
当有读或写等任何注册的事件发生时 可以从Selector 中获得相应的
SelectionKey 从SelectionKey 中可以找到发生的事件和该事件所发生的具体的
SelectableChannel 以获得客户端发送过来的数据 由于在非阻塞网络I/O 中采用了事件触
发机制 处理程序可以得到系统的主动通知 从而可以实现底层网络I/O 无阻塞 流畅地读
写 而不像在原来的阻塞模式下处理程序需要不断循环等待 使用NIO 可以编写出性能更
好 更易扩展的并发型服务器程序
并发型服务器程序的实现代码
应用 NIO 工具包 基于非阻塞网络I/O 设计的并发型服务器程序与以往基于阻塞I/O 的
实现程序有很大不同 在使用非阻塞网络I/O 的情况下 程序读取数据和写入数据的时机不
是由程序员控制的 而是Selector 决定的 下面便给出基于非阻塞网络I/O 的并发型服务器
程序的核心代码片段
import java io * //引入Java io包
import * //引入包
import java nio channels * //引入Java nio channels包
import java util * //引入Java util包
public class TestServer implements Runnable
{
/**
* 服务器Channel对象 负责接受用户连接
*/
private ServerSocketChannel server
/**
* Selector对象 负责监控所有的连接到服务器的网络事件的发生
*/
private Selector selector
/**
* 总的活动连接数
*/
private int activeSockets
/**
* 服务器Channel绑定的端口号
*/
private int port
/**
*
* 构造函数
*/
public TestServer()throws IOException
{
activeSockets=
port= //初始化服务器Channel绑定的端口号为
selector= Selector open() //初始化Selector对象
server=ServerSocketChannel open() //初始化服务器Channel对象
ServerSocket socket=server socket() //获取服务器Channel对应的//ServerSocket对象
socket bind(new InetSocketAddress(port)) //把Socket绑定到监听端口 上
nfigureBlocking(false) //将服务器Channel设置为非阻塞模式
server register(selector SelectionKey OP_ACCEPT) //将服务器Channel注册到
Selector对象 并指出服务器Channel所感兴趣的事件为可接受请求操作
}
public void run()
{
while(true)
{
try
{
/**
*应用Select机制轮循是否有用户感兴趣的新的网络事件发生 当没有
* 新的网络事件发生时 此方法会阻塞 直到有新的网络事件发生为止
*/
selector select()
}
catch(IOException e)
{
continue //当有异常发生时 继续进行循环操作
}
/**
* 得到活动的网络连接选择键的集合
*/
SetSelectionKey keys=selector selectedKeys()
activeSockets=keys size() //获取活动连接的数目
if(activeSockets== )
{
continue //如果连接数为 则继续进行循环操作
}
/**
/**
* 应用For—Each循环遍历整个选择键集合
*/
for(SelectionKey key :keys)
{
/**
* 如果关键字状态是为可接受 则接受连接 注册通道 以接受更多的*
事件 进行相关的服务器程序处理
*/
if(key isAcceptable())
{
doServerSocketEvent(key)
continue
}
/**
* 如果关键字状态为可读 则说明Channel是一个客户端的连接通道
* 进行相应的读取客户端数据的操作
*/
if(key isReadable())
{
doClientReadEvent(key)
continue
}
/**
* 如果关键字状态为可写 则也说明Channel是一个客户端的连接通道
* 进行相应的向客户端写数据的操作
*/
if(key isWritable())
{
doClinetWriteEvent(key)
continue
}
}
}
}
/**
* 处理服务器事件操作
* @param key 服务器选择键对象
*/
private void doServerSocketEvent(SelectionKey key)
{
SocketChannel client=null
try
{
ServerSocketChannel server=(ServerSocketChannel)key channel()
client=server accept()
if(client==null)
{
return
}
nfigureBlocking(false) //将客户端Channel设置为非阻塞型
/**
/**
* 将客户端Channel注册到Selector对象上 并且指出客户端Channel所感
* 兴趣的事件为可读和可写
*/
client register(selector SelectionKey OP_READ|SelectionKey OP_READ)
}catch(IOException e)
{
try
{
client close()
}catch(IOException e ){}
}
}
/**
* 进行向客户端写数据操作
* @param key 客户端选择键对象
*/
private void doClinetWriteEvent(SelectionKey key)
{
代码实现略
}
/**
* 进行读取客户短数据操作
* @param key 客户端选择键对象
*/
private void doClientReadEvent(SelectionKey key)
{
代码实现略
}
}
从上面对代码可以看出 使用非阻塞性I/O进行并发型服务器程序设计分三个部分
向Selector对象注册感兴趣的事件 从Selector中获取所感兴趣的事件 根据不同的事件进
行相应的处理
结语
通过使用NIO 工具包进行并发型服务器程序设计 一个或者很少几个Socket 线程就可
以处理成千上万个活动的Socket 连接 大大降低了服务器端程序的开销 同时网络I/O 采取
非阻塞模式 线程不再在读或写时阻塞 操作系统可以更流畅的读写数据并可以更有效地向
CPU 传递数据进行处理 以便更有效地提高系统的性能
看到这里相信你看了不止 分钟了吧 我说 分钟其实就是想让大家能够轻松的读下去（鸡蛋 ）
好了 到这里大家应该对java nio有个初步的了解了吧~~~
lishixinzhi/Article/program/Java/hx/201311/27190
Q4: Java NIO与IO的区别和比较
J2SE1.4以上版本中发布了全新的I/O类库。本文将通过一些实例来简单介绍NIO库提供的一些新特性：非阻塞I/O，字符转换，缓冲以及通道。
一. 介绍NIO
NIO包（java.nio.*）引入了四个关键的抽象数据类型，它们共同解决传统的I/O类中的一些问题。
1． Buffer：它是包含数据且用于读写的线形表结构。其中还提供了一个特殊类用于内存映射文件的I/O操作。
2． Charset：它提供Unicode字符串影射到字节序列以及逆影射的操作。
3． Channels：包含socket，file和pipe三种管道，它实际上是双向交流的通道。
4． Selector：它将多元异步I/O操作集中到一个或多个线程中（它可以被看成是Unix中select（）函数或Win32中WaitForSingleEvent（）函数的面向对象版本）。
二. 回顾传统
在介绍NIO之前，有必要了解传统的I/O操作的方式。以网络应用为例，传统方式需要监听一个ServerSocket，接受请求的连接为其提供服务（服务通常包括了处理请求并发送响应）图一是服务器的生命周期图，其中标有粗黑线条的部分表明会发生I/O阻塞。
图一
可以分析创建服务器的每个具体步骤。首先创建ServerSocket
ServerSocket server=new ServerSocket（10000）；
然后接受新的连接请求
Socket newConnection=server.accept（）；
对于accept方法的调用将造成阻塞，直到ServerSocket接受到一个连接请求为止。一旦连接请求被接受，服务器可以读客户socket中的请求。
InputStream in = newConnection.getInputStream();
InputStreamReader reader = new InputStreamReader(in);
BufferedReader buffer = new BufferedReader(reader);
Request request = new Request();
while(!request.isComplete()) {
String line = buffer.readLine();
request.addLine(line);
}
这样的操作有两个问题，首先BufferedReader类的readLine（）方法在其缓冲区未满时会造成线程阻塞，只有一定数据填满了缓冲区或者客户关闭了套接字，方法才会返回。其次，它回产生大量的垃圾，BufferedReader创建了缓冲区来从客户套接字读入数据，但是同样创建了一些字符串存储这些数据。虽然BufferedReader内部提供了StringBuffer处理这一问题，但是所有的String很快变成了垃圾需要回收。
同样的问题在发送响应代码中也存在
Response response = request.generateResponse();
OutputStream out = newConnection.getOutputStream();
InputStream in = response.getInputStream()；
int ch；
while(-1 != (ch = in.read())) {
out.write(ch);
}
newConnection.close();
类似的，读写操作被阻塞而且向流中一次写入一个字符会造成效率低下，所以应该使用缓冲区，但是一旦使用缓冲，流又会产生更多的垃圾。
传统的解决方法
通常在Java中处理阻塞I/O要用到线程（大量的线程）。一般是实现一个线程池用来处理请求，如图二
图二
线程使得服务器可以处理多个连接，但是它们也同样引发了许多问题。每个线程拥有自己的栈空间并且占用一些CPU时间，耗费很大，而且很多时间是浪费在阻塞的I/O操作上，没有有效的利用CPU。
三. 新I/O
1． Buffer
传统的I/O不断的浪费对象资源（通常是String）。新I/O通过使用Buffer读写数据避免了资源浪费。Buffer对象是线性的，有序的数据集合，它根据其类别只包含唯一的数据类型。
java.nio.Buffer 类描述
java.nio.ByteBuffer 包含字节类型。 可以从ReadableByteChannel中读在 WritableByteChannel中写
java.nio.MappedByteBuffer 包含字节类型，直接在内存某一区域映射
java.nio.CharBuffer 包含字符类型，不能写入通道
java.nio.DoubleBuffer 包含double类型，不能写入通道
java.nio.FloatBuffer 包含float类型
java.nio.IntBuffer 包含int类型
java.nio.LongBuffer 包含long类型
java.nio.ShortBuffer 包含short类型
可以通过调用allocate(int capacity)方法或者allocateDirect(int capacity)方法分配一个Buffer。特别的，你可以创建MappedBytesBuffer通过调用FileChannel.map(int mode,long position,int size)。直接（direct）buffer在内存中分配一段连续的块并使用本地访问方法读写数据。非直接(nondirect)buffer通过使用Java中的数组访问代码读写数据。有时候必须使用非直接缓冲例如使用任何的wrap方法（如ByteBuffer.wrap(byte[])）在Java数组基础上创建buffer。
2． 字符编码
向ByteBuffer中存放数据涉及到两个问题：字节的顺序和字符转换。ByteBuffer内部通过ByteOrder类处理了字节顺序问题，但是并没有处理字符转换。事实上，ByteBuffer没有提供方法读写String。
Java.nio.charset.Charset处理了字符转换问题。它通过构造CharsetEncoder和CharsetDecoder将字符序列转换成字节和逆转换。
3． 通道(Channel)
你可能注意到现有的java.io类中没有一个能够读写Buffer类型，所以NIO中提供了Channel类来读写Buffer。通道可以认为是一种连接，可以是到特定设备，程序或者是网络的连接。通道的类等级结构图如下
图三
图中ReadableByteChannel和WritableByteChannel分别用于读写。
GatheringByteChannel可以从使用一次将多个Buffer中的数据写入通道，相反的，ScatteringByteChannel则可以一次将数据从通道读入多个Buffer中。你还可以设置通道使其为阻塞或非阻塞I/O操作服务。
为了使通道能够同传统I/O类相容，Channel类提供了静态方法创建Stream或Reader
4． Selector
在过去的阻塞I/O中，我们一般知道什么时候可以向stream中读或写，因为方法调用直到stream准备好时返回。但是使用非阻塞通道，我们需要一些方法来知道什么时候通道准备好了。在NIO包中，设计Selector就是为了这个目的。SelectableChannel可以注册特定的事件，而不是在事件发生时通知应用，通道跟踪事件。然后，当应用调用Selector上的任意一个selection方法时，它查看注册了的通道看是否有任何感兴趣的事件发生。图四是selector和两个已注册的通道的例子
图四
并不是所有的通道都支持所有的操作。SelectionKey类定义了所有可能的操作位，将要用两次。首先，当应用调用SelectableChannel.register(Selector sel,int op)方法注册通道时，它将所需操作作为第二个参数传递到方法中。然后，一旦SelectionKey被选中了，SelectionKey的readyOps()方法返回所有通道支持操作的数位的和。SelectableChannel的validOps方法返回每个通道允许的操作。注册通道不支持的操作将引发IllegalArgumentException异常。下表列出了SelectableChannel子类所支持的操作。
ServerSocketChannel OP_ACCEPT
SocketChannel OP_CONNECT, OP_READ, OP_WRITE
DatagramChannel OP_READ, OP_WRITE
Pipe.SourceChannel OP_READ
Pipe.SinkChannel OP_WRITE
四. 举例说明
1． 简单网页内容下载
这个例子非常简单，类SocketChannelReader使用SocketChannel来下载特定网页的HTML内容。
package examples.nio;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.net.InetSocketAddress;
import java.io.IOException;
public class SocketChannelReader{
private Charset charset=Charset.forName("UTF-8");//创建UTF-8字符集
private SocketChannel channel;
public void getHTMLContent(){
try{
connect();
sendRequest();
readResponse();
}catch(IOException e){
System.err.println(e.toString());
}finally{
if(channel!=null){
try{
channel.close();
}catch(IOException e){}
}
}
}
private void connect()throws IOException{//连接到CSDN
InetSocketAddress socketAddress=
new InetSocketAddress("",80/);
channel=SocketChannel.open(socketAddress);
//使用工厂方法open创建一个channel并将它连接到指定地址上
//相当与SocketChannel.open().connect(socketAddress);调用
}
private void sendRequest()throws IOException{
channel.write(charset.encode("GET "
+"/document"
+"\r\n\r\n"));//发送GET请求到CSDN的文档中心
//使用channel.write方法，它需要CharByte类型的参数，使用
//Charset.encode(String)方法转换字符串。
}
private void readResponse()throws IOException{//读取应答
ByteBuffer buffer=ByteBuffer.allocate(1024);//创建1024字节的缓冲
while(channel.read(buffer)!=-1){
buffer.flip();//flip方法在读缓冲区字节操作之前调用。
System.out.println(charset.decode(buffer));
//使用Charset.decode方法将字节转换为字符串
buffer.clear();//清空缓冲
}
}
public static void main(String [] args){
new SocketChannelReader().getHTMLContent();
}
2． 简单的加法服务器和客户机
服务器代码
package examples.nio;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.net.InetSocketAddress;
import java.io.IOException;
/**
* SumServer.java
*
*
* Created: Thu Nov 06 11:41:52 2003
*
* @author starchu1981
* @version 1.0
*/
public class SumServer {
private ByteBuffer _buffer=ByteBuffer.allocate(8);
private IntBuffer _intBuffer=_buffer.asIntBuffer();
private SocketChannel _clientChannel=null;
private ServerSocketChannel _serverChannel=null;
public void start(){
try{
openChannel();
waitForConnection();
}catch(IOException e){
System.err.println(e.toString());
}
}
private void openChannel()throws IOException{
_serverChannel=ServerSocketChannel.open();
_serverChannel.socket().bind(new InetSocketAddress(10000));
System.out.println("服务器通道已经打开");
}
private void waitForConnection()throws IOException{
while(true){
_clientChannel=_serverChannel.accept();
if(_clientChannel!=null){
System.out.println("新的连接加入");
processRequest();
_clientChannel.close();
}
}
}
private void processRequest()throws IOException{
_buffer.clear();
_clientChannel.read(_buffer);
int result=_intBuffer.get(0)+_intBuffer.get(1);
_buffer.flip();
_buffer.clear();
_intBuffer.put(0,result);
_clientChannel.write(_buffer);
}
public static void main(String [] args){
new SumServer().start();
}
} // SumServer
客户代码
package examples.nio;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.channels.SocketChannel;
import java.net.InetSocketAddress;
import java.io.IOException;
/**
* SumClient.java
*
*
* Created: Thu Nov 06 11:26:06 2003
*
* @author starchu1981
* @version 1.0
*/
public class SumClient {
private ByteBuffer _buffer=ByteBuffer.allocate(8);
private IntBuffer _intBuffer;
private SocketChannel _channel;
public SumClient() {
_intBuffer=_buffer.asIntBuffer();
} // SumClient constructor
public int getSum(int first,int second){
int result=0;
try{
_channel=connect();
sendSumRequest(first,second);
result=receiveResponse();
}catch(IOException e){System.err.println(e.toString());
}finally{
if(_channel!=null){
try{
_channel.close();
}catch(IOException e){}
}
}
return result;
}
private SocketChannel connect()throws IOException{
InetSocketAddress socketAddress=
new InetSocketAddress("localhost",10000);
return SocketChannel.open(socketAddress);
}
private void sendSumRequest(int first,int second)throws IOException{
_buffer.clear();
_intBuffer.put(0,first);
_intBuffer.put(1,second);
_channel.write(_buffer);
System.out.println("发送加法请求 "+first+"+"+second);
}
private int receiveResponse()throws IOException{
_buffer.clear();
_channel.read(_buffer);
return _intBuffer.get(0);
}
public static void main(String [] args){
SumClient sumClient=new SumClient();
System.out.println("加法结果为 :"+sumClient.getSum(100,324));
}
} // SumClient
3． 非阻塞的加法服务器
首先在openChannel方法中加入语句
_serverChannel.configureBlocking(false);//设置成为非阻塞模式
重写WaitForConnection方法的代码如下，使用非阻塞方式
private void waitForConnection()throws IOException{
Selector acceptSelector = SelectorProvider.provider().openSelector();
/*在服务器套接字上注册selector并设置为接受accept方法的通知。
这就告诉Selector，套接字想要在accept操作发生时被放在ready表
上，因此，允许多元非阻塞I/O发生。*/
SelectionKey acceptKey = ssc.register(acceptSelector,
SelectionKey.OP_ACCEPT);
int keysAdded = 0;
javanio代码实例的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java 代码、javanio代码实例的信息别忘了在本站进行查找喔。
