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

• 15个小技巧，让我的Windows电脑更好用了！ 曹元_
  01.桌面及文档处理第一部分的技巧，主要是围绕桌面的一些基本操作，包括主题设置、常用文档文件快捷打开的多种方式等等。主题换色默认情况下，我们的Win界面可能就是白色的文档界面，天蓝色的图表背景，说不出哪里不好看，但是就是觉得不够高级。imageimage说到高级感，本能第一反应就会和暗色模式联想起来，如果我们将整个界面换成黑夜模式的话，它会是这样的。imageimage更改主题颜色及暗色模式，我们
• day15｜前端框架学习和算法 universe_01 前端算法笔记
  T22括号生成先把所有情况都画出来，然后（在满足什么情况下）把不符合条件的删除。T78子集要画树状图，把思路清晰。可以用暴力法、回溯法和DFS做这个题DFS深度搜索：每个边都走完，再回溯应用：二叉树搜索，图搜索回溯算法=DFS+剪枝T200岛屿数量（非常经典BFS宽度把树状转化成队列形式，lambda匿名函数“一次性的小函数，没有名字”setup语法糖：让代码更简洁好写的语法ref创建：基本类型的
• 贫穷家庭的孩子考上985以后会怎样？ Mellisa蜜思言
  我出生在一个贫穷的农村家庭，据我妈说，我出生的时候才4斤多，而她生完我以后月子里就瘦到70斤。家里一直很穷，父母都是在菜市场卖菜的，家里还有几亩地种庄稼的。我很小开始就要去帮忙，暑假的生活就是帮忙去卖菜和割稻谷，那时候自己对于割稻谷这种事情有着莫名的恐惧，生怕自己长大以后还是每年都要过着割稻谷这种日子。父母因为忙于生计无暇顾及我的学习，幸好我因为看到他们这样子的生活，内心里有深深的恐惧感，驱使着我
• 日更50天有什么收益？ 星湾二宝
  坚持在平台上日更50天了，平台也为我生成了日更50天徽章，小开心一下这份坚持。日更50天徽章那坚持50天都有哪些收益呢？收益一，就是最直观的那些钻和贝，我这边确实不太高，但是这些贝足够支撑我保持会员的资格，能够在发文的时候帮助友友们去除广告，方便阅读。钻和贝收益二，文章的收获，日更50天，坚持写作3.7万文字，书写的文字也从开始的流水账/碎碎念逐渐加入自己的思考和观点。以前，一个念头会一晃而过，如
• Linux系统配置（应用程序） 1风天云月 Linuxlinux应用程序编译安装rpmhttp
  目录前言一、应用程序概述1、命令与程序的关系2、程序的组成3、软件包封装类型二、RPM1、RPM概述2、RPM用法三、编译安装1、解包2、配置3、编译4、安装5、启用httpd服务结语前言在Linux中的应用程序被视为将软件包安装到系统中后产生的各种文档，其中包括可执行文件、配置文件、用户手册等内容，这些文档被组织为一个有机的整体，为用户提供特定的功能，因此对于“安装软件包”与“安装应用程序”这两
• 通义万相2.2：开启高清视频生成新纪元 Liudef06小白 特殊专栏AIGC人工智能人工智能通义万相2.2图生视频
  通义万相2.2：开启高清视频生成新纪元2025年7月28日，中国AI领域迎来里程碑时刻——通义万相团队正式开源其革命性视频生成模型Wan2.2的核心权重，这标志着开源社区首次获得支持720P高清视频生成的先进模型架构。一、架构革新：混合专家系统1.1MoE视频扩散架构通义万相2.2首次将混合专家（MoE）架构引入视频扩散模型，通过双专家系统实现计算效率与模型容量的平衡：classMoEVideoD
• 【ARM】FPU,VFP,ASE,NEON,SVE...是什么意思？ 亿道电子Emdoor ARMarm开发ARM
  1、文档目标对执行浮点和SIMD操作的逻辑的各种名称的缩写词进行简要解释。2、问题场景Arm处理器内核中有用于执行浮点和SIMD操作的逻辑，有各种名称。它们通常是一系列的缩写形式，因此本文旨在对每一个缩写词进行简要解释。3、软硬件环境1、软件版本：不涉及2、电脑环境：不涉及4、相关缩写FPU(Floating-PointUnit)浮点单元浮点单元是处理器核心中的一个模块，用于使用浮点数执行算术运算
