NIO学习笔记

在IO流中，大致可以分为普通IO（阻塞式IO）、NIO（非阻塞式IO）、AIO（异步IO）三种。
普通IO就是我们通常说的IO流，按照流对象可以分为字节流和字符流，按照的流的方向可以分为输入流和输出流。这里只是按照这两种方式进行划分，对于IO流还可以划分的更加的详细，这里就不加多说。
下面这个表格有助于我们更好的了解IO流的结构：

字节流 字符流
输入流 InputStream Reader
输出流 OutputStream Writer

字节流与字符流之间的桥梁：InputStreamReader和OutputStreamWriter
针对普通IO就说这么多，下面开始学习NIO
NIO：（New IO）也可以理解为NON BOLOCKING IO，即非阻塞式IO
先看一个表格，再来更好的学习NIO

IO NIO AIO
面向对象 面向流 面向缓冲区
阻塞/非阻塞 阻塞 非阻塞
同/异步 同步 同步 异步
单/双向 单向 双向

1. Buffer_缓冲区

  1. 重要属性
    1. position：当前操作的位置，默认0
    2. limit：极限，默认缓冲区的大小，只能操作limit之前的数据
    3. capacity：容量，缓冲区的大小
    4. mark：标记，用来记录position位置，调用mark方法时position回到标记的位置
  2. 重要方法
    1. allocate(int capacity) ：初始化大小
    2. flip()：切换模式，从写模式转换为读模式，调用该方法后，limit = position，position = 0。
    3. rewind()：重复读，limit不变，positon = 0。
    4. clear()：清空缓冲区，但是数据未进行清空，只不过所有的指针都指向了最初的位置。
    5. mark()：记录position位置，mark = position。
    6. reset()：将positon = mark
  3. 模型
    1. 初始化，假设初始化大小为1024，ByteBuffer.allocate(1024)
    2. 存入数据，buf.put("abcd".getBytes())
    3. 读取数据前调用flip()方法
    4. 读取数据
    5. 调用rewind方法
    6. 调用clear方法
  4. 代码
package buffer;

import org.junit.Test;

import java.nio.ByteBuffer;

/** * @ClassName BufferTest * @Description: TODO * @Author Bobo * @Mail tqb820965236@163.com * @Date 2019/7/23 11:28 * @Version v1.0 */
public class BufferTest {
    @Test
    public void test1(){
        ByteBuffer buf = ByteBuffer.allocate(1024);
        System.out.println("allocate.............");
        System.out.println(buf.position());
        System.out.println(buf.limit());
        System.out.println(buf.capacity());

        buf.put("adcd".getBytes());
        System.out.println("put...........");
        System.out.println(buf.position());
        System.out.println(buf.limit());
        System.out.println(buf.capacity());

        buf.flip();
        System.out.println("flip.......");
        System.out.println(buf.position());
        System.out.println(buf.limit());
        System.out.println(buf.capacity());

        byte[] by = new byte[buf.limit()];
        buf.get(by);
        System.out.println(new String(by, 0, by.length));
        System.out.println("get.........");
        System.out.println(buf.position());
        System.out.println(buf.limit());
        System.out.println(buf.capacity());

        buf.rewind();
        System.out.println("rewind.........");
        System.out.println(buf.position());
        System.out.println(buf.limit());
        System.out.println(buf.capacity());

        byte[] by1 = new byte[buf.limit()];
        buf.get(by1);
        System.out.println(new String(by1, 0, by1.length));
        System.out.println("rewind...get.........");
        System.out.println(buf.position());
        System.out.println(buf.limit());
        System.out.println(buf.capacity());

        buf.clear();
        System.out.println("clear.........");
        System.out.println(buf.position());
        System.out.println(buf.limit());
        System.out.println(buf.capacity());
    }

