修改 eclipse 默认的 toString 模板, 自动对敏感字段进行 *** 处理

最新推荐文章于 2022-11-07 10:43:36 发布
最新推荐文章于 2022-11-07 10:43:36 发布
阅读量6.1k 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dyccsxg/article/details/51638984
版权
本文介绍了如何修改Eclipse的源码，以实现自定义toString方法模板，包括选择StringBuilder/StringBuffer，每字段占一行，并自动对敏感字段进行***处理。涉及到的文件包括ToStringTemplateParser、ToStringGenerationSettings和StringBuilderGenerator。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

简介：
  eclipse 默认可以生成 toString 方法, 但是自动生成的代码有时候满足不了实际要求, 这里演示一下通过修改 eclipse 源码的方式来改变自动生成的 toString 方法.

1. 目标
1.1 将默认的 toString 模板修改为
  {${member.name()}=${member.value}, ${otherMembers}}
1.2 Code style 默认选中 StringBuilder/StringBuffer
1.3 toString 方法中每个字段占一行
1.4 toString 方法中自动对敏感字段进行 *** 处理
# 修改后截图如下：


2. 依赖 jar
eclipse_home\plugins\com.ibm.icu_50.1.1.v201304230130.jar
eclipse_home\plugins\org.eclipse.core.commands_3.6.100.v20130515-1857.jar
eclipse_home\plugins\org.eclipse.core.resources_3.8.101.v20130717-0806.jar
eclipse_home\plugins\org.eclipse.core.runtime_3.9.100.v20131218-1515.jar
eclipse_home\plugins\org.eclipse.equinox.common_3.6.200.v20130402-1505.jar
eclipse_home\plugins\org.eclipse.jdt.core_3.9.2.v20140114-1555.jar
eclipse_home\plugins\org.eclipse.jdt.ui_3.9.2.v20131106-1600.jar
eclipse_home\plugins\org.eclipse.jface_3.9.1.v20130725-1141.jar
eclipse_home\plugins\org.eclipse.swt.win32.win32.x86_3.102.1.v20140206-1358.jar
eclipse_home\plugins\org.eclipse.ui.workbench_3.105.2.v20140211-1711.jar


3. download eclipse source code
  http://archive.eclipse.org/eclipse/downloads/
  
4. 需要修改的文件
4.1 修改 toString 的默认模板
   org.eclipse.jdt.internal.corext.codemanipulation.tostringgeneration.ToStringTemplateParser
   org.eclipse.jdt.internal.ui.dialogs.GenerateToStringDialog
   # GenerateToStringDialog 文件内容不需要修改, 只需要重新编译一下
   
4.2 Code style 默认选中 StringBuilder/StringBuffer
   org.eclipse.jdt.internal.corext.codemanipulation.tostringgeneration.ToStringGenerationSettings
   
4.3 toString 方法中自动对敏感字段进行 *** 处理
   org.eclipse.jdt.internal.corext.codemanipulation.tostringgeneration.StringBuilderGenerator 

/*******************************************************************************
 * Copyright (c) 2008, 2011 Mateusz Matela and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Mateusz Matela <mateusz.matela@gmail.com> - [code manipulation] [dcr] toString() builder wizard - https://bugs.eclipse.org/bugs/show_bug.cgi?id=26070
 *******************************************************************************/
package org.eclipse.jdt.internal.corext.codemanipulation.tostringgeneration;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.NamingConventions;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.IfStatement;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.ReturnStatement;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.StringLiteral;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
import org.eclipse.jdt.core.dom.InfixExpression.Operator;


/**
 * <p>
 * Implementation of <code>AbstractToStringGenerator</code> that creates <code>toString()</code>
 * method using <code>StringBuilder</code> (or <code>StringBuffer</code> for old versions of JDK)
 * </p>
 * <p>
 * Generated methods look like this:
 * 
 * <pre>
 * public String toString() {
 * 	StringBuilder builder= new StringBuilder();
 * 	builder.append("FooClass( field1=");
 * 	builder.append(field1);
 * 	builder.append(", field2=");
 * 	builder.append(field2);
 * 	builder.append(" )");
 * 	return builder.toString();
 * }
 * </pre>
 * 
 * </p>
 * 
 * @since 3.5
 */
