程序员都在用Lombok,原理这么简单?我也手撸了一个

出现ombok.javac.apt.LombokProcessor could not be initialized. Lombok will not run的解决方法 java: lombok.javac.apt.LombokProcessor could not be initialized. Lombok will not run during this compilation: java.lang.IllegalArgumentException: com.sun.tools.javac.main.DelegatingJavaFileManager$DelegatingSJFM extends com.sun.tools.javac.main.Delegating. 阅读详情

罗曼罗兰说过:世界上只有一种英雄主义,就是看清生活的真相之后依然热爱生活。

对于 Lombok 我相信大部分人都不陌生,但对于它的实现原理以及缺点却鲜为人知,而本文将会从 Lombok 的原理出发,手撸一个简易版的 Lombok,让你理解这个热门技术背后的执行原理,以及它的优缺点分析。

简介

在讲原理之前,我们先来复习一下 Lombok (老司机可以直接跳过本段看原理部分的内容)。

Lombok 是一个非常热门的开源项目 (github.com/rzwitserloo…),使用它可以有效的解决 Java 工程中那些繁琐又重复代码,例如 Setter、Getter、toString、equals、hashCode 以及非空判断等,都可以使用 Lombok 有效的解决。

使用

1.添加 Lombok 插件

在 IDE 中必须安装 Lombok 插件,才能正常调用被 Lombok 修饰的代码,以 Idea 为例,添加的步骤如下:

  • 点击 File > Settings > Plugins 进入插件管理页面
  • 点击 Browse repositories...
  • 搜索 Lombok Plugin
  • 点击 Install plugin 安装插件
  • 重启 IntelliJ IDEA

安装完成,如下图所示:

2.添加 Lombok 库

接下来我们需要在项目中添加最新的 Lombok 库,如果是 Maven 项目,直接在 pom.xml 中添加如下配置:

<dependencies>
  <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
	<dependency>
		<groupId>org.projectlombok</groupId>
		<artifactId>lombok</artifactId>
		<version>1.18.12</version>
		<scope>provided</scope>
	</dependency>
</dependencies>
复制代码

如果是 JDK 9+ 可使用模块的方式添加,配置如下:

<annotationProcessorPaths>
	<path>
		<groupId>org.projectlombok</groupId>
		<artifactId>lombok</artifactId>
		<version>1.18.12</version>
	</path>
</annotationProcessorPaths>
复制代码

3.使用 Lombok

接下来到了前半部分中最重要的 Lombok 使用环节了,我们先来看在没有使用 Lombok 之前的代码:

public class Person {
    private Integer id;
    private String name;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
复制代码

这是使用 Lombok 之后的代码:

@Getter
@Setter
public class Person {
    private Integer id;
    private String name;
}
复制代码

可以看出在 Lombok 之后,用一个注解就搞定了之前所有 Getter/Setter 的代码,让代码瞬间优雅了很多。

Lombok 所有注解如下:

  • val:用在局部变量前面,相当于将变量声明为 final;
  • @NonNull:给方法参数增加这个注解会自动在方法内对该参数进行是否为空的校验,如果为空,则抛出 NPE(NullPointerException);
  • @Cleanup:自动管理资源,用在局部变量之前,在当前变量范围内即将执行完毕退出之前会自动清理资源,自动生成 try-finally 这样的代码来关闭流;
  • @Getter/@Setter:用在属性上,再也不用自己手写 setter 和 getter 方法了,还可以指定访问范围;
  • @ToString:用在类上可以自动覆写 toString 方法,当然还可以加其他参数,例如 @ToString(exclude=”id”) 排除 id 属性,或者 @ToString(callSuper=true, includeFieldNames=true) 调用父类的 toString 方法,包含所有属性;
  • @EqualsAndHashCode:用在类上自动生成 equals 方法和 hashCode 方法;
  • @NoArgsConstructor, @RequiredArgsConstructor and @AllArgsConstructor:用在类上,自动生成无参构造和使用所有参数的构造函数以及把所有 @NonNull 属性作为参数的构造函数,如果指定 staticName="of" 参数,同时还会生成一个返回类对象的静态工厂方法,比使用构造函数方便很多;
  • @Data:注解在类上,相当于同时使用了 @ToString、@EqualsAndHashCode、@Getter、@Setter 和 @RequiredArgsConstrutor 这些注解,对于 POJO 类十分有用;
  • @Value:用在类上,是 @Data 的不可变形式,相当于为属性添加 final 声明,只提供 getter 方法,而不提供 setter 方法;
  • @Builder:用在类、构造器、方法上,为你提供复杂的 builder APIs,让你可以像如下方式一样调用Person.builder().name("xxx").city("xxx").build();
  • @SneakyThrows:自动抛受检异常,而无需显式在方法上使用 throws 语句;
  • @Synchronized:用在方法上,将方法声明为同步的,并自动加锁,而锁对象是一个私有的属性 LOCK,而 Java 中的 synchronized 关键字锁对象是 this,锁在 this 或者自己的类对象上存在副作用,就是你不能阻止非受控代码去锁 this 或者类对象,这可能会导致竞争条件或者其它线程错误;
  • @Getter(lazy=true):可以替代经典的 Double Check Lock 样板代码;
  • @Log:根据不同的注解生成不同类型的 log 对象,但是实例名称都是 log,有六种可选实现类 @CommonsLog Creates log = org.apache.commons.logging.LogFactory.getLog(LogExample.class); @Log Creates log = java.util.logging.Logger.getLogger(LogExample.class.getName()); @Log4j Creates log = org.apache.log4j.Logger.getLogger(LogExample.class); @Log4j2 Creates log = org.apache.logging.log4j.LogManager.getLogger(LogExample.class); @Slf4j Creates log = org.slf4j.LoggerFactory.getLogger(LogExample.class); @XSlf4j Creates log = org.slf4j.ext.XLoggerFactory.getXLogger(LogExample.class);

它们的具体使用如下:

① val 使用

val sets = new HashSet<String>();  
// 相当于
final Set<String> sets = new HashSet<>();
复制代码

② NonNull 使用

public void notNullExample(@NonNull String string) {
    string.length();
}
// 相当于
public void notNullExample(String string) {
    if (string != null) {
        string.length();
    } else {
        throw new NullPointerException("null");
    }
}
复制代码

③ Cleanup 使用

public static void main(String[] args) {
    try {
        @Cleanup InputStream inputStream = new FileInputStream(args[0]);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }
    // 相当于
    InputStream inputStream = null;
    try {
        inputStream = new FileInputStream(args[0]);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } finally {
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
复制代码

④ Getter/Setter 使用

@Setter(AccessLevel.PUBLIC)
@Getter(AccessLevel.PROTECTED)
private int id;
private String shap;
复制代码

⑤ ToString 使用

@ToString(exclude = "id", callSuper = true, includeFieldNames = true)
public class LombokDemo {
    private int id;
    private String name;
    private int age;
    public static void main(String[] args) {
        // 输出 LombokDemo(super=LombokDemo@48524010, name=null, age=0)
        System.out.println(new LombokDemo());
    }
}
复制代码

⑥ EqualsAndHashCode 使用

@EqualsAndHashCode(exclude = {"id", "shape"}, callSuper = false)
public class LombokDemo {
    private int id;
    private String shap;
}
复制代码

⑦ NoArgsConstructor、RequiredArgsConstructor、AllArgsConstructor 使用

@NoArgsConstructor
@RequiredArgsConstructor(staticName = "of")
@AllArgsConstructor
public class LombokDemo {
    @NonNull
    private int id;
    @NonNull
    private String shap;
    private int age;
    public static void main(String[] args) {
        new LombokDemo(1, "Java");
        // 使用静态工厂方法
        LombokDemo.of(2, "Java");
        // 无参构造
        new LombokDemo();
        // 包含所有参数
        new LombokDemo(1, "Java", 2);
    }
}
复制代码

⑧ Builder 使用

@Builder
public class BuilderExample {
    private String name;
    private int age;
    @Singular
    private Set<String> occupations;
    public static void main(String[] args) {
        BuilderExample test = BuilderExample.builder().age(11).name("Java").build();
    }
}
复制代码

⑨ SneakyThrows 使用

public class ThrowsTest {
    @SneakyThrows()
    public void read() {
        InputStream inputStream = new FileInputStream("");
    }
    @SneakyThrows
    public void write() {
        throw new UnsupportedEncodingException();
    }
    // 相当于
    public void read() throws FileNotFoundException {
        InputStream inputStream = new FileInputStream("");
    }
    public void write() throws UnsupportedEncodingException {
        throw new UnsupportedEncodingException();
    }
}
复制代码

⑩ Synchronized 使用

public class SynchronizedDemo {
    @Synchronized
    public static void hello() {
        System.out.println("world");
    }
    // 相当于
    private static final Object $LOCK = new Object[0];
    public static void hello() {
        synchronized ($LOCK) {
            System.out.println("world");
        }
    }
}
复制代码

⑪ Getter(lazy = true) 使用

public class GetterLazyExample {
    @Getter(lazy = true)
    private final double[] cached = expensive();
    private double[] expensive() {
        double[] result = new double[1000000];
        for (int i = 0; i < result.length; i++) {
            result[i] = Math.asin(i);
        }
        return result;
    }
}
// 相当于
import java.util.concurrent.atomic.AtomicReference;
public class GetterLazyExample {
    private final AtomicReference<java.lang.Object> cached = new AtomicReference<>();
    public double[] getCached() {
        java.lang.Object value = this.cached.get();
        if (value == null) {
            synchronized (this.cached) {
                value = this.cached.get();
                if (value == null) {
                    final double[] actualValue = expensive();
                    value = actualValue == null ? this.cached : actualValue;
                    this.cached.set(value);
                }
            }
        }
        return (double[]) (value == this.cached ? null : value);
    }
    private double[] expensive() {
        double[] result = new double[1000000];
        for (int i = 0; i < result.length; i++) {
            result[i] = Math.asin(i);
        }
        return result;
    }
}
复制代码

原理分析

我们知道 Java 的编译过程大致可以分为三个阶段:

  1. 解析与填充符号表
  2. 注解处理
  3. 分析与字节码生成

编译过程如下图所示:

而 Lombok 正是利用「注解处理」这一步进行实现的,Lombok 使用的是 JDK 6 实现的 JSR 269: Pluggable Annotation Processing API (编译期的注解处理器) ,它是在编译期时把 Lombok 的注解代码,转换为常规的 Java 方法而实现优雅地编程的。

这一点可以在程序中得到验证,比如本文刚开始用 @Data 实现的代码:

在我们编译之后,查看 Person 类的编译源码发现,代码竟然是这样的:

可以看出 Person 类在编译期被注解翻译器修改成了常规的 Java 方法,添加 Getter、Setter、equals、hashCode 等方法。

Lombok 的执行流程如下:

可以看出,在编译期阶段,当 Java 源码被抽象成语法树 (AST) 之后,Lombok 会根据自己的注解处理器动态的修改 AST,增加新的代码 (节点),在这一切执行之后,再通过分析生成了最终的字节码 (.class) 文件,这就是 Lombok 的执行原理。

手撸一个 Lombok

我们实现一个简易版的 Lombok 自定义一个 Getter 方法,我们的实现步骤是:

  1. 自定义一个注解标签接口,并实现一个自定义的注解处理器;
  2. 利用 tools.jar 的 javac api 处理 AST (抽象语法树)
  3. 使用自定义的注解处理器编译代码。

这样就可以实现一个简易版的 Lombok 了。

1.定义自定义注解和注解处理器

首先创建一个 MyGetter.java 自定义一个注解,代码如下:

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

@Retention(RetentionPolicy.SOURCE) // 注解只在源码中保留
@Target(ElementType.TYPE) // 用于修饰类
public @interface MyGetter { // 定义 Getter

}
复制代码

再实现一个自定义的注解处理器,代码如下:

import com.sun.source.tree.Tree;
import com.sun.tools.javac.api.JavacTrees;
import com.sun.tools.javac.code.Flags;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.TreeMaker;
import com.sun.tools.javac.tree.TreeTranslator;
import com.sun.tools.javac.util.*;

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
import java.util.Set;

@SupportedSourceVersion(SourceVersion.RELEASE_8)
@SupportedAnnotationTypes("com.example.lombok.MyGetter")
public class MyGetterProcessor extends AbstractProcessor {

    private Messager messager; // 编译时期输入日志的
    private JavacTrees javacTrees; // 提供了待处理的抽象语法树
    private TreeMaker treeMaker; // 封装了创建AST节点的一些方法
    private Names names; // 提供了创建标识符的方法

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        this.messager = processingEnv.getMessager();
        this.javacTrees = JavacTrees.instance(processingEnv);
        Context context = ((JavacProcessingEnvironment) processingEnv).getContext();
        this.treeMaker = TreeMaker.instance(context);
        this.names = Names.instance(context);
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        Set<? extends Element> elementsAnnotatedWith = roundEnv.getElementsAnnotatedWith(MyGetter.class);
        elementsAnnotatedWith.forEach(e -> {
            JCTree tree = javacTrees.getTree(e);
            tree.accept(new TreeTranslator() {
                @Override
                public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
                    List<JCTree.JCVariableDecl> jcVariableDeclList = List.nil();
                    // 在抽象树中找出所有的变量
                    for (JCTree jcTree : jcClassDecl.defs) {
                        if (jcTree.getKind().equals(Tree.Kind.VARIABLE)) {
                            JCTree.JCVariableDecl jcVariableDecl = (JCTree.JCVariableDecl) jcTree;
                            jcVariableDeclList = jcVariableDeclList.append(jcVariableDecl);
                        }
                    }
                    // 对于变量进行生成方法的操作
                    jcVariableDeclList.forEach(jcVariableDecl -> {
                        messager.printMessage(Diagnostic.Kind.NOTE, jcVariableDecl.getName() + " has been processed");
                        jcClassDecl.defs = jcClassDecl.defs.prepend(makeGetterMethodDecl(jcVariableDecl));
                    });
                    super.visitClassDef(jcClassDecl);
                }
            });
        });
        return true;
    }

    private JCTree.JCMethodDecl makeGetterMethodDecl(JCTree.JCVariableDecl jcVariableDecl) {
        ListBuffer<JCTree.JCStatement> statements = new ListBuffer<>();
        // 生成表达式 例如 this.a = a;
        JCTree.JCExpressionStatement aThis = makeAssignment(treeMaker.Select(treeMaker.Ident(
                names.fromString("this")), jcVariableDecl.getName()), treeMaker.Ident(jcVariableDecl.getName()));
        statements.append(aThis);
        JCTree.JCBlock block = treeMaker.Block(0, statements.toList());

        // 生成入参
        JCTree.JCVariableDecl param = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER),
                jcVariableDecl.getName(), jcVariableDecl.vartype, null);
        List<JCTree.JCVariableDecl> parameters = List.of(param);