    /** * @Author Bobo * @Description 进行mark属性与reset方法的测试 * @Date 2019/7/23 12:48 * @Param [] * @return void */
    @Test
    public void test2(){
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.put("abcd".getBytes());
        // 读取数据
        buffer.flip();
        // 进行标记，记录position当前位置
        buffer.mark();
        byte[] by1 = new byte[buffer.limit()];
        buffer.get(by1);
        System.out.println(new String(by1, 0, by1.length ));
        // position位置进行重置 position = mark
        buffer.reset();
        byte[] by2 = new byte[buffer.limit()];
        buffer.get(by2);
        System.out.println(new String(by2, 0, by2.length ));
    }
}

2. 直接缓冲区与非直接缓冲区

  1. 非直接缓冲区：在上文我们讲的缓冲区，其实就是非直接缓冲区，我们是通过调用allocate方法进行创建的。那什么是非直接缓冲区呢？在进行我们上边的操作时，我们其实并没有对内存进行直接的操作，我们对内存的操作是间接的。那当我们将一个流写入到磁盘文件中，过程是怎么样的呢？首先我们会在JVM的虚拟内存中开辟一个缓冲区的空间，正如我们所说，它内部是采用数组实现的，在堆中开辟我们需要的空间。我们写入的数据首先会写入到用户地址空间中，内核地址空间再从用户地址空间进行copy数据，接着磁盘才从内核地址空间进行读取储存。这样没有直接对物理内存进行操作的缓冲区称为非直接缓冲区。我们看下面这个图和调用allocate方法的源码实现方式：

    源码：
    public static ByteBuffer allocate(int capacity) {
	      if (capacity < 0)
	          throw new IllegalArgumentException();
	      return new HeapByteBuffer(capacity, capacity);
}

-------------------------------分隔符------------------------------------------------------

HeapByteBuffer(int cap, int lim) { 
        super(-1, 0, lim, cap, new byte[cap], 0);
}
  2. 直接缓冲区：针对上边的解释，我们可能已经知道了什么是直接缓冲区了，其实就是可以直接对内存进行操作，减少了不必要的copy操作，通过物理内存映射文件直接将应用程序和磁盘联系了起来。我们知道，在内存中操作数据的效率是非常高的，但是，直接对内存进行操作也带了一些不可控的问题，如：内存空间消耗过大，不安全等问题。在Buffer中，Java也提供了这种高效率的缓冲区，通过调用allocateDirect()方法就可创建直接缓冲区。这里我们也看一下该方法的源码是如何实现的。
    public static ByteBuffer allocateDirect(int capacity) {
        return new DirectByteBuffer(capacity);
}

-----------------------------------------------------------------------------

DirectByteBuffer(int cap) {                   // package-private
        super(-1, 0, cap, cap);
        boolean pa = VM.isDirectMemoryPageAligned();
        int ps = Bits.pageSize();
        long size = Math.max(1L, (long)cap + (pa ? ps : 0));
        Bits.reserveMemory(size, cap);

        long base = 0;
        try {
            base = unsafe.allocateMemory(size);
        } catch (OutOfMemoryError x) {
            Bits.unreserveMemory(size, cap);
            throw x;
        }
        unsafe.setMemory(base, size, (byte) 0);
        if (pa && (base % ps != 0)) {
            // Round up to page boundary
            address = base + ps - (base & (ps - 1));
        } else {
            address = base;
        }
        cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
        att = null;
 }

3. 通道Channel

  1. 什么是通道：用于 I/O 操作的连接。 通道表示到实体，如硬件设备、文件、网络套接字或可以执行一个或多个不同 I/O 操作（如读取或写入）的程序组件的开放的连接。 通道可处于打开或关闭状态。创建通道时它处于打开状态，一旦将其关闭，则保持关闭状态。一旦关闭了某个通道，试图对其调用 I/O 操作就会导致 ClosedChannelException 被抛出。通过调用通道的 isOpen 方法可测试通道是否处于打开状态。（Java文档）
    Channel本质上就是一个连接通道（连接），用于目标节点与源节点之间的连接，负责缓冲区中数据的传输，Channel是不存储数据的，Buffer才存储，因此使用Channel时需要Buffer！
  2. 通道的实现类：
    1. FileChannel：文件通道
    2. SocketChannel：TCP传输的客户端
    3. ServerSocketChannel：TCP传输的服务端
    4. DatagramChannel：UDP传输
  3. 通道的获取：
    1. 对支持通道的类提供了getChannel()方法
      1. FileInputStream/FileOutputStream
      2. RandomAccessFile
      3. Socket
      4. ServerSocket
      5. DatagramSocket
    2. 对通道提供了open方法，用于获取通道对象（JDK1.7 NIO.2）
    3. Files类的newByteChannel()方法（JDK1.7 NIO.2）
  4. 使用通道的不同方式实现文件的复制
    1. 使用非直接缓冲区（getChannel()方法）
      package channel;

