Tìm kiếm các mẫu mã Java Eclipse hữu ích [đã đóng]

Bạn có thể tạo các mẫu mã Java khác nhau trong Eclipse thông qua

Cửa sổ> Tùy chọn> Java> Trình chỉnh sửa> Mẫu

ví dụ

sysout được mở rộng thành:

System.out.println(${word_selection}${});${cursor}

Bạn có thể kích hoạt điều này bằng cách gõ sysouttheo sauCTRL+SPACE

Những mẫu mã Java hữu ích nào hiện tại bạn đang sử dụng? Bao gồm tên và mô tả về nó và tại sao nó tuyệt vời.

Tôi đang tìm kiếm một bản gốc / tiểu thuyết sử dụng một mẫu chứ không phải là một tính năng hiện có.

• Tạo logger Log4J
• Nhận màu swt từ màn hình
• Syncexec - Khung Eclipse
• Mô hình Singleton / Enum Thế hệ Singleton
• Đọc tài liệu
• hăng sô
• Truy ra
• Chuỗi định dạng
• Nhận xét mã nhận xét
• Định dạng chuỗi
• Thử khóa cuối cùng
• Định dạng tin nhắn i18n và nhật ký
• Người bình đẳng
• Máy băm
• Spring Object tiêm
• Tạo FileOutputStream

Các mẫu mã sau đây sẽ vừa tạo một logger và tạo các bản nhập đúng, nếu cần.

SLF4J

${:import(org.slf4j.Logger,org.slf4j.LoggerFactory)}
private static final Logger LOG = LoggerFactory.getLogger(${enclosing_type}.class);

Log4J 2

${:import(org.apache.logging.log4j.LogManager,org.apache.logging.log4j.Logger)} 
private static final Logger LOG = LogManager.getLogger(${enclosing_type}.class); 

Log4J

${:import(org.apache.log4j.Logger)}
private static final Logger LOG = Logger.getLogger(${enclosing_type}.class);

Nguồn .

THÁNG 7

${:import(java.util.logging.Logger)}
private static final Logger LOG = Logger.getLogger(${enclosing_type}.class.getName());

Một số mẫu bổ sung tại đây: Liên kết I - Liên kết II

Tôi thích cái này:

Đọc tài liệu

 ${:import(java.io.BufferedReader,  
           java.io.FileNotFoundException,  
           java.io.FileReader,  
           java.io.IOException)}  
 BufferedReader in = null;  
 try {  
    in = new BufferedReader(new FileReader(${fileName}));  
    String line;  
    while ((line = in.readLine()) != null) {  
       ${process}  
    }  
 }  
 catch (FileNotFoundException e) {  
    logger.error(e) ;  
 }  
 catch (IOException e) {  
    logger.error(e) ;  
 } finally {  
    if(in != null) in.close();  
 }  
 ${cursor} 

CẬP NHẬT : Phiên bản Java 7 của mẫu này là:

${:import(java.nio.file.Files,
          java.nio.file.Paths,
          java.nio.charset.Charset,
          java.io.IOException,
          java.io.BufferedReader)}
try (BufferedReader in = Files.newBufferedReader(Paths.get(${fileName:var(String)}),
                                                 Charset.forName("UTF-8"))) {
    String line = null;
    while ((line = in.readLine()) != null) {
        ${cursor}
    }
} catch (IOException e) {
    // ${todo}: handle exception
}

Định dạng một chuỗi

MessageFormat - bao quanh vùng chọn bằng MessageFormat.

 ${:import(java.text.MessageFormat)} 
 MessageFormat.format(${word_selection}, ${cursor})

Điều này cho phép tôi di chuyển con trỏ đến một chuỗi, mở rộng vùng chọn thành toàn bộ chuỗi (Shift-Alt-Up), sau đó Ctrl-Space hai lần.

Khóa lựa chọn

khóa - bao quanh các dòng đã chọn bằng khóa thử cuối cùng. Giả sử sự hiện diện của một biến khóa.

${lock}.acquire();
try {
    ${line_selection}
    ${cursor}
} finally {
    ${lock}.release();
}

Các ${line_selection}mẫu NB hiển thị trong menu Surround With (Alt-Shift-Z).

Tôi biết tôi đang đá một bài chết, nhưng muốn chia sẻ điều này để hoàn thành:

Một phiên bản chính xác của mẫu thế hệ đơn, vượt qua thiết kế khóa được kiểm tra hai lần thiếu sót (đã thảo luận ở trên và được đề cập ở nơi khác)

