原文出处:http://blog.csdn.net/u013256816/article/details/51457215#comments
现在使用NIO的场景越来越多,很多网上的技术框架或多或少的使用NIO技术,譬如Tomcat,Jetty。学习和掌握NIO技术已经不是一个Java攻城狮的加分技能,而是一个必备技能。再者,现在互联网的面试中上点level的都会涉及一下NIO或者AIO的问题(AIO下次再讲述,本篇主要讲述NIO),掌握好NIO也能帮助你获得一份较好的offer。 驱使博主写这篇文章的关键是网上关于NIO的文章并不是很多,而且案例较少,针对这个特性,本文主要通过实际案例主要讲述NIO的用法,每个案例都经过实际检验。博主通过自己的理解以及一些案例希望能给各位在学习NIO之时多一份参考。博主能力有限,文中有不足之处欢迎之处。
本文持续更新,转载请保留原文链接。
概述
NIO主要有三大核心部分:Channel(通道),Buffer(缓冲区), Selector。传统IO基于字节流和字符流进行操作,而NIO基于Channel和Buffer(缓冲区)进行操作,数据总是从通道读取到缓冲区中,或者从缓冲区写入到通道中。Selector(选择区)用于监听多个通道的事件(比如:连接打开,数据到达)。因此,单个线程可以监听多个数据通道。
NIO和传统IO(一下简称IO)之间第一个最大的区别是,IO是面向流的,NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节,直至读取所有字节,它们没有被缓存在任何地方。此外,它不能前后移动流中的数据。如果需要前后移动从流中读取的数据,需要先将它缓存到一个缓冲区。NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是,还需要检查是否该缓冲区中包含所有您需要处理的数据。而且,需确保当更多的数据读入缓冲区时,不要覆盖缓冲区里尚未处理的数据。
IO的各种流是阻塞的。这意味着,当一个线程调用read() 或 write()时,该线程被阻塞,直到有一些数据被读取,或数据完全写入。该线程在此期间不能再干任何事情了。 NIO的非阻塞模式,使一个线程从某通道发送请求读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取。而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作,所以一个单独的线程现在可以管理多个输入和输出通道(channel)。
Channel
首先说一下Channel,国内大多翻译成“通道”。Channel和IO中的Stream(流)是差不多一个等级的。只不过Stream是单向的,譬如:InputStream, OutputStream.而Channel是双向的,既可以用来进行读操作,又可以用来进行写操作。 NIO中的Channel的主要实现有:
FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel
这里看名字就可以猜出个所以然来:分别可以对应文件IO、UDP和TCP(Server和Client)。下面演示的案例基本上就是围绕这4个类型的Channel进行陈述的。
Buffer
NIO中的关键Buffer实现有:ByteBuffer, CharBuffer, DoubleBuffer, FloatBuffer, IntBuffer, LongBuffer, ShortBuffer,分别对应基本数据类型: byte, char, double, float, int, long, short。当然NIO中还有MappedByteBuffer, HeapByteBuffer, DirectByteBuffer等这里先不进行陈述。
Selector
Selector运行单线程处理多个Channel,如果你的应用打开了多个通道,但每个连接的流量都很低,使用Selector就会很方便。例如在一个聊天服务器中。要使用Selector, 得向Selector注册Channel,然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回,线程就可以处理这些事件,事件的例子有如新的连接进来、数据接收等。
FileChannel
看完上面的陈述,对于第一次接触NIO的同学来说云里雾里,只说了一些概念,也没记住什么,更别说怎么用了。这里开始通过传统IO以及更改后的NIO来做对比,以更形象的突出NIO的用法,进而使你对NIO有一点点的了解。
传统IO vs NIO
首先,案例1是采用FileInputStream读取文件内容的:
public static void method2 (){
InputStream in = null ;
try {
in = new BufferedInputStream(new FileInputStream("src/nomal_io.txt" ));
byte [] buf = new byte [1024 ];
int bytesRead = in .read(buf);
while (bytesRead != -1 )
{
for (int i=0 ;iout.print((char )buf[i]);
bytesRead = in .read(buf);
}
}catch (IOException e)
{
e.printStackTrace();
}finally {
try {
if (in != null ){
in .close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
输出结果:(略)
案例是对应的NIO(这里通过RandomAccessFile进行操作,当然也可以通过FileInputStream.getChannel()进行操作):
public static void method1 (){
RandomAccessFile aFile = null ;
try {
aFile = new RandomAccessFile("src/nio.txt" ,"rw" );
FileChannel fileChannel = aFile.getChannel();
ByteBuffer buf = ByteBuffer.allocate(1024 );
int bytesRead = fileChannel.read(buf);
System.out .println(bytesRead);
while (bytesRead != -1 )
{
buf.flip();
while (buf.hasRemaining())
{
System.out .print((char )buf.get ());
}
buf.compact();
bytesRead = fileChannel.read(buf);
}
}catch (IOException e){
e.printStackTrace();
}finally {
try {
if (aFile != null ){
aFile.close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
输出结果:(略) 通过仔细对比案例1和案例2,应该能看出个大概,最起码能发现NIO的实现方式比叫复杂。有了一个大概的印象可以进入下一步了。
Buffer的使用
从案例2中可以总结出使用Buffer一般遵循下面几个步骤:
分配空间(ByteBuffer buf = ByteBuffer.allocate(1024); 还有一种allocateDirector后面再陈述)
写入数据到Buffer(int bytesRead = fileChannel.read(buf);)
调用filp()方法( buf.flip();)
从Buffer中读取数据(System.out.print((char)buf.get());)
调用clear()方法或者compact()方法
Buffer顾名思义:缓冲区,实际上是一个容器,一个连续数组。Channel提供从文件、网络读取数据的渠道,但是读写的数据都必须经过Buffer。如下图:
向Buffer中写数据:
从Channel写到Buffer (fileChannel.read(buf))
通过Buffer的put()方法 (buf.put(…))
从Buffer中读取数据:
从Buffer读取到Channel (channel.write(buf))
使用get()方法从Buffer中读取数据 (buf.get())
可以把Buffer简单地理解为一组基本数据类型的元素列表,它通过几个变量来保存这个数据的当前位置状态:capacity, position, limit, mark:
索引
说明
capacity
缓冲区数组的总长度
position
下一个要操作的数据元素的位置
limit
缓冲区数组中不可操作的下一个元素的位置:limit<=capacity
mark
用于记录当前position的前一个位置或者默认是-1
无图无真相,举例:我们通过ByteBuffer.allocate(11)方法创建了一个11个byte的数组的缓冲区,初始状态如上图,position的位置为0,capacity和limit默认都是数组长度。当我们写入5个字节时,变化如下图:
这时我们需要将缓冲区中的5个字节数据写入Channel的通信信道,所以我们调用ByteBuffer.flip()方法,变化如下图所示(position设回0,并将limit设成之前的position的值):
这时底层操作系统就可以从缓冲区中正确读取这个5个字节数据并发送出去了。在下一次写数据之前我们再调用clear()方法,缓冲区的索引位置又回到了初始位置。
调用clear()方法:position将被设回0,limit设置成capacity,换句话说,Buffer被清空了,其实Buffer中的数据并未被清楚,只是这些标记告诉我们可以从哪里开始往Buffer里写数据。如果Buffer中有一些未读的数据,调用clear()方法,数据将“被遗忘”,意味着不再有任何标记会告诉你哪些数据被读过,哪些还没有。如果Buffer中仍有未读的数据,且后续还需要这些数据,但是此时想要先先写些数据,那么使用compact()方法。compact()方法将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素正后面。limit属性依然像clear()方法一样,设置成capacity。现在Buffer准备好写数据了,但是不会覆盖未读的数据。
通过调用Buffer.mark()方法,可以标记Buffer中的一个特定的position,之后可以通过调用Buffer.reset()方法恢复到这个position。Buffer.rewind()方法将position设回0,所以你可以重读Buffer中的所有数据。limit保持不变,仍然表示能从Buffer中读取多少个元素。
SocketChannel
说完了FileChannel和Buffer, 大家应该对Buffer的用法比较了解了,这里使用SocketChannel来继续探讨NIO。NIO的强大功能部分来自于Channel的非阻塞特性,套接字的某些操作可能会无限期地阻塞。例如,对accept()方法的调用可能会因为等待一个客户端连接而阻塞;对read()方法的调用可能会因为没有数据可读而阻塞,直到连接的另一端传来新的数据。总的来说,创建/接收连接或读写数据等I/O调用,都可能无限期地阻塞等待,直到底层的网络实现发生了什么。慢速的,有损耗的网络,或仅仅是简单的网络故障都可能导致任意时间的延迟。然而不幸的是,在调用一个方法之前无法知道其是否阻塞。NIO的channel抽象的一个重要特征就是可以通过配置它的阻塞行为,以实现非阻塞式的信道。
channel.configureBlocking(false )
在非阻塞式信道上调用一个方法总是会立即返回。这种调用的返回值指示了所请求的操作完成的程度。例如,在一个非阻塞式ServerSocketChannel上调用accept()方法,如果有连接请求来了,则返回客户端SocketChannel,否则返回null。
这里先举一个TCP应用案例,客户端采用NIO实现,而服务端依旧使用IO实现。 客户端代码(案例3):
public static void client (){
ByteBuffer buffer = ByteBuffer.allocate(1024 );
SocketChannel socketChannel = null ;
try
{
socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false );
socketChannel.connect(new InetSocketAddress("10.10.195.115" ,8080 ));
if (socketChannel.finishConnect())
{
int i=0 ;
while (true )
{
TimeUnit.SECONDS.sleep(1 );
String info = "I'm " +i+++"-th information from client" ;
buffer.clear();
buffer.put(info.getBytes());
buffer.flip();
while (buffer.hasRemaining()){
System.out .println(buffer);
socketChannel.write(buffer);
}
}
}
}
catch (IOException | InterruptedException e)
{
e.printStackTrace();
}
finally {
try {
if (socketChannel!=null ){
socketChannel.close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
服务端代码(案例4):
public static void server (){
ServerSocket serverSocket = null ;
InputStream in = null ;
try
{
serverSocket = new ServerSocket(8080 );
int recvMsgSize = 0 ;
byte [] recvBuf = new byte [1024 ];
while (true ){
Socket clntSocket = serverSocket.accept();
SocketAddress clientAddress = clntSocket.getRemoteSocketAddress();
System.out .println("Handling client at " +clientAddress);
in = clntSocket.getInputStream();
while ((recvMsgSize=in .read(recvBuf))!=-1 ){
byte [] temp = new byte [recvMsgSize];
System.arraycopy(recvBuf, 0 , temp, 0 , recvMsgSize);
System.out .println(new String(temp));
}
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally {
try {
if (serverSocket!=null ){
serverSocket.close();
}
if (in !=null ){
in .close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
输出结果:(略)
根据案例分析,总结一下SocketChannel的用法。 打开SocketChannel:
socketChannel = SocketChannel.open ();
socketChannel.connect(new InetSocketAddress("10.10.195.115" ,8080 ));
关闭:
socketChannel.close ();
读取数据:
String info = "I'm " +i+++"-th information from client"
buffer.clear ()
buffer.put (info.getBytes ())
buffer.flip ()
while(buffer.hasRemaining ()){
System.out .println (buffer)
socketChannel.write (buffer)
}
注意SocketChannel.write()方法的调用是在一个while循环中的。Write()方法无法保证能写多少字节到SocketChannel。所以,我们重复调用write()直到Buffer没有要写的字节为止。 非阻塞模式下,read()方法在尚未读取到任何数据时可能就返回了。所以需要关注它的int返回值,它会告诉你读取了多少字节。
TCP服务端的NIO写法
到目前为止,所举的案例中都没有涉及Selector。不要急,好东西要慢慢来。Selector类可以用于避免使用阻塞式客户端中很浪费资源的“忙等”方法。例如,考虑一个IM服务器。像QQ或者旺旺这样的,可能有几万甚至几千万个客户端同时连接到了服务器,但在任何时刻都只是非常少量的消息。
需要读取和分发。这就需要一种方法阻塞等待,直到至少有一个信道可以进行I/O操作,并指出是哪个信道。NIO的选择器就实现了这样的功能。一个Selector实例可以同时检查一组信道的I/O状态。用专业术语来说,选择器就是一个多路开关选择器,因为一个选择器能够管理多个信道上的I/O操作。然而如果用传统的方式来处理这么多客户端,使用的方法是循环地一个一个地去检查所有的客户端是否有I/O操作,如果当前客户端有I/O操作,则可能把当前客户端扔给一个线程池去处理,如果没有I/O操作则进行下一个轮询,当所有的客户端都轮询过了又接着从头开始轮询;这种方法是非常笨而且也非常浪费资源,因为大部分客户端是没有I/O操作,我们也要去检查;而Selector就不一样了,它在内部可以同时管理多个I/O,当一个信道有I/O操作的时候,他会通知Selector,Selector就是记住这个信道有I/O操作,并且知道是何种I/O操作,是读呢?是写呢?还是接受新的连接;所以如果使用Selector,它返回的结果只有两种结果,一种是0,即在你调用的时刻没有任何客户端需要I/O操作,另一种结果是一组需要I/O操作的客户端,这是你就根本不需要再检查了,因为它返回给你的肯定是你想要的。这样一种通知的方式比那种主动轮询的方式要高效得多!
要使用选择器(Selector),需要创建一个Selector实例(使用静态工厂方法open())并将其注册(register)到想要监控的信道上(注意,这要通过channel的方法实现,而不是使用selector的方法)。最后,调用选择器的select()方法。该方法会阻塞等待,直到有一个或更多的信道准备好了I/O操作或等待超时。select()方法将返回可进行I/O操作的信道数量。现在,在一个单独的线程中,通过调用select()方法就能检查多个信道是否准备好进行I/O操作。如果经过一段时间后仍然没有信道准备好,select()方法就会返回0,并允许程序继续执行其他任务。
下面将上面的TCP服务端代码改写成NIO的方式(案例5):
public class ServerConnect
{
private static final int BUF_SIZE=1024 ;
private static final int PORT = 8080 ;
private static final int TIMEOUT = 3000 ;
public static void main (String[] args)
{
selector();
}
public static void handleAccept (SelectionKey key) throws IOException{
ServerSocketChannel ssChannel = (ServerSocketChannel)key.channel();
SocketChannel sc = ssChannel.accept();
sc.configureBlocking(false );
sc.register(key.selector(), SelectionKey.OP_READ,ByteBuffer.allocateDirect(BUF_SIZE));
}
public static void handleRead (SelectionKey key) throws IOException{
SocketChannel sc = (SocketChannel)key.channel();
ByteBuffer buf = (ByteBuffer)key.attachment();
long bytesRead = sc.read(buf);
while (bytesRead>0 ){
buf.flip();
while (buf.hasRemaining()){
System.out .print((char )buf.get ());
}
System.out .println();
buf.clear();
bytesRead = sc.read(buf);
}
if (bytesRead == -1 ){
sc.close();
}
}
public static void handleWrite (SelectionKey key) throws IOException{
ByteBuffer buf = (ByteBuffer)key.attachment();
buf.flip();
SocketChannel sc = (SocketChannel) key.channel();
while (buf.hasRemaining()){
sc.write(buf);
}
buf.compact();
}
public static void selector () {
Selector selector = null ;
ServerSocketChannel ssc = null ;
try {
selector = Selector.open();
ssc= ServerSocketChannel.open();
ssc.socket().bind(new InetSocketAddress(PORT));
ssc.configureBlocking(false );
ssc.register(selector, SelectionKey.OP_ACCEPT);
while (true ){
if (selector.select (TIMEOUT) == 0 ){
System.out .println("==" );
continue ;
}
Iterator iter = selector.selectedKeys().iterator();
while (iter.hasNext()){
SelectionKey key = iter.next();
if (key.isAcceptable()){
handleAccept(key);
}
if (key.isReadable()){
handleRead(key);
}
if (key.isWritable() && key.isValid()){
handleWrite(key);
}
if (key.isConnectable()){
System.out .println("isConnectable = true" );
}
iter.remove();
}
}
}catch (IOException e){
e.printStackTrace();
}finally {
try {
if (selector!=null ){
selector.close();
}
if (ssc!=null ){
ssc.close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
下面来慢慢讲解这段代码。
ServerSocketChannel
打开ServerSocketChannel:
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
关闭ServerSocketChannel:
serverSocketChannel.close ();
监听新进来的连接:
while (true ){
SocketChannel socketChannel = serverSocketChannel.accept();
}
ServerSocketChannel可以设置成非阻塞模式。在非阻塞模式下,accept() 方法会立刻返回,如果还没有新进来的连接,返回的将是null。 因此,需要检查返回的SocketChannel是否是null.如:
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open ();
serverSocketChannel.socket().bind(new InetSocketAddress(9999 ));
serverSocketChannel.configureBlocking(false );
while (true )
{
SocketChannel socketChannel = serverSocketChannel.accept();
if (socketChannel != null )
{
}
}
Selector
Selector的创建:Selector selector = Selector.open();
为了将Channel和Selector配合使用,必须将Channel注册到Selector上,通过SelectableChannel.register()方法来实现,沿用案例5中的部分代码:
ssc= ServerSocketChannel.open ()
ssc.socket ().bind (new InetSocketAddress(PORT))
ssc.configureBlocking (false)
ssc.register (selector, SelectionKey.OP _ACCEPT)
与Selector一起使用时,Channel必须处于非阻塞模式下。这意味着不能将FileChannel与Selector一起使用,因为FileChannel不能切换到非阻塞模式。而套接字通道都可以。
注意register()方法的第二个参数。这是一个“interest集合”,意思是在通过Selector监听Channel时对什么事件感兴趣。可以监听四种不同类型的事件:
1. Connect
2. Accept
3. Read
4. Write
通道触发了一个事件意思是该事件已经就绪。所以,某个channel成功连接到另一个服务器称为“连接就绪”。一个server socket channel准备好接收新进入的连接称为“接收就绪”。一个有数据可读的通道可以说是“读就绪”。等待写数据的通道可以说是“写就绪”。
这四种事件用SelectionKey的四个常量来表示:
1. SelectionKey.OP_CONNECT
2. SelectionKey.OP_ACCEPT
3. SelectionKey.OP_READ
4. SelectionKey.OP_WRITE
SelectionKey
当向Selector注册Channel时,register()方法会返回一个SelectionKey对象。这个对象包含了一些你感兴趣的属性:
interest集合
ready集合
Channel
Selector
附加的对象(可选)
interest集合:就像向Selector注册通道一节中所描述的,interest集合是你所选择的感兴趣的事件集合。可以通过SelectionKey读写interest集合。
ready 集合是通道已经准备就绪的操作的集合。在一次选择(Selection)之后,你会首先访问这个ready set。Selection将在下一小节进行解释。可以这样访问ready集合:
int readySet = selectionKey.readyOps();
可以用像检测interest集合那样的方法,来检测channel中什么事件或操作已经就绪。但是,也可以使用以下四个方法,它们都会返回一个布尔类型:
selectionKey.isAcceptable ()
selectionKey.isConnectable ()
selectionKey.isReadable ()
selectionKey.isWritable ()
从SelectionKey访问Channel和Selector很简单。如下:
Channel channel = selectionKey.channel();
Selector selector = selectionKey.selector ();
可以将一个对象或者更多信息附着到SelectionKey上,这样就能方便的识别某个给定的通道。例如,可以附加 与通道一起使用的Buffer,或是包含聚集数据的某个对象。使用方法如下:
selectionKey.attach (theObject)
Object attachedObj = selectionKey.attachment ()
还可以在用register()方法向Selector注册Channel的时候附加对象。如:
SelectionKey key = channel.register (selector, SelectionKey.OP _READ, theObject)
通过Selector选择通道
一旦向Selector注册了一或多个通道,就可以调用几个重载的select()方法。这些方法返回你所感兴趣的事件(如连接、接受、读或写)已经准备就绪的那些通道。换句话说,如果你对“读就绪”的通道感兴趣,select()方法会返回读事件已经就绪的那些通道。
下面是select()方法:
int select()
int select(long timeout)
int selectNow()
select()阻塞到至少有一个通道在你注册的事件上就绪了。 select(long timeout)和select()一样,除了最长会阻塞timeout毫秒(参数)。 selectNow()不会阻塞,不管什么通道就绪都立刻返回(译者注:此方法执行非阻塞的选择操作。如果自从前一次选择操作后,没有通道变成可选择的,则此方法直接返回零。)。
select()方法返回的int值表示有多少通道已经就绪。亦即,自上次调用select()方法后有多少通道变成就绪状态。如果调用select()方法,因为有一个通道变成就绪状态,返回了1,若再次调用select()方法,如果另一个通道就绪了,它会再次返回1。如果对第一个就绪的channel没有做任何操作,现在就有两个就绪的通道,但在每次select()方法调用之间,只有一个通道就绪了。
一旦调用了select()方法,并且返回值表明有一个或更多个通道就绪了,然后可以通过调用selector的selectedKeys()方法,访问“已选择键集(selected key set)”中的就绪通道。如下所示:
Set selectedKeys = selector.selectedKeys();
当向Selector注册Channel时,Channel.register()方法会返回一个SelectionKey 对象。这个对象代表了注册到该Selector的通道。
注意每次迭代末尾的keyIterator.remove()调用。Selector不会自己从已选择键集中移除SelectionKey实例。必须在处理完通道时自己移除。下次该通道变成就绪时,Selector会再次将其放入已选择键集中。
SelectionKey.channel()方法返回的通道需要转型成你要处理的类型,如ServerSocketChannel或SocketChannel等。
一个完整的使用Selector和ServerSocketChannel的案例可以参考案例5的selector()方法。
内存映射文件
JAVA处理大文件,一般用BufferedReader,BufferedInputStream这类带缓冲的IO类,不过如果文件超大的话,更快的方式是采用MappedByteBuffer。
MappedByteBuffer是NIO引入的文件内存映射方案,读写性能极高。NIO最主要的就是实现了对异步操作的支持。其中一种通过把一个套接字通道(SocketChannel)注册到一个选择器(Selector)中,不时调用后者的选择(select)方法就能返回满足的选择键(SelectionKey),键中包含了SOCKET事件信息。这就是select模型。
SocketChannel的读写是通过一个类叫ByteBuffer来操作的.这个类本身的设计是不错的,比直接操作byte[]方便多了. ByteBuffer有两种模式:直接/间接.间接模式最典型(也只有这么一种)的就是HeapByteBuffer,即操作堆内存 (byte[]).但是内存毕竟有限,如果我要发送一个1G的文件怎么办?不可能真的去分配1G的内存.这时就必须使用”直接”模式,即 MappedByteBuffer,文件映射.
先中断一下,谈谈操作系统的内存管理.一般操作系统的内存分两部分:物理内存;虚拟内存.虚拟内存一般使用的是页面映像文件,即硬盘中的某个(某些)特殊的文件.操作系统负责页面文件内容的读写,这个过程叫”页面中断/切换”. MappedByteBuffer也是类似的,你可以把整个文件(不管文件有多大)看成是一个ByteBuffer.MappedByteBuffer 只是一种特殊的ByteBuffer,即是ByteBuffer的子类。 MappedByteBuffer 将文件直接映射到内存(这里的内存指的是虚拟内存,并不是物理内存)。通常,可以映射整个文件,如果文件比较大的话可以分段进行映射,只要指定文件的那个部分就可以。
概念
FileChannel提供了map方法来把文件影射为内存映像文件: MappedByteBuffer map(int mode,long position,long size); 可以把文件的从position开始的size大小的区域映射为内存映像文件,mode指出了 可访问该内存映像文件的方式:
READ_ONLY,(只读): 试图修改得到的缓冲区将导致抛出 ReadOnlyBufferException.(MapMode.READ_ONLY)
READ_WRITE(读/写): 对得到的缓冲区的更改最终将传播到文件;该更改对映射到同一文件的其他程序不一定是可见的。 (MapMode.READ_WRITE)
PRIVATE(专用): 对得到的缓冲区的更改不会传播到文件,并且该更改对映射到同一文件的其他程序也不是可见的;相反,会创建缓冲区已修改部分的专用副本。 (MapMode.PRIVATE)
MappedByteBuffer是ByteBuffer的子类,其扩充了三个方法:
force():缓冲区是READ_WRITE模式下,此方法对缓冲区内容的修改强行写入文件;
load():将缓冲区的内容载入内存,并返回该缓冲区的引用;
isLoaded():如果缓冲区的内容在物理内存中,则返回真,否则返回假;
案例对比
这里通过采用ByteBuffer和MappedByteBuffer分别读取大小约为5M的文件”src/1.ppt”来比较两者之间的区别,method3()是采用MappedByteBuffer读取的,method4()对应的是ByteBuffer。
public static void method4(){
RandomAccessFile aFile = null
FileChannel fc = null
try{
aFile = new RandomAccessFile("src/1.ppt" ,"rw" )
fc = aFile.getChannel ()
long timeBegin = System.currentTimeMillis ()
ByteBuffer buff = ByteBuffer.allocate ((int) aFile.length ())
buff.clear ()
fc.read (buff)
//System.out .println ((char)buff.get ((int)(aFile.length ()/2 -1 )))
//System.out .println ((char)buff.get ((int)(aFile.length ()/2 )))
//System.out .println ((char)buff.get ((int)(aFile.length ()/2 )+1 ))
long timeEnd = System.currentTimeMillis ()
System.out .println ("Read time: " +(timeEnd-timeBegin)+"ms" )
}catch(IOException e){
e.printStackTrace ()
}finally{
try{
if(aFile!=null){
aFile.close ()
}
if(fc!=null){
fc.close ()
}
}catch(IOException e){
e.printStackTrace ()
}
}
}
public static void method3(){
RandomAccessFile aFile = null
FileChannel fc = null
try{
aFile = new RandomAccessFile("src/1.ppt" ,"rw" )
fc = aFile.getChannel ()
long timeBegin = System.currentTimeMillis ()
MappedByteBuffer mbb = fc.map (FileChannel.MapMode .READ _ONLY, 0 , aFile.length ())
// System.out .println ((char)mbb.get ((int)(aFile.length ()/2 -1 )))
// System.out .println ((char)mbb.get ((int)(aFile.length ()/2 )))
//System.out .println ((char)mbb.get ((int)(aFile.length ()/2 )+1 ))
long timeEnd = System.currentTimeMillis ()
System.out .println ("Read time: " +(timeEnd-timeBegin)+"ms" )
}catch(IOException e){
e.printStackTrace ()
}finally{
try{
if(aFile!=null){
aFile.close ()
}
if(fc!=null){
fc.close ()
}
}catch(IOException e){
e.printStackTrace ()
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
通过在入口函数main()中运行:
method3()
System.out .println ("=============" )
method4()
输出结果(运行在普通PC机上):
Read time: 12ms
通过输出结果可以看出彼此的差别,一个例子也许是偶然,那么下面把5M大小的文件替换为200M的文件,输出结果:
Read time: 407ms
可以看到差距拉大。
注:MappedByteBuffer有资源释放的问题:被MappedByteBuffer打开的文件只有在垃圾收集时才会被关闭,而这个点是不确定的。在Javadoc中这里描述:A mapped byte buffer and the file mapping that it represents remian valid until the buffer itself is garbage-collected。详细可以翻阅参考资料5和6.
其余功能介绍
看完以上陈述,详细大家对NIO有了一定的了解,下面主要通过几个案例,来说明NIO的其余功能,下面代码量偏多,功能性讲述偏少。
Scatter/Gatter
分散(scatter)从Channel中读取是指在读操作时将读取的数据写入多个buffer中。因此,Channel将从Channel中读取的数据“分散(scatter)”到多个Buffer中。
聚集(gather)写入Channel是指在写操作时将多个buffer的数据写入同一个Channel,因此,Channel 将多个Buffer中的数据“聚集(gather)”后发送到Channel。
scatter / gather经常用于需要将传输的数据分开处理的场合,例如传输一个由消息头和消息体组成的消息,你可能会将消息体和消息头分散到不同的buffer中,这样你可以方便的处理消息头和消息体。
案例:
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.Channel;
import java.nio.channels.FileChannel;
public class ScattingAndGather
{
public static void main(String args[]){
gather();
}
public static void gather()
{
ByteBuffer header = ByteBuffer.allocate(10 );
ByteBuffer body = ByteBuffer.allocate(10 );
byte [] b1 = {'0' , '1' };
byte [] b2 = {'2' , '3' };
header.put(b1);
body.put(b2);
ByteBuffer [] buffs = {header, body};
try
{
FileOutputStream os = new FileOutputStream("src/scattingAndGather.txt" );
FileChannel channel = os.getChannel();
channel.write(buffs);
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
transferFrom & transferTo
FileChannel的transferFrom()方法可以将数据从源通道传输到FileChannel中。
public static void method1 (){
RandomAccessFile fromFile = null ;
RandomAccessFile toFile = null ;
try
{
fromFile = new RandomAccessFile("src/fromFile.xml" ,"rw" );
FileChannel fromChannel = fromFile.getChannel();
toFile = new RandomAccessFile("src/toFile.txt" ,"rw" );
FileChannel toChannel = toFile.getChannel();
long position = 0 ;
long count = fromChannel.size();
System.out .println(count);
toChannel.transferFrom(fromChannel, position, count);
}
catch (IOException e)
{
e.printStackTrace();
}
finally {
try {
if (fromFile != null ){
fromFile.close();
}
if (toFile != null ){
toFile.close();
}
}
catch (IOException e){
e.printStackTrace();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
方法的输入参数position表示从position处开始向目标文件写入数据,count表示最多传输的字节数。如果源通道的剩余空间小于 count 个字节,则所传输的字节数要小于请求的字节数。此外要注意,在SoketChannel的实现中,SocketChannel只会传输此刻准备好的数据(可能不足count字节)。因此,SocketChannel可能不会将请求的所有数据(count个字节)全部传输到FileChannel中。
transferTo()方法将数据从FileChannel传输到其他的channel中。
public static void method2 ()
{
RandomAccessFile fromFile = null ;
RandomAccessFile toFile = null ;
try
{
fromFile = new RandomAccessFile("src/fromFile.txt" ,"rw" );
FileChannel fromChannel = fromFile.getChannel();
toFile = new RandomAccessFile("src/toFile.txt" ,"rw" );
FileChannel toChannel = toFile.getChannel();
long position = 0 ;
long count = fromChannel.size();
System.out .println(count);
fromChannel.transferTo(position, count,toChannel);
}
catch (IOException e)
{
e.printStackTrace();
}
finally {
try {
if (fromFile != null ){
fromFile.close();
}
if (toFile != null ){
toFile.close();
}
}
catch (IOException e){
e.printStackTrace();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
上面所说的关于SocketChannel的问题在transferTo()方法中同样存在。SocketChannel会一直传输数据直到目标buffer被填满。
Pipe
java NIO 管道是2个线程之间的单向数据连接。Pipe有一个source通道和一个sink通道。数据会被写到sink通道,从source通道读取。
public static void method1(){
Pipe pipe = null
ExecutorService exec = Executors.newFixedThreadPool (2 )
try{
pipe = Pipe.open ()
final Pipe pipeTemp = pipe
exec.submit (new Callable(){
@Override
public Object call () throws Exception
{
Pipe.SinkChannel sinkChannel = pipeTemp.sink ()
while(true){
TimeUnit.SECONDS .sleep (1 )
String newData = "Pipe Test At Time " +System.currentTimeMillis ()
ByteBuffer buf = ByteBuffer.allocate (1024 )
buf.clear ()
buf.put (newData.getBytes ())
buf.flip ()
while(buf.hasRemaining ()){
System.out .println (buf)
sinkChannel.write (buf)
}
}
}
})
exec.submit (new Callable(){
@Override
public Object call () throws Exception
{
Pipe.SourceChannel sourceChannel = pipeTemp.source ()
while(true){
TimeUnit.SECONDS .sleep (1 )
ByteBuffer buf = ByteBuffer.allocate (1024 )
buf.clear ()
int bytesRead = sourceChannel.read (buf)
System.out .println ("bytesRead=" +bytesRead)
while(bytesRead >0 ){
buf.flip ()
byte b[] = new byte[bytesRead]
int i=0
while(buf.hasRemaining ()){
b[i]=buf.get ()
System.out .printf ("%X" ,b[i])
i++
}
String s = new String(b)
System.out .println ("=================||" +s)
bytesRead = sourceChannel.read (buf)
}
}
}
})
}catch(IOException e){
e.printStackTrace ()
}finally{
exec.shutdown ()
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
DatagramChannel
Java NIO中的DatagramChannel是一个能收发UDP包的通道。因为UDP是无连接的网络协议,所以不能像其它通道那样读取和写入。它发送和接收的是数据包。
public static void reveive (){
DatagramChannel channel = null ;
try {
channel = DatagramChannel.open();
channel.socket().bind(new InetSocketAddress(8888 ));
ByteBuffer buf = ByteBuffer.allocate(1024 );
buf.clear();
channel.receive(buf);
buf.flip();
while (buf.hasRemaining()){
System.out .print((char )buf.get ());
}
System.out .println();
}catch (IOException e){
e.printStackTrace();
}finally {
try {
if (channel!=null ){
channel.close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
public static void send (){
DatagramChannel channel = null ;
try {
channel = DatagramChannel.open();
String info = "I'm the Sender!" ;
ByteBuffer buf = ByteBuffer.allocate(1024 );
buf.clear();
buf.put(info.getBytes());
buf.flip();
int bytesSent = channel.send(buf, new InetSocketAddress("10.10.195.115" ,8888 ));
System.out .println(bytesSent);
}catch (IOException e){
e.printStackTrace();
}finally {
try {
if (channel!=null ){
channel.close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
可以通过阅读参考资料2和3了解更多的NIO细节知识,前人栽树后人乘凉,这里就不赘述啦。
你可能感兴趣的:(java,nio,互联网)
kotlin标准库里面也有很多java类
yzpyzp
kotlin android java
Kotlin标准库中确实存在许多与Java类直接关联或基于Java类封装的结构,但这并不是“问题”,而是Kotlin与JVM生态深度兼容和互操作性的体现。以下从技术原理和设计哲学的角度详细解释:一、Kotlin与JVM的底层关系Kotlin代码最终会编译成JVM字节码,因此它必须与Java类库无缝协作。Kotlin标准库的设计原则之一就是兼容Java生态,其内部实现会直接或间接依赖Java标准库中
kotlin-kapt
yzpyzp
kotlin android
kotlin-kaptkotlin-kapt是Kotlin的一个插件,专门用于处理注解处理器(AnnotationProcessor)。以下是对该插件的详细解释和指南:kotlin-kapt是什么?kotlin-kapt是Kotlin官方提供的一个插件,用于在Kotlin项目中支持注解处理。KAPT(KotlinAnnotationProcessingTool)是JavaAPT(Annotatio
【JavaScript fetch API】简介和使用
williamdsy
前端 javascript 开发语言 ecmascript fetch api 简单使用
fetch是一个现代的JavaScriptAPI,用于获取资源,例如从网络服务器获取数据。它提供了一种比传统的XMLHttpRequest更简洁、更易于使用的机制来进行网络请求。fetch基于Promise,这使得异步操作更容易处理。核心概念:fetch(url,[options]):这是fetchAPI的核心函数。它接受一个URL作为第一个参数,可选地接受一个包含请求配置的options对象作为
颠覆传统Java性能瓶颈:Quarkus+GraalVM原生镜像实战解析
桂月二二
java 开发语言
引言:云原生时代的Java困境在容器化与Serverless架构大行其道的今天,传统Java应用的启动速度与内存消耗已成为制约其发展的关键瓶颈。当Node.js应用在300ms内完成冷启动时,SpringBoot应用可能还在JVM预热阶段。本文将揭秘如何通过Quarkus框架与GraalVM原生编译技术,打造启动时间findByOrderNumber(StringorderNumber){retu
JavaScript Fetch
noPermission
JavaScript javascript 前端 开发语言
一、什么是fetch?在前端的发展历程中用于请求网络资源的方式主要有三种:从原生的XMLHttpRequest到jQuery的Ajax再到现在主流的axios,其中Ajax和axios都是对XMLHttpRequest的封装(本质上都是使用XMLHttpRequest方法获取网络资源),这些封装库让开发者对XMLHttpRequest的使用变得更简单高效。然而fetch的推出使开发者对网络资源的异
JAVA架构师需要掌握的常用架构模式有哪些?
猿享天开
Java开发从入门到精通 java 架构 开发语言
引言Java架构师必须掌握常用技术组合及其选型逻辑。技术组合的选择直接影响系统的可扩展性、性能和维护成本。以下是当前主流技术组合、选型原则及常用架构应用的详细说明:一、当前主流技术组合及其应用场景1.基础开发框架技术组合应用场景核心优势SpringBoot+MyBatis+MySQL中小型单体应用、快速迭代业务开发效率高、ORM轻量、数据库兼容性强SpringBoot+JPA+PostgreSQL
ServletRequest 和 HttpServletRequest 的关系
牛马白菜价
tomcat servlet
1.ServletRequest和HttpServletRequest的关系ServletRequest接口:它是JavaServletAPI中的一个核心接口,定义了客户端请求的基本信息和操作方法。该接口提供了通用的请求处理功能,适用于各种协议的请求。例如,它可以获取请求的参数、属性等信息。HttpServletRequest接口:HttpServletRequest是ServletRequest
【JavaScript】异常处理详解
Peter-Lu
# JavaScript javascript 前端 ecmascript
文章目录一、JavaScript异常处理概述1.什么是异常?2.为什么需要异常处理?二、JavaScript中的异常类型1.系统异常示例2.自定义异常示例三、异常处理的基本语法1.try...catch详解2.finally详解四、throw关键字1.手动抛出异常2.自定义异常类型五、异常处理的最佳实践1.避免过度捕获异常2.提供有意义的错误信息3.使用finally释放资源4.避免在finall
Java高级特性(基础知识点总结)
杰—
java
文章目录第三章:java高级API1️⃣什么是集合面试题:集合分为2个顶级接口:分别为Collection和Map面试题面试题2:面试题3Map接口:HashMap的数据结构面试题:面试题面试题包装类:JavaApi输入流和输出流会使用File类操作文件或目录File类的构造方法IO流的分类4大顶级抽象父类字符集基础知识:字节输出流写数据的步骤流的关闭与刷新第三章:java高级API1️⃣什么是集
使用Spring Boot开发后端应用:在IntelliJ IDEA中的实践指南
风亦辰739
后端 spring boot java intellij-idea
一、什么是SpringBoot?SpringBoot是一个开源框架,用于简化Java应用的构建过程,尤其是Web应用。它是基于Spring框架的,提供了许多开箱即用的功能,极大地简化了Spring应用的配置和开发过程。SpringBoot让开发者无需关注繁琐的配置,可以专注于业务逻辑的实现。SpringBoot的优势:自动配置:SpringBoot根据项目的依赖自动配置相关功能,避免手动配置繁琐的
Django学习笔记(第一天:Django基本知识简介与启动)
S1901
python Django django 学习 笔记
博主毕业已经工作一年多了,最基本的测试工作已经完全掌握。一方面为了解决当前公司没有自动化测试平台的痛点,另一方面为了向更高级的测试架构师转型,于是重温Django的知识,用于后期搭建测试自动化平台。为什么不选择Java:Python语法简洁易读,适合快速开发。Selenium、Appium、pytest、Requests等工具对Python支持极好,且有丰富的文档和社区资源。Django简介Dja
详解javascript的bind方法
北京王老师
js vue java javascript python
JS的bind()方法创建一个新的函数,在bind()被调用时,这个新函数的this被指定为bind()的第一个参数,而其余参数将作为新函数的参数,供调用时使用。通过bind可解决两个问题:1)以隐蔽和优雅的方式解决依赖注入的问题,可以将函数执行需要的上下文环境对象通过bind方法传递给函数,在函数内部直接使用this来引用。2)解决多层调用时this对象无法传递给内部函数的问题,实际是第一个问题
详解 JavaScript 中 fetch 方法
ttod_qzstudio
JavaScript JavaScript
在现代的Web开发中,与服务器进行数据交互是一项常见且重要的任务。JavaScript提供了多种方式来实现这一功能,其中fetch方法是一个强大且灵活的工具。本文将详细介绍fetch方法的各个方面,帮助你更好地理解和使用它。什么是fetch方法fetch是JavaScript中用于发起网络请求的现代API,它提供了一种更简洁、更强大的方式来处理网络通信。fetch方法返回一个Promise对象,该
Struts2 命令执行漏洞 S2-045 复现:深入剖析与实战演练
垚垚 Securify 前沿站
十大漏洞 网络 系统安全 web安全 struts 安全 计算机网络 后端
目录前言一、漏洞原理:框架解析缺陷引发的安全危机二、复现环境搭建:搭建模拟战场,重现漏洞场景三、复现步骤:步步为营,揭开漏洞利用的面纱四、漏洞危害与修复建议:正视漏洞危害,筑牢安全防线前言在当今网络安全形势日益严峻的大环境下,Web应用框架的安全问题始终是信息安全领域关注的焦点。Struts2作为一款广泛应用于JavaWeb开发的开源框架,其安全性直接关系到众多Web应用的稳定运行。今天,我们将深
eclipse2017支持的Servlet的版本_jsp进阶(servlet篇)
weixin_39814369
Servlet篇(jsp重点)@author:杜勇帅@email:820482874@qq.com-一.Servlet基础一.Servlet概述Servlet是运行在服务器端的java程序(类),作用是接收并处理客户端的请求,生成响应给客户端。学习了Servlet后,jsp页面只负责展示数据,Servlet负责处理请求(调用Dao实现具体功能),并将数据转发到jsp页面上去展示(生成响应给客户端)
java lambda表达式编译_什么是Java 8 Lambda表达式编译?
我是一只萤火虫呀
java lambda表达式编译
参见英文答案>HowwillJavalambdafunctionsbecompiled?考虑下面的Java8代码段。publicstaticvoidmain(String[]args){Listintegers=Arrays.asList(1,2,3,4,5);Consumerconsumer=x->System.out.print(x);integers.forEach(consumer);}什
线程同步CountDownLatch的使用
初夏の猫
java 开发语言
CountDownLatch是Java中一个常用的同步工具类,主要用于协调多个线程的执行。它可以让一个或多个线程等待,直到其他线程执行完毕后才能继续。常见的使用场景是多个线程执行一些并行任务,主线程需要等待所有线程完成任务才能继续执行。基本概念:CountDownLatch类接受一个初始计数值,这个计数值通常是线程的数量。每个线程在完成其任务时调用countDown()方法将计数值减1,直到计数值
2021-03-01-深入浅出解析jsp
热爱Java的程序猿
后端 jsp servlet java
来历servlet的缺点导致jsp的产生JSP全称是JavaServerPagesjsp=html+js+Java+Tag用法servlet只负责响应请求产生数据,并把数据通过转发技术带给jsp,数据的显示交给jsp来做在长期的软件实践中,人们逐渐把servlet作为web应用中的控制器组件来使用,而把JSP技术作为数据显示模板来使用原理所有的jsp最后都编译成servlet,编译后的路径一般在t
小记 Java stream 中 peek()
神奏
盛开 java lambda
peek函数:接受一个函数作为参数。这个函数会被应用到每个元素上,并将结果元素映射成一个新的元素。相比于类似foreach,更类似于lambda中的map函数。map函数:接受一个函数作为参数。这个函数会被应用到每个元素上,并将返回值映射成一个新的元素。简单来说,map函数就是对流对象(集合中的所有对象)进行操作并返回一个Stream对象,这个Object对象可以是源对象的类型,也可以是其他类型。
HttpServletRequest 作用
冰糖心158
2025 Java面试系列 Java 开发 java
HttpServletRequest接口在JavaServletAPI中扮演着至关重要的角色,它是Servlet处理客户端HTTP请求的核心对象。每次客户端(例如浏览器)向服务器发送一个HTTP请求时,Servlet容器(例如Tomcat)都会创建一个HttpServletRequest对象,并将客户端的请求数据封装在这个对象中,然后将这个对象传递给Servlet的service()方法(或者do
Java进阶之泛型
m0_74824483
面试 学习路线 阿里巴巴 java 开发语言
泛型(Generics)定义泛型:允许在定义类、接口和方法时使用类型参数,从而在编译时捕获类型错误,提高代码的类型安全性和复用性。主要用途类型安全:避免类型转换错误,编译时检查类型安全。代码复用:通过泛型可以编写通用的类和方法,适用于多种数据类型。消除强制类型转换:在使用泛型时,编译器会自动进行类型转换,减少代码中的强制类型转换。泛型的基本语法标记符T是类型参数,通常使用T、E、K、V等字母来表示
ES java客户端中关于BucketSortPipelineAggregationBuilder的问题
Sunager
ElasticSearch elasticsearch java
es聚合后进行分页(非标准分页,涉及到es底层的检索方式)es桶聚合后排序介绍见ES指南介绍//kibana对聚合后的数据GET/_search{"query":{"bool":{"filter":[{"match":{"question":"好的"}},{"range":{
SpringBoot Jwt令牌的使用(黑马javaweb)
liuaiguo75
SpringBoot JAVA Idea spring boot 后端 java spring intellij-idea log4j mybatis
JWT概念JSONWebToken(JWT)是一种开放标准(RFC7519),它定义了一种紧凑和自包含的方式,用于作为JSON对象在各方之间安全地传输信息。这个信息可以被验证和信任,因为它是数字签名的。JWTs可以使用秘密(使用HMAC算法)或使用RSA或ECDSA的公钥/私钥对进行签名。JWT作用1、授权2、信息交换JWT示例代码1、SpringBoot中引入JWTio.jsonwebtoken
java.lang.IllegalStateException: No thread-bound request found 解决方法
摸鱼码长
子线程共享 异步Feign调用 java 后端 经验分享 spring boot
1、让我们看看这熟悉的报错java.lang.IllegalStateException:Nothread-boundrequestfound:Areyoureferringtorequestattributesoutsideofanactualwebrequest,orprocessingarequestoutsideoftheoriginallyreceivingthread?Ifyouare
浅谈Java Spring Boot 框架分析和理解
微笑的曙光(StevenLi)
JAVA java spring boot 开发语言
SpringBoot是一个简化Spring开发的框架,它遵循“约定优于配置”的原则,通过内嵌的Tomcat、Jetty或Undertow等容器,使得开发者能够快速构建独立运行的、生产级别的基于Spring框架的应用程序。SpringBoot包含了大量的自动配置功能,可智能识别已存在的库并配置相应组件,从而减少手动配置的工作量。JavaSpringBoot是一个基于Spring框架的开源Java框架
【LeetCode Hot100】盛最多水的容器[特殊字符]双指针法,Java实现!图文详解,小白也能秒懂!
AllowM
算法hot100 leetcode java 算法
[LeetCodeHot100]盛最多水的容器双指针法,Java实现!图文详解,小白也能秒懂!✏️本文对应题目链接:盛最多水的容器题目描述给定一个长度为n的整数数组height,其中height[i]表示第i条垂直线的高度。找出其中的两条线,使得它们与x轴共同构成的容器可以容纳最多的水。示例:输入:height=[1,8,6,2,5,4,8,3,7]输出:49解释:选择第2条线(高度8)和第9条线
2024年前端最全Java进阶(五十五)-Java Lambda表达式入门_eclipse lambda(2),程序员面试技巧和注意事项
2401_84435192
程序员 前端 面试 学习
算法冒泡排序选择排序快速排序二叉树查找:最大值、最小值、固定值二叉树遍历二叉树的最大深度给予链表中的任一节点,把它删除掉链表倒叙如何判断一个单链表有环由于篇幅限制小编,pdf文档的详解资料太全面,细节内容实在太多啦,所以只把部分知识点截图出来粗略的介绍,每个小节点里面都有更细化的内容!如果你觉得对你有帮助,可以戳这里获取:【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】"And
2024年Java进阶(五十五)-Java Lambda表达式入门_eclipse lambda,2024年最新阿里员工面试
2401_84446712
程序员 前端 面试 学习
最后一个好的心态和一个坚持的心很重要,很多冲着高薪的人想学习前端,但是能学到最后的没有几个,遇到困难就放弃了,这种人到处都是,就是因为有的东西难,所以他的回报才很大,我们评判一个前端开发者是什么水平,就是他解决问题的能力有多强。开源分享:【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】分享一些前端面试题以及学习路线给大家###基本的Lambda例子 现在,我们已经知道什么是l
Java可视化界面
Justice link
java python 开发语言
一。使用JFrame(创建窗口)JDialog(创建新窗口) //1.创建一个窗口对象JFrameframe=newJFrame("一个文件");//2.创建一个容器Containercontainer=frame.getContentPane();//3.为容器添加颜色container.setBackground(Color.gray);//4.为窗口设置大小窗口frame.setBou
使用亚马逊针对 PyTorch 和 MinIO 的 S3 连接器进行模型检查点处理
MinIO分布式存储
分布式存储 MinIO pytorch 百度云 人工智能
2023年11月,Amazon宣布推出适用于PyTorch的S3连接器。适用于PyTorch的AmazonS3连接器提供了专为S3对象存储构建的PyTorch数据集基元(数据集和数据加载器)的实现。它支持用于随机数据访问模式的地图样式数据集和用于流式处理顺序数据访问模式的可迭代样式数据集。适用于PyTorch的S3连接器还包括一个检查点接口,用于将检查点直接保存和加载到S3存储桶,而无需先保存到本
Nginx负载均衡
510888780
nginx 应用服务器
Nginx负载均衡一些基础知识:
nginx 的 upstream目前支持 4 种方式的分配
1)、轮询(默认)
每个请求按时间顺序逐一分配到不同的后端服务器,如果后端服务器down掉,能自动剔除。
2)、weight
指定轮询几率,weight和访问比率成正比
RedHat 6.4 安装 rabbitmq
bylijinnan
erlang rabbitmq redhat
在 linux 下安装软件就是折腾,首先是测试机不能上外网要找运维开通,开通后发现测试机的 yum 不能使用于是又要配置 yum 源,最后安装 rabbitmq 时也尝试了两种方法最后才安装成功
机器版本:
[root@redhat1 rabbitmq]# lsb_release
LSB Version: :base-4.0-amd64:base-4.0-noarch:core
FilenameUtils工具类
eksliang
FilenameUtils common-io
转载请出自出处:http://eksliang.iteye.com/blog/2217081 一、概述
这是一个Java操作文件的常用库,是Apache对java的IO包的封装,这里面有两个非常核心的类FilenameUtils跟FileUtils,其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装,开发中对文件的操作,几乎都可以在这个框架里面找到。 非常的好用。
xml文件解析SAX
不懂事的小屁孩
xml
xml文件解析:xml文件解析有四种方式,
1.DOM生成和解析XML文档(SAX是基于事件流的解析)
2.SAX生成和解析XML文档(基于XML文档树结构的解析)
3.DOM4J生成和解析XML文档
4.JDOM生成和解析XML
本文章用第一种方法进行解析,使用android常用的DefaultHandler
import org.xml.sax.Attributes;
通过定时任务执行mysql的定期删除和新建分区,此处是按日分区
酷的飞上天空
mysql
使用python脚本作为命令脚本,linux的定时任务来每天定时执行
#!/usr/bin/python
# -*- coding: utf8 -*-
import pymysql
import datetime
import calendar
#要分区的表
table_name = 'my_table'
#连接数据库的信息
host,user,passwd,db =
如何搭建数据湖架构?听听专家的意见
蓝儿唯美
架构
Edo Interactive在几年前遇到一个大问题:公司使用交易数据来帮助零售商和餐馆进行个性化促销,但其数据仓库没有足够时间去处理所有的信用卡和借记卡交易数据
“我们要花费27小时来处理每日的数据量,”Edo主管基础设施和信息系统的高级副总裁Tim Garnto说道:“所以在2013年,我们放弃了现有的基于PostgreSQL的关系型数据库系统,使用了Hadoop集群作为公司的数
spring学习——控制反转与依赖注入
a-john
spring
控制反转(Inversion of Control,英文缩写为IoC)是一个重要的面向对象编程的法则来削减计算机程序的耦合问题,也是轻量级的Spring框架的核心。 控制反转一般分为两种类型,依赖注入(Dependency Injection,简称DI)和依赖查找(Dependency Lookup)。依赖注入应用比较广泛。
用spool+unixshell生成文本文件的方法
aijuans
xshell
例如我们把scott.dept表生成文本文件的语句写成dept.sql,内容如下:
set pages 50000;
set lines 200;
set trims on;
set heading off;
spool /oracle_backup/log/test/dept.lst;
select deptno||','||dname||','||loc
1、基础--名词解析(OOA/OOD/OOP)
asia007
学习基础知识
OOA:Object-Oriented Analysis(面向对象分析方法)
是在一个系统的开发过程中进行了系统业务调查以后,按照面向对象的思想来分析问题。OOA与结构化分析有较大的区别。OOA所强调的是在系统调查资料的基础上,针对OO方法所需要的素材进行的归类分析和整理,而不是对管理业务现状和方法的分析。
OOA(面向对象的分析)模型由5个层次(主题层、对象类层、结构层、属性层和服务层)
浅谈java转成json编码格式技术
百合不是茶
json编码 java转成json编码
json编码;是一个轻量级的数据存储和传输的语言
在java中需要引入json相关的包,引包方式在工程的lib下就可以了
JSON与JAVA数据的转换(JSON 即 JavaScript Object Natation,它是一种轻量级的数据交换格式,非
常适合于服务器与 JavaScript 之间的数据的交
web.xml之Spring配置(基于Spring+Struts+Ibatis)
bijian1013
java web.xml SSI spring配置
指定Spring配置文件位置
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/spring-dao-bean.xml,/WEB-INF/spring-resources.xml,
/WEB-INF/
Installing SonarQube(Fail to download libraries from server)
sunjing
Install Sonar
1. Download and unzip the SonarQube distribution
2. Starting the Web Server
The default port is "9000" and the context path is "/". These values can be changed in &l
【MongoDB学习笔记十一】Mongo副本集基本的增删查
bit1129
mongodb
一、创建复本集
假设mongod,mongo已经配置在系统路径变量上,启动三个命令行窗口,分别执行如下命令:
mongod --port 27017 --dbpath data1 --replSet rs0
mongod --port 27018 --dbpath data2 --replSet rs0
mongod --port 27019 -
Anychart图表系列二之执行Flash和HTML5渲染
白糖_
Flash
今天介绍Anychart的Flash和HTML5渲染功能
HTML5
Anychart从6.0第一个版本起,已经逐渐开始支持各种图的HTML5渲染效果了,也就是说即使你没有安装Flash插件,只要浏览器支持HTML5,也能看到Anychart的图形(不过这些是需要做一些配置的)。
这里要提醒下大家,Anychart6.0版本对HTML5的支持还不算很成熟,目前还处于
Laravel版本更新异常4.2.8-> 4.2.9 Declaration of ... CompilerEngine ... should be compa
bozch
laravel
昨天在为了把laravel升级到最新的版本,突然之间就出现了如下错误:
ErrorException thrown with message "Declaration of Illuminate\View\Engines\CompilerEngine::handleViewException() should be compatible with Illuminate\View\Eng
编程之美-NIM游戏分析-石头总数为奇数时如何保证先动手者必胜
bylijinnan
编程之美
import java.util.Arrays;
import java.util.Random;
public class Nim {
/**编程之美 NIM游戏分析
问题:
有N块石头和两个玩家A和B,玩家A先将石头随机分成若干堆,然后按照BABA...的顺序不断轮流取石头,
能将剩下的石头一次取光的玩家获胜,每次取石头时,每个玩家只能从若干堆石头中任选一堆,
lunce创建索引及简单查询
chengxuyuancsdn
查询 创建索引 lunce
import java.io.File;
import java.io.IOException;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Docume
[IT与投资]坚持独立自主的研究核心技术
comsci
it
和别人合作开发某项产品....如果互相之间的技术水平不同,那么这种合作很难进行,一般都会成为强者控制弱者的方法和手段.....
所以弱者,在遇到技术难题的时候,最好不要一开始就去寻求强者的帮助,因为在我们这颗星球上,生物都有一种控制其
flashback transaction闪回事务查询
daizj
oracle sql 闪回事务
闪回事务查询有别于闪回查询的特点有以下3个:
(1)其正常工作不但需要利用撤销数据,还需要事先启用最小补充日志。
(2)返回的结果不是以前的“旧”数据,而是能够将当前数据修改为以前的样子的撤销SQL(Undo SQL)语句。
(3)集中地在名为flashback_transaction_query表上查询,而不是在各个表上通过“as of”或“vers
Java I/O之FilenameFilter类列举出指定路径下某个扩展名的文件
游其是你
FilenameFilter
这是一个FilenameFilter类用法的例子,实现的列举出“c:\\folder“路径下所有以“.jpg”扩展名的文件。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
C语言学习五函数,函数的前置声明以及如何在软件开发中合理的设计函数来解决实际问题
dcj3sjt126com
c
# include <stdio.h>
int f(void) //括号中的void表示该函数不能接受数据,int表示返回的类型为int类型
{
return 10; //向主调函数返回10
}
void g(void) //函数名前面的void表示该函数没有返回值
{
//return 10; //error 与第8行行首的void相矛盾
}
in
今天在测试环境使用yum安装,遇到一个问题: Error: Cannot retrieve metalink for repository: epel. Pl
dcj3sjt126com
centos
今天在测试环境使用yum安装,遇到一个问题:
Error: Cannot retrieve metalink for repository: epel. Please verify its path and try again
处理很简单,修改文件“/etc/yum.repos.d/epel.repo”, 将baseurl的注释取消, mirrorlist注释掉。即可。
&n
单例模式
shuizhaosi888
单例模式
单例模式 懒汉式
public class RunMain {
/**
* 私有构造
*/
private RunMain() {
}
/**
* 内部类,用于占位,只有
*/
private static class SingletonRunMain {
priv
Spring Security(09)——Filter
234390216
Spring Security
Filter
目录
1.1 Filter顺序
1.2 添加Filter到FilterChain
1.3 DelegatingFilterProxy
1.4 FilterChainProxy
1.5
公司项目NODEJS实践0.1
逐行分析JS源代码
mongodb nginx ubuntu nodejs
一、前言
前端如何独立用nodeJs实现一个简单的注册、登录功能,是不是只用nodejs+sql就可以了?其实是可以实现,但离实际应用还有距离,那要怎么做才是实际可用的。
网上有很多nod
java.lang.Math
liuhaibo_ljf
java Math lang
System.out.println(Math.PI);
System.out.println(Math.abs(1.2));
System.out.println(Math.abs(1.2));
System.out.println(Math.abs(1));
System.out.println(Math.abs(111111111));
System.out.println(Mat
linux下时间同步
nonobaba
ntp
今天在linux下做hbase集群的时候,发现hmaster启动成功了,但是用hbase命令进入shell的时候报了一个错误 PleaseHoldException: Master is initializing,查看了日志,大致意思是说master和slave时间不同步,没办法,只好找一种手动同步一下,后来发现一共部署了10来台机器,手动同步偏差又比较大,所以还是从网上找现成的解决方
ZooKeeper3.4.6的集群部署
roadrunners
zookeeper 集群 部署
ZooKeeper是Apache的一个开源项目,在分布式服务中应用比较广泛。它主要用来解决分布式应用中经常遇到的一些数据管理问题,如:统一命名服务、状态同步、集群管理、配置文件管理、同步锁、队列等。这里主要讲集群中ZooKeeper的部署。
1、准备工作
我们准备3台机器做ZooKeeper集群,分别在3台机器上创建ZooKeeper需要的目录。
数据存储目录
Java高效读取大文件
tomcat_oracle
java
读取文件行的标准方式是在内存中读取,Guava 和Apache Commons IO都提供了如下所示快速读取文件行的方法: Files.readLines(new File(path), Charsets.UTF_8); FileUtils.readLines(new File(path)); 这种方法带来的问题是文件的所有行都被存放在内存中,当文件足够大时很快就会导致
微信支付api返回的xml转换为Map的方法
xu3508620
xml map 微信api
举例如下:
<xml>
<return_code><![CDATA[SUCCESS]]></return_code>
<return_msg><![CDATA[OK]]></return_msg>
<appid><