Spring集成Thrift - Servlet

最新推荐文章于 2024-03-05 10:34:36 发布
最新推荐文章于 2024-03-05 10:34:36 发布
阅读量8.9k 收藏 3
点赞数 1
分类专栏： RPC /SOA/分布式 RPC之Thrift学习实战 文章标签： RPC thrift
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhu_tianwei/article/details/44005181
版权

Thrift除了可以通过TCP协议访问，还可以通过HTTP/HTTPS协议访问，在java中，thrift提供了一个servlet：org.apache.thrift.server.TServlet，我们只需继承这个TServlet就可以很方便的将TCP服务转换成HTTP/HTTPS服务，下面我们仍然以前面的helloworld接口与实现为例演示。

1.导入所需的jar包

<dependency>
			<groupId>org.apache.thrift</groupId>
			<artifactId>libthrift</artifactId>
			<version>0.9.2</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.5.8</version>
		</dependency>
		<dependency>
			<groupId>commons-pool</groupId>
			<artifactId>commons-pool</artifactId>
			<version>1.6</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.0.9.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-expression</artifactId>
			<version>4.0.9.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>4.0.9.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.0.9.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>4.0.9.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>commons-fileupload</groupId>
			<artifactId>commons-fileupload</artifactId>
			<version>1.3.1</version>
		</dependency>
2.配置工程的web.xml 

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="WebApp_ID" version="2.5">
	<display-name>ThriftTest</display-name>

	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			classpath:applicationContext-*.xml
		</param-value>
	</context-param>
	
	<filter>
		<filter-name>characterEncoding</filter-name>
		<filter-class>
			org.springframework.web.filter.CharacterEncodingFilter
		</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>characterEncoding</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
	
	<servlet>
		<servlet-name>dispatcherServlet</servlet-name>
		<servlet-class>
			org.springframework.web.servlet.DispatcherServlet
		</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	
	<servlet-mapping>
		<servlet-name>dispatcherServlet</servlet-name>
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>
	
	<listener>
		<listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
	</listener>
 
	<session-config>
		<session-timeout>30</session-timeout>
	</session-config>
	
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
	</welcome-file-list>
	
</web-app>
3.配置spring mvc的dispatcherServlet-servlet.xml 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:util="http://www.springframework.org/schema/util" xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:tool="http://www.springframework.org/schema/tool" xmlns:cache="http://www.springframework.org/schema/cache"
	xsi:schemaLocation="
			http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
			http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
			http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
			http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
			http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd
			http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
			http://www.springframework.org/schema/tool http://www.springframework.org/schema/tool/spring-tool-4.0.xsd
			http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.0.xsd"
	default-lazy-init="true">

	<!-- 定义视图查找规则 -->
	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="viewClass"
			value="org.springframework.web.servlet.view.JstlView">
		</property>
		<property name="prefix" value="/WEB-INF/jsp/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>

	<!-- 定义注解驱动Controller方法处理适配器 -->
	<bean
		class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />

	<bean id="localeResolver"
		class="org.springframework.web.servlet.i18n.SessionLocaleResolver" />

	<!-- 定义文件上传处理器 -->
	<bean id="multipartResolver"
		class="org.springframework.web.multipart.commons.CommonsMultipartResolver"
		p:defaultEncoding="UTF-8" />

	<!-- 定义本地化变更拦截器 -->
	<bean id="localeChangeInterceptor"
		class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor" />

	<util:list id="interceptors">
		<ref bean="localeChangeInterceptor" />
	</util:list>

	<!-- 定义注解URL映射处理器 -->
	<bean id="urlMapping"
		class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">
		<property name="interceptors" ref="interceptors" />
		<property name="order" value="1" />
	</bean>
</beans>

继承TServlet实现

1、服务端

1）TServlet实现类HelloworldServlet.java 
package cn.slimsmart.thrift.demo.spring.servlet;

import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.server.TServlet;

import cn.slimsmart.thrift.demo.helloworld.HelloWorld;

/**
 * 服务端TServlet
 */
public class HelloworldServlet extends TServlet {

	private static final long serialVersionUID = 1L;

