你见过哪些惊艳的 Java 代码技巧?

Java+AI联动开发:用LangChain实现智能编码的6个惊艳案例 在当今技术快速迭代的时代,Java作为企业级开发的主流语言,正经历着与人工智能技术深度融合的转型。全球超过900万家使用Java的企业正面临AI化重构的压力和机遇。传统Java开发体系在应对AI转型时面临多模型适配困境、系统稳定性风险等核心挑战,而LangChain等框架的出现为Java开发者提供了全新的解决方案。 阅读详情

导语

自从毕业后,今年已经是我工作的第 8 个年头了,我甚至都快忘记了到底是那年毕业的。从出来本人一直在做 Java 相关的工作,现在终于有时间坐下来,写一篇关于 Java 写法的一篇文章,来探讨一下如果你真的是一个 Java 程序员,那你真的会写 Java 吗?

笔者是一个务实的程序员,故本文绝非扯淡文章,文中内容都是干货,望读者看后,能有所收获。

本文不是一个吹嘘的文章,不会讲很多高深的架构,相反,会讲解很多基础的问题和写法问题,如果读者自认为基础问题和写法问题都是不是问题,那请忽略这篇文章,节省出时间去做一些有意义的事情。

开发工具

不知道有多少”老”程序员还在使用 Eclipse,这些程序员们要不就是因循守旧,要不就是根本就不知道其他好的开发工具的存在,Eclipse 吃内存卡顿的现象以及各种偶然莫名异常的出现,都告知我们是时候寻找新的开发工具了。

更换 IDE

根本就不想多解释要换什么样的 IDE,如果你想成为一个优秀的 Java 程序员,请更换 IntelliJ IDEA。使用 IDEA 的好处,请搜索谷歌。

别告诉我快捷键不好用

更换 IDE 不在我本文的重点内容中,所以不想用太多的篇幅去写为什么更换IDE。在这里,我只能告诉你,更换 IDE 只为了更好、更快的写好 Java 代码。原因略。

别告诉我快捷键不好用,请尝试新事物。

bean

bean 使我们使用最多的模型之一,我将以大篇幅去讲解 bean,希望读者好好体会。

domain 包名

根据很多 Java 程序员的”经验”来看,一个数据库表则对应着一个 domain 对象,所以很多程序员在写代码时,包名则使用:com.xxx.domain ,这样写好像已经成为了行业的一种约束,数据库映射对象就应该是 domain。但是你错了,domain 是一个领域对象,往往我们再做传统 Java 软件 Web 开发中,这些 domain 都是贫血模型,是没有行为的,或是没有足够的领域模型的行为的,所以,以这个理论来讲,这些 domain 都应该是一个普通的 entity 对象,并非领域对象,所以请把包名改为:com.xxx.entity。

如果你还不理解我说的话,请看一下 Vaughn Vernon 出的一本叫做《IMPLEMENTING DOMAIN-DRIVEN DESIGN》(实现领域驱动设计)这本书,书中讲解了贫血模型与领域模型的区别,相信你会受益匪浅。

DTO

数据传输我们应该使用 DTO 对象作为传输对象,这是我们所约定的,因为很长时间我一直都在做移动端 API 设计的工作,有很多人告诉我,他们认为只有给手机端传输数据的时候(input or output),这些对象成为 DTO 对象。请注意!这种理解是错误的,只要是用于网络传输的对象,我们都认为他们可以当做是 DTO 对象,比如电商平台中,用户进行下单,下单后的数据,订单会发到 OMS 或者 ERP 系统,这些对接的返回值以及入参也叫 DTO 对象。

我们约定某对象如果是 DTO 对象,就将名称改为 XXDTO,比如订单下发OMS:OMSOrderInputDTO。

DTO 转化

正如我们所知,DTO 为系统与外界交互的模型对象,那么肯定会有一个步骤是将 DTO 对象转化为 BO 对象或者是普通的 entity 对象,让 service 层去处理。

场景

比如添加会员操作,由于用于演示,我只考虑用户的一些简单数据,当后台管理员点击添加用户时,只需要传过来用户的姓名和年龄就可以了,后端接受到数据后,将添加创建时间和更新时间和默认密码三个字段,然后保存数据库。

@RequestMapping("/v1/api/user")
@RestController
public class UserApi {
 @Autowired
 private UserService userService;
 @PostMapping
 public User addUser(UserInputDTO userInputDTO){
 User user = new User();
 user.setUsername(userInputDTO.getUsername());
 user.setAge(userInputDTO.getAge());
 return userService.addUser(user);
 }
}

我们只关注一下上述代码中的转化代码,其他内容请忽略:

User user = new User();
user.setUsername(userInputDTO.getUsername());
user.setAge(userInputDTO.getAge());

请使用工具

上边的代码,从逻辑上讲,是没有问题的,只是这种写法让我很厌烦,例子中只有两个字段,如果有 20 个字段,我们要如何做呢? 一个一个进行 set 数据吗?当然,如果你这么做了,肯定不会有什么问题,但是,这肯定不是一个最优的做法。

网上有很多工具,支持浅拷贝或深拷贝的 Utils。举个例子,我们可以使用
org.springframework.beans.BeanUtils#copyProperties 对代码进行重构和优化:

@PostMapping
public User addUser(UserInputDTO userInputDTO){
 User user = new User();
 BeanUtils.copyProperties(userInputDTO,user);
 return userService.addUser(user);
}

BeanUtils.copyProperties 是一个浅拷贝方法,复制属性时,我们只需要把 DTO 对象和要转化的对象两个的属性值设置为一样的名称,并且保证一样的类型就可以了。如果你在做 DTO 转化的时候一直使用 set 进行属性赋值,那么请尝试这种方式简化代码,让代码更加清晰!

转化的语义

上边的转化过程,读者看后肯定觉得优雅很多,但是我们再写 Java 代码时,更多的需要考虑语义的操作,再看上边的代码:

User user = new User();
BeanUtils.copyProperties(userInputDTO,user);

虽然这段代码很好的简化和优化了代码,但是他的语义是有问题的,我们需要提现一个转化过程才好,所以代码改成如下:

@PostMapping
 public User addUser(UserInputDTO userInputDTO){
 User user = convertFor(userInputDTO);
 return userService.addUser(user);
 }
 private User convertFor(UserInputDTO userInputDTO){
 User user = new User();
 BeanUtils.copyProperties(userInputDTO,user);
 return user;
 }

这是一个更好的语义写法,虽然他麻烦了些,但是可读性大大增加了,在写代码时,我们应该尽量把语义层次差不多的放到一个方法中,比如:

User user = convertFor(userInputDTO);
return userService.addUser(user);

这两段代码都没有暴露实现,都是在讲如何在同一个方法中,做一组相同层次的语义操作,而不是暴露具体的实现。

如上所述,是一种重构方式,读者可以参考 Martin Fowler 的《Refactoring Imporving the Design of Existing Code》(重构 改善既有代码的设计) 这本书中的 Extract Method 重构方式。

抽象接口定义

当实际工作中,完成了几个 API 的 DTO 转化时,我们会发现,这样的操作有很多很多,那么应该定义好一个接口,让所有这样的操作都有规则的进行。

如果接口被定义以后,那么 convertFor 这个方法的语义将产生变化,它将是一个实现类。

看一下抽象后的接口:

public interface DTOConvert<S,T> {
 T convert(S s);
}

虽然这个接口很简单,但是这里告诉我们一个事情,要去使用泛型,如果你是一个优秀的 Java 程序员,请为你想做的抽象接口,做好泛型吧。

我们再来看接口实现:

public class UserInputDTOConvert implements DTOConvert {
@Override
public User convert(UserInputDTO userInputDTO) {
User user = new User();
BeanUtils.copyProperties(userInputDTO,user);
return user;
}
}

我们这样重构后,我们发现现在的代码是如此的简洁,并且那么的规范:

@RequestMapping("/v1/api/user")
@RestController
public class UserApi {
 @Autowired
 private UserService userService;
 @PostMapping
 public User addUser(UserInputDTO userInputDTO){
 User user = new UserInputDTOConvert().convert(userInputDTO);
 return userService.addUser(user);
 }
}

review code

如果你是一个优秀的 Java 程序员,我相信你应该和我一样,已经数次重复 review 过自己的代码很多次了。

我们再看这个保存用户的例子,你将发现,API 中返回值是有些问题的,问题就在于不应该直接返回 User 实体,因为如果这样的话,就暴露了太多实体相关的信息,这样的返回值是不安全的,所以我们更应该返回一个 DTO 对象,我们可称它为 UserOutputDTO:

@PostMapping
public UserOutputDTO addUser(UserInputDTO userInputDTO){
 User user = new UserInputDTOConvert().convert(userInputDTO);
 User saveUserResult = userService.addUser(user);
 UserOutputDTO result = new UserOutDTOConvert().convertToUser(saveUserResult);
 return result;
}

这样你的 API 才更健全。

不知道在看完这段代码之后,读者有是否发现还有其他问题的存在,作为一个优秀的 Java 程序员,请看一下这段我们刚刚抽象完的代码:

User user = new UserInputDTOConvert().convert(userInputDTO);

你会发现,new 这样一个 DTO 转化对象是没有必要的,而且每一个转化对象都是由在遇到 DTO 转化的时候才会出现,那我们应该考虑一下,是否可以将这个类和 DTO 进行聚合呢,看一下我的聚合结果:

public class UserInputDTO {
private String username;
private int age;
 public String getUsername() {
 return username;
 }
 public void setUsername(String username) {
 this.username = username;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }
 public User convertToUser(){
 UserInputDTOConvert userInputDTOConvert = new UserInputDTOConvert();
 User convert = userInputDTOConvert.convert(this);
 return convert;
 }
 private static class UserInputDTOConvert implements DTOConvert<UserInputDTO,User> {
 @Override
 public User convert(UserInputDTO userInputDTO) {
 User user = new User();
 BeanUtils.copyProperties(userInputDTO,user);
 return user;
 }
 }
}

然后 API 中的转化则由:

User user = new UserInputDTOConvert().convert(userInputDTO);
User saveUserResult = userService.addUser(user);

变成了:

User user = userInputDTO.convertToUser();
User saveUserResult = userService.addUser(user);

我们再 DTO 对象中添加了转化的行为,我相信这样的操作可以让代码的可读性变得更强,并且是符合语义的。

再查工具类

再来看 DTO 内部转化的代码,它实现了我们自己定义的 DTOConvert 接口,但是这样真的就没有问题,不需要再思考了吗?

我觉得并不是,对于 Convert 这种转化语义来讲,很多工具类中都有这样的定义,这中 Convert 并不是业务级别上的接口定义,它只是用于普通 bean 之间转化属性值的普通意义上的接口定义,所以我们应该更多的去读其他含有 Convert 转化语义的代码。

我仔细阅读了一下 GUAVA 的源码,发现了
com.google.common.base.Convert 这样的定义:

public abstract class Converter<A, B> implements Function<A, B> {
 protected abstract B doForward(A a);
 protected abstract A doBackward(B b);
 //其他略
}

从源码可以了解到,GUAVA 中的 Convert 可以完成正向转化和逆向转化,继续修改我们 DTO 中转化的这段代码:

private static class UserInputDTOConvert implements DTOConvert<UserInputDTO,User> {
 @Override
 public User convert(UserInputDTO userInputDTO) {
 User user = new User();
 BeanUtils.copyProperties(userInputDTO,user);
 return user;
 }
}

修改后:

private static class UserInputDTOConvert extends Converter<UserInputDTO, User> {
 @Override
 protected User doForward(UserInputDTO userInputDTO) {
 User user = new User();
 BeanUtils.copyProperties(userInputDTO,user);
 return user;
 }
 @Override
 protected UserInputDTO doBackward(User user) {
 UserInputDTO userInputDTO = new UserInputDTO();
 BeanUtils.copyProperties(user,userInputDTO);
 return userInputDTO;
 }
 }

看了这部分代码以后,你可能会问,那逆向转化会有什么用呢?其实我们有很多小的业务需求中,入参和出参是一样的,那么我们变可以轻松的进行转化,我将上边所提到的 UserInputDTO 和 UserOutputDTO 都转成 UserDTO 展示给大家。

DTO:

public class UserDTO {
 private String username;
 private int age;
 public String getUsername() {
 return username;
 }
 public void setUsername(String username) {
 this.username = username;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }
 public User convertToUser(){
 UserDTOConvert userDTOConvert = new UserDTOConvert();
 User convert = userDTOConvert.convert(this);
 return convert;
 }
 public UserDTO convertFor(User user){
 UserDTOConvert userDTOConvert = new UserDTOConvert();
 UserDTO convert = userDTOConvert.reverse().convert(user);
 return convert;
 }
 private static class UserDTOConvert extends Converter<UserDTO, User> {
 @Override
 protected User doForward(UserDTO userDTO) {
 User user = new User();
 BeanUtils.copyProperties(userDTO,user);
 return user;
 }
 @Override
 protected UserDTO doBackward(User user) {
 UserDTO userDTO = new UserDTO();
 BeanUtils.copyProperties(user,userDTO);
 return userDTO;
 }
 }
}

API:

@PostMapping
 public UserDTO addUser(UserDTO userDTO){
 User user = userDTO.convertToUser();
 User saveResultUser = userService.addUser(user);
 UserDTO result = userDTO.convertFor(saveResultUser);
 return result;
 }

当然,上述只是表明了转化方向的正向或逆向,很多业务需求的出参和入参的 DTO 对象是不同的,那么你需要更明显的告诉程序:逆向是无法调用的:

private static class UserDTOConvert extends Converter<UserDTO, User> {
 @Override
 protected User doForward(UserDTO userDTO) {
 User user = new User();
 BeanUtils.copyProperties(userDTO,user);
 return user;
 }
 @Override
 protected UserDTO doBackward(User user) {
 throw new AssertionError("不支持逆向转化方法!");
 }
 }

看一下 doBackward 方法,直接抛出了一个断言异常,而不是业务异常,这段代码告诉代码的调用者,这个方法不是准你调用的,如果你调用,我就”断言”你调用错误了。

关于异常处理的更详细介绍,可以参考这篇文章:如何优雅的设计 Java 异常(
lrwinx.github.io/2016/04/28/…) ,应该可以帮你更好的理解异常。

bean 的验证

如果你认为我上边写的那个添加用户 API 写的已经非常完美了,那只能说明你还不是一个优秀的程序员。我们应该保证任何数据的入参到方法体内都是合法的。

为什么要验证

很多人会告诉我,如果这些 API 是提供给前端进行调用的,前端都会进行验证啊,你为什还要验证?

其实答案是这样的,我从不相信任何调用我 API 或者方法的人,比如前端验证失败了,或者某些人通过一些特殊的渠道(比如 Charles 进行抓包),直接将数据传入到我的 API,那我仍然进行正常的业务逻辑处理,那么就有可能产生脏数据!

“对于脏数据的产生一定是致命”,这句话希望大家牢记在心,再小的脏数据也有可能让你找几个通宵!

jsr 303验证

hibernate 提供的 jsr 303 实现,我觉得目前仍然是很优秀的,具体如何使用,我不想讲,因为谷歌上你可以搜索出很多答案!

再以上班的 API 实例进行说明,我们现在对 DTO 数据进行检查:

public class UserDTO {
 @NotNull
 private String username;
 @NotNull
 private int age;
 //其他代码略
}

API 验证:

@PostMapping
 public UserDTO addUser(@Valid UserDTO userDTO){
 User user = userDTO.convertToUser();
 User saveResultUser = userService.addUser(user);
 UserDTO result = userDTO.convertFor(saveResultUser);
 return result;
 }

我们需要将验证结果传给前端,这种异常应该转化为一个 api 异常(带有错误码的异常)。

@PostMapping
public UserDTO addUser(@Valid UserDTO userDTO, BindingResult bindingResult){
 checkDTOParams(bindingResult);
 User user = userDTO.convertToUser();
 User saveResultUser = userService.addUser(user);
 UserDTO result = userDTO.convertFor(saveResultUser);
 return result;
}
private void checkDTOParams(BindingResult bindingResult){
 if(bindingResult.hasErrors()){
 //throw new 带验证码的验证错误异常
 }
}

BindingResult 是 Spring MVC 验证 DTO 后的一个结果集,可以参考spring 官方文档(spring.io/)。

检查参数后,可以抛出一个“带验证码的验证错误异常”

具体可以参考这篇:很优秀的文章

http://lrwinx.github.io/2016/04/28/%E5%A6%82%E4%BD%95%E4%BC%98%E9%9B%85%E7%9A%84%E8%AE%BE%E8%AE%A1java%E5%BC%82%E5%B8%B8/

拥抱 lombok

上边的 DTO 代码,已经让我看的很累了,我相信读者也是一样,看到那么多的 Getter 和 Setter 方法,太烦躁了,那时候有什么方法可以简化这些呢。

请拥抱 lombok,它会帮助我们解决一些让我们很烦躁的问题

去掉 Setter 和 Getter

其实这个标题,我不太想说,因为网上太多,但是因为很多人告诉我,他们根本就不知道 lombok 的存在,所以为了让读者更好的学习,我愿意写这样一个例子:

