新东方学习笔记1

java笔记：

(1):java中是以long形保存日期数据的。
import java.sql.Date;
long time = System.currentSysteTime();
Date d = new Date(time);
System.out.println(d);
//2005-10-26
/

(2):处理数据库中的null
ResultSet rs = stmt.exexuteQuery("select age a from dog");
while(rs.next()){
 rs.getInt("a");
 rs.wasNull(); //true or false?
}
/

(3):servlet是单实例，多线程。
1,第一次用户发出请求，WEB容器创建servlet对象（一个servlet仅创建一个对象，供所有用户

调用）
。容器调用init()方法。
2,以后用户发出请求后，WEB容器就会调用servert的doGet()或doPost()方法。
3,销毁对象是，先调用destroy()方法，然后销毁对象。

servlet是单实例多线程的，所以在调用doGet()和doPost()方法时需要考虑多线程。需要在方法

前加
上线程锁。synchronized 和在方法体中加上Thread.sleep(100);这样就可以避免多用户同时修

改同一
变量了。
/

(4):
Response:
response.setContentType(),// "text/html"
PrintWriter out = response.getWriter().//将把要显示到页面的内容写到流中

Request:
request.getRemoteAddr(),//取得请求地址 172.16.7.16
request.getHeader("");//获取协议头 ，以键值方式 例:key - value
request.getHeaderNames();//获取所有协议头信息  显示好多东西啊！

String id = request.getParaments("id");//获取浏览器端传过来的id键值
Enumeration names = request.getParameterNames();//获得所有的键值对

网页提交一般默认是以'post'方式提交。所以一般在servlet中复写doPost()方法。
jsp将提交信息提交给 servlet,需要在jsp的提交form中写上指定的servlet。<form

name="form1" 
method="post" action="servlet"></form>
'servelt'与配置文件（web.xml）中的 <url-pattern>/servlet</url-pattern>相同。

jsp放置路径与'WEB-INF'在同级目录。
/

(5):
重定项:
浏览器将请求(request)给程序1,程序1 response到浏览器,浏览器根据程序1 response回的信息

(去找
程序2)。浏览器又request到程序2，程序2又response到浏览器。
requst.getPartment("name");//不可以
response.sendRedirect("success.jsp");//可以

转发:
浏览器将请求(request)给程序1,程序1又将请求(request)给了程序2,程序2直接response到浏览

器。
程序2: requst.getPartment("name");//可以
response.sendRedirect("success.jsp");//可以
/

(6):
servelt中可以处理浏览器端传来的cook。

取得cook信息：
Cookid cookid = new Cookid("key","value");
Cookie[] cookies = request.getCookies();
加入cook信息：
Date date = new Date();
String s = String.valueOf(date.getTime());
Cookid cookie = new Cookie(s,s);
response.addCookie(cookie);
cookid.setMaxAge(100);//设置cookid生命期
/

(7):
每一个session对像都有一个session id.通过sessionid来区别对象。
sessionid作为会话cookie保存到浏览器端。记录用户访问信息。用户关闭浏览器，一般都清除
sessionid信息。

HttpSession session = request.getParameter(true);//用户获取session对象
//session 是以键值对出现的
session.setAttribute("username",name);
在jsp中写
Objectg obj = session.getAttribute("username");
if(obj != null){
 String name = (String)obj;
}
/

(8):
共享数据
request,session,ServletContext中都可以放数据
request:同一个请求。'重定项'可以，'转发'不行。
session:同一个会话可以。
ServletContext:同一个application中都可以。

例：
HttpSession session = request.getSession(true);//不存在创建个新的
request.setAttribute("request","request");
session.setAttribute("session","session");
response.sendRedirect("target.jsp");//从定项

Object se = session.getAttribute("session");
Object re = request.getAttribute("request");
out.print("session = "+se);
out.print("request = "+re);

//转发
RequestDispatcher rd = request.getRequestDispatcher("target.jsp");//转发
rd.forward(request,response);

ServletContext ctx = getServletContext();
//Context放入整个应用的共享数据
ctx.setAttribute();
Object obj = ctx.getAttribute("num");
int n=1;
if(obj == null){
 ctx.setAttribute("num",new Integer(n));
}else{
 n = ((Integer)obj).intValue();
 ctx.setAttribute("num",new Integer(n+1));
}
/

(9):
一个用户登录，注册 的程序。
用 jsp,servlet,
select count(*) from user where name = 'name' and pass = 'pass';
判断结果是  0/1

int i = 8888888888; //不对
long l = 8888888888; //不对
long l = 8888888888l; //对
8888888888后什么也不写，默认是int型，int长度放不下长度。
/

(10):
ServletConfig :部署描述符
在servlet配置文件中写入信息
<servlet>
<init-param>
 <param-name>driver</param-name>
 <param-value>jdbc.oracl.OracleDriver</param-value>
</init-param>
<init-param>
 <param-name>url</param-name>
 <param-value>jdbc:oracle:thin:@localhost:1521:ORA001</param-value>
</init-param>
</servlet>

private String url;
private String driver;
public void init(){
 ServletConfig config = this.getServletConfig();
 driver = config.getInitParameter("driver");//获取初始化参数 
 url = config.getInitParmeter("url");//
}
/

(11):

ListList 和ArrayList
ArrayList: 是用动态数组写的。里面使用视图原理，适合查询。
ListList: 是用链表写的。适合插入，删除。
/

(12):
过滤器：

浏览器请求首先调用service()方法，这个方法决定调用 ->doGet() 或 doPost()。
在配置文件中学禁止内容
<filter>
 <filter-name>forbit</filter-name>
 <filter-value>***</filter-value>
</filter>

forbitname = config.getInitParameter("forbit");

doFilter(request,response,chain)
String name  = request.getParameter("username");
if(name != null && name.indexOf(forbitname) != -1){
 return;
}
chain.doFilter(request,response);
/

(13):
标签库
JSF
JSTL
STRUTS

使用标签库，提高效率。
/

(14):
jsp
用jbuilder 2005开发jsp,在'Welcome files'上点击'add'加入欢迎界面。
在web.xml中
  <welcome-file-list>
    <welcome-file>jsp1.jsp</welcome-file>
  </welcome-file-list>

在jsp中写上<%@page language="java"%>//设置语言
           <%@page import="java.util.*,java.text.*"%>
    <%@page pageEncoding="GBK"%>//编码格式
    <%@page errorPage="error.jsp"%>//错误页面，只要出错，就跳转到该页面

tomat 下的work/Catalinal/localhost/TestJSP/org/apache/jsp 下是jsp被编译成的servlet页

面。

jsp中写入以下内容
<%! int i=0;%>//servlet类的成员变量
<%
 int i=0;//service()方法的局部变量
 i ++;
 j ++; 
%>
request.getParament("");//request是jsp中的内置对象，不用定义
out.println("");//out是jsp中的内置对象，不用定义
/

(14)
'abc中国人'
uncold是6
在内存中是9
fileWrite: 调用后是9
/

(15)
强制类型语言

<script type="" language="JavaScript">
 function check(){
  var v = parseInt(f1.times.value);
  if(!isNaN(v) && v>=1 && v<=99){
  return true;
  }else{
  alert("1~99");
  return false;
  }
 }
</script>
/

(16)
格式化日期对象
String format(Date date){
 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
 String s  = sdf.format(date);
 return s;
}
/

(17)
接口 Collection 是超接口，其他容器都继承它
子接口 Set //集合，无序的
子接口 List //链表，有序

 实现类 HashSet
 ArrayList  //动态数组
 LinkedList//链表

接口 Map 放的是键值对
 实现类HashMap

Hashtable //相当与旧版本的 Hashmap
          //Hashmap是同步类
Vector    //相当与ArrayList,LinkedList
   //vector是同步类，而另外两个没有同步，考虑到了性能

StringBuffer //实现了同步，是线程安全的，在多线程中用
StringBuilder//不是线程安全的，在单线程中用
/

(18)
重写类时需要重写以下方法
String toString(){}
boolean equal(Object){}
int hashCode(){}
两个对象如果equal()返回ture,则hashCode()返回的整形也要相等。

两个对象相等的条件是 他们的hashCode值相等，equal相等

若不重写 hashCode 则默认的是对象地址的值。
/

(19)
Collections是个实现类
Collections.sort((List)c1); //c1是arraylist
要排序对象，需要在对象中实现compareTo()方法。
Coolection c5 = Cllections.synchronizedCollection(c1);//c5指向c1
/

(20)
Iterator 为容器实现了统一的遍历方法。
/

(21)
javabean获得列表
public Collection getConrseList(){
 String sql = "";
 Connection con = getConnection();
 PrepareStatement prepStmt = con.prepareStatement(sql);
 ResultSet rs = prepStmt.executeQuery();
 Collection courses = new ArrayList();
 while(rs.next()){
 String id = rs.getString("id");
 String name = rs.getString("name");
 Course course = new Course();
 course.setId(id);
 course.setName(name);
 courses.add(course);
 }
 return courses;
}
/

