Spring Validation數(shù)據校驗詳解

更新時間：2025年09月05日 09:38:30 作者：weixin_44012070

SpringValidation是Spring框架的數(shù)據校驗抽象層,支持注解、分組、嵌套校驗及國際化,默認集成HibernateValidator,可自定義校驗器滿足復雜需求,適用于Web參數(shù)校驗和業(yè)務邏輯驗證

Spring Validation數(shù)據校驗

Spring Validation是SpringFramework提供的一種輕量級的數(shù)據驗證框架，用于Java對象進行校驗。

Spring Validation(Spring的數(shù)據驗證組件)其實是一個抽象層，它為數(shù)據驗證提供了統(tǒng)一的接口和基本的校驗功能。

Spring Validation默認使用了Hibernate Validator作為其具體的實現(xiàn)，但是也可以通過適配器與其他數(shù)據驗證框架（如Apache Commons Validator）一起工作。

Spring Validation的主要功能包括：

1、提供了一套注解，用于對Java對象進行校驗；

2、支持嵌套校驗，用于對一個對象中的屬性進行遞歸校驗；

3、支持分組校驗，用于根據不同的校驗場景，使用不同的校驗規(guī)則；

4、支持國際化，可以根據不同的語言環(huán)境，使用不同的校驗提示消息。

5、支持自定義注解和校驗器，滿足各種復雜的校驗需求。

Spring提供的數(shù)據校驗方式：

實現(xiàn)org.springframework.validation.Validator接口，調用接口實現(xiàn)類；
通過注解方式進行數(shù)據校驗（按照Bean Validation方式）；
基于方法(函數(shù)) 實現(xiàn)數(shù)據校驗；
自定義校驗

依賴引入：

如果springboot版本小于2.3.x，spring-boot-web-starter會自動引入hibernate-validator。

如果spring-boot版本為2.3.x，則需要手動引入依賴，如：

<dependency>  
    <groupId>org.hibernate</groupId>  
    <artifactId>hibernate-validator</artifactId>  
    <version>6.0.1.Final</version>  
</dependency>

1、Validator接口方式

@Data
public class Person {

    private String name;

    private int age;

}

import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;

/**
 * @description 實現(xiàn)接口{@link org.springframework.validation.Validator}
 */
public class PersonValidator implements Validator {
    @Override
    public boolean supports(Class<?> clazz) {
        return Person.class.equals(clazz);
    }

    @Override
    public void validate(Object obj, Errors errors) {
        //設置name為空時，報錯：name.empty
        ValidationUtils.rejectIfEmpty(errors, "name", "name.empty");

        //傳入對象，強轉為實體類Person對象
        Person p = (Person) obj;
        if (p.getAge() < 0) {     //設置age屬性小于零時報錯
            errors.rejectValue("age", "error (age  < 0)");
        } else if (p.getAge() > 110) {//設置age屬性大于110報錯
            errors.rejectValue("age", "error (age  > 110) too old !!");
        }
    }
}

/**
 * 測試
 *
 */
@Slf4j
class IomsApplicationTests {
    public static void main(String[] args) {
        Person person = new Person();
//        person.setName("高啟強");
//        person.setAge(29);

        //創(chuàng)建person對象的DataBinder
        DataBinder binder = new DataBinder(person);
        //設置校驗
        binder.setValidator(new PersonValidator());
        //校驗(當person屬性值為空時，校驗不通過)
        binder.validate();

        //輸出校驗結果
        BindingResult bindingResult = binder.getBindingResult();
        System.out.println(bindingResult.getAllErrors());

    }


}

2、基于注解方式（Bean Validation）

使用Bean Validation校驗方式，需要將Bean Validation需要的javax.validation.ValidatorFactory和javax.validation.Validator注入到容器中。

Spring默認有一個實現(xiàn)類LocalValidatorFactoryBean，它實現(xiàn)了Bean Validator中的接口和org.springframework.validation.Validator接口。

在springboot2.2.2中已自動注入，源碼如下：

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(ExecutableValidator.class)
@ConditionalOnResource(resources = "classpath:META-INF/services/javax.validation.spi.ValidationProvider")
@Import(PrimaryDefaultValidatorPostProcessor.class)
public class ValidationAutoConfiguration {

