# 生成器

## 创建生成器方法一

要创建⼀个⽣成器，有很多种⽅法。第⼀种⽅法很简单，只要把⼀个列表⽣成式的 [ ] 改成 ( )

```python
In [1]: L = [x*2 for x in range(5)]

In [2]: L
Out[2]: [0, 2, 4, 6, 8]

In [3]: G = (x*2 for x in range(5))

In [4]: G
Out[4]: <generator object <genexpr> at 0x000001B281507A98>
```

创建 L 和 G 的区别仅在于最外层的 [ ] 和 ( ) ， L 是列表，G 是生成器。我们可以直接打印出L的每个元素，但我们怎么打印出G的每个元素呢？使用`next`函数



```python
In [3]: G = (x*2 for x in range(5))

In [4]: G
Out[4]: <generator object <genexpr> at 0x000001B281507A98>

In [5]: next(G)
Out[5]: 0

In [6]: next(G)
Out[6]: 2

In [7]: next(G)
Out[7]: 4

In [8]: next(G)
Out[8]: 6

In [9]: next(G)
Out[9]: 8

In [10]: next(G)
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-10-b4d1fcb0baf1> in <module>()
----> 1 next(G)
```

⽣成器保存的是算法，每次调⽤ next(G) ，就计算出 G 的下⼀个元素的值,直到计算到最后.个元素，没有更多的元素时，抛出 StopIteration 的异常。当然，这种不断调⽤ next（）实在是太变态了，正确的⽅法是使⽤ for 循环，因为⽣成器也是可迭代对象。所以，我们创建了⼀个⽣成器后，基本上永远不会调⽤ next（），而是通过for循环来迭代它，并且不需要关心StopIteration 异常！

## 创建生成器方法二

先看看这个斐波那契函数的例子：

```python
In [3]: def creatNum():
   ...:     a,b = 0,1
   ...:     for i in range(5): # 生成5个斐波那契数
   ...:         print(b)
   ...:         a,b = b,a+b
   ...:

In [4]: creatNum()
```

接下来我们把它改成生成器：

```python
#-*- coding:utf-8 -*-

def creatNum():
    print("---start---")
    a,b = 0,1
    for i in range(5):
        print("---1---")
        yield b
        print("---2---")
        a,b = b,a+b
        print("---3---")
    print("---stop---")
```

接下来我们将这个模块导入：

```python
In [1]: from test import *

In [2]: a = creatNum()

In [3]: next(a)
---start---
---1---
Out[3]: 1

In [4]: next(a)
---2---
---3---
---1---
Out[4]: 1

In [5]: next(a)
---2---
---3---
---1---
Out[5]: 2
```

我们在循环过程中不断调⽤ yield ，就会不断中断。当然要给循环设置⼀个条件来退出循环，不然就会产⽣⼀个⽆限数列出来。同样的，把函数改成generator后，我们基本上从来不会⽤ next() 来获取下⼀个返回值，⽽是直接使⽤ for 循环来迭代!

```python
In [1]: from test import *

In [2]: a = creatNum()

In [3]: while True:
   ...:     try:
   ...:         print("value:%d" % next(a))
   ...:     except StopIteration as e:
   ...:         print("生成器返回值：%s" % e.value)
   ...:         break
   ...:
---start---
---1---
value:1
---2---
---3---
---1---
value:1
---2---
---3---
---1---
value:2
---2---
---3---
---1---
value:3
---2---
---3---
---1---
value:5
---2---
---3---
---stop---
生成器返回值：None
```

**注意：`next(a)`与`a.__next__（）`是等价的**

## send

```python
In [1]: def test():
   ...:     i = 0
   ...:     while i<5:
   ...:         tmp = yield i
   ...:         print(tmp)
   ...:         i += 1
   ...:

In [2]: t = test()

In [3]: t.__next__()
Out[3]: 0

In [4]: t.__next__()
None
Out[4]: 1

In [5]: t.__next__()
None
Out[5]: 2
```

