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文档)

• 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
  本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
• 谢谢你们，爱你们！ 鹿游儿
  昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
• 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
  提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
• Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
  目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
• 今天我破防了 sin信仰
  今天本来是大年初一，新年的第一天，应该是高高兴兴的一天，但是我怎么也高兴不起来。具体原因很简单，原本计划年后去县城找了一份会计的工作，被公公婆婆否定了，我心里立马就不舒服了，但是当时刚好肚子疼，我去了厕所，等我上完厕所，公公由于喝了酒还在那里和婆婆唠叨个没完。然后我就在心情极度压抑的情况下把午饭吃完的碗筷和锅给刷了。边刷碗筷和锅，边在那里难受，感觉自己在这个家里真的是过的憋屈死了，公婆不让我去上班
• LLM 词汇表 落难Coder LLMsNLP大语言模型大模型llama人工智能
  Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
• 使用LLaVa和Ollama实现多模态RAG示例 llzwxh888 python人工智能开发语言
  本文将详细介绍如何使用LLaVa和Ollama实现多模态RAG（检索增强生成），通过提取图像中的结构化数据、生成图像字幕等功能来展示这一技术的强大之处。安装环境首先，您需要安装以下依赖包：!pipinstallllama-index-multi-modal-llms-ollama!pipinstallllama-index-readers-file!pipinstallunstructured!p
• 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库python
  深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
• 数组去重 好奇的猫猫猫
  整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
• 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
  leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
• Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
  文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
• 教育 用心灵温暖心灵
  @陈春丽长期学习班冯倩。今天一早就听到说高职合并，取消中专教育的教育信息。感觉是虽然知道，再听还是吓一跳。国家重视职业教育为何还要取消中专技术学校的教育？再听高中就要进行技术教育了，一部分人学习好继续努力学习考大学，一部分人在高中就可以进行职业教育接受职业教育了还要中专技术教育学校干什么呢！a有些职业教育学校转型升级快，不是孩子上完给找工作，而是学校帮孩子创业，我觉得是不错的方向！新闻新你得实时更
• 2023-07-24 DXZHY
  很2023年7月24号星期天，今天呢一早我就去开店，淋完花我就赶去了中心联谊，感谢中心联谊过程当中，他们在唱诵读者上面1.一边流泪，感觉自己的内在灵魂太长，时间没有得到这样了，所以一边唱手一边在流泪，我分不清楚自己是感动了，还是被呼唤的灵魂所能看到，但我就是哭了，泪流满面，我全身细胞在放松，最后我们荣耀完了之后，我打包了一部分回来，我发现我是挺真爱想摸的，然而。那我们商量好之后，他要做出一些违背我
• 第九十章 真情 溪境
  图片发自App图片发自App和雏田在一起的日子真的很开心。姐姐永远是最亲的最真的。佐助总来捣乱。小樱准备一盆水泼佐助。想到恋爱通告亦菲被泼水不免高兴。亦菲是最美的。没想到她也会有这种遭遇。也许不需要赚那么多钱。和家人在一起的日子真好。却轻易破碎。雏田的话语温软，依稀在耳边。她的微笑纯美温柔。喜欢温柔的哥哥，雏田就是这样啊。不知道雏田是喜欢男生还是女生。我都支持。过去门当户对。现在自由恋爱。想永远和
• 【勾心原创】《去年夏天》 不勾心的豆角
  （原创作者：不勾心的豆角）本期【勾心原创】，继续本人不勾心的豆角的现代诗创作之旅。《去年夏天》原创作者：不勾心的豆角那里芳草茵茵绿柳成行澄净蓝天下屋顶们相亲相爱闪着橙色紫色的馨香溪流温柔偎依着村庄牛儿羊儿信步徜徉还有成群的白鸽在尖顶的教堂盘旋歌唱孩子们是自由的蒲公英奔跑在希望的田野上任由天真的笑声肆无忌惮烂漫这人间天堂夜幕小心翼翼呵护着甜美的梦乡只剩尽职的晚风陪伴顽皮的星子们游荡快告诉我心爱的姑娘
• insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
  前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
• 女儿考研完报考雅思 捡拾流年
  是否我过于焦虑？会不会无形间让女儿觉得压力太大了啊。2022年对于我们家来说是不平常的一年。女儿今年大四，为了准备考研，暑假也没回家，年初去了学校到了年末才回家。女儿自己一个人面对考研，没有参加培训，大四学校作业论文等课业也多，她同时也是很努力复习考研的。在疫情开放很多羊的时期，女儿终于顺顺利利参加12月24、25号的考研，我们和家人都觉得女儿回家来要好好休息调养。可女儿回到家，我再查阅考研信息，
• 虚张声势 六月荷清香
  绵绵密密的细雨不间断地下个不停，给这初冬的天气添了几份清冷和寂寥。午后的菜市场内没有一个顾客光顾，几个分肉的屠户望着案板上那些没有分完的肉，还在期待着来一个主顾将它们一起买走。贩卖小菜的女人一边漫不经心地择着菜，一边不时打个哈欠，这样的时光正是好睡觉的时候，可是一天的工作没有完成，还是要坚守岗位。喜欢开玩笑的屠户不时说几句黄段子，调侃着胖胖的卖鸡老板娘，大家说说笑笑着以打发这无聊的时光。张屠户打了
• Linux sh命令 fengyehongWorld Linuxlinux
  目录一.基本语法二.选项2.1-c字符串中读取内容，并执行2.1.1基本用法2.1.2获取当前目录下失效的超链接2.2-x每个命令执行之前，将其打印出来2.3结合Here文档使用一.基本语法⏹Linux和Unix系统中用于执行shell脚本或运行命令的命令。sh[选项][脚本文件][参数...]⏹选项-c：从字符串中读取内容，并执行。-x：在每个命令执行之前，将其打印出来。-s：从标准流中读取内容