Mẫu tạo đơn: Đặt tên nàycreatesingleton

static enum Singleton {
    INSTANCE;

    private static final ${enclosing_type} singleton = new ${enclosing_type}();

    public ${enclosing_type} getSingleton() {
        return singleton;
    }
}
${cursor}

Để truy cập singletons được tạo bằng cách sử dụng ở trên:

Mẫu tham chiếu Singleton: Đặt tên này getsingleton:

${type} ${newName} = ${type}.Singleton.INSTANCE.getSingleton();

Nối đoạn mã để lặp lại Map.entrySet():

Bản mẫu:

${:import(java.util.Map.Entry)}
for (Entry<${keyType:argType(map, 0)}, ${valueType:argType(map, 1)}> ${entry} : ${map:var(java.util.Map)}.entrySet())
{
    ${keyType} ${key} = ${entry}.getKey();
    ${valueType} ${value} = ${entry}.getValue();
    ${cursor}
}

Mã được tạo:

for (Entry<String, String> entry : properties.entrySet())
{
    String key = entry.getKey();
    String value = entry.getValue();
    |
}

Đối với log, một ditty nhỏ hữu ích để thêm vào biến thành viên.

private static Log log = LogFactory.getLog(${enclosing_type}.class);

Tạo một bản giả với Mockito (trong ngữ cảnh "các câu lệnh Java"):

${:importStatic('org.mockito.Mockito.mock')}${Type} ${mockName} = mock(${Type}.class);

Và trong "thành viên kiểu Java":

${:import(org.mockito.Mock)}@Mock
${Type} ${mockName};

Giả định một phương thức void để ném một ngoại lệ:

${:import(org.mockito.invocation.InvocationOnMock,org.mockito.stubbing.Answer)}
doThrow(${RuntimeException}.class).when(${mock:localVar}).${mockedMethod}(${args});

Mock một phương thức void để làm một cái gì đó:

${:import(org.mockito.invocation.InvocationOnMock,org.mockito.stubbing.Answer)}doAnswer(new Answer<Object>() {
public Object answer(InvocationOnMock invocation) throws Throwable {
    Object arg1 = invocation.getArguments()[0];
    return null;
}
}).when(${mock:localVar}).${mockedMethod}(${args});

Xác minh phương thức giả được gọi chính xác một lần:

${:importStatic(org.mockito.Mockito.verify,org.mockito.Mockito.times)}
verify(${mock:localVar}, times(1)).${mockMethod}(${args});

Xác minh phương thức giả định không bao giờ được gọi:

${:importStatic(org.mockito.Mockito.verify,org.mockito.Mockito.never)}verify(${mock:localVar}, never()).${mockMethod}(${args});

Danh sách được liên kết mới bằng Google Guava (và tương tự cho hashset và hashmap):

${import:import(java.util.List,com.google.common.collect.Lists)}List<${T}> ${newName} = Lists.newLinkedList();

Ngoài ra tôi sử dụng một khuôn mẫu lớn tạo ra một lớp Test. Đây là một đoạn ngắn của nó mà mọi người quan tâm nên tùy chỉnh:

package ${enclosing_package};

import org.junit.*;
import static org.junit.Assert.*;
import static org.hamcrest.Matchers.*;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.*;
import org.mockito.Mockito;
import org.slf4j.Logger;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.junit.runner.RunWith;

// TODO autogenerated test stub
@RunWith(MockitoJUnitRunner.class)
public class ${primary_type_name} {

    @InjectMocks
    protected ${testedType} ${testedInstance};
    ${cursor}

    @Mock
    protected Logger logger;

    @Before
    public void setup() throws Exception {
    }

    @Test
    public void shouldXXX() throws Exception {
        // given

        // when
        // TODO autogenerated method stub

        // then
        fail("Not implemented.");
    }
}
// Here goes mockito+junit cheetsheet

Kiểm tra Null!

if( ${word_selection} != null ){
    ${cursor}
}

if( ${word_selection} == null ){
    ${cursor}
}

Một trong những người thân yêu của tôi là foreach :

for (${iterable_type} ${iterable_element} : ${iterable}) {
    ${cursor}
}

Và theo dõi , vì tôi đang sử dụng nó rất nhiều để theo dõi:

System.out.println("${enclosing_type}.${enclosing_method}()");

