XML&Tomcat

1、xml的简介

1.1 什么是xml：eXtensible Markup Language，可扩展标记型语言

（1）标记型语言：html是标记型语言，都是使用标签进行操作。

xml里面的操作也是使用标签进行操作。

（2）可扩展：html里面的标签，每个标签有自己特定的含义，比如<br/> <hr/>,

在xml中标签自己定义的，比如 <aa>  <猫>

（3）xml的主要的功能是存储数据（不是显示数据）

（4）xml的版本 1.0  1.1 ，一般使用的是 1.0版本

 

1.2 xml的应用

（1）xml的应用在三个地方

第一，xml用于作为系统之间传输数据的格式

第二，xml用于表示生活中有关系的数据

第三，xml经常使用在系统的配置文件

 

2、xml的语法

2.1 xml的文档声明

（1）如果创建xml文件，在xml中必须要有一个文档声明

（2）写法： <?xml version="1.0" encoding="utf-8"?>

version : 必须要有，xml的版本 ，一般使用1.0

encoding：可选的，xml的编码方式（utf_8较多）

standalone：可选的，xml是否依赖其他文件 yes  or no

（3）注意：文档声明需要放在xml文件的第一行第一列（顶行顶格写）

1. <?xml version="1.0" encoding="utf-8"?>
2. <person>
3. <name>jack</name>
4. <age>20</age>
5. <sex>man</sex>
6. </person>

 

2.2 xml的元素的定义

（1）xml中的标签定义，有开始标签也要有结束标签

（2）有的标签没有内容（没有结束标签，类似于html <br/>），需要在标签内结束 <aa/>

（3）xml中的标签可以嵌套，但是必须合理嵌套

<a><b></a></b>: 这样写是不对的

正确写法：<a><b></b></a>

（4）一个XML文档必须有且仅有一个根标签，其他标签都是这个根标签的子标签或孙标签

（5）命名规范

第一，xml区分大小写，例如，<P>和<p>是两个不同的标记。

第二，xml的标签不能以数字或"_" (下划线)开头。 <1a> <_bb>: 这样写不对的

第三，xml的标签不能以xml(或XML、或Xml 等)开头。

第四，在xml的标签里面不能包含空格。<a b>: 这样写不对的

第五，xml的标签名称中间不能包含冒号（:）。 <bb:cc>: 这样写不对的

 

2.3 xml的属性的定义

（1）在xml的标签里面可以有多个属性，但是属性的名称不能相同

（2）属性和属性值之间需要使用=隔开，属性值需要使用引号包起来（双引号和单引号）

<aa id1="abcd" id2='qqq'></aa>

（3）属性名称的命名规范与元素的命名规范相同

 

2.4 xml的注释

（1）写法 <!-- 注释的内容 -->

（2）注释不能嵌套

 

2.5 xml的CDATA区

（1）写法： <![CDATA[ 内容 ]]>

（2）把CDATA区里面的内容当做普通文本内容，而不是标签来进行处理

1. <?xml version="1.0" encoding="utf-8"?>
2. <person>
3. <name>zhangsan</name>
4. <age>100</age>
5. <!-- <a>bb</a> -->
6. <![CDATA[ <sex>a<b</sex> ]]>
7. </person>

 

 

3、xml的解析简介

3.1 xml解析的分类

（1）解析xml有三种方式

第一种方式：dom解析

第二种方式：sax解析

第三种方式：pull解析

 

* 掌握dom解析和sax解析的原理，以及优点和缺点

* 掌握pull解析代码

 

3.2 dom解析xml

（1）根据xml的层级结构在内存中分配一个树形结构,

document ：代表整个文档

element：代表元素对象（标签）

属性对象

文本对象

node节点对象，是上面对象的父对象

        （2）dom解析xml的优点：

因为分配了一个树形结构，很方便的实现增加 修改 删除的操作

 

（3）dom解析xml的缺点：

如果要解析的文件过大，一次性在内存中分配一个树形结构，造成内存的溢出

 

 

3.3 sax解析xml

（1）sax解析的方式：边读边解析

