（转）使用Spring-MDP实现分布式作业

最新推荐文章于 2023-10-22 21:10:25 发布
最新推荐文章于 2023-10-22 21:10:25 发布
阅读量636 收藏
点赞数
文章标签： 作业 string object bean class session

自：http://blog.csdn.net/treeclimber/article/details/5662029

 

JMS的作用就不用赘述，它已经是很老掉牙的技术。习惯于单机模式下或中央处理的用户一定没有体会那么深刻。

 

简言之，JMS使得多个JVM并行工作成为可能，Spring-MDP（Message-Driven Pojo）是Spring framework提供的消息驱动包，借助于他我们可以很方便地实现JMS的功能。

 

我现在提供一个场景：一个系统包含客户调用端和服务提供端，客户端非常的Thin，只有接口而并不知道具体的实现类，服务端则包括实现类所需要的各种资源。

 

@MdpService(serviceName="ProxyService")
public interface IProxyService {
   
    public String hello();
   
    public String sayBye();
   
}

这里包含一个Annotation：MdpService，它的作用是告诉服务端，Client调用的是那个服务（serviceName唯一）

@Retention(RetentionPolicy.RUNTIME)
public @interface MdpService {
   
    String serviceName() default "";
    Class<?> serviceClass() default Void.class;
   
}

测试类main方法：

 public static void main(String[] args){
        String[] configuration = {"classpath*:spring-context-test.xml", "classpath:jmsconfig.xml"};
        ApplicationContext context = new ClassPathXmlApplicationContext(configuration);
        IProxyService proxyService = (IProxyService)context.getBean("proxyFactory");
        System.out.println("hello-----------"+proxyService.hello());
        System.out.println("sayBye----------"+proxyService.sayBye());
 }

 

客户端需要用到的Spring技术出了Jms外还有：FactoryBean（代理工厂）, MethodInterceptor（方法拦截）。所以，这里需要实现一个代理工厂类：

public class ProxyFactoryBean implements FactoryBean, MethodInterceptor{
    private Class<Object> serviceInterface;
    private MessageProcessor messageProcessor;

    @Override
    public Object getObject() throws Exception {
        //调用this.invoke()
        return new ProxyFactory(serviceInterface, this).getProxy();
    }

    @Override
    public Class<Object> getObjectType() {
        return serviceInterface;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

    //override MethodInterceptor
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        if (AopUtils.isToStringMethod(invocation.getMethod())) {
            return "JMS invoker proxy for queue";
        }
                
        //远程调用结果，通过MdpService.serviceName找实现
        return this.sendRequestMessage(invocation);
    }
   
    private Object sendRequestMessage(MethodInvocation invocation){
        String serviceName = invocation.getMethod().getDeclaringClass()
                    .getAnnotation(MdpService.class).serviceName();
        LinkedHashMap<String,Object> props = new LinkedHashMap<String,Object>();
        props.put("ServiceName", serviceName);
        String correlationId = UUID.randomUUID().toString();
        props.put("correlationID", correlationId);
       
        RemoteInvocation remote = new RemoteInvocation(invocation);
        String content = JsonUtil.toJsonString(remote); //new String(SerializableUtil.serializeObject(remote));
        try {
            messageProcessor.sendMessage(content, props);
        } catch (JMSException e) {
            e.printStackTrace();
        }
       
        return processResponse(correlationId);
    }
   
    private Object processResponse(String correlationId){
        boolean synch = true;
        if (synch){
            try{
                Thread.sleep(500);
            }catch(Exception e){
                e.printStackTrace();
            }
            return messageProcessor.getInvokeResult(correlationId);
        }else{
            return null;
        }
    }
   
   
    public void setServiceInterface(Class clazz){
        this.serviceInterface = clazz;
    }
    public void setMessageProcessor(MessageProcessor processor){
        this.messageProcessor = processor;
    }

 

 

Server端类：需要托管Spring容器类、远程调用的接口(RemoteInvocation/RemoteInvocationResult)

     1. Spring容器实现类AnnoBeanPostProcessor

public class AnnoBeanPostProcessor implements BeanPostProcessor{
    private static Hashtable<String, RemoteBeanInvoker> invokerMap
                    = new Hashtable<String, RemoteBeanInvoker>();
   
