Home

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    //http://localhost:9007/swagger-ui.html
    @Bean
    public Docket createRestApi() {

        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("cn.com.dinglisec.iot.uaa.api"))
                .paths(PathSelectors.any())
                .build()
                .securitySchemes(securitySchemes())
                .securityContexts(securityContexts());
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("springboot利用swagger构建api文档")
                .description("简单优雅的restful风格")
                .termsOfServiceUrl("")
                .version("1.0")
                .build();
    }

    private List<ApiKey> securitySchemes() {
        List<ApiKey> apiKeys = new ArrayList<>();
        apiKeys.add(new ApiKey("Authorization", "Authorization", "header"));
        return apiKeys;
    }

    private List<SecurityContext> securityContexts() {
        List<SecurityContext> securityContexts = new ArrayList<>();
        securityContexts.add(SecurityContext.builder()
                .securityReferences(defaultAuth())
                .forPaths(PathSelectors.regex("^(?!auth).*$")).build());
        return securityContexts;
    }

    private List<SecurityReference> defaultAuth() {
        AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
        AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
        authorizationScopes[0] = authorizationScope;
        List<SecurityReference> securityReferences = new ArrayList<>();
        securityReferences.add(new SecurityReference("Authorization", authorizationScopes));
        return securityReferences;
    }

}

public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private static final PathMatcher pathMatcher = new AntPathMatcher();

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        if (StringUtils.contains(request.getServletPath(), "swagger")
                || StringUtils.contains(request.getServletPath(), "webjars")
                || StringUtils.contains(request.getServletPath(), "v2")) {
            if (request.getServerName().equals("localhost")) {
                filterChain.doFilter(request, response);
            }
        } else {
            if (isExceededUrl(request)) {
                // 登录注册请求直接放行
                filterChain.doFilter(request, response);
            } else {
                // 获取请求头中的Authorization信息
                String tokenHeader = request.getHeader(TokenConstants.TOKEN_HEADER);

                // token不存在则返回
                if (StringUtils.isBlank(tokenHeader) || !tokenHeader.startsWith(TokenConstants.TOKEN_PREFIX)) {
                    ServletOutputStream out = response.getOutputStream();
                    out.print(ResponseConstants.TOKEN_IS_INVALID);
                    out.close();
                    return;
                }

                // token过期返回
                if (JwtUtil.isExpiration(JwtUtil.getTokenByHeader(tokenHeader))) {
                    ServletOutputStream out = response.getOutputStream();
                    out.print(ResponseConstants.TOKEN_IS_INVALID);
                    out.close();
                    return;
                }

                String uid = "";
                try {
                    uid = JwtUtil.getUidByTokenHeader(request.getHeader(TokenConstants.TOKEN_HEADER));
                } catch (Exception e) {
                    e.printStackTrace();
                }
                request.setAttribute("uid", uid);

                HttpServletRequest req = (HttpServletRequest) request;
                MutableHttpServletRequest mutableRequest = new MutableHttpServletRequest(req);
                mutableRequest.putHeader("uid", uid);
                filterChain.doFilter(request, response);
            }
        }
    }

    /**
     * @Description:我们只对地址 /api 开头的api检查jwt. 不然的话登录/login也需要jwt 做url匹配，参考
     *                     https://www.cnblogs.com/zhangxiaoguang/p/5855113.html
     * @param request
     * @return boolean
     */
    private boolean isProtectedUrl(HttpServletRequest request) {
        return pathMatcher.match("/**", request.getServletPath());
    }

    /**
     * @Description:登录注册不做校验
     * @param request
     * @return boolean
     */
    private boolean isExceededUrl(HttpServletRequest request) {
        return pathMatcher.match("/user/login", request.getServletPath())
                || pathMatcher.match("/user/register", request.getServletPath());
    }

}

class Solution {

    List<List<Integer>> res = new ArrayList<List<Integer>>();
    public List<List<Integer>> permute(int[] nums) {
        List<Integer> list = new ArrayList<>();
        boolean[] used = new boolean[nums.length];// 添加判断条件
        DFS(nums,list,used);
        return res;
    }

    public List<Integer> DFS(int[] nums,List<Integer> list,boolean[] used) {
        // 1.截止条件
        if(list.size()==nums.length) {
        //    res.add(list); // 这里是重点
            res.add(new ArrayList<>(list)); // 这里是重点
            return list;
        }

        // 2.遍历候选节点
        for (int i=0;i<nums.length;i++) {
            int c = nums[i];
            // 2.1 筛选
            if (used[i]!=true) {
                list.add(c);
                used[i] = true;
                DFS(nums,list,used);
                list.remove(list.size()-1);
                used[i] = false;
            }
        }
        return list;
    }

}

