web服务器是一个应用程序(软件),对HTTP协议的操作进行封装,目的是程序员不必直接对协议进行操作,让web开发更加便捷。将web项目部署到服务器上,对外提供“网上信息浏览服务”
Tomcat是一个轻量级的web服务器,支持Servlet/jsp等少量javeEE规范,也成为Servlet容器、web容器
在idea中使用骨架方式创建一个Maven Web项目
war 表示项目打包为war包,默认是jar包
在main下创建java和resources目录,有提示
每次如果都部署项目都要打包放到文件夹里去,这样太慢了,使用tomcat插件会更加方便
名称是tomcat7-maven-plugin,groupId是org开头,2.2版本
还可以在插件中进行一些配置如下:
使用configuration标签中的port标签可以修改端口号,
path标签可以用来修改项目访问路径,如果不配置,需要在网址栏输入项目名称再输入要访问的资源,改成/ 这样可以省略掉项目名称直接输入要访问的资源
可以直接在右侧栏Maven中运行:
使用插件更方便:
直接右键:可以点击编译运行等
1. Servlet是Java提供的一门动态web资源开发技术
2. Servlet是JavaEE规范之一,就是一个接口,我们需要定义Servlet类实现这个接口,并由web服务器运行Servlet
1.创建web项目,导入Servlet依赖坐标
alt+insert搜索servlet选择javax.servlet-api
添加之后由于项目在tomcat中运行,而tomcat中已经有了这个jar包,需要设置作用范围为provided
2.定义一个实现类,实现servlet接口,重写5个方法,可以在service中输出,service方法会自动执行
3.若要访问这个servlet需要给这个类提供@WebServlet(“/访问路径”)注解,添加 访问路径。之后就可以运行了
点击红色框的地址
地址栏输入ser1,控制台会输出那句话
创建项目实现了Servlet接口后,运行这个web项目是由tomcat完成的,
tomcat会自动创建一个实现类的对象,并且会自动执行service方法,
在地址栏中http://localhost:8080/tomcat/ser1中http://localhost:8080会访问到tomcat,加上tomcat会访问到创建的这个web项目,再加上ser1会访问到那个实现类。
Servlet是体系根接口,有一个HttpServlet是对HTTP协议的封装的Servlet实现类,
以后自定义Servlet时都会继承HttpServlet
继承之后需要重写doGet和doPost方法
HttpServlet原理:获取请求方式,并根据请求方式调用不同的doXxx方法
Servlet要想被访问,必须配置其访问路径(urlPattern)
并且一个Servlet可以配置多个urlPattern
在浏览器中访问一些资源时,会输入一些信息,而这些信息会被封装为一个Request对象传给服务器。
*由服务器tomcat来解析请求数据,封装为Request对象传递到service方法中。使用Request对象可以根据HttpServlet接口。可以通过Request对象获取这些信息。
*之后服务端又可以响应浏览器,将要响应的数据封装为Response对象再返回给浏览器,浏览器解析这些数据展现到页面上。
Request的继承体系:
ServletRequest:Java提供的请求对象根接口
HTttpServletRequest:Java提供的对HTTP协议封装的请求对象接口
RequestFacade:tomcat定义的实现类
String username = request.getParameter("username");
username=new String(username.getBytes(StandardCharsets.ISO_8859_1),StandardCharsets.UTF_8);
System.out.println(username);
是一种在服务器内部的资源跳转方式
实现:
req.getRequestDispatcher("资源B路径").forward(req,resp);
请求转发资源间数据共享
setAttribute(String name,Object,o);存储数据到request域中
getAttribute(String name);根据key获取值
removeAttribute(String name):根据key删除键值对
请求转发特点:
浏览器地址栏不变
只能转发到当前浏览器的内部资源
一次请求,可以在转发的资源间使用req共享数据
//demo2文件
System.out.println("demo2");
req.setAttribute("username","张三");
req.getRequestDispatcher("/demo3").forward(req,resp);
//demo3文件
System.out.println("demo3");
Object attribute = request.getAttribute("username");
System.out.println(attribute);
demo2
demo3
张三
通过 Request对象来获取请求数据
通过 Response对象来设置响应数据
响应数据分为3部分:
一种资源跳转方式
浏览器请求资源1,但资源1无法处理,设置响应状态码为302,再设置响应头的location为资源2的访问路径,由资源2处理
重定向特点:
1.浏览器地址栏发生变化
2.可以重定向到任意位置(服务器内部、外部)
3.是两次请求,不能在多个资源中共享数据
//demo3文件
String path = request.getContextPath();
System.out.println("d1");
response.setStatus(302);
response.setHeader("location",path+"/demo2");
//重定向简化书写:sendRedirect,替换原来的两行
response.sendRedirect(path+"/demo2");
//demo2文件
System.out.println("d2");
d2
d1
Response响应字节数据
要想将字节数据写回到浏览器,我们需要两个步骤:
通过Response对象获取字节输出流:ServletOutputStream outputStream = resp.getOutputStream();
通过字节输出流写数据: outputStream.write(字节数据);
Response响应字符数据
要想将字符数据写回到浏览器,我们需要两个步骤:
通过Response对象获取字符输出流: PrintWriter writer = resp.getWriter();
通过字符输出流写数据: writer.write(“aaa”);
// 返回一个中文的字符串你好,需要注意设置响应数据的编码为utf-8
response.setContentType("text/html;charset=utf-8");
PrintWriter writer = response.getWriter();
writer.write("qazxsw");
//content-type,告诉浏览器返回的数据类型是HTML类型数据,这样浏览器才会解析HTML标签
writer.write("
jiafanchen
");
// 注意:一次请求响应结束后,response对象就会被销毁掉,所以不要手动关闭流。
FileInputStream fileInputStream = new FileInputStream("d://0.jpg");
ServletOutputStream outputStream = response.getOutputStream();
byte[] bytes=new byte[1024];
int len=0;
while ((len=fileInputStream.read(bytes))!=-1){
outputStream.write(bytes,0,len);
}
fileInputStream.close();
//通过commons-io的IO工具类简化,导入依赖
IOUtils.copy(fileInputStream,outputStream);
fileInputStream.close();
会话:用户打开浏览器,访问web服务器,会话建立,直到有一方断开连接,会话结束。在一次会话中可以包含多次请求和响应
会话跟踪:服务器需要识别多次请求是否来自同一浏览器,以便在同一次会话的多次请求间共享数据
Http协议是无状态的,每次浏览器向服务器请求时,服务器都会将该请求视为新的请求,因此我们需要会话跟踪技术来实现会话内的数据共享
实现方式:
1. 客户端会话跟踪技术:Cookie
2. 服务端会话跟踪技术:Session
客户端会话技术,将数据保存到客户端,以后每次请求都携带Cookie数据进行访问
1. 创建Cookie对象,设置数据
new Cookie("key","value")
2. 发送Cookie到客户端:使用response对象
response.addCookie(cookie);
1. 获取客户端携带的所有Cookie,使用request对象
Cookie[] cookies=request.getCookies();
2. 遍历数组,获取每一个Cookie对象
3. 使用Cookie对象方法获取数据
cookie.getName();
cookie.getValue();
1. 服务器给浏览器发送Cookie数据,tomcat会进行解析并给Cookie数据加上响应头set-cookie,对应的值就是cookie数据
2. 浏览器接收到会对这个响应头解析,将cookie数据保存到浏览器内存中。下一次访问时浏览器会携带所有的cookie数据去访问,这些数据会加上请求头cookie
Cookie的实现是基于HTTP协议的
响应头:set-cookie
请求头:cookie
3. Cookie存活时间
默认情况,Cookie存储在浏览器内存中,当浏览器关闭时,内存释放,Cookie被销毁
通过setMaxAge(int seconds):设置Cookie存活时间。默认负数表示存到浏览器内存中。设置为正数,表示将Cookie写入浏览器所在电脑的硬盘中,到时间后自动删除。
4. Cookie不能直接存储中文,需要通过URL编码进行存储。获取Cookie时再通过URL解码
String s="贾凡琛";
s = URLEncoder.encode(s, "utf-8");
Cookie cookie = new Cookie("user", s);
response.addCookie(cookie);
Cookie[] cookies = request.getCookies();
for (Cookie cookie :cookies) {
if ("user".equals(cookie.getName())){
System.out.println(cookie.getName()+":"+ URLDecoder.decode(cookie.getValue(),"utf-8"));
break;
}
}
服务端会话跟踪技术:就数据保存到服务端
通过HttpSession接口来实现一次会话的多次请求间数据共享
获取Session对象:
request.getSession()
通过Session对象来获取和存储数据:
setAttribute(String name,Object,o);存储数据到session域中
getAttribute(String name);根据key获取值
removeAttribute(String name):根据key删除键值对
1. Session是基于Cookie实现的,当浏览器第一次请求时,创建session对象,这个对象会有一个id值,将id值响应给浏览器set-cookie:JSEESSIONID=10,浏览器会保存这个数据。
2. 下一次访问时浏览器携带这个id再次请求时,再次获取session对象时会根据id值找到对应的session,如果没有找到才会创建一个新的。
3. Session钝化:在服务器正常关闭后,tomcat会自动将session数据写入硬盘的文件中
Session活化:再次启动服务器后,从文件中加载数据到Session中
Session销毁:默认情况下,没有操作,30min自动销毁
session.invalidate():销毁这个session对象
filter是过滤器,javaweb三大组件(Servlet、Filter、Listener)。过滤器可以把对资源的请求拦截下来,完成一些通用的操作,如权限控制、同一编码、敏感字符处理等。
1. 定义类,实现Filter接口,并重写其三个方法
2. 配置Filter拦截资源的路径:在类上通过@WebFilter注解,@WebFilter("/*")
3. 在doFilter方法中编写:放行前的逻辑、放行、放行后的逻辑
执行流程:放行前的逻辑——>放行——>访问资源——>放行后的逻辑
一个web应用中可以配置多个过滤器,形成过滤器链
执行顺序是比较类名
异步的JavaScript和XML
作用:
1. 与服务器进行数据交换:通过Ajax可以给服务器发送请求,并获取服务器相应的数据,使用HTML+AJAX替换jsp页面
2. 异步交互:在不加载整个页面的前提下,与服务器交换数据并更新部分网页的技术,如:百度搜索、用户名是否存在的校验
引入axios的js文件
使用axios发送请求,并获取响应结果
发送 get 请求
axios({
method:"get",
url:"http://localhost:8080/ajax-demo1/aJAXDemo1?username=zhangsan"
}).then(function (resp){
alert(resp.data);
})
发送 post 请求
axios({
method:"post",
url:"http://localhost:8080/ajax-demo1/aJAXDemo1",
data:"username=zhangsan"
}).then(function (resp){
alert(resp.data);
});
axios()
是用来发送异步请求的,小括号中使用 js 对象传递请求相关的参数:
method
属性:用来设置请求方式的。取值为 get
或者 post
。url
属性:用来书写请求的资源路径。如果是 get
请求,需要将请求参数拼接到路径的后面,格式为: url?参数名=参数值&参数名2=参数值2
。data
属性:作为请求体被发送的数据。也就是说如果是 post
请求的话,数据需要作为 data
属性的值。then()
需要传递一个匿名函数。我们将 then()
中传递的匿名函数称为 回调函数,意思是该匿名函数在发送请求时不会被调用,而是在成功响应后调用的函数。而该回调函数中的 resp
参数是对响应的数据进行封装的对象,通过 resp.data
可以获取到响应的数据。
概念:JavaScript Object Notation
。JavaScript 对象表示法.
如下是 JavaScript
对象的定义格式:
{
name:"zhangsan",
age:23,
city:"北京"
}
接下来我们再看看 JSON
的格式:
{
"name":"zhangsan",
"age":23,
"city":"北京"
}
通过上面 js 对象格式和 json 格式进行对比,发现两个格式特别像。只不过 js 对象中的属性名可以使用引号(可以是单引号,也可以是双引号);而 json
格式中的键要求必须使用双引号括起来,这是 json
格式的规定。json
格式的数据有什么作用呢?
作用:由于其语法格式简单,层次结构鲜明,现多用于作为数据载体,在网络中进行数据传输。如下图所示就是服务端给浏览器响应的数据,这个数据比较简单,如果现需要将 JAVA 对象中封装的数据响应回给浏览器的话,应该以何种数据传输呢?
大家还记得 ajax
的概念吗? 是 异步的 JavaScript 和 xml。这里的 xml就是以前进行数据传递的方式,如下:
<student>
<name>张三name>
<age>23age>
<city>北京city>
student>
再看 json
描述以上数据的写法:
{
"name":"张三",
"age":23,
"city":"北京"
}
上面两种格式进行对比后就会发现 json
格式数据的简单,以及所占的字节数少等优点。
JSON
本质就是一个字符串,但是该字符串内容是有一定的格式要求的。 定义格式如下:
var 变量名 = '{"key":value,"key":value,...}';
JSON
串的键要求必须使用双引号括起来,而值根据要表示的类型确定。value 的数据类型分为如下
示例:
var jsonStr = '{"name":"zhangsan","age":23,"addr":["北京","上海","西安"]}'
创建一个页面,在该页面的 标签中定义json字符串
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Titletitle>
head>
<body>
<script>
//1. 定义JSON字符串
var jsonStr = '{"name":"zhangsan","age":23,"addr":["北京","上海","西安"]}'
alert(jsonStr);
script>
body>
html>
现在我们需要获取到该 JSON
串中的 name
属性值,应该怎么处理呢?
如果它是一个 js 对象,我们就可以通过 js对象.属性名
的方式来获取数据。JS 提供了一个对象 JSON
,该对象有如下两个方法:
parse(str)
:将 JSON串转换为 js 对象。使用方式是: var jsObject = JSON.parse(jsonStr);
stringify(obj)
:将 js 对象转换为 JSON 串。使用方式是:var jsonStr = JSON.stringify(jsObject)
代码演示:
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Titletitle>
head>
<body>
<script>
//1. 定义JSON字符串
var jsonStr = '{"name":"zhangsan","age":23,"addr":["北京","上海","西安"]}'
alert(jsonStr);
//2. 将 JSON 字符串转为 JS 对象
let jsObject = JSON.parse(jsonStr);
alert(jsObject)
alert(jsObject.name)
//3. 将 JS 对象转换为 JSON 字符串
let jsonStr2 = JSON.stringify(jsObject);
alert(jsonStr2)
script>
body>
html>
后面我们使用 axios
发送请求时,如果要携带复杂的数据时都会以 JSON
格式进行传递,如下
axios({
method:"post",
url:"http://localhost:8080/ajax-demo/axiosServlet",
data:"username=zhangsan"
}).then(function (resp) {
alert(resp.data);
})
请求参数不可能由我们自己拼接字符串吧?肯定不用,可以提前定义一个 js 对象,用来封装需要提交的参数,然后使用 JSON.stringify(js对象)
转换为 JSON
串,再将该 JSON
串作为 axios
的 data
属性值进行请求参数的提交。如下:
var jsObject = {name:"张三"};
axios({
method:"post",
url:"http://localhost:8080/ajax-demo/axiosServlet",
data: JSON.stringify(jsObject)
}).then(function (resp) {
alert(resp.data);
})
而 axios
是一个很强大的工具。我们只需要将需要提交的参数封装成 js 对象,并将该 js 对象作为 axios
的 data
属性值进行,它会自动将 js 对象转换为 JSON
串进行提交。如下:
var jsObject = {name:"张三"};
axios({
method:"post",
url:"http://localhost:8080/ajax-demo/axiosServlet",
data:jsObject //这里 axios 会将该js对象转换为 json 串的
}).then(function (resp) {
alert(resp.data);
})
注意:
- js 提供的
JSON
对象我们只需要了解一下即可。因为axios
会自动对 js 对象和JSON
串进行想换转换。- 发送异步请求时,如果请求参数是
JSON
格式,那请求方式必须是POST
。因为JSON
串需要放在请求体中。
学习完 json 后,接下来聊聊 json 的作用。以后我们会以 json 格式的数据进行前后端交互。前端发送请求时,如果是复杂的数据就会以 json 提交给后端;而后端如果需要响应一些复杂的数据时,也需要以 json 格式将数据响应回给浏览器。
在后端我们就需要重点学习以下两部分操作:
接下来给大家介绍一套 API,可以实现上面两部分操作。这套 API 就是 Fastjson
Fastjson
是阿里巴巴提供的一个Java语言编写的高性能功能完善的 JSON
库,是目前Java语言中最快的 JSON
库,可以实现 Java
对象和 JSON
字符串的相互转换。
Fastjson
使用也是比较简单的,分为以下三步完成
导入坐标
<dependency>
<groupId>com.alibabagroupId>
<artifactId>fastjsonartifactId>
<version>1.2.62version>
dependency>
Java对象转JSON
String jsonStr = JSON.toJSONString(obj);
将 Java 对象转换为 JSON 串,只需要使用 Fastjson
提供的 JSON
类中的 toJSONString()
静态方法即可。
JSON字符串转Java对象
User user = JSON.parseObject(jsonStr, User.class);
将 json 转换为 Java 对象,只需要使用 Fastjson
提供的 JSON
类中的 parseObject()
静态方法即可。
引入坐标
创建一个类,专门用来测试 Java 对象和 JSON 串的相互转换,代码如下:
public class FastJsonDemo {
public static void main(String[] args) {
//1. 将Java对象转为JSON字符串
User user = new User();
user.setId(1);
user.setUsername("zhangsan");
user.setPassword("123");
String jsonString = JSON.toJSONString(user);
System.out.println(jsonString);//{"id":1,"password":"123","username":"zhangsan"}
//2. 将JSON字符串转为Java对象
User u = JSON.parseObject("{\"id\":1,\"password\":\"123\",\"username\":\"zhangsan\"}", User.class);
System.out.println(u);
}
}
Vue 是一套前端框架,免除原生JavaScript中的DOM操作,简化书写。
基于MVVM(Model-View-ViewModel)思想,实现数据的双向绑定,将编程的关注点放在数据上。==之前我们是将关注点放在了 DOM 操作上;
MVC
思想是没法进行双向绑定的。双向绑定是指当数据模型数据发生变化时,页面展示的会随之发生变化,而如果表单数据发生变化,绑定的模型数据也随之发生变化。
图中的 Model
就是我们的数据,View
是视图,也就是页面标签,用户可以通过浏览器看到的内容;Model
和 View
是通过 ViewModel
对象进行双向绑定的,而 ViewModel
对象是 Vue
提供的。接下来让大家看一下双向绑定的效果,下图是提前准备的代码,输入框绑定了 username
模型数据,而在页面上也使用 {{}}
绑定了 username
模型数据
Vue 使用起来是比较简单的,总共分为如下三步:
<script src="js/vue.js">script>
在JS代码区域,创建Vue核心对象,进行数据绑定
new Vue({
el: "#app",
data() {
return {
username: ""
}
}
});
创建 Vue 对象时,需要传递一个 js 对象,而该对象中需要如下属性:
el
: 用来指定哪儿些标签受 Vue 管理。 该属性取值 #app
中的 app
需要是受管理的标签的id属性值data
:用来定义数据模型methods
:用来定义函数。这个我们在后面就会用到编写视图
<div id="app">
<input name="username" v-model="username" >
{{username}}
div>
{{}}
是 Vue 中定义的 插值表达式
,在里面写数据模型,到时候会将该模型的数据值展示在这个位置。
整体代码如下:
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Titletitle>
head>
<body>
<div id="app">
<input v-model="username">
{{username}}
div>
<script src="js/vue.js">script>
<script>
//1. 创建Vue核心对象
new Vue({
el:"#app",
data(){ // data() 是 ECMAScript 6 版本的新的写法
return {
username:""
}
}
/*data: function () {
return {
username:""
}
}*/
});
script>
body>
html>
**指令:**HTML 标签上带有 v- 前缀的特殊属性,不同指令具有不同含义。例如:v-if,v-for…
常用的指令有:
指令 | 作用 |
---|---|
v-bind | 为HTML标签绑定属性值,如设置 href , css样式等 |
v-model | 在表单元素上创建双向数据绑定 |
v-on | 为HTML标签绑定事件 |
v-if | 条件性的渲染某元素,判定为true时渲染,否则不渲染 |
v-else | |
v-else-if | |
v-show | 根据条件展示某元素,区别在于切换的是display属性的值 |
v-for | 列表渲染,遍历容器的元素或者对象的属性 |
v-bind
该指令可以给标签原有属性绑定模型数据。这样模型数据发生变化,标签属性值也随之发生变化
例如:
<a v-bind:href="url">百度一下a>
上面的 v-bind:"
可以简化写成 :
,如下:
<a :href="url">百度一下a>
v-model
该指令可以给表单项标签绑定模型数据。这样就能实现双向绑定效果。例如:
<input name="username" v-model="username">
代码演示:
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Titletitle>
head>
<body>
<div id="app">
<a v-bind:href="url">点击一下a>
<a :href="url">点击一下a>
<input v-model="url">
div>
<script src="js/vue.js">script>
<script>
//1. 创建Vue核心对象
new Vue({
el:"#app",
data(){
return {
username:"",
url:"https://www.baidu.com"
}
}
});
script>
body>
html>
v-on
我们在页面定义一个按钮,并给该按钮使用 v-on
指令绑定单击事件,html代码如下
<input type="button" value="一个按钮" v-on:click="show()">
而使用 v-on
时还可以使用简化的写法,将 v-on:
替换成 @
,html代码如下
<input type="button" value="一个按钮" @click="show()">
上面代码绑定的 show()
需要在 Vue 对象中的 methods
属性中定义出来
new Vue({
el: "#app",
methods: {
show(){
alert("我被点了");
}
}
});
注意:
v-on:
后面的事件名称是之前原生事件属性名去掉on。例如:
- 单击事件 : 事件属性名是 onclick,而在vue中使用是
v-on:click
- 失去焦点事件:事件属性名是 onblur,而在vue中使用时
v-on:blur
整体页面代码如下:
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Titletitle>
head>
<body>
<div id="app">
<input type="button" value="一个按钮" v-on:click="show()"><br>
<input type="button" value="一个按钮" @click="show()">
div>
<script src="js/vue.js">script>
<script>
//1. 创建Vue核心对象
new Vue({
el:"#app",
data(){
return {
username:"",
}
},
methods:{
show(){
alert("我被点了...");
}
}
});
script>
body>
html>
条件判断指令
接下来通过代码演示一下。在 Vue中定义一个 count
的数据模型,如下
//1. 创建Vue核心对象
new Vue({
el:"#app",
data(){
return {
count:3
}
}
});
现在要实现,当 count
模型的数据是3时,在页面上展示 div1
内容;当 count
模型的数据是4时,在页面上展示 div2
内容;count
模型数据是其他值时,在页面上展示 div3
。这里为了动态改变模型数据 count
的值,再定义一个输入框绑定 count
模型数据。html 代码如下:
<div id="app">
<div v-if="count == 3">div1div>
<div v-else-if="count == 4">div2div>
<div v-else>div3div>
<hr>
<input v-model="count">
div>
整体页面代码如下:
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Titletitle>
head>
<body>
<div id="app">
<div v-if="count == 3">div1div>
<div v-else-if="count == 4">div2div>
<div v-else>div3div>
<hr>
<input v-model="count">
div>
<script src="js/vue.js">script>
<script>
//1. 创建Vue核心对象
new Vue({
el:"#app",
data(){
return {
count:3
}
}
});
script>
body>
html>
通过浏览器打开页面并在输入框输入不同的值,效果如下
然后我们在看看 v-show
指令的效果,如果模型数据 count
的值是3时,展示 div v-show
内容,否则不展示,html页面代码如下
<div v-show="count == 3">div v-showdiv>
<br>
<input v-model="count">
浏览器打开效果如下:
通过上面的演示,发现 v-show
和 v-if
效果一样,那它们到底有什么区别呢?我们根据浏览器的检查功能查看源代码
通过上图可以看出 v-show
不展示的原理是给对应的标签添加 display
css属性,并将该属性值设置为 none
,这样就达到了隐藏的效果。而 v-if
指令是条件不满足时根本就不会渲染。
v-for 指令
这个指令看到名字就知道是用来遍历的,该指令使用的格式如下:
<标签 v-for="变量名 in 集合模型数据">
{{变量名}}
标签>
注意:需要循环那个标签,
v-for
指令就写在那个标签上。
如果在页面需要使用到集合模型数据的索引,就需要使用如下格式:
<标签 v-for="(变量名,索引变量) in 集合模型数据">
{{索引变量 + 1}} {{变量名}}
标签>
代码演示:
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Titletitle>
head>
<body>
<div id="app">
<div v-for="addr in addrs">
{{addr}} <br>
div>
<hr>
<div v-for="(addr,i) in addrs">
{{i+1}}--{{addr}} <br>
div>
div>
<script src="js/vue.js">script>
<script>
//1. 创建Vue核心对象
new Vue({
el:"#app",
data(){
return {
addrs:["北京","上海","西安"]
}
}
});
script>
body>
html>
生命周期的八个阶段:每触发一个生命周期事件,会自动执行一个生命周期方法,这些生命周期方法也被称为钩子方法。
mounted
:挂载完成,Vue初始化成功,HTML页面渲染成功。而以后我们会在该方法中发送异步请求,加载数据。