(22)
调用错误页面
error.jsp
<%page isErrorPage="true"%>
<%
 exception.getMessage();//exception是jsp内置对象，保存异常信息
%>
/

(23)
数据库连接和关闭都要消耗性能，所以要有连接池。
连接池一般是在一启动，就创建一定数量的对象供使用，用户用到对象时，只需从池中拿来即可

。

(24)
链表可以通过键来获得。
Collections.sort(lsit);//对list排序
Collections.binarySearch(list,'abc');//折半查找

Map map = new HashMap();//键值对 以hash表的方式存放
map.put("one",new Integer(1));
map.put("two",new Integer(2));
map.put("three",new Integer(3));

boolean b = map.containKey("one");//true

SET遍历
Set keys = map.keySet();//把键作为集合返回
Iterator it = keys.iterator();
while(){}

(25)
Reader和Writer  专门用来处理文本类型的数据，和编码有关。 //字符数据
InputStream和OutputStream  //字节型数据

直接跟数据源相连的流叫'节点流'。

节点流 Fis Fos
字符流 BAIS BAOS

缓冲流 Bis Bos
数据流 Dis Dos
对象流 Ois Oos

字符缓冲流 FR RW
           BR BW
转换流 OutputStreamWriter InputStreamReader

PipedInputSteam PipedOutSream

PrintSteam PrintWriter

...stream是处理数据的
专门处理字符串用字符流，涉及到编码问题，字符流可以解决转换问题。

//写字节byte型
FileOutStream fos = new FileOutPutStream("c://temp//a.txt");
FileInputSteam fis = new FileInputSream("c://temp//b.txt");
int b = fis.read();//读一个字节，读的是低8位
fos.write(100);//写低8位，写整形不用转换了

byte[] buffer = new byte[1024];//处理读取效率
while((b = fis.read(buffer)) != -1){//是否读到文件末尾，b表示读取的有效数
 fos.write(buffer,0,b);//
}
如果buffer很到会又问题。所以用缓冲流来解决
BufferOutputStream bos = new BufferedOutputSteam(fos);
BufferInputStream bis = new BufferedInputSteam(fis);
int b = -1;
while((b = bis.read()) != -1){
 bos.write(b);
}
数据流
DateOutputSteam dos = new DateOutputSteam(new FileOutputSteam("c.dat"));
dos.writeInt(100);
dos.writeDoubls("123.456");
dos.close();

DateInputSream dis = new DateInputSream(new FileInputStream("c.dat"));

String s = "abc中国人";
OutputSteamWriter osw = new  OutputSteamWriter(new FileOutputStream("abc.txt"));
osw.write(new char[]{'a','b','c'});
//输出文件大小4

OutputSteamWriter osw = new  OutputSteamWriter(new FileOutputStream("abc.txt"));
osw.write("中");
//输出文件大小1

Write(int)方法写入低16位，前16以0补充，Writer再调用本地编码规范，写到文件中

unicode :所以都是2位
iso8859 :国际标准
ascode  :只能是键盘上的字符
gbk,gb2312:英文是1字节，汉子是2字节
UTF:英文是1字节，汉字、日文是3字节

FileWrite fw = new FileWrite("abc.txt");//只能按默认编码
//相当于
//OutputSteamWriter osw = new  OutputSteamWriter(new //FileOutputStream("abc.txt"));

fw.write(new char[]{'a','b','中'});
fw.close();
osw.close();
//文件大小4字节

BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

(26)
JSP内置标签

1、标签可以嵌入其他标签，可以由自己的属性
2、前面的jsp:前缀 －》可以解决命名问题。
3、和html中的标签不一样，jsp标签所对应的是一段代码，具有一定功能。可以自己定义自己的

标签
，使jsp中不存在逻辑代码。

a.jsp
<jsp:include page="b.jsp" flush="false">
</jsp:include>

把另外一个页面嵌入到jsp页面中
    fulsh的属性是表示将缓存中的数据写到浏览期上。a.jsp向缓冲中写数据，然后b.jsp再向

缓冲中
写数据，返回到a.jsp，再向同以缓冲区中写数据。'false'表示将缓冲中的数据一起写到浏览器

上
,'true'表示在转给b.jsp时，先将缓冲区的数据写到浏览器端，清空缓冲，然后b.jsp将数据写

到缓冲
中，再返回到a.jsp
    浏览器向a.jsp发出请求（request,response），a.jsp进行处理，又对请求

(request,response)
进行一些处理，发给b.jsp.

a.jsp
<jsp:forward page="b.jsp">
 <jsp:param name ="name" value="java"/>
</jsp:forward>
b.jsp可以过
 request.getArrtibute("v");
 request.getParameter("name");
页面转发
a.jsp的数据放到缓存中，数据不输出（输出抛异常），转到b.jsp

<%@page buffer="none"%>

servlet:
//out.flush(); //清缓存将抛异常
System.out.println(response.isCommitted());
RequestDispatcher rd = request.getRequestDispatcher("success.jsp");
rd.forward(request,response);

redirect:可以重定项到任何地方
forward :只能转到本应用内部
include :只能包括本应用中的

(27)
jsp共享数据级别
Object obj0 = pageContext;
Object obj1 = request;
Object obj2 = session;
Object obj3 = application;

Class c0 = pageContext.getClass();
Class c1 = request.getClass();
Class c2 = session.getClass();
Class c3 = application.getClass();

c0.getName();//weblogic.servlet.jsp.PageContextImpl
cl.getName();//weblogic.servlet.internal.ServletRequestImpl
c2.getName();//weblogic.servlet.internal.session.MemorySessionData
c3.getName();//weblogic.servlet.internal.WebAppServletContext

getName();//返回的是实现类

page<request<session<application
page:本页面级别
request:多个页面可以共享，只要是同一个请求范围
session:只要是一个会话（浏览器不关）
application:只要是一个应用（服务器不关）

已经学了以下jsp内置对象
page<request<session<application
exception,out,forward

(28)
涉及到本地比较多，离操作系统比较近，cs结构用的java.newio.*;包比较多。
(29)
解决 Netscape 浏览器屏蔽cooked的问题。
浏览器发送消息到服务器端(session对象默认为session="true")，如果是第一次访问，服务器

创建创
建一个新的session对象。然后将sessionid写到访问览器上。

session.invalidate();//session对象失效。

String loginURL = response.encodeURL("longin.jsp");
String loginURL = response.encodeURL("longout.jsp");
//检测session是否可用

(30)
//java反射
//要求类必须有空构造子
Class c = Class.forName("test.jsp.bean.TestBean");//封装类
Object obj = c.newInstance();//创建实例，调用空构造子
System.out.println(obj);

//活得方法
Method m = c.getMethod("setStringV",new Class[] {String.class,Integer.class});
//class.forName("test.A") 等同于 A.class;
m.invoke(obj,new Object[]{"java"});
public void setStringV(String str,Integer i){}

(31)
<jsp:useBean id="somebean" scope="page" class="teset.jsp.bean.TestBean">
 <jsp:setProperty name="somebean" property="stringV" value="j2ee"/>
 //标签 初始化属性 progerty于javabean中的get,set后面的名相同
 //调用(stringV)setStringV()方法。
 //从小到大page->request->session->application
</jsp:useBean>
//可以创建这个TestBean对象，然后以id的名称，存到scope指定的范围里面。
//jsp中是用反射机制实现对象创建的

//打印属性

<jsp:getProperty name="somebean" property="stringV"/>
等同于
<%=somebean.getStringV()%>

(32)
装饰模式

(33)
java安全：

import java.security.MessageDigest;
public static void main(String[] args){
 MessageDigest md = MessageDigest.getInstance("MD5");//采用MD5算法进行加密，

屏蔽创
建对象的复杂性
 String password = "java";
 byte[] b = password.getBytes();
 byte[] b1 md.digest(b);
 for(int i=0;i<b1.length;i++){
  System.out.println(b1[i]);
 }
}

BufferedInputStream bis = new BufferedInputStream(new 
FileInputSteam("c://temp//abc.txt"));
 int b =-1;
while((b=bis.read())!=-1){
 md.update((byte)b);
}
 byte[] b2 = md.digest();
 for(int i=0;i<b2.lenth;i++){
 System.out.print(b2[i]+" ");
}
(34)

日志：log4j
1，改变输出权限
2，改变输出平台
3，改变输出格式

Logger  //可以有不同的
 Appender(console)->Layout(SimpleLayout)
 Appender(file) -> PatternLayout
 Appender(...)-> ...

使用Log4J配置文件配置Logger,Appender和Layout组建
##LOGGERS##
log4j.logger.testerLogger=WARN,console,file //指定logger定义名称 ，指定级别，输出平