	@Bean
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	@ConditionalOnMissingBean(Validator.class)
	public static LocalValidatorFactoryBean defaultValidator() {
		LocalValidatorFactoryBean factoryBean = new LocalValidatorFactoryBean();
		MessageInterpolatorFactory interpolatorFactory = new MessageInterpolatorFactory();
		factoryBean.setMessageInterpolator(interpolatorFactory.getObject());
		return factoryBean;
	}

    /**
     * 基于方法的校驗方式
     */
	@Bean
	@ConditionalOnMissingBean
	public static MethodValidationPostProcessor methodValidationPostProcessor(Environment environment,
			@Lazy Validator validator) {
		MethodValidationPostProcessor processor = new MethodValidationPostProcessor();
		boolean proxyTargetClass = environment.getProperty("spring.aop.proxy-target-class", Boolean.class, true);
		processor.setProxyTargetClass(proxyTargetClass);
		processor.setValidator(validator);
		return processor;
	}

}

Spring Validation常用的注解

@NotNull：檢查是否為null，不能為null。
@NotBlank：檢查字符串是否為null或空字符串。
@NotEmpty：檢查字符串、集合或數(shù)組是否為null或空。
@Min：檢查數(shù)字是否大于等于指定值。
@Max：檢查數(shù)字是否小于等于指定值。
@DecimalMin：檢查數(shù)字是否大于等于指定值。
@DecimalMax：檢查數(shù)字是否小于等于指定值。
@Size：檢查字符串、集合或數(shù)組的長度是否在指定范圍內。
@Digits：檢查數(shù)字是否符合指定的精度和小數(shù)位數(shù)。
@Past：檢查日期是否在當前時間之前。
@Future：檢查日期是否在當前時間之后。
@Pattern：檢查字符串是否匹配指定的正則表達式。
@Email：檢查是否為有效的電子郵件地址。
@Length：檢查字符串的長度是否在指定范圍內。
@Range：檢查數(shù)字是否在指定范圍內。
@Positive：檢查數(shù)字是否為正數(shù)。
@PositiveOrZero：檢查數(shù)字是否為非負數(shù)。
@Negative：檢查數(shù)字是否為負數(shù)。
@NegativeOrZero：檢查數(shù)字是否為非正數(shù)。
@AssertTrue：檢查是否為true。
@AssertFalse：檢查是否為false。
@NotNull(message = “{user.name.notnull}”)：使用國際化消息提示。
@NotBlank(message = “{user.name.notblank}”)：使用國際化消息提示。
@NotEmpty(message = “{user.name.notempty}”)：使用國際化消息提示。
@Email(message = “{user.email.format}”)：使用國際化消息提示。
@Valid：用于嵌套校驗，可以對一個對象中的屬性進行遞歸校驗。
@ConvertGroup：用于分組校驗，可以指定校驗的分組，根據不同的分組執(zhí)行不同的校驗規(guī)則。
@GroupSequence：用于定義校驗分組的順序，指定不同分組的執(zhí)行順序。

手動校驗：通過"校驗器+注解校驗"

import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotNull;

@Data
public class User {
    @NotEmpty  //不可為空
    private String name;

    @Min(0)   //最小值
    @Max(110) //最大值
    private int age;
}

使用java原生的jakarta.validation.Validator校驗器

import jakarta.validation.ConstraintViolation;
import jakarta.validation.Validator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Set;

/**
 * 使用java原生的jakarta.validation.Validator校驗
 * 
 */
@Service
public class JavaService {

    @Autowired   //自動裝配Validator對象
    private Validator validator;

    //校驗方法
    public boolean validator(User user){
        //校驗后的結果存放進Set集合
        Set<ConstraintViolation<User>> set = validator.validate(user);
        //若沒有校驗到錯誤，集合為空，返回true。
        return set.isEmpty();
    }
}

使用spring提供的 org.springframework.validation.Validator校驗器

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.validation.BindException;
import org.springframework.validation.Validator;

/**
 * 使用spring提供的validate校驗方法
 */
@Service
public class SpringService {
    @Autowired
    private Validator validator;

    public boolean validator2(User user){
        BindException bindException = new BindException(user,user.getName());
        validator.validate(user,bindException);            //調用校驗方法進行校驗
        System.out.println(bindException.getAllErrors());  //輸出所有錯誤信息
        return bindException.hasErrors();                  //若沒有異常，返回false
    }
}

一、基本使用：

對于Web服務來說，為防止非法參數(shù)對業(yè)務造成影響，在Controller層一定要做好參數(shù)校驗。大部分情況下，請求參數(shù)分為如下兩種形式：

