SpringMVC源码分析(七)--数据绑定工厂

已于 2024-04-07 19:26:48 修改
阅读量736 收藏 14
点赞数 19
分类专栏： 框架原理分析 文章标签： java spring
于 2024-03-27 19:58:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zmbw2015/article/details/137087035
版权

1.数据绑定工厂的使用

数据绑定工厂能够创建数据绑定器，将数据绑定到对象中，比如说当接收到请求时，经过http协议解析后数据刚开始都是字符串，此时我们希望将这些属性进行类型转换，并为对象赋值，示例如下：

1）先创建两个实体类Student和Teacher

@Getter
@Setter
@ToString
public class Student {
    private String name;
    private int age;
    private Date birthday;
    private Teacher teacher;
}

@Getter
@Setter
@ToString
public class Teacher {
    private String name;
}

2）使用ServletRequestDataBinderFactory工厂创建数据绑定器，进行数据绑定

public class Test01 {
    public static void main(String[] args) throws Exception {
        // 模拟一个Web请求
        MockHttpServletRequest request = new MockHttpServletRequest();
        // 简单字符串属性
        request.setParameter("name", "lm");
        // 需要将字符串转换为整型
        request.setParameter("age", "28");
        // 需要能够解析自定义格式
        request.setParameter("birthday", "1999-01-02");
        // 需要能够绑定到对象中的属性
        request.setParameter("teacher.name", "lhm");

        Student student = new Student();
        // 使用数据绑定工厂创建数据绑定器，此时没有传入bindMethod或initializer
        ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(null, null);
        WebDataBinder dataBinder = factory.createBinder(new ServletWebRequest(request), student, "student");
        dataBinder.bind(new ServletRequestParameterPropertyValues(request));

        System.out.println(student);
    }
}

执行Test01测试，绑定失败，会报如下错误：

这是因为我们的数据绑定工厂中没有传入bindMethod或者initializer，无法自定义解析日期格式，创建Date对象时没有使用默认的格式导致解析错误，此时我们有如下2种方式完成自定义数据格式的绑定

1.1 向数据绑定工厂中传入bindMethod

通过@InitBinder注解向数据绑定工厂中添加bindMethod

1）首先创建自定义的转换器类

public class DateFormatter implements Formatter<Date> {
    private final SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd");

    @Override
    public Date parse(String text, Locale locale) throws ParseException {
        return simpleDateFormat.parse(text);
    }

    @Override
    public String print(Date date, Locale locale) {
        return simpleDateFormat.format(date);
    }
}

2）创建一个类并添加@InitBinder修饰的转换方法

public class MyBinder {
    @InitBinder
    public void bind(WebDataBinder webDataBinder) {
        // 添加自定义的转换器
        webDataBinder.addCustomFormatter(new DateFormatter());
    }
}

3）修改测试代码，在数据转换工厂中添加bindMethod，即可绑定成功

public class Test02 {
    public static void main(String[] args) throws Exception {
        // 模拟一个Web请求
        MockHttpServletRequest request = new MockHttpServletRequest();
        // 简单字符串属性
        request.setParameter("name", "lm");
        // 需要将字符串转换为整型
        request.setParameter("age", "28");
        // 需要能够解析自定义格式
        request.setParameter("birthday", "1999-01-02");
        // 需要能够绑定到对象中的属性
        request.setParameter("teacher.name", "lhm");

        Student student = new Student();
        // 添加bindMethod
        InvocableHandlerMethod method = new InvocableHandlerMethod(new MyBinder(), MyBinder.class.getMethod("bind", WebDataBinder.class));
        // 使用数据绑定工厂创建数据绑定器，此时没有传入bindMethod或initializer
        ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(Arrays.asList(method), null);
        WebDataBinder dataBinder = factory.createBinder(new ServletWebRequest(request), student, "student");
        dataBinder.bind(new ServletRequestParameterPropertyValues(request));

        // 打印Student(name=lm, age=28, birthday=Sat Jan 02 00:01:00 CST 1999, teacher=Teacher(name=lhm))
        System.out.println(student);
    }
}

1.2 向数据绑定工厂中传入initializer

修改测试代码，在数据转换工厂中添加initializer，使用ConversionService接口进行转换，即可绑定成功

