Transcript 幻灯片 1 - 广东轻工职业技术学院 专业建设

oy Java!
J2EE 平台
oy Java!
 为什么引入J2EE？
 什么是J2EE？
 J2EE的组成
内容
oy Java!




主机系统或单层结构
数据访问、表示和业务逻辑在一个应用中
功能紧紧耦合在一起
代码复用、代码可维护性、和代码的修改十分困难。
不是分布式的，不具有可伸缩性。
oy Java!
传统的客户/服务器：“胖”客户端
胖客户端：
表示逻辑
业务逻辑
业务数据模型
通讯
Fat client
Fat client
 功能集中，不利于更新和维护；
 数据模型“紧耦合”在每一客户端
– 数据库结构改变将导致全体客户端改变
 任何一点更新要对每一客户端进行部署
 数据库连接是针对每一客户端的
– 伸缩困难
 原始数据通过网络传递：加重网络负担
oy Java!
构件(component)与中间层开发
 两个转变：
– 计算模式上：网络计算（Network Computing)
– 生产模式上：基于构件的开发（Component-based Dev)
 二者的结合：
服务器端中间层构件的开发
oy Java!





在企业级应用开发中的问题
分布式
可移植
面向Web体系
可装配
满足企业计算要求
– 一致性
– 事务性
– 安全性
 好的特性
– 可伸缩
– 可扩展
– 易维护
oy Java!
为什么需要J2EE
 分布式、可移植构件的框架
 简化服务器端中间层构件的设计
 为构件与应用服务器提供标准API
oy Java!
J2EE
 Open and standard based platform for developing,
deploying and managing n-tier, Web-enabled,
server-centric enterprise applications
 开放的、基于标准的平台，用以开发、部署和管理N
层结构、面向Web的，以服务器为中心的企业级应用。
oy Java!
J2EE架构
oy Java!











J2EE 1.2中的API与技术
Java 2 SDK, Standard Edition
RMI/ IIOP
JDBC™
Java Messaging Service
JNDI
Servlet
JavaServer Pages™
JavaMail
JavaBeans™ Activation Framework
Enterprise JavaBeans
Java Transaction API
1.0
1.2
1.0
2.0
1.0
1.2
2.2
1.1
1.1
1.0
1.1
oy Java!
文档资源
 Sun Techdays 文档
 Designing Enterprise Applications with the Java 2
Platform, Enterprise Edition，Nicholas Kassem and the
Enterprise Team（jbp-1_0_1b-doc.pdf)
 http:// java. sun. com/ j2ee
 http:// java. sun. com/ products/ ejb
 http:// java. sun. com/ products/ jsp
 http:// java. sun. com/ products/
servlet
 http:// java. sun. com/ products/ jndi
oy Java!
第一章 JDBC
oy Java!
引言：
Client
Database
考虑以下二个问题:
 Java应用不可直接与数据库通信。因为DBMS只能
理解SQL语句，而不能理解JAVA语言的语句。
 当前市场上DBMS产品颇多，JAVA程序应能够和
任何类型的数据库通信。
oy Java! 一.JDBC的特性：
 JDBC的本质就是一些API，针对SQL兼容的关系型数据
库提供了一组通用的数据库访问方法。
 我们将讨论JDBC 2.0 API（最新版本3.0），分为两大部
分：
a）JDBC 核心API，定义在java.sql.*包中
b）JDBC 扩展包API，定义在javax.sql.*包中
oy Java!
JDBC驱动器
 JDBC如何来解决不同类型数据库厂商的问题。
Java
应用
JDBC
API
JDBC
驱动器
DBMS
oy Java!
JDBC驱动器类型：
 类型1－JDBC-ODBC Bridge
Database
Java Application
JDBC
API
JDBCODBC
Bridge
ODBC
API
ODBC
Driver
oy Java!
 类型2－部分采用java，另一部分采用本地驱动器
Database
Java Application
JDBC
API
JDBC驱动器
具体于
厂商的
API
oy Java!
类型3－纯的java驱动器
Database
Java Application
JDBC
API
JDBC驱动器
oy Java!
二.JDBC 2.0 API
2.1) java.sql包中包含由J2SE提供的类和由驱动器厂商实现
的接口。
2.1.1)
1)Connection对象-代表与数据库的连接
a）加载数据库驱动器
在jdbc中,用java.lang.Class对象来加载
try{
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
}
catch(Exception e)
{
System.out.println(e);
}
oy Java!
b) 打开连接
JDBC URL:提供了一种标识数据库驱动器方式
protocol:<subprotocol>:<subname>
protocol:jdbc为协议,在JDBC中它是唯一的允许协议
subprotocol:子协议用于标识一个数据库驱动器,或者是一个数据库的
连接机制名字,由数据库驱动器提供商来选择
subname:子名称的语法具体于驱动器
例如:
url=jdbc:odbc:pubs
得到数据库连接
Connection con=DriverManager.getConnection(url,”sa”,””);
oy Java!
try{
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
String url=”jdbc:odbc:pubs”;
Connection
con=DriverManager.getConnection(url,”sa”,””);
}
catch(Exception e)
{
System.out.println(e);
}
oy Java!
2)Statement对象-查询数据库
try{
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
String url=”jdbc:odbc:pubs”;
Connection con=DriverManager.getConnection(url,”sa”,””);
Statement stat=con.createStatment();
stat.executeQuery(“select * from titles”);
}
catch(Exception e)
{
System.out.println(e);
}
oy Java!
3)ResultSet对象-封装执行结果
try{Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
String url=”jdbc:odbc:pubs”;
Connection
con=DriverManager.getConnection(url,”sa”,””);
Statement stat=con.createStatment();
ResultSet result=stat.executeQuery(“select * from titles”);
}
catch(Exception e)
{System.out.println(e);}
oy Java!
为了读取ResultSet中的结果,可用游标在结果集中滚动。
getXXX()方法检索ResultSet中的数据
while(result.next())
{
System.out.println(result.getString(2));
}
oy Java!
MetaData接口
a）DatabaseMetaData接口－数据库结构信息
b）ResultSetMetaData接口－结果集的结构信息
oy Java!
2.1.2)PreparedStatment 对象－－用于发送带有一个或多个输入参
数（ IN 参数)的 SQL 语句
考察:
select * from titles where title_id=?
首先,创建PreparedStatment对象
stat=con.prepardStatement(“select * from titles where
title_id=?”)
其次,传递参数
stat.setXXX(1,”001”);
另外: 用不同的参数多次执行同一个SQL语句,PreparedStatment
对象编译只需一次,效率更高.
oy Java!
2.1.3)把SQL类型转换成JAVA类型
JDBC类型
SQL类型
Java类型
ARRAY
ARRAY
Java.sql.Array
BIGINT
BIGINT
Long
BLOB
BLOB
Java.sql.Blob
CLOB
CLOB
Java.sql.Clob
DATE
DATE
Java.sql.Date
FLOAT
FLOAT
Double
JAVA_OBJECT
没有映射
Object
VARCHAR
VARCHAR
String
NULL
NULL
NULL
TIME
TIME
Java.sql.Time
oy Java!
2.1.4)事务支持
 JDBC 驱动程序都支持事务
 下面的方法用于操作，回滚，提交事务：
