maven+spring-boot+springfox+swagger2markup+spring restdoc+asciidoctor生成完美的rest文档

http://blog.csdn.net/daisy_xiu/article/details/52368920

写了一个工程，要写文档，相信所有的程序员都和我一样，最讨厌写文档，有没有片动生成文档的东西呢？有！

首先，我们要引入swagger。

1、swagger

什么是swagger？说白了，就是可以帮你生成一个可以测试接口的页面的工具。具体在这里：http://swagger.io/open-source-integrations/。多得我也不说了，文档很多，具体可以看这里：http://blog.sina.com.cn/s/blog_72ef7bea0102vpu7.html。说这个东西的的原因是，springfox是依赖这东西的。

2、springfox

为什么说springfox是依赖swagger的呢？因为swagger本身不支持spring mvc的，springfox把swagger包装了一下，让他可以支持springmvc。

我的项目是用spring-boot做的，基础知识就不在这里说了。只说怎么玩。

先是maven的引入：

 <dependency>
     <groupId>io.springfoxgroupId>
     <artifactId>springfox-swagger-uiartifactId>
     <version>2.5.0version>
 dependency>
 <dependency>
     <groupId>io.springfoxgroupId>
     <artifactId>springfox-swagger2artifactId>
     <version>2.5.0version>
 dependency>
 <dependency>
     <groupId>org.springframework.restdocsgroupId>
     <artifactId>spring-restdocs-mockmvcartifactId>
     <version>1.1.1.RELEASEversion>
 dependency>
 <dependency>
     <groupId>io.springfoxgroupId>
     <artifactId>springfox-staticdocsartifactId>
     <version>2.5.0version>
     <scope>testscope>
 dependency>

我先写一个config类，看不懂的自己补下spring-boot：

 package doc.base;

 import lombok.extern.log4j.Log4j2;
 import org.springframework.boot.bind.RelaxedPropertyResolver;
 import org.springframework.context.EnvironmentAware;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.env.Environment;
 import org.springframework.util.StopWatch;
 import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
 import springfox.documentation.builders.RequestHandlerSelectors;
 import springfox.documentation.service.ApiInfo;
 import springfox.documentation.service.Contact;
 import springfox.documentation.spi.DocumentationType;
 import springfox.documentation.spring.web.plugins.Docket;
 import springfox.documentation.swagger2.annotations.EnableSwagger2;

 import static springfox.documentation.builders.PathSelectors.*;
 import static com.google.common.base.Predicates.*;

 @Configuration
 @EnableSwagger2//注意这里
 @ComponentScan(basePackages = "doc")
 @Log4j2
 public class SwaggerConfig extends WebMvcConfigurerAdapter
         implements EnvironmentAware {

     /**
      * 静态资源映射
      *
      * @param registry
      *            静态资源注册器
      */
     public void addResourceHandlers(ResourceHandlerRegistry registry) {
         registry.addResourceHandler("swagger-ui.html")
                 .addResourceLocations("classpath:/META-INF/resources/");

         registry.addResourceHandler("/webjars/**")
                 .addResourceLocations("classpath:/META-INF/resources/webjars/");
         super.addResourceHandlers(registry);
     }

     @Override
     public void setEnvironment(Environment environment) {//这里是从配置文件里读相关的字段
         this.propertyResolver = new RelaxedPropertyResolver(environment,
                 "swagger.");
     }

     @Bean
     public Docket swaggerSpringfoxDocket4KAD() {//最重要的就是这里，定义了/test/.*开头的rest接口都分在了test分组里，可以通过/v2/api-docs?group=test得到定义的json
         log.debug("Starting Swagger");
         StopWatch watch = new StopWatch();
         watch.start();
         Docket swaggerSpringMvcPlugin = new Docket(DocumentationType.SWAGGER_2)
                 .groupName("test")
                 .apiInfo(apiInfo()).select().apis(RequestHandlerSelectors.any())
                 .paths(regex("/test/.*")) // and by paths
                 .build();
         watch.stop();
         log.debug("Started Swagger in {} ms", watch.getTotalTimeMillis());
         return swaggerSpringMvcPlugin;
     }

     private ApiInfo apiInfo() {//这里是生成文档基本信息的地方
         return new ApiInfo(propertyResolver.getProperty("title"),
                 propertyResolver.getProperty("description"),
                 propertyResolver.getProperty("version"),
                 propertyResolver.getProperty("termsOfServiceUrl"),
                 new Contact(propertyResolver.getProperty("contact.name"),
                         propertyResolver.getProperty("contact.url"),
                         propertyResolver.getProperty("contact.email")),
                 propertyResolver.getProperty("license"),
                 propertyResolver.getProperty("licenseUrl"));
     }

     private RelaxedPropertyResolver propertyResolver;
 }

由于spring-mvc代理了/*，所以要把swagger-ui.html和/webjars/**做为静态资源放出来，不然无法访问。

然后，我们就可以在类上面加上swagger的注解了，只有这样，swagger才能生成文档：

 @ApiOperation(
             value = "get",
             httpMethod = "GET",
             response = String.class,
             notes = "调用test get",
             produces = MediaType.APPLICATION_JSON_VALUE)//这是接口的基本信息，不解释，自己看吧
     @Snippet(
             url = "/test/get",
             snippetClass = MonitorControllerSnippet.Get.class)//这是我自己写的，方便spring-restdoc使用的，后面就说
     @ApiImplicitParams({//这个是入参，因为入参是request，所以要在这里定义，如果是其它的比如spring或javabean入参，可以在参数上使用@ApiParam注解
             @ApiImplicitParam(
                     name = "Service",
                     value = "服务",
                     required = true,
                     defaultValue = "monitor",
                     dataType = "String"),
             @ApiImplicitParam(
                     name = "Region",
                     value = "机房",
                     required = true,
                     dataType = "String"),
             @ApiImplicitParam(
                     name = "Version",
                     value = "版本",
                     required = true,
                     dataType = "String"),
             @ApiImplicitParam(
                     name = "name",
                     value = "名称",
                     example = "kaddefault",
                     required = true,
                     dataType = "String"),
             @ApiImplicitParam(
                     name = "producttype",
                     value = "产品类型",
                     example = "12",
                     required = true,
                     dataType = "int"),
             @ApiImplicitParam(
                     name = "tags",
                     dataType = "String",
                     example = "{\"port\":8080}")
     })
     @RequestMapping(
             path = "/test/get",
             method = RequestMethod.GET)
     public String get(HttpServletRequest request) {
         log.debug("进入get");
         return call4form(request);
     }

然后我们调用一下http://localhost:8080/swagger-ui.html就可以看到了。

好了，我们现在可以用swagger-ui调试spring-mvc了，这只是第一步。

下面，我们要使用springfox生成文档。这里要使用swagger2markup来进行转换。

3、spring restdoc

spring restdoc就是生成例子用的。先用它把每一个接口都调用一遍，会生成一堆acsiidoc文件。但是如果一个一个调，就把代码写死了，于是我写了一个自定的注解去完成这个工作：

 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Snippet {

     String httpMethod() default "GET";

     String url() default "/";

     String mediaType() default "application/x-www-form-urlencoded";

     // 用于生成片断的类，需要是test.doc.swagger.snippet.Snippet类的实现
     Class snippetClass();
 }

接口：

 /**
  *
  * 这是生成片断的方法所必须实现的接口
  *
  * Created by MiaoJia([email protected]) on 2016/8/26.
  */
 public interface ISnippet {
     /**
      * 插入httpMethod
      *
      * @param httpMethod
      *            GET or POST
      */
     void setHttpMethod(String httpMethod);

     /**
      * 获取Http Method
      *
      * @return Http Method
      */
     String getHttpMethod();

     /**
      * 插入mediaType
      *
      * @param mediaType
      *            application/x-www-form-urlencoded or application/json
      */
     void setMediaType(String mediaType);

     /**
      * 获取MediaType
      *
      * @return MediaType
      */
     MediaType getMediaType() ;

     /**
      * 插入URL
      *
      * @param url
      *            URL
      */
     void setURL(String url);

     /**
      * 获取URL
      *
      * @return url
      */
     String getURL();

     /**
      * 获取入参JSONs
      *
      * @return Json
      */
     String getContent();

     /**
      * 获取入参
      *
      * @return MultiValueMap
      */
     MultiValueMap getParams();

     /**
      * 得到头
      *
      * @return HttpHeaders
      */
     HttpHeaders getHeaders();

     /**
      * 得到头Cookie
      * @return Cookie
      */
     Cookie[] getCookie();

 }

