> 数据库 > MySQL >

Mysql自动生成javabean

时间:2015-01-06 00:05  来源:linux.it.net.cn   作者:IT

直接上代码：

 

数据库链接工具类：


  1. import java.sql.Connection;  
  2. import java.sql.DriverManager;  
  3. import java.sql.ResultSet;  
  4. import java.sql.SQLException;  
  5. import java.sql.Statement;  
  6.   
  7. //本类专门用来连接数据库,可以作为固定的工具类使用(记下来即可)  
  8. public class DBManager {  
  9.     // 定义一个静态的连接对象用来连接数据库  
  10.     // private static Connection conn = null;  
  11.     // 定一个静态的语句对象,用来执行sql语句  
  12.     // private static Statement stmt = null;  
  13.     // 定义一个静态的结果集对象用来存放执行sql语句后查询得到的结果  
  14.     // private static ResultSet rs = null;  
  15.   
  16.     /** 
  17.      * 连接数据库的方法 
  18.      *  
  19.      * @return conn 返回一个连接对象 
  20.      */  
  21.     public static Connection mssql(String url, String user, String pass) {  
  22.         Connection conn = null;  
  23.         try {  
  24.             // 1、加载连接驱动  
  25.             // "jdbc:odbc:bookdemo"  
  26.             Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");  
  27.             // 2、连接到数据库（获得连接对象）  
  28.             // 通过连接管理器(DriverManager)类的一个方法来获得连接对象，里面的参数表示我们连接到数据源bookdemo  
  29.             conn = DriverManager.getConnection(url, user, pass);  
  30.         } catch (ClassNotFoundException e) {  
  31.             // 以堆栈的方式将错误信息打印出来  
  32.             e.printStackTrace();  
  33.         } catch (SQLException e) {  
  34.             // TODO Auto-generated catch block  
  35.             e.printStackTrace();  
  36.         }  
  37.   
  38.         return conn; // 将连接对象返回  
  39.     }  
  40.   
  41.     /** 
  42.      * 连接数据库的方法 
  43.      *  
  44.      * @return conn 返回一个连接对象 
  45.      * @throws ClassNotFoundException 
  46.      * @throws SQLException 
  47.      */  
  48.     public static Connection mysql(String url, String user, String pass)  
  49.             throws ClassNotFoundException, SQLException {  
  50.         Connection conn = null;  
  51.   
  52.         // 1、加载连接驱动  
  53.         // "jdbc:odbc:bookdemo"  
  54.         Class.forName("com.mysql.jdbc.Driver");  
  55.         // 2、连接到数据库（获得连接对象）  
  56.         // 通过连接管理器(DriverManager)类的一个方法来获得连接对象，里面的参数表示我们连接到数据源bookdemo  
  57.         conn = DriverManager.getConnection(url, user, pass);  
  58.   
  59.         return conn; // 将连接对象返回  
  60.     }  
  61.   
  62.     /** 
  63.      * 动漫网的mysql数据库连接 
  64.      * @throws SQLException  
  65.      * @throws ClassNotFoundException  
  66.      */  
  67.     public static Connection mysql(String host, String database, String user,  
  68.             String pass) throws ClassNotFoundException, SQLException {  
  69.         String url = "jdbc:mysql://" + host + "/" + database  
  70.                 + "?useUnicode=true&characterEncoding=UTF-8";  
  71.         return mysql(url, user, pass);  
  72.     }  
  73.   
  74.     /** 
  75.      * 本函数用来执行用户传入的sql语句(仅限于select语句) 
  76.      *  
  77.      * @param sql 
  78.      *            传入的sql语句，等待执行 
  79.      * @return 返回执行sql语句后的结果集对象 
  80.      */  
  81.     public static ResultSet query(Connection conn, String sql) {  
  82.         ResultSet rs = null;  
  83.         try {  
  84.             // 3、通过连接对象创建一个语句对象stmt，用来执行sql语句  
  85.             Statement stmt = conn.createStatement();  
  86.             // 4、执行sql语句，得到一个rs（结果集对象）  
  87.             rs = stmt.executeQuery(sql);  
  88.         } catch (Exception e) { // 错误处理，暂时不用理会  
  89.             e.printStackTrace();  
  90.         }  
  91.         return rs; // 将查询得到的结果集对象返回  
  92.     }  
  93.   
  94.     /** 
  95.      * 本方法用来执行更新语句，并返回影响了多少行（insert,update,delete） 
  96.      *  
  97.      * @param sql 
  98.      *            传入的sql语句，等待执行 
  99.      * @return 返回执行sql语句后的结果集对象 
  100.      */  
  101.     public static int update(Connection conn, String sql) {  
  102.         // 执行sql语句前先连接到数据库  
  103.         Statement stmt = null;  
  104.         int i = 0;  
  105.         try {  
  106.             // 通过连接对象创建一个语句对象stmt，用来执行sql语句  
  107.             stmt = conn.createStatement();  
  108.             // 执行更新语句，并返回影响了多少行  
  109.             i = stmt.executeUpdate(sql);  
  110.         } catch (Exception e) { // 错误处理，暂时不用理会  
  111.             e.printStackTrace();  
  112.         } finally {  
  113.             try {  
  114.                 stmt.close();  
  115.             } catch (SQLException e) {  
  116.                 // TODO Auto-generated catch block  
  117.                 e.printStackTrace();  
  118.             }  
  119.         }  
  120.         return i;  
  121.     }  
  122.   
  123.     public static void close(Connection conn, Statement stmt, ResultSet rs) {  
  124.   
  125.         try {  
  126.             if (rs != null) {  
  127.                 rs.close();  
  128.                 rs = null;  
  129.             }  
  130.             if (stmt != null) {  
  131.                 stmt.close();  
  132.                 stmt = null;  
  133.             }  
  134.             if (conn != null) {  
  135.                 conn.close();  
  136.                 conn = null;  
  137.             }  
  138.         } catch (SQLException e) {  
  139.             // TODO Auto-generated catch block  
  140.             e.printStackTrace();  
  141.         }  
  142.     }  
  143. }  