1、POST、PUT請求，使用@RequestBody傳遞參數(shù)；
2、GET請求，使用@RequestParam、@PathVariable傳遞參數(shù)；

①、使用@RequestBody傳遞參數(shù)，后端使用DTO(Data Transfer Object 數(shù)據傳輸對象)進行接受，只要給DTO對象加上@Validated注解就能進行自動參數(shù)校驗。當校驗失敗時，會拋出MethodArgumentNotValidException異常，Spring 默認會將其轉為400（Bad Request）請求。

@Data
@ApiModel("健康度統(tǒng)計")
public class HealthyStatistic {
  
    @Pattern(message = "線路id只能為1-20位數(shù)字", regexp = RegexConstants.ID)
    private String lineId;
    
    @Pattern(message = "站點id只能為1-20位數(shù)字", regexp = RegexConstants.ID)
    private String stationId;
    
    @Pattern(message = "子系統(tǒng)id只能為1-20位數(shù)字", regexp = RegexConstants.ID)
    private String subsystemId;
    
    @EnumValue(message = "月份只能位1-12", intValues = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12})
    private Integer month;
}

/**
 * 在方法參數(shù)上聲明校驗注解@Validated或者@Valid
 */
@PostMapping("/statistic")
public BaseResp healthyStatistic(@Validated @RequestBody HealthyStatistic healthyStatistic) { 
      return BaseResp.getSuccessResult();    
}

②、使用@RequestParam、@PathVariable傳遞參數(shù)，必須在Controller類上標注@Validated注解,

校驗失敗會拋出ConstraintViolationException異常。

/**
 * 類上標注@Validated注解
 */
@RestController
@RequestMapping("${zte.usp.app-name}/alarm/diagnose")
@Validated
public class AlarmDiagnoseController {

    @GetMapping("/get/{userId}")
    public BaseResp getAlarmDiagnose(@PathVariable("userId") @Min(10000000000000000L) Long userId, @RequestParam("alarmId") @NotEmpty String alarmId) {
        
            return IomsBaseResp.getSuccessResult(responseEntity.getData());
    }
}

二、分組校驗：

@Data
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@FieldNameConstants
public class Manufacturer extends Entity {
   
    @NotBlank(message = "廠商id不能為空", groups = UpdateGroup.class)
    private String id;

    private String sn;

    private String name;

    private Integer dockingGatewayId;

    public interface UpdateGroup {
    }
}

@PostMapping("update")
public BaseResp updateManufacturer(@Validated({Manufacturer.UpdateGroup.class, Default.class}) @RequestBody Manufacturer manufacturer) {
        return manufacturerService.updateManufacturer(manufacturer);
 }

三、嵌套校驗：

/**
 * Job屬性 嵌套校驗使用@Valid注解
 */
@Data  
public class UserDTO {    
    @Min(value = 10000000000000000L, groups = Update.class)  
    private Long userId;  
  
    @NotNull(groups = {Save.class, Update.class})  
    @Length(min = 2, max = 10, groups = {Save.class, Update.class})  
    private String userName;  
  
    @NotNull(groups = {Save.class, Update.class})  
    @Valid  
    private Job job;  
  
    @Data  
    public static class Job {  
  
        @Min(value = 1, groups = Update.class)  
        private Long jobId;  
  
        @NotNull(groups = {Save.class, Update.class})  
        @Length(min = 2, max = 10, groups = {Save.class, Update.class})  
        private String jobName;  
  
        @NotNull(groups = {Save.class, Update.class})  
        @Length(min = 2, max = 10, groups = {Save.class, Update.class})  
        private String position;  
    }  
  
    public interface Save {  
    }  
    public interface Update {  
    }  
}

四、多字段聯(lián)合校驗：

Hibernate Validator提供了非標準的@GroupSequenceProvider注解。

根據當前對象實例的狀態(tài)，動態(tài)來決定加載哪些校驗組進入默認校驗組。

為了實現(xiàn)多字段聯(lián)合校驗，需要借助Hibernate Validator提供的DefaultGroupSequenceProvider接口。

/**
 * 該接口定義了：動態(tài)Group序列的協(xié)定
 * 要想它生效，需要在T上標注@GroupSequenceProvider注解并且指定此類為處理類
 * 如果`Default`組對T進行驗證，則實際驗證的實例將傳遞給此類以確定默認組序列
 */ 