        // 生成返回对象
        JCTree.JCExpression methodType = treeMaker.Type(new Type.JCVoidType());
        return treeMaker.MethodDef(treeMaker.Modifiers(Flags.PUBLIC),
                getNewMethodName(jcVariableDecl.getName()), methodType, List.nil(),
                parameters, List.nil(), block, null);

    }

    private Name getNewMethodName(Name name) {
        String s = name.toString();
        return names.fromString("get" + s.substring(0, 1).toUpperCase() + s.substring(1, name.length()));
    }

    private JCTree.JCExpressionStatement makeAssignment(JCTree.JCExpression lhs, JCTree.JCExpression rhs) {
        return treeMaker.Exec(
                treeMaker.Assign(
                        lhs,
                        rhs
                )
        );
    }
}
复制代码

自定义的注解处理器是我们实现简易版的 Lombok 的重中之重,我们需要继承 AbstractProcessor 类,重写它的 init() 和 process() 方法,在 process() 方法中我们先查询所有的变量,在给变量添加对应的方法。我们使用 TreeMaker 对象和 Names 来处理 AST,如上代码所示。

当这些代码写好之后,我们就可以新增一个 Person 类来试一下我们自定义的 @MyGetter 功能了,代码如下:

@MyGetter
public class Person {
    private String name;
}
复制代码