台
(console,file)（下面定义）

##APPENDERS##
log4j.appender.console=org.apache.log4j.ConsoleAppender //指定对应类
log4j.appender.file=org.apache.log4j.FileAppender //指定对应类
log4j.appender.file.File=log.txt //指定输出文件名
##LAYOUT##
log4j.appender.console.layout=org.apache.log4j.SimpleLayout //指定输出格式
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%p-%m%n

import org.apache.log4j.*;

public static void main(String[] args){
 PropertyConfigurator.configure("c://temp//log4j.properties");//读取属性文件
 Logger logger = Logger.getLogger("testerLogger");//选择Logger

 logger.fatal("fatal");
 logger.error("error');
 logger.warn("warn");//产生一个级别为警告的日志
 logger.info("info");
 logger.debug("debug");
}
(35)
标签库
需要引入
improt javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.Tag;
继承 Tag
pageContext : 一个页面也个pageContext,这个方法包含页面的所有信息
application - serveltContext

setParent: 设置上标签（外层标签）值。
getParent: 得到该标签，供容器使用。

doStartTag():遇到标签头（<）时调用。
doEndTag():遇到标签尾（>）时调用。

JspWriter out = pageContext.getout();//获取输出流

定义.tld
<taglib>//根元素
 <tlibversion>1.0</tlibversion> //标签版本号
 <jspversion>1.1</jspversion> //jsp版本号
 <shortname>test</shortname>
 <uri>/test</uri> //uri,供web.xml引入
 <tag>
  <name>hello</name>
  <tagclass>test.jsp.tag.HelloTag</tagclass>
  <bodycontext>empty</bodycontext>
  <attribute>
   <name>num</name> //属性名
   <required>ture</required> //是否必须写
   <rtexprvalue>true</rtexprvalue>
  </attribute>
 </tag>
</taglib>

在web.xml中对标签进行定义
//必须放在最后
<taglib>
 <taglib-uri>/test</taglib>
 <taglib-location>/WEB-INF/testtag.tld</taglib-location>
</taglib>
// web.xml循序时一定的

在jsp中指定标签
<%@taglib uri="/test" prefix="t"%>
页面中写
<t:hello>

1,写标签库
2,定义.tld
3,添加web.xml
4,jsp中引入自己定义标签库

(36)
pageContext

pageContext.setSAttribute("","");
request.setAttrbute("","");
session.setAttrbute("","");
application.setAttrbute("","");

Object obj = pageContext.findAttrbute("");//查找键值，依次
page,request,session.application

pageContext.getAttrbute("some_key",pageContext.SESSION_SCOPE);//在pageContext中获得

值，后
面指定查找范围

pageContext.getAttributeNamesInScope(pageContext.PAGE_SCOPE);//pageContext中的所有键

EVAL_BODY_INCLUDE //执行body内容
SKIP_BODY //跳过body
EVAL_PAGE //执行标签后面的东西

(37)
标准标签库 JSTL
core
 out
 set.remove
 if.choose.when.otherwrise
 forEach.forTokens
 import.redirect.url.param

<c:out value="hello"/> //输出 hello escapeXml默认是true
<c:out value="<b>hello</b>" escapeXml="true"> //输出 <b>hello</b>
<c:out value="<b>hello</b>" escapeXml="false"> //输出 hello

<c:out value="${1+2}"/> 
//${n} 表达式 ，n是一个变量
<c:out value="${request_key}"/> 
//在 page->request->session->application依次查找

<c:out value="${key_1} default="default_values_1"/>
等同
<c:out value="${key_1}">
 default_value_1
</c:out>
//先找key_1,若未找到则用缺省值

set:
<c:set value="hello" var="v1" scope="page"/>
//设置（键）v1为hello, ＝ pageContext.setAttribute("var","hello");

<c:set value="${requestScope.some_key} var="v2"/>
//在指定范围你查找键值 ，然后付给v2 ,默认scope="page"

<c:set value="${header['host']}" var="v5"/>
//从请求协议中取得键为host的值

<c:set value="${param['id']}" var="v6"/>

<c:set value="abc" target=${some} property="value">
//为对象some,给对象属性value赋值为"123"

<c:set target="${map}" property="3"/>
//为容器设置键值

<c:remove var="some_key" scope="page"/>
//删除指定键对应的值

<c:if test="${d1+d2==d3}">
 <c:out value="${${d1}+${d2}+${d3}}"/>
</c:if>

<c:if test="${sessionScope.user != null}">
 <c:out value="${sessionScope.user}"/>
</c:if>

<c:catch var="ex">
<c:choose>
 <c:when test="${param['id'] mod == 0}">
</c:choose>
</c:catch>
//如果遇到异常，将异常保存到ex中

<c:forEach var="v1" items="${c1}">//定义变量v1,对c1进行iterator
 <c:out vaue="${v1}" escapeXml="false"/>
</c:forEach>

<c:forEach var="v2" items="${c2}" varStatus="status">//varStatus="status" 表示容器下

标
 <c:out vaue="${status.index}" escapeXml="false"/>
 //
</c:forEach>

<c:forEach var="v3" items="${c3}" begin="1" end="10" step="2">//
 <c:if test="${!status.lase}">//判断是否是最后一个
 <c:out value=","/>
</c:forEach>

(38)
<c:forEach var ="v5" begin="1" end="9">
 <c:out value="${v5}" escapeXml="false"/>
</c:forEach>

<c:forTokens delimes=",;" items="${s1}" var="v7">//用,:来分割
 <c:out value="${v7}"/ escapeXml="false">
</c:forTokens>

<c:import var="u1" url="link/poem.htm" charEncoding="GBK">
 <c:out value="${u1}" escapeXml="false"/>
</c:import>

<c:import var="u2" url="link/t1.jsp">
 <c:param name="id" value="123"/>
</c:import>

<c:url var="u3" value="link/t2.jsp">
 <c:param name="a1" value="1">
</c:if test="">

<c:url>
 
</c:url>
(39)
String t = "sun,im,;oracle;bean";
StringTokenizer st = new StringTokenizer(t,",;");

(40)
正则表达式
import java.util.regex.*;
public static void main(String[] args){
 String target = "java*****88j2ee****java***java123ajava"; 
 Pattern p = Pattern.compile("java");
 Matcher m = p.matcher(target);
 boolean b = m.matchers();//false
 while(m.find()){
  System.out.print(m.start()+","+m.end());
  System.out.println(target.substring(m.start(),m.end()));
 }
}

 //替换
 StringBuffer buffer = new StringBuffer();
 while(m.find()){
  m.appendReplacement(buffer,"j2ee");
 }
 m.appendTail(buffer);//把尾部加上
 String t1 = buffer.toString();
 System.out.println(t1);
 
(41)
String target ="a1*****b2*****c3**";
Pattern p = Pattern.compile("[abc][0-9]");//abc中的任何一个，0到9中的任何一个

(42)
struts:

M -》业务流程，数据访问。
V -》显示逻辑
C -》控制逻辑（对流程起到控制作用，起到连接M C层）

   C
V -|- M

开元：（学习原则）
1，做了什么？
2，如何扩展？

(43)
用jubilder创建个struts后，自动修改web.xml。同时在/WEB-INF下加入标签库。在lib下加入

.jar文
件。
struts-config.xml是对web.xml的一个补充。
(44)
新建struts如何修改web.xml:

<servlet>
 <servlet-name>action</servlet-name>
 <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
 <init-param>
  <param-name>config</param-name>  
  <param-value>/WEB-INF/struts-confg.xml</param-value>
 </init-param>
 ... ...
</servlet>
<servlet-mapping>
 <servlet-name>action</servlet-name>
 <url-pattern>.do</url-pattern>
</servlet-mapping>
ActionServlet是中央控制器，所有请求都先通过它，然后再转发到其他的地方。它是通过读
struts-confg.xml，来决定转向哪个Servlet的。

(45)
Action 实质也是个Servlet
ActionServlet 是中央控制器
Form 是个bean ，用来保存数据，ActionServlet根据页面请求，调用from做成个对象，传给

action.

(46)
Action path: url路径。
FormBean name:封装的bean
Scope: 参数提交范围
Validate FormBean:提交之前是否验证。

execute相当与servlet里的service方法。

同时修改了struts-config.xml文件。
<action-mapping>
 <action name="loginForm" path="/login" scope="request" 
type="test.struts.action.LoginAction" validate="false">
 <forward name="success" path="/success.jsp"/>
 <forward name="error" path="/error.jsp"/>
 </action>
</action-mapping>

(47)
创建form,
修改struts-config.xml文件
<struts-config>
 <form-beans>
  <form-bean name="loginFrom" type="test.struts.form.LoginFrom"/>
 </form-beans>
</struts-config>

(48)
jsp中的提交
<form name="loginFrom" action="login.do" method="post"></form>

(49)
Action中的execute方法,包含以下参数：
ActionMapping: 配置对象，一个(ActionMapping)相当于配置文件(struts-config.xml)中的一

个
action。
ActionFrom: 传过来的from
HttpServletRequest: request请求
HttpServletResponse: response响应

方法返回值：ActionForward
ActionFroward dd = mapping.findForward("success");
return dd;

jsp -(login.do)->ActionServlet(struts-config.xml)->LoginAction,LoginFrom
然后ActionServlet调用LoginAction的execute方法。
(50)
form验证的功能：

中的get,set方法什么时候调用？
答：实例化form ->调用set,get->validate->实例化Action

 

ActionErrors validate(ActionMapping actionMapping,HttpServletRequest

httpServletRequest){
 ActionErrors errors = new ActionErrors();
 //<html:errors/>
 errors.add("id.null",new ActionError("id is null!!!"));
}
ActionErrors:封装错误信息。

在页面中写上：<html:errors> //全部显示//struts自定义标签
分开显示：<html:error property="id"/>

(51)
struts标签库：
<%@ taglib uri="/WB-INF/struts-html.tld" prefix="html"%> //<html:errors>
资源文件
ApplicationResources.properties
abc=ABC
.. ..
修改配置文件struts-config.xml

<message-resources parameter="resources.ApplicationResources"/>

一般存放到classes下。

根据浏览器的请求判断调用的资源包
(52)
<%@ taglib uri="/WB-INF/struts-bean.tld" prefix="bean"%>
<bean:message key="abc">
<bean:message key="page.login.title"/>  //键值配置文件中定义
<bean:message key="page.login.from.id"/> //键值配置文件中定义
<bean:message key="page.login.form.password"/> //键值配置文件中定义

(53)
配置资源文件可以有两种方法：
1，在web.xml中设置
2，在struts-config.xml中设置
(54)
java中的泛型
ArrayList<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
for(String s : lis){
 System.out.println(s.toUpperCase());
}
(55)
<%@page pageEncoding="UTF-8"%>
国际化标准
struts中所有的资源文件都要有固定的标准
native2ascii -encoding gb2312 a.properties b.properties

资源文件命名
XX_zn_CN

提交时出现乱码，解决方法是写一个过滤器，实现 request.setCharacterEncodeing("UTF-8");
这样整个项目都统一为'UTF-8'了。
1，页面中
2，过滤器
3，资源文件
(56)

页面最前面：<%@ page pageEncoding="UTF-8"%> 显示和提交都是UTF-8格式
服务器端一般默认是以IOS8859方式取数据的。
而我们存数据时是以UTF-8形式存的。
request.setCharacterEncoding("UTF-8");
request.getParameter("value");

给浏览器看的：<%@ page contentType="text/html; charset=UTF-8" %>

(57)
<%@ page pageEncoding="UTF-8"%>
<%@ page contentType="text/html; charset=UTF-8" %>

(58)
在配置文件(struts-config.xml)中写上
<action forward="/regist.jsp" path="/regist" />

(59)
将功能类似的Action和并到一个里面。
新增和查看
继承：org.appachers.struts.actions.DispatchAction

<a href="operation.do?op=operationA"/> _fcksavedurl=""operation.do?op=operationA"/>" //operationA在Action中需要有相同方法
<a href="operation.do?op=operationB"/> //operationB
public ActionForward operationA(ActionMapping mapping,ActionForm actionForm,...){

}

struts-config.xml中修改
<action input="/dispatch.jsp" path="" parameter="op" type="">
</action>
(60)

反射机制
Class c = this.getClass();
Method method = c.getMethod(name,new Class[]{String.class});
//getMethod获取name方法的信息，参数：Class类型数组
method.invoke(this,new Object[]{arg});
//执行方法

(61)
struts中的标签
在配置文件(struts-config.xml)中
page.lookupDispath.form.submitA=A
page.lookupDispath.form.submitB=B

页面：
<html:submit property="op">
 <bean:message key="page.lookupDispath.form.submitA"/>
</html:submit>

(62)
form中的reset方法调用原理：
当一个from对应多个action时，调用reset方法起作用。
先调用下reset方法，然后调用validate方法。

Action是多线程的，要注意同步操作。

页面提交请求，系统调用ServletAction，检测scope范围内是否有from对象，要是没有新建一个

from
对象放入session中。若已经存在，则调用reset方法，然后调用validate方法。然后对from进行
set,get方法，调用action操作。

(63)
Action<-DispathAction<-LookupDispatchAction
DispathAction:
<Action ... parameter="XX"/>
LookupDispatchAction:
需要实现getKeyMethodMap方法
(64)
扩展struts。
关键在于对配置的操作。
(65)
struts标签
<html/> -- <html:html/>
<form action="regist.do"/>
       -- <html:form action="/regist"/>
<input name=""/> -- <html:test property=""/>
<submit name="" value="value"/>
       -- <html:submit property=""><bean:message key="submit"><html:submit/>

(66)
解决重复提交问题。
在提交出写个隐藏表单。提交是，将这个值写入session.
saveToken(request);//将一个值写到request中，同时session中
isTokenValid(request);//用来检查提交上来的值与session中的是否相同
resetToken(request);//清空这个值

saveToken(request)：提交信息，这个方法只动生成个id值，放到session里，然后将这个值转

发到
jsp里。这个jsp页面如果有<html:from>表单,则生成一个隐藏表单。
if(isTokenValid(request)){
 ....
 System.out.println();
 resetToken(request)
}else{
 Systme.out.pritnln("重复提交");
}
/
login.jsp -> saveTOken(request),
 放到session对象里面
 将信息写到regist.jsp
regist.jsp一定要用<html:form>
regist.jsp -> ifTokenValid(request) 

(67)
<html:link forward="/regist">
<html:link/>
必须联接到全局
<global-forwards>
 <form name="regist" path="/regist.jsp">
</global-forwards>

另一种方法
<global-forwards>
 <form name="regist" path="/saveTokenForRegist.do">
</global-forwards>
<action path="/saveTokenForRegist" type="">
 <forward name="regist" path="/regist.jsp"></forward>
</action>

(68)
动态 form
直接用DynaActionForm或继承DynaActionForm
<form-bean name="dynaRegistForm" type="org.apache.struts.action.DynaActionForm">
 <form-property name="id" type="java.lang.String"/>
 <form-property name="password" type="java.lang.String"/>
 <form-property name="name" type="java.lang.String"/>
</form-bean>
(69)
多个页面对应一个form
这个from会自动存到request或session里面

(70)
分次提交
<html:form action="/XX"/>
<html action="XX.do"/>
form :里面的reset()方法不处理
配置文件struts-config.xml
scope="session"
parameter="action"
继承LookupDispatchAction
实现getKeyMethodMap()方法

(71)
在action中验证
ActionErrors errors = new ActionErrors();
ActionError message = new ActionError("key");
errors.add("duplicatie_id",message);
saveERRORS(request,errors);
return mapping.findForward("validate");

(72)
struts中的plug ins
让程序一开始加载是就做某事。
需要实现org.apache.struts.action.Plugln接口
实现destroy(),init()方法。

通过以下方法，可以做各种事情:)
init(ActionServlet servlet,ModuleConfig config)
ActionServlet:中央控制程序
ModuleConfig: 对应struts-config.xml所有信息
ActionMapping:对应struts-config.xml里的action
ActionForward:对应struts-config.xml里的forward

