lyloou

public class Test {
    /**
     * 最多展示 4 个场次
     */
    private static final int MAX_SCENE_SIZE = 4;

    private Result getResult(List<SceneModel> candidateSceneList) {
        Result result = new Result();
        final int size = candidateSceneList.size();

        // 不足4场次全部返回
        if (size <= MAX_SCENE_SIZE) {
            result.setHasNext(false);
            result.setSceneList(candidateSceneList);
            return result;
        }

        // 多余4场次，按以下规则取
        List<SceneModel> resultList;

        // 获取最后一个已结束的场次下标
        int index = getLastFinishedSceneIndex(candidateSceneList);

        // 1. 如果：index=-1 时，表示都没结束，取前4个；hasNext=true
        if (index == -1) {
            resultList = candidateSceneList.subList(0, MAX_SCENE_SIZE);
            result.setSceneList(resultList);
            result.setHasNext(true);
            return result;
        }

        // 2. 如果：size-index<=4 时，表示未结束的不多了，取后4个；hasNext=false
        if (size - index <= MAX_SCENE_SIZE) {
            resultList = candidateSceneList.subList(size - MAX_SCENE_SIZE, size);
            result.setSceneList(resultList);
            result.setHasNext(false);
            return result;
        }

        // 3. 否则：取index、index+1、index+2、index+3；hasNext=true
        resultList = candidateSceneList.subList(index, index + MAX_SCENE_SIZE);
        result.setSceneList(resultList);
        result.setHasNext(true);
        return result;
    }
}

/**
 * 二分查找，从有序的数组中找到目标值
 *
 */
public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};

        System.out.println("找-1的下标：" + bSearch(arr, -1));
        System.out.println("找1的下标：" + bSearch(arr, 1));
        System.out.println("找2的下标：" + bSearch(arr, 2));
        System.out.println("找3的下标：" + bSearch(arr, 3));
        System.out.println("找4的下标：" + bSearch(arr, 4));
        System.out.println("找5的下标：" + bSearch(arr, 5));
        System.out.println("找6的下标：" + bSearch(arr, 6));
        System.out.println("找7的下标：" + bSearch(arr, 7));
        System.out.println("找8的下标：" + bSearch(arr, 8));
        System.out.println("找9的下标：" + bSearch(arr, 9));
        System.out.println("找10的下标：" + bSearch(arr, 10));

        System.out.println("从null中找1的下标：" + bSearch(null, 1));
        System.out.println("从{}中找1的下标：" + bSearch(new int[]{}, 1));
        System.out.println("从{1}找1的下标：" + bSearch(new int[]{1}, 1));
        System.out.println("从{1}找2的下标：" + bSearch(new int[]{1}, 2));
    }

    private static int bSearch(int[] arr, int target) {
        if (arr == null || arr.length < 1) {
            return -1;
        }
        int first = 0;
        int last = arr.length - 1;
        while (first <= last) {

            // 取中间值
            int mid = (first + last) >> 1;

            if (arr[mid] == target) { // 中间值正好是要找的目标值
                return mid;
            } else if (arr[mid] > target) { // 中间值大于目标值，在左边找
                last = mid - 1;
            } else { // 中间值小于目标值，在右边找
                first = mid + 1;
            }
        }

        return -1;
    }
}/* 输出：
找-1的下标：-1
找1的下标：0
找2的下标：1
找3的下标：2
找4的下标：3
找5的下标：4
找6的下标：5
找7的下标：6
找8的下标：7
找9的下标：8
找10的下标：-1
从null中找1的下标：-1
从{}中找1的下标：-1
从{1}找1的下标：0
从{1}找2的下标：-1
 */

/**
 * 有一个长度为 n 的非降序数组，比如[1,2,3,4,5]，将它进行旋转，即把一个数组最开始的若干个元素搬到数组的末尾，变成一个旋转数组，比如变成了[3,4,5,1,2]，或者[4,5,1,2,3]，
 * 这样的。请问，给定这样一个旋转数组，求数组中的最小值。
 *
 */
