传智博客(JavaWeb方面的所有知识)听课记录(经典)
Posted 专注it
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了传智博客(JavaWeb方面的所有知识)听课记录(经典)相关的知识，希望对你有一定的参考价值。
一、 JavaWeb基础
第一天：
1．Eclipse详解：
(1).Bad versionnumber in .class file：编译器版本和运行(JRE)版本不符合。高的JRE版本兼容低版本的编译器版本。
(2).当程序有错误的时候，使用Debug as 运行程序。双击语句设置断点。程序运行到此处停止。点击跳入方法的内部代码。点击跳过，执行下一条代码，点击跳出，跳出方法。观察变量的值，选中变量右击 选择watch. 跳入下一个断点。查看断点，调试完后一定要清除断点。结束运行断点的jvm.
2．HashSet和hashCode和equals方法
java系统首先调用对象的hashCode()方法获得该对象的哈希吗，然后根据哈希吗找到相应的存储区域，最后取出该存储区域内的每个元素与该 元素进行比较.两个equals相等，hashCode()相等。需要重写equals,hashCode()方法.更改数据的值，hashCode() 的值也更改了，并未删除.内存泄露.有个东西不在被用，但是未被删除，导致内存泄露.
3．Junit测试框架
(1).在测试类，方法前加注解：@Test，不然出现初始化异常。
(2).方法before,after前加@Before,@After注解。在测试方法之前和之后运行方法。
(3).静态方法beforeClass,afterClass方法前加上注解@BeforeClass,@AfterClass，类加载的时候运行
(4).Assert断言。判断两个对象是否相等。期望值和实际值相等。
4．得到配置文件的路径
通过类加载器 reflect.class.getClassLoader.getResourceAsStream();在class指定目录下查找指定的类文件进行 加载.编译器把src中的.java文件编译成class文件，所有非.java文件，原封不动的搬过去.但是这种方法是只读的.
通过类的信息reflect.class.getResourceAsStream();相对路径
一般用绝对路径,使用配置文件告诉用户路径.
一定要记住要用完整的路径，但是完整的路径不是硬编码的，是计算出来的.
5．反射
(1).反射主要用于框架开发
(2).一个类有多个组成部分，例如：成员变量，方法，构造方法等，反射就是加载类，并解析类的各个组成部分。
(3).加载类使用Class.forName()静态方法，给类的完整名称，包名和类名。
(4).Class提供了解析public的构造方法，方法，字段等方法以及private。字段封装数据，方法执行功能
(5).静态方法无需传递对象，method.invoke()
(6).升级时保持兼容性，main函数的解析有点麻烦,反射解析数组参变量的时候的问题。启动Java程序的main方法的参数是一个字符串数 组，即public static void main(String[] args),通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢?按照jdk1.5的语法，整个数组是一个参数，而按照 jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理 呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成若干个单独的参数。所以，在给main方法传递参数时， 不能使用代码mainMethod.invoke(null,newString[]{"xxx"}),javac只把它当做jdk1.4的语法进行理 解，而不把它当做jdk1.5的语法解释，因此会出现参数类型不对的问题。解决的方法：
mainMethod.invoke(null,newObject[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)newString[]{"xxx"});编译器会做特殊处理，编译时不把参数当做数组看待，也就不会把数组打散成若干个参数了.
(7).对数组进行反射:相同的维数(不是数组元素的个数,例如都是一维数组，不关心数组的大小)，相同的8种基本数据类型时数组有相同的字节码.
6． 泛型
(1).泛型是对象类型，不能是基本类型，泛型存在源代码级别上，给编译器看的，生成class文件就不存在泛型了
(2).参数类型变量，实际类型变量，泛型类型，参数化的类型
(3).自定义泛型方法：public <T> void method(T args){};public<T,K,V> void method(T a,K b,V c){};
(4).静态方法public static <T> void method(T t){};泛型类不作用静态方法
7．可变参数
(1).可变参数就看成数组，可以使用增强for循环
(2).可变参数列表为最后一个参数
(3).可以给可变参数传递一个数组
(4).可变参数的类型是基本类型还是对象类型
8．课程介绍
(1).在谷歌心目中，“云”必须具备以下条件：数据都存在网上，而非终端里，软件最终消失，只要你的“云”设备拥有浏览器就可以运行现在的一切， “云”时代的互联网终端设备将不仅仅是PC，手机，汽车，甚至手表，只要有简单的操作系统加个浏览器就完全可以实现，由于数据都在“云”端，企业的IT管 理越来越简单，企业和个人用户也不同在担心病毒，数据丢失等问题。
(2).李开复描述了这样一个场景，只要你的PC或手机等终端里安装了一个简单的操作系统和完整功能的浏览器，开机后输入自己的用户名和密码，你存在“云”中的应用软件和数据就会同步到终端里。
9．快捷键
(1).配置快捷键：window->preferences->key
(2).Alt+/ :内容提示
Ctrl+1 :快速修复
Ctrl+Shift+O :快速导入包
Ctrl+Shift+F :格式化代码
Alt+方向键 :跟踪代码
Ctrl+Shift+/ :添加注释
Ctrl+Shift+\ :取消注释
Ctrl+Shift+X :更改为大写
Ctrl+Shift+Y :更改为小写
Ctrl+Shift+向下键 :复制代码
Ctrl+Shift+向上，向下 :改变代码行的顺序
Ctrl+T :查看继承关系
Ctrl+Shift+T :查看源代码
Ctrl+Shift+L :查看所有的快捷键
10．类加载器及其委托机制的深入分析
(1).Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap,ExtClassLoader,AppClassLoader
(2).类加载器也是Java类，因为其他java类的加载器本身也要被类加载器加载，显然必须有第一个类加载器不是java类，这正是BootStrap(内嵌到JVM的内核中，使用C++语言编写的)
(3).Java虚拟机中的所有类装载器采用具有父子关系的属性结构进行组织，在实例化每个类转载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载器
(4).
public class ClassLoaderTest{
public static void main(String[] args){
System.out.println(ClassLoaderTest.class.getClassLoader().getClass().getName());
//输出为sun.misc.Lanuncher$AppClassLoader;
System.out.println(System.class.getClassLoader());
//输出为null,因为类System是由BootStrap加载的;
}
}
(5).BootStrap->ExtClassLoader->AppClassLoader
ClassLoader loader= ClassLoaderTest.class.getClassLoader();
while(loader!=null){
System.out.println(loader.getClass().getName());
loader = loader.getParent();//往上顺序打印
}
System.out.println(loader);//最后打印老祖宗
(6).
BootStrap------>JRE/lib/rt.jar
ExtClassLoader----->JRE/lib/ext/*.jar
AppClassLoader------>ClassPath指定的所有jar或目录
用Eclipse的打包工具将ClassLoaderTest打包成itcast.jar,然后放在jre/lib/ext目录下，在 eclipse中运行这个类，运行结果显示为ExtClassLoader,此时的环境状态是classpath目录有 ClassLoaderTest.class,ext/itcast.jar包中也有ClassLoaderTest.class，这时我们在打印 ClassLoaderTest类的类加载名称，发现是ExtClassLoader,而不是AppClassLoader.
(7).类加载的委托机制：
当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢：
首先当前线程的类加载器去加载线程中的第一个类
如果类A中引用了类B，Java虚拟机将使用加载类A的类加载器来加载类B
还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类
每个类加载器加载类时，又先委托给其上级类加载器
当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException，不是再去找发起者类加载器的儿子，因为没有getChild方法，即使有，那么多个儿子，找哪一个呢？
对着类加载器的层次结构图和委托加载原理
(8).Thread类有一个方法setContextClassLoader(ClassLoader classLoader)//加载当前的类.
(9).每个类加载都首先会委托送到BootStrap，那么BootStrap很累，这样，那为什么不多搞几个BootStrap呢，之所以不这 样做，是因为，便于统一管理，因为所有的类都会找BootStrap，可能这时有几个相同的类进行加载，那么BootStrap，不会多次将他们的 class文件加载内存中，只会加载一份即可.这样效率就高了.
(10).
public class MyClassLoader{
public static void main(String[]args){
String srcPath=args[0];
String destDir=args[1];//得到目录
String destFileName =srcPath.substring(srcPath.lastIndexOf(‘/‘)+1);//得到文件名
String destFilePath=destDir+"\\"+destFileName;
FileInputStream fis = newFileInputStream(srcPath);
FileOutputStream fos=new FileOutputStream(destPath);
cypher(fis,fos);
fis.close();
fos.close();
}
private static void cyp(InputStreamips,OutputStream ops){
int b =-1;
while((b=ips.read())!=-1){
ops.write(b^0xff);//对内容进行异或处理
}
}
}
class ClassLoader extends Date{
public String toString(){
return "hello,itcast";
}
}
args[0]:ClassLoader.class的绝对路径
args[1]:itcastlib
有包名的类不能调用无包名的类.
(11).编写自己的类加载器：
知识讲解：
自定义的类加载器必须继承ClassLoader(抽象类)
覆盖findClass方法
defineClass方法:得到class文件转换成字节码
编程步棸：
编写一个文件内容进行简单加密的程序
编写了一个自己的类加载器，可实现对加密过的类进行装载和解密
编写一个程序调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类，程序中可以出了使用ClassLoader.load方法之外，还可以使用设置线程的上下文类加载器或者系统类加载器，然后再使用Class.forName
(12).
模板设计模式：
父类--->loadClass(相同的)
子类1(自己干的)
子类2(自己干的)
覆盖findClass方法(自己干)
(13).
public class MyClassLoader extendsClassLoader{
public MyClassLoader(){
}
public MyClassLoader(String classDir){
this.classDir = classDir;
}
@Override
protected Class<?> findClass(Stringname){
String classFileName = classDir +"\\" + name + ".class";
FileInputStream fis = new FileInputStream(classFileName);
ByteArrayOutputStream bos = newByteArrayOutputStream();
cypher(fis,bos);
fis.close();
byte[] bytes = bos.toByteArray();
defineClass(bytes,0,bytes.length);
return super.findClass(name);
}
public static void main(String[] args){
Class clazz = newMyClassLoader("itcastlib").loadClass("ClassLoaderAttachment");
ClassLoaderAttachment d1 =clazz.newInstance();
}
}
(14).windows->showview->problem查看错误.
(15).可以查看Servlet的类加载委托继承树
11． 枚举
(1).枚举的作用限定指定的值，没有枚举前设计一个类，将构造函数设置成私有的，变量设置成静态常量
(2).枚举可以有构造函数(私有的)，字段，方法
(3).可以定义set,get方法，获取变量的值。
(4).带有抽象方法的枚举，不能new出新的对象了。在new对象的时候就重写抽象方法，使用匿名内部类
(5).枚举中的每个枚举值代表枚举类的一个对象。
(6).枚举也可以实现接口，或继承抽象类
(7).JDK5中的switch拓展为除了接受int,short,char,byte外，也可以接受枚举类型。
(8).枚举的方法，name,ordial,valueOf,将字符串转换成枚举值。表单提交数据的时候。values返回枚举的所有的枚举值
12．内省
(1).内省:Introspector，专门操作Bean的属性。
(2).Bean的属性：只有字段提供了set/get方法，就是属性。只要有get/set的方法，就有一个属性，所以属性是有get/set方法决定的
(3).任何类都继承了Object类，又因为Object中有一个class属性
(4).内省的入口类：Introspector，方法getPropertyDescriptors()获取Bean的属性
(5).操作Bean的指定属性
(6).BeanUtils框架操作Bean
(7).在工程中新建一个文件夹，将架包复制到文件夹中，还需另外的架包loging,选中架包，右击build path加入到工程的环境中
(8).BeanUtils使用方便，类型自动转化，只支持8中基本数据类型
(9).给BeanUtils注册类型转换器，ConvertUtils.register()
(10).将Map中的数据整合到对象中，BeanUtils.populate()方法
13．配置Java模板代码
window->preferences->java->Editor->Template:编辑模板代码：line_selection,光标cursor，右击选择source with
14．享元模式
相同的对象只实例化一个，实例：桌面上的图标，word中字符，有很多小的对象，有很多相同的属性，不同的属性叫做外部行为，相同的属性叫做内部行为integer的缓冲池
15．注解
(1)[email protected]("deprecation")过时注解
(2)[email protected]注解，表示该方法是否过时，架包升级时添加的注解
(3).注解相当于一种标记，通过反射了解你的类及各种元素上有无何种标记
(4).注解相当于一个类：@interface Annotation{};注解类，应用注解类的类，对应用了注解类的类进行反射操作的类
(5).AnnotationTest.class.getAnnotation(ItcastAnnotation.class)得到类AnnotationTest上的注解ItcastAnnotation，注解上使用注解叫做元注解，元数据，元信息
(6)[email protected](RetentionPolicy.RUNTIME)(保持到运行阶段),@Retention(RetentionPolicy.SOURCE)(保持在源文件阶 段),@Retention(RetentionPolicy.CLASS)(保持在class文件中)：源代码->class文件->(类加载)内存中的文件(字节码)
(7)[email protected]注解保持到SOURCE,@SuppressWarning注解保持到SOURCE，@Deprecated注解保持到RUNTIME(只有将该类调到内存中才知道该类中的方法是否过时了)
(8)[email protected]({ElementType.METHOD,ElementType.TYPE})注解只能标记到方法上或类,接口等类型上 (9).注解的属性：String color();类有个color属性,还有一个特殊的属性value,属性的默认值default,数组的属性值,枚举的属性值,注解的属性值
第二天：
1．dom4j解析XML文档
(1).Dom4j是一个简单、灵活的开放源代码的库，Dom4j是由早期开发JDOM的人分离出来而后独立开发的，与JDOM不同的是，dom4j使用接口和抽象基类，虽然Dom4j的api相对要复杂一些，但是他提供了比JDOM更好的灵活性
(2).Dom4j是一个非常优秀的Java XML API,具有性能优异、功能强大和极易使用的特点，现在很多软件采用的Dom4j,例如hibernate,包括sun公司自己的JAXM也使用了Dom4j
(3).使用Dom4j开发，需要下载dom4j相应的jar文件
2. XML语法
(1).编写XML文档时，需要先使用文档声明，声明XML文档的类型，使用IE校验XML文档的正确性.
(2).XML文档中的"中国"保存为本地的码表的"中国"
(3).在XML文档中，空格和换行都作为原始内容被处理
(4).XML区分大小写，一个标签可以有多个属性，每个属性都有它自己的名称和取值，在XML技术中，
标签属性所代表的信息也可以被表示子标签表示
(5).XML文件中的注释采用:"<!-- >"格式
(6).CDATA区域内的内容，XML解析程序不会处理，而是直接原封不动的输出
(7).转义字符: "<":< ">":>
3. Xml语言
在xml语言中，它允许用户自定义标签，一个标签用于描述一段数据，一个标签可分为开始标签和结束标签之间，又可以使用其他标签描述其他数据，以此来实现数据关系的描述.用于配置文件，以描述程序模块之间的关系
4. XML约束
(1).在XML技术里，可以编写一个文档来约束一个XML文档的书写规范
(2).常用的约束技术:XML DTD 和 XML Schema
(3).如果dtd文件中含有中文，一定要存为utf-8格式.
(4).IE5以上的浏览器内置了XML解析工具：Microsort.XMLDOM,开发人员可以编写javascript代码，利用这个解析工具装载xml文件，并对xml文件进行dtd验证.创建xml文档解析器对象：
var xmldoc = newActiveXObject("Microsoft.XMLDOM");
开启xml校验
xmldoc.validateOnParse= "true";
装载xml文档
xmldoc.load("book.xml");
获取错误信息
xmldoc.parseError.reason;xmldoc.parseError.line
(5).将DTD文件导入到eclipse中，可进行校验xml是否遵循dtd文件
在xml文件中编写DTD
第三天：
1．HTTP请求头各个头字段详解
请求头详解:
Accept:text/html,image/*用于告诉服务器，客户机支持的数据类型,
Accept-Charset：客户机采用的编码
Accept-Encoding:客户机支持的压缩格式
Accept-Language:客户机的语言环境,不同国家访问的内容也是不同的，就是通过这个头实现的，用于实现国际化
Host:www.it315.org:8080：告诉服务器，想访问的主机名
If-Modified-Since:客户机通过这个头告诉服务器，资源的缓存时间，提高访问效率
Referer:客户机告诉服务器，他是从哪个资源来访问服务器的(防盗链),通过检查该头是否是从本网站点击过来的，如不是的，就让他跳到本网站的首页来
User-Agent:客户机告诉服务器，客户机的软件环境
Cookie:客户机通过这个头向服务器带点数据
2．Http请求行和请求方式
一个完整的HTTP请求包含：一个请求行，若干个请求头，以及实体内容，请求行，请求头，之后空一行，带有请求信息(如表单提交数据为post方式)如下所示
Get/books/java.html HTTP/1.1 :请求行，用于描述客户端的请求方式，请求的资源名称，以及使用的HTTP的协议版本号
Accept:*
Accept-Language:en-us
Connection:Keep-Alive
Host:localhost
Referer:http://localhost/links.asp
User-Agent:Mozilla/4.0
Accept-Encoding:gzip,deflate
以上的内容为多个消息头，用于描述客户端请求哪台主机，以及客户端的一些环境信息等
请求行中的GET称之为请求方式，请求方式：post,get,head,options,delete,trace,put,常用的 有:get,post，用户没有设置，默认情况下浏览器向服务器发送的都是get请求,例如在浏览器直接输地址访问，点连接访问都是get,用户如想把请 求方式改为post，可通过更改表单的提交方式实现.不管post或get，都用于向服务器请求某个web资源，这两种方式的区别主要表现在数据传递上： 请求方式为get方式，则可以再请求的URL地址后以?的形式带上交给服务器的数据，多个数据之间以&进行分割，同时在URL地址后附带的参数是 有限制的，其数据容量通常不能超过1k,若请求方式为post方式，则可以再请求的实体内容中向服务器发送数据，post方式的特点：传送的数据无限制
<ahref="1.html?name=aaaaaaa">连接</a>get方式
3．Http响应头字段详解
响应头:
Location:
这个头配合302状态码使用，用于告诉用户找谁
,response.setStatus(302),response.setHeader("Location","/day04/1.html");请求重定向，判断浏览器的地址栏的地址是否发生变化，实例是用户登录
Server:服务器通过这个头，告诉浏览器的类型
Content-Encoding:服务器通过这个头，数据的压缩格式,收费是靠数据出口量算的， 所以为了省钱和效率高，要进行数据压缩，jdk中的GZIPOutputStream类，压缩类流,包装流和底层流，最好将包装流关了或者刷新，数据写入到底层流中去,
response.setHeader("Content-Encoding","gzip");response.setHeader("Content-length",gzip.length+"");
Content-Length:服务器会送的数据的长度
Content-Type:服务器会送数据的类型，response.getOutputStream().write();服务器会送数据都是二 进制，通过这个头，可以告诉浏览器这个二进制是什么类 型，this.getServletContext().getResourceAsStream("/1.bmp");intlen = 0;byte buffer[] =new byte[1024];OutputStream out =response.getOutputStream();while((len=in.read(buffer))>0) {out.write(buffer,0,len)},在服务器的目录下的web.xml中查看各个数据类型的 respose.setHeader("content-type","")的写法.
Refresh:告诉浏览器隔多长时间刷新一次，response.setHeader("refresh","3;url=""")控制浏览器隔三秒跳到指定的网页上
Content-Disposition:告诉浏览器以下载的方式打开文件,response.setHeader("content-disposition","attachment;filename=3.jpg);
Transfer-Encoding:告诉浏览器数据的传送格式
ETag:缓存相关的头，服务器根据数据的内容生产一个字符串，客户机第二次访问服 务器时带来的ETag的值和服务器的值一样，就拿缓存给客户，实时更新，
Expires:高速浏览器，把会送的资源缓存多少时间，-1或0，则是不缓存的
Pragma：no-cache
Cache-Control:no-cache
控制浏览器不要缓存数据,当数据不发生改变时，就要缓存，当实时性要求很高的数据不能缓存.
4．Http响应状态行
HTTP /1.1 200OK :状态行，用于描述服务器对请求的处理结果
Server:Microsoft-IIS/5.0
Date:....
Content-Length:2291
Content-Type:text/html
Cache-control:private
多个消息头:用于描述服务器的基本信息，以及数据的描述，服务器通过这些数据的描述信息，可以通知客户端如何处理等一会它会送的数据
<HTML>
<BODY>
实体内容：代表服务器向客户端会送的数据
具体:
状态行：
格式：HTTP版本号 状态码 原因叙述<CRLF>
举例：HTTP1.1 200 OK
状态码用于表示服务器对请求的处理结果，他是一个三位的十进制数，响应状态码分为5类，
100-199:表示接收请求，要求客户端继续提交下一次请求才能完成整个处理过程
200-299：表示成功接收请求并已完成整个处理过程，常用200
300-399：为完成请求，客户需进一步细化请求，例如，请求的资源已经移动一个新地址，常用302(你请求我，我叫你去找别人),307和304(拿缓存)
400-499：客户端的请求有错误，常用404,403(没有权限访问)
500-599：服务器端出现错误，常用500
5．http协议概述
(1).浏览所有的服务器:
在命令行中敲入
telnet localhost 8080
GET /aa/1.html HTTP/1.1
Host:
(2).在HTTP1.0协议中，客户端和Web服务器建立连接后，只能获得一个web资源。在HTTP1.1协议，允许客户端与web服务器建立连接后，在一个连接上获取多个web资源。
(3).在命令行中敲入以上的命令，HTTP/1.0获取一次资源，就断开连接，而HTTP/1.1不会断开连接
(4).一个web页面中，使用img标签引用了三幅图片，当客户端访问服务器中的这个web页面时，客户端总共会访问几次服务器，即向服务器发送了几次HTTP请求：
<img src="1.jpg">
<img src="2.jpg">
<img src="3.jpg">
共四次请求，浏览器认识img标签，浏览器解析img，则img一次请求，最好将这三张图片整合到一张图片上，这样就只有两次请求了
(5).<scriptsrc="1.js">
<scriptsrc="1.js">
共三次请求，可以将多个js文件整合到一个js文件,避免多次向服务器发出请求
6． tomcat服务器目录结构
bin：存放启动和关闭Tomcat的脚本文件(命令)
conf：存放Tomcat服务器的各种配置文件(核心文件:server.xml)
lib：存放Tomcat服务器的支撑jar包
logs：存放Tomcat的日志文件(catalina文件)
temp：存放Tomcat运行时产生的临时文件
webapps：web应用所在目录，即供外界访问的web资源的存放目录
work：Tomcat的工作目录,jsp翻译成servelet文件
7．web服务器启动问题
(1).tomcat是使用Java编写的，启动的时候需要JVM,java环境设置不正确的话可能导致服务器不能启动，还有就是8080端口被占用了.
(2).在conf->中server.xml中对tomcat服务器进行配置
(3).我的电脑->计算机管理->服务->停止windows服务
(4).http://www.sina.com/是url;www.sina.com是主机名;sina.com是域名，在域名下可以搭建多个网站
(5).tomcat文件下的webapps下新建一个web资源
(6).Cataline_home环境变量的设置问题,服务器的目录，启动的服务器的目录要和服务器存放的目录一致
8． web开发相关概念和常见web服务器
(1).自己开发服务器:
public class Server
{
public static void main(String[] args)throws Exception{
ServerSocket server = newServerSocket(9999);//服务器建立端口
Socket sock server.accept();//客户端访问
FileInputStream in = newFileInputStream("c:\\a\\1.html");
OutputStream out = sock.getOutputStream();
int len = 0;
byte buffer[] new byte[1024];
while((len = in.read(buffer))>0){
out.write(buffer,0,len);
}in.close();
out.close();
sock.close();
server.close();
}
}
(2).WebLogic是BEA公司的产品，是目前应用最广泛的Web服务器，支持J2EE规范，是商业产品，需要收费
(3).常用的Web服务器IBM公司的WebShpere，也遵循J2EE规范，也要收费
(4).Tomcat服务器只支持JSP以及Servlet规范，不支持EJB，如果要支持可以使用JBOSS
(5).http:80,smtp:25,pop3:110,ftp:23,https:443
9. web应用和虚拟目录
(1).web应用虚拟目录映射：自己开发好的web应用项目到部署到服务器上的web应用项目的关系目录，在服务器的配置文件中配置，虚拟目 录，<Context path="/itcast"docBase="c:\news"/>,"/itcast"就是虚拟目录，"c:\news"是磁盘上web应用的 目录，修改配置文件后一定要重启服务器.http://localhost:8080/itcast/1.html，浏览c:\news\1.html文 件.当path=""时，就是缺省设置
(2).tomcatdocument中reference中观察tomcat的配置文件设置方法.在Catanena\localhost\新建一个context.xml文件.这种方法无需重启服务器.
<ContextdocBase="c:\news"/>,http://localhost:8080/1.html;多级虚拟目 录:文件名:a#b#c.xml,http://localhost:8080/a/b/c/1.html;缺省的虚拟目录，把文件名改成 ROOT.xml重启服务器，覆盖原先的缺省设置.
(3).webapps文件夹中的web应用可以让外界访问，又服务器自动映射目录,把news文件放到webapps中去，http://localhost:8080/news/1.html,当服务器和webapps不在一个目录时，此方法不可以.
10. web应用组织结构
(1).mail:Web应用所在目录
html,jsp,css,js文件等,这些文件一般存在web应用根目录下，根目录下的文件外界可以直接访问，java类，jar包,web应用 的配置文件存在这个目录下WEB-INF，这个文件夹的文件名一个单词都不能写错，这个文件要新建，在这个文件夹下载新建一个classes文件夹，放置 java程序，新建一个lib文件夹，放置架包，该目录下的文件外界无法非法直接访问，由web服务器负责调用.每个web应用应该有个web配置文件， 是最重要的一个配置文件，一切配置可以通过这个文件进行配置web.xml
(2).对于web.xml文件，可以从server.xml中拷贝，拷贝头和尾部分.
11. web资源访问流程
(1).服务器认识war包，自动解压，放到webapps中，自动生成应用.
(2).配置context元素的reloadable="true",应用程序修改，不需要重新发布应用，建议不要配置，因为只要一修改，就要重新加载，出现问题.
(3).context.xml中<Context>中配置，被所有的web应用使用.
12. 配置虚拟主机
(1).在一个tomcat服务器中可以放置多个网站，所谓配置虚拟主机，就是在tomcat服务器中配置一个网站
(2).如需在Web服务器中配置一个网站，需使用Host元素进行配置， 例:<Hostname="site1"appBase="c:\app"></Host>,配置的主机(网站)要想被外部访 问，必须在DNS服务器或windows系统中注册.
(3).在server.xml新建一个主机,新建一个Host标签，<Host name=www.sina.com appBase="c:\sina"><Contextpath="/.mail" docBase="c:\sina\main"/></Host>
(4).互联网访问流程:ie中输入错误！超链接引用无效。 返回给ie，接着使用ip地址访问sina.com
(5).ie开始会访问windows的host文件，如果这个文件知道这个地址，就不会去问DNS，没有则会去访问DNS服务器：/windows/system32/drivers/etc/hosts文件进行配置.
13. 软件密码学和配置tomcat的https连接器
(1).对称加密:加密和解密的密码是相同的.
(2).非对称加密:接受者生成一对公钥和私钥，公钥加密的数据只能私钥解，私钥加密的数据只能公钥解，然后接受者将公钥传给发送者,用接受者的公 钥进行加密,然后接受者用私钥解密.然而，在传送公钥的途中可能被黑客拦截，然后黑客自己生成自己的公钥和私钥，然后将公钥送给发送者，发送者如何知道公 钥是不是接受者的公钥?这是在互联网上有个叫CA的机构，接受者产生一对公钥和私钥，然后让CA认证，CA给接受者一份数字证书，这时发送者受到的是数字 证书，发送者验证数字证书是不是接受者的数字证书.信任点就是CA.网上银行出示一份数字证书(公钥),浏览器可以验证数字证书正确，注册，当你填写信息 时，浏览器就是用这份数字证书验证.但是数字证书可能被黑客拦截，怎么确定数字证书是接受者发的还是黑客发的，数字签名(私钥加密)，发送者自己生成一对 公钥和私钥，发送者想让接受者相信是自己加密的，发送者就需要签名(使用自己的私钥),然后只有接受者使用公钥解密，就相信是发送者将内容加密的.MD5 算法得到数据指纹.然后对数据指纹加密.将密文和指纹加密信息传给接受者，可以判断在传送过程没有被篡改，用密文生成数据指纹，和传过来的数据指纹对比.
第四天：
1．Eclipse开发servlet
(1).web工程的名称，该工程部署时，在webapps目录下就会有一个example的web应用
(2).src文件夹，Java程序的开发目录，该目录下编写的所有程序在部署时，会自动部署到example/web-inf/classes目录下
(3).WebRoot文件夹，webroot对应于web应用的根目录，该目录下的所有子目录和子文件夹在部署时，会原封不动的发布到web应用目录下
(4).Web rootfolder:WebRoot应用的根目录，Context root URL:映射到服务器的目录，在WebRoot目录下新建Web资源，应用发布时，将src文件夹中的源文件编译成class到webRoot\web- inf下的classes文件夹
(5).servlet导入源码，到tomcat服务器的目录下查找文件夹
(6).为servlet配置对外访问路径，
<servlet><servlet-name>
别名
</servlet-name><servlet-class>
类名(全称)
</servlet-class></servlet>
<servlet-mapping><servlet-name>
别名
</servlet-name><url-pattern>/aa<url-pattern></servlet-mapping>
(7).还可以更改tomcat的运行java环境
2． HttpServlet和一些开发细节
Servlet接口sun公司定义了两个默认实现：
GenericServlet,HttpServlet
httpservlet指能够处理HTTP请求的servlet,它在原有的servlet接口上添加了一些与http协议处理方法，它比servlet接口的功能更为强大，因此开发人员在编写Servlet时，通常应继承这个类，而避免直接去实现Servlet接口
httpservlet在实现servlet接口时，复写了service方法,该方法体内的代码会自动判断用户的请求方式，如为get请求，则调 用httpservlet的doGet方法，如为post请求，则调用doPost方法，因此，开发人员在编写Servlet时，通常只需要复写 doGet或doPost方法，而不要去复写service方法.可以查看httpservlet的源码,
修改servlet的模板代码.进入myeclipse,搜索Servlet.java文件，打开修改文件.
3．ServletConfig对象以及它的开发场景
(1).在servlet的配置文件中，可以使用一个或多个<init-param>标签为servlet配置一些初始化参数，当 servlet配置了初始化参数后，web容器在创建servlet实例对象时，会自动将这些初始化参数封装到servletconfig对象中，并在调 用servlet的init方法时，将servletConfig对象传递给servlet，进而，程序员通过servletconfig对象就可以得到 当前servlet的初始化参数信息.
(2).web服务器创建的容器对象
request,response,servletconfig,servletcontext,session,cookie
(3).servletconfig
配置参数信息.
<init-param><param-name>data</param-name><param-value>xxxx</param-value></init-param>
(4).覆写init()方法带有servletconfig参数的,服务器自动将参数信息封装到servletconfig对象中.调用 init()方法时，servlet可以得到这些参数信息.在servlet中定义一个servletconfig对象，将init()传递过来的 servletconfig接收到.private ServletConfig config;public voidinit(ServletConfig config){this.config = config;}String value =config.getInitParameter("data");System.out.println(value);参数信息不在程序中，而是在 配置文件.同时this.getServletConfig();代替privateServletConfig config;因为父类已经定义了ServletConfig对象，只需调用父类的getServletConfig方法即可.
(5).可以配置多个参数信息，同时为得到所有的参数信息:
Enumeration e =this.getServletConfig().getInitParameterName();
while(e.hasMoreElements())
{
String name = (String)e.nextElement();
String value =this.getServletConfig().getInitparameter(name);
System.out.println(value);
}
(6).开发过程中，参数不能在程序中写死，需要在配置文件中给出参数信息.实例:字符集，连接不通的数据库.读取不同的配置文件.
(7).struts就是个实例.可以到struts实例中查看struts的web.xml文件
4. ServletContext读取web应用中的资源文件
(1).在web开发中，用于资源文件的类型一般为两种xml,property，如果数据之间是没有关系就是用property，有关系就使用xml，数据库的连接关系没有关系，一般用property文件，
(2).db.properties文件，url=jdbc:MySQL://localhost:3306/test;username=root;password=root;读取db.properties文件.通用代码:
InputStream in
= this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
斜杠就代表web应用根目录,Properties props = new Properties();props.load(in);把文件load到Properties对象中，用Map对象存储String url =props.getProperty("url");
String username =props.getProperty("username");
String password = props.getProperty("password");
(3).web应用中不使用FileInputStream in = newFileInputStream("src/db.properties");采用的是相对路径，相对路径中有这个资源，这是相对路径相对的是 jvm的启动目录.当时jvm的启动目录是服务器的启动目录:服务器/bin
(4).另外的读取资源的方法:
String path = this.getServletContext().getRealPath("/WEB-INF/classes/db.properties");得 到硬盘的绝对路径 此时就可以使用FileInputStream in = new FileInputStream(path);需求:下载，可以得到资源的名称,读取文件时客户机带来的，当前读取的资源文件的名称.可以从path中截 取出来.
String filename =path.substring(path.lastIndexOf("\\")+1);
(5).在servlet中用dao对象操作数据库，dao对象需要properties文件的内容即数据库的连接信息.dao一般放到 cn.itcast.dao包中.不能将servlet中的context对象传递给dao对象，web层和服务层不能有交织了.如果读取资源文件的程序 不是servlet的话，此时要通过类装载器读取资源,在UserDao对象中InputStream in =UserDao.class.getClassLoader().getResourceAsStream,资源文件 ("db.properties");一般只需读取一次，有个习惯:将读取文件代码放在static{};静态代码块中.通常抛出初始化错误throw new ExcepitonInitaliterError(e);文件不能太大，类加载器要装载到内存中
(6).有人可能把properties文件改了.然后读取的内容是原始的，还是修改的，读取的是原始的,因为类装载的方式，但是类只装载一次.但 是想读取更新后的内容：String path =UserDao.class.getClassLoader.getResource("db.properties").getPath();然后用 FileInputStream去读取.
5. ServletContext对象
(1).web容器在启动时，它会为每个web应用程序都创建一个对应的ServletContext对象,它代表当前web应 用,servletconfig对象中维护了servletcontext对象的引用，开发人员在编写servlet时，可以通过 servletconfig.getServletContext方法得到servletContext对象.同时也可以context = this.getServletContext();得到父类的context查看servletContext api 文档了解servletContext对象的功能.
(2).servletContext为所有的servlet对象实现数据共享.是全局概念.方法getContext()为了得到别的web应 用.getInitParmeter()方法可以得到web应用的配置信息.getNameDispatcher()得到一个转发对 象.getRealPath()方法得到资源的硬盘真实路径,方法getResource()得到资源的路径，只是返回的是URL地 址.getResourcePaths()方法返回给定目录下的所有资源.getServletContextName()方法返回web应用的名 称.setAttribute(),getAttribute(),removeAttribute();
(3).由于一个web应用中所有servlet共享同一个servletcontext对象，所以多个servlet通过 servletcontext对象是实现数据共享。servletcontext对象通常也被称之为context域对象.可以获取web应用的初始化参 数，实现servlet的转发,利用servletcontext对象读取资源文件:得到文件路径，读取资源文件的三种方式，.properties文件 (属性文件),context域，request域，session域，page域.
(4).实例:聊天室,资源共享.开个浏览器说，开个浏览器读
(5).<context-param><param-name>data</param-name>
<param-value>XXXX</param-value></context-param>
和config不同，config是给某个servlet初始化参数，而context是所有的servlet初始化参数
(6).servletconfig中的初始化信息中连接数据库信息，应该写成context的初始化信息，因为可能有多个servlet需要数据库连接
(7).转发和重定向：转发：你找我，我帮你去找他，重定向：你找我，我告诉你，你自己去找他；如果是转发：只有一次请求，地址栏不发生改变重定 向：两次请求。servlet中不适合浏览器的数据的输出，因为要数据的排版，应该在html,jsp中输出数据.servlet要将输出数据要转发给 jsp显示.
RequestDispatcherrd = this.getServletContext().getRequestDispatcher("/1.jsp");
rd.forward(request,response);
在jsp中取数据，
<% String.data=application.getAttribute("data");out.write(data);%> servletcontext可以，但是在开发过程中是有问题的：有一个人来访问数据，把它的数据存到context中，当他在jsp中取数据的时候，此 时又来一个人，也来存数据，可能覆盖前一个人的数据，那前一个人取得数据可能是后来的那个人的数据，因为context是共享资源，存在线程安全问题.在 开发过程中一般用request域带数据.
(8).服务器启动时，为每个web应用创建servletcontext对象，当服务器停止时，servletcontext对象被销毁.
6. Servlet的生命周期
ie浏览器，web服务器,Servelet程序
浏览器输入地址->连接web服务器，发送HTTP请求，解析出客户机想访问的主机名,解析客户机想访问的web应用和web资源 -->使用反射技术创建一个servlet实例对象(servlet第一次访问的时候被创建)-->调用servlet.init()完成对 象的初始化->调用servlet.service()响应客户端的请求,服务器创建request,response容器,service方法执 行->向response容器中写入客户机请求的数据->服务器从response中取出数据构建一个HTTP响应回写给客户机--> 回写http响应
客户机第一次访问服务器,生成一个servlet，第二次在访问同一个servlet就不会再创建了，当关闭服务器时servlet就消亡了
7. Servlet的线程安全
(1).当多个客户端并发访问同一个servlet时,web服务器会为每一个客户端的访问请求创建一个线程，并在这个线程上调用servlet的 service方法，因此service方法如果访问了同一个资源的话，就有可能引发线程安全的问题,如果某个servlet实现了 SingleThreadModel接口，那么servlet引擎将以单线程模式来调用其service方法。SingleThreadModel接口中 没有定义任何方法，只要在servlet类的定义中增加实现SingleThreadModel接口的声明即可.对于实现了 SingleThreadModel接口的servlet,servlet引擎仍然支持对该servlet的多线程并发访问，其采用的方式是产生多个 servlet实例对象，并发的每个线程分别条用一个独立的servlet实例对象。实现SingleThreadModel接口并不能真正解决 servlet的线程安全问题，因为servlet的引擎会创建多个Servlet实例对象，而真正意义上解决多线程安全问题是指一个servlet实例 对象被多个线程同时调用的问题，事实上，在servlet api2.4中，已经将SingleThreadModel标记为Deprecated(过时的).标准的解决方案是同步方式sychronized
(2).如果线程向person的静态list集合中加入了数据(aaa)，数据用完后，一般要移除静态集合中的数据(aaa)，否则集合中的数据越来越多，就会导致内存溢出。对象销毁了，静态资源的字节码仍然驻留在内存中.
(3).web中的异常一般不能抛，要catch住.
8. Servlet开发的一些重要细节
(1).由于客户端是通过URL地址访问web服务器中的资源，所以Servlet程序若想被外界访问，必须把servlet程序映射到一个URL 地址上，这个工作在web.xml文件中，使用<servlet>元素和<servlet-mapping>元素完成
(2).<servlet>元素用于注册Servlet，它包含有两个主要的子元素:<servlet-name>和<servlet-class>，分别用于设置Servlet的注册名称和Servlet的完整名.
一个<servlet-mapping>元素用于映射一个已注册的Servlet的一个对外访问路径，它包含有两个子元 素:<servlet-name>和<url-patteren>，分别用于指定Servlet的注册名称和Servlet的对 外访问路径
(3).进入myeclipse->Web更改Web-Content-root
(4).一个servlet可以映射到多个对外访问路径.只需多复制个
<servlet-name><url-patteren>(伪静态)
(5).同一个Servlet可以映射到多个URL上，即多个<servlet-mapping>元素的<servlet-name>子元素的设置值可是同一个servlet的注册名
(6).在servlet映射到的URL中可以使用*通配符,但是只能有两种固定的格式：一种格式是："*.扩展名",另一种格式是以正斜杠/开头并以"/*"结尾的.
<servlet-mapping><servlet-name>anyName</servlet-name>
<url-pattern>*.do</url-pattern></servlet-mapping>
匹配所有后缀名为do的访问路径(也可以不需要后缀名, 匹配所有的文件)<servlet-mapping><servlet-name>anyName</servlet- name><url-pattern>/action/*</url-pattern></servlet- mapping>服务器在更改web.xml时，无需重启，<WatchedResource>WEB- INF/web.xml</WatchedResource>在服务器的conf文件夹下的context.xml配置文件中，监视 web.xml是否发生改动
(7).servlet1 映射到 /abc/*
servlet2 映射到 /*
servlet3 映射到 /abc
servlet4 映射到 *.do
问题:
1.当请求URL为"/abc/a.html","/abc/*"和"/*"都匹配，但是servlet引擎会调用servlet1
2.当请求URL为"/abc"时,"/abc/*"和"/abc"都匹配,但是servlet引擎会调用servlet3
3.当请求URL为"/abc/a.do"时,"/abc/*"和"*.do"都匹配,但是servlet引擎会调用servlet1
4.当请求URL为"/a.do"时,"/*"和"*.do"都匹配,但是servlet引擎会调用servlet2
5.当请求URL为"/xxx/yyy/a.do"时,"/*"和"*.do"都匹配，但是servlet引擎会调用servlet2
总结:谁长的最像，谁先匹配，同时*的优先级最低.
(8).Servlet是一个供其他Java程序(Servlet引擎:服务器端调用servlet的程序)调用的Java类，它不能独立运行，它 的运行完全由servlet引擎来控制和调度.针对客户端的多次servlet请求,通常情况下，服务器只会创建一个servlet实例对象,也就是说 servlet实例对象一旦创建,他就会驻留在内存中，为后续的其他请求服务，直至web容器退出，servlet实例对象才会销毁.在servlet的 整个生命周期内，servlet的init方法只会被调用一次,而对一个servlet的每次访问请求都导致servlet引擎调用一次servlet的 service方法,对于每次访问请求，servlet引擎都会创建一个新的httpservletrequest请求对象和一个新的 httpservletresponse响应对象,然后将这两个对象作为参数传递给她调用的servlet的service方法，service方法再根 据请求方式分别调用doXXX方法.
(9).右击，可以选择父类的方法，进行重写父类的方法
(10).服务器启动时，servlet并未创建，只有当访问web资源时会创建一个servlet，调用init()方法.一个servlet为多个请求服务，当服务器停了，servlet就被摧毁了，调用destory()方法.
(11).针对客户端的每一次请求，服务器端都会为用户创建一个request和reponse，他们的生命周期很短，如果是并发的请求，大量的请求可能创建大量的request和reponse对象，可能导致服务器运行变慢，但是不是并发的话，可能不会创建那么多个对象
(12).如果在<servlet>元素中配置一个<load-on-startup>元素，那么web应用程序在启动 时，就会装载并创建servlet的实例对象，以及调用servlet实例对象的init()方 法,<servlet><servlet-name>invoker</servlet- name><servlet-class>...</servlet-class><load-on- startup>2</load-on-startup>;用途为web应用写一个initservlet,这个servlet配置为 启动时装载,为整个web应用创建必要的数据库表和数据.(即启动服务器时就创建了servlet),struts就是一个非常大的servlet，其中 数字的大小就是启动的优先级,数值越小优先级越高.struts中的数值为2，担心用户需要扩张，所以不使用1.
(13).如果某个servlet的映射路径仅仅为一个正斜杠/，那么这个servlet就成为当前web应用程序的缺省servlet；凡是在 web.xml文件中找不到匹配的<servlet-mapping>元素的URL,它们的访问请求都将交给缺省servlet处理,也就是 说,缺省servlet用于处理所有其他servlet都不处理的访问请求.在<tomcat的安装目录>\conf\web.xml文件 中，注册了一个名称为org.apach.catalina.servlets.DefaultServlet的Servlet，并将这个servlet 设置为缺省servlet；当访问tomcat服务器中的某个静态html文件和图片时，实际上是在访问这个缺省servlet。这个用途主要用于:用户 请求一个数据(html,jpg,avi等)服务器将启动一个缺省的servlet提供给客户数据.在浏览器看到的任何内容都是数据都需要由一个 servlet来为客户提供数据，包括错误信息.
(14).配置文件修改了，不需要重启服务器，但是源程序修改了，要重启服务器.
9. Servlet开发入门
(1).jsp就是servlet，servlet是sun公司提供的一门用于开发动态web资源的技术，编写一个java类，实现servlet 接口.获得servlet启动信息,通过getServletConfig(),service的两个参数，ServletRequest req,ServletResponse res,这个方法是服务器调用的，获取客户机的对象，只需找request,输出信息找response.getOutputStream();
(2).进入服务器的目录，新建一个web应用,在应用中新建一个java，class,lib，在文件夹java下新建一个servlet文件，
package cn.itcast
public classFistServlet extendsGenericServlet{
public void service(
ServletRequest req,ServletResponseres)throws ServletException,java.io.IOException{
OutputStream out = res.getOutputStream();
out.write("Servlet".getBytes());
}
}
(3).servlet所需的架包导入，tomcat能运行servlet，则在服务器的lib目录下含有架包，为servlet配置对外访问路径web.xml，代码可以到服务器的web.xml文件中拷贝
第五天：
1. HttpServletResponse简介
(1).web服务器收到客户端的http请求，会对每一次请求，分别创建一个用于代表请求的request对象，和代表响应的reponse对 象.request和reponse对象既然代表请求和响应，那我们要获取客户及提交过来的数据，只需要找request对象就行了，要向客户机输出数 据，只需要找response对象就行了.
(2).reponse的相关方法，构建一个http响应的方法，getStatus(),setHeader(),getWriter(),getOutputStream();字节流可以写任何数据
2．request获取请求头和请求数据
(1).用户点击链接和表单提交向服务器提交数据
(2).在服务器端获取数据:
request.getParameter("username");
request.getParmeterName();
得到所有的名称的枚举.
request.getParameterValues();
得到名称相同的值
(3).在用户提交的数据中，可能抛空指针异常，加强代码的健壮性.
(4).Mapmap=request.getParameterMap();将用户的数据封装到对象中User，先获取Map，再用 JavaBeans将Map转化成对象User,其中map关键字是请求参数名称，关键字的类型是String,值的类型是String[]，因为可能有 多个相同名称对应的值就有多个，所以是个数组;Map将值填充对象User,迭代Map，得到关键字和对应的值，利用反射技术将这些数据填充到User对 象中.设计一个对象代表表单.BeanUtils.copyProperties(user,formbean);将表单beans拷贝到user对象 beans中；BeanUtils.populate(user,map);对象上的字段必须是八种基本类型，不是的话，要自己写个转换器.
(5).服务器以断点的方式运行进行调试,
(6).request.getInputStream();获取输入流，进行获取数据，进行文件上传.
3. request简介.txt
(1).HttpServletRequest对象代表客户端的请求，当客户端通过HTTP协议访问服务器时，HTTP请求头中的所有信息都封装在这个对象中，开发人员通过这个对象的方法，可以获得客户这些信息.
(2).getMethod();获取请求方式，getRequestURI();获取客户想我访问的资 源;getHeader();getDateHeader();getHeaderNames();获取所有的头信息，getHeaders();与 getHeaderNames();不同的是：可能有同名的头信息，此时就要用getHeaders()方法，a-xx;y- xx；getParameter获取客户带来的数据name="aaa";password="rot";getParameterNames(); getParameterValues();getInputStream()：将用户的数据当做流读入，如:客户进行文件上传;
(3).getRequestURL():/day07/servlet/demo1;
getRequestURI():http://localhost:8080/day07/servlet/demo1
用在权限拦截上，不同的网页有不同访问权限，做个拦截器，过滤器，还有是在记录页面的访问次数.getQueryString()客户携带的查询信 息,地址栏后的类容，getRemoteAddr();得到访问者的ip地址;getRemoteHost():主机在DNS注册了，打印了主机 名.getRemotePort();来访者的端口，ie也是一个程序，需要一个端口getLocalAddr();返回web服务器的ip地 址,getMethod():获取请求方式，默认是get方式
4．request乱码
(1).在文本框中敲入中文，浏览器提交数据的码表就是浏览器使用哪个码表打开.request容器也是默认码表是iso8859码表，所以在获取 数据时，request.setCharsetsEncoding("UTF-8");这种改变码表的方式只对post方式有效，对get方式无效.这种 方式解决的是post方式提交的数据.
(2).但是这种方式不能用于get方式,如果是get提交，必定是乱码，所以必须在servlet中手动的改变乱码，newString(username.getBytes("iso8859"),"UTF-8");
(3).用户使用超链接提交数据时，带有中文，其实超链接就是一个get方式，所以要使用get方式去解决乱码问题.
(4).更改服务器的配置，解决乱码问题，但是在开发中严禁这种方式的使用，从浏览器中进入tomcat，修改连接 器，HTTP->URLEncoding,然后到tomcat目录下的server.xml中修改连接器Connector,在其中添加一个属 性:URLEncoding="UTF-8";还有一种方法，在连接器中添加一个属性，useBodyEncodingForURI="true";是将 post方式解决乱码的方法可以用于解决get方式乱码.所以还要事先设置好request容器的码表.
(5).request.setCharacterEncoding("UTF-8");
String username =request.getParameter("username");
response.setCharacterEncoding("gb2312");
response.setContentType("text/html";charset="gb2312");
response.getWriter.write(username);不会有乱码
5．request实现请求转发和mvc设计模式.txt
(1).request是个域对象，request作用的范围是请求范围中，主要用于设计mvc中.
(2).servlet中转发到jsp显示数据，
request.getRequestDispatcher("/mesage.jsp").forward(request,response);
在开发中一般都是用这种方式，而不是用ServletContext的转发方式.每一次请求都对应一个request，正好，request的作用域是一个请求，所有request的转发，都是一个请求，都在这个作用域中.
(3).request.getParameter()方法是获取客户机带来的数据，而request.getAttribute()方法是获取request域中获取数据.
(4).forward方法用于将请求转发到requestDispatcher对象封装的资源，如果在调用forward方法之前，在 servlet程序中写入的部分内容已经被真正的传送到了客户端(关闭response流)，forward方法将抛出 IlegalStateExcepiton异常，如果在调用forward方法之前向servlet引擎的缓冲区(response)中写入了内容，只要 写入到缓冲区中的内容还没有被真正输出到客户端，forward方法就可以被正常执行，原来写入到输出缓冲区中的内容将被清空，但是，已经写入到 HTTPServletResponse对象中的响应头字段信息保持有效.
(5).if(true){request.getRequestDispatcher("/index.jsp").forward(request,response)}
跳转到index.jsp向客户机写数据
request.getRequestDispatcher("/index.jsp").forward(request,response)也要向用户写数据。所以一个良好的习惯是跳转之后一定要return；
(6).String data ="aaa";response.getWriter().write(data);不要关闭这个流，这是可以 request.getRequestDispatcher("/index.jsp").forward(request,response);理论上 应该是两部分内容的组合，即data和jsp中的内容，但是实际上只显示jsp中的内容，因为jsp的内容将覆盖data内容，但是消息头不改变，在这个 过程中创建了两个servlet，因为jsp也是一个servlet，但是只有一起请求.不会创建两个容器.
6. request实现页面包含
所有的网页都有相同的网头和网脚，此时只需要将网头和网脚设置共同的部分 html，request.getRequesetDispatcher("head.jsp").include(request,response);response.getWriter().writer("hhh");request.getRequestDispatcher("foot.jsp").incude(request,response); 被包含页面不能出现全局架构标签，因为可能重复.实现页面包含的作用
以上是关于传智博客(JavaWeb方面的所有知识)听课记录(经典)的主要内容，如果未能解决你的问题，请参考以下文章
传智播客JavaWeb程序设计任务教程 第十，十一，十二章练习答案2021最新合集
传智播客JavaWeb程序设计任务教程 第十，十一，十二章练习答案2021最新合集