public void setAutoCommit(boolean autoCommit)
throws SQLException
public void commit() throws SQLException
public void rollback() throws SQLException
oy Java!
2.1.5）批量更新
 允许把多条更新语句（insert,update,delete）在一个请求
中提交给数据库。
 方法：
addBatch()
executeBatch()
 优点：
大量语句的批量执行可在性能上带来相当大的提高
oy Java!
2.1.6)可滚动的和可更新的结果集
JDBC 2.1提供了更为灵活的访问结果集的方式
 可滚动的结果集
 滚动相关性
 可修改的结果集
(1)更新 updateXXX()方法
(2)删除
deleteRow()方法
(3)插入
result.moveToInsertRow();
result.updateString(1, "100050");
result.updateFloat(2, 1000000.0f);
result.insertRow();
oy Java!
2.1.7连接池
连接池
创
取
返
建
得
回
一
一
连
个
个
接
池
连
接
JDBC应用程序
JDBC驱动器
DB
oy Java!
2.2)JDBC 扩展包API
 javax.sql.DataSource代替了静态的java.sql.DriverManager,
作为创建数据库连接的主要方式
JNDI服务
2.查找
Datasource对象
JDBC应用程序
3.从
Datasource
中取得连接
连接
4.使用connection
对象访问数据
1.绑定
Datasource对象
应用程序器
的基本框架
DataSource
JDBC驱动器
oy Java!
第二章 JavaBean
oy Java!
一 JavaBean 引言
 1.1 为什么要JavaBean
oy Java!
一个计算器的例子:
oy Java!
 1.2 bean的定义:
Bean是一个基于Sun公司的JavaBean规范的,可在编程
工具中被可视化处理的可重用的软件组件.
提示:你可以在软件商店里看到特性齐全的Bean出售,或者在
www.gamelan.com和IBM的http://alpaworks.ibm.com发现免费的
Beans.
eg:图表控件,拼写检查,余额生成
oy Java!
1.3 JavaBean编写过程:

a)三个开发阶段:构造阶段,内建阶段,执行阶段
b) 每个JavaBean包含的3个基本元素:
I)属性
II)方法
III)事件
eg:一个流行的图表控件具有:
60个属性 47个事件 14个方法 178页的文档
oy Java!
c)JavaBeans的规格说明




一个Java对象具有
以下特性就是一个
JavaBean:
定制
持久性
通信
反省
简单的说:
 必须有get/set方法
 不能有main函数
 如果有构造函数,则不
能有参数
oy Java!
一个简单的bean:
public class Bean1 {
private String str;
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
}
oy Java!
d)JavaBean的类型
 控件Bean
 容器Bean
 不可见的运行Bean
oy Java!
二 Bean的编程
2.1 编程环境
----Bean Development Kit(BDK)
oy Java!
2.2 创建Bean
 1) 构造Bean
import java.awt.*;
import java.io.Serializable;
public class SimpleBean extends Panel
implements Serializable {
private Color color = Color.green;
public Color getColor() {
return color;
}
public void setColor(Color newColor) {
color = newColor;
repaint();
}
public void paint (Graphics g) {
g.setColor(color);
g.fillRect(20,5,20,30);
}
public SimpleBean() {
setSize(60,40);
setBackground(Color.red);
}
}




Serializable接口
color属性
set/get方法
paint()方法
oy Java!
2) 测试和编辑Bean
 编译源代码,生成.class文件
 打包成jar文件
A)创建manifest文件
manifest文件包含所有的类文件以及指出JavaBean.
Name: SimpleBean.class
Java-Bean: True
B）创建jar文件
jar cfm SimpleBean.jar manifest.tmp SimpleBean.class

装载jar到BDK
oy Java!
稍等一下.....
在此列基础上,增加一个属性logo,怎么做?
oy Java!
 定义私有变量logo
private String logo;
 set/get方法
public String getLogo() {
return logo;
}
public void setLogo(String newLabel) {
logo = newLabel;
}
oy Java!
2.3 处理JavaBean中的事件
1）自定义事件类
import java.util.*;
public class NumEvent extends EventObject
{
public int num1,num2;
public NumEvent(Object o,int num1,int num2)
{
super(o);
this.num1=num1;
this.num2=num2;
}
}
oy Java!
2）监听器（接口）
import java.util.* ;
public interface NumEnteredListener extends EventListener
{
public void arithmeticPerformed(NumEvent mec);
}
oy Java!
//NumberBean
public class NumberBean extends JPanel implements ActionListener
{
JLabel l1=new JLabel("Enter the First Number: ");
JLabel l2=new JLabel("Enter the Second Number:");
JTextField tf1 = new JTextField(10);
JTextField tf2 = new JTextField(10);
JButton ok = new JButton("Calculate");
boolean addListernered;
public NumberBean()
{
setLayout(new FlowLayout());
add(l1);
add(tf1);
add(l2);
add(tf2);
add(ok);
ok.addActionListener(this);
}
oy Java!
NumEnteredListener mel;
//3)注册
public void addNumListener(NumEnteredListener mel)
{
addListernered=true;
this.mel = mel;
}
//4)移除
public void removeNumListener(NumEnteredListener mel)
{
addListernered=false;
mel=null;
}
oy Java!
NumEvent mec;
//5)触发
public void fireNumEvent(NumEvent mec)
{
mel.arithmeticPerformed(mec);
}
public void actionPerformed(ActionEvent ae)
{if (ae.getSource()==ok)
{
int f1=Integer.parseInt(tf1.getText());
int f2=Integer.parseInt(tf2.getText());
if(addListernered)
{
mec = new NumEvent(ok,f1,f2);
fireNumEvent(mec);
}}}}
oy Java!
 import java.awt.* ;
 import java.awt.event.* ;
 import javax.swing.*;
//消费者
 public class ArithmeticPerformer extends JFrame implements
NumEnteredListener
 {
 NumberBean meb;
 public ArithmeticPerformer()
 {

super("Arithmetic Calculations");

meb = new NumberBean();

getContentPane().add(meb);

meb.addNumListener(this);
 }
oy Java!
 public void arithmeticPerformed(NumEvent mec)
 {

int result=mec.num1*mec.num2;

String temp="The result of adding the numbers is:
"+String.valueOf(result);

JOptionPane.showMessageDialog(this,temp);
 }

public static void main(String a[])
 {

ArithmeticPerformer mec = new ArithmeticPerformer();

mec.setSize(300, 300);

mec.setVisible(true);
 }
 }
oy Java!
2.4 Bean的属性
• 一般属性
• indexed属性
－－设置或访问数组属性
• Bound属性
－－值变化通知给其他beans的Bean属性
• Constrained属性
－－阻止别的bean值属性值变动的属性
oy Java!
Bound属性
要实现一个关联属性,必须实现两个机制
1)无论属性值何时变化,Bean必须向所有注册监听器发送一
个PropertyChange事件
2)相关的监听器自我注册,实现方法:
public void addPropertyChangeListener(PropertyChangeListener listener)
public void
removePropertyChangeListener(PropertyChangeListener listener)
Java.Bean包中的PropertyChangeSupport管理着监听器
oy Java!
 Constraint属性
要更新限制属性值,Bean使用以下两步:
1)把变化属性值的意图通知给所有可否决变化监听器
使用VetoableChangeSupport类的fireVetoableChange方法
2)如果所有可否决变化监听器都没有抛出异常,那么就更新属
性值
注意:直到所有注册的可否决变化监听器都同意后才变化属
性值
oy Java!
2.5 定制Bean属性
提供Bean信息(方法,属性,事件)
 BeanInfo 接口
 SimpleBeanInfo 类
