`
郑云飞
  • 浏览: 814085 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

java 从数据库表反射出实体类，自动生成实体类

 
阅读更多 
mysql数据库
package com.s9.common.web;


import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Date;

public class GenEntityMysql {
	
	private String packageOutPath = "com.s9.cfj.user.entity";//指定实体生成所在包的路径
	private String authorName = "郑云飞";//作者名字
	private String tablename = "cfj_user";//表名
	private String[] colnames; // 列名数组
	private String[] colTypes; //列名类型数组
	private int[] colSizes; //列名大小数组
	private boolean f_util = false; // 是否需要导入包java.util.*
	private boolean f_sql = false; // 是否需要导入包java.sql.*
    
    //数据库连接
	private static final String URL ="jdbc:mysql://localhost:3306/caifujie";
	private static final String NAME = "root";
	private static final String PASS = "root";
	private static final String DRIVER ="com.mysql.jdbc.Driver";

	/*
	 * 构造函数
	 */
	public GenEntityMysql(){
    	//创建连接
    	Connection con;
		//查要生成实体类的表
    	String sql = "select * from " + tablename;
    	PreparedStatement pStemt = null;
    	try {
    		try {
				Class.forName(DRIVER);
			} catch (ClassNotFoundException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
    		con = DriverManager.getConnection(URL,NAME,PASS);
			pStemt = con.prepareStatement(sql);
			ResultSetMetaData rsmd = pStemt.getMetaData();
			int size = rsmd.getColumnCount();	//统计列
			colnames = new String[size];
			colTypes = new String[size];
			colSizes = new int[size];
			for (int i = 0; i < size; i++) {
				colnames[i] = rsmd.getColumnName(i + 1);
				colTypes[i] = rsmd.getColumnTypeName(i + 1);
				if(colTypes[i].equalsIgnoreCase("datetime")){
					f_util = true;
				}
				if(colTypes[i].equalsIgnoreCase("image") || colTypes[i].equalsIgnoreCase("text")){
					f_sql = true;
				}
				colSizes[i] = rsmd.getColumnDisplaySize(i + 1);
			}
			
			String content = parse(colnames,colTypes,colSizes);
			
			try {
				File directory = new File("");
				//System.out.println("绝对路径："+directory.getAbsolutePath());
				//System.out.println("相对路径："+directory.getCanonicalPath());
				String path=this.getClass().getResource("").getPath();
				
				System.out.println(path);
				System.out.println("src/?/"+path.substring(path.lastIndexOf("/com/", path.length())) );
//				String outputPath = directory.getAbsolutePath()+ "/src/"+path.substring(path.lastIndexOf("/com/", path.length()), path.length()) + initcap(tablename) + ".java";
				String outputPath = directory.getAbsolutePath()+ "/src/"+this.packageOutPath.replace(".", "/")+"/"+initcap(tablename) + ".java";
				FileWriter fw = new FileWriter(outputPath);
				PrintWriter pw = new PrintWriter(fw);
				pw.println(content);
				pw.flush();
				pw.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			
		} catch (SQLException e) {
			e.printStackTrace();
		} finally{
//			try {
//				con.close();
//			} catch (SQLException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
		}
    }

	/**
	 * 功能：生成实体类主体代码
	 * @param colnames
	 * @param colTypes
	 * @param colSizes
	 * @return
	 */
	private String parse(String[] colnames, String[] colTypes, int[] colSizes) {
		StringBuffer sb = new StringBuffer();
		sb.append("package " + this.packageOutPath + ";\r\n");
		//判断是否导入工具包
		if(f_util){
			sb.append("import java.util.Date;\r\n");
		}
		if(f_sql){
			sb.append("import java.sql.*;\r\n");
		}
		sb.append("\r\n");
		//注释部分
		sb.append("   /**\r\n");
		sb.append("    * "+tablename+" 实体类\r\n");
		sb.append("    * "+new Date()+" "+this.authorName+"\r\n");
		sb.append("    */ \r\n");
		//实体部分
		sb.append("\r\n\r\npublic class " + initcap(tablename) + "{\r\n");
		processAllAttrs(sb);//属性
		processAllMethod(sb);//get set方法
		sb.append("}\r\n");
		
    	//System.out.println(sb.toString());
		return sb.toString();
	}
	
	/**
	 * 功能：生成所有属性
	 * @param sb
	 */
	private void processAllAttrs(StringBuffer sb) {
		
		for (int i = 0; i < colnames.length; i++) {
			sb.append("\tprivate " + sqlType2JavaType(colTypes[i]) + " " + colnames[i] + ";\r\n");
		}
		
	}

	/**
	 * 功能：生成所有方法
	 * @param sb
	 */
	private void processAllMethod(StringBuffer sb) {
		
		for (int i = 0; i < colnames.length; i++) {
			sb.append("\tpublic void set" + initcap(colnames[i]) + "(" + sqlType2JavaType(colTypes[i]) + " " + 
					colnames[i] + "){\r\n");
			sb.append("\tthis." + colnames[i] + "=" + colnames[i] + ";\r\n");
			sb.append("\t}\r\n");
			sb.append("\tpublic " + sqlType2JavaType(colTypes[i]) + " get" + initcap(colnames[i]) + "(){\r\n");
			sb.append("\t\treturn " + colnames[i] + ";\r\n");
			sb.append("\t}\r\n");
		}
		
	}
	
	/**
	 * 功能：将输入字符串的首字母改成大写
	 * @param str
	 * @return
	 */
	private String initcap(String str) {
		
		char[] ch = str.toCharArray();
		if(ch[0] >= 'a' && ch[0] <= 'z'){
			ch[0] = (char)(ch[0] - 32);
		}
		
		return new String(ch);
	}

	/**
	 * 功能：获得列的数据类型
	 * @param sqlType
	 * @return
	 */
	private String sqlType2JavaType(String sqlType) {
		
		if(sqlType.equalsIgnoreCase("bit")){
			return "boolean";
		}else if(sqlType.equalsIgnoreCase("tinyint")){
			return "byte";
		}else if(sqlType.equalsIgnoreCase("smallint")){
			return "short";
		}else if(sqlType.equalsIgnoreCase("int")){
			return "int";
		}else if(sqlType.equalsIgnoreCase("bigint")){
			return "long";
		}else if(sqlType.equalsIgnoreCase("float")){
			return "float";
		}else if(sqlType.equalsIgnoreCase("decimal") || sqlType.equalsIgnoreCase("numeric") 
				|| sqlType.equalsIgnoreCase("real") || sqlType.equalsIgnoreCase("money") 
				|| sqlType.equalsIgnoreCase("smallmoney")){
			return "double";
		}else if(sqlType.equalsIgnoreCase("varchar") || sqlType.equalsIgnoreCase("char") 
				|| sqlType.equalsIgnoreCase("nvarchar") || sqlType.equalsIgnoreCase("nchar") 
				|| sqlType.equalsIgnoreCase("text")){
			return "String";
		}else if(sqlType.equalsIgnoreCase("datetime")){
			return "Date";
		}else if(sqlType.equalsIgnoreCase("image")){
			return "Blod";
		}
		
		return null;
	}
	
	/**
	 * 出口
	 * TODO
	 * @param args
	 */
	public static void main(String[] args) {
		
		new GenEntityMysql();
		
	}

}

    oracle数据库

01.package com.db.gen.entity.tool;  
02.  
03.  
04.import java.io.File;  
05.import java.io.FileWriter;  
06.import java.io.IOException;  
07.import java.io.PrintWriter;  
08.import java.sql.Connection;  
09.import java.sql.DriverManager;  
10.import java.sql.PreparedStatement;  
11.import java.sql.ResultSet;  
12.import java.sql.ResultSetMetaData;  
13.import java.sql.SQLException;  
14.import java.sql.Statement;  
15.import java.util.Date;  
16.  
17.public class GenEntityOracle {  
18.      
19.    private String packageOutPath = "com.user.entity";//指定实体生成所在包的路径  
20.    private String authorName = "郑云飞";//作者名字  
21.    private String tablename = "emp";//表名  
22.    private String[] colnames; // 列名数组  
23.    private String[] colTypes; //列名类型数组  
24.    private int[] colSizes; //列名大小数组  
25.    private boolean f_util = false; // 是否需要导入包java.util.*  
26.    private boolean f_sql = false; // 是否需要导入包java.sql.*  
27.      
28.    //数据库连接  
29.     private static final String URL ="jdbc:oracle:thin:@127.0.0.1:1521:ORCL";  
30.     private static final String NAME = "scrot";  
31.     private static final String PASS = "tiger";  
32.     private static final String DRIVER ="oracle.jdbc.driver.OracleDriver";  
33.  
34.    /* 
35.     * 构造函数 
36.     */  
37.    public GenEntityOracle(){  
38.        //创建连接  
39.        Connection con;  
40.        //查要生成实体类的表  
41.        String sql = "select * from " + tablename;  
42.        Statement pStemt = null;  
43.        try {  
44.            try {  
45.                Class.forName(DRIVER);  
46.            } catch (ClassNotFoundException e1) {  
47.                // TODO Auto-generated catch block  
48.                e1.printStackTrace();  
49.            }  
50.            con = DriverManager.getConnection(URL,NAME,PASS);  
51.            pStemt = (Statement) con.createStatement();  
52.            ResultSet rs = pStemt.executeQuery(sql);  
53.            ResultSetMetaData rsmd = rs.getMetaData();  
54.            int size = rsmd.getColumnCount();   //统计列  
55.            colnames = new String[size];  
56.            colTypes = new String[size];  
57.            colSizes = new int[size];  
58.            for (int i = 0; i < size; i++) {  
59.                colnames[i] = rsmd.getColumnName(i + 1);  
60.                colTypes[i] = rsmd.getColumnTypeName(i + 1);  
61.                  
62.                if(colTypes[i].equalsIgnoreCase("date") || colTypes[i].equalsIgnoreCase("timestamp")){  
63.                    f_util = true;  
64.                }  
65.                if(colTypes[i].equalsIgnoreCase("blob") || colTypes[i].equalsIgnoreCase("char")){  
66.                    f_sql = true;  
67.                }  
68.                colSizes[i] = rsmd.getColumnDisplaySize(i + 1);  
69.            }  
70.              
71.            String content = parse(colnames,colTypes,colSizes);  
72.              
73.            try {  
74.                File directory = new File("");  
75.                //System.out.println("绝对路径："+directory.getAbsolutePath());  
76.                //System.out.println("相对路径："+directory.getCanonicalPath());  
77.                String path=this.getClass().getResource("").getPath();  
78.                  
79.                System.out.println(path);  
80.                System.out.println("src/?/"+path.substring(path.lastIndexOf("/com/", path.length())) );  
81.//              String outputPath = directory.getAbsolutePath()+ "/src/"+path.substring(path.lastIndexOf("/com/", path.length()), path.length()) + initcap(tablename) + ".java";  
82.                String outputPath = directory.getAbsolutePath()+ "/src/"+this.packageOutPath.replace(".", "/")+"/"+initcap(tablename) + ".java";  
83.                FileWriter fw = new FileWriter(outputPath);  
84.                PrintWriter pw = new PrintWriter(fw);  
85.                pw.println(content);  
86.                pw.flush();  
87.                pw.close();  
88.            } catch (IOException e) {  
89.                e.printStackTrace();  
90.            }  
91.              
92.        } catch (SQLException e) {  
93.            e.printStackTrace();  
94.        } finally{  
95.//          try {  
96.//              con.close();  
97.//          } catch (SQLException e) {  
98.//              // TODO Auto-generated catch block  
99.//              e.printStackTrace();  
100.//          }  
101.        }  
102.    }  
103.  
104.    /** 
105.     * 功能：生成实体类主体代码 
106.     * @param colnames 
107.     * @param colTypes 
108.     * @param colSizes 
109.     * @return 
110.     */  
111.    private String parse(String[] colnames, String[] colTypes, int[] colSizes) {  
112.        StringBuffer sb = new StringBuffer();  
113.          
114.        //判断是否导入工具包  
115.        if(f_util){  
116.            sb.append("import java.util.Date;\r\n");  
117.        }  
118.        if(f_sql){  
119.            sb.append("import java.sql.*;\r\n");  
120.        }  
121.        sb.append("package " + this.packageOutPath + ";\r\n");  
122.        sb.append("\r\n");  
123.        //注释部分  
124.        sb.append("   /**\r\n");  
125.        sb.append("    * "+tablename+" 实体类\r\n");  
126.        sb.append("    * "+new Date()+" "+this.authorName+"\r\n");  
127.        sb.append("    */ \r\n");  
128.        //实体部分  
129.        sb.append("\r\n\r\npublic class " + initcap(tablename) + "{\r\n");  
130.        processAllAttrs(sb);//属性  
131.        processAllMethod(sb);//get set方法  
132.        sb.append("}\r\n");  
133.          
134.        //System.out.println(sb.toString());  
135.        return sb.toString();  
136.    }  
137.      
138.    /** 
139.     * 功能：生成所有属性 
140.     * @param sb 
141.     */  
142.    private void processAllAttrs(StringBuffer sb) {  
143.          
144.        for (int i = 0; i < colnames.length; i++) {  
145.            sb.append("\tprivate " + sqlType2JavaType(colTypes[i]) + " " + colnames[i] + ";\r\n");  
146.        }  
147.          
148.    }  
149.  
150.    /** 
151.     * 功能：生成所有方法 
152.     * @param sb 
153.     */  
154.    private void processAllMethod(StringBuffer sb) {  
155.          
156.        for (int i = 0; i < colnames.length; i++) {  
157.            sb.append("\tpublic void set" + initcap(colnames[i]) + "(" + sqlType2JavaType(colTypes[i]) + " " +   
158.                    colnames[i] + "){\r\n");  
159.            sb.append("\tthis." + colnames[i] + "=" + colnames[i] + ";\r\n");  
160.            sb.append("\t}\r\n");  
161.            sb.append("\tpublic " + sqlType2JavaType(colTypes[i]) + " get" + initcap(colnames[i]) + "(){\r\n");  
162.            sb.append("\t\treturn " + colnames[i] + ";\r\n");  
163.            sb.append("\t}\r\n");  
164.        }  
165.          
166.    }  
167.      
168.    /** 
169.     * 功能：将输入字符串的首字母改成大写 
170.     * @param str 
171.     * @return 
172.     */  
173.    private String initcap(String str) {  
174.          
175.        char[] ch = str.toCharArray();  
176.        if(ch[0] >= 'a' && ch[0] <= 'z'){  
177.            ch[0] = (char)(ch[0] - 32);  
178.        }  
179.          
180.        return new String(ch);  
181.    }  
182.  
183.    /** 
184.     * 功能：获得列的数据类型 
185.     * @param sqlType 
186.     * @return 
187.     */  
188.    private String sqlType2JavaType(String sqlType) {  
189.          
190.        if(sqlType.equalsIgnoreCase("binary_double")){  
191.            return "double";  
192.        }else if(sqlType.equalsIgnoreCase("binary_float")){  
193.            return "float";  
194.        }else if(sqlType.equalsIgnoreCase("blob")){  
195.            return "byte[]";  
196.        }else if(sqlType.equalsIgnoreCase("blob")){  
197.            return "byte[]";  
198.        }else if(sqlType.equalsIgnoreCase("char") || sqlType.equalsIgnoreCase("nvarchar2")   
199.                || sqlType.equalsIgnoreCase("varchar2")){  
200.            return "String";  
201.        }else if(sqlType.equalsIgnoreCase("date") || sqlType.equalsIgnoreCase("timestamp")  
202.                 || sqlType.equalsIgnoreCase("timestamp with local time zone")   
203.                 || sqlType.equalsIgnoreCase("timestamp with time zone")){  
204.            return "Date";  
205.        }else if(sqlType.equalsIgnoreCase("number")){  
206.            return "Long";  
207.        }  
208.          
209.        return "String";  
210.    }  
211.      
212.    /** 
213.     * 出口 
214.     * TODO 
215.     * @param args 
216.     */  
217.    public static void main(String[] args) {  
218.          
219.        new GenEntityOracle();  
220.          
221.    }  
222.  
223.}

 

分享到：
| 修改js文件结果jsp页面不更新
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java从数据库表反射出实体类，自动生成实体类

    根据提供的文件信息，我们可以深入探讨如何使用Java编程语言来实现从数据库表中自动反射并生成实体类的功能。这种技术在实际开发中非常有用，尤其是在快速搭建项目基础结构时，能够大大减少手动编码的工作量。 ### ...

    JAVA通过实体生成数据库表

    在实体类生成数据库表的过程中，反射被用来读取实体类的元数据，如字段名、类型等，然后根据这些信息构建出创建数据库表的SQL语句。 在实际应用中，我们可能使用Hibernate的`Hibernate Tools`或者MyBatis的`MyBatis...

    mysql自动生成实体类

    总结起来，"mysql自动生成实体类"是一种实用的开发辅助工具，它结合了MySQL数据库和Java反射技术，帮助开发者快速生成与数据库表结构相对应的实体类，便于在ORM框架中使用，提高了开发效率和代码的可维护性。

    java将数据库表反射成java实体类xml中sql语句

    本主题聚焦于如何利用Java将数据库表自动反射为Java实体类，并自动生成对应的XML配置文件中的SQL操作语句，包括INSERT、SELECT、UPDATE等。 首先，数据库表和Java实体类之间的映射是ORM的核心概念。一个数据库表的...

    JAVA SQLite 自动生成实体类 源码

    本项目提供的"JAVA SQLite 自动生成实体类 源码"是一个实用工具，它能够帮助开发者自动生成与SQLite数据库表结构对应的Java实体类，从而简化数据操作的代码编写工作。 首先，我们来理解这个工具的工作原理。当...

    java根据数据库表或视图创建实体

    3. **反射API**：这个工具可能使用了Java的反射机制来动态获取数据库表的信息，如字段名、类型等，并根据这些信息自动生成实体类的源代码。反射允许在运行时检查类、接口、字段和方法的信息，甚至可以动态地调用方法...

    实体类转换成数据库表

    4. **反向工程（Reverse Engineering）**: Hibernate支持从现有数据库生成实体类和映射文件，这是一个称为反向工程的过程。在描述中提到的"sqlserver数据库中的表通过Hibernate反射生成的的实体类"，就是指的这个...

    利用JAVA反射,读取数据库表名,自动生成对应实体类的操作

    标签中主要包含三个关键词：JAVA反射、数据库表名、生成实体类。这三个标签非常重要，因为它们直接体现了本文的主要内容和技术点。 部分内容分析： 部分内容主要展示了代码，用于读取数据库表名并自动生成对应实体...

    Maven插件源码：根据库表生成实体类&根据实体类生成库表

    总结来说，"Maven插件源码：根据库表生成实体类&根据实体类生成库表"是一个高效且实用的开发工具，它整合了数据库与Java代码的自动化生成，提高了开发效率，降低了错误的可能性。对于大型项目或频繁迭代的系统，这样...

    根据数据库自动生成java或c#实体类

    描述中提到的“C#通过自定义特性实现根据实体类自动创建数据库表”，这是一种反向操作，即根据实体类生成数据库表。这通常涉及到反射和动态SQL生成。当实体类添加了特定的特性，如`TableAttribute`和`...

    生成数据库表实体

    3. 生成实体类：基于元数据，生成对应的实体类代码，每个字段对应数据库表的一个列。 4. 注释和注解：添加必要的注释和注解，比如字段的描述，以及数据验证规则等。 5. 反射和映射：如果使用ORM（对象关系映射）框架...

    java根据实体类生成Hibernate映射文件

    总的来说，通过编写Java程序自动根据实体类生成Hibernate映射文件，可以提高开发效率，减少手动维护映射文件的工作量。这个过程涉及到Java反射、XML处理以及对Hibernate映射机制的理解，对于深入掌握Java与数据库的...

    用java生成实体类

    为了解决这个问题，我们可以利用Java来动态生成实体类，根据数据库中的表结构自动创建对应的类，大大提高了开发效率。 Java动态生成实体类通常涉及以下知识点： 1. **反射（Reflection）**：Java反射机制允许程序...

    JAVA读取Excel，建库建表，并生成java实体

    如果需要自动生成实体类，可以考虑使用模板引擎如FreeMarker或Velocity，将Excel数据映射到模板上，生成Java源代码。 5. **SyncDBJava-master项目**： 提供的压缩包文件名称`SyncDBJava-master`可能是一个包含源...

    Java直接通过连接数据库生成对应的Resful格式的API

    在这个场景下，ORM框架可能用于自动根据表结构生成Java实体类和DAO层代码。 3. JPA（Java Persistence API）：Java标准的ORM规范，提供了一种统一的方式来管理持久化对象。 4. Spring Boot：一个流行的Java框架，...

    (带源码)根据MS SQLServer数据库信息生成C#或JAVA实体类DEMO

    标题中的"(带源码)根据MS SQLServer数据库信息生成C#或JAVA实体类DEMO"表明这是一个编程示例，展示了如何从Microsoft SQL Server数据库中获取结构信息，并自动生成C#或Java的实体类代码。这样的工具在开发过程中非常...

    自动生成实体类

    "自动生成实体类"是一个高效的方法，可以帮助开发者快速创建与数据库表结构相对应的Java类，减少手动编码的工作量，提高开发效率。 实体类一般包含属性（对应数据库表的列）和getter/setter方法，有时还会有构造...

    Java反射泛型，实现数据库的动态增删改查等功能

    具体实现时，我们可以为每个数据库操作创建一个泛型方法，使用反射获取实体类的字段，根据字段生成对应的SQL语句片段。比如在插入操作中，我们可以遍历`T`的所有字段，构建一个`INSERT INTO table_name (field1, ...

    sql2005数据库自动生成代码 java

    一旦建立了数据库连接，你可以使用Java反射API或者第三方库（如Apache Velocity或Freemarker）来遍历数据库中的表和列，并生成相应的Java实体类、DAO（Data Access Object）、Service或Repository代码。 例如，...

    采用反射技术和XML的通用实体类

    生成实体类的过程大致如下： 1. **解析XML**：首先，我们需要读取并解析XML配置文件，从中提取表名、列名和数据类型等信息。 2. **构建实体类模板**：根据解析出的数据，动态生成Java实体类的源代码。每个实体类...

Magicbox
Global site tag (gtag.js) - Google Analytics