181054867
- 浏览: 147399 次
- 性别:
- 来自: 广州
-
最新评论
-
763863446：
非常感谢博主，整好解决了问题！！！
Mysql Can't find file: './mysql/host.frm' (errno: 13) 的解决方法 -
qianzhiyong：
遇到同样的问题，按照已经解决，感谢！
com.caucho.jsp.JspParseException: illegal utf8 encoding at 0xfd 解决方法 -
netwelfare：
resin出现编码问题，不一定真正是编码错误造成的。有的时候是 ...
com.caucho.jsp.JspParseException: illegal utf8 encoding at 0xfd 解决方法 -
istone：
gubaojian 写道集群时采用负载均衡策略时，选用sess ...
如何重写HttpSession的setAttribute方法，实现Session集群 -
java_doom：
不错 太赞了 我也遇到同样的问题 看到你这篇才解决
Mysql Can't find file: './mysql/host.frm' (errno: 13) 的解决方法
例如我有一个这样的sql：
select username, password from users
我想在select结束后，通过ResultSet中的字段名生成一个JavaBean，其代码大概如下：
public class Record{
//生成这个方法，get后返回sql中结果集的username字段值
public String getUsername(){}
//生成这个方法，get后返回sql中结果集的password字段值
public String getPassword(){}
}
关键在于：这个JaveBean是动态的，Get方法因应sql字段不同而不同
曾经记得在Hibernate中广泛使用这种生成字节码，动态化Class的应用，敢问各位高手，是否知道如何实现，请赐教！！
补充一下应用场景：
select 后，生成的这个Record，我是用在Jsp的 el 表达式中：
<h1>UserName:${record.Username}<h1>
<h1>Password:${record.Password}<h1>
这样就避免每个数据库表都写一个JavaBean了，不知我这样的想法是否可行，如有什么性能问题或其他担心，敬请指正！
感谢！！
分享到：
评论
43 楼
181054867
2010-05-15
你说得很深奥，我没理解！
42 楼
抛出异常的爱
2010-05-15
181054867 写道
呵呵，具体情况具体对待吧，国际化跟JaveBean没关系，完全可以在页面通过自定义标签做，返回Enum我的项目就没用过，对于你上面Bean中对日期的处理，也完全可以用自定义EL表达式跟自定义标签处理。
至于连接式树节点，就只能在显示时再执行另外的sql查询结果，再进行显示了，因为不是Hibernate，所以是没办法的。
你说得很对，有些JavaBean是没必要存在的，让开发人员每做一张表都要做这么多工作，而且页面又是如此的简单显示一下，未免效率低下，也容易让人日久生厌。
我就是这样，所以才有了这样的想法，呵呵
至于连接式树节点，就只能在显示时再执行另外的sql查询结果，再进行显示了，因为不是Hibernate，所以是没办法的。
你说得很对，有些JavaBean是没必要存在的，让开发人员每做一张表都要做这么多工作，而且页面又是如此的简单显示一下，未免效率低下，也容易让人日久生厌。
我就是这样，所以才有了这样的想法，呵呵
那些你说的没用的BEAN是数据库的建表语句的重覆。
所以把数据库的建表语句删了用一个工具用POJO建表吧
PS：我说的国际化是由于数据库里有四种语言字段到页面上要判断用哪种语言，自定义标签。。。。不如写到bean中好用。
用ENUM作字段不用再去数据库里查一次代码表。下拉菜单里的内容，下增菜单里所选中的项都包含了。少查一次代码表
日期处理是VO向PO传时间区间用的。查询时间条件从来不是一个时间点。都是两个条件的组合。
至少写代码时不绑定的东西不得不通过Bean来调和
41 楼
181054867
2010-05-15
呵呵，具体情况具体对待吧，国际化跟JaveBean没关系，完全可以在页面通过自定义标签做，返回Enum我的项目就没用过，对于你上面Bean中对日期的处理，也完全可以用自定义EL表达式跟自定义标签处理。
至于连接式树节点，就只能在显示时再执行另外的sql查询结果，再进行显示了，因为不是Hibernate，所以是没办法的。
你说得很对，有些JavaBean是没必要存在的，让开发人员每做一张表都要做这么多工作，而且页面又是如此的简单显示一下，未免效率低下，也容易让人日久生厌。
我就是这样，所以才有了这样的想法，呵呵
至于连接式树节点，就只能在显示时再执行另外的sql查询结果，再进行显示了，因为不是Hibernate，所以是没办法的。
你说得很对，有些JavaBean是没必要存在的，让开发人员每做一张表都要做这么多工作，而且页面又是如此的简单显示一下，未免效率低下，也容易让人日久生厌。
我就是这样，所以才有了这样的想法，呵呵
40 楼
抛出异常的爱
2010-05-15
引用
在我接触的一些产品项目中，JavaBean是[color]很单纯的[/color]，就一些get set方法，set完后就在页面get出来显示就完了，最多就在页面上处理一下，不会有很多复杂的操作，每一次做一张新表，都有以下步骤：
public class Z{
private Date t = null;
set......
public String getTime(){
return DateFormater(t).pase("hh:mi");
}
public int getWeekDay(){
return Clender(t).weekDay();
}
public Date[] getStarEnd(){
Date[] se = new Date[2];
.............
return se;
}
}
还有国际化。。。。。
还有返回Enum
还有连接式树节点。
我承认大多数BEAN没逻辑，也没必要存在。
但还是有那么一些需要逻辑处理的。
39 楼
181054867
2010-05-15
呵呵，对于我刚才的那些做法，有什么不同想法的，请回复一下指正，感激感激！！
38 楼
181054867
2010-05-15
使用Hibernate的朋友不要再把Hibernate的一套搬出来回复我，我暂时没看到它的好处！
37 楼
181054867
2010-05-15
<p>回楼上，首先说一下我的实现方法：</p>
<pre name="code" class="sql">select username, password from users</pre>
<p>通过对ResultSet封装，产生类似这样一个Map：</p>
<pre name="code" class="java">List<Map> results = new ArrayList<Map>(2);
Map map = new HashMap(2);
map.put("userName", "abc");
map.put("passWord", "cba");
results.add(map);
map = new HashMap(2);
map.put("userName", "efg");
map.put("passWord", "gfe");
results.add(map);</pre>
<p>然后我在页面上如此显示结果：</p>
<pre name="code" class="JSP"><c:foreach item="${list}" var="user">
<h1>UserName：${user.userName}</h1>
<h1>Password：${user.passWord}</h1>
</c:foreach></pre>
<p>如果使用JavaBean，那行先写个Bean Class：</p>
<pre name="code" class="java">public class User {
private String userName;
private String passWord;
get...;
set...;
get.......;
set.......;
}</pre>
<p> 在执行完sql后，手动编码封装结果进JavaBean，要写这样的代码：</p>
<pre name="code" class="java">List<User> userList;
foreach resultset {
User user = new User();
user.setUserName(username);
user.setPassWord(password);
userList.add(user);
}</pre>
<p>最后页面显示跟上面一样。</p>
<p>在我接触的一些产品项目中，JavaBean是很单纯的，就一些get set方法，set完后就在页面get出来显示就完了，最多就在页面上处理一下，不会有很多复杂的操作，每一次做一张新表，都有以下步骤：</p>
<p>1、写一个很难看的JavaBean(我认为很难看)，就只有get set方法；</p>
<p>2、调用完sql后，手动编码来封装成一个JavaBean，返回List到页面；</p>
<p>3、在页面上调用显示出来；</p>
<p> </p>
<p><span style="font-size: small;"><strong>我想说的是，无论如何，开发者都会清楚，这里返回的结果，是执行了什么sql得到的，也就是用户会直观看到甚至直接参与sql语句的编写维护工作，假设：现在新的开发者在users表加了一个字段(login_time)，他想要显示出来，按我的方法，两步，1：改sql语句，2：改显示的JSP页面，按传统的做法：1、在JavaBean加上get set方法，2、改sql语句，并手动再添加上封装loginTime的结果到JavaBean，3、改显示的JSP页面；</strong></span></p>
<p><span style="font-size: small;"><strong>
</strong></span></p>
<p><span style="font-size: small;"><strong> </strong></span><span style="font-size: small;"><strong>开发者还是要知道，里面执行了什么sql语句，并且，用传统的方法，要写让人感到无比重复厌烦的JavaBean代码，我个人深恶痛绝这样的编码方式(当然，你用Hibernate就没得说了)。</strong></span></p>
<p><span style="color: #ff0000;">可以想到，他会慢慢敲开MAP的门，然后悄悄的问：“嘿，你这个MAP里装的是什么呀”，MAP回答：“你自己看查询sql噻”，而如果采用实体bean，直接查看bean他就能清楚知道查询返回了什么</span></p>
<p>在新的开发者维护这些代码前，返回的JavaBean里只有username跟password，这时，他看到JaveBean里有一个getLoginTime()方法，他马上就在页面上写：</p>
<p> </p>
<pre name="code" class="JSP"><h1>LoginTime：${user.loginTime}</h1></pre>
<p> </p>
<p> 这样行吗，一定不行，因为sql可能只返回了两个字段：username and password，这样他就要改sql语句了，那他就一定得去看执行的那句sql，他就清楚要怎么做才能得到他想要的结果。</p>
<p>既然避免不了要维护sql，为什么不做得更简单一点呢，而且我也没看到有什么不负责任的东西在里面，这就是我的想法！</p>
<pre name="code" class="sql">select username, password from users</pre>
<p>通过对ResultSet封装，产生类似这样一个Map：</p>
<pre name="code" class="java">List<Map> results = new ArrayList<Map>(2);
Map map = new HashMap(2);
map.put("userName", "abc");
map.put("passWord", "cba");
results.add(map);
map = new HashMap(2);
map.put("userName", "efg");
map.put("passWord", "gfe");
results.add(map);</pre>
<p>然后我在页面上如此显示结果：</p>
<pre name="code" class="JSP"><c:foreach item="${list}" var="user">
<h1>UserName：${user.userName}</h1>
<h1>Password：${user.passWord}</h1>
</c:foreach></pre>
<p>如果使用JavaBean，那行先写个Bean Class：</p>
<pre name="code" class="java">public class User {
private String userName;
private String passWord;
get...;
set...;
get.......;
set.......;
}</pre>
<p> 在执行完sql后，手动编码封装结果进JavaBean，要写这样的代码：</p>
<pre name="code" class="java">List<User> userList;
foreach resultset {
User user = new User();
user.setUserName(username);
user.setPassWord(password);
userList.add(user);
}</pre>
<p>最后页面显示跟上面一样。</p>
<p>在我接触的一些产品项目中，JavaBean是很单纯的，就一些get set方法，set完后就在页面get出来显示就完了，最多就在页面上处理一下，不会有很多复杂的操作，每一次做一张新表，都有以下步骤：</p>
<p>1、写一个很难看的JavaBean(我认为很难看)，就只有get set方法；</p>
<p>2、调用完sql后，手动编码来封装成一个JavaBean，返回List到页面；</p>
<p>3、在页面上调用显示出来；</p>
<p> </p>
<p><span style="font-size: small;"><strong>我想说的是，无论如何，开发者都会清楚，这里返回的结果，是执行了什么sql得到的，也就是用户会直观看到甚至直接参与sql语句的编写维护工作，假设：现在新的开发者在users表加了一个字段(login_time)，他想要显示出来，按我的方法，两步，1：改sql语句，2：改显示的JSP页面，按传统的做法：1、在JavaBean加上get set方法，2、改sql语句，并手动再添加上封装loginTime的结果到JavaBean，3、改显示的JSP页面；</strong></span></p>
<p><span style="font-size: small;"><strong>
</strong></span></p>
<p><span style="font-size: small;"><strong> </strong></span><span style="font-size: small;"><strong>开发者还是要知道，里面执行了什么sql语句，并且，用传统的方法，要写让人感到无比重复厌烦的JavaBean代码，我个人深恶痛绝这样的编码方式(当然，你用Hibernate就没得说了)。</strong></span></p>
<p><span style="color: #ff0000;">可以想到，他会慢慢敲开MAP的门，然后悄悄的问：“嘿，你这个MAP里装的是什么呀”，MAP回答：“你自己看查询sql噻”，而如果采用实体bean，直接查看bean他就能清楚知道查询返回了什么</span></p>
<p>在新的开发者维护这些代码前，返回的JavaBean里只有username跟password，这时，他看到JaveBean里有一个getLoginTime()方法，他马上就在页面上写：</p>
<p> </p>
<pre name="code" class="JSP"><h1>LoginTime：${user.loginTime}</h1></pre>
<p> </p>
<p> 这样行吗，一定不行，因为sql可能只返回了两个字段：username and password，这样他就要改sql语句了，那他就一定得去看执行的那句sql，他就清楚要怎么做才能得到他想要的结果。</p>
<p>既然避免不了要维护sql，为什么不做得更简单一点呢，而且我也没看到有什么不负责任的东西在里面，这就是我的想法！</p>
36 楼
icanfly
2010-05-12
aaa5131421 写道
你这种编码的随意性就太大了，开发前就不需要完整的实体模型设计，开发者想用什么字段整合成一个对象都可以，让后期其他人怎么去维护呢？
这样的情况好hibernate做的比较好，开发前有个固定的模型设计，你查出来的都是固定结构化了对象，更何况你要是在一对多的情况下你怎么生成一个bean呢？难道还要查出多个不同的对象出来？本来通过hibernate的关系就可以用。导航出来的东西，你会多出好多的代码
这样的情况好hibernate做的比较好，开发前有个固定的模型设计，你查出来的都是固定结构化了对象，更何况你要是在一对多的情况下你怎么生成一个bean呢？难道还要查出多个不同的对象出来？本来通过hibernate的关系就可以用。导航出来的东西，你会多出好多的代码
我比较同意以上的观点。你查询出来的一个MAP封装你想要的数据，你觉得非常cool，设想一下，当下一位维护者来维护这套代码的时候真的是连死的心都有，可以想到，他会慢慢敲开MAP的门，然后悄悄的问：“嘿，你这个MAP里装的是什么呀”，MAP回答：“你自己看查询sql噻”。而如果采用实体bean，直接查看bean他就能清楚知道查询返回了什么
对大量使用MAP返回数据的人严重鄙视。这是一种不负责的做法
35 楼
aws
2010-05-12
^^^^^
34 楼
haiyangyiba
2010-05-12
看这各个朋友滔滔不绝呀，我现在写了一个查询分页的标签，准备前台是用jstl的c标签和el表达式来取值的。大体上是这样的，
提供一个工具类，用户给定包名，类名，一个查询的sql语句，然后根据这些查询的sql语句的表字段来生成一个javabean对象，也就是说，这个javabean的字段就是数据库表的字段，类型也一致，页面上取值也就和LZ你说的一样了。
提供一个工具类，用户给定包名，类名，一个查询的sql语句，然后根据这些查询的sql语句的表字段来生成一个javabean对象，也就是说，这个javabean的字段就是数据库表的字段，类型也一致，页面上取值也就和LZ你说的一样了。
33 楼
181054867
2010-04-03
<p>感谢<span style="font-size: small;"><span style="color: #0000ff;">aaa5131421,非常感谢!!</span></span></p>
<p> </p>
<p> </p>
32 楼
aaa5131421
2010-04-03
<div class="quote_title">181054867 写道</div>
<div class="quote_div">
<div class="quote_title">aaa5131421 写道</div>
<div class="quote_div">
<div class="quote_title">181054867 写道</div>
<div class="quote_div">
<div class="quote_title">aaa5131421 写道</div>
<div class="quote_div">你这种编码的随意性就太大了，开发前就不需要完整的实体模型设计，开发者想用什么字段整合成一个对象都可以，让后期其他人怎么去维护呢？<br>这样的情况好hibernate做的比较好，开发前有个固定的模型设计，你查出来的都是固定结构化了对象，更何况你要是在一对多的情况下你怎么生成一个bean呢？难道还要查出多个不同的对象出来？本来通过hibernate的关系就可以用。导航出来的东西，你会多出好多的代码</div>
<br>您不能理解随意性，我认为，为数据库的每个表写一个JavaBean，在执行select sql后，还要写代码new这个Bean，然后在ResultSet中getString(XX)，把值一个一个地赋给Bean，这样属于硬编码。<br>事实是，一些以显示为主的网站，对ResultSet结果集的操作只是单纯的显示出来，所以，我相信可能通过优化，避免我前面说的：写很多很多枯燥无用的代码，通过对ResultSet进行封装，产生一个Bean，然后在页面通过column name直接获得值，这样我们要写的代码会大大减少，缩短我们的开发时间，也让我们觉得，现在做的只是为了写代码更方便，当作一种享受，不要重复发明轮子而已。<br>至于你说的什么一对多，请不要把Hibernate的理念搬到这里回复，因为我并不使用Hibernate，也不存在什么一对多，这个Bean的产生，只是跟你写的sql有关系，你sql怎么写，你返回什么字段，这个Bean就生成相应字段的Get方法，sql你已经确定，至于什么一对多，多对多，是在你写sql前的事<br>我这样做是为了写更少的代码</div>
<br>可是最普遍的表结构都是一对多的关系，你不用hibernate只要使用数据库也肯定会碰到一对多关系。怎么可能会没有呢？<br>例子：界面需求就是简单的将一个一对多的数据展现出来，可是你的简单的键值对的bean无法满足这个要求，最简单的例子，班级表和学生表，界面上要展示出班级名称和对应学生s的名称，用你的方法，怎么用一条sql查询出来然后整合到一个bean中去呢？你是不是要拆开来用两个方法去查呢，分别得到班级名称和学生数据集合呢？<br>而hibernate直接可以简单写一个查出班级的代码，之后直接在界面导航出学生列表。<br>你觉得哪个省代码呢？想要省代码应该先从宏观上，上层上去考虑。</div>
<p> </p>
<p>有两张表：</p>
<pre name="code" class="sql">create table test_class (
`class_id` int(11) auto_increment primary key,
`class_name` varchar(50) NOT NULL default '',
`class_level` varchar(50) NOT NULL default ''
) ENGINE=MyISAM DEFAULT CHARSET=gbk;</pre>
<pre name="code" class="sql">create table test_student (
`student_id` int(11) auto_increment primary key,
`class_id` int(11) not null default '0',
`student_name` varchar(50) NOT NULL default ''
) ENGINE=MyISAM DEFAULT CHARSET=gbk;</pre>
<p> </p>
<p>假设你要显示班级及其学生，需要执行两条sql:</p>
<pre name="code" class="sql">select class_id, class_name, class_level from test_class;</pre>
<p> </p>
<pre name="code" class="sql">select student_id, student_name from test_student where class_id = ${class_id}</pre>
<p> </p>
<p>第一句，查出class，系统自动封装出一个List，list里保存了这样一个JavaBean，这个JavaBean包含班级的信息，代码类似这样(这个类是动态的，不是硬编码写出来的)：</p>
<pre name="code" class="java">class Record{
public String getClass_id(){}
public String getClass_name(){}
public String getClass_level(){}
}</pre>
<p>假设这个List保存在request，名字为list，那么，我在页面上如此遍历它：</p>
<pre name="code" class="JSP"><c:foreach item="${requestScope.list}" var="item">
<h1>班级名：${item.class_name}<h1>
<h1>班级级别：${item.class_level}<h1>
<table>
<tr>
<th>学生编号</th>
<th>学生姓名</th>
</tr>
<%-- 这里执行第二条sql，根据class_id查到所有学生，假设保存在request，名字为stulist，遍历这个list，显示所有学生 --%>
<c:foreach item="${requestScope.stulist}" var="stu">
<tr>
<td>${item.student_id}</t>
<td>${item.student_name}</t>
</tr>
</c:foreach>
</table>
</c:foreach>
Hibernate同样会执行这两条sql，只是不用你手动去调用而已。
而我说的问题是：怎么样实现我上面的显示效果，直接用列名访问数据.
你的sql甚至可以这样写：
select test_class.class_name, test_class.class_level, test_student.student_id, test_student.student_name from test_class, test_student where test_class.class_id = test_student.class_id
只要最后能让我用上面的格式来显示结果就可以了。
至于数据类型，你可以在显示时再转换成跟数据库一样的类型，再进行特别的处理，这也属于显示问题了。
我只是想减轻显示时的代码量，不涉及到其他表的对应关系
</pre>
</div>
<p> </p>
<p>1、Hibernate同样会执行这两条sql，只是不用你手动去调用而已。<br> 我要的就是你这句话，什么叫省代码，这才叫省代码！</p>
<p>2、我只是想减轻显示时的代码量，不涉及到其他表的对应关系<br> 从开始的“省代码量”变成了“省显示时的代码量”，你的观点在变哎，而且还要提出一点的是：省代码量不是用拆东墙补西墙的方式得来的，你以增加后台的编码量（要写两条sql，相当于要调用两个业务逻辑方法）的方式“省显示层的代码”你觉得合适吗？</p>
<p> </p>
<p>3、而我说的问题是：怎么样实现我上面的显示效果，直接用列名访问数据.</p>
<p> 你的这种方法怎么做大家都有回答，直接map就可以，而我回这么多的目的是想告诉你你确实可以简单的、局部的省些代码，可是从总体上，宏观上考虑，你的这个省代码是以没有复杂需求的情况下才成立，没有表的关系在里面的时候才成立，可是这是实际项目中不可能的。遇到普遍的一对多关系就需要写两个sql，放在两个业务逻辑方法里面，从总体上来说代码并没有省。</p>
<p> 突然发现，例子中你居然mvc都没有使用，界面展示到半道才又去数据库中取数据，或许也只有这样你才能查到特定班级的特定学生列表吧，如果用mvc呢，你的界面逻辑还会这么简单吗？</p>
<p>到此为止吧，呵呵，我只是想说的是省代码应该从宏观上考虑，开发前首先要有固定的领域模型，简单的键值对的形式会增加代码维护成本，而且更不容易适应需求的变化，省代码并是不少写几行代码那么简单，应该从面向对象上，封装、复用上去考虑，如果你暂时省了几行代码，可是没几天需求变了，你的键值对的代码改动面积相对于hibernate大的多，应该就不算是省代码了吧。</p>
<p>我只是想表达这个意思，没有别的意思哈，你的这个创意不错，呵呵，我只是想将你的兴趣转移到对项目整体有利的方向上去，哈哈，见笑~</p>
<p> </p>
<div class="quote_div">
<div class="quote_title">aaa5131421 写道</div>
<div class="quote_div">
<div class="quote_title">181054867 写道</div>
<div class="quote_div">
<div class="quote_title">aaa5131421 写道</div>
<div class="quote_div">你这种编码的随意性就太大了，开发前就不需要完整的实体模型设计，开发者想用什么字段整合成一个对象都可以，让后期其他人怎么去维护呢？<br>这样的情况好hibernate做的比较好，开发前有个固定的模型设计，你查出来的都是固定结构化了对象，更何况你要是在一对多的情况下你怎么生成一个bean呢？难道还要查出多个不同的对象出来？本来通过hibernate的关系就可以用。导航出来的东西，你会多出好多的代码</div>
<br>您不能理解随意性，我认为，为数据库的每个表写一个JavaBean，在执行select sql后，还要写代码new这个Bean，然后在ResultSet中getString(XX)，把值一个一个地赋给Bean，这样属于硬编码。<br>事实是，一些以显示为主的网站，对ResultSet结果集的操作只是单纯的显示出来，所以，我相信可能通过优化，避免我前面说的：写很多很多枯燥无用的代码，通过对ResultSet进行封装，产生一个Bean，然后在页面通过column name直接获得值，这样我们要写的代码会大大减少，缩短我们的开发时间，也让我们觉得，现在做的只是为了写代码更方便，当作一种享受，不要重复发明轮子而已。<br>至于你说的什么一对多，请不要把Hibernate的理念搬到这里回复，因为我并不使用Hibernate，也不存在什么一对多，这个Bean的产生，只是跟你写的sql有关系，你sql怎么写，你返回什么字段，这个Bean就生成相应字段的Get方法，sql你已经确定，至于什么一对多，多对多，是在你写sql前的事<br>我这样做是为了写更少的代码</div>
<br>可是最普遍的表结构都是一对多的关系，你不用hibernate只要使用数据库也肯定会碰到一对多关系。怎么可能会没有呢？<br>例子：界面需求就是简单的将一个一对多的数据展现出来，可是你的简单的键值对的bean无法满足这个要求，最简单的例子，班级表和学生表，界面上要展示出班级名称和对应学生s的名称，用你的方法，怎么用一条sql查询出来然后整合到一个bean中去呢？你是不是要拆开来用两个方法去查呢，分别得到班级名称和学生数据集合呢？<br>而hibernate直接可以简单写一个查出班级的代码，之后直接在界面导航出学生列表。<br>你觉得哪个省代码呢？想要省代码应该先从宏观上，上层上去考虑。</div>
<p> </p>
<p>有两张表：</p>
<pre name="code" class="sql">create table test_class (
`class_id` int(11) auto_increment primary key,
`class_name` varchar(50) NOT NULL default '',
`class_level` varchar(50) NOT NULL default ''
) ENGINE=MyISAM DEFAULT CHARSET=gbk;</pre>
<pre name="code" class="sql">create table test_student (
`student_id` int(11) auto_increment primary key,
`class_id` int(11) not null default '0',
`student_name` varchar(50) NOT NULL default ''
) ENGINE=MyISAM DEFAULT CHARSET=gbk;</pre>
<p> </p>
<p>假设你要显示班级及其学生，需要执行两条sql:</p>
<pre name="code" class="sql">select class_id, class_name, class_level from test_class;</pre>
<p> </p>
<pre name="code" class="sql">select student_id, student_name from test_student where class_id = ${class_id}</pre>
<p> </p>
<p>第一句，查出class，系统自动封装出一个List，list里保存了这样一个JavaBean，这个JavaBean包含班级的信息，代码类似这样(这个类是动态的，不是硬编码写出来的)：</p>
<pre name="code" class="java">class Record{
public String getClass_id(){}
public String getClass_name(){}
public String getClass_level(){}
}</pre>
<p>假设这个List保存在request，名字为list，那么，我在页面上如此遍历它：</p>
<pre name="code" class="JSP"><c:foreach item="${requestScope.list}" var="item">
<h1>班级名：${item.class_name}<h1>
<h1>班级级别：${item.class_level}<h1>
<table>
<tr>
<th>学生编号</th>
<th>学生姓名</th>
</tr>
<%-- 这里执行第二条sql，根据class_id查到所有学生，假设保存在request，名字为stulist，遍历这个list，显示所有学生 --%>
<c:foreach item="${requestScope.stulist}" var="stu">
<tr>
<td>${item.student_id}</t>
<td>${item.student_name}</t>
</tr>
</c:foreach>
</table>
</c:foreach>
Hibernate同样会执行这两条sql，只是不用你手动去调用而已。
而我说的问题是：怎么样实现我上面的显示效果，直接用列名访问数据.
你的sql甚至可以这样写：
select test_class.class_name, test_class.class_level, test_student.student_id, test_student.student_name from test_class, test_student where test_class.class_id = test_student.class_id
只要最后能让我用上面的格式来显示结果就可以了。
至于数据类型，你可以在显示时再转换成跟数据库一样的类型，再进行特别的处理，这也属于显示问题了。
我只是想减轻显示时的代码量，不涉及到其他表的对应关系
</pre>
</div>
<p> </p>
<p>1、Hibernate同样会执行这两条sql，只是不用你手动去调用而已。<br> 我要的就是你这句话，什么叫省代码，这才叫省代码！</p>
<p>2、我只是想减轻显示时的代码量，不涉及到其他表的对应关系<br> 从开始的“省代码量”变成了“省显示时的代码量”，你的观点在变哎，而且还要提出一点的是：省代码量不是用拆东墙补西墙的方式得来的，你以增加后台的编码量（要写两条sql，相当于要调用两个业务逻辑方法）的方式“省显示层的代码”你觉得合适吗？</p>
<p> </p>
<p>3、而我说的问题是：怎么样实现我上面的显示效果，直接用列名访问数据.</p>
<p> 你的这种方法怎么做大家都有回答，直接map就可以，而我回这么多的目的是想告诉你你确实可以简单的、局部的省些代码，可是从总体上，宏观上考虑，你的这个省代码是以没有复杂需求的情况下才成立，没有表的关系在里面的时候才成立，可是这是实际项目中不可能的。遇到普遍的一对多关系就需要写两个sql，放在两个业务逻辑方法里面，从总体上来说代码并没有省。</p>
<p> 突然发现，例子中你居然mvc都没有使用，界面展示到半道才又去数据库中取数据，或许也只有这样你才能查到特定班级的特定学生列表吧，如果用mvc呢，你的界面逻辑还会这么简单吗？</p>
<p>到此为止吧，呵呵，我只是想说的是省代码应该从宏观上考虑，开发前首先要有固定的领域模型，简单的键值对的形式会增加代码维护成本，而且更不容易适应需求的变化，省代码并是不少写几行代码那么简单，应该从面向对象上，封装、复用上去考虑，如果你暂时省了几行代码，可是没几天需求变了，你的键值对的代码改动面积相对于hibernate大的多，应该就不算是省代码了吧。</p>
<p>我只是想表达这个意思，没有别的意思哈，你的这个创意不错，呵呵，我只是想将你的兴趣转移到对项目整体有利的方向上去，哈哈，见笑~</p>
<p> </p>
31 楼
181054867
2010-04-02
<div class="quote_title">aaa5131421 写道</div>
<div class="quote_div">
<div class="quote_title">181054867 写道</div>
<div class="quote_div">
<div class="quote_title">aaa5131421 写道</div>
<div class="quote_div">你这种编码的随意性就太大了，开发前就不需要完整的实体模型设计，开发者想用什么字段整合成一个对象都可以，让后期其他人怎么去维护呢？<br>这样的情况好hibernate做的比较好，开发前有个固定的模型设计，你查出来的都是固定结构化了对象，更何况你要是在一对多的情况下你怎么生成一个bean呢？难道还要查出多个不同的对象出来？本来通过hibernate的关系就可以用。导航出来的东西，你会多出好多的代码</div>
<br>您不能理解随意性，我认为，为数据库的每个表写一个JavaBean，在执行select sql后，还要写代码new这个Bean，然后在ResultSet中getString(XX)，把值一个一个地赋给Bean，这样属于硬编码。<br>事实是，一些以显示为主的网站，对ResultSet结果集的操作只是单纯的显示出来，所以，我相信可能通过优化，避免我前面说的：写很多很多枯燥无用的代码，通过对ResultSet进行封装，产生一个Bean，然后在页面通过column name直接获得值，这样我们要写的代码会大大减少，缩短我们的开发时间，也让我们觉得，现在做的只是为了写代码更方便，当作一种享受，不要重复发明轮子而已。<br>至于你说的什么一对多，请不要把Hibernate的理念搬到这里回复，因为我并不使用Hibernate，也不存在什么一对多，这个Bean的产生，只是跟你写的sql有关系，你sql怎么写，你返回什么字段，这个Bean就生成相应字段的Get方法，sql你已经确定，至于什么一对多，多对多，是在你写sql前的事<br>我这样做是为了写更少的代码</div>
<br>可是最普遍的表结构都是一对多的关系，你不用hibernate只要使用数据库也肯定会碰到一对多关系。怎么可能会没有呢？<br>例子：界面需求就是简单的将一个一对多的数据展现出来，可是你的简单的键值对的bean无法满足这个要求，最简单的例子，班级表和学生表，界面上要展示出班级名称和对应学生s的名称，用你的方法，怎么用一条sql查询出来然后整合到一个bean中去呢？你是不是要拆开来用两个方法去查呢，分别得到班级名称和学生数据集合呢？<br>而hibernate直接可以简单写一个查出班级的代码，之后直接在界面导航出学生列表。<br>你觉得哪个省代码呢？想要省代码应该先从宏观上，上层上去考虑。</div>
<p> </p>
<p>有两张表：</p>
<pre name="code" class="sql">create table test_class (
`class_id` int(11) auto_increment primary key,
`class_name` varchar(50) NOT NULL default '',
`class_level` varchar(50) NOT NULL default ''
) ENGINE=MyISAM DEFAULT CHARSET=gbk;</pre>
<pre name="code" class="sql">create table test_student (
`student_id` int(11) auto_increment primary key,
`class_id` int(11) not null default '0',
`student_name` varchar(50) NOT NULL default ''
) ENGINE=MyISAM DEFAULT CHARSET=gbk;</pre>
<p> </p>
<p>假设你要显示班级及其学生，需要执行两条sql:</p>
<pre name="code" class="sql">select class_id, class_name, class_level from test_class;</pre>
<p> </p>
<pre name="code" class="sql">select student_id, student_name from test_student where class_id = ${class_id}</pre>
<p> </p>
<p>第一句，查出class，系统自动封装出一个List，list里保存了这样一个JavaBean，这个JavaBean包含班级的信息，代码类似这样(这个类是动态的，不是硬编码写出来的)：</p>
<pre name="code" class="java">class Record{
public String getClass_id(){}
public String getClass_name(){}
public String getClass_level(){}
}</pre>
<p>假设这个List保存在request，名字为list，那么，我在页面上如此遍历它：</p>
<pre name="code" class="JSP"><c:foreach item="${requestScope.list}" var="item">
<h1>班级名：${item.class_name}<h1>
<h1>班级级别：${item.class_level}<h1>
<table>
<tr>
<th>学生编号</th>
<th>学生姓名</th>
</tr>
<%-- 这里执行第二条sql，根据class_id查到所有学生，假设保存在request，名字为stulist，遍历这个list，显示所有学生 --%>
<c:foreach item="${requestScope.stulist}" var="stu">
<tr>
<td>${item.student_id}</t>
<td>${item.student_name}</t>
</tr>
</c:foreach>
</table>
</c:foreach>
Hibernate同样会执行这两条sql，只是不用你手动去调用而已。
而我说的问题是：怎么样实现我上面的显示效果，直接用列名访问数据.
你的sql甚至可以这样写：
select test_class.class_name, test_class.class_level, test_student.student_id, test_student.student_name from test_class, test_student where test_class.class_id = test_student.class_id
只要最后能让我用上面的格式来显示结果就可以了。
至于数据类型，你可以在显示时再转换成跟数据库一样的类型，再进行特别的处理，这也属于显示问题了。
我只是想减轻显示时的代码量，不涉及到其他表的对应关系
</pre>
<div class="quote_div">
<div class="quote_title">181054867 写道</div>
<div class="quote_div">
<div class="quote_title">aaa5131421 写道</div>
<div class="quote_div">你这种编码的随意性就太大了，开发前就不需要完整的实体模型设计，开发者想用什么字段整合成一个对象都可以，让后期其他人怎么去维护呢？<br>这样的情况好hibernate做的比较好，开发前有个固定的模型设计，你查出来的都是固定结构化了对象，更何况你要是在一对多的情况下你怎么生成一个bean呢？难道还要查出多个不同的对象出来？本来通过hibernate的关系就可以用。导航出来的东西，你会多出好多的代码</div>
<br>您不能理解随意性，我认为，为数据库的每个表写一个JavaBean，在执行select sql后，还要写代码new这个Bean，然后在ResultSet中getString(XX)，把值一个一个地赋给Bean，这样属于硬编码。<br>事实是，一些以显示为主的网站，对ResultSet结果集的操作只是单纯的显示出来，所以，我相信可能通过优化，避免我前面说的：写很多很多枯燥无用的代码，通过对ResultSet进行封装，产生一个Bean，然后在页面通过column name直接获得值，这样我们要写的代码会大大减少，缩短我们的开发时间，也让我们觉得，现在做的只是为了写代码更方便，当作一种享受，不要重复发明轮子而已。<br>至于你说的什么一对多，请不要把Hibernate的理念搬到这里回复，因为我并不使用Hibernate，也不存在什么一对多，这个Bean的产生，只是跟你写的sql有关系，你sql怎么写，你返回什么字段，这个Bean就生成相应字段的Get方法，sql你已经确定，至于什么一对多，多对多，是在你写sql前的事<br>我这样做是为了写更少的代码</div>
<br>可是最普遍的表结构都是一对多的关系，你不用hibernate只要使用数据库也肯定会碰到一对多关系。怎么可能会没有呢？<br>例子：界面需求就是简单的将一个一对多的数据展现出来，可是你的简单的键值对的bean无法满足这个要求，最简单的例子，班级表和学生表，界面上要展示出班级名称和对应学生s的名称，用你的方法，怎么用一条sql查询出来然后整合到一个bean中去呢？你是不是要拆开来用两个方法去查呢，分别得到班级名称和学生数据集合呢？<br>而hibernate直接可以简单写一个查出班级的代码，之后直接在界面导航出学生列表。<br>你觉得哪个省代码呢？想要省代码应该先从宏观上，上层上去考虑。</div>
<p> </p>
<p>有两张表：</p>
<pre name="code" class="sql">create table test_class (
`class_id` int(11) auto_increment primary key,
`class_name` varchar(50) NOT NULL default '',
`class_level` varchar(50) NOT NULL default ''
) ENGINE=MyISAM DEFAULT CHARSET=gbk;</pre>
<pre name="code" class="sql">create table test_student (
`student_id` int(11) auto_increment primary key,
`class_id` int(11) not null default '0',
`student_name` varchar(50) NOT NULL default ''
) ENGINE=MyISAM DEFAULT CHARSET=gbk;</pre>
<p> </p>
<p>假设你要显示班级及其学生，需要执行两条sql:</p>
<pre name="code" class="sql">select class_id, class_name, class_level from test_class;</pre>
<p> </p>
<pre name="code" class="sql">select student_id, student_name from test_student where class_id = ${class_id}</pre>
<p> </p>
<p>第一句，查出class，系统自动封装出一个List，list里保存了这样一个JavaBean，这个JavaBean包含班级的信息，代码类似这样(这个类是动态的，不是硬编码写出来的)：</p>
<pre name="code" class="java">class Record{
public String getClass_id(){}
public String getClass_name(){}
public String getClass_level(){}
}</pre>
<p>假设这个List保存在request，名字为list，那么，我在页面上如此遍历它：</p>
<pre name="code" class="JSP"><c:foreach item="${requestScope.list}" var="item">
<h1>班级名：${item.class_name}<h1>
<h1>班级级别：${item.class_level}<h1>
<table>
<tr>
<th>学生编号</th>
<th>学生姓名</th>
</tr>
<%-- 这里执行第二条sql，根据class_id查到所有学生，假设保存在request，名字为stulist，遍历这个list，显示所有学生 --%>
<c:foreach item="${requestScope.stulist}" var="stu">
<tr>
<td>${item.student_id}</t>
<td>${item.student_name}</t>
</tr>
</c:foreach>
</table>
</c:foreach>
Hibernate同样会执行这两条sql，只是不用你手动去调用而已。
而我说的问题是：怎么样实现我上面的显示效果，直接用列名访问数据.
你的sql甚至可以这样写：
select test_class.class_name, test_class.class_level, test_student.student_id, test_student.student_name from test_class, test_student where test_class.class_id = test_student.class_id
只要最后能让我用上面的格式来显示结果就可以了。
至于数据类型，你可以在显示时再转换成跟数据库一样的类型，再进行特别的处理，这也属于显示问题了。
我只是想减轻显示时的代码量，不涉及到其他表的对应关系
</pre>
30 楼
zoutm
2010-04-02
有办法，根据javabean的规则，生成相应的java字符串，然后用compiler编译成字节码放到当前classloader的查找路径下，用classLoader装载进来，但这样生成的instance只能用反射方式获取属性值。就入像其他人说的，如果解决这个问题的话根本不需要动态生成javaBean。map最适合这个工作
29 楼
tiannet
2010-04-02
181054867 写道
aaa5131421 写道
你这种编码的随意性就太大了，开发前就不需要完整的实体模型设计，开发者想用什么字段整合成一个对象都可以，让后期其他人怎么去维护呢？
这样的情况好hibernate做的比较好，开发前有个固定的模型设计，你查出来的都是固定结构化了对象，更何况你要是在一对多的情况下你怎么生成一个bean呢？难道还要查出多个不同的对象出来？本来通过hibernate的关系就可以用。导航出来的东西，你会多出好多的代码
这样的情况好hibernate做的比较好，开发前有个固定的模型设计，你查出来的都是固定结构化了对象，更何况你要是在一对多的情况下你怎么生成一个bean呢？难道还要查出多个不同的对象出来？本来通过hibernate的关系就可以用。导航出来的东西，你会多出好多的代码
您不能理解随意性，我认为，为数据库的每个表写一个JavaBean，在执行select sql后，还要写代码new这个Bean，然后在ResultSet中getString(XX)，把值一个一个地赋给Bean，这样属于硬编码。
事实是，一些以显示为主的网站，对ResultSet结果集的操作只是单纯的显示出来，所以，我相信可能通过优化，避免我前面说的：写很多很多枯燥无用的代码，通过对ResultSet进行封装，产生一个Bean，然后在页面通过column name直接获得值，这样我们要写的代码会大大减少，缩短我们的开发时间，也让我们觉得，现在做的只是为了写代码更方便，当作一种享受，不要重复发明轮子而已。
至于你说的什么一对多，请不要把Hibernate的理念搬到这里回复，因为我并不使用Hibernate，也不存在什么一对多，这个Bean的产生，只是跟你写的sql有关系，你sql怎么写，你返回什么字段，这个Bean就生成相应字段的Get方法，sql你已经确定，至于什么一对多，多对多，是在你写sql前的事
我这样做是为了写更少的代码
可以使用JdbcTemplate来写啊，只要你的字段名和JavaBean符合一定的规则，不用从ResultSet中get数据。
如果动态生成JavaBean，还不如直接生成Map呢，
使用实现定义好的JavaBean，最大的好处就是你知道里面有什么属性，而且知道确切的类型。
28 楼
aaa5131421
2010-04-02
181054867 写道
aaa5131421 写道
你这种编码的随意性就太大了，开发前就不需要完整的实体模型设计，开发者想用什么字段整合成一个对象都可以，让后期其他人怎么去维护呢？
这样的情况好hibernate做的比较好，开发前有个固定的模型设计，你查出来的都是固定结构化了对象，更何况你要是在一对多的情况下你怎么生成一个bean呢？难道还要查出多个不同的对象出来？本来通过hibernate的关系就可以用。导航出来的东西，你会多出好多的代码
这样的情况好hibernate做的比较好，开发前有个固定的模型设计，你查出来的都是固定结构化了对象，更何况你要是在一对多的情况下你怎么生成一个bean呢？难道还要查出多个不同的对象出来？本来通过hibernate的关系就可以用。导航出来的东西，你会多出好多的代码
您不能理解随意性，我认为，为数据库的每个表写一个JavaBean，在执行select sql后，还要写代码new这个Bean，然后在ResultSet中getString(XX)，把值一个一个地赋给Bean，这样属于硬编码。
事实是，一些以显示为主的网站，对ResultSet结果集的操作只是单纯的显示出来，所以，我相信可能通过优化，避免我前面说的：写很多很多枯燥无用的代码，通过对ResultSet进行封装，产生一个Bean，然后在页面通过column name直接获得值，这样我们要写的代码会大大减少，缩短我们的开发时间，也让我们觉得，现在做的只是为了写代码更方便，当作一种享受，不要重复发明轮子而已。
至于你说的什么一对多，请不要把Hibernate的理念搬到这里回复，因为我并不使用Hibernate，也不存在什么一对多，这个Bean的产生，只是跟你写的sql有关系，你sql怎么写，你返回什么字段，这个Bean就生成相应字段的Get方法，sql你已经确定，至于什么一对多，多对多，是在你写sql前的事
我这样做是为了写更少的代码
可是最普遍的表结构都是一对多的关系，你不用hibernate只要使用数据库也肯定会碰到一对多关系。怎么可能会没有呢？
例子：界面需求就是简单的将一个一对多的数据展现出来，可是你的简单的键值对的bean无法满足这个要求，最简单的例子，班级表和学生表，界面上要展示出班级名称和对应学生s的名称，用你的方法，怎么用一条sql查询出来然后整合到一个bean中去呢？你是不是要拆开来用两个方法去查呢，分别得到班级名称和学生数据集合呢？
而hibernate直接可以简单写一个查出班级的代码，之后直接在界面导航出学生列表。
你觉得哪个省代码呢？想要省代码应该先从宏观上，上层上去考虑。
27 楼
yangzhanchun
2010-04-02
<div class="quote_title">直接el输出resultset不可以吗?为什么还要封装一次呢?</div>
<div class="quote_title"><span style="font-weight: normal;">
<pre name="code" class="jsp"><h1>UserName:${resultset[i][0]}<h1>
<h1>Password:${resultset[i][1]}<h1></pre>
</span></div>
<div class="quote_title"><br></div>
<div class="quote_title">181054867 写道</div>
<div class="quote_div">
<p>例如我有一个这样的sql：</p>
<pre name="code" class="sql">select username, password from users</pre>
<p> 我想在select结束后，通过ResultSet中的字段名生成一个JavaBean，其代码大概如下：</p>
<pre name="code" class="java">public class Record{
//生成这个方法，get后返回sql中结果集的username字段值
public String getUsername(){}
//生成这个方法，get后返回sql中结果集的password字段值
public String getPassword(){}
}</pre>
<p>关键在于：这个JaveBean是动态的，Get方法因应sql字段不同而不同</p>
<p>曾经记得在Hibernate中广泛使用这种生成字节码，动态化Class的应用，敢问各位高手，是否知道如何实现，请赐教！！</p>
<p> </p>
<p>补充一下应用场景：</p>
<p>select 后，生成的这个Record，我是用在Jsp的 el 表达式中：</p>
<pre name="code" class="jsp"><h1>UserName:${record.Username}<h1>
<h1>Password:${record.Password}<h1></pre>
<p> 这样就避免每个数据库表都写一个JavaBean了，不知我这样的想法是否可行，如有什么性能问题或其他担心，敬请指正！</p>
<p>感谢！！</p>
</div>
<p> </p>
<div class="quote_title"><span style="font-weight: normal;">
<pre name="code" class="jsp"><h1>UserName:${resultset[i][0]}<h1>
<h1>Password:${resultset[i][1]}<h1></pre>
</span></div>
<div class="quote_title"><br></div>
<div class="quote_title">181054867 写道</div>
<div class="quote_div">
<p>例如我有一个这样的sql：</p>
<pre name="code" class="sql">select username, password from users</pre>
<p> 我想在select结束后，通过ResultSet中的字段名生成一个JavaBean，其代码大概如下：</p>
<pre name="code" class="java">public class Record{
//生成这个方法，get后返回sql中结果集的username字段值
public String getUsername(){}
//生成这个方法，get后返回sql中结果集的password字段值
public String getPassword(){}
}</pre>
<p>关键在于：这个JaveBean是动态的，Get方法因应sql字段不同而不同</p>
<p>曾经记得在Hibernate中广泛使用这种生成字节码，动态化Class的应用，敢问各位高手，是否知道如何实现，请赐教！！</p>
<p> </p>
<p>补充一下应用场景：</p>
<p>select 后，生成的这个Record，我是用在Jsp的 el 表达式中：</p>
<pre name="code" class="jsp"><h1>UserName:${record.Username}<h1>
<h1>Password:${record.Password}<h1></pre>
<p> 这样就避免每个数据库表都写一个JavaBean了，不知我这样的想法是否可行，如有什么性能问题或其他担心，敬请指正！</p>
<p>感谢！！</p>
</div>
<p> </p>
26 楼
crazy.j
2010-04-02
有个土鳖的办法~
先自己写个classloader用来加载生成的java类
然后获得元数据 通过元数据生成一个java类文件
编译
反射new
反射set值
至于数据库里的数据类型怎样对应java的类型
自己查jdbc标准吧
先自己写个classloader用来加载生成的java类
然后获得元数据 通过元数据生成一个java类文件
编译
反射new
反射set值
至于数据库里的数据类型怎样对应java的类型
自己查jdbc标准吧
25 楼
181054867
2010-04-01
有图为证，哈哈
24 楼
181054867
2010-04-01
感谢大家的热烈评论，让这篇文章推首页啦，哈哈，感谢！
发表评论
相关推荐
javabean中有100个属性字段，想要在前端页面获取这100个字段和字段对应的中文名称，如用户名称(username),密码(password),可以动态的获取到中文名称和属性字段，并返回前端页面，本例只实现动态解析功能
根据数据库表字段自动生成javaBean工具(支持Mysql,Oracle) , 能够智能开启驼峰标识 ,操作非常简单, 包含使用教程
于是一怒之下，自己动手丰衣足食，就自己用Swing写了一个通过数据库的表生成JavaBean的工具，支持MySQL、Oracle、SQLServce、PostgreSQL，完美支持JPA注解，可以同时生成Entity和DTO，可以自动去除表前缀，并支持...
于是一怒之下，自己动手丰衣足食，就自己用Swing写了一个通过数据库的表生成JavaBean的工具，支持MySQL、Oracle、SQLServce、PostgreSQL，完美支持JPA注解，可以同时生成Entity和DTO，可以自动去除表前缀，并支持...
网上收了一下，没有找到太适合的javabean生成工具...我这个是用的sqlserver数据库，大家如果用其他数据库的话，可以收缩其他数据库获取表格和字段，类型的sql将里面的相应的sql替换掉就可以了。希望能给大家带来帮助。
可以 将 数据库表中字段转为相应的 javaBean 对象 很方便的 生产bean
用vba编写的生成javabean中get和set方法的工具。使用时一定要把编号写上。
根据数据表结构自动生成javabean，需JDK1.7以上版本
Sqlbean是一款通过Java语法生成SQL语句的ORM插件，其理念是弱化在开发阶段对数据库的操作，无需先建表再开发，可直接编写实体类和业务代码，项目启动后自动创建表和维护表结构。内置大量常用方法，支持灵活的条件...
就自己用Swing写了一个通过数据库的表生成JavaBean的工具，支持MySQL、Oracle、SQLServce，完美支持JPA注解，可以同时生成Entity和DTO，可以自动去除表前缀，并支持去除多个前缀，支持精确指定只生成哪几个表的Bean...
于是一怒之下，自己动手丰衣足食，就自己用Swing写了一个通过数据库的表生成JavaBean的工具，支持MySQL、Oracle、SQLServce、PostgreSQL，完美支持JPA注解，可以同时生成Entity和DTO，可以自动去除表前缀，并支持...
于是就自己用Swing写了一个基于数据库的自动化生成工具，支持MySQL、Oracle、SQLServce、PostgreSQL，完美支持JPA注解，可以同时生成Entity和DTO等，可以自动去除表前缀，支持单个和批量生成JavaBean，现在不但成员...
就自己用Swing写了一个通过数据库的表生成JavaBean的工具，支持MySQL、Oracle、SQLServce，完美支持JPA注解，可以同时生成Entity和DTO，可以自动去除表前缀，并支持去除多个前缀，支持精确指定只生成哪几个表的Bean...
在已经有xml的情况下，快速生成javabean代码，不需要自己再手打大量无聊的代码。
就自己用Swing写了一个通过数据库的表生成JavaBean的工具，支持MySQL、Oracle、SQLServce，完美支持JPA注解，可以同时生成Entity和DTO，可以自动去除表前缀，并支持去除多个前缀，支持精确指定只生成哪几个表的Bean...
就自己用Swing写了一个通过数据库的表生成JavaBean的工具，支持MySQL、Oracle、SQLServce，完美支持JPA注解，可以同时生成Entity和DTO，可以自动去除表前缀，并支持去除多个前缀，支持精确指定只生成哪几个表的Bean...
根据javabean生成建表语句
就自己用Swing写了一个通过数据库的表生成JavaBean的工具，支持MySQL、Oracle、SQLServce，完美支持JPA注解，可以同时生成Entity和DTO，可以自动去除表前缀，并支持去除多个前缀，支持精确指定只生成哪几个表的Bean...
JavaBean 生成 get set
于是就自己用Swing写了一个基于数据库的自动化生成工具，支持MySQL、Oracle、SQLServce、PostgreSQL，完美支持JPA注解，可以同时生成Entity和DTO等，可以自动去除表前缀，支持单个和批量生成JavaBean，现在不但成员...