//
Colliction type = m.getAllBookType();
ServletContext application = servlet.getServletContext();
application.setAttribute("book_types",type);

(72)
<logic:iterate id="bookType" name="book_type" scopte="application">
 <bean:write name="bookType" property="id"/>
 <bean:write name="bookType" property="desc"/>
</logic:iterate>
Collections.sort(List);//按定好的方法排序
Collections.sort(List,Comparator);//临时指定排序逻辑

接口:
Comparable:实现该类，并复写compared();
Comparator:int compare(Object,Object);

class BookNameComparator implements COmparator{
 public int compare(Object o1,Object o2){
  BookType b1 = (BookType)b1;
  BookType b2 = (BookType)b2;
  return b1.getName().compareTo(b2.getName);
 }
}

(73)
static 内部类 :是为这个类本身服务的。
class BookType implements Comparable{
 public static finally Comparator BY_NAME =  new NameCoparator();
 private static class NameCoparator implementor{
 public int compare(Object o1,Object o2){
  BookType b1 = (BookType)b1;
  BookType b2 = (BookType)b2;
  return b1.getName().compareTo(b2.getName);
 }  
 }
}

Collections.sort(list,new COmparator(){
 public int compare(Obejct o1,Object 2){
  BookType b1 = (BookType)o1;
  BookType b2 = (BookType)o2;
  return b1.getName().compared(b2);
 }
});

(74)
resulSet 在执行sql语句时，(select * from emp)是，不是一下全取出数据，而是一次取部分