public class Test03 {
    public static void main(String[] args) throws Exception {
        // 模拟一个Web请求
        MockHttpServletRequest request = new MockHttpServletRequest();
        // 简单字符串属性
        request.setParameter("name", "lm");
        // 需要将字符串转换为整型
        request.setParameter("age", "28");
        // 需要能够解析自定义格式
        request.setParameter("birthday", "1999-01-02");
        // 需要能够绑定到对象中的属性
        request.setParameter("teacher.name", "lhm");

        Student student = new Student();
        // 创建ConversionService，添加自定义的转换器
        FormattingConversionService conversionService = new FormattingConversionService();
        conversionService.addFormatter(new DateFormatter());
        // 创建initializer对象，添加ConversionService
        ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer();
        initializer.setConversionService(conversionService);
        // 使用数据绑定工厂创建数据绑定器，此时传入initializer
        ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(null, initializer);
        WebDataBinder dataBinder = factory.createBinder(new ServletWebRequest(request), student, "student");
        dataBinder.bind(new ServletRequestParameterPropertyValues(request));

        // 打印Student(name=lm, age=28, birthday=Sat Jan 02 00:01:00 CST 1999, teacher=Teacher(name=lhm))
        System.out.println(student);
    }
}

如果同时传入了bindMethod和initializer，会优先使用bindMethod

另外ApplicationConversionService中添加了许多默认的转换器，可以直接使用

但是在使用前，需要在字段上添加相应的注解，例如date类型上添加@DateTimeFormat注解即可完成绑定

@Getter
@Setter
@ToString
public class Student {
    private String name;
    private int age;
    @DateTimeFormat(pattern = "yyyy-mm-dd")
    private Date birthday;
    private Teacher teacher;
}
public class Test04 {
    public static void main(String[] args) throws Exception {
        // 模拟一个Web请求
        MockHttpServletRequest request = new MockHttpServletRequest();
        // 简单字符串属性
        request.setParameter("name", "lm");
        // 需要将字符串转换为整型
        request.setParameter("age", "28");
        // 需要能够解析自定义格式
        request.setParameter("birthday", "1999-01-02");
        // 需要能够绑定到对象中的属性
        request.setParameter("teacher.name", "lhm");

        Student student = new Student();
        // 创建ConversionService，使用默认的转换器
        FormattingConversionService conversionService = new ApplicationConversionService();
        // 创建initializer对象，添加ConversionService
        ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer();
        initializer.setConversionService(conversionService);
        // 使用数据绑定工厂创建数据绑定器，此时传入initializer
        ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(null, initializer);
        WebDataBinder dataBinder = factory.createBinder(new ServletWebRequest(request), student, "student");
        dataBinder.bind(new ServletRequestParameterPropertyValues(request));

        // 打印Student(name=lm, age=28, birthday=Sat Jan 02 00:01:00 CST 1999, teacher=Teacher(name=lhm))
        System.out.println(student);
    }
}

2.数据绑定原理

2.1 创建数据绑定器

示例代码使用factory.createBinder通过ServletRequestDataBinderFactory创建dataBinder，源码如下：

public final WebDataBinder createBinder(NativeWebRequest webRequest, @Nullable Object target, String objectName) throws Exception {
    // 1、创建dataBinder
    WebDataBinder dataBinder = createBinderInstance(target, objectName, webRequest);
    if (this.initializer != null) {
        // 2.如果构造工厂时传入了initializer，则初始化ConversionService方式扩展的绑定器
        this.initializer.initBinder(dataBinder, webRequest);
    }
    // 3.初始化@InitBinder方式扩展的绑定器
    initBinder(dataBinder, webRequest);
    return dataBinder;
}

// ServletRequestDataBinderFactory#createBinderInstance
protected ServletRequestDataBinder createBinderInstance(@Nullable Object target, String objectName, NativeWebRequest request) throws Exception  {
    // 返回ExtendedServletRequestDataBinder
    return new ExtendedServletRequestDataBinder(target, objectName);
}

