新东方学习笔记1

技术2022-05-11 139

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):处理数据库中的nullResultSet 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.16request.getHeader("");//获取协议头，以键值方式例:key - valuerequest.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 和ArrayListArrayList: 是用动态数组写的。里面使用视图原理，适合查询。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):标签库JSFJSTLSTRUTS

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

(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在内存中是9fileWrite: 调用后是9/

(15)强制类型语言

(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.PageContextImplcl.getName();//weblogic.servlet.internal.ServletRequestImplc2.getName();//weblogic.servlet.internal.session.MemorySessionDatac3.getName();//weblogic.servlet.internal.WebAppServletContext

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

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

已经学了以下jsp内置对象page<request<session<applicationexception,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)

日志：log4j1，改变输出权限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.PatternLayoutlog4j.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;继承 TagpageContext : 一个页面也个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,定义.tld3,添加web.xml4,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 //跳过bodyEVAL_PAGE //执行标签后面的东西

(37)标准标签库 JSTLcore 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 实质也是个ServletActionServlet 是中央控制器Form 是个bean ，用来保存数据，ActionServlet根据页面请求，调用from做成个对象，传给

action.

(46)Action path: url路径。FormBean name:封装的beanScope: 参数提交范围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: 传过来的fromHttpServletRequest: request请求HttpServletResponse: response响应

方法返回值：ActionForwardActionFroward 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.propertiesabc=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"/> //operationBpublic 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=Apage.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<-LookupDispatchActionDispathAction:<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.jspregist.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.xmlscope="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里的actionActionForward:对应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);//用上面的信息做一个Contextqcf = (QueueConnectionFactory)ctx.lookup("CF"); //查找JNDI "CF"已经在webligic中定义

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

qc = qcf.createQueueConnection();session = qc.createQueueSession(false,Session.Auto_ACKNOWLEDGE);//自动应答sender = 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>

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

<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的aa.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表达数据，并且用schema2，用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,DOMSAX是读一点对开始解析。效率高，编程复杂。DOM是一下全读到内存中，效率底，编程简单。数据绑定集合两者，具有跟好的功能。

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

<><>区分大小写必须有根元素& ->&> ->>< -> <" ->'<![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:

方法schedulescheduleAtFixedRate

随机函数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><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();//获取cookrequest.getHeader(String);//获取http协议头里面的信息,协议以键值对方式存放request.getRequestURL();// /TestServlet/hellorequest.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表达式：要求自己会写

专利

最新回复(0)