@PostMapping
public ResponseEntity<Map<String, Object>> login(){
    HashMap<String, Object> result = new HashMap<>();
    boolean isOk = false;
    if( !isOk ) {
        result.put("message", "invalid username or password");
        // status(HttpStatus.BAD_REQUEST) 是设置返回的状态码
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(result);
    }else {
        return ResponseEntity.status(HttpStatus.OK).body(result);
    }
}

import java.util.concurrent.*;
import java.util.*;
import java.util.stream.*;
 
public class TestPromise{
     
    public static void main(String[] argvs) throws Exception{
        // 简单的lambda表达式的例子
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
        list.forEach(n -> System.out.println(n));
        System.out.println("-------");
        list.forEach(System.out::println);
        System.out.println("-------");
  
        //下面是2个异步执行，执行完毕后使用结果的例子
        String s = CompletableFuture.supplyAsync(() -> {
            System.out.println("enter s1");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("s1");
            return "hello";
        }).thenCombine(CompletableFuture.supplyAsync(() -> {
            System.out.println("enter s2");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("s2");
            return "world";
        }), (s1, s2) -> {return s1 + " " + s2;} ).join();
        System.out.println(s);
        System.out.println("-------");
 
        // 多个方法异步执行，结果通过操纵一个共有的Map来保存，待全部执行完毕后显示结果
        Map<String, String>  result = new HashMap<String, String>();
        CompletableFuture.allOf(
            CompletableFuture.supplyAsync(() -> {
                System.out.println("enter s1");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("s1");
                result.put("k1", "11111");
                return "11";
            }),
            CompletableFuture.supplyAsync(() -> {
                System.out.println("enter s2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("s2");
                result.put("k2", "22222");
                return "22";
            }),
            CompletableFuture.supplyAsync(() -> {
                System.out.println("enter s3");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("s3");
                result.put("k3", "33333");
                return "33";
            })
        ).get();
        //.get()方法会等待allOf中所有参数方法执行完毕
        System.out.println(result.get("k1") + " " + result.get("k2") + " " + result.get("k3"));
 
 
        System.out.println("\r\n-------------------\r\n");
        // 改进一下第一个方法，使其更易读；
        CompletableFuture<Map<String, Object>> cf1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("enter s1");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("s1");
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("s1", "11111");
            return map;
        });
        CompletableFuture<Map<String, Object>> cf2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("enter s2");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("s2");
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("s2", "22222");
            return map;
        });
        CompletableFuture<Map<String, Object>> cf3 = CompletableFuture.supplyAsync(() -> {
            System.out.println("enter s3");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("s3", "33333");
            return map;
        });
        // 注释掉的这2行和上一个例子相同，不处理cf1,cf2,cf3的返回值
        // CompletableFuture<Void> cf = CompletableFuture.allOf(cf1, cf2, cf3);
        // cf.get();
        // 把各个CompletableFuture的执行结果放到一起
 
        // 把结果合并成一个List
        //List<Map<String, Object>> resultList = Stream.of(cf1, cf2, cf3).map(CompletableFuture::join).collect(Collectors.toList());
        //resultList.forEach(n -> System.out.println("\t---" + n));
 
        // 把结果合并到一个map里
        Map<String, Object> resultMap = new HashMap<String, Object>();
        Stream.of(cf1, cf2, cf3).map(CompletableFuture::join).forEach(v -> resultMap.putAll(v));
        System.out.println(resultMap);
    }
}

public class NpeThief {
    public void callManyNPEInLoop() {
        int preLen = -1;
        for (int i = 0; i < 10000000; i++) {
            try {
                ((Object)null).getClass();
            } catch (Exception e) {
                if(e.getStackTrace().length != preLen){
                    System.out.println("#" + i + "   " + e.getStackTrace().length);
                    preLen = e.getStackTrace().length;
                }
            }
        }
    }
    public static void main(String[] args) {
        NpeThief thief = new NpeThief();
        thief.callManyNPEInLoop();
    }
}

package com.test.websocket;

import javax.websocket.server.ServerEndpointConfig.Configurator;

public class ChatServerEndPointConfigurator extends Configurator {

    private ChatServerEndPoint chatServer = new ChatServerEndPoint();

    @Override
    public <T> T getEndpointInstance(Class<T> endpointClass)
                 throws InstantiationException {
        return (T) chatServer;
	}
}

if(endpointClass.isAssignableFrom(chatServer.getClass())){
    return endpointClass.cast(chatServer);
}else{
    AssertionError ae = new AssertionError("Cannot cast to " + endpointClass.getName() + 
            " from " + chatServer.getClass().getName());
    log.error("类型不匹配", ae);
    throw ae;
}