// ConfigurableWebBindingInitializer#initBinder
public void initBinder(WebDataBinder binder) {
    binder.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
    if (this.directFieldAccess) {
        binder.initDirectFieldAccess();
    }
    if (this.messageCodesResolver != null) {
        binder.setMessageCodesResolver(this.messageCodesResolver);
    }
    if (this.bindingErrorProcessor != null) {
        binder.setBindingErrorProcessor(this.bindingErrorProcessor);
    }
    if (this.validator != null && binder.getTarget() != null &&
        this.validator.supports(binder.getTarget().getClass())) {
        binder.setValidator(this.validator);
    }
    if (this.conversionService != null) {
        // 设置conversionService
        binder.setConversionService(this.conversionService);
    }
    if (this.propertyEditorRegistrars != null) {
        for (PropertyEditorRegistrar propertyEditorRegistrar : this.propertyEditorRegistrars) {
            propertyEditorRegistrar.registerCustomEditors(binder);
        }
    }
}

// InitBinderDataBinderFactory#initBinder
public void initBinder(WebDataBinder dataBinder, NativeWebRequest request) throws Exception {
    // 遍历传入的binderMethods
    for (InvocableHandlerMethod binderMethod : this.binderMethods) {
        // 判断方法上是否有InitBinder注解且符合条件
        if (isBinderMethodApplicable(binderMethod, dataBinder)) {
            // 反射调用binderMethod方法
            Object returnValue = binderMethod.invokeForRequest(request, null, dataBinder);
            if (returnValue != null) {
                throw new IllegalStateException(
                    "@InitBinder methods must not return a value (should be void): " + binderMethod);
            }
        }
    }
}

protected boolean isBinderMethodApplicable(HandlerMethod initBinderMethod, WebDataBinder dataBinder) {
    InitBinder ann = initBinderMethod.getMethodAnnotation(InitBinder.class);
    Assert.state(ann != null, "No InitBinder annotation");
    String[] names = ann.value();
    // value为空或者value包含数据绑定器名称
    return (ObjectUtils.isEmpty(names) || ObjectUtils.containsElement(names, dataBinder.getObjectName()));
}

2.2 执行数据转换

使用WebDataBinder#bind方法转换数据类型，并设置到对象中

public void bind(PropertyValues pvs) {
    MutablePropertyValues mpvs = (pvs instanceof MutablePropertyValues ?
                                  (MutablePropertyValues) pvs : new MutablePropertyValues(pvs));
    // 执行绑定
    doBind(mpvs);
}

protected void doBind(MutablePropertyValues mpvs) {
    checkFieldDefaults(mpvs);
    checkFieldMarkers(mpvs);
    super.doBind(mpvs);
}

// DataBinder#doBind
protected void doBind(MutablePropertyValues mpvs) {
    checkAllowedFields(mpvs);
    checkRequiredFields(mpvs);
    applyPropertyValues(mpvs);
}

// DataBinder#applyPropertyValues
protected void applyPropertyValues(MutablePropertyValues mpvs) {
    try {
        // 获取属性访问器设置属性
        getPropertyAccessor().setPropertyValues(mpvs, isIgnoreUnknownFields(), isIgnoreInvalidFields());
    }
    catch (PropertyBatchUpdateException ex) {
        for (PropertyAccessException pae : ex.getPropertyAccessExceptions()) {
            getBindingErrorProcessor().processPropertyAccessException(pae, getInternalBindingResult());
        }
    }
}

// AbstractPropertyAccessor#setPropertyValues
public void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
throws BeansException {
    // 省略其他代码...

    // 循环处理每个名值对
    for (PropertyValue pv : propertyValues) {
        try {
            setPropertyValue(pv);
        }

        // 省略其他代码...
    }

    // 省略其他代码...
}

public void setPropertyValue(PropertyValue pv) throws BeansException {
    // 省略中间调用链，会调用到TypeConverterDelegate#convertIfNecessary
    setPropertyValue(pv.getName(), pv.getValue());
}

通过setPropertyValue会调用到TypeConverterDelegate#convertIfNecessary

