Mencari templat kode Java Eclipse yang berguna [ditutup]

Anda dapat membuat berbagai templat kode Java di Eclipse via

Window> Preferences> Java> Editor> Templates

misalnya

sysout diperluas ke:

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

Anda dapat mengaktifkan ini dengan mengetik sysoutdiikuti olehCTRL+SPACE

Template kode Java apa yang bermanfaat yang saat ini Anda gunakan? Sertakan nama dan uraiannya serta mengapa itu keren.

Saya mencari penggunaan template asli / novel daripada fitur bawaan yang ada.

• Buat Log4J logger
• Dapatkan warna swt dari tampilan
• Syncexec - Kerangka Eclipse
• Singleton Pattern / Enum Singleton Generation
• Bacafile
• Const
• Menelusuri
• Format String
• Ulasan Kode Komentar
• Format string
• Coba Akhirnya Kunci
• Format Pesan i18n dan log
• Equalsbuilder
• Pembuat Hashcodebuilder
• Injeksi Objek Pegas
• Buat FileOutputStream

Templat kode berikut akan membuat logger dan membuat impor yang tepat, jika perlu.

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

Sumber .

JULI

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

Beberapa templat tambahan di sini: Tautan I - Tautan II

Saya suka yang ini:

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} 

UPDATE : Versi Java 7 dari templat ini adalah:

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

Memformat string

MessageFormat - mengelilingi pilihan dengan MessageFormat.

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

Ini memungkinkan saya memindahkan kursor ke string, memperluas pilihan ke seluruh string (Shift-Alt-Up), lalu Ctrl-Space dua kali.

Kunci pilihan

kunci - mengelilingi garis yang dipilih dengan mencoba akhirnya mengunci. Asumsikan ada variabel kunci.

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

${line_selection}Templat NB muncul di menu Surround With (Alt-Shift-Z).

Saya tahu saya menendang tiang yang mati, tetapi ingin membagikan ini demi penyelesaian:

Versi yang benar dari templat generasi tunggal, yang mengatasi desain penguncian ganda yang cacat (dibahas di atas dan disebutkan di tempat lain)

Templat Pembuatan Singleton: Beri nama inicreatesingleton

static enum Singleton {
    INSTANCE;

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

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

Untuk mengakses lajang yang dihasilkan menggunakan di atas:

Templat referensi Singleton: Beri nama ini getsingleton:

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

Tambahkan potongan kode untuk diulangi Map.entrySet():

Templat:

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

Kode yang Dihasilkan:

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

Untuk log, sedikit lagu pendek untuk menambahkan variabel anggota.

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

Buat tiruan dengan Mockito (dalam konteks "Pernyataan Java"):

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

Dan di "anggota tipe Java":

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

Mock metode void untuk melempar pengecualian:

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

Mock metode kosong untuk melakukan sesuatu:

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

Verifikasi metode mocked yang dipanggil tepat sekali:

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

Verifikasi metode mocked tidak pernah dipanggil:

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

Daftar tertaut baru menggunakan Google Guava (dan serupa untuk hashset dan hashmap):

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

Saya juga menggunakan templat besar yang menghasilkan kelas Tes. Ini adalah bagian singkat yang harus disesuaikan oleh semua orang yang tertarik:

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

Cek kosong!

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

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

Salah satu yang saya cintai adalah foreach :

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

Dan penelusuran , karena saya sering menggunakannya untuk melacak:

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

Saya hanya berpikir tentang yang lain dan telah menemukannya di Internet suatu hari, const :

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

Sedikit tip tentang sysout - Saya suka menamainya menjadi "sop". Tidak ada yang lain di lib java dimulai dengan "sop" sehingga Anda dapat dengan cepat mengetik "sop" dan boom, itu menyisipkan.

Lempar IllegalArgumentException dengan variabel dalam lingkup saat ini (illarg):

throw new IllegalArgumentException(${var});

Lebih baik

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

Tidak ada yang mewah untuk produksi kode - tetapi cukup berguna untuk ulasan kode

Saya memiliki template coderev saya rendah / med / tinggi melakukan hal berikut

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

Dan kemudian dalam tampilan Tugas - akan menunjukkan kepada saya semua komentar ulasan kode yang ingin saya sampaikan selama rapat.

Beberapa templat lagi di sini .

Termasuk:

• Buat objek tanggal dari tanggal tertentu
• Buat ArrayList generik baru
• Pengaturan logger
• Log dengan level yang ditentukan
• Buat HashMap generik baru
• Iterasi melalui peta, cetak kunci dan nilai-nilai
• Pisahkan waktu menggunakan SimpleDateFormat
• Baca file baris demi baris
• Log dan rethrow pengecualian yang tertangkap
• Cetak waktu eksekusi satu blok kode
• Buat Timer berkala
• Tulis string ke file

slf4j Logging

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

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

Properti Kacang

private ${Type} ${property};

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

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

Dukungan PropertiChange

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

Post Java 7, cara yang bagus untuk mengatur logger yang membutuhkan (atau lebih suka) referensi statis ke kelas terlampir adalah dengan menggunakan API MethodHandles yang baru diperkenalkan untuk mendapatkan kelas runtime dalam konteks statis.

Cuplikan contoh untuk SLF4J adalah:

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

Selain menjadi potongan sederhana dalam IDE apa pun, juga kurang rapuh jika Anda mengubah fungsi tertentu ke kelas lain karena Anda tidak akan sengaja membawa nama kelas dengannya.

Meminta kode pada utas GUI

Saya mengikat templat berikut ke pintasan slateruntuk dengan cepat mengirimkan kode pada utas GUI.

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

Saat menguji sekitar dengan kode saya kadang-kadang terjawab di menghapus beberapa syso s. Jadi saya membuat sendiri template yang disebut syt .

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

Sebelum saya kompilasi saya selalu memeriksa TODO saya dan tidak akan pernah lupa untuk menghapus System.out lagi.

strf -> String.format("msg", args) cukup sederhana tetapi menghemat sedikit mengetik.

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

Dapatkan warna SWT dari tampilan saat ini:

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

Suround dengan syncexec

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

Gunakan pola desain tunggal:

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

Dan equalsbuilder, adaptasi 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);
}

