@Range(max = 150, min = 1, message = "年龄范围应该在1-150内。")
private Integer age;

@PostMapping("save")
public void v1(@RequestBody @Valid AppUser appUser,BindingResult result){
      if(result.hasErrors()){
            for (ObjectError error : result.getAllErrors()) {
                System.out.println(error.getDefaultMessage());
            }
        }
}

@PostMapping("save")
public void v1(@RequestBody @Valid AppUser appUser,BindingResult result,@RequestBody @Valid AppUser appUser2,BindingResult result2){
      if(result.hasErrors()){
            for (ObjectError error : result.getAllErrors()) {
                System.out.println(error.getDefaultMessage());
            }
        }
}

AppUser appUser=new AppUser();
Set<ConstraintViolation<AppUser>> violationSet = validator.validate(appUser);
   for (ConstraintViolation<AppUser> model : violationSet) {
        System.out.println(model.getMessage());
   }

public interface AppUserVaildC {
}

public interface AppUserVaildU {
}

@Range(min = 0,max = 100,message = "年龄必须在[0,100]",groups={Default.class})
    /**年龄*/
private Integer age;
@Range(min = 0,max = 2,message = "性别必须在[0,2]",groups = {AppUserVaildC.class})
    /**性别 0：未知；1：男；2：女*/
private Integer sex;

@PostMapping("save")
public void v1(@RequestBody @Validated({AppUserVaildC.class, AppUserVaildU.class}) AppUser appUser,BindingResult result){
      if(result.hasErrors()){
            for (ObjectError error : result.getAllErrors()) {
                System.out.println(error.getDefaultMessage());
            }
        }
}

AppUser appUser=new AppUser();
Set<ConstraintViolation<AppUser>> violationSet = validator.validate(appUser,AppUserVaildC,AppUserVaildU);
   for (ConstraintViolation<AppUser> model : violationSet) {
        System.out.println(model.getMessage());
   }

@GroupSequence({AppUserVaildC.class, AppUserVaildU.class, Default.class})
public interface GroupOrder {
}

@PostMapping("save")
public void v1(@RequestBody @Validated({GroupOrder.class}) AppUser appUser,BindingResult result){
      if(result.hasErrors()){
            for (ObjectError error : result.getAllErrors()) {
                System.out.println(error.getDefaultMessage());
            }
        }
}

AppUser appUser=new AppUser();
Set<ConstraintViolation<AppUser>> violationSet = validator.validate(appUser,GroupOrder);
   for (ConstraintViolation<AppUser> model : violationSet) {
        System.out.println(model.getMessage());
   }

public enum CaseMode {
    UPPER,
    LOWER;
}


@Target( { ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = CheckCaseValidator.class)
@Documented
public @interface CheckCase {
    String message() default "";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

    CaseMode value();
}


public class CheckCaseValidator implements ConstraintValidator<CheckCase, String> {
    private CaseMode caseMode;
    public void initialize(CheckCase checkCase) {
        this.caseMode = checkCase.value();
    }

    public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) {
        if (s == null) {
            return true;
        }

        if (caseMode == CaseMode.UPPER) {
            return s.equals(s.toUpperCase());
        } else {
            return s.equals(s.toLowerCase());
        }
    }
}

@Range(value = CaseMode.LOWER ,message = "年必须是小写",groups={Default.class})
    /**年龄*/
private String loginName;
@Range(min = 0,max = 2,message = "性别必须在[0,2]",groups = {AppUserVaildC.class})
    /**性别 0：未知；1：男；2：女*/
private Integer sex;

@Bean
public Validator validator(){
    ValidatorFactory validatorFactory = Validation.byProvider( HibernateValidator.class )
            .configure()
            .addProperty( "hibernate.validator.fail_fast", "true" )
            .buildValidatorFactory();
    Validator validator = validatorFactory.getValidator();

    return validator;
}

String d="08-12月-17 05.38.07.812000 下午";
        Locale locale=Locale.CHINA;
        Date dd=new SimpleDateFormat("dd-M月-y hh.mm.ss.S a",locale).parse(d);
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(dd));

