// 定义一个自定义事件
public class UserRegisteredEvent extends ApplicationEvent {
    private String username;

    public UserRegisteredEvent(Object source, String username) {
        super(source);
        this.username = username;
    }

    public String getUsername() {
        return username;
    }
}

// 发布事件
@Component
public class UserService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;

    public void registerUser(String username) {
        // 业务逻辑
        eventPublisher.publishEvent(new UserRegisteredEvent(this, username));
    }
}

// 监听事件
@Component
public class WelcomeEmailListener implements ApplicationListener<UserRegisteredEvent> {
    @Override
    public void onApplicationEvent(UserRegisteredEvent event) {
        // 发送欢迎邮件
        System.out.println("Sending welcome email to " + event.getUsername());
    }
}

ServerSocket serverSocket = new ServerSocket(8080);
Socket socket = serverSocket.accept(); // 阻塞等待连接
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);

String inputLine;
while ((inputLine = in.readLine()) != null) {
    out.println("Echo: " + inputLine);
}
socket.close();
serverSocket.close();

Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
    selector.select();
    Set<SelectionKey> keys = selector.selectedKeys();
    for (SelectionKey key : keys) {
        if (key.isAcceptable()) {
            SocketChannel clientChannel = serverChannel.accept();
            clientChannel.configureBlocking(false);
            clientChannel.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            SocketChannel clientChannel = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            clientChannel.read(buffer);
            buffer.flip();
            clientChannel.write(buffer);
        }
        keys.remove(key);
    }
}

EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
    ServerBootstrap bootstrap = new ServerBootstrap();
    bootstrap.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 protected void initChannel(SocketChannel ch) {
                     ch.pipeline().addLast(new StringDecoder(), new StringEncoder(), new SimpleChannelInboundHandler<String>() {
                         @Override
                         protected void channelRead0(ChannelHandlerContext ctx, String msg) {
                             ctx.writeAndFlush("Echo: " + msg);
                         }
                     });
                 }
             });

    ChannelFuture future = bootstrap.bind(8080).sync();
    future.channel().closeFuture().sync();
} finally {
    bossGroup.shutdownGracefully();
    workerGroup.shutdownGracefully();
}

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://example.com"))
        .GET()
        .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

@ClientEndpoint
public class WebSocketClient {
    @OnOpen
    public void onOpen(Session session) {
        session.getAsyncRemote().sendText("Hello");
    }

    @OnMessage
    public void onMessage(String message) {
        System.out.println("Received: " + message);
    }
}

InputStream in = socket.getInputStream();
byte[] buffer = new byte[1024];
int bytesRead = in.read(buffer); // 阻塞等待数据

SocketChannel channel = SocketChannel.open();
channel.configureBlocking(false); // 设置为非阻塞模式
ByteBuffer buffer = ByteBuffer.allocate(1024);

int bytesRead = channel.read(buffer); // 非阻塞，可能立即返回0
if (bytesRead > 0) {
    buffer.flip(); // 准备读数据
}

Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
    selector.select(); // 阻塞，直到至少一个事件发生
    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    for (SelectionKey key : selectedKeys) {
        if (key.isAcceptable()) {
            SocketChannel clientChannel = serverChannel.accept();
            clientChannel.configureBlocking(false);
            clientChannel.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            SocketChannel clientChannel = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            clientChannel.read(buffer); // 非阻塞读取
        }
    }
    selectedKeys.clear(); // 清理已处理的事件
}

package zeh.myjavase.code00common;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;

// 文件操作-工具类
public class FileHandleUtil {

