View Javadoc
1   /**
2    *    Copyright 2006-2016 the original author or authors.
3    *
4    *    Licensed under the Apache License, Version 2.0 (the "License");
5    *    you may not use this file except in compliance with the License.
6    *    You may obtain a copy of the License at
7    *
8    *       http://www.apache.org/licenses/LICENSE-2.0
9    *
10   *    Unless required by applicable law or agreed to in writing, software
11   *    distributed under the License is distributed on an "AS IS" BASIS,
12   *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   *    See the License for the specific language governing permissions and
14   *    limitations under the License.
15   */
16  package org.mybatis.generator.codegen.ibatis2.dao;
17  
18  import static org.mybatis.generator.internal.util.StringUtility.stringHasValue;
19  import static org.mybatis.generator.internal.util.messages.Messages.getString;
20  
21  import java.util.ArrayList;
22  import java.util.List;
23  
24  import org.mybatis.generator.api.CommentGenerator;
25  import org.mybatis.generator.api.FullyQualifiedTable;
26  import org.mybatis.generator.api.dom.java.CompilationUnit;
27  import org.mybatis.generator.api.dom.java.Field;
28  import org.mybatis.generator.api.dom.java.FullyQualifiedJavaType;
29  import org.mybatis.generator.api.dom.java.Interface;
30  import org.mybatis.generator.api.dom.java.JavaVisibility;
31  import org.mybatis.generator.api.dom.java.Method;
32  import org.mybatis.generator.api.dom.java.TopLevelClass;
33  import org.mybatis.generator.codegen.AbstractJavaClientGenerator;
34  import org.mybatis.generator.codegen.AbstractXmlGenerator;
35  import org.mybatis.generator.codegen.ibatis2.dao.elements.AbstractDAOElementGenerator;
36  import org.mybatis.generator.codegen.ibatis2.dao.elements.CountByExampleMethodGenerator;
37  import org.mybatis.generator.codegen.ibatis2.dao.elements.DeleteByExampleMethodGenerator;
38  import org.mybatis.generator.codegen.ibatis2.dao.elements.DeleteByPrimaryKeyMethodGenerator;
39  import org.mybatis.generator.codegen.ibatis2.dao.elements.InsertMethodGenerator;
40  import org.mybatis.generator.codegen.ibatis2.dao.elements.InsertSelectiveMethodGenerator;
41  import org.mybatis.generator.codegen.ibatis2.dao.elements.SelectByExampleWithBLOBsMethodGenerator;
42  import org.mybatis.generator.codegen.ibatis2.dao.elements.SelectByExampleWithoutBLOBsMethodGenerator;
43  import org.mybatis.generator.codegen.ibatis2.dao.elements.SelectByPrimaryKeyMethodGenerator;
44  import org.mybatis.generator.codegen.ibatis2.dao.elements.UpdateByExampleParmsInnerclassGenerator;
45  import org.mybatis.generator.codegen.ibatis2.dao.elements.UpdateByExampleSelectiveMethodGenerator;
46  import org.mybatis.generator.codegen.ibatis2.dao.elements.UpdateByExampleWithBLOBsMethodGenerator;
47  import org.mybatis.generator.codegen.ibatis2.dao.elements.UpdateByExampleWithoutBLOBsMethodGenerator;
48  import org.mybatis.generator.codegen.ibatis2.dao.elements.UpdateByPrimaryKeySelectiveMethodGenerator;
49  import org.mybatis.generator.codegen.ibatis2.dao.elements.UpdateByPrimaryKeyWithBLOBsMethodGenerator;
50  import org.mybatis.generator.codegen.ibatis2.dao.elements.UpdateByPrimaryKeyWithoutBLOBsMethodGenerator;
51  import org.mybatis.generator.codegen.ibatis2.dao.templates.AbstractDAOTemplate;
52  import org.mybatis.generator.config.PropertyRegistry;
53  import org.mybatis.generator.internal.rules.Rules;
54  
55  /**
56   * 
57   * @author Jeff Butler
58   * 
59   */
60  public class DAOGenerator extends AbstractJavaClientGenerator {
61  
62      private AbstractDAOTemplate daoTemplate;
63      private boolean generateForJava5;
64  
65      public DAOGenerator(AbstractDAOTemplate daoTemplate,
66              boolean generateForJava5) {
67          super(true);
68          this.daoTemplate = daoTemplate;
69          this.generateForJava5 = generateForJava5;
70      }
71  
72      @Override
73      public List<CompilationUnit> getCompilationUnits() {
74          FullyQualifiedTable table = introspectedTable.getFullyQualifiedTable();
75          progressCallback.startTask(getString(
76                  "Progress.14", table.toString())); //$NON-NLS-1$
77          TopLevelClass topLevelClass = getTopLevelClassShell();
78          Interface interfaze = getInterfaceShell();
79  
80          addCountByExampleMethod(topLevelClass, interfaze);
81          addDeleteByExampleMethod(topLevelClass, interfaze);
82          addDeleteByPrimaryKeyMethod(topLevelClass, interfaze);
83          addInsertMethod(topLevelClass, interfaze);
84          addInsertSelectiveMethod(topLevelClass, interfaze);
85          addSelectByExampleWithBLOBsMethod(topLevelClass, interfaze);
86          addSelectByExampleWithoutBLOBsMethod(topLevelClass, interfaze);
87          addSelectByPrimaryKeyMethod(topLevelClass, interfaze);
88          addUpdateByExampleParmsInnerclass(topLevelClass, interfaze);
89          addUpdateByExampleSelectiveMethod(topLevelClass, interfaze);
90          addUpdateByExampleWithBLOBsMethod(topLevelClass, interfaze);
91          addUpdateByExampleWithoutBLOBsMethod(topLevelClass, interfaze);
92          addUpdateByPrimaryKeySelectiveMethod(topLevelClass, interfaze);
93          addUpdateByPrimaryKeyWithBLOBsMethod(topLevelClass, interfaze);
94          addUpdateByPrimaryKeyWithoutBLOBsMethod(topLevelClass, interfaze);
95  
96          List<CompilationUnit> answer = new ArrayList<CompilationUnit>();
97          if (context.getPlugins().clientGenerated(interfaze,
98                  topLevelClass, introspectedTable)) {
99              answer.add(topLevelClass);
100             answer.add(interfaze);
101         }
102 
103         return answer;
104     }
105 
106     protected TopLevelClass getTopLevelClassShell() {
107         FullyQualifiedJavaType interfaceType = new FullyQualifiedJavaType(
108                 introspectedTable.getDAOInterfaceType());
109         FullyQualifiedJavaType implementationType = new FullyQualifiedJavaType(
110                 introspectedTable.getDAOImplementationType());
111 
112         CommentGenerator commentGenerator = context.getCommentGenerator();
113 
114         TopLevelClass answer = new TopLevelClass(implementationType);
115         answer.setVisibility(JavaVisibility.PUBLIC);
116         answer.setSuperClass(daoTemplate.getSuperClass());
117         answer.addImportedType(daoTemplate.getSuperClass());
118         answer.addSuperInterface(interfaceType);
119         answer.addImportedType(interfaceType);
120 
121         for (FullyQualifiedJavaType fqjt : daoTemplate
122                 .getImplementationImports()) {
123             answer.addImportedType(fqjt);
124         }
125 
126         commentGenerator.addJavaFileComment(answer);
127 
128         // add constructor from the template
129         answer.addMethod(daoTemplate.getConstructorClone(commentGenerator,
130                 implementationType, introspectedTable));
131 
132         // add any fields from the template
133         for (Field field : daoTemplate.getFieldClones(commentGenerator,
134                 introspectedTable)) {
135             answer.addField(field);
136         }
137 
138         // add any methods from the template
139         for (Method method : daoTemplate.getMethodClones(commentGenerator,
140                 introspectedTable)) {
141             answer.addMethod(method);
142         }
143 
144         return answer;
145     }
146 
147     protected Interface getInterfaceShell() {
148         Interface answer = new Interface(new FullyQualifiedJavaType(
149                 introspectedTable.getDAOInterfaceType()));
150         answer.setVisibility(JavaVisibility.PUBLIC);
151 
152         String rootInterface = introspectedTable
153                 .getTableConfigurationProperty(PropertyRegistry.ANY_ROOT_INTERFACE);
154         if (!stringHasValue(rootInterface)) {
155             rootInterface = context.getJavaClientGeneratorConfiguration()
156                     .getProperty(PropertyRegistry.ANY_ROOT_INTERFACE);
157         }
158 
159         if (stringHasValue(rootInterface)) {
160             FullyQualifiedJavaType fqjt = new FullyQualifiedJavaType(
161                     rootInterface);
162             answer.addSuperInterface(fqjt);
163             answer.addImportedType(fqjt);
164         }
165 
166         for (FullyQualifiedJavaType fqjt : daoTemplate.getInterfaceImports()) {
167             answer.addImportedType(fqjt);
168         }
169 
170         context.getCommentGenerator().addJavaFileComment(answer);
171 
172         return answer;
173     }
174 
175     protected void addCountByExampleMethod(TopLevelClass topLevelClass,
176             Interface interfaze) {
177         if (introspectedTable.getRules().generateCountByExample()) {
178             AbstractDAOElementGenerator methodGenerator = new CountByExampleMethodGenerator(
179                     generateForJava5);
180             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
181                     interfaze);
182         }
183     }
184 
185     protected void addDeleteByExampleMethod(TopLevelClass topLevelClass,
186             Interface interfaze) {
187         if (introspectedTable.getRules().generateDeleteByExample()) {
188             AbstractDAOElementGenerator methodGenerator = new DeleteByExampleMethodGenerator();
189             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
190                     interfaze);
191         }
192     }
193 
194     protected void addDeleteByPrimaryKeyMethod(TopLevelClass topLevelClass,
195             Interface interfaze) {
196         if (introspectedTable.getRules().generateDeleteByPrimaryKey()) {
197             AbstractDAOElementGenerator methodGenerator = new DeleteByPrimaryKeyMethodGenerator();
198             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
199                     interfaze);
200         }
201     }
202 
203     protected void addInsertMethod(TopLevelClass topLevelClass,
204             Interface interfaze) {
205         if (introspectedTable.getRules().generateInsert()) {
206             AbstractDAOElementGenerator methodGenerator = new InsertMethodGenerator();
207             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
208                     interfaze);
209         }
210     }
211 
212     protected void addInsertSelectiveMethod(TopLevelClass topLevelClass,
213             Interface interfaze) {
214         if (introspectedTable.getRules().generateInsertSelective()) {
215             AbstractDAOElementGenerator methodGenerator = new InsertSelectiveMethodGenerator();
216             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
217                     interfaze);
218         }
219     }
220 
221     protected void addSelectByExampleWithBLOBsMethod(
222             TopLevelClass topLevelClass, Interface interfaze) {
223         if (introspectedTable.getRules().generateSelectByExampleWithBLOBs()) {
224             AbstractDAOElementGenerator methodGenerator = new SelectByExampleWithBLOBsMethodGenerator(
225                     generateForJava5);
226             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
227                     interfaze);
228         }
229     }
230 
231     protected void addSelectByExampleWithoutBLOBsMethod(
232             TopLevelClass topLevelClass, Interface interfaze) {
233         if (introspectedTable.getRules().generateSelectByExampleWithoutBLOBs()) {
234             AbstractDAOElementGenerator methodGenerator = new SelectByExampleWithoutBLOBsMethodGenerator(
235                     generateForJava5);
236             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
237                     interfaze);
238         }
239     }
240 
241     protected void addSelectByPrimaryKeyMethod(TopLevelClass topLevelClass,
242             Interface interfaze) {
243         if (introspectedTable.getRules().generateSelectByPrimaryKey()) {
244             AbstractDAOElementGenerator methodGenerator = new SelectByPrimaryKeyMethodGenerator();
245             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
246                     interfaze);
247         }
248     }
249 
250     protected void addUpdateByExampleParmsInnerclass(
251             TopLevelClass topLevelClass, Interface interfaze) {
252         Rules rules = introspectedTable.getRules();
253         if (rules.generateUpdateByExampleSelective()
254                 || rules.generateUpdateByExampleWithBLOBs()
255                 || rules.generateUpdateByExampleWithoutBLOBs()) {
256             AbstractDAOElementGenerator methodGenerator = new UpdateByExampleParmsInnerclassGenerator();
257             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
258                     interfaze);
259         }
260     }
261 
262     protected void addUpdateByExampleSelectiveMethod(
263             TopLevelClass topLevelClass, Interface interfaze) {
264         if (introspectedTable.getRules().generateUpdateByExampleSelective()) {
265             AbstractDAOElementGenerator methodGenerator = new UpdateByExampleSelectiveMethodGenerator();
266             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
267                     interfaze);
268         }
269     }
270 
271     protected void addUpdateByExampleWithBLOBsMethod(
272             TopLevelClass topLevelClass, Interface interfaze) {
273         if (introspectedTable.getRules().generateUpdateByExampleWithBLOBs()) {
274             AbstractDAOElementGenerator methodGenerator = new UpdateByExampleWithBLOBsMethodGenerator();
275             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
276                     interfaze);
277         }
278     }
279 
280     protected void addUpdateByExampleWithoutBLOBsMethod(
281             TopLevelClass topLevelClass, Interface interfaze) {
282         if (introspectedTable.getRules().generateUpdateByExampleWithoutBLOBs()) {
283             AbstractDAOElementGenerator methodGenerator = new UpdateByExampleWithoutBLOBsMethodGenerator();
284             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
285                     interfaze);
286         }
287     }
288 
289     protected void addUpdateByPrimaryKeySelectiveMethod(
290             TopLevelClass topLevelClass, Interface interfaze) {
291         if (introspectedTable.getRules().generateUpdateByPrimaryKeySelective()) {
292             AbstractDAOElementGenerator methodGenerator = new UpdateByPrimaryKeySelectiveMethodGenerator();
293             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
294                     interfaze);
295         }
296     }
297 
298     protected void addUpdateByPrimaryKeyWithBLOBsMethod(
299             TopLevelClass topLevelClass, Interface interfaze) {
300         if (introspectedTable.getRules().generateUpdateByPrimaryKeyWithBLOBs()) {
301             AbstractDAOElementGenerator methodGenerator = new UpdateByPrimaryKeyWithBLOBsMethodGenerator();
302             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
303                     interfaze);
304         }
305     }
306 
307     protected void addUpdateByPrimaryKeyWithoutBLOBsMethod(
308             TopLevelClass topLevelClass, Interface interfaze) {
309         if (introspectedTable.getRules()
310                 .generateUpdateByPrimaryKeyWithoutBLOBs()) {
311             AbstractDAOElementGenerator methodGenerator = new UpdateByPrimaryKeyWithoutBLOBsMethodGenerator();
312             initializeAndExecuteGenerator(methodGenerator, topLevelClass,
313                     interfaze);
314         }
315     }
316 
317     protected void initializeAndExecuteGenerator(
318             AbstractDAOElementGenerator methodGenerator,
319             TopLevelClass topLevelClass, Interface interfaze) {
320         methodGenerator.setDAOTemplate(daoTemplate);
321         methodGenerator.setContext(context);
322         methodGenerator.setIntrospectedTable(introspectedTable);
323         methodGenerator.setProgressCallback(progressCallback);
324         methodGenerator.setWarnings(warnings);
325         methodGenerator.addImplementationElements(topLevelClass);
326         methodGenerator.addInterfaceElements(interfaze);
327     }
328 
329     @Override
330     public AbstractXmlGenerator getMatchedXMLGenerator() {
331         // this method is not called for iBATIS2
332         return null;
333     }
334 }