public class BinaryExtendSearch {
    public static void main(String[] args) {
        System.out.println("{5, 6, 7, 8, 9, 1, 2, 3, 4} 找最小值，应该是1：" + bExtendSearch(new int[]{5, 6, 7, 8, 9, 1, 2, 3, 4}));
        System.out.println("{1, 2, 3, 4}找最小值，应该是1：" + bExtendSearch(new int[]{1, 2, 3, 4}));
        System.out.println("{1, 0, 1, 1, 1}找最小值，应该是0：" + bExtendSearch(new int[]{1, 0, 1, 1, 1}));
        System.out.println("{1, 1, 1, 1, 1}找最小值，应该是1：" + bExtendSearch(new int[]{1, 1, 1, 1, 1}));

    }

    private static int bExtendSearch(int[] arr) {
        if (arr == null || arr.length < 1) {
            return -1;
        }

        // 取最右端数据为目标值
        int target = arr[arr.length - 1];

        int first = 0;
        int last = arr.length - 1;
        while (first < last) {
            // 提前结束
            if (arr[first] < arr[last]) {
                return arr[first];
            }

            // 取中值
            int mid = (first + last) >> 1;

            // 如果中间值大于目标值，最小值在右边
            if (arr[mid] > target) {
                first = mid + 1;
                continue;
            }

            // 如果中间值小于目标值，最小值在左边，目标值成为中间值
            if (arr[mid] < target) {
                last = mid;
                target = arr[mid];
                continue;
            }

            // 其它情况，中间值==目标值
            last--;
        }

        return arr[first];
    }
}/*输出
{5, 6, 7, 8, 9, 1, 2, 3, 4} 找最小值，应该是1：1
{1, 2, 3, 4}找最小值，应该是1：1
{1, 0, 1, 1, 1}找最小值，应该是0：0
{1, 1, 1, 1, 1}找最小值，应该是1：1
*/

class ValidateLoginAspect {

  @Around("pointCutMethod()")
  public Object preHandle(ProceedingJoinPoint pjp) {
    // ......
    UserContextHolder.getInstance().setContext(userMap);
    final Object proceed;
    try {
      proceed = pjp.proceed();
    } finally {
      UserContextHolder.getInstance().clear();
    }
    return proceed;
  }
}

@RestController
public class UserController extends BaseTokenController {

    // 从父类继承了ValidateLogin，需要身份验证
    @GetMapping("/ping")
    public String ping() {
        final Integer userId = currentUserId();
        System.out.println(userId);
        return "pong";
    }

}

@RestController
public class UserController extends BaseTokenController {

    @Autowired
    TokenService tokenService;

    // 手动忽略身份验证
    @IgnoreValidateLogin
    @GetMapping("/login")
    public String login(String userId, String username) {

        Map<String, String> map = new HashMap<>();
        map.put("userId", userId);
        map.put("userName", username);
        map.put("userAvatar", "http://cdn.lyloou.com/a.jpg");

        final String token = tokenService.createToken(userId, username, JSONUtil.toJsonStr(map));
        return token;
    }
}

@RestController
public class UserController {


    // 手动添加身份验证
    @ValidateLogin
    @GetMapping("userinfo")
    public Map<String, String> userInfo() {
        Map<String, String> map = new HashMap<>();
        map.put(UserManager.X_USER_ID, UserManager.getUserId() + "");
        map.put(UserManager.X_USER_IP, UserManager.getUserIP());
        map.put(UserManager.X_USER_NAME, UserManager.getUserName());
        map.put(UserManager.X_USER_INFO, UserManager.getUserInfo());
        return map;
    }
}

/**
 * @author lilou
 * @since 2021/7/14
 */
@Service
public class RedisCodeCache implements DataCache {

    @Autowired
    private RedisService redisService;
    @Autowired
    private TokenProperties tokenProperties

    @Override
    public void set(String key, String value) {
        set(key, value, tokenProperties.getExpireSecond());
    }

    @Override
    public void set(String key, String value, long timeout) {
        redisService.set(key, value, (int) timeout);
    }

    @Override
    public String get(String key) {
        return redisService.get(key);
    }

    @Override
    public void remove(String key) {
        redisService.del(key);
    }

    @Override
    public boolean containsKey(String key) {
        return redisService.exists(key);
    }
}

