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

• “深入浅出”系列之QT：（10）Qt接入Deepseek 我真不会起名字啊 qt开发语言
  项目配置：在.pro文件中添加网络模块：QT+=corenetworkAPI配置：将apiUrl替换为实际的DeepSeekAPI端点将apiKey替换为你的有效API密钥根据API文档调整请求参数（模型名称、温度值等）功能说明：使用QNetworkAccessManager处理HTTP请求自动处理JSON序列化/反序列化支持异步请求处理包含基本的错误处理扩展建议：添加更完善的错误处理（HTTP状
• css主题色修改后会多出一个css吗？css怎么定义变量？ 编程星空 CSSrust开发语言后端
  在CSS中修改主题色时，通常不会直接生成一个新的CSS文件，而是通过CSS变量（CustomProperties）或预处理器变量（如Sass、Less）来动态修改样式。以下是详细说明：1.CSS变量（CustomProperties）CSS变量是现代CSS提供的一种功能，允许在样式表中定义可复用的值，并在需要时动态修改。定义CSS变量CSS变量以--开头，通常在:root伪类中定义全局变量。:ro
• GPT (Generative Pre-trained Transformer) 彬彬侠 自然语言处理gpttransformer预训练NLP自然语言处理
  GPT(GenerativePre-trainedTransformer)是由OpenAI提出的一个基于Transformer架构的自回归语言模型。GPT模型通过大规模无监督预训练，使用大量的文本数据进行学习，然后再进行微调（fine-tuning）来适应具体的下游任务。GPT的设计目标是能够理解和生成自然语言文本，并且它以其出色的自然语言生成能力在多个领域取得了显著的成果。GPT的基本原理GPT
• 国产编辑器EverEdit - 独门暗器：自动监视剪贴板内容 编辑器爱好者 妙用编辑器编辑器EverEditEmEditorNotepad
  1监视剪贴板1.1应用场景  如果需要对剪贴板的所有历史进行记录，并进行分析和回顾，则可以使用监视剪贴板功能，不仅在EverEdit中的复制会记录，在其他应用的复制也会记录。1.2使用方法  新建一个空文档(重要：防止扰乱正常文件)，单击主菜单文档->监视剪贴板即可。该功能打开后，当前系统所有的复制内容，都会追加到用户指定的文档中。说明：监视剪贴板只会监控文本内容，图片、文档等非文本信息，不会追加
• uniapp开发APP，主动连接mqtt，订阅消息 路痴先森 uni-app
  一、安装依赖通过查阅资料，了解到现在mqtt.js库的最新版本已经是5，但是目前应该[email protected]版本最为稳定，我项目开发中使用的也是[email protected]版本[email protected]参考插件：MQTT使用-模板项目-DCloud插件市场参考文档：GitHub-mqttjs/MQTT.js:TheMQTTclientforNode.jsandthebrowser二、封装一个工具
