KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > jdon > model > handler > HandlerMethodMetaArgsFactory


1 /**
2  * Copyright 2003-2006 the original author or authors.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6
7  http://www.apache.org/licenses/LICENSE-2.0
8
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15
16 package com.jdon.model.handler;
17
18 import com.jdon.bussinessproxy.meta.MethodMetaArgs;
19 import com.jdon.controller.events.EventModel;
20 import com.jdon.util.Debug;
21
22 /**
23  * Meta Method Factory. in jdonframework.xml:
24  *
25  * <handler>
26  * <service ref="accountService">
27  * <initMethod name="initAccount" />
28  * <getMethod name="getAccount" />
29  * <createMethod name="insertAccount" />
30  * <updateMethod name="updateAccount" />
31  * <deleteMethod name="deleteAccount" />
32  * </service>
33  * </handler>
34  *
35  *
36  *
37  *
38  * @author banq
39  */
40 public class HandlerMethodMetaArgsFactory {
41     private final static String JavaDoc module = HandlerMethodMetaArgsFactory.class
42             .getName();
43
44     /**
45      * create init method
46      *
47      * @param handlerMetaDef
48      * @return MethodMetaArgs instance
49      */
50     public MethodMetaArgs createinitMethod(HandlerMetaDef handlerMetaDef,
51             EventModel em) {
52         String JavaDoc p_methodName = handlerMetaDef.getInitMethod();
53         if (p_methodName == null)
54             return null;
55         return createCRUDMethodMetaArgs(p_methodName, em);
56     }
57
58     /**
59      * create find method
60      * the service's find method parameter type must be String type
61      *
62      * @param handlerMetaDef
63      * @param keyValue
64      * @return MethodMetaArgs instance
65      */
66     public MethodMetaArgs createGetMethod(HandlerMetaDef handlerMetaDef,
67             Object JavaDoc keyValue) {
68
69         String JavaDoc p_methodName = handlerMetaDef.getFindMethod();
70         if (p_methodName == null) {
71             Debug
72                     .logError(
73                             "[JdonFramework] not configure the findMethod parameter: <getMethod name=XXXXX /> ",
74                             module);
75         }
76         if (keyValue == null) {
77             Debug.logError("[JdonFramework] not found model's key value:"+ handlerMetaDef.getModelMapping().getKeyName()+"=? in request parameters", module);
78         }
79         return createCRUDMethodMetaArgs(p_methodName, keyValue);
80     }
81
82     /**
83      * create insert/create method
84      * the service/s method parameter type must be EventModel type;
85      *
86      * @param handlerMetaDef
87      * @param em
88      * @return MethodMetaArgs instance
89      */
90     public MethodMetaArgs createCreateMethod(HandlerMetaDef handlerMetaDef,
91             EventModel em) {
92
93         String JavaDoc p_methodName = handlerMetaDef.getCreateMethod();
94         if (p_methodName == null) {
95             Debug
96                     .logError(
97                             "[JdonFramework] not configure the createMethod parameter: <createMethod name=XXXXX /> ",
98                             module);
99         }
100         return createCRUDMethodMetaArgs(p_methodName, em);
101     }
102
103     /**
104      *
105      * create update method
106      * the service/s method parameter type must be EventModel type;
107      *
108      * @param handlerMetaDef
109      * @param em
110      * @return MethodMetaArgs instance
111      */
112     public MethodMetaArgs createUpdateMethod(HandlerMetaDef handlerMetaDef,
113             EventModel em) {
114
115         String JavaDoc p_methodName = handlerMetaDef.getUpdateMethod();
116         if (p_methodName == null) {
117             Debug
118                     .logError(
119                             "[JdonFramework] not configure the updateMethod parameter: <updateMethod name=XXXXX /> ",
120                             module);
121         }
122         return createCRUDMethodMetaArgs(p_methodName, em);
123     }
124
125     /**
126      * create update method
127      * the service/s method parameter type must be EventModel type;
128      *
129      * @param handlerMetaDef
130      * @param em EventModel
131      * @return MethodMetaArgs instance
132      */
133     public MethodMetaArgs createDeleteMethod(HandlerMetaDef handlerMetaDef,
134             EventModel em) {
135
136         String JavaDoc p_methodName = handlerMetaDef.getDeleteMethod();
137         if (p_methodName == null) {
138             Debug
139                     .logError(
140                             "[JdonFramework] not configure the deleteMethod parameter: <deleteMethod name=XXXXX /> ",
141                             module);
142         }
143
144         return createCRUDMethodMetaArgs(p_methodName, em);
145     }
146
147     public MethodMetaArgs createDirectMethod(String JavaDoc methodName,
148             Object JavaDoc[] methodParams) {
149         MethodMetaArgs methodMetaArgs = null;
150         try {
151             if (methodName == null)
152                 throw new Exception JavaDoc(
153                         "no configure method value, but now you call it: ");
154
155             Debug.logVerbose("[JdonFramework] construct " + methodName, module);
156             Class JavaDoc[] paramTypes = new Class JavaDoc[methodParams.length];
157             Object JavaDoc[] p_args = new Object JavaDoc[methodParams.length];
158             for (int i = 0; i < methodParams.length; i++) {
159                 paramTypes[i] = methodParams[i].getClass();
160                 p_args[i] = methodParams[i];
161                 Debug.logVerbose("[JdonFramework], parameter type:"
162                         + paramTypes[i] + " and parameter value:" + p_args[i],
163                         module);
164             }
165             methodMetaArgs = new MethodMetaArgs(methodName, paramTypes, p_args);
166
167         } catch (Exception JavaDoc ex) {
168             Debug.logError("[JdonFramework] createDirectMethod error: " + ex,
169                     module);
170         }
171         return methodMetaArgs;
172     }
173
174     private MethodMetaArgs createCRUDMethodMetaArgs(String JavaDoc p_methodName,
175             Object JavaDoc args) {
176         MethodMetaArgs methodMetaArgs = null;
177         try {
178             Class JavaDoc[] paramTypes = new Class JavaDoc[1];
179             paramTypes[0] = args.getClass();
180             Object JavaDoc[] p_args = new Object JavaDoc[1];
181             p_args[0] = args;
182             methodMetaArgs = new MethodMetaArgs(p_methodName, paramTypes,
183                     p_args);
184             Debug.logVerbose("[JdonFramework] construct "
185                     + methodMetaArgs.getMethodName() + ", parameter type:"
186                     + paramTypes[0], module);
187         } catch (Exception JavaDoc ex) {
188             Debug.logError("[JdonFramework] create CRUD method error: " + ex,
189                     module);
190         }
191         return methodMetaArgs;
192     }
193
194 }
195
Popular Tags