javax.net.ssl.SSLHandshakeException: 
sun.security.validator.ValidatorException: 
PKIX path building failed: 
sun.security.provider.certpath.SunCertPathBuilderException: 
unable to find valid certification path to requested target

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.kaptcha.Kaptcha;

@RestController
@RequestMapping("/code")
public class CodeController {
	@Autowired
    private Kaptcha kaptcha;
	
	@RequestMapping("/image")
	void renderImage() {
		String code = kaptcha.render();
		System.out.println(code);
	}
	
	@RequestMapping("/valid")
	boolean validImage(@RequestParam String code) {
		return kaptcha.validate(code);
	}
}

import java.util.Arrays;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.access.AccessDecisionManager;
import org.springframework.security.access.AccessDecisionVoter;
import org.springframework.security.access.vote.AuthenticatedVoter;
import org.springframework.security.access.vote.UnanimousBased;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.web.access.expression.WebExpressionVoter;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
import org.springframework.session.web.http.HttpSessionIdResolver;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
	@Autowired
	private AuthProviderUsernamePassword authProviderUsernamePassword;
	@Autowired
	private AuthSuccessHandler authSuccessHandler;
	@Autowired
	private AuthFailureHandler authFailureHandler;
	@Autowired
	private ExitSuccessHandler exitSuccessHandler;
	
	@Bean
	protected AuthenticationFailureHandler authenticationFailureHandler() {
		authFailureHandler.setDefaultFailureUrl("/login?error");
		return authFailureHandler;
	}
	
	@Bean
	protected LogoutSuccessHandler logoutSuccessHandler() {
		exitSuccessHandler.setDefaultTargetUrl("/login?logout");
		return exitSuccessHandler;
	}

	private static String[] INGORE_URLS = {"/login", "/error",};

	@Override
	public void configure(WebSecurity webSecurity) {
		webSecurity.ignoring().antMatchers("/static/**");//忽略静态资源
		webSecurity.ignoring().antMatchers("/favicon.ico");
	}

	@Override
	protected void configure(HttpSecurity httpSecurity) throws Exception {
		httpSecurity
			.authorizeRequests()
				.antMatchers(INGORE_URLS).permitAll()
				.anyRequest().authenticated()
				.accessDecisionManager(accessDecisionManager())//如果不需要权限验证，去掉这句即可
		.and()
		    .formLogin()
		        .successHandler(authSuccessHandler)
		        .failureHandler(authFailureHandler)
		        .loginPage("/login")//.permitAll()
		.and()
			.logout()
				.logoutSuccessHandler(logoutSuccessHandler())//.permitAll()
		//.and().rememberMe()
		.and().csrf().disable();
	}
	
	@Override
	protected void configure(AuthenticationManagerBuilder auth) throws Exception {
		auth.authenticationProvider(authProviderUsernamePassword);
		//auth.authenticationProvider(authProvider2);可以增加多个认证方式，比如码验证等
	}

	@Bean
    protected AccessDecisionManager accessDecisionManager() {
        List<AccessDecisionVoter<? extends Object>> decisionVoters = Arrays.asList(
            new WebExpressionVoter(),
            authDecisionVoter(),//new RoleVoter(),
            new AuthenticatedVoter());
        return new UnanimousBased(decisionVoters);
    }
	
	@Bean
	protected AuthDecisionVoter authDecisionVoter() {
		return new AuthDecisionVoter();
	}
	
	@Bean
	public HttpSessionIdResolver httpSessionIdResolver() {
		return new HeaderCookieHttpSessionIdResolver();
	}
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.stereotype.Component;

@Component
public class AuthProviderUsernamePassword implements AuthenticationProvider {
	@Autowired 
	AuthUserService authUserService;