Tôi chỉ nghĩ về một cái khác và đã tìm thấy nó qua Internet một ngày nào đó, const :

private static final ${type} ${name} = new ${type} ${cursor};

Một mẹo nhỏ về sysout - Tôi muốn đổi tên nó thành "sop". Không có gì khác trong java libs bắt đầu bằng "sop" để bạn có thể nhanh chóng gõ "sop" và boom, nó chèn vào.

Ném một IllegalArgumentException với biến trong phạm vi hiện tại (ảo ảnh):

throw new IllegalArgumentException(${var});

Tốt hơn

throw new IllegalArgumentException("Invalid ${var} " + ${var});  

Không có gì lạ mắt cho việc sản xuất mã - nhưng khá hữu ích cho việc đánh giá mã

Tôi có coderev mẫu của tôi thấp / med / high làm như sau

/**
 * Code Review: Low Importance
 * 
 *
 * TODO: Insert problem with code here 
 *
 */

Và sau đó trong chế độ xem Nhiệm vụ - sẽ hiển thị cho tôi tất cả các nhận xét đánh giá mã mà tôi muốn đưa ra trong cuộc họp.

Một số mẫu khác ở đây .

Bao gồm:

• Tạo một đối tượng ngày từ một ngày cụ thể
• Tạo một ArrayList chung mới
• Thiết lập logger
• Đăng nhập với mức quy định
• Tạo một HashMap chung mới
• Lặp lại qua bản đồ, in các khóa và giá trị
• Phân tích thời gian bằng SimpleDateFormat
• Đọc một dòng tập tin theo dòng
• Đăng nhập và suy nghĩ lại một ngoại lệ bị bắt
• Thời gian thực hiện in của một khối mã
• Tạo bộ đếm thời gian định kỳ
• Viết một chuỗi vào một tập tin

đăng nhập slf4j

${imp:import(org.slf4j.Logger,org.slf4j.LoggerFactory)}

private static final Logger LOGGER = LoggerFactory
    .getLogger(${enclosing_type}.class);

Đậu tài sản

private ${Type} ${property};

public ${Type} get${Property}() {
    return ${property};
}

public void set${Property}(${Type} ${property}) {
    ${propertyChangeSupport}.firePropertyChange("${property}", this.${property},     this.${property} = ${property});
}

PropertyChangeSupport

private PropertyChangeSupport ${propertyChangeSupport} = new PropertyChangeSupport(this);${:import(java.beans.PropertyChangeSupport,java.beans.PropertyChangeListener)}
public void addPropertyChangeListener(PropertyChangeListener listener) {
  ${propertyChangeSupport}.addPropertyChangeListener(listener);
}

public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
  ${propertyChangeSupport}.addPropertyChangeListener(propertyName, listener);
}

public void removePropertyChangeListener(PropertyChangeListener listener) {
  ${propertyChangeSupport}.removePropertyChangeListener(listener);
}

public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
  ${propertyChangeSupport}.removePropertyChangeListener(propertyName, listener);
}

Đăng Java 7, một cách tuyệt vời để thiết lập các logger cần (hoặc thích) các tham chiếu tĩnh đến lớp kèm theo là sử dụng API Phương thức mới được giới thiệu để có được lớp thời gian chạy trong ngữ cảnh tĩnh.

Một đoạn ví dụ cho SLF4J là:

private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

Ngoài việc là một đoạn mã đơn giản trong bất kỳ IDE nào, nó cũng sẽ dễ vỡ hơn nếu bạn tái cấu trúc một số chức năng nhất định sang một lớp khác vì bạn sẽ không vô tình mang tên lớp với nó.

Gọi mã trên luồng GUI

Tôi liên kết mẫu sau với phím tắt slaterđể nhanh chóng gửi mã trên luồng GUI.

${:import(javax.swing.SwingUtilities)}
SwingUtilities.invokeLater(new Runnable() {      
      @Override
      public void run() {
        ${cursor}
      }
    });

Khi kiểm tra xung quanh với mã đôi khi tôi đã bỏ lỡ việc xóa một số syso s. Vì vậy, tôi đã tạo cho mình một mẫu gọi là syt .

System.out.println(${word_selection}${});//${todo}:remove${cursor}

Trước khi biên dịch, tôi luôn kiểm tra các TODO của mình và sẽ không bao giờ quên xóa System.out nữa.

strf -> String.format("msg", args) khá đơn giản nhưng tiết kiệm một chút gõ.