import org.junit.Test;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/** * @ClassName ChannelDemo1 * @Description: 使用getChannel获取通道 * @Author Bobo * @Mail tqb820965236@163.com * @Date 2019/7/23 15:27 * @Version v1.0 */
public class ChannelDemo1 {
    @Test
    public void test1() throws Exception{
        FileInputStream fis = new FileInputStream("1.jpg");
        FileOutputStream fos = new FileOutputStream("2.jpg");

        FileChannel inChannel = fis.getChannel();
        FileChannel outChannel = fos.getChannel();

        ByteBuffer buffer = ByteBuffer.allocate(1024);
        while (inChannel.read(buffer) != -1){
            buffer.flip();// 转换为读模式
            outChannel.write(buffer);
            buffer.clear();// 清空缓冲区
        }

        inChannel.close();
        outChannel.close();
        fis.close();
        fos.close();
    }
}
    2. 使用open()获取通道，且通过直接缓冲区进行操作
      package channel;

import org.junit.Test;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

/** * @ClassName ChannelDemo1 * @Description: 使用open获取通道，且通过直接缓冲区进行操作 * @Author Bobo * @Mail tqb820965236@163.com * @Date 2019/7/23 15:27 * @Version v1.0 */
public class ChannelDemo2 {
    @Test
    public void test1() throws Exception{
        FileChannel in = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
        FileChannel out = FileChannel.open(Paths.get("3.jpg"), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);

        // 创建内存映射文件的类对象
        MappedByteBuffer map_IN = in.map(FileChannel.MapMode.READ_ONLY, 0, in.size());
        MappedByteBuffer map_OUT = out.map(FileChannel.MapMode.READ_WRITE, 0, in.size());

        // 创建字节数组
        byte[] buf = new byte[map_IN.limit()];

        // 调用get、put操作进行数据的传输
        map_IN.get(buf);
        map_OUT.put(buf);
        in.close();
        out.close();
    }
}
    3. 使用open()获取通道，且通过直接缓冲区进行操作(transferTo()方法)
      package channel;

import org.junit.Test;

import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

/** * @ClassName ChannelDemo1 * @Description: 使用open获取通道，且通过直接缓冲区进行操作(transferTo方法) * @Author Bobo * @Mail tqb820965236@163.com * @Date 2019/7/23 15:27 * @Version v1.0 */
public class ChannelDemo3 {
    @Test
    public void test1() throws Exception{
        FileChannel in = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
        FileChannel out = FileChannel.open(Paths.get("4.jpg"), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);

        // 此方法依旧使用的是直接缓冲区
        in.transferTo(0, in.size(), out);
        in.close();
        out.close();
    }
}

4. 分散读取与聚集写入

  1. 分散读取：从单个通道Channel中读取数据时，采用多个Buffer，即Buffer数组进行数据的读取工作。
  2. 聚集写入：将多个Buffer的内容写入单个Channel中。

示例：

package gatherscatter;

