JDBC读取数据库元数据,生成JAVA实体类，SQL语句，Mybatis动态sql语句

最新推荐文章于 2024-06-10 21:59:35 发布
最新推荐文章于 2024-06-10 21:59:35 发布
阅读量1.1k 收藏 9
点赞数 1
分类专栏： java mysql SQL jdbc java开发 文章标签： java mysql SQL jdbc java开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zi971553/article/details/82862039
版权
java 同时被 3 个专栏收录
1 篇文章 0 订阅
订阅专栏
mysql
1 篇文章 0 订阅
订阅专栏
SQL
1 篇文章 0 订阅
订阅专栏

由于我们在做一些简单项目时候(开发工具：可以使用IntelliJ IDEA 或者Eclipse/MyEclipse或者NetBeans)，经常要写一些和数据库对应的java实体类，手写太慢，我自己根据jdbc读取表结构元数据的原理写了下面的工具类，该工具类拥有如下功能:

  1. 能够生成实体类java文件（实体类名称可以随便自由定义）
  2. 能够生成常用的SQL语句
  3. 能够生成Mybatis常用的SQL语句
  4. 能够生成servlet获取参数赋值java代码


java 通过数据库中属性生成相对应的Javabean只是实现了常用字段的生成 生成路径默认是项目根目录下面{项目名/生成文件在这里} 使用方法（只适合mysql数据库）： 修改下面的数据库连接信息，然后使用主函数运行下面方法，然后点击项目名称右键刷新，或者F5刷新， 就可以看到生成实体类文件，将文件复制到项目中就可以，修改一下包路径就可以。

GenEntityTool_Mysql_MybatisSQL.Java文件需要修改配置信息如下:（绿色加粗部分需要修改）

// MYSQL 数据库连接驱动信息
String databaseName = "db_cate";// mysql数据库名称
String user = "root"; // 数据库连接用户名
String password = "root"; // 数据库连接密码
String tableName = "tb_company"; // 要生成实体类的数据库表名（数据库中表名称）
String entityName = "Company";// 要生成实体类的表名 【Java类名】

具体代码如下:

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.*;

//JDBC读取数据库元数据,生成JAVA实体类

/**
 * java 通过数据库中属性生成相对应的Javabean 只是实现了常用字段的生成 生成路径默认是项目根目录下面{项目名/生成文件在这里}
 * 使用方法（只适合mysql数据库）： 修改下面的数据库连接信息，然后使用主函数运行下面方法，然后点击项目名称右键刷新，或者F5刷新，
 * 就可以看到生成实体类文件，将文件复制到项目中就可以，修改一下包路径就可以
 *
 * @author 谭清明
 * @QQ 2551449109
 */
public class GenEntityTool_Mysql_MybatisSQL {
    public static void main(String[] args) {
        // MYSQL 数据库连接驱动信息
        String databaseName = "db_cate";// mysql数据库名称
        String user = "root"; // 数据库连接用户名
        String password = "tianming"; // 数据库连接密码
        String tableName = "tb_company"; // 要生成实体类的数据库表名（数据库中表名称）
        String entityName = "Company";// 要生成实体类的表名 【Java类名】
        String driverClassName = "com.mysql.jdbc.Driver";
        String url = "jdbc:mysql://localhost:3306/" + databaseName + "?characterEncoding=utf8";// //
        new GenEntityTool_Mysql_MybatisSQL(driverClassName, url, user, password, tableName, entityName);

        /**
         * 案例： 使用说明： 修改数据库名称 --databaseName test 修改数据库表名 --tableName tb_user
         * 修改生成Java类的类名 --entityName UserEntity
         *
         * 修改后直接使用main函数运行程序 可以在项目目录下面 entityName值命名.java的文件 就是根据数据库生成实体类 @2551449109
         * 有问题可以直接咨询
         *
         */

    }

    private String tablename = ""; // 要生成实体类的表名
    private String entityName = ""; // 要生成实体类的实体名称

    private String[] colnames; // 列名数组

    private String[] colTypes; // 列名类型数组

    private int[] colSizes; // 列名大小数组

    private String[] CommentSizes; // 注释内容数组

    private boolean f_util = true; // 是否需要导入包java.util.* false 不引入