String.format("${cursor}",)

Nhận màu SWT từ màn hình hiện tại:

Display.getCurrent().getSystemColor(SWT.COLOR_${cursor})

Tuyệt vời với syncexec

PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable(){
    public void run(){
        ${line_selection}${cursor}
    }
});

Sử dụng mẫu thiết kế singleton:

/**
 * The shared instance.
 */
private static ${enclosing_type} instance = new ${enclosing_type}();

/**
 * Private constructor.
 */
private ${enclosing_type}() {
    super();
}

/**
 * Returns this shared instance.
 *
 * @returns The shared instance
 */
public static ${enclosing_type} getInstance() {
    return instance;
}

Và một người chơi cân bằng, thích ứng hashcodebuilder:

${:import(org.apache.commons.lang.builder.EqualsBuilder,org.apache.commons.lang.builder.HashCodeBuilder)}
@Override
public boolean equals(Object obj) {
    return EqualsBuilder.reflectionEquals(this, obj);
}

@Override
public int hashCode() {
    return HashCodeBuilder.reflectionHashCode(this);
}

Các mẫu cho khai báo logger là tuyệt vời.

Tôi cũng tạo linfo, ldebug, lwarn, lerror cho các mức log mà tôi sử dụng thường xuyên hơn.

người cho vay:

logger.error(${word_selection}${});${cursor}

Tạo mọi thứ cho một sự kiện

Vì các sự kiện hơi khó tạo ra trong Java - tất cả các giao diện, phương thức và công cụ để viết chỉ cho 1 sự kiện - Tôi đã tạo một mẫu đơn giản để tạo mọi thứ cần thiết cho 1 sự kiện.

${:import(java.util.List, java.util.LinkedList, java.util.EventListener, java.util.EventObject)}

private final List<${eventname}Listener> ${eventname}Listeners = new LinkedList<${eventname}Listener>();

public final void add${eventname}Listener(${eventname}Listener listener)
{
    synchronized(${eventname}Listeners) {
        ${eventname}Listeners.add(listener);
    }
}

public final void remove${eventname}Listener(${eventname}Listener listener)
{
    synchronized(${eventname}Listeners) {
        ${eventname}Listeners.remove(listener);
    }
}

private void raise${eventname}Event(${eventname}Args args)
{
    synchronized(${eventname}Listeners) {
        for(${eventname}Listener listener : ${eventname}Listeners)
            listener.on${eventname}(args);
    }
}

public interface ${eventname}Listener extends EventListener
{
    public void on${eventname}(${eventname}Args args);
}

public class ${eventname}Args extends EventObject
{
    public ${eventname}Args(Object source${cursor})
    {
        super(source);
    }
}

Nếu bạn có các sự kiện chia sẻ một sự kiện EventObject, chỉ cần xóa một sự kiện tùy chỉnh được chèn bởi mẫu và thay đổi các phần thích hợp của raise___()và on____().

Tôi đã viết một cơ chế tạo sự kiện đẹp, nhỏ, thanh lịch bằng cách sử dụng một giao diện chung và lớp chung, nhưng nó sẽ không hoạt động do cách Java xử lý các tổng quát. = (

Chỉnh sửa : 1) Tôi gặp phải vấn đề trong đó các chủ đề đang thêm / xóa người nghe trong khi một sự kiện đang diễn ra. Các Listkhông thể được sửa đổi trong khi sử dụng, vì vậy tôi thêm synchronizedkhối nơi danh sách các thính giả đang được truy cập hoặc sử dụng, khóa thuộc danh mục riêng của mình.

Chèn các phương thức kiểm tra nên cho trước khi đó

Tôi đã thấy một phiên bản tương tự như phiên bản này gần đây trong khi lập trình cặp với một nhà phát triển và bạn bè rất tốt, và tôi nghĩ rằng nó có thể là một bổ sung tốt cho danh sách này.

Mẫu này sẽ tạo một phương thức thử nghiệm mới trên một lớp, theo cách tiếp cận Cho - Khi - Sau đó từ mô hình phát triển theo hướng hành vi (BDD) trên các nhận xét, như một hướng dẫn để cấu trúc mã. Nó sẽ bắt đầu tên phương thức bằng "nên" và cho phép bạn thay thế phần còn lại của tên phương thức giả "Check ThisAndThat" bằng mô tả tốt nhất có thể về trách nhiệm của phương thức thử nghiệm. Sau khi điền tên, TAB sẽ đưa bạn thẳng đến // Given section, để bạn có thể bắt đầu nhập các điều kiện tiên quyết của mình.