public class SignAutoConfiguration implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new SignInterceptor());
    }
}

public abstract class AuthDefaultRequest implements AuthRequest{
	// ...
	protected abstract AuthToken getAccessToken(AuthCallback var1);

    protected abstract AuthUser getUserInfo(AuthToken var1);
	// ...
}

public interface AuthSource {
    String authorize();

    String accessToken();

    String userInfo();

    default String revoke() {
        throw new AuthException(AuthResponseStatus.UNSUPPORTED);
    }

    default String refresh() {
        throw new AuthException(AuthResponseStatus.UNSUPPORTED);
    }

    default String getName() {
        return this instanceof Enum ? String.valueOf(this) : this.getClass().getSimpleName();
    }
}
public enum AuthDefaultSource implements AuthSource {
    GITHUB {
        public String authorize() {
            return "https://github.com/login/oauth/authorize";
        }

        public String accessToken() {
            return "https://github.com/login/oauth/access_token";
        }

        public String userInfo() {
            return "https://api.github.com/user";
        }
    },
    WEIBO {
        public String authorize() {
            return "https://api.weibo.com/oauth2/authorize";
        }

        public String accessToken() {
            return "https://api.weibo.com/oauth2/access_token";
        }

        public String userInfo() {
            return "https://api.weibo.com/2/users/show.json";
        }

        public String revoke() {
            return "https://api.weibo.com/oauth2/revokeoauth2";
        }
    }
	// ...
}

// justauth-spring-boot-starter JustAuthStateCacheConfiguration
    @ConditionalOnMissingBean({AuthStateCache.class})
    @ConditionalOnProperty(
        name = {"justauth.cache.type"},
        havingValue = "default",
        matchIfMissing = true  // 默认
    )
    static class Default {
        Default() {
        }

        @Bean
        public AuthStateCache authStateCache() {
            return AuthDefaultStateCache.INSTANCE;
        }

        static {
            JustAuthStateCacheConfiguration.log.debug("JustAuth 使用 默认缓存存储 state 数据");
        }
    }

/**
 * 各个平台 scope 类的统一接口
 *
 * @author yadong.zhang (yadong.zhang0415(a)gmail.com)
 * @version 1.0.0
 * @since 1.15.7
 */
public interface AuthScope {

    /**
     * 获取字符串 {@code scope}，对应为各平台实际使用的 {@code scope}
     *
     * @return String
     */
    String getScope();

    /**
     * 判断当前 {@code scope} 是否为各平台默认启用的
     *
     * @return boolean
     */
    boolean isDefault();
}

/**
 * Google 平台 OAuth 授权范围
 *
 * @author yadong.zhang (yadong.zhang0415(a)gmail.com)
 * @version 1.0.0
 * @since 1.0.0
 */
@Getter
@AllArgsConstructor
public enum AuthGoogleScope implements AuthScope {

    /**
     * {@code scope} 含义，以{@code description} 为准
     */
    USER_OPENID("openid", "Associate you with your personal info on Google", true),
    USER_EMAIL("email", "View your email address", true),
    USER_PROFILE("profile", "View your basic profile info", true),
    USER_PHONENUMBERS_READ("https://www.googleapis.com/auth/user.phonenumbers.read", "View your phone numbers", false),
    USER_ORGANIZATION_READ("https://www.googleapis.com/auth/user.organization.read", "See your education, work history and org info", false),
    USER_GENDER_READ("https://www.googleapis.com/auth/user.gender.read", "See your gender", false),
    USER_EMAILS_READ("https://www.googleapis.com/auth/user.emails.read", "View your email addresses", false),

    USER_BIRTHDAY_READ("https://www.googleapis.com/auth/user.birthday.read", "View your complete date of birth", false)
    // ...
}