import org.junit.Test;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/** * @ClassName Demo * @Description: 分散读取与聚集写入 * @Author 田清波 * @Mail tqb820965236@163.com * @Date 2019/7/25 11:04 * @Version v1.0 */
public class Demo {
    /** * 分散读取与聚集写入 */
    @Test
    public void scatherAndgather() {
        RandomAccessFile ras = null;
        try {
            ras = new RandomAccessFile("1.txt", "rw");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        FileChannel channel = ras.getChannel();

        ByteBuffer buffer1 = ByteBuffer.allocate(100);
        ByteBuffer buffer2 = ByteBuffer.allocate(1024);

        ByteBuffer[] buf = {buffer1, buffer2};
        try {
            channel.read(buf);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 转换模式
        buffer1.flip();
        buffer2.flip();

        System.out.println(new String(buffer1.array(), 0, buffer1.limit()));
        System.out.println("----------------------分隔符------------------------------");
        System.out.println(new String(buffer2.array(), 0, buffer2.limit()));

        // 聚集写入
        RandomAccessFile fas1 = null;
        try {
            fas1 = new RandomAccessFile("2.txt", "rw");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        FileChannel channel2 = fas1.getChannel();
        try {
            channel2.write(buf);
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            channel.close();
            channel2.close();
            fas1.close();
            ras.close();
        } catch (Exception e) {
        }
    }
}

5. TCP通信中的阻塞与非阻塞

在之前了解的TCP通信中，使用到的Socket类有：ServerSocket、Socket，使用这两个类进行TCP通信的时候，采用的是阻塞式通信，如果要使用非阻塞的方式进行TCP通信，那就得使用ServerSocketChannel和SocketChannel这两个类。
在非阻塞通信中，有三个重要的类或者接口是需要熟悉的：

  1. Channel：是个接口，上边了解到，其实就是个连接对象，用于Buffer的数据传输，下面是部分实现类。
    1. SocketChannel
    2. ServerSocketChannel
    3. DatagramChannel
  2. Buffer：缓冲区
  3. Seletor：SelectableChannel 对象的多路复用器。 选择器，在非阻塞通信中，用于将Channel注册到选择器中，并且指定注册事件，在事件完成时，才执行具体的操作。

这里需要了解什么是SelectableChannel 对象，从Java文档中了解到，上边写到的三个Channel以及后边讲的Pipe.SinkChannel和SourceChannel都是SelectableChannel 对象，它们继承AbstractSelectableChannel，而AbstractSelectableChannel又继承SelectableChannel。

而SelectionKey则就是在进行注册时必须要指定的注册事件，用于后续监听，被称为选择键，有下面几个选择键类型以及常用方法


下面用代码的方式实现一下SocketChannel和ServerSocketChannel的阻塞与非阻塞方式的通信：

阻塞式的通信方式（其实默认为阻塞方式，若要实现非阻塞得调用configureBlocking()方法进行配置）

package nio_blocking;

import org.junit.Test;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.Locale;
import java.util.Scanner;

/** * @ClassName Demo * @Description: NIO的阻塞式 * @Author 田清波 * @Mail tqb820965236@163.com * @Date 2019/7/25 17:29 * @Version v1.0 */
public class Demo {
    @Test
    public void client() throws Exception {
        // 创建客户端Channel
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("localhost", 9999));

        // 创建缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 向缓冲区中存放数据
        String str = "hello world";
        buffer.put((LocalDateTime.now() + "\n" + str).getBytes());
        // 切换模式
        buffer.flip();
        socketChannel.write(buffer);
        buffer.clear();

        socketChannel.close();
    }

    @Test
    public void server() throws IOException {
        // 创建服务器端的channel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(9999));

        // 创建缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 获取客户端socket连接对象
        SocketChannel socketChannel = serverSocketChannel.accept();
        System.out.println(socketChannel.getLocalAddress() + "连接至服务器");

        // 读取数据
        socketChannel.read(buffer);

        // 切换到读模式
        buffer.flip();
        System.out.println(new String(buffer.array(), 0, buffer.limit()));
    }
}

非阻塞式的通信方式

package nio_nonblocking;

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.time.LocalDateTime;
import java.util.Iterator;

/** * @ClassName Demo1 * @Description: NIO的非阻塞通信方式 * @Author 田清波 * @Mail tqb820965236@163.com * @Date 2019/7/25 19:53 * @Version v1.0 */
public class Demo1 {
    @Test
    public void client() throws IOException {
        // 创建客户端Channel
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("localhost", 9999));
        // 设置Channel为非阻塞模式
        sChannel.configureBlocking(false);
        // 创建缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        // 发送数据
        buffer.put(LocalDateTime.now().toString().getBytes());
        buffer.flip();
        sChannel.write(buffer);
        buffer.clear();
        // 关闭通道
        sChannel.close();
    }

    @Test
    public void server() throws IOException {
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        // non-blocking
        ssChannel.configureBlocking(false);
        // bind port
        ssChannel.bind(new InetSocketAddress(9999));
        // 创建缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        // 创建选择器
        Selector selector = Selector.open();
        // 注册
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
        // 轮询注册事件
        while (selector.select() > 0) {
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            // 进行判断事件是否为Accept
            while (it.hasNext()) {
                SelectionKey s = it.next();
                if (s.isAcceptable()){
                    SocketChannel sChannel = ssChannel.accept();
                    sChannel.configureBlocking(false);
                    sChannel.register(selector, SelectionKey.OP_READ);
                }else if (s.isReadable()){
                    SocketChannel sChannel = (SocketChannel) s.channel();
                    sChannel.read(buffer);
                    buffer.flip();
                    System.out.println(new String(buffer.array(), 0, buffer.limit()));
                    buffer.clear();
                }
            }
            // 取消选择键selectionKeys
            it.remove();
        }
        // ssChannel.close();
    }
}

6. UDP的非阻塞式通信

上边针对TCP方式进行了讲解，UDP非阻塞式通信的代码和TCP差的不多，但是是两种完全不同的通信方式，不要混淆。

package udp_nonblocking;

import org.junit.Test;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.time.LocalDateTime;
import java.util.Iterator;
import java.util.Scanner;

/** * @ClassName Demo * @Description: UDP通信的NIO方式 * @Author 田清波 * @Mail tqb820965236@163.com * @Date 2019/7/26 9:15 * @Version v1.0 */
public class Demo {
    // @Test
    /*public void send() throws IOException { }*/
    // IDEA @Test 在控制台无法输入，有解决办法的可以告诉一下我
    public static void main(String[] args) throws IOException {
        DatagramChannel dChannel = DatagramChannel.open();
        // 创建缓冲区
        // NIO
        dChannel.configureBlocking(false);
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        Scanner sc = new Scanner(System.in);
        if (sc.hasNext()) {
            String str = sc.nextLine();
            buffer.put((LocalDateTime.now() + ":\n" + str).getBytes());
            buffer.flip();
            dChannel.send(buffer, new InetSocketAddress("127.0.0.1", 9999));
            buffer.clear();
        }
        dChannel.close();
    }

