java nio socket 异步接收数据

nio socket 异步接收数据,如何确定收接的数据,就是发送的返回的?有谁研究过没。

5个回答

在消息中增加UUID,在调用端记录UUID,并将UUID和消息一起发送到服务端,服务端的回传消息附件上UUID,调用端根据收到的消息包含的UUID确定给哪个调用者。

love398146779
love398146779 nio客户端是否可以同步接收数据呢?是把socketChannel.configureBlocking(true)吗?
大约 6 年之前 回复

我不大了解,按原理来说非阻塞的可以用消息标识加以区分吧

你可以给出去的消息加一个标识,让他回来的时候带上这个标识

nio又不是一个socket来处理所有的请求

socket这里是讲会话周期,一个对话中request肯定对应的是一个response

异步调用的常见问题。因为没有办法实施返回,只有打标志了。要你把通信协议规化好。

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
nio socket 异步客户端读取时的问题!

<p> </p> <p>最近学习java的nio socket非阻塞模式编程</p> <p>服务器端发送信息格式如下: 8位的头部包含类型和信息的长度 如 LLWH002001234567890123456789,后面的信息中包含gb2312编码的汉字。</p> <p>写客户端的时候碰到个问题:</p> <p>SocketChannel的read(ByteBuffer[] dsts, int offset, int length)方法还没弄清楚怎么使用。</p> <p>服务端发来 LLWH002001234567890123456789 这个消息时,用read(ByteBuffer dst) 这个方法读取到信息经常是分成好多段,</p> <p>怎么才能把全部信息读取到ByteBuffer里头。</p> <p>现在的代码如下:</p> <p> </p> <pre name="code" class="java"> public void Rec() throws IOException { int count; r_buff.clear(); count = sc.read(r_buff); r_buff.flip(); byte[] temp = new byte[r_buff.limit()]; r_buff.get(temp); System.out.println("reply is " + count + " long, and content is: " + new String(temp)); }</pre>

Java做socket实时接收数据存入数据库不及时?

* 应公司业务做了一个基于socket的实时接收数据的功能,就是我java后端写了一个服务端是基于UDP协议的,实时接收客服端发来的数据,对数据进行处理存入数据库。 * 目前的客户端发来的数据比较快,一秒能有10个包发过来,每个包的数据也不大,挺小的,但就是我在处理这些数据的时候写的逻辑运算比较多,造成了目前存入数据库时不能达到所谓的实时更新的效果 * 我说一下这个数据必须要在页面实时更新展示的 * 补充一下:是开启多个客户端同时向服务端发送数据的,就比如目前有三个客户端对服务端同时发送数据(同一个端口),就会出现数据存入数据库不及时,但数据是已经接收到了(我在控制台打印看到了,只是没有及时存到数据库) * 如果只是一个客户端向数据库发送数据就可以达到理想化的实时存入数据库然后在页面实时展现数据,多个就不行了 * 想问下各位大佬,是程序运行的太慢了,还是什么原因呢?我也做了开启多线程执行程序了啊 ``` public String startDs() { DatagramSocket socket = null; try { socket = new DatagramSocket(8800); } catch (SocketException e) { e.printStackTrace(); } //记录客户端的数量 int count = 0; while (true) { data = new byte[16];// 创建字节数组,指定接收的数据包的大小 packet = new DatagramPacket(data, data.length); try { socket.receive(packet); } catch (IOException e) { e.printStackTrace(); } // 此方法在接收到数据报之前会一直阻塞 Thread thread = new Thread(new UDPThread(socket, packet)); thread.start(); } } ```

java NIO写入和读取的数据不一样 丢失了很多数据 怎么解决

java NIO写入和读取的数据不一样 丢失了很多数据 怎么解决 我把图片对象存入Bytebuffer, 发到服务器读取后,很多图片都是不完整的

java nio 如何实现 阻塞读 不阻塞写

java nio 如何实现 阻塞读 不阻塞写 java nio 如何实现 阻塞读 不阻塞写

关于java 实现socket的异步通信

