User defined annotation realizes the function of verifying information

Custom annotations implement validation logic

• Guide pack

        <!-- hibernate  Validation framework  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>

• Definition BO object , Business object from the front end , The properties in the object need to be verified

package com.imooc.boapi;

//import com.imooc.annotationcustom.VlogId;
import com.imooc.annotationcustom.VlogId;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class VlogBOApi {
    
    private String id;
   @VlogId(message = " The user doesn't exist , Do not insert video ")
    private String vlogerId;
    private String url;
    private String cover;
    private String title;
    private Integer width;
    private Integer height;
    private Integer likeCounts;
    private Integer commentsCounts;
}

• Define a verification annotation

package com.imooc.annotationcustom;




import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({
     ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = VlogIdValidator.class) // Logical processing class of verification 
public @interface VlogId {
    
    String message();

    /** *  take validator To classify , Different classes group Will perform different validator operation  * * @return validator The classification type of  */
    Class<?>[] groups() default {
    };

    /** *  Mainly aimed at bean, Rarely used  * * @return  load  */
    Class<? extends Payload>[] payload() default {
    };
}

• At the same time, a verification class is required , Implement a logic of annotation verification

package com.imooc.annotationcustom;

import com.imooc.mapper.UsersMapper;
import com.imooc.pojo.Users;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

@Slf4j
@Component
public class VlogIdValidator implements ConstraintValidator<VlogId, String> {
    


    @Autowired
    UsersMapper usersMapper;

    @Override
    public void initialize(VlogId constraintAnnotation) {
    
        log.info(" Annotation logic initialization ");
    }

    @Override
    public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) {
    
        Users user = new Users();
        user.setId(s);
        Users reslut = usersMapper.selectByPrimaryKey(user);
        System.out.println(" Annotation blocking takes effect +package com.imooc.annotationcustom;");
        if (reslut == null) {
    
            return false;
        } else {
    
            return true;
        }
    }

}

• Business code

    @PostMapping("publish")
    public GraceJSONResult publish(@Valid @RequestBody VlogBOApi vlogBO) {
    

// vlogService.createVlog(vlogBO);
        return GraceJSONResult.ok();
    }

• Verification failed, exception , Define a global exception capture , Return this error to the front end

    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseBody
    public GraceJSONResult returnMethodArgumentNotValid(MethodArgumentNotValidException e) {
    
        BindingResult result = e.getBindingResult();
        Map<String, String> map = getErrors(result);
        return GraceJSONResult.errorMap(map);
    }

Customize annotations to simplify development

Purpose ： Do a function to intercept likes . The process ： You need to determine how many times you like after blocking

• Definition notes ：

package com.imooc.annotationcustom;


import java.lang.annotation.*;


@Inherited
@Documented
@Target({
    ElementType.FIELD, ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestLimit {
    
    /** *  Within time   Seconds per unit  * @return */
    int second() default 10;

    /*** *  Number of visits allowed  * @return */

    int maxCount() default 5;
}

• Interceptor code , Here you need to get the custom annotation on the interface handlerMethod.getMethodAnnotation

        if (handler instanceof HandlerMethod) {
    
            HandlerMethod handlerMethod =  (HandlerMethod) handler;
            // obtain RequestLimit annotation 
            RequestLimit requestLimit = handlerMethod.getMethodAnnotation(RequestLimit.class);
            if (null == requestLimit) {
    
                System.out.println(" No comments were obtained ");
                return true; // There is no limit for each annotation , Many times ok
            }
            // Limited time frame 
            int seconds = requestLimit.second();
            // Limit the maximum number of times in the time 
            int maxCount = requestLimit.maxCount();
            // Get users ip
            String userIp = IPUtil.getRequestIp(request);
            // Judge redis If there ip
            boolean keyIsExist = redis.keyIsExist(LIKE_VLOG_OPERATE_COUNT + ":" + userIp);

            // Without this key , Indicates that the current user is 20s I didn't like it in , Because this interceptor is the backend interface that intercepts likes , So if you don't have this key, set a key 
            if (keyIsExist == false) {
    
                redis.set(LIKE_VLOG_OPERATE_COUNT + ":" + userIp, "0", seconds);
                System.out.println("ok");
                return  true;
            }
            //  return true, It is necessary to determine the number of values corresponding to this key 
            String res = redis.get(LIKE_VLOG_OPERATE_COUNT + ":" + userIp);
            if (Integer.valueOf(res) >= maxCount) {
    
                GraceException.display(ResponseStatusEnum.LIKE_VLOG_WAIT_ERROR);
                return false;
            }
        }





        return true;
    }

• Business code

    @PostMapping("like")
    //TODO:  Debugging is needed here 
    @RequestLimit(maxCount = 3, second = 60)
    public GraceJSONResult like(@RequestParam String userId,
                                @RequestParam String vlogerId,
                                @RequestParam String vlogId,
                                HttpServletRequest request) {
    
        vlogService.userLikeVlog(userId, vlogId);
        redis.increment(REDIS_VLOGER_BE_LIKED_COUNTS + ":" + vlogerId, 1);
        redis.increment(REDIS_VLOG_BE_LIKED_COUNTS + ":" + vlogId, 1);

        redis.set(REDIS_USER_LIKE_VLOG + ":" + userId + ":" + vlogId, "1");

        //------------------------------------------//
        // New function , Limit the number of likes ,
        String userIp = IPUtil.getRequestIp(request);
        redis.increment(LIKE_VLOG_OPERATE_COUNT + ":" + userIp,1);
        //-------------------------------------------//


        return GraceJSONResult.ok();
    }