class Solution {
    public int mySqrt(int x) {
        if (x<2)
            return x;
        int left = 0;
        // x 一定大于 x/2
        int right = x/2+1;

        while (left<right) {
            // 这个是需要注意的点，平放有可能会超出int范围
            int mid = left+(right-left)/2;
            long num = (long)mid * mid;
            if (num==x)
                return mid;
            if (num>x)
                right=mid;
            else
                left=mid+1;
        }

        return left-1;
    }
}

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int len = nums.length;
        int[] res = new int[]{-1,-1};
        int left =0;
        int right = len;
        // 先找左边界
        while (left<right){
            int mid = left+(right-left)/2;
            if (nums[mid] == target)
                res[0] = mid;
            if (nums[mid]>=target) {
                right = mid;

            }
            else
                left = mid+1;
        }

        // 先找右边界
        right = len;
        while (left<right){
            int mid = left+(right-left)/2;
            if (nums[mid] == target)
                res[1] = mid;
            if (nums[mid]<=target) {
                left = mid+1;
            }
            else
                right = mid;
        }
        return res;
    }
}

public static String dfs(char[] chars,Stack stack) {
        // 1.截止条件
        if (stack.size()==chars.length) {
            List<String> list = new ArrayList<>();
            System.out.println(stack.toString());
            return stack.toString();
        }

        // 2.遍历候选节点
        for (int i=0;i<chars.length;i++) {
            char c = chars[i];
            // 2.1 筛选
            if (chars[i]!='0') {
                stack.push(c);
                chars[i] = '0';
                dfs(chars,stack);
                stack.pop();
                chars[i] = c;
            }
        }
        return stack.toString();
    }

import com.querydsl.core.BooleanBuilder;
import com.querydsl.core.QueryModifiers;
import com.querydsl.core.QueryResults;
import com.querydsl.core.types.*;
import com.querydsl.core.types.dsl.*;
import com.querydsl.jpa.impl.JPAQuery;
import com.querydsl.jpa.impl.JPAQueryFactory;
import com.querydsl.jpa.sql.JPASQLQuery;
import com.querydsl.sql.DerbyTemplates;
import com.querydsl.sql.SQLExpressions;
import com.querydsl.sql.SQLTemplates;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;

import javax.annotation.PostConstruct;
import javax.persistence.EntityManager;
import java.util.List;
import java.util.stream.Collectors;


public class PageTest extends SpringbootJpaApplicationTests {

    @Autowired
    private EntityManager entityManager;

    //查询工厂实体
    private JPAQueryFactory queryFactory;


    //实例化控制器完成后执行该方法实例化JPAQueryFactory
    @PostConstruct
    public void initFactory() {
        queryFactory = new JPAQueryFactory(entityManager);
    }


    /**
     * 普通查询
     */
    @Test
    public void getcheckDayInfo() {
        QCheckDayInfo qCheckDayInfo = QCheckDayInfo.checkDayInfo;
        List<CheckDayInfo> checkDayInfo = queryFactory
                .selectFrom(qCheckDayInfo)
                .where(
                        qCheckDayInfo.username.eq("javaniuniu"),
                        qCheckDayInfo.checked.eq(1)
                )
                .fetch();
        System.out.println(checkDayInfo);
    }

    /**
     * BooleanBuilder 绑定条件进行查询
     */
    @Test
    public void getCheckDayInfos() {
        // 使用 QueryDSL 进行查询
        QCheckDayInfo qCheckDayInfo = QCheckDayInfo.checkDayInfo;
        // 定于获取条件
        BooleanBuilder booleanBuilder = new BooleanBuilder();
        // 放入要查询的条件信息
        booleanBuilder.and(qCheckDayInfo.username.contains("javaniuniu"));
        // queryFactory 是上方定义的工厂实体
        // select（生成的实体类的字段）.from（生成实体类的名称）.where（上方要查询的条件）.orderBy（排序）.fetch（）进行查询
        List<CheckDayInfo> checkDayInfoList = queryFactory.select(qCheckDayInfo)
                .from(qCheckDayInfo)
                .where(booleanBuilder)
                .orderBy(qCheckDayInfo.date.asc())
                .fetch();
        System.out.println(checkDayInfoList);
    }

    /**
     * 分页查询
     */
    @Test
    public void getCheckDayInfoPage() {
        Pageable pageable = PageRequest.of(0, 5);
        QCheckDayInfo qCheckDayInfo = QCheckDayInfo.checkDayInfo;
        QueryResults<CheckDayInfo> checkDayInfo = queryFactory
                .selectFrom(qCheckDayInfo)
                .orderBy(qCheckDayInfo.checked.desc())
                .orderBy(qCheckDayInfo.checkedTime.desc())
                .offset(pageable.getOffset())
                .limit(pageable.getPageSize())
                .fetchResults();
        System.out.println(checkDayInfo);
    }

    /**
     * 通过 JPASQLQuery 做分页查询
     */
    @Test
    public void getbCheckDayInfoPageByJPASQLQuery() {
        SQLTemplates templates = new DerbyTemplates();

        JPASQLQuery<?> jpasqlQuery = new JPASQLQuery<Void>(entityManager, templates);
        Pageable pageable = PageRequest.of(0, 5);
        QCheckDayInfo qCheckDayInfo = QCheckDayInfo.checkDayInfo;
        QueryResults<CheckDayInfo> checkDayInfo = jpasqlQuery
                .select(qCheckDayInfo)
                .from(qCheckDayInfo)
                .orderBy(qCheckDayInfo.checked.desc())
                .orderBy(qCheckDayInfo.checkedTime.desc())
                .offset(pageable.getOffset())
                .limit(pageable.getPageSize())
                .fetchResults();
        System.out.println(checkDayInfo);
    }