定制属性编辑器
 PropertyEditor 接口
 PropertyEditorSupport 类
oy Java!
2.6 反省
 反省是一个过程,考察bean的结构,并确定bean所支持的
属性,方法,事件
 Java.bean.Introspector类
public static BeanInfo getBeanInfo(Class beanClass) throws
IntrospectionException
 Java.bean.BeanInfo接口
oy Java!
第三章 Javascipt
oy Java!
oy Java!
2.Javascript的特点
 事件驱动
 平台独立
--Netscape 2.0,IE3.0
 基于对象
--内置对象,但不支持继承
 大小写敏感
oy Java!
 Java与javascript是完全不同的
Java
Javascript
程序设计语言
脚本语言
JVM
浏览器解释执行
OOP
OB
oy Java!
不同版本的 Netscape 浏览器所支持的不同版本的
JavaScript：
 JavaScript - Netscape 2.0
 JavaScript1.1 - Netscape 3.0
 JavaScript1.2 - Netscape 4.0
oy Java!
3.HTML中嵌套Javascript
 <html>
 <body>
 <br>
 <script language="JavaScript">

document.write("Hello JavaScript World!")
 </script>
 </br>
 </body>
 </html>
oy Java!
二 Javascript的基本构成
1.数据类型和变量
JavaScript 有六种数据类型。主要的类型有 number、
string、object 、 Boolean 类型、null 和 undefined。
JavaScript是一种对数据类型变量要求不太严格的语
言，所以不必声明每一个变量的类型，但在使用变量
之前先进行声明是一种好的习惯。可以使用 var 语句
来进行变量声明。
如：var men = true; // men 中存储的值为 Boolean 类型
oy Java!
2 语句
 条件和分支语句：if...else，switch
 循环语句：for， for...in，while,break,continue。
 对象操作语句：with，this，new。
with语句的语法如下：
with (对象名称){
执行语句
}
 注释语句：//，/*...*/
oy Java!
 3 函数
Function 函数名 （参数,变元）{
函数体;.
Return 表达式;
}
说明：
·函数由关键字Function定义。
·函数名：定义自己函数的名字。
·参数表，是传递给函数使用或操作的值，其值可以是
常量 ，变量或其它表达式。
oy Java!
4 事件驱动及事件处理
a)基本概念
采用事件驱动。它是在图形界面的下，使得一切输入
变化简单化。通常鼠标或热键的动作我们称之为事件，
而由鼠标或热键引发的一连串程序的动作，称之为事件
驱动。而对事件进行处理程序或函数，我们称之为事件
处理程序
b)事件处理程序
在javascript中对象事件的处理通常由函数(Function)担任。
c)事件驱动
javascript事件驱动中的事件是通过鼠标或热键的动作引
发的
oy Java!









<html>
<head>
<script language=“JavaScript">
function pushbutton() { alert("嗨! 你好"); }
</script>
</head>
<body>
<form>
<input type="button" name="Button1" value="Push me"
onclick="pushbutton()">
 </form>
 </body>
 </html>
oy Java!
三 基于对象的 Javascript
 用户自定义对象
 javascript内置对象
 浏览器对象
oy Java!
1.用户自定义对象
Javascript中的对象看成是属性和方法的集合
【构造对象函数】
function Product(name, num, price, shipping, quantity) {
this.name = name;
this.catalogNumber = num;
this.price = price;
this.shippingCost = shipping;
this.quantity = quantity;
}
this，它指向被创建的对象
var item1 = new Product("blender", "9003-2", 24.95, 2.50, 2);
oy Java!
【定义方法】
function Product(name, num, price, shipping, quantity) {
this.name = name;
this.catalogNumber = num;
this.price = price;
this.shippingCost = shipping;
this.quantity = quantity;
this.totalCost = totalCost;
}
function totalCost() {
return ((this.price + this.shippingCost) * this.quantity);
}
使用该方法:
var total = item1.totalCost();
oy Java!
JavaScript 中，对象和数组是一样处理的。可以按名称来
引用一个对象的任何成员（属性和方法）, 也可以按其
数组下标索引来引用。JavaScript 中下标的是从 0 开始
编号的，也可以用其名称来引用下标。
myobj = someobj.width;
myobj = someobj[3]; // [3] 是 "width" 的索引。
myobj = someobj["width"];
oy Java!
2.JavaScript的内置对象
a)String
b)Math
Math对象可以用来处理各种数学运算。其中既定义
了一些常用的数学常数，也定义了很多实现从三角到
代数各种运算的方法。
C)Date
JavaScript内置的Date对象可以用来处理所有有关日期
与时间的操作。
Date对象定义的方法：
mydate=new Date();
d)Array
数组定义的方法：
myarray=new Array() 或 myarray=new Array(7)
oy Java!
3.浏览器对象
navigator
navigator对象提供关于整个浏览器环境的信息，比如
浏览器的商标和版本
Window
代表了当前运行的脚本所嵌入的HTML文档所在的窗
口或者Frame。Window对象包含了Frame的列表、历史
记录列表、Document对象和Location对象。
oy Java!
第四章 Servlet
oy Java!
一 Servlet引言
1.Servlet的需要
检索信息
Servlet是部署在java的web服务器上的java程序,以
扩展和增强web功能
oy Java!
2.servlet的特征
 可移植的
 可扩展的
 持久的
 健壮的
oy Java!
oy Java!
二 java.servlet包





Servlet接口
提供创建servlet一般框架
public void init(ServletConfig config) throws
ServletException
public ServletConfig getServletConfig()
public void service(ServletRequest req, ServletResponse res)
throws ServletException, java.io.IOException
public java.lang.String getServletInfo()
public void destroy()
oy Java!
servlet的生命周期
oy Java!
Servlet 类(1)
oy Java!
Servlet 类(2)
GenericServlet,用于创建可与任何协议一起使用的servlet
oy Java!
创建servlet
oy Java!





















