उपयोगी ग्रहण जावा कोड टेम्प्लेट [बंद]

Question

आप ग्रहण के माध्यम से विभिन्न जावा कोड टेम्प्लेट बना सकते हैं

विंडो> वरीयताएँ> जावा> संपादक> टेम्पलेट

जैसे

sysout इसका विस्तार किया गया है:

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

sysoutइसके बाद टाइप करके आप इसे सक्रिय कर सकते हैंCTRL+SPACE

वर्तमान में आप किस उपयोगी जावा कोड टेम्प्लेट का उपयोग करते हैं? इसमें नाम और विवरण शामिल करें और यह क्यों भयानक है।

मैं एक अंतर्निहित / मौजूदा सुविधा के बजाय टेम्पलेट के मूल / उपन्यास उपयोग की तलाश कर रहा हूं।

• Log4J लकड़हारा बनाएँ
• प्रदर्शन से swt रंग प्राप्त करें
• Syncexec - ग्रहण की रूपरेखा
• सिंगलटन पैटर्न / Enum सिंगलटन जेनरेशन
• readfile
• कॉन्स्ट
• पता लगानां
• प्रारूप स्ट्रिंग
• टिप्पणी कोड की समीक्षा करें
• स्ट्रिंग प्रारूप
• अंत में लॉक की कोशिश करें
• संदेश प्रारूप i18n और लॉग करें
• Equalsbuilder
• Hashcodebuilder
• स्प्रिंग ऑब्जेक्ट इंजेक्शन
• FileOutputStream बनाएं

Comments

क्या कोई ऐसा है जो Enum से सभी संभावित मामलों के साथ एक स्विच स्टेटमेंट उत्पन्न करता है? मुझे पता है कि आप CTRL + 1 के साथ ऐसा कर सकते हैं, लेकिन मैं cmd ​​पूरा करने का उपयोग करूंगा।

— ग्रीनकिवी

क्या आप System.out.println(${word_selection}${});${cursor}इसका मतलब बता सकते हैं ? ऐसा लगता है कि एक शब्द का चयन करने का एक तरीका है और स्वचालित रूप से sysoutकॉल के अंदर इसे एनसेसे कर रहा है, क्या मैं सही हूं? कैसे?

— कोडिबुस्टीन

आप उस शब्द को हाइलाइट करें जिसे आप sysout कॉल से घिरा चाहते हैं और Ctrl-Space दबाएं (फिर टेम्पलेट का नाम टाइप करें यदि आपके पास बहुत सारे हाइलाइट

— अवेयर

@JReader $ {} क्या करता है?

— रोलैंड

Answer 1

निम्न कोड टेम्प्लेट एक लकड़हारा पैदा करेगा और ज़रूरत पड़ने पर सही आयात करेगा।

SLF4J

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

लॉग 4 जे 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());

Comments

ठंडा। मुझे $ {: आयात ...} के बारे में पता नहीं था।

— जेस्पर

मुझे लगता है कि $ {: import ...} केवल ग्रहण के नए संस्करणों में काम करता है। मैं 3.2 के साथ फंस गया हूं और यह मेरे लिए काम नहीं करता है।

— एडम क्रूम

मेरे संस्करण (3.5) में भी नहीं। क्या किसी को पता है कि यह किस संस्करण में पेश किया गया था?

— फिन्वेन

मुझे यह पसंद है! लेकिन मैंने लकड़हारा घोषणा के नीचे $ {आयात ...} डाल दिया, ताकि यह एक नई पंक्ति न जोड़े।

— डारियो सेडल

@ टीएमएस - जोड़ा, धन्यवाद!

— रॉबर्ट मुंटेनू

Answer 2

यहाँ कुछ अतिरिक्त टेम्पलेट: लिंक 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} 

अद्यतन : इस टेम्पलेट का जावा 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
}

Comments

मुझे लगता है कि यह एक विधि है :) के लिए

— बेन्मुर्फी

मुझे लगता है कि आप इस बिंदु से चूक गए हैं ... यह कहते हुए कि मुझे वास्तव में नहीं पता कि आपकी बात क्या है ... यह कोड पीढ़ी के बारे में नहीं है ...

— जॉन

मुझे लगता है कि यह बात यह है कि एक खाके में इस कोड को जोड़ने के लिए एक बहुत ही सामान्य स्थिति के लिए कट-एंड-पेस्ट प्रोग्रामिंग है।

