基于EJB3.0的留言板项目的开发全过程

基于EJB3.0的留言板项目的开发全过程

因为工作关系，所以准备了EJB3.0的课程，其实以前就做过了这方面的工作，但是当时没有想到要讲课，所以学的很浅，而且很长时间不用也忘记了，这会又重写看了一下。其实，网上有很多的视频或者是什么的，但是貌似我就是没有看到一个稍微完整的项目例子的，很多都只是连上了数据库，稍微写一个方法就算完事了，所以这一次，我写了一个留言板，很简单的功能。当然很简单了，只是一对一的关系，但是这里面却也有一些体会。

好了，开始写了哦！
首先，不用说别的，肯定需要连接数据库，所以先创建一个数据库吧，我用的是mysql。都说了是很简单的留言板例子了，数据库当然简单的不象话了，这个不用多说了。配置一下数据源，说白了就是xml文件。这个文件不详细讲解了，一会我会把所有的文件打包传上来，并且在我前面的教程中也有这些内容。
好了，这几个准备工作完成了，那么我们创建一个EJB Project（EJB项目）。我们要知道这样子一个事情，EJB，我们用来作出一个一个的模块，然后我们在项目中去使用它。
项目创建好了以后，导入jar包，在jboss下的client下面。好了，一个项目建好了，我们在persistence.xml（在META-INF目录下面），创建项目的时候自动创建了一个，这个文件里面的内容是：

<?xml version=”1.0″?>
<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
 <A href=”http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd” target=_blank>http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd</A>” version=”1.0″>
 <persistence-unit name=”ejbdb” transaction-type=”JTA”>
  <jta-data-source>
   java:EJBDS
  </jta-data-source>
  <properties>
   <property name=”hibernate.hbm2dd1.auto” value=”create-drop”/>
  </properties>
 </persistence-unit>
</persistence>

简单说一下：ejbdb是我后面要用到的一个名字，随便起，当然要满足一定的规则。EJBDS是我配置的mysql-ds.xml里面的JNDI名字。因为这是一个全局的JNDI，所以我们使用java:EJBDS就可以找到。

接着看，我们开始创建Entity Bean。这个更加简单了，尤其是对于有Hibernate基础的朋友来说，这部分真的实在是太简单了。先把代码给大家。
package org.adam.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=”user”)
public class UserBean implements Serializable{
 
 private Integer user_id;
 
 private String username;
 
 private String password;

 @Id
 @Column(name=”user_id”)
 @GeneratedValue(strategy=GenerationType.AUTO)
 public Integer getUser_id() {
  return user_id;
 }

 public void setUser_id(Integer user_id) {
  this.user_id = user_id;
 }

 @Column(name=”username”,length=50,nullable=false)
 public String getUsername() {
  return username;
 }

 public void setUsername(String username) {
  this.username = username;
 }

 @Column(name=”password”,length=50,nullable=false)
 public String getPassword() {
  return password;
 }

 public void setPassword(String password) {
  this.password = password;
 }
}

package org.adam.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=”context”)
public class ContextBean implements Serializable{
 
 private Integer context_id;
 
 private String title;
 
 private String context;
 
 private String email;

 @Id
 @Column(name=”context_id”)
 @GeneratedValue(strategy=GenerationType.AUTO)
 public Integer getContext_id() {
  return context_id;
 }

 public void setContext_id(Integer context_id) {
  this.context_id = context_id;
 }

 @Column(name=”title”,length=50,nullable=false)
 public String getTitle() {
  return title;
 }

 public void setTitle(String title) {
  this.title = title;
 }

 @Column(name=”context”,length=200,nullable=false)
 public String getContext() {
  return context;
 }

 public void setContext(String context) {
  this.context = context;
 }

 @Column(name=”email”,length=30,nullable=true)
 public String getEmail() {
  return email;
 }

 public void setEmail(String email) {
  this.email = email;
 }
}