抽象实现类：

 public abstract class ASnippet implements ISnippet {

     @Override
     public void setHttpMethod(String httpMethod) {
         this.httpMethod = httpMethod;
     }

     @Override
     public String getHttpMethod() {
         return httpMethod;
     }

     @Override
     public void setMediaType(String mediaType) {
         this.mediaType = MediaType.valueOf(mediaType);
     }

     @Override
     public MediaType getMediaType() {
         return mediaType;
     }

     @Override
     public void setURL(String url) {
         this.url = url;
     }

     @Override
     public String getURL() {
         return url;
     }

     @Override
     public HttpHeaders getHeaders() {
         return new HttpHeaders();
     }

     @Override
     public String getContent() {
         return null;
     }

     @Override
     public Cookie[] getCookie() {
         return new Cookie[0];
     }

     String httpMethod;
     MediaType mediaType;
     String url;

 }

对应的实现类：

 public class MonitorControllerSnippet {

     /**
      * 抽象类
      */
     abstract static class BaseMonitorControllerSnippet extends ASnippet {

         public MultiValueMap<String, String> getParams() {
             MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
             parameters.put("Version", Collections.singletonList("2016-07-26"));
             parameters.put("Region",
                     Collections.singletonList("cn-shanghai-3"));
             parameters.put("Service", Collections.singletonList("monitor"));

             return parameters;
         }

         @Override
         public Cookie[] getCookie() {
             Cookie cookie = new Cookie(PassportAPI.USER_TOKEN_KSCDIGEST,
                     "046011086e3e617b98b7a6aa4cae88fc-668349870");
             return new Cookie[] {
                     cookie
             };
         }
     }

     /**
      * get方法的
      */
     public static class Get extends BaseMonitorControllerSnippet {
         public MultiValueMap<String, String> getParams() {
             MultiValueMap<String, String> parameters = super.getParams();
             parameters.put("name", Collections.singletonList("kaddefault"));
             parameters.put("instance", Collections
                     .singletonList("0faae51b-e91f-4583-b83e-6b696d03d6b1"));
             parameters.put("producttype", Collections.singletonList("12"));

             return parameters;
         }

     }
 }