Template untuk deklarasi logger sangat bagus.

Saya juga membuat linfo, ldebug, lwarn, lerror untuk level log yang saya gunakan lebih sering.

lerror:

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

Buat semuanya untuk sebuah acara

Karena acara agak merepotkan untuk dibuat di Jawa - semua antarmuka, metode, dan hal-hal untuk ditulis hanya untuk 1 acara - saya membuat template sederhana untuk membuat semua yang diperlukan untuk 1 acara.

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

Jika Anda memiliki acara yang membagikan satu EventObject, cukup hapus satu yang disesuaikan yang disisipkan oleh templat dan ubah bagian yang sesuai dari raise___()danon____() .

Saya telah menulis mekanisme acara yang bagus, sedikit, elegan menggunakan antarmuka generik dan kelas generik, tetapi tidak akan berhasil karena cara Java menangani obat generik. = (

Sunting : 1) Saya mengalami masalah ketika utas menambah / menghapus pendengar saat acara sedang berlangsung. Tidak Listdapat dimodifikasi saat sedang digunakan, jadi saya menambahkan synchronizedblok di mana daftar pendengar sedang diakses atau digunakan, mengunci daftar itu sendiri.

Masukkan metode uji yang harus diberikan-kapan-kemudian

Saya melihat versi yang mirip dengan yang satu ini baru-baru ini ketika memasangkan pemrograman dengan pengembang dan teman yang sangat baik, dan saya pikir ini bisa menjadi tambahan yang bagus untuk daftar ini.

Templat ini akan membuat metode pengujian baru di kelas, mengikuti pendekatan Diberikan - Kapan - Kemudian dari pengembangan yang didorong perilaku (BDD) pada komentar, sebagai panduan untuk menyusun kode. Ini akan memulai nama metode dengan "harus" dan membiarkan Anda mengganti sisa nama metode dummy "CheckThisAndThat" dengan deskripsi terbaik dari tanggung jawab metode pengujian. Setelah mengisi nama, TAB akan membawa Anda langsung ke// Given section , sehingga Anda dapat mulai mengetik prasyarat Anda.

Saya memetakannya ke tiga huruf "tst", dengan deskripsi "Metode pengujian harus-diberikan-kapan-kemudian";)

Saya harap Anda merasakan manfaatnya seperti ketika saya melihatnya:

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

    // When


    // Then

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

