### Armazenar em cache o esquema OpenAPI

Você pode usar a propriedade `.openapi_schema` como um "cache" para armazenar o esquema gerado.

Dessa forma, sua aplicação não precisará gerar o esquema toda vez que um usuário abrir a documentação da sua API.

Ele será gerado apenas uma vez, e o mesmo esquema armazenado em cache será utilizado nas próximas requisições.

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.common.cache;

import com.google.common.annotations.GwtCompatible;

/**
 * An object that can receive a notification when an entry is removed from a cache. The removal
 * resulting in notification could have occurred to an entry being manually removed or replaced, or

import org.codelibs.fess.crawler.util.XmlUtil;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

import jakarta.annotation.Resource;

/**
 * <p>

        assertArgumentNotNull("locale", locale);

        DecimalFormatSymbols symbols = CACHE.get(locale);
        if (symbols == null) {
            symbols = new DecimalFormatSymbols(locale);
            CACHE.put(locale, symbols);
        }
        return symbols;
    }

	// NowFunc the function to be used when creating a new timestamp
	NowFunc func() time.Time
	// DryRun generate sql without execute
	DryRun bool
	// PrepareStmt executes the given query in cached statement
	PrepareStmt bool
	// PrepareStmt cache support LRU expired,
	// default maxsize=int64 Max value and ttl=1h
	PrepareStmtMaxSize int
	PrepareStmtTTL     time.Duration

	// DisableAutomaticPing
	DisableAutomaticPing bool

    }
  }

  @Test
  public void testPutNewValue() {
    assertThat(mapCache.put("key", "value")).isNull();
    assertThat(mapCache.get("key")).isEqualTo("value"); // ensure key/value is cached
    assertThat(mapCache.put("key", "new value")).isEqualTo("value");
    assertThat(mapCache.get("key")).isEqualTo("new value");
  }

  @Test
  public void testRemoveEqualKeyWithDifferentReference() {

		ctags["cgo"] = true
	}
	for _, tag := range context.BuildTags {
		ctags[tag] = true
	}
	// TODO: ReleaseTags (need to load default)
	key := dir

	// explicit on GOOS and GOARCH as global cache will use "all" cached packages for
	// an indirect imported package. See https://github.com/golang/go/issues/21181
	// for more detail.
	tags = append(tags, context.GOOS, context.GOARCH)
	slices.Sort(tags)

  }

  private fun enableCache(): Cache? {
    cache = makeCache()
    client = client.newBuilder().cache(cache).build()
    return cache
  }

  private fun makeCache(): Cache {
    val cacheDir = File.createTempFile("cache-", ".dir")
    cacheDir.delete()
    return Cache(cacheDir, (1024 * 1024).toLong())
  }

  companion object {

		case "Deleted":
			z.Deleted, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Deleted")
				return
			}
		case "Cached":
			z.Cached, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Cached")
				return
			}
		case "NoMetadata":
			z.NoMetadata, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "NoMetadata")

        this.maxContentLength = maxContentLength;
        return this;
    }

    /**
     * Sets the cache file size threshold in bytes.
     *
     * @param cacheFileSize the cache file size to set
     * @return this builder instance for method chaining
     */
    public ExtractorBuilder cacheFileSize(final int cacheFileSize) {