public interface DefaultGroupSequenceProvider<T> {
	/**
     * 合格方法是給T返回默認的組（多個）。因為默認的組是Default
     * 入參T object允許在驗證值狀態(tài)的函數(shù)中動態(tài)組合默認組序列。（非常強大）
     * object是待校驗的Bean。它可以為null哦~（Validator#validateValue的時候可以為null）
     * 返回值表示默認組序列的List。它的效果同@GroupSequence定義組序列，尤其是列表List必須包含類型T
     */
    List<Class<?>> getValidationGroups(T object);
}

實現(xiàn)步驟：

1、實現(xiàn)DefaultGroupSequenceProvider接口

public class PersonGroupSequenceProvider implements DefaultGroupSequenceProvider<Person> {

    @Override
    public List<Class<?>> getValidationGroups(Person bean) {
        List<Class<?>> defaultGroupSequence = new ArrayList<>();
        defaultGroupSequence.add(Person.class); // 這一步不能省,否則Default分組都不會執(zhí)行了，會拋錯的

        if (bean != null) { // 這塊判空請務必要做
            Integer age = bean.getAge();
            if (age < 30) {
                defaultGroupSequence.add(Person.AgeLt30Group.class);
            } else if (age >= 30 && age < 40) {
                defaultGroupSequence.add(Person.Age30And40Group.class);
            }
        }
        return defaultGroupSequence;
    }
}

2、在待校驗的Bean上使用@GroupSequenceProvider注解指定處理器，并定義好校驗邏輯（?；罘纸M）

@GroupSequenceProvider(PersonGroupSequenceProvider.class)
@Getter
@Setter
@ToString
public class Person {

    @NotNull
    private String name;
    @NotNull
    @Range(min = 10, max = 40)
    private Integer age;

    @NotNull(groups = {AgeLt30Group.class, Age30And40Group.class})
    @Size(min = 1, max = 2, groups = AgeLt30Group.class)
    @Size(min = 3, max = 5, groups = Age30And40Group.class)
    private List<String> hobbies;

    /**
     * 定義專屬的業(yè)務邏輯分組
     */
    public interface AgeLt30Group{
    }
    public interface Age30And40Group{
    }
}

五、@GroupSequence（JSR提供），具有控制校驗組順序及短路能力

public class User {

    @NotEmpty(message = "firstname may be empty")
    private String firstname;
    @NotEmpty(message = "middlename may be empty", groups = Default.class)
    private String middlename;
    @NotEmpty(message = "lastname may be empty", groups = GroupA.class)
    private String lastname;
    @NotEmpty(message = "country may be empty", groups = GroupB.class)
    private String country;


    public interface GroupA {
	}
	public interface GroupB {
	}
	// 組序列
	@GroupSequence({Default.class, GroupA.class, GroupB.class})
	public interface Group {
	}
}

3、基于方法的校驗（MethodValidationPostProcessor）

@Data
public class User {
    @NotNull
    private String name;
    @Min(0)
    @Max(129)
    private int age;
    //手機號格式 1開頭 第二位是（3、4、6、7、9）其一，后面是9位數(shù)字
    @Pattern(regexp = "^1(3|4|6|7|9)\\d{9}$", message = "手機號碼格式錯誤")
    @NotBlank(message = "手機號碼不能為空")
    private String phone;
}


import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import javax.validation.Valid;
import javax.validation.constraints.NotNull;

@Service
@Validated
public class MethodValidService {

    /**
     * 校驗Service層方法參數(shù)
     *
     * @param user
     * @return
     */
    public String validParams(@Valid @NotNull User user) {
        return user.toString();
    }
}

源碼解析：

public class MethodValidationPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessor
		implements InitializingBean {

	private Class<? extends Annotation> validatedAnnotationType = Validated.class;

	@Nullable
	private Validator validator;

	......

    /**
	 * 生成切點AnnotationMatchingPointcut
	 */
	@Override
	public void afterPropertiesSet() {
		Pointcut pointcut = new AnnotationMatchingPointcut(this.validatedAnnotationType, true);
		this.advisor = new DefaultPointcutAdvisor(pointcut, createMethodValidationAdvice(this.validator));
	}

	/**
	 * 生成切面AOP advice
	 */
	protected Advice createMethodValidationAdvice(@Nullable Validator validator) {
		return (validator != null ? new MethodValidationInterceptor(validator) : new MethodValidationInterceptor());
	}

}

