// 返回当前线程中thread-local变量副本的值，如果当前线程的变量没有值，则该变量会被方法initialValue初始化
public T get();

// 设置当前线程的thread-local变量副本为指定的值
public void set(T value);

// 移除当前线程的thread-local变量副本的值
public void remove();

public class ThreadLocalTest {

    // (1) 创建线程变量
    private static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        // (2) 设置线程变量
        threadLocal.set("hello world");
        // (3) 启动子线程
        Thread thread = new Thread(() -> {
            // (4) 子线程输出变量的值
            System.out.println("thread: " + threadLocal.get());
        });
        thread.start();

        // (5) 主线程输出线程变量的值
        System.out.println("main: " + threadLocal.get());
    }
    
}

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
		// (1) 获取对应的ThreadLocalMap.Entry实例
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

private T setInitialValue() {
	T value = initialValue();
	Thread t = Thread.currentThread();
	ThreadLocalMap map = getMap(t);
	if (map != null)
		// (1)处获取的Entry实例为空，会重新创建一个Entry
		map.set(this, value);
	else
		createMap(t, value);
	return value;
}

protected T initialValue() {
	return null;
}

// 获取key关联的Entry
private Entry getEntry(ThreadLocal<?> key);

// 设置value关联key
private void set(ThreadLocal<?> key, Object value);

// 移除key对应的Entry
private void remove(ThreadLocal<?> key);

static class Entry extends WeakReference<ThreadLocal<?>> {
	/** The value associated with this ThreadLocal. */
	Object value;

	Entry(ThreadLocal<?> k, Object v) {
		super(k);
		value = v;
	}
}

package io.github.lmy.springbootinaction.request;

import io.github.lmy.springbootinaction.entity.User;
import lombok.Data;
import org.hibernate.validator.constraints.Range;
import org.springframework.beans.BeanUtils;

import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;

@Data
public class UserRequest {

    @NotBlank(message = "用户名不能为空")
    private String name;

    @Range(min = 0, max = 150, message = "年龄格式不正确")
    @NotNull
    private Integer age;

    @Email(message = "邮箱格式不正确")
    @NotBlank(message = "邮箱不能为空")
    private String email;

    @Pattern(regexp = "^1(3|4|5|7|8)\\d{9}$", message = "手机号码格式不正确")
    @NotBlank(message = "手机号不能为空")
    private String phone;

    @NotBlank(message = "密码不能为空")
    private String password;
    
}

package io.github.lmy.springbootinaction.controller;

import io.github.lmy.springbootinaction.request.LoginRequest;
import io.github.lmy.springbootinaction.request.UserRequest;
import io.github.lmy.springbootinaction.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.validation.Valid;

@Controller
@RequestMapping("/user")
@Slf4j
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping("/register")
    @ResponseBody
    public boolean register(@Valid @RequestBody UserRequest userRequest, BindingResult result) {
        if (result.hasErrors()) {
            for (FieldError fieldError : result.getFieldErrors()) {
                log.info("field: {}, message: {}", fieldError.getField(), fieldError.getDefaultMessage());
            }
            return false;
        }
        boolean success = userService.register(userRequest);
        return success;
    }

    @PostMapping("/login")
    public String login(@Validated @RequestBody LoginRequest loginRequest) {
        userService.login(loginRequest);
        return "index";
    }

}

package io.github.lmy.springbootinaction.global;

import org.springframework.http.HttpStatus;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.Map;
import java.util.stream.Collectors;

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Map<String, String> handleValidationExceptions(MethodArgumentNotValidException ex) {
        Map<String, String> result = ex.getBindingResult()
                .getFieldErrors()
                .stream()
                .collect(Collectors.toMap(FieldError::getField, FieldError::getDefaultMessage));
        return result;
    }

}

@Test
public void testTryCatchFinally() {
    BufferedReader br = null;
    try {
        br = new BufferedReader(new FileReader(new File("D://Resource/file.txt")));
        String line;
        while((line = br.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (br != null) {
                br.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

@Test
public void testTryWithResource() {
    try(BufferedReader br = new BufferedReader(new FileReader(new File("D://Resource/file.txt")))) {
        String line;
        while((line = br.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Test
public void testTryWithResource() {
    try {
        BufferedReader br = new BufferedReader(new FileReader(new File("D://Resource/file.txt")));Throwable localThrowable3 = null;
        try {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Throwable localThrowable1) {
            localThrowable3 = localThrowable1;throw localThrowable1;
        } finally {
            if (br != null) {
                if (localThrowable3 != null) {
                    try {
                        br.close();
                    } catch (Throwable localThrowable2) {
                        localThrowable3.addSuppressed(localThrowable2);
                    }
                } else {
                    br.close();
                }
            }
        }
    }
    catch (IOException e) {
        e.printStackTrace();
    }
}