OSS报表系统 实训笔记
实训公司:中科天地 (王海格,老师超好)
Edited by Hen Egg ,Michelangelo
2005-2-21
8:00
JasperReport 开支
面向OO 应用服务器
Java 开源数据库
J2EE 需求分析
成绩：
课堂表现
项目
项目：
l Java平台
（1） （编程语言）开发环境（编译器）
（2） 部署环境（应用服务器）(JDK提供软件运行服务器及基本运行条件,在此基础上的开发需要配置) 目的是重用 (相关工具类)
（3） 运行环境（操作系统）
--JVM虚拟机是操作系统，即运行环境
--Java包 文件性
--垃圾收集 内存管理
--虚拟cpu (优势)
--线程
(1)+(2)+(3) 统一环境 简单开发
l Java语言
1． OO（最重要的特征）——很大的系统
2． 可移植性JVM (并不重要)
3． 分布式 JVM＋AppServer ——跨平台的系统
充分利用网络资源 跨地域跨国界
4． 安全性
Unix:安全性强类型
JVM内置强安全性 >Unix
关键业务
1． 人命
医疗 检查公安 重型工业 航空
2． 钱
银行
小结：
JVM是操作系统
Java是面向对象，分布式，安全的语言
PS:以上红字粗体部分为java关键技术
l Java虚拟机
1．垃圾收集
2．分布式 支持各种协议
3．多线程 线程管理
4．安全性
概念
模拟了一台计算机
功能
1．垃圾回收：
（在内存中）new的对象被装载到对象堆中
A = new Air;
new 出一个对象
调用构造函数，分配在对象堆中
返回一个引用
引用计数器++
当计数器减为0，该变量变成垃圾，从名单里除去。
垃圾收集作用：内存泄漏，空指针
垃圾收集机制：
后台精灵线程：当CPU出现闲置，调用该线程（优先级低） 要求CPU很快 有闲置的时候（用Java 先CPU再内存再次网卡）
2．提供运行时环境
操作系统的功能，负责调入代码，监督代码运行，帮助程序做输入输出，给程序提供一系列的支持
提供 CPU 寄存器 网络读写 文件系统 安全性
Class Loader 加载
Byte Code Verifier文件格式 语法 数组越界
校验4遍
Interpreter: 中间代码
JIT 即时编译 （快）（编译成本地代码）
安装jdk
配置环境变量
JAVA_HOME c:\j2sdk
Path ;%JAVA_HOME%\bin
CLASSPATH .;%JAVA_HOME%\lib
(ps:dos窗口不能自动刷新,改变环境变量后记得重新开)
14:00
类：
自定义
抽象
包：
package
把功能相近的类组合在一起
包是相对路径，相当于windows里的文件夹
import一个包 就引入了一个命名空间
import不等于include
没写包的话，系统默认一个包
Java代码三部分
1) package com.project.src
2) import java.io.*;
3) 类
一个文件里可以有多个类，但是有且只有一个public类
eg1
1. static void main(String []args)
Main method is not public
2. public void main(String []args)
Exception in thread "main" java.lang.NoSuchMethodError: main
main是整个程序的入口，不能用new出来 由于是static方法所以在载入内存时便直接执行 以此作为其他程序的入口 但main不是关键字
3. public static main(String []args)
TestHelloWorld.java:4: invalid method declaration; return type required
public static main(String[] args)
java规定必须有范围类型，没有返回值必须定义为void。但是构造函数不允许有返回类型。
4. public static void main(String []args) == static public void main(String []args)
访问控制符和修饰符位置任意。但习惯把访问控制符放前面
5.但是返回类型 不能放在上面两者前面
TestHelloWorld.java:4: <identifier> expected
void static public main(String[] args)
^
TestHelloWorld.java:8: '(' expected //返回值必须贴紧方法名
}
^
2 errors
main不是关键字，但是自己不要用它。
6. String[] args
从arg[0]开始
注释：
调程序用
//
/* */
javadoc注释
/**
*/
用javadoc变成文档
javadoc HelloWorld.java –d doc
Java关键字&标识符&保留字
标识符 开头：字母（_, $）
编码规范：
1) 有意义的单词组成，第一个单词第一个字母小写，其他单词第一个字母大写
2) 变量名和方法名同等处理。
3) 常量由有意义的单词组成，所有单词全大写，单词之间用下划线分开。
4) 类名第一个字母大写
Java数据类型
1． 基本数据类型（不是对象）
8种：
int, long, short, byte, float, double, char, bool.
2． 引用类型
对象只能通过引用访问
实际上是安全的指针
数组是引用类型（因为他在C语言里是指针类型）
默认:
Char ‘\u0000’
bool false
引用 null
数组 null
表达式和流程控制
不要用++ --，容易引起误读 除了在循环里面
=与==： ==只能用于基本类型，不要用于引用类型。equals
短路运算符： if (lasting!=null)&&，||
把概率最高的判断放在前面，节省程序执行的时间
类型转换
高位转低位，必须进行强制类型转化 ,short与char的转换总要
传参和传值
基本类型传值
引用类型传引用
传的是变量的副本
控制流程，循环
最好不要用switch (破坏封装,消耗性能,破坏流程)
分支尽量用if else
循环尽量用for
while(true)在服务器中，做死循环用
别用do-while
练习1
强制类型转换
练习2
传参
2005-2-22
8:00
l Java OO
最早的面向对象Smalltalk, 后来的C++, Java, Phyon, .NET
Smalltalk纯的 Java不纯（基本类型等）
Java是对面向对象的一个实现
对象 -> 数据 <- 操作
对象之间的关系 –> 消息
OO: 按符合人的思维习惯的逻辑来分析设计，形成了一套模式，即面向对象体系。
注意:
1. 不要去继承有代码的类。有代码的类请用对象的组合.
2. 继承抽象基类或接口（n个）。接口设计完，不能减少和修改，只能增加.
3. 多重继承本身没错,必不可少,但要限制多重或单继承,破坏封装性.
多态：
技术实现：
1． 编译时:SRC 检查形式类型（声明）
2． 运行时:JVM 检查实际类型
重载：
（编译时）
处理相同的方法名，不同的参数列表
在编译器里用方法签名区别。（method signature，由方法名＋参数列表组成）
不要用运算符重载
14:00
类（实用类）：
1． 类头
只有public 和 默认的，没有私有类
2． 属性
static 只保留一份拷贝。与类代码保存在一起
静态属性的构造方法： static {}块。
non-static
3． 方法
4． 构造方法（不是类的基本结构）
5． static块
l 类的定义
[权限][修饰] class 类名 [extends 父类名][implements 接口列表]
{
类体;
}
权限： 有 public —— 公有类
无 public —— 同包类
修饰： abstract 抽象类，只能被继承（如果一个类里面有一个抽象方法，则这个类必须是抽象类。反之，抽象类不一定包含抽象方法）不能实例化
final 终极类，完美类，不能被继承。只能实例化
ps:
1:一般静态变量被定义成常量
2:用静态方法不能访问实例变量,static
3:native 在java中调用本地c代码
4:构着方法:选择native(高级)
5:接口作为引用类型来使用,任何实现该接口的实例都可以存在该接口类型的变量中.
数据成员：
[权限][修饰] 类型 变量名[= 初值];
修饰： static 有 —— 类变量（类名点取）
static 无 —— 实例变量 （对象名点取）
final 用于修饰常量
static final int N=5; （90％以上用到static，就加final把它变成常量。光static破坏封装性）
方法成员：
[权限][修饰] 返回值类型 方法名(行参列表) （传值不传参）
{
方法体;
}
修饰： static （静态方法不能访问实例对象）
final （不允许重载） （用不到）
abstract （该类必须声明为抽象类）
native 本地方法。可以调用本地代码，比如调用C代码。
成员权限
public > protected > (default) > private
default 同包类
protected 同包＋子类
接口里的方法默认为： public abstract
构造方法：(仅能初始化非静态属性,静态方法不能操作非静态属性,反之可以)
方法名＝类名
一般不是public访问权限
不能有任何修饰
无返回值类型
如果不提供构造方法，则系统提供一个无参的构造方法。但是存在任何自己写的构造方法，缺省的构造方法立即失效。
类继承的时候，不继承构造方法。
初始化父类super()。 如果父类是抽象基类，就不用加了。
super()
this()
接口定义
[权限] interface 接口名 [extends 接口列表]
{
接口体;
}
可以继承多个接口。称为接口的拼装
接口一般声明为public
接口作为引用类型来使用。通过这些变量，可以访问所有实现该接口的方法。
练习：
1．mod02/exercise3
类的公有方法被称为类的接口。
写一个Account类 放在包banking中
并用TestBanking测试
2．在banking中添加类Customer.
3．修改TestBanking。用Customer操作Account。
2005-2-23
8:00
1． 需求分析（top n）
概念
业务
业务流程
2． 用例图（修正）
例：银行的账户Account和客户Customer关系
1) 客户有一个或多个账户
2) 账户与一个客户关联（例外：联名账户）
3) 客户私有、控制账户
需求分析
总体设计
详细设计
例：银行和客户、账号的关系
银行有若干个客户
客户可以选择多家银行（跨边界）
系统中只能有一家银行（系统边界）
银行应该对客户信息保全
银行拥有裁决权
银行类的内部创建帐户（银行类完全创建控制帐户）
要求：
创建客户
用户提交：姓、名、最初额度、身份证号码、六位密码
创建帐户
提交：
身份证号码、初始余额
业务：
身份证号码
帐户号码
密码
业务选择（参数）：存取款 查余额
开会标准
概要设计
1． 需求会（10～15分钟）
分头写草图
2． 开会合并草图
修改草图
3． 提交修改草图
4． 合并修改草图
5． 画类图：每个类两个人
6． 组装至一台机器，编译运行
10:43——17:30
banking项目
2005-2-24
8:00
项目总评
细节问题：
1．只能有一个Bank，设计方法：
Sington设计模式：
构造方法私有，则不能从外界创建他
利用该类的静态常量来保存。
static final Bank bookIntance = new Bank();
Bank类被加载到内存里
new出一个Bank实例，并存在静态区
private Bank()
{
customers = new Customer[MAX];
customerNumber=0;
}
private static final Bank bankInstance = new Bank();
public static Bank getBankInstance() {
return bankInstance;
}
或：
private static final Bank bankInstance = null;
public static Bank getBankInstance() {
if(bankInstance = null)
bankInstance=new Bank();
return bankInstance;
}
在Test.java中
Bank aBank= Bank.getBankInstance();
3． 数组
引用数组是指针的指针，所以要判空
Vector, List, arrayList (只能存一种类型的对象)，也要判空
4． 密码管理方法不能用getPassword()。要用Verify()。
上课内容：
异常
java中的异常
程序中60％代码用于处理异常
任何异常都被包装成异常对象
有异常时候，就抛出异常对象，给JVM。JVM去查调用栈
产生异常的代码不处理异常
好处
1) 用对象处理异常
2) 利用虚拟机作异常对象的传递
3) 正常代码和处理异常代码完全分开
try
{
unsafe;
} catch (异常类 e)
{
异常处理;
}
方法声明为throws，该方法实用时，必须放在try，catch结构中
public void f(int score) throws MyException
{
if(score<0||score>100)
throw new MyExceptino(“”);
}
继承类的时候，不能抛出超出父类的异常。
tips:
接口是用来统领类，分类类的
类是用来实现接口的，实例化接口的一个工具
I/O 流
输入流，输出流 是控制同一个流
字符型，字节型
类库里凡是有Stream都是字节流，有Reader就是字符流
InputStreamReader把字节流转换为字符流
//把System.in转化为一个带缓冲的字符流
BufferedReader in=new BufferedReader(new InputStreamReader(System.in))
in.readline()
网络
添加
Client端，Server端，协议解释器
Socket连接
协议自己定
协议的解析器
new ServerSocket
accept()
new Socket
实例：
Server端
1．new一个ServerSocket
try{
s=new ServerSocket(5432);
}catch (IOException e){}
2．建一个死循环
while(true)
{
try{
Socket s1=s.accept();
}catch(IOException e){}
}
3.用产生的普通Socket通讯
OutputStream s1out=s1.getOutputStream();
DataOutputStream dos=new DataOutputStream(s1out);
dos.writeUTF(input);
dos.close();
s1.close();
Client端
1． 建一个普通Socket
Socket s1= new Socket(“127.0.0.1”, 5432)
2．用Socket通讯
InputStream is = s1.getInputStream();
DataInputStream dis = new DataInputStream(is);
System.out.println(dis.readUTF());
dis.close();
s1.close();
作业：
1． 用例和流程
2． 设计类库，Server结构
2005-2-25
8:00
多线程
业务需求 并发访问
技术需求 多进程、多线程
I/O流阻塞当前进程
技术
模型一
1． 创建线程的线程
2． 线程中跑的代码是哪一个对象的代码
定义一个实现Runnable接口的类，实现他的run()方法，然后将这个类的实例作为Thread构造方法的参数。创建Thread类的实例。
在服务器里
new Thread(Object ); //Object工具类，存所有参数。（包含业务代码）
.start.
构造这个类
class BusinessClass implements Runnable
{
public void run()
{
代码; //调用其他对象完成业务和交互。
}
}
见exercise/mod15/exercise1
内部类
当
外->内代码（功能）
内->外部非公有
需要实用内部类
小结：
1． new Thread( 类 )
2． 定义这个类， implements Runnable
C/S Bank项目
11:00 ~ 2005-2-26 17:40
2005-3-7
8:00
复习：
面向对象：清晰，封装，抽象（针对接口编程），复用（io类，集合类）
C/S -> B/S
区别：
C/S是基于操作系统的（JVM）和基本类库（JDK）的开发模式。
B/S 是基于已有“容器”的开发模式。
B/S优点：屏蔽底层的东西
1． 给商业系统的开发带来方便，重用基础代码和服务(事务安全性)
2． 可以使用经证明有效（率）的软件架构(j2ee核心模式 mvc)
3． 商业的技术支持(第三方)
C/S优点：
1． 完全控制Client, Server端的结构，使用自定义的通讯/业务协议
2． 可以精确定义底层服务，减少冗余和错误
3． 所有的开发代码都是透明的，不存在黑箱
用途
B/S 用于比较大型的，面向最终用户的商业系统（财务、人事、物流、电子商务、工作流）
C/S 用于各种软件系统(用于二次开发)，或软件产品；特殊专用的商业系统(银行,国防部)
C/S 是B/S的基础。前者用的技术后者都能用到，反之不成立。
B/S几种流行的架构
都是一种开发模式，实现技术变化中
1． J2EE (开发模式 不是开发技术)
2． .NET
3． PHP
4． CGI(perl, C)
J2EE开发模式结构：
系统功能
客户端
Web层
控制层
业务层
数据操作层
容器
浏览器
Web服务器，JSP/Servlet容器
JSP/Servlet容器，EJB容器
EJB容器，Servlet容器
EJB容器， Servlet容器
技术
HTML, CSS, XML, JavaScript, Applet
HTTP, JSP, Servlet, HTML
JSP/Servlet，EJB，JavaBean
EJB，JavaBean，Servlet
EJB（Entity），DAO， JDO， R/O Mapping
辅助技术
美工，Flash
资源文件（国际化），MVC
资源文件（国际化），MVC。
针对容器本身的配置文件，JNDI
JMS，JTA
Tips：
JNDI：Java的目录服务（Java Naming and Directory Interface）
JMS：Java消息服务
JTA：Java事务服务
EJB强侵入型容器，不推荐使用。
EJB基于的两个技术：RMI和序列化
重要级：
要学的，重要的：HTML, XML格式，HTTP, JSP，Servlet，JavaBean
要熟的：HTML，JavaScript， DAO，MVC （这两个是两种架构）
看一下：EJB，JNDI，JMS，JTA
10:00
HTML/JSP
HTML表单
JSP 计算->服务器
痩客户端
Client Server端
浏览器
Brower ----------------à JSP
| Compile
Servlet --------------------------à后台调用
| Run
HTML
过程
1) 发请求HTTP协议
2) 生成两个对象request, response
3) 编译servlet
4) 显示部分硬编码
5) 返回给客户
HTML：
XML
<table>
<Form> 表单
1) 收集用户输入
2) 通过HTTP协议，提交参数到制定的URL（简化了从客户端传到服务器端的过程，但是服务器端传回来的功能就大大减弱了）
JSP表现：
返回：
1) 处理结果（Response）
2) HTML标签（用来做界面）
3) 动作：结果 -> HTML格式
4) 返回给客户
TIPS:
服务器端画界面
画的界面通过response对象返回
eg.
//03.html
<form action=”03.jsp”>
<Input type=”text” name=”myname”><br> //文本框控件
<select name=”interest”> //下拉菜单控件
<option value=”football”>football</option>
</select>
<Input type=”submit” value=”提交”> //提交按钮
<Input type=”reset” value=”重置”> //重置按钮，自动给所有值赋为默认值，避免空指针错误
</form>
//03.jsp
<%
String name= request.getParameter(“myname”);
String interest= request.getParameter(“interest”);
out.println(“Your name is “+ name);
out.println(“<br>Your interest is: “ + inerest); //println的回车对源文件回车，对HTML的显示不起作用，所以要加回车标签<br>
%>
14:00
JSP语法
1． 脚本元素（代码）
1) 注释 <%-- --%> （只在本代码中存在）
2) 表达式<%= %>
3) 声明<%! %> (只在本页起作用)
4) 代码段<% %>
2． 页面指令<%@name 属性列表 %>
1) page指令 <%@page Attribute_List %>
<%@page language=”scriptingLanguage” import=”” contentType=”text/html;charset=GBK” %>
2) jsp:include指令 <jsp:include page=”URLSpec” />
3) jsp:forward指令 <jsp:forward page=”URLSpec” /> （只能转到本机上某一其他页面）
4) jsp:param指令 不能单独使用 <jsp:param name=”name” value=”value” />
3． 内置对象
使用out对象输出数据
request对象和用户输入信息
response对象向客户端发送信息
使用session对象在不同页面共享数据（使用Cookies或重写URL）
启动Tomcat
1. Startup
2. bin下service install 控制面板－》服务－》Apache 启动
配置
在conf文件夹里把server.xml里的connector里的端口号改成别的
tome-users.xml 可以改密码，加用户
练习JSP
webapps\test
webapps\test\WEB-INF 是放应用程序的配置文件和类、库文件
webapps\test\WEB-INF\classeswebapps\test\WEB-INF\libWEB-INF\web.xml
在Tomcat Manager里面部署Deploy
练习：
提交: 1.jsp
<html>
<body>
<form action="echo.jsp" method="post">
<p>内容
<p><textarea name="content" rows="20" col="40"></textarea>
<p><input type="submit" value="submit">
</form>
</body>
</html>
返回: echo.jsp
<%@page contentType="text/html;charset=GBK" %>
<%
request.setCharacterEncoding("GBK");
String content=request.getParameter("content");
content=content.replaceAll("\n","<br>");
out.println(content);
%>
2005-3-8
8:00
复习：
JSP语法
HTML表单
TIPS
HTTP协议有两个方法：
POST: 放在BODY内
GET: 放在URL头部。 URL?attribute=value
<form method=”POST”>
凡是表单提交数据，都用POST
练习1：
密码登陆框
tips:
判断是否空字符串要用.equals(“”)
文件名.jsp小写
练习2：
简单验证在客户端进行，使用Jscript.
JS标签
Script在客户端运行。简单的验证挪到客户端进行
<Script Language=”JavaScript”>
function mycheck() {
if(document.myform.myname.value==””){ //document是浏览器内置对象
alert(“请填写姓名!”);
return;
}
if((document.myform.password1.value!=document.myform.password2.value)||){
alert
return;
}
document.myform.submit();
}
</Script>
提交表单
<form name=”myform” action=”simple.jsp” method=”post”>
<input type=”button” value=”提交” onclick=”mycheck()”>
session内置对象保存用户状态
//session-1.jsp
<%
//初始化
if(session.getAttribute(“flag”) == null) {
session.setAttribute(“flag”,”ok”);
session.setAttribute(“shop”,””);
session.setAttribute(“price”,””);
}
session.setAttribute(“shop”,session.getAttribute(“shop”)+”主板”);
session.setAttribute(“price”,session.getAttribute(“price”)+”100”);
out.println(session.getAttribute(“shop”)+”<br>”);
out.println(session.getAttribute(“price”)+”<br>”);
%>
窗口关掉，只要没离开这个网站，状态依然保留。
JavaBean
轻量级的组件
组件技术
JavaBean概述
可以被Applet、Servlet、JSP等Java程序调用
特点
1) 独立性
2) 可重用性
3) 在可视化开发工具中使用
4) 保存状态
JavaBean属性
1) Simple属性
get/set 都有：读写属性，有get：只读属性
2) Indexed属性
可加索引的属性
3) Bound属性
4) Constrained属性
bean放在WEB-INF/classess下
在JSP中调用JavaBean
<jsp:useBean id=”bean名字” scope=”page|request|session|application” class=”bean对应的类名”/>
//id是应用变量 scope是bean作用的范围。page该页，request该请求，session该会话，application服务器不关机，则永远有效
<jsp:setProperty name=”checking” property=”balance” value=”0.0” />
<jsp:getProperty …>
eg.//bean.jsp
<jsp:useBean id=”first” scope=”page” class=”bean.sampleBean” />
<body>
调用jsp:setProperty之前的值：<jsp:getProperty name=”first” property=”str” />
<p>
<jsp:setProperty name=”first” property=”str” value=”change value” />
调用jsp:setProperty之后的值：<jsp:getProperty name=”first” property=”str” />
</body>
</html>
//sampleBean.java
package bean;
public class sampleBean
{
private String str=”first value”;
public String getStr() {
return str;
}
public void setStr(String value) {
str=value;
}
}
tips
写JavaBean的注意事项
必须写set/get方法
必须package.不能放在默认包里
14:00
Tips:
JavaBean的scope。 session最长用。同一个客户的多个请求用同一个Bean
get/set方法使用条件：无参的。（标签使用法）
Bean作为一个普通的java类。可以直接用他的方法。
练习3：
1． HTML页面。下拉表单
2． JSP。submit/item。
3． JavaBean。用户购物清单
2005-3-9
8:00
JDBC
JDBC是连接数据库的一种协议。在这个系统架构里相当于HTTP。
功能：J2EE连接到外部资源
现在可以用XML访问数据库
协议：规定了统一的数据库访问接口，由各个厂商实现。
类：
1． DriverManager
getConnection
接口：
2． Connection（数据库厂商写的）
3． Statement （执行SQL语句）
使用注意：
不要让JDBC破坏程序原有结构。R/O Mapping
把数据库的作用降低到只有数据持久化。
语法：
JDBC API
1． DriverManager 管理JDBC（不是JDBC协议里的）将driver加载进内存
2． Connection由 drivermanager 返回一实例
3． Statement向数据库发送SQL查询和取得一组结果的工具,也由数据库厂商提供
4． ResultSet定义访问执行Statement产生的数据表方法
5． PreparedStatement编译好的SQL语句
eg.连接mysql数据库
import java.sql.*;
public class JdbcMySQL{
public static void main(String args[]) {
String serverName=”localhost”;
try{
Class.forName(“com.mysql.jdbc.Driver”); //先把路径配到CLASSPATH里
String url=”jdbc:mysql://”+serverName”+”:3306/test”; //每个数据库不一样的
Connection conn=DriverManager.getConnection(url,”root", "root");
Statement stmt=conn.createStatement();
ResultSet rs=stmt.executeQuery(“select * from student”);
while(re.next()){
System.out.print("StudentNo:"+rs.getInt(1));
System.out.print(“\tStudmentName:”+rs.getString(2));
}
}catch(Exception e) {}
连接字符串每个数据库都不一样。
练习：
投票系统
//VoteConn.java
package vote;
import java.sql.*;
public class VoteConn {
String sDBDriver=”sun.jdbc.odbc.JdbcOdbcDriver”;
String sConnStr=”jdbc:odbc:vote”;
Connection connect=null;
ResultSet rs=null;
public VoteConn(){
try{
Class.forName(sDBDriver);
}
catch(java.lang.Exception e){}
}
public ResultSet executeQuery(String sql) {
try {
connect=DriverManager.getConnection(sConnStr);
Statement stmt=connect.
public int executeUpdate(String sql) {
int result=0;
try{
connect=Driver
//index.jsp
<%@page contentType="text/html;charset=GBK" %>
<%@page import="java.sql.*" %>
<jsp:useBean id="connDbBean" scope="page" class="vote.VoteConn" />
<%
ReasultSet rs=connDbBean.executeQuery("select * from vote");
%>
<html>
<body>
<center>
<h2><font color=#0000ff>请你投票</font></h2>
<table border bgcolor=#00ffff>
<form action="vote.jsp" method="post">
<% while(rs.next()) {%>
<TR><TD><input type="radio" name="type"
value =<%=rs.getString("id")%>><%=rs.getString("note")%></TD></TR>
<%}
rs.close();
%>
<TR align="center"><TD><Input type="submit" value="投票"></TD></TR>
</form>
<TR><TD><A href="details.jsp">查看投票</TD></TR>
<table>
</center>
</body>
</html>
//style.css
//vote.jsp
<%@page contentType="text/html;charset=GBK" %>
<%@page import="java.sql.*" %>
<jsp:useBean id="connDbBean" scope="page" class="vote.VoteConn" />
<%
String rb=request.getParameter("type");
if(rb!=null&& rb!=""){
String sql="Update vote Set c_num=c_num+1 where id="+rb;
connDbBean.executeUpdate(sql);
}
%>
<jsp:forward page="detail.jsp" />
//admin.jsp
<%
connDbBeanexecute
<%=tempRs.getString(“note”)%>
<div align=”center”><a href=”delvote.jsp?id=<%=tempRs.getInt(“id”)%>”>删除</a></div>
//delvote.jsp
<%
String d_id=request.getParameter(“id”);
if(d_id!=null
connDbBean.execute
//addvote.jsp
<jsp:useBean scope=”page” class>
String nn=request.getParameter(“note”);
if(nn!=null
connDbBean.executeQuery(“select max(id) As maxid from vote”);
tmpRs.next();
int max_id=tmpRs.get Int(“maxid”)+1;
tmpRs.close();
String sql=”insert into vote value(“+max_id+”,’”;
sql+=nn+”’,0”;
System.out.println(sql);
conDbBean.executeUpdate(sql);
}
%>
<jsp:forward page=”admin.jsp”>
2005-3-10
8:00
Servlet
常用API：http.servlet
特点
1． 结构很严格
2． 代码框架已经写好
3． 窗口给Sevlet运行提供context
4． 仅用于处理http请求
initial方法：第一次调到内存时，访问一次。
destroy方法：被调出内存时，访问一次。
service方法：主方法，参数（request，response）
doget()，dopost()：我们要写的方法。
eg1.
//TestServlet 放在classes下面
import javax.servlet.*;
import javax.servlet.http.*;
public class TestServlet extends HttpServlet
{
public void doGet(HttpServlet Request req, HttpServletResponse res) throws ServletException{
res.setContentType(“text/html;charset=GBK”);
req.setChanracterEncoding(“GBK”);
PrintWriter cut=res.getWriter();
out.println();
out.close();
}
}
//.jsp
<form action=”/myServlet/TestServ”>
路径要在配置文件里配：//web.xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<!-- JSPC servlet mappings start --> //配置servlet
<web-app>
<display-name>first</display-name>
<servlet>
<servlet-name>aaaa</servlet-name>
<servlet-class>TestServlet</servlet-class>
//起始地址为WEB-INFO/classes，包名.类名
</servlet>
<servlet-mapping>
<servlet-name>aaaa</servlet-name>
<url-pattern>/myServlet/TestServ</url-pattern>
// <url-pattern>/myServlet/*.do</url-pattern> //可以把很多种请求映射到一个Servlet
// <url-pattern>/myServlet/*.*</url-pattern> //一组一组的mapping
<servlet-mapping>
<!-- JSPC servlet mappings end -->
</web-app>
TIPS：
写Servlet不是主要的。而配置文件是主要的。
以配置文件（程序结构和框架）为中心，以JSP/Servlet, HTML, JavaBean, EJB为辅
eg2.从servlet转到jsp
//jsp转servlet forward
request.setAttribute(“applet”,”servlet”); //相当于jsp里的param标签
getSevletConfig().getServletContext().getRequestDispatcher(“/hello.jsp”).forward(request.response);
在servlet里面使用JavaBean。new一个。
//servlet和JavaBean都是内置多线程。最好不用静态属性。
TIPS:
Servlet配置
1． servlet-api.jar
javac –classpath %classpath%;…..
2． web.xml
14:00
MVC
一个Controller带了一组Servlet，一个config
Controller分三部分
1． 控制器
2． 干活的
3． 配置文件
Struts是一个MVC的框架
好处
1． 成熟
2． 用的多
特点：
1． 物理：Struts是MVC基于Java的一个框架（一个类库Java和标签库JSP）
2． 功能：辅助实现MVC
struts框架
控制程序流程的类
实现和执行程序业务逻辑的类
自定义的标记使创建和验证HTML表单更加容易
*.tld 标签库文件
*.war web application 包
类库的安装：只需解压缩到一个路径，然后配置环境变量
struts难点
1． config.xml
2． 标签库
3． 体现MVC
Struts的组件
ActionServlet 控制器
ActionClass包含事务逻辑
ActionForm显示模块数据
ActionMapping 帮助控制器将请求映射到操作
ActionForward 用来指示操作转移的 对象
ActionError 用来存储和回收错误
Struts标记库 可以减轻开发显示层次的工作
struts配置文件：struts-config.xml
自己写的部分Action里的perform()
小结：
在MVC中，
Struts主要给了C的框架。M自己写。V用标签库自己写。
提供两个功能。一个C。一个C背后的系统设计。
Controller写好了
Action的框架写好了，只要填perform()
扭转。反向扭转用ActionForward。
提供一个对用户输入数据的缓存部分ActionForm。
帮助流程设计。一个struts-config.xml。另一个是把流程抽象到对象放在内存里面。
标签库中会用到几个。
2005-3-11
8:00
Model部分设计：
Façade
值对象
eg. struts-blank
index.jsp做客户代理
<action
path="/Welcome"
forward="/pages/Welcome.jsp"/> //调用了一个默认的action
1． 写aciton
2． 在config.xml里面的actionMapping改成我们的类
3． 写个.jsp
2005-3-12
8:00
使用struts-console查错
使用ant自动建构
两部分：property target
14:00
../ 上一级目录
./ 当前目录
/ 当前盘符的根目录
转向:1 页面中最好都使用xxxx.do来把控制权交给action
2 真正的转向由control来做 path=”/xxx/xxx.jsp” 第一个xxx为web-inf下的一目录名
JSP的scope对应servlet里的：（scope指生命周期和可见性）
page 局部变量
request request
session session
application servletContext
值对象(用于由action中传出数据)
MODEL中：facade
练习
struts+bean+jdbc+ant
2005-3-14
8:00
小结
1．request.setAttribute(“name”, myBean)
2．值对象 注意scope
3．MODEL中用facade
final项目
报表：
1． struts
2． JasperReport API
3． IReport
14:00
final项目OSS报表
1． 需求：
a) 管理报表定义和实例
b) 用户查看和输出
2． 工具
a) struts，ant，IDE，mySQL，JasperReport，JSP/Servlet，JavaBean，iReport，tomcat
3． 流程
合作
1. 共享资源专人负责
a) struts
b) ant, mySQL, tomcat
c) JasperReport(iReport)
2. 需求分析：
a) 会：草案
b) 分：用例图（流程）
c) 会：合并用例图。初步系统设计
d) 分：修正
e) 会：最终版本的系统设计
3. 设计数据结构
a) 类，配置文件
b) 数据库表
4． 详细设计
a) 分工：接口（协议）
b) 分：详细设计
