Lombok 简介

<dependencies>
    ...
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.20</version>
        <scope>provided</scope>
    </dependency>
    ...
</dependencies>

@Entity
public class User implements Serializable {
    private @Id Long id; // will be set when persisting
    private String firstName;
    private String lastName;
    private int age;
    public User() {
    }
    public User(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }
    // getters and setters: ~30 extra lines of code
}

@Entity
@Getter @Setter @NoArgsConstructor // <--- THIS is it
public class User implements Serializable {
    private @Id Long id; // will be set when persisting
    private String firstName;
    private String lastName;
    private int age;
    public User(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }
}

private @Id @Setter(AccessLevel.PROTECTED) Long id;

public class GetterLazy {
    @Getter(lazy = true)
    private final Map<String, Long> transactions = getTransactions();
    private Map<String, Long> getTransactions() {
        final Map<String, Long> cache = new HashMap<>();
        List<String> txnRows = readTxnListFromFile();
        txnRows.forEach(s -> {
            String[] txnIdValueTuple = s.split(DELIMETER);
            cache.put(txnIdValueTuple[0], Long.parseLong(txnIdValueTuple[1]));
        });
        return cache;
    }
}

public class GetterLazy {
    private final AtomicReference<Object> transactions = new AtomicReference();
    public GetterLazy() {
    }
    //other methods
    public Map<String, Long> getTransactions() {
        Object value = this.transactions.get();
        if (value == null) {
            synchronized(this.transactions) {
                value = this.transactions.get();
                if (value == null) {
                    Map<String, Long> actualValue = this.readTxnsFromFile();
                    value = actualValue == null ? this.transactions : actualValue;
                    this.transactions.set(value);
                }
            }
        }
        return (Map)((Map)(value == this.transactions ? null : value));
    }
}

public class LoginResult {
    private final Instant loginTs;
    private final String authToken;
    private final Duration tokenValidity;
    
    private final URL tokenRefreshUrl;
    // constructor taking every field and checking nulls
    // read-only accessor, not necessarily as get*() form
}

@RequiredArgsConstructor
@Accessors(fluent = true) @Getter
public class LoginResult {
    private final @NonNull Instant loginTs;
    private final @NonNull String authToken;
    private final @NonNull Duration tokenValidity;
    
    private final @NonNull URL tokenRefreshUrl;
}

// Imagine fields were no longer final now
return new LoginResult()
  .loginTs(Instant.now())
  .authToken("asdasd")
  . // and so on

@OneToMany(mappedBy = "user")
private List<UserEvent> events;

public class ApiClientConfiguration {
    private String host;
    private int port;
    private boolean useHttps;
    private long connectTimeout;
    private long readTimeout;
    private String username;
    private String password;
    // Whatever other options you may thing.
    // Empty constructor? All combinations?
    // getters... and setters?
}

@Builder
public class ApiClientConfiguration {
    // ... everything else remains the same
}

ApiClientConfiguration config = 
    ApiClientConfiguration.builder()
        .host("api.server.com")
        .port(443)
        .useHttps(true)
        .connectTimeout(15_000L)
        .readTimeout(5_000L)
        .username("myusername")
        .password("secret")
    .build();

public String resourceAsString() {
    try (InputStream is = this.getClass().getResourceAsStream("sure_in_my_jar.txt")) {
        BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
        return br.lines().collect(Collectors.joining("\n"));
    } catch (IOException | UnsupportedCharsetException ex) {
        // If this ever happens, then its a bug.
        throw new RuntimeException(ex); <--- encapsulate into a Runtime ex.
    }
}

@SneakyThrows
public String resourceAsString() {
    try (InputStream is = this.getClass().getResourceAsStream("sure_in_my_jar.txt")) {
        BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
        return br.lines().collect(Collectors.joining("\n"));
    } 
}

@Cleanup InputStream is = this.getClass().getResourceAsStream("res.txt");

@Cleanup("dispose") JFrame mainFrame = new JFrame("Main Window");

public class ApiClientConfiguration {
    private static Logger LOG = LoggerFactory.getLogger(ApiClientConfiguration.class);
    // LOG.debug(), LOG.info(), ...
}

@Slf4j // or: @Log @CommonsLog @Log4j @Log4j2 @XSlf4j
public class ApiClientConfiguration {
    // log.debug(), log.info(), ...
}

@Synchronized
public /* better than: synchronized */ void putValueInCache(String key, Object value) {
    // whatever here will be thread-safe code
}

public interface HasContactInformation {
    String getFirstName();
    void setFirstName(String firstName);
    String getFullName();
    String getLastName();
    void setLastName(String lastName);
    String getPhoneNr();
    void setPhoneNr(String phoneNr);
}

@Data
public class ContactInformationSupport implements HasContactInformation {
    private String firstName;
    private String lastName;
    private String phoneNr;
    @Override
    public String getFullName() {
        return getFirstName() + " " + getLastName();
    }
}

public class User implements HasContactInformation {
    // Whichever other User-specific attributes
    @Delegate(types = {HasContactInformation.class})
    private final ContactInformationSupport contactInformation =
            new ContactInformationSupport();
    // User itself will implement all contact information by delegation
    
}