当使用sax方式读到特定的标签时候，自动调用相应的方法进行操作

（2）sax解析xml的优点：

不会造成内存的溢出

 

（3）sax解析xml的缺点：

不能实现增加 修改 删除的操作

 

 

3.4 pull解析xml

首先，导入pull的jar包（两个jar包）

（1）使用pull解析xml文件把xml中的内容放到集合里面

步骤：

 * 1、创建解析器工厂

 * 2、根据解析器工厂创建解析器

 * 3、把要操作的文件放到解析器里面

1. import java.io.FileInputStream;
2. import java.io.InputStream;
3. import java.util.ArrayList;
4. import java.util.List;
5. import org.xmlpull.v1.XmlPullParser;
6. import org.xmlpull.v1.XmlPullParserFactory;
7. public class day06_2_1_Pull解析xml {
8. /**
9. * 1、创建解析器工厂
10. * 2、根据解析器工厂创建解析器
11. * 3、把要操作的文件放到解析器里面
12. */
13. public static void main(String[] args) throws Exception {
14. //创建解析器工厂
15. XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
16. //根据工厂创建解析器
17. XmlPullParser parser = factory.newPullParser();
18. //得到要操作文件的输入流
19. InputStream in = new FileInputStream("src/stu.xml");
20. //把要操作的文件放到解析器里面
21. parser.setInput(in, "utf-8");
22. //开始解析
23. int type = 0;
24. List<Student> list = null;
25. Student student = null;
26. //如果当前解析到的标签，不是文档的结束，继续操作
27. while((type=parser.getEventType())!=XmlPullParser.END_DOCUMENT) {
28. //得到当前解析的标签的名称
29. String tagName = parser.getName();
30. /*
31. * 1、如果解析到students ，创建list集合
32. * 2、如果解析到student，创建student对象
33. * 3、如果解析到name和age，获取标签里面内容
34. * 4、把内容放到student对象里面
35. * */
36. switch(type) {
37. case XmlPullParser.START_TAG:
38. if("students".equals(tagName)) {
39. //创建list集合
40. list = new ArrayList<Student>();
41. } else if("student".equals(tagName)) {
42. student = new Student();
43. } else if("name".equals(tagName)) {
44. //得到标签里面的值
45. String name = parser.nextText();
46. //把name值放到对象里面
47. student.setName(name);
48. } else if("age".equals(tagName)) {
49. String age = parser.nextText();
50. student.setAge(age);
51. }
52. break;
53. case XmlPullParser.END_TAG:
54. //当解析到结束的student时候，把对象放到list里面
55. if("student".equals(tagName)) {
56. list.add(student);
57. }
58. break;
59. }
60. //向下执行
61. parser.next();
62. }
63. //遍历list集合
64. for (Student stu : list) {
65. System.out.println(stu.toString());
66. }
67. }
68. }

对象类

1. private String name;
2. private String age;
3. public String getName() {
4. return name;
5. }
6. public void setName(String name) {
7. this.name = name;
8. }
9. public String getAge() {
10. return age;
11. }
12. public void setAge(String age) {
13. this.age = age;
14. }
15. @Override
16. public String toString() {
17. return "Student [name=" + name + ", age=" + age + "]";
18. }
19. }

XML文档

1. <?xml version="1.0" encoding="UTF-8"?>
2. <students>
3. <student>
4. <name>mary</name>
5. <age>20</age>
6. </student>
7. <student>
8. <name>lucy</name>
9. <age>30</age>
10. </student>
11. <student>
12. <name>张飞</name>
13. <age>2230</age>
14. </student>
15. </students>

 

 

（2）把集合（对象）里面的数据写到xml文件中(序列化)