    /**
     * 在初始化一个<bean/>对象前的操作
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
   
    /**
     * 注册RemoteBeanInvoker(MdpService.serviceName, bean)
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Intialized bean '"+beanName+"' "+bean);
        if (bean.getClass().isAnnotationPresent(MdpService.class)){
            MdpService mdpService = bean.getClass().getAnnotation(MdpService.class);
            String serviceName = mdpService.serviceName();
            RemoteBeanInvoker remoteInvoker = invokerMap.get(serviceName);
            if (remoteInvoker != null){
                throw new BeanInitializationException("Already exist Service instance for '"+serviceName+"'");
            }
            remoteInvoker = new RemoteBeanInvoker();  //RemoteInvocationBasedExporter
            invokerMap.put(serviceName, remoteInvoker);
            remoteInvoker.setService(bean);
            if (mdpService.serviceClass() == Void.class){
                throw new BeanInitializationException("Mandatory 'serviceClass' must NOT be empty for bean["+beanName+"]");
            }
            remoteInvoker.setServiceInterface(mdpService.serviceClass());
            remoteInvoker.setRemoteInvocationExecutor(new DefaultRemoteInvocationExecutor());
            System.out.println("service '"+serviceName+"' remoteImpl:"+bean);
        }
        return bean;
    }
   
    public static RemoteBeanInvoker getRemoteInvoker(String serviceName){
        return invokerMap.get(serviceName);
    }

}

     2. 远程调用接口封装

public class RemoteBeanInvoker extends RemoteInvocationBasedExporter {
    private RemoteInvocation invocation = null;
   
    public Object invoke()throws Throwable{
        Object remoteBean = super.getProxyForService();  //from message.property("ServiceName")
        RemoteInvocationResult result = super.invokeAndCreateResult(invocation, remoteBean);
       
        Object returnValue = null;
        try{
            returnValue = result.recreate();
        }catch(Throwable t){
            if (result.hasInvocationTargetException()) {
                throw t;
            } else {
                throw new RemoteInvocationFailureException("Invoke [" + invocation + "] failed", t);
            }
        }
       
        this.sendResponseMessage();;
       
        return returnValue;
    }
   
    private void sendResponseMessage(){
       
    }
   
    public void setRemoteInvocation(RemoteInvocation invocation){
        this.invocation = invocation;
    }
    public void setMethodInvocation(MethodInvocation method){
        invocation = new RemoteInvocation(method);
    }
       
}

     3. 最后是Service的实现类

@MdpService(serviceName="ProxyService", serviceClass=IProxyService.class)
public class ServiceImpl implements IProxyService {

    @Override
    public String hello() {
        System.out.println("ServiceImpl.hello()---");
        return "hello, xiongsl";
    }

    @Override
    public String sayBye() {
        System.out.println("ServiceImpl.sayBye()---");
        return "Good bye! xiongsl";
    }

}

     4. 测试方法：

public static void main(String[] args) throws Throwable{
        String[] locations = {"classpath:spring-context-test_svr.xml", "classpath:jmsconfig.xml"};
        ApplicationContext context = new ClassPathXmlApplicationContext(locations);
        MessageProcessor processor = (MessageProcessor)context.getBean("messageProcessor");
        processor.receiveMessage();
}

 

 

---------------------------------------------------------------------------------------------------------------

以上是Service的Client/Server相关类。下面才是Spring-MDP接口的调用类。

client.JmsQueueTextSender

          |-----MessageProcessor

server.JmsQueueReceiver

          |-----MessageProcessor

------------------------------------------------------------------------------------------------------------------
import java.util.Map;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

/**
 * Queue消息发送器，同时也可以作为消息监听器
 * @author shuilin.xiong
 */
public class JmsQueueTextSender {
    protected ConnectionFactory connectFactory;
    protected String queueName;
   
    protected Connection connection;
    protected Session session;
    private Queue queue;
   
    public void sendMessage(String content, Map<String,Object> props) throws JMSException{
        if (connection == null){
            this.afterProperiesSet();
        }
       
        TextMessage message = session.createTextMessage(content);
        message.setJMSCorrelationID((String)props.remove("correlationID"));
        for (String key : props.keySet()){
            message.setObjectProperty(key, props.get(key));
        }
        session.createProducer(queue).send(message);
    }
   