	@Override
	public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        String username = authentication.getName();  
        String password = authentication.getCredentials().toString();  
		AuthUser userDetails = authUserService.loadUserByUsername(username);
        if(userDetails == null){  
            throw new BadCredentialsException("账号或密码错误");  
        }  
        if (!authUserService.checkPassword(userDetails, password)) {  
            throw new BadCredentialsException("账号或密码不正确");  
        }  
        //认证校验通过后，封装UsernamePasswordAuthenticationToken返回  
        return new UsernamePasswordAuthenticationToken(userDetails, password, authUserService.fillUserAuthorities(userDetails));  
	}

	@Override
	public boolean supports(Class<?> authentication) {
		return true;
	}
}

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler;
import org.springframework.security.web.savedrequest.HttpSessionRequestCache;
import org.springframework.security.web.savedrequest.RequestCache;
import org.springframework.security.web.savedrequest.SavedRequest;
import org.springframework.stereotype.Component;

@Component
public class AuthSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {
	private RequestCache requestCache = new HttpSessionRequestCache();

	@Override
	public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
			Authentication authentication) throws ServletException, IOException {
		//登录成功处理，比如记录登录日志
		String ip = request.getRemoteAddr();
		String targetUrl = "";
		SavedRequest savedRequest = requestCache.getRequest(request, response);
		if (savedRequest != null) {
			targetUrl = savedRequest.getRedirectUrl();
		}
		AuthUser aUser = (AuthUser) authentication.getPrincipal();
		System.out.printf("User %s login, ip: %s, url: ", aUser.getUsername(), ip, targetUrl);
		
		if (WebUtils.isAjaxReq(request)) {//ajax登录
			response.sendError(200, "success");
            return;
		}
		super.onAuthenticationSuccess(request, response, authentication);
	}
}

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler;
import org.springframework.security.web.savedrequest.HttpSessionRequestCache;
import org.springframework.security.web.savedrequest.RequestCache;
import org.springframework.security.web.savedrequest.SavedRequest;
import org.springframework.stereotype.Component;

@Component
public class AuthFailureHandler extends SimpleUrlAuthenticationFailureHandler {
	@Override
	public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
			AuthenticationException exception) throws IOException, ServletException {
		String uaSummary = WebUtils.getUserAgentSummary(request);
		String ip = request.getRemoteAddr();
		String username = request.getParameter("username");
		System.out.printf("User %s login failed, ip: %s, ua: %s", username, ip, uaSummary);
		super.saveException(request, exception);
		if (WebUtils.isAjaxReq(request)) {//ajax登录
		    //为什么用sendError会导致302重定向到login页面?
		    //--When you invoke sendError it will dispatch the request to /error (it the error handling code registered by Spring Boot. However, Spring Security will intercept /error and see that you are not authenticated and thus redirect you to a log in form.
			response.sendError(403, exception.getMessage());
			return;
		}
		response.sendRedirect("login?error");
	}
}

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.logout.SimpleUrlLogoutSuccessHandler;
import org.springframework.stereotype.Component;

@Component
public class ExitSuccessHandler extends SimpleUrlLogoutSuccessHandler {
	@Override
	public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication)
			throws IOException, ServletException {
		if (WebUtils.isAjaxReq(request)) {//ajax登录
			response.sendError(200, "success");
			return;
		}
		super.onLogoutSuccess(request, response, authentication);
	}
}

import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.session.web.http.CookieHttpSessionIdResolver;
import org.springframework.session.web.http.HeaderHttpSessionIdResolver;
import org.springframework.session.web.http.HttpSessionIdResolver;

public class HeaderCookieHttpSessionIdResolver implements HttpSessionIdResolver {
	protected HeaderHttpSessionIdResolver headerResolver = HeaderHttpSessionIdResolver.xAuthToken();
	protected CookieHttpSessionIdResolver cookieResolver = new CookieHttpSessionIdResolver();

	@Override
	public List<String> resolveSessionIds(HttpServletRequest request) {
		List<String> sessionIds = headerResolver.resolveSessionIds(request);
		if (sessionIds.isEmpty()) {
			sessionIds = cookieResolver.resolveSessionIds(request);
		}
		return sessionIds;
	}