（
oracle默认是10），在执行next()时在取。所以不能断开连接。

有时侯将resultSet付给容器，其目的是为了减少再次编译时间，并不是将结果保存到容易中。

(75)
Statement中有个getFetchSize()方法，返回一次取多少条记录。高手用。
(76)
jdk1.5新加功能 rt.jar jdbc:
有个RowSet，也是用来访问数据库的，
Class.forName("oracle.jdbc.OracleDriver");
Object obj = Class.forName("com.sun.rowset.CacheRowSetImpl");.newInstance();//反射机

智创
造对象
RowSet rs = (RowSet)obj;
rs.setUrl("");
rs.setUsername("");
rs.setPassword("");
rs.setCommand("");
rs.execute();
while(rs.netxt()){
 System.out.println(rs.getString(1));
}
rs.close();
(77)
struts中的标签
html:显示用
bean:用来取page,request,session,application中的数据
logic:逻辑用
(78)
1 ,web.xml中声明
2 ,<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html"%>
3 ,lib加入实现类
定义一个标签共需要以上三个步骤

(79)
<html:html/>
<html:link href="www.163.com">
//跟写<a />一样功能
 href
</html:link>
<html:link forward="login">
//forward需要在struts-config.xml中全局中定义，
 
</html:link>
<html:link page="/htmlLink.do" paramId="id" paramName="123" paramProperty="a">
//可以链接到action和页面 action需要在struts-config.xml中定义
//paramId相当于key //paramName相当于value
//没有paramProperty=""，显示结果是 "id="123" "
//有paramProperty="a"，则结果是" id="123".getA() "
 page（/htmlLink.do 或者/login.jsp）
</html:link>

是否有".do"，关键在于需要调用servlet
在struts中"/"表示本应用的相对路径
在struts标签中看到Name说明是个bean
(80)
struts中的文件上传标签
<html:form action="HtmlFile.do" enctype="multipart/form-data">
 <html:file property="file"/><br/><br/>
 <html:submit>submit</html:submit>
</hmtl:form>
定义一个form,
import org.apache.struts.upload.FormFile;

在action 中的动作：
HtmlFileForm f = (HtmlFileForm)actionFrom;
FormFile file = f.getFile();
String filePath = this.servlet.getServletContext().getRealPath("/uploads");

//servlet是中
央控制器
FileOutputStream fos = new FileOutputSteam(filePath+"/"+file.getFileName());
BufferedOutputSteam bos = new BufferedOutputSteam(fos);
InputStream is = file.getInputSteam();
BufferedInputSteam fis = new BufferedInputSteam(is);

int b = -1;
while(b=fis.read()!= -1){
 bos.write(b);
} 
bos.flush();//同时将缓存中的数据写到本地。//close()也会调用这个方法的
(81)
<html:form action="/HtmlForm"> //HtmlForm不用写.do，如果用html调用时需要写.do
 <html:text property="name"/>//property相当于html中的name
 <html:submit property="submit"/>
 <html:hidden property=""/>
 <html:optionsCollection name="book_types" label="desc" value="id"/>
 //name是四个中的一个值
</html:form>

<bean:define id="v1" value="vean-v1" scope="request"/>
<bean:define id="v1" name="" property=""/>

//定义一个变量
//id:变量的名字
//scope:变量范围
//value:变量的值
//name:与四种存值方式相对应
//property:get,set方法对应

<>
(82)
${stu1.name} //struts中jsp2.0 表达式可以直接使用
(83)
<%
 Student student = new Student();
 student.setName("xml");
 pageContext.setAttribute("stu",student);
%>
<logic:equal value="xml" name="stu" property>
 ok
</logic:qual>
//一般来说是比较字符串，如果两个多是数字则，按数字来比较