我们看上面的代码，首先我们会发现，和以往我们看到的一般的Java Bean并没有太大的区别，都是一些属性，然后set,get方法。当然了，我们仔细观察，又看出了一些不同。这里面添加了很多的Java Annotation的内容，就是Java注解的内容。下面，我们来一一看一下这些个Java注解。
@Entity：表示这是一个实体Bean。
@Table(name=”context”)：对应数据库中的那一张表。
@Id：主健
@Column(name=”context_id”)：这一列在数据库中对应的是那一列，还有其他的一些参数可以设置。
@GeneratedValue(strategy=GenerationType.AUTO)：自动增长
@Column(name=”email”,length=30,nullable=true)：对应数据库中的email列，长度50，可以为空。
当然了，我们还需要实现Serializable，实现序列化。
好了，基本的出现的Java注解都已经讲完了，并且，我们的Java注解一定要写在get方法的上面，这是由相应的Java Annotation所规定的。
好的，实体Bean已经开发完了，那么我们就应该写一些业务方法了。所以我们先创建接口，代码给出来。
package org.adam.service;

import java.util.List;

import javax.ejb.Remote;

import org.adam.bean.UserBean;

@Remote
public interface UserService {
 
 public void regist(UserBean user);
 
 public void delete(Integer user_id);
 
 public void update(UserBean user);
 
 public UserBean getUser(Integer user_id);
 
 public List getAllUser();
}

package org.adam.service;

import java.util.List;

import javax.ejb.Remote;

import org.adam.bean.ContextBean;

@Remote
public interface ContextService {
 
 public void say(ContextBean con);
 
 public void deletecontext(Integer context_id);
 
 public void updatecontext(ContextBean con);
 
 public ContextBean getSomething(Integer context_id);
 
 public List getAllContext();
}

这是两个很简单的接口，没有什么好说的了，唯一稍有不同的在interface的上面有@Remote一句，这是表示一个远程接口的意思。
好的，既然已经写完了接口，那么我们自然就要实现它，所以我们创建了两个类实现了这两个接口，先把代码给出来。

package org.adam.service.impl;

import java.util.List;

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

import org.adam.bean.ContextBean;

import org.adam.service.ContextService;
@Stateless
public class ContextServiceBean implements ContextService{

 @PersistenceContext(unitName=”ejbdb”)
 EntityManager em;
 public void deletecontext(Integer context_id) {
  em.remove(em.find(ContextBean.class, context_id));
 }

 public List getAllContext() {
  return em.createQuery(“select c from ContextBean c”).getResultList();
 }

 public ContextBean getSomething(Integer context_id) {
  return em.find(ContextBean.class, context_id);
 }

 public void say(ContextBean con) {
  em.persist(con);
 }

 public void updatecontext(ContextBean con) {
  em.merge(con);
 }

}

package org.adam.service.impl;

import java.util.List;

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

import org.adam.bean.UserBean;
import org.adam.service.UserService;

@Stateless
public class UserServiceBean implements UserService{

 @PersistenceContext(unitName=”ejbdb”)
 EntityManager em;
 public void delete(Integer user_id) {
  em.remove(em.find(UserBean.class, user_id));
 }

 public List getAllUser() {
  return em.createQuery(“select u from UserBean u”).getResultList();
 }

 public UserBean getUser(Integer user_id) {
  return em.find(UserBean.class, user_id);
 }

 public void regist(UserBean user) {
  em.persist(user);
 }

 public void update(UserBean user) {
  em.merge(user);
 }

}

这两个类的结构和代码基本上都是一样的，主要的不同点就是在与操纵的是不同的表，但是这不要紧，我们明白了一个，自然也就明白了另外一个。很简单。
@Stateless：表示这是一个无状态的会话Bean。
@PersistenceContext(unitName=”ejbdb”) ：记得我们在最前面的那个xml文件吗，里面有一项的内容就是ejbdb。在这里用到了。
剩下的就没有什么特殊的了，就是5个很平常的Java代码。这样子其实就完成了会话Bean的开发。

