@Autowired @Qualifier("thisone") MyObject myObject;

@Service("thisone")
public MyObject{
}

@Qualifier("thisone")
@Service
public MyObject{
}

@JsonFormat(shape = JsonFormat.Shape.NUMBER)

@JsonFormat(timezone="GMT+8", pattern="yyyy-MM-dd")

import java.lang.reflect.Field;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
 
import org.apache.ibatis.jdbc.SQL;
 
 
/**
 * 使用此类有几个默认规则： 表名和类名相对应，属性名和字段名对应
 * java类内用驼峰命名法；数据库表和字段都用下划线
 * 类的属性定义的变量名和get/set方法名，以及set的参数类型一致，才会映射到数据库字段
 * 例如： private String name; 而且有 public void setName(String name) 和 public String getName()方法
 * 如果不是严格按照此规则定义的属性，不会被影射到数据库字段上
 */
public class InsertUpdateSqlProvider {
 
    /**
     * id如果传入了值，会被insert使用；如果id为null，不会被insert的columns列出
     */
    public static String insert(Object obj) {
        Map<String, String> map;
        try {
            map = getFieldsMap(obj, true);
        } catch (IllegalArgumentException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
        return new SQL() {
            {
                INSERT_INTO(getTableName(obj));
                for (String col : map.keySet()) {
                    VALUES(col, map.get(col));
                }
            }
        }.toString();
    }
     
    private static String updateById(Object obj, boolean includeNullValueField) {
        Map<String, String> map;
        try {
            map = getFieldsMap(obj, includeNullValueField);
            map.remove("id");
        } catch (IllegalArgumentException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
        return new SQL() {
            {
                UPDATE(getTableName(obj));
                for (String col : map.keySet()) {
                    SET(col + "=" + map.get(col));
                }
                WHERE("id = #{id}");
            }
        }.toString();
    }
 
    public static String updateById(Object obj) {
        return updateById(obj, true);
    }
 
    public static String updateNonNullById(Object obj) {
        return updateById(obj, false);
    }
 
    private static Map<String, String> getFieldsMap(Object obj, boolean includeNullValue)
            throws IllegalArgumentException, IllegalAccessException {
        HashMap<String, String> result = new HashMap<>();
        Class<?> cls = obj.getClass();
        Field[] fields = cls.getDeclaredFields(); // getDeclaredFields
        for (Field f : fields) {
            String col = f.getName();
            String colName = col.substring(0, 1).toUpperCase() + col.substring(1);
            f.setAccessible(true);
            try {
                cls.getMethod("get" + colName);
                cls.getMethod("set" + colName, f.getType());
            } catch (NoSuchMethodException | SecurityException e) {
                continue;
            }
            if ((!"id".equals(col) && includeNullValue) || f.get(obj) != null) {
                result.put(camelCase2Underscore(col), "#{" + col + "}");
            }
        }
        return result;
    }
 
    public static String getTableName(Object obj) {
        return camelCase2Underscore(obj.getClass().getSimpleName());
    }
 
    public static String camelCase2Underscore(String s) {
        StringBuffer buf = new StringBuffer();
        for (String w : s.split("(?<!(^|[A-Z]))(?=[A-Z])|(?<!^)(?=[A-Z][a-z])")) {
            buf.append("_").append(w.toLowerCase());
        }
        return buf.substring(1);
    }
}

import org.apache.ibatis.annotations.InsertProvider;
import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.UpdateProvider;
import org.springframework.stereotype.Repository;
 
@Repository
public interface GenericDao {
 
    @UpdateProvider(type=InsertUpdateSqlProvider.class, method="updateById")
    public int updateById(Object bean);
     
    @UpdateProvider(type=InsertUpdateSqlProvider.class, method="updateNonNullById")
    public int updateNonNullById(Object bean);
     
    @Options(useGeneratedKeys=true, keyProperty="id", keyColumn="id")
    @InsertProvider(type=InsertUpdateSqlProvider.class, method="insert")
    public int insert(Object bean);
     
    @InsertProvider(type=InsertUpdateSqlProvider.class, method="insert")
    public int insertWithoutGeneratedKey(Object bean);
}

import java.util.HashMap;
import java.util.Map;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.NoHandlerFoundException;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
 
 
/**
 * 
 * RestController执行过程中发生异常会被此处捕获处理
 *
 */
@RestControllerAdvice
public class ControllerExceptionHandler extends ResponseEntityExceptionHandler {
    private static final Log log = LogFactory.getLog(ControllerExceptionHandler.class);
     
    /**
     * 通过ExceptionHandler来设置待捕获的异常，Throwable可捕获任何异常，但优先级最低，因此
     * HttpRequestMethodNotSupportedException HttpMediaTypeNotSupportedException
     * HttpMediaTypeNotAcceptableException MissingPathVariableException
     * MissingServletRequestParameterException ServletRequestBindingException
     * ConversionNotSupportedException TypeMismatchException
     * HttpMessageNotReadableException HttpMessageNotWritableException
     * MethodArgumentNotValidException MissingServletRequestPartException
     * BindException NoHandlerFoundException AsyncRequestTimeoutException
     * 等已经在父类声明捕获的异常不会被此方法处理。
     */
    @ExceptionHandler(Throwable.class)
    @ResponseBody
    ResponseEntity<Object> handleControllerException(Throwable ex, WebRequest request) {
        Map<String,String> responseBody = new HashMap<>();
        // 这里控制返回给客户端的信息
        responseBody.put("message","internal server error. " + ex.getMessage());
         
        Exception e;
        if(ex instanceof Exception) {
            e = (Exception) ex;
        }else {
            e = new Exception(ex);
        }
        return handleExceptionInternal(e, responseBody, new HttpHeaders(), HttpStatus.INTERNAL_SERVER_ERROR, request);
    }
 
    /**
     * 需要覆盖这个方法，并且在此方法里记录日志；查看ResponseEntityExceptionHandler源码可知，
     * 有些异常被父类捕获，不会进入此类的handleControllerException，因此如果在handleControllerException
     * 记录异常日志，会导致部分异常无日志
     */
    @Override
    protected ResponseEntity<Object> handleExceptionInternal(Exception ex, Object body,
            HttpHeaders headers, HttpStatus status, WebRequest request) {
        if(log.isErrorEnabled()) {
            log.error("内部错误", ex);
        }
        return super.handleExceptionInternal(ex, body, headers, status, request);
    }
}

@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);
    }
}