1. import java.io.FileOutputStream;
2. import java.io.OutputStream;
3. import org.xmlpull.v1.XmlPullParserException;
4. import org.xmlpull.v1.XmlPullParserFactory;
5. import org.xmlpull.v1.XmlSerializer;
6. public class day06_3_1_Pull序列化 {
7. /**
8. * 把对象里面的数据写到本地的xml文件中
9. *
10. * 1、创建解析器工厂
11. * 2、根据工厂创建解析器
12. * 3、设置文件的地址
13. * @throws XmlPullParserException
14. */
15. public static void main(String[] args) throws Exception {
16. //创建对象
17. Student stu = new Student();
18. stu.setName("zhangsan");
19. stu.setAge("200");
20. //创建解析器工厂
21. XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
22. //根据工厂创建解析器
23. XmlSerializer serializer = factory.newSerializer();
24. OutputStream out = new FileOutputStream("i:\\stu.xml");
25. //设置文件的地址
26. serializer.setOutput(out, "utf-8");
27. //把stu对象里面的数据 写到本地的xml文件中
28. serializer.startDocument(null, true);
29. //生成开始students标签
30. serializer.startTag(null, "students");
31. //生成开始和结束的student标签
32. serializer.startTag(null, "student");
33. //生成name和age标签
34. serializer.startTag(null, "name");
35. //写入name的值
36. serializer.text(stu.getName());
37. serializer.endTag(null, "name");
38. serializer.startTag(null, "age");
39. serializer.text(stu.getAge());
40. serializer.endTag(null, "age");
41. serializer.endTag(null, "student");
42. //生成结束students标签
43. serializer.endTag(null, "students");
44. serializer.endDocument();
45. }
46. }

 

 

Tomcat

1、web相关概念的介绍

1.1 动态资源和静态资源

（1）静态资源：html+css+js

（2）动态资源：数据是变化的

（3）动态资源的开发技术

* sun公司：jsp servlet

* php

* asp

..........

 

1.2 c s 和 b s结构

（1）c s：客户端 服务器   （）

常见的应用：qq、迅雷.........

优点：需要在本地电脑安装软件，减轻服务器的压力

缺点：服务器如果升级，客户端软件也需要升级

 

（2）b s：浏览器 服务器

常见的应用：网银、支付宝、12306.....

优点：服务器如果升级，不需要升级

缺点：不需要安装软件，造成服务器的压力比较大

 

1.3 web间的通信

（1）在浏览器的地址栏输入地址 http://www.itcast.cn

把输入的域名转换成ip地址，通过ip地址+端口号进行访问

 

2、web服务器介绍

2.1 什么是服务器

（1）硬件：一台配置高的电脑

（2）软件：在电脑上安装服务器软件

2.2 在电脑浏览器的地址栏输入地址，可以访问电脑上文件

（1）使用网络编程

2.3 常见的web服务器

（1）tomcat服务器：是Apache组织，开源的免费的服务器

（2）weblogic服务器：bea公司，收费的软件

（3）websphere服务器：ibm公司，收费的软件

 

3、tomcat服务器的安装和目录结构

3.1 tomcat的安装

（1）安装tomcat服务器有两种方式：第一种方式使用exe文件进行安装；第二种方式使用压缩文件进行安装（推荐）

 

（2）检验toma安装成功

= 启动tomcat服务器，如果正常启动，tomcat安装成功了

== 找到tomcat的bin目录，找到文件startup.bat文件，点击这个文件，启动tomcat服务器。

== 出现一个黑窗口，在黑窗口里面出现ms，同时没有异常信息，表示tomcat启动成功了

 

= 关闭tomcat服务器

== 直接关闭黑窗口；找到tomcat里面bin目录，找到文件shutd.bat文件，点击这个文件关闭tomcat服务器

 

（3）访问tomcat

= tomcat的默认端口是8080

= 使用ip地址+tomcat的端口号进行访问

== 因为使用的本机，ip地址可以写：127.0.0.1或者localhost

http://127.0.0.1:8080

 

3.2 tomcat问题的解决

（1）安装tomcat时候前提条件：

            必须安装jdk，同时配置环境变量JAVA_HOME

= 没有配置环境变量，启动tomcat服务器，一闪就消失了

= 查看错误：打开cmd窗口，进入到启动tomcat文件所在的路径，执行文件，看到错误信息

 

（2）端口冲突的问题