	public HelloworldServlet(HelloWorld.Iface helloWorldImpl) {
		super(new HelloWorld.Processor<HelloWorld.Iface>(helloWorldImpl) , new TCompactProtocol.Factory());
	}
}
2）配置applicationContext-servlet.xml 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
				http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd"
	default-lazy-init="true">
	
	<description>thrift-servlet服务</description>
	
	 <!-- servlet适配器，这里必须明确声明，因为spring默认没有初始化该适配器 -->  
    <bean id="servletHandlerAdapter" class="org.springframework.web.servlet.handler.SimpleServletHandlerAdapter"/>  
    
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">
		<property name="order" value="2" />
	</bean>
    
    <bean  id="helloWorldImpl" class="cn.slimsmart.thrift.demo.helloworld.HelloWorldImpl"/>
    
    <!-- servlet -->  
    <bean name="/helloworldServlet.do" class="cn.slimsmart.thrift.demo.spring.servlet.HelloworldServlet"> 
    	<constructor-arg>
    		<ref bean="helloWorldImpl"/>
    	</constructor-arg>  
    </bean>	
</beans>
3）启动tomcat服务
4）客户端调用测试
HelloWorldServletTest.java
 
package cn.slimsmart.thrift.demo.spring.servlet;

import org.apache.http.HttpVersion;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.BasicClientConnectionManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.CoreProtocolPNames;
import org.apache.http.params.HttpConnectionParams;
import org.apache.thrift.TException;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.THttpClient;
import org.apache.thrift.transport.TTransportException;

import cn.slimsmart.thrift.demo.helloworld.HelloWorld;

public class HelloWorldServletTest {

	public static void main(String[] args) {
		String url = "http://127.0.0.1:8080/thrift-demo/helloworldServlet.do";
		
		BasicHttpParams params = new BasicHttpParams();
		params.setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
		params.setParameter(CoreProtocolPNames.HTTP_CONTENT_CHARSET, "UTF-8");
		// Disable Expect-Continue
		params.setParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE, false);
		// Enable staleness check
		params.setParameter("http.connection.stalecheck", true);
		HttpConnectionParams.setSoTimeout(params, 10000); // 10 secondes
		HttpConnectionParams.setConnectionTimeout(params, 10000); // 10 secondes

		SchemeRegistry schemeRegistry = new SchemeRegistry();
		schemeRegistry.register(new Scheme("http", 8080, PlainSocketFactory.getSocketFactory()));
		schemeRegistry.register(new Scheme("https", 443, SSLSocketFactory.getSocketFactory()));
		BasicClientConnectionManager cm = new BasicClientConnectionManager(schemeRegistry);
		THttpClient thc = null;
		try {
			thc = new THttpClient(url, new DefaultHttpClient(cm, params));
			TProtocol loPFactory = new TCompactProtocol(thc);
			HelloWorld.Client client = new HelloWorld.Client(loPFactory);
			System.out.println(client.sayHello("Jack"));
		} catch (TTransportException e) {
			e.printStackTrace();
		} catch (TException e) {
			e.printStackTrace();
		}
	}

}

2、客服端

通过代理实现

1、服务端

服务端代理ThriftServletServerProxy.java 
package cn.slimsmart.thrift.demo.spring.servlet;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.thrift.TException;
import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.protocol.TProtocolFactory;
import org.apache.thrift.transport.TIOStreamTransport;
import org.apache.thrift.transport.TTransport;
import org.springframework.util.StringUtils;

@SuppressWarnings("serial")
public class ThriftServletServerProxy extends HttpServlet {

	private final TProcessor processor;

	private final TProtocolFactory inProtocolFactory;

	private final TProtocolFactory outProtocolFactory;

	private final Collection<Map.Entry<String, String>> customHeaders;

	@SuppressWarnings({ "rawtypes", "unchecked" })
	public ThriftServletServerProxy(String serviceInterface, String serviceIface,
			Object serviceImplObject) throws Exception {
		super();

		Class Processor = Class.forName(serviceInterface + "$Processor");
		Class Iface = Class
				.forName(StringUtils.hasText(serviceIface) ? serviceIface
						: serviceInterface + "$Iface");
		Constructor con = Processor.getConstructor(Iface);
		TProcessor processor = (TProcessor) con.newInstance(serviceImplObject);

		this.processor = processor;
		this.inProtocolFactory = new TCompactProtocol.Factory();
		this.outProtocolFactory = new TCompactProtocol.Factory();
		this.customHeaders = new ArrayList<Map.Entry<String, String>>();

	}
	
	public ThriftServletServerProxy(String serviceInterface,
			Object serviceImplObject) throws Exception {
		this(serviceInterface,null,serviceImplObject);

	}

	/**
	 * @see HttpServlet#HttpServlet()
	 */
	public ThriftServletServerProxy(TProcessor processor,
			TProtocolFactory inProtocolFactory,
			TProtocolFactory outProtocolFactory) {
		super();
		this.processor = processor;
		this.inProtocolFactory = inProtocolFactory;
		this.outProtocolFactory = outProtocolFactory;
		this.customHeaders = new ArrayList<Map.Entry<String, String>>();
	}