    @Test
    public void receive() throws IOException {
        DatagramChannel reChannel = DatagramChannel.open();
        reChannel.bind(new InetSocketAddress("127.0.0.1", 9999));
        reChannel.configureBlocking(false);
        Selector selector = Selector.open();
        // 注册
        reChannel.register(selector, SelectionKey.OP_READ);
        while (selector.select() > 0) {
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                if (key.isReadable()) {
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    reChannel.receive(buffer);
                    buffer.flip();
                    System.out.println(new String(buffer.array(), 0, buffer.limit()));
                    buffer.clear();
                }
            }
            iterator.remove();
        }
    }
}

7. 管道通信

了解

package pipe;

import org.junit.Test;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;

/** * @ClassName Demo * @Description: 管道方式通讯 * @Author 田清波 * @Mail tqb820965236@163.com * @Date 2019/7/26 9:45 * @Version v1.0 */
public class Demo {
    @Test
    public void test1() throws IOException {
        Pipe pipe = Pipe.open();
        // 创建管道写入Channel
        Pipe.SinkChannel sinkChannel = pipe.sink();
        // 创建缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.put("单向管道通信".getBytes());
        buffer.flip();
        // 向管道中写入数据
        sinkChannel.write(buffer);

        // 创建管道读取Channel
        Pipe.SourceChannel sourceChannel = pipe.source();
        buffer.flip();
        int len = sourceChannel.read(buffer);
        System.out.println(new String(buffer.array(), 0, len));
        buffer.clear();
    }
}
全部评论