    private void afterProperiesSet()throws JMSException{
        connection = connectFactory.createConnection();
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        queue = session.createQueue(queueName);
       
        this.processResponseIfNecessary();
    }
   
    public void close() throws JMSException{
        if (session != null){
            session.close();
        }
        if (connection != null){
            connection.close();
        }
    }
   
    protected void processResponseIfNecessary() throws JMSException{
        //监听respQueueName(@see springstudy.proxy.MessageProcessor)
    }
   
    public void setConnectFactory(ConnectionFactory connectFactory) {
        this.connectFactory = connectFactory;
    }
    public void setQueueName(String queueName) {
        this.queueName = queueName;
    }

}


import java.util.HashMap;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.TextMessage;

import com.tsinghuatec.dawn.waf.jms.JmsQueueTextSender;
import com.tsinghuatec.dawn.waf.util.json.JsonUtil;

public class MessageProcessor extends JmsQueueTextSender {
    private String respQueueName;
    HashMap<String,Object> resultMap = new HashMap<String,Object>();
   
    @Override
    protected void processResponseIfNecessary() throws JMSException{
        Queue respQueue;
        if (respQueueName == null){
            respQueue = session.createTemporaryQueue();
        }else{
            respQueue = session.createQueue(respQueueName);
        }
        final MessageConsumer consumer = session.createConsumer(respQueue);
        consumer.setMessageListener( new MessageListener(){
            @Override
            public void onMessage(Message message) {
                try {
                    processResponseMessage((TextMessage)message);
                } catch (Throwable e) {
                    try {
                        consumer.close();
                    } catch (JMSException e1) {
                        e1.printStackTrace();
                    }
                }
            }
        });
    }
   