	@Override
	public void setSessionId(HttpServletRequest request, HttpServletResponse response, String sessionId) {
		headerResolver.setSessionId(request, response, sessionId);
		cookieResolver.setSessionId(request, response, sessionId);
	}

	@Override
	public void expireSession(HttpServletRequest request, HttpServletResponse response) {
		headerResolver.expireSession(request, response);
		cookieResolver.expireSession(request, response);
	}
}

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import javax.persistence.Id;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.util.StringUtils;
import lombok.Data;

@Data
public class AuthUser implements UserDetails, Serializable {
	private static final long serialVersionUID = -1572872798317304041L;
	
	@Id
	private Long id;
	private String username;
	private String password;
	
	private Collection<? extends GrantedAuthority> authorities;

	public Collection<? extends GrantedAuthority> fillPerms(List<String> perms) {
		String authorityString = StringUtils.collectionToCommaDelimitedString(perms);
		authorities = AuthorityUtils.commaSeparatedStringToAuthorityList(authorityString);
		return authorities;
	}

	@Override
	public Collection<? extends GrantedAuthority> getAuthorities() {
		return authorities;
	}

	@Override
	public boolean isAccountNonExpired() {
		return true;
	}

	@Override
	public boolean isAccountNonLocked() {
		return true;
	}

	@Override
	public boolean isCredentialsNonExpired() {
		return true;
	}

	@Override
	public boolean isEnabled() {
		return true;
	}
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.joda.time.LocalDateTime;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class AuthUserService implements UserDetailsService {
	@Override
	public AuthUser loadUserByUsername(String username) throws UsernameNotFoundException {
		//读取用户，一般是从数据库读取，这里随便new一个
		AuthUser user = new AuthUser();// userDao.findByUsername(username);
		user.setId(System.currentTimeMillis());
		user.setUsername(username);
		user.setPassword(username);
		return user;
	}
	
	public boolean checkPassword(AuthUser user, String pwd) {
		//判断用户密码，这里简单判断相等
		if (pwd != null && pwd.equals(user.getPassword())) {
			return true;
		}
		return false;
	}

	public Collection<? extends GrantedAuthority> fillUserAuthorities(AuthUser aUser) {
		//获取用户权限，一般从数据库读取，并缓存。这里随便拼凑
		List<String> perms = new ArrayList<>(); //permDao.findPermByUserId(aUser.getId());
		LocalDateTime now = LocalDateTime.now();
		perms.add("P"+now.getHourOfDay());
		perms.add("P"+now.getMinuteOfHour());
		perms.add("P"+now.getSecondOfMinute());
		return aUser.fillPerms(perms);
	}
}

import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class AuthController {
	@RequestMapping("/login")//登录入口
	String login(String username, Model model) {
		model.addAttribute("username", username);
		return "login";
	}
	
	@RequestMapping("/")//主页
	@ResponseBody
	Object home(@AuthenticationPrincipal AuthUser currentUser) {
		return currentUser;
	}
	
	@RequestMapping("/{path}")//测试用
	@ResponseBody
	Object url1(@PathVariable String path) {
        if (path.contains("0")) {//模拟错误
			path = String.valueOf(1/0);
		}
		return path;
	}
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.springframework.security.access.AccessDecisionVoter;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.access.SecurityConfig;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.web.FilterInvocation;
import org.springframework.util.StringUtils;

public class RbacDecisionVoter implements AccessDecisionVoter<Object> {
	static final String permitAll = "permitAll";
	
	@Override
	public boolean supports(ConfigAttribute attribute) {
		return true;
	}

	@Override
	public boolean supports(Class<?> clazz) {
		return true;
	}

	@Override
	public int vote(Authentication authentication, Object object, Collection<ConfigAttribute> attributes) {
		if (authentication == null) {
			return ACCESS_DENIED;
		}

		if (attributes != null) {
			for (ConfigAttribute attribute : attributes) {
				if (permitAll.equals(attribute.toString())) {// skip permitAll
					return ACCESS_ABSTAIN;
				}
			}
		}

		String requestUrl = ((FilterInvocation) object).getRequestUrl();// 当前请求的URL
		Collection<ConfigAttribute> urlPerms = getPermissionsByUrl(requestUrl);// 能访问URL的权限
		if (urlPerms == null || urlPerms.isEmpty()) {
			return ACCESS_ABSTAIN;
		}

		int result = ACCESS_ABSTAIN;
		Collection<? extends GrantedAuthority> userAuthorities = authentication.getAuthorities(); // 当前用户的权限
		for (ConfigAttribute attribute : urlPerms) {
			String urlPerm = attribute.getAttribute();
			if (StringUtils.isEmpty(urlPerm)) {
				continue;
			}
			
			result = ACCESS_DENIED;
			// Attempt to find a matching granted authority
			for (GrantedAuthority authority : userAuthorities) {
				if (urlPerm.equals(authority.getAuthority())) {
					return ACCESS_GRANTED;
				}
			}
		}
		return result;
	}

	Collection<ConfigAttribute> getPermissionsByUrl(String url) {
		// 获取url的访问权限，一般从数据库读取，并缓存。这里随便拼凑
		if ("/".equals(url)) {
    		return null;//根路径不限权
		}
		String n1 = url.substring(url.length()-1);
		String n2 = url.substring(url.length()-2);
		return SecurityConfig.createList("P"+n1, "P"+n2);
	}
}

import java.util.Map;
import org.springframework.boot.web.servlet.error.DefaultErrorAttributes;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.WebRequest;

@Component
public class CustomErrorAttributes extends DefaultErrorAttributes {
	@Override
	public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) {
		Map<String, Object> errorAttributes = super.getErrorAttributes(webRequest, includeStackTrace);
		errorAttributes.put("code", errorAttributes.getOrDefault("status", 0));//自定义code属性
		Throwable error = super.getError(webRequest);
		if (error != null && error.getMessage() != null) {
			String message = (String)errorAttributes.getOrDefault("message", "");
			if (!message.equals(error.getMessage())) {
				errorAttributes.put("message", message+" "+error.getMessage());//增强message属性
			}
		}
		return errorAttributes;
	}
}

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;

@Service
public class MailService {
	@Value("${spring.mail.username}")//from address must be same as authorization user
	String mailFrom;
	
