public class A extends B {
    {	// 局部作用域
        int a = 233;
    }
    private static int a;
    static {
        System.out.println("The initial value of a is " + a);
    }
    public static void fun(){
    	  System.out.println("The is a function from A.");
	 }
    public A() {
        System.out.println("This is A, over.");
    }

    public static void main(String[] args) {
        A a1 = new A();
        B b1 = new A();
    }
}
class B {
    static {
        System.out.println("Hello, I am B");
    }
		
    B() {
        System.out.println("This is B, over.");
    }
}

String[]   s = {"1","2","3"};
String[][] s = {{"1","2"},{"3","4"}};

new Thread(){
    public void run(){
    }
}.start();

Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(3);

private static final Set<Integer> set = new HashSet<>();
static {
    set.add(1);
    set.add(2);
    set.add(3);
}

Set<Integer> set = new HashSet<Integer>() {{
    add(1);
    add(2);
    add(3);
}};

public class Main {
    private static final Set<String> stringSet = new HashSet<>(){{
       add("I");
       add("am");
       add("stringSet");
    }};
    // ...others
}

Map source = new HashMap(){{
    put("firstName", "John");
    put("lastName", "Smith");
    put("organizations", new HashMap(){{
        put("0", new HashMap(){{
            put("id", "1234");
        }});
        put("abc", new HashMap(){{
            put("id", "5678");
        }});
    }});
}};

public class BST<Key extends Comparable<Key>, Value>
{ 
private static final boolean RED   = true;
private static final boolean BLACK = false;
private Node root;
private class Node
{
    Key key;
    Value val;
    Node left, right;
    boolean color;
    Node(Key key, Value val, boolean color)
    {
        this.key   = key;
        this.val = val;
        this.color = color;
	}	
} 
   public Value get(Key key)
   // Search method.
   public void put(Key key, Value val)
   // Insert method.
   public void delMax(Key key)
}
private boolean isRed(Node x)
{
	if (x == null)
		return false;
	return (x.color == RED);
}

private Node put(Node x, Key key, Value val){
    // 从Node x 开始put
    // 如果存在key,在更新key所在节点的val
    // 否则新建一个叶子节点
    if (x == null) return new Node(key,val,1);
    int cmp = key.compareTo(x.key);
    if (cmp < 0){
        return put(x.left,key,val);
    }
    else if (cmp > 0){
        return put(x.right,key,val);
    }
    else{
        x.val = val;
    }
    // 更新子树的节点个数
    x.N = x.left.N + x.right.N + 1;
    return x;
}

private Node rotateLeft(Node h){
    // 向左旋转
    Node x = h.right;
    h.right = x.left;
    x.left = h;
    x.color = h.color;
    h.color = RED;
    // 更新节点计数器 todo 此处略有不熟
    x.N = h.N;
    h.N = 1 + size(h.left) + size(h.right);
    return x;
}

private Node rotateRight(Node h){
    // 向右旋转,与向左相反
    Node x = h.left;
    h.left = x.right;
    x.right = h;
    x.color = h.color;
    h.color = RED;
    // 更新节点计数器 todo 此处略有不熟
    x.N = h.N;
    h.N = 1 + size(h.left) + size(h.right);
    return x;
}

private void flipColors(Node h){
    h.left.color = BLACK;
    h.right.color = BLACK;
    h.color = RED;
}

private Node colorFlip(Node h)
{
	x.color = !x.color;
	x.left.color = !x.left.color;
	x.right.color = !x.right.color;
	return x;
}

/**
 * @author wangxiaobin
 */
@Configuration
public class JwtCfg {
    @Bean
    public FilterRegistrationBean<JwtFilter> jwtFilter() {
        FilterRegistrationBean<JwtFilter> registrationBean;
        registrationBean = new FilterRegistrationBean<JwtFilter>();
        registrationBean.setFilter(new JwtFilter());
        registrationBean.addUrlPatterns("/api/*");

        return registrationBean;
    }
}

/**
 * 从Http请求中提取JWT的信息，并使用了”secretkey”这个密匙对JWT进行验证
 * @author wangxiaobin
 */