import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
public class HitCountServlet extends HttpServlet{
static int count;
public void init(ServletConfig config) throws ServletException
{ super.init(config) ;
count=1; }
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{ response.setContentType("text/html");
count++;
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head><title>HitCountServlet</title></head>");
out.println("<body>");
out.println("<p>You are user number "+String.valueOf(count)+ " visting out Web
site.</p>");
out.println("</body></html>"); }
public String getServelet()
{ return "BasicServlet information"; }
}
oy Java!
部署servlet
 Web包容器
--控制servlet的生命周期
 Web服务器
Web
浏览器
http应答
http请求
Web
服务器
J2EE WEB包容器
应用程序
应用程序
Servlet
Servlet
oy Java!
稍等一下:
如果servlet请求方法为post,应该怎么做?
oy Java!
oy Java!
servlet实例的个数及因此引发的问题
我们在实现自己的serlvet时需要考虑多线程的问题，
一般而言，servlet无状态(不要定义任何属性,只能定义
一些常量)
public class SomeHttpServlet extends HttpServlet {
HttpSession session;
...
}
这样的servlet在使用中一定会出现问题
oy Java!
三 servlet会话
http是一种无状态的协议





Cookies
URL重写
隐藏表单
HttpSession接口
SSL会话
oy Java!
1.Cookie
 Cookie的定义:
Cookie是一种服务器发送给客户的片断信息,存储在客户
环境中,并且在客户所有的对服务器的请求中都要发回它
服务器按照这种形式发送Cookie:
Set-Cookie:NAME=VALUE;Comment=COMMENT;Domain=域
名;Max-age=SECONDS;Path=路径;Version=1*DIGIT
oy Java!

Servlet的Cookie API
(1)创建Cookie
new Cookie(name,value)
(2)读取和设置Cookie值
getComment/setComment
getMaxAge/setMaxAge
getPath/setPath --获取/设置Cookie适用的路径
例如，someCookie.setPath(“/”)，此时服务器上的所有页面都可以接收
到该Cookie。
(3)在应答头中设置Cookie
Cookie可以通过HttpServletResponse的addCookie方法加入到SetCookie
应答头
(4)从客户端读入Cookie
Servlet调用request.getCookies()
oy Java!

1.
2.
优点:
实现容易
浏览器关闭时信息持久

缺点:
用户经常因为安全原因关闭cookie
oy Java!
2.URL重写
URL重写的时候包含会话信息
 优点:a)用户信息匿名 b)被广泛支持
 缺点:a)必须重写所有相应的URL b)浏览器关闭时信息
 方法:
public java.lang.String encodeRedirectURL(java.lang.String url)
3.隐藏表单
Serlvt规范中不使用这种方法
oy Java!
oy Java!
 会话对象驻留在服务器端
每个用户对应于一个HttpSession对象
会话对象类似于hashtable
 查看当前请求的会话对象
HttpSession session = request.getSession(true);
 查看和会话有关的信息
getAttribute("cartItem")
 在会话对象中保存数据
setAttribute("cartItem", cart)
oy Java!
5.安全套接字层会话(SSL)
SSL是一种运行在TCP/IP之上的加密技术,是用在
HTTPS协议中的技术。
加密连接
服务器和客户可以产生－－“会话密钥”，它是一种
用于加密和解密消息的对称的密钥
oy Java!
四.Servlet之间通信
Servlet A
客户
（浏览器）
别名
Servlet B
Servlet C
1.RequestDispatcher接口
2.Servlet上下文
oy Java!
第五章 JSP
oy Java!
一 介绍JSP
 Servlet能帮助我们作很多事,但是:
－－使用println()方法产生HTML
－－维护HTML页面
 JSP定义
a)基于文本的文档,返回给客户浏览器动态内容
b)包含HTML,XML,java代码和JSP tags,能访问JavaBean

1.
2.
3.
4.
JSP的优势
把静态和动态内容分离
支持软件组件重用
源代码变化时自动重编译
平台独立
oy Java!
几种技术的比较
ASP与JSP
特色
ASP
JSP
可以在各种server上使用
否,(主要是IIS)
可应用在多种平台上
否
跨平台的重用组件
是(COM)
开发规格与其他厂商合 否
作
ODBC,ADO
与数据库连接
是(Apache,IIS,Netscape)
是
是(JavaBean,EJB)
是(Weblogic,
IBM,Oracle,Netscape)
JDBC
定位
Java规格书
Microsoft产品
Servlet与JSP
 Servlet在服务器上执行和解释浏览器的请求，把动态的内容混合静
态的内容以产生HTML
 JSP,把静态和动态内容分离
oy Java!
JSP工作原理
 JSP文件以.jsp扩展形式存储在服务器上
 JSP包容器（也叫JSP引擎）第一次加载JSP时，编译
并加载到serlet容器中
 从客户来的后续请求都由这个servlet处理
oy Java!
oy Java!
JSP的生命周期
oy Java!
第一个JSP页面：
 <html><body>
 <% java.util.Date date=new java.util.Date();%>
 <H1>今天是：<%= date %></H1>
 </body></html>
oy Java!
oy Java!
二 创建JSP页面
1 JSP基础知识


JSP



directive (指令)
scripting （脚本）
action （动作）
Template data ：除JSP语法外，JSP引擎
不能解读的东西
oy Java!
 1）在JSP中使用的directive(指令)主要有三个：
– page指令(定义页面属性)
– include指令(指出编译JSP页面是要插入的文件)

在JSP的任何地方，以任何顺序，一个页面可以包
含任意数量的page指令
– taglib指令
oy Java!
2)Scripting（脚本）包括三种类型
 <%！declaraction %>
 <% scriptlet %>
 <%= expression %>
oy Java!
3)action（动作）
标准的动作类型有：
 <jsp:useBean>
调用javabean的动作
 <jsp:setProperty>
 <jsp:getProperty>
 <jsp:param>
 <jsp:include>
 <jsp:forward>：请求被传送到另外的JSP或servlet上
 <jsp:plugin>
oy Java!
Eg：
<jsp:forward page="second.jsp">
<jsp:param name="customer" value="stella"/>
</jsp:forward>
oy Java!
 <jsp:usebean>标签要包含几个参数，它们分别说明：
该JavaBean所从属的类
该JavaBean实例的名称
该JavaBean的作用域（生命周期）

Eg：
<jsp:useBean ID="ssb" SCOPE="session"
CLASS="jsp.beans.samples.SuperSimpleBean"/>
<jsp:setProperty NAME="ssb" PROPERTY="counter" VALUE="2"/>
<h2>Counter: <jsp:getProperty NAME="ssb"
PROPERTY="counter"/></h2>
oy Java!
对象的范围
oy Java!
2.JSP隐含对象
 request 客户端请求，包括从GET/POST请求传递过来的参
数
 response 网页传回客户端的反应
 pageContext 在此管理网页属性
 session 与请求关联的会话
 application 代码片段的运行环境
 out 传送响应的输出流
 config 代码片段配置对象
 page JSP网页本身
 exception 有错的网页中未被捕获的例外
oy Java!
关于同步
 <%@ page isThreadSafe="true" %>
oy Java!
三 JSP客户标签
oy Java!
企业级应用特点及需求
 特点
--涉及外部资源多
--事务密集
--跨越intranet和internet
 需求
--高可用性
--安全性
--可扩展性
oy Java!
 什么时候使用tags
oy Java!