Injeksi Musim Semi

Saya tahu ini agak terlambat untuk permainan, tapi ini yang saya gunakan untuk Spring Injection di kelas:

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

Berikut ini adalah konstruktor untuk kelas yang tidak bisa dipakai:

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

Ini untuk pengecualian khusus:

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

Saya suka komentar kelas yang dihasilkan seperti ini:

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

"Saya ..." segera mendorong pengembang untuk menggambarkan apa yang dilakukan kelas. Saya tampaknya memperbaiki masalah kelas tidak berdokumen.

Dan tentu saja $ Id $ adalah kata kunci CVS yang berguna.

Saya sudah banyak menggunakan cuplikan ini, mencari null nilai dan string kosong.

Saya menggunakan "uji argumen" -templat sebagai kode pertama dalam metode saya untuk memeriksa argumen yang diterima.

testNullArgument

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

Anda mungkin ingin mengubah pesan pengecualian agar sesuai dengan standar perusahaan atau proyek Anda. Namun, saya merekomendasikan memiliki beberapa pesan yang menyertakan nama argumen yang menyinggung. Kalau tidak, penelepon metode Anda harus melihat dalam kode untuk memahami apa yang salah. (SEBUAHNullPointerException tanpa pesan menghasilkan pengecualian dengan pesan "null" yang tidak masuk akal).

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

Anda juga dapat menggunakan kembali templat pemeriksaan nol dari atas dan menerapkan cuplikan ini hanya untuk memeriksa string kosong. Anda kemudian akan menggunakan kedua templat untuk menghasilkan kode di atas.

Template di atas, bagaimanapun, memiliki masalah bahwa jika argumen in adalah final Anda harus mengubah kode yang dihasilkan beberapa (the ${varName} = ${varName}.trim() akan gagal).

Jika Anda menggunakan banyak argumen terakhir dan ingin memeriksa string kosong tetapi tidak harus memotongnya sebagai bagian dari kode Anda, Anda bisa menggunakan ini:

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

Saya juga membuat beberapa cuplikan untuk memeriksa variabel yang tidak dikirim sebagai argumen (perbedaan besar adalah tipe pengecualian, sekarang menjadi IllegalStateExceptiongantinya).

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

Ini adalah template umum untuk menguji suatu variabel. Butuh beberapa tahun untuk benar-benar belajar menghargai yang ini, sekarang saya sering menggunakannya (dalam kombinasi dengan template di atas tentu saja!)

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

Anda memasukkan nama variabel atau kondisi yang mengembalikan nilai, diikuti oleh operan ("==", "<", ">" dll) dan nilai atau variabel lain dan jika tes gagal, kode yang dihasilkan akan melempar IllegalArgumentException.

Alasan klausa if sedikit rumit, dengan seluruh ekspresi dibungkus dengan "! ()" Adalah untuk memungkinkan untuk menggunakan kembali kondisi pengujian dalam pesan pengecualian.

Mungkin akan membingungkan kolega, tetapi hanya jika mereka harus melihat kode, yang mungkin tidak harus mereka lakukan jika Anda melemparkan pengecualian semacam ini ...

Berikut ini contoh dengan array:

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

Anda mendapatkan hasil ini dengan memanggil templat, mengetik "from.length" [TAB] "== to.length".

Hasilnya jauh lebih lucu daripada "ArrayIndexOutOfBoundsException" atau serupa dan mungkin benar-benar memberi pengguna Anda kesempatan untuk mencari tahu masalahnya.

Nikmati!

Saya menggunakan ini untuk MessageFormat (menggunakan Java 1.4). Dengan begitu saya yakin bahwa saya tidak memiliki rangkaian yang sulit untuk diekstraksi ketika melakukan internasionalisasi

i18n

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

Juga untuk logging:

catatan

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

Beberapa favorit saya adalah ...

1: Javadoc, untuk menyisipkan dokumen tentang metode menjadi metode injeksi objek Musim Semi.

 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: Jendela debug, untuk membuat FileOutputStream dan menulis konten buffer ke file. Digunakan ketika Anda ingin membandingkan buffer dengan run yang lalu (menggunakan BeyondCompare), atau jika Anda tidak dapat melihat konten buffer (melalui inspeksi) karena terlalu besar ...

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