oschina 的 bean 的基类 POJO_pojo和javabean的区别_词汇网
oschina 的 bean 的基类 POJO
责任编辑：词汇网 发表时间： 15:39:28
POJO.java 是所有 oschina 的 Bean 类的基类。因为oschina的数据库操作逻辑都直接写在bean类中，该类主要提供一些bean的基本操作。 牵涉到的一些类的源码： QueryHelper: http://www.oschina.net/code/snippet_12_6
CacheManager: http://www.oschina.net/code/snippet_12_1574
Inflector: http://www.oschina.net/code/snippet_12_2663 标签： OSCHINA POJO DbUtils 代码片段(1)[全屏查看所有代码] 1.[文件] POJO.java~8KB 下载(316) package my.import java.io.Simport java.sql.PreparedSimport java.sql.ResultSimport java.sql.SQLEimport java.util.ArrayLimport java.util.Limport java.util.Mimport my.cache.CacheMimport my.util.Iimport net.oschina.beans.Uimport mons.beanutils.BeanUimport mons.dbutils.DbU/** * 数据库对象的基类 * @author Winter Lau * @date
上午11:33:56 */public class POJO implements Serializable {protected final static transient char OBJ_COUNT_CACHE_KEY = "#";private long ___key_public long getId() { return ___key_ }public void setId(long id) { this.___key_id = }private String __this_table_public static void evictCache(String cache, Serializable key) {CacheManager.evict(cache, key);}public static void setCache(String cache, Serializable key, Serializable value) {CacheManager.set(cache, key, value);}public static Object getCache(String cache, Serializable key) {return CacheManager.get(cache, key);}/** * 分页列出所有对象 * @param page * @param size * @return */public List List(int page, int size) {String sql = "SELECT * FROM " + TableName() + " ORDER BY id DESC";return QueryHelper.query_slice(getClass(), sql, page, size);}public List Filter(String filter, int page, int size) {String sql = "SELECT * FROM " + TableName() + " WHERE " + filter + " ORDER BY id DESC";return QueryHelper.query_slice(getClass(), sql, page, size);}/** * 统计此对象的总记录数 * @return */public int TotalCount(String filter) {return (int)QueryHelper.stat("SELECT COUNT(*) FROM " + TableName() + " WHERE " + filter);}/** * 返回默认的对象对应的表名 * @return */protected String TableName() {if(__this_table_name == null)__this_table_name = "osc_" + Inflector.getInstance().tableize(getClass());return __this_table_}/** * 返回对象对应的缓存区域名 * @return */public String CacheRegion() { return this.getClass().getSimpleName(); }/** * 是否根据ID缓存对象，此方法对Get(long id)有效 * @return */protected boolean IsObjectCachedByID() { }/** * 插入对象到数据库表中 * @return */public long Save() {if(getId() > 0)_InsertObject(this);elsesetId(_InsertObject(this));if(this.IsObjectCachedByID())CacheManager.evict(CacheRegion(), OBJ_COUNT_CACHE_KEY);return getId();}/** * 根据id主键删除对象 * @return */public boolean Delete() {boolean dr = Evict(QueryHelper.update("DELETE FROM " + TableName() + " WHERE id=?", getId()) == 1);if(dr)CacheManager.evict(CacheRegion(), OBJ_COUNT_CACHE_KEY);}/** * 根据条件决定是否清除对象缓存 * @param er * @return */public boolean Evict(boolean er) {if(er && IsObjectCachedByID())CacheManager.evict(CacheRegion(), getId());}/** * 清除指定主键的对象缓存 * @param obj_id */protected void Evict(long obj_id) {CacheManager.evict(CacheRegion(), obj_id);}public POJO Get(java.math.BigInteger id) {if(id == null)return Get(id.longValue());}/** * 根据主键读取对象详细资料，根据预设方法自动判别是否需要缓存 * @param id * @return */@SuppressWarnings("unchecked")public
T Get(long id) {if(id <= 0)String sql = "SELECT * FROM " + TableName() + " WHERE id=?";boolean cached = IsObjectCachedByID();return (T)QueryHelper.read_cache(getClass(), cached?CacheRegion():null, id, sql, id);}public List BatchGet(List ids) {if(ids==null || ids.size()==0)StringBuilder sql = new StringBuilder("SELECT * FROM " + TableName() + " WHERE id IN (");for(int i=1;i<=ids.size();i++) {sql.append("?");if(i < ids.size())sql.append(",");}sql.append(")");List beans = QueryHelper.query(getClass(), sql.toString(), ids.toArray(new Object[ids.size()]));if(IsObjectCachedByID()){for(Object bean : beans){CacheManager.set(CacheRegion(), ((POJO)bean).getId(), (Serializable)bean);}}}/** * 统计此对象的总记录数 * @return */public int TotalCount() {if(this.IsObjectCachedByID())return (int)QueryHelper.stat_cache(CacheRegion(),OBJ_COUNT_CACHE_KEY, "SELECT COUNT(*) FROM " + TableName());return (int)QueryHelper.stat("SELECT COUNT(*) FROM " + TableName());}/** * 批量加载项目 * @param pids * @return */@SuppressWarnings("rawtypes")public List LoadList(List p_pids) {if(p_pids==null)final List pids = new ArrayList(p_pids.size());for(Number obj : p_pids){pids.add(obj.longValue());}String cache = this.CacheRegion();List prjs = new ArrayList(pids.size()){{for(int i=0;i<pids.size();i++)add(null);}};List no_cache_ids = new ArrayList();for(int i=0;i0){List no_cache_prjs = BatchGet(no_cache_ids);if(no_cache_prjs != null)for(POJO obj : no_cache_prjs){prjs.set(pids.indexOf(obj.getId()), obj);}}no_cache_ids =//Check Usersif(prjs!=null && IsAutoLoadUser()){List no_cache_userids = new ArrayList();String user_cache = User.INSTANCE.CacheRegion();for(POJO pojo : prjs){if(pojo == null)long userid = pojo.GetAutoLoadUser();if(userid > 0 && !no_cache_userids.contains(userid)){POJO user = (POJO)CacheManager.get(user_cache, userid);if(user == null){no_cache_userids.add(userid);}}}if(no_cache_userids.size()>0)User.INSTANCE.BatchGet(no_cache_userids);no_cache_userids =}}protected boolean IsAutoLoadUser() { }protected long GetAutoLoadUser() { return 0L; }/** * 插入对象 * @param obj * @return 返回插入对象的主键 */private static long _InsertObject(POJO obj) {Map pojo_bean = obj.ListInsertableFields();String[] fields = pojo_bean.keySet().toArray(new String[pojo_bean.size()]);StringBuilder sql = new StringBuilder("INSERT INTO ") ;sql.append(obj.TableName());sql.append("(");for(int i=0;i 0) sql.append(",");sql.append(fields[i]);}sql.append(") VALUES(");for(int i=0;i 0) sql.append(",");sql.append("?");}sql.append(")");PreparedStatement ps =ResultSet rs =try{ps = QueryHelper.getConnection().prepareStatement(sql.toString(), PreparedStatement.RETURN_GENERATED_KEYS);for(int i=0;i<fields.i++){ps.setObject(i+1, pojo_bean.get(fields[i]));}ps.executeUpdate();rs=ps.getGeneratedKeys();return rs.next()?rs.getLong(1):-1;}catch(SQLException e){throw new DBException(e);}finally{DbUtils.closeQuietly(rs);DbUtils.closeQuietly(ps);sql=fields=pojo_bean=}}/** * 列出要插入到数据库的域集合，子类可以覆盖此方法 * @return */@SuppressWarnings("unchecked")protected Map ListInsertableFields() {try {Map props = BeanUtils.describe(this);if(getId() <= 0)props.remove("id");props.remove("class");} catch (Exception e) {throw new RuntimeException("Exception when Fetching fields of " + this);}}@Overridepublic boolean equals(Object obj) {if (obj == null)if (obj == this)//不同的子类尽管ID是相同也是不相等的if(!getClass().equals(obj.getClass()))POJO wb = (POJO)return wb.getId() == getId();}}
上一集:没有了 下一集:
相关文章：&&&&&&&&&&
最新添加资讯
24小时热门资讯
附近好友搜索3733人阅读
JAVA（284）
POJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规范，理论上讲，任何一个 Java 类都可以是一个 Bean 。但通常情况下，由于 Java Bean 是被容器所创建（如
Tomcat) 的，所以 Java Bean 应具有一个无参的构造器，另外，通常 Java Bean 还要实现 Serializable 接口用于实现 Bean 的持久性。 Java Bean 是不能被跨进程访问的
JavaBean是一种组件技术，就好像你做了一个扳子，而这个扳子会在很多地方被拿去用，这个扳子也提供多种功能(你可以拿这个扳子扳、锤、撬等等)，而这个扳子就是一个组件。
一般在web应用程序中建立一个数据库的映射对象时，我们只能称它为POJO。
POJO(Plain Old Java Object)这个名字用来强调它是一个普通java对象，而不是一个特殊的对象。
2005年11月时，“POJO”主要用来指代那些没用遵从特定的Java对象模型，约定或框架如EJB的Java对象.
理想地讲，一个POJO是一个不受任何限制的Java对象（除了Java语言规范）。例如一个POJO不应该是
& &1. 扩展预定的类，如 & & & public class Foo extends javax.servlet.http.HttpServlet { ...
& &2. 实现预定的接口，如 & public class Bar implements javax.ejb.EntityBean { ...
& &3. 包含预定的标注，如 & @javax.ejb.Entity public class Baz{ ...
然后，因为技术上的困难及其他原因，许多兼容POJO风格的软件产品或框架事实上仍然要求使用预定的标注，譬如用于更方便的持久化。
JavaBean 是一种JAVA语言写成的可重用组件。它的方法命名，构造及行为必须符合特定的约定：
& &1. 这个类必须有一个公共的缺省构造函数。
& &2. 这个类的属性使用getter和setter来访问，其他方法遵从标准命名规范。
& &3. 这个类应是可序列化的。&
因为这些要求主要是靠约定而不是靠实现接口，所以许多开发者把JavaBean看作遵从特定命名约定的POJO。
简而言之，当一个Pojo可序列化，有一个无参的构造函数，使用getter和setter方法来访问属性时，他就是一个JavaBean。
我的整理与总结：
一、对于java bean，就是一个java模型组件，他为使用java类提供了一种标准的格式，在用户程序和可视化管理工具中可以自动获得这种具有标准格式的类的信息，并能够创建和管理这些类。&
java bean 可以使应用程序更加面向对象，可以把数据封装起来，把应用的业务逻辑和显示逻辑分离开，降低了开发的复杂程度和维护成本！
JavaBean 是一种JAVA语言写成的可重用组件。为写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。JavaBeans 通过提供符合一致性设计模式的公共方法将内部域暴露称为属性。众所周知，属性名称符合这种模式，其他Java 类可以通过自省机制发现和操作这些JavaBean 属性。
从编程的角度，也就是最基本的实现了get跟set方法的类。
二、Enterprise Bean，也就是Enterprise JavaBean（EJB），是J2EE的一部分，定义了一个用于开发基于组件的企业多重应用程序的标准。其特点包括网络服务支持和核心开发工具(SDK)。
& & 在 J2EE里，Enterprise Java Beans(EJB)称为Java 企业Bean，是Java的核心代码，分别是会话 Bean（Session Bean），实体Bean（Entity Bean）和消息驱动Bean（MessageDriven Bean）。 &
& & 1.Session Bean用于实现业务逻辑，它可以是有状态的，也可以是无状态的。每当客户端请求时，容器就会选择一个Session Bean来为客户端服务。Session Bean可以直接访问数据库，但更多时候，它会通过Entity Bean实现数据访问。 这个类一般用单例模式来实现，因为每次连接都需要用到它。
& & &2.Entity Bean是域模型对象，用于实现O/R映射，负责将数据库中的表记录映射为内存中的Entity对象，事实上，创建一个Entity Bean对象相当于新建一条记录，删除一个 Entity Bean会同时从数据库中删除对应记录，修改一个Entity Bean时，容器会自动将Entity Bean的状态和数据库同步。&
& & & Java Persistence 1.0规范中的entity bean仅作为普通Java对象(POJO)来使用，并且是映射到关系数据库表的。与其他类型的EJB不同，entity bean可以被分配，序列化，并像任何其他POJO那样通过网络被发送出去。
& & &3.MessageDriven Bean是EJB2.0中引入的新的企业Bean，它基于JMS消息，只能接收客户端发送的JMS消息然后处理。MDB实际上是一个异步的无状态Session Bean，客户端调用MDB后无需等待，立刻返回，MDB将异步处理客户请求。这适合于需要异步处理请求的场合，比如订单处理，这样就能避免客户端长时间的等待一个方法调用直到返回结果。&
& & 三、Enterprise Bean 与 JavaBean的区别
最初，JavaBean的目的是为了将可以重复使用的软件代码打包标准。特别是用与帮助厂家开发在综合开发环境（IDE）下使用的java软件部件。这些包括如Grid控件，用户可以将该部件拖放到开发环境中。从此，JavaBean就可以扩展为一个java web 应用的标准部件，并且JavaBean部件框架已经扩展为企业版的 Bean（EJB）。&
JavaBean 和 Server Bean（通常称为 Enterprise JavaBean (EJB)）有一些基本相同之处。它们都是用一组特性创建，以执行其特定任务的对象或组件。它们还有从当前所驻留服务器上的容器获得其它特性的能力。这使得 bean 的行为根据特定任务和所在环境的不同而有所不同。
JavaBean 是使用 java.beans 包开发的，它是 Java 2 标准版的一部分。JavaBean 是一台机器上同一个地址空间中运行的组件。JavaBean 是进程内组件。Enterprise Bean 是使用 javax.ejb 包开发的，它是标准 JDK 的扩展，是 Java 2 Enterprise Edition 的一部分。Enterprise Bean 是在多台机器上跨几个地址空间运行的组件。因此 Enterprise Bean 是进程间组件。JavaBean 通常用作 GUI 窗口小部件，而
Enterprise Bean 则用作分布式商业对象.&
四、POJO一个正规的Java对象（不是JavaBean，EntityBean等），也不担当任何的特殊的角色，也不实现任何Java框架指定的接口。POJO是一个简单的、正规Java对象，它包含业务逻辑处理或持久化逻辑等，但不是JavaBean、EntityBean等，不具有任何特殊角色和不继承或不实现任何其它Java框架的类或接口。
& POJO 应该不是我们开始认为的JavaBean，当然更不是EJB，它不应该依赖于框架即继承或实现某些框架类或接口。例如：Struts1中的Action和 ActionForm当然不属于POJO了，而在Struts2中的Action由于可以不继承任何的接口，所以在这种情况下Action是POJO，但是Struts2中的Action也可以继承ActionSupport类就不再属于POJO了。POJO里面是可以包含业务逻辑处理和持久化逻辑，也可以包含类似与JavaBean属性和对属性访问的set和get方法的。
& & 在百度百科上的解释是：简单的Java对象（Plain Ordinary Java Objects）实际就是普通JavaBeans,使用POJO名称是为了避免和EJB混淆起来, 而且简称比较直接. 其中有一些属性及其getter setter方法的类,有时可以作为value object或dto(Data Transform Object)来使用.当然,如果你有一个简单的运算属性也是可以的,但不允许有业务方法,也不能携带有connection之类的方法。&
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1415062次
积分：14534
积分：14534
排名：第868名
原创：79篇
转载：845篇
评论：170条
(1)(1)(26)(5)(42)(46)(105)(81)(67)(37)(4)(1)(12)(12)(24)(28)(69)(32)(34)(20)(1)(7)(10)(13)(36)(1)(2)(12)(21)(6)(8)(16)(1)(11)(4)(3)(6)(4)(2)(2)(2)(3)(4)(3)(2)(1)(5)(4)(1)(6)(6)(4)(2)(6)(5)(7)(1)(7)(15)(5)(1)(16)(5)
(window.slotbydup = window.slotbydup || []).push({
id: '4740881',
container: s,
size: '200,200',
display: 'inlay-fix'java基础学习总结（17）
POJO（Plain Old Java Object）这种叫法是Martin Fowler、Rebecca Parsons和Josh MacKenzie在2000年的一次演讲的时候提出来的。
在/TERM/P/POJO.htm查到解释如下：
POJO, or Plain Old Java Object, is a normal Javaobjectclass (that is, not aJavaBean, EntityBean etc.) and does not serve any other special role nor does it implement any special interfaces of any of the Java frameworks. This term was coined by Martin Fowler,
Rebbecca Parsons and Josh MacKenzie who believed that by creating the acronym POJO, such objects would have a &fancy name&, thereby convincing people that they were worthy of use.
基本意思是说POJO一个正规的Java对象（不是JavaBean，EntityBean等），也不担当任何的特殊的角色，也不实现任何Java框架指定的接口。
POJO(Plain Old Java Object)这个名字用来强调它是一个普通java对象，而不是一个特殊的对象，同时不含有业务逻辑和持久化，可以有简单的代码。
“POJO”主要用来指代那些没用遵从特定的Java对象模型，约定或框架如EJB的Java对象.
理想地讲，一个POJO是一个不受任何限制的Java对象（除了Java语言规范）。例如一个POJO不应该是
扩展预定的类，如 & & &&public class Foo extends javax.servlet.http.HttpServlet { ...
实现预定的接口，如 &&public class Bar implements javax.ejb.EntityBean { ...
包含预定的标注，如 &&@javax.ejb.Entity public class Baz{ ...
然后，因为技术上的困难及其他原因，许多兼容POJO风格的软件产品或框架事实上仍然要求使用预定的标注，譬如用于更方便的持久化。
JavaBean 是一种JAVA语言写成的可重用组件。它的方法命名，构造及行为必须符合特定的约定：
这个类必须有一个公共的缺省构造函数。
这个类的属性使用getter和setter来访问，其他方法遵从标准命名规范。
这个类应是可序列化的。&
因为这些要求主要是靠约定而不是靠实现接口，所以许多开发者把JavaBean看作遵从特定命名约定的POJO。
简而言之，当一个Pojo可序列化，有一个无参的构造函数，使用getter和setter方法来访问属性时，他就是一个JavaBean。
转自@留下脚印&http://blog.csdn.net/wozeze1/article/details/6045627
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：99884次
积分：2291
积分：2291
排名：第17392名
原创：122篇
转载：62篇
评论：13条
(5)(7)(32)(15)(18)(2)(1)(7)(6)(2)(18)(6)(4)(11)(12)(1)(21)(6)(1)(4)(11)
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'
