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 ‘/u 0000’
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
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/classes/
webapps/test/WEB-INF/lib/
WEB-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=”提交” οnclick=”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) 分:详细设计