— स्कॉट मैकइंटायर

हां, आपको कोड के पेस्ट करने के बजाय फ़ाइल को पढ़ने के लिए एक उपयोगिता विधि का उपयोग करना चाहिए। स्वयं एक विधि लिखें, या अपाचे कॉमन्स-आईओ आईओटीटीएल का उपयोग करें। फिर भी, यदि आप अलग-अलग क्लासपैथ के साथ बहुत सारी फालतू परियोजनाएँ बनाते हैं, तो किसी फ़ाइल को पढ़ने के लिए आपके उपयोगिता वर्ग में एक JAR या लिंक जोड़ना एक दर्द हो सकता है। कभी-कभी आपको बस कुछ फेंकने वाले कोड लिखने की ज़रूरत होती है जो एक फ़ाइल पढ़ता है, और अपने जीवन के साथ मिलता है।

— माइक क्लार्क

जावा 7 में, StandardCharsets.UTF_8अधिक पसंद करें Charset.forName("UTF-8")।

— माइक क्लार्क

Answer 3

एक स्ट्रिंग प्रारूपित करें

MessageFormat - MessageFormat के साथ चयन को घेर लें।

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

यह मुझे एक स्ट्रिंग को कर्सर ले जाने देता है, चयन को पूरे स्ट्रिंग (Shift-Alt-Up) तक बढ़ाता है, फिर दो बार Ctrl-Space।

चयन लॉक करें

लॉक - एक अंत में लॉक के साथ चयनित लाइनों को घेरें। एक लॉक चर की उपस्थिति मान लें।

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

NB ${line_selection}टेम्पलेट्स मेनू (Alt-Shift-Z) के साथ चारों ओर दिखाई देते हैं ।

Comments

मैं इसे लॉग स्टेटमेंट्स के साथ संयुक्त रूप से उपयोग करता हूं: logger.info (MessageFormat.format ($ {word_selection}, $ {कर्सर});

— पियरे हेनरी

ताले प्राप्त करने और जारी करने के तरीकों को कहा जाता है lockऔर unlock। acquireऔर releaseसेमाफोर के लिए उपयोग किया जाता है और एक कोशिश के अंत में उनके उपयोग को ताले के साथ दृढ़ता से सलाह नहीं दी जाती है ।

— मार्को लैकोविक

Ctrl + Space दो बार किसी भी अधिक काम नहीं करता है, SWT टेम्प्लेट लाता है। क्या कोई प्रतिस्थापन है?

— नौमेनन

Answer 4

मुझे पता है कि मैं एक मृत पोस्ट को मार रहा हूं, लेकिन इसे पूरा करने के लिए साझा करना चाहता हूं:

सिंगलटन पीढ़ी टेम्पलेट का एक सही संस्करण, जो त्रुटिपूर्ण डबल-चेक लॉकिंग डिज़ाइन (ऊपर चर्चा की गई है और जहाँ उल्लेख किया गया है) से अधिक है।

सिंगलटन क्रिएशन टेम्प्लेट: इसे नाम दें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();

Comments

यह मृत नहीं है, यह सामुदायिक विकी है, इसलिए यह समझ में आता है कि आप इसे खोजने के लिए और अधिक टेम्पलेट जोड़ सकते हैं। वहाँ वास्तव में इन कहीं और का एक व्यापक सेट नहीं है ...

— जॉन

जॉन, पहले के पोस्ट और मेरी पोस्ट के बीच का समय अंतराल लगभग 8 महीने था, जो कि ऐसा करने के लिए मजबूर था। मैं इसे आपकी टिप्पणी से बेहतर नहीं बता सकता :)

— खोजकर्ता

जब मैं इसे एक वर्ग (एक नेस्टेड एनम इन ए क्लास) के हिस्से के रूप में बनाता हूं तो मुझे कक्षा का नाम इस प्रकार मिलता है ${enclosing_type}- इरादा?

— Mr_and_Mrs_D

@Mr_and_Mrs_D, मुझे लगता है कि बात है। आपको उस वर्ग का एक एकल उदाहरण मिलता है जिसमें आपने यह खाका डाला है। अब आपको बस इतना करना है कि एन्क्लोजिंग टाइप कंस्ट्रक्टर को निजी बनाएं और एक बहुत ही सुरक्षित सिंगलटन जेनरेटर रखें।

— माइक एडलर