Tôi đã ánh xạ tới ba chữ cái "tst", với mô tả "Các phương thức kiểm tra nên cho trước khi đó";)

Tôi hy vọng bạn thấy nó hữu ích như tôi đã làm khi tôi thấy nó:

@Test
public void should${CheckThisAndThat}() {
    Assert.fail("Not yet implemented");
    // Given
    ${cursor}

    // When


    // Then

}${:import(org.junit.Test, org.junit.Assert)}

Tiêm mùa xuân

Tôi biết điều này là muộn của trò chơi, nhưng đây là một trò chơi tôi sử dụng cho Spring tiêm trong một lớp:

${:import(org.springframework.beans.factory.annotation.Autowired)}
private ${class_to_inject} ${var_name};

@Autowired
public void set${class_to_inject}(${class_to_inject} ${var_name}) {
  this.${var_name} = ${var_name};
}

public ${class_to_inject} get${class_to_inject}() {
  return this.${var_name};
}

Đây là một hàm tạo cho các lớp không thể thực hiện được:

// Suppress default constructor for noninstantiability
@SuppressWarnings("unused")
private ${enclosing_type}() {
    throw new AssertionError();
}

Đây là một ngoại lệ tùy chỉnh:

/**
 * ${cursor}TODO Auto-generated Exception
 */
public class ${Name}Exception extends Exception {
    /**
     * TODO Auto-generated Default Serial Version UID
     */
    private static final long serialVersionUID = 1L;    

    /**
     * @see Exception#Exception()
     */
    public ${Name}Exception() {
        super();
    }

    /**
     * @see Exception#Exception(String) 
     */
    public ${Name}Exception(String message) {
        super(message);         
    }

    /**
     * @see Exception#Exception(Throwable)
     */
    public ${Name}Exception(Throwable cause) {
        super(cause);           
    }

    /**
     * @see Exception#Exception(String, Throwable)
     */
    public ${Name}Exception(String message, Throwable cause) {
        super(message, cause);
    }
}

Tôi thích một nhận xét lớp được tạo như thế này:

/**
 * I... 
 * 
 * $Id$
 */

"Tôi ..." ngay lập tức khuyến khích nhà phát triển mô tả những gì lớp làm. Tôi dường như cải thiện vấn đề của các lớp học không có giấy tờ.

Và tất nhiên, $ Id $ là một từ khóa CVS hữu ích.

Tôi đã sử dụng rất nhiều đoạn trích này, tìm kiếm các nullgiá trị và chuỗi trống.

Tôi sử dụng "kiểm tra đối số" -tem mẫu làm mã đầu tiên trong các phương thức của mình để kiểm tra các đối số nhận được.

testNullArgument

if (${varName} == null) {
    throw new NullPointerException(
        "Illegal argument. The argument cannot be null: ${varName}");
}

Bạn có thể muốn thay đổi thông báo ngoại lệ để phù hợp với tiêu chuẩn của công ty hoặc dự án của bạn. Tuy nhiên, tôi khuyên bạn nên có một số thông báo bao gồm tên của đối số vi phạm. Nếu không, người gọi phương thức của bạn sẽ phải xem mã để hiểu những gì đã sai. (MộtNullPointerException không có tin nhắn tạo ra một ngoại lệ với thông điệp khá vô nghĩa "null").

testNullOrEmptyStringArgument

if (${varName} == null) {
    throw new NullPointerException(
        "Illegal argument. The argument cannot be null: ${varName}");
}
${varName} = ${varName}.trim();
if (${varName}.isEmpty()) {
    throw new IllegalArgumentException(
        "Illegal argument. The argument cannot be an empty string: ${varName}");
}

Bạn cũng có thể sử dụng lại mẫu kiểm tra null từ phía trên và triển khai đoạn mã này để chỉ kiểm tra các chuỗi trống. Sau đó, bạn sẽ sử dụng hai mẫu đó để tạo mã ở trên.

Tuy nhiên, mẫu ở trên có một vấn đề là nếu đối số là cuối cùng, bạn sẽ phải sửa đổi một số mã được sản xuất ( ${varName} = ${varName}.trim() sẽ thất bại).

Nếu bạn sử dụng nhiều đối số cuối cùng và muốn kiểm tra các chuỗi trống nhưng không phải cắt chúng thành một phần của mã, bạn có thể đi với điều này thay thế:

if (${varName} == null) {
    throw new NullPointerException(
        "Illegal argument. The argument cannot be null: ${varName}");
}
if (${varName}.trim().isEmpty()) {
    throw new IllegalArgumentException(
        "Illegal argument. The argument cannot be an empty string: ${varName}");
}

testNullFieldState

Tôi cũng đã tạo một số đoạn mã để kiểm tra các biến không được gửi dưới dạng đối số (sự khác biệt lớn là loại ngoại lệ, bây giờ là một IllegalStateExceptionthay thế).

if (${varName} == null) {
    throw new IllegalStateException(
        "Illegal state. The variable or class field cannot be null: ${varName}");
}

testNullOrEmptyStringFieldState

if (${varName} == null) {
    throw new IllegalStateException(
        "Illegal state. The variable or class field cannot be null: ${varName}");
}
${varName} = ${varName}.trim();
if (${varName}.isEmpty()) {
    throw new IllegalStateException(
        "Illegal state. The variable or class field " +
            "cannot be an empty string: ${varName}");
}

kiểm tra

Đây là một mẫu chung để kiểm tra một biến. Tôi đã mất vài năm để thực sự học cách đánh giá cao cái này, bây giờ tôi sử dụng nó rất nhiều (kết hợp với các mẫu trên tất nhiên!)

if (!(${varName} ${testExpression})) {
    throw new IllegalArgumentException(
        "Illegal argument. The argument ${varName} (" + ${varName} + ") " +
        "did not pass the test: ${varName} ${testExpression}");
}

Bạn nhập tên biến hoặc điều kiện trả về giá trị, theo sau là toán hạng ("==", "<", ">" v.v.) và một giá trị hoặc biến khác và nếu kiểm tra thất bại, mã kết quả sẽ ném IllegalArgumentException.

Lý do cho mệnh đề if hơi phức tạp, với toàn bộ biểu thức được gói trong "! ()" Là để có thể sử dụng lại điều kiện kiểm tra trong thông báo ngoại lệ.

Có lẽ nó sẽ gây nhầm lẫn cho một đồng nghiệp, nhưng chỉ khi họ phải xem mã, điều mà họ có thể không phải làm nếu bạn ném những loại ngoại lệ này ...

Dưới đây là một ví dụ với mảng:

public void copy(String[] from, String[] to) {
    if (!(from.length == to.length)) {
        throw new IllegalArgumentException(
                "Illegal argument. The argument from.length (" +
                            from.length + ") " +
                "did not pass the test: from.length == to.length");
    }
}

Bạn nhận được kết quả này bằng cách gọi lên mẫu, gõ "from.length" [TAB] "== to.length".

Kết quả là thú vị hơn một "ArrayIndexOutOfBoundException" hoặc tương tự và thực sự có thể cung cấp cho người dùng của bạn một cơ hội để tìm ra vấn đề.

Thưởng thức!

Tôi sử dụng cái này cho MessageFormat (sử dụng Java 1.4). Bằng cách đó, tôi chắc chắn rằng tôi không có kết nối nào khó trích xuất khi thực hiện quốc tế hóa

i18n

String msg = "${message}";
Object[] params = {${params}};
MessageFormat.format(msg, params);

Ngoài ra để đăng nhập:

đăng nhập

if(logger.isDebugEnabled()){
  String msg = "${message}"; //NLS-1
  Object[] params = {${params}};
  logger.debug(MessageFormat.format(msg, params));
}

Một vài yêu thích của tôi là ...

1: Javadoc, để chèn doc về phương thức là phương thức tiêm đối tượng Spring.

 Method to set the <code>I${enclosing_type}</code> implementation that this class will use.
* 
* @param ${enclosing_method_arguments}<code>I${enclosing_type}</code> instance 

2: Cửa sổ gỡ lỗi, để tạo FileOutputStream và ghi nội dung của bộ đệm vào một tệp. Được sử dụng khi bạn muốn so sánh bộ đệm với lần chạy trước (sử dụng BeyondCompare) hoặc nếu bạn không thể xem nội dung của bộ đệm (thông qua kiểm tra) vì nó quá lớn ...

java.io.FileOutputStream fos = new java.io.FileOutputStream( new java.io.File("c:\\x.x"));
fos.write(buffer.toString().getBytes());
fos.flush();
fos.close();