	@Autowired
	JavaMailSender mailSender;
	
	public void sendHtml(String mailTo, String subject, String html) throws MessagingException{
		MimeMessage mime = mailSender.createMimeMessage();
		MimeMessageHelper mail = new MimeMessageHelper(mime);
		mail.setFrom(mailFrom);
		mail.setTo(mailTo.split(";"));//支持多个接收者
		mail.setSubject(subject);
		mail.setText(html, true);
		mailSender.send(mime);
	}
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.thymeleaf.TemplateEngine;
import org.thymeleaf.context.Context;

@Service
public class NotifyService {
    private static final String MAIL_TPL_NOTIFY = "mail/notify";//邮件模板.html
	@Autowired
	private MailService mailService;
	@Autowired
	private TemplateEngine templateEngine;

	public void sendNotify(String mailTo, String subject, Context context) {
		new Thread(() -> {//开启线程异步发送邮件
			try {
				String html = templateEngine.process(MAIL_TPL_NOTIFY, context);
				mailService.sendHtml(mailTo, subject, html);
				//TODO: 发送成功
			} catch (Exception e) {
			    //TODO: 发送失败
				e.printStackTrace();
			}
		}).start();
	}
}

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.MessageDigest;
import java.util.Date;
import java.util.Formatter;
import java.util.UUID;
import org.springframework.lang.Nullable;
import org.springframework.util.DigestUtils;

public class StringUtils extends org.springframework.util.StringUtils {
	
	public static boolean equals(@Nullable String str1, @Nullable String str2) {
		if (str1 == null || str2 == null) {
			return (str1 == null && str2 == null);
		}
		return str1.equals(str2);
	}
	
