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

• 想品客老师的第十三天：宏任务、微任务--js任务调度流程 Au_ust jsjavascript前端开发语言
  同步->微任务->宏任务->同步......定时器的任务是宏任务，无论等待时间短还是长，都先进行同步任务，进行同步任务的时候定时器正常计时，等到同步任务结束，宏任务被放到宏任务队列里，就可以直接执行定时器内的任务如果有两个定时器，在等完同步任务结束后，这两个定时器谁定的时间短，也就是计时的快，就先把谁放进宏任务队列里微任务的执行举个例子就是：例如这段代码会怎么输出setTimeout(()=>{ 
• 在项目中调用本地Deepseek（接入本地Deepseek） mr_cmx AIai前端DeepSeekAI
  前言之前发表的文章已经讲了如何本地部署Deepseek模型，并且如何给Deepseek模型投喂数据、搭建本地知识库，但大部分人不知道怎么应用，让自己的项目接入AI模型。文末有彩蛋哦！！！要接入本地部署的deepseek，我就要利用到我们之前部署时安装的ollama服务，并调用其API本地API接口1、生成文本（GenerateText）url:POST/api/generate功能：向模型发送提示
• python 快速实现链接转 word 文档 嘿嘿潶黑黑 pythonword
  python快速实现链接转word文档演示代码展示最后演示代码展示fromnewspaperimportArticlefromdocximportDocumentfromdocx.sharedimportPt,RGBColorfromdocx.enum.styleimportWD_STYLE_TYPEfromdocx.oxml.nsimportqn#tkinterGUIimporttkintera
• DeepSeek与ChatGPT：会取代搜索引擎和人工客服的人工智能革命 云边有个稻草人 热门文章chatgpt搜索引擎人工智能DeepSeek
  云边有个稻草人-CSDN博客在众多创新技术中，DeepSeek和ChatGPT无疑是最为引人注目的。它们通过强大的搜索和对话生成能力，能够改变我们与计算机交互的方式，帮助我们高效地获取信息，增强智能服务。本文将深入探讨这两项技术如何结合使用，为用户提供更精准、更流畅的对话和搜索体验。目录一、介绍1.1什么是DeepSeek？1.2什么是ChatGPT？1.3DeepSeek与ChatGPT的结合：
• flutter pigeon gomobile 插件中使用go工具类 yujunlong3919 fluttergolangswiftkotlin
  文章目录为什么flutter要用go写工具类1.下载pigeon插件模版2.编写go代码3.生成greeting.aar，Greeting.xcframework4.ios5.android6.dart中使用为什么flutter要用go写工具类在Flutter应用中，有些场景涉及到大量的计算，比如复杂的加密算法、数据压缩/解压缩或者图形处理中的数学计算等1.下载pigeon插件模版base_plu
• Redis主从复制 小松聊PHP进阶 Redis后端redis服务器nosql数据库sql架构
  主从复制官方文档：https://redis.io/docs/latest/operate/oss_and_stack/management/replication/极简概括：将一个主Redis服务器的数据复制到其它从Redis服务器的过程。角色：主节点（Master）：负责处理客户端的写（或者读）请求，并将写操作同步到从节点。从节点（Slave）：负责处理客户端的读请求，并将主节点发送过来的数据
• LLM与知识图谱融合:智能运维知识库构建 AI天才研究院 DeepSeekR1&大数据AI人工智能大模型AI大模型企业级应用开发实战AI实战计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
  1.背景介绍随着信息技术的飞速发展，IT运维管理面临着越来越大的挑战。海量的设备、复杂的网络环境、日益增长的数据量，使得传统的运维方式难以满足需求。为了提高运维效率和质量，智能运维应运而生。智能运维的核心是将人工智能技术应用于运维领域，通过机器学习、深度学习等算法，实现自动化、智能化的运维管理。其中，大语言模型（LLM）和知识图谱是两个重要的技术方向。LLM能够理解和生成自然语言，可以用于构建智能
• xml DOM高级 夜夜yaya WSDL解析
  XMLDOM(DocumentObjectModel)定义了访问和操作XML文档的标准方法。XMLDOMDOM把XML文档视为一种树结构。通过这个DOM树，可以访问所有的元素。可以修改它们的内容（文本以及属性），而且可以创建新的元素。元素，以及它们的文本和属性，均被视为节点。在本教程的较早章节中，我们介绍了XMLDOM，并使用了XMLDOM的getElementsByTagName()从DOM树中
• XML的介绍及使用DOM，DOM4J解析xml文件 late summer182 xmljava
  1XML简介XML（可扩展标记语言，ExtensibleMarkupLanguage）是一种用于定义文档结构和数据存储的标记语言。它主要用于在不同的系统之间传输和存储数据。作用：数据交互配置应用程序和网站Ajax基石特点XML与操作系统、编程语言的开发平台无关实现不同系统之间的数据交换2XML文档结构王珊.NET高级编程包含C#框架和网络编程等李明明XML基础编程包含XML基础概念和基本作用2.1
• 前端性能优化——如何提高页面加载速度？ 忘川... 前端性能优化html
  1.将样式表放在头部首先说明一下，将样式表放在头部对于实际页面加载的时间并不能造成太大影响，但是这会减少页面首屏出现的时间，使页面内容逐步呈现，改善用户体验，防止“白屏”。我们总是希望页面能够尽快显示内容，为用户提供可视化的回馈，这对网速慢的用户来说是很重要的。将样式表放在文档底部会阻止浏览器中的内容逐步出现。为了避免当样式变化时重绘页面元素，浏览器会阻塞内容逐步呈现，造成“白屏”。这源自浏览器的
• 《Java高级-Xml：利用DOM4j解析XML》 大大大钢琴 #Java：经验总结javaxml开发语言
  利用DOM4j解析XMLdom4j是一个简单的开源库，用于处理XML、XPath和XSLT，它基于Java平台，使用Java的集合框架，全面集成了DOM，SAX和JAXP。dom4j是目前在xml解析方面是最优秀的(Hibernate、Sun的JAXM也都使用dom4j来解析XML)，它合并了许多超出基本XML文档表示的功能，包括集成的XPath支持、XMLSchema支持以及用于大文档或流化文档
• 事件驱动框架 MacRsh 开源单片机stm32c语言设计模式
  事件驱动框架文档事件驱动框架是一种异步事件处理机制,它通过事件分发和回调的方式,可以有效地提高系统的异步处理能力、解耦性和可扩展性。事件驱动框架包含两个主要组件:事件服务器和事件客户端。事件服务器用于接收和分发事件,它内部维护一个事件队列用于存储待处理事件和一个事件列表用于存储注册的事件客户端。事件客户端用于处理特定类型的事件,它需要注册到事件服务器并提供一个回调函数。当事件发生时,事件服务器会将
• scoped作用原理及样式穿透的应用 太阳与星辰 Vue2前端面试前端vue面试
  scoped作用原理及样式穿透的应用(1)scoped作用原理(2)对第三条的详细解释(3)场景----微调第三方库样式(4)样式穿透(5)补充(1)scoped作用原理scoped是Vue样式作用域的一个特性,相信很多人经常在项目中用它来避免样式污染(即样式隔离)。当我们在一个组件中给style标签加上scoped时候,它会遵循以下三个规则，如下为组件实例生成一个唯一标识(可以称为文件指纹),给
• CSS属性 augenstern416 CSScss前端
  1.CSS定位方式initial：设置该属性为浏览器默认值inherit：规定应该从父元素继承position属性的值。static：默认值。没有定位，元素出现在正常的流中（忽略top,bottom,left,right或者z-index声明）。relative：生成相对定位的元素，相对于其正常位置进行定位。因此，“left:20”会向元素的LEFT位置添加20像素。absolute：生成绝对定位
• 【BAT-表姐御用01dir命令】批量获取文件夹中的文件名 Ama_tor BAT合集-表姐御用
  前言：本篇使用dir命令，末尾有彩蛋1、新建txt文件2、输入以下代码DIR*.*/B>LIST.TXT3、把txt文件的后缀改成.bat4、双击应用生成一个已获取名字列表的文本文件拓展：dir的语法（TIPS:dir/?:获取dir用法大全）1、dir：可得到当前目录下所有文件夹及文件，包含文件日期、时间、大小和文件名，不过不包含子文件夹下的文件夹和文件。2、dir目录：在命令后面添加文件夹名称
• 《DeepSeek-R1 vs ChatGPT-4：AI大模型“王座争夺战”的终极拆解报告》 Athena-H LLM人工智能gptchatgptai
  引言：大模型时代的双雄博弈在生成式AI爆发式迭代的今天，DeepSeek-R1与ChatGPT-4分别以“中国智造新锐”与“全球标杆王者”的身份，掀起技术路线与应用生态的激烈碰撞。本文从架构设计、场景适配、性能极限三大维度，揭示两大模型的真实战力图谱。一、核心技术架构：差异化路线对决对比维度DeepSeek-R1ChatGPT-4模型架构多模态混合专家模型（MoE+Transformer）纯Dec
• Failed to initialize editor Mac Zhu android
  今天遇到很奇葩的问题layout文件不能预览花了很长的时间处理，就是各种AndroidStudio相关的缓存文件的处理1.Invalidateandrestart2.删除Administrator下面的.android和.gradle3.删除Administrator\AppData\Local\Google\AndroidStudio2024.2目录4.重装AS5.升级降低AGPVersion和
• Jira，一个强大灵活的项目和任务管理工具 Python 库 图灵学者 python精华jirapython开发语言
  目录01初识Jira为什么选择Jira？02安装与配置安装jira库配置Jira访问获取APItoken：配置Python环境：03基本操作创建项目创建任务查询任务更新任务删除任务04高级操作处理子任务搜索任务添加附件评论任务05实战案例自动化创建与分配任务自动生成项目报告06结语01初识JiraJira是Atlassian公司开发的一款项目和任务管理工具。它广泛应用于软件开发、IT支持、营销等各
• 03.Docker 命令帮助 转身後 默落 Dockerdockereureka容器
  Docker命令帮助Docker命令帮助1.docker命令帮助2.docker优化Docker命令帮助docker命令是最常使用的docker客户端命令，其后面可以加不同的参数以实现不同的功能。1.docker命令帮助官方文档：https://docs.docker.com/reference/cli/docker/docker[OPTIONS]COMMANDCOMMAND分为:Manageme
• AI编剧系统深度解析：从算法架构到影视工业化应用实战 Coderabo DeepSeekR1模型企业级应用人工智能算法
  媒体娱乐行业革命：AI编剧创意辅助系统架构解析与实战应用一、行业背景与技术架构在流媒体内容需求激增的当下，传统编剧模式面临产能瓶颈。AI编剧创意辅助系统通过自然语言处理（NLP）、生成对抗网络（GAN）和知识图谱技术，构建了包含剧本生成、情节优化、角色塑造等模块的智能创作平台。核心架构分为：知识图谱层：整合影视剧本数据库（IMSDb）、维基百科等结构化数据NLP处理层：基于Transformer的
• 使用BLIP模型生成图像描述的可查询索引 dgay_hua python计算机视觉开发语言
  在本篇文章中，我们将介绍如何使用预训练的SalesforceBLIP图像描述模型，生成一个可查询的图像描述索引。我们将使用ImageCaptionLoader来加载图像，并通过一系列步骤生成查询索引。使用示例代码进行演示，帮助读者理解和实践。技术背景介绍随着计算机视觉技术的发展，图像描述生成成为了重要的研究领域。通过对图像内容自动生成文字描述，可以大大提高对图像信息的检索和管理效率。Salesfo
• 在 DeepSeek 驱动的编程变革中抓住机遇并脱颖而出 智想天开 AI技术人工智能deeplearning
  公众号地址:在DeepSeek驱动的编程变革中抓住机遇并脱颖而出更多内容请关注公众号：智想天开前言在DeepSeek引领的新一轮AI技术革新中，程序员们正面临着前所未有的挑战。随着DeepSeek等人工智能工具的迅猛发展，编程领域正在发生深刻变革。这些先进的工具不仅能够自动化完成繁重的代码生成和调试任务，还能够根据大量数据提供优化建议，改变了传统编程的工作流程。虽然这些技术为提高工作效率和解放开发
• MapEX - Mind the map! Accounting for existing maps when estimating online HDMaps from sensors. zisuina_2 python深度学习3d
  MapEX加入地图编码的MAP检测论文链接MapEX背景与动机：HD地图的重要性与高成本：HD地图是自动驾驶的关键组成部分，但其采集和维护成本极高。现有方法的局限性：现有方法主要依赖传感器数据生成HD地图，但通常忽略了已有的HD地图资源。当前方法最多只是对低质量地图进行地理定位或使用通用的已知地图数据库，效率和效果都有限。提出的解决方案：充分利用现有地图：在HD地图估计中引入现有HD地图资源，具体
• 利用人工智能增强可读性：自动为文本添加标点符号 姚家湾 AI标点符号
  在数字通信时代，文本的清晰度和可读性至关重要。无论是转录口语、处理原始文本数据还是改进用户生成的内容，标点符号在传达预期信息方面都起着至关重要的作用。但是，手动编辑文本以添加标点符号可能非常耗时且容易出错。这就是人工智能(AI)发挥作用的地方，它提供了一种强大的解决方案，可以自动将标点符号插入句子中。目前，利用大模型的能力，完全可以胜任添加标点符号的工作，不需要其它特别的处理程序。参考代码from
• DeepSeek 爆火：初级程序员的饭碗要丢？别慌，这是进阶的号角！ 清水白石008 人工智能职业生涯提升学习人工智能深度学习自然语言处理
  DeepSeek爆火：初级程序员的饭碗要丢？别慌，这是进阶的号角！前言最近，一款名为DeepSeek的AI编程工具火遍了程序员圈。其强大的代码生成能力、智能的代码理解，让不少初级程序员感到一丝焦虑：AI都这么厉害了，我们这些写基础代码的，饭碗还能保得住吗？作为一名在程序软件领域摸爬滚打多年的老兵，我深知技术变革带来的冲击，也理解初级程序员们心中的担忧。但我想说的是，DeepSeek的爆火，非但不是
• DeepSeek使用中的问题及解决方案（部分） WeiLai1112 DeepSeek人工智能
  1.模型部署与配置问题问题1：环境依赖冲突现象：安装模型依赖库时出现版本不兼容（如Python、PyTorch版本冲突）。解决方案：使用虚拟环境（如conda或venv）隔离依赖。严格按照官方文档的版本要求安装依赖，例如：condacreate-ndeepseekpython=3.9condaactivatedeepseekpipinstalltorch==2.0.1transformers==4
• 【机器学习】基于3D CNN通过CT图像分类预测肺炎 MUKAMO AIPython应用机器学习深度学习人工智能神经网络3DCNN
  1.引言1.1.研究背景在医学诊断中，医生通过分析CT影像来预测疾病时，面临一些挑战和局限性：图像信息的广度与复杂性：CT扫描生成的大量图像对医生来说既是信息的宝库也是处理上的负担。每组CT数据可能包含数百张切片，医生必须迅速审阅这些图像，以便捕捉到病变的微小细节。这种庞大的信息量要求医生在有限的时间内做出精准诊断，但同时也增加了漏诊或误诊的风险。部分容积效应也可能模糊小病变的边界，使得准确诊断变
• 一个Python的轻量级搜索工具--Whose Ai_绘画小南 python开发语言
  本文将简单介绍Python中的一个轻量级搜索工具Whoosh，并给出相应的使用示例代码。Whoosh简介Whoosh由MattChaput创建，它一开始是一个为Houdini3D动画软件包的在线文档提供简单、快速的搜索服务工具，之后便慢慢成为一个成熟的搜索解决工具并已开源。Whoosh纯由Python编写而成，是一个灵活的，方便的，轻量级的搜索引擎工具，现在同时支持Python2、3，其优点如下：
• Python Web开发新选择：FastAPI框架详细教程 车载testing pythonpython前端fastapi
  PythonWeb开发新选择：FastAPI框架详细教程简介FastAPI是一个用于构建API的现代、快速（高性能）的Web框架，它基于Python3.6+的类型提示。本文将通过具体的示例，详细介绍如何使用FastAPI进行Web开发。一、FastAPI简介1.FastAPI能做什么？FastAPI适用于构建：Web站点WebAPI测试平台持续集成工具自动生成API文档2.为什么要学习FastAP
• 【拥抱AI】如何实现AI外呼通话，并与客户达成确认 奔跑草- 人工智能人工智能
  实现AI外呼通话并与客户达成确认涉及多个技术组件和步骤。以下是一个基本的流程和技术方案，仅供参考。1.技术选型与准备主要技术组件语音识别（ASR）：将客户的语音转换为文本。自然语言处理（NLP）：理解和生成自然语言对话。语音合成（TTS）：将文本转换为客户可以听到的语音。呼叫平台/API：用于发起和管理电话呼叫。数据库：存储客户信息、通话记录等数据。业务逻辑层：处理对话管理和决策逻辑。2.系统架构
• 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.