jooq生成records_Java 14 Records类

冷不防 2023-02-28 06:28 29阅读 0赞

jooq生成records

Java 14 introduced a new way to create classes called Records. In this tutorial, we will learn:

Java 14引入了一种创建记录的新方法，称为记录。 在本教程中，我们将学习：

*  Why do we need Java Records
    
    为什么我们需要Java记录
 *  How to create Records and use it
    
    如何创建记录并使用它
 *  Overriding and extending Records classes
    
    覆盖和扩展Records类

**Recommended Reading**: [Java 14 Features][]

**推荐读物** ： [Java 14特性][Java 14 Features]

## 为什么我们需要Java记录？ **(****Why do we need Java Records?****)** ##

One of the common complaints with Java has been its verbosity. If you have to create a simple POJO class, it requires the following boiler-plate code.

Java的普遍抱怨之一是它的冗长。 如果必须创建一个简单的POJO类，则需要以下样板代码。

*  Private fields
    
    私人领域
 *  Getter and Setter Methods
    
    getter和setter方法
 *  Constructors
    
    建设者
 *  hashCode(), equals(), and toString() methods.
    
    hashCode（），equals（）和toString（）方法。

This verbosity is one of the reasons for high interest in [Kotlin][] and [Project Lombok][].

这种冗长的语言是引起人们对[Kotlin][]和[Project Lombok][]高度兴趣的原因之一。

In fact, the sheer frustration of writing these generic methods each and every time lead to the shortcuts to create them in Java IDEs such as Eclipse and IntelliJ IDEA.

实际上，每次编写这些通用方法的无奈之举导致在Java IDE（例如Eclipse和IntelliJ IDEA）中创建这些通用方法的捷径。

Here is the screenshot showing Eclipse IDE option to generate the ceremonial methods for a class.

这是显示Eclipse IDE选项以生成类的仪式方法的屏幕截图。

![Eclipse Shortcuts Generate Ceremonial Methods][]

Eclipse Shortcuts to Generate Ceremonial Methods Eclipse生成仪式方法的快捷方式

Java Records are meant to remove this verbosity by providing a compact structure to create the POJO classes.

Java Records通过提供一个紧凑的结构来创建POJO类来消除这种冗长的含义。

## 如何创建Java记录 **(****How to Create Java Records****)** ##

Java Records is a preview feature, which is developed under [JEP 359][]. So, you need two things to create Records in your Java projects.

Java Records是预览功能，是在[JEP 359][]下开发的。 因此，您需要两件事在Java项目中创建Records。

1.  JDK 14 installed. If you are using an IDE, then it must provide support for Java 14 too. Both Eclipse and IntelliJ already provide support for Java 14, so we are good here.
    
    已安装JDK 14。 如果使用的是IDE，则它也必须提供对Java 14的支持。 Eclipse和IntelliJ都已经提供了对Java 14的支持，因此我们在这里很好。
2.  **Enable Preview Feature**: By default, the preview features are disabled. You can enable it in Eclipse from the Project Java Compiler setting.
    
    **启用预览功能** ：默认情况下，预览功能处于禁用状态。 您可以在Eclipse中从Project Java Compiler设置启用它。

![Java 14 Enable Preview Feature In Eclipse][]

Java 14 Enable Preview Feature In Eclipse Java 14在Eclipse中启用预览功能

You can enable Java 14 preview features in the command line using the `--enable-preview -source 14` option.

您可以使用`--enable-preview -source 14`选项在命令行中启用Java 14预览功能。

Let’s say I want to create a Employee model class. It will look something like the following code.

假设我要创建一个Employee模型类。 它看起来像下面的代码。