public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSupport implements BeanPostProcessor {

	@Nullable
	protected Advisor advisor;

	protected boolean beforeExistingAdvisors = false;

	private final Map<Class<?>, Boolean> eligibleBeans = new ConcurrentHashMap<>(256);


	public void setBeforeExistingAdvisors(boolean beforeExistingAdvisors) {
		this.beforeExistingAdvisors = beforeExistingAdvisors;
	}


	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) {
		return bean;
	}
    
    /**
     * 通過ProxyFactory返回代理對象
     */
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		if (this.advisor == null || bean instanceof AopInfrastructureBean) {
			// Ignore AOP infrastructure such as scoped proxies.
			return bean;
		}

		if (bean instanceof Advised) {
			Advised advised = (Advised) bean;
			if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {
				// Add our local Advisor to the existing proxy's Advisor chain...
				if (this.beforeExistingAdvisors) {
					advised.addAdvisor(0, this.advisor);
				}
				else {
					advised.addAdvisor(this.advisor);
				}
				return bean;
			}
		}

		if (isEligible(bean, beanName)) {
			ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
			if (!proxyFactory.isProxyTargetClass()) {
				evaluateProxyInterfaces(bean.getClass(), proxyFactory);
			}
			proxyFactory.addAdvisor(this.advisor);
			customizeProxyFactory(proxyFactory);
			return proxyFactory.getProxy(getProxyClassLoader());
		}

		// No proxy needed.
		return bean;
	}

	
	protected boolean isEligible(Object bean, String beanName) {
		return isEligible(bean.getClass());
	}

	protected boolean isEligible(Class<?> targetClass) {
		Boolean eligible = this.eligibleBeans.get(targetClass);
		if (eligible != null) {
			return eligible;
		}
		if (this.advisor == null) {
			return false;
		}
		eligible = AopUtils.canApply(this.advisor, targetClass);
		this.eligibleBeans.put(targetClass, eligible);
		return eligible;
	}

	protected ProxyFactory prepareProxyFactory(Object bean, String beanName) {
		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.copyFrom(this);
		proxyFactory.setTarget(bean);
		return proxyFactory;
	}

	protected void customizeProxyFactory(ProxyFactory proxyFactory) {
	}

}

public class MethodValidationInterceptor implements MethodInterceptor {

	private final Validator validator;

    ......


	@Override
	@SuppressWarnings("unchecked")
	public Object invoke(MethodInvocation invocation) throws Throwable {
		// Avoid Validator invocation on FactoryBean.getObjectType/isSingleton
		if (isFactoryBeanMetadataMethod(invocation.getMethod())) {
			return invocation.proceed();
		}

		Class<?>[] groups = determineValidationGroups(invocation);

		// Standard Bean Validation 1.1 API
		ExecutableValidator execVal = this.validator.forExecutables();
		Method methodToValidate = invocation.getMethod();
		Set<ConstraintViolation<Object>> result;

		try {
			result = execVal.validateParameters(
					invocation.getThis(), methodToValidate, invocation.getArguments(), groups);
		}
		catch (IllegalArgumentException ex) {
			// Probably a generic type mismatch between interface and impl as reported in SPR-12237 / HV-1011
			// Let's try to find the bridged method on the implementation class...
			methodToValidate = BridgeMethodResolver.findBridgedMethod(
					ClassUtils.getMostSpecificMethod(invocation.getMethod(), invocation.getThis().getClass()));
			result = execVal.validateParameters(
					invocation.getThis(), methodToValidate, invocation.getArguments(), groups);
		}
		if (!result.isEmpty()) {
			throw new ConstraintViolationException(result);
		}

		Object returnValue = invocation.proceed();

		result = execVal.validateReturnValue(invocation.getThis(), methodToValidate, returnValue, groups);
		if (!result.isEmpty()) {
			throw new ConstraintViolationException(result);
		}

		return returnValue;
	}

	......

}

4、自定義校驗

自定義注解，編寫校驗器實現(xiàn)ConstraintValidator

/**
 * 自定義校驗規(guī)則的注解，并指定校驗器
 *
 */
@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER})
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = {EnumValueValidator.class})
public @interface EnumValue {
    // 默認錯誤消息
    String message() default "必須為指定值";

    // 字符串類型
    String[] strValues() default {};

    // 整型
    int[] intValues() default {};

    // 枚舉類
    Class<?> enumClass() default Class.class;

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

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

    // 指定多個時使用
    @Target({FIELD, METHOD, PARAMETER, ANNOTATION_TYPE})
    @Retention(RUNTIME)
    @Documented
    @interface List {
        EnumValue[] value();
    }
}