• 可处理！环境排放3.0项目怎么提现？裕华投资会刘裕华免费荐股骗局曝光！ 墨守成法
  骗子冒充裕华投资会刘裕华通过伪造或仿冒投资平台，向股民发送虚假环境排放3.0项目链接，引导股民者下载进行投资，以送一万体验金操作小额投资能提现作为诱饵，不断引导消费者加大资金投入。不法分子随后迅速转移资金，当投资者要提现时候就以“流水未完成”“登录异常”“服务器维护”“比赛未结束”等借口不让提现，直到平台关闭跑了或者完成流水任务为由一波亏完。在以翻本为借口继续让投资者加入资金。若你不幸遭遇到裕华投
• 平静得接受自己的笨拙 20190118 晨间日记 吴伯符
  图片发自App最近做了一个关于微习惯的分享，这里有八个字：微量开始，超额完成。这里的言下之意其实是要你在一开始的时候，平静地接受自己的笨拙。接受自己的笨拙，理解自己的笨拙，放慢速度尝试，观察哪里可以改进，再反复练习，观察自己哪里可以再进一步改进，再反复…这是学习一切技能的必须的过程。这里的两个关键点是：1.尽快的开始这个过程，这就能够用到微习惯的微量开始。2.尽快的度过这个过程，这就需要用到超额完
• 京东家电年销售额是去年的1300%，主要来自于他.... Shanshan小课堂
  经过大半个月角逐纠缠，时间终于来到6月18日，618全球年中购物节迎来最高潮。作为国内最大的家电零售平台，京东家电从18日0点开始，便开启了飞速狂奔的模式，仅8分钟销售额就突破20亿元!展现出强劲的增长势头与家电主场的王者霸气的同时，也让各家电品牌实现了爆发式增长，美的、海尔、格力、奥克斯均在3分钟内突破1亿元大关。在今年的618中，除了消费者已经熟悉的网购形式外，线上线下联动的融合模式、社交电商
• 基于redis的Zset实现作者的轻量级排名 周童學 Javaredis数据库缓存
  基于redis的Zset实现轻量级作者排名系统在今天的技术架构中，Redis是一种广泛使用的内存数据存储系统，尤其在需要高效检索和排序的场景中表现优异。在本篇博客中，我们将深入探讨如何使用Redis的有序集合（ZSet）构建一个高效的笔记排行榜系统，并提供相关代码示例和详细的解析。1.功能背景与需求假设我们有一个笔记分享平台，用户可以发布各种笔记，系统需要根据用户发布的笔记数量来生成一个实时更新的
• 分支和循环（下） tryxr 服务器运维
  写⼀个猜数字游戏游戏要求：1.电脑⾃动⽣成1~100的随机数2.玩家猜数字，猜数字的过程中，根据猜测数据的⼤⼩给出⼤了或⼩了的反馈，直到猜对，游戏结束1.随机数生成要想完成猜数字游戏，⾸先得产⽣随机数，那怎么产⽣随机数呢？randC语⾔提供了⼀个函数叫rand，这函数是可以⽣成随机数的，函数原型如下所⽰：intrand(void);rand函数会返回⼀个伪随机数，这个随机数的范围是在0~RAND_
• STM32入门之TIM基本定时器 嵌入式白话 STM32入门学习stm32嵌入式硬件单片机
  一、定时器简介定时器是嵌入式系统中的关键外设之一，它可以用于生成精确的延时、周期性中断、PWM波形生成等功能。在STM32F1系列单片机中，定时器不仅能为系统提供精确的时钟，还支持外部事件的捕获以及信号输出。对于定时器的功能，我们可以通过一个生活中非常常见的例子来形象地描述：微波炉的定时器。想象你正在使用微波炉加热食物。在微波炉里，定时器的作用就是帮助你控制食物加热的时间。当你设置了加热时间后，定
• 常规笔记本和加固笔记本的区别 luchengtech 电脑三防笔记本加固计算机加固笔记本
  在现代科技产品中，笔记本电脑因其便携性和功能性被广泛应用。根据使用场景和需求的不同，笔记本可分为常规笔记本和加固笔记本，二者在多个方面存在显著区别。适用场景是区分二者的重要标志。常规笔记本主要面向普通消费者和办公人群，适用于家庭娱乐、日常办公、学生学习等相对稳定的室内环境。比如，人们在家用它追剧、处理文档，学生在教室用它完成作业。而加固笔记本则专为特殊行业设计，像军事、野外勘探、工业制造、交通运输
• 给妻子的信 青年_1ea0
  亲爱的妻子：感谢你陪我走过了七年的风雨历程，因为我职业的原因，我对你、对女儿、对这个家庭没有尽到当丈夫、当父亲的责任。说来惭愧，女儿快六岁了和我单独在一起的日子又有多少呢?你每天上班，做饭，带小孩，很辛苦！我欠你的、欠孩子的、欠父母的太多太多了。你总是说既然选择了我也就选择了我的一切，你默默无闻的经营着这个家，在你的支持帮助下我安心工作，在工作上取得了一定的成就！亲爱的，感谢你陪我走过了人生最美的