public class JwtFilter extends GenericFilterBean {
    public void doFilter(final ServletRequest req, final ServletResponse res, final FilterChain chain)
            throws IOException, ServletException {

        // Change the req and res to HttpServletRequest and HttpServletResponse
        final HttpServletRequest request = (HttpServletRequest) req;
        final HttpServletResponse response = (HttpServletResponse) res;

        // Get authorization from Http request
        final String authHeader = request.getHeader("authorization");

        // If the Http request is OPTIONS then just return the status code 200
        // which is HttpServletResponse.SC_OK in this code
        if ("OPTIONS".equals(request.getMethod())) {
            response.setStatus(HttpServletResponse.SC_OK);

            chain.doFilter(req, res);
        }
        // Except OPTIONS, other request should be checked by JWT
        else {

            // Check the authorization, check if the token is started by "Bearer "
            if (authHeader == null || !authHeader.startsWith("Bearer ")) {
                throw new ServletException("Missing or invalid Authorization header");
            }

            // Then get the JWT token from authorization
            final String token = authHeader.substring(7);

            try {
                // Use JWT parser to check if the signature is valid with the Key "secretkey"
                // 使用了”secretkey”这个密匙对JWT进行验证
                final Claims claims = Jwts.parser().setSigningKey("secretkey").parseClaimsJws(token).getBody();

                // Add the claim to request header
                request.setAttribute("claims", claims);
            } catch (final SignatureException e) {
                throw new ServletException("Invalid token");
            }

            chain.doFilter(req, res);
        }
    }
}

/**
 * @author wangxiaobin
 */
@RestController
@RequestMapping("/users")
public class UserController {

    private final UserService userService;
    private final ModelMapper modelMapper;

    @Autowired
    public UserController(UserService userService, ModelMapper modelMapper) {
        this.userService = userService;
        this.modelMapper = modelMapper;
    }

    @PostMapping("/signup")
    public String signUp(@RequestBody User user) {
        return userService.signUp(user);
    }

    @PostMapping("/login")
    public Object logIn(@RequestParam String username,@RequestParam String password){
        String token = userService.logIn(username,password);
        UserDataDTO info = modelMapper.map(userService.search(username),UserDataDTO.class);
        JSONObject result = new JSONObject();
        result.put("userMsg",info);
        result.put("accessToken",token);
        return JSON.toJSON(result);
    }
}

/**
 * @author wangxiaobin
 */
@Component
public class JwtTokenProvider {
    /**
     * THIS IS NOT A SECURE PRACTICE! For simplicity, we are storing a static key here. Ideally, in a
     * microservices environment, this key would be kept on a config-server.
   */
    @Value("${security.jrwt.token.secret-key:secret-key}")
    private String secretKey;

    @Value("${security.jwt.token.expire-length:3600000}")
    private long validityInMilliseconds = 3600000; // 1h

    @Autowired
    private MyUserDetails myUserDetails;

    @PostConstruct
    protected void init() {
        secretKey = Base64.getEncoder().encodeToString(secretKey.getBytes());
    }
	
	/**
     * 生成jwt
     */
    public String createToken(String username, List<Role> roles) {

        Claims claims = Jwts.claims().setSubject(username);
        claims.put("auth", roles.stream().map(s -> new SimpleGrantedAuthority(s.getAuthority())).filter(Objects::nonNull).collect(Collectors.toList()));

        Date now = new Date();
        Date validity = new Date(now.getTime() + validityInMilliseconds);

        return Jwts.builder()//
                .setClaims(claims)//
                .setIssuedAt(now)//
                .setExpiration(validity)//
                .signWith(SignatureAlgorithm.HS256, "secretkey")//
                .compact();
    }

    public Authentication getAuthentication(String token) {
        UserDetails userDetails = myUserDetails.loadUserByUsername(getUsername(token));
        return new UsernamePasswordAuthenticationToken(userDetails, "", userDetails.getAuthorities());
    }

    public String getUsername(String token) {
        return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody().getSubject();
    }
    
    
    /**
     * 分解request，获取token
     */
    public String resolveToken(HttpServletRequest req) {
        String bearerToken = req.getHeader("Authorization");
        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7, bearerToken.length());
        }
        return null;
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
            return true;
        } catch (JwtException | IllegalArgumentException e) {
            throw new CustomException("Expired or invalid JWT token", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

}

/**
 * 描述:
 * Product控制器
 *
 * @author wangxiaobin
 */
@Transactional
@RestController
@RequestMapping(value = "/api")
public class ProductController{
    private final ProductRepository productRepository;
    private final ProductServiceImpl productService;

    @Autowired
    public ProductController(ProductRepository productRepository, ProductServiceImpl productService) {
        this.productRepository = productRepository;
        this.productService = productService;
    }
    /**
     * 产品列表分页查询
     */
    @RequestMapping(value = "/products",method = RequestMethod.GET)
    public Object retrieveAllProducts(@RequestParam(value = "page", defaultValue = "0") Integer page ,
                                             @RequestParam(value = "size", defaultValue = "15") Integer size){
        return JSON.toJSON(productService.findProductNoCriteria(page,size).getContent());
    }

    /**
     * 根据产品编号"no"查询商品详情
     */
    @GetMapping(value = "/products/{no}")
    public Object retrieveProduct(@PathVariable("no") String no) {
        Optional<Product> product = productService.retrieveProduct(no);
        return JSON.toJSON(product);
    }
}