目录

一、SpringMVC之自定义注解

1.1 Java注解简介

1.2 为什么要用注解

1.3 注解的分类 ⭐

1.3.1 JDK基本注解

1.3.2 JDK元注解 

1.3.3 自定义注解 

1.4 自定义注解三种使用案例

1.4.1 案例一(获取类与方法上的注解值)

1.4.2 案例二(获取类属性上的注解属性值)

1.4.3 案例三(获取参数修饰注解对应的属性值)

二、Aop自定义注解的应用  

2.1 自定义注解类

2.2 切面类

2.3 Controller层代码

2.4 测试


一、SpringMVC之自定义注解

1.1 Java注解简介

注解(Annotation)是Java语言的一种元数据(metadata)机制,它提供了一种在代码中添加额外信息的方式。注解可以用于标记代码的特定元素,如类、方法、字段、参数等,以便在编译时、运行时或者通过工具进行处理。

注解相关类都包含在java.lang.annotation包中。

1.2 为什么要用注解

使用注解的主要目的是为了提供更多的元数据信息,以便在编译时或运行时进行处理。注解可以用于以下几个方面:

  1. 编译时处理:注解可以在编译时被编译器识别和处理。通过在代码中添加注解,我们可以告诉编译器执行特定的操作,如生成额外的代码、进行静态检查、生成文档等。例如,JUnit框架中的@Test注解用于标记测试方法,在编译时会被JUnit运行器识别并执行相应的测试。

  2. 运行时处理:注解可以在程序运行时通过反射机制被读取和处理。通过读取注解,我们可以获取代码中的元数据信息,并根据注解的定义执行相应的逻辑。例如,Spring框架中的@Autowired注解用于自动注入依赖,通过读取注解,Spring容器可以自动将依赖注入到相应的对象中。

  3. 工具处理:注解可以被工具读取和处理,以实现特定的功能。例如,JavaDoc工具可以读取代码中的注解,并生成相应的文档。其他工具,如代码生成器、静态分析工具等,也可以利用注解来实现特定的功能。

使用注解的好处包括:

  1. 提供更多的元数据信息:注解可以为代码添加额外的元数据信息,使得代码更加丰富和可读。通过注解,我们可以标记代码的特定含义、行为和规则,提高代码的可理解性和可维护性。

  2. 简化开发流程:注解可以简化开发流程,减少重复的代码和配置。通过使用注解,我们可以自动化一些常见的任务,如依赖注入、配置解析、路由映射等,提高开发效率。

  3. 增强代码的可靠性和安全性:注解可以用于进行静态检查和约束,以确保代码的正确性和安全性。通过在代码中添加注解,我们可以在编译时或运行时进行验证,避免一些常见的错误和问题。

总之,注解是一种强大的元数据机制,它可以为代码添加额外的信息和行为,提高代码的可读性、可维护性和可靠性。通过使用注解,我们可以简化开发流程,提高开发效率,并实现更灵活和可扩展的功能。

1.3 注解的分类 ⭐

1.3.1 JDK基本注解

JDK基本注解是Java开发工具包(JDK)中提供的一组预定义注解,用于标记代码的特定元素。这些注解包括:

  1. @Override:用于标记方法覆盖(重写)父类中的方法。当一个方法使用了该注解时,编译器会检查该方法是否正确地覆盖了父类中的方法。

  2. @Deprecated:用于标记已过时的方法、类或字段。当一个方法或类被标记为过时时,编译器会发出警告,提醒开发者不再推荐使用该方法或类。

  3. @SuppressWarnings:用于抑制编译器产生的警告信息。可以在方法、类或整个代码块上使用该注解,以忽略特定类型的警告。

1.3.2 JDK元注解

JDK元注解是用于注解其他注解的注解,它们提供了更多的元数据和行为来定义注解的行为。JDK中提供了四个元注解:

  1. @Retention:用于指定注解的生命周期。可以设置为SOURCE(只在源代码中可见)、CLASS(在编译时可见)或RUNTIME(在运行时可见)。

  2. @Target:用于指定注解可以应用的目标元素类型。可以设置为TYPE(类、接口、枚举)、METHOD(方法)、FIELD(字段)等。

  3. @Documented:用于指定注解是否包含在Java文档中。如果一个注解被@Documented注解修饰,那么它的信息将包含在生成的文档中。

  4. @Inherited:用于指定注解是否可以被继承。如果一个注解被@Inherited注解修饰,那么它的子类将自动继承该注解(不常用)