    // 创建文件和上层目录
    public static void createFileAndDirectory(File f) {
        if (f != null) {
            if (!f.isDirectory()) {
                // 取出文件父目录
                File parentFiles = f.getParentFile();
                if (parentFiles != null) {
                    if (!parentFiles.exists()) {
                        System.out.println("----开始递归创建文件夹----");
                        // 递归创建指定文件夹
                        parentFiles.mkdirs();
                        System.out.println("----递归创建文件夹结束----");
                    } else {
                        System.out.println("---指定文件夹存在----");
                    }
                }
                if (!f.exists()) {
                    System.out.println("----开始创建文件----");
                    try {
                        // 如果直接是文件的话，则创建该文件
                        f.createNewFile();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    System.out.println("----创建文件结束----");
                } else {
                    System.out.println("----指定文件存在----");
                }
            }
        }
    }

    // 下述方法作用：递归删除指定目录
    // 如何判断目录：当传入的文件对象，其实体确实存在子目录或者子文件，则此时文件对象就是目录，否则就不是目录，当做文件对象处理
    public static void deleteFile(File file) {
        if (file != null) {
            if (file.exists()) {
                if (file.isDirectory()) {
                    File f[] = file.listFiles();

                    if (f != null) {
                        for (int i = 0; i < f.length; i++) {
                            deleteFile(f[i]);
                            f[i].delete();
                        }
                        file.delete();
                    }
                } else {
                    file.delete();
                }
            } else {
                System.out.println("----要删除的文件(目录)不存在----");
            }
        }
    }

    // 下述方法作用：在实例化输出流前，验证File对象路径的完整性，创建目录和文件文件对象，永远都是完整路径，除非传入的是根目录，否则传入的永远都是完整路径，按照文件对象去操作，而不是目录对象
    public static boolean checkFile(File file, boolean isCreateFile) {
        boolean checkResult = true;
        if (file != null) {
            if (!file.isDirectory()) {
                File parentFiles = file.getParentFile();
                if (parentFiles != null) {
                    if (!parentFiles.exists()) {
                        // 如果父目录不存在，则直接创建父目录(包含创建父目录的多个层级)
                        parentFiles.mkdirs();
                    }
                }
                if (isCreateFile) {
                    if (!file.exists()) {
                        try {
                            file.createNewFile();
                        } catch (IOException e) {
                            System.out.println("读取数据异常");
                        }
                    }
                } else {
                    if (!file.exists()) {
                        String errorMessage = "----文件[" + file + "]不存在----";
                        try {

                            throw new FileNotFoundException(errorMessage);
                        } catch (FileNotFoundException e) {
                            e.printStackTrace();
                        }
                        checkResult = false;
                    }
                }
            }
        } else {
            checkResult = false;
        }
        return checkResult;
    }

    // 下述方法作用：判断isSaveTxt，若为false，则清空result目录
    public static void clearResultDir(boolean isSaveTxt) {
        File result = new File("result");
        if (!isSaveTxt) {
            // false则清空result目录
            FileHandleUtil.deleteFile(result);
            System.out.println("isSaveTxt设置为false，result目录清空");
        } else {
            // true则什么都不做
            ;
        }
    }
}

package zeh.myjavase.code26io;

import zeh.myjavase.code00common.FileHandleUtil;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo01CreateFileAndOutput {
    private static String filePath = "C:" + File.separator + "D" + File.separator + "FileClass" + File.separator + "zhaoerhu.txt";

    public static void main(String args[]) throws IOException {
        File f = new File(filePath);
        FileHandleUtil.createFileAndDirectory(f);

        OutputStream out = new FileOutputStream(f);
        // 写入每一个内容时，后面都拼接了换行符\n，这样写入的内容是换行的，否则不换行
        buildFileContent().stream().map(c -> c + "\n").forEach(e -> {
            try {
                out.write(e.getBytes(StandardCharsets.UTF_8));
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        });
        out.close();
        System.out.println("=====" + f.getCanonicalPath());
    }

    private static List<String> buildFileContent() {
        return Stream.of("我是赵二虎", "who are u?", "daisy", "Daniel", "i love Daisy!!!").collect(Collectors.toList());
    }
}

我是赵二虎
who are u?
daisy
Daniel
i love Daisy!!!

package zeh.myjavase.code26io;

import zeh.myjavase.code00common.FileHandleUtil;

import java.io.*;
import java.nio.charset.StandardCharsets;

// 从键盘中读取内容，写入到文件中去 
// 输入流定位操作对象为键盘 
// 输出流定位操作对象为文件
public class Demo02CreateFileAndOutputToFile {
    private static String filePath = "C:" + File.separator + "D" + File.separator + "FileClass" + File.separator + "zhaoerhu2.txt";

    // 使用打印流的write方法写入数据
    private static class PrintStreamWrite {
        public static void main(String[] args) throws FileNotFoundException {
            BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入东西：");
            String content = null;
            PrintStream filePrint = initPrintStream();
            try {
                boolean flag = true;
                while (flag) {
                    content = buf.readLine();
                    if ("end".equals(content)) {
                        return;
                    }
                    // write方法需要转换成字节数组，并且转换前就需要拼接上换行符
                    filePrint.write((content + "\n").getBytes(StandardCharsets.UTF_8));
                    System.out.println("----[" + content + "]");
                }

            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (buf != null) {
                    try {
                        buf.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (filePrint != null) {
                    filePrint.close();
                }
            }
        }
    }

    // 初始化打印流
    private static PrintStream initPrintStream() throws FileNotFoundException {
        PrintStream filePrint = null;
        File f = new File(filePath);
        FileHandleUtil.createFileAndDirectory(f);
        filePrint = new PrintStream(new FileOutputStream(f, true));
        return filePrint;
    }

}

    // print方法打印不会自动换行，需要手动拼接换行符
    public static class PrintStreamPrint {
        public static void main(String[] args) throws FileNotFoundException {
            BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入东西：");
            String content = null;
            PrintStream filePrint = initPrintStream();
            try {
                boolean flag = true;
                while (flag) {
                    content = buf.readLine();
                    if ("end".equals(content)) {
                        return;
                    }
                    // print方法不会自动换行，需要我们拼接换行符
                    filePrint.print(content + "\n");
                    System.out.println("----[" + content + "]");
                }

            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (buf != null) {
                    try {
                        buf.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (filePrint != null) {
                    filePrint.close();
                }
            }
        }
    }

    // println方法会自动换行
    private static class PrintStreamPrintln {
        public static void main(String[] args) {
            System.out.println("请输入东西：");
            String content = null;

            try (BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
                 PrintStream filePrint = initPrintStream();) {
                boolean flag = true;
                while (flag) {
                    content = buf.readLine();
                    if ("end".equals(content)) {
                        return;
                    }
                    // print方法不会自动换行，需要我们拼接换行符
                    filePrint.println(content + "\n");
                    System.out.println("----[" + content + "]");
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static class PrintStreamOfSystem{
        public static void main(String[] args) throws FileNotFoundException {
            BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入东西：");
            String content = null;
            // 为了后面将标准输出流再重新定向到控制台，此处在重定向前先保存下标准输出流
            PrintStream filePrintBefore = System.out;
            PrintStream filePrint = initPrintStream();
            try {
                boolean flag = true;
                while (flag) {
                    content = buf.readLine();
                    if ("end".equals(content)) {
                        return;
                    }
                    // 重定向到文件
                    System.setOut(filePrint);
                    System.out.println(content);
                    // 重新定向到标准输出流，这个标准输出流是前面重定向之前保存的
                    System.setOut(filePrintBefore);
                    System.out.println("----[" + content + "]");
                }

            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (buf != null) {
                    try {
                        buf.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (filePrint != null) {
                    filePrint.close();
                }
            }
        }
    }

package zeh.myjavase.code26io;

import zeh.myjavase.code00common.FileHandleUtil;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

// 使用相对路径向文件中输出东西
public class Demo03FileOutputStreamToFile {
    // 相对路径，相对当前代码工作根目录的路径
    private static String filePath = "FileClass" + File.separator + "zhaoerhu3.txt";

    public static void main(String args[]) throws IOException {
        File f = new File(filePath);
        FileHandleUtil.createFileAndDirectory(f);
        OutputStream out = new FileOutputStream(f);
        String str = "wo shi zhaoerhu!";
        out.write(str.getBytes());
        out.close();
    }
}