यदि आप एनम का उपयोग ${primary_type_name}उदाहरण बनाने के लिए इसका उपयोग करना चाहते हैं :public enum ${primary_type_name} { INSTANCE; private ${return_type} ${name} = new ${return_type}(); public ${return_type} ${getName}(${}) { return ${name}; } ${cursor} }

— रॉबर्ट स्मिट

Answer 5

इस पर पुनरावृत्ति करने के लिए कोड स्निपेट संलग्न करें 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();
    |
}

Comments

आपकी तस्वीर की तरह, यह मुझे दिखाता है कि आप एक चर का उपयोग कर सकते हैं ${}और इसके बजाय ${cursor}, खेतों के बीच "टैब पुनरावृत्ति" को सक्षम करता है। धन्यवाद।

— पश्चिमीगंज

Answer 6

के लिए log, सदस्य चर में जोड़ने के लिए एक सहायक थोड़ा किटी।

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

Comments

मैन्युअल रूप से एक लॉग फ़ाइल में लिखने के लिए: $ {: import (java.io.PrintWriter, java.io.BufferedWriter, java.io.FileWriter)} कोशिश करें {PrintWriter बाहर = नया वेबवॉटर (नया बफरवार्ड (नया FileWriter) ($ {logFile:) var (स्ट्रिंग)}, सच))); out.println ($ {logline: var (स्ट्रिंग)} $ {कर्सर}); out.close (); } पकड़ (IOException e) {/ * TODO: अपवाद हैंडलिंग * / e.printStackTrace (); }

— जैक मिलर

Answer 7

मॉकिटो के साथ एक मॉक बनाएं ("जावा स्टेटमेंट्स" संदर्भ में):

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

और "जावा प्रकार के सदस्य" में:

${: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 (और हैशसेट और हैशमप के समान) का उपयोग करके नई लिंक की गई सूची:

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

Comments

मैं उत्सुक हूं: आपको लकड़हारे का मजाक उड़ाने की जरूरत क्यों पड़ेगी?

— व्लादिमीर सिज़िकोव

आप सत्यापित कर सकते हैं कि यदि कोई अपवाद पकड़ा गया था (विफलता परिदृश्य) तो नकली लकड़हारे को बुलाया गया था। यदि आप इसे फिर से उखाड़ फेंकने का इरादा नहीं रखते हैं, लेकिन ऐसा नहीं है तो इसे अनदेखा न करें।

— मन्त्रिद

Answer 8

अशक्त जाँच!

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

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

Comments

PreConditions.checkNotNull(...)अमरूद में विधि एक बहुत ही पठनीय विकल्प (विशेष रूप से स्थिर आयात के साथ)

— Thorbjorn Ravn एंडरसन

अशक्त न होने के लिए जाँच करने से पहले पहले अशक्त (== अशक्त) की जाँच करना सबसे अच्छा अभ्यास है।

— कृष्णप्रभाकर

Answer 9

मेरे प्रिय से एक foreach :

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

और ट्रेसआउट , क्योंकि मैं इसे ट्रैकिंग के लिए बहुत उपयोग कर रहा हूं:

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

मैं तो बस एक दूसरे के बारे में सोचा और इंटरनेट कुछ दिन, पर यह पाया है स्थिरांक :

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

Comments

फॉरचैक ग्रहण में एक मानक कोड सहायता के रूप में उपलब्ध है, मैं नहीं देखता कि आपका टेम्पलेट मानक संस्करण के लिए अतिरिक्त कुछ भी करता है

— रिच सेलर

सही, और sysout बहुत नवीन टेम्पलेट है। प्रश्न संबंधित था, उपयोगी टेम्प्लेट जो हम उपयोग कर रहे हैं।

— आर्टेम बारगर

आपके traceoutग्रहण में पहले से ही उपलब्ध है systrace।

— dogbane

अच्छा, मुझे विश्वास है कि यह इस प्रश्न के कारण ग्रहण में अब प्रकट होता है।

— आर्टेम बार्गर

const एक मानक कोड असिस्ट के रूप में उपलब्ध है, जबकि static_final (सुनिश्चित नहीं है कि इसे कब जोड़ा गया था)

— आर्मंड

Answer 10

Sysout पर थोड़ा टिप - मुझे इसका नाम बदलकर "sop" करना पसंद है। जावा लिबास में और कुछ भी "सोप" से शुरू नहीं होता है, इसलिए आप जल्दी से "सोप" और बूम टाइप कर सकते हैं, यह सम्मिलित करता है।

Comments

डिफ़ॉल्ट रूप से, बस टाइपिंग सिस्सो ही sysout के रूप में करेगा।

— मास्टरस्कैट

सोप के साथ फिर से 25% से हराया, हालांकि ...;)

