精华内容
下载资源
问答
  • cd C:\software\OTP 21.0.1 Windows 64-bit Binary File\rabbitmq-server-windows-3.7.7\rabbitmq_server-3.7.7\sbin rabbitmq-server.bat ④运行后端  绿色三角号 ⑤运行前端 dbblog-manage-...

    1、根据PID关闭对应端口号

    netstat -nao|findstr   XXX                     XX 为 要关闭的端口号

    taskkill   /F   /PID    XXX                      XX 为 端口号对应的PID 

    2、如何使用IDEA运行一个由GIT导入的Spring Boot项目?

    首先配置JDK:https://blog.csdn.net/zhangxianling11/article/details/101348988

    切记是在Project里面配置

    3、运行项目:

    ①打开Redis

    https://blog.csdn.net/weixin_43784880/article/details/90378301

     

    cd C:\software\Redis-x64-3.0.504\Redis-x64-3.0.504

    auth "1234556"

    ②打开ES

    cd C:\software\ES\elasticsearch-6.4.2\bin

    elasticsearch.bat

    ③打开MQ

    cd C:\software\OTP 21.0.1 Windows 64-bit Binary File\rabbitmq-server-windows-3.7.7\rabbitmq_server-3.7.7\sbin

    rabbitmq-server.bat

    ④运行后端

        绿色三角号

    ⑤运行前端

    dbblog-manage-frontend:

        npm set sass_binary_site=https://npm.taobao.org/mirrors/node-sass/

        npm install

        npm run dev

    dbblog-frontend:

        npm install

        npm run dev

    展开全文
  • rabbitmq安装和erlang环境的安装直接参考 官网;...springboot :2.2.4 rabbitmq 大致操作流程(simple) 创建连接工厂ConnectionFactory,输入host、port、username、password、虚拟访问节点VirtualHo

    rabbitmq安装和erlang环境的安装直接参考 官网;需要注意的是要查看一下两个的最低版本对应,避免出现版本问题,详细查看官网:
    https://www.rabbitmq.com/which-erlang.html
    我的版本:erlang:24.0,rabbitmq:3.8.17
    springboot :2.2.4

    rabbitmq 大致操作流程(simple)

    1. 创建连接工厂ConnectionFactory,输入host、port、username、password、虚拟访问节点VirtualHost(默认"/",发送到根目录/根节点下)
    2. 使用连接工厂创建连接Connection,连接可以取名和传参;
    3. 通过连接创建通道Channel
    4. 准备要发送的消息
    5. 准备交换机,创建一个交换机或者不指定交换机exchange;不指定交换机会使用默认的交换机;创建交换机:通过通道channel创建,即声明交换机,channel.exchangeDeclare(),声明交换机的话需要指定一下交换机的类型exchangeType,交换机类型四种:direct/topic/fanout/headers
    6. 准备队列queue,创建队列,即声明一个队列,和声明交换机基本一致,channel.queueDeclare()
    7. 队列指定routerKey,作用是为了指定消费者接受和消费消息;
    8. 绑定队列和交换机,channel.queueBind()
    9. 发布消息,channel.basicPublish()
    10. 关闭通道,关闭连接

    四种模式

    1. direct 路由模式,由路由routerKey来指定哪些消费者来接收和消费消息
    2. topic 也是路由模式,只不过使用模糊的方式来指定路由routerKey,使用#和*,#表示有一级或者多级或者没有,表示必须有一级;例如#.com.,表示com前面可有一级或者多级或者没有,com后面必须有一级也可以是多级,这样的路由才符合接收消息的消费者条件
    3. fanout 发布订阅模式,只要订阅了,有消息,都可以进行接收消费;他没有路由key
    4. headers 参数匹配模式

    使用springboot就可以简单的更多,看起来更加的简洁

    springboot 集成rabbitmq

    新建项目,导入rabbitmq依赖
    配置配置信息,使用yml或者配置类,本地安装不需要配置,spring已经配置好了,如果在web页面(15672管理页面)修改过用户信息,需要把用户信息配置一下,默认guest;
    需要建立两个项目,一个生产者和一个消费者

    生产者
    #rabbitmq配置 本机安装的话不需要配置,spring已经有过配置了
    #不是本机安装需要配置一下
    #spring:
    #  rabbitmq:
    #    username:
    #    password:
    #    host:
    #    virtual-host: /
    #    port: 5567
    #    listener:
    #      simple:
    #        # 手动应答
    #        acknowledge-mode: manual
    

    这边配置了手动应答,不使用默认应答方式,如果程序抛异常,把消息进行其他的操作,防止消息丢失;生产者实际上是不需要的,消费者和生产者基本上一致,所以直接复制了;消费者配置更多的是使用了配置类,详细的会在消费者里面说。

    配置成功之后,创建队列和转换机;创建的位置生产者和消费者哪一侧都可以,我放在了生产者中;生产者生产的消息到转换机中,由转换机投递到队列中,队列绑定转换机。

    这次只用了fanoutdirect两个模式
    使用配置类创建交换机和队列(也可以说声明)

    配置类

    @Configuration
    public class RabbitMQConfiguration {
    
        //1.声明交换机 fanout交换机
        //2.声明队列
        //3.队列绑定交换机
    
        @Bean
        public FanoutExchange fanoutExchange(){
            return new FanoutExchange("fanout_exchange",true,false);
        }
        @Bean
        public Queue smsQueue(){
            return new Queue("sms_queue",true,false,false);
        }
    
        /**
         * 设置ttl队列,一定的时间消息过期,过期的消息可以转入死信队列
         * @return
         */
        @Bean
        public Queue ttlQueue(){
            //web界面可以看到队列的设置采用的是键值对的形式,所以用了map
            Map<String,Object> map = new HashMap<>();
            map.put("x-message-ttl",60000);//key是一定的,设置队列中消息的过期时间
            map.put("x-dead-letter-exchange","dead_direct_exchange");//死信队列
            map.put("x-dead-letter-routing-key","dead");//direct模式需要添加死信队列的routingKey,如果是fanout则不需要
            return new Queue("ttl_queue",true,false,false,map);
        }
    
        @Bean
        public Binding binding(){
            return BindingBuilder.bind(smsQueue()).to(fanoutExchange());
        }
    
        /**
         * 声明direct交换机
         * @return
         */
        @Bean
        public DirectExchange directExchange(){
            return new DirectExchange("direct_exchange",true,false);
        }
    
        /**
         * 绑定direct交换机
         * @return
         */
        @Bean
        public Binding directBinding(){
            return BindingBuilder.bind(ttlQueue()).to(directExchange()).with("ttl");
        }
    
        /**
         * 死信队列
         * @return
         */
        @Bean
        public Queue deadQueue(){
            return new Queue("dead_queue",true);
        }
    
        /**
         * 绑定死信队列
         * @return
         */
        @Bean
        public Binding directBindingDead(){
            return BindingBuilder.bind(deadQueue()).to(directDeadExchange()).with("dead");
        }
        /**
         * 声明direct交换机,作为死信队列的交换机
         * @return
         */
        @Bean
        public DirectExchange directDeadExchange(){
            return new DirectExchange("dead_direct_exchange",true,false);
        }
    
    }
    

    生产者

    @Service
    public class OrderServiceImpl {
    
        @Autowired
        private RabbitTemplate rabbitTemplate;
    
        public void makeOrderByFanout(){
            Order order = new Order();
            order.setOrderId(UUID.randomUUID().toString());
            order.setOrderName("哈哈哈");
            order.setOrderPrice(new BigDecimal(123));
            order.setPriceTotal(BigDecimal.ZERO);
            order.setCreateTime(new Date());
            order.setPayTime(new Date());
            String exchange = "fanout_exchange";
            String routingKey = "";
            rabbitTemplate.convertAndSend(exchange,routingKey,JSONObject.toJSONString(order));
        }
    
        /**
         *  使用direct模式测试TTL和死信度列
         */
        public void makeOrderByDirect(){
            Order order = new Order();
            order.setOrderId(UUID.randomUUID().toString());
            order.setOrderName("哈哈哈");
            order.setOrderPrice(new BigDecimal(123));
            order.setPriceTotal(BigDecimal.ZERO);
            order.setCreateTime(new Date());
            order.setPayTime(new Date());
            String exchange = "direct_exchange";
            String routingKey = "ttl";
            rabbitTemplate.convertAndSend(exchange,routingKey, JSONObject.toJSONString(order));
        }
    }
    

    使用测试类就可以启动啦,到web页面15672查看就发现交换机exchange已创建,队列queue也创建好啦!

    创建的三个交换机
    队列

    注意:如果通过map方式修改队列的信息是不可以的,只能重新删掉队列,创建修改参数的队列,不然报错。生产环境不可以删掉队列,一般重新创建一个队列,而不是直接删除创建。

    其中TTL和死信队列也一并加入测试了一下,需要注意的是过期时间的设置,可以设置队列也可以设置消息;通常情况是设置队列来达到消息的过期,事实上消息过期并不意味折消息要清理掉,更多的情况是将消息投递到其他地方去消费了,例如:死信队列

    死信队列接绑定之后,队列的过期消息、达到消息数量上限的消息和被拒绝的额消息,都可以投递到消息队列中(在生产者的配置类中已经写出操作),消息拒绝放在消费者里面大致讲解。

    消息创建成功

    消费者

    先配置消费者,消费者的配置采用了配置类,其中指定了手动应答和消息转换,这个解释呢,不多说,代码里面注释好了。

    @Configuration
    public class ConsumeConfiguration {
    
        /**
         * 开启手动应答
         * @return
         */
        @Bean
        public RabbitProperties.Listener addListener(){
            RabbitProperties.Listener listener = new RabbitProperties.Listener();
            RabbitProperties.SimpleContainer simple = listener.getSimple();
            simple.setAcknowledgeMode(AcknowledgeMode.MANUAL);//设置手动应答
            return listener;
        }
    
        /**
         * 配置监听的数据转换,将byte[]转换为message
         * 如果直接按照官方类上面@RabbitListener,消费者方法上面@RabbitHandler,会报错
         * 因为管道里的两种转换,第一次转换awqp将数据准换为byte[],第二次由spring将数据转换为Message
         * 用@RabbitHandler类型的转换会出错,找不到class,所以方法上面也用@RabbitListener
         * @param connectionFactory
         * @return
         */
        @Bean
        public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
            SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
            factory.setConnectionFactory(connectionFactory);
            factory.setMessageConverter(new Jackson2JsonMessageConverter());
            return factory;
        }
    
        /**
         * 配置连接信息
         * 本机Windows环境,不需要配置,spring已经有默认的配置
         * @return
         */
    //    @Bean
    //    public RabbitProperties addProperties(){
    //        RabbitProperties properties = new RabbitProperties();
    //        properties.setAddresses("");
    //        properties.setHost("");
    //        properties.setPort(5567);
    //        properties.setUsername("");
    //        properties.setPassword("");
    //        properties.setVirtualHost("/");//默认;也可以自己设置
    //        return properties;
    //    }
    }
    

    消费者,顾名思义就是拿到生产者生产的东西消费;生产者将消息放在交换机,由交换机exchange投递到队列queue;消费者consumer监听队列(这里用的fanout发布订阅模式和direct路由key的模式,而且各自的交换机和队列只创建了一个,可能显示效果不明显,可以自己多创建几个队列,注意,是队列),一旦有消息投递,消费者立刻就监听到,获取消息进行消费。默认是自动应答,即消费者程序跑完即消费完成,不论程序中是否异常或者业务代码是否执行(try/catch);这就需要手动应答,当消息真正被消费了,再清理队列中的消息;如果发生异常,最好不要拒绝消息,否则它会重新投递,当然你也可以设置参数requeue为false,不让它回队列了。最好的方式就是给发生异常时的消息找一个地方去继续进行异常的操作,也就是死信队列(死信队列的设置我放在了生产者中的配置类);

    fanout的消费者

    @Service
    @RabbitListener(queues = {"sms_queue"})
    public class SmsConsumerServiceImpl {
    
        private RabbitTemplate rabbitTemplate;
    
        //问题:如果出现异常,只要程序走完,消息依旧被消费了
        //似乎是应答模式的问题,没有指定应答模式,使用的是默认的应答模式,自动应答;需要设置手动应答
        //手动来返回是否消息被消费了
        @RabbitListener(queues = {"sms_queue"},containerFactory = "rabbitListenerContainerFactory")
        public void receiveMessage(Channel channel,Message messages) throws IOException {
            System.out.println("消费者进来啦---------------->");
            try{
                Integer.valueOf("haha");
                System.out.println("sms_queue接收到的----->订单信息:"+ new String(messages.getBody()));
                channel.basicAck(messages.getMessageProperties().getDeliveryTag(),true);
            }catch (Exception e){
                System.out.println("程序出错-------->消息消费失败");
                //一般程序出错,拒绝消息
    //            channel.basicReject(messages.getMessageProperties().getDeliveryTag(),true);
                //抛异常不再拒绝消息,将消息投递到死信队列
                String deadExchange = "dead_direct_exchange";
                String deadRoutingKey = "dead";
                channel.basicPublish(deadExchange,deadRoutingKey,new AMQP.BasicProperties(),messages.getBody());
            }
    
        }
    }
    

    消费者消费消息

    死信队列的消费者

    @RabbitListener(queues = {"dead_queue"})
    @Service
    public class DeadDirectConsumerServiceImpl {
    
        @RabbitListener(queues = {"dead_queue"},containerFactory = "rabbitListenerContainerFactory")
        public void deadDirectConsumer(Channel channel, Message message){
            System.out.println("监听到死信队列啦-----");
        }
    }
    

    在这里插入图片描述

    这里让消息走到死信队列就结束了,这里当然是要看自己的业务逻辑来制定。

    死信队列执行完毕

    work的轮询和公平分发模式

    轮询分发模式

    • 一人一个的分发消息
    • 不考虑服务器的性能和处理消息的能力
    • 消费者接受消息basicConsume()设置autoAck参数为true
    • 使用公平分发模式消费者不指定指标basicQos(),指标即一次从队列中取出的消息数量

    公平分发模式

    • 能者多劳
    • 服务器性能好、处理消息能力高的接收和消费的消息越多
    • 消费者接受消息basicConsume()设置autoAck参数为false,即应答模式为手动应答,并对应答进行设置,channel.basicAck()
    • 指定指标basicQos(),根据内存的状况来指定指标数值制定多少

    感谢大佬手动应答数据转换问题:
    https://www.bbsmax.com/A/KE5Qy4y5LG/

    展开全文
  • Windows CMD命令运行springboot jar包

    千次阅读 2020-06-04 14:04:49
    指定目录下运行 javar -jar 包名.jar --server.port=7777

    指定目录下运行

    javar -jar 包名.jar --server.port=7777
    展开全文
  • windows下cmd启动springboot的jar包

    千次阅读 2020-06-12 10:28:00
    ## 确定是否安装JDK 在cmd命令行中输入`java -version` 如果正常显示java版本号,即表示JDK已安装,并且已设置为环境变量,否则先去安装JDK,网上参考资料很多这里不再赘述。 ## 运行方法 方法一: ...

    ## 确定是否安装JDK

    在cmd命令行中输入`java -version`

    如果正常显示java版本号,即表示JDK已安装,并且已设置为环境变量,否则先去安装JDK,网上参考资料很多这里不再赘述。

    ## 运行方法

    方法一:

    `javar -jar 包名.jar --server.port=8081` 

    此方法是指明包的目录,如果jar包中已经配置好端口号,可以不再输入`--server.port`

    方法二:

    `java -jar -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=128m -Xms1024m -Xmx30720m -Xmn256m -Xss256k -XX:SurvivorRatio=8 -XX:+UseConcMarkSweepGC D:\包名.jar`

    此方法未指明包的目录

    展开全文
  • 对于之前的Spring框架的使用,各种配置文件XML、properties一旦出错之后错误难寻,这也是为什么SpringBoot被推上主流的原因,SpringBoot的配置简单,说5分钟能从框架的搭建到运行也不为过,现在更是微服务当道,所以...
  • 今天去现场熟悉生产环境,接触了解到除了在服务器安装启动Tomcat服务,或者黑窗口java -jar运行服务外,针对项目可以采用注册Windows服务的方式运行程序,这点相比前面两种方式,就很合理。 问题: Windows系统...
  • Windows系统修改catalina.bat,在环境变量的说明后,脚本开始前加上set JAVA_OPTS=%JAVA_OPTS% "-Dhudson.util.ProcessTree.disable=true"; 无效 4、安装daemonize防止被进程被杀,脚本最后一行执行命令 ...
  • 假设这时候,我想定时重启这个springboot,那么由于它没有部署在tomcat里,无法通过定时重启tomcat的windows服务或者tomcat脚本来实现。 这时可以如下: 1)制作一个启动run.bat rem ---------- 先杀死 当前 正...
  • windows server 2016 计划任务添加批处理运行springboot jar包 问题描述: 程序运行没有问题,但是每次运行三天左右进程就会自动关闭,并且没有任何日志记录 java -jar -XX:MetaspaceSize=128m -XX:...
  • springboot项目jar包windows后台运行

    千次阅读 2018-09-10 20:18:18
    idea打包 右侧meven project - Lifecycle - (双击)package 取出target里的jar包,out里的不行。 bat脚本内容 @echo off START &amp;quot;demo&amp;quot; &amp;quot;C:\Program Files\Java...quot
  • springboot项目注册为windows系统服务并设置开机自启关于springboot项目的部署与SSM(框架)部署war包到Tomcat下有所不同,比较明显的是springboot打包为jar包,运行则是执行通过java -jar xxx.jar,不再需要放置在...
  • SpringBoot+dubbo ,5分半完美起来

    千次阅读 2018-05-04 15:34:28
    最近有用到Springboot+dubbo,但是去网上搜了好多帖子,发现都不能用,于是打算自己出一个。首先安装zookeeper,因为是开发环境,所以直接在Windows上安的,修改一下配置文件,点击zkServer.cmd启动,不要关闭窗口,...
  • Springboot - 用SpringBoot 2.3.0.M1创建Docker映像)1、发布2、说明3、常见的Docker 运行方式4、常规方式通过docker 运行springboot 存在的问题5、如何解决常规方式的不足呢6、到底怎么构建7、分层8、写分层形式的...
  • SpringBoot入门

    2020-05-10 22:22:56
    文章目录SpringBoot入门SpringBoot简介使用IDEA快速搭建SpringBoot项目更换Maven源介绍配置文件自定义Banner打JAR包参考文章 SpringBoot简介 了解 SpringBoot之前,我们要先了解一下Spring。Spring是一个开源框架,...
  • 这是因为我采用的项目打包方式是主流的也是springboot项目极力推荐的打包方式:“打包成jar包”。但如果你将springboot项目打包成war包就需要安装tomcat。、 2.将springboot项目打包成jar包的方法见: ...
  • Spring全家桶————[SpringBoot入门到路] 对于之前的Spring框架的使用,各种配置文件XML、properties一旦出错之后错误难寻,这也是为什么SpringBoot被推上主流的原因,SpringBoot的配置简单,说5分钟能从框架的...
  • 程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 4 分钟。作者:双主双机热备来源:http://suo.im/5yPoPJ关于springboot项目的部署与SSM...
  • 一行代码,告别 if else 判断系统类型,通用在 Windows 和 Linux 环境下读取文件
  • Spring全家桶————[SpringBoot入门到路] 对于之前的Spring框架的使用,各种配置文件XML、properties一旦出错之后错误难寻,这也是为什么SpringBoot被推上主流的原因,SpringBoot的配置简单,说5分钟能从框架...
  • SpringBoot部署

    2020-01-09 16:38:01
    springboot框架下的程序在idea中可以正常运行之后,需要发布。主要参照官方文档、statckoverflow以及github。 1、官方文档 官方文档中介绍了如何将程序打包成jar 但是当我按照文档中的说明配置pom.xml文件时,运行...
  • 1.打开McAfee并点击防火墙 ... 接着启动在IDEA中启动自己的项目,查看下自己的IP,先试试局域网中的其他电脑是否能ping同自己的电脑,如果能ping同则直接在浏览器中输入IP+:+端口号+访问的资源路径即可! ...
  • windows服务程序 环境:idea 2017 + Maven 3.3.9+jdk 1.8 一、springboot项目 创建过程依次如下图所示: 至此一个简单的springboot 项目框架建好,可以往里面填充内容了 二、控制台程序 创建...
  • SpringBoot初步学习

    2019-04-22 22:49:52
    Spring Boot 的设计是为了让你尽可能快的起来 Spring 应用程序并且尽可能减少你的配置文件。简单来说就是SpringBoot其实不是什么新的框架,它默认配置了很多框架的使用方式,就像maven整合了所有的jar包,spring ...
  • 看了日志发现报错 g.apache.catalina.startup.Catalina.start The required Server component failed to start so Tomcat is unable to start. org.apache.catalina.LifecycleException: Failed to start ...
  • SpringBoot CLi

    2019-04-25 20:45:02
    Spring Boot CLI 是什么 Spring Boot CLI 是 Spring ...在 Spring Boot CLI 可以 Groovy 脚本,通过简单的 Java 语法就可以快速而又简单的学习 Spring Boot 原型。 Spring Boot CLI 安装 打开 Spring Boot CLI...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,611
精华内容 644
关键字:

windows跑springboot

spring 订阅