public class StringBuilderGenerator extends AbstractToStringGenerator {
	protected StringBuffer fBuffer;

	protected String fBuilderVariableName;

	protected final String APPEND_METHOD_NAME= "append"; //$NON-NLS-1$

	protected void flushBuffer(Block target) {
		if (fBuffer.length() > 0) {
			StringLiteral literal= fAst.newStringLiteral();
			literal.setLiteralValue(fBuffer.toString());
			if (target == null)
				target= toStringMethod.getBody();
			target.statements().add(fAst.newExpressionStatement(createMethodInvocation(fBuilderVariableName, APPEND_METHOD_NAME, literal)));
			fBuffer.setLength(0);
		}
	}

	@Override
	protected void initialize() {
		super.initialize();
		fBuilderVariableName= createNameSuggestion(getContext().is50orHigher() ? "sb" : "sb", NamingConventions.VK_LOCAL); //$NON-NLS-1$ //$NON-NLS-2$
		fBuffer= new StringBuffer();
		VariableDeclarationFragment fragment= fAst.newVariableDeclarationFragment();
		fragment.setName(fAst.newSimpleName(fBuilderVariableName));
		ClassInstanceCreation classInstance= fAst.newClassInstanceCreation();
		Name typeName= addImport(getContext().is50orHigher() ? "java.lang.StringBuilder" : "java.lang.StringBuffer"); //$NON-NLS-1$ //$NON-NLS-2$
		classInstance.setType(fAst.newSimpleType(typeName));
		fragment.setInitializer(classInstance);
		VariableDeclarationStatement vStatement= fAst.newVariableDeclarationStatement(fragment);
		vStatement.setType(fAst.newSimpleType((Name)ASTNode.copySubtree(fAst, typeName)));
		toStringMethod.getBody().statements().add(vStatement);
	}

	@Override
	protected void complete() throws CoreException {
		flushBuffer(null);
		super.complete();
		ReturnStatement rStatement= fAst.newReturnStatement();
		rStatement.setExpression(createMethodInvocation(fBuilderVariableName, "toString", null)); //$NON-NLS-1$
		toStringMethod.getBody().statements().add(rStatement);
	}

	protected void addElement(Object element, Block block) {
		if (element instanceof String)
			fBuffer.append((String)element);
		if (element instanceof Expression) {
			flushBuffer(block);
			block.statements().add(fAst.newExpressionStatement(createMethodInvocation(fBuilderVariableName, APPEND_METHOD_NAME, (Expression)element)));
		}
	}

	@Override
	protected void addMemberCheckNull(Object member, boolean addSeparator) {
		IfStatement ifStatement= fAst.newIfStatement();
		ifStatement.setExpression(createInfixExpression(createMemberAccessExpression(member, true, true), Operator.NOT_EQUALS, fAst.newNullLiteral()));
		Block thenBlock= fAst.newBlock();
		flushBuffer(null);
		String[] arrayString= getContext().getTemplateParser().getBody();
		for (int i= 0; i < arrayString.length; i++) {
			addElement(processElement(arrayString[i], member), thenBlock);
		}
		if (addSeparator)
			addElement(getContext().getTemplateParser().getSeparator(), thenBlock);
		flushBuffer(thenBlock);

		if (thenBlock.statements().size() == 1 && !getContext().isForceBlocks()) {
			ifStatement.setThenStatement((Statement)ASTNode.copySubtree(fAst, (ASTNode)thenBlock.statements().get(0)));
		} else {
			ifStatement.setThenStatement(thenBlock);
		}
		toStringMethod.getBody().statements().add(ifStatement);
	}

