hibernate set里面如果有inverse="true",那么cascade="delete-orphan"似乎不起作用了。。。。

zk21 2005-11-07 11:30:24
<hibernate-mapping package="com.chinabig.model">
<class name="CompanyBase"
table="company_test" >

<set name="tradeClasses"
cascade="delete-orphan"
inverse="true"
access="org.hibernate.auction.persistence.DirectSetAccessor">
<key>
<column name="COMP_ID" not-null="true"/>
</key>
<one-to-many class="CompanyTrade"/>
</set>
</class>

===========================================

<class name="CompanyTrade"
table="AN_COMPANY_CLASS_TEST">

<many-to-one name="comp"
insert="false"
update="false"
not-null="true"
access="org.hibernate.auction.persistence.DirectSetAccessor"
column="COMP_ID"/>
</class>

</hibernate-mapping>

以上配置下,用下面的代码:
Company com = this.getCompany();
com.getTradeClasses().clear();
cod.makePersistent(com);
本以为能够删除所有集合里的CompanyTrade,
可是没有作用,最有只有是用以下方法:
CompanyTrade ct = (CompanyTrade)com.getTradeClasses().toArray()[0];
cod.makeTransient(ct);
但这样的做法显然不令人满意的,另外我也想弄清楚这个问题。。。想知道是不是inverse="true"的缘故,如果是的话,你们代码里也用后面这种方法解决的吗?
cascade="delete-orphan" Hibernate will delete any persistent entity
instance that has been removed (dereferenced) from the association (for
example, from a collection).
这是官方书上说的哦!
...全文
706 12 打赏 收藏 转发到动态 举报
写回复
用AI写文章
12 条回复
切换为时间正序
请发表友善的回复…
发表回复
zk21 2005-11-09
  • 打赏
  • 举报
回复
呵呵,这确实很奇怪,我又作了测试,我的cascade="delete-orphan"如果删除父亲则可以删除儿子,但清空儿子集合再保存,则儿子没被删除,但我用cascade="all-delete-orphan"则两种情况都能删除阿!
myth822 2005-11-09
  • 打赏
  • 举报
回复
delete-orphan

当对象从association(例如一个Collection)中移除时,会同时删除该对象的持久化对象。
myth822 2005-11-09
  • 打赏
  • 举报
回复
我也做了一个测试

mysql+hibernate3.0

两个表user,room,多对一关联,
<set name="user" table="USERO2M" cascade="delete-orphan" inverse="true" lazy="true">
<key column="ROOM_ID1"/>
<one-to-many class="com.softbrain.wangzl.hibernate.one2many.User"></one-to-many>
</set>

测试类

Room room = (Room) session.load(Room.class, new Long(1));

room.getUser().remove(room.getUser().toArray()[0]);
System.out.println(room.getUser().size());
tx.commit();

控制台打印:
Hibernate: select room0_.ROOM_ID as ROOM1_0_, room0_.ADDRESS as ADDRESS1_0_ from ROOMO2M room0_ where room0_.ROOM_ID=?
Hibernate: select user0_.ROOM_ID1 as ROOM3_1_, user0_.USER_ID as USER1_1_, user0_.USER_ID as USER1_0_, user0_.NAME as NAME0_0_, user0_.ROOM_ID1 as ROOM3_0_0_ from USERO2M user0_ where user0_.ROOM_ID1=?
1
Hibernate: delete from USERO2M where USER_ID=?
zk21 2005-11-09
  • 打赏
  • 举报
回复
事实是,有影响的,如果你们有兴趣,可以自己测试,我说的这些是建立在测试基础上的。
zk21 2005-11-09
  • 打赏
  • 举报
回复
恩,就算没影响,但为什么cascade="delete-orphan"不起作用呢?他并没有删除集合中的那些被删除了的对象阿。
www203 2005-11-08
  • 打赏
  • 举报
回复
up
zk21 2005-11-08
  • 打赏
  • 举报
回复
外键?他们的联系是通过column="COMP_ID"/>建立的阿,你是说非要有foreign-key的吗?这个只是个名称吧,hibernate in action里面讲cascade例子都没有要这个,虽然他用的是cascade="save-update"
sgdb 2005-11-08
  • 打赏
  • 举报
回复
cascade,你db里的外键建起来了么?
zeq258 2005-11-08
  • 打赏
  • 举报