— स्कॉट स्टैनफील्ड ने

चूंकि ग्रहण मंगल के शॉर्टकट "सिसो" + Ctrl + स्पेस पर एक खराब कदम है, यह कुछ वर्गों को सूचीबद्ध करेगा, जिनके नाम में वर्ण, y, s और o हैं (नए कैमलकेसे ढूंढने के कारण)। इसलिए, अब आपको सूची से sysout को चुनना होगा और रिटर्न को दबाना होगा।

— बोबेल

Answer 11

मौजूदा दायरे (चर) में परिवर्तन के साथ एक अवैध अतिक्रमण अपवाद को फेंक दें:

throw new IllegalArgumentException(${var});

बेहतर

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

Answer 12

कोड उत्पादन के लिए कुछ भी नहीं फैंसी - लेकिन कोड समीक्षा के लिए काफी उपयोगी है

मेरे पास मेरा टेम्पलेट है कोडरव निम्न / मेड / उच्च निम्न करते हैं

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

और फिर कार्य दृश्य में - मुझे उन सभी कोड समीक्षा टिप्पणियों को दिखाया जाएगा जो मैं एक बैठक के दौरान लाना चाहता हूं।

Answer 13

कुछ और टेम्प्लेट यहाँ ।

शामिल हैं:

• किसी विशेष दिनांक से दिनांक ऑब्जेक्ट बनाएँ
• एक नया जेनेरिक ArrayList बनाएँ
• लकड़हारा सेटअप
• निर्दिष्ट स्तर के साथ लॉग इन करें
• एक नया सामान्य HashMap बनाएँ
• एक नक्शे के माध्यम से, कुंजी और मूल्यों को प्रिंट करें
• SimpleDateFormat का उपयोग कर एक समय पार्स
• एक फ़ाइल लाइन लाइन द्वारा पढ़ें
• लॉग इन करें और एक पकड़ा exeption को उखाड़ फेंकें
• कोड के एक ब्लॉक का प्रिंट निष्पादन समय
• समय-समय पर टाइमर बनाएँ
• एक फ़ाइल के लिए एक स्ट्रिंग लिखें

Comments

एक तरह से मशीन लिंक जोड़ा गया

— berezovskyi

Answer 14

slf4j लॉगिंग

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

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

Answer 15

बीन संपत्ति

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

Answer 16

पोस्ट जावा 7, लॉगर को सेट करने का एक शानदार तरीका, जो संलग्न वर्ग के स्थिर संदर्भों की आवश्यकता (या पसंद) है, एक नए संदर्भ में रनटाइम क्लास प्राप्त करने के लिए नए शुरू किए गए मेथडेंडल्स एपीआई का उपयोग करना है।

SLF4J के लिए एक उदाहरण स्निपेट है:

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

किसी भी आईडीई में एक साधारण स्निपेट होने के अलावा, यह भी कम भंगुर है यदि आप किसी अन्य वर्ग में निश्चित कार्यक्षमता को रिफ्लेक्टर करते हैं क्योंकि आप गलती से कक्षा का नाम नहीं लेंगे।

Answer 17

GUI थ्रेड पर कोड लागू करें

मैं slaterGUI थ्रेड पर कोड को जल्दी भेजने के लिए शॉर्टकट के लिए निम्नलिखित टेम्पलेट को बांधता हूं ।

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

Answer 18

जब कोड के साथ परीक्षण किया जाता है तो मुझे कभी-कभी कुछ सीसो को हटाने में चूक हुई । इसलिए मैंने खुद को syt नाम से एक टेम्पलेट बनाया ।

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

संकलित करने से पहले मैं हमेशा अपने TODO की जांच करता हूं और फिर से एक System.out को हटाना कभी नहीं भूलूंगा।

Answer 19

strf -> String.format("msg", args) बहुत सरल है, लेकिन टाइप करने से थोड़ा बचाता है।

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

Comments

