Java 链式编程 和 lombok 实现链式编程

最新推荐文章于 2024-08-17 16:16:14 发布
最新推荐文章于 2024-08-17 16:16:14 发布
阅读量4.1w 收藏 66
点赞数 25
分类专栏： Java基础
原文链接：www.baidu.com
版权

文章目录

一、什么是链式编程

1、链式编程定义

链式编程的原理就是返回一个this对象，就是返回本身，达到链式效果。

我们经常用的 StringBuffer 就是 实现了链式的写法。

StringBuffer builder = new StringBuffer();
builder.append("blake").append("bob").append("alice").append("linese").append("eve");

是不是很方便呢!

怎么实现呢，其实就是在设置的 返回当前的对象 。

2、查看 jdk 中 StringBuffer 源码：

public final class StringBuilder  extends ... {

    // ...省略代码...
    
    public StringBuilder append(String str) {
        super.append(str);
        return this;             // 返回this
    }
  
    private StringBuilder append(StringBuilder sb) {
        if (sb == null)
            return append("null");
        int len = sb.length();
        int newcount = count + len;
        if (newcount > value.length)
            expandCapacity(newcount);
        sb.getChars(0, len, value, count);
        count = newcount;
        return this;           // 返回this
    }
  
    public StringBuilder append(StringBuffer sb) {
        super.append(sb);
        return this;			// 返回this
    }
 
    public StringBuilder delete(int start, int end) {
        super.delete(start, end);
        return this;			// 返回this
    }
 
    public StringBuilder deleteCharAt(int index) {
        super.deleteCharAt(index);
        return this;			// 返回this
    }
  
    public StringBuilder replace(int start, int end, String str) {
        super.replace(start, end, str);
        return this;			// 返回this
    }   
    
    public StringBuilder insert(int offset, String str) {
        super.insert(offset, str);
        return this;			// 返回this
    }
  
    public int indexOf(String str) {
        return indexOf(str, 0);			// 返回this
    }   
   
    public int lastIndexOf(String str) {
        return lastIndexOf(str, count);		// 返回this
    }
   
    public StringBuilder reverse() {
        super.reverse();
        return this;						// 返回this
    }

    public String toString() {      
        return new String(value, 0, count);			// 返回this
    }
}

3、按照上面的方法写一个例子:

public class StudentBean {
	private String name;
	private int age;

	public String getName() {
		return name;
	}

	public StudentBean setName(String name) {
		this.name = name;
		return this;		// 返回this
	}

	public int getAge() {
		return age;
	}

	public StudentBean setAge(int age) {
		this.age = age;
		return this;		// 返回this
	}
}

测试：

public class Main {

	public static void main(String[] args) {
		
		StudentBean studentBean = new StudentBean().setAge(22).setName("ly");
		System.out.println(studentBean.getAge());
		System.out.println(studentBean.getName());
	}
}

二、 lombok 链式编程

lombok 能通过注解的方式，在编译时自动为属性生成构造器、getter/setter、equals、hashcode、toString方法。

2.1、依赖

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

2.2、lombok 实现静态的链式编程

我们把这个 bean 改成 lombok 实现只需要加上一个 @Accessors(chain = true) 即可。

import lombok.*;
import lombok.experimental.Accessors;

@Accessors(chain = true)
@Data
public class StudentBean {
	private String name;	
	private int age;
	
}

这样代码简洁多了 ，而且实现了链式编程。
在这里插入图片描述

测试代码与上面的代码完全一样。

三、静态的链式编程

静态的链式编程 比 普通的链式编程 的好处：

  • 创建对象更简洁；
  • 可以在静态方法、静态代码块等中使用；
  • 对于必输字段，可以强制要求。

对比：

特点静态的链式编程普通的链式编程
创建对象更简洁对象.静态方法()new 对象()
可以在静态方法、静态代码块等中使用
对于必输字段，可以强制要求。对象.静态方法(param)if( xxx ){ ...}

3.1、lombok 实现静态的链式编程

比如，创建 StudentBean 对象时，有时会要求一些必输字段，比如name字段必须有值。

1）如果自己编写代码实现静态的链式编程。

代码如下：

import lombok.NonNull;

public class StudentBean {
 
	private String name;  
	private int age;
	
	
	private StudentBean(String name) {   //默认构造方法置为 private
	  	this.name = name;
	}
	
	public static StudentBean getInstance(String name) {  //唯一的 public 构造方法，name 不能为空
	 	if (name == null)
	    	throw new NullPointerException("name is not null"); 
	  	return new StudentBean(name);
	}  
	
	//------------  getter/setter  --------------
	public StudentBean setName(String name) { 
	  	this.name = name;
	  	return this;   // 返回this
	}
	
	public StudentBean setAge(int age) {
	 	this.age = age;
	  	return this;   // 返回this
	}  
	
	public String getName() {
	  	return this.name;
	} 
	
	public int getAge() {
	  	return this.age;
	}  
	
	public String toString() {
	  	return "StudentBean(name=" + getName() + ", age=" + getAge() + ")";
	}
}

上面是自己编写静态的链式编程。 如果使用 lombok 注解，则代码更加简洁。

