How Can I Implement an Interface with Unexported Methods from Another Go Package?

Implementing Interfaces with Unexported Methods from Other Packages

In Go, interfaces serve as contracts that define a set of methods that must be implemented by any type that adheres to it. Typically, the methods of an interface are exported to allow access from other packages. However, there may be scenarios where you need to hide specific implementations from the consuming program.

Consider the following example, where we define an interface for accounting system access:

package accounting

import "errors"

type IAdapter interface {
    GetInvoice() error
}

To hide specific implementations, we make the interface methods unexported and introduce wrapper functions in the base package that invoke the appropriate implementation via an adapter:

var adapter IAdapter

func SetAdapter(a IAdapter) {
    adapter = a
}

func GetInvoice() error {
    if (adapter == nil) {
        return errors.New("No adapter set!")
    }
    return adapter.GetInvoice()
}

While this approach seems promising, it encounters an issue when trying to implement the interface in another package. The compiler complains about not being able to see the unexported GetInvoice method.

This problem stems from the way interfaces work in Go. An interface consists of the method signatures only, with no knowledge of their implementation. When a type implements an interface, it must expose all the methods with the same signatures as the interface.

To overcome this limitation, we can utilize anonymous struct fields:

type Adapter struct {
    accounting.IAdapter
}

This allows us to implement the interface in another package by embedding it anonymously, but we cannot provide custom implementations for the unexported methods.

A more idiomatic solution would be to expose an unexported adapter and provide a registration function in the base package:

package accounting

type IAdapter interface {
    GetInvoice() error
}

---

package accountingsystem

type adapter struct {}

func (a adapter) GetInvoice() error {return nil}  

func SetupAdapter() {
    accounting.SetAdapter(adapter{})
}

---

package main

func main() {
    accountingsystem.SetupAdapter()
}

This approach ensures the adapter remains hidden while still allowing for the registration of an appropriate implementation.

The above is the detailed content of How Can I Implement an Interface with Unexported Methods from Another Go Package?. For more information, please follow other related articles on the PHP Chinese website!