2.使用自定义的注解处理器编译代码

上面的所有流程执行完成之后,我们就可以编译代码测试效果了。 首先,我们先进入代码的根目录,执行以下三条命令。

进入的根目录如下:

① 使用 tools.jar 编译自定义的注解器

javac -cp $JAVA_HOME/lib/tools.jar MyGetter* -d .

注意:命令最后面有一个“.”表示当前文件夹。

② 使用自定义注解器,编译 Person 类

javac -processor com.example.lombok.MyGetterProcessor Person.java

③ 查看 Person 源码

javap -p Person.class

源码文件如下:

可以看到我们自定义的 getName() 方法已经成功生成了,到这里简易版的 Lombok 就大功告成了。

Lombok 优缺点

Lombok 的优点很明显,它可以让我们写更少的代码,节约了开发时间,并且让代码看起来更优雅,它的缺点有以下几个。

缺点1: 降低了可调试性

Lombok 会帮我们自动生成很多代码,但这些代码是在编译期生成的,因此在开发和调试阶段这些代码可能是“丢失的”,这就给调试代码带来了很大的不便。

缺点2:可能会有兼容性问题

Lombok 对于代码有很强的侵入性,加上现在 JDK 版本升级比较快,每半年发布一个版本,而 Lombok 又属于第三方项目,并且由开源团队维护,因此就没有办法保证版本的兼容性和迭代的速度,进而可能会产生版本不兼容的情况。