好了，绝大部分的内容都完成了，为了验证我们的程序是否正确，我们使用了JUnit。实际上我也不很会这部分内容，但是简单的使用还是可以的。我在前面的教程中也讲到了如何使用，以及使用步骤，需要注意的地方等等。好了，把测试的代码给出来。
package org.adam.unittest;

import static org.junit.Assert.*;

import java.util.List;
import java.util.Properties;

import javax.naming.InitialContext;
import org.adam.bean.UserBean;
import org.adam.service.UserService;

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

public class UserServiceTest {

 private static UserService user;
 @BeforeClass
 public static void setUpBeforeClass() throws Exception {
  Properties props = new Properties();
  props.setProperty(“java.naming.factory.initial”,”org.jnp.interfaces.NamingContextFactory”);
  props.setProperty(“java.naming.provider.url”, “jnp://localhost:1099″);
  InitialContext ctx=new InitialContext(props); 
  user=(UserService)ctx.lookup(“UserServiceBean/remote”);
 }

 @Test
 public void testDelete() {
  user.delete(2);
 }

 @Test
 public void testGetAllUser() {
  List<UserBean> list=user.getAllUser();
  for(int i=0;i<list.size();i++){
   System.out.println(list.get(i).getUsername());
  }
 }

 @Test
 public void testGetUser() {
  UserBean u=user.getUser(1);
  System.out.println(u.getUsername()+” “+u.getPassword());
 }

 @Test
 public void testRegist() {
  UserBean u=new UserBean();
  u.setUsername(“Adam”);
  u.setPassword(“43046721″);
  user.regist(u);
 }

 @Test
 public void testUpdate() {
  UserBean u=new UserBean();
  u.setUser_id(1);
  u.setUsername(“张弘”);
  u.setPassword(“123456″);
  user.update(u);
 }

}

package org.adam.unittest;

import static org.junit.Assert.*;

import java.util.List;
import java.util.Properties;

import javax.naming.InitialContext;

import org.adam.bean.ContextBean;
import org.adam.service.ContextService;
import org.adam.service.UserService;
import org.junit.BeforeClass;
import org.junit.Test;

public class ContextServiceTest {

 private static ContextService context;
 @BeforeClass
 public static void setUpBeforeClass() throws Exception {
  Properties props = new Properties();
  props.setProperty(“java.naming.factory.initial”,”org.jnp.interfaces.NamingContextFactory”);
  props.setProperty(“java.naming.provider.url”, “jnp://localhost:1099″);
  InitialContext ctx=new InitialContext(props); 
  context=(ContextService)ctx.lookup(“ContextServiceBean/remote”);
 }

 @Test
 public void testSay() {
  ContextBean c=new ContextBean();
  c.setTitle(“hello”);
  c.setContext(“helloworld”);
  c.setEmail(“[e-mail]“);
  context.say(c);
 }

 @Test
 public void testDeletecontext() {
  context.deletecontext(1);
 }

 @Test
 public void testUpdatecontext() {
  ContextBean c=new ContextBean();
  c.setContext_id(1);
  c.setTitle(“welcome”);
  c.setContext(“helloworld”);
  c.setEmail(“[e-mail]“);
  context.updatecontext(c);
 }

 @Test
 public void testGetSomething() {
  ContextBean c=context.getSomething(1);
  System.out.println(c.getTitle()+” “+c.getContext());
 }

 @Test
 @SuppressWarnings(“unchecked”)
 public void testGetAllContext() {
  List<ContextBean> list=context.getAllContext();
  for(int i=0;i<list.size();i++){
   System.out.println(list.get(i).getTitle()+” “+list.get(i).getContext());
  }
 }

}

经过验证，全部成功。那么，我们使用EJB3.0对于数据库的增删改查的功能就全部完成了，我们现在要做的，就是把这个EJB Project打成一个jar包，使用Eclipse自带的打包工具就可以，直接生成了一个jar包，拿来就可以使用了。
我们创建一个Web项目，把jar导入，创建页面和servlet就可以了，bean基本上就用不到了。
这个web项目我就写了一点点，没有什么难度了，大家参考一下吧！
谢谢！