技术标签: Dubbo 实现分析 java rpc
Dubbo 泛化调用、阿里的好舒服的泛化调用都是类似的功能。最近给同事排查一个dubbo-admin 控制台调用报错的问题的小研究,为此还给社区提了一个issue,具体可以查看链接 dubbo-admin 泛型参数测试 ClassNotFoundException 看了最新版本好像自动去掉了出现泛型<这样的信息通通干掉,不过没有发布release版本。 参考文档:使用泛化调用
泛化接口调用方式主要用于客户端没有 API 接口(泛化调用是指不需要依赖服务的二方包)及模型类元的情况,参数及返回值中的所有 POJO 均用 Map 表示,通常用于框架集成,API网关比如:实现一个通用的服务测试框架,可通过 GenericService 调用所有服务实现。泛化调用的方式可以有效减少平台型产品的二方包依赖,实现系统的轻量级运行。对于服务提供方新增的接口不需要修改二方包的版本,即可调用,不方便的就是对于数据入参、返回值由于没有二方包很难理解,全部都是org.apache.dubbo.common.utils.PojoUtils#generalize(java.lang.Object) 转换为基本类型或者Map等等。
PojoUtils. Travel object deeply, and convert complex type to simple type. (深度遍历对象,并将复杂类型转换为简单类型),同时也提供了反向转换。
Simple type below will be remained:
PojoUtils 提供了讲复杂对象转换为简单的对象,通过简单对象转换为复杂对象。有点像序列化和反序列话,你要说它是不是,感觉也没错哈!官方的测试例子不错,可以去了解一下
List<User> users = new ArrayList<>();
User user = new User();
user.setName("other");
user.setAge(31);
users.add(user);
Object generalize = PojoUtils.generalize(users);
System.out.println(generalize);
//[{name=other, class=org.apache.dubbo.samples.Dto.User, age=31}]
基于官方demo 中 dubbo-samples-zookeper,本地安装一个zk 即可启动
https://github.com/apache/dubbo-samples/tree/master/java/dubbo-samples-zookeeper
泛化调用最好的一个参考例子就是dubbo-admin 中 ,通过泛化进行控制台的调用实践,泛化没有二方包,服务提供方的方法参数类型无法直接使用强类型表示,传递的参数也无法直接使用强类型只能通过 参考 :PojoUtils 序列化 Object generalize = PojoUtils.generalize(data) 例子传递 Map、List 、Array 等基本类型的参数
eg List -> [{name=other, age=31, class=org.apache.dubbo.samples.Dto.User}] 就是List<HashMap<String,String> 这样的结构**,中增加 class 字段信息,反序列化时候使用表征对应的泛型的信息,或者类class的信息**。
为啥需要这些,就是为了找到具体的接口的提供者、接口的具体的方法是哪个?调用传递的参数是啥,即可享受正常的调用逻辑。如下是dubbo-admin 控制台实践指南,Dubbo API 网关也是类似的概念哦!只要通过配置或者传递参数中有如下的概念即可搞定问题。
泛化泛化的结果:也是基本类型的数据,根据 PojoUtils.generalize(result) 根据result 进行Pojo作为泛化的结果。如下是 dubbo-admin 控制台测试的代码
https://github.com/apache/dubbo-admin/blob/develop/dubbo-admin-server/src/main/java/org/apache/dubbo/admin/service/impl/GenericServiceImpl.java
public Object invoke(String service, String method, String[] parameterTypes, Object[] params) {
ReferenceConfig<GenericService> reference = new ReferenceConfig<>();
String group = Tool.getGroup(service);
String version = Tool.getVersion(service);
String intf = Tool.getInterface(service);
reference.setGeneric(true);
reference.setApplication(applicationConfig);
reference.setInterface(intf);
reference.setVersion(version);
reference.setGroup(group);
try {
removeGenericSymbol(parameterTypes);
GenericService genericService = reference.get();
return genericService.$invoke(method, parameterTypes, params);
} finally {
reference.destroy();
}
}
/**
* remove generic from parameterTypes 排除掉泛型信息
*
* @param parameterTypes
*/
private void removeGenericSymbol(String[] parameterTypes){
for (int i = 0; i < parameterTypes.length; i++) {
int index = parameterTypes[i].indexOf("<");
if (index > -1) {
parameterTypes[i] = parameterTypes[i].substring(0, index);
}
}
}
针对官方的版本 添加了一个泛化的对象的接口
import java.util.List;
import org.apache.dubbo.config.annotation.Service;
import org.apache.dubbo.samples.Dto.User;
import org.apache.dubbo.samples.api.GreetingService;
@Service(version = "1.0.0.daily", group = "dubbo")
public class AnnotatedGreetingService implements GreetingService {
/**
* 简单测试
*
* @param name
* @return
*/
@Override
public String sayHello(String name) {
System.out.println("greeting service received: " + name);
return "hello, " + name;
}
/**
* 测试泛型接口
*
* @param users
* @return
*/
@Override
public List<User> getListUserIncludeMe(List<User> users) {
if (users == null) {
return null;
}
User user = new User();
user.setName("wangji");
user.setAge(28);
users.add(user);
return users;
}
}
/**
* @author wangji
* @date 2020/6/2 7:12 PM
*/
public class User {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
最最关键的地方在于 genericService.$invoke,调用这个泛化接口的几个最主要的参数信息。最好自己动手实践一下子。
public static void main(String[] args) {
ApplicationConfig application = new ApplicationConfig();
application.setName("Test-" + UUID.randomUUID().toString());
RegistryConfig registryConfig = new RegistryConfig();
registryConfig.setAddress("zookeeper://127.0.0.1:2181");
application.setRegistry(registryConfig);
application.setQosEnable(false);
ReferenceConfig<GenericService> reference = new ReferenceConfig<>();
String group = "dubbo";
String version = "1.0.0.daily";
String interfaceName = "org.apache.dubbo.samples.api.GreetingService";
reference.setGeneric(true);
reference.setApplication(application);
reference.setInterface(interfaceName);
reference.setVersion(version);
reference.setGroup(group);
GenericService genericService = reference.get();
Object data = genericService.$invoke("sayHello", new String[] {
"java.lang.String" },
new Object[] {
"wangji" });
System.out.println("result:" + data);
}
// result:hello, wangji
如果你不知道怎么编写这个参数,可以 PojoUtils.generalize(data) 通过这个接口来生成对象,来看一下生成的数据的结构是咋样的。
注意泛型参数传递的参数类型不包含 java.util.List<org.apache.dubbo.samples.Dto.User> 后面的泛型的信息,只需要传递 java.util.List 即可。
public static void main(String[] args) {
ApplicationConfig application = new ApplicationConfig();
application.setName("Test-" + UUID.randomUUID().toString());
RegistryConfig registryConfig = new RegistryConfig();
registryConfig.setAddress("zookeeper://127.0.0.1:2181");
application.setRegistry(registryConfig);
application.setQosEnable(false);
ReferenceConfig<GenericService> reference = new ReferenceConfig<>();
String group = "dubbo";
String version = "1.0.0.daily";
String interfaceName = "org.apache.dubbo.samples.api.GreetingService";
reference.setGeneric(true);
reference.setApplication(application);
reference.setInterface(interfaceName);
reference.setVersion(version);
reference.setGroup(group);
GenericService genericService = reference.get();
List<User> users = new ArrayList<>();
User user = new User();
user.setName("other");
user.setAge(31);
users.add(user);
Object generalize = PojoUtils.generalize(users);
System.out.println(generalize);
Object getListUserIncludeMe = genericService.$invoke("getListUserIncludeMe", new String[] {
"java.util.List" },
new Object[] {
generalize });
System.out.println(getListUserIncludeMe);
}
// [{name=other, class=org.apache.dubbo.samples.Dto.User, age=31}]
// [{name=other, class=org.apache.dubbo.samples.Dto.User, age=31}, {name=wangji, class=org.apache.dubbo.samples.Dto.User, age=28}]
测试环境中相同的服务会存在多台,如果你想调用具体的某台机子咋办呢?指定具体的IP进行调用,没有看到官方的文档、问了一下小杰子的实践,参考试了一下泛化调用直接ip 也是ok的,只需要找到具体的服务提供者即可。
不过不同的版本好像不一样,没有仔细尝试
设置服务的url 即可满足,能够定位一个服务即可
reference.setUrl("dubbo://192.168.1.3:20880/org.apache.dubbo.samples.api.GreetingService");
需要添加分组的信息才行
reference.setUrl("dubbo://192.168.1.3:20880/分组/org.apache.dubbo.samples.api.GreetingService");
基于 2.7.2 版本
public static void main(String[] args) {
ApplicationConfig application = new ApplicationConfig();
application.setName("Test-" + UUID.randomUUID().toString());
RegistryConfig registryConfig = new RegistryConfig();
registryConfig.setAddress("zookeeper://127.0.0.1:2181");
application.setRegistry(registryConfig);
application.setQosEnable(false);
ReferenceConfig<GenericService> reference = new ReferenceConfig<>();
String group = "dubbo";
String version = "1.0.0.daily";
String interfaceName = "org.apache.dubbo.samples.api.GreetingService";
reference.setGeneric(true);
reference.setApplication(application);
reference.setInterface(interfaceName);
reference.setVersion(version);
reference.setGroup(group);
reference.setUrl("dubbo://192.168.1.3:20880/org.apache.dubbo.samples.api.GreetingService");
GenericService genericService = reference.get();
Object data = genericService.$invoke("sayHello", new String[] {
"java.lang.String" },
new Object[] {
"wangji" });
System.out.println("result:" + data);
}
java.util.List<org.apache.dubbo.samples.Dto.User> 这个是由于PojoUtils的实现问题,导致这样的写法是有问题的。
Object getListUserIncludeMe = genericService.$invoke("getListUserIncludeMe", new String[] { "java.util.List<org.apache.dubbo.samples.Dto.User>" },
new Object[] { generalize });
// at org.apache.dubbo.rpc.protocol.ProtocolFilterWrapper$1.invoke(ProtocolFilterWrapper.java:82)
// at org.apache.dubbo.rpc.filter.EchoFilter.invoke(EchoFilter.java:41)
// at org.apache.dubbo.rpc.protocol.ProtocolFilterWrapper$1.invoke(ProtocolFilterWrapper.java:82)
// at org.apache.dubbo.rpc.protocol.ProtocolFilterWrapper$CallbackRegistrationInvoker.invoke(ProtocolFilterWrapper.java:150)
// at org.apache.dubbo.rpc.protocol.dubbo.DubboProtocol$1.reply(DubboProtocol.java:152)
// at org.apache.dubbo.remoting.exchange.support.header.HeaderExchangeHandler.handleRequest(HeaderExchangeHandler.java:102)
// at org.apache.dubbo.remoting.exchange.support.header.HeaderExchangeHandler.received(HeaderExchangeHandler.java:193)
// at org.apache.dubbo.remoting.transport.DecodeHandler.received(DecodeHandler.java:51)
// at org.apache.dubbo.remoting.transport.dispatcher.ChannelEventRunnable.run(ChannelEventRunnable.java:57)
// at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
// at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
// at java.lang.Thread.run(Thread.java:748)
// Caused by: java.lang.ClassNotFoundException: java.util.List<org.apache.dubbo.samples.Dto.User>
// at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
// at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
// at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349)
// at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
// at java.lang.Class.forName0(Native Method)
// at java.lang.Class.forName(Class.java:348)
// at org.apache.dubbo.common.utils.ReflectUtils.name2class(ReflectUtils.java:743)
// at org.apache.dubbo.common.utils.ReflectUtils.name2class(ReflectUtils.java:670)
// at org.apache.dubbo.common.utils.ReflectUtils.findMethodByMethodSignature(ReflectUtils.java:885)
dubbo泛化调用原理 画的这个图不错十分的形象生动,可以总结一下 泛化的原理
+-------------------------------------------+ +-------------------------------------------+
| consumer 端 | | provider 端 |
| | | |
| | | |
| | | |
| | | |
| +------------------+ | | +--------------+ |
| |GenericImplFilter | | Invocation | |GenericFilter | |
| +----> | +-------------------------> | | |
| | +------------------+ | | +--------------+ |
| +-----------+ | | | +-----------+ |
| | | | | | | | |
| |Client | | | +--> | Service | |
| | | | | | | |
| +-----------+ | | +-------+---+ |
| | | | |
| ^ +------------------+ | | +--------------+ | |
| | |GenericImplFilter | | | |GenericFilter | <----------+ |
| +-------------+ | <-------------------------+ | |
| +------------------+ | | +--------------+ |
| | | |
| | | |
| | | |
| | | |
+-------------------------------------------+ +-------------------------------------------+
/**
* GenericImplInvokerFilter 基于官方的class 2.7.2 删掉不要的东西,简化理解
*/
@Activate(group = CommonConstants.CONSUMER, value = GENERIC_KEY, order = 20000)
public class GenericImplFilter extends ListenableFilter {
private static final Logger logger = LoggerFactory.getLogger(GenericImplFilter.class);
private static final Class<?>[] GENERIC_PARAMETER_TYPES = new Class<?>[]{
String.class, String[].class, Object[].class};
public GenericImplFilter() {
super.listener = new GenericImplListener();
}
@Override
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
String generic = invoker.getUrl().getParameter(GENERIC_KEY);
if ((invocation.getMethodName().equals($INVOKE) || invocation.getMethodName().equals($INVOKE_ASYNC))
&& invocation.getArguments() != null
&& invocation.getArguments().length == 3
&& ProtocolUtils.isGeneric(generic)) {
invocation.setAttachment(
GENERIC_KEY, invoker.getUrl().getParameter(GENERIC_KEY));
}
return invoker.invoke(invocation);
}
static class GenericImplListener implements Listener {
@Override
public void onResponse(Result appResponse, Invoker<?> invoker, Invocation invocation) {
}
@Override
public void onError(Throwable t, Invoker<?> invoker, Invocation invocation) {
}
}
}
/**
* GenericInvokerFilter. 基于官方的class 2.7.2 删掉不要的东西,简化理解
*/
@Activate(group = CommonConstants.PROVIDER, order = -20000)
public class GenericFilter extends ListenableFilter {
public GenericFilter() {
super.listener = new GenericListener();
}
@Override
public Result invoke(Invoker<?> invoker, Invocation inv) throws RpcException {
if ((inv.getMethodName().equals($INVOKE) || inv.getMethodName().equals($INVOKE_ASYNC))
&& inv.getArguments() != null
&& inv.getArguments().length == 3
&& !GenericService.class.isAssignableFrom(invoker.getInterface())) {
String name = ((String) inv.getArguments()[0]).trim();
String[] types = (String[]) inv.getArguments()[1];
Object[] args = (Object[]) inv.getArguments()[2];
try {
// 找到调用的接口
Method method = ReflectUtils.findMethodByMethodSignature(invoker.getInterface(), name, types);
Class<?>[] params = method.getParameterTypes();
if (args == null) {
args = new Object[params.length];
}
String generic = inv.getAttachment(GENERIC_KEY);
if (StringUtils.isBlank(generic)) {
generic = RpcContext.getContext().getAttachment(GENERIC_KEY);
}
if (StringUtils.isEmpty(generic)
|| ProtocolUtils.isDefaultGenericSerialization(generic)) {
// 将PojoUtils 转换的简单对象 转换为复杂的对象
args = PojoUtils.realize(args, params, method.getGenericParameterTypes());
}
return invoker.invoke(new RpcInvocation(method, args, inv.getAttachments()));
} catch (NoSuchMethodException e) {
throw new RpcException(e.getMessage(), e);
} catch (ClassNotFoundException e) {
throw new RpcException(e.getMessage(), e);
}
}
return invoker.invoke(inv);
}
static class GenericListener implements Listener {
@Override
public void onResponse(Result appResponse, Invoker<?> invoker, Invocation inv) {
if ((inv.getMethodName().equals($INVOKE) || inv.getMethodName().equals($INVOKE_ASYNC))
&& inv.getArguments() != null
&& inv.getArguments().length == 3
&& !GenericService.class.isAssignableFrom(invoker.getInterface())) {
String generic = inv.getAttachment(GENERIC_KEY);
if (StringUtils.isBlank(generic)) {
generic = RpcContext.getContext().getAttachment(GENERIC_KEY);
}
if (appResponse.hasException() && !(appResponse.getException() instanceof GenericException)) {
appResponse.setException(new GenericException(appResponse.getException()));
}
// 设置反序列化 讲复杂对象转换为简单的基础对象
appResponse.setValue(PojoUtils.generalize(appResponse.getValue()));
}
}
@Override
public void onError(Throwable t, Invoker<?> invoker, Invocation invocation) {
}
}
}
org.apache.dubbo.rpc.RpcInvocation 打印的效果,方便理解。
public String toString() {
return "RpcInvocation [methodName=" + methodName + ", parameterTypes="
+ Arrays.toString(parameterTypes) + ", arguments=" + Arrays.toString(arguments)
+ ", attachments=" + attachments + "]";
}
org.apache.dubbo.rpc.filter.GenericImplFilter
dubbo://192.168.1.3:20880/org.apache.dubbo.samples.api.GreetingService?application=Test-0519fed7-71d4-494b-b225-15f153bb79db&dubbo=2.0.2&generic=true&group=dubbo&interface=org.apache.dubbo.samples.api.GreetingService&lazy=false&pid=12632&qos-enable=false®ister.ip=192.168.1.3&side=consumer&sticky=false×tamp=1591110891800&version=1.0.0.daily
RpcInvocation
[methodName=$invoke,//调用的方法
parameterTypes=[class java.lang.String, class [Ljava.lang.String;,
class [Ljava.lang.Object;],//通用泛型的参数类型
arguments=[sayHello, [Ljava.lang.String;@68b32e3e, [Ljava.lang.Object;@bcef303],
attachments={}
]
org.apache.dubbo.rpc.filter.GenericFilter
RpcInvocation
[methodName=$invoke,
parameterTypes=[class java.lang.String, class [Ljava.lang.String;, class [Ljava.lang.Object;],
arguments=[sayHello, [Ljava.lang.String;@4174acb6, [Ljava.lang.Object;@5486085f],
attachments={path=org.apache.dubbo.samples.api.GreetingService,
input=351, dubbo=2.0.2,
interface=org.apache.dubbo.samples.api.GreetingService,
version=1.0.0.daily, generic=true,
group=dubbo}]
dubbo://192.168.1.3:20880/org.apache.dubbo.samples.api.GreetingService?anyhost=true&application=zookeeper-demo-provider&bean.name=ServiceBean:org.apache.dubbo.samples.api.GreetingService:1.0.0.daily:dubbo&bind.ip=192.168.1.3&bind.port=20880&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&group=dubbo&interface=org.apache.dubbo.samples.api.GreetingService&methods=sayHello,getListUserIncludeMe&pid=12595&qos-accept-foreign-ip=false®ister=true&release=2.7.2&revision=1.0.0.daily&side=provider×tamp=1591110149299&version=1.0.0.daily
对于dubbo的泛化调用的文章一直想记录一篇,一直苦于没有思路,不知道怎么找到合适的切入角来描述这个问题,正好最近协助同事排查问题,正好有所收获,因此记录一篇博客,在了解过程中不断的进化,加深了对于dubbo的认知。6-2 号,特殊的日子,好像是我阳历的生日 happy ~~
文章浏览阅读3.4k次,点赞8次,收藏42次。一、什么是内部类?or 内部类的概念内部类是定义在另一个类中的类;下面类TestB是类TestA的内部类。即内部类对象引用了实例化该内部对象的外围类对象。public class TestA{ class TestB {}}二、 为什么需要内部类?or 内部类有什么作用?1、 内部类方法可以访问该类定义所在的作用域中的数据,包括私有数据。2、内部类可以对同一个包中的其他类隐藏起来。3、 当想要定义一个回调函数且不想编写大量代码时,使用匿名内部类比较便捷。三、 内部类的分类成员内部_成员内部类和局部内部类的区别
文章浏览阅读118次。分布式系统要求拆分分布式思想的实质搭配要求分布式系统要求按照某些特定的规则将项目进行拆分。如果将一个项目的所有模板功能都写到一起,当某个模块出现问题时将直接导致整个服务器出现问题。拆分按照业务拆分为不同的服务器,有效的降低系统架构的耦合性在业务拆分的基础上可按照代码层级进行拆分(view、controller、service、pojo)分布式思想的实质分布式思想的实质是为了系统的..._分布式系统运维工具
文章浏览阅读174次。1.数据源准备2.数据处理step1:数据表处理应用函数:①VLOOKUP函数; ② CONCATENATE函数终表:step2:数据透视表统计分析(1) 透视表汇总不同渠道用户数, 金额(2)透视表汇总不同日期购买用户数,金额(3)透视表汇总不同用户购买订单数,金额step3:讲第二步结果可视化, 比如, 柱形图(1)不同渠道用户数, 金额(2)不同日期..._exce l趋势分析数据量
文章浏览阅读3.3k次。堡垒机可以为企业实现服务器、网络设备、数据库、安全设备等的集中管控和安全可靠运行,帮助IT运维人员提高工作效率。通俗来说,就是用来控制哪些人可以登录哪些资产(事先防范和事中控制),以及录像记录登录资产后做了什么事情(事后溯源)。由于堡垒机内部保存着企业所有的设备资产和权限关系,是企业内部信息安全的重要一环。但目前出现的以下问题产生了很大安全隐患:密码设置过于简单,容易被暴力破解;为方便记忆,设置统一的密码,一旦单点被破,极易引发全面危机。在单一的静态密码验证机制下,登录密码是堡垒机安全的唯一_horizon宁盾双因素配置
文章浏览阅读7.7k次,点赞4次,收藏16次。Chrome作为一款挺不错的浏览器,其有着诸多的优良特性,并且支持跨平台。其支持(Windows、Linux、Mac OS X、BSD、Android),在绝大多数情况下,其的安装都很简单,但有时会由于网络原因,无法安装,所以在这里总结下Chrome的安装。Windows下的安装:在线安装:离线安装:Linux下的安装:在线安装:离线安装:..._chrome linux debian离线安装依赖
文章浏览阅读153次。中国发达城市榜单每天都在刷新,但无非是北上广轮流坐庄。北京拥有最顶尖的文化资源,上海是“摩登”的国际化大都市,广州是活力四射的千年商都。GDP和发展潜力是衡量城市的数字指...
文章浏览阅读3.3k次。前言spark在java使用比较少,多是scala的用法,我这里介绍一下我在项目中使用的代码配置详细算法的使用请点击我主页列表查看版本jar版本说明spark3.0.1scala2.12这个版本注意和spark版本对应,只是为了引jar包springboot版本2.3.2.RELEASEmaven<!-- spark --> <dependency> <gro_使用java调用spark注册进去的程序
文章浏览阅读4.8k次。汽车零部件开发工具巨头V公司全套bootloader中UDS协议栈源代码,自己完成底层外设驱动开发后,集成即可使用,代码精简高效,大厂出品有量产保证。:139800617636213023darcy169_uds协议栈 源代码
文章浏览阅读4.6k次,点赞20次,收藏148次。AUTOSAR基础篇之OS(下)前言首先,请问大家几个小小的问题,你清楚:你知道多核OS在什么场景下使用吗?多核系统OS又是如何协同启动或者关闭的呢?AUTOSAR OS存在哪些功能安全等方面的要求呢?多核OS之间的启动关闭与单核相比又存在哪些异同呢?。。。。。。今天,我们来一起探索并回答这些问题。为了便于大家理解,以下是本文的主题大纲:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JCXrdI0k-1636287756923)(https://gite_autosar 定义了 5 种多核支持类型
文章浏览阅读2.2k次,点赞6次,收藏14次。原因:自己写的头文件没有被加入到方案的包含目录中去,无法被检索到,也就无法打开。将自己写的头文件都放入header files。然后在VS界面上,右键方案名,点击属性。将自己头文件夹的目录添加进去。_vs2013打不开自己定义的头文件
文章浏览阅读3.3w次,点赞80次,收藏342次。此时,可以将系统中所有用户的 Session 数据全部保存到 Redis 中,用户在提交新的请求后,系统先从Redis 中查找相应的Session 数据,如果存在,则再进行相关操作,否则跳转到登录页面。此时,可以将系统中所有用户的 Session 数据全部保存到 Redis 中,用户在提交新的请求后,系统先从Redis 中查找相应的Session 数据,如果存在,则再进行相关操作,否则跳转到登录页面。当数据量很大时,count 的数量的指定可能会不起作用,Redis 会自动调整每次的遍历数目。_redis命令
文章浏览阅读449次,点赞3次,收藏3次。URP的设计目标是在保持高性能的同时,提供更多的渲染功能和自定义选项。与普通项目相比,会多出Presets文件夹,里面包含着一些设置,包括本色,声音,法线,贴图等设置。全局只有主光源和附加光源,主光源只支持平行光,附加光源数量有限制,主光源和附加光源在一次Pass中可以一起着色。URP:全局只有主光源和附加光源,主光源只支持平行光,附加光源数量有限制,一次Pass可以计算多个光源。可编程渲染管线:渲染策略是可以供程序员定制的,可以定制的有:光照计算和光源,深度测试,摄像机光照烘焙,后期处理策略等等。_urp渲染管线