回复
呵呵,,,
还请楼主多看些资料,把这两个概念分清!
myth822 2005-11-08
  • 打赏
  • 举报
回复
同意zeq258(近朱者赤) 的观点,楼主把inverse和cascade的概念混淆了

就算是主控方为B,但是你是在A上设定的cascade,两个互不影响
zk21 2005-11-08
  • 打赏
  • 举报
回复
抛开这个问题不说,如果A 一方设置成inverse=true,B的是inverse=false,而A这端有cascade=all-delete-orphan,那么,控制方应该是B了,但是通过A删除存有B的集合,它不是会删除的B吗?(就我这个帖子的里面那个例子来说,至少,删除A的时候,B是被删除了的),那不是A在控制吗?
zeq258 2005-11-08
  • 打赏
  • 举报
回复
在关联关系中 inverse=false 的是主控方(默认是false),inverse=true 的是被控方。

inverse 和 cascade 实际上是两个互不相关的概念,inverse 指的是关联关系的控制

方向。而cascade 是指是否对它的关联关系进行级连操作。
Hibernate的检索方式:(查询/加载) 1. 通过OID加载 session.get(Users.class, 1); * 2. 通过HQL/SQL 检索 hibernate query language (面向对象的查询语言) * a) 不再操纵表,它操纵的是持久化类的对象 b) 面向对象的 3. QBC ( query by criteria ) 更加面向对象 4. QBE ( query by Example ) 5. SQL Hibernate的检索策略: 1. 延迟检索(加载)映射文件中改变lazy a) Lazy的取值: i. Many-to-one 1. false 2. proxy 3. no-proxy ii. set 一对多 1. true   2. false   3. extra 根据对set容器的不同,可以产生高效的sql访问数据库 2. 批量检索:batch-size=3 a) 可以使用批量检索: b) 在内存中,如果有多个set(代理)容器需要初始化, 则当访问任何一个代理set容器时,一次初始化n个set容器,减少sql语句; c) 产生的语句是:select * from ….. where FK in (?,?,?... …n); 3. 迫切(fetch)左外连接检索: a) 在映射文件中设置:fetch(抓取) i. Select 什么都不做 ii. Subselect 当访问内存中的一个代理容器时,一次将所有的set容器用一个子查询,全部初始化 iii. Join 1. 对OID检索方式有用 2. 对hql检索方式没有用 b) 在hql中要使用迫切左外连接时,必须加 left join fetch 对象.关系属性 i. 如果不加fetch关键字,则hibernate不会抓取关系属性,但会遍历关系属性所对应的表 ii. 不加fetch关键字时,select 要指定返回的对象,否则它要返回数组 iii. 条件:持久化类之间有关系属性映射 Hibernate级联操作对象的关系属性: 映射文件中设置: 1. Cascade a) none b) Save-update 当使用session的api对当前对象进行save,update操作时,对它的关系属性也进行save或者update c) Delete d) All = delete + save-update e) Delete-orphan 只是删除父子关系的子对象 f) All-delete-orphan 父子关系的表设为此值,表示,当删除一个父对象时,将这个set容器中的子对象全部删除 2. Inverse 只能在set映射时使用;它的作用是:是否根据set容器中存放的对象,产生update语句,维护关系(子)表的外键属性;取值为true时,将不产生update语句。当inverse设为true时,通过父亲增儿子时,必须建立双向关系. Session的一级缓存:(相当于一系列的map容器,它是需要维护的) 1. 提高效率 2. 维护缓存中的对象和数据库中对应表的记录之间进行同步 3. 当一级缓存中的对象状态(属性)发展生改变时,session在特定的时刻清理缓存: a) 清理缓存的时间点: i. Transaction.commit(); 事务提交时 ii. Session.flush(); 4. 管理session一级缓存的方法 a) Session.evict(obj)从session的一级缓存中移出一个对象 b) Session.clear() 将一级缓存中的所有对象全部清空 c) Session.close() 关闭一个session 对象的状态和对象的生命周期: 持久化类的对象,在hibernate应用中可以处于三种状态(根据对象和session之间的关系进行划分): 1. 临时态,瞬态:特点: a) 在数据库中没有记录和它对应 b) 和session没有任何关系 c) New 出来的对象,都处于临时态 2. 持久态:特点: a) 处于session的一级缓存中 b) 数据库中有一条记录和它对应 c) Session会在特定的时刻(清理缓存时)维护这个对象和数据库中的记录进行同步 d) 在同一个session的缓存中,具有相同OID的持久态对象,只有一个(同一个session的一缓存中,不可能同时有两个OID相同的同一个持久化类的对象存在) 3. 游离态,脱管 a) 不在一级缓存之中 b) 数据库可能有记录和它对应,也可能没有记录和它对应 c) 从一个持久态对象转化过来的,从session的一级缓存中出来的,因为调用了session的一些方法,产生了这种对象(session.close()) SessionFctory: Hibernate映射一对多关系: public class Dept implements java.io.Serializable { // Fields private Integer deptid; private String deptname; private Integer deptnum; private Integer actNum; private Date cdate; private Set emps = new HashSet(0) ; //getter/setter方法 略… } 映射文件: <hibernate-mapping> <set name="emps" inverse ="true" lazy="true" cascade="none" batch-size="2" fetch="join" > set> hibernate-mapping> Hibernate映射多对一: public class Emp implements java.io.Serializable { private Integer empid; private Dept dept; private String empname; //getter/setter方法略 } <hibernate-mapping> cascade ="none" lazy ="proxy"> hibernate-mapping> Hibernate映射一对一(通过主键实现一对一的关系) //主PO对象(一个员工对个应一个身份证) public class Employees implements Serializable{ private Integer empid; private String name; private String sex; private Date birthday; private Double salary; //关系属性: private Idcard idcard; } <hibernate-mapping package ="org.wllt.www.po"> … 属性映射略 cascade ="save-update"> hibernate-mapping> //子PO对象 public class Idcard { private Integer empid; private String cardno; private String addr; private String fzjg; private Date enddate; //关系属性 private Employees emp; } <hibernate-mapping package="org.wllt.www.po3"> emp cascade="save-update" > hibernate-mapping> Hibernate映射一对一(通过外键实现一对一的关系) 子表引用主表的主键做外键,这个外键建立了unique约束、not-null约束 //主对象: public class Dept implements java.io.Serializable { private Integer deptid; private String deptname; private Integer deptnum; private Integer actNum; private Date cdate; //关系属性 private Phonenote phonenote; } <hibernate-mapping> <-- …property 映射略 --> cascade ="all" fetch="join" > hibernate-mapping> 子对象 public class Phonenote implements java.io.Serializable { // Fields private Integer phonid; private Dept dept; private String phonecode; } <hibernate-mapping> cascade ="all"> hibernate-mapping> Hibernate映射多对多(两个一对多实现多对多) 表:材料表和产品表多对多,在数据库中有中间表即产品材料表用来存放两个表之间的关系 Java类:材料PO,产品PO,中间PO,中间PO的复合主键类(由于是两个一对多形成的多对多,所以,这里只讲一个一对多,另一个是相同的映射方法) //产品类: public class Product { private Integer cpbh; private String cpmc; private String gg; private String sh; private String nbxh; private String txm; private String bzfs; private Set proMals = new HashSet(0); } <hibernate-mapping package="org.wllt.www.po"> <-- property 映射略 --> <set name="proMals" inverse="true" cascade="all-delete-orphan"> set> hibernate-mapping> 中间PO public class ProMal { private ProMalId id; } 复合主键类: public class ProMalId implements Serializable{ private Product product; private Clzb clzb; } <hibernate-mapping package="org.wllt.www.po"> hibernate-mapping> Hibernate映射多对多(两个PO类直接实现多对多) 表:材料表和产品表多对多,在数据库中有中间表即产品材料表用来存放两个表之间的关系 Java类:材料PO,产品PO,这两个PO分别包含一个set容器, 相互放对方的对象,没有中间PO, 程序员因为得不到中间PO对象,所以不能直接操作数据库的中间表。中间表中的记录的维护工作,只能交给hibernate来处理,这时,set容器的inverse属性必须设为false 主PO: public class Users implements java.io.Serializable { private Integer uerid; private String name; private String passwd; private Set roles = new HashSet(0); } <hibernate-mapping> <-- property的映射略 --> <set name="roles" inverse ="false" table ="USERANDROLE"> set> hibernate-mapping>
jdbc: 1.数据库连接的方式: ODBC:开放式数据库连接。 C语言实现的,提供语言和(基于SQL的)数据库进行交互的“一致性”的接口 JDBC:java版本的ODBC JDBC连接数据库的步骤: 1.注册驱动(加载驱动): 注册的方式: 1.使用类加载器(使用反射的方式) Class.forName(driverName); 2.实例化Driver Driver driver = new oracle.jdbc.driver.OracleDriver(); DriverManager.registerDriver(driver); 3.加虚拟机参数jdbc.drivers -Djdbc.drivers=oracle.jdbc.driver.OracleDriver 4.从Jdk6.0以后要求,JDBC 4.0 Drivers 必须包括 META-INF/services/java.sql.Driver 文件,有了这个文件以后不需要在显示的使用Class.forName来进行驱动的注册 Oracle数据库进行连接的时候,使用的驱动类: 1.oracle.jdbc.driver.OracleDriver 2.oracle.jdbc.OracleDriver 2.建立连接 连接方式: 1.DriverManager(中的getConnection其实也是调用的Driver.connect方法) getConnection(url);//没有用户名密码 //将用户名密码存放在java.util.Properties对象中 getConnection(url,properties); getConnection(url,user,passwd); 2.直接调用Driver.connect方法执行 Driver d = new DriverClass(); d.connect(url,properties); 3.创建Statement: Statement: 1.创建时不需要传递sql语句,但是执行时需要传递sql语句 2.如果涉及到动态参数的传递,必须使用字符串拼接 PreparedStatement: 1.创建时就需要传递sql语句,执行的时候不需要传递sql语句 2.如果涉及到动态参数的传递,可以使用字符串拼接,也可以使用?占位的形式 给?号传值使用的是 pstmt.setType(index,value); index从1开始 3.提供预编译的功能,某种程度上可以避免sql注入的问题 4.提前做语法检查,在给?赋值的过程中要求数据类型一定要匹配,这样在某种程度上可以避免因为数据类型不匹配而发生的异常 CallableStatement:主要用来执行pl/sql的一些过程,函数等。 1.写一条恒成立的select语句,无论你输入的条件是什么,总是能讲表中的所有数据输出 select id,last_name from s_emp where '1' ='1'; where 1=1; findByOption(Integer age,String province,String gender){ String sql = select * from s_emp where 1=1; if(age!=null){ sql + "and age < age"; } if(province!=null){ sql + "and province=province"; } if(gender!=null){ sql + "and gender = gender"; } } 4.执行sql语句: execute:返回boolean类型的值,代表是否有结果集返回(如果执行select操作,是有ResultSet的,返回值为true) executeUpdate:返回int类型的值,代表的是,操作执行完成后,受影响的数据库的行计数(针对于insert,update,delete) executeQuery:返回的是ResultSet ResultSet:类似于指针或者游标的东西,里边保存的不是所有的结果,而是指向结果集的正上方。所以如果一旦连接关闭那么ResultSet将取不到值 5.处理结果 如果有结果集,处理结果集 ResultSet next(),每执行一次,向下移动一次,如果有值,返回true,如果没值返回false while(rs.next()){ rs.getType(index/columnName); 如果传的是index,那么索引是从1开始的。 select id,last_name from s_emp; 那么1代表的就是id,依次类推 } 6.关闭资源 先开的后关 D:\oraclexe\app\oracle\product\10.2.0\server\jdbc\lib\ojdbc14.jar linux下启动数据库监听的命令: lsnrctl start; "select id from s_emp where name = '"+name+"'"; table s_user( id , name, age) class User{ } //分别使用Statement对象和PreparedStatement对象实现 public class JDBCTest{ //查找s_user表中所有的数据,并且返回他们的集合 public Collection findAll(){ } //按照名字进行删除 public int deleteUser(String name){ } //将user对象的信息更新到数据库表中 public int updateUser(User user){ } //讲User对象保存到数据库中 public void insertUser(User user){ } } JDBC:本身自动帮我做事务管理的操作 AutoCommit = true; Connection.setAutoCommit(false); 正常: conn.commit(); 异常: conn.rollback(); JDBC批处理: addBatch executeBatch Statement PreparedStatement Statement{ 1.获取连接 getConnection(); 2.创建Statement conn.createStatement(); 3.执行sql语句 String sql .... insert delete update executeUpdate select ----- Result executeQuery 4.如果有结果集处理结果集 5.资源关闭 } Statement: update/delete/insert: stmtExecute(String sql){ 1.获取连接 getConnection(); 2.创建Statement conn.createStatement(); 3.执行sql语句 stmt.execute(sql); 4.资源关闭 } Select: stmtQuery(String sql,ResultHander handler){ 1.获取连接 getConnection(); 2.创建Statement conn.createStatement(); 3.执行sql语句 ResultSet set = executeQuery 4.如果有结果集处理结果集 handler!=null handler.handler(set); 5.资源关闭 } 结果集处理的规则: ResultHandler{ handler(ResultSet rs); } PreparedStatement update/delete/insert: pstmtExecute(String sql,PstmtSetter setter){ 1.获取连接 getConnection(); 2.创建PreparedStatement conn.prepareStatement(sql); if(setter!=null){ setter.setter(pstmt); } 3.执行sql语句 pstmt.execute(sql); 4.资源关闭 } ?设值的标准: PstmtSetter{ setter(PreparedStatement pstmt); } Select: stmtQuery(String sql,PstmtSetter setter,ResultHander handler){ 1.获取连接 getConnection(); 2.创建PreparedStatement conn.prepareStatement(); setter!=null setter.setter(pstmt); 3.执行sql语句 ResultSet set = executeQuery 4.如果有结果集处理结果集 handler!=null handler.handler(set); 5.资源关闭 } 结果集处理的规则: ResultHandler{ handler(ResultSet rs); } 表现层 业务逻辑层 持久层 java中的对象分为: 1.域对象:主要作为信息的载体 2.行为对象:注重操作 Register(User user){ } insert(User user){ String sql = "insert into s_user( user.getId()+user.getName().......)"; } insert(User user){ save(user); } ORM Object Relational Class-Object 表 名字 表名 属性 字段(列) object 记录 User s_User id id name name passwd passwd insert into s_user(id,name,passwd) values(?,?,?); Hibernate:ORM的中间件,或者说是实现了ORM的一个框架,对JDBC做了轻量级的封装。 ORM:使用元数据信息来描述对象和数据库之间的关系,并且能够自动实现java中持久化对象到关系型数据库中表的映射 脏检查:自动对缓存中的数据进行检查,并且选择在合适的时机和数据库之间进行交互,以保持数据的一致性 延迟加载:从数据库中还原对象的时候,不会立即对对象进行初始化,而是等到用到的时候才会进行初始化 Core: POJO hibernate.cfg.xml .hbm.xml Session: 1.轻量级的,创建和销毁不需要消耗很大的资源 2.非线程安全的 3.hibernate的一级缓存 4.介于Connection和Transaction之间的一个对象 5.hibernate中用来做持久化操作的 SessionFactory 1.重量级的,创建和销毁需要消耗很大的资源,不建议频繁创建和销毁 2.线程安全的,一个数据库对应一个Sessionfactory(一般一个应用程序对应一个SessionFactory就够了) 3.是一个很大的缓存,本身维护了一个可配置的二级缓存 4.用来构建Session对象 Configuration 1.启动和配置Hibernate 2.读取hibernate的配置文件和映射文件 3.构建SessionFactory对象 Transaction 1.事务管理对象 Query 1.查询对象,HQL Criteria 1.hibernate提供的更面向对象的一种查询方式。 准备工作: 1.java中的POJO对象存在 2.数据库,表得存在 3.hibernate的配置文件(hibernate.cfg.xml)得存在 4.POJO.hbm.xml文件存在 5.hibernate的jar包以及数据库的驱动包存在 Hibernate的编程: 1.构建Configuration对象读取配置文件 2.读取映射文件 3.构建SessionFactory对象 4.构建Session对象 5.开启事务 6.持久化操作 7.事务的提交(正常提交,不正常回滚) 8.关闭资源 主键增长策略: 1.increment:自动增长 select max(id) from table; 找到最大值之后+1赋给要持久化的对象 2.assigned:指派 hibernate不在自动生成主键值,需要你在插入时自己指明 3.hilo:高低值算法,由数据库表提供高值,程序提供低值 value = hi*(max_lo+1)+lo 4.sequences Cat: cid name color weight age --------------------------- 1.每个人都有一个地址 person{ id name } Address{ country province city street } table: id name country province city street Component:数据库中采用一张表的设计,java中采用两个类的设计 ----------------------------------- Employee: id name salary award amount table id name salary award formula: ---------------------------- 关系模型: 多对一: 订单和客户之间的关系 Order{ id amount customer } Customer{ id name } many-to-one:标签中对于cascade的取值delete,delete-orphan,all-delete-orphan(只用unique属性值不为true不能出现)慎用 cascade:级联属性 none:不做任何级联操作 save-update:对当前对象执行save,update, saveOrupdate,会级联操作和它相关联的对象 delete:在删除当前对象的时候,级联删除和他相关联的对象 all: save-update+delete delete-orphan:解除关联关系时,删除和当前对象失去关联的对象 all-delete-orphan:all+delete-orphan 单向的一对多的关系,在进行关联关系的操作时,会执行不必要的update语句,所以,一般情况下,我们不会做单向一对多的映射。 inverse="true":让其中一方放弃对关联关系的维护 一般在做双向多对一(一对多)关联关系映射的时候,一般会设置让一的一方放弃对关联关系的维护,以减少不必要的更新语句 一对一: 基于外键的一对一 Wife Husband id id name name h_id references Husband(id) unique 基于主键的一对一 Wife Husband id references Husband(id) id name name create table Husband( id number primary key, name varchar2(15) ); create table Wife( id number primary key references husband(id), name varchar2(15) ); 多对多: Teacher Student id id name name 桥表:s_t s_id t_id ------------------------------ 操作持久化对象: Hibernate中对象的三种状态: Transient(瞬态): 1.由new关键字创建 2.没有和Session进行关联的 3.数据库中没有对应的记录存在 4.操作不会影响数据库中的数据 Persistent(持久态): 1.和Session之间有关联 2.在数据库中有对应记录存在,并且有持久化标识 3.对持久对象的更动,会对数据库中的数据产生影响。(自动脏检查机制) Detached(托管状态): 1.和Session失去关联 2.数据库中有对应记录存在 3.对托管对象的更动,在托管期间不会影响数据库,但是将托管状态重新和数据库进行关联的时候会将托管对象重新变为持久态,那么在托管期间发生的更动也会被更新到数据库中 get()/load():从数据库中还原数据 get: 1.先从缓存中进行查找,如果找到就直接返回 2.如果找不到,get()会立即发送sql语句到数据库中查找数据,如果找到就返回,如果找不到返回null; load:(使用延迟加载策略) 1.load()方法默认要加载的对象一定存在,所以很放心的使用代理对象,等到用到的时候从缓存中查找数据,如果找到,就返回,找不到发送sql语句到数据库中查找,如果数据库中没有对应记录存在,抛ObjectNotFoundException Hibernate中的查询: 1.OID检索: get load 2.导航对象图查询: Customer ---- Order之间有对应关系 通过检索到Customer以后,想获取和Customer相关的对象,可以使用 cus.getOrders(); 3.HQL: Query sql: select name from t_cus; hql: select name from hiber.many2one.Customer query.list(); 直接发送一条select语句去表中查找所有的属性 query.iterate(); 先发送一条select语句从表中查找所有的id,然后根据id从缓存中进行查找,找到就返回,找不到再发送sql语句按id从数据库中进行查找,所以可能会产生N+1的问题 Customer order select from customer order where customer.id=order.c_id; 4.QBC(Query By Criteria) Criteria Restrictions Order Projections QBE(Query By Example) 5.sql A B 总额 《 4000 - 100 1900 2100 900 Session默认在遇到以下情况的时候会flush: 1.事务提交的时候 2.某些查询操作执行的时候(不是所有的查询) 3.当应用程序显示的调用session.flush操作的时候 悲观锁: LockMode LockMode.UPGRADE:借助于数据库的 select ... for update; 那么事务一定会等到上一个获取了锁的事务commit之后才执行,如果上一个事务一直不提交,那么它就一直等下去 LockMode.UPGRADE_NOWAIT: select ... for update nowait; nowait就是不等待,一旦在操作过程中发现要操作的数据被加了锁,那么直接抛 ORA-00054: 资源正忙, 但指定以 NOWAIT 方式获取资源 乐观锁: 版本控制(version) 时间戳(timestamp)

67,512

社区成员

发帖
与我相关
我的任务
社区描述
J2EE只是Java企业应用。我们需要一个跨J2SE/WEB/EJB的微容器,保护我们的业务核心组件(中间件),以延续它的生命力,而不是依赖J2SE/J2EE版本。
社区管理员
  • Java EE
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