缺点3:可能会坑到队友

尤其对于组人来的新人可能影响更大,假如这个之前没用过 Lombok,当他把代码拉下来之后,因为没有安装 Lombok 的插件,在编译项目时,就会提示找不到方法等错误信息,导致项目编译失败,进而影响了团结成员之间的协作。

缺点4:破坏了封装性

面向对象封装的定义是:通过访问权限控制,隐藏内部数据,外部仅能通过类提供的有限的接口访问和修改内部数据。

也就是说,我们不应该无脑的使用 Lombok 对外暴露所有字段的 Getter/Setter 方法,因为有些字段在某些情况下是不允许直接修改的,比如购物车中的商品数量,它直接影响了购物详情和总价,因此在修改的时候应该提供统一的方法,进行关联修改,而不是给每个字段添加访问和修改的方法。

小结

本文我们介绍了 Lombok 的使用以及执行原理,它是通过 JDK 6 实现的 JSR 269: Pluggable Annotation Processing API (编译期的注解处理器) ,在编译期时把 Lombok 的注解转换为 Java 的常规方法的,我们可以通过继承 AbstractProcessor 类,重写它的 init() 和 process() 方法,实现一个简易版的 Lombok。但同时 Lombok 也存在这一些使用上的缺点,比如:降低了可调试性、可能会有兼容性等问题,因此我们在使用时要根据自己的业务场景和实际情况,来选择要不要使用 Lombok,以及应该如何使用 Lombok。

最后提醒一句,再好的技术也不是万金油,就好像再好的鞋子也得适合自己的脚才行!

lombok_lombok_源码.zip 立即下载

相关推荐

3D美术14——max——fbx导入max后直接生成bip人形骨骼插件

最近经常会从unity里反八FBX到max里进行2次修改。 但是非常尴尬的事情就是,就是用max做的fbx,你在反导入回来,BIP骨骼都会变成预制体。这个时候有一个方法补救。那就是在导入的时候调整一下参数。(如下图) 把这里调整成设置为骨骼。就还可以了。 但是,如果你不是用max做的FBX。呵呵,那么你一定很头大,因为完全没有用。 所以,这个时候就要上插件了。 Autofbxtobip v.1.1 这个插件适用于2015及其以上版本。 在这之前我还用过一款叫BIPPY,但是效果相当感人,照着这个图片调整

qq_37576129的博客 1万+

Java Lombok 报错(IllegalAccessError: class lombok.javac.apt.LombokProcessor)解决方法

本文主要介绍Java 中,使用Lombok报错:java: java.lang.IllegalAccessError: class lombok.javac.apt.LombokProcessor的解决方法及示例代码。 原文地址:Java Lombok 报错(IllegalAccessError: class lombok.javac.apt.LombokProcessor)解决方法 ...

亮亮的专栏 2万+

Python+Vue计算机毕业设计风电场监控系统的设计与实现7bd6i(程序+LW+源码+部署)

Python3.7.7+Django+Mysql5.7+pip list+HBuilderX(Vscode也行)+Vue+Pychram社区版。2. 前端:vue+css+javascript+jQuery+easyUI+highcharts。2.IDE环境:Python和Python 社区版都可以。Django + Vue +Python+Mysql 等等组成,B/S模式等等。该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。1. 后端:Python、Vue、Django、Mysql。

华信计算机毕设源码程序 344

Lombok报错:class lombok.javac.apt.LombokProcessor

Ctrl + Alt + Shift + S快捷键打开Project Structure。lombok版本和jdk版本不匹配。在pom坐标上修改lombok版本。比如将jdk19变为JDK1.8。

jj89929665的博客 7874

Aurix TC3XX Cache memory分析