我在网上也找到一个例子,但是没有客户端,我自己写了一个用ServerSocket连的客户端,但是连接上后不能写也不能读,不知道怎么回事,请高手解决。最好能给一个简单异步编程的例子。 下面是代码: package org.scorpion.scoket; /** * * @author chenjd */ import java.io.IOException; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.Socket; import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.channels.SelectableChannel; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.nio.charset.CharacterCodingException; import java.nio.charset.Charset; import java.nio.charset.CharsetDecoder; import java.util.HashMap; import java.util.Iterator; import java.util.Set; public class NBServer { int port = 8090; int BUFFERSIZE = 1024; Selector selector = null; ServerSocketChannel serverChannel = null; HashMap clientChannelMap = null;// 用来存放每一个客户连接对应的套接字和通道 public NBServer(int port) { this.clientChannelMap = new HashMap(); this.port = port; } public void initialize() throws IOException { // 初始化,分别实例化一个选择器,一个服务器端可选择通道 this.selector = Selector.open(); this.serverChannel = ServerSocketChannel.open(); this.serverChannel.configureBlocking(false); InetAddress localhost = InetAddress.getLocalHost(); InetSocketAddress isa = new InetSocketAddress(localhost, this.port); this.serverChannel.socket().bind(isa);// 将该套接字绑定到服务器某一可用端口 } // 结束时释放资源 public void finalize() throws IOException { this.serverChannel.close(); this.selector.close(); } // 将读入字节缓冲的信息解码 public String decode(ByteBuffer byteBuffer) throws CharacterCodingException { Charset charset = Charset.forName("ISO-8859-1"); CharsetDecoder decoder = charset.newDecoder(); CharBuffer charBuffer = decoder.decode(byteBuffer); String result = charBuffer.toString(); return result; } // 监听端口,当通道准备好时进行相应操作 public void portListening(String data) throws IOException, InterruptedException { // 服务器端通道注册OP_ACCEPT事件 SelectionKey acceptKey = this.serverChannel.register(this.selector, SelectionKey.OP_ACCEPT); // 当有已注册的事件发生时,select()返回值将大于0 while (acceptKey.selector().select() > 0) { System.out.println("event happened"); // 取得所有已经准备好的所有选择键 Set readyKeys = this.selector.selectedKeys(); // 使用迭代器对选择键进行轮询 Iterator i = readyKeys.iterator(); while (i.hasNext()) { SelectionKey key = (SelectionKey) i.next(); i.remove();// 删除当前将要处理的选择键 if (key.isAcceptable()) {// 如果是有客户端连接请求 System.out.println("more client connect in!"); ServerSocketChannel nextReady = (ServerSocketChannel) key .channel(); // 获取客户端套接字 Socket s = nextReady.accept().socket(); // 设置对应的通道为异步方式并注册感兴趣事件 s.getChannel().configureBlocking(false); SelectionKey readWriteKey = s.getChannel().register( this.selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE); // 将注册的事件与该套接字联系起来 readWriteKey.attach(s); // 将当前建立连接的客户端套接字及对应的通道存放在哈希表//clientChannelMap中 this.clientChannelMap.put(s, new ClientChInstance(s .getChannel())); } else if (key.isReadable()) {// 如果是通道读准备好事件 System.out.println("Readable"); // 取得选择键对应的通道和套接字 SelectableChannel nextReady = (SelectableChannel) key .channel(); Socket socket = (Socket) key.attachment(); // 处理该事件,处理方法已封装在类ClientChInstance中 this.readFromChannel(socket.getChannel(), (ClientChInstance) this.clientChannelMap .get(socket)); } else if (key.isWritable()) {// 如果是通道写准备好事件 System.out.println("writeable"); // 取得套接字后处理,方法同上 Socket socket = (Socket) key.attachment(); SocketChannel channel = (SocketChannel) socket.getChannel(); // this.writeToChannel(channel, "This is from server!"); this.writeToChannel(channel, data); } } } } // 对通道的写操作 public void writeToChannel(SocketChannel channel, String message) throws IOException { ByteBuffer buf = ByteBuffer.wrap(message.getBytes()); int nbytes = channel.write(buf); } // 对通道的读操作 public void readFromChannel(SocketChannel channel, ClientChInstance clientInstance) throws IOException, InterruptedException { ByteBuffer byteBuffer = null; try{ byteBuffer = ByteBuffer.allocate(BUFFERSIZE); int nbytes = channel.read(byteBuffer); }catch(Exception e){ clientChannelMap.remove(channel.socket()); channel.close(); e=null; return; } byteBuffer.flip(); String result = this.decode(byteBuffer); // 当客户端发出”@exit”退出命令时,关闭其通道 if (result.indexOf("@exit") >= 0||result.indexOf("q")>=0) { channel.close(); } // else if(result.indexOf("@close") >= 0){//关闭服务 // channel.close(); // this.finalize(); // } else { clientInstance.append(result.toString()); // 读入一行完毕,执行相应操作 if (result.indexOf("\n") >= 0) { System.out.println("client input" + result); clientInstance.execute(); } } } // 该类封装了怎样对客户端的通道进行操作,具体实现可以通过重载execute()方法 public class ClientChInstance { SocketChannel channel; StringBuffer buffer = new StringBuffer(); public ClientChInstance(SocketChannel channel) { this.channel = channel; } public void execute() throws IOException { String message = "This is response after reading from channel!"; writeToChannel(this.channel, message); buffer = new StringBuffer(); } // 当一行没有结束时,将当前字窜置于缓冲尾 public void append(String values) { buffer.append(values); } } // 主程序 public static void main(String[] args) { NBServer nbServer = new NBServer(8090); try { nbServer.initialize(); } catch (Exception e) { e.printStackTrace(); System.exit(-1); } try { nbServer.portListening("This is from server!"); } catch (Exception e) { e.printStackTrace(); } } } 我写的客户端: package org.scorpion.scoket; import java.io.OutputStream; import java.net.Socket; public class TCPClient { public static void main(String[] args) throws Exception { Socket s = new Socket("172.22.71.146", 8000); OutputStream os = s.getOutputStream(); byte[] by="ksfsksjfklsdjflsdj".getBytes(); os.write(by); s.close(); } }

java nio 业务接收多线程处理是否必要

<p>nio在服务器收到客户端请求的时候,是单线程的,即使自己在后续的业务流程处理中使用了线程池操作,由于接收部分是单线程的,也没有什么意义?有何办法提高效率?</p>

关于java阻塞socket和非阻塞socket的应用区别

最近在学习NIO,在学习非阻塞Socket的时候 很困惑,不知道他相对于阻塞的Socket的优势 在哪,希望大神指点一二,在线等。

java nio selector怎么达到与Linux select一样的效果

前几天做了一个linux下的socket实验使用了select,可以让程序在不使用多线程的情况下,实现io的异步,也就是可以收数据,也可以发数据,但不阻塞。 于是我就想能不能移植到Java下来实现。结果我发现Java也有select类似的功能,但是我发现Java nio的Chanel无法对标准输入进行处理,要发数据的时候就会阻塞。 可能是我技术不够,我想问问大家Java nio到底能不能实现与linux select一样的效果? package server; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.ServerSocket; import java.net.Socket; import java.nio.channels.SocketChannel; import java.util.Iterator; import java.util.Scanner; import java.nio.ByteBuffer; import java.nio.channels.Channel; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; public class ServerSock { public ServerSock() { // TODO Auto-generated constructor stub try { ServerSocketChannel server= ServerSocketChannel.open(); server.bind(new InetSocketAddress(InetAddress.getLocalHost(), 8899), 5); System.out.println("服务器启动...."); Selector selector = Selector.open(); server.configureBlocking(false); server.register(selector, SelectionKey.OP_ACCEPT); ByteBuffer buf = ByteBuffer.allocate(48); SocketChannel channel = null; while(true){ int a=selector.select(); Iterator<SelectionKey> keyIter = selector.selectedKeys().iterator(); while(keyIter.hasNext()){ SelectionKey key = keyIter.next(); if (key.isAcceptable()) { channel = server.accept(); System.out.println("接受: "); channel.configureBlocking(false); channel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE); }else if (key.isReadable()) { System.out.println("读取:"); int bytesRead = channel.read(buf); buf.flip(); String aString = new String(buf.array()).trim(); System.out.println(aString); buf.clear(); }else if (key.isWritable()) { System.out.println("写入:"); Scanner scanner = new Scanner(System.in); String b = scanner.nextLine(); buf.put(b.getBytes()); buf.flip(); channel.write(buf); buf.clear(); } keyIter.remove(); } } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } public static void main(String[] args) { new ServerSock(); } } ``` ```

java NIO通信 客户端为什么收不到数据

客户端程序 public class NioSelectorClient { public static void main(String[] args) throws IOException{ SocketChannel channel = SocketChannel.open(); channel.configureBlocking(false); Selector selector = Selector.open(); channel.connect(new InetSocketAddress("127.0.0.1", 7777)); channel.register(selector,SelectionKey.OP_CONNECT|SelectionKey.OP_READ); System.out.println("============读===AAAA======"); while(true) { int n = selector.select(); if(n==0) continue; Iterator<SelectionKey> iter = selector.selectedKeys().iterator(); while(iter.hasNext()){ SelectionKey key = iter.next(); if(key.isConnectable()) { System.out.println("================连接成功了==============="); } if( key.isReadable()) { System.out.println("=========数据来了============"); SocketChannel client = (SocketChannel)key.channel(); ByteBuffer buf = ByteBuffer.allocate(1024); int a= client.read(buf); buf.flip(); byte[] b = new byte[a]; System.arraycopy(buf.array(), 0, b, 0, a); String s = new String(b); System.out.println("============读描述符有数据了======服务器发来的数据:"+s); } iter.remove(); } } } } 服务端程序 public class NioSelectorServer { public static void main(String[] args) throws IOException { // 创建一个selector选择器 Selector selector = Selector.open(); SocketChannel clientchannel = null; // 打开一个通道 ServerSocketChannel serverchannel = ServerSocketChannel.open(); // 使设定non-blocking的方式。 serverchannel.configureBlocking(false); serverchannel.socket().bind(new InetSocketAddress(7777)); // 向Selector注册Channel及我们有兴趣的事件 serverchannel.register(selector, SelectionKey.OP_ACCEPT); while(true) { int n = selector.select(); if (n != 0) { Iterator<SelectionKey> it = selector.selectedKeys().iterator(); while (it.hasNext()) { SelectionKey key = (SelectionKey) (it.next()); if (key.isAcceptable()) { System.out.println("=====服务端========连接了======="); ServerSocketChannel Serverchannel = (ServerSocketChannel) key.channel(); clientchannel = Serverchannel.accept(); clientchannel.configureBlocking(false); clientchannel.register(selector, SelectionKey.OP_WRITE); } if(key.isWritable()) { System.out.println("=============服务端===========可写========="); SocketChannel client = (SocketChannel) key.channel(); String ss = "客户端 你好"; client.write(ByteBuffer.wrap(ss.getBytes())); } it.remove(); } } } } } 在本地运行 为什么客户端一直收不到服务端发来的数据了,到底程序错在哪了 ,请大家帮忙指点,最好将我的错误代码改正过来,万分感谢!!!

java socket服务器接收不到客户端发来的消息

package socket; public class MySeverSocket { public static void main(String[] args) { new ServerListener().start(); } } **************************************** package socket; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import javax.swing.JOptionPane; public class ServerListener extends Thread { public void run (){ try { ServerSocket serverSocket = new ServerSocket(55555); while (true){ Socket socket = serverSocket.accept(); JOptionPane.showMessageDialog(null, "有客户端连接到了55555端口"); ChatSocket cs = new ChatSocket(socket); cs.start(); ChatManager.getChatManager().add(cs); } } catch (IOException e) { e.printStackTrace(); } } } *************************************** package socket; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.UnsupportedEncodingException; import java.net.Socket; public class ChatSocket extends Thread { Socket socket; public ChatSocket(Socket s) { this.socket = s; } public void out(String out) { try { socket.getOutputStream().write(out.getBytes("UTF-8")); } catch (UnsupportedEncodingException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } @Override public void run() { try { BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8")); String line = null; while ((line = br.readLine()) != null) { ChatManager.getChatManager().publich(this, line); } br.close(); } catch (UnsupportedEncodingException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } ******************************************************** package socket; import java.util.Vector; public class ChatManager { private ChatManager() {} private static final ChatManager cm = new ChatManager(); public static ChatManager getChatManager() { return cm; } Vector<ChatSocket> vector = new Vector<ChatSocket>(); public void add(ChatSocket cs) { vector.add(cs); } public void publich(ChatSocket cs,String out) { for(int i = 0;i<vector.size();i++){ ChatSocket csChatSocket = vector.get(i); if (!cs.equals(csChatSocket)) { csChatSocket.out(out); } } } } 安卓客户端连接与发送消息方法 public void connect(){ final AsyncTask<Void,String,Void> read = new AsyncTask<Void, String, Void>() { String iptext = ip.getText().toString(); @Override protected Void doInBackground(Void... params) { try { socket = new Socket(iptext,55555); writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); reader = new BufferedReader(new InputStreamReader(socket.getInputStream())); publishProgress("@success"); } catch (IOException e) { Toast.makeText(MainActivity.this,"连接失败",Toast.LENGTH_SHORT).show(); e.printStackTrace(); } try { String line; while ((line = reader.readLine()) != null){ publishProgress(line); } } catch (IOException e) { e.printStackTrace(); } return null; } @Override protected void onProgressUpdate(String... values) { if (values[0].equals("@success")){ Toast.makeText(MainActivity.this,"连接成功",Toast.LENGTH_SHORT).show(); } text.append("别人说"+values[0]+"\n"); super.onProgressUpdate(values); } }; read.execute(); } public void send(){ try { // text.append("我说:"+editText.getText().toString()+"\n"); writer.write(editText.getText().toString()+"\n"); writer.flush(); editText.setText(""); } catch (IOException e) { e.printStackTrace(); } }

JAVA NIO双向通信问题

我想要是使用JAVA NIO做一个客户端、服务器**双向通讯**的东东,但是我遇到的问题是: 服务器无法想客户端发送消息,类似这样的方式并不是我想要的: while(it.hasNext()) { SelectionKey key = it.next(); if(key.isAcceptable()) { log.info("Server: SelectionKey is acceptable."); handler.handleAccept(key); } else if(key.isReadable()) { log.info("Server: SelectionKey is readable."); handler.handleRead(key); } else if(key.isWritable()) { log.info("Server: SelectionKey is writable."); handler.handleWrite(key); } it.remove(); 我的数据是从前台产生的,**数据产生的时间比较随机**,因此并不能像上述一下作为反馈信息发送回去,那么这种情况该怎么解决呢? *我真的没有C币啊,求懂的人帮下忙啦~~~~*

nio中从socket读取数据到缓冲区,如果缓冲区太小,多出来的数据会怎么样

如题。会丢吗?不会丢的话,后面的数据是怎么处理的呢

java的socket编程问题:为什么客户端接收服务器的数据时会有空白数据项?

例如:03-17 07:02:00.330 1984-2007/? I/info﹕ client buff --> 0/20160316//早餐/123.0 03-17 07:02:00.340 1984-2007/? I/info﹕ insert expend_table 03-17 07:02:00.340 1984-2007/? I/info﹕ client buff --> 03-17 07:02:00.340 1984-2007/? I/info﹕ client buff --> 0/20160316//午餐/22.0 03-17 07:02:00.340 1984-2007/? I/info﹕ insert expend_table 03-17 07:02:00.340 1984-2007/? I/info﹕ client buff --> 03-17 07:02:00.340 1984-2007/? I/info﹕ client buff --> 0/20160316/22ss/服装/123.0 数据内容忽视。client buff是客户端接受到的数据 就是为什么会是一条有数据一条没有数据这样循环下去? 服务端代码: pw = new PrintWriter(s.getOutputStream()); Cursor c = dbManager.query(Constant.DATA_TABLE,"username=?",new String[]{username}); while (c.moveToNext()){ // client端发送数据的顺序: isIncome + "/" + date + "/" + title + "/" + content + "/" + money String title = c.getString(c.getColumnIndex("title")); String money = c.getString(c.getColumnIndex("money")); Long date = c.getLong(c.getColumnIndex("date")); String isIncome = c.getString(c.getColumnIndex("isIncome")); String content = c.getString(c.getColumnIndex("content")); String data = isIncome + "/" + date + "/" + title + "/" + content + "/" + money + '\n'; pw.println(data); pw.flush(); } String endFlag = username + "/end" + '\n'; pw.println(endFlag); pw.flush(); 客户端代码: br = new BufferedReader(new InputStreamReader(s.getInputStream())); String buff; while (!(buff = br.readLine()).endsWith(mUsername + "/end")) { // server端发送数据的顺序: isIncome + "/" + date + "/" + title + "/" + content + "/" + money String[] str = buff.split("/"); if (str.length == 5) { //确保接收的数据正确 ContentValues values = new ContentValues(); values.put("isIncome", str[0]); values.put("date", Long.valueOf(str[1])); values.put("title", str[2]); values.put("content", str[3]); values.put("money", str[4]); if ("0".equals(str[0])) { if (!dbManager.insert(Constant.EXPEND_TABLE, values)) { flag = false; break; } } else if ("1".equals(str[0])) { if (!dbManager.insert(Constant.INCOME_TABLE, values)) { flag = false; break; } } } } db.setTransactionSuccessful(); db.endTransaction();

java nio/netty异步io操作问题

最近学习netty遇到一个问题:netty下的IO操作时异步的,比如执行channel.write()马上返回一个ChannelFuture,假如我要在write()写完后要执行一些操作doSomething(),一般做法是对ChannelFuture添加监听器ChannelFutureListener,然后在监听器内部覆写operationComplete方法,加入doSomething()即可。我的问题是: 1.执行完异步write()后,是不是有其它线程在实际处理“将数据写出”这个操作呢?(Netty下是Boss线程?) 2.当数据处理完,doSomething()这部分代码应该不是write()操作所属线程来执行的,那是由什么线程运行呢?(Boss线程?) 谢谢阅读,可以的话详细说一下……

java nio selector.select不阻塞

# java nio selector.select不阻塞 java nio 构建的服务端在与客户端(用ubuntu虚拟机的netcat)连接上后, netcat直接ctrl + d(什么内容都不输入)的话,服务端的selector.select()方法的结果就一直是0 也不阻塞了。请问这是为什么。 代码如下: ```java package chapter4; import org.junit.Test; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.util.Iterator; import java.util.Set; public class List4_2 { @Test public void test1(){ PlainNIOServer server = new PlainNIOServer(); try { server.serve(12345); } catch (IOException e) { e.printStackTrace(); } } private static class PlainNIOServer { public void serve(int port) throws IOException {//在对方连接上以后直接ctrl+d会陷入readable的死循环 ServerSocketChannel serverChannel = ServerSocketChannel.open(); serverChannel.configureBlocking(false); serverChannel.bind(new InetSocketAddress(port)); Selector selector = Selector.open(); serverChannel.register(selector, SelectionKey.OP_ACCEPT); while(true){ if (selector.select() == 0){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } // continue; } Set<SelectionKey> keys = selector.selectedKeys(); Iterator<SelectionKey> it = keys.iterator(); while (it.hasNext()){ SelectionKey key = it.next(); it.remove(); System.out.println("acc : " + key.isAcceptable() + ", w : " + key.isWritable() + ", r : " + key.isReadable() + ", conn : " + key.isConnectable() + ", v : " + key.isValid()); try { if (key.isAcceptable()) { ServerSocketChannel server = (ServerSocketChannel) key.channel(); SocketChannel client = server.accept(); if (client != null) { client.configureBlocking(false); client.register(selector, SelectionKey.OP_READ); System.out.println("Accept Connection from " + client); } } if (key.isReadable()) { SocketChannel client = (SocketChannel) key.channel(); ByteBuffer byteBuffer = ByteBuffer.allocate(5); System.out.println("readable !!!"); int count = 0; while (( count = client.read(byteBuffer)) > 0 ) { byteBuffer.flip(); byte[] bytes = new byte[1024]; while (byteBuffer.hasRemaining()) { byteBuffer.get(bytes, 0, Math.min(byteBuffer.remaining(), bytes.length)); String sentence; System.out.println(sentence = new String(bytes, 0, count)); byteBuffer.compact(); byteBuffer.put(sentence.getBytes()); byteBuffer.flip(); client.write(byteBuffer); } byteBuffer.compact(); } } } catch (Exception e){ e.printStackTrace(); key.channel().close(); } } } } } } ``` 运行如上代码以后,在虚拟机里运行netcat , 截图如下 ![图片说明](https://img-ask.csdn.net/upload/201806/23/1529747149_870890.png) 此时在netcat中按下ctrl + d (EOF)则服务端的selector.select方法调用之后返回结果一直为0且不再阻塞,所有连上的客户端也没办法发消息了。 服务端效果如下: ![图片说明](https://img-ask.csdn.net/upload/201806/23/1529747418_255698.png)

java nio SelectionKey isWritable为什么一直是true

服务器 [code="java"] package test.nio; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.CharBuffer; 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; import java.util.Iterator; import java.util.Set; public class NonBlockEchoServer { private ServerSocketChannel serverSocketChannel; private int port = 8992; private Selector selector; private Charset charset; public NonBlockEchoServer() throws IOException { charset = Charset.forName("UTF-8"); selector = Selector.open(); serverSocketChannel = ServerSocketChannel.open(); //可以绑定到同一个端口 serverSocketChannel.socket().setReuseAddress(true); //设置为非阻塞模式 serverSocketChannel.configureBlocking(false); serverSocketChannel.socket().bind(new InetSocketAddress(port)); } public void service() throws IOException { serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); while(selector.select() > 0) { Set<SelectionKey> keys = selector.selectedKeys(); Iterator<SelectionKey> it = keys.iterator(); while(it.hasNext()) { SelectionKey key = null; try { key = it.next(); it.remove(); if(key.isAcceptable()) { ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel(); SocketChannel socketChannel = serverSocketChannel.accept(); socketChannel.configureBlocking(false); ByteBuffer byteBuffer = ByteBuffer.allocate(0); socketChannel.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE, byteBuffer); } if(key.isReadable()) { read(key); } if(key.isWritable()) { write(key); } }catch (IOException e) { if(key != null) { try { key.cancel(); key.channel().close(); } catch (IOException e1) { e1.printStackTrace(); } } e.printStackTrace(); } } } } private void write(SelectionKey key) throws IOException { SocketChannel socketChannel = (SocketChannel) key.channel(); ByteBuffer byteBuffer = (ByteBuffer) key.attachment(); byteBuffer.flip(); String data = decode(byteBuffer); if(data.indexOf("\r\n") == -1) { return; } String outputData = data.substring(0, data.indexOf("\n")+1); System.out.println("--->" + outputData); ByteBuffer outputBuffer = encode("echo:" + outputData); while(outputBuffer.hasRemaining()) { socketChannel.write(outputBuffer); } ByteBuffer temp = encode(outputData); byteBuffer.position(temp.limit()); byteBuffer.compact(); if(outputData.equals("bye\r\n")) { key.cancel(); socketChannel.close(); System.out.println("链接已经关闭"); } } private void read(SelectionKey key) throws IOException { System.out.println("server read"); SocketChannel socketChannel = (SocketChannel) key.channel(); socketChannel.configureBlocking(false); ByteBuffer byteBuffer = (ByteBuffer) key.attachment(); ByteBuffer readBuff = ByteBuffer.allocate(32); socketChannel.read(readBuff); byteBuffer.limit(byteBuffer.capacity()); readBuff.flip(); byteBuffer.put(readBuff); } /** * 解码 * @param byteBuffer * @return */ private String decode(ByteBuffer byteBuffer) { CharBuffer charBuffer = charset.decode(byteBuffer); return charBuffer.toString(); } /** * 编码 * @param str * @return */ private ByteBuffer encode(String str) { return charset.encode(str); } public static void main(String[] args) throws IOException { NonBlockEchoServer nonServer = new NonBlockEchoServer(); nonServer.service(); } } [/code] 客户端 [code="java"] package test.nio; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.SocketChannel; import java.nio.charset.Charset; import java.util.Iterator; import java.util.Set; public class NonBlockEchoClient { private SocketChannel socketChannel; private ByteBuffer sendBuffer = ByteBuffer.allocate(1024); private ByteBuffer receiveBuffer = ByteBuffer.allocate(1024); Charset charset = Charset.forName("utf-8"); private Selector selector; private int port = 8992; public NonBlockEchoClient() throws IOException { socketChannel = SocketChannel.open(); socketChannel.connect(new InetSocketAddress(port)); socketChannel.configureBlocking(false); System.out.println("与服务器链接成功"); selector = Selector.open(); } public static void main(String[] args) throws IOException { final NonBlockEchoClient non = new NonBlockEchoClient(); Thread client = new Thread(new Runnable() { @Override public void run() { non.receiveFromUser(); } }); client.start(); non.talk(); } private void talk() throws IOException { socketChannel.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE); while(selector.select() > 0) { Set<SelectionKey> keys = selector.selectedKeys(); Iterator<SelectionKey> it = keys.iterator(); while(it.hasNext()) { SelectionKey key = it.next(); it.remove(); if(key.isReadable()) { receive(key); } if(key.isWritable()) { send(key); } } } } public void receiveFromUser() { try { BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in)); String msg = null; while((msg = bufferedReader.readLine()) != null) { System.out.println(msg); synchronized (sendBuffer) { sendBuffer.put(encode(msg+"\r\n")); } if("bye".equals(msg)) { break; } } } catch(IOException e) { e.printStackTrace(); } } private void send(SelectionKey key) throws IOException { SocketChannel socketChannel = (SocketChannel) key.channel(); synchronized (sendBuffer) { sendBuffer.flip(); socketChannel.write(sendBuffer); sendBuffer.compact(); } } private void receive(SelectionKey key) throws IOException { System.out.println("client RECEIVE"); SocketChannel socketChannel = (SocketChannel) key.channel(); socketChannel.read(receiveBuffer); receiveBuffer.flip(); String receiveData = decode(receiveBuffer); if(receiveData.indexOf("\n") == -1) return; String outputData = receiveData.substring(0, receiveData.indexOf("\n") + 1); System.out.println("--->" + outputData); if(outputData.equals("echo:bye\r\n")) { key.cancel(); socketChannel.close(); selector.close(); System.exit(0); } ByteBuffer temp = encode(outputData); receiveBuffer.position(temp.limit()); receiveBuffer.compact(); } private String decode(ByteBuffer byteBuffer) { return charset.decode(byteBuffer).toString(); } private ByteBuffer encode(String str) { return charset.encode(str); } } [/code] 各位大侠,最近小弟在学习nio编程,遇到一个问题:客户端在连接服务器端成功后,没有进行任何操作,服务器端并没有触发 写事件 为什么key.isWritable()一直为true ??

求教Java.Nio 中SocketChannel 写入数据的问题

### 请问SocketChannel 写入大一点的数据时该如何处理 ![图片说明](https://img-ask.csdn.net/upload/201901/18/1547780789_544042.png) ###这个方法如何用循环完善,不然数据稍微大点就会报错 /** * 把指定的字符串按照默认编码转化成byte字节流写入到socket channel中 * @param channel * @param buffer * @param str * @throws IOException */ public static void wirteCmd(SocketChannel channel,ByteBuffer buffer,String str) throws IOException{ buffer.clear(); byte[] bytes=str.getBytes(); buffer.put(bytes); buffer.flip(); channel.write(buffer); buffer.clear(); } ``` ```

java NIO 多线程

<div class="iteye-blog-content-contain" style="font-size: 14px;"> <pre name="code" class="java">public void run() { exitRequest = false ; while( !exitRequest) { try { // 初期化 socketChannel = SocketChannel.open() ; selector = Selector.open() ; socketChannel.socket().setReuseAddress( true) ; socketChannel.configureBlocking( false) ; socketChannel.socket().setReceiveBufferSize( RECV_BUFFER) ; selectionKey = socketChannel.register( selector, SelectionKey.OP_CONNECT) ; selectionKey.attach( new SocketNioControl( notifyObject, selector, socketChannel, selectionKey)) ; socketChannel.connect( inetAddress) ; int timer = 0 ; while( !socketChannel.isConnected()) { selector.select(100) ; if( exitRequest) { break ; } for( SelectionKey key : selector.selectedKeys()) { if( key.isConnectable()) { SocketChannel socketChannel = ( SocketChannel)key.channel() ; SocketNioControl socketControl = ( SocketNioControl)key.attachment() ; socketChannel.finishConnect() ; key.interestOps( SelectionKey.OP_READ) ; socketControl.connect() ; break ; } } if( timer &gt;= TIMER_CONNECT * 1000) { throw new ConnectException() ; } timer += 100 ; } try { while( !exitRequest) { selector.select() ; for( SelectionKey key : selector.selectedKeys()) { SocketNioControl socketControl = ( SocketNioControl)key.attachment() ; if( key.isReadable()) { socketControl.read() ; } if( key.isWritable()) { socketControl.write() ; } } } } catch ( ConnectException ioex) { } catch ( CancelledKeyException ckex) { } } catch ( UnknownHostException uhex) { ErrorMessage.logging( uhex) ; } catch ( Exception ex) { ErrorMessage.logging( ex) ; } finally { try { for( SelectionKey key : selector.keys()) { SocketNioControl socketControl = ( SocketNioControl)key.attachment() ; socketControl.disconnect() ; } if( selector != null) { selector.close() ; selector = null ; } for( int timer = 0; timer &lt; TIMER_RETRY * 1000; timer += 100) { Thread.sleep( 100) ; if( exitRequest) { break ; } } } catch( IOException ioe) { } catch( InterruptedException iex) { } } } }</pre> <p> 线程一直被占用,导致系统hungup.是哪里出问题呢?另外<span style="font-family: monospace; font-size: 1em; line-height: 1.5;"> selector.select() 的值一直是0;</span><span style="font-family: monospace; font-size: 1em; line-height: 1.5;">这一句是起什么作用的?</span></p> </div>

java socket 发送二进制流的问题

想通过java socket发送一个二进制流: 0x05 0x03 0x00 0x00 0x00 0x40 0x45 0xbe 说明:这个二进制不代表任何字符串,就是一个命令,服务器端能够识别。 做法是这样的,先申请一块空间赋值,然后发送出去。 char cmd[] = {0x05, 0x03, 0x00, 0x00, 0x00, 0x40, 0x45, 0xbe}; os.print(cmd); os.flush 或者: char cmd[] = {0x05, 0x03, 0x00, 0x00, 0x00, 0x40, 0x45, 0xbe}; String command = new String(cmd); os.print(command); os.flush 用wireshark抓包看的话, 实际发送的数据是: 0x05, 0x03, 0x00, 0x00, 0x00, 0x40, 0x45, 0x3f. 这个是怎么回事儿?有大神知道吗? 我试了下,貌似数据大于0x80的都有这个问题,是不是二进制转化为字符的时候会有特殊处理?如果我真想要发送一个大于0x80的二进制该怎么处理?

程序员的兼职技能课

获取讲师答疑方式: 在付费视频第一节(触摸命令_ALL)片头有二维码及加群流程介绍 限时福利 原价99元,今日仅需39元!购课添加小助手(微信号:csdn590)按提示还可领取价值800元的编程大礼包! 讲师介绍: 苏奕嘉&nbsp;前阿里UC项目工程师 脚本开发平台官方认证满级(六级)开发者。 我将如何教会你通过【定制脚本】赚到你人生的第一桶金? 零基础程序定制脚本开发课程,是完全针对零脚本开发经验的小白而设计,课程内容共分为3大阶段: ①前期将带你掌握Q开发语言和界面交互开发能力; ②中期通过实战来制作有具体需求的定制脚本; ③后期将解锁脚本的更高阶玩法,打通任督二脉; ④应用定制脚本合法赚取额外收入的完整经验分享,带你通过程序定制脚本开发这项副业,赚取到你的第一桶金!

Windows版YOLOv4目标检测实战:训练自己的数据集

课程演示环境:Windows10; cuda 10.2; cudnn7.6.5; Python3.7; VisualStudio2019; OpenCV3.4 需要学习ubuntu系统上YOLOv4的同学请前往:《YOLOv4目标检测实战:训练自己的数据集》 课程链接:https://edu.csdn.net/course/detail/28745 YOLOv4来了!速度和精度双提升! 与 YOLOv3 相比,新版本的 AP (精度)和 FPS (每秒帧率)分别提高了 10% 和 12%。 YOLO系列是基于深度学习的端到端实时目标检测方法。本课程将手把手地教大家使用labelImg标注和使用YOLOv4训练自己的数据集。课程实战分为两个项目:单目标检测(足球目标检测)和多目标检测(足球和梅西同时检测)。 本课程的YOLOv4使用AlexyAB/darknet,在Windows系统上做项目演示。包括:安装软件环境、安装YOLOv4、标注自己的数据集、整理自己的数据集、修改配置文件、训练自己的数据集、测试训练出的网络模型、性能统计(mAP计算)和先验框聚类分析。还将介绍改善YOLOv4目标检测性能的技巧。 除本课程《Windows版YOLOv4目标检测实战:训练自己的数据集》外,本人将推出有关YOLOv4目标检测的系列课程。请持续关注该系列的其它视频课程,包括: 《Windows版YOLOv4目标检测实战:人脸口罩佩戴检测》 《Windows版YOLOv4目标检测实战:中国交通标志识别》 《Windows版YOLOv4目标检测:原理与源码解析》

lena全身原图(非256*256版本,而是全身原图)

lena全身原图(非256*256版本,而是全身原图) lena原图很有意思,我们通常所用的256*256图片是在lena原图上截取了头部部分的256*256正方形得到的. 原图是花花公子杂志上的一个

快速入门Android开发 视频 教程 android studio

这是一门快速入门Android开发课程,顾名思义是让大家能快速入门Android开发。 学完能让你学会如下知识点: Android的发展历程 搭建Java开发环境 搭建Android开发环境 Android Studio基础使用方法 Android Studio创建项目 项目运行到模拟器 项目运行到真实手机 Android中常用控件 排查开发中的错误 Android中请求网络 常用Android开发命令 快速入门Gradle构建系统 项目实战:看美图 常用Android Studio使用技巧 项目签名打包 如何上架市场

Java调用微信支付

Java 使用微信支付 一. 准备工作 1.

汽车租赁管理系统需求分析规格说明书

汽车租赁管理系统需求分析规格说明书,这只是一个模板,如果有不会的可以借鉴一下,还是蛮详细的。。。。

C/C++跨平台研发从基础到高阶实战系列套餐

一 专题从基础的C语言核心到c++ 和stl完成基础强化; 二 再到数据结构,设计模式完成专业计算机技能强化; 三 通过跨平台网络编程,linux编程,qt界面编程,mfc编程,windows编程,c++与lua联合编程来完成应用强化 四 最后通过基于ffmpeg的音视频播放器,直播推流,屏幕录像,

程序员的算法通关课:知己知彼(第一季)

【超实用课程内容】 程序员对于算法一直又爱又恨!特别是在求职面试时,算法类问题绝对是不可逃避的提问点!本门课程作为算法面试系列的第一季,会从“知己知彼”的角度,聊聊关于算法面试的那些事~ 【哪些人适合学习这门课程?】 求职中的开发者,对于面试算法阶段缺少经验 想了解实际工作中算法相关知识 在职程序员,算法基础薄弱,急需充电 【超人气讲师】 孙秀洋&nbsp;| 服务器端工程师 硕士毕业于哈工大计算机科学与技术专业,ACM亚洲区赛铜奖获得者,先后在腾讯和百度从事一线技术研发,对算法和后端技术有深刻见解。 【课程如何观看?】 PC端:https://edu.csdn.net/course/detail/27272 移动端:CSDN 学院APP(注意不是CSDN APP哦) 本课程为录播课,课程无限观看时长,但是大家可以抓紧时间学习后一起讨论哦~

机器学习初学者必会的案例精讲

通过六个实际的编码项目,带领同学入门人工智能。这些项目涉及机器学习(回归,分类,聚类),深度学习(神经网络),底层数学算法,Weka数据挖掘,利用Git开源项目实战等。

Python入门视频精讲

Python入门视频培训课程以通俗易懂的方式讲解Python核心技术,Python基础,Python入门。适合初学者的教程,让你少走弯路! 课程内容包括:1.Python简介和安装 、2.第一个Python程序、PyCharm的使用 、3.Python基础、4.函数、5.高级特性、6.面向对象、7.模块、8.异常处理和IO操作、9.访问数据库MySQL。教学全程采用笔记+代码案例的形式讲解,通俗易懂!!!

我以为我对Mysql事务很熟,直到我遇到了阿里面试官

太惨了,面试又被吊打

深度学习原理+项目实战+算法详解+主流框架(套餐)

深度学习系列课程从深度学习基础知识点开始讲解一步步进入神经网络的世界再到卷积和递归神经网络,详解各大经典网络架构。实战部分选择当下最火爆深度学习框架PyTorch与Tensorflow/Keras,全程实战演示框架核心使用与建模方法。项目实战部分选择计算机视觉与自然语言处理领域经典项目,从零开始详解算法原理,debug模式逐行代码解读。适合准备就业和转行的同学们加入学习! 建议按照下列课程顺序来进行学习 (1)掌握深度学习必备经典网络架构 (2)深度框架实战方法 (3)计算机视觉与自然语言处理项目实战。(按照课程排列顺序即可)

Java62数据提取代码

利用苹果手机微信下面的wx.data文件提取出62数据,通过62可以实现不同设备直接登陆,可以通过文件流的方式用脚本上传到服务器进行解析

Python代码实现飞机大战

文章目录经典飞机大战一.游戏设定二.我方飞机三.敌方飞机四.发射子弹五.发放补给包六.主模块 经典飞机大战 源代码以及素材资料(图片,音频)可从下面的github中下载: 飞机大战源代码以及素材资料github项目地址链接 ————————————————————————————————————————————————————————— 不知道大家有没有打过飞机,喜不喜欢打飞机。当我第一次接触这个东西的时候,我的内心是被震撼到的。第一次接触打飞机的时候作者本人是身心愉悦的,因为周边的朋友都在打飞机, 每

2018年全国大学生计算机技能应用大赛决赛 大题

2018年全国大学生计算机技能应用大赛决赛大题,程序填空和程序设计(侵删)

Lena图像处理测试专业用图,高清完整全身原图

Lena图像处理测试专业用图,高清完整全身原图,该图片很好的包含了平坦区域、阴影和纹理等细节,这些都有益于测试各种不同的图像处理算法。它是一幅很好的测试照片!其次,由于这是一个非常有魅力女人的照片。

MySQL数据库面试题(2020最新版)

文章目录数据库基础知识为什么要使用数据库什么是SQL?什么是MySQL?数据库三大范式是什么mysql有关权限的表都有哪几个MySQL的binlog有有几种录入格式?分别有什么区别?数据类型mysql有哪些数据类型引擎MySQL存储引擎MyISAM与InnoDB区别MyISAM索引与InnoDB索引的区别?InnoDB引擎的4大特性存储引擎选择索引什么是索引?索引有哪些优缺点?索引使用场景(重点)...

verilog实现地铁系统售票

使用 verilog 实现地铁售票

Python+OpenCV计算机视觉

Python+OpenCV计算机视觉系统全面的介绍。

Python可以这样学(第四季:数据分析与科学计算可视化)

董付国老师系列教材《Python程序设计(第2版)》(ISBN:9787302436515)、《Python可以这样学》(ISBN:9787302456469)配套视频,在教材基础上又增加了大量内容,通过实例讲解numpy、scipy、pandas、statistics、matplotlib等标准库和扩展库用法。

150讲轻松搞定Python网络爬虫

【为什么学爬虫?】 &nbsp; &nbsp; &nbsp; &nbsp;1、爬虫入手容易,但是深入较难,如何写出高效率的爬虫,如何写出灵活性高可扩展的爬虫都是一项技术活。另外在爬虫过程中,经常容易遇到被反爬虫,比如字体反爬、IP识别、验证码等,如何层层攻克难点拿到想要的数据,这门课程,你都能学到! &nbsp; &nbsp; &nbsp; &nbsp;2、如果是作为一个其他行业的开发者,比如app开发,web开发,学习爬虫能让你加强对技术的认知,能够开发出更加安全的软件和网站 【课程设计】 一个完整的爬虫程序,无论大小,总体来说可以分成三个步骤,分别是: 网络请求:模拟浏览器的行为从网上抓取数据。 数据解析:将请求下来的数据进行过滤,提取我们想要的数据。 数据存储:将提取到的数据存储到硬盘或者内存中。比如用mysql数据库或者redis等。 那么本课程也是按照这几个步骤循序渐进的进行讲解,带领学生完整的掌握每个步骤的技术。另外,因为爬虫的多样性,在爬取的过程中可能会发生被反爬、效率低下等。因此我们又增加了两个章节用来提高爬虫程序的灵活性,分别是: 爬虫进阶:包括IP代理,多线程爬虫,图形验证码识别、JS加密解密、动态网页爬虫、字体反爬识别等。 Scrapy和分布式爬虫:Scrapy框架、Scrapy-redis组件、分布式爬虫等。 通过爬虫进阶的知识点我们能应付大量的反爬网站,而Scrapy框架作为一个专业的爬虫框架,使用他可以快速提高我们编写爬虫程序的效率和速度。另外如果一台机器不能满足你的需求,我们可以用分布式爬虫让多台机器帮助你快速爬取数据。 &nbsp; 从基础爬虫到商业化应用爬虫,本套课程满足您的所有需求! 【课程服务】 专属付费社群+每周三讨论会+1v1答疑

获取Linux下Ftp目录树并逐步绑定到treeview

在linux下抓取目录树,双击后获取该节点子节点(逐步生成)。另外有两个类,一个是windows下的(一次性获取目录树),一个是linux下的(足部获取目录树)

YOLOv3目标检测实战系列课程

《YOLOv3目标检测实战系列课程》旨在帮助大家掌握YOLOv3目标检测的训练、原理、源码与网络模型改进方法。 本课程的YOLOv3使用原作darknet(c语言编写),在Ubuntu系统上做项目演示。 本系列课程包括三门课: (1)《YOLOv3目标检测实战:训练自己的数据集》 包括:安装darknet、给自己的数据集打标签、整理自己的数据集、修改配置文件、训练自己的数据集、测试训练出的网络模型、性能统计(mAP计算和画出PR曲线)和先验框聚类。 (2)《YOLOv3目标检测:原理与源码解析》讲解YOLOv1、YOLOv2、YOLOv3的原理、程序流程并解析各层的源码。 (3)《YOLOv3目标检测:网络模型改进方法》讲解YOLOv3的改进方法,包括改进1:不显示指定类别目标的方法 (增加功能) ;改进2:合并BN层到卷积层 (加快推理速度) ; 改进3:使用GIoU指标和损失函数 (提高检测精度) ;改进4:tiny YOLOv3 (简化网络模型)并介绍 AlexeyAB/darknet项目。

手把手实现Java图书管理系统(附源码)

【超实用课程内容】 本课程演示的是一套基于Java的SSM框架实现的图书管理系统,主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的java人群。详细介绍了图书管理系统的实现,包括:环境搭建、系统业务、技术实现、项目运行、功能演示、系统扩展等,以通俗易懂的方式,手把手的带你从零开始运行本套图书管理系统,该项目附带全部源码可作为毕设使用。 【课程如何观看?】 PC端:https://edu.csdn.net/course/detail/27513 移动端:CSDN 学院APP(注意不是CSDN APP哦) 本课程为录播课,课程2年有效观看时长,大家可以抓紧时间学习后一起讨论哦~ 【学员专享增值服务】 源码开放 课件、课程案例代码完全开放给你,你可以根据所学知识,自行修改、优化

微信小程序开发实战之番茄时钟开发

微信小程序番茄时钟视频教程,本课程将带着各位学员开发一个小程序初级实战类项目,针对只看过官方文档而又无从下手的开发者来说,可以作为一个较好的练手项目,对于有小程序开发经验的开发者而言,可以更好加深对小程序各类组件和API 的理解,为更深层次高难度的项目做铺垫。

Java 最常见的 200+ 面试题:面试必备

这份面试清单是从我 2015 年做了 TeamLeader 之后开始收集的,一方面是给公司招聘用,另一方面是想用它来挖掘在 Java 技术栈中,还有那些知识点是我不知道的,我想找到这些技术盲点,然后修复它,以此来提高自己的技术水平。虽然我是从 2009 年就开始参加编程工作了,但我依旧觉得自己现在要学的东西很多,并且学习这些知识,让我很有成就感和满足感,那所以何乐而不为呢? 说回面试的事,这份面试...

Java基础知识面试题(2020最新版)

文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的主类有何不同?Java应用程序与小程序之间有那些差别?Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...

三个项目玩转深度学习(附1G源码)

从事大数据与人工智能开发与实践约十年,钱老师亲自见证了大数据行业的发展与人工智能的从冷到热。事实证明,计算机技术的发展,算力突破,海量数据,机器人技术等,开启了第四次工业革命的序章。深度学习图像分类一直是人工智能的经典任务,是智慧零售、安防、无人驾驶等机器视觉应用领域的核心技术之一,掌握图像分类技术是机器视觉学习的重中之重。针对现有线上学习的特点与实际需求,我们开发了人工智能案例实战系列课程。打造:以项目案例实践为驱动的课程学习方式,覆盖了智能零售,智慧交通等常见领域,通过基础学习、项目案例实践、社群答疑,三维立体的方式,打造最好的学习效果。

微信小程序 实例汇总 完整项目源代码

微信小程序 实例汇总 完整项目源代码

基于西门子S7—1200的单部六层电梯设计程序,1部6层电梯

基于西门子S7—1200的单部六层电梯设计程序,1部6层电梯。 本系统控制六层电梯, 采用集选控制方式。 为了完成设定的控制任务, 主要根据电梯输入/输出点数确定PLC 的机型。 根据电梯控制的要求,

相关热词 c#分级显示数据 c# 不区分大小写替换 c#中调用就java c#正则表达式 验证小数 c# vscode 配置 c#三维数组能存多少数据 c# 新建excel c#多个文本框 c#怎么创建tcp通讯 c# mvc 电子病例
立即提问
相关内容推荐