• jwt的简介以及jwt工具类的介绍

    目录

    一. jwt的简介

    二. jwt工具类介绍

    三. jwt集成spa项目

    一. jwt的简介

    JWT全称为JSON Web Token，是一种用于身份验证和授权的开放标准。它是一个紧凑且安全的方式，通过在不同系统之间传递可信任的信息来实现用户身份验证。JWT由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。

    头部包含了描述令牌类型和所使用的加密算法的元数据。常见的加密算法有HMAC、RSA等。载荷包含了要传输的数据，比如用户ID、角色和其他相关的声明信息。载荷可以自定义，但需要遵循一定的规范。

    签名是对头部和载荷进行签名生成的，用于验证令牌的真实性和完整性。它使用头部中指定的加密算法和密钥进行签名，并将签名与头部和载荷一起编码为一个字符串形式的JWT。

    JWT的精髓在于：“去中心化”，数据是保存在客户端的。 

    JWT的工作流程通常如下：当用户登录时，服务器会生成一个JWT并返回给客户端。客户端在后续的请求中将这个JWT放在请求的头部或参数中发送给服务器。服务器在接收到请求后会解析JWT，并根据其中的信息进行身份验证和授权。

    JWT的优点是可以避免在服务器端存储session信息，使得服务端无状态化，提高了系统的可扩展性。同时，JWT还具有跨域支持和自包含性的特点，使得它在分布式系统中广泛应用。

    需要注意的是，JWT仅仅对于信息的完整性和真实性提供了保护，但并不加密具体的数据。因此，在使用JWT时，应避免在载荷中包含敏感信息，或者对敏感信息进行加密处理。另外，由于JWT是基于Token的认证方式，为了确保安全性，应采取适当的措施保护JWT的传输过程和存储过程。

     

    二. jwt工具类介绍

    JWT工具类是一个用于生成、解析和验证JSON Web Token的辅助类。它提供了一系列方法来简化JWT的处理过程，使得开发者可以方便地在应用中使用JWT进行身份验证和授权。

    JWT工具类通常包括以下功能：

    1. 生成JWT：提供方法用于生成JWT，传入有效载荷和加密密钥等参数，生成符合规范的JWT字符串。

    2. 解析JWT：提供方法用于解析JWT，将JWT字符串解析成头部和载荷的JSON对象，并对签名进行验证。

    3. 验证JWT：提供方法用于验证JWT的有效性，包括验证签名是否正确、验证令牌是否过期等。

    4. 获取载荷信息：提供方法用于获取JWT中的载荷信息，比如用户ID、角色等。

    5. 刷新JWT：提供方法用于刷新JWT，生成新的JWT并返回给客户端，用于延长认证的有效期。

    6. 配置参数：提供方法用于配置JWT的相关参数，比如加密算法、密钥、过期时间等。

    使用JWT工具类可以简化JWT的处理逻辑，减少代码重复性，并增加系统的安全性。通过封装好的方法，开发者可以方便地在不同的场景中使用JWT进行身份验证和授权，提高开发效率。但需要注意，在使用JWT工具类时，应确保密钥的安全性，避免泄露导致令牌被篡改或伪造。

    1. package com.zking.ssm.jwt;
    2.  
    3. import java.util.Date;
    4. import java.util.Map;
    5. import java.util.UUID;
    6.  
    7. import javax.crypto.SecretKey;
    8. import javax.crypto.spec.SecretKeySpec;
    9.  
    10. import org.apache.commons.codec.binary.Base64;
    11.  
    12. import io.jsonwebtoken.Claims;
    13. import io.jsonwebtoken.JwtBuilder;
    14. import io.jsonwebtoken.Jwts;
    15. import io.jsonwebtoken.SignatureAlgorithm;
    16.  
    17. /**
    18.  * JWT验证过滤器：配置顺序 CorsFilte->JwtUtilsr-->StrutsPrepareAndExecuteFilter
    19.  *
    20.  */
    21. public class JwtUtils {
    22. 	/**
    23. 	 * JWT_WEB_TTL：WEBAPP应用中token的有效时间,默认30分钟
    24. 	 */
    25. 	public static final long JWT_WEB_TTL = 30 * 60 * 1000;
    26.  
    27. 	/**
    28. 	 * 将jwt令牌保存到header中的key
    29. 	 */
    30. 	public static final String JWT_HEADER_KEY = "jwt";
    31.  
    32. 	// 指定签名的时候使用的签名算法，也就是header那部分，jwt已经将这部分内容封装好了。
    33. 	private static final SignatureAlgorithm SIGNATURE_ALGORITHM = SignatureAlgorithm.HS256;
    34. 	private static final String JWT_SECRET = "f356cdce935c42328ad2001d7e9552a3";// JWT密匙
    35. 	private static final SecretKey JWT_KEY;// 使用JWT密匙生成的加密key
    36.  
    37. 	static {
    38. 		byte[] encodedKey = Base64.decodeBase64(JWT_SECRET);
    39. 		JWT_KEY = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
    40. 	}
    41.  
    42. 	private JwtUtils() {
    43. 	}
    44.  
    45. 	/**
    46. 	 * 解密jwt，获得所有声明(包括标准和私有声明)
    47. 	 * 
    48. 	 * @param jwt
    49. 	 * @return
    50. 	 * @throws Exception
    51. 	 */
    52. 	public static Claims parseJwt(String jwt) {
    53. 		Claims claims = Jwts.parser()
    54. 				.setSigningKey(JWT_KEY)
    55. 				.parseClaimsJws(jwt)
    56. 				.getBody();
    57. 		return claims;
    58. 	}
    59.  
    60. 	/**
    61. 	 * 创建JWT令牌，签发时间为当前时间
    62. 	 * 
    63. 	 * @param claims
    64. 	 *            创建payload的私有声明（根据特定的业务需要添加，如果要拿这个做验证，一般是需要和jwt的接收方提前沟通好验证方式的）
    65. 	 * @param ttlMillis
    66. 	 *            JWT的有效时间(单位毫秒)，当前时间+有效时间=过期时间
    67. 	 * @return jwt令牌
    68. 	 */
    69. 	public static String createJwt(Map<String, Object> claims, 
    70. 			long ttlMillis) {
    71. 		// 生成JWT的时间，即签发时间 2021-10-30 10:02:00 -> 30 10:32:00
    72. 	
    73. 		long nowMillis = System.currentTimeMillis();
    74.  
    75. 		
    76. 		//链式语法：
    77. 		// 下面就是在为payload添加各种标准声明和私有声明了
    78. 		// 这里其实就是new一个JwtBuilder，设置jwt的body
    79. 		JwtBuilder builder = Jwts.builder()
    80. 				// 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
    81. 				.setClaims(claims)
    82. 				// 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
    83. 				// 可以在未登陆前作为身份标识使用
    84. 				.setId(UUID.randomUUID().toString().replace("-", ""))
    85. 				// iss(Issuser)签发者，写死
    86. 				.setIssuer("zking")
    87. 				// iat: jwt的签发时间
    88. 				.setIssuedAt(new Date(nowMillis))
    89. 				// 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
    90. 				// .setSubject("{}")
    91. 				// 设置签名使用的签名算法和签名使用的秘钥
    92. 				.signWith(SIGNATURE_ALGORITHM, JWT_KEY)
    93. 				// 设置JWT的过期时间
    94. 				.setExpiration(new Date(nowMillis + ttlMillis));
    95.  
    96. 		return builder.compact();
    97. 	}
    98.  
    99. 	/**
    100. 	 * 复制jwt，并重新设置签发时间(为当前时间)和失效时间
    101. 	 * 
    102. 	 * @param jwt
    103. 	 *            被复制的jwt令牌
    104. 	 * @param ttlMillis
    105. 	 *            jwt的有效时间(单位毫秒)，当前时间+有效时间=过期时间
    106. 	 * @return
    107. 	 */
    108. 	public static String copyJwt(String jwt, Long ttlMillis) {
    109. 		//解密JWT，获取所有的声明（私有和标准）
    110. 		//old
    111. 		Claims claims = parseJwt(jwt);
    112.  
    113. 		// 生成JWT的时间，即签发时间
    114. 		long nowMillis = System.currentTimeMillis();
    115.  
    116. 		// 下面就是在为payload添加各种标准声明和私有声明了
    117. 		// 这里其实就是new一个JwtBuilder，设置jwt的body
    118. 		JwtBuilder builder = Jwts.builder()
    119. 				// 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
    120. 				.setClaims(claims)
    121. 				// 设置jti(JWT ID)：是JWT的唯一标识，根据业务需要，这个可以设置为一个不重复的值，主要用来作为一次性token,从而回避重放攻击。
    122. 				// 可以在未登陆前作为身份标识使用
    123. 				//.setId(UUID.randomUUID().toString().replace("-", ""))
    124. 				// iss(Issuser)签发者，写死
    125. 				// .setIssuer("zking")
    126. 				// iat: jwt的签发时间
    127. 				.setIssuedAt(new Date(nowMillis))
    128. 				// 代表这个JWT的主体，即它的所有人，这个是一个json格式的字符串，可放数据{"uid":"zs"}。此处没放
    129. 				// .setSubject("{}")
    130. 				// 设置签名使用的签名算法和签名使用的秘钥
    131. 				.signWith(SIGNATURE_ALGORITHM, JWT_KEY)
    132. 				// 设置JWT的过期时间
    133. 				.setExpiration(new Date(nowMillis + ttlMillis));
    134. 		return builder.compact();
    135. 	}
    136. }
    137.  
    138.  
    139.  
    140.

    三. jwt集成spa项目

    后台要求：

    1. 用户登录方法，放开用户信息生成jwt串保存到响应头中

    1. package com.zking.ssm.controller;
    2.  
    3. import com.zking.ssm.service.IUserService;
    4. import com.zking.ssm.util.JsonResponseBody;
    5. import com.zking.ssm.util.PageBean;
    6. import com.zking.ssm.vo.UserVo;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.stereotype.Controller;
    9. import org.springframework.web.bind.annotation.RequestMapping;
    10. import org.springframework.web.bind.annotation.ResponseBody;
    11.  
    12. import javax.servlet.http.HttpServletRequest;
    13. import javax.servlet.http.HttpServletResponse;
    14. import java.util.HashMap;
    15. import java.util.List;
    16. import java.util.Map;
    17. import com.zking.ssm.jwt.*;
    18.  
    19. @Controller
    20. @RequestMapping("/user")
    21. public class UserController {
    22.  
    23.     @Autowired
    24.     private IUserService userService;
    25.  
    26.     @RequestMapping("/userLogin")
    27.     @ResponseBody
    28.     public JsonResponseBody<?> userLogin(UserVo userVo, HttpServletResponse response){
    29.         if(userVo.getUsername().equals("admin")&&userVo.getPassword().equals("123")){
    30.             //私有要求claim
    31.             Map<String,Object> json=new HashMap<String,Object>();
    32.             json.put("username", userVo.getUsername());
    33. //            生成JWT，并设置到response响应头中
    34.             String jwt=JwtUtils.createJwt(json, JwtUtils.JWT_WEB_TTL);
    35.             response.setHeader(JwtUtils.JWT_HEADER_KEY, jwt);
    36.             return new JsonResponseBody<>("用户登陆成功！",true,0,null);
    37.         }else{
    38.             return new JsonResponseBody<>("用户名或密码错误！",false,0,null);
    39.         }
    40.     }
    41.  
    42.     @RequestMapping("/userRegister")
    43.     @ResponseBody
    44.     public JsonResponseBody<?> userRegistered(UserVo userVo, HttpServletRequest request){
    45.         int insertSelective = userService.insertSelective(userVo);
    46.         if(insertSelective>0){
    47.             return new JsonResponseBody<>("用户注册成功！",true,0,null);
    48.         }else{
    49.             return new JsonResponseBody<>("注册失败，请稍后！",false,0,null);
    50.         }
    51.     }
    52.  
    53.     @RequestMapping("/queryUserPager")
    54.     @ResponseBody
    55.     public JsonResponseBody<List<Map<String,Object>>>
    56.             queryUserPager(UserVo userVo, HttpServletRequest request){
    57.         try {
    58.             PageBean pageBean=new PageBean();
    59.             pageBean.setRequest(request);
    60.             List<Map<String, Object>> users = userService.queryUserPager(userVo, pageBean);
    61.             return new JsonResponseBody<>("OK",true,pageBean.getTotal(),users);
    62.         } catch (Exception e) {
    63.             e.printStackTrace();
    64.             return new JsonResponseBody<>("分页查询用户信息失败！",false,0,null);
    65.         }
    66.  
    67.     }
    68. }

    2. 关闭JwtFilter中的OFF开关，开启jwt验证

    1. package com.zking.ssm.jwt;
    2.  
    3. import java.io.IOException;
    4. import java.util.regex.Matcher;
    5. import java.util.regex.Pattern;
    6.  
    7. import javax.servlet.Filter;
    8. import javax.servlet.FilterChain;
    9. import javax.servlet.FilterConfig;
    10. import javax.servlet.ServletException;
    11. import javax.servlet.ServletRequest;
    12. import javax.servlet.ServletResponse;
    13. import javax.servlet.http.HttpServletRequest;
    14. import javax.servlet.http.HttpServletResponse;
    15.  
    16. import io.jsonwebtoken.Claims;
    17.  
    18. /**
    19.  * * JWT验证过滤器，配置顺序 ：CorsFilter-->JwtFilter-->struts2中央控制器
    20.  * 
    21.  * @author Administrator
    22.  *
    23.  */
    25. public class JwtFilter implements Filter {
    26.  
    27. 	// 排除的URL，一般为登陆的URL(请改成自己登陆的URL)
    28. 	private static String EXCLUDE = "^/user/userLogin?.*$";
    29.  
    30. 	private static Pattern PATTERN = Pattern.compile(EXCLUDE);
    31.  
    32. 	private boolean OFF = false;// true关闭jwt令牌验证功能
    33.  
    34. 	@Override
    35. 	public void init(FilterConfig filterConfig) throws ServletException {
    36. 	}
    37.  
    38. 	@Override
    39. 	public void destroy() {
    40. 	}
    41.  
    42. 	@Override
    43. 	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    44. 			throws IOException, ServletException {
    45. 		HttpServletRequest req = (HttpServletRequest) request;
    46. 		HttpServletResponse resp = (HttpServletResponse) response;
    47. 		//获取当前请求路径。只有登录的请求路径不进行校验之外，其他的URL请求路径必须进行JWT令牌校验
    48. 		//http://localhost:8080/ssh2/bookAction_queryBookPager.action
    49. 		//req.getServletPath()==/bookAction_queryBookPager.action
    50. 		String path = req.getServletPath();
    51. 		if (OFF || isExcludeUrl(path)) {// 登陆直接放行
    52. 				chain.doFilter(request, response);
    53. 				return;
    54. 		}
    55.  
    56. 		// 从客户端请求头中获得令牌并验证
    57. 		//token=头.载荷.签名
    58. 		String jwt = req.getHeader(JwtUtils.JWT_HEADER_KEY);
    59. 		Claims claims = this.validateJwtToken(jwt);
    60. 		//在这里请各位大哥大姐从JWT令牌中提取payload中的声明部分
    61. 		//从声明部分中获取私有声明
    62. 		//获取私有声明中的User对象 -> Modules
    63. 		Boolean flag=false;
    64. 		if (null == claims) {
    65. 			// resp.setCharacterEncoding("UTF-8");
    66. 			resp.sendError(403, "JWT令牌已过期或已失效");
    67. 			return;
    68. 		} else {
    69. 			
    70. 			//1.获取已经解析后的payload（私有声明）
    71. 			//2.从私有声明中当前用户所对应的权限集合List<String>或者List<Module>
    72. 			//3.循环权限(Module[id,url])
    73. 			// OK,放行请求 chain.doFilter(request, response);
    74. 			// NO,发送错误信息的JSON
    75. 			// ObjectMapper mapper=new ObjectMapper()
    76. 			// mapper.writeValue(response.getOutputStream(),json)
    77. 			
    78. 			String newJwt = JwtUtils.copyJwt(jwt, JwtUtils.JWT_WEB_TTL);
    79. 			resp.setHeader(JwtUtils.JWT_HEADER_KEY, newJwt);
    80. 			chain.doFilter(request, response);
    81. 		}
    82. 	}
    83.  
    84. 	/**
    85. 	 * 验证jwt令牌，验证通过返回声明(包括公有和私有)，返回null则表示验证失败
    86. 	 */
    87. 	private Claims validateJwtToken(String jwt) {
    88. 		Claims claims = null;
    89. 		try {
    90. 			if (null != jwt) {
    91. 				//该解析方法会验证：1）是否过期 2）签名是否成功
    92. 				claims = JwtUtils.parseJwt(jwt);
    93. 			}
    94. 		} catch (Exception e) {
    95. 			e.printStackTrace();
    96. 		}
    97. 		return claims;
    98. 	}
    99.  
    100. 	/**
    101. 	 * 是否为排除的URL
    102. 	 * 
    103. 	 * @param path
    104. 	 * @return
    105. 	 */
    106. 	private boolean isExcludeUrl(String path) {
    107. 		Matcher matcher = PATTERN.matcher(path);
    108. 		return matcher.matches();
    109. 	}
    110.  
    111. 	// public static void main(String[] args) {
    112. 	// String path = "/sys/userAction_doLogin.action?username=zs&password=123";
    113. 	// Matcher matcher = PATTERN.matcher(path);
    114. 	// boolean b = matcher.matches();
    115. 	// System.out.println(b);
    116. 	// }
    117.  
    118. }
    119.

    3. web.xml中要配置corsfilter，允许jwt使用请求头及响应头

    1. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    2.          xmlns="http://java.sun.com/xml/ns/javaee"
    3.          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    4.          id="WebApp_ID" version="3.0">
    5.   <display-name>Archetype Created Web Application</display-name>
    6.  
    7.   <!--1.实现Spring与Web集成，实现Spring上下文的初始化工作-->
    8.   <!-- spring上下文配置文件 -->
    9.   <context-param>
    10.     <param-name>contextConfigLocation</param-name>
    11.     <param-value>classpath:spring.xml</param-value>
    12.   </context-param>
    13.   <!-- 读取Spring上下文的监听器 -->
    14.   <listener>
    15.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    16.   </listener>
    17.  
    18.   <!--2.配置中文乱码过滤器，使用Spring自带的过滤器-->
    19.   <filter>
    20.     <filter-name>encodingFilter</filter-name>
    21.     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    22.     <async-supported>true</async-supported>
    23.     <init-param>
    24.       <param-name>encoding</param-name>
    25.       <param-value>UTF-8</param-value>
    26.     </init-param>
    27.   </filter>
    28.   <filter-mapping>
    29.     <filter-name>encodingFilter</filter-name>
    30.     <url-pattern>/*</url-pattern>
    31.   </filter-mapping>
    32.  
    33.   <!--CrosFilter跨域过滤器-->
    34.   <filter>
    35.     <filter-name>corsFilter</filter-name>
    36.     <filter-class>com.zking.ssm.util.CorsFilter</filter-class>
    37.   </filter>
    38.   <filter-mapping>
    39.     <filter-name>corsFilter</filter-name>
    40.     <url-pattern>/*</url-pattern>
    41.   </filter-mapping>
    42.  
    43.   <!--JwtFilter-->
    44.   <filter>
    45.     <filter-name>jwtFilter</filter-name>
    46.     <filter-class>com.zking.ssm.jwt.JwtFilter</filter-class>
    47.   </filter>
    48.   <filter-mapping>
    49.     <filter-name>jwtFilter</filter-name>
    50.     <url-pattern>/*</url-pattern>
    51.   </filter-mapping>
    52.  
    53.   <!--Spring MVC核心控制器-->
    54.   <servlet>
    55.     <servlet-name>SpringMVC</servlet-name>
    56.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    57.     <!--此参数可以不配置，默认值为：/WEB-INF/springmvc-servlet.xml-->
    58.     <init-param>
    59.       <param-name>contextConfigLocation</param-name>
    60.       <param-value>/WEB-INF/spring-mvc.xml</param-value>
    61.     </init-param>
    62.     <load-on-startup>1</load-on-startup>
    63.     <!--web.xml 3.0的新特性，是否支持异步-->
    64.     <async-supported>true</async-supported>
    65.   </servlet>
    66.   <servlet-mapping>
    67.     <servlet-name>SpringMVC</servlet-name>
    68.     <url-pattern>/</url-pattern>
    69.   </servlet-mapping>
    70. </web-app>

    前端代码：

    state.js

    1. export default{
    2.   wxName:'派大星',
    3.   jwt:''
    4. }

    mutations.js

    1. export default{
    2.   // state指的是state.js文件中导出的对象
    3.   // payload就是vue文件传递过来的参数
    4.   setWxName:(state,payload)=>{
    5.     state.wxName = payload.wxName
    6.   },
    7.   setJwt:(state,payload)=>{
    8.     state.jwt = payload.jwt
    9.   }
    10. }
    11.

    getters.js

    1. export default{
    2.   getWxName:(state)=>{
    3.     return state.wxName;
    4.   },
    5.   getJwt:(state)=>{
    6.     return state.jwt;
    7.   }
    8. }

    http.js

    1. /**
    2.  * vue项目对axios的全局配置
    3.  */
    4. import axios from 'axios'
    5. import qs from 'qs'
    6.  
    7. //引入action模块，并添加至axios的类属性urls上
    8. import action from '@/api/action'
    9. axios.urls = action
    10.  
    11. // axios默认配置
    12. axios.defaults.timeout = 10000; // 超时时间
    13. // axios.defaults.baseURL = 'http://localhost:8080/j2ee15'; // 默认地址
    14. axios.defaults.baseURL = action.SERVER;
    15.  
    16. //整理数据
    17. // 只适用于 POST,PUT,PATCH，transformRequest` 允许在向服务器发送前，修改请求数据
    18. axios.defaults.transformRequest = function(data) {
    19. 	data = qs.stringify(data);
    20. 	return data;
    21. };
    22.  
    23.  
    24. // 请求拦截器
    25. axios.interceptors.request.use(function(config) {
    26.   let jwt = window.vm.$store.getters.getJwt;
    27.   if(jwt){
    28.     config.headers['jwt']=jwt;
    29.   }
    30. 	return config;
    31. }, function(error) {
    32. 	return Promise.reject(error);
    33. });
    34.  
    35. // 响应拦截器
    36. axios.interceptors.response.use(function(response) {
    37.   let jwt = response.headers['jwt'];
    38.   if(jwt){
    39.     // 要将响应头中的jwt串放入到state.js中
    40.     window.vm.$store.commit('setJwt',{
    41.       jwt:jwt
    42.     });
    43.   }
    44. 	return response;
    45. }, function(error) {
    46. 	return Promise.reject(error);
    47. });
    48.  
    49.  
    50. export default axios;

    main.js

    1. // The Vue build version to load with the `import` command
    2. // (runtime-only or standalone) has been set in webpack.base.conf with an alias.
    3. import Vue from 'vue'
    4.  
    5. //开发环境下才会引入mockjs
    6. // process.env.MOCK && require('@/mock')
    7.  
    8. // 新添加1
    9. import ElementUI from 'element-ui'
    10. // 新添加2，避免后期打包样式不同，要放在import App from './App';之前
    11. import 'element-ui/lib/theme-chalk/index.css'
    12.  
    13. import App from './App'
    14. import router from './router'
    15. import store from './store'
    16.  
    17. // 新添加3
    18. Vue.use(ElementUI)
    19. Vue.config.productionTip = false
    20.  
    21. import axios from '@/api/http'
    22. import VueAxios from 'vue-axios'
    23.  
    24. Vue.use(VueAxios,axios)
    25.  
    26. /* eslint-disable no-new */
    27. window.vm = new Vue({
    28.   el: '#app',
    29.   router,
    30.   store,
    31.   data(){
    32.     return {
    33.       Bus:new Vue()
    34.     }
    35.   },
    36.   components: { App },
    37.   template: ''
    38. })
  • 相关阅读:
    CNN经典架构
    骚操作！居然能修改已运行的 Docker 容器端口映射？
    二、Flink SQL 调优汇总
    XmlDocument.SelectNodes 不起作用
    第6篇 vue的打包工具webpack
    HCIP练习02（OSPF）
    Excel中多条件判断公式怎么写？
    ZooKeeper-实战
    Android frameworks学习
    软考网络工程师知识点总结（五）
  • 原文地址：https://blog.csdn.net/lijie1025/article/details/133793620