String d="08-12月-17 05.38.07.812000 下午";
        Locale locale=Locale.CHINA;
        Date dd=new SimpleDateFormat("dd-M月-y hh.mm.ss.S a",locale).parse(d);
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(dd));

@Test
public void LocalDateTest(){
        //        region  LocalDate
        log.debug("LocalDate => ISO_LOCAL_DATE 结果为   {}",LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE));
        log.debug("LocalDate => ISO_DATE 结果为   {}",LocalDate.now().format(DateTimeFormatter.ISO_DATE));
        log.debug("LocalDate => ISO_ORDINAL_DATE 结果为   {}",LocalDate.now().format(DateTimeFormatter.ISO_ORDINAL_DATE));
        log.debug("LocalDate => ISO_WEEK_DATE 结果为   {}",LocalDate.now().format(DateTimeFormatter.ISO_WEEK_DATE));
        log.debug("LocalDate => BASIC_ISO_DATE 结果为   {}",LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE));
//        endregion
        }


@Test
public void LocalTimeTest(){
        //        region  LocalTime
        log.debug("LocalTime => ISO_LOCAL_TIME 结果为   {}",LocalTime.now().format(DateTimeFormatter.ISO_LOCAL_TIME));
        log.debug("LocalTime => ISO_TIME 结果为   {}",LocalTime.now().format(DateTimeFormatter.ISO_TIME));
//        endregion
        }

@Test
public void LocalDateTimeTest(){
        //        region  LocalDateTime
        log.debug("LocalDateTime => ISO_LOCAL_DATE 结果为   {}",LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE));
        log.debug("LocalDateTime => ISO_DATE 结果为   {}",LocalDateTime.now().format(DateTimeFormatter.ISO_DATE));
        log.debug("LocalDateTime => ISO_LOCAL_TIME 结果为   {}",LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_TIME));
        log.debug("LocalDateTime => ISO_TIME 结果为   {}",LocalDateTime.now().format(DateTimeFormatter.ISO_TIME));
        log.debug("LocalDateTime => ISO_LOCAL_DATE_TIME 结果为   {}",LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
        log.debug("LocalDateTime => ISO_DATE_TIME 结果为   {}",LocalDateTime.now().format(DateTimeFormatter.ISO_DATE_TIME));
        log.debug("LocalDateTime => ISO_ORDINAL_DATE 结果为   {}",LocalDateTime.now().format(DateTimeFormatter.ISO_ORDINAL_DATE));
        log.debug("LocalDateTime => ISO_WEEK_DATE 结果为   {}",LocalDateTime.now().format(DateTimeFormatter.ISO_WEEK_DATE));
        log.debug("LocalDateTime => BASIC_ISO_DATE 结果为   {}",LocalDateTime.now().format(DateTimeFormatter.BASIC_ISO_DATE));
        log.debug("LocalDateTime.parse(\"2019-01-01\", DateTimeFormatter.ISO_DATE_TIME) {}",LocalDateTime.parse("2019-01-01",DateTimeFormatter.ISO_LOCAL_DATE));
        //        endregion
        }