    @SuppressWarnings("unchecked")
    public void processResponseMessage(TextMessage message) throws JMSException {
        String jsonResult = message.getText();
        System.out.println("收到文本消息=====/n" + jsonResult);
        String correlationId = message.getJMSCorrelationID();
        if (jsonResult != null){
            try {
                Class returnType = Class.forName(message.getStringProperty("ResultType"));
                Object result = JsonUtil.getObject(jsonResult, returnType);
                synchronized(resultMap){
                    resultMap.put(correlationId, result);
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
   
    public Object getInvokeResult(String correlationID){
        synchronized(resultMap){
            return resultMap.remove(correlationID);
        }
    }

    public void setRespQueueName(String respQueueName) {
        this.respQueueName = respQueueName;
    }
   
}

 

 

Server:


import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

public class JmsQueueReceiver {
    protected ConnectionFactory connectFactory;
    protected String queueName;
    protected String respQueueName;
   
    private Session session;
    private Connection connection;
    private Queue queue;
   
    public void receiveMessage() throws JMSException{
        if (connection == null){
            this.afterProperiesSet();
        }
       
        final MessageConsumer consumer = session.createConsumer(queue);
        consumer.setMessageListener( new MessageListener(){
            @Override
            public void onMessage(Message message) {
                try {
                    processMessage((TextMessage)message);
                } catch (Throwable e) {
                    try {
                        consumer.close();
                    } catch (JMSException e1) {
                        e1.printStackTrace();
                    }
                }
            }
        });
    }
   
    protected void processMessage(TextMessage message) throws JMSException {
        System.out.println("收到文本消息=====/n"+message.getText());
    }
   
    private void afterProperiesSet()throws JMSException{
        connection = connectFactory.createConnection();
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        queue = session.createQueue(queueName);
    }
   
    public void setConnectFactory(ConnectionFactory connectionFactory) {
        this.connectFactory = connectionFactory;
    }
    public void setQueueName(String queueName) {
        this.queueName = queueName;
    }
    public void setRespQueueName(String respQueueName) {
        this.respQueueName = respQueueName;
    }

}

 


import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.remoting.support.RemoteInvocation;

import com.tsinghuatec.dawn.waf.jms.JmsQueueReceiver;
import com.tsinghuatec.dawn.waf.util.json.JsonUtil;

public class MessageProcessor extends JmsQueueReceiver/*implements ApplicationListener*/{
    @Autowired
    private AnnoBeanPostProcessor postProcessor;
   
    private Session session;
    private Connection connection;
   
    /**
     * 接收RequestMessage，调用接口，并创建返回消息
     */
    protected void processMessage(TextMessage message) throws JMSException {
        super.processMessage(message);

        String serviceName = message.getStringProperty("ServiceName");
        RemoteInvocation remote = JsonUtil.getObject(message.getText(), RemoteInvocation.class);
        Object result = this.getInvocationResult(serviceName, remote);
       
        this.sendResponse(result, message.getJMSCorrelationID());
    }
   
    private Object getInvocationResult(String serviceName, RemoteInvocation remote){
        RemoteBeanInvoker invoker = postProcessor.getRemoteInvoker(serviceName);
        try {
            invoker.setRemoteInvocation(remote);
            return invoker.invoke();
        } catch (Throwable e) {
            e.printStackTrace();
            return null;
        }
    }
   
    private void sendResponse(Object result, String correlationId) throws JMSException{
        if (session == null){
            connection = connectFactory.createConnection();
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        }
        TextMessage message = session.createTextMessage();
        message.setJMSCorrelationID(correlationId);
        if (result != null){
            message.setText(JsonUtil.toJsonString(result));
            message.setStringProperty("ResultType", result.getClass().getName());
        }
       
        Queue respQueue;
        if (respQueueName == null){
            respQueue = session.createTemporaryQueue();
        }else{
            respQueue = session.createQueue(respQueueName);
        }
        session.createProducer(respQueue).send(message);
    }

}

 

 

 

配置文件：jmsconfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <!-- jndiTemplate -->
    <bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
      <property name="environment">
        <props>
          <prop key="java.naming.factory.initial">
             com.sonicsw.jndi.mfcontext.MFContextFactory
          </prop>
          <prop key="java.naming.provider.url">tcp://localhost:2506</prop>
          <prop key="java.naming.security.principal">Administrator</prop>
          <prop key="java.naming.security.credentials">Administrator</prop>
          <prop key="com.sonicsw.jndi.mfcontext.domain">Domain1</prop>
          <prop key="com.sonicsw.jndi.mfcontext.idleTimeout">60000</prop>
        </props>
      </property>
    </bean>
   
     <!-- JMS连接工厂 -->
    <bean id="connectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
      <property name="jndiName" value="seashellSonicSendXAConnectionFactory" />
      <property name="jndiTemplate" ref="jndiTemplate" />
    </bean>
    <bean id="cachedConnectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
      <property name="targetConnectionFactory" ref="connectionFactory"/>
    </bean>


 </beans>

spring-context-test.xml：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:os-core="http://www.openspaces.org/schema/core"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    

    <context:annotation-config />
   
    <bean id="proxyFactory" class="com.tsinghuatec.dawn.waf.springstudy.proxy.ProxyFactoryBean">
      <property name="serviceInterface" value="com.tsinghuatec.dawn.waf.springstudy.proxy.IProxyService"/>
      <property name="messageProcessor" ref="messageProcessor"/>
    </bean>
   
    <bean id="messageProcessor" class="com.tsinghuatec.dawn.waf.springstudy.proxy.MessageProcessor">
      <property name="queueName" value="SampleQ2"/>
      <property name="respQueueName" value="SampleQ3"/>
      <property name="connectFactory" ref="cachedConnectionFactory"/>
    </bean>
</beans>

 

spring-context-test_svr.xml：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:os-core="http://www.openspaces.org/schema/core"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <!--context:property-placeholder location="classpath:/DBConnConfig.properties" /-->
   
    <bean id="beanPostProcessor" class="com.tsinghuatec.dawn.waf.springstudy.startup.AnnoBeanPostProcessor">
    </bean>
   
    <bean id="messageProcessor" class="com.tsinghuatec.dawn.waf.springstudy.startup.MessageProcessor">
      <property name="queueName" value="SampleQ2"/>
      <property name="respQueueName" value="SampleQ3"/>
      <property name="connectFactory" ref="cachedConnectionFactory"/>
    </bean>
   
    <bean class="com.tsinghuatec.dawn.waf.springstudy.startup.ServiceImpl" />
   
</beans>

  

先运行Server端，后运行Client端。

haoppywang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用Spring Boot Mossrose快速构建健壮的分布式作业
crnlm的博客
05-17 504
mossrose轻量分布式作业框架特性通过选举保证集群中只出现一个主节点，负责trigger作业所有集群节点参与作业计算任务内置多种作业类型，并预留了SPI接口支持扩展文档Wiki: https://github.com/jiuxiantuan/mossrose/wikiSpring Boot Starter: https://github.com/jiuxiantuan/mossrose-spr...
mdp框架_MDP实现细节（一）-- 贝尔曼方程
weixin_42510731的博客
01-02 343
之前MDP框架我们总体上介绍了MDP的大致概念，现在来说说实现这个框架的细节概念。我们知道一个智能体如果要到达指定的目标，在规划路径的时候，我们可以使用MDP最大化累计回报的方法来获取最优的线路。我们来看一个例子：在这个网格世界，智能体想从左上角移动到右下角的目标位置，R代表的是从每一个位置移动懂下个位置的回报值。好了，先来介绍第一个概念:1.状态值函数简单的说就是一定的策略下，在t时刻状态S下未...
使用Spring-MDP实现分布式作业
风上人的专栏
06-10 5511
<br />JMS的作用就不用赘述，它已经是很老掉牙的技术。习惯于单机模式下或中央处理的用户一定没有体会那么深刻。<br /> <br />简言之，JMS使得多个JVM并行工作成为可能，Spring-MDP（Message-Driven Pojo）是Spring framework提供的消息驱动包，借助于他我们可以很方便地实现JMS的功能。<br /> <br />我现在提供一个场景：一个系统包含客户调用端和服务提供端，客户端非常的Thin，只有接口而并不知道具体的实现类，服务端则包括实现类所需要的各种资源
Java Message Service :Spring POJO (MDP)与EJB3的Java Message Driven (MDB)
di0808的博客
04-23 101
Spring提供了一个用于简化JMS API使用的抽象框架，并且对用户屏蔽了JMS API中1.0.2和1.1版本的差异。 JMS的功能大致上分为两块，叫做消息制造和消息消耗。JmsTemplate 用于制造消息和同步消息接收。和Java EE的事件驱动Bean风格类似，对于异步接收消息，Spring提供了一些消息侦听容器来创建消息驱动的POJO（MDP）。 ...
Spring MDP异步接收和处理ActiveMQ消息
HYhhhhhhh的博客
06-20 211
Spring MDP异步接收和处理ActiveMQ消息 先配置配置activemq连接工厂 @Bean public ConnectionFactory connectionFactory(){ ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(); return factory; } 配置队列和主题 /** * 配置activemq队列 * @return
ETG5001-1-MDP-GeneralSpec
最新发布
03-17
包括《ETG5001_1_MDP_GeneralSpec》、《ETG5001_4_MDP_Safety》、《ETG5001_6220_IO-LinkMaster》仅用于学习目的
matlab中存档算法代码-python-mdp-toolkit:python-mdp-toolkit
05-23
已实现的算法列表包括向后归纳，线性编程，策略迭代，q学习和值迭代以及若干变体。 这些类和功能是根据（法国）的进行开发的。 有适用于MATLAB，GNU Octave，Scilab和R的版本。MDP工具箱套件在Chades I，Chapron G，...
git-mdp:mdp (https
06-25
git-mdp 用于介绍 git 的甲板
brushing-mdp
08-04
用于多维投影的数据引导的布鲁斯 应用程序代码
accd-mdp-ct
02-12
accd-mdp-ct
mdp框架_Reinforcement Learning笔记(1)--基本框架-问题和解决方案
weixin_39907220的博客
12-20 328
「学习内容总结自udacity深度学习课程，截图来自 udacity 课件」基本框架-问题1.基本框架RL的基本框架如下图所示，主要是指智能体(Agent)如何学习与环境(Environment)互动的过程。将时间离散化看待，在最开始的时间步中，环境会向智能体展示一些情景或者说智能体会观察环境得到一个结果(observation)，然后智能体必须向环境做出响应动作(action)。在下一个时间步中...
RabbitMQ （五）实现类似Dubbo的RPC调用
fmi110的博客
07-04 443
springboot对rabbitMQ的接口做了封装，要实现 request/reponse 模式的调用，只需要调用 rabbitTemplate.convertSendAndReceive 方法即可，队列和交换器的设置使用topic模式即可。 Object res = rabbitTemplate.convertSendAndReceive(exchangeName, routingKey, reqJson,message -> { MessageProperties...
mdp框架_强化学习中q learning和MDP的区别是什么？
weixin_39672396的博客
12-20 853
MDP通常是指一种用转移概率描述连续不确定概率过程的数学框架，是强化学习中最基础的概念，很多强化学习的算法都是在把问题抽象为一个MDP之后再想办法求解的。而q-learning是求解强化学习问题的算法的一种，大类上属于value-based方法(MDP确定的情况下求解一个最优的奖励期望值表格，从表格得到最优策略)中的Temporal Differences(TD)一系列方法之一。我其实理解你一部分...
MDP建模方法
han_liwei的博客
10-22 199
猜你喜欢”是美团流量最大的推荐展位，位于首页最下方，产品形态为信息流，承担了帮助用户完成意图转化、发现兴趣、并向美团点评各个业务方导流的责任。经过多年迭代，目前“猜你喜欢”基线策略的排序模型是业界领先的流式更新的Wide&Deep模型[1]。考虑Point-Wise模型缺少对候选集Item之间的相关性刻画，产品体验中也存在对用户意图捕捉不充分的问题，从模型、特征入手，更深入地理解时间，仍有推荐体验和效果的提升空间。
MDP移动端开发平台初了解（一）
zdldan的专栏
06-29 3091
最近公司采购了这款产品（后来我去网上搜索了下，人家是免费的！！！），让我们使用这个进行新产品的开发。发现使用中还是需要一定的基础的，遂整理下我的开发过程（这样我就不用解答新来的问的笨笨的问题的，直接网址一扔，完美）。 项目搭建 基于springboot开发，官方提供了源码项目，正常导入IDE、引入依赖就可以使用了，这里不做过多的赘述。如果对springboot不是很了解的朋友，可以自行百度一下，...
Springboot项目 我的后端大作业 制作⼀个直播收藏平台
xyccz的博客
03-10 1344
在这个加长版寒假里，为了挤进学校的实验室里打下手 ，我花了好长时间完成了这份大作业，至少对我这个假期才刚刚接触后端的新人来说这份大作业属实不简单。 不过也是顺利完成了，发出来给大伙们乐乐~~希望大家能给给建议啥的~ 1.工具： 开发软件：IDEA //IDEA，永远滴神！！数据库：mysql 测试工具：火狐浏览器和postman 2.思路： 登录功能...
Spring框架期末总结和作业完成情况
lbj5063的博客
06-20 417
期末总结 + 作业情况期末总结作业情况 期末总结 不知不觉已经到了期末，这学期我有学习到了新知识。刚接触这门课的时候觉得还比较容易，但是越往后学越困难，而且还涉及到数据库和前端内容，就更难了。虽然有讲课笔记，但是有的内容，还是要自己理解，实在理解不到就百度查。 这学期我们学习了spring的内容，其中又分了三个分类分别是MyBatis框架、Spring框架、Spring Boot框架。MyBatis框架主要讲了简单查询、CRUD操作、关联和条件查询，在查询内容时涉及到数据库的内容，就比较麻烦，因为查询语句都
msm8916 MDP(mobile display processor) 简介
Eliot_shao的专栏
01-18 5510
硬件上面，Msm8916只有一个mipi-dsi接口用于连接LCM，由MDP(mobile display processor)进行管理，大概硬件结构图如下： mdp提供图片格式转换，旋转，overlay（overlay技术）等功能，dsi提供传输数据。 注意：overlay主要为了满足多界面叠加的需求，可理解为pipe，MDP支持3个overlay pipe。
mdp框架_MDP -- 马尔科夫决策过程
weixin_39728320的博客
12-20 256
在自动驾驶中，路径规划有很多种方式，传统算法包括深度广度优先搜索，A*算法。这些都是不错的算法，但是都有一个问题，他们都是建立在控制运动的结果是确定性的假设上的。比如，汽车的速度，转弯的角度，位置，雷达数据都是无误差的。但是在现实世界中，是到处都充满了误差的。实际上，运动会引入不确定性，因为运动的结果就是不确定的。其次，我们区分完全可观测系统和部分可观测系统。经典的机器人通常假设传感器可以测量环境...
MDP模型在matlab中如何实现
03-31
MDP（马尔可夫决策过程）模型在Matlab中可以使用reinforcement learning toolbox实现。以下是一个简单的示例代码： ```matlab % 定义状态空间 states = [1 2 3 4]; % 定义动作空间 actions = [1 2]; % 定义转移概率...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值