How to use Interface FilterFactory class of org.junit.runner package

private PeerConnection peerConnection;

private VideoRenderer.Callbacks remoteRender;
private final PCObserver pcObserver = new PCObserver();
private final SDPObserver sdpObserver = new SDPObserver();
private PeerConnection peerConnection;
private LinkedList<IceCandidate> queuedRemoteCandidates;
private boolean isInitiator;
private SessionDescription localSdp;
private VideoTrack remoteVideoTrack;

@SpringBootApplication
public class So66993561Application {

    public static void main(String[] args) {
        SpringApplication.run(So66993561Application.class, args);
    }

    @Bean
    AbstractServerConnectionFactory server() {
        return Tcp.netServer(1234)
                .deserializer(TcpCodecs.lf())
                .serializer(TcpCodecs.lf())
                .get();
    }

    @Bean
    AbstractClientConnectionFactory client() {
        return Tcp.netClient("localhost", 1235)
                .deserializer(TcpCodecs.lf())
                .serializer(TcpCodecs.lf())
                .get();
    }

    @Bean
    IntegrationFlow serverInbound(AbstractServerConnectionFactory server) {
        return IntegrationFlows.from(Tcp.inboundAdapter(server))
                .transform(Transformers.objectToString())
                .handle("service", "sendToNCL")
                .get();
    }

    @Bean
    IntegrationFlow serverOutbound(AbstractServerConnectionFactory server) {
        return IntegrationFlows.from(ServerGateway.class)
                .handle(Tcp.outboundAdapter(server))
                .get();
    }

    @Bean
    IntegrationFlow clientInbound(AbstractClientConnectionFactory client) {
        return IntegrationFlows.from(Tcp.inboundAdapter(client))
                .transform(Transformers.objectToString())
                .handle("service", "broadcastToClients")
                .get();
    }

    @Bean
    IntegrationFlow clientOutbound(AbstractClientConnectionFactory client) {
        return IntegrationFlows.from(ClientGateway.class)
                .handle(Tcp.outboundAdapter(client))
                .get();
    }

    @Bean
    @DependsOn("clientOutbound")
    public ApplicationRunner runner(AbstractClientConnectionFactory client) {
        return args -> {
            System.out.println("Hit enter when netcat is running");
            System.in.read(); // nc -l 1235
            client.getConnection(); // just open the connection.
        };
    }

}

interface ServerGateway {

    @Gateway(payloadExpression = "#args[0]",
            headers = @GatewayHeader(name = IpHeaders.CONNECTION_ID, expression = "#args[1]" ))
    void send(String out, String connectionId);

}

interface ClientGateway {

    void send(String out);

}

@Component
@DependsOn({ "clientOutbound", "serverOutbound" })
class Service {

    private final Set<String> serverClients = ConcurrentHashMap.newKeySet();

    private final ClientGateway client;

    private final ServerGateway server;

    private volatile boolean clientOpen;

    public Service(ClientGateway client, ServerGateway server) {
        this.client = client;
        this.server = server;
    }

    public void broadcastToClients(String in) {
        System.out.println("received from server: " + in);
        this.serverClients.forEach(client -> {
            try {
                this.server.send(in, client);
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        });
    }

    public void sendToNCL(String in) {
        System.out.println("received from a client: " + in);
        if (this.clientOpen) {
            try {
                this.client.send(in);
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    @EventListener
    public void opens(TcpConnectionOpenEvent event) {
        System.out.println(event);
        if (event.getConnectionFactoryName().equals("server")) {
            this.serverClients.add(event.getConnectionId());
        }
        else {
            this.clientOpen = true;
        }
    }

    @EventListener
    public void closes(TcpConnectionCloseEvent event) {
        System.out.println(event);
        this.serverClients.remove(event.getConnectionId());
        if (event.getConnectionFactoryName().equals("client")) {
            this.clientOpen = false;
        }
    }

}