package com.journaldev.java14;
    
    import java.util.Map;
    
    public class Employee {
    
    	private int id;
    	private String name;
    	private long salary;
    	private Map<String, String> addresses;
    
    	public Employee(int id, String name, long salary, Map<String, String> addresses) {
    		super();
    		this.id = id;
    		this.name = name;
    		this.salary = salary;
    		this.addresses = addresses;
    	}
    
    	public int getId() {
    		return id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public long getSalary() {
    		return salary;
    	}
    
    	public Map<String, String> getAddresses() {
    		return addresses;
    	}
    
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + ((addresses == null) ? 0 : addresses.hashCode());
    		result = prime * result + id;
    		result = prime * result + ((name == null) ? 0 : name.hashCode());
    		result = prime * result + (int) (salary ^ (salary >>> 32));
    		return result;
    	}
    
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Employee other = (Employee) obj;
    		if (addresses == null) {
    			if (other.addresses != null)
    				return false;
    		} else if (!addresses.equals(other.addresses))
    			return false;
    		if (id != other.id)
    			return false;
    		if (name == null) {
    			if (other.name != null)
    				return false;
    		} else if (!name.equals(other.name))
    			return false;
    		if (salary != other.salary)
    			return false;
    		return true;
    	}
    
    	@Override
    	public String toString() {
    		return "Employee [id=" + id + ", name=" + name + ", salary=" + salary + ", addresses=" + addresses + "]";
    	}
    
    }

Phew, that’s 70+ lines of auto-generated code. Now let’s see how to create an Employee Record class, which essentially provides the same features.

哎呀，这是70多行自动生成的代码。 现在，让我们看看如何创建Employee Record类，该类本质上提供相同的功能。

package com.journaldev.java14;
    
    import java.util.Map;
    
    public record EmpRecord(int id, String name, long salary, Map<String, String> addresses) {
    }

Wow, this can’t go any shorter than this. I am already loving Record classes.

哇，这不能比这短。 我已经喜欢录制课程了。

Now, let’s use the `javap` command to figure out what is happening behind the scene when a Record is compiled.

现在，让我们使用`javap`命令找出在编译记录时幕后发生的事情。

# javac --enable-preview -source 14 EmpRecord.java
    Note: EmpRecord.java uses preview language features.
    Note: Recompile with -Xlint:preview for details.
    
    # javap EmpRecord      
    Compiled from "EmpRecord.java"
    public final class EmpRecord extends java.lang.Record {
      public EmpRecord(int, java.lang.String, long, java.util.Map<java.lang.String, java.lang.String>);
      public java.lang.String toString();
      public final int hashCode();
      public final boolean equals(java.lang.Object);
      public int id();
      public java.lang.String name();
      public long salary();
      public java.util.Map<java.lang.String, java.lang.String> addresses();
    }
    #

![Java Record Class Details][]

Java Record Class Details Java记录类详细信息

If you want more internal details, run the javap command with -v option.

如果需要更多内部详细信息，请运行带有-v选项的javap命令。

# javap -v EmpRecord

## 有关记录类的要点 **(****Important Points about Record Classes****)** ##

1.  A Record class is final, so we can’t extend it.
    
    Record类是最终的，因此我们无法扩展它。
2.  The Record classes implicitly extend `java.lang.Record` class.
    
    Record类隐式扩展了`java.lang.Record`类。
3.  All the fields specified in the record declaration are final.
    
    记录声明中指定的所有字段均为最终字段。
4.  The record fields are “shallow” immutable and depend on the type. For example, we can change the addresses field by accessing it and then making updates to it.
    
    记录字段是“浅”不变的，并取决于类型。 例如，我们可以通过访问地址字段然后对其进行更新来更改地址字段。
5.  A single constructor is created with all the fields specified in the record definition.
    
    使用记录定义中指定的所有字段创建单个构造函数。
6.  The Record class automatically provides accessor methods for the fields. The method name is the same as the field name, not like generic and conventional getter methods.
    
    Record类自动为字段提供访问器方法。 方法名称与字段名称相同，与通用和常规getter方法不同。
7.  The Record class provides [hashCode()][hashCode], equals(), and toString() implementations too.
    
    Record类也提供[hashCode（）][hashCode] ，equals（）和toString（）实现。

## 在Java程序中使用记录 **(****Using Records in Java Program****)** ##

Let’s look at a simple example of using our EmpRecord class.

让我们看一个使用EmpRecord类的简单示例。

package com.journaldev.java14;
    
    public class RecordTest {
    
    	public static void main(String[] args) {
    		
    		EmpRecord empRecord1 = new EmpRecord(10, "Pankaj", 10000, null);
    		EmpRecord empRecord2 = new EmpRecord(10, "Pankaj", 10000, null);
    
    		// toString()
    		System.out.println(empRecord1);
    		
    		// accessing fields
    		System.out.println("Name: "+empRecord1.name()); 
    		System.out.println("ID: "+empRecord1.id());
    		
    		// equals()
    		System.out.println(empRecord1.equals(empRecord2));
    		
    		// hashCode()
    		System.out.println(empRecord1 == empRecord2);		
    	}
    }