• 图片粘贴上传实现 SarinaDu javascripthtml5
  图片上传htmldemo直接粘贴本地运行查看效果即可，有看不懂的直接喂给deepseek会解释的很清晰粘贴图片上传示例-使用场景，粘贴桌面图片上传、粘贴word文档中图片上传、直接截图上传等body{font-family:Arial,sans-serif;padding:20px;}.upload-area{width:100%;height:200px;border:2pxdashed#ccc
• Shopro商城新零售多商户社交电商分销商城系统支持微信公众号、微信小程序、H5、APP 狂团商城小师妹 博纳miui52086微信小程序小程序微信公众平台
  新零售解决方案重新建立消费者、货物、经营场所三者之间的联系。线上线下联合发力，以消费者体验为核心，全面布局新零售会员管理更便捷规范管理会员信息一目了然，可自动生成会员消费标签，帮助您制定个性化会员营销方案提高会员粘性将会员资源转化为订单。商城管理更省心规范管理会员信息一目了然，可自动生成会员消费标签，帮助您制定个性化会员营销方案提高会员粘性将会员资源转化为订单。社交电商解决方案社交电商已成为线上购
• AJAX使用和固定格式 乐多_L ajax前端javascript
  ajax的全称AsynchronousJavaScriptandXML(异步JavaScript和XML)。ajax是一种创建交互式网页应用的网页开发技术。其中最核心的依赖是浏览器提供的XMLHttpRequest对象，是这个对象使得浏览器可以发出HTTP请求与接收HTTP响应。实现了在页面不刷新的情况下和服务器进行交互。方法描述newXMLHttpRequest()生成一个XMLHttpRequ
• 探索AI音乐创作的未来：八款顶尖AI音乐生成工具（本期介绍国外-国内另外专题介绍） 带娃的IT创业者 AIGC程序员创富人工智能音视频ai
  探索AI音乐创作的未来：八款顶尖AI音乐生成工具（本期介绍国外-国内另外专题介绍）在科技飞速发展的今天，人工智能（AI）已经渗透到我们生活的方方面面，其中音乐创作也不例外。AI音乐生成工具不仅为专业音乐人提供了新的创作方式，也让普通人能够轻松创作出高质量的音乐作品。本文将介绍八款知名的AI音乐生成工具，帮助你了解它们的特点和优势。1.SunoSuno是一款AI驱动的音乐生成器，能够快速创建高质量的
• 如何解决分布式应用数量庞大而导致数据库连接数满的问题？ 纵然间 数据库
  修改数据库服务器的配置文件或参数来增加最大连接数限制。例如，在MySQL中，可以通过修改my.cnf（Linux）或my.ini（Windows）文件中的max_connections参数来增加最大连接数。具体的操作方法可以参考数据库服务器的官方文档或相关技术支持。检查应用程序代码，确保在使用完数据库连接后及时释放连接资源，避免长时间占用连接而导致连接数不足。可以使用连接池技术来管理数据库连接，提
• 清华大学第四发《DeepSeek+DeepResearch 让科研像聊天一样简单》 人工智能
  当下科研领域，传统模式急需改变，清华大学第四版《DeepSeek+DeepResearch：让科研像聊天一样简单》全文一共86页，以下是文档的关键内容总结：一、智能组合优势DeepSeek与DeepResearch构建先进技术体系，有强大模型运算、智能数据处理和友好交互界面。模型在数据处理速度、精准度和泛化能力上远超传统模型。数据采集渠道广、处理快，能读取多种格式文件。数据分析深入，可视化直观，还
• docker部署kafka（单节点） + Springboot集成kafka wsdhla dockerkafkaspringbootzookeeper
  环境：操作系统：win10Docker：DockerDesktop4.21.1(114176)、DockerEnginev24.0.2SpringBoot：2.7.15步骤1：创建网络：dockernetworkcreate--subnet=172.18.0.0/16net-kafka步骤2：安装zk镜像dockerpullzookeeper:latestdockerrun-d--restarta
• cocos creator从零开发简单框架(12)-代码生成单色Sprite cocos
  在写Panel前，先写个方法生成单色Sprite，这样当碰到需要单色Sprite的时候不需要在编辑器拖拽和代码动态加载资源。编辑framework/scripts/AppUtil.ts，添加newSpriteNode方法。//生成默认白色100x100大小Sprite(单色)节点publicstaticnewSpriteNode(name:string='newSpriteNode'):cc.No
• CSS中五种定位方式（position）对比分析 七公子77 csscss前端
  在CSS中，定位方式（position）决定了元素如何相对于其参照物进行定位，同时影响文档流的布局。以下是五种定位方式的对比、参照物说明及代码示例：1.position:static（默认定位）参照物：无，元素位于默认文档流中。文档流：元素按照HTML顺序自然排列。特点：top、right、bottom、left和z-index属性无效。示例：Box1Box2.box{width:100px;he
• Centos7 搭建 Jupyter + Nginx 服务 某龙兄 pythonnginxlinuxcentos
  JupyterNotebook（此前被称为IPythonnotebook）是一个交互式笔记本，支持运行40多种编程语言。JupyterNotebook的本质是一个Web应用程序，便于创建和共享文学化程序文档，支持实时代码，数学方程，可视化和markdown。用途包括：数据清理和转换，数值模拟，统计建模，机器学习等等。本文讲述如何搭建Jupyter+Nginx服务,仅供学习与交流，请勿用于商业用途一
• PHP搜索引擎WindSearch，新增Faker伪数据生成功能
  WindSearch是一个基于中文分词，由纯PHP开发全文检索引擎，可快速搭建PHP站点的站内搜索，他没有任何繁琐的安装配置、不需要维护调优、不占用服务器内存、可与PHP项目完美融合在一起。Faker数据生成安装导入//将WindSearch代码下载到本地，再像下面这样引入require_once'yourdirname/windsearch/vendor/autoload.php';开始生成//
• java实现，使用向量相似度 输入字符串，在定义好的字符串集合中根据语义匹配出最准的一个。 melck 1024程序员节
  以下是完整的Java示例代码，包括字符串集合的定义和根据输入字符串匹配最相似字符串的逻辑：importjava.util.*;publicclassSemanticMatching{publicstaticvoidmain(String[]args){//定义字符串集合ListstringCollection=Arrays.asList("Whereistherestroom?","Canyout
• FakeApp 技术浅析（一） 爱研究的小牛 AIGC—深度伪造虚拟现实人工智能AIGC深度学习机器学习
  FakeApp是一款早期的深度伪造（Deepfake）工具，最初于2018年发布，用于生成和编辑换脸视频。尽管FakeApp已经不再更新，但它在深度伪造技术的发展中起到了重要作用。1.技术背景与理论基础1.1生成对抗网络（GANs）生成对抗网络（GANs）是深度学习领域中的一种重要模型，由生成器（Generator）和判别器（Discriminator）组成。生成器负责生成逼真的数据（如图像、视频
• 图论篇--代码随想录算法训练营第五十七天打卡| 最小生成树问题 無量空所 leetcode算法图论数据结构c++学习
  题目链接：53.寻宝（第七期模拟笔试）题目描述：在世界的某个区域，有一些分散的神秘岛屿，每个岛屿上都有一种珍稀的资源或者宝藏。国王打算在这些岛屿上建公路，方便运输。不同岛屿之间，路途距离不同，国王希望你可以规划建公路的方案，如何可以以最短的总公路距离将所有岛屿联通起来（注意：这是一个无向图）。给定一张地图，其中包括了所有的岛屿，以及它们之间的距离。以最小化公路建设长度，确保可以链接到所有岛屿。解题
• 简易java调用DeepSeek Api教程 m0_62519278 学习小本本java数据库开发语言
  一、请求格式首先观察官方文档给出的访问api的样例脚本curlhttps://api.deepseek.com/chat/completions\-H"Content-Type:application/json"\-H"Authorization:Bearer"\-d'{"model":"deepseek-chat","messages":[{"role":"system","content":"
• DeepSeek 赋能工业软件之全流程方案 爱吃青菜的大力水手 人工智能自动化持续部署语言模型开源
  deepseek赋能工业软件之全流程方案之侧重半导体FABdeepseek在工业软件中的应用场景“deepseek”大模型在工业软件领域拥有广泛的应用场景，包括以下几个方面：智能调度：利用深度学习和优化算法，根据实时数据动态调整生产计划和资源分配。它可以综合考虑订单需求、设备状态和产能限制，智能生成最优的生产排程方案，减少等待时间和切换成本。例如在汽车制造工厂，deepseek可根据订单需求和设备
• 大学生学完python靠几个接单网站兼职，实现经济独立 「已注销」 python开发语言
  大学生学完python靠几个接单网站兼职，实现经济独立程序员就是当今时代的手艺人，程序员可以通过个人的技术来谋生。而在工作之余接私单可以作为一种创富的途径，受到程序员的广泛认可。说句实在话，现在这个时代，很多人仅靠主业顶多维持基本生活，想让自己、家人生活好一点很难。我接的私活并不算多，加起来也就几万左右，只能算一半，我想把一些经验分享出来，毕竟现在生活都不容易，能赚一点是一点。一、程序员接活、新手
• 2025.2.20总结 天真小巫 总结总结
  今晚评测试报告，评到一半，由于看板数据没有分析完，最后让我搞完再评.尽管工作了多年的同事告诉我，活没干完，差距比较大，没资格评报告，但还是本着试试的态度，结果没想到评审如此严苛.内心多少有些受打击，毕竟，加班加点的工作，只为能取得个好的结果，但感觉无论怎么努力，还是把交代的工作干成了烂泥，有时候也会有些怀疑，到底能否胜任这份工作.为什么努力了，还是没能把事情做好.难道是我工作的方式有问题吗？工作中
• 欧*雅WCS项目总结 十五001 项目归档后端java程序人生
  项目介绍使用系统APRISO下发任务与wcs交互，wcs包含与海康agv对接，以及APRISO不纳入管理的库位（包括线边库位、码头库位、暂存区库位、空栈板库位）。wcs的主要定位就是高度定制化贴合生产业务，可以说wcs成为了agv和APRISO之间的桥梁。APRISO下发任务时候，通过生成xml文件实现的，这时候wcs会监听该文件目录新建的xml文件来生成任务。刚开始部署后不到一周出现了监听失效问
• 【vue】Mammoth.js的使用：将.docx转换成HTML 暴富暴富暴富啦啦啦 1024程序员节
  mammoth.convertToHtml(input,options）：把源文档转换为HTML文档mammoth.convertToMarkdown(input,options)：把源文档转换为Markdown文档。mammoth.extractRawText(input)：提取文档的原始文本。这将忽略文档中的所有格式。每个段落后跟两个换行符。npminstallelement-uimammot
• 麒麟v10安装mysql5.7（ARM架构） qqxinxi arm开发
  下载路径：华为云镜像麒麟v10是潮流时代的新时髦的linux操作系统，但随着ARM架构流行，出现了一些卡点，不以为然，没当回事的大吃一惊。经常卡住。例如:在安装mysql5.7（ARM架构）最简单：使用rpmmysql-5.7.27.1.el7.aarch64.rpm文件比较小下载完之后rpm-ivhmysql-5.7.27.1.el7.aarch64.rpm比较简单常用的方法，再不能连接互联网时
• RealtimeSTT：实时语音转文本的开源神器，轻松实现高效语音处理 AI云极 【开源系列】语音识别开源
  在语音技术飞速发展的时代，实时语音转文本（Speech-to-Text，简称STT）技术已逐渐成为语音助手、在线会议记录、字幕生成等应用的核心功能。今天要为大家推荐的是一款开源的实时语音转文本工具——RealtimeSTT，它功能强大且易于集成，为开发者提供了快速构建实时语音处理应用的能力。项目地址：GitHub-RealtimeSTT一、什么是RealtimeSTT？RealtimeSTT是一款
• 快速复制A库表数据前10000行到B库 musk1212 数据库sqlmysql
  提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录应用场景一、存储过程，快速复制A库表数据前10000行到B库二、使用优化点说明结构优化性能调整错误处理增强安全改进调用示例应用场景表结构可预先存在或不存在mysql5.7快速复制A库表数据前10000行到B库一、存储过程，快速复制A库表数据前10000行到B库/*设置自定义分隔符以处理存储过程中的分号*/DELIMITER$$
• Labelbox：引领AI与人类协作的未来 魏兴雄Milburn
  Labelbox：引领AI与人类协作的未来labelbox-pythonLabelboxPythonClient项目地址:https://gitcode.com/gh_mirrors/la/labelbox-python项目介绍Labelbox是一款专为企业和学术研究社区设计的开源工具，旨在简化数据标注、生成高质量的人类反馈数据、评估和提升模型性能，并通过无缝结合AI与人类工作流程来自动化任务。无
• Java 运行时常量池笔记（详细版 小猫猫猫◍˃ᵕ˂◍ java笔记python
  Java运行时常量池笔记（详细版）Java的运行时常量池（RuntimeConstantPool）是JVM方法区的一部分，用于存储编译期生成的字面量和符号引用。它是Java类文件常量池的运行时表示，具有动态性和共享性。运行时常量池的核心概念1.什么是运行时常量池？运行时常量池是JVM方法区的一部分，存储类文件中常量池的内容。它包含：字面量：如字符串、整数、浮点数等。符号引用：如类名、方法名、字段名
• 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.