相关推荐

05-16 20:06
卓越里程_中台运营(准入职员工)
卓越教育内推卓越教育内推码
工作氛围人际关系融洽：员工以&nbsp;90&nbsp;后为主，同事之间友好相处，人际关系简单透明。大家工作时认真，下班时充满活力，团队氛围轻松愉快，在这样的环境中工作心情较为愉悦。团队协作良好：学段主管、学科教练、教研团队和营运团队等分工明确，相互协作。例如，资深的教研团队会带领教师打磨教学专业力，一流的营运团队为教师解答三大考政策，能让员工在工作中感受到团队的力量。薪资福利薪资待遇优厚：不同岗位薪资不同，以教师岗为例，首年起薪&nbsp;10&nbsp;-&nbsp;40&nbsp;万&nbsp;/&nbsp;年，入职前六个月有保底工资，每年有年度绩效调薪机会，最高可达&nbsp;12%，每年两次晋升机会，调薪幅度最高可达&nbsp;20%。福利种类丰富：入职即购买六险一金，还有补充医疗...
投递卓越教育等公司6个岗位 >
点赞 评论 收藏
分享
头像
05-15 10:12
已编辑
南京大学 Java
点赞 评论 收藏
分享
04-24 16:06
蚌埠坦克学院 后端
点赞 评论 收藏
分享
04-10 11:45
杭州电子科技大学 golang
点赞 评论 收藏
分享
昨天 10:35
已编辑
东南大学 前端工程师
B站-暑期前端-二面
昨天面的，到现在还没有后续，估摸着可能凉了共计45分钟左右；在研究生阶段主要研究内容是？以什么语言为基础？在本科生阶段学习的主要内容是？好，然后因为你研究生阶段研究一些比如说神经网络，或如说智能安全相关的，当下人工智能处于风口，你觉得AI和前端相结合的方向有哪些？那你觉得，比如说刚才你聊到的那个根据设计稿来生成一些代码。从你的角度，它能做到什么样程度？可能会有一些什么样的问题呢？从你刚才分析的角度来看，就是我们整个开发过程去看的话。你觉得最终AI辅助开发，能够带来多少的提效？反过来看这个问题，你觉得AI生成代码会有哪些局限性？比如说针对的一开始提始提中，比如说团队内部他有一些规范，然后有一些组...
点赞 评论 收藏
分享
评论
点赞
收藏
分享

全站热榜

更多

创作者周榜

更多
正在热议
更多
# 我的求职总结 #
12333次浏览 225人参与
# 辞职之后最想做的一件事 #
7988次浏览 87人参与
# 毕业季，给职场新人一些建议 #
11677次浏览 217人参与
# 选offer应该考虑哪些因素 #
9895次浏览 135人参与
# 我的实习日记 #
2417609次浏览 25273人参与
# 工作后会跟朋友渐行渐远吗 #
20516次浏览 159人参与
# 你小时候最想从事什么职业 #
90123次浏览 1690人参与
# 你想留在一线还是回老家？ #
36352次浏览 439人参与
# 薪资爆料 #
102017次浏览 1039人参与
# 毕业后不工作的日子里我在做什么 #
167761次浏览 1484人参与
# 设计人如何选offer #
108027次浏览 707人参与
# 生物制药/化工校招攻略 #
42634次浏览 282人参与
# 比亚迪求职进展汇总 #
703394次浏览 3060人参与
# 第一份工作应该只看薪资吗 #
136873次浏览 1438人参与
# 你们公司哪个部门最累？ #
14381次浏览 123人参与
# 你们的毕业论文什么进度了 #
1014001次浏览 9513人参与
# 秋招想进国企该如何准备 #
56674次浏览 363人参与
# 招聘要求与实际实习内容不符怎么办 #
98177次浏览 718人参与
# 工作中的卑微时刻 #
8771次浏览 54人参与
# 大学最后一个寒假，我想…… #
35470次浏览 454人参与
牛客网
牛客企业服务