मैं उपयोग करता हूं String.format("${string}",${objects})क्योंकि ग्रहण मुझे अपनी स्ट्रिंग और मेरी वस्तुओं की सूची के बीच टैब करने की अनुमति देता है।

— डंकन जोन्स

मैं इस संस्करण का उपयोग करता हूं: String.format(${word_selection}${},)${cursor}पहले एक स्ट्रिंग चुनें, फिर उस पर 'sf' का उपयोग करें। % S

— वगैरह

Answer 20

वर्तमान प्रदर्शन से एक SWT रंग प्राप्त करें:

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

सिन्सेक्स के साथ सुर

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

Comments

बस एक त्वरित ध्यान दें - एक Enum का उपयोग करते हुए जोशुआ बलोच के रूप में जाना जाने वाला मेस्ट्रो के अनुसार, जावा में एकल बनाने के लिए पसंदीदा तरीका होना चाहिए।

— पाब्लोइजम

हाय पाब्लोइजिम, जब से मैंने इस टेम्पलेट को पोस्ट किया है मैंने प्रभावी जावा पढ़ना शुरू कर दिया है और मैंने अपने सिंगलेट्स के कार्यान्वयन को बदल दिया है। फिर भी मुझे एनम जनरेट करने वाले खाके का कोई तरीका नहीं मिला और इस तरह क्लास डिक्लेरेशन को संशोधित करना पड़ा। क्या आपको यह टेम्पलेट मिला है? धन्यवाद मनु

— मैनुएल सेल्वा

FYI करें: यहाँ enum सिंगलटन पैटर्न electrotek.wordpress.com/2008/08/06/… है । मुझे यह पसंद नहीं है, लेकिन फिर मेरे पास कई सिंगलेट्स नहीं हैं। इसे जावा टेम्प्लेट में बदलना आसान है।

— pjp

एनम एप्रोच के लिए, मुझे आशा है कि आपके सभी सिंग्लेटन्स तुलनात्मक, सीरियल करने योग्य वस्तुओं के रूप में समझ में आएंगे, क्योंकि बहुत सारे सिंग्लेटन्स नहीं करते हैं (और उन्हें आश्चर्य होता है कि यह "... दृष्टिकोण अभी तक व्यापक रूप से अपनाया गया है" - क्योंकि तुलनीयता और अनुक्रमिक डॉन 'कुछ

— एकल

Serializable? हाँ। अपने सिंगलटन के संदर्भ के साथ एक वस्तु के क्रमांकन पर विचार करें। यदि यह सीरियल करने योग्य नहीं है, तो आप एक एनपीई का सामना कर सकते हैं। यदि यह है (और आप डिफॉल्ट डे-सीरीज़ाइज़ेशन को ओवरराइट करने के लिए तरीके नहीं जोड़ते हैं), तो आपको अपने "सिंगलटन" का एक और उदाहरण मिल सकता है।

— जोहान्स कुह्न

Answer 21

और एक समतुल्य व्यक्ति, हैशकोडबिल्डर अनुकूलन:

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

Comments

प्रतिबिंब के बिना किसी समाधान के लिए नीचे दिए

— gswierczynski

Answer 22

लकड़हारा घोषणा के लिए टेम्पलेट बहुत अच्छा है।

मैं लॉग स्तरों के लिए लिनफो, लेडबग, लैवर्न, लेरर भी बनाता हूं जो मैं अक्सर उपयोग करता हूं।

lerror:

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

Answer 23

एक घटना के लिए सब कुछ बनाएँ

चूंकि इवेंट्स जावा में बनाने के लिए एक दर्द हैं - उन सभी इंटरफेस, विधियों और सामान को सिर्फ 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ब्लॉक जहां श्रोताओं की सूची पहुँचा जा रहा है या उपयोग किया है, सूची पर ही ताला लगा।

Comments

एक लॉक (सिंक्रनाइज़ या अन्यथा) में होने के दौरान घटनाओं को भेजना एक गतिरोध की घटना है। इस मामले में श्रोताओं को कॉपी करना बेहतर होगा जबकि एक सिंक्रनाइज़ किए गए ब्लॉक में और नई सूची को पुनरावृत्त करना।

— ssindelar

एक समवर्ती स्तर का उपयोग करें । इसमें लॉकिंग की आवश्यकता नहीं होती है, क्योंकि इसमें एक कमजोर सुसंगत पुनरावृत्ति होती है, जो कभी भी एक समवर्ती मैडिफिकेशन अपवाद को फेंकता नहीं है।

— स्टीफन डॉलस

Answer 24

सम्मिलित परीक्षण विधियाँ दी जानी चाहिए-जब-तब

मैंने हाल ही में एक बहुत ही अच्छे डेवलपर और दोस्त के साथ जोड़ी प्रोग्रामिंग करते समय इसका एक समान संस्करण देखा, और मुझे लगता है कि यह इस सूची में एक अच्छा जोड़ हो सकता है।

यह टेम्पलेट एक क्लास पर एक नया टेस्ट मेथड बनाएगा, दिए जाने के बाद - जब - तब कोड संचालित करने के लिए एक गाइड के रूप में, टिप्पणियों पर व्यवहार-संचालित विकास (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)}