• 人生最美的遇见，是灵魂的相遇 柔情灬淺風
  紫陌红尘，行色匆匆，总有一些故事铭心刻骨，历久弥香；总有一份遇见来得恰好，芬芳着整个苍绿孤旅；总有所谓伊人在水一方，清扬婉兮。心中有美一人，如花开在眸里；心中有君一人，如月挂在窗前。最美的遇见，是两颗敏感的灵魂走到了一起，从而，你中有我，我中有你，山有木兮木有枝，吾悦君兮君悦吾。清晨，雨住，天晴，霞光漫天，风柔草青，清新沁心，轻盈舒适。一个人安静地漫步在风中，心旌摇曳，心湖轻漾，激起的点点涟漪，像
• 元宇宙中的视觉技术：虚拟化身与场景生成 xcLeigh 计算机视觉CV元宇宙虚拟化身场景生成AIGC数字孪生
  元宇宙中的视觉技术：虚拟化身与场景生成前言一、元宇宙与视觉技术的深度关联1.1元宇宙概念深度剖析1.2视觉技术：元宇宙的“灵魂之窗”二、虚拟化身：数字世界的“第二自我”2.1虚拟化身技术的深度解析2.1.1核心技术构成2.1.2技术实现原理与流程2.2虚拟化身的应用领域及案例展示2.2.1游戏娱乐领域2.2.2教育培训领域三、场景生成：构建元宇宙的虚拟天地3.1场景生成技术全景透视3.1.1关键技
• python笔记14介绍几个魔法方法 抢公主的大魔王 pythonpython
  python笔记14介绍几个魔法方法先声明一下各位大佬，这是我的笔记。如有错误，恳请指正。另外，感谢您的观看，谢谢啦！(1).__doc__输出对应的函数，类的说明文档print(print.__doc__)print(value,...,sep='',end='\n',file=sys.stdout,flush=False)Printsthevaluestoastream,ortosys.std
• 2021-10-26 躺平日记：18.《陀枪师姐》 春迟馆
  写了一天字，明天《道德经》就可以临完了。阳台的玻璃也擦完了，明天再收拾收拾花盆什么的，阳台就基本告一段落。不管干活还是写字，总是用老剧做背景声音。因为看过，所以有一眼没一眼都无所谓，主要作用一是可以计时，一是提醒自己每集播完都起身活动活动。这几天放的是《陀枪师姐》。看朱素娥一步步从一个生活、事业陷入困境的绝望主妇，通过努力，不断提升自己，成长为优秀的配枪女警，真是很励志。
• 《倾“庙”之恋》里的诗意 道之可道
  这是毕飞宇老师《小说课》的最后一课。同前些课一样，他的每节课带给我的全新的解读视角都令我目眩神迷。汪曾祺老师的《受戒》正是我前段时间读过的，读后只觉得很有意思，两个单纯的可爱的少男少女之间的感情非常令人心动，而那个小和尚的身份又让这个故事有些传奇色彩，然而清新又是主调，还有一种淡淡的悲悯，为着他们未来未知的可能是悲剧的命运。毕老师的解读简直让我瞠目结舌，原来这个小说里藏着那么多唯美的诗意，那么多生
• Pktgen-DPDK：开源网络测试工具的深度解析与应用 艾古力斯
  本文还有配套的精品资源，点击获取简介：Pktgen-DPDK是基于DPDK的高性能流量生成工具，适用于网络性能测试、硬件验证及协议栈开发。它支持多种网络协议，能够模拟高吞吐量的数据包发送。本项目通过利用DPDK的高速数据包处理能力，允许用户自定义数据包内容，并实现高效的数据包管理与传输。文章将指导如何安装DPDK、编译Pktgen、配置工具以及使用方法，最终帮助开发者和网络管理员深入理解并优化网络
• 替身贵妃将我扒光沉塘，暴君杀红了眼陆知白李双儿全本免费小说阅读_最新完本小说替身贵妃将我扒光沉塘，暴君杀红了眼(陆知白李双儿) 多多文馆
  《替身贵妃将我扒光沉塘，暴君杀红了眼》主角：陆知白李双儿简介：我是贫门农女，也是暴君爱而不得的白月光。为逼我入宫，他将我满村屠尽！暴君在后宫建了一座水晶殿，将我禁锢其中。他日日宠幸我，直至寻到一个与我七分相似的替身，方才淡了兴致。他将替身封为贵妃，千娇万宠一言可戏诸侯。贵妃恃宠生娇，趁着暴君出宫巡视，带着一群人闯进水晶殿。“本宫马上就要受封为后，今天就来清理后宫！”她在我脸上刻奴字，挑断我的手筋脚