为什么会打印出None呢？是应为`yield i`执行完毕之后会把结果直接返回，但是不会赋值给tmp，所以每次打印都是None，此时使用send方法就会在`yield i`执行完毕之并返回结果之后给`yield i`赋值：

```python
In [1]: def test():
   ...:     i = 0
   ...:     while i<5:
   ...:         tmp = yield i
   ...:         print(tmp)
   ...:         i += 1
   ...:

In [2]: t = test()

In [3]: t.__next__()
Out[3]: 0

In [4]: t.__next__()
None
Out[4]: 1

In [5]: t.__next__()
None
Out[5]: 2

In [6]: t.send("Hello")
Hello
Out[6]: 3

In [7]: t.send("HelloWorld")
HelloWorld
Out[7]: 4
```

### send的注意事项

```python
In [8]: def test():
   ...:    ...:     i = 0
   ...:    ...:     while i<5:
   ...:    ...:         tmp = yield i
   ...:    ...:         print(tmp)
   ...:    ...:         i += 1
   ...:    ...:
   ...:

In [9]: a = test()

In [10]: a.send("---")
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-10-dc33d05574fa> in <module>()
----> 1 a.send("---")

TypeError: can't send non-None value to a just-started generator
```

不能在第一次生成的时候就调用send方法，因为代码还未执行到`yield i`，所以要先使用`__next()__`，再使用`send()`

当然还有一个方法：

```python
In [11]: def test():
    ...:    ...:     i = 0
    ...:    ...:     while i<5:
    ...:    ...:         tmp = yield i
    ...:    ...:         print(tmp)
    ...:    ...:         i += 1
    ...:    ...:
    ...:

In [12]: t = test()

In [13]: t.send(None)
Out[13]: 0
```

## 总结

生成器是这样一个函数，它记住上一次返回时在函数体中的位置。对生成器函数的第二次（或者第n次）调用跳转至该函数体中间，而上次调用的所有局部变量都保持不变！

⽣成器不仅“记住”了它数据状态；⽣成器还“记住”了它在流控制构造（在命令式编程中，这种构造不只是数据值）中的位置

**生成器的特点**

* 节约内存，在超大列表的情况下是非常吃内存的！
* 迭代到下⼀次的调⽤时，所使⽤的参数都是第⼀次所保留下的，即是说，在整个所有函数调⽤的参数都是第⼀次所调⽤时保留的，⽽不是新创建的，这样非常高效！
迭代是访问集合元素的⼀种⽅式。迭代器是⼀个可以记住遍历的位置的对象。迭代器对象从集合的第⼀个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退！
# 可迭代对象
以直接作⽤于 for 循环的数据类型有以下⼏种：
⼀类是集合数据类型，如 list 、 tuple 、 dict 、 set 、 str 等；
⼀类是 generator ，包括⽣成器和带 yield 的generator function。
这些可以直接作⽤于 for 循环的对象统称为可迭代对象： Iterable
```python
In [1]: for s in "Hello":
   ...:     print(s)
   ...:
H
e
l
l
o

In [2]: b = (x for x in range(5))

In [3]: b
Out[3]: <generator object <genexpr> at 0x0000021FEBC98A40>

In [4]: for tmp in b:
   ...:     print(tmp)
   ...:
0
1
2
3
4
```
# 判断是否可以迭代
可以使⽤`isinstance()`判断一个对象是否是Iterable (可迭代的)对象：
```python
In [1]: from collections import Iterable

In [2]: isinstance([],Iterable)
Out[2]: True

In [3]: isinstance({},Iterable)
Out[3]: True

In [4]: isinstance('abc',Iterable)
Out[4]: True

In [5]: isinstance((x for x in range(5)),Iterable)
Out[5]: True
```
⽽⽣成器不但可以作⽤于 for 循环，还可以被 next() 函数不断调⽤并返回下⼀个值，直到最后抛出 StopIteration 错误表示⽆法继续返回下⼀个值了!
# 迭代器
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
可以使用`isinstance()` 判断某个对象是否是 Iterator (迭代器)对象
```python
In [1]: from collections import Iterator

In [2]: isinstance((x for x in range(10)),Iterator)
Out[2]: True

In [3]: isinstance([],Iterator)
Out[3]: False

In [4]: isinstance({},Iterator)
Out[4]: False

In [5]: isinstance("abc",Iterator)
Out[5]: False

In [6]: isinstance(100,Iterator)
Out[6]: False
```
所以说，生成器也是迭代器的一种！