@Bean
public JsonSerializer<LocalDateTime> basicJsonSerializer(){
        return new JsonSerializer<LocalDateTime>(){
@Override
public void serialize(LocalDateTime value,JsonGenerator gen,SerializerProvider serializers)throws IOException{
        gen.writeString(value.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        }
        };
        }

@Bean
public Converter<String, LocalDateTime> localDateTimeConverter(){
        return new Converter<String, LocalDateTime>(){
@Override
public LocalDateTime convert(@NotNull String oldValue){
        /*处理String*/
        return null;
        }
        };
        }

@Component
public class BootWebMvcConfigurer implements WebMvcConfigurer {
    @Override
    public void addFormatters(FormatterRegistry registry) {
        /*常用类型转换数组*/
        BootConverters.getConverterToRegister().forEach(registry::addConverter);
    }
}

@Bean
public JsonDeserializer<LocalDateTime> basicJsonDeserializer(){
        return new JsonDeserializer<LocalDateTime>(){
@Override
public LocalDateTime deserialize(JsonParser p,DeserializationContext ctxt)throws IOException,JsonProcessingException{
        String oldValue=p.getText();
        /*处理String*/
        return null;
        }
        };
        }

/**
 * Json序列化和反序列化转换器，用于转换Post请求体中的json以及将我们的对象序列化为返回响应的json
 */
@Bean
public ObjectMapper objectMapper(){
        ObjectMapper objectMapper=new ObjectMapper();
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        objectMapper.disable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE);

        /*LocalDateTime系列序列化和反序列化模块，继承自jsr310，我们在这里修改了日期格式
         * 在这里修改之后，就不用再去全局序列化了*/
        JavaTimeModule javaTimeModule=new JavaTimeModule();
        javaTimeModule.addSerializer(LocalDateTime.class
                ,new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DateBootUtil.DEFAULT_DATETIME_FORMAT)));
                        javaTimeModule.addSerializer(LocalDate.class
                ,new LocalDateSerializer(DateTimeFormatter.ofPattern(DateBootUtil.DEFAULT_DATE_FORMAT)));
                        javaTimeModule.addSerializer(LocalTime.class
                ,new LocalTimeSerializer(DateTimeFormatter.ofPattern(DateBootUtil.DEFAULT_TIME_FORMAT)));
                        javaTimeModule.addDeserializer(LocalDateTime.class
                ,new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DateBootUtil.DEFAULT_DATETIME_FORMAT)));
                        javaTimeModule.addDeserializer(LocalDate.class
                ,new LocalDateDeserializer(DateTimeFormatter.ofPattern(DateBootUtil.DEFAULT_DATE_FORMAT)));
                        javaTimeModule.addDeserializer(LocalTime.class
                ,new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DateBootUtil.DEFAULT_TIME_FORMAT)));
                        /*Date序列化和反序列化  jackson-datatype-jsr310 包中已经存在 这里就不用再次写了*/
                        objectMapper.registerModule(javaTimeModule);
                        return objectMapper;
                        }

package java.lang;

public class Object {

    /* 一个本地方法，具体是用C（C++）在DLL中实现的，然后通过JNI调用。*/
    private static native void registerNatives();

    /* 对象初始化时自动调用此方法*/
    static {
        registerNatives();
    }

    /* 返回此 Object 的运行时类。*/
    public final native Class<?> getClass();     
    
/*   
hashCode 的常规协定是：   
1.在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。    
2.如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。    
3.如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不 要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。   
*/

    public native int hashCode();

public boolean equals(Object obj){
        return(this==obj);
        }

    /*本地CLONE方法，用于对象的复制。*/
protected native Object clone()throws CloneNotSupportedException;

/*返回该对象的字符串表示。非常重要的方法*/
public String toString(){
        return getClass().getName()+"@"+Integer.toHexString(hashCode());
        }

/*唤醒在此对象监视器上等待的单个线程。*/
public final native void notify();

/*唤醒在此对象监视器上等待的所有线程。*/
public final native void notifyAll();     
    
    
/*在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。    
当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。*/
public final void wait()throws InterruptedException{
        wait(0);
        }



/*在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。*/
public final native void wait(long timeout)throws InterruptedException;

/* 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。*/
public final void wait(long timeout,int nanos)throws InterruptedException{
        if(timeout< 0){
        throw new IllegalArgumentException("timeout value is negative");
        }

        if(nanos< 0||nanos>999999){
        throw new IllegalArgumentException(
        "nanosecond timeout value out of range");
        }

        if(nanos>=500000||(nanos!=0&&timeout==0)){
        timeout++;
        }

        wait(timeout);
        }     
    
    /*当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
    子类一般会重写该方法做一些系统资源清理工作。一个对象只会被调用一次finalize方法。如果finalize方法抛出异常，这个对象的终结将会停止。
    */
protected void finalize()throws Throwable{}
        }    