• 环境搭建 | Python + Anaconda / Miniconda + PyCharm 的安装、配置与使用
  本文将分别介绍Python、Anaconda/Miniconda、PyCharm的安装、配置与使用，详细介绍Python环境搭建的全过程，涵盖Python、Pip、PythonLauncher、Anaconda、Miniconda、Pycharm等内容，以官方文档为参照，使用经验为补充，内容全面而详实。由于图片太多，就先贴一个无图简化版吧，详情请查看Python+Anaconda/Minicond
• Qwen3 大模型实战：使用 vLLM 部署与函数调用（Function Call）全攻略 曦紫沐 大模型大模型部署Qwen3vLLM函数调用
  文章摘要本文将带你从零开始，深入掌握如何使用Qwen3-8B大语言模型，结合vLLM进行高性能部署，并通过函数调用（FunctionCall）实现模型与外部工具的智能联动。我们将详细讲解部署命令、调用方式、代码示例及实际应用场景，帮助你快速构建基于Qwen3的智能应用。一、Qwen3简介与部署环境准备Qwen3是通义千问系列的最新一代大语言模型，具备强大的自然语言理解和生成能力，尤其在函数调用、工
• 坚持53天断更 重新开始 静安梨子
  因为种种原因，原本计划好不管怎样每天坚持更新一篇的，但计划赶不上变化，在更完53天后终于还是断更了。但是也不算后悔，之前的状态确实不好，每天的输出大多数都感觉自己在凑字数，内容连自己都感觉看不下去了。调整好状态以后重新开始，给自己一个鼓励，虽然断更了，但能重新开始也很好，至少没有选择永远放弃。加油！
• [spring6: Mvc-网关]-源码解析
  推荐阅读：[spring6:Mvc-函数式编程]-源码解析GatewayServerMvcAutoConfiguration@AutoConfiguration(after={HttpClientAutoConfiguration.class,RestTemplateAutoConfiguration.class,RestClientAutoConfiguration.class,FilterAu
• Android 基础知识：Android 应用权限详解 流水mpc android
  这篇文章为大家系统的梳理一下Android权限相关的知识，在日常开发中，我们都用过权限，但是对于权限的一些细节我们可能掌握的还不够全面，这篇文章会全面的为大家介绍权限相关的知识。当然，本篇文章依然是参考了Google的官方文档：应用权限。本文目录一、认识Android权限（一）Android系统为什么需要权限？Android系统设置权限的目的是保护Android用户的隐私。对于用户的敏感数据And
• Android GreenDao介绍和Generator生成表对象代码
  目录(?)[-]介绍创建工程转载请注明：http://blog.csdn.net/sinat_30276961/article/details/50052109最近无意中发现了GreenDao，然后查看了一些资料后，发现这个数据库框架很适合用，于是乎，查看了官网的api，并自己写了一个小应用总结一下它的使用方法。介绍按照国际惯例，在开篇，总要先介绍一下什么是GreenDao吧。首先需要说明的是Gr
• 2019-04-05 诚信装饰祝希信
  2019年4月5日星期五天气晴(451)六年级七班祝全文今天是清明节，都放假了，好多人外出游玩踏青。一大早醒来去提水浇菜园子，全文还在呼呼睡大觉，浇完菜园子，简单吃了点饭就去干活了。中午回到家，厨房里乱七八糟，全文自己的脏衣服也没有洗，心里感觉真不是滋味，怎么会这样？优秀的孩子不是这样的，是我不该发脾气吗？还是回家继续忙碌，他人爱怎么怎么？家庭是共同的家庭，应该都有责任去承担，不要整天说来说去。全
• 基于DeepSeek的下一代大型游戏开发革命：架构、核心技术与项目管理实践 Liudef06小白 特殊专栏人工智能AIGC架构人工智能deepseek
  基于DeepSeek的下一代大型游戏开发革命：架构、核心技术与项目管理实践DeepSeek大模型正重塑游戏开发范式，本文将深入解析如何利用这一革命性技术构建下一代大型游戏，涵盖从架构设计到项目管理的全流程实践。目录DeepSeek游戏引擎核心架构1.1神经符号系统融合架构1.2动态世界生成引擎智能NPC与剧情系统2.1角色人格建模技术2.2动态叙事生成算法大型项目管理体系3.1敏捷-AI混合开发流
• 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.