	@Override
	protected void addElement(Object element) {
		addElement(element, toStringMethod.getBody());
	}
	
     以下为新添加的内容  //
    /**
     * 添加成员信息
     */
    @SuppressWarnings("unchecked")
    protected void addMember(Object member, boolean addSeparator) {
        flushBuffer(null);
        
        List<Object> objList = new ArrayList<Object>();
        Object fieldName = null;
        Object fieldValue = null;
        String templateElement = null;
        StringBuilder sb = new StringBuilder();
        
        String[] stringArray = this.fContext.getTemplateParser().getBody();
        for (int i = 0; i < stringArray.length; i++) {
            templateElement = stringArray[i];
            if (templateElement.equals("${member.name}") || templateElement.equals("${member.name()}")) {
                fieldName = processElement(stringArray[i], member);
                objList.add(fieldName);
                continue;
            } else if (templateElement == "${member.value}") {
                fieldValue = processElement(stringArray[i], member);
                if (isSensitiveField(fieldName)) {
                    fieldValue = "*******";
                }
                objList.add(fieldValue);
                continue;
            } else {
                objList.add(processElement(stringArray[i], member));
            }
        }
        if (addSeparator) {
            objList.add(this.fContext.getTemplateParser().getSeparator());
        }
        
        Expression currExpression = null;
        for (Object element : objList) {
            if (element instanceof String) {
                sb.append(element);
            } else if (element instanceof Expression) {
                if (sb.length() != 0) {
                    StringLiteral literal = this.fAst.newStringLiteral();
                    literal.setLiteralValue(sb.toString());
                    currExpression = getNextExpression(currExpression, literal);
                    sb.delete(0, sb.length());
                }
                currExpression = getNextExpression(currExpression, (Expression)element);
            }
        }
        if (sb.length() != 0) {
            StringLiteral literal = this.fAst.newStringLiteral();
            literal.setLiteralValue(sb.toString());
            currExpression = getNextExpression(currExpression, literal);
            sb.delete(0, sb.length());
        }
        this.toStringMethod.getBody().statements().add(this.fAst.newExpressionStatement(currExpression));
    }
    
    /**
     * 计算新的表达式
     * @param currExpression
     * @param argument
     * @return
     */
    @SuppressWarnings("unchecked")
    private Expression getNextExpression(Expression currExpression, Expression argument) {
        MethodInvocation invocation = this.fAst.newMethodInvocation();
        if (currExpression == null) {
            invocation.setExpression(this.fAst.newName(this.fBuilderVariableName));
        } else {
            invocation.setExpression(currExpression);
        }
        invocation.setName(this.fAst.newSimpleName("append"));
        invocation.arguments().add(argument);
        return invocation;
    }
    
    /**
     * 判断是否是敏感字段
     * @param fieldName
     * @return
     */
    private boolean isSensitiveField(Object fieldName) {
        String name = String.valueOf(fieldName).toLowerCase(Locale.US);
        String[] words = new String[]{"pass", "pwd", "session", "token"};
        for (String word : words) {
            if (name.contains(word)) {
                return true;
            }
        }
        return false;
    }
     end  //
}
5. 用编译出来的 *.class 文件替换 jar 包中的内容
   org.eclipse.jdt.ui_3.9.2.v20131106-1600.jar
   