• Linux vi常用命令 fengyehongWorld Linuxlinux
  参考资料viコマンド（vimコマンド）リファレンス目录一.保存系命令二.删除系命令三.移动系命令四.复制粘贴系命令一.保存系命令⏹保存并退出:wq⏹强制保存并退出:wq!⏹退出(文件未编辑):q⏹强制退出(忽略已编辑内容):q!⏹另存为:w新文件名二.删除系命令⏹删除当前行dd⏹清空整个文档gg：移动到文档顶部dG：删除到最后一行ggdG三.移动系命令⏹移动到文档顶部gg⏹移动到文档底部#方式1G
• 基于Python给出的PDF文档转Markdown文档的方法 程序媛了了 pythonpdf开发语言
  注：网上有很多将Markdown文档转为PDF文档的方法，但是却很少有将PDF文档转为Markdown文档的方法。就算有，比如某些网站声称可以将PDF文档转为Markdown文档，尝试过，不太符合自己的要求，而且无法保证文档没有泄露风险。于是本人为了解决这个问题，借助GPT（能使用GPT镜像或者有条件直接使用GPT的，反正能调用GPT接口就行）生成Python代码来完成这个功能。笔记、代码难免存在
• BART&BERT Ambition_LAO 深度学习
  BART和BERT都是基于Transformer架构的预训练语言模型。模型架构：BERT(BidirectionalEncoderRepresentationsfromTransformers)主要是一个编码器（Encoder）模型，它使用了Transformer的编码器部分来处理输入的文本，并生成文本的表示。BERT特别擅长理解语言的上下文，因为它在预训练阶段使用了掩码语言模型（MLM）任务，即
• 2020-8-19晨间日记：看过的电影 盐大虾
  今天是周三起床：6点半就寝：11点天气：晴心情：正常纪念日：周三任务清单今日完成的任务，最重要的三件事：1.整理写过的文档2.电影《电灯泡》3.这就是街舞第三季第五期改进：早睡早起习惯养成：早睡早起，看书周目标·完成进度两篇文章学习·信息·阅读电影艺术发展史相关教材健康·饮食·锻炼吃了挺多零食，还喝了果粒橙，还是得少吃，多锻炼，不然会慢慢死掉的。人际·家人·朋友淡定交流，不放在心上。工作·思考专心
• 无题 琴韵无声
  问了几家门诊部都没有科兴疫苗，突然自我感觉这种品牌的疫苗是不是少一些，于是又无端滋生焦虑感，可别一拖再拖影响孩子上学，学校要求下学期开学得接种完新冠疫苗。我在这种自制的焦虑的驱使下，立马上网查询看哪里能打到北京科兴的疫苗，终于找到了，大喜。与珊宝一起打车过去（路比较远，早想借此机会让她徒步拉练一下的计划泡汤了）。到达目的地，一看到医院大门前一条长龙似的队伍就知道那里应该是打疫苗的地方。迅速过去排队
• 张芝华49天共修 - 草稿 李娟AINI
  祈禱、靜心、源代碼編程、觀想發願四根支柱，運用靈性能量的助力，讓夢想和渴望在最大向度中輕鬆實現。共修群指定书籍:1.能断金刚麦克格西2.新世界：灵性的觉醒埃克哈特·托尔3.爱是一切的答案芭芭拉迪安吉莉思4.完美的爱,不完美的关系约翰•威尔伍德5.爱的业力法则麦克格西6.漫画《金刚经》蔡志忠7.蔡志忠典藏国学漫画系列(套装共6册)作业:全部在共修群里完成，并请保存好自己的作业。l一周三次共修觉察作业
• Python神器！WEB自动化测试集成工具 DrissionPage 亚丁号 python开发语言
  一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
• tiff批量转png 诺有缸的高飞鸟 opencv图像处理pythonopencv图像处理
  目录写在前面代码完写在前面1、本文内容tiff批量转png2、平台/环境opencv,python3、转载请注明出处：https://blog.csdn.net/qq_41102371/article/details/132975023代码importnumpyasnpimportcv2importosdeffindAllFile(base):file_list=[]forroot,ds,fsin
• 怎么做才能真正限制塑料袋的使用？ BalNews
  Environmentalpollutionisalwaysamajorlivelihoodissue.Morethanadecadeago,ourgovernmenthadintroducedapolicyaboutrestrictionsontheuseofplasticbags,wecallitrestrictionsontheuseofplasticbags.Butmorethan10ye
• 入门MySQL——查询语法练习 K_un
  前言：前面几篇文章为大家介绍了DML以及DDL语句的使用方法，本篇文章将主要讲述常用的查询语法。其实MySQL官网给出了多个示例数据库供大家实用查询，下面我们以最常用的员工示例数据库为准，详细介绍各自常用的查询语法。1.员工示例数据库导入官方文档员工示例数据库介绍及下载链接：https://dev.mysql.com/doc/employee/en/employees-installation.h
• 阅读笔记：阅读方法中的逻辑和转念 施吉涛
  聊聊一些阅读的方法论吧，别人家的读书方法刚开始想写，然后就不知道写什么了，因为作者写的非常的“精致”我有一种乡巴佬进城的感觉，看到精美的摆盘，精致的食材不知道该如何下口也就是《阅读的方法》，我们姑且来试一下强劲的大脑篇，第一节：逻辑通俗的来讲，也就是表达的排列和顺序，再进一步就是因果关系和关联实际上书已经看了大概一遍，但直到打算写一下笔记的时候，才发现作者讲的推理更多的是阅读的对象中呈现出的逻辑也
• 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.