<jsp:useBean>
<jsp:setProperty>
<jsp:getProperty>
<jsp:param>
<jsp:include>
<jsp:forward>
<jsp:plugin>
标准动作tags
oy Java!
客户动作
a）扩展功能
b）一致性
c）封装
－－重用
－－维护
d）分离JSP页面的内容和行为
－－代码开发者创建tag
－－页面开发者开发内容
oy Java!
使用标签库
标签库的类型
简单标识 <book:welcome/>
带属性的标识 <book:welcome user=“normal”/>
带body的标识
<book:login>
<html>
<book:welcome user=“normal”/>
</html>
</book:login>
oy Java!
Attribute Type
Conversion on String Value
boolean or Boolean
java.lang.Boolean.valueOf(String
byte or Byte
java.lang.Byte.valueOf(String)
char or Character
java.lang.Character.valueOf(String)
double or Double
java.lang.Double.valueOf(String)
int or Integer
java.lang.Integer.valueOf(String)
float or Float
java.lang.Float.valueOf(String)
long or Long
java.lang.Long.valueOf(String)
oy Java!
Tags的实现
 标识句柄类
 标识库描述文件
 Jsp文件
oy Java!
Tags工作方式
oy Java!
• JSP在javax.servlet.jsp.tagext 中定义了tag，bodyTag，我们可以直接
或间接引用这些接口
类型
简单标识
可继承的基类
TagSupport
可重载的方法
doStartTag
doEndTag
带属性标识
TagSupport
release
doStartTag
doEndTag
Set/get Attribute
带标识体标识
TagSupport
（不对标识体处理）
release
doStartTag
doEndTag
release
带标识体标识
（对标识体处理）
BodyTagSupport
doStartTag
doEndTag
Release
doInitBody
doafterBody
oy Java!
oy Java!
























import java.io.IOException;
import java.util.Date;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;
public class TestTag extends TagSupport
{
public int doStartTag() throws JspTagException
{
return EVAL_BODY_INCLUDE;
}
public int doEndTag() throws JspTagException
{
String dateString=new Date().toString();
try
{
pageContext.getOut().write("Hello everybody</br>");
pageContext.getOut().write("Date: " + dateString + "<p/>");
}
catch(IOException ee)
{
throw new JspTagException("Error encountered");
}
return EVAL_PAGE;
}
}
oy Java!
JSP文件中使用tag
 <%@ page import="TestTag" %>
 <%@ taglib uri="TestTaglib.tld" prefix="first" %>











<HTML>
<HEAD>
<TITLE> Using custom tags</TITLE>
</HEAD>
<BODY>
Hello, Welcome!
<first:welcome>
</first:welcome>
</BODY>
</HTML>
oy Java!
TLD文件
 <?xml version="1.0" encoding="ISO-8859-1" ?>
 <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag
Library 1.1//EN"
 "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">
 <taglib>

<tlibversion>1.0</tlibversion>

<jspversion>1.1</jspversion>

<shortname>first</shortname>

<info>Example of a tag</info>

<tag>

<name>welcome</name>

<tagclass>TestTag</tagclass>

<bodycontent>JSP</bodycontent>

<info>An example</info>

</tag >
 </taglib>
oy Java!
oy Java!
oy Java!
总结
 Tag是jsp1.1版本之后的重要特征
 标准的tag库被广泛应用
 客户标签 使得:
–分离JSP页面的内容和行为
– 封装动作以重用
– 创建客户标识语言
• 组件化表示层
oy Java!
JSP设计基础
我们的目标是，在WEB应用程序设计中，必须分离应用
逻辑和表示。针对JSP设计有两种这样途径：
 以JSP为中心，请求被直接发送给JSP页面
 以servlet为中心
Tips:
1)JSP设计关键在于包含尽可能少的”java”成分
2)形成输出模板(表示组件)
oy Java!
以页面为中心
oy Java!
以servlet为中心
oy Java!
以页面为中心的例子
oy Java!
以servlet为中心的例子
oy Java!
第六章 RMI
oy Java!
 分布式应用
 RMI的概念与示例
 总结和参考文献
内容
oy Java!
一 分布式
对于绝大多数传统的（非分布式）Java 编程，构成
程序的所有对象都在同一台机器上，并在同一个进程
或 JVM 中出现。
Object
Object
oy Java!
分布式编程有哪些不同之处
 在分布式计算中，程序模块可以在同一台机器的不
同进程中，也可以在不同机器中
oy Java!
三层分布式对象架构
 客户端：业务数据模型与UI分开，更“瘦”
 业务逻辑在中间层，成为“对象服务”。
 中间层可以处理多客户端，通过：连接池，多线程，
对象一致性处理
 数据库服务器端只作数据处理
 分布式计算用来利用多个系统的组合计算能力，以
便比在单个系统上更有效或更快地解决问题
oy Java!
为什么 Java 平台适合分布式对象编程
因为以下几点原因，所以 Java 平台是分布式编程的理想工具：
 Java 平台为所有平台实现定义了基本类型（如整数和浮点）的一致
大小和格式，还定义了字节排列假设。这意味着，由于传送机制在
与另一方交谈时不必进行转换或调整，因此能使该机制变得极其简
单。这也有性能方面的优势
 主要的 Java 分布式编程 API — RMI，是该语言标准版的一部分
 Java RMI 接口的使用相当简便
 Java 参数可以按引用（远程）或按值（序列化）传递。
 Java 平台的普及以及把它当作许多编程课程中的教学语言，这些都
意味着对于该环境有广泛的编程技巧资源可供使用
 最后，Java 平台还支持许多用于分布式编程的其它技术，如套接字
编程模型
oy Java!
远程方法调用--RMI
 RMI是一种使用TCP/IP套接字方式的分布式
系统
oy Java!
 RMI服务器
 RMI客户端
 RMI注册表
RMI应用的构件
oy Java!
开发RMI应用
1.定义远程接口--远程接口类
import java.rmi.*;
public interface rmiHello extends java.rmi.Remote
{
String fn() throws RemoteException;
}
oy Java!
2.实现服务器远程方法—服务器类
import java.rmi.*;
import java.rmi.server.*;
public class rmiHelloImpl extends UnicastRemoteObject implements
rmiHello
{ public rmiHelloImpl() throws RemoteException
{
super();
}
public String fn()
{
return "Hello RMI";
}
}
创建 rmiHelloImpl类的stub和skeleton：
提示符: rmic rmiHelloImpl
oy Java!
3.RMI注册表
import java.io.*;
import java.rmi.*;
import java.rmi.server.*;
public class Server {
public static void main(String s[])
{
try{
//创建与安装安全管理程序
System.setSecurityManager(new RMISecurityManager());
//实例化远程对象
rmiHelloImpl o=new rmiHelloImpl();
//远程对象注册到RMI注册表
Naming.rebind("rmi://localhost/rmiHello",o);
}
catch(Exception e) { System.out.print(e); }
}
}
oy Java!
 启动 RMI 注册表
start rmiregistry
 运行服务器程序
java Server
oy Java!
4.创建RMI客户
import java.rmi.*;
public class client
{
public static void main(String s[])
{
try{
rmiHello server=(rmiHello)Naming.lookup("rmi://localhost/rmiHello");
System.out.print(server.fn());
}
catch(Exception e)
{
System.out.print(e); }
}
}
运行客户端: java client
oy Java!
典型 RMI 应用程序的部署
oy Java!
文章、教程及其它在线参考资料

Damian Hagge 的“RMI-IIOP in the enterprise: An introduction to running RMI over IIOP”
（developerWorks，2002 年 3 月）简要介绍了 RMI-IIOP，还向您展示了如何构建和运
行一个简单的基于 Java 技术的 RMI-IIOP 客户机／服务器应用程序。

“RMI-IIOP Programmer's Guide”教您如何编写可以利用 IIOP 来访问远程对象的 Java
RMI 程序。RMI-IIOP frequently asked questions 也有助于您的理解。

Dave Bartlett 所写的由两篇文章组成的“IDL-to-Java mapping”第一部分
（developerWorks，2000 年 10 月）和第二部分（developerWorks，2000 年 11 月）描
述了如何将离散的组件接口定义转换成 Java 元素。

developerWorks 图书馆提供了关于 alternative client/server implementation techniques 及
其定义的简明摘要（2001 年 6 月）。

有关对 Java RMI 的深入讨论及对 CORBA 的一点探讨，请参阅由 O'Reilly 于 2002 年
出版的、William Grosso 所著的 Java RMI。