	/**
	 * @see HttpServlet#HttpServlet()
	 */
	public ThriftServletServerProxy(TProcessor processor,
			TProtocolFactory protocolFactory) {
		this(processor, protocolFactory, protocolFactory);
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
	 *      response)
	 */
	@Override
	protected void doPost(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		TTransport inTransport = null;
		TTransport outTransport = null;

		try {
			response.setContentType("application/x-thrift");

			if (null != this.customHeaders) {
				for (Map.Entry<String, String> header : this.customHeaders) {
					response.addHeader(header.getKey(), header.getValue());
				}
			}
			InputStream in = request.getInputStream();
			OutputStream out = response.getOutputStream();

			TTransport transport = new TIOStreamTransport(in, out);
			inTransport = transport;
			outTransport = transport;

			TProtocol inProtocol = inProtocolFactory.getProtocol(inTransport);
			TProtocol outProtocol = outProtocolFactory
					.getProtocol(outTransport);

			processor.process(inProtocol, outProtocol);
			out.flush();
		} catch (TException te) {
			throw new ServletException(te);
		}
	}

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse
	 *      response)
	 */
	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		doPost(request, response);
	}

	public void addCustomHeader(final String key, final String value) {
		this.customHeaders.add(new Map.Entry<String, String>() {
			public String getKey() {
				return key;
			}

			public String getValue() {
				return value;
			}

			public String setValue(String value) {
				return null;
			}
		});
	}

	public void setCustomHeaders(Collection<Map.Entry<String, String>> headers) {
		this.customHeaders.clear();
		this.customHeaders.addAll(headers);
	}

}
在applicationContext-servlet.xml添加如下配置： 
<!-- servlet proxy -->  
    <bean name="/helloworldServletProxy.do" class="cn.slimsmart.thrift.demo.spring.servlet.ThriftServletServerProxy"> 
    	<constructor-arg index="0" value="cn.slimsmart.thrift.demo.helloworld.HelloWorld"/>
    	<constructor-arg>
    		<ref bean="helloWorldImpl"/>
    	</constructor-arg>  
    </bean>

启动tomcat服务。

2、客户端

1）客户端代理ThriftServletClientProxy.java 
package cn.slimsmart.thrift.demo.spring.servlet;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import org.apache.http.HttpVersion;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.params.ConnPerRouteBean;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.BasicClientConnectionManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.CoreProtocolPNames;
import org.apache.http.params.HttpConnectionParams;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.THttpClient;
import org.apache.thrift.transport.TTransportException;

@SuppressWarnings("deprecation")
public class ThriftServletClientProxy {

	/**
	 * servlet 地址
	 */
	private String servletUrl;

	public String getServletUrl() {
		return servletUrl;
	}

	public void setServletUrl(String servletUrl) {
		this.servletUrl = servletUrl;
	}

	/**
	 * thrift 接口
	 */
	private String serviceInterface;

	public String getServiceInterface() {
		return serviceInterface;
	}

	public void setServiceInterface(String serviceInterface) {
		this.serviceInterface = serviceInterface;
	}

	private static BasicHttpParams params;

	static {
		params = new BasicHttpParams();
		params.setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
		params.setParameter(CoreProtocolPNames.HTTP_CONTENT_CHARSET, "UTF-8");
		// Disable Expect-Continue
		params.setParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE, false);
		// Enable staleness check
		params.setParameter("http.connection.stalecheck", true);
		HttpConnectionParams.setSoTimeout(params, 10000); // 10 secondes
		HttpConnectionParams.setConnectionTimeout(params, 10000); // 10 secondes
		ConnManagerParams.setMaxTotalConnections(params, 20);
		ConnPerRouteBean connPerRoute = new ConnPerRouteBean(20);
		ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute);

	}

	@SuppressWarnings({ "rawtypes", "unchecked" })
	public Object getClient() {
		Object object = null;
		try {
			BasicClientConnectionManager cm = new BasicClientConnectionManager(getSchemeRegistry());
			THttpClient thc = new THttpClient(getServletUrl(), new DefaultHttpClient(cm, params));
			TProtocol loPFactory = new TCompactProtocol(thc);
			Class client = Class.forName(getServiceInterface() + "$Client");
			Constructor con = client.getConstructor(TProtocol.class);
			object = con.newInstance(loPFactory);
		} catch (TTransportException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		return object;
	}

	public SchemeRegistry getSchemeRegistry() {
		SchemeRegistry schemeRegistry = new SchemeRegistry();
		URL url;
		try {
			// 分析url，取出端口
			url = new URL(getServletUrl());
			String protocol = url.getProtocol();
			int port = url.getPort();
			if (-1 == port) {
				if ("https".equals(protocol)) {
					port = 443;
				} else {
					port = 80;
				}
			}
			if ("https".equals(protocol)) {
				schemeRegistry.register(new Scheme("https", port, SSLSocketFactory.getSocketFactory()));
			} else {
				schemeRegistry.register(new Scheme("http", port, PlainSocketFactory.getSocketFactory()));
			}
		} catch (MalformedURLException e) {
			e.printStackTrace();
		}
		return schemeRegistry;
	}
}
2）spring配置applicationContext-servlet-client.xml 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
				http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
				http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd"
	default-lazy-init="true">
	<description>thrift配置文件 </description>
	<bean id="thriftServletClientProxy" class="cn.slimsmart.thrift.demo.spring.servlet.ThriftServletClientProxy">
		<property name="servletUrl">
			<value>
				http://127.0.0.1:8080/thrift-demo/helloworldServletProxy.do
			</value>
		</property>
		<property name="serviceInterface" value="cn.slimsmart.thrift.demo.helloworld.HelloWorld">
		</property>
	</bean>
