`
wcxt2012
  • 浏览: 22750 次
  • 性别: Icon_minigender_1
  • 来自: 甘肃
社区版块
存档分类
最新评论

框架学习之Hibernate 第六节 关系映射

阅读更多

学习各种映射关系时总结:

①如何将对象之间的关联关系映射到数据库中

②如何检索出关联对象

 

1.多对一映射

它是使用最多的映射关系,性能上占有优势

关系模型和对象模型:两者并不是一一对应的

举个例子:告诉员工属于哪个部门和告诉部门有哪些员工对于 数据库(关系模型)来说只要有一个就可以

但是对于对象模型不是如此,告诉员工属于哪个部门之后,部门并不会知道自己有哪些员工

幻灯片17

实例:

domain 包中添加

Department .java

/**
* @Author:胡家威  
* @CreateTime:2011-8-15 下午10:03:58
* @Description:
*/

package com.yinger.domain;


public class Department {
    
    private int id;
    private String name;
    
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    
}

 

Employee.java

/**
* @Author:胡家威  
* @CreateTime:2011-8-15 下午10:05:08
* @Description:
*/

package com.yinger.domain;

public class Employee {
    
    private int id;
    private String name;
    private Department depart;
    
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public Department getDepart() {
        return depart;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setDepart(Department depart) {
        this.depart = depart;
    }    

}

 

并添加两个新的 xml

Department.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.yinger.domain">

    <class name="Department">
        <id name="id">
            <generator class="native" />
        </id>
        <property name="name"/>
    </class>
    
</hibernate-mapping>

 

Employee.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.yinger.domain">

    <class name="Employee">
        <id name="id">
            <generator class="native" />
        </id>
        <property name="name"/>
        
        <!-- 多对一映射  name是对应的属性名  column是对应的表的字段名[可以不指定] 
         Hibernate 会自动的根据数据库中的这个字段的值到属性对应的类对应的表里查找对象
         -->
        <many-to-one name="depart" column="depart_id"></many-to-one>
    </class>
    
</hibernate-mapping>

 

然后在 Hibernate.cfg.xml 中添加两个新的mapping

<mapping resource="com/yinger/domain/Department.hbm.xml"/>
<mapping resource="com/yinger/domain/Employee.hbm.xml"/>

 

最后,编写测试类和方法

/**
* @Author:胡家威  
* @CreateTime:2011-8-15 下午11:18:42
* @Description:
*/

package com.yinger.main;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.yinger.domain.Department;
import com.yinger.domain.Employee;
import com.yinger.util.HibernateUtils;

public class Many2One {

    public static void main(String[] args) {
        add();
    }

    private static void add() {
        Department depart = new Department();
        depart.setName("depart name");
        
        Employee emp1 = new Employee();
        emp1.setName("emp1 name");
        emp1.setDepart(depart);
        
        Employee emp2 = new Employee();
        emp2.setName("emp2 name");
        emp2.setDepart(depart);
        
        Session s = null;
        Transaction tr = null;
        try{
            s = HibernateUtils.getSession();
            tr = s.beginTransaction();
            s.save(depart);
            s.save(emp1);
            s.save(emp2);
            
            tr.commit();
        }catch(Exception e){
            if(tr!=null)
                tr.rollback();
        }finally{
            if(s!=null)
                s.close();
        }
    }

}
测试结果:控制台输出

many2one1

 
数据库中的数据

department1department2

 
建表语句:[MySQL 命令行中获取的]

mysql_departmysql_emp

 
修改save的顺序
s.save(emp1);
s.save(emp2);
s.save(depart);
Hibernate的sql语句:多了两天update,因为在保存(insert)emp时还没有建立department

many2one3

 

2.一对多映射

它的关系模型和上面一样,也就是表的结构并不改变,但是对象模型改变了

幻灯片18

实例:

在原有的 Department.java 中添加

属性  private Set<Employee> emps;  以及相应的get和set方法

删掉 Employee.hbm.xml 中的多对一映射

修改 Department.hbm.xml 添加

        <!-- 一对多的映射,key属性一定要有,指定字段名,这个字段是“多”的那个表中的字段名
             class属性是指set中的元素的类型
        -->
        <set name="emps">
            <key column="depart_id" />
            <one-to-many class="Employee"/>
        </set>

 

最后编写测试类:One2Many.java

/**
* @Author:胡家威  
* @CreateTime:2011-8-15 下午11:18:42
* @Description:
*/

package com.yinger.main;

import java.util.HashSet;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.yinger.domain.Department;
import com.yinger.domain.Employee;
import com.yinger.util.HibernateUtils;

public class One2Many {

    public static void main(String[] args) {
        add();
    }

    private static void add() {
        Department depart = new Department();
        depart.setName("depart name");
        
        Employee emp1 = new Employee();
        emp1.setName("emp1 name");
        
        Employee emp2 = new Employee();
        emp2.setName("emp2 name");
        
        Set<Employee> emps = new HashSet<Employee>();
        emps.add(emp1);
        emps.add(emp2);
        depart.setEmps(emps);
        
        Session s = null;
        Transaction tr = null;
        try{
            s = HibernateUtils.getSession();
            tr = s.beginTransaction();
            s.save(emp1);
            s.save(emp2);
            s.save(depart);
            
            tr.commit();
        }catch(Exception e){
            if(tr!=null)
                tr.rollback();
        }finally{
            if(s!=null)
                s.close();
        }
    }

}

 

测试结果:三条 insert 和 两条 update,先保存emp,这时的emp的depart_id为null,所以当插入了depart之后,就要update了

因为这个时候的emp都是持久对象,Hibernate会自动的检测它们的改变并更新

即使修改了save顺序,结果还是一样,因为插入了depart之后,还要根据 depart.setEmps(emps);  确定depart和emp的关系,所以还是要更新

数据库的结果和上面的多对一是一样的

one2many1

 

3.一对一映射

主对象和从对象

主对象如果没有从对象可以,但是从对象没有主对象是不行的

查找主对象时只用了一条sql语句,使用了outer join

查找从对象时用了两条语句,首先查从对象,然后查主对象(如果要使用从对象对应的主对象)

 

两种映射方法:① 基于主键的 一对一

幻灯片19

② 基于外键的 一对一

幻灯片20

 

测试实例:

添加两个domain Object:

Person.java

/**
* @Author:胡家威  
* @CreateTime:2011-8-16 上午12:44:38
* @Description:
*/

package com.yinger.domain;

public class Person {
    
    private int id;
    private String name;
    private IdCard idCard;
    
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public IdCard getIdCard() {
        return idCard;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }

}

 

IdCard.java

/**
* @Author:胡家威  
* @CreateTime:2011-8-16 上午12:45:35
* @Description:
*/

package com.yinger.domain;

import java.util.Date;

public class IdCard {
    
    private int id;
    private Date life;
    private Person person;
    
    public int getId() {
        return id;
    }
    public Person getPerson() {
        return person;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setPerson(Person person) {
        this.person = person;
    }
    public Date getLife() {
        return life;
    }
    public void setLife(Date life) {
        this.life = life;
    }

}

 

添加 映射文件

如果是第一种,基于主键的一对一:此时 person表中id和id_card 表中的id一一对应

Person.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.yinger.domain">

    <class name="Person">
        <id name="id">
            <generator class="native" />
        </id>
        <property name="name"/>
    </class>
    
</hibernate-mapping>

 

IdCard.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.yinger.domain">

    <class name="IdCard" table="id_card">
        <id name="id">
            <generator class="foreign">
                <param name="property">person</param>
            </generator>
        </id>
        <property name="life" />
        <one-to-one name="person" constrained="true"/>
    </class>

</hibernate-mapping>

 

如果是第二种,基于外键的一对一:此时 id_card 表中的字段 person_id 与 person 表中的 id对应

Person.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.yinger.domain">

    <class name="Person">
        <id name="id">
            <generator class="native" />
        </id>
        <property name="name"/>
            
    </class>
    
</hibernate-mapping>

 

IdCard.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.yinger.domain">

    <class name="IdCard" table="id_card">

        <!-- 基于外键的一对一映射,加上了unique="true"约束,相当于就是一对一映射 
        首先假设多个idCard对应一个person,但是加上了unique约束之后就变成了一个idCard对应一个person 
        -->
        <id name="id">
            <generator class="native" />
        </id>
        <property name="life" />
        <many-to-one name="person" column="person_id" unique="true"></many-to-one>

    </class>

</hibernate-mapping>

 

添加了 mapping 映射之后,编写测试类 One2One.java

/**
* @Author:胡家威  
* @CreateTime:2011-8-16 上午12:52:21
* @Description:
*/

package com.yinger.main;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.yinger.domain.IdCard;
import com.yinger.domain.Person;
import com.yinger.util.HibernateUtils;

public class One2One {
    
    public static void main(String[] args) {
        add();
    }

    private static void add() {
        Person p = new Person();
        p.setName("person name");
        
        IdCard card = new IdCard();
        card.setLife(new Date());
        
        //p.setIdCard(card);  // 外键一对一映射的这种情况下 id_card表中的person_id字段没有值
        card.setPerson(p);
        
        Session s = null;
        Transaction tr = null;
        try{
            s = HibernateUtils.getSession();
            tr = s.beginTransaction();
            s.save(p);
            s.save(card);
            
            tr.commit();
        }catch(Exception e){
            if(tr!=null)
                tr.rollback();
        }finally{
            if(s!=null)
                s.close();
        }
    }

}

 

结果:

sql语句: 都是 两条 sql 语句

3

数据库数据:

基于 主键的 情况,id_card 表没有 person_id 字段

4 5

 

基于 外键的 情况,id_card 表有 person_id 字段

2 1

4.多对多映射

使用的不是很多,要注意数据量的大小对性能的影响,因为多对多需要查三张表

幻灯片21

 

测试实例:

Teacher.java

/**
* @Author:胡家威  
* @CreateTime:2011-8-16 上午12:44:38
* @Description:
*/

package com.yinger.domain;

import java.util.Set;

public class Teacher {
    
    private int id;
    private String name;
    private Set<Student> stus;
    
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<Student> getStus() {
        return stus;
    }
    public void setStus(Set<Student> stus) {
        this.stus = stus;
    }

}

 

Student.java

/**
* @Author:胡家威  
* @CreateTime:2011-8-16 上午12:44:38
* @Description:
*/

package com.yinger.domain;

import java.util.Set;

public class Student {
    
    private int id;
    private String name;
    private Set<Teacher> teas;
    
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<Teacher> getTeas() {
        return teas;
    }
    public void setTeas(Set<Teacher> teas) {
        this.teas = teas;
    }

}

 

hbm.xml

Teacher.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.yinger.domain">

    <class name="Teacher">
        <id name="id">
            <generator class="native" />
        </id>
        <property name="name"/>
        <set name="stus" table="teacher_student">
            <key column="teacher_id"></key>
            <many-to-many class="Student" column="student_id"></many-to-many>
        </set>
    </class>
    
</hibernate-mapping>

 

Student.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.yinger.domain">

    <class name="Student">
        <id name="id">
            <generator class="native" />
        </id>
        <property name="name"/>
        <set name="teas" table="teacher_student">
            <key column="student_id"></key>
            <many-to-many class="Teacher" column="teacher_id"></many-to-many>
        </set>
    </class>
    
</hibernate-mapping>

 

添加到了 cfg 中之后,编写测试类:

/**
* @Author:胡家威  
* @CreateTime:2011-8-15 下午11:18:42
* @Description:
*/

package com.yinger.main;

import java.util.HashSet;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.yinger.domain.Student;
import com.yinger.domain.Teacher;
import com.yinger.util.HibernateUtils;

public class Many2Many {

    public static void main(String[] args) {
        add();
    }

    private static void add() {
        Teacher t1 = new Teacher();
        t1.setName("teacher name 1");
        
        Teacher t2 = new Teacher();
        t2.setName("teacher name 2");
        
        Student s1 = new Student();
        s1.setName("student name 1");
        
        Student s2 = new Student();
        s2.setName("student name 2");
        
        Set<Teacher> teas = new HashSet<Teacher>();
        teas.add(t1);
        teas.add(t2);
        s1.setTeas(teas);
        s2.setTeas(teas);
        
        // 这一部分和上面的部分产生的效果是一样的,但是不能同时存在,否则会因为唯一性约束导致事务回滚,数据库中没有任何数据
//        Set<Student> stus = new HashSet<Student>();
//        stus.add(s1);
//        stus.add(s2);
//        t1.setStus(stus);
//        t2.setStus(stus);
        
        Session s = null;
        Transaction tr = null;
        try{
            s = HibernateUtils.getSession();
            tr = s.beginTransaction();
            s.save(s1);
            s.save(s2);
            s.save(t1);
            s.save(t2);
            
            tr.commit();
        }catch(Exception e){
            if(tr!=null)
                tr.rollback();
        }finally{
            if(s!=null)
                s.close();
        }
    }

}

 

测试结果:

控制台输出:

6

数据库中的数据,新创建了三张表,这种多对多映射就是通过创建一个关联表来实现的

7 8 9

 

5. 组件映射

当一个类的属性很特殊,不是数据库中支持的类型,而且又算不上是一个实体,没有表与之对应时可以使用 组件映射

如果组件的属性不能和表中的字段简单对应的时候可以选择使用自定义用户类型!

幻灯片22

 

测试:

People.java

/**
* @Author:胡家威  
* @CreateTime:2011-8-17 下午09:16:04
* @Description:
*/

package com.yinger.domain;

public class People {
    
    private int id;
    private Name name;
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public Name getName() {
        return name;
    }
    public void setName(Name name) {
        this.name = name;
    }

}
 
Name.java
/**
* @Author:胡家威  
* @CreateTime:2011-8-17 下午09:16:36
* @Description:
*/

package com.yinger.domain;

public class Name {

    private String firstName;
    private String lastName;
    
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    
}

 

People.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.yinger.domain">

    <class name="People">
        <id name="id">
            <generator class="native" />
        </id>
        <component name="name" class="Name">
            <property name="firstName"></property>
            <property name="lastName"></property>
        </component>
    </class>
    
</hibernate-mapping>

 

测试类:

/**
* @Author:胡家威  
* @CreateTime:2011-8-16 上午12:52:21
* @Description:
*/

package com.yinger.main;

import org.hibernate.Session;
import org.hibernate.Transaction;

import com.yinger.domain.Name;
import com.yinger.domain.People;
import com.yinger.util.HibernateUtils;

public class ComponentTest {
    
    public static void main(String[] args) {
        add();
    }

    private static void add() {
        People p = new People();
        Name n = new Name();
        n.setFirstName("firstName");
        n.setLastName("lastName");
        p.setName(n);
        
        Session s = null;
        Transaction tr = null;
        try{
            s = HibernateUtils.getSession();
            tr = s.beginTransaction();
            s.save(p);
            tr.commit();
        }catch(Exception e){
            if(tr!=null)
                tr.rollback();
        }finally{
            if(s!=null)
                s.close();
        }
    }

}

 

测试结果:

10

 

11

 

6.关系映射的总结

①对于关联关系的查询,Hibernate一般都是使用两条sql语句将它查出来,但是一对一的情况里的查主对象例外,它是一条sql

②分析各种情况可以根据表的结构开始,用 关系模型来分析 对象模型

 

7.集合映射

xml –>  Java集合类型   ->  特点                                      xml中需要配置的信息

set:->Set                     没有重复,不保存加入的顺序

array:->Class[]            有顺序的                                     list-index

list:->List                     可以重复,有顺序的                  list-index

bag:->List                   不保存顺序的List                       list-index

map:->Map                map键值对的映射类型              map-key

编写 xml 方法

幻灯片32

幻灯片33

幻灯片34

 

使用原则:多数情况下都是使用set,需要保证顺序使用list,但是想用List而又不需要保证顺序使用bag

幻灯片35

 

注意点:

① 定义成 Set,而不是 HashSet

② 原来是 HashSet,保存了之后就不再是 HashSet 了,强制转型时会报错的!

原因是Hibernate进行的封装,变成了 PersistentSet,实现了 Set 接口,但是和 HashSet 没有关系,不能转型!

 

关系级联的设置

cascade:关系级联的处理方式,默认是 none

多对多和多对一 一般不配置级联

一对一 一般是 delete(前提是主从对象是同生共死的关系)

一对多 一般是 save-update

delete 就是说,比如删除一个部门,那么就要删除这个部门的所有的员工,这个一般是不符合实际的

 

inverse :是否放弃维护关联关系

如果是true的话,当某个对象是持久对象时,如果和它关联的对象发生了改变,Hibernate是不会产生update语句来进行更新的,所以会产生错误

注意:如果是true的话,那么一对多中的“多”一定要被告知是对应哪个“一”,否则数据库中“一”的字段会出现 null!

 

幻灯片36

分享到:
评论

相关推荐

    Hibernate笔记 马士兵

    第6课 第一个示例Hibernate HelloWorld 7 第7课 建立Annotation版本的HellWorld 9 第8课 什么是O/R Mapping 11 一、 定义: 11 二、 Hibernate的创始人: 11 三、 Hibernate做什么: 12 四、 Hibernate存在的原因: ...

    低清版 大型门户网站是这样炼成的.pdf

    第6章 充分利用spring 2.5的ioc利器统管bean世界 349 6.1 java程序员的春天厚礼—spring 2.5 349 6.1.1 爱上spring 2.5的十大理由 350 6.1.2 一睹spring 2.5芳容 351 6.1.3 spring 2.5拿手戏——控制反转与依赖...

    java必了解的六大问题

    *第十四阶段:Hibernate框架学习,三大框架之一,包括检索映射技术,多表查询技术,缓存技术以及性能方面的优化; *第十五阶段:Spring框架的学习,三大框架之一,包括了IOC,AOP,DataSource,事务,SSH集成以及...

    java web技术开发大全(最全最新)

    《Java Web开发技术大全:JSP+Servlet+Struts+Hibernate+Spring+Ajax》重点讲解了Struts 2、Speing和HIbernate框架的基础知识和高级技术,如Sruts 2中的*、类型转换、国际化和标签等,HIbe rna{e的会话、0/R映射和...

    Java语言基础下载

    第六章:继承 86 学习目标: 86 单继承(single inheritance) 87 访问控制 89 方法重载(method overloading) 91 方法覆盖(method overriding) 93 基于继承的多态实现 94 隐藏(hiding) 95 构造方法在继承中的使用 96 ...

    java web开发技术大全

    《Java Web开发技术大全:JSP+Servlet+Struts+Hibernate+Spring+Ajax》重点讲解了Struts 2、Speing和HIbernate框架的基础知识和高级技术,如Sruts 2中的*、类型转换、国际化和标签等,HIbe rna{e的会话、0/R映射和...

    计算机网络专业毕业实习报告3000字.docx

    Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端...

    从Java走向Java+EE+.rar

    第6章 JSP——前后台更好地分离 79 6.1 JSP的概念 79 6.2 JSP页面的组成 80 6.2.1 JSP的指令元素 82 6.2.2 JSP的脚本元素 83 6.2.3 JSP的标准动作元素 85 6.2.4 JSP中的内置对象 87 6.3 实例——利用...

    iBATIS实战

    第6章 使用高级查询技术 96 6.1 在iBATIS中使用XML 96 6.1.1 XML参数 96 6.1.2 XML结果 98 6.2 用已映射语句关联对象 101 6.2.1 复杂集合 101 6.2.2 延迟加载 104 6.2.3 避免N+1查询问题 105 6.3 继承 107 6.4 其他...

    基于J2EE框架的个人博客系统项目毕业设计论文(源码和论文)

    由于J2EE的开源的框架中提供了MVC模式实现框架Struts、对象关系模型中的Hibernate 的框架及拥有事务管理和依赖注入的Spring。利用现存框架可以更快开发系统。所以选择Java技术作为blog 的开发工具。 为了增加系统的...

    计算机专业毕业实习日记.docx

    Hibernate吗,就是一个实现对象与关系映射的中间件,大家知道,现在的主流数据库还是关系型的,但编程却已经采用了面向对象的思想,如何让编程人员能像操作对象一样,操纵数据库里的数据呢?Hibernate就是这样一种...

    支持多数据库的ORM框架ef-orm.zip

    表结构元数据的API也向用户开放,同时支持在使用过程中,灵活调整映射关系,因此用户可以用API动态的创建表结构的模型,从而实现各种动态类型和表的映射(例如POJO中包含一个Map,用于映射各种动态扩展的字段)企业...

    spring in action英文版

     第6章 远程调用  6.1 Spring远程调用概览  6.2 与RMI一起工作  6.2.1 连接RMI服务  6.2.2 输出RMI服务  6.3 使用Hessian和Burlap的远程调用  6.3.1 访问Hessian/Burlap服务  6.3.2 用...

    Struts2 in action中文版

    第6章 构建视图——标签 108 6.1 入门 108 6.1.1 ActionContext和OGNL 109 6.1.2 虚拟对象ValueStack 111 6.2 Struts 2标签概要 113 6.2.1 Struts 2标签API语法 113 6.2.2 使用OGNL设置标签属性 115 6.3 数据标签 ...

    经典JAVA.EE企业应用实战.基于WEBLOGIC_JBOSS的JSF_EJB3_JPA整合开发.pdf

    第6章 利用JMS实现企业消息处理 226 6.1 面向消息的架构和JMS概述 227 6.1.1 面向消息的应用架构 227 6.1.2 JMS的基础知识和优势 228 6.1.3 JMS的两个重要版本 229 6.2 PTP类型的JMS 230 6.2.1 配置PTP的JMS服务器 ...

    Java学习笔记-个人整理的

    {2.8}框架中移动的小球}{59}{section.2.8} {2.9}抽象与接口}{59}{section.2.9} {2.10}访问控制}{60}{section.2.10} {2.10.1}类的属性}{60}{subsection.2.10.1} {2.10.2}类的方法}{61}{subsection.2.10.2} {...

    JAVA上百实例源码以及开源项目源代码

    创建发送者和映射消息。发送消息,同时对文本进行少量修改,发送end-of-messages消息,最后关闭连接。 Tcp服务端与客户端的JAVA实例源代码 2个目标文件 摘要:Java源码,文件操作,TCP,服务器  Tcp服务端与客户端的...

    深入浅出Struts 2 .pdf(原书扫描版) part 1

    第6章 通用标签 95 6.1 property标签 95 6.2 a标签 97 6.3 action标签 97 6.4 param标签 98 6.5 bean标签 98 6.6 date标签 100 6.7 include标签 100 6.8 set标签 101 6.9 push标签 103 6.10 url标签 104 6.11 if、...

Global site tag (gtag.js) - Google Analytics