dyccsxg
关注
mybatis自动填充时间字段示例代码
08-26
MyBatis 自动填充时间字段示例代码 MyBatis 是一个基于 Java 的持久层框架，它提供了对数据库的交互操作。其中一个常见的需求是自动填充时间字段，即在实体类中自动填充 created_on 和 updated_on 字段。今天，我们...
Eclipse设置toString模板以及使用StringBuilder构建
砷碲 - Shendi
05-14 7278
最近用到bean比较多,看到自动生成的toString 是字符串用 + 连接起来的,对于性能来说,这肯定会低效,所以就试着改了一下模板 在Eclipse的编辑器处右键 进入后界面如下 当我们点击String format里的edit 自己可以定制一下返回的文本 有时候我们需要用到 json 的模板 如下 ${member.name} 是参数名 ${member.value} 是参数值 ${otherMembers} 后续都按前面的格式返回(没有这个则生成不了) 生成结果,性能会比
修复eclipse代码提示过度智能
谭先森的博客
07-30 960
eclipse版本：     1.打开eclipse插件管理：windows-&gt;show View-&gt;other-&gt;Plug-ins   2.找到org.eclipse.jface.text   3.右键单击选择import as -&gt;Source Project   4.在Project Explorer中出现org.eclipse.jf...
ecplise中修改tostring方法，使其自动生成JSON类型的字符串数据
qq_53966363的博客
09-17 709
自动生成toString方法改造，使其生成JSON格式的字符串
java 日志打印实体类时隐藏敏感字段不打印
陈Sir的博客
11-07 3960
在日常开发过程中经常会遇到一些实体类中定义的字段是敏感字段，例如密码，手机号等敏感信息，有需要将实体信息打印到日志中的情况。所以需要在调用日志打印框架时想将敏感字段隐藏掉，不要输出到日志中。
Eclipse:定制toString()
weixin_34007291的博客
02-01 274
一直对一些问题没有去深的研究,有人说Intellij好,有人说MyEclipse好,有人说Eclipse好,其实萝卜青菜各有所爱,只是看大家使用的习惯或者说公司用什么,你不能左右的时候,请去适合周围的环境,当我们说建立一个类的时候,最后去重写其toString方法,但是我们是否考虑过生成自己喜欢的风格呢? 下面我就来介绍一下使用Eclipse定制生成toString模版 Eclipse官方文档...
toString()一个会自动调用的方法
09-05
例如，可以修改数组的默认`toString`行为，使其返回一个格式化的字符串，而不是简单的逗号分隔的值列表。在给出的示例中，数组的`toString`方法被重写为返回一个JSON风格的字符串，使得输出更易读。同样，对于一个...
C# 将数据导出到excel模板 自定义字段
06-29
6. **保存更改**：最后，记得保存对Excel文件的修改。 ```csharp package.Save(); ``` 通过这种方式，你能够灵活地将数据导入到预先设计好的Excel模板中，同时保留模板的格式和样式。这个过程适用于需要生成定制...
Java自动添加重写的toString方法详解
08-25
默认情况下，每个Java类都继承了`Object`类，因此都包含了`toString()`方法，该方法返回类名和对象的哈希码，通常是以`@`分隔的形式，例如`"ClassName@hashCode"`。然而，这样的输出对于调试和日志记录通常并不友好...
STL标准模板库 字符与字符串 string，string-view，const char *
07-26
能支持任意STL容器打印
ToString()格式设置大全
03-06
ToString()格式设置大全ToString()格式设置大全ToString()格式设置大全ToString()格式设置大全
关于toString方法的重写工具ToStringBuilder
z69183787的专栏
07-26 3629
apache的commons-lang3的工具包里有一个ToStringBuilder类，这样在打日志的时候可以方便的打印出类实例中的各属性的值。 具体用法如下： [java] view plain copy import org.apache.commons.lang3.builder.ToStringBuilder;   import
（二十三）Java工具类ToStringBuilder方法详解
OceanSky的专栏
02-08 2107
ToStringBuilder类的作用是协助Object.toString()方法实现字符串输出； 这个类是一个良好和一致的对于toString()方法去输出任何类或者对象，这个类旨在简化处理过程： 允许字段名 处理所有的类型 处理null类型 输出数组和多维数组 允许为对象和集合控制详细级别 处理类的层次结构 1.使用此类编写的代码如下： package common.lang;...
toString()模板语法研究
LinWanCheng的博客
09-01 1530
自定义类和JavaBean的toString方法生成的字符串格式，MyEclipse、IntelliJ IDEA的模板语法简单解释
Eclipse自动生成toString()方法
qq_43542011的博客
07-18 1363
右键单击代码区——Source——Generate toString()
eclipse中自定义类的toString模版生成Json字符串
bewithme的专栏
05-19 1145
     Java类本身的toString方法是继承自父类的，有时候当前类需要重写父类的方来实现自己的 toString方法，以下在是在eclipse中自定义一个生成Json字符串的的模版并用该模版生成toString方法的过程。   第一步，在类编辑窗口中单击右键，按下图点选菜单。   第二步，选择要使用的字段，并点选字符格式模版下拉框的“Edit”按钮。     ...