Comments

मुझे वह टेम्पलेट पसंद है। मैंने परीक्षण के आराम को कम करने के लिए एक "थ्रो एक्ससेप्शन" जोड़ा।

— टॉरस्टेन

मुझे बीडीडी प्रतिमान पसंद है। उसके लिए बहुत अच्छा टेम्पलेट। और बस एक नोट: आपका बहुत अच्छा-डेवलपर-और-मित्र चला गया है!

— बोबेल

Answer 25

स्प्रिंग इंजेक्शन

मुझे पता है कि यह खेल के लिए देर से है, लेकिन यहाँ मैं एक वर्ग में स्प्रिंग इंजेक्शन के लिए उपयोग करता हूं:

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

Answer 26

यहाँ गैर-तात्कालिक वर्गों के लिए एक निर्माणकर्ता है:

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

Answer 27

मुझे इस तरह एक उत्पन्न वर्ग टिप्पणी पसंद है:

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

"I ..." तुरंत डेवलपर को यह बताने के लिए प्रोत्साहित करता है कि कक्षा क्या करती है। मुझे अनिर्दिष्ट वर्गों की समस्या में सुधार प्रतीत होता है।

और निश्चित रूप से $ Id $ एक उपयोगी CVS कीवर्ड है।

Answer 28

मैंने इन स्निपेट्स का बहुत उपयोग किया है, जिसकी तलाश है null मूल्यों और खाली तारों की ।

मैं "तर्क परीक्षण" का उपयोग करता हूं-प्राप्त तर्कों को जांचने के लिए मेरे तरीकों में पहले कोड के रूप में।

testNullArgument

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

आप अपनी कंपनी या परियोजना के मानक के अनुरूप अपवाद संदेश को बदलना चाह सकते हैं। हालाँकि, मैं कुछ संदेश रखने की सलाह देता हूं जिसमें आपत्तिजनक तर्क का नाम भी शामिल है। अन्यथा आपकी विधि के कॉलर को समझने के लिए कोड में देखना होगा कि क्या गलत हुआ। (एNullPointerException बिना किसी संदेश के, काफी निरर्थक संदेश "अशक्त" के साथ एक अपवाद पैदा करता है)।

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

आप एक चर नाम या एक शर्त दर्ज करते हैं जो एक मान लौटाता है, जिसके बाद एक ऑपरेंड ("==", "<", ">" आदि) और दूसरा मान या चर होता है और यदि परीक्षण विफल हो जाता है तो परिणामी कोड एक IllegalArgumentception को फेंक देगा।

यदि क्लॉज में पूरी अभिव्यक्ति के साथ ", (") लिपटा हुआ है, तो थोड़ा जटिल होने का कारण अपवाद संदेश में परीक्षण की स्थिति का पुन: उपयोग करना संभव है।

शायद यह एक सहकर्मी को भ्रमित करेगा, लेकिन केवल अगर उन्हें कोड को देखना है, जो कि आपको इस तरह के अपवादों को फेंकने की ज़रूरत नहीं है ...

यहाँ ऐरे के साथ एक उदाहरण दिया गया है:

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" या इसी तरह से मजेदार है और वास्तव में आपके उपयोगकर्ताओं को समस्या का पता लगाने का मौका दे सकता है।

का आनंद लें!

Answer 29

मैं MessageFormat (जावा 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));
}

Answer 30

मेरे पसंदीदा कुछ हैं ...

1: Javadoc, एक स्प्रिंग ऑब्जेक्ट इंजेक्शन विधि होने के तरीके के बारे में डॉक्टर को सम्मिलित करने के लिए।

 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: डिबग विंडो, एक 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();