@Target:指定被修饰的Annotation可以放置的位置(被修饰的目标)
@Target(ElementType.TYPE)      //接口、类
@Target(ElementType.FIELD)     //属性
@Target(ElementType.METHOD)     //方法
@Target(ElementType.PARAMETER)     //方法参数
@Target(ElementType.CONSTRUCTOR)     //构造函数
@Target(ElementType.LOCAL_VARIABLE)    //局部变量
@Target(ElementType.ANNOTATION_TYPE)   //注解
@Target(ElementType.PACKAGE)    //包


注:可以指定多个位置,例如:
@Target({ElementType.METHOD, ElementType.TYPE}),也就是此注解可以在方法和类上面使用

1.3.3 自定义注解

自定义注解是开发者根据自己的需求创建的注解。通过自定义注解,开发者可以为代码添加特定的元数据信息,并定义相应的处理逻辑。自定义注解的创建步骤包括:

  1. 使用@interface关键字定义一个注解类型。
  2. 在注解中定义需要的元素,可以包括基本类型、枚举类型、Class类型、注解类型等。
  3. 使用元注解对注解进行修饰,例如@Retention、@Target等,以定义注解的生命周期和使用范围。
  4. 在代码中使用自定义注解,可以通过反射获取注解的元素值,并根据注解的定义进行相应的处理。

要创建一个自定义注解,你需要使用Java的注解机制。下面是一个简单的示例,展示了如何创建一个自定义注解:

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CustomAnnotation {
    // 在这里定义注解的属性
    String value();
}

在上面的示例中,我们创建了一个名为CustomAnnotation的注解。它有一个属性value,可以用来传递一些自定义的信息。

通过自定义注解,开发者可以实现更灵活和可扩展的功能,如自定义验证规则、日志记录、权限控制等。自定义注解可以在类、方法、字段、参数等级别上使用,以满足不同的需求。

1.4 自定义注解三种使用案例

注解(根据Annotation是否包含成员变量,可以把Annotation分为两类):

1. 标记注解(Marker Annotation):这种注解没有成员变量,它们仅通过自身的存在与否来提供信息。

例如:Java中的@Override注解就是一个标记注解,用于标记方法覆盖(重写)父类中的方法。

2. 元数据注解(Meta Annotation):这种注解包含成员变量,它们可以接受和提供更多的元数据信息。元数据注解除了标记代码的特定元素外,还可以携带额外的数据或参数。通过元数据注解,我们可以为代码添加更多的元数据信息,以便在编译时、运行时或者通过工具进行处理。元数据注解可以用于配置、约束、验证等方面。

例如:Spring框架中的@RequestMapping注解就是一个元数据注解,它不仅可以标记请求处理方法,还可以指定请求的URL路径、请求方法、请求参数等。

1.4.1 案例一(获取类与方法上的注解值)

1. 定义一个枚举类:用来表示一组固定的值。

package com.ycxw.model;

public enum  TranscationModel {
    Read, Write, ReadWrite
}

2. 定义三个不同注解方式的类:

MyAnnotation1 :  

package com.ycxw.annotation;

import java.lang.annotation.*;

/**
 * MyAnnotation1注解可以用在类、接口、属性、方法上
 * 注解运行期也保留
 * 不可继承
 */
