การค้นหาเท็มเพลตโค้ด Eclipse Java ที่มีประโยชน์ [ปิด]

คุณสามารถสร้างเท็มเพลตโค้ด Java ต่างๆใน Eclipse ผ่าน

หน้าต่าง> ค่ากำหนด> Java> Editor> เทมเพลต

เช่น

sysout ถูกขยายเป็น:

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

คุณสามารถเปิดใช้งานได้โดยพิมพ์sysoutตามด้วยCTRL+SPACE

เท็มเพลตโค้ด Java ที่มีประโยชน์อะไรที่คุณใช้อยู่ในปัจจุบัน? รวมชื่อและคำอธิบายของมันและทำไมมันเจ๋ง

ฉันกำลังมองหาการใช้เทมเพลตต้นฉบับ / นวนิยายแทนที่จะเป็นฟีเจอร์ที่มีอยู่แล้วภายใน

• สร้าง Logger Logger
• รับสี swt จากจอแสดงผล
• Syncexec - Eclipse Framework
• รูปแบบซิงเกิล / Enum รูปแบบซิงเกิล
• readfile
• const
• Traceout
• รูปแบบสตริง
• รีวิวรหัสความคิดเห็น
• รูปแบบสตริง
• ลองล็อคสุดท้าย
• รูปแบบข้อความ i18n และบันทึก
• Equalsbuilder
• Hashcodebuilder
• การฉีดสปริงวัตถุ
• สร้าง FileOutputStream

แม่แบบรหัสต่อไปนี้จะสร้าง logger และสร้างการนำเข้าที่ถูกต้องหากจำเป็น

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);

แหล่ง

กรกฎาคม

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

เทมเพลตเพิ่มเติมบางส่วนที่นี่: ลิงก์ I - ลิงก์ II

ฉันชอบอันนี้:

readfile

 ${: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} 

อัปเดต : เทมเพลตนี้เวอร์ชัน Java 7 คือ:

${: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
}

จัดรูปแบบสตริง

MessageFormat - ล้อมรอบส่วนที่เลือกด้วย MessageFormat

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

สิ่งนี้ทำให้ฉันเลื่อนเคอร์เซอร์ไปที่สตริงขยายการเลือกไปยังทั้งสตริง (Shift-Alt-Up) จากนั้นกด Ctrl-Space สองครั้ง

ล็อคส่วนที่เลือก

lock - ล้อมรอบเส้นที่เลือกด้วยการลองล็อคในที่สุด สมมติว่ามีตัวแปรล็อคอยู่

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

${line_selection}เทมเพลตNB แสดงขึ้นในเมนูSurround With (Alt-Shift-Z)

ฉันรู้ว่าฉันกำลังเตะโพสต์ที่ตายแล้ว แต่ต้องการแบ่งปันสิ่งนี้เพราะเห็นว่าเสร็จ:

เทมเพลตการสร้างซิงเกิลเวอร์ชั่นที่ถูกต้องซึ่งเอาชนะการออกแบบล็อคที่มีการตรวจสอบซ้ำสองครั้ง (กล่าวถึงข้างต้นและที่อื่น ๆ )

เทมเพลตการสร้างเดี่ยว: ตั้ง ชื่อสิ่งนี้createsingleton

static enum Singleton {
    INSTANCE;

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

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

วิธีเข้าถึงซิงเกิลตันที่สร้างโดยใช้ด้านบน:

แม่แบบการอ้างอิงเดี่ยว: ชื่อนี้getsingleton:

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

ต่อท้ายโค้ดเพื่อวนซ้ำMap.entrySet():

แม่แบบ:

${: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}
}

สร้างรหัส:

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

สำหรับlogสิ่งเล็กน้อยที่เป็นประโยชน์เพื่อเพิ่มในตัวแปรสมาชิก

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

สร้างการจำลองด้วย Mockito (ในบริบท "คำสั่ง Java"):

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

และใน "สมาชิกประเภท Java":

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

เยาะเย้ยเป็นโมฆะวิธีการโยนข้อยกเว้น:

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

เยาะเย้ยวิธีการที่จะทำให้บางสิ่งบางอย่าง:

${: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});

ตรวจสอบวิธีการเยาะเย้ยที่เรียกว่าหนึ่งครั้ง:

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

ยืนยันว่าวิธีการเยาะเย้ยไม่เคยถูกเรียกใช้:

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

รายการที่เชื่อมโยงใหม่โดยใช้ Google Guava (และคล้ายกับ hashset และ hashmap):

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

ฉันยังใช้เทมเพลตขนาดใหญ่ที่สร้างคลาสการทดสอบ นี่คือส่วนสั้น ๆ ของมันที่ทุกคนที่สนใจควรปรับแต่ง:

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

