在desploy下创建数据源mysql-ds.xml
<?xml version="1.0" encoding="UTF-8"?>
<datasources>
<local-tx-datasource>
<jndi-name>zynDS</jndi-name>
<use-java-context>false</use-java-context>
<connection-url>jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8</connection-url>
<driver-class>com.mysql.jdbc.Driver</driver-class>
<user-name>root</user-name>
<password>admin</password>
<exception-sorter-class-name>org.
jboss.resource.adapter.jdbc.vendor.
MySQLExceptionSorter</exception-sorter-class-name>
<metadata>
<type-mapping>mySQL</type-mapping>
</metadata>
</local-tx-datasource>
</datasources>
在class路径下创建文件META-INF,在这个文件下创建persistence.xml,配置数据源
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
version="1.0">
<persistence-unit name="zyn">
<jta-data-source>zynDS</jta-data-source>
<properties>
<property name="show_sql" value="true" />
<property name="hibernate.hbm2ddl.auto" value="update" />
</properties>
</persistence-unit>
</persistence>
开发实体对象
@Entity
@Table(name = "student")
public class Student extends DomainObject {
/**
*
*/
private static final long serialVersionUID = 9090499971596826674L;
public Student() {
}
public Student(String name, int age, Long num) {
this.name = name;
this.age = age;
this.num = num;
}
/**
* 业务主键ID,自增,增量1
*/
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Id
private Integer id;
/**
* 学生姓名
*/
@Column(length = 10, name = "student_name", nullable = false)
private String name = "";
/**
* 学生年龄
*/
@Column(length = 2, name = "student_age", nullable = false)
private Integer age = 0;
/**
* 学号
*/
@Column(length = 4, name = "student_no", nullable = false)
private Long num;
@ManyToMany(fetch=FetchType.LAZY,mappedBy="students",cascade={CascadeType.MERGE,CascadeType.PERSIST})
private Set<Teacher> teachers = new HashSet<Teacher>();
@OneToOne(fetch=FetchType.EAGER,mappedBy="student",cascade=CascadeType.ALL,optional=true)
private StudentInfo studentInfo ;
public StudentInfo getStudentInfo() {
return studentInfo;
}
public void setStudentInfo(StudentInfo studentInfo) {
this.studentInfo = studentInfo;
}
public Set<Teacher> getTeachers() {
return teachers;
}
public void setTeachers(Set<Teacher> teachers) {
this.teachers = teachers;
}
public Long getNum() {
return num;
}
public void setNum(Long num) {
this.num = num;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
@SuppressWarnings("serial")
@Entity
@Table(name = "student_info")
public class StudentInfo extends DomainObject {
public StudentInfo() {
}
public StudentInfo(String card, String address) {
this.userCard = card;
this.address = address;
}
// 使用当前对象中student属性的主键来作为本对象的主键
@Id
@GeneratedValue(generator = "pkGenerator")
@GenericGenerator(name = "pkGenerator", strategy = "foreign", parameters = @Parameter(name = "property", value = "student"))
private Integer id;
/**
* 身份证号
*/
private String userCard;
/**
* 详细地址
*/
private String address;
@OneToOne(cascade = { CascadeType.PERSIST, CascadeType.MERGE }, optional = false)
@PrimaryKeyJoinColumn
private Student student;
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUserCard() {
return userCard;
}
public void setUserCard(String userCard) {
this.userCard = userCard;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
@SuppressWarnings("serial")
@Entity
@Table(name = "teacher")
//@Cache(usage=CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public class Teacher extends DomainObject {
public Teacher() {
}
public Teacher(String name) {
this.name = name;
}
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
@Column(name = "teacher_name",nullable=false)
private String name;
@ManyToMany(fetch=FetchType.LAZY,cascade={CascadeType.PERSIST,CascadeType.MERGE})
@JoinTable(name = "teacher_student", joinColumns = @JoinColumn(name = "teacher_id",referencedColumnName="id"), inverseJoinColumns = @JoinColumn(name = "student_id",referencedColumnName="id"))
@OrderBy("num DESC")
private Set<Student> students = new HashSet<Student>();
@OneToMany(mappedBy="teacher",fetch=FetchType.LAZY,cascade={CascadeType.MERGE,CascadeType.REMOVE})
private Set<Course> courses = new HashSet<Course>();
public Set<Course> getCourses() {
return courses;
}
public void setCourses(Set<Course> courses) {
this.courses = courses;
}
public Set<Student> getStudents() {
return students;
}
public void setStudents(Set<Student> students) {
this.students = students;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
开发持久化接口和实现的bean
public interface StudentDao {
public void persist(Student student);
public void merge(Student student);
public void getAll();
}
@Remote(value={StudentDao.class})
@Stateless
public class StudentDaoBean implements StudentDao{
@PersistenceContext(unitName="zyn")
private EntityManager entityManager ;
public void persist(Student student) {
this.entityManager.persist(student);
}
public void merge(Student student) {
this.entityManager.merge(student);
}
public void getAll() {
}
}
测试:
public class StudentDaoTest {
private StudentDao studentDao ;
private InitialContext context;
@Before
public void init() {
try {
context = new InitialContext();
this.studentDao = (StudentDao)this.context.lookup("StudentDaoBean/remote");
} catch (Exception e) {
e.printStackTrace();
}
}
@Test
public void save() {
Student student = new Student("李四", 22, 20072724L);
Teacher teacher1 = new Teacher("王老师");
Teacher teacher2 = new Teacher("李老师");
student.getTeachers().add(teacher1);
student.getTeachers().add(teacher2);
StudentInfo studentInfo = new StudentInfo("520000000000000000","成都市");
studentInfo.setStudent(student);
try {
this.infoDao.persist(studentInfo);
} catch (Exception e) {
e.printStackTrace();
}
}
}
分享到:
相关推荐
### 实体Bean开发实例 #### 实体Bean基本理论 实体Bean是EJB(Enterprise JavaBeans)框架中的一个重要组成部分,主要用于代表持久化的数据。简而言之,实体Bean是一种服务器端组件,用于封装存储在数据库或其他...
4. 注解驱动的实体Bean开发 5. 数据库关系映射 6. EJB本地接口与业务方法 7. JPA和数据源配置 8. 部署与管理 以上就是在JBoss下开发EJB应用,特别是实体Bean应用的基本流程和关键知识点。通过这个过程,开发者可以...
在这个"购物车"案例中,我们将会探讨如何使用EJB来开发一个简单的实体Bean,以及与之交互的Web前端。 1. **EJB概述**:EJB是Java EE平台的一部分,它提供了一种标准的方式来创建分布式的企业级应用。EJB容器管理着...
本篇文章将深入探讨EJB实体Bean的概念、其在Eclipse集成开发环境中的使用,以及与MySQL数据库的集成。 ### 一、EJB实体Bean概述 EJB实体Bean是Java EE应用服务器管理的对象,它们负责处理数据存储和检索。实体Bean...
实体Bean继承是Java企业级应用开发中的一个重要概念,特别是在使用Java持久化技术(JPA)进行数据存储时。实体Bean代表数据库中的一个表,而实体Bean之间的继承关系则需要在数据库层面进行适当的映射,以便正确地...
本资源包包含了会话Bean、实体Bean和消息Bean的源代码,这三种类型的Bean是EJB 3.0的核心组成部分。 1. **会话Bean (Session Beans)** - **无状态会话Bean (Stateless Session Beans)**: 提供无持久性状态的业务...
EJB 3.0是Java企业版(Java EE)中的一个重大改进,它极大地简化了企业级Java组件的开发,特别是对于实体Bean的处理。在EJB 3.0之前,实体Bean通常需要实现Home接口、Remote接口或Local接口,这使得编码过程变得复杂...
2. **Container-managed Persistence (CMP)**:容器负责对象与数据库之间的持久化工作,开发者无需直接处理数据库操作,只需定义实体Bean的字段和属性。 3. **Entity Beans 3.0(EJB 3.0引入)**:简化了Entity Bean...
总之,EJB实体Bean是Java EE开发中的重要概念,它简化了服务器端应用程序的数据访问层。无论选择BMP还是CMP,了解其工作方式和如何进行CRUD操作都是成为熟练Java EE开发者的关键。在实际项目中,根据需求和团队能力...
在Java EE应用开发中,实体Bean(Entity Bean)是一种核心组件,用于表示数据库中的数据对象。这个主题“10_开发单表映射的实体bean”聚焦于如何将数据库单表的数据映射到Java对象,以便在应用程序中进行操作。在本...
在Java开发中,单表实体Bean是用于封装数据库中单个表的数据对象,它是Java Persistence API(JPA)或Hibernate等ORM(对象关系映射)框架中的核心概念。本篇文章将深入探讨单表实体Bean的概念、作用以及如何在实际...
主要包括有状态会话Bean (Stateful Session Bean) 和无状态会话Bean (Stateless Session Bean),以及容器管理持久化实体Bean (CMP Entity Bean) 和Bean管理持久化实体Bean (BMP Entity Bean) 的开发过程。...
本教程聚焦于EJB 3,特别是第10讲,主要讲解如何开发单表映射的实体Bean。在本篇详细解答中,我们将深入探讨EJB 3中的实体Bean及其与数据库单表映射的关系。 首先,实体Bean是EJB的一种类型,代表业务逻辑中的持久...
标题和描述中提到的"各种转换,xml,实体bean,动态bean,map等"涉及了Java编程语言中的一些核心概念,这些概念在企业级应用开发中非常常见。下面我们将详细探讨这些知识点。 1. **XML(Extensible Markup Language)*...
### Java Persistence API (JPA) 与 EJB 3.0 实体 Bean 注解详解 #### 一、JPA 概述与实体 Bean 的转变 Java Persistence API (JPA) 是 Java 社区规范 JSR-220 的一部分,旨在提供一种标准的方式来处理对象与关系...
**EJB实体Bean与事务管理** 企业级JavaBean(Enterprise JavaBeans,简称EJB)是Java平台上的一个核心组件,用于构建可部署在服务器端的分布式应用程序。在EJB规范中,实体Bean(Entity Bean)是一种特殊类型的组件...