@Target({ElementType.TYPE, ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation1 {
    String name();
}

MyAnnotation2 :  

package com.ycxw.annotation;

import com.ycxw.model.TranscationModel;

import java.lang.annotation.*;

/**
 *  MyAnnotation2注解可以用在方法上
 *  注解运行期也保留
 *  不可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation2 {
    TranscationModel model() default TranscationModel.ReadWrite;
}

MyAnnotation3 :  

package com.ycxw.annotation;

import com.ycxw.model.TranscationModel;

import java.lang.annotation.*;


/**
 * MyAnnotation3注解可以用在方法上
 * 注解运行期也保留
 * 可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation3 {
    TranscationModel[] models() default TranscationModel.ReadWrite;
}

Demo1测试类 : 获取类与方法上的注解值

package com.ycxw.annotation.demo;

import com.ycxw.annotation.MyAnnotation1;
import com.ycxw.annotation.MyAnnotation2;
import com.ycxw.annotation.MyAnnotation3;
import com.ycxw.model.TranscationModel;

/**
 * 获取类与方法上的注解值
 */
@MyAnnotation1(name = "abc")
public class Demo1 {

    @MyAnnotation1(name = "xyz")
    private Integer age;

    @MyAnnotation2(model = TranscationModel.Read)
    public void list() {
        System.out.println("list");
    }

    @MyAnnotation3(models = {TranscationModel.Read, TranscationModel.Write})
    public void edit() {
        System.out.println("edit");
    }
}

Demo1Test测试类:

package com.ycxw.annotation.demo;

import com.ycxw.annotation.MyAnnotation1;
import com.ycxw.annotation.MyAnnotation2;
import com.ycxw.annotation.MyAnnotation3;
import com.ycxw.model.TranscationModel;
import org.junit.Test;

public class Demo1Test {
    @Test
    public void list() throws Exception {
//        获取类上的注解
        MyAnnotation1 annotation1 = Demo1.class.getAnnotation(MyAnnotation1.class);
        System.out.println(annotation1.name());//abc

//        获取方法上的注解
        MyAnnotation2 myAnnotation2 = Demo1.class.getMethod("list").getAnnotation(MyAnnotation2.class);
        System.out.println(myAnnotation2.model());//Read

//        获取属性上的注解
        MyAnnotation1 myAnnotation1 = Demo1.class.getDeclaredField("age").getAnnotation(MyAnnotation1.class);
        System.out.println(myAnnotation1.name());// xyz
    }

    @Test
    public void edit() throws Exception {
        MyAnnotation3 myAnnotation3 = Demo1.class.getMethod("edit").getAnnotation(MyAnnotation3.class);
        for (TranscationModel model : myAnnotation3.models()) {
            System.out.println(model);//Read,Write
        }
    }
}

运行list方法结果:

运行edit方法结果:

1.4.2 案例二(获取类属性上的注解属性值)

1. 自定义注解类:

package com.ycxw.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//@Retention(RetentionPolicy.SOURCE)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface TestAnnotation {
    String value() default "默认value值";

    String what() default "这里是默认的what属性对应的值";
}

2. 定义测试类:获取类属性上的注解属性值

package com.ycxw.annotation.demo2;

import com.ycxw.annotation.TestAnnotation;

/**
 * 获取类属性上的注解属性值
 */
public class Demo2 {
    @TestAnnotation(value = "这就是value对应的值_msg1", what = "这就是what对应的值_msg1")
    private static String msg1;

    @TestAnnotation("这就是value对应的值1")
    private static String msg2;

    @TestAnnotation(value = "这就是value对应的值2")
    private static String msg3;

    @TestAnnotation(what = "这就是what对应的值")
    private static String msg4;
}

3. 测试

package com.ycxw.annotation.demo2;

import com.ycxw.annotation.TestAnnotation;
import org.junit.Test;

public class Demo2Test {
    @Test
    public void test1() throws Exception {
        TestAnnotation msg1 = Demo2.class.getDeclaredField("msg1").getAnnotation(TestAnnotation.class);
        System.out.println(msg1.value());
        System.out.println(msg1.what());
    }

    @Test
    public void test2() throws Exception{
        TestAnnotation msg2 = Demo2.class.getDeclaredField("msg2").getAnnotation(TestAnnotation.class);
        System.out.println(msg2.value());
        System.out.println(msg2.what());
    }

    @Test
    public void test3() throws Exception{
        TestAnnotation msg3 = Demo2.class.getDeclaredField("msg3").getAnnotation(TestAnnotation.class);
        System.out.println(msg3.value());
        System.out.println(msg3.what());
    }

    @Test
    public void test4() throws Exception{
        TestAnnotation msg4 = Demo2.class.getDeclaredField("msg4").getAnnotation(TestAnnotation.class);
        System.out.println(msg4.value());
        System.out.println(msg4.what());
    }
}

1.4.3 案例三(获取参数修饰注解对应的属性值)

1, 创建自定义注解:

package com.ycxw.annotation;

import java.lang.annotation.*;

/**
 * 非空注解:使用在方法的参数上,false表示此参数可以为空,true不能为空
 */
@Documented
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface IsNotNull {
    boolean value() default false;
}

2. 创建测试类:获取参数修饰注解对应的属性值

package com.ycxw.annotation.demo3;

import com.ycxw.annotation.IsNotNull;

/**
 * 获取参数修饰注解对应的属性值
 */
public class Demo3 {

    public void hello1(@IsNotNull(true) String name) {
        System.out.println("hello:" + name);
    }

    public void hello2(@IsNotNull String name) {
        System.out.println("hello:" + name);
    }
}

3. 测试

package com.ycxw.annotation.demo3;

import com.ycxw.annotation.IsNotNull;
import org.junit.Test;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

public class Demo3Test {

    @Test
    public void hello1() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello1", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//true
            }
        }
    }

    @Test
    public void hello2() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello2", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//false
            }
        }
    }

    @Test
    public void hello3() throws Exception {
//        模拟浏览器传递到后台的参数 解读@requestParam
        String name = "zs";
        Demo3 demo3 = new Demo3();
        Method method = demo3.getClass().getMethod("hello1", String.class);
        for (Parameter parameter : method.getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//true
                if (annotation.value() && !"".equals(name)){
                    method.invoke(demo3,name);
                }
            }
        }
    }
}