ตรวจสอบ Null!

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

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

ที่รักของฉันคนหนึ่งคือforeach :

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

และติดตามเนื่องจากฉันใช้มันมากสำหรับการติดตาม:

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

ฉันเพิ่งคิดเกี่ยวกับอีกคนหนึ่งและได้พบมันผ่านทางอินเทอร์เน็ตบางวันconst :

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

เคล็ดลับเล็ก ๆ น้อย ๆ เกี่ยวกับ sysout - ฉันต้องการเปลี่ยนชื่อเป็น "sop" ไม่มีอะไรใน java libs ที่ขึ้นต้นด้วย "sop" เพื่อให้คุณสามารถพิมพ์ "sop" และ boom ได้อย่างรวดเร็ว

โยน IllegalArgumentException ด้วยตัวแปรในขอบเขตปัจจุบัน (illarg):

throw new IllegalArgumentException(${var});

ดีกว่า

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

ไม่มีอะไรแฟนซีสำหรับการผลิตรหัส - แต่ค่อนข้างมีประโยชน์สำหรับการตรวจสอบรหัส

ฉันมีแม่แบบ coderev ของฉันต่ำ / med / สูงทำดังต่อไปนี้

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

จากนั้นในมุมมองงาน - จะแสดงความคิดเห็นเกี่ยวกับรหัสทั้งหมดที่ฉันต้องการนำมาแสดงในระหว่างการประชุม

บางแม่มากขึ้นที่นี่

รวม:

• สร้างวัตถุวันที่จากวันที่ที่เฉพาะเจาะจง
• สร้าง ArrayList สามัญใหม่
• การตั้งค่าคนตัดไม้
• เข้าสู่ระบบด้วยระดับที่ระบุ
• สร้าง HashMap ทั่วไปใหม่
• วนซ้ำผ่านแผนที่พิมพ์ปุ่มและค่าต่างๆ
• แยกเวลาโดยใช้ SimpleDateFormat
• อ่านไฟล์ทีละบรรทัด
• เข้าสู่ระบบและ rethrow exption ที่ถูกจับ
• พิมพ์เวลาดำเนินการของบล็อกของรหัส
• สร้างตัวจับเวลาเป็นระยะ
• เขียน String ไปยังไฟล์

slf4j การบันทึก

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

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

ทรัพย์สินถั่ว

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);
}

โพสต์ Java 7 วิธีที่ยอดเยี่ยมในการตั้งค่าตัวบันทึกที่ต้องการ (หรือต้องการ) การอ้างอิงแบบคงที่ไปยังคลาสที่ปิดล้อมคือการใช้ MethodHandles API ที่แนะนำใหม่เพื่อรับคลาสรันไทม์ในบริบทแบบสแตติก

ตัวอย่างโค้ดสำหรับ SLF4J คือ:

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

นอกเหนือจากการเป็นตัวอย่างข้อมูลง่ายๆใน IDE ใด ๆ มันยังเปราะน้อยกว่าหากคุณปรับการทำงานบางอย่างให้เป็นคลาสอื่นเนื่องจากคุณจะไม่นำชื่อคลาสไปด้วย

เรียกใช้รหัสบนเธรด GUI

ฉันผูกแม่แบบต่อไปนี้กับทางลัดslaterเพื่อส่งรหัสอย่างรวดเร็วบนเธรด GUI

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

เมื่อการทดสอบรอบกับรหัสบางครั้งฉันพลาดออกลบบางsyso s ดังนั้นฉันทำเองแม่แบบที่เรียกว่าSYT

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

ก่อนที่ฉันจะรวบรวมฉันจะตรวจสอบสิ่งที่ต้องทำของฉันและจะไม่มีวันลืมที่จะลบ System.out อีกครั้ง

strf -> String.format("msg", args) ค่อนข้างเรียบง่าย แต่ประหยัดการพิมพ์เล็กน้อย

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

รับสี SWT จากจอแสดงผลปัจจุบัน:

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

เพิ่มขึ้นด้วย syncexec

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

ใช้รูปแบบการออกแบบเดี่ยว:

/**
 * 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;
}

และผู้สร้าง Equalsbuilder, hashcodebuilder adaptation:

${: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);
}

เทมเพลตสำหรับการประกาศตัวบันทึกนั้นยอดเยี่ยมมาก

ฉันยังสร้าง linfo, ldebug, lwarn, lerror สำหรับระดับการบันทึกที่ฉันใช้บ่อยขึ้น

lerror:

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

สร้างทุกอย่างสำหรับเหตุการณ์

เนื่องจากเหตุการณ์เป็นสิ่งที่เจ็บปวดในการสร้างใน Java - อินเตอร์เฟสวิธีการและสิ่งที่ต้องเขียนทั้งหมดสำหรับ 1 เหตุการณ์ - ฉันสร้างเทมเพลตอย่างง่ายเพื่อสร้างทุกสิ่งที่จำเป็นสำหรับ 1 เหตุการณ์

${: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);
    }
}

ถ้าคุณมีกิจกรรมที่ร่วมกันเป็นหนึ่งเดียวEventObjectเพียงลบหนึ่งที่กำหนดเองเขียนโดยแม่แบบและเปลี่ยนชิ้นส่วนที่เหมาะสมและraise___()on____()

ฉันได้เขียนกลไกการจัดอีเวนท์ที่ดีและสง่างามโดยใช้อินเตอร์เฟสทั่วไปและคลาสทั่วไป แต่มันก็ไม่ได้ผลเนื่องจากวิธีที่จาวาจัดการกับข้อมูลทั่วไป = (

แก้ไข : 1) ฉันพบปัญหาที่มีการเพิ่ม / ลบเธรดในขณะที่มีการจัดกิจกรรม Listไม่สามารถแก้ไขได้ในขณะที่ในการใช้งานดังนั้นฉันเพิ่มsynchronizedบล็อกที่รายชื่อของผู้ฟังจะถูกเข้าถึงหรือใช้ล็อคอยู่ในรายชื่อของตัวเอง

วิธีการทดสอบแบบแทรกควรได้รับเมื่อ - ในตอนนั้น

ฉันเห็นรุ่นที่คล้ายกันกับรุ่นนี้เมื่อไม่นานมานี้ในขณะที่จับคู่การเขียนโปรแกรมกับนักพัฒนาและเพื่อนที่ดีมากและฉันคิดว่ามันน่าจะเป็นส่วนเสริมที่ดีของรายการนี้

เทมเพลตนี้จะสร้างวิธีการทดสอบใหม่ในชั้นเรียนโดยทำตามกระบวนทัศน์ที่กำหนด - เมื่อ - จากนั้นให้แนวทางจากกระบวนทัศน์การพัฒนาที่ขับเคลื่อนด้วยพฤติกรรม (BDD) ในความคิดเห็นเพื่อเป็นแนวทางสำหรับการจัดทำโค้ด มันจะเริ่มต้นชื่อเมธอดด้วย "ควร" และให้คุณแทนที่ส่วนที่เหลือของชื่อเมธอดดัมมี "CheckThisAndThat" ด้วยคำอธิบายที่ดีที่สุดของความรับผิดชอบของวิธีการทดสอบ หลังจากกรอกชื่อ TAB จะนำคุณตรงไปที่// Given sectionเพื่อให้คุณสามารถเริ่มพิมพ์เงื่อนไขเบื้องต้นของคุณ

ฉันได้แมปกับตัวอักษรสามตัว "tst" พร้อมคำอธิบาย "วิธีการทดสอบที่ควรได้รับเมื่อ - ตอนนั้น";)

ฉันหวังว่าคุณจะพบว่ามีประโยชน์อย่างที่ฉันเคยเห็นเมื่อ:

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

    // When


    // Then

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

สปริงฉีด

ฉันรู้ว่านี่มันสายไปแล้วสำหรับเกม แต่นี่คือสิ่งที่ฉันใช้สำหรับ Spring Injection ในชั้นเรียน:

${: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};
}

นี่คือตัวสร้างสำหรับคลาสที่ไม่สามารถใช้งานได้ทันที:

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

อันนี้สำหรับข้อยกเว้นที่กำหนดเอง:

/**
 * ${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);
    }
}

ฉันชอบความคิดเห็นในชั้นเรียนที่สร้างขึ้นเช่นนี้:

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

"ฉัน ... " กระตุ้นให้ผู้พัฒนาอธิบายถึงสิ่งที่ชั้นเรียนทำในทันที ฉันดูเหมือนจะปรับปรุงปัญหาของคลาสที่ไม่มีเอกสาร

และแน่นอนว่า $ Id $ เป็นคำหลัก CVS ที่มีประโยชน์

ฉันใช้ตัวอย่างข้อมูลเหล่านี้เพื่อค้นหาnullค่านิยมและสตริงว่าง ๆ

ฉันใช้ "การทดสอบการโต้แย้ง" - เทมเพลตเป็นรหัสแรกในวิธีการของฉันเพื่อตรวจสอบข้อโต้แย้งที่ได้รับ

testNullArgument

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

คุณอาจต้องการเปลี่ยนข้อความแสดงข้อยกเว้นให้เหมาะสมกับมาตรฐานของ บริษัท หรือโครงการของคุณ อย่างไรก็ตามฉันขอแนะนำให้มีข้อความที่มีชื่อของอาร์กิวเมนต์ที่ละเมิด มิฉะนั้นผู้เรียกวิธีการของคุณจะต้องดูในรหัสเพื่อทำความเข้าใจกับสิ่งที่ผิดพลาด (A ที่NullPointerExceptionไม่มีข้อความจะสร้างข้อยกเว้นด้วยข้อความ "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}");
}

นอกจากนี้คุณยังสามารถใช้เทมเพลตการตรวจสอบว่างจากด้านบนและใช้ตัวอย่างข้อมูลนี้เพื่อตรวจสอบสตริงว่างเท่านั้น จากนั้นคุณจะใช้สองแม่แบบเหล่านี้เพื่อสร้างรหัสข้างต้น

อย่างไรก็ตามเทมเพลตดังกล่าวข้างต้นมีปัญหาว่าหากการโต้แย้งเป็นที่สิ้นสุดคุณจะต้องแก้ไขรหัสที่ผลิตบางส่วน ( ${varName} = ${varName}.trim()จะจะล้มเหลว)

หากคุณใช้อาร์กิวเมนต์สุดท้ายจำนวนมากและต้องการตรวจสอบสตริงที่ว่างเปล่า แต่ไม่จำเป็นต้องตัดมันเป็นส่วนหนึ่งของรหัสของคุณคุณสามารถใช้สิ่งนี้แทน:

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

ฉันยังสร้างตัวอย่างบางส่วนสำหรับการตรวจสอบตัวแปรที่ไม่ได้ส่งเป็นอาร์กิวเมนต์ (ความแตกต่างใหญ่คือประเภทข้อยกเว้นตอนนี้เป็นแบบIllegalStateExceptionแทน)

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}");
}

testArgument

นี่คือเทมเพลตทั่วไปสำหรับการทดสอบตัวแปร ฉันใช้เวลาสองสามปีในการเรียนรู้ที่จะชื่นชมสิ่งนี้จริง ๆ ตอนนี้ฉันใช้มันมาก (เมื่อใช้ร่วมกับเทมเพลตข้างต้นแน่นอน!)

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

คุณป้อนชื่อตัวแปรหรือเงื่อนไขที่ส่งคืนค่าตามด้วยตัวถูกดำเนินการ ("==", "<", ">" ฯลฯ ) และค่าหรือตัวแปรอื่นและหากการทดสอบล้มเหลวรหัสผลลัพธ์จะส่ง IllegalArgumentException

เหตุผลสำหรับความซับซ้อนเล็กน้อยหากข้อด้วยการแสดงออกทั้งหมดห่อใน "! ()" คือการทำให้มันเป็นไปได้ที่จะนำมาใช้ใหม่สภาพการทดสอบในข้อความข้อยกเว้น

บางทีมันอาจจะทำให้เพื่อนร่วมงานสับสน แต่ถ้าพวกเขาต้องดูรหัสที่พวกเขาอาจไม่ต้องทำถ้าคุณโยนข้อยกเว้นประเภทนี้ ...

นี่คือตัวอย่างของอาร์เรย์:

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");
    }
}

คุณได้รับผลลัพธ์นี้โดยเรียกใช้เทมเพลตโดยพิมพ์ "from.length" [TAB] "== to.length"

ผลลัพธ์นั้นสนุกกว่า "ArrayIndexOutOfBoundsException" หรือคล้ายกันและอาจทำให้ผู้ใช้ของคุณมีโอกาสที่จะเข้าใจปัญหา

สนุก!

ฉันใช้สิ่งนี้กับ MessageFormat (โดยใช้ Java 1.4) ด้วยวิธีนี้ฉันมั่นใจว่าฉันไม่มีการต่อข้อมูลที่ยากที่จะแยกออกเมื่อดำเนินการเป็นสากล

i18n

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

สำหรับการบันทึกด้วย:

เข้าสู่ระบบ

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

คนโปรดของฉันคือ ...

1: Javadoc เพื่อแทรก doc เกี่ยวกับวิธีการเป็นวิธีการฉีดอ็อบเจ็กต์สปริง

 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: หน้าต่าง Debug เพื่อสร้าง FileOutputStream และเขียนเนื้อหาของบัฟเฟอร์ลงในไฟล์ ใช้สำหรับเมื่อคุณต้องการเปรียบเทียบบัฟเฟอร์กับการรันที่ผ่านมา (ใช้ BeyondCompare) หรือหากคุณไม่สามารถดูเนื้อหาของบัฟเฟอร์ (ผ่านการตรวจสอบ) เนื่องจากมีขนาดใหญ่เกินไป ...

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