# Can bannedbook/fanqiang Be Used with Other Tools? Integration Guide and Examples

> Discover how to integrate bannedbook/fanqiang with other tools. This guide details using its Go library for seamless incorporation into your projects. Learn integration methods and see examples.

- Repository: [如何翻墙/fanqiang](https://github.com/bannedbook/fanqiang)
- Tags: integration-guide
- Published: 2026-06-15

---

**Yes, bannedbook/fanqiang can be integrated with other tools through its self-contained Go library (`fqnews2/libcore`), which exposes a configurable HTTP client, TLS utilities, and RSS parsing functions that can be imported into any Go project or wrapped for cross-language use.**

While bannedbook/fanqiang is widely recognized as a curated collection of anti-censorship tutorials, the repository also maintains a production-ready Go module separate from its documentation. The `fqnews2/libcore` package implements a lightweight HTTP client abstraction with support for modern TLS configurations, SOCKS5 proxy routing, and feed parsing. Because the library carries no hidden dependencies, developers can embed bannedbook/fanqiang functionality into custom proxy tools, monitoring services, or CLI utilities with standard Go module imports.

## Core Library Architecture

The integration capabilities stem from the `libcore` package located in `fqnews2/libcore/`. Unlike the static markdown tutorials, this code is designed for reuse in external applications.

### HTTP Client and TLS Configuration

The primary interface is defined in [`fqnews2/libcore/http.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/http.go). The `HTTPClient` type wraps the standard `net/http` stack while providing chainable configuration methods:

- **`ModernTLS()`** — Enables TLS 1.2 and above for broad compatibility.
- **`RestrictedTLS()`** — Enforces TLS 1.3-only connections for maximum security.
- **`PinnedTLS12()` / `PinnedSHA256()`** — Implements certificate pinning to prevent MITM attacks.
- **`TrySocks5(port)`** — Routes all traffic through a local SOCKS5 daemon (e.g., V2Ray or Shadowsocks).
- **`KeepAlive()`** — Enables HTTP/2 support and connection reuse.

These methods return the client instance, allowing fluent configuration before constructing an `HTTPRequest` via `NewRequest()`.

### RSS and Feed Parsing

Located in [`fqnews2/libcore/export.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/export.go), the parsing utilities convert RSS or Atom feeds into JSON. The **`ParseBodyString()`** function accepts a raw XML string and returns structured JSON bytes using the `github.com/mmcdole/gofeed` library. This operates entirely offline, requiring no external services beyond the feed content itself.

## Integration Scenarios

Developers can leverage bannedbook/fanqiang in several architectural patterns:

**Custom Proxy Tools**  
Reuse `HTTPClient.TrySocks5` to forward requests through existing Shadowsocks or V2Ray SOCKS5 endpoints. Combine with `RestrictedTLS()` to ensure all proxied traffic uses modern cryptography.

**Monitoring and Scraping Services**  
Use `NewHttpClient().ModernTLS().NewRequest()` to fetch JSON APIs or news feeds from behind restrictive firewalls. Pipe the response through `ParseBodyString` to normalize RSS data for storage or analysis pipelines.

**Cross-Language Wrappers**  
Compile the library into a shared object using cgo, then invoke it from Python, Node.js, or Rust via FFI. Alternatively, build static binaries that shell scripts can execute for connectivity testing.

**CLI Utilities**  
Build command-line tools that leverage the STUN client in `fqnews2/libcore/stun/*` for NAT discovery, or use the HTTP client to verify proxy connectivity and fetch blocked resources.

## Implementation Examples

The following snippets demonstrate how to import `github.com/bannedbook/fanqiang/fqnews2/libcore` and utilize its core features.

### Execute a GET Request with Modern TLS

```go
package main

import (
	"fmt"
	"log"

	"github.com/bannedbook/fanqiang/fqnews2/libcore"
)

func main() {
	// Create a reusable client
	c := libcore.NewHttpClient()
	c.ModernTLS()          // TLS 1.2+ (default for most servers)
	c.KeepAlive()          // enable HTTP/2 & keep-alive

	// Build a request
	req := c.NewRequest()
	if err := req.SetURL("https://example.com/api/status"); err != nil {
		log.Fatalf("bad URL: %v", err)
	}
	req.SetMethod("GET")
	req.SetUserAgent("fanqiang-demo/1.0")

	// Execute
	resp, err := req.Execute()
	if err != nil {
		log.Fatalf("request failed: %v", err)
	}
	body, err := resp.GetContentString()
	if err != nil {
		log.Fatalf("read body: %v", err)
	}
	fmt.Println("Response:", body)

	c.Close()
}

```

*Key methods:* `NewHttpClient` and `ModernTLS` are defined in [`fqnews2/libcore/http.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/http.go).

### Parse an RSS Feed into JSON

```go
package main

import (
	"fmt"
	"log"

	"github.com/bannedbook/fanqiang/fqnews2/libcore"
)

func main() {
	// Prepare HTTP client (TLS not required for most RSS endpoints)
	c := libcore.NewHttpClient()
	req := c.NewRequest()
	_ = req.SetURL("https://news.ycombinator.com/rss")
	req.SetMethod("GET")

	resp, err := req.Execute()
	if err != nil {
		log.Fatalf("failed to fetch RSS: %v", err)
	}
	raw, _ := resp.GetContentString()

	// Convert the raw RSS XML to JSON
	jsonBytes, err := libcore.ParseBodyString(raw)
	if err != nil {
		log.Fatalf("parse error: %v", err)
	}
	fmt.Println(string(jsonBytes))

	c.Close()
}

```

*Key methods:* `ParseBodyString` lives in [`fqnews2/libcore/export.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/export.go).

### Route Traffic Through a SOCKS5 Proxy

```go
package main

import (
	"log"

	"github.com/bannedbook/fanqiang/fqnews2/libcore"
)

func main() {
	c := libcore.NewHttpClient()
	// Assume a V2Ray SOCKS5 listener on localhost:1080
	c.TrySocks5(1080)

	// Now every request goes through the proxy
	req := c.NewRequest()
	_ = req.SetURL("https://api.ipify.org?format=json")
	req.SetMethod("GET")

	resp, err := req.Execute()
	if err != nil {
		log.Fatalf("proxy request failed: %v", err)
	}
	body, _ := resp.GetContentString()
	log.Println("Public IP:", body)

	c.Close()
}

```

*Key methods:* `TrySocks5` is implemented in [`fqnews2/libcore/http.go`](https://github.com/bannedbook/fanqiang/blob/main/fqnews2/libcore/http.go).

## Summary

- bannedbook/fanqiang provides a reusable Go library at `fqnews2/libcore` that is decoupled from its tutorial content.
- The `HTTPClient` abstraction in [`http.go`](https://github.com/bannedbook/fanqiang/blob/main/http.go) supports configurable TLS modes, certificate pinning, and SOCKS5 proxy routing.
- `ParseBodyString` in [`export.go`](https://github.com/bannedbook/fanqiang/blob/main/export.go) enables server-side RSS-to-JSON conversion without external API dependencies.
- Zero hidden dependencies allow standard import via `go get github.com/bannedbook/fanqiang/fqnews2/libcore`.
- Cross-language integration is achievable through cgo, FFI, or static binary compilation.

## Frequently Asked Questions

### Can I use bannedbook/fanqiang in a Python or Node.js project?

Yes. While the library is implemented in Go, you can compile it as a shared object using cgo and invoke it via Python's `ctypes` or Node.js FFI bindings. Alternatively, build a Go binary that exposes CLI commands and call it from your application using subprocess mechanisms.

### What is the minimum Go version required to import fqnews2/libcore?

The library relies on standard library features available in Go 1.18 and later. Import it using `go get github.com/bannedbook/fanqiang/fqnews2/libcore` and ensure your `go.mod` file specifies a compatible version.

### Does the HTTP client support HTTP/2 and TLS 1.3?

Yes. Calling `ModernTLS()` configures the client for TLS 1.2 and above, while `RestrictedTLS()` enforces TLS 1.3-only connections. The `KeepAlive()` method enables HTTP/2 support when the server advertises it via ALPN.

### Is the RSS parser dependent on external cloud services?

No. The `ParseBodyString` function processes XML content locally using the `gofeed` package. It requires only the RSS or Atom feed content as a string or byte slice, making it suitable for offline or air-gapped environments where external API calls are prohibited.