@Setter
@Getter
public class UserDTO {
 @NotNull
 private String username;
 @NotNull
 private int age;
 public User convertToUser(){
 UserDTOConvert userDTOConvert = new UserDTOConvert();
 User convert = userDTOConvert.convert(this);
 return convert;
 }
 public UserDTO convertFor(User user){
 UserDTOConvert userDTOConvert = new UserDTOConvert();
 UserDTO convert = userDTOConvert.reverse().convert(user);
 return convert;
 }
 private static class UserDTOConvert extends Converter<UserDTO, User> {
 @Override
 protected User doForward(UserDTO userDTO) {
 User user = new User();
 BeanUtils.copyProperties(userDTO,user);
 return user;
 }
 @Override
 protected UserDTO doBackward(User user) {
 throw new AssertionError("不支持逆向转化方法!");
 }
 }
}

看到了吧,烦人的 Getter 和 Setter 方法已经去掉了。

但是上边的例子根本不足以体现 lombok 的强大。我希望写一些网上很难查到,或者很少人进行说明的 lombok 的使用以及在使用时程序语义上的说明。

比如:@Data,@AllArgsConstructor,@NoArgsConstructor..这些我就不进行一一说明了,请大家自行查询资料。

bean 中的链式风格

什么是链式风格?我来举个例子,看下面这个 Student 的 bean:

public class Student {
 private String name;
 private int age;
 public String getName() {
 return name;
 }
 public Student setName(String name) {
 this.name = name;
 return this;
 }
 public int getAge() {
 return age;
 }
 public Student setAge(int age) {
 return this;
 }
}

仔细看一下 set 方法,这样的设置便是 chain 的 style,调用的时候,可以这样使用:

Student student = new Student()
 .setAge(24)
 .setName("zs");

相信合理使用这样的链式代码,会更多的程序带来很好的可读性,那看一下如果使用 lombok 进行改善呢,请使用 @Accessors(chain = true),看如下代码:

@Accessors(chain = true)
@Setter
@Getter
public class Student {
 private String name;
 private int age;
}

这样就完成了一个对于 bean 来讲很友好的链式操作。

静态构造方法

静态构造方法的语义和简化程度真的高于直接去 new 一个对象。比如 new 一个 List 对象,过去的使用是这样的:

List<String> list = new ArrayList<>();

看一下 guava 中的创建方式:

List<String> list = Lists.newArrayList();

Lists 命名是一种约定(俗话说:约定优于配置),它是指 Lists 是 List 这个类的一个工具类,那么使用 List 的工具类去产生 List,这样的语义是不是要比直接 new 一个子类来的更直接一些呢,答案是肯定的,再比如如果有一个工具类叫做 Maps,那你是否想到了创建 Map 的方法呢:

HashMap<String, String> objectObjectHashMap = Maps.newHashMap();

好了,如果你理解了我说的语义,那么,你已经向成为 Java 程序员更近了一步了。

再回过头来看刚刚的 Student,很多时候,我们去写 Student 这个 bean 的时候,他会有一些必输字段,比如 Student 中的 name 字段,一般处理的方式是将 name 字段包装成一个构造方法,只有传入 name 这样的构造方法,才能创建一个 Student 对象。

接上上边的静态构造方法和必传参数的构造方法,使用 lombok 将更改成如下写法(@RequiredArgsConstructor 和 @NonNull):

@Accessors(chain = true)
@Setter
@Getter
@RequiredArgsConstructor(staticName = "ofName")
public class Student {
 @NonNull private String name;
 private int age;
}

测试代码:

Student student = Student.ofName("zs");

这样构建出的 bean 语义是否要比直接 new 一个含参的构造方法(包含 name 的构造方法)要好很多。

当然,看过很多源码以后,我想相信将静态构造方法 ofName 换成 of 会先的更加简洁:

@Accessors(chain = true)
@Setter
@Getter
@RequiredArgsConstructor(staticName = "of")
public class Student {
 @NonNull private String name;
 private int age;
}

测试代码:

Student student = Student.of("zs");

当然他仍然是支持链式调用的:

Student student = Student.of("zs").setAge(24);

这样来写代码,真的很简洁,并且可读性很强。

使用 builder

Builder 模式我不想再多解释了,读者可以看一下《Head First》(设计模式) 的建造者模式。

今天其实要说的是一种变种的 builder 模式,那就是构建 bean 的 builder 模式,其实主要的思想是带着大家一起看一下 lombok 给我们带来了什么。

看一下 Student 这个类的原始 builder 状态:

public class Student {
 private String name;
 private int age;
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }
 public static Builder builder(){
 return new Builder();
 }
 public static class Builder{
 private String name;
 private int age;
 public Builder name(String name){
 this.name = name;
 return this;
 }
 public Builder age(int age){
 this.age = age;
 return this;
 }
 public Student build(){
 Student student = new Student();
 student.setAge(age);
 student.setName(name);
 return student;
 }
 }
}

调用方式:

Student student = Student.builder().name("zs").age(24).build();

这样的 builder 代码,让我是在恶心难受,于是我打算用 lombok 重构这段代码:

@Builder
public class Student {
 private String name;
 private int age;
}

调用方式:

Student student = Student.builder().name("zs").age(24).build();

代理模式

正如我们所知的,在程序中调用 rest 接口是一个常见的行为动作,如果你和我一样使用过 spring 的 RestTemplate,我相信你会我和一样,对他抛出的非 http 状态码异常深恶痛绝。

所以我们考虑将 RestTemplate 最为底层包装器进行包装器模式的设计:

public abstract class FilterRestTemplate implements RestOperations {
 protected volatile RestTemplate restTemplate;
 protected FilterRestTemplate(RestTemplate restTemplate){
 this.restTemplate = restTemplate;
 }
 //实现RestOperations所有的接口
}

然后再由扩展类对 FilterRestTemplate 进行包装扩展:

public class ExtractRestTemplate extends FilterRestTemplate {
 private RestTemplate restTemplate;
 public ExtractRestTemplate(RestTemplate restTemplate) {
 super(restTemplate);
 this.restTemplate = restTemplate;
 }
 public <T> RestResponseDTO<T> postForEntityWithNoException(String url, Object request, Class<T> responseType, Object... uriVariables)
 throws RestClientException {
 RestResponseDTO<T> restResponseDTO = new RestResponseDTO<T>();
 ResponseEntity<T> tResponseEntity;
 try {
 tResponseEntity = restTemplate.postForEntity(url, request, responseType, uriVariables);
 restResponseDTO.setData(tResponseEntity.getBody());
 restResponseDTO.setMessage(tResponseEntity.getStatusCode().name());
 restResponseDTO.setStatusCode(tResponseEntity.getStatusCodeValue());
 }catch (Exception e){
 restResponseDTO.setStatusCode(RestResponseDTO.UNKNOWN_ERROR);
 restResponseDTO.setMessage(e.getMessage());
 restResponseDTO.setData(null);
 }
 return restResponseDTO;
 }
}

包装器 ExtractRestTemplate 很完美的更改了异常抛出的行为,让程序更具有容错性。在这里我们不考虑 ExtractRestTemplate 完成的功能,让我们把焦点放在 FilterRestTemplate 上,“实现 RestOperations 所有的接口”,这个操作绝对不是一时半会可以写完的,当时在重构之前我几乎写了半个小时,如下:

public abstract class FilterRestTemplate implements RestOperations {
 protected volatile RestTemplate restTemplate;
 protected FilterRestTemplate(RestTemplate restTemplate) {
 this.restTemplate = restTemplate;
 }
 @Override
 public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
 return restTemplate.getForObject(url,responseType,uriVariables);
 }
 @Override
 public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
 return restTemplate.getForObject(url,responseType,uriVariables);
 }
 @Override
 public <T> T getForObject(URI url, Class<T> responseType) throws RestClientException {
 return restTemplate.getForObject(url,responseType);
 }
 @Override
 public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
 return restTemplate.getForEntity(url,responseType,uriVariables);
 }
 //其他实现代码略。。。
}

我相信你看了以上代码,你会和我一样觉得恶心反胃,后来我用 lombok 提供的代理注解优化了我的代码(@Delegate):

@AllArgsConstructor
public abstract class FilterRestTemplate implements RestOperations {
 @Delegate
 protected volatile RestTemplate restTemplate;
}

这几行代码完全替代上述那些冗长的代码。

是不是很简洁,做一个拥抱 lombok 的程序员吧。

重构

需求案例

项目需求

项目开发阶段,有一个关于下单发货的需求:如果今天下午 3 点前进行下单,那么发货时间是明天,如果今天下午 3 点后进行下单,那么发货时间是后天,如果被确定的时间是周日,那么在此时间上再加 1 天为发货时间。

思考与重构

我相信这个需求看似很简单,无论怎么写都可以完成。

很多人可能看到这个需求,就动手开始写 Calendar 或 Date 进行计算,从而完成需求。

而我给的建议是,仔细考虑如何写代码,然后再去写,不是说所有的时间操作都用 Calendar 或 Date 去解决,一定要看场景。

对于时间的计算我们要考虑 joda-time 这种类似的成熟时间计算框架来写代码,它会让代码更加简洁和易读。

请读者先考虑这个需求如何用 Java 代码完成,或先写一个你觉得完成这个代码的思路,再来看我下边的代码,这样,你的收获会更多一些:

final DateTime DISTRIBUTION_TIME_SPLIT_TIME = new DateTime().withTime(15,0,0,0);
private Date calculateDistributionTimeByOrderCreateTime(Date orderCreateTime){
 DateTime orderCreateDateTime = new DateTime(orderCreateTime);
 Date tomorrow = orderCreateDateTime.plusDays(1).toDate();
 Date theDayAfterTomorrow = orderCreateDateTime.plusDays(2).toDate();
 return orderCreateDateTime.isAfter(DISTRIBUTION_TIME_SPLIT_TIME) ? wrapDistributionTime(theDayAfterTomorrow) : wrapDistributionTime(tomorrow);
}
private Date wrapDistributionTime(Date distributionTime){
 DateTime currentDistributionDateTime = new DateTime(distributionTime);
 DateTime plusOneDay = currentDistributionDateTime.plusDays(1);
 boolean isSunday = (DateTimeConstants.SUNDAY == currentDistributionDateTime.getDayOfWeek());
 return isSunday ? plusOneDay.toDate() : currentDistributionDateTime.toDate() ;
}

读这段代码的时候,你会发现,我将判断和有可能出现的不同结果都当做一个变量,最终做一个三目运算符的方式进行返回,这样的优雅和可读性显而易见,当然这样的代码不是一蹴而就的,我优化了 3 遍产生的以上代码。读者可根据自己的代码和我写的代码进行对比。

提高方法

如果你做了 3 年+的程序员,我相信像如上这样的需求,你很轻松就能完成,但是如果你想做一个会写 Java 的程序员,就好好的思考和重构代码吧。

写代码就如同写字一样,同样的字,大家都会写,但是写出来是否好看就不一定了。如果想把程序写好,就要不断的思考和重构,敢于尝试,敢于创新,不要因循守旧,一定要做一个优秀的 Java 程序员。

提高代码水平最好的方法就是有条理的重构!(注意:是有条理的重构)

设计模式

设计模式就是工具,而不是提现你是否是高水平程序员的一个指标。

我经常会看到某一个程序员兴奋的大喊,哪个程序哪个点我用到了设计模式,写的多么多么优秀,多么多么好。我仔细去翻阅的时候,却发现有很多是过度设计的。

业务驱动技术 or 技术驱动业务

业务驱动技术 or 技术驱动业务 ? 其实这是一个一直在争论的话题,但是很多人不这么认为,我觉得就是大家不愿意承认罢了。我来和大家大概分析一下作为一个 Java 程序员,我们应该如何判断自己所处于的位置.