# iter()函数
生成器都是Iterator对象，但是list、dict、str虽然是Iterable，去不是Iterator
```
In [7]: isinstance(iter("abc"),Iterator)
Out[7]: True

In [8]: isinstance(iter([]),Iterator)
Out[8]: True
```
# 总结
* 凡是可作⽤于 for 循环的对象都是 Iterable 类型
* 凡是可作⽤于 next() 函数的对象都是 Iterator 类型
* 集合数据类型如 list 、 dict 、 str 等是 Iterable 但不是 Iterator，不过可以通过 iter() 函数获得⼀个 Iterator 对象。
# 闭包
内部函数对外部函数作用域变量的引用（非全局变量），则称内部函数为闭包！
![mark](https://img.zouchanglin.cn/blog/20200822/4811pq5YLEo3.png)

## 应用实例
```python
def linr_conf(a, b):
	def line(x):
		return a*x + b

	return line

# 相当于通过同一个方法构建了两种直线模型
line1 = linr_conf(1,1)
line2 = linr_conf(4,5)

print(line1(5))
print(line2(5))
```
这个例子中，函数line与变量a,b构成闭包。在创建闭包的时候，我们通过line_conf的参数a,b说明了这两个变量的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用！
如果没有闭包，我们需要每次创建直线函数的时候同时说明a,b,x。这样，我们就需要更多的参数传递，也减少了代码的可移植性！
## 总结

* 闭包似优化了变量，原来需要类对象完成的工作，闭包也可以完成
* 由于闭包引用了外部函数的局部变量，则外部函数局部变量没有释放，消耗内存
# 装饰器
装饰器是程序开发中经常会⽤到的⼀个功能，⽤好了装饰器，开发效率如⻁添翼，所以这也是Python⾯试中必问的问题，但对于好多初次接触这个知识的⼈来讲，这个功能有点绕，⾃学时直接绕过去了，然后⾯试问到了就挂了，因为装饰器是程序开发的基础知识，这个都不会，别跟⼈家说你会Python, 看了下⾯的⽂章，保证你学会装饰器！
## 模拟场景
假设这些都是核心业务方法，但是现在的需求是：不能让每一个人都随意的调用这些方法，为了安全起见，在调用这些方法的时候必须进行权限验证！
```python
def coreCode():
	...
def coreCode2():
	...
def coreCode3():
	...
```
为了增加权限验证的逻辑，修改后的代码如下：
```python
def coreCode():
	# 验证一
	# 验证二
	...
def coreCode2():
	# 验证一
	# 验证二
	...
def coreCode3():
	# 验证一
	# 验证二
	...
```
很显然这是极不合理的，代码太过于冗余，修改之后：
```python
def check_call():
	# 验证-
	# 验证二
def coreCode():
	check_call()
	...
def coreCode2():
	check_call()
	...
def coreCode3():
	check_call()
	...
```
这回修改之后的代码显得不是很冗余，但是违反了**开放封闭原则**，这样会修改核心业务代码，也是非常不推荐的做法，接着装饰器就登场了：
```python
def check(func):
	def inner():
		# 验证1
		# 验证2
		func()
	return inner

@check
def coreCode():
	...
	
@check
def coreCode2():
	...
	
@check	
def coreCode3():
	...
```
对于上述代码，也是仅仅对基础平台的代码进行修改，就可以实现在其他人调用coreCode1、coreCode2、coreCode3的时候都进行验证操作！
```
def check(func):
	def inner():
		print("验证1...")
		print("验证2...")
		print("验证3...")
		func()
	return inner


@check
def  coreCode1():
	print("coreCode1...")

def  coreCode2():
	print("coreCode2...")


coreCode1()
print("-"*30)
coreCode2()
```
![mark](https://img.zouchanglin.cn/blog/20200822/HNCTA6BFwxFL.png)
python解释器就会从上到下解释代码，步骤如下:

1. def check(func): ==>将check函数加载到内存
2. @check
没错， 从表⾯上看解释器仅仅会解释这两句代码，因为函数在没有被调⽤之前其内部代码不会被执行。从表面上看解释器着实会执行这两句，但是 @check 这⼀句代码里却有大文章， @函数名 是python的⼀种语法糖.
## @check到底做了什么
*  执行check函数，并且会把@check下面的函数当做check函数的参数，所以内部就会执行验证的逻辑，执行完毕才去调用参数中的方法！
*  check的返回值，将执行完毕的check函数返回值赋值给@check下面的函数名coreCode
*  所以想要执行coreCode 函数时，就会执行新coreCode函数，在新coreCode函数内部先执⾏验证，再执行原来的coreCode函数，然后将原来coreCode函数的返回值返回给了业务调⽤者。

## 再议装饰器

装饰器的装饰执行时间：并不是在调用的时候才去装饰函数，而是在解释器解释到那一句的时候就已经装饰了函数！

生成器、迭代器、闭包与装饰器

Python语法学习日志

百度的预搜索是怎么实现的呢？如下图：

![mark](https://img.zouchanglin.cn///20200131/SABcmd0wvlq5.png)
这个场景应该是大家非常熟悉的吧，为什么我们没有点击搜索但是却可以弹出相关的搜索内容条目呢？其中就用到了ajax引擎！接下来我们就可以看一下这个ajax，哈哈！

## 一、Ajax概述

### 什么是同步，什么是异步

同步现象：客户端发送请求到服务器端，当服务器返回响应之前，客户端都处于等待卡死状态
异步现象：客户端发送请求到服务器端，无论服务器是否返回响应，客户端都可以随 意做其他事情，不会被卡死

### Ajax的运行原理

页面发起请求，会将请求发送给浏览器内核中的Ajax引擎，Ajax引擎会提交请求到 服务器端，在这段时间里，客户端可以任意进行任意操作，直到服务器端将数据返回 给Ajax引擎后，会触发你设置的事件，从而执行自定义的js逻辑代码完成某种页面功能。



## 二、js原生的Ajax技术

js原生的Ajax其实就是围绕浏览器内内置的Ajax引擎对象进行学习的，要使用js原生的Ajax完成异步操作，有如下几个步骤：

- 创建Ajax引擎对象
- 为Ajax引擎对象绑定监听（监听服务器已将数据响应给引擎）
- 绑定提交地址
- 发送请求

下面是一个使用原生Ajax的示例：

```html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<script type="text/javascript">
	//异步请求
	function fn1(){
		//(1)创建引擎对象
		var xmlhttp = new XMLHttpRequest();
		
		//(2)绑定监听
		xmlhttp.onreadystatechange = function(){
			//(5)接受相应数据
			if(xmlhttp.readyState == 4 && xmlhttp.status == 200){
				var res = xmlhttp.responseText;
				document.getElementById("span1").innerHTML = res;
			}
		}
		
		//(3)绑定地址
		xmlhttp.open("GET", "/WEB21/ajaxservlet", true);
		
		//(4)发送请求
		xmlhttp.send();
	}
	
	//同步请求
	function fn2(){
		//(1)创建引擎对象
		var xmlhttp = new XMLHttpRequest();
		
		//(2)绑定监听
		xmlhttp.onreadystatechange = function(){
			//(5)接受相应数据
			if(xmlhttp.readyState == 4 && xmlhttp.status == 200){
				var res = xmlhttp.responseText;
				document.getElementById("span2").innerHTML = res;
			}
		}
		
		//(3)绑定地址
		xmlhttp.open("GET", "/WEB21/ajaxservlet", false);
		
		//(4)发送请求
		xmlhttp.send();
	}
</script>
</head>
<body>
	<input type="button" value="异步访问服务器" onclick="fn1()"/><span id="span1"></span>
	<br>
	<input type="button" value="同步访问服务器" onclick="fn2()"/><span id="span2"></span>
	<br>
	<input type="button" value="测试按钮" onclick="alert()"/>
</body>
</html>
```

 servlet如下： 

```java
protected void doGet(HttpServletRequest request, HttpServletResponse response)
 throws ServletException, IOException {
		// TODO Auto-generated method stub
		//response.getWriter().write("XPU");
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		response.getWriter().write(Math.random()+"");
}
```

这样的话会得到下图所示的效果：
![mark]( https://img.zouchanglin.cn/E6f3Y6.gif)
现象很简单，我的测试按钮其实就是弹出一个空的提示框，当我点击异步访问的时候，浏览器会向服务器的servlet发送一个请求，这个请求是获取一个随机数，而且为了模拟服务器长达3秒的运算我让服务器睡眠了3秒钟，点击异步访问后可以立马点击测试按钮弹出提示框，但是点击同步访问后立马点击测试按钮却要等待3秒才会弹出提示框，而且我点击了多次就弹出了多次提示框，相信这个额例子是非常容易理解同步和异步的特点的！

为什么要这样做呢？有时候我们在加载网页的时候，可能有些图片非常大，在网速不是很好的情况下需要很长的时间才可以加载，如果使用ajax引擎发起对图片的异步请求，即使在图片还没有加载完毕的情况下也可以使用其他的功能，这就是异步请求的一个应用，接下来用图片说明一下：
![mark](https://img.zouchanglin.cn///20200131/rJO2fqEVFhKy.png)
很显然，如果没有ajax引擎的情况下发起请求而且等到收到响应对于浏览器来说是非常浪费时间的，尤其是发起的请求计算量过大，网速特别慢的时候是非常影响用户体验的，有了ajax引擎替我们发起请求和接受协议，浏览器就有机会去做其他的事情，而不是傻傻的等待！

原生ajax的GET与POST请求：
GET 请求比较简单，如下格式即可（上面的代码中用的就是GET请求）

```javascript
xmlhttp.open("GET","test1.txt",true);
xmlhttp.send();
```

但是使用GET请求可能的到的是缓存结果，为了避免这样的情况出现，应该使用如下示例设置不同的ID：

```javascript
xmlhttp.open("GET","demo_get.asp?t=" + Math.random(),true);
xmlhttp.send();
```



简单地POST请求：

```javascript
xmlhttp.open("POST","demo_post.asp",true);
xmlhttp.send();
```



带参数的POST请求(**切记不要忘记添加请求头**）：

```javascript
xmlhttp.open("POST","ajax_test.asp",true);
xmlhttp.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xmlhttp.send("fname=Bill&lname=Gates");
```



最后说一个关于获取XMLHttpRequest 对象的问题：
创建 XMLHttpRequest 对象：所有现代浏览器（IE7+、Firefox、Chrome、Safari 以及 Opera）均内建 XMLHttpRequest 对象。

### XMLHttpRequest 对象三个重要的属性

| 属性               | 描述                                                         |
| :----------------- | :----------------------------------------------------------- |
| onreadystatechange | 存储函数（或函数名），每当 readyState 属性改变时，就会调用该函数。 |
| readyState         | 存有 XMLHttpRequest 的状态。从 0 到 4 发生变化。0: 请求未初始化 1: 服务器连接已建立 2: 请求已接收 3: 请求处理中 4: 请求已完成，且响应已就绪 |
| status             | 200: “OK” 404: 未找到页面                                    |

创建 XMLHttpRequest 对象的语法：

```javascript
variable=new XMLHttpRequest();
```



老版本的 Internet Explorer （IE5 和 IE6）使用 ActiveX 对象：

```javascript
variable=new ActiveXObject("Microsoft.XMLHTTP");
```



为了应对所有的现代浏览器，包括 IE5 和 IE6，请检查浏览器是否支持 XMLHttpRequest 对象。如果支持，则创建 XMLHttpRequest 对象。如果不支持，则创建 ActiveXObject ：

```javascript
var xmlhttp;if (window.XMLHttpRequest){	
	// code for IE7+, Firefox, Chrome, Opera, Safari	
	xmlhttp=new XMLHttpRequest();
}else{
	// code for IE6, IE5	
	xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
}
```



使用XMLHttpRequest对象用于在后台与服务器交换数据，应用场景：

- 在不重新加载页面的情况下更新网页
- 在页面已加载后从服务器请求数据
- 在页面已加载后从服务器接收数据
- 在后台向服务器发送数据

所有异步访问都是靠ajax引擎！

## 三、JSON数据格式

json是一种与语言无关的数据交换的格式，作用：

- 使用ajax进行前后台数据交换
- 移动端与服务端的数据交换

### Json的格式与解析

json有两种格式：
1）对象格式：{“key1”:obj,”key2”:obj,”key3”:obj…}
2）数组/集合格式：[obj,obj,obj…]

例如：user对象 用json数据格式表示

```json
{"username":"zhangsan","age":28,"password":"123","addr":"北京"}
```



例如：List 用json数据格式表示

```json
[{"pid":"10","pname":"小米4C"},{},{}]
```



注意：对象格式和数组格式可以互相嵌套
注意：json的key是字符串 jaon的value是Object

json的解析：
json是js的原生内容，也就意味着js可以直接取出json对象中的数据

### Json的转换插件

将java的对象或集合转成json形式字符串

json的转换插件是通过java的一些工具，直接将java对象或集合转换成json字符串。
常用的json转换工具有如下几种：
1）jsonlib
2）Gson：google
3）fastjson：阿里巴巴
4）cJSON：腾讯的

## 四、Jquery的Ajax技术

jquery是一个优秀的js框架，自然对js原生的ajax进行了封装，封装后的ajax的操 作方法更简洁，功能更强大，与ajax操作相关的jquery方法有如下几种，但开发中经常使用的有三种 ：

```javascript
$.get(url, [data], [callback], [type])$.post(url, [data], [callback], [type])
```



url：代表请求的服务器端地址
data：代表请求服务器端的数据（可以是key=value形式也可以是json格式）
callback：表示服务器端成功响应所触发的函数（只有正常成功返回才执行）
type：表示服务器端返回的数据类型（jquery会根据指定的类型自动类型转换）
常用的返回类型：text、json、html等

```
$.ajax( { option1:value1,option2:value2... } );
```

async：是否异步，默认是true代表异步
data：发送到服务器的参数，建议使用json格式
dataType：服务器端返回的数据类型，常用text和json
success：成功响应执行的函数，对应的类型是function类型
type：请求方式，POST/GET
url：请求服务器端地址

下面是一个使用示例：

```html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<script type="text/javascript" src="jquery-1.11.3.min.js"></script>
<script type="text/javascript">
	function fn1() {
		//get异步访问
		$.get(
				"/WEB21/ajaxservlet",//url地址
				{"name":"邹长林","age":20},//请求参数
				function(data){ //成功后的回调函数
					alert(data.firstname+" "+data.lastname+" "+data.age);
				},
				"json"
			);
	}
	
	function fn2() {
		$.post(
				"/WEB21/ajaxservlet",//url地址
				{"name":"邹长林","age":20},//请求参数
				function(data){ //成功后的回调函数
					alert(data.firstname+" "+data.lastname+" "+data.age);
				},
				"json"
			);
	}
	
	function fn3() {
		$.ajax({
			url:"/WEB21/ajaxservlet", //请求的地址
			type:"GET", //请求类型
			async:true, //是否同步，默认同步
			data:{"name":"tim", "age":18}, //请求的数据，JSON格式
			success:function(data){ //请求成功的回调函数
				alert(data.firstname);
			},
			error:function(){ //请求失败的回调函数
				alert("请求失败");
			},
			dataType:"json",//从服务器接受返回的数据类型，一般为JSON或者text
			
		});
	}
</script>
<body>
	<input type="button" value="GET访问服务器" onclick="fn1()"/>
	<span id="span1"></span>
	<br>
	<input type="button" value="POST访问服务器" onclick="fn2()"/>
	<span id="span2"></span>
	<br>
	<input type="button" value="Ajax访问服务器" onclick="fn3()"/>
</body>
</html>
```

在使用Ajax三种请求的时候需要注意的地方：
GET方式提交的数据到服务器可能会出现乱码，使用编解码的方式就可以解决
POST方式提交的数据已经经过ajax处理了，无需我们再自己处理一遍
获取数据的时候的乱码问题也是很好解决的：

```java
request.setCharacterEncoding("UTF-8");
```

Ajax异步请求与JSON数据格式

关于编码的问题有几点需要说清楚：UTF-8国际编码，GBK中文编码。GBK包含GB2312，即如果通过GB2312编码后可以通过GBK解码，反之可能不成立；英文文字就是26个字母，真正的对应关系就是ASCII码表中的关系，但是如何表示汉字呢？很显然也需要一套对应的码表，于是UTF-8、GBK、GB2312这些编码方式就是为了解决这个问题的。



下面看看正题：首先我的目录是：压缩包即是我要下载的文件

![mark](https://img.zouchanglin.cn///20200131/E9RTK8UIkt1n.png)

我的下载界面：

```html
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>Insert title here</title>
</head>
<body>
  <h3> 使用a标签指向服务器资源 </h3>
  <a href="/Web14_response/download/a.flv">a.flv</a><br>
  <a href="/Web14_response/download/a.jpg">a.jpg</a><br>
  <a href="/Web14_response/download/a.mp3">a.mp3</a><br>
  <a href="/Web14_response/download/a.mp4">a.mp4</a><br>
  <a href="/Web14_response/download/a.txt">a.txt</a><br>
  <a href="/Web14_response/download/a.zip">a.zip</a><br>
  <h3> 使用服务器代码完成服务器资源下载 </h3>
  <a href="/Web14_response/DownloadServlet2?filename=a.flv">a.flv</a><br>
  <a href="/Web14_response/DownloadServlet2?filename=a.jpg">a.jpg</a><br>
  <a href="/Web14_response/DownloadServlet2?filename=a.mp3">a.mp3</a><br>
  <a href="/Web14_response/DownloadServlet2?filename=a.mp4">a.mp4</a><br>
  <a href="/Web14_response/DownloadServlet2?filename=a.txt">a.txt</a><br>
  <a href="/Web14_response/DownloadServlet2?filename=压缩包.zip">压缩包.zip</a><br>
</body>
</html>
```

提供文件下载的Servlet:

```java
package com.xpu.content;
 
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLEncoder;
 
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import sun.misc.BASE64Encoder;
 
public class DownloadServlet extends HttpServlet {
 
	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// 这个主要是下载中文的
		// 获取要下载的文件的名称
		String filename = request.getParameter("filename");
		// 解决获得中文参数的乱码
		filename = new String(filename.getBytes("ISO8859-1"), "UTF-8");
		// 设置头信息
		response.setContentType(getServletContext().getMimeType(filename));
		String agent = request.getHeader("User-Agent");
		String filenameEncoder = "";
		if (agent.contains("MSIE")) {
			// IE浏览器
			filenameEncoder = URLEncoder.encode(filename, "utf-8");
			filenameEncoder = filename.replace("+", " ");
		} else if (agent.contains("Firefox")) {
			// 火狐浏览器
			BASE64Encoder base64Encoder = new BASE64Encoder();
			filenameEncoder = "=?utf-8?B?" + base64Encoder.encode(filename.getBytes("utf-8")) + "?=";
		} else {
			// 其它浏览器
			filenameEncoder = URLEncoder.encode(filename, "utf-8");
		}
 
		response.setHeader("Content-Disposition", "attachment;filename=" + filenameEncoder);
		System.out.println(filename);
		// 获取文件的绝对路径
		String path = getServletContext().getRealPath("/download/" + filename);
		// 获取该文件的输入流
		InputStream is = new FileInputStream(path);
		// 获取输出流
		ServletOutputStream os = response.getOutputStream();
		// 文件拷贝的模板代码
		int len = 0;
		byte[] bys = new byte[1024];
		while ((len = is.read(bys)) != -1) {
			os.write(bys, 0, len);
		}
		is.close();
	}
 
	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}
}
```

下载效果：

![mark](https://img.zouchanglin.cn///20200131/IC3Udto0HwWz.png)

下载中文文件乱码解决方式

### 1、首先附上要解析的xml数据
```xml
<?xml version="1.0" encoding="utf-8"?>
<weather>
	<city>
		<name>西安</name>
		<temp>23</temp>
		<pm25>40</pm25>
	</city>
	<city>
		<name>郑州</name>
		<temp>26</temp>
		<pm25>100</pm25>
	</city>
	<city>
		<name>镇巴</name>
		<temp>28</temp>
		<pm25>800</pm25>
	</city>
</weather>
```


### 2、根据xml的结果设计JavaBean

```java
package domain;

public class City {
	private String name;
	private String temp;
	private String pm25;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getTemp() {
		return temp;
	}
	public void setTemp(String temp) {
		this.temp = temp;
	}
	public String getPm25() {
		return pm25;
	}
	public void setPm25(String pm25) {
		this.pm25 = pm25;
	}
	@Override
	public String toString() {
		return "City [name=" + name + ", temp=" + temp + ", pm25=" + pm25 + "]";
	}
	
}

```
### 3、点击按钮开始解析
```java
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import org.xmlpull.v1.XmlPullParser;

import android.app.Activity;
import android.os.Bundle;
import android.util.Xml;
import android.view.View;
import domain.City;

public class MainActivity extends Activity {
	List<City> list;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
    }
    
    public void click(View v){
    	//获取天气xml文件
    	InputStream is = getClassLoader().getResourceAsStream("weather.xml");
    	
    	//获取xml解析器
    	XmlPullParser parser = Xml.newPullParser();
    	
    	try{
    		//初始化
    		parser.setInput(is, "UTF-8");
    		
    		//获取当前节点的事件类型
    		int type = parser.getEventType();
    		
    		City city = null;
    		//不到文档结束就一直解析
    		while(type != XmlPullParser.END_DOCUMENT){
    			switch (type) {
				case XmlPullParser.START_TAG:
					//获取当前节点的名称
					if("weather".equals(parser.getName())){
						list = new ArrayList<City>();
					}else if("city".equals(parser.getName())){
						city = new City();
					}else if("name".equals(parser.getName())){
						//获取下一个节点的文本,而且把指针移动到当前节点的结束节点
						city.setName(parser.nextText());
					}else if("temp".equals(parser.getName())){
						city.setTemp(parser.nextText());
					}else if("pm25".equals(parser.getName())){
						city.setPm25(parser.nextText());
					}
					break;
				case XmlPullParser.END_TAG:
					if("city".equals(parser.getName())){
						list.add(city);
					}
					break;
				}
    			type = parser.next();    			
    		}
    	}catch(Exception e){
    		e.printStackTrace();
    	}
    	
    	//输出数据
    	for (City city : list) {
			System.out.println(city.toString());
		}
    }
}
```
![mark](https://img.zouchanglin.cn/blog/20200822/8LWxbExN25d5.png)

生成器

创建生成器方法一

编译器与解释器

一、Ajax概述

什么是同步，什么是异步

Ajax的运行原理

1、首先附上要解析的xml数据