2） 使用 lombok 注解 实现静态的链式编程

代码如下：

import lombok.*;
import lombok.experimental.Accessors;

@Accessors(chain = true)
@Data
@RequiredArgsConstructor(staticName = "getInstance")   //指定构造方法 
public class StudentBean {

	@NonNull
	private String name;
	
	private int age;
}

3） 探究 lombok 注解的原理

@RequiredArgsConstructor 究竟做了什么，我们通过 StudentBean.class 反编译（整理后）可以看到 ：

import lombok.NonNull;

public class StudentBean {

	  @NonNull
	  private String name;  
	  private int age;
	  
	   // 默认构造方法置为 private
	  private StudentBean(@NonNull String name) { 
		    if (name == null)
		      	throw new NullPointerException("name"); 
		    this.name = name;
	  }
	  
	   //唯一的 public 构造方法，name 不能为空
	  public static StudentBean getInstance(@NonNull String name) { 
	    	return new StudentBean(name);
	  }
	  	

	  //------------  getter/setter  --------------
	   public StudentBean setName(@NonNull String name) {
		   if (name == null)
		      throw new NullPointerException("name"); 
		   this.name = name;
		   return this;         // 返回this
	  }  
	  
	  public StudentBean setAge(int age) {
		  this.age = age;
		  return this;         // 返回this
	  }
	  
	  @NonNull
	  public String getName() {
	   	 return this.name;
	  }
	  
	  public int getAge() {
	  	  return this.age;
	  }

	 public String toString() {
	    return "StudentBean(name=" + getName() + ", age=" + getAge() + ")";
	 }

  	 // -- 省略 equals，canEqual ，hashCode--- 	
}
  • 默认构造方法置为 private ；
  • 唯一的、指定为public的 getInstance 构造方法，要求 name 不能为空。

4）测试方法：

public class Main {	
	public static void main(String[] args) {		
		StudentBean studentBean = StudentBean.getInstance("zhangsan").setAge(22);
		System.out.println(studentBean.getAge());
		System.out.println(studentBean.getName());
	}
}

这样不仅实现了链式编程，还实现了静态创建。

四、builder模式的链式Bean

4.1、自定义 builder模式的链式Bean

build模式实现原理为在bean里面创建一个 静态builder方法 和一个 静态内部Builder类 ，通过调用静态builder方法来创建 Builder类，然后通过 builder类 中的 build方法直接创建一个Bean，具体如下：

public class StudentBean {
	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 StudentBean build() {
			StudentBean studentBean = new StudentBean();
			studentBean.setName(name);
			studentBean.setAge(age);
			return studentBean;
		}
	}
}

测试方法：

StudentBean studentBean = StudentBean.builder().name("zhangsan").age(11).build();

4.2、lombok 实现 builder模式的链式bean

这样就实现了一个builder模式的链式bean。其实用lombok就一个注解的事情，调用与上面同样

import lombok.*;

@Builder
@Data
public class StudentBean {
	private String name;
	
