精华内容
下载资源
问答
  • Java动态增加实体类的属性
    千次阅读
    2022-02-15 14:45:41

    1、DynamicBean

    import org.springframework.cglib.beans.BeanGenerator;
    import org.springframework.cglib.beans.BeanMap;
    
    import java.util.Map;
    
    public class DynamicBean {
    
        /**
         * 目标对象
         */
        private Object target;
    
        /**
         * 属性集合
         */
        private BeanMap beanMap;
    
        public DynamicBean(Class superclass, Map<String, Class> propertyMap) {
            this.target = generateBean(superclass, propertyMap);
            this.beanMap = BeanMap.create(this.target);
        }
    
        /**
         * bean 添加属性和值
         *
         * @param property
         * @param value
         */
        public void setValue(String property, Object value) {
            beanMap.put(property, value);
        }
    
        /**
         * 获取属性值
         *
         * @param property
         * @return
         */
        public Object getValue(String property) {
            return beanMap.get(property);
        }
    
        /**
         * 获取对象
         *
         * @return
         */
        public Object getTarget() {
            return this.target;
        }
    
    
        /**
         * 根据属性生成对象
         *
         * @param superclass
         * @param propertyMap
         * @return
         */
        private Object generateBean(Class superclass, Map<String, Class> propertyMap) {
            BeanGenerator generator = new BeanGenerator();
            if (null != superclass) {
                generator.setSuperclass(superclass);
            }
            BeanGenerator.addProperties(generator, propertyMap);
            return generator.create();
        }
    
    }
    
    

    2、BeanAddPropertiesUtil

    import com.google.common.collect.Maps;
    import org.apache.commons.beanutils.PropertyUtilsBean;
    
    import java.beans.PropertyDescriptor;
    import java.util.Map;
    
    public class BeanAddPropertiesUtil {
        public static Object getTarget(Object dest, Map<String, Object> addProperties) {
            // get property map
            PropertyUtilsBean propertyUtilsBean = new PropertyUtilsBean();
            PropertyDescriptor[] descriptors = propertyUtilsBean.getPropertyDescriptors(dest);
            Map<String, Class> propertyMap = Maps.newHashMap();
            for (PropertyDescriptor d : descriptors) {
                if (!"class".equalsIgnoreCase(d.getName())) {
                    propertyMap.put(d.getName(), d.getPropertyType());
                }
            }
            // add extra properties
            addProperties.forEach((k, v) -> propertyMap.put(k, v.getClass()));
            // new dynamic bean
            DynamicBean dynamicBean = new DynamicBean(dest.getClass(), propertyMap);
            // add old value
            propertyMap.forEach((k, v) -> {
                try {
                    // filter extra properties
                    if (!addProperties.containsKey(k)) {
                        dynamicBean.setValue(k, propertyUtilsBean.getNestedProperty(dest, k));
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
            // add extra value
            addProperties.forEach((k, v) -> {
                try {
                    dynamicBean.setValue(k, v);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
            Object target = dynamicBean.getTarget();
            return target;
    
        }
    }
    
    

    3、实际运用:

    OrderUserOrderMerchantDTO orderMerchantDTO = new OrderUserOrderMerchantDTO ();
    orderMerchantDTO.setRealName(***);
    Map<String, Object> map = new HashMap<>();
    //通过list动态添加属性
    if (CollectionUtils.isNotEmpty(orderMerchandiseList)) {
        List<String> orderNumberList = orderMerchandiseList.stream().map(OrderUserOrderMerchandiseVO::getOrderNumber).collect(Collectors.toList());
        for (int i = 0, j = orderNumberList.size(); i < j; i++) {
            map.put("orderNumber" + i, orderNumberList.get(i));
        }
    }
    OrderUserOrderMerchantDTO merchantDTO = (OrderUserOrderMerchantDTO) BeanAddPropertiesUtil.getTarget(orderMerchantDTO, map);
    //增加后的实体对象引用
     String jsonStr = toJSONString(merchantDTO);
    
    更多相关内容
  • JAVA 动态生成实体类.rar

    热门讨论 2009-12-13 20:01:21
    JAVA 动态生成实体类.rar mvc做的,指需要输入数据库名 密码 数据库的名字即可
  • 实体类生成工具

    2018-12-05 13:28:18
    根据三方提供的api参数生成项目所需的java实体类,目前只支持docx文档
  • Java逆向生成实体类:包括所需要的import,tag,字段注释,序列化等。配套的还有dao层,dao.xml,service层,serviceImpl的生成文件,在其他下载资源中。
  • 主要介绍了Java运行时动态生成类实现过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java实体类生成工具

    2019-04-15 14:26:31
    是在前辈基础上进行完善的, 可以于生成一般的Java实体类,欢迎提出存在的bug 与 升级建议.
  • java桌面程序,已打成jar包,双击运行即可,目前支持oracle、mysql、db2(因没装环境故没测试),oracle、mysql测试通过生成实体类,带comment注释、带get、set方法,
  • 下载后可直接导入工程,设置好要连接的数据库,点运行即可自动生成mybatis中用到的mapper、实体类、mapper.xml
  • 根据数据库表动态生成java实体类

    千次阅读 2020-11-05 10:51:23
    前言,本次记录重点在读取数据库表结构,及解析转换成java实体类需要字段。 主要包含,表 列名、类型、注释的读取解析 至于代码生成,可以基于已有的代码生成模板 整合进去即可 pom: <!-- Mysql Connector ...

    前言,本次记录重点在读取数据库表结构,及解析转换成java实体类需要字段。

    主要包含,表 列名、类型、注释的读取解析

    至于代码生成,可以基于已有的代码生成模板 整合进去即可

    pom:

    <!-- Mysql Connector -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.48</version>
            </dependency>
    
    <!--//驼峰转换-->
            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>21.0</version>
            </dependency>
    <!-- Beetl代码生成使用 -->
            <dependency>
                <groupId>com.ibeetl</groupId>
                <artifactId>beetl</artifactId>
                <version>2.9.10</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>3.10</version>
            </dependency>

    一、从mysql读取实体类相关信息实现

    1、数据库-java数据结构对应map

    /**
     * @Author: WXM
     * @Description: mysql数据结构对应
     * @Date: create in 2020/11/4 19:03
     */
    
    public class DataTypeUtil {
    
        public static Map<String ,String> map = new HashMap<>();
        static {
            map.put("smallint","java.lang.Integer");
            map.put("mediumint","java.lang.Integer");
            map.put("integer","java.lang.Integer");
            map.put("tinyint","java.lang.Short");
            map.put("int","java.lang.Integer");
            map.put("bigint","java.lang.Long");
            map.put("float","java.lang.Float");
            map.put("double","java.lang.Double");
            map.put("decimal","java.math.BigDecimal");
            map.put("date","java.util.Date");
            map.put("datetime","java.util.Date");
            map.put("timestamp","java.util.Date");
            map.put("time","java.util.Date");
            map.put("year","java.util.Date");
            map.put("char","java.lang.String");
            map.put("varchar","java.lang.String");
            map.put("binary","byte[]");
            map.put("varbinary","byte[]");
            map.put("tinyblob","byte[]");
            map.put("tinytext","java.lang.String");
            map.put("blob","byte[]");
            map.put("text","java.lang.String");
            map.put("mediumblob","byte[]");
            map.put("mediumtext","java.lang.String");
            map.put("longblob","byte[]");
            map.put("longtext","java.lang.String");
            map.put("enum","java.lang.String");
            map.put("set","java.lang.String");
            map.put("bit","java.lang.Boolean");
        }
    }

    2、表结构存储实体类

    /**
     * @Author: WXM
     * @Description: 表结构信息
     * @Date: create in 2020/11/4 17:03
     */
    
    public class TableRowInfo {
    
        private String columnName;
        private String columnType;
        private String columnComment;
    
        public String getColumnName() {
            return columnName;
        }
    
        public void setColumnName(String columnName) {
            this.columnName = columnName;
        }
    
        public String getColumnType() {
            return columnType;
        }
    
        public void setColumnType(String columnType) {
            this.columnType = columnType;
        }
    
        public String getColumnComment() {
            return columnComment;
        }
    
        public void setColumnComment(String columnComment) {
            this.columnComment = columnComment;
        }
    }

    3、数据库连接配置及获取表结构

    /**
     * @Author: WXM
     * @Description: mysql获取表结构
     * @Date: create in 2020/11/4 16:27
     */
    
    public class MysqlConnectUtil {
    
        private String driverClass;
        private String url;
        private String userName;
        private String passWord;
        private String tableName;
    
        public List<TableRowInfo> creat(){
            List<TableRowInfo> tableRowInfos = new ArrayList<>();
            if(StringUtils.isNotBlank(driverClass) && StringUtils.isNotBlank(url) && StringUtils.isNotBlank(userName) && StringUtils.isNotBlank(passWord)
                    && StringUtils.isNotBlank(tableName)){
                try {
    
                    Class.forName(driverClass);
                    Connection con = DriverManager.getConnection(url, userName, passWord);
                    String sql = "show full columns from  "+tableName;
                    Statement st = con.createStatement();
                    ResultSet res = st.executeQuery(sql);
                    while (res.next()){
                        TableRowInfo tri = new TableRowInfo();
                        tri.setColumnName(CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, res.getString("Field")));
                        tri.setColumnType(DataTypeUtil.map.get(res.getString("Type").split("\\(")[0]));
                        tri.setColumnComment(res.getString("Comment"));
                        tableRowInfos.add(tri);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
    
            }else {
                throw new RuntimeException("请填写完整mysql连接所需参数");
            }
    
            return tableRowInfos;
        }
    
        public MysqlConnectUtil setDriverClass(String driverClass) {
            this.driverClass = driverClass;
            return this;
        }
    
        public MysqlConnectUtil setUrl(String url) {
            this.url = url;
            return this;
        }
    
        public MysqlConnectUtil setUserName(String userName) {
            this.userName = userName;
            return this;
        }
    
        public MysqlConnectUtil setPassWord(String passWord) {
            this.passWord = passWord;
            return this;
        }
    
        public MysqlConnectUtil setTableName(String tableName) {
            this.tableName = tableName;
            return this;
        }
    }

    4、实际测试

        /**
         * 根据数据库表生成实体类
         */
        private static String driverClass = "com.mysql.jdbc.Driver";
        private static String url = "jdbc:mysql://127.0.0.1:3306/zhzf_xingzhengfuyi?useUnicode=true&characterEncoding=utf-8";
        private static String userName = "root";
        private static String passWord = "123456";
        private static String tableName = "b_anjianxinxi";
        private static List<TableRowInfo> tableRowInfos = new ArrayList<>();
    
        public void getTableRowInfo(){
            tableRowInfos = new MysqlConnectUtil()
                    .setDriverClass(driverClass)
                    .setUrl(url)
                    .setUserName(userName)
                    .setPassWord(passWord)
                    .setTableName(tableName)
                    .creat();
        }

    二、生成代码实现

    1、新建blt后缀的文件,到资源文件夹下,把整合好的 tableRowInfos 写入模板生成文件中即可,类似下面

    package ${entity.entityPackage};
    
    import java.util.Date;
    import lombok.Data;
    
    @Data
    public class ${entity.className} {
    
        private static final long serialVersionUID = 1L;
    
        <%
            for(var tableRowInfo in entity.tableRowInfos){
        %>
        // ${tableRowInfo.columnComment}
        private ${tableRowInfo.columnType} ${tableRowInfo.columnName};
        <%
            }
        %>
    
    }

    2、编写生成代码

    import org.beetl.core.Configuration;
    import org.beetl.core.GroupTemplate;
    import org.beetl.core.Template;
    import org.beetl.core.resource.ClasspathResourceLoader;
    
    
    
        /**
         * 主键类型
         */
        private static final String primaryKeyType = "String";
    
        /**
         * 实体类对应包
         * (文件自动生成至该包下)
         */
        private static final String entityPackage = "com.budongfeng.tboot.modules.your.entity";
        /**
         * 实体类名
         * 建议仅需修改
         */
        private static final String className = "JuedingshuTemp";
    
        /**
         * 根据数据库表生成实体类
         */
        private static String driverClass = "com.mysql.jdbc.Driver";
        private static String url = "jdbc:mysql://127.0.0.1:3306/zhzf_xingzhengfuyi?useUnicode=true&characterEncoding=utf-8";
        private static String userName = "root";
        private static String passWord = "123456";
        private static String tableName = "juedingshu_temp";
        private static List<TableRowInfo> tableRowInfos = new ArrayList<>();
    
    public static void main(String[] args) throws Exception {
            //读取表格信息
            TbootMPGenerator tb = new TbootMPGenerator();
            tb.getTableRowInfo();
    
            // 模板路径
            ClasspathResourceLoader resourceLoader = new ClasspathResourceLoader("/btl/");
            Configuration cfg = Configuration.defaultConfiguration();
            GroupTemplate gt = new GroupTemplate(resourceLoader, cfg);
    
            // 生成代码
            generateCode(gt);
    
            // 读取你的实体类中的字段,补充生成条件构造分页查询代码【需自行复制控制台打印输出的代码自行覆盖】
    //        generatePlus(gt);
    
            // 根据类名删除生成的代码
    //         deleteCode(className);
        }
    
    private static void generateCode(GroupTemplate gt) throws IOException {
    
            //读取资源文件夹下刚创建的blt文件
            Template entityTemplate = gt.getTemplate("entity.btl");
    
            OutputStream out = null;
            //生成实体类代码,将上面生成的table信息赋值到下面创建的类中
            Entity entity = new Entity();
            entity.setTableRowInfos(tableRowInfos);
            entity.setClassName(className);
            entity.setTableName(tableName);
            entity.setEntityPackage(entityPackage);
            String entityResult = entityTemplate.render();
            System.out.println(entityResult);
            entityTemplate.binding("entity", entity);
            //创建输出文件
            String entityFileUrl = System.getProperty("user.dir") + "/src/main/java/" + dotToLine(entityPackage) + "/" + className + ".java";
            File entityFile = new File(entityFileUrl);
            File entityDir = entityFile.getParentFile();
            if (!entityDir.exists()) {
                entityDir.mkdirs();
            }
            if (!entityFile.exists()) {
                // 若文件存在则不重新生成
                entityFile.createNewFile();
                out = new FileOutputStream(entityFile);
                entityTemplate.renderTo(out);
            }
        }
        /**
         * 点转斜线
         * @param str
         * @return
         */
        public static String dotToLine(String str){
            return str.replace(".", "/");
        }
    
    public void getTableRowInfo(){
            tableRowInfos = new MysqlConnectUtil()
                    .setDriverClass(driverClass)
                    .setUrl(url)
                    .setUserName(userName)
                    .setPassWord(passWord)
                    .setTableName(tableName)
                    .creat();
        }
    @Data
    public class Entity {
    
        private String entityPackage;
    
        private String daoPackage;
    
        private String servicePackage;
    
        private String serviceImplPackage;
    
        private String controllerPackage;
    
        private String author;
    
        private String className;
    
        private String classNameLowerCase;
    
        private String tableName;
    
        private String description;
    
        private String primaryKeyType;
    
        private Boolean activiti;
    
        private Boolean isTree;
    
        private List<TableRowInfo> tableRowInfos;
    }

    展开全文
  • java生成mysql实体类

    2018-02-28 14:59:36
    GenEntityMysql.java 此工具可连接数据库查询表信息并实现表自动生成实体类工具
  • Java实体类生成工具

    2017-12-08 19:11:07
    该jar基于网络上的源码修改而成,可在具有java环境的电脑中双击运行。并同时支持MySQL、Oracle、SQLserver,三个数据库。
  • Java自动生成数据库里面说有表的实体类,减轻了程序员的负担,并且不易出错
  • Java 工具类自动生成实体类文件

    千次阅读 2019-06-08 20:11:55
    在一些程序中,实体类是数据不可缺少的一部分,简单点说就是属性类,通常定义在model层里面。一般的实体类对应一个数据表,其中的属性对应数据表中的字段。属性可以对字段定义和状态进行判断和过滤,把相关信息用一...

    在一些程序中,实体类是数据不可缺少的一部分,简单点说就是属性类,通常定义在model层里面。一般的实体类对应一个数据表,其中的属性对应数据表中的字段。属性可以对字段定义和状态进行判断和过滤,把相关信息用一个实体类封装后,在程序中可以把实体类作为参数传递,更加方便。然而,当数据表中字段过多时,就不好写了,需要一个一个地封装,显得有点麻烦,而且浪费时间,所以,弄了一个工具类,根据表名去查询该表的字段生成实体类,代码如下:

    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSetMetaData;
    import java.sql.SQLException;
    
    public class TableToPo {
    	private String tablename = "SYS_MaterType";// 表名
    	private String[] colnames; // 列名数组
    	private String[] colTypes; // 列名类型数组
    	private int[] colSizes; // 列名大小数组
    	private boolean f_util = false; // 是否需要导入包java.util.*
    	private boolean f_sql = false; // 是否需要导入包java.sql.*
    	private boolean f_math = false;// 是否需要导入包java.math.*
    	public TableToPo() {
    		Connection con = Dbutil.getConnection();
    		PreparedStatement ps = null;
    		ResultSetMetaData rs = null;
    		String strsql = "select * from " + tablename;
    		try {
    			ps = con.prepareStatement(strsql);
    			rs = ps.getMetaData();
    			int size = rs.getColumnCount();
    			colnames = new String[size];
    			colTypes = new String[size];
    			colSizes = new int[size];
    			for (int i = 0; i < rs.getColumnCount(); i++) {
    				colnames[i] = rs.getColumnName(i + 1);
    				colTypes[i] = rs.getColumnTypeName(i + 1);
    				if (colTypes[i].equalsIgnoreCase("datetime")
    						|| colTypes[i].equalsIgnoreCase("date")
    						|| colTypes[i].equalsIgnoreCase("smalldatetime")
    						|| colTypes[i].equalsIgnoreCase("time")) {
    					f_sql = true;
    				}
    				if (colTypes[i].equalsIgnoreCase("money")
    						|| colTypes[i].equalsIgnoreCase("decimal")
    						|| colTypes[i].equalsIgnoreCase("smallmoney")
    						|| colTypes[i].equalsIgnoreCase("numeric")) {
    					f_math = true;
    				}
    				colSizes[i] = rs.getColumnDisplaySize(i + 1);
    			}
    			String content = parse(colnames, colTypes, colSizes);
    			FileWriter fileWriter = new FileWriter(initcap(tablename) + ".java");
    			PrintWriter pw = new PrintWriter(fileWriter);
    			pw.println(content);
    			pw.flush();
    			pw.close();
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				ps.close();
    				con.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.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");
    		}
    		if (f_math) {
    			sb.append("import java.math.BigDecimal;\r\n\r\n\r\n");
    		}
    		sb.append("public class " + initcap(tablename) + " {\r\n");
    		processAllAttrs(sb);
    		processAllMethod(sb);
    		sb.append("}\r\n");
    		System.out.println(sb.toString());
    		return sb.toString();
    	}
    	/**
    	 * 生成所有的方法
    	 * 
    	 * @param sb
    	 */
    	private void processAllMethod(StringBuffer sb) {
    		for (int i = 0; i < colnames.length; i++) {
    			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");
    			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");
    
    		}
    	}
    	/**
    	 * 解析输出属性
    	 * 
    	 * @return
    	 */
    	private void processAllAttrs(StringBuffer sb) {
    		for (int i = 0; i < colnames.length; i++) {
    			sb.append("\tprivate " + sqlType2JavaType(colTypes[i]) + " "
    					+ colnames[i] + ";\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);
    	}
    
    	private String sqlType2JavaType(String sqlType) {
    		if (sqlType.equalsIgnoreCase("bit")) {
    			return "Boolean";
    		} else if (sqlType.equalsIgnoreCase("timestamp")
    				|| sqlType.equalsIgnoreCase("binary")
    				|| sqlType.equalsIgnoreCase("image")
    				|| sqlType.equalsIgnoreCase("varbinary")) {
    			return "byte[]";
    		} else if (sqlType.equalsIgnoreCase("smallint")
    				|| sqlType.equalsIgnoreCase("tinyint")) {
    			return "short";
    		} else if (sqlType.equalsIgnoreCase("int")) {
    			return "Integer";
    		} else if (sqlType.equalsIgnoreCase("bigint")) {
    			return "long";
    		} else if (sqlType.equalsIgnoreCase("real")) {
    			return "float";
    		} else if (sqlType.equalsIgnoreCase("real")
    				|| sqlType.equalsIgnoreCase("float")) {
    			return "double";
    		} else if (sqlType.equalsIgnoreCase("money")
    				|| sqlType.equalsIgnoreCase("decimal")
    				|| sqlType.equalsIgnoreCase("smallmoney")
    				|| sqlType.equalsIgnoreCase("numeric")) {
    			return "BigDecimal";
    		} else if (sqlType.equalsIgnoreCase("varchar")
    				|| sqlType.equalsIgnoreCase("char")
    				|| sqlType.equalsIgnoreCase("nvarchar")
    				|| sqlType.equalsIgnoreCase("nchar")
    				|| sqlType.equalsIgnoreCase("text")
    				|| sqlType.equalsIgnoreCase("ntext")
    				|| sqlType.equalsIgnoreCase("uniqueidentifier")) {
    			return "String";
    		} else if (sqlType.equalsIgnoreCase("date")) {
    			return "Date";//Date
    		} else if (sqlType.equalsIgnoreCase("smalldatetime")
    				|| sqlType.equalsIgnoreCase("datetime")) {
    			return "Timestamp";
    		} else if (sqlType.equalsIgnoreCase("time")) {
    			return "Time";
    		}
    		return null;
    	}
    	public static void main(String[] args) {
    		new TableToPo();
    	}
    }

    工具类执行效果:

    展开全文
  • javaAutoCode 根据表结构自动生成实体类,Mybatis的Mapper文件,Action,service,dao[java project]
  • 配置好数据库连接字符串和输出路径,自动把MySQL数据表生成相应的Java实体类。附上数据库。来源是参考别人的代码,有添加了自动获取表名的功能,不需要手动写表名,非常方便。
  • 自动生成java实体类

    2018-05-25 10:46:00
    解压配置好generator.xml后,打开cmd,使用(说明.txt)中的命令。。就可以生成实体类了,哇哈哈哈。这样就可以根据数据库表自动生成java实体类~~
  • 自动生成Java实体类

    2015-04-14 10:17:21
    JDBC读取数据库元数据,生成JAVA实体类
  • 自己编写的小工具,能将mysql数据库中的表转化为java实体类
  • JAVA实体类生成代码

    2017-11-02 10:32:54
    JAVA实体类生成代码,复制粘贴直接可以用了;我的微信514704369,备注CSDN可以和我交流;
  • 本人手写一键生成mybatis增删改查,从java类开始,代码注释,方法注释,实体注释,都有,生成Service impl dao xml 支持 mysql数据库,不实用打我。
  • 可以直接从数据库查取数据并生成字段,现只支持mysql,傻瓜式操作,大大加快了实体类的编写速度,非常有用切非常耐用。
  • 实现功能: 1.根据SQLite数据库文件,生成java实体类 可用于使用了SQLite数据的 android 或 Java项目.
  • 为了提高开发效率,减少繁琐的手动代码编写,也减少了手动编写的出错率,根据oracle或者Mysql表自动生成实体和mybatis接口以及xml文件
  • Excel宏生成java实体类

    2018-06-26 15:38:11
    excel生成实体类,本人有使用过,无问题,直接生成实体类:有注释,set,get方法
  • java反向生成实体工具

    2017-11-09 15:04:14
    非常好用代码生成工具,让你免了手动编写实体的枯燥,你值得拥有的开发宝典
  • 生成的文件可用UE打开或在exlipse打开,如果使用词本打开显示格式不友好
  • java 从数据库表反射出实体类,自动生成实体类
  • Java逆向工程,使用mybatis生成实体类跟Mapper映射,包含所需的jar包
  • 主要介绍了利用JAVA反射,读取数据库表名,自动生成对应实体类的操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 读取mysql数据库,创建所有的Entity实体类实体类里面有对应的注释,数据库的comment会作为字段的注释。 生成dao文件以及对应的mapper.xml文件,这是为了mybaits准备的。 mapper.xml文件里面配置了resultMap,实现...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 223,688
精华内容 89,475
关键字:

java动态生成实体类

java 订阅
友情链接: calculate_stack_linux.rar