业务驱动技术:如果你所在的项目是一个收益很小或者甚至没有收益的项目,请不要搞其他创新的东西,不要驱动业务要如何如何做,而是要熟知业务现在的痛点是什么?如何才能帮助业务盈利或者让项目更好,更顺利的进行。

技术驱动业务:如果你所在的项目是一个很牛的项目,比如淘宝这类的项目,我可以在满足业务需求的情况下,和业务沟通,使用什么样的技术能更好的帮助业务创造收益,比如说下单的时候要进队列,可能几分钟之后订单状态才能处理完成,但是会让用户有更流畅的体验,赚取更多的访问流量,那么我相信业务愿意被技术驱动,会同意订单的延迟问题,这样便是技术驱动业务。

我相信大部分人还都处于业务驱动技术的方向吧。

所以你既然不能驱动业务,那就请拥抱业务变化吧。

代码设计

一直在做 Java 后端的项目,经常会有一些变动,我相信大家也都遇到过。

比如当我们写一段代码的时候,我们考虑将需求映射成代码的状态模式,突然有一天,状态模式里边又添加了很多行为变化的东西,这时候你就挠头了,你硬生生的将状态模式中添加过多行为和变化。

慢慢的你会发现这些状态模式,其实更像是一簇算法,应该使用策略模式,这时你应该已经晕头转向了。

说了这么多,我的意思是,只要你觉得合理,就请将状态模式改为策略模式吧,所有的模式并不是凭空想象出来的,都是基于重构。

Java 编程中没有银弹,请拥抱业务变化,一直思考重构,你就有一个更好的代码设计!

你真的优秀吗?

真不好意思,我取了一个这么无聊的标题。

国外流行一种编程方式,叫做结对编程,我相信国内很多公司都没有这么做,我就不在讲述结对编程带来的好处了,其实就是一边 code review,一边互相提高的一个过程。既然做不到这个,那如何让自己活在自己的世界中不断提高呢?

“平时开发的时候,做出的代码总认为是正确的,而且写法是完美的。”,我相信这是大部分人的心声,还回到刚刚的问题,如何在自己的世界中不断提高呢?

答案就是:

  1. 多看成熟框架的源码
  2. 多回头看自己的代码
  3. 勤于重构

你真的优秀吗? 如果你每周都完成了学习源码,回头看自己代码,然后勤于重构,我认为你就真的很优秀了。

即使也许你只是刚刚入门,但是一直坚持,你就是一个真的会写java代码的程序员了。

技能

UML

不想多讨论 UML 相关的知识,但是我觉得你如果真的会写 Java,请先学会表达自己,UML 就是你说话的语言,做一名优秀的 Java 程序员,请至少学会这两种 UML 图:

  1. 类图
  2. 时序图

clean code

我认为保持代码的简洁和可读性是代码的最基本保证,如果有一天为了程序的效率而降低了这两点,我认为是可以谅解的,除此之外,没有任何理由可以让你任意挥霍你的代码。

  1. 读者可以看一下 Robert C. Martin 出版的《Clean Code》(代码整洁之道) 这本书
  2. 可以参考美团文章聊聊 clean code(tech.meituan.com/clean-code.…);
  3. 也可以看一下阿里的 Java 编码规范(yq.aliyun.com/articles/69…)。

无论如何,请保持你的代码的整洁。

Linux 基础命令

这点其实和会写 Java 没有关系,但是 Linux 很多时候确实承载运行 Java 的容器,请学好 Linux 的基础命令。

  1. 参考鸟哥的《Linux私房菜》

总结

Java 是一个大体系,今天讨论并未涉及框架和架构相关知识,只是讨论如何写好代码。

本文从写 Java 程序的小方面一直写到大方面,来阐述了如何才能写好 Java 程序,并告诉读者们如何才能提高自身的编码水平。

我希望看到这篇文章的各位都能做一个优秀的 Java 程序员

鸿蒙OS开机动画背后的秘密:从代码到视觉的完整解析(附源码分析) 本文深入解析了鸿蒙OS开机动画的系统级实现原理。从bootanimation服务的启动配置、与Render Service的协同,到基于VSync信号的帧率同步与绘制流水线,结合OpenHarmony源码进行了逐行解读。文章揭示了其事件驱动的优雅退出机制,并探讨了视频支持、多屏适配等高级特性与定制化可能,为开发者理解鸿蒙图形子系统提供了硬核技术视角。 阅读详情

相关推荐

磁感应强度B、磁场强度H、矢量磁位A的study

学完电磁场很久了但是对电磁场中磁感应强度B⃗\vec{B}B、磁场强度HHH、矢量磁位A⃗\vec{A}A,这几个变量所表征的含义一直很模糊,所以就总结了一下

sinat_42386289的博客 1万+

确定自己会写java了?

该文章主要是摘要一些大牛对java的理解 技术点 本文不是一个吹嘘的文章,不会讲很多高深的架构,相反,会讲解很多基础的问题和写法问题,如果读者自认为基础问题和写法问题都是不是问题,那请忽略这篇文章,节省出时间去做一些有意义的事情。 开发工具 不知道有多少”老”程序员还在使用 Eclipse,这些程序员们要不就是因循守旧,要不就是根本就不知道其他好的开发工具的存在,Eclipse 吃内存卡顿的现象以...

litao19920203的博客 334

【深度学习】肺结节分割项目实战二:分割肺实质

在后续训练模型的时候如果直接使用原始的肺部CT图像,其中的非肺区域会对训练造成干扰,因此我们需要提取分割肺实质。这一部分参考了kaggle上的教程。 从这张CT图像中可以看出扫描器以外的部分为黑色,背景和肺内部颜色较深,非肺组织和骨头颜色较浅。我们的目的是将肺部分割出来。由于肺部区域和其他部分对比明显,我们可以设置一个合适的阈值对图像中的区域进行隔离。 import argparse import os import numpy as np from medpy.filter.smoothing imp