二、Aop自定义注解的应用

2.1 自定义注解类

package com.ycxw.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    String desc();
}

2.2 切面类

package com.ycxw.aspect;

import com.ycxw.annotation.MyLog;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);

    /**
     * 只要用到了com.javaxl.p2.annotation.springAop.MyLog这个注解的,就是目标类
     */
    @Pointcut("@annotation(com.ycxw.annotation.MyLog)")
    private void MyValid() {
    }

    @Before("MyValid()")
    public void before(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        logger.debug("[" + signature.getName() + " : start.....]");
        System.out.println("[" + signature.getName() + " : start.....]");

        MyLog myLog = signature.getMethod().getAnnotation(MyLog.class);
        logger.debug("【目标对象方法被调用时候产生的日志,记录到日志表中】:"+myLog.desc());
        System.out.println("【目标对象方法被调用时候产生的日志,记录到日志表中】:" + myLog.desc());
    }
}

2.3 Controller层代码

package com.ycxw.web;

import com.ycxw.annotation.MyLog;
import org.springframework.stereotype.Component;

@Component
public class LogController {
    @MyLog(desc = "这是结合spring aop知识,讲解自定义注解应用的一个案例")
    public void testLogAspect(){
        System.out.println("记录日志...");
    }
}

2.4 测试

访问地址:http://localhost:8080/log/mylog

相关文章

使用Go Validator在Go应用中有效验证数据

Go Validator是一个开源的包,为Go结构体提供强大且易于使用的数据验证功能。该库允许开发者为其数据结构定义自定义验证规则,并确保传入的数据满足指定的条件。Go Validator支持内置验证器、自定义验证器,甚至允许您链式多个验证规则以满足更复杂的数据验证需求。如果内置验证器无法满足您的需求,您可以通过定义自己的验证函数来创建自定义验证器。这个功能允许您实现特定于应用程序需求的验证逻辑。

【Vue3】使用ref与reactive创建响应式对象

先来简单介绍一下ref,它可以定义响应式的变量let xxx = ref(初始值)。**返回值:**一个RefImpl的实例对象,简称ref对象或refref对象的value属性是响应式的。JSxxx.value,但模板中不需要.value,直接使用即可。对于let name = ref('张三')来说,name不是响应式的,name.value是响应式的。下面我们看一看上图红框中代表的意思是,我们哪里需要响应就在哪个里面导入上述代码即可。

如何设置页面恢复运行事件触发回调

由于 Android 原生的 resume 和 pause 事件不能区分是压后台导致还是页面切换导致,所以 pageResume 和 pagePause 事件是通过 JSAPI 调用记录回调的,仅适用于同一个 session 内 Window 之间的互相切换。当一个 WebView 界面重新回到栈顶时,例如从后台被唤起、锁屏界面恢复、从下个页面回退,会触发页面恢复运行(resume)事件。如果这个界面是通过 popWindow 或 popTo 到达,且传递了 data 参数,则此页可以获取到这些参数。

日常遇到Maven出现依赖版本/缓存问题通用思路。

如果怀疑是本地仓库中缓存的依赖有问题,可以手动删除本地仓库(默认位置在用户的.m2/repository目录下),但这是一个较为极端的做法,因为这会删除所有项目的所有本地依赖,之后Maven将不得不重新下载这些依赖。针对于这样的问题 首先我们的第一思路 就是怀疑到是缓存的问题,那么我在这里去描述一下 我们遇到这类通用类的问题如何解决。检查项目的pom.xml文件,确认依赖声明正确无误,没有冲突的版本号或不正确的依赖范围。版本问题导致的,但是我确认过了一下的一些操作 依然没有解决我的问题。