	private int age;
}
猎人在吃肉
关注
专栏目录
使用lombok 实现链式编程
weixin_42327945的博客
05-27 3783
实体类： import lombok.*; import lombok.experimental.Accessors; //@Accessors(chain = true) setter类型的链式编程 @Getter @Setter //使用@bulider时，必须添加无参，全参构造方法，否则转json报错 @Builder//使用@bulider时，使用className.bulider...
Java的链式编程（支持lombok）
qq_45068781的博客
11-27 1953
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 前言：链式编程可以更快，更简洁的给对象赋值 链式编程需要在属性Getter、Setter时，重写Setter的方法 作用是给属性赋值后，返回类本身，这样就可以接着对属性赋值了 这样我们就能一直对这个类的属性进行赋值 lombok实现链式编程 我们只需要在类名上方加入@Accessors(chain = true)，就可以实现链式编程 前言 提示：这里可以添加本文要记录的大概内...
提升开发效率,Lombok的链式编程和构建模式
暗武逢天的博客
07-30 2744
Lombok是一个Java库，它通过注解来减少Java代码的冗长和重复。使用Lombok可以简化Java类的编写，减少样板代码，提高代码的可读性和可维护性。
@Accessors(chain = true) 注解解释
最新发布
lhlhh_aichi的博客
08-17 494
是 Lombok 库中的一个注解，用于简化 Java 类中 getter 和 setter 方法的调用方式。Lombok 是一个 Java 库，它可以自动为你的类生成一些常见的、容易重复的代码，比如构造器、getter 和 setter 方法等。
lombok 实现链式编程
qq_38229543的博客
11-23 1901
一、什么是链式编程 1、链式编程定义 链式编程的原理就是返回一个this对象，就是返回本身，达到链式效果。 我们经常用的 StringBuffer 就是 实现了链式的写法。 StringBuffer builder = new StringBuffer(); builder.append("blake").append("bob").append("alice").append("linese").append("eve"); 是不是很方便呢! 怎么实现呢，其实就是在设置的 返回当前的对象 。
java链式编程/级联式编程
ice-wee的专栏
07-27 3461
链式编程，也叫级联式编程，调用对象的函数时返回一个this对象指向对象本身，达到链式效果，可以级联调用。 链式编程： 通过高阶函数以点为连接将多个函数连接在一起完成参数传递和复杂的操作！通俗的说是通过点号(.)链接在一起成为一句代码。 链式编程的优点是：编程性强、可读性强、代码简洁。 举例： StringBuilder builder = new StringBuilder(96); builder.append("select id, name from ") .append(T_USE..
java---什么是链式编程
m0_48805880的博客
12-09 2553
在我们编写代码过程中，一定听说过许多编程说法： 如：大家熟悉的面向对象编程、面向切面编程、以及函数式编程、范式编程等等。 同时还有链式编程，接下来我们来聊一下链式编程 普通： 1.维护性强； 2.对方法返回的类型无要求； 3.对程序员的业务要求适中； 链式; 1.编程性强； 2.可读性强； 3.代码更简洁； 4.对程序员的业务能力要求高； 5.不太利于代码调...
Java必备——Java 链式编程 和 lombok 实现链式编程
悦来阅美好_IT
03-24 822
目录 一、什么是链式编程 1、链式编程定义 2、jdk 中 StringBuffer 源码： 3、按照上面的方法写一个例子: 二、lombok链式编程 2.1、依赖 2.2、lombok实现静态的链式编程 三、静态的链式编程 3.1、lombok实现静态的链式编程 四、builder模式的链式Bean 4.1、自定义 builder模式的链式Bean 一、什么是链式编程 1、链式编程定义 链式编程的原理就是返回一个this对象，就是返回本身，达到链式效果。 我们经常...
简单使用lombok 链式编程
DaDaguai001的博客
07-04 1024
使用条件 一，导包 <!--只是用来下载一个jar--> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.12</version> <scope>provided</scope>
JAVA 链式编程和建造者模式的使用(lombok的使用)
qq_43471945的博客
10-24 1159
java链式编程与建造者模式融合使用
Lombok常用注解
Shawn的个人博客
10-23 781
1、Lombok简介 Lombok是一个可以通过简单的注解形式来帮助我们简化消除一些必须有但显得很臃肿的Java代码的工具，通过使用对应的注解，可以在编译源码的时候生成对应的方法。 官方地址：https://projectlombok.org/ github地址：https://github.com/rzwitserloot/lombok 2、Maven引入 除了引入maven，还需要安装Lombok插件 <dependency> <groupId>org.project
lombok常用注解
搬砖农民工的博客
07-19 2283
Lombok是一个Java库，它通过注解的方式来简化Java代码的编写。以下是Lombok库中常用的注解： @Getter：自动生成getter方法。 @Setter：自动生成setter方法。 @ToString：自动生成toString方法。 @EqualsAndHashCode：自动生成equals和hashCode方法。 @NoArgsConstructor：自动生成无参构造方法。 @AllArgsConstructor：自动生成全参构造方法。 @Data：自动生成getter、se
java 链式写法_JAVA中实现链式操作（方法链）的简单例子
weixin_35128928的博客
01-17 955
在使用jQuery时候，我们经常会看到或者使用到方法链，例如：$("#p1").css("color","red").slideUp(2000).slideDown(2000);这段代码的意思是选择器选择id为p1的html标签，颜色变红，之后slideup，再slidedown。自然是可以将这几个方法分开写，但是不分开的话不仅有很好的易读性，代码量也会有减少，那么何乐而不为？这种调用函数的方式在...
Lombok链式调用，子类对象set父类属性，返回父类对象
ql_7256的博客
09-13 8613
前言 lombok相信大家都用过，没用过肯定也不会点进来，一直用着都很舒服。今但是天在码代码时，碰到了一个问题，卡了半天。问题是这样的：Lombok链式调用父类中的set属性时，返回的居然是一个父类对象，紧靠文字描述，可能比较抽象，代码如下： 子类实体 父类实体 其实就是实体间的继承，把公共的字段抽取出来，具体的实体继承。我这里的JcZyyhzh继承了BaseCompanyIdEntity，BaseCompanyIdEntity其实还继承了BaseIdEntity，因为和我们今天主题扯不上关系，就没贴出
lombok链式编程
chaochao2113的博客
09-08 2311
lombok链式编程 lombok能通过注解的方式，在编译时自动为属性生成构造器，getter/setter、equals、hashcode、toString方法。 1.添加依赖 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.16.14</version> <scope&g
lombok启动链式编程
06-07
Lombok可以通过注解来简化Java代码的编写，其中包括链式编程。使用Lombok的@Accessors注解可以启用链式编程，该注解有一个fluent属性，默认值为false，将其设置为true即可启用链式编程。例如： ``` import lombok.Data; import lombok.experimental.Accessors; @Data @Accessors(chain = true) public class Person { private String name; private int age; } // 使用 Person person = new Person() .setName("Tom") .setAge(20); ``` 在上面的示例中，通过@Data注解自动生成了getter和setter方法，通过@Accessors注解的chain属性启用了链式编程，使得可以在一行代码中设置对象的多个属性。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值