public <T> T convertIfNecessary(@Nullable String propertyName, @Nullable Object oldValue, @Nullable Object newValue,
                                @Nullable Class<T> requiredType, @Nullable TypeDescriptor typeDescriptor) throws IllegalArgumentException {
    // 1.首先检查是否有自定义的PropertyEditor，即我们通过@InitBinder扩展的转换方法
    PropertyEditor editor = this.propertyEditorRegistry.findCustomEditor(requiredType, propertyName);
    
    ConversionFailedException conversionAttemptEx = null;
    
    // 2.如果没有自定义的PropertyEditor，再看有没有ConversionService转换器
    ConversionService conversionService = this.propertyEditorRegistry.getConversionService();
    if (editor == null && conversionService != null && newValue != null && typeDescriptor != null) {
        TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
        // 判断该conversionService能否将原始类型sourceTypeDesc转换为实际类型typeDescriptor
        if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
            try {
                // 如果可以转换则通过此ConversionService转换类型
                return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
            }
            catch (ConversionFailedException ex) {
                conversionAttemptEx = ex;
            }
        }
    }
    
    Object convertedValue = newValue;
    
    // 如果没有ConversionService转换器，或者ConversionService转换器无法处理
    if (editor != null || (requiredType != null && !ClassUtils.isAssignableValue(requiredType, convertedValue))) {
        if (typeDescriptor != null && requiredType != null && Collection.class.isAssignableFrom(requiredType) &&
            convertedValue instanceof String) {
            TypeDescriptor elementTypeDesc = typeDescriptor.getElementTypeDescriptor();
            if (elementTypeDesc != null) {
                Class<?> elementType = elementTypeDesc.getType();
                if (Class.class == elementType || Enum.class.isAssignableFrom(elementType)) {
                    convertedValue = StringUtils.commaDelimitedListToStringArray((String) convertedValue);
                }
            }
        }
        if (editor == null) {
            // 获取默认的PropertyEditor
            editor = findDefaultEditor(requiredType);
        }
        // 3.通过默认的PropertyEditor执行类型转换
        convertedValue = doConvertValue(oldValue, convertedValue, requiredType, editor);
    }
    
    boolean standardConversion = false;
    
    // 省略其他代码...
    
    return (T) convertedValue;
}

从源码可以看出，在转换过程中会调用到TypeConverterDelegate委派给ConversionService或PropertyEditor真正执行类型转换，转换的优先级如下：

1）首先判断是否有通过@InitBinder扩展的自定义转换器，通过适配器模式将Formatter转换为PropertyEditor，源码见DataBinder#addCustomFormatter

public void addCustomFormatter(Formatter<?> formatter) {
    FormatterPropertyEditorAdapter adapter = new FormatterPropertyEditorAdapter(formatter);
    getPropertyEditorRegistry().registerCustomEditor(adapter.getFieldType(), adapter);
}

2） 其次再判断能否通过ConversionService进行转换

public Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType) {
    Assert.notNull(targetType, "Target type to convert to cannot be null");
    if (sourceType == null) {
        Assert.isTrue(source == null, "Source must be [null] if source type == [null]");
        return handleResult(null, targetType, convertNullSource(null, targetType));
    }
    if (source != null && !sourceType.getObjectType().isInstance(source)) {
        throw new IllegalArgumentException("Source to convert from must be an instance of [" +
                                           sourceType + "]; instead it was a [" + source.getClass().getName() + "]");
    }
    // 根据原始类型和目标类型获取GenericConverter转换器
    GenericConverter converter = getConverter(sourceType, targetType);
    if (converter != null) {
        // 调用转换器执行数据转换，得到转换结果
        Object result = ConversionUtils.invokeConverter(converter, source, sourceType, targetType);
        return handleResult(sourceType, targetType, result);
    }
    return handleConverterNotFound(source, sourceType, targetType);
}

protected GenericConverter getConverter(TypeDescriptor sourceType, TypeDescriptor targetType) {
    ConverterCacheKey key = new ConverterCacheKey(sourceType, targetType);
    // 先从缓存中查找
    GenericConverter converter = this.converterCache.get(key);
    if (converter != null) {
        return (converter != NO_MATCH ? converter : null);
    }
    // 在Converters成员变量中查找用户添加的转换器
    converter = this.converters.find(sourceType, targetType);
    if (converter == null) {
        // 如果原始类型是目标类型或其子类，获取默认的转换器NoOpConverter，否则返回null
        converter = getDefaultConverter(sourceType, targetType);
    }

    if (converter != null) {
        this.converterCache.put(key, converter);
        return converter;
    }

    this.converterCache.put(key, NO_MATCH);
    return null;
}

protected GenericConverter getDefaultConverter(TypeDescriptor sourceType, TypeDescriptor targetType) {
    return (sourceType.isAssignableTo(targetType) ? NO_OP_CONVERTER : null);
}

3）最后再使用默认的PropertyEditor进行转换，查找内置的PropertyEditor逻辑如下：