Output:

输出：

EmpRecord[id=10, name=Pankaj, salary=10000, addresses=null]
    Name: Pankaj
    ID: 10
    true
    false

The Record object works in the same way as any model class, data object, etc.

Record对象的工作方式与任何模型类，数据对象等相同。

## 扩展记录构造器 **(****Extending Records Constructor****)** ##

Sometimes, we want to have some validations or logging in our [constructor][]. For example, employee id and salary should not be negative. The default constructor won’t have this validation. We can create a compact constructor in the record class. The code of this constructor will be placed at the start of the auto-generated constructor.

有时，我们想进行一些验证或登录我们的[构造函数][constructor] 。 例如，员工ID和薪水不应为负数。 默认的构造函数将没有此验证。 我们可以在记录类中创建一个紧凑的构造函数。 该构造函数的代码将放置在自动生成的构造函数的开头。

public record EmpRecord(int id, String name, long salary, Map<String, String> addresses) {
    	
    	public EmpRecord {
    		if (id < 0)
    			throw new IllegalArgumentException("employee id can't be negative");
    
    		if (salary < 0)
    			throw new IllegalArgumentException("employee salary can't be negative");
    	}
    
    }

If we create an EmpRecord like the following code:

如果我们创建一个类似以下代码的EmpRecord：

EmpRecord empRecord1 = new EmpRecord(-10, "Pankaj", 10000, null);

We will get runtime exception as:

我们将获得运行时异常为：

Exception in thread "main" java.lang.IllegalArgumentException: employee id can't be negative
    	at com.journaldev.java14.EmpRecord.<init>(EmpRecord.java:9)

## 记录类可以有方法吗？ **(****Can Records Classes Have Methods?****)** ##

Yes, we can create method in records.

是的，我们可以在记录中创建方法。

public record EmpRecord(int id, String name, long salary, Map<String, String> addresses) {
    
    	public int getAddressCount() {
    		if (this.addresses != null)
    			return this.addresses().size();
    		else
    			return 0;
    	}
    }

But, records are meant to be data carriers. We should avoid having utility methods in a record class. For example, the above method can be created in a utility class.

但是，记录本来是数据载体。 我们应该避免在记录类中使用实用程序方法。 例如，可以在实用工具类中创建上述方法。

If you think that having a method is must for your Record class, think carefully if you really need a Record class?

如果您认为Record类必须具有方法，请仔细考虑是否确实需要Record类？

## 结论 **(****Conclusion****)** ##

Java Records are a welcome addition to the core programming features. You can think of it as a “named tuple”. It’s meant to create a data carrier object with compact structure, avoiding all the boiler-plate code.

Java Records是核心编程功能的一个受欢迎的补充。 您可以将其视为“命名元组”。 它旨在创建结构紧凑的数据载体对象，从而避免所有样板代码。

> 翻译自: [https://www.journaldev.com/39987/java-records-class][https_www.journaldev.com_39987_java-records-class]

jooq生成records

[Java 14 Features]: https://www.journaldev.com/37273/java-14-features
[Kotlin]: https://www.journaldev.com/kotlin
[Project Lombok]: https://www.journaldev.com/18124/java-project-lombok
[Eclipse Shortcuts Generate Ceremonial Methods]: https://cdn.journaldev.com/wp-content/uploads/2020/05/eclipse-shortcuts-generate-ceremonial-methods-1024x832.png
[JEP 359]: https://openjdk.java.net/jeps/359
[Java 14 Enable Preview Feature In Eclipse]: https://cdn.journaldev.com/wp-content/uploads/2020/05/java-14-enable-preview-feature-in-eclipse-1024x460.png
[Java Record Class Details]: /images/20230209/0fb50669ff124b5abdda37311463131c.png
[hashCode]: https://www.journaldev.com/21095/java-equals-hashcode
[constructor]: https://www.journaldev.com/18899/constructor-in-java
[https_www.journaldev.com_39987_java-records-class]: https://www.journaldev.com/39987/java-records-class