// AuthDefaultRequest.java
    /**
     * 返回带{@code state}参数的授权url，授权回调时会带上这个{@code state}
     *
     * @param state state 验证授权流程的参数，可以防止csrf
     * @return 返回授权地址
     * @since 1.9.3
     */
    @Override
    public String authorize(String state) {
        return UrlBuilder.fromBaseUrl(super.authorize(state))
            .queryParam("access_type", "offline")
            .queryParam("scope", this.getScopes(" ", false, AuthScopeUtils.getDefaultScopes(AuthGoogleScope.values())))
            .queryParam("prompt","select_account")
            .build();
    }
    /**
     * 获取以 {@code separator}分割过后的 scope 信息
     *
     * @param separator     多个 {@code scope} 间的分隔符
     * @param encode        是否 encode 编码
     * @param defaultScopes 默认的 scope， 当客户端没有配置 {@code scopes} 时启用
     * @return String
     * @since 1.16.7
     */
    protected String getScopes(String separator, boolean encode, List<String> defaultScopes) {
        List<String> scopes = config.getScopes();
        if (null == scopes || scopes.isEmpty()) {
            if (null == defaultScopes || defaultScopes.isEmpty()) {
                return "";
            }
            scopes = defaultScopes;
        }
        if (null == separator) {
            // 默认为空格
            separator = " ";
        }
        String scopeStr = String.join(separator, scopes);
        return encode ? UrlUtil.urlEncode(scopeStr) : scopeStr;
    }

USER_OPENID("openid", "Associate you with your personal info on Google", true),
USER_EMAIL("email", "View your email address", true),
USER_PROFILE("profile", "View your basic profile info", true),

protected AuthUser getUserInfo(AuthToken authToken) {
    HttpHeader header = new HttpHeader();
    header.add("Authorization", "token " + authToken.getAccessToken());
    String response = (new HttpUtils(this.config.getHttpConfig())).get(UrlBuilder.fromBaseUrl(this.source.userInfo()).build(), (Map)null, header, false);
    JSONObject object = JSONObject.parseObject(response);
    this.checkResponse(object.containsKey("error"), object.getString("error_description"));
    return AuthUser.builder().rawUserInfo(object).uuid(object.getString("id")).username(object.getString("login")).avatar(object.getString("avatar_url")).blog(object.getString("blog")).nickname(object.getString("name")).company(object.getString("company")).location(object.getString("location")).email(object.getString("email")).remark(object.getString("bio")).gender(AuthUserGender.UNKNOWN).token(authToken).source(this.source.toString()).build();
}

public class HttpUtils {
    public HttpUtils(HttpConfig config) {
        HttpUtil.setConfig(config);
    }
    // ...
}

public class HttpUtil{
   public void setConfig(HttpConfig httpConfig) {
		checkHttpNotNull(proxy);
		if (null == httpConfig) {
			httpConfig = HttpConfig.builder().timeout(Constants.DEFAULT_TIMEOUT).build();
		}
		proxy.setHttpConfig(httpConfig);
	}
    private void checkHttpNotNull(Http proxy) {
		if (null == proxy) {
			selectHttpProxy();
		}
	}
}

public class HttpUtil {
	private static AbstractHttp proxy;

	private void selectHttpProxy() {
		AbstractHttp defaultProxy = null;
		ClassLoader classLoader = HttpUtil.class.getClassLoader();
		// 基于 java 11 HttpClient
		if (ClassUtil.isPresent("java.net.http.HttpClient", classLoader)) {
			defaultProxy = getHttpProxy(com.xkcoding.http.support.java11.HttpClientImpl.class);
		}
		// 基于 okhttp3
		if (null == defaultProxy && ClassUtil.isPresent("okhttp3.OkHttpClient", classLoader)) {
			defaultProxy = getHttpProxy(com.xkcoding.http.support.okhttp3.OkHttp3Impl.class);
		}
		// 基于 httpclient
		if (null == defaultProxy && ClassUtil.isPresent("org.apache.http.impl.client.HttpClients", classLoader)) {
			defaultProxy = getHttpProxy(com.xkcoding.http.support.httpclient.HttpClientImpl.class);
		}
		// 基于 hutool
		if (null == defaultProxy && ClassUtil.isPresent("cn.hutool.http.HttpRequest", classLoader)) {
			defaultProxy = getHttpProxy(com.xkcoding.http.support.hutool.HutoolImpl.class);
		}

		if (defaultProxy == null) {
			throw new SimpleHttpException("Has no HttpImpl defined in environment!");
		}

		proxy = defaultProxy;
	}
}