Javebean生成类：

 

 

[java] view plaincopyprint?
  1. import java.awt.BorderLayout;  
  2. import java.awt.Color;  
  3. import java.awt.EventQueue;  
  4. import java.awt.event.ActionEvent;  
  5. import java.awt.event.ActionListener;  
  6. import java.awt.event.WindowAdapter;  
  7. import java.awt.event.WindowEvent;  
  8. import java.io.File;  
  9. import java.io.FileInputStream;  
  10. import java.io.FileNotFoundException;  
  11. import java.io.FileOutputStream;  
  12. import java.io.FileWriter;  
  13. import java.io.IOException;  
  14. import java.io.InputStream;  
  15. import java.io.OutputStream;  
  16. import java.sql.Connection;  
  17. import java.sql.ResultSet;  
  18. import java.sql.SQLException;  
  19. import java.text.SimpleDateFormat;  
  20. import java.util.Date;  
  21. import java.util.Properties;  
  22.   
  23. import javax.swing.JButton;  
  24. import javax.swing.JCheckBox;  
  25. import javax.swing.JFrame;  
  26. import javax.swing.JLabel;  
  27. import javax.swing.JPanel;  
  28. import javax.swing.JTextField;  
  29. import javax.swing.UIManager;  
  30. import javax.swing.UnsupportedLookAndFeelException;  
  31.   
  32. /** 
  33.  * 此类用来将mysql的表直接生成Bean 
  34.  *  
  35.  * @author Ming 
  36.  */  
  37. public class MySQLToBean extends JFrame {  
  38.     /** 
  39.      *  
  40.      */  
  41.     private static final long serialVersionUID = 1L;  
  42.     private JCheckBox checkBox;  
  43.     Properties p = new Properties();  
  44.     String configFile = "config.ini";  
  45.     private JLabel lblNewLabel_4;  
  46.   
  47.     public MySQLToBean() {  
  48.   
  49.         setResizable(false);  
  50.   
  51.         setTitle("MySQL生成javabean小工具");  
  52.         setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);  
  53.   
  54.         setBounds(100, 100, 484, 324);  
  55.   
  56.         JPanel panel = new JPanel();  
  57.         getContentPane().add(panel, BorderLayout.CENTER);  
  58.         panel.setLayout(null);  
  59.   
  60.         txtLocalhost = new JTextField();  
  61.         txtLocalhost.setText("localhost");  
  62.         txtLocalhost.setBounds(146, 10, 147, 21);  
  63.         panel.add(txtLocalhost);  
  64.         txtLocalhost.setColumns(10);  
  65.   
  66.         JLabel lblIp = new JLabel("IP:");  
  67.         lblIp.setBounds(80, 13, 30, 15);  
  68.         panel.add(lblIp);  
  69.   
  70.         JLabel label = new JLabel("数据库:");  
  71.         label.setBounds(80, 42, 54, 15);  
  72.         panel.add(label);  
  73.   
  74.         textField = new JTextField();  
  75.         textField.setBounds(146, 39, 147, 21);  
  76.         panel.add(textField);  
  77.         textField.setColumns(10);  
  78.   
  79.         JLabel label_1 = new JLabel("表名:");  
  80.         label_1.setBounds(80, 127, 54, 15);  
  81.         panel.add(label_1);  
  82.   
  83.         textField_1 = new JTextField();  
  84.         textField_1.setBounds(146, 124, 147, 21);  
  85.         panel.add(textField_1);  
  86.         textField_1.setColumns(10);  
  87.   
  88.         JLabel label_2 = new JLabel("包名:");  
  89.         label_2.setBounds(79, 156, 54, 15);  
  90.         panel.add(label_2);  
  91.   
  92.         txtComyourcom = new JTextField();  
  93.         txtComyourcom.setText("com.yourcom.bean");  
  94.         txtComyourcom.setBounds(146, 155, 147, 21);  
  95.         panel.add(txtComyourcom);  
  96.         txtComyourcom.setColumns(10);  
  97.   
  98.         JLabel lblNewLabel = new JLabel("输出目录：");  
  99.         lblNewLabel.setBounds(80, 190, 65, 15);  
  100.         panel.add(lblNewLabel);  
  101.   
  102.         textField_3 = new JTextField();  
  103.         textField_3.setBounds(146, 186, 147, 21);  
  104.         panel.add(textField_3);  
  105.         textField_3.setColumns(10);  
  106.   
  107.         checkBox = new JCheckBox("生成包结构目录");  
  108.         checkBox.setSelected(true);  
  109.         checkBox.setBounds(145, 213, 147, 23);  
  110.         panel.add(checkBox);  
  111.   
  112.         JLabel lblNewLabel_1 = new JLabel("可以指定表名，也可以不指定");  
  113.         lblNewLabel_1.setBounds(303, 127, 176, 15);  
  114.         panel.add(lblNewLabel_1);  
  115.   
  116.         JLabel lblNewLabel_2 = new JLabel("* 数据库名");  
  117.         lblNewLabel_2.setForeground(Color.RED);  
  118.         lblNewLabel_2.setBounds(303, 42, 66, 15);  
  119.         panel.add(lblNewLabel_2);  
  120.   
  121.         JLabel lblNewLabel_3 = new JLabel("* 包结构");  
  122.         lblNewLabel_3.setForeground(Color.RED);  
  123.         lblNewLabel_3.setBounds(303, 158, 79, 15);  
  124.         panel.add(lblNewLabel_3);  
  125.   
  126.         JButton button = new JButton("执行");  
  127.         button.addActionListener(new ActionListener() {  
  128.             public void actionPerformed(ActionEvent e) {  
  129.                 go();  
  130.             }  
  131.         });  
  132.         button.setBounds(145, 242, 93, 23);  
  133.         panel.add(button);  
  134.   
  135.         textField_4 = new JTextField();  
  136.         textField_4.setText("123456");  
  137.         textField_4.setBounds(145, 93, 147, 21);  
  138.         panel.add(textField_4);  
  139.         textField_4.setColumns(10);  
  140.   
  141.         txtRoot = new JTextField();  
  142.         txtRoot.setText("root");  
  143.         txtRoot.setBounds(145, 66, 148, 21);  
  144.         panel.add(txtRoot);  
  145.         txtRoot.setColumns(10);  
  146.   
  147.         JLabel label_3 = new JLabel("用户名:");  
  148.         label_3.setBounds(80, 69, 54, 15);  
  149.         panel.add(label_3);  
  150.   
  151.         JLabel label_4 = new JLabel("密码:");  
  152.         label_4.setBounds(80, 96, 54, 15);  
  153.         panel.add(label_4);  
  154.   
  155.         lblNewLabel_4 = new JLabel("");  
  156.         lblNewLabel_4.setForeground(Color.RED);  
  157.         lblNewLabel_4.setBounds(248, 242, 204, 23);  
  158.         panel.add(lblNewLabel_4);  
  159.   
  160.         addWindowListener(new WindowAdapter() {  
  161.   
  162.             public void windowClosing(WindowEvent e) {  
  163.                 super.windowClosing(e);  
  164.                 export();  
  165.                 System.exit(0);  
  166.             }  
  167.   
  168.         });  
  169.   
  170.         inport();  
  171.     }  
  172.   
  173.     static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
  174.     private JTextField txtLocalhost;  
  175.     private JTextField textField;  
  176.     private JTextField textField_1;  
  177.     private JTextField txtComyourcom;  
  178.     private JTextField textField_3;  
  179.     private JTextField textField_4;  
  180.     private JTextField txtRoot;  
  181.   
  182.     /** 
  183.      * @param args 
  184.      */  
  185.     public static void main(String[] args) {  
  186.         try {  
  187.             UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());  
  188.         } catch (ClassNotFoundException e) {  
  189.   
  190.             e.printStackTrace();  
  191.         } catch (InstantiationException e) {  
  192.   
  193.             e.printStackTrace();  
  194.         } catch (IllegalAccessException e) {  
  195.   
  196.             e.printStackTrace();  
  197.         } catch (UnsupportedLookAndFeelException e) {  
  198.   
  199.             e.printStackTrace();  
  200.         }  
  201.         EventQueue.invokeLater(new Runnable() {  
  202.             public void run() {  
  203.                 try {  
  204.                     MySQLToBean frame = new MySQLToBean();  
  205.                     frame.setLocationRelativeTo(null);  
  206.                     frame.setVisible(true);  
  207.                 } catch (Exception e) {  
  208.                     e.printStackTrace();  
  209.                 }  
  210.             }  
  211.         });  
  212.     }  
  213.   
  214.     private void inport() {  
  215.         File config = new File(configFile);  
  216.         if (config.exists()) {  
  217.             try {  
  218.                 InputStream is = new FileInputStream(config);  
  219.                 p.load(is);  
  220.                 is.close();  
  221.                 setUIVal();  
  222.             } catch (FileNotFoundException e) {  
  223.                 // TODO Auto-generated catch block  
  224.                 e.printStackTrace();  
  225.             } catch (IOException e) {  
  226.                 // TODO Auto-generated catch block  
  227.                 e.printStackTrace();  
  228.             }  
  229.         } else {  
  230.             try {  
  231.                 config.createNewFile();  
  232.             } catch (IOException e) {  
  233.                 e.printStackTrace();  
  234.             }  
  235.         }  
  236.   
  237.     }  
  238.   
  239.     public void setUIVal() {  
  240.         txtLocalhost.setText(p.getProperty("host", "localhost"));  
  241.         textField.setText(p.getProperty("database", ""));  
  242.         txtRoot.setText(p.getProperty("user", "root"));  
  243.         textField_4.setText(p.getProperty("pass", "123456"));  
  244.         txtComyourcom.setText(p.getProperty("packname", "com.youcom.bean"));  
  245.         textField_3.setText(p.getProperty("dirstr", ""));  
  246.         textField_1.setText(p.getProperty("tablename", ""));  
  247.     }  
  248.   
  249.     private void export() {  
  250.         String host = txtLocalhost.getText();  
  251.         String database = textField.getText();  
  252.         String user = txtRoot.getText();  
  253.         String pass = textField_4.getText();  
  254.         String packname = txtComyourcom.getText();  
  255.         String dirstr = textField_3.getText();// 空表示当前目录  
  256.         String tablename = textField_1.getText();  
  257.   
  258.         p.setProperty("host", host);  
  259.         p.setProperty("database", database);  
  260.         p.setProperty("user", user);  
  261.         p.setProperty("pass", pass);  
  262.         p.setProperty("packname", packname);  
  263.         p.setProperty("dirstr", dirstr);  
  264.         p.setProperty("tablename", tablename);  
  265.   
  266.         try {  
  267.             OutputStream out = new FileOutputStream(configFile);  
  268.             p.store(out, "退出保存文件," + sdf.format(new Date()));  
  269.         } catch (FileNotFoundException e) {  
  270.             // TODO Auto-generated catch block  
  271.             e.printStackTrace();  
  272.         } catch (IOException e) {  
  273.             // TODO Auto-generated catch block  
  274.             e.printStackTrace();  
  275.         }  
  276.   
  277.     }  
  278.   
  279.     public void setTips(String msg) {  
  280.         lblNewLabel_4.setText(msg);  
  281.     }  
  282.   
  283.     public void go() {  
  284.         String host = txtLocalhost.getText();  
  285.         String database = textField.getText();  
  286.   
  287.         if (database.length() == 0) {  
  288.             setTips("数据库名必填");  
  289.             return;  
  290.         }  
  291.   
  292.         String user = txtRoot.getText();  
  293.         String pass = textField_4.getText();  
  294.         String packname = txtComyourcom.getText();  
  295.         String dirstr = textField_3.getText();// 空表示当前目录  
  296.         String tablename = textField_1.getText();  
  297.         boolean createPackage = checkBox.getSelectedObjects() != null;  
  298.         System.out.println(createPackage);  
  299.         if (dirstr != null && !dirstr.isEmpty()) {  
  300.             if (!dirstr.endsWith("/")) {  
  301.                 dirstr += "/";  
  302.             }  
  303.         }  
  304.         File dir = new File(dirstr);  
  305.         if (createPackage) {  
  306.             dir = new File(dirstr + packname.replaceAll("\\.", "/"));  
  307.             if (!dir.exists()) {  
  308.                 dir.mkdirs();  
  309.             }  
  310.         }  
  311.         String outputdir = dir.getAbsolutePath();// bean的生成目录  
  312.   
  313.         Connection conn = null;  
  314.         try {  
  315.   
  316.             conn = DBManager.mysql(host, database, user, pass);  
  317.             if (tablename.length() > 0) {  
  318.                 parseTableByShowCreate(conn, tablename, packname, outputdir);  
  319.             } else {  
  320.                 parseAllTable(conn, packname, outputdir);  
  321.             }  
  322.         } catch (ClassNotFoundException e) {  
  323.             // TODO Auto-generated catch block  
  324.             e.printStackTrace();  
  325.             setTips("找不到MySQL的jar包");  
  326.         } catch (SQLException e) {  
  327.             // TODO Auto-generated catch block  
  328.             e.printStackTrace();  
  329.         }  
  330.   
  331.     }  
  332.   
  333.     /** 
  334.      * 开始处理生成所有表 如果不传入表名，表示将数据库中所有表生成bean; 可以指定表名生成bean; 
  335.      */  
  336.     public void parseAllTable(Connection conn, String packname, String outputdir) {  
  337.   
  338.         String sql = "show tables";  
  339.         ResultSet rs = DBManager.query(conn, sql);  
  340.         try {  
  341.             while (rs.next()) {  
  342.                 String tablename = rs.getString(1);  
  343.                 parseTableByShowCreate(conn, tablename, packname, outputdir);  
  344.             }  
  345.             DBManager.close(conn, null, rs);  
  346.         } catch (SQLException e) {  
  347.             // TODO Auto-generated catch block  
  348.             e.printStackTrace();  
  349.         }  
  350.     }  
  351.   
  352.     /** 
  353.      * 通过 mysql的 show create table TABLE_NAME逆向生成Bean; 
  354.      *  
  355.      * @param conn 
  356.      * @param tname 
  357.      * @param outputdir 
  358.      * @param packname 
  359.      */  
  360.     private void parseTableByShowCreate(Connection conn, String tablename,  
  361.             String packname, String outputdir) {  
  362.         StringBuilder classInfo = new StringBuilder("\t/**\r\n\t*");  
  363.         boolean shouldCloseConn = false;  
  364.   
  365.         String sql = "desc " + tablename;  
  366.         ResultSet rs = null;  
  367.         try {  
  368.             rs = DBManager.query(conn, sql);  
  369.             StringBuilder fields = new StringBuilder();  
  370.             StringBuilder methods = new StringBuilder();  
  371.             int i = 0;  
  372.             while (rs.next()) {  
  373.                 String fieldName = rs.getString("Field");  
  374.                 System.out.println(rs.getString("Type"));  
  375.                 String fieldType = "";  
  376.                 if (rs.getString("Type").contains("(")) {  
  377.                     fieldType = typeTrans(rs.getString("Type").substring(0,  
  378.                             rs.getString("Type").indexOf("(")));  
  379.                 } else {  
  380.                     fieldType = typeTrans(rs.getString("Type"));  
  381.                 }  
  382.   
  383.                 fields.append(getFieldStr(fieldName, fieldType, null));  
  384.                 methods.append(getMethodStr(fieldName, fieldType));  
  385.   
  386.                 if (i == 0) {  
  387.                     classInfo.append("此类由" + getClass().getSimpleName()  
  388.                             + "工具自动生成\r\n");  
  389.   
  390.                     classInfo.append("\r\n");  
  391.                     classInfo.append("\t*@author \r\n");  
  392.                     classInfo.append("\t*@since ");  
  393.                     classInfo.append(sdf.format(new Date()));  
  394.                     classInfo.append("\r\n\t*/\r\n\r\n");  
  395.   
  396.                 }  
  397.                 i++;  
  398.             }  
  399.             classInfo.append("\tpublic class ")  
  400.                     .append(upperFirestChar(tablename)).append("{\r\n");  
  401.             classInfo.append(fields);  
  402.             classInfo.append(methods);  
  403.             classInfo.append("\r\n");  
  404.             classInfo.append("}");  
  405.         } catch (SQLException e) {  
  406.             // TODO Auto-generated catch block  
  407.             e.printStackTrace();  
  408.         } finally {  
  409.   
  410.             DBManager.close(shouldCloseConn ? conn : null, null, rs);  
  411.         }  
  412.   
  413.         String packageinfo = "package " + packname.replace("src.", "")  
  414.                 + ";\r\n\r\n";  
  415.         File file = new File(outputdir, upperFirestChar(tablename) + ".java");  
  416.         System.out.println(file.getAbsolutePath());  
  417.         try {  
  418.             FileWriter fw = new FileWriter(file);  
  419.             fw.write(packageinfo);  
  420.             fw.write(classInfo.toString());  
  421.             fw.flush();  
  422.             fw.close();  
  423.         } catch (IOException e) {  
  424.             // TODO Auto-generated catch block  
  425.             e.printStackTrace();  
  426.         }  
  427.     }  
  428.   
  429.     /** 
  430.      *  
  431.      * @param type 
  432.      * @return 
  433.      */  
  434.     private String getMethodStr(String field, String type) {  
  435.         StringBuilder get = new StringBuilder("\tpublic ");  
  436.         get.append(type).append(" ");  
  437.         if (type.equals("boolean")) {  
  438.             get.append(field);  
  439.         } else {  
  440.             get.append("get");  
  441.             get.append(upperFirestChar(field));  
  442.         }  
  443.         get.append("(){").append("\r\n\t\treturn this.").append(field)  
  444.                 .append(";\r\n\t}\r\n");  
  445.         StringBuilder set = new StringBuilder("\tpublic void ");  
  446.   
  447.         if (type.equals("boolean")) {  
  448.             set.append(field);  
  449.         } else {  
  450.             set.append("set");  
  451.             set.append(upperFirestChar(field));  
  452.         }  
  453.         set.append("(").append(type).append(" ").append(field)  
  454.                 .append("){\r\n\t\tthis.").append(field).append("=")  
  455.                 .append(field).append(";\r\n\t}\r\n");  
  456.         get.append(set);  
  457.         return get.toString();  
  458.     }  
  459.   
  460.     public String upperFirestChar(String src) {  
  461.         return src.substring(0, 1).toUpperCase().concat(src.substring(1));  
  462.     }  
  463.   
  464.     private String getFieldStr(String field, String type, String cmt) {  
  465.         StringBuilder sb = new StringBuilder();  
  466.         sb.append("\t").append("private ").append(type).append(" ")  
  467.                 .append(field).append(";");  
  468.         if (cmt != null) {  
  469.             sb.append("//").append(cmt);  
  470.         }  
  471.         sb.append("\r\n");  
  472.         return sb.toString();  
  473.     }  
  474.   
  475.     /** 
  476.      * mysql的类型转换到java 类型参考文章 
  477.      *  
  478.      */  
  479.     public String typeTrans(String type) {  
  480.         if (type.contains("tinyint")) {  
  481.             return "boolean";  
  482.         } else if (type.contains("int")) {  
  483.             return "int";  
  484.         } else if (type.contains("varchar") || type.contains("date")  
  485.                 || type.contains("time") || type.contains("datetime")  
  486.                 || type.contains("timestamp") || type.contains("text")  
  487.                 || type.contains("enum") || type.contains("set")) {  
  488.             return "String";  
  489.         } else if (type.contains("binary") || type.contains("blob")) {  
  490.             return "byte[]";  
  491.         } else {  
  492.             return "String";  
  493.         }  
  494.     }  
  495. }  
  496.  


(责任编辑：IT)
    最近关注
    热点内容