另一本 RMI 的实用参考大全是 Addison-Wesley 2001 年出版的、由 Esmond Pitt 与
Kathleen McNiff 合著的 Java.rmi: The Remote Method Invocation Guide。
oy Java!
CORBA(Common Object Request Broker)
CORBA简介
 是分布式应用开发框架,由OMG开发
 常见错误概念
1. CORBA并不是一种编程语言,而是一个规范
2. 不是特定厂家的产品
 使用CORBA的好处
-语言独立性
-位置透明性
-支持异构网络
-互操作性
oy Java!
第七章 Enterprise Java Bean
oy Java!
 EJB—J2EE的基石
 EJB的容器和服务器
 EJB的分类
– 会话bean
– 实体bean
 EJB的三个关键构件
 EJB的实现与部署
内容
oy Java!
N层计算模式的引入
 从1层到N层，得到的改进：
–
–
–
–
–
每一层可以被单独改变，而无需其它层的改变
降低了部署与维护的开销
资源（如连接）可以被缓冲和重复利用
提高了灵活性、可伸缩性，并使性能提高成为可能
瘦客户端的引入使Internet接入方便，而计算被集中至服
务器端
 仍然存在的问题：
– 对企业级应用开发人员的要求太高：熟悉分布式协议，
进行一致性事务处理，负载平衡，安全……
oy Java!
软件构件
“软件构件是实现良定义的接口及明确说明的上下文
相关性。一个软件构件可以被独立部署且服务于第三
方所做的组合.”
oy Java!
应用服务器
 应用服务器可以为服务器端构件提供：
– 一致性，事务处理与负载平衡
从而简化了编程工作
 但在J2EE之前，这些API是应用服务器相关的！
oy Java!
容器和构件
容器处理
• 一致性
• 安全性
构件处理
•表示
•JSP, Servlet, Applet
• 可获得性
•业务逻辑
• 可伸缩性
•EJB
• 事务性
•数据访问逻辑
• 分布性
•EJB
• 生命周期管理
• （持久性）
oy Java!
EJB—J2EE的基石
 Enterprise JavaBeans(EJB) 是：
Java服务器端服务框架的规范，软件厂商根据它来实现EJB服务器。
应用程序开发者可以专注于支持应用所需的商业逻辑，而不用担
心周围框架的实现问题。
 EJB容器是：
一个管理一个或多个EJB类/实例的抽象。它通过规范中定义的接
口使EJB类访问所需的服务。容器厂商也可以在容器或服务器中
提供额外服务的接口。
 EJB服务器是：
管理EJB容器的高端进程或应用程序，并提供对系统服务的访问。
EJB服务器也可以提供厂商自己的特性，如优化的数据库访问接
口，对其他服务（如CORBA服务）的访问。一个EJB服务器必须
提供对可访问JNDI的名字服务和事务服务支持。
oy Java!
EJB 服务器和容器
oy Java!
EJB 容器的责任
oy Java!
EJB的分类
 Entity Bean
Enterprise Bean
– Container-Managed Persistence Entity
Bean
– Bean-Managed Persistence Entity Bean
 Session Bean
- Stateful Session Bean
- Stateless Session Bean
 Message Driven Bean
oy Java!
例子:
客户查询帐户业务
SessionBean
EntityBean
帐户信息
余额
client
业务数据
SessionBean
业务过程
oy Java!
会话Bean？实体Bean？
会话bean
实体bean
 表示一个业务过程
 每一客户一个实例
 Short-lived：与客户生命同步
 表示业务数据
 在多个客户间共享实例
 Long-lived：与数据库中数据
同步
 持久的
 服务器崩溃后可重构
 总是事务性的
 暂态的
 服务器崩溃后丢失
 可以是事务性的
oy Java!
会话bean(Session Bean)
 相对生命较短（一般与客户同步）
 在EJB服务器崩溃时被删除
 不表示数据库中的数据，但可以访问数据
 作为一个客户的代表执行功能
 可以加入事务
oy Java!
会话bean(Session Bean)
 会话bean经常用于涉及多个实体bean的业务处理和控
制逻辑。
Session
Entity
Entity
Entity
oy Java!
何时使用会话Bean
 使用会话bean 对针对于某一客户的处理或控制对象
建模
 对工作流、任务和管理活动等建模（如订房、购物
车等）
 协调多个实体bean，控制实体bean之间的交互
 将业务应用逻辑从客户端转移到服务器端
oy Java!
第一个EJB
作为Bean的开发者，主要关注于三个构件：
 EJBHome 接口（扩展javax.ejb.EJBHome接口）：定义
了创建、查找EJB的方法。
 EJBObject接口（扩展javax.ejb.EJBObject接口）：定
义了在bean中实现的业务逻辑方法。
 Bean实现类（实现javax.ejb.EntityBean/SessionBean）：
实现业务逻辑。
oy Java!
会话Bean的实现—创建Home接口
<<interface>>
EJBHome
extends
<<interface>>
HelloHome
Create()
一般情况下，习惯将主接口的命名规则规定为<bean-name>Home，所以
我们把这个主接口类起名为HelloHome
public interface HelloHome extends javax.ejb.EJBHome
{
public Hello create()
throws java.rmi.RemoteException, javax.ejb.CreateException;
}
oy Java!
会话Bean的实现—创建远程接口
<<interface>>
EJBObject
extends
<<interface>>
Hello
getHello()
// business methods
public interface Hello extends javax.ejb.EJBObject
{
public String getHello() throws java.rmi.RemoteException;
}
oy Java!
EJB的实现—HelloBean的实现
import javax.ejb.*;
public class HelloEJB implements SessionBean{
public void ejbCreate(){}
public void ejbRemove(){}
public void ejbActivate(){}
public void ejbPassivate(){}
public void setSessionContext(SessionContext ctx){}
public String getHello() {
return new String(“Hello,EJB”);
}
}
oy Java!
从客户端看的EJB视图
Create
EJBHome
Glue
client
Bean
Business
Method
EJBObject
container
server
oy Java!
EJB部署
 部署到application server上
 JNDI(Java命名和目录接口)
a)命名服务:为给定的数据提供创建标准名字的服务
b)目录服务:是命名服务,包括描述由名字引用的对象的元
数据.(电话簿,DNS)
oy Java!
一个EJB 组件是没有任何运行界面的，所有组件的实例都被容器所管理，为了测试
这个Bean组件，需要写一段测试程序
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import javax.ejb.*;
import javax.naming.InitialContext;
public class HelloServlet extends HttpServlet{
public void service(HttpServletRequest req,
HttpServletResponse res) throws IOException {
res.setContenType("text/html");
PrintWriter out =res.getWriter();
out.println("<html><head><title>the first EJB</title></head>");
oy Java!
try{
InitialContext ctx=new InitialContext();
Object objRef = ctx.lookup("java:comp/env/ejb/Hello");
//主接口
HelloHome
home=(HelloHome)javax.rmi.PortableRemoteObject.narrow(
objRef,HelloHome.class);
//组件接口
Hello bean =home.create();
out.println(bean.getHello());
}
catch(Exception e){}
}
out.println("</body></html>");
}}
oy Java!
稍等一下:
 Home Objects,EJB Objects,Bean实例有何区别?
oy Java!
两种类型的会话bean
 无状态（Stateless）bean