有的注解类，还要有一个读注解的类：

 @Component
 @Log4j2
 public class ScanSnippet {

     /**
      * 查询所有的拥有@ApiOperation注解和@Snippet注解的方法，找到@Snippet注解中定义的snippetClass，放入缓存备用
      *
      * @param basePackages 扫描路径
      * @return 扫描到的类
      */
     private void doScan(String basePackages) throws Exception {
         ScanUtils.scanner(basePackages, classMetadata -> {
             Class beanClass = this.getClass().getClassLoader()
                     .loadClass(classMetadata.getClassName());
             for (Method method : beanClass.getMethods()) {
                 ApiOperation apiOperation = method
                         .getAnnotation(ApiOperation.class);
                 Snippet snippet = method.getAnnotation(Snippet.class);
                 if (apiOperation != null && snippet != null) {
                     String apiName = apiOperation.value();
                     Class snippetClass = snippet.snippetClass();
                     if (ISnippet.class.isAssignableFrom(snippetClass)) {
                         try {
                             ISnippet _snippet = (ISnippet) snippetClass
                                     .newInstance();
                             _snippet.setHttpMethod(snippet.httpMethod());
                             _snippet.setMediaType(snippet.mediaType());
                             _snippet.setURL(snippet.url());

                             log.info("扫描到了：apiName={},_snippet={}", apiName,
                                     _snippet);
                             snippetMap.put(apiName, _snippet);
                         } catch (InstantiationException
                                 | IllegalAccessException e) {
                             e.printStackTrace();
                         }
                     }
                 }
             }
         });
     }

     /**
      * 启动时扫描
      */
     @PostConstruct
     public void scanSnippetMethod() {
         try {
             this.doScan("test");
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     /**
      * snippetMap
      */
     public final static Map snippetMap = new HashMap<>();

这里用了扫描:

 package test.util.classreading;

 import java.io.File;
 import java.io.FileFilter;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.JarURLConnection;
 import java.net.URL;
 import java.net.URLDecoder;
 import java.util.Enumeration;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;

 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.Opcodes;

 public class ScanUtils {

     /**
      * 从包package中获取所有的Class
      *
      * @return
      * @throws Exception
      */
     public static Set scanner(
             String resourcePath,
             ScannerHandle scannerHandle) throws Exception {

         // 第一个class类的集合
         Set classes = new LinkedHashSet();
         // 是否循环迭代
         boolean recursive = true;
         // 获取包的名字 并进行替换
         String packageName = resourcePath;
         String packageDirName = packageName.replace('.', '/');
         // 定义一个枚举的集合 并进行循环来处理这个目录下的things
         Enumeration dirs;
         try {
             dirs = Thread.currentThread().getContextClassLoader()
                     .getResources(packageDirName);
             // 循环迭代下去
             while (dirs.hasMoreElements()) {
                 // 获取下一个元素
                 URL url = dirs.nextElement();
                 // 得到协议的名称
                 String protocol = url.getProtocol();
                 // 如果是以文件的形式保存在服务器上
                 if ("file".equals(protocol)) {
                     // System.err.println("file类型的扫描");
                     // 获取包的物理路径
                     String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                     // 以文件的方式扫描整个包下的文件 并添加到集合中
                     findAndAddClassesInPackageByFile(packageName, filePath,
                             recursive, classes, scannerHandle);
                 } else if ("jar".equals(protocol)) {
                     // 如果是jar包文件
                     // 定义一个JarFile
                     // System.err.println("jar类型的扫描");
                     JarFile jar;
                     try {
                         // 获取jar
                         jar = ((JarURLConnection) url.openConnection())
                                 .getJarFile();
                         // 从此jar包 得到一个枚举类
                         Enumeration entries = jar.entries();
                         // 同样的进行循环迭代
                         while (entries.hasMoreElements()) {
                             // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
                             JarEntry entry = entries.nextElement();
                             String name = entry.getName();
                             // 如果是以/开头的
                             if (name.charAt(0) == '/') {
                                 // 获取后面的字符串
                                 name = name.substring(1);
                             }
                             // 如果前半部分和定义的包名相同
                             if (name.startsWith(packageDirName)) {
                                 int idx = name.lastIndexOf('/');
                                 // 如果以"/"结尾 是一个包
                                 if (idx != -1) {
                                     // 获取包名 把"/"替换成"."
                                     packageName = name.substring(0, idx)
                                             .replace('/', '.');
                                 }
                                 // 如果可以迭代下去 并且是一个包
                                 if ((idx != -1) || recursive) {
                                     // 如果是一个.class文件 而且不是目录
                                     if (name.endsWith(".class")
                                             && !entry.isDirectory()) {
                                         // 去掉后面的".class" 获取真正的类名
                                         // String className = name.substring(
                                         // packageName.length() + 1,
                                         // name.length() - 6);
                                         ClassMetadata classMetadata = getClassMetadata(
                                                 jar.getInputStream(entry));
                                         if (scannerHandle != null) {
                                             scannerHandle.handle(classMetadata);
                                         }
                                         // 添加到classes
                                         classes.add(classMetadata);
                                     }
                                 }
                             }
                         }
                     } catch (IOException e) {
                         // log.error("在扫描用户定义视图时从jar包获取文件出错");
                         e.printStackTrace();
                     }
                 }
             }
         } catch (IOException e) {
             e.printStackTrace();
         }

         return classes;
     }

     /**
      * 以文件的形式来获取包下的所有Class
      *
      * @param packageName
      * @param packagePath
      * @param recursive
      * @param classes
      * @throws Exception
      */
     private static void findAndAddClassesInPackageByFile(
             String packageName,
             String packagePath,
             final boolean recursive,
             Set classes,
             ScannerHandle scannerHandle)
             throws Exception {
         // 获取此包的目录 建立一个File
         File dir = new File(packagePath);
         // 如果不存在或者 也不是目录就直接返回
         if (!dir.exists() || !dir.isDirectory()) {
             // log.warn("用户定义包名 " + packageName + " 下没有任何文件");
             return;
         }
         // 如果存在 就获取包下的所有文件 包括目录
         File[] dirfiles = dir.listFiles(new FileFilter() {
             // 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
             public boolean accept(File file) {
                 return (recursive && file.isDirectory())
                         || (file.getName().endsWith(".class"));
             }
         });
         // 循环所有文件
         for (File file : dirfiles) {
             // 如果是目录 则继续扫描
             if (file.isDirectory()) {
                 findAndAddClassesInPackageByFile(
                         packageName + "." + file.getName(),
                         file.getAbsolutePath(), recursive, classes,
                         scannerHandle);
             } else {
                 // 如果是java类文件 去掉后面的.class 只留下类名
                 // String className = file.getName().substring(0,
                 // file.getName().length() - 6);
                 ClassMetadata classMetadata = getClassMetadata(
                         new FileInputStream(file));
                 if (scannerHandle != null) {
                     scannerHandle.handle(classMetadata);
                 }
                 // 添加到classes
                 classes.add(classMetadata);
             }
         }
     }

     /**
      * 返回类的元数据信息
      *
      * @param className
      * @return
      * @throws Exception
      */
     @SuppressWarnings("unused")
     @Deprecated
     private static ClassMetadata getClassMetadata(String className)
             throws Exception {
         ClassReader cr = new ClassReader(className);// ClassReader只是按顺序遍历一遍class文件内容，基本不做信息的缓存
         ClassMetadataVisitor cn = new ClassMetadataVisitor(Opcodes.ASM4);
         cr.accept(cn, ClassReader.SKIP_DEBUG);
         return cn;
     }

     /**
      * 返回类的元数据信息
      *
      * @return
      * @throws Exception
      */
     private static ClassMetadata getClassMetadata(InputStream inputStream)
             throws Exception {
         try {
             ClassReader cr = new ClassReader(inputStream);// ClassReader只是按顺序遍历一遍class文件内容，基本不做信息的缓存
             ClassMetadataVisitor cn = new ClassMetadataVisitor(Opcodes.ASM4);
             cr.accept(cn, ClassReader.SKIP_DEBUG);
             return cn;
         } finally {
             if (inputStream != null) {
                 inputStream.close();
             }
         }
     }

 }


 package test.util.classreading;

 public interface ScannerHandle {

     void handle(ClassMetadata classMetadata) throws Exception;
 }


 package test.util.classreading;


 public interface ClassMetadata {


     /**
      * Return the name of the underlying class.
      */
     String getClassName();

     /**
      * Return whether the underlying class represents an interface.
      */
     boolean isInterface();

     /**
      * Return whether the underlying class is marked as abstract.
      */
     boolean isAbstract();

     /**
      * Return whether the underlying class represents a concrete class,
      * i.e. neither an interface nor an abstract class.
      */
     boolean isConcrete();

     /**
      * Return whether the underlying class is marked as 'final'.
      */
     boolean isFinal();

     /**
      * Determine whether the underlying class is independent,
      * i.e. whether it is a top-level class or a nested class
      * (static inner class) that can be constructed independent
      * from an enclosing class.
      */
     boolean isIndependent();

     /**
      * Return whether the underlying class has an enclosing class
      * (i.e. the underlying class is an inner/nested class or
      * a local class within a method).
      * If this method returns {@code false}, then the
      * underlying class is a top-level class.
      */
     boolean hasEnclosingClass();

     /**
      * Return the name of the enclosing class of the underlying class,
      * or {@code null} if the underlying class is a top-level class.
      */
     String getEnclosingClassName();

     /**
      * Return whether the underlying class has a super class.
      */
     boolean hasSuperClass();

     /**
      * Return the name of the super class of the underlying class,
      * or {@code null} if there is no super class defined.
      */
     String getSuperClassName();

     /**
      * Return the names of all interfaces that the underlying class
      * implements, or an empty array if there are none.
      */
     String[] getInterfaceNames();

     /**
      * Return the names of all classes declared as members of the class represented by
      * this ClassMetadata object. This includes public, protected, default (package)
      * access, and private classes and interfaces declared by the class, but excludes
      * inherited classes and interfaces. An empty array is returned if no member classes
      * or interfaces exist.
      */
     String[] getMemberClassNames();



 }


 package test.util.classreading;

 import java.util.LinkedHashSet;
 import java.util.Set;

 import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.Opcodes;

 public class ClassMetadataVisitor extends ClassVisitor implements Opcodes,
         ClassMetadata {

     private String className;

     private boolean isInterface;

     private boolean isAbstract;

     private boolean isFinal;

     private String enclosingClassName;

     private boolean independentInnerClass;

     private String superClassName;

     private String[] interfaces;

     private Set memberClassNames = new LinkedHashSet();

     public ClassMetadataVisitor(int api) {
         super(api);
     }

     public void visit(int version, int access, String name, String signature,
             String superName, String[] interfaces) {
         this.className = this.convertResourcePathToClassName(name);
         this.isInterface = ((access & Opcodes.ACC_INTERFACE) != 0);
         this.isAbstract = ((access & Opcodes.ACC_ABSTRACT) != 0);
         this.isFinal = ((access & Opcodes.ACC_FINAL) != 0);
         if (superName != null) {
             this.superClassName = this
                     .convertResourcePathToClassName(superName);
         }
         this.interfaces = new String[interfaces.length];
         for (int i = 0; i < interfaces.length; i++) {
             this.interfaces[i] = this
                     .convertResourcePathToClassName(interfaces[i]);
         }
     }

     public void visitOuterClass(String owner, String name, String desc) {
         this.enclosingClassName = this.convertResourcePathToClassName(owner);
     }

     public void visitInnerClass(String name, String outerName,
             String innerName, int access) {
         if (outerName != null) {
             String fqName = this.convertResourcePathToClassName(name);
             String fqOuterName = this.convertResourcePathToClassName(outerName);
             if (this.className.equals(fqName)) {
                 this.enclosingClassName = fqOuterName;
                 this.independentInnerClass = ((access & Opcodes.ACC_STATIC) != 0);
             } else if (this.className.equals(fqOuterName)) {
                 this.memberClassNames.add(fqName);
             }
         }
     }

     public String convertResourcePathToClassName(String resourcePath) {
         return resourcePath.replace('/', '.');
     }

     @Override
     public String getClassName() {
         return this.className;
     }

     @Override
     public boolean isInterface() {
         return this.isInterface;
     }

     @Override
     public boolean isAbstract() {
         return this.isAbstract;
     }

     @Override
     public boolean isConcrete() {
         return !(this.isInterface || this.isAbstract);
     }

     @Override
     public boolean isFinal() {
         return this.isFinal;
     }

     @Override
     public boolean isIndependent() {
         return (this.enclosingClassName == null || this.independentInnerClass);
     }

     @Override
     public boolean hasEnclosingClass() {
         return (this.enclosingClassName != null);
     }

     @Override
     public String getEnclosingClassName() {
         return this.enclosingClassName;
     }

     @Override
     public boolean hasSuperClass() {
         return (this.superClassName != null);
     }

     @Override
     public String getSuperClassName() {
         return this.superClassName;
     }

     @Override
     public String[] getInterfaceNames() {
         return this.interfaces;
     }

     @Override
     public String[] getMemberClassNames() {
         return this.memberClassNames.toArray(new String[this.memberClassNames
                 .size()]);
     }

 }

具体的原理就是扫描文件和jar包里的class文件，用asm把class文件里的相关内容读取出来然后再交给handler进行操作。有人会问，干嘛用asm？，直接Class.forName()就完了？这里的原因有两点：1、是你加载的class可能会依赖别的包，但可能那个包并不在你的lib中，2、jvm是按需加载class的，你全都加载了，你的方法区（持久带）有多大？够放得下吗？就算是jdk8改成了直接内存，也得悠着点用。

说多了，这里扫描到了所有@ApiOperation注解和@Snippet注解的方法，然后把@Snippet注解里内容读出来，放map里备用。

然后，我们要用junit了：

 package doc;

 import test.controller.WebConfiguration;
 import doc.base.AbstractSwagger2Markup;
 import doc.base.SwaggerConfig;
 import io.github.robwin.markup.builder.MarkupLanguage;
 import io.github.robwin.swagger2markup.GroupBy;
 import io.github.robwin.swagger2markup.Swagger2MarkupConverter;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.http.MediaType;
 import org.springframework.restdocs.JUnitRestDocumentation;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import org.springframework.test.context.web.WebAppConfiguration;
 import org.springframework.test.web.servlet.MockMvc;
 import org.springframework.test.web.servlet.MvcResult;
 import org.springframework.test.web.servlet.setup.MockMvcBuilders;
 import org.springframework.web.context.WebApplicationContext;
 import springfox.documentation.staticdocs.SwaggerResultHandler;

 import static org.springframework.restdocs.mockmvc.MockMvcRestDocumentation.documentationConfiguration;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;


 @WebAppConfiguration
 @RunWith(SpringJUnit4ClassRunner.class)
 @SpringBootTest(classes = {
         WebConfiguration.class, SwaggerConfig.class
 })
 public class Swagger2Markup extends AbstractSwagger2Markup {

     @Autowired
     private WebApplicationContext context;

     private MockMvc mockMvc;


     @Rule
     public final JUnitRestDocumentation restDocumentation = new JUnitRestDocumentation(
             snippetsOutputDir);

     @Before
     public void setUp() {
         this.mockMvc = MockMvcBuilders.webAppContextSetup(this.context)
                 .apply(documentationConfiguration(this.restDocumentation))
                 .build();
     }

     /**
      * 生成所有接口的片断
      *
      * @throws Exception
      */
     @Test
     public void createSnippets() throws Exception {
         super.createSnippets(this.mockMvc);
     }
 }

McckMvc就是spring-restdoc的类，用来访问接口后成asciidoc用的，setUp方法定义了输出路径，最下面那个方法用得是super里的方法：

 package doc.base;

 import lombok.extern.log4j.Log4j2;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MockMvc;
 import org.springframework.test.web.servlet.ResultActions;
 import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;

 import static org.springframework.restdocs.mockmvc.MockMvcRestDocumentation.document;
 import static org.springframework.restdocs.operation.preprocess.Preprocessors.preprocessResponse;
 import static org.springframework.restdocs.operation.preprocess.Preprocessors.prettyPrint;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;

 /**
  *
  * 所有Swagger2Markup类的父类
  *
  */
 @Log4j2
 public abstract class AbstractSwagger2Markup {

     /**
      * 生成所的类的片段
      *
      * @param mockMvc
      *            MockMvc
      * @throws Exception
      */
     public void createSnippets(MockMvc mockMvc) throws Exception {
         ScanSnippet.snippetMap.forEach((K, V) -> {
             log.info("k={},v{}", K, V);
             String httpMethod = V.getHttpMethod();
             if (httpMethod != null) {
                 MockHttpServletRequestBuilder requestBuilder = null;
                 if (httpMethod.equalsIgnoreCase("get")) {
                     requestBuilder = get(
                             V.getURL());
                 } else if (httpMethod.equalsIgnoreCase("post")) {
                     requestBuilder = post(
                             V.getURL());
                 }
                 assert requestBuilder != null;
                 try {
                     log.info("开始生成" + K + "的片段");
                     if (V.getMediaType().equals(MediaType.APPLICATION_JSON)) {
                         ResultActions resultActions = mockMvc
                                 .perform(requestBuilder
                                         .content(V.getContent())
                                         .params(V.getParams())
                                         .headers(V.getHeaders())
                                         .cookie(V.getCookie())
                                         .contentType(
                                                 MediaType.APPLICATION_JSON))
                                 .andDo(document(K,
                                         preprocessResponse(prettyPrint())));
                         // resultActions.andExpect(status().isOk());
                     } else if (V.getMediaType()
                             .equals(MediaType.APPLICATION_FORM_URLENCODED)) {
                         ResultActions resultActions = mockMvc
                                 .perform(requestBuilder
                                         .params(V.getParams())
                                         .headers(V.getHeaders())
                                         .cookie(V.getCookie())
                                         .contentType(
                                                 MediaType.APPLICATION_FORM_URLENCODED))
                                 .andDo(document(K,
                                         preprocessResponse(prettyPrint())));
                         // resultActions.andExpect(status().isOk());
                     }
                     log.info("生成" + K + "的片段成功");
                 } catch (Exception e) {
                     log.error("生成" + K + "的片段失败：{}", e);
                 }

             }
         });
     }

     public String snippetsOutputDir = System
             .getProperty("io.springfox.staticdocs.snippetsOutputDir");// 片断目录
     public String outputDir = System
             .getProperty("io.springfox.staticdocs.outputDir");// swagger.json目录
     public String generatedOutputDir = System
             .getProperty("io.springfox.staticdocs.generatedOutputDir");// asciiDoc目录
 }

这个方法就是从刚才生成的map里得到所有的描述，一个一个的去访问，然后生成片段。

运行这个test会生成这些文件：

4、swagger2markup（http://swagger2markup.github.io/swagger2markup/1.0.1/）

swagger2markup是一个专门用来转换swagger接口到markdown或acsiidoc的工具，可以把/v2/api-docs里得到的json转成markdown或acsiidoc格式。

 @Test
 public void createSpringfoxSwaggerJson() throws Exception {

     // 得到swagger.json
     MvcResult mvcResult = this.mockMvc
             .perform(get("/v2/api-docs?group=test")
                     .accept(MediaType.APPLICATION_JSON))
             .andDo(SwaggerResultHandler.outputDirectory(outputDir).build())
             .andExpect(status().isOk())
             .andReturn();

     // 转成asciiDoc，并加入Example
     Swagger2MarkupConverter.from(outputDir + "/swagger.json")
             .withPathsGroupedBy(GroupBy.TAGS)// 按tag排序
             .withMarkupLanguage(MarkupLanguage.ASCIIDOC)// 格式
             "color:#ff0000;">.withExamples(snippetsOutputDir)// 插入片断
             .build()
             .intoFolder(generatedOutputDir);// 输出
 }

这里访问了/v2/api-docs?group=test生成了test组的文档，同时,代码里红色的那句就是把刚才生成的片段插入到里面去。注意，目录要名字要和@ApiOperation中的value一样。

现在所有的东西都准备好了，但是我们一般不会看acsiidoc文件的。但可以生成HTML5，通过asciidoctor。

5、asciidoctor

asciidoctor有maven插件，可以自动把acsiidoc文件转成html和pdf，能自动生成目录，非常方便

先在创建这个文件：

文件内容是：

 include::{generated}/overview.adoc[]
 include::{generated}/definitions.adoc[]
 include::{generated}/paths.adoc[]

意思就是引入三个文件。

然后是maven插件：

 <properties>
      <snippetsDirectory>${project.build.directory}/generated-snippetssnippetsDirectory>

      <asciidoctor.input.directory>${project.basedir}/src/docs/asciidocasciidoctor.input.directory>

      <swagger.output.dir>${project.build.directory}/swaggerswagger.output.dir>
      <swagger.snippetOutput.dir>${project.build.directory}/asciidoc/snippetsswagger.snippetOutput.dir>
      <generated.asciidoc.directory>${project.build.directory}/asciidoc/generatedgenerated.asciidoc.directory>
      <asciidoctor.html.output.directory>${project.build.directory}/asciidoc/htmlasciidoctor.html.output.directory>
      <asciidoctor.pdf.output.directory>${project.build.directory}/asciidoc/pdfasciidoctor.pdf.output.directory>

      <swagger.input>${swagger.output.dir}/swagger.jsonswagger.input>
  properties>

  <plugin>
              <groupId>org.asciidoctorgroupId>
              <artifactId>asciidoctor-maven-pluginartifactId>
              <version>1.5.3version>

              <dependencies>
                  <dependency>
                      <groupId>org.asciidoctorgroupId>
                      <artifactId>asciidoctorj-pdfartifactId>
                      <version>1.5.0-alpha.10.1version>
                  dependency>
              dependencies>

              <configuration>
                  <sourceDirectory>${asciidoctor.input.directory}sourceDirectory>
                  <sourceDocumentName>index.adocsourceDocumentName>
                  <attributes>
                      <doctype>bookdoctype>
                      <toc>lefttoc>
                      <toclevels>3toclevels>
                      <numbered>numbered>
                      <hardbreaks>hardbreaks>
                      <sectlinks>sectlinks>
                      <sectanchors>sectanchors>
                      <generated>${generated.asciidoc.directory}generated>
                  attributes>
              configuration>

你可能感兴趣的:(maven+spring-boot+springfox+swagger2markup+spring restdoc+asciidoctor生成完美的rest文档)

• 大学播音主持都学什么内容？播音主持专业学什么？ 配音新手圈
  有些喜欢播音主持并且犹豫要不要报考这个大学专业的小伙伴们就会想要了解大学播音主持都学什么内容吧，毕竟如果不够了解就直接选择这个专业真的等选择完进去学习以后才知道这个专业并不是自己想要学习的东西那就来不及了。下面是小编为大家整理出来的一些播音主持专业学习的内容，请往下看吧。大学播音主持专业主要学习的课程有：播音发声、播音创作基础、广播播音主持、电视播音主持、文艺作品演播学概论、新闻学概论、新闻采编、
• Flink中的SQL Client和SQL Gateway BigDataMLApplication flinkflinksqlgateway
  Flink中的SQLClient和SQLGateway对比目录定义基本原理适用场景主要区别常用运维命令示例官方链接正文1.定义SQLClient：FlinkSQLClient是一种用于提交和执行FlinkSQL语句的命令行界面或图形界面工具。SQLGateway：FlinkSQLGateway是一个独立的服务，它允许客户端通过RESTfulAPI将SQL查询提交到Flink集群。2.基本原理SQL
• 2022年河南省高等职业教育技能大赛云计算赛项竞赛赛卷（样卷） 忘川_ydy 云计算云计算openstackkubernetesdockerpythonk8sansible
  #需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！第一部分：私有云任务1私有云服务搭建(10分)使用提供的用户名密码，登录竞赛用的云计算平台，按要求自行使用镜像创建两台云主机，创建完云主机后确保网络正常通信，然后按要求配置服务器。根据提供安装脚本框架，补充脚本完成OpenStack平台的安装搭
• SpringMVC设置全局异常处理器 水岸齐天 javaspring
  文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
• 为自己点滴的进步喝彩 e5633888b9f4
  当听到单位需要每周一三五加班到九点的时候，内心很坦然，没有指责抱怨，想到的是：又体验一下值夜班的感觉，还能趁此机会多与大家待在一起，孩子也可以得到独立方面的锻炼，一切都不是问题，搞不好再发点加班费就更好了，把这些都看成多得的，心情美美的，自己的事全力以赴做好，别人的事选择尊重，老天的事选择臣服。只要心有了目标，方向正确，就不怕路途的遥远。我们每一个人都不是孤立存在的，祖先一代代传承将生命体传承给了
• 第一章 山洞传来牛铃声 满眼荷花
  春夏时节，田野一片青碧，山林薄雾蔼蔼，水草萋萋的小河边静静立着一只白鹭，像一位白头钓翁，在耐心地等鱼。王三乐牵着一头老黄牛，正在河边田埂上放牛。看见白鹭，他百无聊赖地捡起一块小石头扔了过去。白鹭动作舒缓、姿势优美地飞起避过，在空中飞行一段后，宛若晴空一片云，翩然而下，又静静立于河边青草间，继续呈现完美的画面。王三乐也觉得自己很无聊，这也难怪，从他记事起就开始放牛，一直到现在都大学毕业了，还没丢下放
• Django之Debug篇 菜鸟之编程 Djangodjangopython后端
  一、DebugToolBar基本使用1.1、概述Django框架的调试工具栏使用django-debug-toolbar库，是一组可配置的面板，显示有关当前请求/响应的各种调试信息，点击时，显示有关面板内容的更多详细信息。官方文档：DjangoDebugToolbar—DjangoDebugToolbar4.3.0documentation1.2、安装pipinstalldjango-debug-
• 心赏（2018.10.8） 六一节_3928
  1.上班第一天，同事彤休完产假，回来上班，给我带了酸奶和水果。她生小孩时，我给她发了一个小红包贺喜，哪知她就记在心里了。心赏这个有心的90后。2.女儿放学回来，说自己当了小组长。一边说不想当，一边得意的样子。心赏老师给了孩子这个锻炼的机会。3.老妈今天做了"蚂蚁上树"的菜，得到女儿的高度肯定。心赏老妈还在不断学习。
• keras.optimizers优化器中文文档 地上悬河 python开发语言后端
  优化器optimizers优化器是编译Keras模型必要的两个参数之一model=Sequential()model.add(Dense(64,init='uniform',input_dim=10))model.add(Activation('tanh'))model.add(Activation('softmax'))sgd=SGD(lr=0.01,decay=1e-6,momentum=0.
• 【美丽特色乡村】，景德镇马鞍岭村， 粒子飞翔
  【美丽特色乡村】，景德镇马鞍岭村，就像是陶渊明笔下的山水田园，阡陌交通，精美的白房参差错落，碧绿透亮的河水从不远处的深涧里连绵不绝流入此地，滋养着土里。成群的白鸭悠闲地在河水里戏水，人与环境达成和谐的境界。借助三宝国际瓷谷建设的契机，马鞍岭村迎来了天翻地覆的沧桑巨变,此地以陶瓷文化为特色，融合原来生态资源，修复了水碓遗址、矿坑遗址等历史文化遗产，提升生态环境现状。同时，依托三宝溪围绕整个村落，对河
• 2022-2-13晨间日记 越亮也打烊
  今天是什么日子起床：7:00就寝：12:08天气：晴心情：糟糕纪念日：无任务清单昨日完成的任务，最重要的三件事：寒假作业，网课，画画改进：作业时间剪短习惯养成：网课不逃～周目标·完成进度数学卷子100％学习·信息·阅读《傅雷家书》《钢铁是怎样炼成的》健康·饮食·锻炼我终于不喝饮料啦，喝茶～人际·家人·朋友邝姐姐带我吃火锅工作·思考啥时候开学，我还有几天赶完作业最美好的三件事1.卷子写完了2.我有冰
• 中国最美的100个地方，待“软禁”结束后，满血复活去一次旅行！ 是北河二1995
  【阅读原文，请点击：原文，硬核100个】离成为一个倾国倾城、走路带风的女子还有365天！大家好，我是小草们的北河二~一转眼，2020年已过1/4，突如其来的病毒，搅得人心惶惶。原本的3月里，景区爆满、街道拥堵、小吃铺做无缺席。然而，地球妈妈不会一直宠着我们，给了我们好几个警告。如今，连CCTV-1播出的《人与自然》，我都可以看上好一会儿......高山、流水、湖泊、森林、大海.....它们也在这初
• 4.24 使用计算命令制作图像合成艺术效果 [Ps教程] 互动教程网
  1.本节课程将为您演示，如何使用[计算]命令，将两张示例图片，制作成超酷的图像合成特效。首先点击顶部的文档标签，切换至另一张示例图片。image2.接着依次点击[图像>计算]命令，弹出[计算]窗口。image3.[计算]命令，用于混合两个来自一个或多个源图像的单个通道。然后可以将结果应用到新图像、新通道或当前图像的选区中。image4.在弹出的计算窗口中，点击下拉箭头，选择[计算]命令的源图片。i
• docker基础（一） 运维搬运工 容器-dockerdocker容器运维
  相关概念介绍Docker是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖到一个可移植的容器中，然后发布到任何流行的linux机器上，也可以实现虚拟化，容器是完全使用沙箱机制，互相之间不会有任何接口。Docker有几个重要概念：dockerfile，配置文件，用来生成dockerimagedockerimage，交付部署的最小单元docker命令与API，定义命令与接口，支持第三方系统集
• Golang标准库fmt深入解析与应用技巧 walkskyer golang标准库golangjava数据库
  Golang标准库fmt深入解析与应用技巧前言fmt包的基本使用打印与格式化输出函数Print系列函数格式化字符串格式化输入函数小结字符串格式化基本类型的格式化输出自定义类型的格式化输出控制格式化输出的宽度和精度小结错误处理与fmt使用fmt.Errorf生成错误信息fmt包与错误处理的最佳实践小结日志记录与fmtfmt包在日志记录中的应用结合log包使用fmt进行高级日志处理小结fmt与IOfm
• 自己选择的路，爬也要爬完 一只疯狂的没有目标的青豆子
  你有没有怀疑过人生？有没有怀疑过自己的选择？有没有在一开始很坚定，然后走着走着就开始怀疑自己为什么要走这么苦逼的路，也开始后悔自己当初的选择？相信谁都有过这样的经历，但是最终的结果呢？是依旧坚持走到了最后，还是说你真的放弃了？朋友狠狠的告诉我：“我自己选的路，爬也要爬完，我就是要对自己狠”。我说：“为什么？为什么非要坚持下去？”他说：“我知道选择的对与错，既然已经开始了，我就选择风雨兼程、坚持到底
• SQLite版本3中的文件锁定和并发(七） 代码工匠云 数据库SQLiteC与c++sqlitec++数据库
  返回：SQLite—系列文章目录上一篇：自己编译SQLite或将SQLite移植到新的操作系统（六）下一篇：SQLite—系列文章目录正文：1.0SQLite版本3中的文件锁定和并发SQLite版本3.0.0引入了新的锁定和日志功能旨在提高SQLite版本2的并发性的机制并减少作家的饥饿问题。新机制还允许交易的原子提交涉及多个数据库文件。本文档介绍新的锁定机制。目标受众是想要理解和/或修改的程序员
• Acrobat Pro DC ----专业PDF编辑与管理 *橙子 officepdfmacos
  AcrobatProDC2023是一款功能强大的PDF处理软件，它提供了丰富的编辑工具，支持创建、编辑、合并、分割PDF文件，以及高质量的PDF到其他格式的转换功能。同时，该软件集成了最新的OCR技术，可将扫描文档或图片转换成可编辑的PDF。AcrobatProDC2023还具备电子签名功能，支持多人协作和云端同步共享，大大提高了工作效率和团队协作效率。无论是设计、建筑、金融还是法律等行业，Acr
• 《和另一个自己谈谈心》成长篇24 磷破读心理
  标题:生命的存在只能“体验”到。人们常说:“艺术源于生活。”艺术代表着创造，它将生活的场景与情感进行了完美的融合。而它深层的含义是为了传递自己内心的体验。所以说，生命存在的意义在于体验。话虽如此，但体验也有好坏之分。而人的天性是只喜欢好的不喜欢坏的。于是，在面对不好的体验时，人们更愿意站在一个至高无上的位子去抱怨和评判。这样他们就可以远离身体的不舒服（包括:恐惧、无助、伤痛甚至是背叛的强烈刺激），
• C++ pdf 打印 插入图片 灿烂李 java前端服务器
  一：使用PODOFO给PDF插入图片：#includeintmain(){PoDoFo::PdfMemDocumentpdfDocument;PoDoFo::PdfPage*page;PoDoFo::PdfImageimage;PoDoFo::PdfVecObjects*vec_objects;PoDoFo::PdfRectrect;//打开PDF文档pdfDocument.loadFromFil
• 《人脉是设计出来的》P81-P99 叶子君sasha
  忙完一轮供应小学生早餐过后，我就忙着去办健康证了。9点左右，我从医院回到店里了。早上一般没有客人，前段时间（迷茫许久的时期），因为自己心情浮躁，一直都没有好好看书，今天终于好好地看了一会书，这本书的书名叫《人脉是设计出来的》，作者名字叫张超。这本书在我还没开店的时候就买了，但是没有怎么认真去思考书中的内容，看了很容易忘，便以这样的方式，写读后感。读书有个输入输出的过程，才能成为自己的东西。对吧？回
• 忙忙碌碌才是生活 北渔说
  观海年后上班，因为项目接近尾声甚是消闲。说是消闲，其实身消闲，心不消闲。都说当下社会是焦虑的社会，因为人们普遍焦虑。上班已有半月，想想这好像是上班几年来最空闲的一段时间了。空闲的主要原因是工作处在了瓶颈期，心有余而力不足。因为有一颗力求完美的心，但却没有力求完美的能力，所以徒有焦虑。不知道大家有没有这种感觉，在高压学习或工作一段时间之后，突然闲下来就会茫然无措。有时候读一本长篇，好不容易结束本来应
• Numpy、Pandas库的使用 貮叁 量化投资分析pythonpython数据分析
  目录Numpy1、概述2、基础操作2.1生成一个numpy的array数组：2.2自定义一个新的数据类型：np.dtype()3、并行化思想4、量化分析应用4.1索引选取和切片选择4.2数据转换与规整4.3逻辑条件进行数据筛选4.4通用序列函数4.5文件保存与读取Pandas1、简介2、Series和DataFrame的使用2.1Series2.2DataFrame3、量化分析应用3.1形成一个p
• 人生最美两年 汉子娃娃
  宝贝儿，妈妈觉得人生中最完美的时间就是从你出生，有你和外婆相伴的两年，那种美好是同时处于两种身份的交融，一边厢我是一位母亲，一边厢我亦是一个女儿，跟外婆的相处模式也由曾经的母女，升级为朋友、闺蜜，那种感觉真的很好！对了，你是不是有个疑问，觉得妈妈的字里行间都没怎么出现过你爸爸这个称呼？不要意外，因为妈妈跟你爸爸当初在一起就不是一个幸福的开始，生活在一起时就总是争吵不断，两个都是火爆脾气，在一起自然
• C语言演示多线程编程条件下自旋锁和屏障的使用 嫦娥妹妹等等我 开发语言c语言开源
  主线故事:有4个人玩游戏输了,惩罚:1分别使用4台不同的ATM机给我存钱2必须一块一块的存3存完还得在ATM上看一下我的余额设计模式:1每个人使用一条单独的线程,再准备一个计时线程用来输出时间2存钱涉及到对共享资源的读写,是原子操作需要用锁保护这里使用自旋锁3都存完钱后需要等待在各自的ATM上回显余额这里使用屏障技术4如果在主线程中回显对应他们给我打电话告诉我存完了我自己看一下则不需要使用屏障因为
• 陈情令趣事40：蓝湛吃月饼，前后口味变化大，景仪不解思追秒懂 苏小妹娱乐
  （苏小妹/文）在《陈情令》里，姑苏蓝氏是极其注重礼仪的家族。什么重大节日，都有一定的礼仪。如今恰逢中秋，自然也是不例外的。一系列的礼仪操作下来，忙完的蓝景仪等小辈们赶紧跟着含光君去厨房报道了。因为某人说要吃亲手做的月饼，所以大家伙赶紧来忙活咯。蓝忘机走的是雅正的路线，他做的月饼都是比较传统的。而蓝景仪等人虽然很努力地想要学，但总归是时间有限，最后干脆打下手好了。因为相比上次端午节有大把的时间包粽子
• Python Flask 使用数据库 安果移不动 pythonflask开发语言
  pipinstallflask_sqlalchemy官方文档：Flask-SQLAlchemy—Flask-SQLAlchemyDocumentation(3.1.x)为了不报错也需要导入另外两个库#pipinstallflask_sqlalchemy#pipinstallmysqlclient完整代码importosfromflaskimportFlaskfromflask_sqlalchemy
• 电商打单ERP必备API列表-API调用指南 懂电商API接口的Jennifer 淘宝API接口springjava后端爬虫数据挖掘网络爬虫
  1、打开淘宝开放平台API文档，查看API参数。2、选择需要的API，进行测试对接。注册账号获取APIkey3、进入API测试页，开始测试taobao.customcustom-自定义API操作公共参数名称类型必须描述keyString是调用key（必须以GET方式拼接在URL中）secretString是调用密钥api_nameString是API接口名称（包括在请求地址中）[item_sear
• 史上最详细的测试用例写作规范 心软小念 测试用例
  软件测试用例得出软件测试用例的内容，其次，按照软件测试写作方法，落实到文档中，两者是形式和内容的关系，好的测试用例不仅方便自己和别人查看，而且能帮助设计的时候考虑的更周。一个好的测试用例必须包含足够的内容，将这些内容可以拆分为八个要素：用例编号、测试项目、测试标题、重要级别、预置条件、测试输入、操作步骤、预期输出。1、用例编号1）规则：是由字符和数字组成的字符串，具有唯一性、易识别性。2）不同阶段
• Linux初学（十）shell脚本 王依硕 Linuxlinux运维服务器
  一、for循环1.1循环的格式for变量in列表do代码代码....done循环的逻辑：将列表中的每个元素逐一赋值给变量每赋值一次，do和done之间的代码就会执行一次1.2列表的生成方式方法1：直接给出列表元素【用空格分隔多个元素】133129hahabaidu方法2：用通配符来生成元素/home/a*方法3：用命令来生成元素ls/etc/方法4：用{}展开的形式生成元素{3..7}{a..e}
• Java开发中，spring mvc 的线程怎么调用？ 小麦麦子 springmvc
  今天逛知乎，看到最近很多人都在问spring mvc 的线程http://www.maiziedu.com/course/java/ 的启动问题，觉得挺有意思的，那哥们儿问的也听仔细，下面的回答也很详尽，分享出来，希望遇对遇到类似问题的Java开发程序猿有所帮助。 问题：     在用spring mvc架构的网站上，设一线程在虚拟机启动时运行，线程里有一全局
• maven依赖范围 bitcarter maven
  1.test 测试的时候才会依赖，编译和打包不依赖，如junit不被打包 2.compile 只有编译和打包时才会依赖 3.provided 编译和测试的时候依赖，打包不依赖，如：tomcat的一些公用jar包 4.runtime 运行时依赖，编译不依赖 5.默认compile 依赖范围compile是支持传递的，test不支持传递 1.传递的意思是项目A，引用
• Jaxb org.xml.sax.saxparseexception : premature end of file darrenzhu xmlprematureJAXB
  如果在使用JAXB把xml文件unmarshal成vo(XSD自动生成的vo)时碰到如下错误： org.xml.sax.saxparseexception : premature end of file 很有可能时你直接读取文件为inputstream，然后将inputstream作为构建unmarshal需要的source参数。InputSource inputSource = new In
• CSS Specificity 周凡杨 html权重Specificitycss
    有时候对于页面元素设置了样式，可为什么页面的显示没有匹配上呢？ because specificity CSS 的选择符是有权重的，当不同的选择符的样式设置有冲突时，浏览器会采用权重高的选择符设置的样式。     规则：   HTML标签的权重是1 Class 的权重是10 Id 的权重是100
• java与servlet g21121 servlet
  servlet 搞java web开发的人一定不会陌生，而且大家还会时常用到它。 下面是java官方网站上对servlet的介绍： java官网对于servlet的解释 写道 Java Servlet Technology Overview Servlets are the Java platform technology of choice for extending and enha
• eclipse中安装maven插件 510888780 eclipsemaven
  1.首先去官网下载 Maven： http://www.apache.org/dyn/closer.cgi/maven/binaries/apache-maven-3.2.3-bin.tar.gz 下载完成之后将其解压， 我将解压后的文件夹：apache-maven-3.2.3， 并将它放在 D:\tools目录下， 即 maven 最终的路径是：D:\tools\apache-mave
• jpa@OneToOne关联关系 布衣凌宇 jpa
  Nruser里的pruserid关联到Pruser的主键id，实现对一个表的增删改，另一个表的数据随之增删改。 Nruser实体类 //***************************************************************** @Entity @Table(name="nruser") @DynamicInsert @Dynam
• 我的spring学习笔记11-Spring中关于声明式事务的配置 aijuans spring事务配置
  这两天学到事务管理这一块，结合到之前的terasoluna框架，觉得书本上讲的还是简单阿。我就把我从书本上学到的再结合实际的项目以及网上看到的一些内容，对声明式事务管理做个整理吧。我看得Spring in Action第二版中只提到了用TransactionProxyFactoryBean和<tx:advice/>,定义注释驱动这三种，我承认后两种的内容很好，很强大。但是实际的项目当中
• java 动态代理简单实现 antlove javahandlerproxydynamicservice
  dynamicproxy.service.HelloService package dynamicproxy.service; public interface HelloService { public void sayHello(); }   dynamicproxy.service.impl.HelloServiceImpl package dynamicp
• JDBC连接数据库 百合不是茶 JDBC编程JAVA操作oracle数据库
           如果我们要想连接oracle公司的数据库，就要首先下载oralce公司的驱动程序，将这个驱动程序的jar包导入到我们工程中;   JDBC链接数据库的代码和固定写法;     1,加载oracle数据库的驱动;     &nb
• 单例模式中的多线程分析 bijian1013 javathread多线程java多线程
  谈到单例模式，我们立马会想到饿汉式和懒汉式加载，所谓饿汉式就是在创建类时就创建好了实例，懒汉式在获取实例时才去创建实例，即延迟加载。 饿汉式： package com.bijian.study; public class Singleton { private Singleton() { } // 注意这是private 只供内部调用 private static
• javascript读取和修改原型特别需要注意原型的读写不具有对等性 bijian1013 JavaScriptprototype
          对于从原型对象继承而来的成员，其读和写具有内在的不对等性。比如有一个对象A，假设它的原型对象是B，B的原型对象是null。如果我们需要读取A对象的name属性值，那么JS会优先在A中查找，如果找到了name属性那么就返回；如果A中没有name属性，那么就到原型B中查找name，如果找到了就返回；如果原型B中也没有
• 【持久化框架MyBatis3六】MyBatis3集成第三方DataSource bit1129 dataSource
  MyBatis内置了数据源的支持，如：   <environments default="development"> <environment id="development"> <transactionManager type="JDBC" /> <data
• 我程序中用到的urldecode和base64decode,MD5 bitcarter cMD5base64decodeurldecode
  这里是base64decode和urldecode，Md5在附件中。因为我是在后台所以需要解码： string Base64Decode(const char* Data,int DataByte,int& OutByte) { //解码表 const char DecodeTable[] = { 0, 0, 0, 0, 0, 0
• 腾讯资深运维专家周小军：QQ与微信架构的惊天秘密 ronin47
  社交领域一直是互联网创业的大热门，从PC到移动端，从OICQ、MSN到QQ。到了移动互联网时代，社交领域应用开始彻底爆发，直奔黄金期。腾讯在过去几年里，社交平台更是火到爆，QQ和微信坐拥几亿的粉丝，QQ空间和朋友圈各种刷屏，写心得，晒照片，秀视频，那么谁来为企鹅保驾护航呢？支撑QQ和微信海量数据背后的架构又有哪些惊天内幕呢？本期大讲堂的内容来自今年2月份ChinaUnix对腾讯社交网络运营服务中心
• java-69-旋转数组的最小元素。把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素 bylijinnan java
  public class MinOfShiftedArray { /** * Q69 旋转数组的最小元素 * 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。 * 例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。 */ publ
• 看博客，应该是有方向的 Cb123456 反省看博客
  看博客，应该是有方向的:  我现在就复习以前的，在补补以前不会的，现在还不会的，同时完善完善项目，也看看别人的博客.  我刚突然想到的:  1.应该看计算机组成原理，数据结构，一些算法，还有关于android,java的。  2.对于我，也快大四了，看一些职业规划的，以及一些学习的经验，看看别人的工作总结的.    为什么要写
• [开源与商业]做开源项目的人生活上一定要朴素,尽量减少对官方和商业体系的依赖 comsci 开源项目
       为什么这样说呢？  因为科学和技术的发展有时候需要一个平缓和长期的积累过程，但是行政和商业体系本身充满各种不稳定性和不确定性，如果你希望长期从事某个科研项目，但是却又必须依赖于某种行政和商业体系，那其中的过程必定充满各种风险。。。       所以，为避免这种不确定性风险，我
• 一个 sql优化 （[精华] 一个查询优化的分析调整全过程！很值得一看 ） cwqcwqmax9 sql
  见   http://www.itpub.net/forum.php?mod=viewthread&tid=239011 Web翻页优化实例 提交时间: 2004-6-18 15:37:49      回复    发消息  环境： Linux ve
• Hibernat and Ibatis dashuaifu Hibernateibatis
  Hibernate  VS  iBATIS 简介 Hibernate 是当前最流行的O/R mapping框架，当前版本是3.05。它出身于sf.net，现在已经成为Jboss的一部分了 iBATIS 是另外一种优秀的O/R mapping框架，当前版本是2.0。目前属于apache的一个子项目了。 相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mappi
• 备份MYSQL脚本 dcj3sjt126com mysql
  #!/bin/sh # this shell to backup mysql #[email protected] (QQ:1413161683 DuChengJiu) _dbDir=/var/lib/mysql/ _today=`date +%w` _bakDir=/usr/backup/$_today [ ! -d $_bakDir ] && mkdir -p
• iOS第三方开源库的吐槽和备忘 dcj3sjt126com ios
  转自 ibireme的博客   做iOS开发总会接触到一些第三方库，这里整理一下，做一些吐槽。   目前比较活跃的社区仍旧是Github，除此以外也有一些不错的库散落在Google Code、SourceForge等地方。由于Github社区太过主流，这里主要介绍一下Github里面流行的iOS库。   首先整理了一份 Github上排名靠
• html wlwmanifest.xml eoems htmlxml
  所谓优化wp_head()就是把从wp_head中移除不需要元素，同时也可以加快速度。 步骤： 加入到function.php remove_action('wp_head', 'wp_generator'); //wp-generator移除wordpress的版本号，本身blog的版本号没什么意义，但是如果让恶意玩家看到，可能会用官网公布的漏洞攻击blog remov
• 浅谈Java定时器发展 hacksin java并发timer定时器
  java在jdk1.3中推出了定时器类Timer,而后在jdk1.5后由Dou Lea从新开发出了支持多线程的ScheduleThreadPoolExecutor，从后者的表现来看，可以考虑完全替代Timer了。 Timer与ScheduleThreadPoolExecutor对比： 1.    Timer始于jdk1.3,其原理是利用一个TimerTask数组当作队列
• 移动端页面侧边导航滑入效果 ini jqueryWebhtml5cssjavascirpt
  效果体验：http://hovertree.com/texiao/mobile/2.htm可以使用移动设备浏览器查看效果。效果使用到jquery-2.1.4.min.js，该版本的jQuery库是用于支持HTML5的浏览器上，不再兼容IE8以前的浏览器，现在移动端浏览器一般都支持HTML5，所以使用该jQuery没问题。HTML文件代码： <!DOCTYPE html> <h
• AspectJ+Javasist记录日志 kane_xie aspectjjavasist
  在项目中碰到这样一个需求，对一个服务类的每一个方法，在方法开始和结束的时候分别记录一条日志，内容包括方法名，参数名+参数值以及方法执行的时间。   @Override public String get(String key) { // long start = System.currentTimeMillis(); // System.out.println("Be
• redis学习笔记 MJC410621 redisNoSQL
  1)nosql数据库主要由以下特点：非关系型的、分布式的、开源的、水平可扩展的。 1，处理超大量的数据 2，运行在便宜的PC服务器集群上， 3，击碎了性能瓶颈。 1)对数据高并发读写。 2)对海量数据的高效率存储和访问。 3)对数据的高扩展性和高可用性。 redis支持的类型： Sring 类型 set name lijie get name lijie set na
• 使用redis实现分布式锁 qifeifei
  在多节点的系统中，如何实现分布式锁机制，其中用redis来实现是很好的方法之一，我们先来看一下jedis包中，有个类名BinaryJedis,它有个方法如下：   public Long setnx(final byte[] key, final byte[] value) { checkIsInMulti(); client.setnx(key, value); ret
• BI并非万能，中层业务管理报表要另辟蹊径 张老师的菜 大数据BI商业智能信息化
         BI是商业智能的缩写，是可以帮助企业做出明智的业务经营决策的工具，其数据来源于各个业务系统，如ERP、CRM、SCM、进销存、HER、OA等。        BI系统不同于传统的管理信息系统，他号称是一个整体应用的解决方案，是融入管理思想的强大系统：有着系统整体的设计思想，支持对所有
• 安装rvm后出现rvm not a function 或者ruby -v后提示没安装ruby的问题 wudixiaotie function
  1.在~/.bashrc最后加入 [[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"  2.重新启动terminal输入：   rvm use ruby-2.2.1 --default  把当前安装的ruby版本设为默

按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他

首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.