private static void Main(string[] args)
{
var bookServiceHandler = new BookServiceHandler();
var userAccountServiceHandler = new UserAccountServiceHandler();
var bookServiceProcessor = new BookService.Processor(bookServiceHandler);
var userAccountProcessor = new UserAccountService.Processor(userAccountServiceHandler);
var processor = new TMultiplexedProcessor();
processor.RegisterProcessor(nameof(BookService), bookServiceProcessor);
processor.RegisterProcessor(nameof(UserAccountService), userAccountProcessor);
TServerTransport transport = new TServerSocket(9090);
TServer server = new TThreadPoolServer(processor, transport); // TThreadPoolServer accepts multiple clients
Console.WriteLine("Starting the server...");
// Start server on a different background thread so the console continues to be responsive
var serverThread = new Thread(() => server.Serve())
{
IsBackground = true
};
serverThread.Start();
Console.WriteLine("Done. Press any key to stop the server...");
Console.ReadKey(true);
server.Stop();
}
private void InitTransportService()
{
ServiceHandler _serviceHandler = new ServiceHandler();
_serviceHandler._login = _business.Login;
_serviceHandler._logout = _business.Logout;
_serviceHandler._loadCustomers = _business.LoadCustomer;
_serviceHandler._loadOrderItems = _business.LoadOrderItem;
_serviceHandler._loadRegularOrders = _business.LoadRegularOrder;
_serviceHandler._loadIrregularOrders = _business.LoadIrregularOrder;
_serviceHandler._loadSystemConfig = _business.LoadSystemConfig;
_serviceHandler._loadTickets = _business.LoadTicket;
_serviceHandler._createOrder = _business.CreateOrder;
_serviceHandler._deleteOrder = _business.DeleteOrder;
_serviceHandler._updateOrderInfo = _business.UpdateOrderInfo;
_serviceHandler._updateSingleOrderInfo = _business.UpdateSingleOrderInfo;
_serviceHandler._updateTicket = _business.UpdateTicket;
_serviceHandler._insertTicket = _business.InsertTicket;
_serviceHandler._cancelTicket = _business.CancelTicket;
_serviceHandler._syncIrregularOrders = _business.SyncIrregularOrder;
_serviceHandler._syncOrderItems = _business.SyncOrderItem;
_serviceHandler._syncRegularOrders = _business.SyncRegularOrder;
_serviceHandler._syncTickets = _business.SyncTicket;
TransportServer.Processor serverProcessor = new TransportServer.Processor(_serviceHandler);
IPAddress ip = IPAddress.Parse(_serverIP);
TcpListener listener = new TcpListener(ip, _serverPort);
TServerTransport transport = new TServerSocket(listener);
_server = new TThreadPoolServer(serverProcessor, transport);
_server.Serve();
}
/// <summary>
/// The start server.
/// </summary>
/// <param name="inputFile">
/// The input file (vocabulary).
/// </param>
/// <param name="port">
/// The server port.
/// </param>
public void Run(string inputFile, int port)
{
this.reader.AddVocabulary(File.OpenText(inputFile));
try
{
var service = new AutoCompleteServiceImplementation();
TProcessor processor = new AutoCompleteService.Processor(service);
TServerTransport transport = new TServerSocket(port);
this.server = new TThreadPoolServer(
processor,
transport,
new TTransportFactory(),
new TTransportFactory(),
new TBinaryProtocol.Factory(),
new TBinaryProtocol.Factory(),
1,
this.Throughput,
(t) => { });
Logger.Info("The THRIFT server is ready. Listening {0} port ...", port);
this.server.Serve();
}
catch (Exception ce)
{
Logger.Error("An exception occurred: {0}", ce.Message);
}
}
public void Start <T>() where T : class
{
Task.Factory.StartNew(() => {
var tType = typeof(T);
if (!tType.IsInterface || tType.ReflectedType == null)
{
throw new InvalidOperationException(string.Format("{0}不是接口", tType.FullName));
}
var processorTypeName = tType.ReflectedType.FullName + "+Processor";
var processorType = tType.Assembly.GetType(processorTypeName, false);
if (processorType == null)
{
string Info = "没有发现将要向外公开的服务接口,请确保您用的是Thrift生成的服务接口";
throw new InvalidOperationException(string.Format(Info, new object[0]));
}
TServerSocket socket = new TServerSocket(_serverEndPointConfig.Port, ClientTimeoutDefault, false);
TProcessor processor = (TProcessor)ContainerSingleton.Instance.Resolve(processorType);
_server = new TThreadedServer(processor, socket,
new TTransportFactory(),
new TTransportFactory(),
new TCompactProtocol.Factory(),
new TCompactProtocol.Factory(),
MaxThreadsDefault,
new TServer.LogDelegate((str) => {
//写日志。。。。
}));
try
{
_server.Serve();
}
finally
{
}
});
}
public void ThrifTestMethod1()
{
//服务端:开始Thrift rpc服务
new Thread(() =>
{
var processor1 = new HelloThrift.Processor(new HelloThriftHandler());
TMultiplexedProcessor processor = new TMultiplexedProcessor();
processor.RegisterProcessor("HelloThriftHandler", processor1);
var serverTransport = new TServerSocket(9090);
var server1 = new TThreadedServer(processor, serverTransport);
Console.WriteLine("向客户端输出服务开启");
server1.Serve();
}).Start();
//客户端:调用服务端的HelloThrift的HelloWorld方法
TTransport transport = new TSocket("localhost", 9090);
TProtocol protocol = new TBinaryProtocol(transport);
TMultiplexedProtocol mp1 = new TMultiplexedProtocol(protocol, "HelloThriftHandler");
HelloThrift.Client client = new HelloThrift.Client(mp1);
transport.Open();
client.HelloWorld();
client.adding(2, 3);
Console.WriteLine(client.GetData(1));
transport.Close();
}
public void Start2()
{
try
{
// 设置服务端口为7911
TServerSocket serverTransport = new TServerSocket(7911, 0, false);
// 关联处理器与服务的实现
UserService.Processor processor = new UserService.Processor(new MyUserService());
/*
* 创建服务端对象；
*
* 服务端类型
* TSimpleServer —— 单线程服务器端使用标准的阻塞式 I/O，
* TThreadPoolServer —— 多线程服务器端使用标准的阻塞式 I/O。
*
* 由于C#语言的限制无法使用非阻塞的多线程服务端。
* 一般开发使用阻塞式多线程服务端即可。
*
*/
TServer server = new TSimpleServer(processor, serverTransport);
Console.WriteLine("Starting server on port 7911 ...");
server.Serve();
}
catch (TTransportException ex)
{
Console.WriteLine(ex.Message);
}
}
public TransportWindow(ClientController clientController, int port)
{
InitializeComponent();
StartPosition = FormStartPosition.CenterScreen;
ridesView.ReadOnly = true;
bookingsView.ReadOnly = true;
bookingsView.Columns.Cast <DataGridViewColumn>().ToList().ForEach(f => f.SortMode = DataGridViewColumnSortMode.NotSortable);
_clientController = clientController;
_clientController.UpdateEvent += _clientController_UpdateEvent;
NotifyOnEvent();
var clientProcessor = new ITransportObserver.Processor(_clientController);
var processor = new TMultiplexedProcessor();
processor.RegisterProcessor(nameof(ITransportServer.Iface), clientProcessor);
var trasport = new TServerSocket(port);
_server = new TThreadPoolServer(processor, trasport);
FormClosed += (a, b) => {
_clientController.Logout();
_clientController.UpdateEvent -= _clientController_UpdateEvent;
_server.Stop();
};
_updates = Task.Run(() =>
{
_server.Serve();
});
}
static void Main(string[] args)
{
try
{
FileTransferServer transferServer = new FileTransferServer();
FileTransferService.Processor processor = new FileTransferService.Processor(transferServer);
// Set server listening port
TServerTransport serverTransport = new TServerSocket(2320);
// Create server object
TServer server = new TSimpleServer(processor, serverTransport);
Console.WriteLine("Starting is up and running ... ");
// Start server
server.Serve();
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
Console.WriteLine("Server is down");
}
static void Main(string[] args)
{
try
{
//MathServiceImpl handler = new MathServiceImpl();
//MathService.Processor processor = new MathService.Processor(handler);
//TServerTransport serverTransport = new TServerSocket(8088);
//TServer server = new TSimpleServer(processor, serverTransport);
//Console.WriteLine("Starting the server...");
//server.Serve();
TServerSocket serverTransport = new TServerSocket(8088); // 设置服务端口为8088
//Factory factory = new Factory(); // 设置协议工厂为 TBinaryProtocol
TBinaryProtocol.Factory factory = new TBinaryProtocol.Factory();
TTransportFactory transportFactory = new TTransportFactory();
TProcessor processor = new MathService.Processor(new MathServiceImpl());
TServer server = new TThreadPoolServer(processor, serverTransport, transportFactory, factory);
Console.WriteLine($"Starting the server");
server.Serve();
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
Console.WriteLine("Done.");
}
static void Main(string[] args)
{
try
{
//设置服务端口为8080
TServerSocket serverTransport = new TServerSocket(9081);
//设置传输协议工厂
TBinaryProtocol.Factory factory = new TBinaryProtocol.Factory();
//关联处理器与服务的实现
TProcessor helloProcessor = new HelloService.Processor(new MyHelloService());
TProcessor schoolProcessor = new SchoolService.Processor(new MySchoolService());
//创建服务端对象
var processorMulti = new TMultiplexedProcessor();
processorMulti.RegisterProcessor("helloService", helloProcessor);
processorMulti.RegisterProcessor("schoolService", schoolProcessor);
TServer server = new TThreadPoolServer(processorMulti, serverTransport, new TTransportFactory(), factory);
Console.WriteLine("服务端正在监听9081端口");
server.Serve();
}
catch (TTransportException ex)//捕获异常信息
{
//打印异常信息
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// 要注册的服务器列表，注意一个服务只能注册一次，否则会失败（port不能重复注册）
/// </summary>
/// <param name="servers"></param>
public void Register(SuperGMSServer[] servers)
{
try
{
if (servers == null || servers.Length < 1)
{
throw new Exception("no Server can Register");
}
foreach (SuperGMSServer s in servers)
{
TServerSocket serverTransport = new TServerSocket(s.Config.Port);
TBinaryProtocol.Factory factory = new TBinaryProtocol.Factory();//传输协议
TProcessor processor = new ThriftService.Processor(s.Server);
TServer server = new TThreadPoolServer(processor, serverTransport, new TTransportFactory(), factory);
}
}
catch (TTransportException tex)
{
//等log组件改造完之后再记录
}
catch (Exception ex)
{
//等log组件改造完之后再记录
}
}
public void Start()
{
TServerSocket serverTransport = new TServerSocket(7911, 0, true);
Thrift.Protocol.TMultiplexedProcessor processor = new Thrift.Protocol.TMultiplexedProcessor();
processor.RegisterProcessor("SecondService", new SecondService.Processor(new SecondServiceImpl()));
processor.RegisterProcessor("ThriftTest", new ThriftTest.Processor(new ThriftTestImpl()));
//Impl.ThriftTestImpl handler = new ThriftTestImpl();
//ThriftTest.Processor processor = new ThriftTest.Processor(handler);
// TServer server = new TSimpleServer(processor, serverTransport);
TServer server = new TThreadPoolServer(
processor,
serverTransport,
new TFramedTransport.Factory(),
new TBinaryProtocol.Factory());
// TServer server = new TThreadPoolServer(processor, serverTransport);
Console.WriteLine("Starting server on port 7911 ...");
server.Serve();
}
static void Main(string[] args)
{
try
{
int ServerPort = int.Parse(System.Configuration.ConfigurationManager.AppSettings["ThriftServerPort"]);
//设置服务端口
TServerSocket serverTransport = new TServerSocket(ServerPort);
//设置传输协议工厂
TBinaryProtocol.Factory factory = new TBinaryProtocol.Factory();
//关联处理器与服务的实现
TProcessor processor = new QuesService.Processor(new Question());
//创建服务端对象
TServer server = new TThreadPoolServer(processor, serverTransport, new TTransportFactory(), factory);
Console.WriteLine("试题服务端正在监听" + ServerPort + "端口");
server.Serve();
Console.ReadLine();
}
catch (TTransportException ex)
{
//打印异常信息
Console.WriteLine(ex.Message);
}
}
static void Execute(int port)
{
try
{
// create protocol factory, default to BinaryProtocol
TProtocolFactory ProtocolFactory = new TBinaryProtocol.Factory(true, true);
TServerTransport servertrans = new TServerSocket(port, 0, false);
TTransportFactory TransportFactory = new TFramedTransport.Factory();
BenchmarkService.Iface benchHandler = new BenchmarkServiceImpl();
TProcessor benchProcessor = new BenchmarkService.Processor(benchHandler);
Aggr.Iface aggrHandler = new AggrServiceImpl();
TProcessor aggrProcessor = new Aggr.Processor(aggrHandler);
TMultiplexedProcessor multiplex = new TMultiplexedProcessor();
multiplex.RegisterProcessor(Constants.NAME_BENCHMARKSERVICE, benchProcessor);
multiplex.RegisterProcessor(Constants.NAME_AGGR, aggrProcessor);
TServer ServerEngine = new TSimpleServer(multiplex, servertrans, TransportFactory, ProtocolFactory);
Console.WriteLine("Starting the server ...");
ServerEngine.Serve();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
static void Main(string[] args)
{
TServerTransport transport = new TServerSocket(8800); //监听8800端口
var processor = new UserService.Processor(new UserServiceImpl()); //设置实现类
TServer server = new TThreadPoolServer(processor, transport);
server.Serve();
}
static void Main(string[] args)
{
TimeServiceImplementation service = new TimeServiceImplementation();
TProcessor processor = new TimeService.Processor(service);
TServerTransport transport = new TServerSocket(1337, 1000);
TServer server = new TSimpleServer(processor, transport);
server.Serve();
}
public static void Run(Iface processor, int port)
{
var pc =
new Processor(processor);
var serverTransport = new TServerSocket(port);
var server = new TThreadPoolServer(pc, serverTransport);
server.Serve();
}
internal SimpleServer(int port)
{
TSampleService.Iface remoteService = new SampleService(port);
TServerTransport transport = new TServerSocket(port);
var processor = new TSampleService.Processor(remoteService);
server = new TSimpleServer(processor, transport);
}
public static void Start()
{
ThriftConfig tc = ThriftConfig.CreateInstance();
TServerSocket serverTransport = new TServerSocket(tc.Port, 0, true);
BrokerCenter.Processor processor = new BrokerCenter.Processor(new BusinessImpl());
_server = new TThreadedServer(processor, serverTransport,Log.Log.ConsoleWriteLine,200);
new Thread(_server.Serve) { IsBackground = true }.Start();//开启业务服务
State = true;
}
private void RunServer(PatientServiceThrift.Processor processor)
{
TServerTransport serverTransport = new TServerSocket(9090);
TServer server = new TSimpleServer(processor, serverTransport);
System.Console.WriteLine("Started server...");
server.Serve();
server.Stop();
}
public void Start(int port = 10001)
{
SpeakService.Processor processor = new SpeakService.Processor(Instance);
TServerTransport transport = new TServerSocket(port);
TServer server = new TThreadPoolServer(processor, transport);
Console.WriteLine("server 10001 starting...");
server.Serve();
transport.Close();
}
private static void ThreadStartPoint()
{
GrafoCB hwServer = new GrafoCB(true);
GrafoService.Processor processor = new GrafoService.Processor(hwServer);
TServerTransport serverTransport = new TServerSocket(Convert.ToInt16(VariaveisGlobais.servidorLocal.Porta));
TServer server = new TThreadPoolServer(processor, serverTransport);
server.Serve();
}
public static void Start(int port)
{
TServerSocket serverTransport = new TServerSocket(port, 0, false);
ThriftOperation.Processor processor = new ThriftOperation.Processor(new demo());
TServer server = new TSimpleServer(processor, serverTransport);
Console.WriteLine("Starting server on port {0} ...", port);
server.Serve();
}
public void Start()
{
TServerSocket serverTransport = new TServerSocket(7911, 0, false);
MyDemo.Processor processor = new MyDemo.Processor(new SImpl());
TServer server = new TSimpleServer(processor, serverTransport);
Console.WriteLine("Starting server on port 7911 ...");
server.Serve();
}
/// <summary>
/// Starts the adapter server
/// </summary>
public void Start()
{
//Create a new server transport
TServerTransport serverTransport = new TServerSocket(this.port);
//Use a multithreaded server
this.server = new TThreadPoolServer(this.processor, serverTransport, new BufferedTransportFactory(), new TCompactProtocol.Factory());
this.server.Serve();
}
private static void StartServer()
{
var handler = new GameUiHandler();
var processor = new GameUi.Processor(handler);
var serverTransport = new TServerSocket(9090);
var server = new TSimpleServer(processor, serverTransport);
Console.WriteLine("Starting Platform Server");
server.Serve();
}
static void Main(string[] args)
{
TServerSocket serverTransport = new TServerSocket(7911, 0, false);
ThriftCase.Processor processor = new ThriftCase.Processor(new BusinessImpl());
TServer server = new TSimpleServer(processor, serverTransport);
Console.WriteLine("Starting server on port 7911 ...");
server.Serve();
}
public SocketServer(int port) : base(port)
{
CallFuncThriftEx <T> handler = new CallFuncThriftEx <T>();
CallFuncThrift.Processor processor = new CallFuncThrift.Processor(handler);
TServerTransport serverTransport = new TServerSocket(port);
server = new TThreadPoolServer(processor, serverTransport);
Logger.log("创建ThriftServer", $"端口号:{port}");
}
static void Main(string[] args)
{
var handler = new LibraryServiceHandler();
var processor = new LibraryService.Processor(handler);
TServerTransport transport = new TServerSocket(9090);
TServer server = new TThreadPoolServer(processor, transport);
server.Serve();
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
Console.Title = "Thrift服务端-Server";
TServerSocket serverTransport = new TServerSocket(8899, 0, false);
UserService.Processor processor = new UserService.Processor(new Services.TheUserService());
TServer server = new TSimpleServer(processor, serverTransport);
Console.WriteLine("启动服务器，监听端口8899 ...");
server.Serve();
}