eclipse 自动生成json格式的toString()方法
热门推荐
鑫的专栏
02-27 1万+
关键在这里点edit将下面的内容复制到文本框内，即可生成的代码即json格式的{"${member.name()}":"${member.value}", "${otherMembers}"} 若对象中引入其他对象则生成的json格式是不正确的如： { "id": "9", "img": "1363161532531.JPG", 此处的引号应去掉  “user”:{
Java基础---eclipse和toString()
qmanzb83的博客
08-18 1134
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 重点: 1.eclipse开发工具  常见操作都做一遍  debug调试  继承抽象类,实现接口  项目的删除和导入 2.Object类(重点掌握这两个,会重写)  toString()  equals() 1:Eclipse的安装
它主要用于 自动生成 getter、setter、构造方法、toString()、equals() 等方法
最新发布
02-08
### 自动生成 Java 类方法的工具 为了简化开发过程并提高效率，多种工具和插件可以自动生成 `getter`、`setter`、构造函数（包括全参构造器和无参构造器）、`toString()` 和 `equals()` 方法。 #### Lombok 注解库 Lombok 是一种流行的 Java 库，通过简单的注解来减少样板代码。使用 Lombok 可以显著降低编写这些常见方法的工作量： - **@Data**: 提供了 `getter`/`setter`、`toString()`、`equals()` 和 `hashCode()` 的实现[^1]。 注意：当使用 `@Data` 时，默认会为所有字段生成 `equals()` 和 `hashCode()` 实现，这可能导致意外行为，因此建议单独指定所需的组件[^4]。 - **@Getter/@Setter**: 单独为目标属性生成访问器或修改器方法。 - **@NoArgsConstructor**, **@AllArgsConstructor**, **@RequiredArgsConstructor**: 分别用于创建无参数构造函数、全部参数构造函数以及仅含必需字段的构造函数。 - **@ToString(includeFieldNames=true)** 或者更细粒度控制如 `@ToString(of={"field1", "field2"})`: 定制化输出字符串表示形式[^3]。 - **@EqualsAndHashCode(callSuper=false, of={"field1",...})**: 自定义比较逻辑而不依赖默认继承机制。 #### IDE 内置功能与插件支持 主流集成开发环境 (IDE)，例如 IntelliJ IDEA 和 Eclipse 都内置了一定程度上的辅助生成功能；同时也有专门针对此目的设计的各种插件可用： - 支持一键生成上述提到的方法模板。 - 插件市场中有许多增强型插件可以帮助进一步优化这一流程，比如 “GenerateSerialVersionUID”。 - **Eclipse** - 同样具备类似的快捷键组合来自动生成所需代码片段。 - 社区贡献了许多实用的小工具，像 JAutodoc 就能在文档方面提供额外帮助。 对于希望保持项目轻量化而又不想牺牲生产力的人来说，合理利用 Lombok 结合强大 IDE 功能无疑是一个明智的选择。 ```java // 使用 Lombok 示例 import lombok.*; @Getter @Setter @NoArgsConstructor @AllArgsConstructor public class Person { private String name; private int age; // 如果只需要部分字段参与 toString() @Override public String toString() { return "Person{" + "name='" + name + '\'' + '}'; } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值