java.net.BindException: Address already in use: JVM_Bind <null>:8080

= 修改tomcat的启动端口

== 找到tomcat的conf目录，找到server.xml文件，进行端口的修改

    <Connector port="8080" protocol="HTTP/1.1"

               connectionTimeout="20000"

               redirectPort="8443" />

== 修改了tomcat的端口，重新启动tomcat服务器

= 修改tomcat的启动端口为 80，访问时候不需要输入端口号了，直接通过ip地址进行访问

 

3.3 tomcat的目录结构

bin（**）：放tomcat启动和关闭的文件

conf（**）：放tomcat配置文件（server.xml  web.xml）

lib：放jar包

logs：放tomcat的日志文件

temp：放临时文件

webapps（**）：如果一个项目想要在tomcat里面运行，这个项目放到webapps里面

work：jsp就是servlet，最终会被编译成servlet，jsp编译成servlet放到这个目录

 

4、发布项目到tomcat

4.1 开放式项目部署

（1）在tomcat里面webapps目录，把项目直接复制到这个目录下面

（2）静态网站

= 在tomcat的webapps目录下创建文件夹，比如aa，在aa里面创建html文件

= 在浏览器的地址栏就可以访问到这个文件

http://127.0.0.1:端口号/创建的文件夹的名称/文件的名称

 

（3）动态网站

= 如果想要在tomcat里面运行动态网站，必须要遵循一定的目录结构

= 结构：

== website 

WEB-INF(必须)

-- web.xml(必须)

-- classes(可选)

-- lib(可选)

 

4.2 配置虚拟路径

有两种方式

（1）第一种方式配置虚拟路径

找到tomcat的conf目录里面server.xml，进行虚拟路径的配置

写在Host标签里面

<Context docBase="部署的项目所在的路径" path="访问的路径"></Context>

 

<Context docBase="I:\itcast" path="/demo"></Context>

访问：http://127.0.0.1/demo/hello.html

 

（2）第二种方式配置虚拟路径

找到tomcat的conf，下面继续找\Catalina\localhost文件夹

在这个文件夹里面创建一个xml格式的文件，进行虚拟路径的配置

在创建的文件里面进行配置（使用Context，不需要写path属性）

<?xml version="1.0"?>

<Context docBase="I:\itheima"></Context>

访问：使用创建的xml文件的名称作为访问的路径

http://127.0.0.1/it100/it.html

 

4.3 使用myeclipse整合tomcat

（1）在myeclipse中整合tomcat的过程

（2）在myeclipse中启动tomcat服务器和关闭tomcat服务器

（3）在myeclipse把项目发布到tomcat里面

= 创建web项目，部署之后，把web项目里面webroot里面的内容都放到tomcat的webapps目录下面，webroot变成

项目的名称

（4）在myeclipse中移除tomcat中的项目

（5）两个名称区别

= 上面的名称是项目显示名称

= 下面的名称是部署到tomcat的webapps里面的名称（通过浏览器访问的名称）

http协议

 

1、http协议的简介

1.1 请求和响应

（1）请求：在浏览器的地址栏输入一个地址，点击回车，这个过程就是一次请求

（2）响应：服务器根据发送的请求，把数据返回显示到浏览器的页面上，这个过程称为响应

 

1.2 什么是http协议

（1）请求和响应遵循的数据格式

                [1]请求部分

                    <1>请求行

                          GET      URL   HTTP    

                          post

                    <2>请求头

                        编码方式

 

                    <3>请求体

                          请求数据

             

                [2]响应部分

                    <1>响应行

                                

 

                    <2>响应头

                        编码方式

 

                    <3>响应体

                          响应数据

 

（2）http协议的特点：

第一个：基于请求和响应的操作（先有请求，再有响应）

第二个：基于tcp协议，80端口

 

2、使用抓包工具查看http协议

2.1 httpwatch软件，通过这个软件查看当前请求和响应的数据格式（只能用在ie浏览器里面）

2.2 在ie、火狐、谷歌浏览器里面都有自带调试工具，点击键盘上面f12 ，会在页面下面出现调试的工