@Override
@Cacheable(value = "allUsersCache", key = "#id")
public String init(String id) {
    this.init2("self_key");
    return "init_";
}

@Override
@Cacheable(value = "userCache", key = "#id")
public String init2(String id) {
    return "init2_";
}

@Slf4j
@Service
public class CustomCacheService implements ICustomCacheService {
    /**
     * 1. Self-autowired reference to proxified bean of this class.
     */
    @Resource
    private ICustomCacheService self;

    @Override
    @Cacheable(value = "allUsersCache", key = "#id")
    public String init(String id) {
        // 2. call cached method using self-bean
        self.init2("self_key");
        return "init_";
    }

    @Override
    @Cacheable(value = "userCache", key = "#id")
    public String init2(String id) {
        return "init2_";
    }
}

/**
 * Enumeration used to determine whether JDK proxy-based or
 * AspectJ weaving-based advice should be applied.
 *
 * @author Chris Beams
 * @since 3.1
 * @see org.springframework.scheduling.annotation.EnableAsync#mode()
 * @see org.springframework.scheduling.annotation.AsyncConfigurationSelector#selectImports
 * @see org.springframework.transaction.annotation.EnableTransactionManagement#mode()
 */
public enum AdviceMode {

	/**
	 * JDK proxy-based advice.
	 */
	PROXY,

	/**
	 * AspectJ weaving-based advice.
	 */
	ASPECTJ
}

/**
 * JpaSpecificationExecutor 这是为了实现第二种查询方式
 * @author maxzhao
 * @date 2019-05-06
 */
@Repository(value = "appTableRepository")
public interface AppTableRepository extends JpaRepository<AppTable, String>, JpaSpecificationExecutor<AppTable> {

}

/**
 * 测试
 * @author maxzhao
 * @date 2019-06-06
 */
@RunWith(SpringRunner.class)
// BasicApplication 是启动类
@SpringBootTest(classes = BasicApplication.class)
public class AppColumnServiceTest {
    // 如果没有日志可以删掉
    private final static Logger logger = LoggerFactory.getLogger(AppTablesRepositoryTest.class);
    @Resource(name = "appTableRepository")
    private AppTableRepository appTableRepository;

    @Before
    public void startInit() {
        logger.info("---------------- {} -------------------", "AppColumnServiceTest");
    }

    @After
    public void endDestory() {    }

    @Test
    public void listTableTest() {
        //Sort.Direction是个枚举有ASC(升序)和DESC(降序)
        Sort.Direction sort = Sort.Direction.ASC;
        //PageRequest继承于AbstractPageRequest并且实现了Pageable
        //获取PageRequest对象 index:页码 从0开始  size每页容量 sort排序方式 "tab_name"->properties 以谁为准排序
        // 这里的tabName是实体的属性，不是数据库字段的名称
        Pageable pageable = PageRequest.of(0, 5, sort, "tabName");

        //region 查询条件设置方式一：
        //要匹配的实例对象
        AppTable appTable = new AppTable();
        appTable.setTabName("app_");
        //定义匹配规则 匹配"vendorId"这个属性 exact 精准匹配
        // 这里的tabName是实体的属性，不是数据库字段的名称
        ExampleMatcher exampleMatcher = ExampleMatcher
                .matching()
                .withMatcher("tabName", ExampleMatcher.GenericPropertyMatchers.contains());
        Example<AppTable> example = Example.of(appTable, exampleMatcher);
        //下面加断点，查询结果集
        Page<AppTable> page = appTableRepository.findAll(example, pageable);
        //获取总页数
        page.getTotalPages();
        //获取总元素个数
        page.getTotalElements();
        //获取该分页的列表
        page.getContent();
        page.getSize();
        //endregion

        //查询条件设置方式二：
        Specification<AppTable> specification = (Specification<AppTable>) (root, query, criteriaBuilder) -> {
            // 这里的tabName是实体的属性，不是数据库字段的名称
            Path<String> name = root.get("tabName");
			//Path<String> alias = root.get("alias");
            //查询条件1
            Predicate p1 = criteriaBuilder.like(name, "%" + "app_" + "%");
            //查询条件2
		//Predicate p2 = criteriaBuilder.lt(alias param.getAge());
            //查询条件1和2的关系
		//Predicate p = criteriaBuilder.and(p1, p2);
            return p1;
        };
        //下面加断点，查询结果集
        Page<AppTable> page2 = appTableRepository.findAll(specification,pageable);
        //endregion
    }
}

// Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder cb
List<Predicate> predicates = new ArrayList<>();
if (user.getUserId() != null && !user.getUserId().equals("")) {
	predicates.add(cb.like(root.get("userId").as(String.class), "%" + user.getUserId() + "%"));
}
if (user.getUserName() != null && !user.getUserName().equals("")) {
	predicates.add(cb.like(root.get("userName").as(String.class), "%" + user.getUserName() + "%"));
}
if (user.getGender() != null && !user.getGender().equals("")) {
	predicates.add(cb.like(root.get("gender").as(String.class), "%" + user.getGender() + "%"));
}
if (user.getAge() != null && !user.getAge().equals("")) {
	predicates.add(cb.like(root.get("age").as(String.class), "%" + user.getAge() + "%"));
}
Predicate[] pre = new Predicate[predicates.size()];
criteriaQuery.where(predicates.toArray(pre));
return cb.and(predicates.toArray(pre));

// (Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder cb)
List<Predicate> list = new ArrayList<>();
                //根据userId 查询user
if (StringUtils.isNotBlank(params.getUserId())) {
	list.add(cb.equal(root.get("userId").as(String.class), params.getUserId()));
}
                //根据userName 模糊查询user
if (StringUtils.isNotBlank(params.getUserName())) {
 	list.add(cb.like(root.get("userName").as(String.class), "%" + params.getUserName() + "%"));
}
                //根据gender 查询user
if (StringUtils.isNotBlank(params.getGender())) {
 	list.add(cb.equal(root.get("gender").as(String.class), params.getGender()));
}
                //根据age>? 查询user
if (StringUtils.isNotBlank(params.getAge())) {
 	list.add(cb.gt(root.get("age").as(Integer.class), Integer.valueOf(params.getAge())));
}
                //根据gradeName 查询user
if (StringUtils.isNotBlank(params.getGradeName())) {
	Join<Grade, User> join = root.join("grade", JoinType.LEFT);
	list.add(cb.equal(join.get("gradeName"), params.getGradeName()));
}
                //根据schoolName 查询user
if (StringUtils.isNotBlank(params.getSchoolName())) {
	Join<School, User> join = root.join("grade", JoinType.LEFT);
	list.add(cb.equal(join.get("school").get("schoolName"), params.getSchoolName()));
}
Predicate[] pre = new Predicate[list.size()];
criteriaQuery.where(list.toArray(pre));
return cb.and(list.toArray(pre));

Path<String> path = root.get("tabName");
CriteriaBuilder.In<String> in = criteriaBuilder.in(path);
in.value("app_table");
in.value("app_column");
criteriaBuilder.and(in);
return criteriaBuilder.and(p1, in);

   @PersistenceContext
   private EntityManager entityManager;
// 查询
entityManager.find(AppTable.class, id);
// 查询列表
entityManager.createQuery(hql).getResultList();
// 查询列表数量,有参数
entityManager.createQuery(hql)
               .setParameter(0, tabName)
               .setParameter(1, alias).getResultList().size();
// 	更新
AppTable appTable = entityManager.find(AppTable.class, id);
appTable.setTabName("X");
   entityManager.flush();
// 删除
entityManager.remove(entityManager.find(AppTable.class, id));

@Configuration
public class RedisConfig {
    /**
     * redisTemplate 默认使用JDK的序列化机制, 存储二进制字节码, 所以自定义序列化类
     * @param redisConnectionFactory redis连接工厂类
     * @return RedisTemplate
     */
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 使用Jackson2JsonRedisSerialize 替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 设置value的序列化规则和 key的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}