    /**
     * 返回数据到DTO
     */
    @Test
    public void getCheckDayInfoDTO() {
        QCheckDayInfo qCheckDayInfo = QCheckDayInfo.checkDayInfo;
        Pageable pageable = PageRequest.of(0, 2);
        List<CheckDayInfoDTO> checkDayInfo = queryFactory
                .select(
                        qCheckDayInfo.username,
                        qCheckDayInfo.checked,
                        qCheckDayInfo.checkedTime,
                        qCheckDayInfo.upvoteNumber
                )
                .from(qCheckDayInfo)
//                .where(
//                        qCheckDayInfo.checked.eq(1)
//                )
                .orderBy(qCheckDayInfo.checked.desc())
                .orderBy(qCheckDayInfo.checkedTime.asc())
                .offset(pageable.getOffset())
                .limit(pageable.getPageSize())
                .fetch()
                .stream()
                .map(tuple -> CheckDayInfoDTO.builder()
                        .username(tuple.get(qCheckDayInfo.username))
                        .checked(tuple.get(qCheckDayInfo.checked))
                        .checkedTime(tuple.get(qCheckDayInfo.checkedTime))
                        .upvoteNumber(tuple.get(qCheckDayInfo.upvoteNumber))
                        .build()
                )
                .collect(Collectors.toList());
        System.out.println(checkDayInfo);
    }


    /**
     * 通过 JPAQuery 做连表查询
     * 但是不能分页
     */
    @Test
    public void getCheckDayInfoDTOPages() {

        SQLTemplates templates = new DerbyTemplates();

        JPASQLQuery<?> jpasqlQuery = new JPASQLQuery<Void>(entityManager, templates);

        JPAQuery jpaQuery = new JPAQuery(entityManager);
        Pageable pageable = PageRequest.of(1, 2);

        String date = "2020-04-17";
        QMember qMember = QMember.member;
        QCheckDayInfo qCheckDayInfo = QCheckDayInfo.checkDayInfo;

        StringPath me = Expressions.stringPath("me");
        StringPath info = Expressions.stringPath("info");


        SimpleTemplate<String> address = Expressions.template(String.class, "me.address");
        NumberTemplate<Integer> totalChecked = Expressions.numberTemplate(Integer.class, "me.totalChecked");
        SimpleTemplate<String> avatar = Expressions.template(String.class, "me.avatar");
        SimpleTemplate<String> me_username = Expressions.template(String.class, "me.username");

        NumberTemplate<Integer> checked = Expressions.numberTemplate(Integer.class, "info.checked");
        SimpleTemplate<String> checkedTime = Expressions.template(String.class, "info.checkedTime");
        NumberTemplate<Integer> upvoteNumber = Expressions.numberTemplate(Integer.class, "info.upvoteNumber");
        SimpleTemplate<String> username = Expressions.template(String.class, "info.username");

        OrderSpecifier orderByChecked = new OrderSpecifier(Order.DESC,
                Expressions.template(String.class, "info.checked"));

        OrderSpecifier orderByCheckedTime = new OrderSpecifier(Order.ASC,
                Expressions.template(String.class, "info.checkedTime"));

//        long l1 = 2;
//        long l2 = 1;
//
//        QueryModifiers queryModifiers = new QueryModifiers(l1, l2);

        SubQueryExpression queryCheckByDate = SQLExpressions
                .select(
                        qCheckDayInfo.username,
                        qCheckDayInfo.checked,
                        qCheckDayInfo.checkedTime,
                        qCheckDayInfo.upvoteNumber
                )
                .from(qCheckDayInfo)
                .where(qCheckDayInfo.date.eq(date));

        SubQueryExpression queryMember = SQLExpressions
                .select(
                        qMember.address,
                        qMember.totalChecked,
                        qMember.avatar,
                        qMember.username
                )
                .from(qMember)
                .where(qMember.status.eq(0));

        QueryResults<CheckDayInfoDTO> checkDayInfoDTOS = jpasqlQuery.select(
                Projections.bean(
                        CheckDayInfoDTO.class,
                        address.as("address"), totalChecked.as("totalChecked"), avatar.as("avatar"), checked.as("checked"),
                        checkedTime.as("checkedTime"),
                        upvoteNumber.as("upvoteNumber"), username.as("username")))
                .from(qMember)
                .leftJoin(queryCheckByDate, info).on(me_username.eq(username))
                .orderBy(orderByChecked)
                .orderBy(orderByCheckedTime)
//                .limit(pageable.getPageSize()) // 做不了分页
//                .offset(pageable.getOffset())
//                .restrict(queryModifiers)
                .fetchResults();
        System.out.println(checkDayInfoDTOS);


    }

}