    private boolean f_sql = false; // 是否需要导入包java.sql.* false 不引入

    private String driverClassName;// 数据库驱动名称
    private String url; // 数据库连接地址
    private String password; // 数据库连接密码
    private String user; // 数据库连接用户名

    public GenEntityTool_Mysql_MybatisSQL(String driverClassName, String url, String user, String password,
                                          String tablename, String entityName) {
        this.tablename = tablename;
        this.driverClassName = driverClassName;
        this.url = url;
        this.password = password;
        this.user = user;
        this.entityName = entityName;
        Connection conn;
        try {
            conn = getConnection();
            // 得到数据库连接
            String strsql = "select * from " + tablename;
            try {
                PreparedStatement pstmt = conn.prepareStatement(strsql);
                ResultSetMetaData rsmd = pstmt.getMetaData();
                int size = rsmd.getColumnCount(); // 共有多少列
                colnames = new String[size];
                colTypes = new String[size];
                colSizes = new int[size];
                CommentSizes = new String[size];
                for (int i = 0; i < rsmd.getColumnCount(); 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);
                }

                /**
                 * 读取字段注释信息
                 *
                 */
                Statement stmt = conn.createStatement();
                ResultSet rs = stmt.executeQuery("show full columns from " + tablename);
                int a = 0;
                while (rs.next()) { // 获取字段注释
                    CommentSizes[a] = rs.getString("Comment");
                    a++;
                }
                String content = parse(colnames, colTypes, colSizes);
                try {
                    // 将内容输出为文件
                    FileWriter fw = new FileWriter(entityName + ".java");
                    PrintWriter pw = new PrintWriter(fw);
                    pw.println(content);
                    pw.flush();
                    pw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                closeConn(conn);
            }

        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }

    /**
     * 获取数据库连接
     *
     * @return
     */
    public Connection getConnection() {
        try {
            Class.forName(driverClassName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            throw new RuntimeException("加载数据库驱动错误!", e);
        }
        Connection conn = null;
        try {
            conn = DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("数据库连接错误!", e);
        }
        return conn;

    }

    /**
     * 关闭数据库连接
     *
     * @param conn
     */
    public void closeConn(Connection conn) {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

    public GenEntityTool_Mysql_MybatisSQL() {
        Connection conn;
        try {
            conn = getConnection();// 得到数据库连接
            String strsql = "select * from " + tablename;
            try {
                PreparedStatement pstmt = conn.prepareStatement(strsql);
                ResultSetMetaData rsmd = pstmt.getMetaData();
                int size = rsmd.getColumnCount(); // 共有多少列
                colnames = new String[size];
                colTypes = new String[size];
                colSizes = new int[size];
                for (int i = 0; i < rsmd.getColumnCount(); 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 {
                    FileWriter fw = new FileWriter(entityName + ".java");
                    PrintWriter pw = new PrintWriter(fw);
                    pw.println(content);
                    pw.flush();
                    pw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                closeConn(conn);
            }
        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }

    /**
     * 解析处理(生成实体类主体代码)
     */
    private String parse(String[] colNames, String[] colTypes, int[] colSizes) {
        StringBuffer sb = new StringBuffer();
        if (f_util) {
            sb.append("import java.util.Date; \r\n");
        }
        if (f_sql) {
            sb.append("import java.sql.*; \r\n\r\n\r\n");
        }
        sb.append("public class " + entityName + " implements  Serializable   {\r\n");
        processAllAttrs(sb);
        sb.append("\n");// 所有属性之后追加一个换行
        processNullConstructor(sb);
        processAllMethod(sb);
        processtoString(sb);
        sb.append("}\r\n");
        System.out.println(sb.toString());
        return sb.toString();

    }

    /**
     * 生成所有的方法
     *
     * @param sb
     */

    private void processAllMethod(StringBuffer sb) {
        /**
         * 生成servlet自动获取参数的代码
         */
        createRequest();
        /************
         * jdbc PrepareStatement SQL start
         **************************/
        createInsertJdbcSQL();
        createDeleteJdbcSQL();
        createUpdateJdbcSQL();
        createSelectJdbcSQL();
        /************ jdbc PrepareStatement SQL end **************************/

        /************ jdbc Mybatis SQL start **************************/
        String showColnames = "";
        String restultColnames = "";
        String selectSql = "SELECT  \n";
        String insertSql = null;
        String insertSql2 = ") VALUES (\n";
        String updatesql = "";
        String findAllsql = "\n SELECT * FROM "+tablename+" \n";  //查询所有动态sql
        findAllsql+="<WHERE>";
        String deleteSql = "DELETE FROM " + tablename + " WHERE ";
        deleteSql += colnames[0] + "  = #{" + colnames[0] + "} ";

        insertSql = "INSERT INTO  " + tablename + "(\n";// insert SQL
        updatesql = "UPDATE  " + tablename + "\n<set> ";// update SQL
        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("\t\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\n");

            // 以下用于生成实体类操作Mybatis中sql 语句
            showColnames += colnames[i] + ",\n";
            restultColnames += "<result property=\"" + colnames[i] + "\" column=\"" + colnames[i] + "\" />\n";
            selectSql += colnames[i] + ",\n";

            insertSql += colnames[i] + ",\n";
            insertSql2 += "#{" + colnames[i] + "},\n";

            if (i != 0) {
                if(sqlType2JavaType(colTypes[i]).equals("Date")){
                  updatesql += "\n<if test=\"" + colnames[i] + " != null \">\n";
                }else{
                    updatesql += "\n<if test=\"" + colnames[i] + " != null and " + colnames[i] + " != ''\">\n";
                }
                updatesql += "\t" + colnames[i] + " = #{" + colnames[i] + "},\n";
                updatesql += "</if>";

                //查询所有sql语句  动态sql拼接
                if(sqlType2JavaType(colTypes[i]).equals("Date")){
                    findAllsql += "\n<if test=\"" + colnames[i] + " != null \">\n";
                }else{
                    findAllsql += "\n<if test=\"" + colnames[i] + " != null and " + colnames[i] + " != ''\">\n";
                }
                findAllsql += "\t and " + colnames[i] + " = #{" + colnames[i] + "}\n";
                findAllsql += "</if>";
            }

        }
        findAllsql+="\n</WHERE>\n";
        showColnames = showColnames.substring(0, showColnames.length() - 2);// 除去最后一个，
        selectSql = selectSql.substring(0, selectSql.length() - 2);// 除去最后一个，
        selectSql += " FROM " + tablename;
        System.out.println(showColnames);
        System.out.println();
        System.out.println(restultColnames);
        System.out.println();
        System.out.println(selectSql);
        System.out.println();
        System.out.println(findAllsql);
        System.out.println();
        insertSql = insertSql.substring(0, insertSql.length() - 2);// 除去最后一个，
        insertSql2 = insertSql2.substring(0, insertSql2.length() - 2);// 除去最后一个，
        insertSql += insertSql2 + "\n\t) ";
        System.out.println(insertSql);
        System.out.println();
        updatesql += "\n</set>" + "\n\t" + " where " + colnames[0] + " = #{" + colnames[0] + "}";
        System.out.println(updatesql);
        System.out.println();
        System.out.println(deleteSql);
        /************ jdbc Mybatis SQL end **************************/
    }

    /**
     * create insert SQL
     */
    private void createInsertJdbcSQL() {
        String insertSql = null;
        String insertSql2 = ") VALUES (";
        insertSql = "INSERT INTO  " + tablename + "(";
        for (int i = 0; i < colnames.length; i++) {
            insertSql += colnames[i] + ",";
            insertSql2 += "?,";
        }
        insertSql = insertSql.substring(0, insertSql.length() - 1);// 除去最后一个，
        insertSql2 = insertSql2.substring(0, insertSql2.length() - 1);// 除去最后一个，
        insertSql += insertSql2 + ")";
        System.out.println(insertSql + "\n");
    }

    /**
     * create delete SQL
     */
    private void createDeleteJdbcSQL() {
        String deleteSql = "DELETE FROM " + tablename + " WHERE ";
        deleteSql += colnames[0] + "  = ? " + "\n";
        System.out.println(deleteSql + "\n");
    }

    /**
     * create update SQL
     */
    private void createUpdateJdbcSQL() {
        String updateSql = "";
        updateSql = "UPDATE  " + tablename + " SET  ";// update SQL
        for (int i = 1; i < colnames.length; i++) {
            updateSql += colnames[i] + "=?,";
        }
        updateSql = updateSql.substring(0, updateSql.length() - 1);// 去除多余的逗号
        updateSql += " WHERE " + colnames[0] + "=? ";
        System.out.println(updateSql + "\n");
    }

    /**
     * create select SQL
     */
    private void createSelectJdbcSQL() {
        String selectSql = "SELECT  ";
        for (int i = 0; i < colnames.length; i++) {
            selectSql += colnames[i] + ",";
        }
        selectSql = selectSql.substring(0, selectSql.length() - 1);// 除去最后一个，
        selectSql += " FROM " + tablename;
        System.out.println(selectSql + "\n");
    }

    /**
     * 生成Servlet自动获取参数的代码
     */
    private void createRequest() {
        String str = "";
        StringBuffer sb = new StringBuffer();
        StringBuffer sbResultSetSql = new StringBuffer();
        StringBuffer getAttr = new StringBuffer();
        String objName = initLowercase(entityName);
        sb.append(entityName + " " + objName + "= new " + entityName + "();\n");
        sbResultSetSql.append(entityName + " " + objName + "= new " + entityName + "();\n");
        for (int i = 0; i < colnames.length; i++) {
            str += "String " + colnames[i] + "=" + "request.getParameter(\"" + colnames[i] + "\");\n";

            sb.append(objName + ".set" + initcap(colnames[i]) + "(" + colnames[i] + ");\n");

            sbResultSetSql.append(objName + ".set" + initcap(colnames[i]) + "(rs.get"
                    + initcap(sqlType2JavaType(colTypes[i])) + "(\"" + colnames[i] + "\"));\n");

            getAttr.append("obj" + ".get" + initcap(colnames[i]) + "(),\n");

        }
        System.out.println(str + "\n");
        System.out.println(sb.toString() + "\n");
        System.out.println(sbResultSetSql.toString() + "\n");
        System.out.println(getAttr.toString() + "\n");
    }

    /**
     * 解析输出属性
     *
     * @return
     */
    private void processAllAttrs(StringBuffer sb) {
        for (int i = 0; i < colnames.length; i++) {
            sb.append("\tprivate " + sqlType2JavaType(colTypes[i]) + " " + colnames[i] + ";");
            if (CommentSizes[i] != null && CommentSizes[i] != "") {
                sb.append("\t//" + CommentSizes[i]);
            }
            sb.append(" \r\n");
        }
    }

    /**
     * 把输入字符串的首字母改成小写
     *
     * @param str
     * @return
     */
    private String initLowercase(String str) {
        char[] ch = str.toCharArray();
        if (ch[0] >= 'A' && ch[0] <= 'Z') {
            ch[0] = (char) (ch[0] + 32);
        }
        return new String(ch);
    }

    /**
     * 把输入字符串的首字母改成大写
     *
     * @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);
    }

    /**
     * 判断数据库中的字段类型对应Java中的类型
     *
     * @param sqlType
     * @return
     */
    private String sqlType2JavaType(String sqlType) {
        // 以下数据库中字段对应Java字段匹配过程中，可能存在失误
        // 对于特殊字段类型，可以需要手动修改一下
        // System.err.println(sqlType);// 输出字段类型名称
        // System.err.println(sqlType);// 输出字段类型名称
        if (sqlType.equalsIgnoreCase("bit")) {
            return "boolean";
        } else if (sqlType.equalsIgnoreCase("tinyint") || sqlType.equalsIgnoreCase("TINYINT UNSIGNED")) {
            return "byte";
        } else if (sqlType.equalsIgnoreCase("smallint") || sqlType.equalsIgnoreCase("SMALLINT UNSIGNED")) {
            return "short";
        } else if (sqlType.equalsIgnoreCase("INT UNSIGNED") || sqlType.equalsIgnoreCase("int")) {
            return "Integer";
        } else if (sqlType.equalsIgnoreCase("bigint") || sqlType.equalsIgnoreCase("BIGINT UNSIGNED")) {
            return "long";
        } else if (sqlType.equalsIgnoreCase("float")) {
            return "float";
        } else if (sqlType.equalsIgnoreCase("decimal") || sqlType.equalsIgnoreCase("numeric")
                || sqlType.equalsIgnoreCase("real")) {
            return "double";
        } else if (sqlType.equalsIgnoreCase("money") || sqlType.equalsIgnoreCase("smallmoney")) {
            return "double";
        } else if (sqlType.equalsIgnoreCase("varchar") || sqlType.equalsIgnoreCase("char")
                || sqlType.equalsIgnoreCase("blob") || sqlType.equalsIgnoreCase("nvarchar")
                || sqlType.equalsIgnoreCase("nchar") || sqlType.equalsIgnoreCase("longblob")) {
            return "String";
        } else if (sqlType.equalsIgnoreCase("datetime") || sqlType.equalsIgnoreCase("time")) {
            return "Date";
        } else if (sqlType.equalsIgnoreCase("date")) {
            return "Date";
        } else if (sqlType.equalsIgnoreCase("timestamp")) {
            return "Timestamp";
        } else if (sqlType.equalsIgnoreCase("double")) {
            return "double";
        } else if (sqlType.equalsIgnoreCase("image")) {
            return "Blob";
        } else if (sqlType.equalsIgnoreCase("text")) {
            return "Clob";
        }
        return null; // 不能匹配情况下直接返回null，到时候需要自己优化
    }

    /**
     * 生成toString方法 双引号转义 \"
     *
     * @param sbf
     */
    public void processtoString(StringBuffer sbf) {
        sbf.append("\t@Override\n");
        sbf.append("\tpublic String toString(){\n");
        sbf.append("\t\t");
        sbf.append("return \" " + entityName + " [");
        for (int i = 0; i < colnames.length; i++) {
            if (i > 0) { // 不是第一个属性追加 ",
                sbf.append(" \" , ");
            }
            sbf.append(colnames[i] + "=\" " + "+ " + colnames[i] + "+");
        }
        sbf.append("\"]\"");
        sbf.append(";");
        sbf.append("\n\t}\n\n");
    }

    /**
     * 生成无参构造函数
     *
     * @param sbf
     */
    public void processNullConstructor(StringBuffer sbf) {
        sbf.append("\tpublic " + entityName + " (){\n");
        sbf.append("\n\t}\n\n");
    }

}

测试数据库表用户表tb_user:

DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user` (
  `user_id` int(11) DEFAULT NULL COMMENT '用户ID',
  `user_name` varchar(255) DEFAULT NULL COMMENT '用户姓名',
  `user_pwd` varchar(255) DEFAULT NULL COMMENT '用户密码'
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

控制台生成代码如下：

String user_id=request.getParameter("user_id");
String user_name=request.getParameter("user_name");
String user_pwd=request.getParameter("user_pwd");


User user= new User();
user.setUser_id(user_id);
user.setUser_name(user_name);
user.setUser_pwd(user_pwd);


User user= new User();
user.setUser_id(rs.getInteger("user_id"));
user.setUser_name(rs.getString("user_name"));
user.setUser_pwd(rs.getString("user_pwd"));


obj.getUser_id(),
obj.getUser_name(),
obj.getUser_pwd(),


INSERT INTO  tb_user(user_id,user_name,user_pwd) VALUES (?,?,?)

DELETE FROM tb_user WHERE user_id  = ? 


UPDATE  tb_user SET  user_name=?,user_pwd=? WHERE user_id=? 

SELECT  user_id,user_name,user_pwd FROM tb_user

user_id,
user_name,
user_pwd

<result property="user_id" column="user_id" />
<result property="user_name" column="user_name" />
<result property="user_pwd" column="user_pwd" />


SELECT  
user_id,
user_name,
user_pwd FROM tb_user


 SELECT * FROM tb_user 
<WHERE>
<if test="user_name != null and user_name != ''">
     and user_name = #{user_name}
</if>
<if test="user_pwd != null and user_pwd != ''">
     and user_pwd = #{user_pwd}
</if>
</WHERE>


INSERT INTO  tb_user(
user_id,
user_name,
user_pwd) VALUES (
#{user_id},
#{user_name},
#{user_pwd}
    ) 

UPDATE  tb_user
<set> 
<if test="user_name != null and user_name != ''">
    user_name = #{user_name},
</if>
<if test="user_pwd != null and user_pwd != ''">
    user_pwd = #{user_pwd},
</if>
</set>
     where user_id = #{user_id}

DELETE FROM tb_user WHERE user_id  = #{user_id} 
import java.util.Date; 
public class User implements  Serializable   {
    private Integer user_id;    //用户ID 
    private String user_name;    //用户姓名 
    private String user_pwd;    //用户密码 

    public User (){

    }

    public void setUser_id(Integer user_id){
        this.user_id=user_id;
    }
    public Integer getUser_id(){
        return user_id;
    }

    public void setUser_name(String user_name){
        this.user_name=user_name;
    }
    public String getUser_name(){
        return user_name;
    }

    public void setUser_pwd(String user_pwd){
        this.user_pwd=user_pwd;
    }
    public String getUser_pwd(){
        return user_pwd;
    }

    @Override
    public String toString(){
        return " User [user_id=" + user_id+ " , user_name=" + user_name+ " , user_pwd=" + user_pwd+"]";
    }

}
 

还会生成一个java文件：

 

具体实现代码下载（包括驱动+测试代码）:

https://download.csdn.net/download/zi971553/10690015

天明源码
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDBC-根据反射机制动态构建插入实体记录的sql语句
fightee的博客
03-12 637
思路 动态构建实现添加的sql语句，根据传入的不同实体类的字段属性不同，来构建不同的sql语句。 封装前的数据库添加操作 以插入学生实体记录为例，该实体有id，sn，name，password，sex五个字段属性。 String sql = "insert into student(id,sn,name,password,sex) values(null,?,?,?,?)"; try { ...
jdbc实体类操作
melody875649004的博客
09-07 1376
public class Jdbcclass {     public static void main(String[] args) throws SQLException, ClassNotFoundException {         Jdbcclass jc = new Jdbcclass();         jc.fun1();     }     public static vo...
JDBC（三）通用操作
faramita_of_mine的博客
11-11 539
JDBC之通用操作一、反射编写通用插入二、反射编写通用修改三、反射编写通用查询四、Stream 递归树形封装 本节主要内容如下： 一、反射编写通用插入   在使用反射完成数据库通用操作时一般我们需要制定一些约定。假设我们数据库在设计和开发时都满足如下约定： 1.数据库表名和实体名满足下划线与驼峰命名转换规则。 2.数据库字段与实体属性名满足下划线与驼峰命名转换规则。 3.每张表都有一个叫 id 的字段并是该表的自增主键。 4.添加时实体不需要有 id 值，而修改时是必须的。   满足如上规则后我们便可以编写
带你学习Mybatis之DataSource数据源
最新发布
Lxn2zh的博客
06-10 787
当程序需要使用数据库连接时，从池中获取连接；所有的数据源组件都实现了javax.sql.DataSource接口，Mybatis实现了两个接口实现，分别为PooledDataSource和UnpooledDataSource，使用不同的DataSourceFactory接口实现创建不同类型的DataSource。数据库连接的创建是非常耗时的，数据库能够建立的连接数也是有限的，像上述UnpooledDataSource中这种每次都会创建连接的方式是存在弊端的，很多系统都是使用数据库连接池。
JDBC002--java中连接数据库后执行insert插入记录的操作
码到成龚的博客
08-03 4951
java中连接数据库后执行插入记录的操作
jdbc操作根据bean类自动组装sql,天啦，我感觉我实现了hibernate
懒松鼠Flink
06-12 120
场景:需要将从ODPS数仓中计算得到的大额可疑交易信息导入到业务系统的mysql中供业务系统审核。最简单的方式是用阿里云的组件自动进行数据同步了。但是本系统是开放是为了产品化，要保证不同环境的可移植性，同时同步的表也就6个表，那么就利用现有的基于jdbc的规则引擎工程来自己实现数据的同步。 完整的工程代码可以参考我的github https://github.com/intsmaze/...
MySQL表自动生成Java实体类
11-23
Java实体类（Entity Class）作为数据模型的表示，与数据库中的表进行映射，使得开发者能够更方便地操作数据库。本主题主要讲解如何利用工具或自定义脚本将MySQL数据表自动生成对应的Java实体类，提高开发效率。 ...
java操作mysql数据库，不写sql语句版
08-28
Hibernate通过XML配置文件或注解将Java实体类映射到数据库表，然后提供了Session接口来处理数据持久化。例如，我们可以使用`Session.save()`方法来保存对象，`Session.get()`来读取，`Session.update()`来更新，以及...
java代码生成器数据库表一键生成类文件
03-05
这个小项目的核心功能在于自动化地从数据库中读取表的信息，如字段名、数据类型、主键等，然后根据这些信息生成对应的Java实体类、DAO（数据访问对象）、Service以及Mapper接口等文件。通过这种方式，开发者可以快速...
pgsql中使用mybatis生成实体类
06-20
1. **安装和配置MyBatis Generator（MBG）**：MBG是MyBatis的一个插件，它可以自动根据数据库表结构生成Java实体类、Mapper接口和XML配置文件。首先，你需要在项目中添加MBG的依赖，通常是在Maven或Gradle的配置文件...
JDBC读取数据库元数据,生成JAVA实体类
开源 共享 学习
12-11 508
JDBC读取数据库元数据,生成JAVA实体类
使用idea自带database快速创建实体类等基础文件
qq_41444892的博客
09-28 4553
使用idea自带database功能快速创建dao,entity,mapper等基础文件 本次操作演示数据库为mysql idea版本为2019.3.4 此次操作之前需要安装Free MyBatis plugin插件 第一步：在idea中连接数据库 1：点击idea右边Database菜单栏，点击左上角的＋号按钮，选择你想要链接的数据库类型 2：在弹出的配置框中将红色部分修改为你的数据库信息 3：点击Test Connection，下边留白部分出现如图提示即连接成功 第二步：选择对应的表名配置文件位置
使用jdbc获取数据生成新的insert sql文本
weixin_54685622的博客
02-28 666
以oracle数据库为列： 1、pom文件配置 <properties> <!-- 编译编码方式 --> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <jdk.version>1.7</jdk.version> </properties> <dependencies> <dependency
怎么创建JDBC语句对象来执行SQL语句（详解）
Feng0811xin的博客
11-22 5202
JDBC执行SQL语句： 一旦获得了链接，我们可以与数据库进行交互。JDBC Statement和PreparedStatement 接口定义了使 您能发送SQL命令并从数据库 进行接收数据的方法和属性。 1.Statement：创建语句对象 在使用Statement对象执行SQL语句之前，需要使用Connection对象的createStatement（）方法来创建 在创建Statem...
mybatis 中对元数据的操作
天涯共明月的博客
10-06 1956
mybatis 中对元数据的操作 目录mybatis 中对元数据的操作1. 使用MySQL内部数据库information_schema表查询实现1.1 MySQL内部字段表 information_schema.COLUMNS1.2 mybatis的mapper.xml文件1.3 mybatis服务层1.4 输出结果2. 使用jdbc方式获取元数据2.1 使用原生jdbc获取元数据2.1.1 原生JDBC2.1.2 DatabaseMetaData.getColumns2.2 mybatis采用JDBC
mybatis mysql元数据_Mybatis源码研究6：元数据(metadata) | 学步园
weixin_33518100的博客
01-30 121
原理分析之六：元数据(metadata)一、依赖关系 本包对mybatis的其它包没有任何依赖，mybatis的其它包也不依赖于本包，即本包可以作为单独的组件或者工具类提出来。二、类功能概述 包含了3个元数据实体类和一个工厂类。Table是对表的简单封装，包括name,columns,primaryKey,catalog，schema。Column是对列的简单封装，包括name和type。Da...
mybatis进击四：原始SQL查询
琼华
05-10 593
一、原始SQL查询 public static void main(String[] args) throws ClassNotFoundException, SQLException { // 四大参数 // MySQL 8.0 以上版本 - JDBC 驱动名及数据库 URL String JDBC_DRIVER = "com.mysql.jdbc.Driver"; String DB_URL = "jdbc:mysql://localh
Mybatis和实体类方法的操作
JAVA_SR的博客
06-05 2561
Mybatis和实体类方法以及数据库的一系列操作
java如何读取oracle的表自动生成实体类
08-07
Java可以使用JDBC连接Oracle数据库，并通过执行SQL语句读取表的结构信息，从而生成对应的实体类。 首先，需要引入Java连接Oracle数据库的依赖，如ojdbc.jar。 接下来，可以使用Java代码连接到Oracle数据库，通过...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值