private PropertyEditor findDefaultEditor(@Nullable Class<?> requiredType) {
    PropertyEditor editor = null;
    if (requiredType != null) {
        // 查找默认的PropertyEditor
        editor = this.propertyEditorRegistry.getDefaultEditor(requiredType);
        if (editor == null && String.class != requiredType) {
            editor = BeanUtils.findEditorByConvention(requiredType);
        }
    }
    return editor;
}

public PropertyEditor getDefaultEditor(Class<?> requiredType) {
    if (!this.defaultEditorsActive) {
        return null;
    }
    if (this.overriddenDefaultEditors != null) {
        PropertyEditor editor = this.overriddenDefaultEditors.get(requiredType);
        if (editor != null) {
            return editor;
        }
    }
    if (this.defaultEditors == null) {
        // 如果defaultEditors为空，创建默认的PropertyEditor
        createDefaultEditors();
    }
    // 获取默认的PropertyEditor
    return this.defaultEditors.get(requiredType);
}

private void createDefaultEditors() {
    this.defaultEditors = new HashMap<>(64);

    // 创建Java中常见类型的转换器
    this.defaultEditors.put(Charset.class, new CharsetEditor());
    this.defaultEditors.put(Class.class, new ClassEditor());
    this.defaultEditors.put(Class[].class, new ClassArrayEditor());
    this.defaultEditors.put(Currency.class, new CurrencyEditor());
    this.defaultEditors.put(File.class, new FileEditor());
    this.defaultEditors.put(InputStream.class, new InputStreamEditor());
    this.defaultEditors.put(InputSource.class, new InputSourceEditor());
    this.defaultEditors.put(Locale.class, new LocaleEditor());
    this.defaultEditors.put(Path.class, new PathEditor());
    this.defaultEditors.put(Pattern.class, new PatternEditor());
    this.defaultEditors.put(Properties.class, new PropertiesEditor());
    this.defaultEditors.put(Reader.class, new ReaderEditor());
    this.defaultEditors.put(Resource[].class, new ResourceArrayPropertyEditor());
    this.defaultEditors.put(TimeZone.class, new TimeZoneEditor());
    this.defaultEditors.put(URI.class, new URIEditor());
    this.defaultEditors.put(URL.class, new URLEditor());
    this.defaultEditors.put(UUID.class, new UUIDEditor());
    this.defaultEditors.put(ZoneId.class, new ZoneIdEditor());

    this.defaultEditors.put(Collection.class, new CustomCollectionEditor(Collection.class));
    this.defaultEditors.put(Set.class, new CustomCollectionEditor(Set.class));
    this.defaultEditors.put(SortedSet.class, new CustomCollectionEditor(SortedSet.class));
    this.defaultEditors.put(List.class, new CustomCollectionEditor(List.class));
    this.defaultEditors.put(SortedMap.class, new CustomMapEditor(SortedMap.class));

    this.defaultEditors.put(byte[].class, new ByteArrayPropertyEditor());
    this.defaultEditors.put(char[].class, new CharArrayPropertyEditor());

    this.defaultEditors.put(char.class, new CharacterEditor(false));
    this.defaultEditors.put(Character.class, new CharacterEditor(true));

    this.defaultEditors.put(boolean.class, new CustomBooleanEditor(false));
    this.defaultEditors.put(Boolean.class, new CustomBooleanEditor(true));
    
    this.defaultEditors.put(byte.class, new CustomNumberEditor(Byte.class, false));
    this.defaultEditors.put(Byte.class, new CustomNumberEditor(Byte.class, true));
    this.defaultEditors.put(short.class, new CustomNumberEditor(Short.class, false));
    this.defaultEditors.put(Short.class, new CustomNumberEditor(Short.class, true));
    this.defaultEditors.put(int.class, new CustomNumberEditor(Integer.class, false));
    this.defaultEditors.put(Integer.class, new CustomNumberEditor(Integer.class, true));
    this.defaultEditors.put(long.class, new CustomNumberEditor(Long.class, false));
    this.defaultEditors.put(Long.class, new CustomNumberEditor(Long.class, true));
    this.defaultEditors.put(float.class, new CustomNumberEditor(Float.class, false));
    this.defaultEditors.put(Float.class, new CustomNumberEditor(Float.class, true));
    this.defaultEditors.put(double.class, new CustomNumberEditor(Double.class, false));
    this.defaultEditors.put(Double.class, new CustomNumberEditor(Double.class, true));
    this.defaultEditors.put(BigDecimal.class, new CustomNumberEditor(BigDecimal.class, true));
    this.defaultEditors.put(BigInteger.class, new CustomNumberEditor(BigInteger.class, true));
    
    if (this.configValueEditorsActive) {
        StringArrayPropertyEditor sae = new StringArrayPropertyEditor();
        this.defaultEditors.put(String[].class, sae);
        this.defaultEditors.put(short[].class, sae);
        this.defaultEditors.put(int[].class, sae);
        this.defaultEditors.put(long[].class, sae);
    }
}
lm_ylj
关注
  • 19
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
java springboot 集成 阿里通义千问
qq_25987725的博客
07-25 340
一、在阿里云https://www.aliyun.com官网直接搜索“通义千问”，点击“开通DashScope”进行服务激活。四、在config目录添加配置 TongYiAiConfiguration.java。三、在yml中配置中配置key。二、加入Maven依赖。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 437
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 236
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 608
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
wehpd的博客
07-30 256
集合之Map
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 733
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 416
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 465
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java8新特性之FlatMap&Reduce
startqbb的博客
07-26 197
【代码】Java8新特性之FlatMap&Reduce。
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 158
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 217
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
高级java每日一道面试题-2024年7月29日-并发篇-什么时候用乐观锁,什么时候用悲观锁?
qq_43071699的博客
07-29 652
悲观锁适用于数据竞争激烈的场景，能够提供强一致性，但可能导致较多的线程等待。乐观锁适用于读多写少的场景，能够提供更高的并发性能，但可能需要多次尝试才能成功更新数据。
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 886
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
Java —— 线程
JL_L666的博客
07-26 677
程序(program)：为完成特定的任务，选用某一种语言编写的，即指，静态对象。进程(process)：程序的一次执行过程，或是。程序是静态的、进程是。进程是调度和分配资源的最小单位。注意：不同的进程之间是不共享内存的、进程之间的数据交换和通信的成本很高。线程(thread)：进程可以进一步细化为线程，是运行中进程的一条或多条执行路径。线程调度策略单核CPU与多核CPU并行与并发上。
Java基础
m0_74074214的博客
07-26 665
方法需要定义在类体中，方法是类体中的一员，每个方法之间都是并列的。语法如下：[访问权限修饰符] [其他修饰符] [返回值类型] 方法名（[参数列表]）{code //方法体return；注意：中括号[ ]表示可有可无的部分，需要的话就写上，如果不需要就不写，方法名是一种标识符，需要使用小驼峰命名法方法与方法间是并列平级的，不允许出现方法嵌套方法//定义一个方法： 返回两个int类型的变量的最大值if(a>=b){return a;}else{
教务管理平台/高校教务管理系统的设计与实现/教务网站/学生成绩管理系统/学生课程管理系统
weixin_47958760的博客
07-27 792
本毕业设计的内容是设计并且实现一个基于JSP技术的教务管理平台。采用MYSQL为数据库开发平台，SSM框架，Tomcat网络信息服务作为应用服务器。教务管理平台的功能已基本实现，主要有学生、教师、课程信息、课程选择、教师课表、学生成绩、图书信息、考试等管理功能。 论文主要从系统的分析与设计 、数据库设计和系统的详细设计等几个方面来进行论述，系统分析与设计部分主要论述了系统的功能分析、系统的设计思路，数据库设计主要论述了数据库的设计，系统的详细设计部分主要论述了几个主要模块的详细设计过程。
用Java手写jvm之尝试解析clazz文件内容
wang0907的博客
07-30 228
本文尝试来解析下class文件的内容，了解了class文件内容后，对我们提升java认知将会带来很大的帮助，有多大呢，不好说，总之很大很大，大到受不了😍😍😍。
Mybatis批量更新数据库错误
qq_42108331的博客
07-30 344
Mybatis批量更新数据库错误
Dolphinscheduler 3.2.1bug记录
最新发布
guofei_ok的博客
07-30 69
问题1：
上机实验5-SpringMVC的数据绑定和页面跳转加法器
05-28
上机实验5-SpringMVC的数据绑定和页面跳转加法器，是一个使用SpringMVC框架实现的简单加法计算器。它可以从前端获取两个数字，然后通过SpringMVC框架中的数据绑定，将这两个数字绑定到Java对象中，进行简单的加法...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lm_ylj

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值