</beans>
3）测试启动类
HelloWorldServletProxyTest.java 
package cn.slimsmart.thrift.demo.spring.servlet;

import org.apache.thrift.TException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.slimsmart.thrift.demo.helloworld.HelloWorld;

public class HelloWorldServletProxyTest {
	@SuppressWarnings("resource")
	public static void main(String[] args) throws TException {
		ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/servlet/applicationContext-servlet-client.xml");
		ThriftServletClientProxy thriftServletClientProxy = (ThriftServletClientProxy)context.getBean(ThriftServletClientProxy.class);
		HelloWorld.Iface client = (HelloWorld.Iface)thriftServletClientProxy.getClient();
		System.out.println(client.sayHello("han meimei"));
	}
}
slimina
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
Spring集成Thrift--Server AND Client
04-22
NULL 博文链接：https://hanqunfeng.iteye.com/blog/1936556
spring-thrift-starter：一组很酷的注释，可帮助您使用Spring Boot构建Thrift应用程序
01-30
如何连接项目非常简单： repositories { jcenter()}compile ' info.developerblog.spring.thrift:spring-thrift-starter:+ '如何使用服务器端注释@ThriftController（“ servlet_path”）帮助您构建服务器控制器以...
使用 Thrift 进行文件传输
JiangMengYa
07-25 1万+
这里简单展现一下 Thrift 的文件传输功能
Thrift、Dubbo、Spring Cloud 和 gRPC
爱琴孩的博客
09-09 408
Thrift、Dubbo、Spring Cloud 和 gRPC 都是现代软件开发中广泛使用的开源框架，它们在分布式系统开发中扮演着重要的角色。
揭秘Thrift：高效、可扩展的跨语言通信框架（一）
最新发布
凛鼕将至的博客
03-05 939
Thrift是一种高效、可扩展的跨语言通信框架，最初由Facebook开发并开源。它旨在简化不同编程语言之间的通信，使得不同的系统能够无缝地交换数据。Thrift通过定义一种中立的接口描述语言（IDL）来实现跨语言通信。开发人员可以使用IDL描述数据结构和服务接口，并使用Thrift编译器将IDL文件转换为各个目标语言的可用代码。这样，不同语言的应用程序就可以通过Thrift框架进行通信，而无需关注底层实现细节。Thrift提供了一套丰富的数据类型和通信协议，使得开发者可以轻松定义和传输复杂的数据结构。
Thrift在Tomcat中以Servlet运行
Leon's Blog——Study Notes
11-03 778
Thrift在Tomcat中以Servlet运行创建Servlet继承自TServlet 创建Servlet继承自TServlet 以前在将Thrift服务在Tomcat中以Servlet运行时，需要自己实现协议转换的“中间”Servlet，现在只需要继承org.apache.thrift.server.TServlet就可以，（Thrift的基本知识在此不再冗述，读者可自己查看github。此处...
thrift servlet
specialsun的专栏
08-01 188
  Thrift通常以独立服务存在，也支持HTTP协议，以servlet方式在Tomcat中运行。   一. 服务端Servlet 实现比较简单，只需实现TExtensibleServlet，并在getProcessor()中填充实现类。 /** * Thrift servlet */ @WebServlet(name="thrifttest",value="/thriftt...
微服务网关选型，请收下我的膝盖!
石杉的架构笔记
02-14 1015
「关注“石杉的架构笔记”，大厂架构经验倾囊相授」儒猿技术团队最新出品《基于ShardingSphere的分库分表实战》文章来源：【公众号：楼仔】| 常用API网关的对比和选型，并讲解...
spring-cloud-starter-thrift:spring-cloud-starter-thrift提供SpringCloud对可伸缩的跨语言服务调用框架Apache Thrift的封装和集成
05-06
spring-cloud-starter-thrift包括客户端spring-cloud-starter-thrift-client和服务端spring-cloud-starter-thrift-server两个模块。服务端：支持Apache Thrift的各种原生服务线程模型，包括单线程阻塞模型(simple)、...
spring-thrift-integration:示例如何将Thrift集成到Spring应用程序中
05-17
这是一个示例，展示了如何在不使用Spring Boot的情况下将集成到Spring应用程序中。 相反，它依赖于Spring的WebApplicationInitializer类，因此不需要web.xml。 如何建造 让Maven编译代码： mvn compile 如果出现...
Thrift和Spring集成
peng.zhou
09-28 1292
1.服务端通过TMultiplexedProcessor同时暴露多个服务 /** * Thrift通用服务启动类 可以和spring集成 */ public class CommonServerDemo { private int port; private MapString, Object> exposedServerMap; public Common
spring与thrift集成
08-14
http://my.oschina.net/penngo/blog/492253文章源码
thrift服务集成spring及连接池
04-01
thrift是为了解决facebook系统中各系统间大数据量的传输通信以及系统之间语言环境不同需要跨平台的特性。thrift服务支持多种程序语言。比webservice简单方便。thrift集成spring。thrift集成连接池。使通信服务更简单。
Thrift-server与spring集成
08-03
NULL 博文链接：https://shift-alt-ctrl.iteye.com/blog/1990026
Thrift--Spring集成ThriftServlet
hanqunfeng的专栏
09-25 118
Thrift除了可以通过TCP协议访问，还可以通过HTTP/HTTPS协议访问，在java中，thrift提供了一个servlet：org.apache.thrift.server.TServlet，我们只需继承这个TServlet就可以很方便的将TCP服务转换成HTTP/HTTPS服务，参考http://hanqunfeng.iteye.com/blog/1936556，为其中的Contra...
java thrift servlet_thrift的使用—servlet服务器端与as3客户端通信
weixin_27918373的博客
02-13 78
项目一直有用到thrift这东西，thrift的介绍网上也挺多的。描述：thrift是一个软件框架，用来进行可扩展且跨语言的服务的开发。它结合了功能强大的软件堆栈和代码生成引擎，以构建在 C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, and OCaml ...
java thrift spring_[转载] Thrift-server与spring集成
weixin_42117622的博客
02-16 89
转载自http://shift-alt-ctrl.iteye.com/blog/1990026Thrift服务server端,其实就是一个ServerSocket线程 + 处理器,当Thrift-client端建立链接之后,处理器负责解析socket流信息,并根据其指定的"方法名"+参数列表,来调用"服务实现类"的方法,并将执行结果(或者异常)写入到socket中.一个server,就需要创建一个...
2019年分布式架构教程 SpringCloud+Docker基础入门到实战
08-31
<p><img src="https://img-bss.csdnimg.cn/202102041018548151.png" alt="" /></p> <p><img src="https://img-bss.csdnimg.cn/202102041019016789.png" alt="" /></p> <p><img src="https://img-bss.csdnimg.cn/202102041019154356.png" alt="" /></p> <p><img src="https://img-bss.csdnimg.cn/202102041019238874.png" alt="" /></p>
SpringBoot整合RPC框架---Thrift
热门推荐
一行Java的博客
09-18 1万+
文章目录什么是Thrift架构支持的通讯协议支持的传输协议支持的服务模型Thrift的优点SpringBoot整合Thrift为什么会出现RPC框架常见的RPC框架集成套路开撸官网下载代码生成工具本示例模拟的业务场景编写接口代码生成文件thrift-server服务thrift-client客户端服务 什么是Thrift Thrift是一种接口描述语言和二进制通讯协议，它被用来定义和创建跨语言的服...
iotdb-thrift-commons: thrift did not exit cleanly.
02-06
iotdb-thrift-commons 是一个用于在 Apache Thrift 和 IoTDB 之间进行通信的 Java 库。如果你看到 "thrift did not exit cleanly" 的消息，这意味着在 Thrift 进程结束时发生了意外错误。这可能是由于网络问题、资源...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值