spring 测试类test测试方法
实例掩码地址为：孔浩组织结构设计
web.xml配置文件：
<!-- Spring 的监听器可以通过这个上下文参数来获取beans.xml的位置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:beans.xml</param-value>
</context-param>
测试类
package org.konghao.service; import javax.inject.Inject; import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.konghao.sys.org.iservice.IInitService;
import org.springframework.orm.hibernate4.SessionHolder;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.support.TransactionSynchronizationManager; @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/beans.xml")
public class TestInitService {
@Inject
private IInitService initService;
@Inject
23 private SessionFactory sessionFactory;
24
25 @Before
26 public void setUp() {
27 //此时最好不要使用Spring的Transactional来管理，因为dbunit是通过jdbc来处理connection，再使用spring在一些编辑操作中会造成事务shisu
28 Session s = sessionFactory.openSession();
29 TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(s));
30 //SystemContext.setRealPath("D:\\teach_source\\class2\\j2EE\\dingan\\cms-da\\src\\main\\webapp");
31 }
32
33 @After
34 public void tearDown() {
35 SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
36 Session s = holder.getSession();
37 s.flush();
38 TransactionSynchronizationManager.unbindResource(sessionFactory);
39 }
@Test
public void testInitByXml() {
initService.initEntityByXml("orgs.xml");
}
}
解析xml文件 将信息保存到数据库;
package org.konghao.sys.org.service.impl; import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List; import javax.inject.Inject; import org.apache.commons.beanutils.BeanUtils;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.konghao.sys.org.iservice.IInitService;
import org.konghao.sys.org.model.SysException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.stereotype.Service; @Service("initService")
public class InitService extends AbstractBaseSevice implements IInitService{ private Document document;
@Inject
private BeanFactory factory; @Override
public void initEntityByXml(String filename) {
Element root = this.readDocument(filename);
String pname = root.attributeValue("package");
List<Element> initEntitys = root.selectNodes("/entitys/initEntity");
for (Element element : initEntitys) {
//如果这个实体存在就不添加
if (element.attributeValue("exist") == "1") {
continue;
}else{
String cname = element.attributeValue("class");
cname = pname + "." + cname;
String method = element.attributeValue("method");
List<Element> entitys = (List<Element>)element.selectNodes("entity");
addElements(cname,method,entitys);
}
}
} private Element readDocument(String filename){
try {
SAXReader saxReader = new SAXReader();
Document d = saxReader.read( InitService.class.getClassLoader().getResourceAsStream("init/" + filename));
return d.getRootElement();
} catch (DocumentException e) {
e.printStackTrace();
}
return null; } private void addElements(String cname, String method, List<Element> entitys) {
for (Element element : entitys) {
addElement(cname , method , element);
}
} private void addElement(String cname, String method, Element element) {
List<Attribute> attrs = element.attributes();
try {
Object o = Class.forName(cname).newInstance();
String[] methods = method.split("\\.");
if (methods.length !=2) {
throw new SysException("方法格式不正确");
}
String sname = methods[0]; //对应org.xml文件的method的第一个
String mname = methods[1];
for (Attribute attribute : attrs) {
System.out.println(attribute.getName() + " ; " + attribute.getValue());
String name = attribute.getName();
String value = attribute.getValue();
BeanUtils.copyProperty(o, name, value);//利用反射进行拷贝
}
Object service = factory.getBean(sname);//该sname应该与注入的service名称一致 ，例如本地中使用的是OrgtypeService，则对应的service也是OrgTypeService，否则将报找不到该注入的类型
Method m = service.getClass().getMethod(mname , o.getClass());
m.invoke(service, o);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
解析文件：
<?xml version="1.0" encoding="UTF-8"?>
<entitys package="org.konghao.sys.org.model" >
<initEntity exist="1" class="OrgType" method="OrgTypeService.add">
<entity name="学校" sn="XX" />
<entity name="分校" sn="FX" />
<entity name="校办领导" sn="XBLD" />
<entity name="行政部门" sn="XZBM" />
<entity name="教学部门" sn="JXBM" />
<entity name="专业" sn="ZY" />
<entity name="班级" sn=" BJ" />
</initEntity> <initEntity exist="0" class="Position" method="PositionService.add">
<entity name="校长" sn="XZ" />
<entity name="副校长" sn="FXZ" />
<entity name="处长" sn="CZ" />
<entity name="副处长" sn="FCZ" />
<entity name="科长" sn="KZ" />
<entity name="辅导员" sn="RDY" />
<entity name="班主任" sn="BZR" />
</initEntity>
</entitys>
底层实现：
package org.konghao.sys.org.service.impl; import java.util.List; import javax.inject.Inject; import org.konghao.sys.org.idao.IOrgTypeDao;
import org.konghao.sys.org.iservice.IOrgTypeService;
import org.konghao.sys.org.model.OrgType;
import org.konghao.sys.org.model.SysException;
import org.springframework.stereotype.Service; @Service("OrgTypeService")
public class OrgTypeService extends AbstractBaseSevice implements IOrgTypeService{ @Inject
private IOrgTypeDao orgTypeDao; @Override
public void add(OrgType orgType) {
if (orgTypeDao.loadBySn(orgType.getSn()) != null) {
throw new SysException("要添加的组织机构类型的sn已经存在");
}
orgTypeDao.add(orgType);
} }
spring的beans.xml配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
<!-- 打开Spring的Annotation支持 -->
<context:annotation-config />
<!-- 设定Spring 去哪些包中找Annotation -->
<context:component-scan base-package="org.konghao" /> <bean id="ftlPath" class="java.lang.String">
<constructor-arg value="/ftl"/>
</bean> <bean id="outPath" class="java.lang.String">
<constructor-arg value="/jsp/template"/>
</bean> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<!-- 配置连接池的初始值 -->
<property name="initialSize" value="1" />
<!-- 连接池的最大值 -->
<!-- <property name="maxActive" value="500"/> -->
<!-- 最大空闲时，当经过一个高峰之后，连接池可以将一些用不到的连接释放，一直减少到maxIdle为止 -->
<!-- <property name="maxIdle" value="2"/> -->
<!-- 当最小空闲时，当连接少于minIdle时会自动去申请一些连接 -->
<property name="minIdle" value="1" />
<property name="maxActive" value="100" />
<property name="maxIdle" value="20" />
<property name="maxWait" value="1000" />
</bean>
<!--创建Spring的SessionFactory工厂 -->
<context:property-placeholder location="classpath:jdbc.properties" />
<!--
和hibernate4整合没有提供专门的针对Annotation的类，直接在LocalSessionFactoryBean中已经集成
-->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource" />
<!-- 设置Spring取那个包中查找相应的实体类 -->
<property name="packagesToScan">
<value>org.konghao.sys.org.model</value>
</property>
<property name="hibernateProperties">
<!-- <value> hibernate.dialect=org.hibernate.dialect.HSQLDialect </value> -->
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.format_sql">true</prop>
</props>
</property>
</bean> <!-- 配置Spring的事务处理 -->
<!-- 创建事务管理器-->
<bean id="txManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 配置AOP，Spring是通过AOP来进行事务管理的 -->
<aop:config>
<!-- 设置pointCut表示哪些方法要加入事务处理 -->
<!-- 以下的事务是声明在DAO中，但是通常都会在Service来处理多个业务对象逻辑的关系，注入删除，更新等，此时如果在执行了一个步骤之后抛出异常
就会导致数据不完整，所以事务不应该在DAO层处理，而应该在service，这也就是Spring所提供的一个非常方便的工具，声明式事务 -->
<aop:pointcut id="allMethods"
expression="execution(* org.konghao.sys.org.service.impl.*.*(..))" />
<!-- 通过advisor来确定具体要加入事务控制的方法 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="allMethods" />
</aop:config>
<!-- 配置哪些方法要加入事务控制 -->
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<!-- 让所有的方法都加入事务管理，为了提高效率，可以把一些查询之类的方法设置为只读的事务 -->
<tx:method name="*" propagation="REQUIRED" read-only="true"/>
<!-- 以下方法都是可能设计修改的方法，就无法设置为只读 -->
<tx:method name="add*" propagation="REQUIRED"/>
<tx:method name="del*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="clear*" propagation="REQUIRED"/>
<tx:method name="empty*" propagation="REQUIRED"/>
<tx:method name="init*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
</beans>
————————————————————————————————————————————————————————————————————————
版本3： 多层次解析xml文件的实现
package org.konghao.sys.org.service.impl; import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.List; import javax.inject.Inject;
import javax.persistence.criteria.CriteriaBuilder.In; import org.apache.commons.beanutils.BeanUtils;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.konghao.sys.org.iservice.IInitService;
import org.konghao.sys.org.model.OrgType;
import org.konghao.sys.org.model.SysException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.stereotype.Service; @Service("initService")
public class InitService extends AbstractBaseSevice implements IInitService{ private Document document;
@Inject
private BeanFactory factory; @Override
public void initEntityByXml(String filename) {
Element root = this.readDocument(filename);
String pname = root.attributeValue("package");
List<Element> initEntitys = root.selectNodes("/entitys/initEntity");
for (Element element : initEntitys) {
String ipname = element.attributeValue("package");
String cname = element.attributeValue("class");
System.out.println(element.attributeValue("exist"));
//如果为1 表示已经添加过了
if (element.attributeValue("exist") == "1" || element.attributeValue("exist").equals("1")) {
continue;
}if (ipname != null && !"".equals(ipname)) {
cname = ipname + "." + cname;
} else{
cname = pname + "." + cname;
}
String method = element.attributeValue("method");
List<Element> entitys = (List<Element>)element.selectNodes("entity");
System.out.println(cname + " " + method );
addElements(cname,method,entitys); }
} private Element readDocument(String filename){
try {
SAXReader saxReader = new SAXReader();
Document d = saxReader.read( InitService.class.getClassLoader().getResourceAsStream("init/" + filename));
return d.getRootElement();
} catch (DocumentException e) {
e.printStackTrace();
}
return null; } private void addElements(String cname, String method, List<Element> entitys) {
for (Element element : entitys) {
addElement(cname , method , element , null);
}
} private void addElement(String cname, String method, Element e,Object parent) {
try {
//获取所有的属性
List<Attribute> atts = (List<Attribute>)e.attributes();
Object obj = Class.forName(cname).newInstance();
String [] ms = method.split("\\.");
if(ms.length!=2) throw new SysException("方法格式不正确");
String sname = ms[0]; String mname = ms[1];
for(Attribute att:atts) {
String name = att.getName();
String value = att.getValue();
BeanUtils.copyProperty(obj, name, value);
}
if(parent!=null) {
87 BeanUtils.copyProperty(obj, "parent", parent);
88 }
89 Object service = factory.getBean(sname);
90 Method m = service.getClass().getMethod(mname,obj.getClass());
91 m.invoke(service, obj);
92 List<Element> es = e.selectNodes("entity");
93 for(Element ele:es) {
94 addElement(cname, method, ele, obj);
95 }
} catch (ClassNotFoundException e1) {
e1.printStackTrace();
} catch (IllegalAccessException e1) {
e1.printStackTrace();
} catch (InvocationTargetException e1) {
e1.printStackTrace();
} catch (SecurityException e1) {
e1.printStackTrace();
} catch (NoSuchMethodException e1) {
e1.printStackTrace();
} catch (InstantiationException e1) {
e1.printStackTrace();
}
} }
实体类Org
package org.konghao.sys.org.model; import java.util.List; import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table; /**
* 组织对象，该表可以生成完整的组织树
* 根据组织类型来具体存储实际中存在的组织
* 学院 --> xx
* 校本部--> FX
* 南校区--> FX
* @author jrx
*
*/
@Entity
@Table(name="t_org")
public class Org { /**
* 组织机构的id
*/
private int id;
/**
* 组织机构的名称
*/
private String name ;
/**
* 组织机构所属类型的id，此处不要使用ManyToOne
*/
private Integer typeId;
/**
* 组织机构所属类型的名称，冗余
*/
private String typeName;
/**
* 组织机构的排序号
*/
private Integer orderNum ;
/**
* 组织机构的父亲组织
*/
private Org parent ;
/**
* 管理类型
*/
private int managerType;
/**
* 组织机构的地址
*/
private String address ;
/**
* 组织机构的电话
*/
private String phone ;
/**
* 扩展属性，用于在针对某些特殊的组织存储相应的信息
*/
private String att1 ;
private String att2 ;
private String att3 ; @Id
@GeneratedValue
public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} @Column(name="tid")
public Integer getTypeId() {
return typeId;
} public void setTypeId(Integer typeId) {
this.typeId = typeId;
}
@Column(name="tname")
public String getTypeName() {
return typeName;
} public void setTypeName(String typeName) {
this.typeName = typeName;
}
@Column(name="order_num")
public Integer getOrderNum() {
return orderNum;
} public void setOrderNum(Integer orderNum) {
this.orderNum = orderNum;
}
@ManyToOne
@JoinColumn(name="pid")
public Org getParent() {
return parent;
} public void setParent(Org parent) {
this.parent = parent;
} public String getAddress() {
return address;
} public void setAddress(String address) {
this.address = address;
} public String getPhone() {
return phone;
} public void setPhone(String phone) {
this.phone = phone;
} public String getAtt1() {
return att1;
} public void setAtt1(String att1) {
this.att1 = att1;
} public String getAtt2() {
return att2;
} public void setAtt2(String att2) {
this.att2 = att2;
} public String getAtt3() {
return att3;
} public void setAtt3(String att3) {
this.att3 = att3;
} @Column(name = "manager_type")
public int getManagerType() {
return managerType;
} public void setManagerType(int managerType) {
this.managerType = managerType;
} @Override
public String toString() {
return "Org [id=" + id + ", name=" + name + ", typeId=" + typeId
+ ", typeName=" + typeName + ", orderNum=" + orderNum
+ ", parent=" + parent + ", managerType=" + managerType
+ ", address=" + address + ", phone=" + phone + ", att1="
+ att1 + ", att2=" + att2 + ", att3=" + att3 + "]";
} }
底层实现：
package org.konghao.sys.org.service.impl; import java.util.List; import javax.inject.Inject; import org.konghao.basic.model.Pager;
import org.konghao.sys.dto.TreeDto;
import org.konghao.sys.org.idao.IOrgDao;
import org.konghao.sys.org.idao.IOrgTypeDao;
import org.konghao.sys.org.iservice.IOrgService;
import org.konghao.sys.org.model.Org;
import org.konghao.sys.org.model.SysException;
import org.springframework.stereotype.Service; @Service("orgService")
public class OrgService extends AbstractBaseSevice implements IOrgService { @Inject
private IOrgDao orgDao; @Inject
private IOrgTypeDao orgTypeDao; private void checkChildOrgNum(Org cOrg , Org pOrg){
if (pOrg == null) {
return;
}
//获取根据组织类型获取某组织类型下组织的数量（数量根据OrgTypeRule的num来确定数量，即某类型下组织数量需小于等于OrgTypeRule中num的数量）
int hnum = orgDao.loadNumByType(pOrg.getId(), cOrg.getTypeId());
//根据组织类型的父id和子id获取num数量
int rnum = orgTypeDao.loadOrgTypeRuleNum(pOrg.getTypeId(), cOrg.getTypeId());
if (rnum < 0) {
return;
}
if (hnum >= rnum) {
throw new SysException(pOrg.getName() +"下的" + cOrg.getName() + "的数量已经达到最大化");
}
} //parent已经存在的添加
@Override
public void add(Org org) {
checkChildOrgNum(org, org.getParent());
if (org.getParent() != null) {
org.setOrderNum(orgDao.getMaxOrder(org.getParent().getId()));
}else {
org.setOrderNum(null);
}
orgDao.add(org);
} @Override
public void add(Org org, Integer pid) {
if (pid != null) {
Org p = orgDao.load(pid);
if (p == null) {
throw new SysException("要添加的父组织不存在");
}
checkChildOrgNum(org, org.getParent());
org.setParent(p);
}
org.setOrderNum(orgDao.getMaxOrder(pid));
orgDao.add(org);
} }
spring 测试类test测试方法的更多相关文章
- 12、testng.xml指定运行测试包、测试类、测试方法
目录如下: TestFixture.java 代码如下: package com.testng.cn; import org.testng.annotations.*; public class Te ...
- 二 Spring的IOC入门，环境搭建，Spring测试类
IOC:inversion of Control 控制反转,Spring框架的核心.削减计算机程序的耦合问题,把对象(例如JDBC)的创建权交给Spring. IOC的两种类型: 依赖注入: 依赖查 ...
- 【原】Spring测试类代码
package test; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.bea ...
- python+pytest接口自动化(11)-测试函数、测试类/测试方法的封装
前言 在python+pytest 接口自动化系列中,我们之前的文章基本都没有将代码进行封装,但实际编写自动化测试脚本中,我们都需要将测试代码进行封装,才能被测试框架识别执行. 例如单个接口的请求代码 ...
- SpringBoot高版本修改为低版本时测试类报错解决
有时在使用idea通过Spring Initailizr创建项目时,默认只能创建最近的版本的SpringBoot项目. 这是如果想要换成版本,就可以在项目创建好了之后,在pom文件中直接将版本修改过来 ...
- XCode中的单元测试：编写测试类和方法（内容意译自苹果官方文档）
当你在工程中通过测试导航栏添加了一个测试target之后, xcode会在测试导航栏中显示该target所属的测试类和方法. 这一章演示了怎么创建测试类,以及如何编写测试方法. 测试targets, ...
- 一个简单的Spring测试的例子
在做测试的时候我们用到Junit Case,当我们的项目中使用了Sring的时候,我们应该怎么使用spring容器去管理我的测试用例呢?现在我们用一个简单的例子来展示这个过程. 1 首先我们新建一个普 ...
- 测试类异常Manual close is not allowed over a Spring managed SqlSession
在用Spring 和mybatis整合的 写测试类的时候报出解决办法:在全局配置文件 class="org.mybatis.spring.SqlSessionTemplate" ...
- Injection of autowired dependencies failed; autowire 自动注入失败，测试类已初始化过了Spring容器。
1 严重: StandardWrapper.Throwable org.springframework.beans.factory.BeanCreationException: Error creat ...
随机推荐
- Mybatis 传递多个参数
Mybatis提供了4种传递多个参数的方法: 1 Map sql语句 接口 调用方法 这个方法虽然简单易用,但是存在一个弊端:Map存储的元素是键值对,可读性不好. 2 注解 使用MyBatis的参数 ...
- 最长递增子序列（ LIS）
LIS LIS的优化说白了其实是贪心算法,比如说让你求一个最长上升子序列把,一起走一遍. 比如说(4, 2, 3, 1, 2,3,5)这个序列,求他的最长上升子序列,那么来看,如果求最长的上升序列,那 ...
- Aizu0189 Convenient Location（多源最短路）
https://vjudge.net/problem/Aizu-0189 题意:求某一点到其他所有点的最短路径之和,输出该点与和. 注意Floyd可以求多源最短路径,而Dijkstra只能求单源. # ...
- django之内置Admin
本篇导航: 配置路由 定制Admin Django内置的Admin是对于model中对应的数据表进行增删改查提供的组件,使用方式有: 依赖APP: django.contrib.auth django ...
- iOS：基于RTMP的视频推流
iOS基于RTMP的视频推流 一.基本介绍 iOS直播一出世,立马火热的不行,各种直播平台如雨后春笋,正因为如此,也同样带动了直播的技术快速发展,在IT界精通直播技术的猴子可是很值钱的.直播技术涉及的 ...
- 小程序longpress的bug及其解决
我的小程序中,用到一个长按修改的功能,设计是这样的,短按tap,长按longpress 但是,偶尔出现长按无效的情况.我自己都经常碰到,今天仔细研究,用半天时间反复寻找,重现,发现问题和内存或别的因素 ...
- org.springframework.web.method.HandlerMethod 与 org.springframework.messaging.handler.HandlerMethod 转换失败
Springmvc hander.getclassclass org.springframework.web.method.HandlerMethod HandlerMethod.classclass ...
- 最新的Delphi版本号对照
The CompilerVersion constant identifies the internal version number of the Delphi compiler. It is de ...
- 【C#】C#线程_基元线程的同步构造
目录结构: contents structure [+] 简介 为什么需要使用线程同步 线程同步的缺点 基元线程同步 什么是基元线程 基元用户模式构造和内核模式构造的比较 用户模式构造 易变构造(Vo ...
- C#7.2——编写安全高效的C#代码 c# 中模拟一个模式匹配及匹配值抽取 走进 LINQ 的世界 移除Excel工作表密码保护小工具含C#源代码 腾讯QQ会员中心g_tk32算法【C#版】
C#7.2——编写安全高效的C#代码 2018-11-07 18:59 by 沉睡的木木夕, 123 阅读, 0 评论, 收藏, 编辑 原文地址:https://docs.microsoft.com/ ...