(84)
 Map map = new HashMap();
 map.put("one",new Integer(1);
 map.put("two",new Integer(2);
 Set set = map.entrySet();
 Iterator it = set.iterator();
 while(it.hasNext()){
 Map.Entry entry = (Map.Entry)it.next();
 entry.getKey();entry.getValue();
 //Map.Entry内部类
}

(85)
分步式：
 EJB，JMS，SOCKET，WEBSERVICE都可以实现的。
JMS （JAVA MESSAGE SERVICE）
Destination:消息容器（用来存放消息的容器）
 包括：队列（Queue）:点对点传送消息
 和主题（Topiz）：
Connection:消息连接
ConnectionFactory:消息连接工厂
JNDI:把资源和组建绑定。 

(86)
import javax.jmx.*;
import javax.naming.*;

QueueConnectionFactory qcf;
QueueConnection qc;
QueueSession session;
QueueSender sender;
TextMessage message;
Queue q;

Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,"weblogic.jndi.WLInitialContextFactory");//

用
WLInitialContextFactory做一个工厂
env.put(Context.PROVIDEX_URL,"t3://localhost:7001");//weblgic协议

Context ctx = new InitialContxt(env);//用上面的信息做一个Context
qcf = (QueueConnectionFactory)ctx.lookup("CF"); //查找JNDI "CF"已经在webligic中定义

好了
q = (Queue)ctx.lookup("queue");//查找JNDI
ctx.close();

qc = qcf.createQueueConnection();
session = qc.createQueueSession(false,Session.Auto_ACKNOWLEDGE);//自动应答
se
nder = session.createSender(q);
message = session.createTextMessage();
//

(87)

EJB:
1 是服务器段组件
2 分布式组件（远程调用）
3 容器提供服务支持
(88)
session分为有状态和无状态bean.
 一般应用中用无状态的会话bean.因为一般在用session和request中就可以保存状态，

用ejb
来保存状态，对性能要求太高。

session分为stateful和stateless.

(89)
实体bean:完成数据的持久化。
不使用ejb有几个原因。1 性能。2 过于复杂。

EJB设计是为了使操作简单，而事实却相反。
性能：对数据库访问本身就是性能的要害。
复杂：过于复杂，重量级。

bmp:由自己来管理持久化。
cmp:由容器来管理持久化。
(90)
项目性能的，首先在于数据库的设计，其次是o/mp，而代码级是最小的。
(91)
通过EJBObject 对Entity Bean操作。
(92)
面试准备：
 笔试就是基本工。（编程习惯）lang,io,util,thread,jsp(标签),servlet,jstl(标签
),struts(标签)。
 面试：（编故事）。说了就一定得会。心得体会。
  java设计模式。1 原理，类图。2 那些api用了这些模式。3 自己实际在项目

中用的
模式（为什么做）。
  （uml）
(93)
在session bean中访问entity bean,
需要在session bean中实现。

CustomerHome ch;
pulbic void ejbCreate() throws CreateException{
 Context ctx = new InitialContext();//
 ch = (CutomerHome)ctx.look("customer");//weblogic-ejb-jar.xml中查找
 //session bean访问entity bean是本地接口，不需要造型
 
} 
(94)
EJB QL:
Cutstorm ,Order,Item,Book

select i.orger.Cutomer.name form Item i where i.date =?1

select object(o) form Order o,Customer c //声明

select o.id form Customer c,IN(c.orders) o where c.name=?1 and o.createTime=?2

select i.date from Cutorm c,IN(c.orders) o,IN(o.items) i where c.id=?1 and

i.book.name 
=?2

(95)
合成模式：（与装饰模式相识，合成是可以包含多个父类，复写父类的方法）
 应用：文件搜索
观察者模式：
 java.util.Observer;//观察者
 java.util.Observable;//被观察者

 class Hero extends Observale{
  private int x,y;
  public void move(int dx,int dy){
  x += dx;y += dy;
  this.setChanged();//状态改变
  this.notifyObservers();//通知
  }
  pulbic String getXY(){
   //
  }
    
 }
 class WeaponA extends Weapon{
  WeaponA(Observale o){super(o);}
  public void update(Observale o,Object arg){//o被观察者,args
  Hero hero = (Hero)o;
  System.ou...
 }
 }
 class WeaponB extends Weapon{
  WeaponB(Observale o){super(o);}
  public void update(Observale o,Object arg){
  Hero hero = (Hero)o;
  System.ou...
  }
 }
 abstratct class Weapon implements Observer{
 Weapon(Observale o){
  o.addObserver(this);
  }
 }

(96)
EJB QL
 finder and seletor
 访问BEAN的对象
 除了findByPrimaryKey所有的（finder and seletor ）方法都要在ejb-jar.xml中定义

。用
<ejb-ql>。
 Finders:在home 和local home中定义。返回的是EJB OBJECT对象。不能返回related

date。
在ejb-jar.xml 的<ejb-ql></ejb-ql>之间。
 Selectors:可以返回Bean Object ，可以返回字段。需要在实体bean中定义（不象

finder在
home接口中定义），需要在ejb-jar.xml中描述。
 命名：finder<method> 和ejbSelect<method>
 finder可以暴露给客户。select由内部使用，客户无法调用。
 返回：finder:返回写在的实体的对象。select：可以返回任何对象（在一个包中）或

容器或
CMP fields。
 finder:select object(o)...
 
(97)
 在jbuilder中建立实体关系。
 Clear默认关系，建立关系。
 删除实体中与（建立关系新生成）字段重复字段。
 将有用字段加入到ejbCreate(...)方法中
(98)
 在session中返回用户的消费。
 ch.findByPrimaryKey(customerID){
 Customer c;
 c.getOrders();
 Collection orders = getIterm();
 //..
}
 //需要多次访问实体。
 //解决方法是在Customer中使用select方法。
 
 select i.price from Customer c IN(c.orders) o IN(o.items) i
 在BEAN中有ejbSelectTotalitemPrice
 在ejb-jar.xml 有select i.price from Customer c IN(c.orders) o IN(o.items) i
 在Customer中定义selectTotalitemPrice（）方法。
 需要在BEAN中实现selectTotalitemPrice（）方法。
 public double getTotalprice(){
  COllection prices = ejbSelectTOtalItmePrimece(getId());
  Iterator it = prices.iteratoro();
  double sum = 0.0;
  while(){
   //...
  }
 }
(99)
 在Session Bean中实现查找与通过在实体BEAN中用select方法。应该后者效率更高些。

因为
用Session Bean 需要多次访问。
(100) 
 每个实体bean都有一个EntityContext.
 (Customer)entityContext.getEJBLocalObject().//
 通过entityContext可以获得和这个实体Bean相关的方法。
(101)
 j2ee核心设计模式。
 Delegate模式是为了封装远程调用的复杂性。
 JMSService和EJBService都是分布式。
 Delegate模式只在分布式情况下使用。
 Delegate需要调用ServiceLocator(singleton)，ServiceLocator在lookup 
BushinessService.
(102)
 EJB使用stu,ske..协议。
 WebService使用XML的SOAP协议。

(103)
 UML图中，序列图中返回一般不画。除非特殊情况除外。默认调用就返回。
(104)
 //客户端访问EJB
 //将与weblogic有关的信息放入hastable中
 Properties pro = new Properties();
       

pro.put(Context.INITIAL_CONTEXT_FACTORY,"weblogic.jndi.WLInitialContextFactory");
        pro.put(Context.PROVIDER_URL,url);//url = "t1://localhost:7001"
 //通过hastable信息初始化context
        Context context = new InitialContext(pro);
 //在树上查找对象
        Object ref = context.lookup("jndi");//"jndi"是在ejb-jar.xml指定上树的
 //构造远程home对象
        home = (SessionHome)protableRemoteObject.narrow(ref,...class);
 //调用方法
 home.findByPrimaryKey(id){ ... }
(105)
 hibernate 访问DB是从session开始的。
 <session-factory>
  //有关hibernate连接数据库配置信息
 <mapping resource="test/hibernate/Book.hbm.xml"/> //可以这里写，也可以动态加

载
 </session-factory>
(106)
 1 将hibernate导入类包
 2 写hibernate.cfg.xml配置文件
(107)
 <hibernate-mapping package="test.hibernate'>
  <class name="Book" table="BOOKS">
   //必须有id项
   <id name="id" column="ID" type="java.lang.String">
    <generator class="assigned"/>
   </id>
   <property name="name" cloumn="NAME" type="java.lang.String" 
not-null="true">
   </property>
  </class>
 </hibernate-mapping>
(108)
 //用hibernate自带包调试
 Configuration config = new Configuration();
 config.configure("/hibernate.cfg.xml");//加载配置文件
 SessionFactory sessionFactory = config.buildSessionFactory();//创建工厂
 Session session = sessionFactory.openSession();//打开工厂

 Transaction tx = session.beginTransaction();//开启一个事务
 Book book = new Book();
 book.setId("10000");
 book.setName("hibernate");
 book.setPrice(new Double(60.00));
 book.set...

 session.save(book);
 tx.commit();
 session.close();
(109)
 1 hibernate简单，具有缓存技术
 2 把对数据库的实现完全用hibernate 来实现，优化做的特别好
(110)
 hibernate 中的session尽量重用。session 对于一个线呈是唯一的。
 hibernate中的sessionFactory是基本的类，功能已经很强大了。但我们要对它进一步

实现，
用组合实现。
 public class TestSessionFactory{
 private static SessionFactroy factory = null;
 private static Configureation config = new Configuration();
 private static ThreadLocal t1 = new ThradLocal();
 
 public static Session getSession() throws Exception{
  Object obj = t1.get();
  if(obj==null){
   if(factory==null){
    config.configure("/hibernate.cfg.xml");
    factory = config.buildSessionFactory();
   }
    Session session = gactroy.openSession();
    t1.set(session);
    return session;
  }else{
    return (Session)obj;
  }
 }
 public static void closeSession(){
  Ojbect obj = t1.get();
  if(obj!= null){
   Session session = (Session)obj;
   session.close();
  }else{
   session.close();
  }
 }
 }
(111)
设计模式
创建模式：用来构造对象的模式。java中2种创建对象方式，new和动态(java反射机制)。
1. 简单工厂模式(simpleFactory)：产品类（接口或抽象类）和具体产品。具体产品继承

于产品。工厂类（create）产品类（抽象类）。这里面有3个角色。什么时候用？需要把具体类

封装起来时，在不同的场合创建不同的对象，这些对象有共同的接口。把这种逻辑封装到工厂里

面。有时会有变形，工厂类会和产品类和2为一,抽象类有个静态方法，返回他的事例。例如：日

历（Clea..）类和DateFormate类。这两个类中会有创建类。返回本身的创建。 还有可能3个角

色和3为1，这就是单例模式。 Jdk1.5中的枚举就是多例模式。我什么时候用？比如连接数据库

的时候，可能连接不同的数据库（mysql,oracle），我就用到了工厂模式。还有平时中做项目时

，有几种实现，可以有ejb和javabean，我就用到了简单工厂模式。（合适的情况下，用合适的

对象）
2. 工厂方法模式：实际中的应用，jdk中的collection. 什么时候用？简单工厂是为了创

建产品。当两个父发生关系，当不同的条件生成不同的对象时，具体实现有子类来实现，就时用

这个模式。（家族的成员为另一个家族服务，比如：家族是枪和子弹，具体的枪和具体的子弹是

家族成员，枪的不同，决定了子弹的不同）。应该说明白了。
3. 抽象工厂方法模式：DTO模式就是用的典型的抽象工厂方法模式。有个抽象工厂类（

AbstratFactory），Product1类,Product2类。为什么用这个模式，把数据库表的访问封装。对

不同的表需要提供不同的DAO。为oracle和 mysql个写个实现类。
DAOFactory factory = DAOFactory.getInstance(“oracle”); 
CustormDTO dao = factory.getCustomDTO();
Dao.save(“”);
只要改变字符串就可以了。
比较简单时就举jdk的例子，复杂点的就举实际的应用。开闭原则（向变化是开发的，向修改是

封闭的）。我反编译JDK1.5中的enun用了多例。哈哈。。。
结构模式：用来描述类间的关系。
1. 装饰模式：具体的类，和装饰器。Component（抽象类），里面有个方法（比如read）

，具体有两个子类，这两个子类中也有这个方法(read)。实现：jdk中文件流。应用：IO的输入

输出。什么时候用？在做SWING中，主题有不同的颜色，字体和风格，用户可以来回切换，就是

用装饰模式来实现的。在一个主见中灵活的安装，切换时应用。
2. 合成模式：合成模式与装饰类图几乎相同，就是改为1 …n。装饰是1..1。就两种，叶

子和树枝。Junit中应用了合成模式。
3. 适配器模式：在代码重构是应用。比如过去的JDK中用vector ,和hashtable用的多，但

现在主要用arraylist, hashset等，而过去的却不能丢弃，这个时候用的比较多。使得对象既使

原来的方法可以应用，又有了新的功能。JDK中的Enemeration和Iterator.
4. 不变模式：String 就是典型的不模式。他的成员是finel类型，外面不能改变，不能

return。这个模式中大量的应用了clone(). 不变模式是线程安全的。hashCode不用改变，（

hashCode是根据成员变量算的）。为什么StringBuffer的equal不重写？因为他的变量是改变的

，所以写不写没有多大意义。像常量经常变的类，就无需实现hashCode.我们的应用：写了一个

复数类。一般说来实现了equal方法的，一般都是不变模式。Date中的get,set方法不推荐使用，

就是因为他实现了不变模式。Date中的setTime,getTime是供日期转换调用的，要想获得日期不

要用他们，用Clander类获得。

Public class Complex{//不应该有set方法，有set的方法就可以改变值了。
Private double a;
Private double b;
toString();
equal();
hashCode();
compabled();//如果实现compablable
}
(112)
XML:
<book>
 <bookName>java</bookName>
 <bookPrice>100.00</bookPrice>
</book>

xml文档和对象的映射
hibernate:数据库表和对象的映射.
Castor:从xml 文档中读数据，变成对象。
(113)
Session session = SessionFactory.getCurrentSession();
Transaction tx = null;

Customer customer = (Customer)session.load(Customer.class,customerID);//通过类明和类

型，查找xml文档
List list = session.find("select c  from Customer as c order by c.name

desc");//Customer是类明
session.delete(cusomer);//删除持久化

(114)
Customer c = home.findByPrimaryKey("id");
c.setName("name");//会马上改变数据库
(115)
HIBERNATE：
public class Customer implements Serializable{//需要实现Serializable接口
 //定义变量
 //get,set方法 
}
映射文件
<hibernate-mapping package="">
 <calss name="Customer" table="CUSTOMERS">
 <id name="id" column="ID" type="string">//column与set方法名相同
  <generator class="assigned"/>
 </id>
 <properator name="name" column="NAME" type="string"/>

 <set name="orders">//字段名
   <key column="CID"></key>//column:关联的字段，
   <one-to-many class="test.hibernate.Order">//class:用来指定关联的对象
   </one-to-many>
 </set>

 </calss>

</hibernate-mapping>

hibernate是在配置文件中做关联
(116)
在类中实现collection con = null;
set,get..
<many-to-one name="customer" class="test.hibernate.Customer">
 //
</many-to-one>
(117)
Order order = (Order)session.load(Order.calss,new Integer(105));
Customer c = order.getCustomer();
Syset...

对对象操作，必须转为持久化对象
(118)
Caster:开元组件，解析xml文件，做成对象。
<?xml version="1.0">
<item>
 <name></name>
 <descript></descript>
 <price></price>
 <quantity></quantity>
</item>
import org.exolab.castor.mapping.Mapping;

import org.exolab.castor.xml.Marshaller;//分组
import org.exolab.castor.xml.Unmarshaller;//解组

public class Item{
 private String name;
 private String descritp;
 private double price;
 private int quantity;

 public String get..
 public void set..
}

Unmarshall//把xml变成对象。
Marshall//把对象变成xml文件。

//将xml做成对象
FileReader fr = new FileReader("c://temp//item.xml");
Item item = Unmarshaller.unmarshal(Item.class,fr);

//将对象作成xml文件
Item item = new Item();
item.set..();
..
Marshaller.marsha(item,new FileWriter("c://temp//iteml.xml"));
//默认时，把数字型存成属性，字符型存成成员。

如果存在嵌套，需要新定义文件。
mapping.xml
<?xml version="1.0"?>
<mapping>
 <class name="tst.xml.castor.Item">
 <field name="name" type="string"/>
 <field name="desc" type="string">  //
  <bind-xml name="description"/>
 </field>
 </class>
</mapping>

1 载入包 import org.exolab.castor.mapping.Mapping;
2 Mapping mapping = new Mapping();
  mapping.loadMapping("mapping.xml");
  Unmarshaller unmarshaller = new Unmarshaller(Item.class);
  unmarshaller.setMapping(mapping);

  FileReader fr = new FileReader("c://temp//item.xml");
//  Item item = unmarshaller.unmarshal(Item.class,fr);
  Item item = unmarshaller.unmarshal(fr);
  System.out.println(item.getName());

///

mapping.xml
<?xml version="1.0"?>
<mapping>

 <class name="tst.xml.castor.Item">

 <field name="name" node="attribute" type="string" > //node:表示是元素
               <bind-xml node = "attribute/">
        </field>

 <field name="desc" type="string">  //
  <bind-xml name="description"/>
 </field>
 </class>
</mapping>

<web-app>与属性webApp相对应。
Schema是用来定义标准的，用来约束xml文档。用来规定另外一个xml，那些元属该写，那些不该

写。
有两种dtd和Shchema。

通过shchema生成。
<?xml version="1.0" standalone="yes"?>
<order>
 <item/>
 <item/>
 <item/>
</order>

public class Order{
 private Vector item;
 get,set..
}
<?xml version="1.0"?>
<mapping>
 <class name="test.xml.caltor.Order">
  <field name="items" type="test.xml.castor.Item"  

collection="Item">
 </class>
 <class name="test.xml.caltor.Item"> 
  //...
 </class>
</mapping>

今天学习解析有xml共有三种
1: Unmarshaller.unmarshaller(Class,Reader);
 //所有的元属与类的属性必须相同。
2: 应用一个配置文件。
 Mapping.loadMapping(...);
 unmarshaller.setMapping(mapping);
 //需要会写mapping文档
3:
(119)
driver:com.mysql.jdbc.Driver;
url:jdbc:mysql://localhost:3306/sampledb
(120)
 import org.exolab.castor.xml.*;//导入命名空间
(121)
多线程，IO，Collection
(122)
重载和重写的区别。
一个是前期绑定一个是后期绑定。
(123)
静态方法或变量
class A{
static int a = 1;
static void f(){}
}
class B extends A{
static int a = 2;
static void f(){}
}
public static void main(){
A a = new B();
a.a// A的a
a.f();//A的f()
}
静态的是类的东西，与对象没关系
如果变量不是静态的（int a），
成员变量不叫重写，叫隐藏。

访问控制
public,fridendly 类前面。
public,fridendly,protected,private方法前面。
什么时候加protected?一个抽象类，需要子类来扩充，需要用protected

接口和抽象类(interface,abstract)
接口可以继承接口。
抽象类不能被示例化。只能被继承。
能用接口就不用抽象类。
子类公共的部分提取出来，要用抽象类。
继承是怎么想出来的？
 方法的实现，就用抽象类。
什么时候用抽象类？用继承的同时用重用（代码重用）。
什么时候用接口？用继承不必用重用。

接口的回调。comparable类的comparaTo方法。
事例：
class StudentList{
private ArrayList students;
public void addStudent(Student student){
this.students.add(students);
}

public void print(StudnetFilter filter){
Interator it = filter.iterator();
while(it.hasNext()){
Student student = (Student)it.next();
if(filter.match(s)){
 System.out.pirntln(s);
}
}
}
}
interface StudentFilter{
pubicvoolean match(Student student);
}

(124)
属性和成员变量。
一般相同。严格的讲是说：带有get,set方法的叫属性。
对象和变量。
对象放到堆中。栈中放的是变量。
(125)
Integer i = new Integer(1000);
//左边 声明变量i,类型是Integer
//右边 在内存创建一个对象，初始值是1000
//将地址复给i。
(126)
内部类的种类：
public class Test1{
 private class T{//这个类是为外边的对象服务的
  int i;
 }
}
对象和类之间的关系：
对象的属性值不一样。

静态内部类：
这个类是为外边的类服务的。
可以用pulbic来调用。
什么使用？这个静态内部类跟普通类一样。因为它的功能单一，就为这个类服务的。

局部匿名内部类：
只与方法有关系。

什么时候用他们？？
1，普通内部类。
 一个类运行，有个线程来跑
2，实现单一的功能。
 就相当与一个方法。

(127)
两个字符串一样hashCode一定一样，
两个字符串不一样hashCode不一定不一样。
Object的hashCOde默认是地址值。
subString(,);//前包后不包
StringTokenizeng()//类
string的正则表达式.
XXvalue();抛出NumberformatException异常。
日期：Calendar ,Date,Long
 GregorianClendar//阳历
 .getInstance();//按默认
 .getInstance(Locale lLocale);
 .get(int field);//获取字段值
 DAY_OF_WEEK_IN_MONTH//
(128)
 DateFormat,SimpledateFormat//按照指定的格式对日期格式化
(129)
 开闭原则。
 把变与不变分开来。面向接口设计。
 为什么要用继承：适应与面向对象的基本途径。符合开闭原则。 
(130)
XML：表示数据的规范。
java和xml是绝配。xml是数据无关。
java与其他语言传递数据，可以通过xml来传递。

1，设计出合理的xml表达数据，并且用schema
2，用java解析xml文件.

(131)
XML语法:基本语法
DTO,schema:对xml进行规范的。
解析xml:SAX,DOM
显示xml:xsl
(132)
XML语法:基本语法
XML与HTML，HTML复杂，XML简单。
XML：标签成对出现，可以加内容，可以加子标签。
 <book id="123"/>

<class-info id="123">
 <teacher>
  <name>...</name>
  <>...</>
 </teacher>
 <student id="1">
  <name>...</name>
 </student>
</class-info>
写的好就形成一个公用标准。
DTD，SCHEMA来描述标准。
SCHEMA也是一个XML文档。是一个已经规范了的。W3C组织。

解析xml:SAX,DOM
SAX是读一点对开始解析。效率高，编程复杂。
DOM是一下全读到内存中，效率底，编程简单。
数据绑定集合两者，具有跟好的功能。

显示xml:xsl
xml就表示数据。
(133)
HTTP(HyperText Transfer Protocol)
XML(extensible Markup Language)
(134)
<?xml version="1.0'encoding="GB2312" standalone="no"?>//可以有很多
//encoding以什么编码
//standalone是否独立
<?xml-stylesheet type="text/"?>//显示样式

<>
<>
区分大小写
必须有根元素
& ->&amp
> ->&gt
< -> &lt
" ->
'
<![CDATE[文本内容]]>
(135)
DTD:文档类型定义。
<!OCTYPE 书籍列表[
 <!ELEMENT 书籍列表（计算机书籍）*>
 <!ELEMENT 计算机书籍（书名，价格，简要介绍）>
 <!ELEMENT 书名（#PCDATA）>
 <!ELEMENT 价格（#PCDATA）>
 <!ELEMENT 简要介绍（#PCDATA）>
]>

可以直接写到文件前面，也可以写到另一个文件中，引用进来。
(136)
<!OCTYPE petris[
 <!ELEMENT petris(petri)*>

 <!ELEMENT petri(圆|方)*>
 <!ELEMENT 圆（点|线）*>
 <!ELEMENT 点（#PCDATA）>
 <!ELEMENT 线（#PCDATA）>
 <!ELEMENT 方（线*）>
 <!ELEMENT 线（#PCDATA）>
]>

(137)
public static final char sep='#';
//final在编译时就将sep替换成'#',提高效率

(138)
ArrayStoreException：
Object[] a = new String[2];
a[0]="a";
a[1]= new Integer(1);
String[] b = (String[])a; //抛出异常
(139)
String[] ar = (String[])Array.newInstance(String.class,3);
//用反射机智创建一个数组
(140)
定时类。
TimerTask:抽象类
Timer:

方法
schedule
scheduleAtFixedRate

随机函数
Random
属性
Properties
是hashTable的子类
数值
BigDecimal
反射机智
Class :
 classfoName("类的路径");
 Class.class();
 对象.getClass();
Method: 
 
Array :

(141)
class A{
public String f(Strings ,Integer i){
 return "f"; 
}
public String g(Strings ,Integer i){
 return "g"; 
}
}

A a new A();
String method = "f";
Class c = Class.foName("....A");
Ojbect  o = c.newInstance();
Method m = c.getMethods(method,new Class[]{String.class,Integer.class});
String str = m.invoke(obj,new Object[]{"abc",new Integer(1)});
System.out.println(str);
(142)
<!DOCTYPE person[<!ELEMENT person(#PCDATA)>
]>
<person>john</person>

//
cmd
> smxml -d 1.xml  //检查xml并打印

(143)
把DTD放到另一个文件中
<!DOCYTE person SYSTEM "2.dtd">
<person>john</person>
(144)
<!DOCTYPE person[
<!ELEMENT person(name,addr)>
<!ELEMENT name(#PCDATA)>
<!ELEMENT addr(#PCDATA)>
]>

<person>john</person>
(145)
<!DOCTYPE person[
<!ELEMENT person ANY>
<!ELEMENT name ANY>
<!ELEMENT addr(#PCDATA)>
]>

<person>
<addr>ht</addr>
<name>John</name>
</person>
(146)
<!DOCTYPE person[
<!ELEMENT person (name,addr,(tel|email))> //注意应该有空格的
<!ELEMENT name (#PCDATA)>
<!ELEMENT addr (#PCDATA)>
<!ELEMENT tel (#PCDATA)>
<!ELEMENT email (#PCDATA)>
]>
<person>
<name></name>
<addr></addr>
<tel/>//或</email>
</person>
(147)
#PCDATA  //文本内容
(148)
<!ELEMENT br EMPTY> //元素是空的，可以加属性
(149)
<!ENTITY email "iam@263.net"> //实体引用
//在DTO中可以规定系统不带的实体引用
email 代表"iam@263.net"

<email>&email</email>
(150)
<!ENTITY context SYSTEM "13.txt"> //引用本地文件

&context  //是13.txt的内容
(151)
<!ENTITY %name>
(152)
<!ENTITY % pc "(#PCDATA)">//%内部实体引用

(153)
<!ATTLIST book language CDATA "Englist">
//属性列表
<book language = "somelanguage">
 //...
</book>
(154)
<!ATTLIST book language CDATA #REQU> //必须指定
<!ATTLIST book language CDATA #IMPLIED> //可有可无
<!ATTLIST book language CDATA #FIXED> //定死的
<!ATTLIST book language CDATA (Engilsh|France) "Englist"> //可选的定死的
(155)
<tel>123456</tel>
DTD限制不够灵活，
Schema:本身就是一个xml，功能强大。用来约束其他的xml。
(156)
Schema:
一致性。与xml相同
扩展性。可以自己增加
规范性。比DTD更细。
(157)
<?xml version="1.0"?>
<xsd:schema>
 <xsd:element name="greeting" type="xsd:string"/>//xsd:string类型
</xsd:schema>

//xml文件内容
<?xml version="1.0"?>
//xml命名空间,是xml具有比较好的扩展性
<greeting xmlns:xsi="http://www.w3.org/2001XMLSchema-instance"
   xsi:noNamespaceSchemaLocation="hello.xsd">
Hello,Wrold.
</greeting>
(158)
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

<xsd:element name="customer">
<xsd:compleType>
<xsd:sequence>
 <xsd:element name="name" type="xsd:string"/>
 <xsd:element name="address" type="xsd:stirng"/>
</xsd:sequence>
</xsd:compleType>

</xsd:element>

</xsd:schema>
(159)
多线程的创建。
Tread中的基本的方法。
 默认一个线程.main()
 一个线程对应一个栈空间。一个程序记数器。
线程分为守护线程和非守护线程。
区别：java虚拟机是一个程序。如果发现现在所有线程都是守护线程，就会退出。
 setDaemon(boolean on)把守护线程变成非守护线程。
 例如给学生出题，打印时间就可以做成一个守护线程。
(160)
jdk1.5：多了一个同步包。java.lang.annotation
原来是开元东东，现在被吸纳到jdk1.5中。
(161)
1、servelt的生命周期？
Servlet接口，HttpServlet类，后者实现前者。
 init,service,destroy,
 init:事例初始化时调用。service:接到服务请求是调用,协议无关的，所有说servlet

不只能做web程序。destroy:事例被销毁前调用。
 HttpServlet：实现了servlet ,专门为http协议服务的。还具有其他方法。

doGet,doPost。get,post是http协议的两种方法。HttpServlet的servlet根据请求的协议头是

get,post方法，来调doGet,doPost方法。
2、ServletContext：包含上下文信息。相当于一个工具箱。一个它对应一个webApplication。

获取ServletContext属性。
ServletContext ctx = getServletContext();
ctx.setAttribute();//键值对
ctx.getAttribute();//通过键获得
ctx.getInitParameter();//
ctx.getInitParameterNames();//得到初始化的名，返回值是所有键

在web.xml文件中根：
<context-param>
 //web应用所共有的参数。
</context-param>
 
ctx.getRealPath();//返回文件的真实路径

RequestDiaptcher rd = ctx.getRequestDispatcher("a.jsp");//获取转发请求
rd.forward(request,response);//转发请求

ctx.getServerInfo();//servlet的基本信息

 

ServletConfig针对一个servlet。ServletContext针对的是一个application的。
<servlet>
 <init-param>
 //通过ServletConfig来获取
 </init-param>
</servlet>
(162)
ServletConfig://比较简单
ServletConfig config = getS3ervletConfig();
config.getinitParameter(String);
config.getServletName();
(163)
request,response:
request.getAttribute();//获取属性
request.getContextPath();//获取url的根目录
request.getCookies();//获取cook
request.getHeader(String);//获取http协议头里面的信息,协议以键值对方式存放
request.getRequestURL();// /TestServlet/hello
request.getRequestURI();// http://localhost:7001/TestServlet/hello
(164)
response:
response.addCookie();//
response.getWriter();//获取输出流
response.encodeURL(String);//重写url.有的ie不支持cook,进行重写。
(165)
获取请求信息：
request.getParameter();
session控制：
session每一个用户获取sessionId。
如果客户端禁止cook，就要进行url重写。
(166)
数据共享：Servlet是单实例多线程。
过滤：Filter 要求熟练写，和在 web.xml中配置
监听：
(167)
JSP:基本标签。//要求特别熟练
JSP怎么变Servlet？
(168)
内嵌对象：
out,exception,application,request,response,session,pageContext(jsp专有的)。
(169)
编码处理：
jsp的编码格式。rsponse.setContextType();
与<%@ page contextType="text/html;charst="UTF-8" %>对应
request.setCharacterEncoding("");//
<%@ page pageEncoding="UTF-8"%>//告诉servlet转码是按照这个方式编译
(170)
标签库：自己会写简单的标签库
(171)
JSTL表达式：要求自己会写