Rapid-generator Java code Generator

Feeling in the immediate need to do a larger business system, think of the endless additions and deletions to check, paste copy, immediately after the brain rises a cool breeze. Then think of a search or write a Java code generator, so that in the normal development of the progress, you can still have more time to do something else.

Gossip less say, first summarize the following requirements:

I need this tool to be able to read the database table structure, through the analysis of the field type, name and other required variables, according to the template to generate the corresponding Pojo class, hibernate XML configuration file, DAO and Service interfaces and classes.

Demand seems very simple, but one is not done such a small tool, the second is the technology is not clear, so still think of looking for there is no open source code to take over according to their own needs to change.

So found Rapid-generator this open source tool, students can download Rapid-generator direct use, according to their own needs to write a good template on the line.

Due to the special circumstances of their own projects and the company's norms and other factors, but also want to learn the design of others, so I have to cut the source code and modify the function.

Look at the main classes:

Table: An object created from a table structure.

Column: The object created by each column in the table.

Generator: Generator Core class, which is responsible for generating final Java code files based on table objects and reading Freemarker templates.

Generatorcontrol: Some parameters, such as whether files are overwritten, file encoding, etc., that control the generation process.

Generatorproperties: Reads the configuration file class, the configuration file includes the database connection information and some basic parameter configuration.

Here's a look at the template writing:

Pojo templates:

2. < #include "/java_copyright.include" >
4. < #assign ClassName = table.classname>
6. < #assign Classnamelower = classname?uncap_first>
8. Package ${basepackage}.pojo.${mpackage}.${table.classnamefirstlower};
12. < #include "/java_imports.include" >
14. Import com.linkage.agri.pojo.base.BaseEntity;
18. Public class ${classname} extends BaseEntity {
20. private Static final long serialversionuid = 5454155825314635342L;
24. < #list Table.columns as column>
26. /**  
28. * ${column.remarks}
30. */
32. private ${column.simplejavatype} ${column.columnnamelower};
34. </#list >
38. <@generateJavaColumns/>
42. < #macro generatejavacolumns>
44. < #list Table.columns as column>
46. <#if column.isdatetimecolumn>
48. Public String get${column.columnname}string () {
50. return Dateconvertutils.format (Get${column.columnname} (), format_${column.constantname});
52. }
54. public void set${column.columnname}string (String ${column.columnnamelower}) {
56. Set${column.columnname} (Dateconvertutils.parse (${column.columnnamelower}, format_${column.constantname},${ Column.simplejavatype}.  class));
58. }
60. </#if>
62. public Void Set${column.columnname} (${column.simplejavatype} ${column.columnnamelower}) {
64. This.${column.columnnamelower} = ${column.columnnamelower};
66. }
70. Public ${column.simplejavatype} Get${column.columnname} () {
72. return This.${column.columnnamelower};
74. }
76. </#list >
78. </#macro >

Freemarker's basic grammar can be seen in the Freemarker Chinese manual.

${} can refer to a number of variables, including: Environment variables, table objects, configuration variables, and so on, these variables are installed in a map, if you have special needs, of course, you can modify the source to load more variable values.

Note: When a variable is an object, the properties of the Access object are accessed through the Get method. For example, ${table.classnamefirstlower}, which is the Getnamefirstlower () method that references the Table object, can be referenced even if the property is not namefirstlower in the Table object.

Then look at the template I wrote for DAO:

2. < #include "/java_copyright.include" >
4. < #assign ClassName = table.classname>
6. < #assign Classnamelower = classname?uncap_first>
8. Package ${basepackage}.dao.${mpackage}.${table.classnamefirstlower};
12. Import Java.math.BigDecimal;
14. Import java.util.List;
16. Import Java.util.Map;
20. Import Com.linkage.agri.dao.base.AbstractHibernateDAO;
22. Import com.linkage.agri.exception.DAOException;
24. Import ${basepackage}.pojo.${mpackage}.${classnamelower}.${classname};
28. < #include "/java_imports.include" >
32. Public Class ${classname}daoimpl extends Abstracthibernatedao implements ${classname}dao
34. {
36. /**  
38. * <query all>
40. * @param parammap
42. * @param ordermap
44. * @param pagenum
46. * @param pageSize
48. * @return
50. * @throws daoexception
52. */
54. @SuppressWarnings
56. Public list<${classname}> querylist${classname}byattr (map<string, object> parammap, Map<String, String> ordermap, int pagenum,
58. int pageSize)
60. throws Daoexception
62. {
64. return super.listinstances (${classname}.  Class, Parammap, Ordermap, Pagenum, pageSize);
66. }
70. /**  
72. *
74. * <find one by id>
76. * @param serial
78. * @throws daoexception
80. */
82. Public ${classname} Find${classname}by${table.pkcolumn.columnname} (${table.pkcolumn.simplejavatype} ${ Table.pkColumn.columnNameFirstLower})
84. throws Daoexception
86. {
88. return (${classname})Super.findbyid (${classname}.  Class, ${table.pkcolumn.columnnamefirstlower});
90. }
94. /**  
96. *
98. * <save one>
100. * @param ${table.classnamefirstlower}
102. * @throws daoexception
104. */
106. Public ${table.pkcolumn.simplejavatype} Save${classname} (${classname} ${table.classnamefirstlower})
108. throws Daoexception
110. {
112. return (${table.pkcolumn.simplejavatype})super.saveinstance (${table.classnamefirstlower});
114. }
118. /**  
120. *
122. * <update one>
124. * @param ${table.classnamefirstlower}
126. * @throws daoexception
128. */
130. public Void Update${classname} (${classname} ${table.classnamefirstlower})
132. throws Daoexception
134. {
136. super.updateinstance (${classname});
138. }
142. /**  
144. * <check one is have?>
146. * @param parammap
148. * @return
150. * @throws daoexception
152. */
154. Public Boolean check${classname}ishavebyattr (map<string, object> parammap)
156. throws Daoexception
158. {
160. StringBuffer sqlbuffer = new StringBuffer ();
162. Sqlbuffer.append ("Select COUNT (*) from ${table.sqlname} T");
164. Sqlbuffer.append ("WHERE t.${table.pkcolumn.sqlname} =?");
168. BigDecimal big = (BigDecimal)super.finduniqueresultbysqlwithparams (sqlbuffer.tostring (), Parammap.get ("${  Table.pkColumn.columnNameFirstLower} "));
170. return Big.intvalue () > 0?  false: true;
172. }
176. /**  
178. * <update some>
180. * @param ${table.classnamefirstlower}list
182. * @return
184. * @throws daoexception
186. */
188. public void Update${classname}batch (list<${classname}> ${table.classnamefirstlower}list)
190. throws Daoexception
192. {
194. super.updatebatchinstance (${table.classnamefirstlower}list);
196. }
200. /**  
202. *
204. * <delete one>
206. * @param ${table.classnamefirstlower}
208. * @throws daoexception
210. */
212. public Void Delete${classname} (${classname} ${table.classnamefirstlower})
214. throws Daoexception
216. {
218. super.deleteinstance (${table.classnamefirstlower});
220. }
224. }

Establishing a template is the key to solving your own problems, and it is very easy to write a template after you have explored the doorway. In fact, the principle is simple, is to use a series of placeholders to replace the actual value of the variable.

The template path can be called according to the path in the actual project, and the generator can read all the templates under a path to be generated, such as:

Interfaces and implementations:

Say so much, interested can study the source of the tool, but also DIY a set of their own code generation tools. Direct write templates that are not interested can be used.

Rapid-generator Java code Generator