什么是tomcat?tomcat是干什么用的?

Tomcat是一个开源的、轻量级的应用服务器,是Apache软件基金会的一个项目。它实现了Java Servlet、JavaServer Pages(JSP)和Java Expression Language(EL)等Java技术,用于支持在Java平台上运行的动态Web应用程序。AJP是用于Apache服务器与Tomcat之间进行通信的协议,通常用于将动态生成的内容传递给Apache服务器进行处理。它能够运行Servlet和JSP,提供了一个环境,使得开发者能够构建和运行基于Java的Web应用。

C# winfrom中excel文件导入导出

在C#交流群里,看到很多小伙伴在excel数据导入导出到C#界面上存在疑惑,所以今天专门做了这个主题,希望大家有所收获!环境:win10+vs2017界面:主要以演示为主,所以没有做优化,然后主界面上添加两个按钮,分别命名为ExportExcel和ImportExcel,添加两个dataGridView,分别是dataGridView1和dataGridView2然后在窗体加载程序中给dataGr...

Java 与 JavaScript 的区别与联系

Java 和 JavaScript 两种编程语言在软件开发中扮演着重要的角色。尽管它们都以“Java”命名,但实际上它们是完全不同的语言,各有其独特的特点和用途。本文将深入探讨 Java 和 JavaScript 的区别与联系,帮助大家更好地理解它们在编程世界中的作用。

C语言中的作用域与生命周期

但是全局变量被 static 修饰之后,外部链接属性就变成了内部链接属性,只能在自己所在的源文件内部使用了,其他源文件,即使声明了,也是无法正常使用的。结论:static修饰局部变量改变了变量的生命周期,生命周期改变的本质是改变了变量的存储类型,本来一个局部变量是存储在内存的栈区的,但是被 static 修饰后存储到了静态区。extern 是用来声明外部符号的,如果一个全局的符号在A文件中定义的,在B文件中想使用,就可以使用extern进行声明,然后使用。全局变量的生命周期是:整个程序的生命周期。

Python和Java的区别(不断更新)

运行效率:一般来说,Java的运行效率要高于Python,这主要是因为Java是编译型语言,其代码在执行前会进行预编译,而Python是解释型语言,边解释边执行。而Python没有类似的强大虚拟机,但它的核心是可以很方便地使用C语言函数或C++库,这使得Python可以轻松地与底层硬件进行交互。**类型系统:**Java是一种静态类型语言,所有变量需要先声明(类型)才能使用,且类型在编译时就已经确定。总的来说,Python和Java各有其优势和特点,选择哪种语言取决于具体的项目需求、开发环境以及个人偏好。

服务器与电脑的区别?

服务器是指一种专门提供计算和存储资源、运行特定软件服务的物理或虚拟计算机。服务器主要用于接受和处理来自客户端(如个人电脑、手机等)的请求,并向客户端提供所需的服务或数据。服务器在网络环境中扮演着中心节点的角色,负责存储和管理数据、提供网络服务、处理计算任务等。

windows下ngnix自启动(借助工具winSw)

在windows下安装nginx后,不想每次都手动启动。本文记录下windows下ngnix自启动(借助工具winSw)的操作流程提示:以下是本篇文章正文内容,下面案例可供参考本文记录下windows下ngnix自启动(借助工具winSw)的操作流程。

synchronized 和 Lock 有什么区别?synchronized 和 ReentrantLock 区别是什么?说一下 atomic 的原理?

例如,AtomicInteger 的 incrementAndGet() 方法就是通过 CAS 操作实现的,它首先尝试原子地将共享变量加 1,如果操作成功,则返回新的值,否则重试直到操作成功为止。CAS 操作的原理是,当 V 的值等于 A 时,将 V 的值更新为 B,否则什么也不做。synchronized 和 Lock 都是 Java 中用于实现线程同步的关键字/类库,它们都能够提供对共享资源的安全访问和防止数据竞争的功能,但是在实现方式、特性、适用场景等方面存在一些差异。

SpringBoot security 安全认证(二)——登录拦截器

本节内容:实现登录拦截器,除了登录接口之外所有接口访问都要携带Token,并且对Token合法性进行验证,实现登录状态的保持。核心内容:1、要实现登录拦截器,从Request请求中获取token,从缓存中获取Token并验证登录是否过期,若验证通过则放行;2、实现对拦截器配置,SpringBoot 安全模块使用HttpSecurity 来完成请求安全管理。