Aurix Cache memory 分析

qwe0405080615的博客 4358

NVIDIA显卡驱动历史版本全攻略:从官网隐藏入口到精准下载

本文详细介绍了如何获取NVIDIA显卡驱动历史版本的完整攻略,包括官网隐藏入口的揭秘、精准筛选驱动版本的技巧以及安装避坑指南。特别针对游戏玩家、创作者和老显卡用户提供了实用建议,帮助用户解决驱动兼容性问题,提升显卡性能。

m2n3o4p5的博客 3770

IDEA 解决 LombokProcessor could not be initialized 问题

使用 IDEA 时,LombokProcessor could not be initialized 怎么办?解答。。。

Regino的博客 3626

一篇文章带你搞定数学建模中的线性回归模型(05年长江水质问题示例讲解含代码)

文章目录一、问题分析二、原理讲解三、MATLAB 实现线性回归模型 一、问题分析 根据你的预测分析,如果未来10年内每年都要求长江干流的Ⅳ类和Ⅴ类水的比例控制在20%以内,且没有劣Ⅴ类水,那么每年需要处理多少污水 为了达到题目中所要求的水质,可建立废水排放量与各类水百分比之间的二元线性回归模型,对未来十年的废水排放量进行预测,并确定其与各类水所占百分比之间的函数关系式。通过此关系式,可以计算在这种情况下长江所能承受的最大污水排放量,将这个排放量与预测的排放量进行比较,多出来的部分就是需要每年处理掉的。 二、

南淮北安的博客 2167

Lombok 原理与实现

本文主要包含以下内容: Lombok 的实现机制分析。 插入式注解处理器的说明及使用。 动手实现 lombok 的 @Getter 和 @Setter 注解。 配置 IDEA 以调试 Java 编译过程。

Sumkor的博客 1471

NLP高频面试题(一)——Transformer的基本结构、作用和代码实现

本文详细介绍了Transformer模型的基本结构和PyTorch代码实现过程。首先解析了Transformer的核心组成部分,包括嵌入层、多头自注意力机制、位置编码、前馈神经网络、编码器和解码器等模块,并通过清晰的代码示例逐步展示了如何在PyTorch中构建完整的Transformer模型。文末提供了一个可运行的简单示例,帮助读者快速理解并实践Transformer的核心原理与实现方法。

WeLearnNLP 1029

【Matlab】刃边法计算mtf

摘要:刃边法是一种测量光学系统调制传输函数(MTF)的常用方法。本文介绍了基于Matlab的MTF计算实现方案,包括图像灰度化、梯度计算、刀口方向选择、梯度投影等关键步骤,并给出了完整的代码实现。该方案可通过添加图像预处理、多方向计算、函数封装等方式进行扩展,提高MTF计算的准确性和实用性,适用于不同应用场景的光学系统性能评估需求。(148字)

unber的博客 391

99%的程序员都在用Lombok,原理竟然这么简单?我也手撸了一个!

世界上只有一种英雄主义,就是看清生活的真相之后依然热爱生活。对于 Lombok 我相信大部分人都不陌生,但对于它的实现原理以及缺点却鲜为人知,而本文将会从 Lombok 的原理出发,手...

macrozheng的专栏 832

完美解决unknown failed to transfer from http://0.0.0.0/ during a previous attempt的错误

完美解决unknown failed to transfer from http://0.0.0.0/ during a previous attempt的错误

念兮为美 2282

99%的程序员都在用Lombok,原理竟然这么简单?我也手撸了一个!|建议收藏