–
–
–
–
表达一个无状态的服务（如列表，mail）
不存储用户相关信息，进行对请求的响应
暂态的
可用来构造响应频繁而简单的访问的bean池
 有状态（Stateful）bean
– 维护客户状态
oy Java!
开发会话Bean—无状态SessionBean
 什么是无状态Session Bean?
无状态Session Bean 每次调用只对客户提供业务逻辑，但不保存客户
端的任何数据状态但并不意味着stateless 类型的Bean 没有状态，而是这
些状态被保持在客户端，容器不负责管理.
oy Java!
无状态会话Bean生命周期
无状态Session Bean 有两种状态：存在或不存在。
oy Java!
编写一个stateless会话bean
 Home接口
负责控制一个Bean 的生命周期（生成、删除、查找Bean）
import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.ejb.EJBHome;
public interface StatelessDateHome extends EJBHome{
public StatelessDate create() throws
RemoteException,CreateException;
}
oy Java!
 开发组件接口(StatelessDate.java)：
当远程用户调用主接口类生成方法（create()）时，客户要得到一
个组件的远程引用，为这个Bean 的所有方法提供一个接口类
import javax.ejb.EJBObject;
import java.rmi.RemoteException;
import java.util.Date;
public interface StatelessDate extends EJBObject{
public int getDayInRange(Date lowerLimitDate,Date upperLimitDate)
throws RemoteException;
public int getDayForOlympic() throws RemoteException;
}
oy Java!
 开发Bean实现类(StatelessDateEJB.java)
包含了业务逻辑的所有详细设计细节
 import javax.ejb.*;
 import java.util.Date;
 public class StatelessDateEJB implements SessionBean{
 public void ejbCreate(){}
 public void ejbRemove(){}
 public void ejbActivate(){}
 public void ejbPassivate(){}
 public void setSessionContext(SessionContext ctx){}
oy Java!
















//计算两个日期之间相隔的天数
public int getDayInRange(Date lowerLimitDate,Date upperLimitDate)
throws Exception{
long upperTime,lowerTime;
upperTime=upperLimitDate.getTime();
lowerTime=lowerLimitDate.getTime();
if(upperTime<lowerTime)
throw new Exception();
Long result=new Long((upperTime-lowerTime)/(1000*60*60*24));
return result.intValue();}
//得到距离2008 年奥运会天数
public int getDayForOlympic() throws Exception {
Date olympic=new Date("2008/01/01");
Date today=new Date(System.currentTimeMillis());
return getDayInRange(today,olympic);
}}
oy Java!
 部署到应用服务器上,并测试
oy Java!
开发会话Bean—有状态SessionBean
 什么是有状态Session Bean?
有状态会话Bean(Stateful Session Bean)就是在客户引用期间维护Bean中
的所有实例数据的状态值，这些数据在引用期间可以被其他方法所引用，
其他客户不会共享同一个Session Bean的实例
典型的有状态会话bean:购物车
oy Java!
有状态Session Bean寿命周期
有状态会话Bean有四种状态：
 不存在
 方法现成
 事务中方法现成
 钝化
oy Java!
编写一个有状态Session Bean程序
 开发Home接口
import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.ejb.EJBHome;
public interface StatefulAccountHome extends EJBHome{
public StatefulAccount create(double fund)
throwsRemoteException,CreateException;
}
oy Java!
 开发组件接口
import javax.ejb.EJBObject;
import java.rmi.RemoteException;
public interface StatefulAccount extends EJBObject{
public void addFunds(double fund) throws RemoteException;
public void removeFunds(double fund) throws RemoteException;
public double getBalance() throws RemoteException;
}
oy Java!
 开发Bean实现类
import javax.ejb.*;
public class StatefulAccountEJB implements SessionBean{
public void ejbCreate(double fund)throws CreateException{
if (fund<0)
throw new Exception("Invalid fund");
this.fundBalance=fund;
}
public void ejbRemove(){}
public void ejbActivate(){}
public void ejbPassivate(){}
public void setSessionContext(SessionContext ctx){}
//实例变量，有状态的会话bean 将在组件池中维护这个实例的值
private double fundBalance;
oy Java!
















//向基金帐户增加基金
public void addFunds(double fund)throws Exception{
if (fund<0)
throw new Exception("Invalid fund");
this.fundBalance+=fund;}
//从基金帐户撤除部分基金
public void removeFunds(double fund)throws Exception{
if(fund<0)
throw new Exception("Invalid fund");
if(this.fundBalance<fund)
throw new Exception("the balance less than fund");
this.fundBalance-=fund;}
//得到基金帐户的余额
public double getBalance(){
return this.fundBalance;}
}
oy Java!
 部署到application server上
 开发测试程序
 实体bean（Entity Bean)
– 实体(entity) bean用来代表底层的对象，最常用的是用Entity Bean映
射关系数据库中的记录。在一个Entity Bean中，关系型数据库的字
段可以被一对一的映射到一个Entity Bean中，而表与表之间的关系
就可以看成是Entity Bean之间的关系。一个Entity Bean 的实例可能
会对应表中一个特定的行记录描述或者对于一个查询结果
业务数据模型
– 在持久存储中业务实体的对象视图
– 提供访问和操作数据的对象封装
– 支持多用户共享的数据
oy Java!
实体bean的持久性
 Bean-Managed Persistence（自管理的持久性）
– 优点：
• 开发者有完全的控制
• 无需复杂的提供商支持
– 缺点：
• 编码复杂
• 在改变时需要重新编码和部署
• 影响可移植性
 Container-Managed Persistence（容器管理的持久性）
– 优点：
• 提供商解决，可能会有更好的缓冲和性能
• 在部署描述符中进行改变即可
• 可移植性好
– 缺点：
• 对容器提供商的工具依赖性强
• 可能不易反映复杂的数据关系
oy Java!
EJB的事务处理
 EJB服务器的概念使平台提供商可以在可伸缩的、可
靠的、分布的事务服务方面提供增值服务。
 事务提供一个“all-all-nothing”的简单模型来管理工作，
即所有对象成功更新，所有工作成功提交，或者一个
对象失败而整个工作回滚。
 bean的客户可以以两种方式驱动事务：
– 在“部署描述符”中声明“公布的事务”(declarative
transactions)
– 使用用户事务API（JTA）来驱动事务
oy Java!
EntityBean的状态
Entity Bean 的寿命将超过创建它的客户端寿命，尽管客户在调用完一个
Entity Bean释放其资源后，Entity Bean的实例本身仍然存在于组件池中，
与映射的数据库记录保持持久性
oy Java!
Entity Bean的生命周期
oy Java!
开发CMP
 EJB结构的一个重要优点是EJB容器可以自动的为Entity Bean提供
各种有用的功能，负责实例的生成、装入、寻找、更新、删除等.
Bean 开发者不用编写一行对数据库操作的代码就可以完成对数
据库的基本操作
oy Java!
 CMP Bean如何连接到数据库？
--JDNI
 CMP Bean如何映射一个数据表？
--在设计一个CMP Bean时，Bean被固定映射一个实体表，表中
的每个指定字段被映射成bean 的一个public型类变量
 CMP Bean主键如何理解？
--只有Entity Bean 有主键，每个Entity Bean的实例代表一行记录，所以
就必须有一个主键来标识这个对象，以能够对其进行持久性操作
oy Java!
oy Java!
 开发Home接口

