读取.sql文件，转化为javabean

最新推荐文章于 2023-12-27 14:55:43 发布
最新推荐文章于 2023-12-27 14:55:43 发布
阅读量1.5k 收藏 6
点赞数 3
分类专栏： 编译原理 文章标签： 编译原理实验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hao5335156/article/details/50948484
版权

.sql文件里面的数据众多，如何找出表名和字段名，然后生成具有get和set属性的javabean呢？其实很简单，利用输入和输出流就可以完成。

1.实验描述：

网络系统的设计与开发往往遵循MVC设计模式。本实验要求编写一个自动代码生成工具。它能读入“myapproval.sql”里的“account”和“authority”的建表语句，分别自动生成如“AccountModel.java”和“AuthorityModel.java”Model类对象的源代码。

2.需要读取的.sql文件：

/*

MySQL Data Transfer
Source Host: localhost
Source Database: myDatabase
Target Host: localhost
Target Database: myDatabase
Date: 2010-1-30 1:08:21
*/

SET FOREIGN_KEY_CHECKS=0;

– Table structure for account

DROP TABLE IF EXISTS account;
CREATE TABLE account (
account varchar(60) NOT NULL default ” COMMENT ‘用户账户’,
password varchar(60) NOT NULL default ‘default’ COMMENT ‘用户密码’,
number varchar(10) default NULL COMMENT ‘用户号码’,
name varchar(60) default NULL COMMENT ‘用户名称’,
title varchar(100) default NULL COMMENT ‘职称’,
job varchar(100) default NULL COMMENT ‘职位’,
department varchar(255) default NULL COMMENT ‘工作部门’,
PRIMARY KEY (account)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

– Table structure for authority

DROP TABLE IF EXISTS authority;
CREATE TABLE authority (
authority int(11) NOT NULL auto_increment COMMENT ‘权限编号’,
name varchar(60) default NULL COMMENT ‘权限名称’,
describes varchar(255) default NULL COMMENT ‘权限描述’,
PRIMARY KEY (authority)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

– Records

3.思路：

利用输入流逐个读取.sql文件中的字符，用空格或者‘；’作为划分各个单词的依据。当遇到CREATE TABLE时候，那么接下来的单词就要存储起来作为表名。遇到varchar或者int等关键字，那么前面的单词就要作为字段名。最后，把找出的关键词写入文件。

4.代码：

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
//InputStream和Reader是所有输入流的基类。
//区别：InputStream面向字节，而Reader面向字符
public class MyTest {

     public static void main(String[] args) {   
         //list保存读取的所有单词
         List<String> list = new ArrayList<String>();
         //listBean保存读取的所有数据表名和数据字段
         List<String> listBean = new ArrayList<String>();
        //listBean1保存读取的数据表1信息
         List<String> listBean1 = new ArrayList<String>();
        //listBean2保存读取的数据表2信息
         List<String> listBean2 = new ArrayList<String>();
           try {
               String encoding = "utf-8";
               File sourceFile = new File("E:\\BY\\myapproval.sql");
               FileInputStream fileInputStream = new FileInputStream(sourceFile);
               //InputStreamReader是转换流，将字节流转化为字符流
               InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, encoding);                         
               int cc;
               //strWord用来保存读取的单词
               String strWord="";
               //int占4个字节，char占2个字节
               //inputStreamReader是字符流，调用read()每次读取的单位是字符
               while ((cc = inputStreamReader.read()) > 0) {
                 if(!((char) cc==' ')&&!((char) cc==';')){
                     String strWordTemp=(char) cc+"";  //(char) cc+""代表char类型转化为string类型
                     strWord=strWord+strWordTemp;
                 }else{
                     list.add(strWord);
                     strWord="";
                 }
               }
               inputStreamReader.close();
               fileInputStream.close();

               String filePath1="";
               String filePath2="";
               for(int i=0;i<list.size();i++){
                   if(list.get(i).contains("CREATE")&&list.
                           get(i+1).contains("TABLE")){
                      //这里把数据表的表名存进去，以#作为标识
                      listBean.add(reMoveVar(list.get(i+2))+"#");        

                   }
                   if(list.get(i).contains("varchar")||list.get(i).contains("int")){
                     //这里把数据表的字段名存进去
                      listBean.add(reMoveVar(list.get(i-1)));
                   }
               }    
               //下面的代码是把listBean中数据分别存入listBean1和listBean2
               int Tab=1;//标记
               for(int i=0;i<listBean.size();i++){  
                   if(listBean.get(i).contains("#")){
                       if(Tab==1){
                           listBean1.add(listBean.get(i));
                           String tem=listBean.get(i);
                           //去掉tem最后那个字符#
                           tem=tem.substring(0, tem.length()-1);                          
                           filePath1=  writeFileName(tem);  
                           Tab=2;
                       }else{                          
                           listBean2.add(listBean.get(i));
                           String tem=listBean.get(i);
                           tem=tem.substring(0, tem.length()-1);                          
                           filePath2=  writeFileName(tem);  
                           Tab=3;
                       }

                   }else{
                       if(Tab==2){
                           listBean1.add(listBean.get(i));
                       }else{
                           listBean2.add(listBean.get(i));
                       }

                   }

               }
              //获得文件输出流 假设目标文件名为resutl.txt 追加方式
               FileOutputStream fileOutputStream= new FileOutputStream("E:\\BY\\"+filePath1+".java",true);
               OutputStreamWriter outputStreamWriter= new OutputStreamWriter(fileOutputStream);
               //普通的Writer写入内容不太方便，包装成BufferedWriter
               BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);

               String temp_var="";//存变量
               String temp_fun="";//存函数
               String temp_funG="";//存构造函数
               for(int i=0;i<listBean1.size();i++){
                   System.out.println(">>"+listBean1.get(i));
                   if(listBean1.get(i).contains("#")){
                       String tem=listBean1.get(i);
                       tem=tem.substring(0, tem.length()-1);    
                       bufferedWriter.write(writeClassName(tem));
                       temp_funG=writeFun(tem);
                   }else{
                       temp_var=temp_var+writeVar(listBean1.get(i));
                       temp_fun=temp_fun+writeSetFunction(listBean1.get(i));
                   }

               }
               bufferedWriter.write(temp_var);
               bufferedWriter.write(temp_funG);
               bufferedWriter.write(temp_fun);
               bufferedWriter.write("}");
               bufferedWriter.close();
               temp_var="";//存变量
               temp_fun="";//存函数
               temp_funG="";//存构造函数

               fileOutputStream= new FileOutputStream("E:\\BY\\"+filePath2+".java",true);
               outputStreamWriter= new OutputStreamWriter(fileOutputStream);
               bufferedWriter = new BufferedWriter(outputStreamWriter);

               for(int i=0;i<listBean2.size();i++){
                   System.out.println("listBean2>>"+listBean2.get(i));
                   if(listBean2.get(i).contains("#")){
                       String tem=listBean2.get(i);
                       tem=tem.substring(0, tem.length()-1);    
                       bufferedWriter.write(writeClassName(tem));
                       temp_funG=writeFun(tem);
                   }else{
                       System.out.println("temp_var>>"+temp_var);
                       temp_var=temp_var+writeVar(listBean2.get(i));
                       temp_fun=temp_fun+writeSetFunction(listBean2.get(i));
                   }

               }

               bufferedWriter.write(temp_var);
               bufferedWriter.write(temp_funG);
               bufferedWriter.write(temp_fun);
               bufferedWriter.write("}");           
               bufferedWriter.close();


              System.out.println(writeSetFunction("name"));
              System.out.println(writeVar("name"));
              System.out.println(writeFun("name"));
              System.out.println(reMoveVar("'name'"));
              System.out.println(writeFileName("nameee"));


           } catch (Exception e) {
               System.out.println(e);
               e.getStackTrace();
           }
        }

     /***
      * 
      * 写函数
      * @param str
      * @return
      */
     public static String writeSetFunction(String str){
         String tem=str.charAt(0)+"";
         tem=str.replace(str.charAt(0), tem.toUpperCase().charAt(0));
         System.out.println(str.replace(str.charAt(0), tem.toUpperCase().charAt(0)));

         String s1="public void set"+tem+"(String " +str+"){"+
                 "\r\n"+"\t  this."+str+"="+str+";\r\n"
                 +"}"+"\r\n";

         String s2="public String get"+tem+"(" +"){"+
         "\r\n"+"\treturn this."+str+";\r\n"
         +"}"+"\r\n";

         return s1+s2;       
     }

     /***
      * 
      * 写变量
      * @param str
      * @return
      */
     public static String writeVar(String str){
         String s1="private String "+str+"=\"\";\r\n";
         return s1;
     }
     /***
      * 
      * 写构造函数
      * @param str
      * @return
      */
     public static String writeFun(String str){
         String tem=str.charAt(0)+"";
         tem=str.replace(str.charAt(0), tem.toUpperCase().charAt(0));
         String s1="public "+tem+""+"Model(){\r\n" +
            "}\r\n";
         return s1;
     }
     /***
      * 
      * 写类名和相关部分
      * @param str
      * @return
      */
     public static String writeClassName(String str){
         String tem=str.charAt(0)+"";
         tem=str.replace(str.charAt(0), tem.toUpperCase().charAt(0));
         String s1="public class"+tem+""+"Model(){\r\n" +
                 "\r\n";
         return s1;
     }
     /***
      * 
      * 写函数名
      * @param str
      * @return  StrModel
      */
     public static String writeFileName(String str){
         String tem=str.charAt(0)+"";
         tem=str.replace(str.charAt(0), tem.toUpperCase().charAt(0));
         String s1=tem+""+"Model";
         return s1;
     }
     /***
      * 
      * 去掉第一个和最后一个多余字符
      * @param str
      * @return
      */
     public static String reMoveVar(String str){            
         return str.substring(1, str.length()-1);
     }

     /***
      * 
      * 第一个大写和最后一个去掉
      * @param str
      * @return
      */
     public static String reMoveLastAndReplaceFirst(String str){  
         String tem=str.charAt(0)+"";
         tem=str.replace(str.charAt(0), tem.toUpperCase().charAt(0));
         return tem.substring(0, str.length()-1);
     }     

}
HawardScut
关注
专栏目录
快速生成JavaBean: .sql转JavaBean一步到位
shuoGG的专栏
07-31 3824
简介 我一般数据表结构是用PowerDesigner来建, 建完就需要建Model也即一堆javaBean, 如果没有辅助工具挨个建要累死, 于是用python写了这样一个辅助小工具, 仅需复制下PowerDesigner中Preview中的sql语句, 然后双击下工具就直接生成出所有数据表的javaBean了 源码: https://github.com/shuoGG1239/SqlTo...
java读取excel 文件，并把读取到的数据转换成javabean对象
shuiyiyouqing的专栏
04-11 4954
javaBean对象public class AcademicaChievements { private Integer aid; private String number; private String sname; private String award_category; private String award_name; private String award_or...
读取.sql文件，转化为javabean保存为.java文件
03-21
该项目可以读取.sql文件，找出表名和字段名，然后把他们转化为javabean保存为.java文件。
java工具类–自动将数据库表生成javabean
查苏的吉古勒
11-18 477
最近和数据库的表打交道挺多的，因为暂时做的是接口活。 在这过程中发现要把表转换成对应的javabean类型，字段少的表还行，如果不小心碰到几十个字段的他妈的写起来就有点麻烦了，万一碰到几百个的呢，那不是要崩溃。 于是想写个工具类，自动生成javabean。 先说下思路： 1.读取数据库表，获取里面的字段名。 准备连接数据库的驱动包，这里只是针对了oracle数据库和m
解析sql文件并且生成Javabean的工具类
06-23
本人编译原理的作业，完成基本全部使用正则表达式，使用意义不大，需要的人可以下载。
java实现SQL select查询语句转JavaBean
最新发布
小筱在线博客
12-27 558
可以使用Java的反射机制来实现将SQL查询结果转换为JavaBean对象。首先，需要获取SQL查询结果的元数据，然后根据元数据创建JavaBean对象，并将查询结果中的字段值赋给JavaBean对象的属性。使用该转换器可以将SQL查询结果转换为JavaBean对象。这样，就可以将查询结果转换为MyBean对象，并打印出来。
使用javabean封装数据库操作1.rar_bean_javabean_javabean 数据库_planet7r1
09-22
3. **JavaBean与ResultSet映射**：当我们从数据库查询数据时，结果集（ResultSet）会被转化为JavaBean对象。通过迭代ResultSet，我们可以调用setter方法将每一行数据赋值给JavaBean的属性。 4. **CRUD操作**：...
使用JSP、JavaBean和Servlet实现一个简单的留言板设计.zip
05-26
在Servlet中，当用户提交留言后，会将JavaBean对象转化为SQL语句，插入到`Message`表中。同时，读取留言时，Servlet会从数据库中查询所有留言，转换为JavaBean对象，再传递给JSP显示。 6. **用户管理**：虽然描述中...
mysql,sqlserver,Oracle 数据库生成javabean小工具
08-08
本工具“mysql, sqlserver, Oracle 数据库生成javabean小工具”正是为了解决开发者手动编写javabean时的繁琐工作，它能够自动根据数据库中的表结构生成对应的javabean文件。 1. **数据库连接**： 工具支持三种主流...
使用Java泛型和反射技术将Mysql记录集转换为Javabean集合
凯旋的博客
08-27 1264
实现原理： * 获取结果集的元数据，得到各列的列名称 * 使用反射，创建参数clazz的对象，调用对象与列名称相对应的所有的set方法 * 【注意】请确保结果集的列名称和Javabean的属性名称、个数和类型完全相同 * 如果属性名称和数据库字段名称不同，可以在sql查询语句中使用  AS 关键字为列起别名 代码，附我的Mysql操作类：   import jav
基于数据库的自动化生成工具，自动生成JavaBean、自动生成数据库文档等(v5.0.0版_JAR)
05-31
博客地址：http://blog.csdn.net/vipbooks 一直以来根据数据库表结构自动生成JavaBean、自动生成MyBaits的Mapper映射配置文件、自动生成数据库设计文档都是一件让人很头痛的事情，既浪费时间又很繁琐，看着几十上百个表的成千上万个字段，真是一件让人痛苦的事情。 我们也想过很多办法解决这个问题，包括用MyEclipse连接数据库生成JavaBean，但多多少少还是会有一些不尽人意的地方，包括表和表字段的comment总是无法生成，而且还会生成很多无用的注释代码，让代码看起来一点都不干净，配置非常繁琐等等问题。 于是一怒之下，自己动手丰衣足食，于是就自己用Swing写了一个基于数据库的自动化生成工具，支持MySQL、Oracle、SQLServce、PostgreSQL，完美支持JPA注解，可以同时生成Entity和DTO等，可以自动去除表前缀，支持单个和批量生成JavaBean，现在不但成员变量上能生成备注了，而且在Getter和Setter上也能有注释了。更重要的是还能自动生成数据库设计文档和MyBaits的Mapper映射配置文件，如果有多个数据源还能批量生成，使用非常方便。 所有的配置都保存在本地，只要配置过一次，下次使用的时候完全可以秒生成JavaBean、MyBaits的Mapper映射配置文件和数据库设计文档，并且还集成各种实用工具，使得工作效率瞬间爆棚，生产力瞬间爆表！
使用Annotation和反射实现Bean转SQL语句Demo
10-27
使用Annotation和反射实现Bean转SQL语句Demo
数据库库表转换为java的bean对象
02-22
oracle mysql 数据库库表转换为java对象
sql转换工具
12-09
可以将sql server的函数 视图 存储过程等转换为mysql的格式，也可以转其他，很好用的一个sql转换工具，
SQL和 Bean 互转通用工具类
weixin_43326384的博客
11-16 1704
package com.fresh.utils; import org.apache.commons.lang3.StringUtils; import java.io.File; import java.lang.reflect.Field; import java.util.*; public class BeanSQLUtils { static Map<String, String> columnMap = null; static Map<String,
sql语句生成javabean类
u012744265的博客
09-05 1610
数据库环境sqlserver sql语句如下 declare @tb nvarchar(100)  set @tb='Shop_OrderItem'    Select 'private '+  (case when st.name ='decimal' then 'double' when st.name='int' then 'int' when st.name
java实现文件读写提取sql脚本
GBK_8的博客
07-01 1367
通过java流从日志中提取sql脚本前提IO流简单介绍java中的IO分类： 前提 忘记备份数据，和开启MySQL的binlog记录日志。导致一些数据误删没办法快速恢复，只能通过系统日志去查看这些操作从中捞出INSERT INTO xxxx(表名)语句。再去重新执行。由于每天都会有日志文件所以导致要筛选的日志过于庞大耗费时间超长，所以使用JAVA写了个小型脚本用于筛选所需信息。 package com.mlzhang; import java.io.*; import java.util.ArrayLis
this.getSession().createSQLQuery 查询出来的字段自动转换为bean对象
shena的专栏
06-26 3221
List bsbs=this.getSession().createSQLQuery(sql).setResultTransformer(new AliasToBeanResultTransformer(BudStatsBean.class)).list();
java解析sql文件
weixin_34357962的博客
06-13 383
package com.athena.ckx.util; import java.io.FileInputStream; import java.io.InputStream; import java.sql.Connection; import java.sql.Statement; import java.util.ArrayList; import java.util....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值