Kafka常见生产问题详解

比如,在原有Topic下,可以调整Producer的分区策略,让Producer将后续的消息更多的发送到新增的Partition里,这样可以让各个Partition上的消息能够趋于平衡。思路是可行的,但是重试的次数,发送消息的数量等都是需要考虑的问题。PageCache缓存中的消息是断电即丢失的。因为如果业务逻辑异步进行,而消费者已经同步提交了Offset,那么如果业务逻辑执行过程中出现了异常,失败了,那么Broker端已经接收到了消费者的应答,后续就不会再重新推送消息,这样就造成了业务层面的消息丢失。

深入理解 Java 变量类型、声明及应用

Java 变量 变量是用于存储数据值的容器。在 Java 中,有不同类型的变量,例如: String - 存储文本,例如 "你好"。字符串值用双引号引起来。 int - 存储整数(全数字),没有小数,例如 123 或 -123。 float - 存储浮点数,带有小数,例如 19.

Zookeeper分布式队列实战

ZooKeeper实现队列步骤1.创建队列根节点:在Zookeeper中创建一个持久节点,用作队列的根节点。所有队列元素的节点将放在这个根节点下。2.实现入队操作:当需要将一个元素添加到队列时,可以在队列的根节点下创建一个临时有序节点。节点的数据可以包含队列元素的信息。3.实现出队操作:当需要从队列中取出一个元素时,先获取根节点下的所有子节点。再找到具有最小序号的子节点,获取该节点的数据,删除该节点,然后返回节点的数据。

SpringMVC校验注解不生效

用来实现参数校验功能。Spring使用hibernate-validator作为它的默认实现,我们只需要进行一些简单的注解声明,就可以达到参数校验的功能。但是在实际使用场景中,经常会出现校验没生效的问题。

Web 安全之点击劫持(Clickjacking)攻击详解

点击劫持(Clickjacking)攻击,又称为界面伪装攻击,是一种利用视觉欺骗手段进行攻击的方式。攻击者通过技术手段欺骗用户点击本没有打算点击的位置,当用户在被攻击者攻击的页面上进行操作时,实际点击结果被劫持,从而被攻击者利用。这种攻击方式利用了用户对网站的信任,通过覆盖层(通常是透明的iframe)覆盖在另一个网页之上,使受害者无法察觉。

为什么Java中的String类被设计为final类?

String类作为Java中不可或缺的类之一,被设计成final类带来了不可变性、安全性、可靠性和性能优势。不可变的特性使得String对象在多线程环境下安全共享,提高了应用程序的并发性和性能。此外,String类的设计还符合Java类库的一致性和规范,确保了整个语言的稳定性和可靠性。因此,String类被设计成final类是出于多方面的考虑,以提供最佳的使用体验和编程效率。

bat脚本打开多个黑窗口并执行不同的命令

在使用java -jar运行jar包之前,需要先启动redis,而redis的安装目录与jar包不在同一目录下,所以每次启动项目的时候都需要来回的切换目录。现写了一个bat脚本,用来一键启动redis和jar包。start cmd /k "cd /d redis安装目录 && redis-server redis.windows.conf"其中,cmd /k命令是不关闭黑窗口的命令,timeout /T 3表示等待3秒,/NOBREAK表示键盘输入不会中断等待。

鸿蒙(ArkUI)开发:实现二级联动

列表的二级联动(Cascading List)是指根据一个列表(一级列表)的选择结果,来更新另一个列表(二级列表)的选项。这种联动可以使用户根据实际需求,快速定位到想要的选项,提高交互体验。例如,短视频中拍摄风格的选择、照片编辑时的场景的选择,本文即为大家介绍如何开发二级联动。

Vue和React的区别 | | React函数式写法和类写法的区别

React 更多的是一个库而不是框架,它更专注于视图层的管理,通过社区和第三方库来进行补充和扩展。类式组件: 类式组件是 ES6 中引入的 class 类的一种用法,它继承自 React.Component,拥有完整的生命周期和内部状态管理能力。它是无状态的,没有生命周期和内部状态。而在 React 中,我们使用 JSX 语法,它是一种 JavaScript 的扩展语法,可以在 JavaScript 中直接编写类似 HTML 的结构。在 React 中,我们可以定义组件的两种方式,即函数式组件和类式组件。
返回
顶部