import java.util.Collection;

import java.rmi.RemoteException;

import javax.ejb.*;

public interface Cmp1BookHome extends EJBHome{

public Cmp1Book create(String bookid,String bookname,double bookprice)

throws RemoteException;

//按主键[bookid 字段]查找对象

public Cmp1Book findByPrimaryKey(String bookid)

throws FinderException,RemoteException;

//查找定价符合范围内的图书，将结果放到Collection 中

public Collection findInPrice(double lowerLimitPrice,double upperLimitPrice)

throws FinderException,RemoteException;}
oy Java!
 开发组件接口
import javax.ejb.EJBObject;
import java.rmi.RemoteException;
public interface Cmp1Book extends EJBObject{
public void setBookName(String bookname) throws RemoteException;
public void setBookPrice(double bookprice) throws RemoteException;
public String getBookName() throws RemoteException;
public double getBookPrice() throws RemoteException;
}
oy Java!
 开发bean实现类
import java.util.*;
import javax.ejb.*;
public class Cmp1BookEJB implements EntityBean{
public void ejbPostCreate(String bookid,String bookname,double bookprice){}
public void ejbLoad(){}
public void ejbStore(){}
public void ejbRemove(){}
public void unsetEntityContext(){}
public void setEntityContext(EntityContext context){}
public void ejbActivate(){}
public void ejbPassivate(){}
public String bookid; //映射bookid 字段
public String bookname; //映射bookname 字段
public double bookprice; //映射bookprice 字段
public void setBookName(String bookname){
this.bookname=bookname;}
oy Java!
public void setBookPrice(double bookprice){
this.bookprice=bookprice;}
public String getBookName(){
return this.bookname;}
public double getBookPrice(){
return this.bookprice;}
public String ejbCreate(String bookid,String bookname,double bookprice)
throws CreateException{
if(bookid==null)
throw new CreateException("The bookid is required");
this.bookid=bookid;
this.bookname=bookname;
this.bookprice=bookprice;
return null;}
}
oy Java!
oy Java!
开发BMP
 BMP Bean 要求所有的数据库操作都要由Bean实例完成
oy Java!
BMP Bean 要求所有的数据库操作都要由Bean实例完成
oy Java!
从客户端看的EJB视图
Create,
find
EJBHome
Glue
client
Bean
Business
Method
EJBObject
container
server
oy Java!
BMP映射表之间关系
 One-to-One Relationships
 One-to-Many Relationships
 Many-to-Many Relationships
oy Java!
oy Java!
oy Java!
oy Java!
oy Java!
j2ee的安全
1． 基于容器的安全
组件的安全是由他们各自的容器来负责的，这种安全逻辑和
业务逻辑相对独立的架构，使得企业级应用系统有更好的灵活性
和扩展性。
 声明性的安全性
 可编程的安全性
isCallerInRole (EJBContext)
getCallerPrincipal (EJBContext)
isUserInRole (HttpServletRequest)
getUserPrincipal (HttpServletRequest)
oy Java!
声明还是编程
 声明授权使EJB只关注业务逻辑
 编程授权比较灵活
Eg:处理银行帐户,经理的职权只能$1000之下,对于这种具
体的bean实例,声明无法处理
oy Java!
2．J2ee的验证模型
 验证
 授权
--角色
--用户和组
--访问控制
--映射
oy Java!
JavaBean Servlet
JSP
组件目的 通用组件体系结 实现
EJB
生成
请求/应答结 动态内容
构
封装
商务逻辑
运行等级 任意：客户端
服务器
服务器
典型服务 Java库
所有的servlet 持久化、事务
生命周期服务，
请求/应答
服务、脚本、 与安全性、连
标记扩展、应 接池、生命周
答缓存
期服务
构
服务器
（swing组件）
或者服务器端
（用于JSP页面）
oy Java!
回顾J2EE架构
oy Java!
J2EE应用的形式
oy Java!
几点体会
 1. 清晰、统一的概念
 2. 标准的接口，屏蔽底层的实现（JDBC，EJB…Java）
 3. 实现方式的多样化——trade-off与充分的选择权
– CMP，BMP
– JTA，
 4. 标准 vs. 扩展（语义的可理解性与可表达性）
oy Java!
JDO
 Java 数据对象（Java Data Objects (JDO)）是 Sun
Microsystems 的一项新技术
 Sun Microsystems 的 Java 数据对象（JDO）规范的目
标是向 Java 程序员提供面向对象持久数据急需的轻量
级的视图。
oy Java!


从较高层次的观点而言，使用 JDO 构建的应用程序由下列组件构成：
应用程序本身，它必须遵从 JDO 及其 API

一组业务对象，由以下两个类型构成：
– 瞬态业务对象，是不可持久存储的典型类
– 持久业务对象，是通过持久性管理器进行访问的类，它实现 JDO 的
PersistenceCapable 接口


持久性管理器，应用程序用来访问查询和事务

底层数据存储，持久性管理器用来对数据存储提供持久性和操作

类元数据，是描述持久类的关系和内容以及数据存储本身的 XML 文件
oy Java!
oy Java!
用于开发和部署的工具
 JDO 的开发工具使用类元数据来增强进行持久存储的
类，并构建支持那些类的表模式
 下图说明了 JDO 工具、数据库、类元数据以及可进行
持久存储的业务对象之间的关系。
oy Java!
软件需求
真正利用 JDO 规范，除 Java 2 平台软件以外，您还需
要用到一个大小适中的软件栈。首先，您需要 JDO 实
现，它通常与 JDO 规范上的 JDO 接口捆绑在一起。
您还需要支持它的关系数据库和 JDBC 驱动程序。
oy Java!
开发过程
用 JDO 进行开发的过程在许多方面类似于用 EJB
CMP 进行开发的过程，只不过它更轻量级一些。JDO
开发过程基本上有四部分：
 创建对象
 定义对象持久性
 创建应用程序
 部署应用程序
oy Java!
•
第一步是构建源代码（.java 文件）。理论上，
我们在这一步构建的对象源不必具有持久性。
• 下一步是确定什么类需要持久性。
• 类增强使构建过程与现有 IDE 集成很困难。
它也是用 JDO 进行开发的最有争议的方面。
修改 .class 文件是一种需好好研究的巧妙形
式，而且已开发了工具来协助直接进行类的
修改。尽管如此，要让您理解涉及创建与源
代码并不对应的 .class 文件的过程，仍很困
难。如果您使用诸如 Ant 那样的构建工具，
那么它会在幕后为您无缝地完成一切操作。
• 下一步是使用已增强的 .class 文件和 JDO 接
口来构建应用程序对象。尽管持久性对象不
使用 JDO API 和实现，但应用程序对象将使
用 JDO API 来控制持久对象的持久性、事务
以及查询机制。在应用程序中，要与之打交
道的主要部分是与特定数据源相关联的
PersistenceManager。
在构建应用程序时，我们还使用实际的数据
库模式。通常，JDO 实现包含一个工具，它
从前几步中创建的元数据和已增强的类文件
中自动创建数据库模式。
oy Java!
设计模式
oy Java!
Web应用程序的四种基本体系结构
 基本HTML
 包含JSP和servlet HTML
 Servlet和JavaBean组件的JSP页面
 Servlet，JSP页面，JavaBean和EJB
oy Java!