    public static boolean isBlank(@Nullable String string) {
        if (isEmpty(string)) {
            return true;
        }
        for (int i = 0; i < string.length(); i++) {
            if (!Character.isWhitespace(string.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    public static boolean isNotBlank(@Nullable String string) {
        return !StringUtils.isBlank(string);
    }
    
    public static boolean isBlank(@Nullable Integer id) {
        return id == null || id == 0;
    }

    public static boolean isNotBlank(@Nullable Integer id) {
        return id != null && id != 0;
    }

	public static String[] split(@Nullable String string, @Nullable String delimiter, int limit) {
		if (isEmpty(string) || delimiter == null || limit == 1) {
			return new String[]{string};
		}
		return string.split(delimiter, limit);
	}
	
	/* @return uuid string(32) */
	public static String uuid() {
		return UUID.randomUUID().toString().replace("-", "");
	}
	
	private static final String[] chars = new String[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l",
			"m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6",
			"7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R",
			"S", "T", "U", "V", "W", "X", "Y", "Z" };
	/* gen short unique id(8 chars) */
	public static String unid8() {
		return StringUtils.unid8(null);
	}
	private static String unid8(String uuid32) {
		StringBuffer shortBuffer = new StringBuffer();
		if (StringUtils.isBlank(uuid32)) {
			uuid32 = StringUtils.uuid();
		}
		for (int i = 0; i < 8; i++) {
			String str = uuid32.substring(i * 4, i * 4 + 4);
			int x = Integer.parseInt(str, 16);
			shortBuffer.append(StringUtils.chars[x % 0x3E]);
		}
		return shortBuffer.toString();
	}
	/* gen unique id(20 chars) that has timestamp */
	public static String unid20() {
		long ts = new Date().getTime();
		return String.format("%d_%s", ts, StringUtils.unid8());
	}
	
	/* MD5, null as empty str. */
	public static String MD5(String str) {
		if (str == null) {
			str = "";
		}
		return DigestUtils.md5DigestAsHex(str.getBytes());
	}

	/* SHA-1, null as empty str. */
	public static String SHA1(String str) {
		if (str == null) {
			return "";
		}
		try {
			MessageDigest crypt = MessageDigest.getInstance("SHA-1");
			crypt.reset();
			crypt.update(str.getBytes("UTF-8"));
			return byteToHex(crypt.digest());
		} catch (Exception e) {
			e.printStackTrace();
		}
		return str;
	}
	private static String byteToHex(final byte[] hash) {
		Formatter formatter = new Formatter();
		for (byte b : hash) {
			formatter.format("%02x", b);
		}
		String result = formatter.toString();
		formatter.close();
		return result;
	}
	
	public static String urlDecode(String raw) {
		try {
			return URLDecoder.decode(raw, "UTF-8");
		} catch (UnsupportedEncodingException uee) {
			throw new IllegalStateException(uee); // can't happen
		}
	}

	public static String urlEncode(String str) {
		try {
			return URLEncoder.encode(str, "UTF-8");
		} catch (UnsupportedEncodingException uee) {
			throw new IllegalStateException(uee); // can't happen
		}
	}
	
	public static String urlEncode(String str, String en) {
		try {
			return URLEncoder.encode(str, en);
		} catch (UnsupportedEncodingException uee) {
			throw new IllegalStateException(uee); // can't happen
		}
	}
	
	public static String convert(String str, String from, String to) {
		try {
			str = new String(str.getBytes(from), to);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return str;
	}
}

import org.springframework.lang.Nullable;

public class NumberUtils extends org.springframework.util.NumberUtils {
	public static <T extends Number> boolean equals(@Nullable T a, @Nullable T b) {
		if (a == null || b == null) {
			return (a == null && b == null);
		}
		return a.equals(b);
	}
	
	public static <T extends Number> T parse(String text, Class<T> targetClass, T defaultValue) {
		if (text == null || text.equals("")) {
			return defaultValue;
		}
		try {
			return NumberUtils.parseNumber(text, targetClass);
		}catch(Exception e){
			e.printStackTrace();
		}
		return defaultValue;
	}
	public static <T extends Number> T parse(String text, Class<T> targetClass) {
		return NumberUtils.parse(text, targetClass, null);
	}
	public static Integer parseInt(String text) {
		return NumberUtils.parse(text, Integer.class);
	}
	public static Long parseLong(String text) {
		return NumberUtils.parse(text, Long.class);
	}
}

import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.chrono.ChronoLocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.Locale;
import org.springframework.lang.Nullable;

public class DateTimeUtils {
	public static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
	
	public static int compare(Date theDate, Date anotherDate) {
		if (theDate == null) {
			theDate = new Date();
		}
		if (anotherDate == null) {
			anotherDate = new Date();
		}
		return theDate.compareTo(anotherDate);
	}

	public static int compare(ChronoLocalDateTime<?> theDate, ChronoLocalDateTime<?> anotherDate) {
		if (theDate == null) {
			theDate = LocalDateTime.now();
		}
		if (anotherDate == null) {
			anotherDate = LocalDateTime.now();
		}
		return theDate.compareTo(anotherDate);
	}

    public static Date toDate(LocalDateTime localDateTime) {
    	if (localDateTime == null) return null;
        return Date.from(localDateTime.toInstant(ZoneOffset.of("+8")));
    }
 
    public static LocalDateTime toLocalDateTime(Date date) {
    	if (date == null) return null;
        return fromMilli(date.getTime());
    }
    
    public static Date parseDate(@Nullable String string) {
		SimpleDateFormat format = new SimpleDateFormat(DATETIME_PATTERN, Locale.CHINA);
		try {
			return format.parse(string);
		} catch (Exception e) {
			return null;
		}
	}
	public static LocalDateTime parseLocalDateTime(@Nullable String string) {
		DateTimeFormatter format = DateTimeFormatter.ofPattern(DATETIME_PATTERN, Locale.CHINA);
		try {
			return LocalDateTime.parse(string, format);
		} catch (Exception e) {
			return null;
		}
	}
	
	public static String formatDateTime(LocalDateTime dt) {
		if (dt == null) return null;
		
		DateTimeFormatter format = DateTimeFormatter.ofPattern(DATETIME_PATTERN, Locale.CHINA);
		return dt.format(format);
	}
	
	public static LocalDateTime fromSecond(long second, ZoneOffset offset) {
		if (offset == null) {
			offset = ZoneOffset.of("+8");
		}
		LocalDateTime localDateTime = LocalDateTime.ofEpochSecond(second, 0, offset);
		return localDateTime;
	}
	public static LocalDateTime fromSecond(long second) {
		return DateTimeUtils.fromSecond(second, null);
	}
	
	public static LocalDateTime fromMilli(long ts, ZoneOffset offset) {
		if (offset == null) {
			offset = ZoneOffset.of("+8");
		}
		Instant instant = Instant.ofEpochMilli(ts);
		LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, offset);
		return localDateTime;
	}
	public static LocalDateTime fromMilli(long ts) {
		return DateTimeUtils.fromMilli(ts, null);
	}
	
	//返回世纪秒
	public static long secondsOf(ChronoLocalDateTime<?> ldt, ZoneOffset offset) {
		if (ldt == null) {
			return 0;
		}
		if (offset == null) {
			offset = ZoneOffset.of("+8");
		}
		long second = ldt.toEpochSecond(offset);
		return second;
	}
	public static long secondsOf(ChronoLocalDateTime<?> ldt) {
		return DateTimeUtils.secondsOf(ldt, null);
	}
	
	//返回世纪毫秒
	public static long micsecondsOf(ChronoLocalDateTime<?> ldt, ZoneOffset offset) {
		if (ldt == null) {
			return 0;
		}
		if (offset == null) {
			offset = ZoneOffset.of("+8");
		}
		long mic = ldt.toInstant(offset).toEpochMilli();
		return mic;
	}
	public static long micsecondsOf(ChronoLocalDateTime<?> ldt) {
		return DateTimeUtils.micsecondsOf(ldt, null);
	}
}