View Javadoc

1   package org.codehaus.xfire.annotations.jsr181;
2   
3   import java.lang.annotation.Annotation;
4   import java.lang.reflect.Method;
5   
6   import javax.jws.HandlerChain;
7   import javax.jws.Oneway;
8   import javax.jws.WebMethod;
9   import javax.jws.WebParam;
10  import javax.jws.WebResult;
11  import javax.jws.WebService;
12  import javax.jws.soap.SOAPBinding;
13  
14  import org.codehaus.xfire.annotations.HandlerChainAnnotation;
15  import org.codehaus.xfire.annotations.WebAnnotations;
16  import org.codehaus.xfire.annotations.WebMethodAnnotation;
17  import org.codehaus.xfire.annotations.WebParamAnnotation;
18  import org.codehaus.xfire.annotations.WebResultAnnotation;
19  import org.codehaus.xfire.annotations.WebServiceAnnotation;
20  import org.codehaus.xfire.annotations.soap.SOAPBindingAnnotation;
21  
22  public class Jsr181WebAnnotations
23          implements WebAnnotations
24  {
25      public boolean hasWebServiceAnnotation(Class clazz)
26      {
27          return clazz.isAnnotationPresent(WebService.class);
28      }
29  
30      public WebServiceAnnotation getWebServiceAnnotation(Class clazz)
31      {
32          WebService webService = (WebService) clazz.getAnnotation(WebService.class);
33          if (webService != null)
34          {
35              WebServiceAnnotation annotation = new WebServiceAnnotation();
36              annotation.setEndpointInterface(webService.endpointInterface());
37              annotation.setName(webService.name());
38              annotation.setServiceName(webService.serviceName());
39              annotation.setTargetNamespace(webService.targetNamespace());
40  
41              return annotation;
42          }
43          else
44          {
45              return null;
46          }
47      }
48  
49      public boolean hasWebMethodAnnotation(Method method)
50      {
51          return method.isAnnotationPresent(WebMethod.class);
52      }
53  
54      public WebMethodAnnotation getWebMethodAnnotation(Method method)
55      {
56          WebMethod webMethod = (WebMethod) method.getAnnotation(WebMethod.class);
57          if (webMethod != null)
58          {
59              WebMethodAnnotation annotation = new WebMethodAnnotation();
60              annotation.setAction(webMethod.action());
61              annotation.setOperationName(webMethod.operationName());
62  
63              return annotation;
64          }
65          else
66          {
67              return null;
68          }
69      }
70  
71      public boolean hasWebResultAnnotation(Method method)
72      {
73          return method.isAnnotationPresent(WebResult.class);
74      }
75  
76      public WebResultAnnotation getWebResultAnnotation(Method method)
77      {
78          Annotation[][] annotations = method.getParameterAnnotations();
79          WebResult webResult = (WebResult) method.getAnnotation(WebResult.class);
80          if (webResult != null)
81          {
82              WebResultAnnotation annot = new WebResultAnnotation();
83              annot.setName(webResult.name());
84              annot.setTargetNamespace(webResult.targetNamespace());
85  
86              return annot;
87          }
88          else
89          {
90              return null;
91          }
92      }
93  
94      public boolean hasWebParamAnnotation(Method method, int parameter)
95      {
96          Annotation[][] annotations = method.getParameterAnnotations();
97          if (parameter >= annotations.length)
98          {
99              return false;
100         }
101         else
102         {
103             for (int i = 0; i < annotations[parameter].length; i++)
104             {
105                 Annotation annotation = annotations[parameter][i];
106                 if (annotation.annotationType().equals(WebParam.class))
107                 {
108                     return true;
109                 }
110             }
111             return false;
112         }
113     }
114 
115     public WebParamAnnotation getWebParamAnnotation(Method method, int parameter)
116     {
117         Annotation[][] annotations = method.getParameterAnnotations();
118         if (parameter >= annotations.length)
119         {
120             return null;
121         }
122         WebParam webParam = null;
123         for (int i = 0; i < annotations[parameter].length; i++)
124         {
125             Annotation annotation = annotations[parameter][i];
126             if (annotation.annotationType().equals(WebParam.class))
127             {
128                 webParam = (WebParam) annotations[parameter][i];
129                 break;
130             }
131         }
132         if (webParam != null)
133         {
134             WebParamAnnotation annot = new WebParamAnnotation();
135             annot.setName(webParam.name());
136             annot.setTargetNamespace(webParam.targetNamespace());
137             annot.setHeader(webParam.header());
138 
139             if (webParam.mode() == WebParam.Mode.IN)
140             {
141                 annot.setMode(WebParamAnnotation.MODE_IN);
142             }
143             else if (webParam.mode() == WebParam.Mode.INOUT)
144             {
145                 annot.setMode(WebParamAnnotation.MODE_INOUT);
146             }
147             else if (webParam.mode() == WebParam.Mode.OUT)
148             {
149                 annot.setMode(WebParamAnnotation.MODE_OUT);
150             }
151 
152             return annot;
153         }
154         else
155         {
156             return null;
157         }
158     }
159 
160     public boolean hasOnewayAnnotation(Method method)
161     {
162         return method.isAnnotationPresent(Oneway.class);
163     }
164 
165     public boolean hasSOAPBindingAnnotation(Class clazz)
166     {
167         return clazz.isAnnotationPresent(SOAPBinding.class);
168     }
169 
170     public SOAPBindingAnnotation getSOAPBindingAnnotation(Class clazz)
171     {
172         SOAPBinding binding = (SOAPBinding) clazz.getAnnotation(SOAPBinding.class);
173 
174         SOAPBindingAnnotation annot = null;
175         if (binding != null)
176         {
177             annot = new SOAPBindingAnnotation();
178             if (binding.parameterStyle() == SOAPBinding.ParameterStyle.BARE)
179             {
180                 annot.setParameterStyle(SOAPBindingAnnotation.PARAMETER_STYLE_BARE);
181             }
182             else if (binding.parameterStyle() == SOAPBinding.ParameterStyle.WRAPPED)
183             {
184                 annot.setParameterStyle(SOAPBindingAnnotation.PARAMETER_STYLE_WRAPPED);
185             }
186 
187             if (binding.style() == SOAPBinding.Style.DOCUMENT)
188             {
189                 annot.setStyle(SOAPBindingAnnotation.STYLE_DOCUMENT);
190             }
191             else if (binding.style() == SOAPBinding.Style.RPC)
192             {
193                 annot.setStyle(SOAPBindingAnnotation.STYLE_RPC);
194             }
195 
196             if (binding.use() == SOAPBinding.Use.ENCODED)
197             {
198                 annot.setUse(SOAPBindingAnnotation.USE_ENCODED);
199             }
200             else if (binding.use() == SOAPBinding.Use.LITERAL)
201             {
202                 annot.setUse(SOAPBindingAnnotation.USE_LITERAL);
203             }
204         }
205 
206         return annot;
207     }
208 
209     public boolean hasHandlerChainAnnotation(Class clazz)
210     {
211         return clazz.isAnnotationPresent(HandlerChain.class);
212     }
213 
214     public HandlerChainAnnotation getHandlerChainAnnotation(Class clazz)
215     {
216         HandlerChain handlerChain = (HandlerChain) clazz.getAnnotation(HandlerChain.class);
217         HandlerChainAnnotation annotation = null;
218         if (handlerChain != null)
219         {
220             annotation = new HandlerChainAnnotation(handlerChain.file(), 
221                                                     handlerChain.name());
222         }
223         return annotation;
224     }
225 }