/**
 * 一个自定义接口，供下面的程序调用；
 */
public interface MyInterface {
    public String getName();
    public void setName(String name);
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 实现InvocationHandler的类，对创建出来的类的调用都会转给此类
 */
public class MyInvocationHandler implements InvocationHandler {

    public Object invoke(Object proxy, Method method, Object[] args)  {
        System.out.println("invoke(" + proxy.getClass().getName() + ", method:" + method.getName() + ", " + (args == null ? "NULL" : args) + ")");
        if(method.getName().equals("getName")) {
            return "waytt";
        } else if(method.getName().equals("setName")) {
            System.out.println("args " + (args != null && args.length > 0 ? args[0] : "NULL"));
            return null;
        }
        return null;
    }

    
    public static void main(String[] argvs) throws Exception{
        // 动态创建接口的程序在此
        InvocationHandler handler = new MyInvocationHandler();
        // 第二个参数是需要实现的接口，可以多个，一个类实现多个接口
        MyInterface e = (MyInterface) Proxy.newProxyInstance(MyInterface.class.getClassLoader(),
                new Class[] { MyInterface.class }, handler);
        e.setName("abc");
        System.out.println("getName() return " + e.getName());
    }
}

BufferedImage bufferedImage = ImageIO.read(new File("desk.tif"));
// 这里得到的bufferedImage == null

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
 
public class CompletableFutureTester {
 
    public static void main(String[] argvs) {
        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("enter cf");
            try {
                //sleep 3秒
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("s1");
            return "done";
        });
 
        try {
            //试图在2秒内得到结果，否则算超时
            String result = cf1.get(2, TimeUnit.SECONDS);
            System.out.println("result is : " + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            System.out.println("超时未得到结果");
            e.printStackTrace();
        }
    }
}

String content = "这是段.md文件的内容。其中[这是一个链接](./html/README.md)，还有其他内容，这里又有一个[another link](another.md)，这次链接到了another.md。";
 
//括号用于分组；需要匹配括号则用\c
//[^\]] 表示任意不是']'的字符，后面的*表示任意多个
Pattern p = Pattern.compile("\\[([^\\]]*)\\]\\(([^\\)]*)\\)", Pattern.CASE_INSENSITIVE);
 
Matcher matcher = p.matcher(content);
while(matcher != null && matcher.find()) {
    String link = matcher.group();
    for(int i=0; i<= matcher.groupCount(); i++){
        //得到的分组，第0个是整个字串，例如第一次发现时打印：[这是一个链接](./html/README.md)
        //第一个是正则表达式中第一个括号匹配到的内容，例如第一次发现时打印：这是一个链接
        System.out.println(matcher.group(i));
    }
    System.out.println();
}

import java.net.*;
import java.io.*;
 
public class WebsocketClient {
 
    public static void main(String[] args) throws Exception {
 
        String hostname = "localhost";
        int port = 8080;
 
        try (Socket socket = new Socket(hostname, port)) {
 
            OutputStream output = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(output, true);
 
            writer.println("GET /chat HTTP/1.1");
            writer.println("Host: " + hostname + ":" + port);
            // 下面两行是告诉服务器端，此次连接的使用的http协议期望升级到websocket协议，如果服务端同意升级会返回
            // Connection: upgrade  upgrade: websocket表示已经升级了，而且状态吗是101 switching protocols
            writer.println("Connection: upgrade");
            writer.println("Upgrade: WebSocket");
            // 下面这2行是必须的，sec-websocket-key是base64格式的一个随机数，由客户端生成
            // sec-websocket-version是指明客户端的websocket版本
            writer.println("Sec-WebSocket-Key:  "AQIDBAUGBwgJCgsMDQ4PEC=" =");
            writer.println("Sec-WebSocket-Version: 13");
            writer.println("User-Agent: MSIE");
            writer.println("Origin: http://localhost:8080/");
            writer.println();
 
            InputStream input = socket.getInputStream();
 
            BufferedReader reader = new BufferedReader(new InputStreamReader(input));
 
            System.out.println("request sent...");
            int i=0;
            while (i < 10) {
                if (reader.ready()){
                    // 在读websocket发送过来的消息时，这里没有解码消息帧，都当字符串了，消息的数据报文格式前面有些事数据包控制的bit，所以打印时有乱码
                    char[] bin = new char[2048];
                    int len = reader.read(bin, 0, bin.length);
                    char[] buf = new char[len];
                    System.arraycopy(bin, 0, buf, 0, len);
                    System.out.println(new String(buf));
                    i++;
                }
            }
            // 连接好了后可以发送数据，发送的数据报格式是 Base Framing Protocol， ABNF RFC5234
            writer.close();
            output.close();
            socket.close();
        } catch (UnknownHostException ex) {
            System.out.println("Server not found: " + ex.getMessage());
        } catch (IOException ex) {
            System.out.println("I/O error: " + ex.getMessage());
        }
    }
}