weixin_42182906的博客 7242

你见过哪些目瞪口呆的 Java 代码优化技巧?

若有收获,请记得分享和转发哦前言我之前写过两篇关于优化相关文章,发表之后,在全网受到广大网友的好评。阅读量和点赞率都很高,说明了这类文章的价值。今天接着优化这个话题,我们一起聊聊Java中代码优化的30个小技巧,希望会对你有所帮助。1.用String.format拼接字符串不知道你有没有拼接过字符串,特别是那种有多个参数,字符串比较长的情况。比如现在有个需求:要用get请求调用第三方接口,url后...

IT技术精选文摘 283

从DCI-P3到sRGB:跨媒体色彩转换的矩阵奥秘与实践

本文深入解析从DCI-P3到sRGB的色彩空间转换技术,揭示矩阵运算的核心原理与实践技巧。通过实战案例展示如何正确处理白点差异、伽马曲线转换等关键环节,帮助影视从业者解决跨媒体色彩匹配问题,确保作品在不同设备上呈现一致的视觉效果。

weixin_28709649的博客 330

从“破解”到应用:三菱数控系统M80协议逆向分析与工业数据采集网关搭建指南

本文深入解析三菱数控系统M80协议的逆向分析方法与工业数据采集网关搭建技术。通过TCP协议实现跨平台通信,详细介绍了M80协议的数据包结构、多语言实现方案(C#、Java、C/C++)以及Linux数据采集网关的架构设计与容器化部署。为工业自动化领域的开发者提供从协议分析到企业级数据采集落地的完整解决方案。

weixin_29228781的博客 1214

分享Java代码中一些常见的炫技代码写法,请各位点赞、收藏

这种能力可以用于编写更灵活和动态的代码,但也需要小心处理,因为它可能会导致性能和安全性方面的问题。请记住,炫技的代码写法应适度使用,权衡其简洁性和可读性,并确保符合项目的需求和团队的编码规范。使用流式操作可以对集合进行各种处理,如过滤、映射和收集。通过使用方法引用,可以将现有的方法作为参数传递给函数式接口,简化代码并提高可读性。通过使用链式调用的构造器模式,可以更清晰地设置对象的属性,并避免过多的构造器重载。使用流式处理可以更简洁地表达对集合中元素的条件判断,如检查是否存在满足条件的元素。

算命de博客 1420

第十篇|网络子系统 ②——无损以太网、PFC/ECN、DCQCN 与拥塞可视化

网络部分了解了解

qq_37535542的博客 1877

恕我直言,在座的各位根本不会写 Java!

学了这么多年的 Java,你写的代码如何?导语自 2013 年毕业后,今年已经是我工作的第 4 个年头了,总在做 Java 相关的工作,终于有时间坐下来,写一篇关于 Ja...

优快云资讯 3571

YOLOv10改进 | 主干篇 | 引入FasterNet:Run, Don‘t Walk,追求更快的神经网络

本文引入了 FasterNet 作为 YOLOv10 的主干网络。通过 PConv 算子,我们有效降低了模型的计算冗余。对于追求极致推理速度的场景(如树莓派、Jetson Nano),该改进方案极具价值。建议在训练时配合混合精度训练 (AMP)进一步加速。

weixin_51988935的博客 605

气象大模型光伏功率预测中的应用:从短期,超短期,中长期的实现与开源代码详解

本文详细介绍了基于大模型的光伏功率预测方法,涵盖超短期(15分钟-1小时)、短期(1-6小时)和中长期(1天-1周)预测。文章首先讨论了数据准备与预处理,包括历史功率、气象、天文和电站特性数据的收集与特征工程。随后,针对不同预测需求,提出了多种深度学习模型:超短期预测采用1DCNN-LSTM混合模型,短期预测使用Transformer模型,中长期预测则通过多尺度特征提取模型和概率预测方法处理不确定性。文章还提供了模型训练、评估、部署和优化的完整流程,并开源了代码实现。未来研究方向包括结合数值天气预报、开发时

专注AI大模型,软件混淆,授权 1591

【Java】那些我认为牛逼的代码(1)

Javaassist 就是一个用来处理 Java 字节码的类库。它可以在一个已经编译好的类中添加新的方法,或者是修改已有的方法,并且不需要对字节码方面有深入的了解。同时也可以去生成一个新的类对象(toClass),通过完全手动的方式。

qq_63691275的博客 1343

【WorkBuddy专栏43】如何利用WorkBuddy开发一个PC网站(上)——环境选型、设计编码到部署上线

【WorkBuddy专栏43】如何利用WorkBuddy开发一个PC网站(上)——环境选型、设计编码到部署上线

AI人人懂 2281

你见过哪些目瞪口呆的 Java 代码技巧?

文章来源:https://c1n.cn/kufbz目录导语开发工具重构技能总结导语自从毕业后,今年已经是我工作的第 8 个年头了,我甚至都快忘记了到底是哪年毕业的。从出来,本人一直在做 Java 相关的工作,现在终于有时间坐下来,写一篇关于 Java 写法的一篇文章,来探讨一下如果你真的是一个 Java 程序员,那你真的会写 Java 吗?笔者是一个务实的程序员,故本文绝...

石杉的架构笔记 316

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

细思极恐!你见过哪些目瞪口呆的 Java 代码技巧?

点击上方“Java精选”,选择“设为星标”别问别人为什么,多问自己凭什么!下方有惊喜留言必回,有问必答!每一天进步一点点,是成功的开始...技术点开发工具BeanBean 的验证拥抱 lombok重构设计模式技能总结技术点本文不是一个吹嘘的文章,不会讲很多高深的架构,相反,会讲解很多基础的问题和写法问题,如果读者自认为基础问题和写法问题都是不是问题,那请忽略这篇文章,节省...

Java精选 681

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

那些让我拍案叫绝的Java代码技巧(附避坑指南)

快来告诉大家你的血泪史,帮助其他Java开发者避坑!Java 8+ 的黑科技,接口居然可以带方法体!: 你见过最惊艳的Java代码是什么?: 欢迎在评论区分享你的"哇塞"时刻!: 这些技巧中有没有你踩过的坑?大小固定,增删操作都会报错。,新增方法不影响已有实现。,有专门表示无穷大的方式。(Arrays内部类)在构造时执行put操作。,不强制实现所有方法。创建HashMap的。

iku_n的博客 315

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

聊聊Java中代码优化的30个小技巧

​ 我之前写过两篇关于优化相关的问题:《聊聊sql优化的15个小技巧》和《聊聊接口性能优化的11个小技巧》,发表之后,在全网受到广大网友的好评。阅读量和点赞率都很高,说明了这类文章的价值。 今天接着优化这个话题,我们一起聊聊Java中代码优化的30个小技巧,希望会对你有所帮助。 ​...

java_beautiful的博客 808

【python代码小技巧】职场大佬写的代码,堪称“满分作文”

python编码小技巧之——整齐规范的命名,恰到好处的注释,合理的封装类,封装钩子等等

向上生长的程序媛的博客 1219

有哪些算法惊艳到了你?

举个例子,你有一堆人名,想快速查找到“老韩”,你可以用哈希算法把每个人名转成一个数字,比如“老韩”映射到123,然后把数据存储在编号123的位置。惊艳的是,它不是硬算所有可能性,而是用“贪心”的思路,逐步缩小范围,效率非常高。动态规划(Dynamic Programming,简称DP)这个名字,听起来就很高端,但它的核心思想其实很朴素:“把复杂问题拆解成简单问题,用之前的结果解决后续的问题。哈希算法的核心逻辑是:通过一个函数,把数据映射到一个固定范围内的值上,存储起来,查找的时候直接用这个值定位到目标。

m0_61562916的博客 1694

java也惊艳_JavaSwing也惊艳之二:环环相套

一、序言关于“Java做不好桌面”的争论已经由来已久。虽然Swing和Java2D已经有超过十年的历史,也有JIDE、JGoodies、TWaver等不少开源Swing组件,但是用Java做桌面程序仍然不是一件轻松的事。本《Java也惊艳》系列文章,就是想通过一些简单生动的例子,和大家一起认识Java、探索Swing。其实你只需要多一点创意、多一点耐心,你的Java程序也可以“惊艳”!本文就带您一...

weixin_34817716的博客 141

有趣短小的java代码_Java8 中有趣酷炫的小技巧

执行注释大多数开发人员认为注释永远不会在程序中执行,并用于帮助代码理解。但是,它们却可以被执行:程序输出:wmyskxz is awesome!Java 允许使用 Unicode 字符而不进行编码。这里的 Unicode 字符 被 Java 编译器解析为新行,因此可以理解为该 Unicode 字符后面出现的语句会在下一行被执行。双括号初始化集合在 Java 中,Set/ List/ Map...

weixin_27419879的博客 1291

如何用BeautyEye打造惊艳Java界面:初学者的终极美化指南

BeautyEye是一款强大的Java Swing跨平台外观组件库,能帮助开发者轻松构建现代、美观且专业的桌面应用界面。无论是新手还是有经验的开发者,都能通过它快速提升Java应用的视觉吸引力,让你的程序在众多软件中脱颖而出。 ## ???? 为什么选择BeautyEye?三大核心优势解析 ### 1. 跨平台一致性设计,一处美化处处适用 BeautyEye最大的亮点在于其出色的跨平台兼容性,无论...

gitblog_00359的博客 1040

Java完全自学手册,你要悄悄努力,然后惊艳所有人

路线在手不迷路

公号:一条coding 2万+

2008年终盘点-十大惊艳Java应用程序

首页空间新闻论坛群组BLOG文档下载读书TAG网摘视频开源培训书店程序员人才项目交易数据库logo标签 JAVA已登录:luanfengxia您的位置:优快云 首页−>新闻频道−>正文 2008年终盘点-十大惊艳Java应用程序     Java

luanfengxia的专栏 1192

【Java】反射调用与面向对象结合使用产生的惊艳

缘起我在看Spring的源码时,发现了一个隐藏的问题,就是父类方法(Method)在子类实例上的反射(Reflect)调用。初次看到,感觉有些奇特,因为父类方法可能是抽象的或私有的,但我没有去怀疑什么,这可是Spring的源码,肯定不会有错。不过我去做了测试,发现确实是正确的,那一瞬间竟然给我了一丝的惊艳。这其实是面向对象(继承与重写,即多态)和反射结合的产物。下面先来看测试,最后再进行总结。友情提示:测试内容较多,不过还是值得一看。具体方法的继承与重写先准备一个父类,有三个方法,分别是publ...

ElegantHedgehog的博客 164

Java 中的5个代码性能提升技巧,最高提升近10倍

这篇文章介绍几个 Java 开发中可以进行性能优化的小技巧,虽然大多数情况下极致优化代码是没有必要的,但是作为一名技术开发者,我们还是想追求代码的更小、更快,更强。如果哪天你发现程序的运行速度不尽人意,可能会想到这篇文章。 提示:我们不应该为了优化而优化,这有时会增加代码的复杂度。 这篇文章中的代码都在以下环境中进行性能测试。 JMH version: 1.33(Java 基准测试框架) VM version: JDK 17, OpenJDK 64-Bit Server VM, 17

m0_67322837的博客 316
上一篇: SpringBoot2.X与redis Lettuce集成踩坑
下一篇: 微服务MySQL分库分表数据到MongoDB同步方案
Java佳佳
博客等级 码龄4年 216粉丝 286原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值