import lombok.extern.slf4j.Slf4j;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * 枚舉值校驗器
 *
 */
@Slf4j
public class EnumValueValidator implements ConstraintValidator<EnumValue, Object> {

    private String[] strValues;

    private int[] intValues;

    private List<Object> objValues = new ArrayList<>();

    @Override
    public void initialize(EnumValue constraintAnnotation) {
        strValues = constraintAnnotation.strValues();
        intValues = constraintAnnotation.intValues();
        Class<?> enumClass = constraintAnnotation.enumClass();
        if (!Objects.isNull(enumClass) && Enum.class.isAssignableFrom(enumClass)) {
            try {
                Method method = enumClass.getMethod("getId");
                Object[] enumConstants = enumClass.getEnumConstants();
                for (Object constant : enumConstants) {
                    objValues.add(method.invoke(constant));
                }
            } catch (Exception e) {
                log.error("使用自定義枚舉類型校驗的時候枚舉必須用id來進行范圍校驗", e);
            }

        }
    }

    @Override
    public boolean isValid(Object value, ConstraintValidatorContext constraintValidatorContext) {
        if (Objects.isNull(value)) {
            return true;
        }
        if (objValues.size() > 0) {
            if (objValues.contains(value)) {
                return true;
            }
        } else if (value instanceof String) {
            for (String s : strValues) {
                if (s.equals(value)) {
                    return true;
                }
            }
        } else if (value instanceof Integer) {
            for (Integer s : intValues) {
                if (s == value) {
                    return true;
                }
            }
        }
        return false;
    }
}

總結

以上為個人經驗，希望能給大家一個參考，也希望大家多多支持腳本之家。

您可能感興趣的文章:

MyBatis-Plus分頁時排序的實現(xiàn)方法
這篇文章主要介紹了MyBatis-Plus分頁時的排序,分頁時排序的方法，后端OrderItems排序、Wrapper排序前端指定排序，文章結合實例代碼給大家介紹的非常詳細，需要的朋友可以參考下
2022-03-03
使用logback日志文件多環(huán)境配置路徑方式
文章介紹了兩種解決Spring Boot項目中日志文件多環(huán)境配置路徑問題的方法,第一種方法是通過啟動jar包時添加參數(shù)指定日志配置文件；第二種方法是通過配置logback-spring.xml文件根據不同的環(huán)境加載不同的日志路徑
2025-02-02
SpringBoot中YAML配置文件用法及說明
SpringBoot項目中,YAML配置文件因其簡潔語法和層級結構清晰等成為首選,本文詳細介紹了YAML的基礎語法、數(shù)據類型映射及實戰(zhàn)技巧,并幫助開發(fā)者更好地管理和配置文件
2026-05-05
Java面試題沖刺第二十天--算法(1)
這篇文章主要為大家分享了最有價值的三道關于算法的面試題，涵蓋內容全面，包括數(shù)據結構和算法相關的題目、經典面試編程題等，感興趣的小伙伴們可以參考一下
2021-08-08
Mybatis常見注解有哪些(總結)
這篇文章主要介紹了Mybatis常見注解有哪些(總結)，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2021-03-03
Springboot在有參構造方法類中使用@Value注解取值
這篇文章主要介紹了Springboot在有參構造方法類中使用@Value注解取值,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
2020-06-06
Java 容器類源碼詳解 Set
這篇文章主要介紹了Java 容器類源碼詳解 Set，Set 表示由無重復對象組成的集合，也是集合框架中重要的一種集合類型，直接擴展自 Collection 接口。,需要的朋友可以參考下
2019-06-06
SpringBoot項目修改訪問端口和訪問路徑的方法
這篇文章主要介紹了SpringBoot項目修改訪問端口和訪問路徑的方法，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧
2018-12-12
Java中dubbo+zookeeper微服務架構簡介
Apache Dubbo是一款高性能的 Java RPC 框架，這篇文章主要介紹了Java中dubbo+zookeeper微服務架構,需要的朋友可以參考下
2021-09-09
RabbitMQ,RocketMQ,Kafka?事務性,消息丟失,消息順序性和消息重復發(fā)送的處理策略問題
這篇文章主要介紹了RabbitMQ,RocketMQ,Kafka?事務性,消息丟失,消息順序性和消息重復發(fā)送的處理策略,本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下
2022-03-03