ejb项目Helloword
首先把jboss下client下的jar全都引入项目中
package cn.ldf.bean;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="people")
public class People implements Serializable{
private static final long serialVersionUID = 1L;
private Integer id;
private String name;
private String sex;
private Integer age;
public People() {
}
public People(String name, String sex, Integer age) {
super();
this.name = name;
this.sex = sex;
this.age = age;
}
@Id @GeneratedValue
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(length=30)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(length=2)
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Column(length=3)
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((age == null) ? 0 : age.hashCode());
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((sex == null) ? 0 : sex.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;
final People other = (People) obj;
if (age == null) {
if (other.age != null)
return false;
} else if (!age.equals(other.age))
return false;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (sex == null) {
if (other.sex != null)
return false;
} else if (!sex.equals(other.sex))
return false;
return true;
}
}
package cn.ldf.service.impl;
import java.util.List;
import javax.ejb.Local;
import javax.ejb.Remote;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import cn.ldf.bean.People;
import cn.ldf.service.PeopleService;
@Stateless
//定义为无状态bean
@Remote(PeopleService.class)
@Local(PeopleService.class)
public class PeopleServiceBean implements PeopleService {
@PersistenceContext(unitName = "itcast")
EntityManager em;
// unitName 为持久化单元名字
@Override
public void delete(Integer id) {
// TODO Auto-generated method stub
em.remove(em.getReference(People.class, id));
}
@SuppressWarnings("unchecked")
public List<People> getAllPeople() {
// TODO Auto-generated method stub
// 面向对象的语句 这里的People为实体的名称
return em.createQuery("select 0 from People 0").getResultList();
}
public People getPeopleById(Integer id) {
// TODO Auto-generated method stub
return em.find(People.class, id);
}
public void save(People p) {
// TODO Auto-generated method stub
// 对新建状态的保存
em.persist(p);
}
public void update(People p) {
// TODO Auto-generated method stub
// 必须是游离状态的时候才能调用这个方法
em.merge(p);
}
}
package cn.ldf.service;
import java.util.List;
import cn.ldf.bean.People;
public interface PeopleService {
public void save(People p);
public void update(People p);
public void delete(Integer id);
public People getPeopleById(Integer id);
public List<People> getAllPeople();
}
build.xml
<?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
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
version="1.0">
<!-- 持久化单元,就是一些实体的集合 事务类型为本地事务 -->
<persistence-unit name="itcast" transaction-type="JTA">
<!-- JPA的驱动,就类似JDBC的驱动,是跟JPA实现对接的入口类 -->
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<jta-data-source>java:itcast</jta-data-source>
<properties>
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
<!--
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
<property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/>
<property name="hibernate.connection.username" value="root"/>
<property name="hibernate.connection.password" value="000000"/>
<property name="hibernate.connection.url" value="jdbc:mysql://127.0.0.1:3306/itcast?createDatabaseIfNotExist=true&useUnicode=true&characterEncoding=UTF-8"/>
-->
<property name="hibernate.hbm2ddl.auto" value="create"/>
<property name="hibernate.show_sql" value="true"/>
</properties>
</persistence-unit>
</persistence>
<?xml version="1.0" encoding="UTF-8"?>
<project name="helloWorld" basedir=".">
<property name="src.dir" value="${basedir}\src"/>
<property environment="env"/>
<property name="jboss.home" value="${env.JBOSS_HOME}"/>
<property name="jboss.server.config" value="default"/>
<property name="build.dir" value="${basedir}\build"/>
<path id="build.classpath">
<fileset dir="${jboss.home}\client">
<include name="*.jar"/>
</fileset>
<pathelement location="${build.dir}"/>
</path>
<target name="prepare">
<delete dir="${build.dir}"/>
<mkdir dir="${build.dir}"/>
</target>
<target name="compile" depends="prepare" description="编绎">
<javac srcdir="${src.dir}" destdir="${build.dir}">
<classpath refid="build.classpath"/>
</javac>
</target>
<target name="ejbjar" depends="compile" description="创建EJB发布包 ">
<jar jarfile="${basedir}\${ant.project.name}.jar">
<fileset dir="${build.dir}">
<include name="**/*.class"/>
</fileset>
<metainf dir="${src.dir}\META-INF"></metainf>
</jar>
</target>
<target name="deploy" depends="ejbjar" description="发布ejb">
<copy file="${basedir}\${ant.project.name}.jar" todir="${jboss.home}\server\${jboss.server.config}\deploy"></copy>
</target>
<target name="undeploy" description="卸载ejb">
<delete file="${jboss.home}\server\${jboss.server.config}\deploy\${ant.project.name}.jar"/>
</target>
</project>
把helloword项目放入jboss下。
建一个web项目,把jobss下的client目录下的jbossall-client.jar放入项目里(如果不行可以把client所有的jar包放入了)
把上面的ejb项目打成jar包,这个jar包不包含实现类。把它也放入web项目中
注意:如何你的程序下有资源文件jndi.properties文件的话,你最好能弄好它的位置,因为你要是用main方法运行的话那它就能找到这个文件。如何的用web运行的话,那你还把它把到src下,那么就打不到这个文件啊。就会报,XXXX类 name not boud int this context错误。而你用main函数运行时而不报错,像我下面那样写就一定不会有错的
package cn.ldf;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Properties;
import javax.naming.InitialContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import cn.ldf.bean.People;
import cn.ldf.service.PeopleService;
public class InsertPeople extends HttpServlet {
private static final long serialVersionUID = 1L;
public InsertPeople() {
super();
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doPost(request,response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String name=request.getParameter("name");
String agestr=request.getParameter("age");
String sex=request.getParameter("sex");
int age =Integer.parseInt(agestr);
PeopleService ps=null;
InitialContext ctx=null;
People p = new People();
try {
Properties pro = new Properties();
pro.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
pro.setProperty("java.naming.provider.url", "127.0.0.1:1099");
ctx = new InitialContext(pro);
ps = (PeopleService) ctx.lookup("PeopleServiceBean/remote");
//p.setId(1);
p.setName(name);
p.setSex(sex);
p.setAge(age);
ps.save(p);
System.out.println("添加成功!");
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
PeopleService ps=null;
InitialContext ctx=null;
People p = new People();
//jnp\://127.0.0.1\:1099
System.out.println("jnp\\://127.0.0.1\\:1099");
}
}
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
</head>
<body>
This is my JSP page. <br>
<form action="InsertPeople" method="post">
姓名 <input type="text" name="name"/><br>
年龄<input type="text" name="age"/><br>
性别<input type="text" name="sex"/><br>
<input type="submit" value="提交"/>
<input type="reset" value="重置"/>
</form>
</body>
</html>
分享到:
相关推荐
【标题】:“一个宠物商店,基EJB3分布技术开发” 这个项目是一个使用EJB3(Enterprise JavaBeans 3)技术构建的分布式应用程序,主要针对的是宠物商店的业务场景。EJB3是Java EE(Java Platform, Enterprise ...
EJB集群是EJB技术的一个重要特性,它允许EJB容器(如JBOSS)在多台服务器上分布和复制EJB实例,以实现高可用性和负载均衡。 在给定的示例中,我们看到一个简单的无状态会话Bean(Stateless Session Bean)`...
- **对象分布**:EJB支持分布式环境下的对象通信,使得部署于不同位置的组件能够相互协作。 - **便携式组件基础架构**:EJB的设计使得组件可以在不同的运行环境中被重用,而无需修改代码或配置。 - **对象持久化**...
RM-ODP开放分布处理参考模型为中间件开发设定了标准。 2.1 J2EE平台 J2EE是企业级应用的规范,涵盖了多种技术,如JavaScript、Ajax、JSP、Servlet、JavaBean、EJB、JMS、JDBC、JTA等,以及各种框架,如Struts、...
- **分布性**:EJB支持在不同机器上的组件间通信,使得应用可以跨越多个服务器部署。 - **事务处理能力**:EJB内置了对事务的支持,确保了数据的一致性和完整性。 - **持久化能力**:EJB支持对象的状态被持久化到...
- **EJB 定义**: Enterprise JavaBeans (EJB),即企业级Java Bean,是一种用于开发、部署服务器端分布式组件的标准(规范),它采用了Java语言进行编写。 - **EJB 的发展历程与背景**: - **早期系统架构**: - **...
在Java企业级应用开发中,EJB(Enterprise ...通过EJB的事务管理和分布能力,结合Hibernate的ORM特性,可以简化数据访问层的实现,提高开发效率。在实际项目中,遵循最佳实践和规范,可以确保系统的稳定性和可扩展性。
5. **分布性**:EJB可以在分布式环境中透明地运行,允许跨网络的通信和数据共享。 6. **持久化**:通过EJB实体Bean或JPA实现数据的持久化,简化数据库操作。 ### EJB的案例 假设我们有一个在线购物系统,可以使用...
6. **远程接口**:EJB可以通过RMI(远程方法调用)提供远程访问,使得分布在不同网络位置的应用程序能够调用服务器上的EJB方法,实现了分布式计算。 7. **设计模式**:书中也涵盖了使用EJB进行系统设计时的一些最佳...
EJB3是EJB规范的一个版本,它引入了许多改进,使得开发更加简单且更符合Java编程习惯。 标题“JNDI调用分布式EJB3 通用接口”意味着我们将探讨如何使用JNDI来查找和调用分布在不同节点上的EJB3组件。EJB3中的一个...
EJB(Enterprise JavaBeans)和RMI(Remote Method Invocation)是Java开发中两个重要的概念,尤其是在J2EE(Java 2 Platform, Enterprise Edition)环境中。这两个技术都是Java平台为企业级应用提供服务的核心组件...
【EJB学习笔记、运行机制】 ...总之,EJB是Java企业级开发的重要组成部分,它提供了丰富的服务和管理功能,简化了开发流程,促进了组件化和模块化的软件设计,从而在大型分布式系统中发挥着关键作用。
这层间接性确保了EJB实例的安全隔离和分布透明性。 #### 结论 EJB作为Java企业级应用开发的重要组成部分,其规范不仅简化了复杂系统的开发流程,还确保了组件的可移植性和服务的一致性。通过深入理解EJB的体系结构...
【EJB分布式文档】主要探讨了使用Enterprise JavaBeans(EJB)进行分布式开发的方法和解决在开发过程中可能遇到的问题。EJB是一种Java EE标准,它提供了服务器端组件模型,用于构建可扩展、安全且事务处理的分布式...
7. **分布式计算**:EJB允许组件在不同的网络节点上分布,实现跨服务器的通信和负载均衡。 8. **EJB 3.x及之后的简化**:自EJB 3.0版本起,EJB规范变得更加轻量级,减少了大量XML配置,引入了注解,使得开发更简洁...
**企业级JavaBeans (EJB) 基础** ...从EJB 3.0开始,它变得更加易用,降低了开发复杂性,但仍保留了强大的功能,如事务管理、安全性、可伸缩性和分布性。学习EJB基础,对于理解和开发企业级Java应用至关重要。
EJB 3.0是EJB规范的一个重要版本,它引入了许多改进,使得EJB的开发变得更加简单,更接近普通Java对象(POJOs)的编程模型。以下是关于EJB 3.0的一些关键知识点: 1. **无状态会话Bean(Stateless Session Beans)*...
EJB支持分布式计算,可以在多个服务器之间透明地分布组件,提高系统的可伸缩性和可用性。 7. **EJB与RESTful服务** EJB可以通过JAX-RS(Java API for RESTful Web Services)实现RESTful服务,使EJB组件能够对外...