डेकोरेटर जावा

Question

में मैं अजगर में डेकोरेटर example के बारे में देखें:

def makebold(fn): 
    def wrapped(): 
     return "<b>" + fn() + "</b>" 
    return wrapped 

def makeitalic(fn): 
    def wrapped(): 
     return "<i>" + fn() + "</i>" 
    return wrapped 

@makebold 
@makeitalic 
def hello(): 
    return "hello world" 

print hello() ## returns <b><i>hello world</i></b> 

और कुछ उत्सुक हो गया कि यह कैसे जावा में लागू किया जा सकता है, तो मैं खोज और कुछ Decorator Design Pattern का उपयोग कर उदाहरण मिला है।

public class Main { 

    public static void main(String[] args) { 
     Wrapper word = new BoldWrapper(new ItalicWrapper()); 
     // display <b><i>hello world</i></b> 
     System.out.println(word.make("Hello World")); 
    } 
} 

public interface Wrapper { 

    public String make(String str); 

} 

public class BoldWrapper implements Wrapper { 

    private Wrapper wrapper; 

    public BoldWrapper() { 

    } 

    public BoldWrapper(Wrapper wrapper) { 
     this.wrapper = wrapper; 
    } 

    @Override 
    public String make(String str) { 
     if(wrapper != null) { 
      str = wrapper.make(str); 
     } 

     return "<b>" + str + "</b>"; 
    } 

} 

public class ItalicWrapper implements Wrapper { 

    private Wrapper wrapper; 

    public ItalicWrapper() { 

    } 

    public ItalicWrapper(Wrapper wrapper) { 
     this.wrapper = wrapper; 
    } 

    @Override 
    public String make(String str) { 
     if(wrapper != null) { 
      str = wrapper.make(str); 
     } 

     return "<i>" + str + "</i>"; 
    } 

} 

मैं इस एक की तरह एक जावा एनोटेशन का उपयोग करके उपरोक्त अजगर उदाहरण की तरह इस बनाने के लिए कैसे करें:

public class Main { 
    public static void main(String[] args) { 
     @BoldWrapper 
     @ItalicWrapper 
     String str = "Hello World"; 
     // Display <b><i>Hello World</i></b> 
    } 
} 

public @interface BoldWrapper { 
    public void wrap() default "<b>" + str + "</b>"; 
} 

public @interface ItalicWrapper { 
    public void wrap() default "<i>" + str + "</i>"; 
} 

मैं कुछ समस्या हो गया, जब मैं नमूना करने की कोशिश की, समस्या मैं है पता नहीं कैसे मैं BoldWrapper और ItalicWrapper को main विधि से str मूल्य पारित कर सकते हैं तो यह और जोड़ सकते हैं कि यह कैसे वापस जाने के लिए है, तो main विधि परिणाम प्रदर्शित कर सकती है जो को जोड़ती है।

कृपया सलाह दें कि एनोटेशन की मेरी समझ में कुछ गड़बड़ है या नहीं।

Answer 1

1) आपके द्वारा उद्धृत लिंक एक अच्छा है - यह जावा के संबंध में "सजावटी पैटर्न" का न्याय करता है। "डिजाइन पैटर्न" खुद जाहिर है, किसी विशेष OO भाषा से स्वतंत्र हैं:

• When to use the decorator pattern

:

• http://en.wikipedia.org/wiki/Design_Patterns

2) यहाँ एक और अच्छा कड़ी है

जावा में, सजावटी पैटर्न का एक शास्त्रीय उदाहरण जावा I/O स्ट्रीम कार्यान्वयन है।

FileReader  frdr = new FileReader(filename); 
LineNumberReader lrdr = new LineNumberReader(frdr); 

4) तो हाँ, "सजावटी पैटर्न" इस समस्या के लिए एक अच्छा उम्मीदवार है।)

String myHtml = 
    new BoldText (
     new ItalicText (
     new HtmlText ("See spot run"))); 

5 हालांकि एनोटेशन भी एक विकल्प हैं:

व्यक्तिगत रूप से, मैं समाधान इस तरह पसंद करेंगे। उदाहरण के लिए:

• http://docs.oracle.com/javase/1.5.0/docs/guide/language/annotations.html

Answer 2

आप विशेष रूप से एनोटेशन के साथ सामान इस तरह का कर रही में रुचि रखते हैं (अगर तुम सच में की जरूरत नहीं है):

यह उदाहरण मिलना चाहिए आप शुरू कर दिया:

public class AnnotationTest 
{ 
    @Target(ElementType.METHOD) 
    @Retention(RetentionPolicy.RUNTIME) 
    public static @interface TagWrapper 
    { 
     public String[] value() default {}; 
    } 

    public static interface TextFragment 
    { 
     public String getText(); 
    } 

    public static class TagWrapperProcessor 
    { 
     public static String getWrapperTextFragment(TextFragment fragment) 
     { 
      try 
      { 
       Method getText = fragment.getClass().getMethod("getText"); 
       TagWrapper tagWrapper = getText.getAnnotation(TagWrapper.class); 
       String formatString = "<%s>%s</%s>"; 
       String result = (String) getText.invoke(fragment); 
       for (String tag : tagWrapper.value()) 
       { 
        result = String.format(formatString, tag, result, tag); 
       } 
       return result; 
      } 
      catch (Exception e) 
      { 
       throw new RuntimeException(e); 
      } 
     } 
    } 

    public static class BoldItalicFragment implements TextFragment 
    { 

     private String _text; 

     public BoldItalicFragment(String text) 
     { 
      _text = text; 
     } 

     @Override 
     @TagWrapper(
     { 
      "b", "i" 
     }) 
     public String getText() 
     { 
      return _text; 
     } 

    } 

    @Test 
    public void testStuff() 
    { 
     System.out.println(TagWrapperProcessor.getWrapperTextFragment(new BoldItalicFragment("Hello, World!"))); // prints: <i><b>Hello, World!</b></i> 
    } 
} 

Answer 3

हालांकि यह "सजावट डिजाइन" का उपयोग करने के बजाय एनोटेशन का उपयोग करने का तरीका हल नहीं करता है, मैं प्रस्तावित कर सकता हूं यदि आप अपनी आवश्यकताओं के लिए बेहतर सूट करते हैं तो यह "बिल्डर डिजाइन" का उपयोग करता है (ऐसा लगता है)।

त्वरित उपयोग का उदाहरण:

public class BuilderPatternExample { 

    public static void main(String args[]) { 

     //Creating object using Builder pattern in java 
     Cake whiteCake = new Cake.Builder() 
           .sugar(1) 
           .butter(0.5) 
           .eggs(2) 
           .vanilla(2) 
           .flour(1.5) 
           .bakingPowder(0.75) 
           .milk(0.5) 
           .build(); 

     //Cake is ready to eat :) 
     System.out.println(whiteCake); 
    } 
} 

आउटपुट: केक {चीनी = 0.75, मक्खन = 0.5, अंडे = 2, वनीला = 2, आटा = 1.5, bakingpowder = 0.0, दूध = 0.5, चेरी = 0}

पूर्ण कार्यान्वयन और एक बहुत अच्छा विवरण के लिए, कृपया जाँच http://javarevisited.blogspot.mx/2012/06/builder-design-pattern-in-java-example.html