在JBOSS中操作实体BEAN

首先我们来解释一下什么叫做实体bean，如下：

解释完了以后，现在正是动手操作啦。新建一个工程，并把JBOSS中的jar包引入进去，路劲为：D:\JBoss\jboss-5.1.0.GA\client

然后，我们要在src目录下创建一个名为“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">
	<!-- 定义持久化单元，即实体类的集合，name为自定义 -->
	<persistence-unit name="MySql" transaction-type="JTA">
		<jta-data-source>java:MySqlDS</jta-data-source>
		<properties>
			<!-- 每启动一次服务器就更新一次表结构 -->
			<property name="hibernate.hbm2ddl.auto" value="update"/>
			<!-- 显示执行的SQL语句 -->
			<property name="hibernate.show_sql" value="true"/>
			<!-- 格式化显示的SQL -->
			<property name="hibernate.format_sql" value="true"/>
		</properties>
	</persistence-unit>
</persistence>

然后创建一个实体bean，代码如下：

package com.zlb.bean;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="stu")
public class Student implements Serializable{
	/**
	 * 实现序列接口，以便区分客户端与服务器中值的异同
	 */
	private static final long serialVersionUID = 733200529487550550L;

	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)//默认值，表示此字段可以跨平台字段增长
	private Integer id;
	
	@Column(length=20,nullable=false)//字段不能为空
	private String name;
	
	//需要无参的构造函数
	public Student(){};
	public Student(String string) {
		this.name = string;
	}
	
	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;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		return result;
	}
	
	/**
	 * 判断返回给客户端的值是否与给服务器的值相同，以便区分客户端与服务器
	 */
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		return true;
	}
	
}

接着，创建相对应的接口以及实现类，如下：

package com.zlb.service;

import java.util.List;

import com.zlb.bean.Student;

public interface StudentService {

	public void save(Student student);
	public void delete(int studentId);
	public void update(Student student);
	public Student getStudent(int studentId);
	public List<Student> findStudent();
}

package com.zlb.service.impl;

import java.util.List;

import javax.ejb.Remote;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import com.zlb.bean.Student;
import com.zlb.service.StudentService;

@Stateless
@Remote(StudentService.class)
public class StudentServiceImpl implements StudentService {
	@PersistenceContext EntityManager em;//定义持久化上下文的实体管理器

	@Override
	public void save(Student student) {
		em.persist(student);
	}

	@Override
	public void delete(int studentId) {
		em.remove(em.getReference(Student.class, studentId));
	}

	@Override
	public void update(Student student) {
		em.merge(student);
	}

	@Override
	public Student getStudent(int studentId) {
		return em.find(Student.class, studentId);
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<Student> findStudent() {
		return em.createQuery("select s from Student s").getResultList();
	}

}

然后，我们要创建JNDI配置文件，以便通过JNDI获取EJB对象，名称为，jndi.properties，内容如下：

java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.provider.url=localhost:1099

之后，我们要对EJB进行编译的话，得创建ANT，名称为：build.xml，代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<!--工程名字以及它所在的目录，“.”代表跟此文件在同一目录-->
<project name="EntityBean" basedir=".">
	<!--相关属性-->
	
	<!--src的目录-->
	<property name="src.dir" value="${basedir}\src"></property>
	<!--声明环境变量的别名-->
	<property environment="env" />
	<!--jboss环境变量的值-->
	<property name="jboss.home" value="${env.JBOSS_HOME}"></property>
	<!--jboss服务的加载项，在此设置为默认的-->
	<property name="jboss.server.config" value="default"></property>
	<!--class文件的存放目录-->
	<property name="build.dir" value="${basedir}\build"></property>

	<!--指定jboss的JAR包及class文件的路径-->
	<path id="build.classpath">
		<fileset dir="${jboss.home}\client">
			<include name="*.jar"/>
		</fileset>
		<!--class文件的目录-->
		<pathelement location="${build.dir}"/>
	</path>
	
	<!--创建class文件目录-->
	<target name="prepare">
		<delete dir="${build.dir}"></delete>
		<mkdir dir="${build.dir}"/>
	</target>
	
	<!--创建编译任务时的环境,depends表示在执行此任务之前会先执行的任务-->
	<target name="compile" depends="prepare" description="编译">
		<javac srcdir="${src.dir}" destdir="${build.dir}" includes="com/**">
			<classpath refid="build.classpath"></classpath>
		</javac>
	</target>
	
	<target name="ejbjar" depends="compile" description="创建EJB发布包">
		<jar destfile="${basedir}\${ant.project.name}.jar">
			<fileset dir="${build.dir}">
				<include name="**/*.class"/>
			</fileset>
			<metainf dir="${src.dir}/META-INF"></metainf><!-- 表示把src/meta-inf路径下的所有文件都打进meta-inf文件中 -->
		</jar>
	</target>
	
	<target name="deploy" depends="ejbjar" description="发布EJB">
		<copy file="${basedir}\${ant.project.name}.jar" todir="${jboss.home}\server\${jboss.server.config}\deploy"/>
	</target>
	
	<!--
	<target name="undeploy" description="卸载EJB">
		<delete file="${jboss.home}\server\${jboss.server.config}\deploy\${ant.project.name}.jar"/>
	</target>
	-->
</project>

最后一步，创建调用此实现类中的方法进行访问的Junit测试类，创建方法如下：

1、记住要在所要测试的接口上面右击：

2、记得要勾选红框中的那一项，它表示在类加载完之后所要执行的方法

3、点击“下一步”之后，进入此页面，然后选择你要测试的方法

点击“完成”，接着开始编写代码，如下：

package junit.zlb;

import java.util.List;

import javax.naming.InitialContext;

import org.junit.BeforeClass;
import org.junit.Test;

import com.zlb.bean.Student;
import com.zlb.service.StudentService;

public class StudentServiceTest {
	private static StudentService studentService;

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		try {
			InitialContext initialContext = new InitialContext();
			studentService = (StudentService)initialContext.lookup("StudentServiceImpl/remote");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Test
	public void testSave() {
		studentService.save(new Student("小明"));
	}

	@Test
	public void testDelete() {
		studentService.delete(1);
	}

	@Test
	public void testUpdate() {
		Student stu = (Student) studentService.getStudent(1);
		stu.setName("周玲斌");
		studentService.update(stu);
	}

	@Test
	public void testGetStudent() {
		Student stu = (Student) studentService.getStudent(1);
		System.out.println(stu.getName());
	}

	@Test
	public void testFindStudent() {
		List<Student> students = studentService.findStudent();
		for(Student stu : students){
			System.out.println(stu.getName());
		}
	}

}

最后，右击你要测试的方法，进行测试，如下：

说明：以上操作用到了JPA规范，有兴趣的朋友可以自己去查下文档，有时间我也会发表一篇关于JPA规范的文章。