世界上只有一种英雄主义,就是看清生活的真相之后依然热爱生活。 对于 Lombok 我相信大部分人都不陌生,但对于它的实现原理以及缺点却鲜为人知,而本文将会从 Lombok 的原理出发,手撸一个简易版的 Lombok,让你理解这个热门技术背后的执行原理,以及它的优缺点分析。 简介 在讲原理之前,我们先来复习一下 Lombok (老司机可直接跳过本段)。 Lombok 是一个非常热门的开源项目 (...

磊哥聊Java 3126

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

lombok原理_好多Java程序员都用的轻巧Lombok,原理简单到你可手撸一个!

作者:老王链接:https://mp.weixin.qq.com/s/ppE8HTkFIIAD7pZ_TjlG1g世界上只有一种英雄主义,就是看清生活的真相之后依然热爱生活。对于 Lombok 我相信大部分人都不陌生,但对于它的实现原理以及缺点却鲜为人知,而本文将会从 Lombok 的原理出发,手撸一个简易版的 Lombok,让你理解这个热门技术背后的执行原理,以及它的优缺点。简介在讲原理之前,我...

weixin_39604045的博客 166

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

lombok原理_99%的程序员都在用Lombok,原理竟然这么简单?我也手撸了一个!

世界上只有一种英雄主义,就是看清生活的真相之后依然热爱生活。对于 Lombok 我相信大部分人都不陌生,但对于它的实现原理以及缺点却鲜为人知,而本文将会从 Lombok 的原理出发,手撸一个简易版的 Lombok,让你理解这个热门技术背后的执行原理,以及它的优缺点。简介在讲原理之前,我们先来复习一下 Lombok (老司机可直接跳过本段)。Lombok 是一个非常热门的开源项目 (ht...

weixin_39693193的博客 206

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

lombok @data 忽略属性_99%的程序员都在用Lombok,原理竟然这么简单?我也手撸了一个!

作者:老王_Java中文社群罗曼罗兰说过:世界上只有一种英雄主义,就是看清生活的真相之后依然热爱生活。对于 Lombok 我相信大部分人都不陌生,但对于它的实现原理以及缺点却鲜为人知,而本文将会从 Lombok 的原理出发,手撸一个简易版的 Lombok,让你理解这个热门技术背后的执行原理,以及它的优缺点分析。简介在讲原理之前,我们先来复习一下 Lombok (老司机可以直接跳过本段看原理部分的内...

weixin_39747399的博客 1362

lombok原理_99%的程序员都在用Lombok,原理竟然这么简单?我也手撸了一个!|建议收藏

世界上只有一种英雄主义,就是看清生活的真相之后依然热爱生活。对于 Lombok 我相信大部分人都不陌生,但对于它的实现原理以及缺点却鲜为人知,而本文将会从 Lombok 的原理出发,手撸一个简易版的 Lombok,让你理解这个热门技术背后的执行原理,以及它的优缺点分析。简介在讲原理之前,我们先来复习一下 Lombok (老司机可直接跳过本段)。Lombok 是一个非常热门的开源项目 (https...

weixin_39962153的博客 263

99%的程序员都在用Lombok,原理竟然这么简单?我也手撸了一个!|建议收藏!!!...

世界上只有一种英雄主义,就是看清生活的真相之后依然热爱生活。对于 Lombok 我相信大部分人都不陌生,但对于它的实现原理以及缺点却鲜为人知,而本文将会从 Lombok 的原理出发,手...

weixin_44742132的博客 504

手撸一个简单的Lombok

以前在工作中也用到过Lombok,但是对其原理不了解。Lombok真是个让人又爱又恨的插件,它可以让程序员优雅的实现getter、setter、toString和构造方法等方法,使代码更加精简,但是因为没安装插件或者插件版本问题导致项目报错。 今天正好看到一篇文章,讲解了一下Lombok的基本原理。于是跟着手敲了一遍代码加深学习印象,中间也遇到一些问题。 Lombok的原理简单一句话来讲,就是在*...

weixin_42281516的博客 558

99%的程序员都在用Lombok,原理竟然这么简单?

作者 | 老王责编 | 郭芮对于 Lombok 我相信大部分人都不陌生,但对于它的实现原理以及缺点却鲜为人知,而本文将会从 Lombok 的原理出发,手撸一个简易版的 Lombok,让...

CSDN资讯 2940

lombok原理_99%的程序员都在用Lombok,原理竟然这么简单?

作者 | 老王责编 | 郭芮对于 Lombok 我相信大部分人都不陌生,但对于它的实现原理以及缺点却鲜为人知,而本文将会从 Lombok 的原理出发,手撸一个简易版的 Lombok,让你理解这个热门技术背后的执行原理,以及它的优缺点。简介在讲原理之前,我们先来复习一下 Lombok (老司机可直接跳过本段)。Lombok 是一个非常热门的开源项目 (https://github.com/...

weixin_39585463的博客 169
上一篇: 这应该是全网最全的分库分表方案了
下一篇: 2W字,详解20道Redis经典面试题,(珍藏版)
JavaMonsterr
博客等级 码龄5年 211粉丝 481原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值