精华内容
下载资源
问答
  • springboot-vertx 使用SpringBoot和Vert.x(3.0.0)示例 用法 步骤1.建立 mvn package 步骤2.运行 java -jar target/springboot-vertx-example-1.0.0.jar
  • vert.x是内存占用极小的快速开发框架,springboot模版项目
  • Vert.x嵌入Springboot 当您需要异步多线程工作器模式时,可以使用此示例在JAVA中进行分布式处理,并且具有: Vert.x Worker线程verticle示例 SpringBoot Liquebase,在容器部署时初始化数据库数据迁移。 ...
  • vertx for springboot

    2018-08-29 14:58:08
    vertx for springboot 是基于vert.x集成spring boot框架,只需要启动自己的eureka service 就能启动
  • 演示-springboot-vertx3 嵌入 vertx3 并使用 Apex 作为 Web 服务器的多模块 springboot 应用程序的 poc。 该项目的结构如下: parent |- backend |- web |- build 在哪里: “后端”是服务器端java部分,它...
  • vert.x结合springboot开发mqtt服务端,直接启动主类。
  • Vert.x 与Springboot集成

    万次阅读 2018-05-26 23:48:04
    欢迎使用Markdown编辑器写博客 众所知周,Vert.x是一个异步无阻塞的网络框架,其参照物是node.js。基本上node.js能干的事情,Vert.x都能干。...Springboot是应用非常广泛的java快速开发框架,它提供了与数据库,w...

    众所知周,Vert.x是一个异步无阻塞的网络框架,其参照物是node.js。基本上node.js能干的事情,Vert.x都能干。Vert.x利用Netty4的EventLoop来做单线程的事件循环,所以跑在Vert.x上的业务不能做CPU密集型的运算,这样会导致整个线程被阻塞。

    Springboot是应用非常广泛的java快速开发框架,它提供了与数据库,websocket,消息系统等等各种集成。
    业务中已经使用了springboot,如果又有需要使用vert.x,最好是将这两者集成,而不是Vert.x单独作为一个程序。

    如何集成Vert.x与Springboot? 非常简单,我们只需要创建一个Vert.x Server,让它在springboot启动的时候自动启动即可。

    第一步, 设置Vert.x server端口,
    创建一个简单的配置类,它从环境变量获取我们Vert.x Server的端口,如果环境变量没有设置,就使用默认的8081.

    package com.yq.springboot;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.env.Environment;
    
    /**
     * A configuration bean.
     * @author <a href="http://escoffier.me">Clement Escoffier</a>
     */
    @Configuration
    public class AppConfiguration {
    
        @Autowired
        Environment environment;
    
        public int httpPort() {
            return environment.getProperty("http.port", Integer.class, 8081);
        }
    
    }
    

    第二步,创建Vert.x server
    我们需要创建一个简单的WebServer, 这里直接使用Vert.x自带的StaticHandler,也可以自己创建新的Handler,这里只是演示,就直接使用Vert.x自带的StaticHandler。

    package com.yq.springboot;
    
    import io.vertx.core.AbstractVerticle;
    import io.vertx.ext.web.Router;
    import io.vertx.ext.web.handler.StaticHandler;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    
    @Component
    public class StaticServer extends AbstractVerticle {
    
        @Autowired
        AppConfiguration configuration;
    
        @Override
        public void start() throws Exception {
            Router router = Router.router(vertx);
    
            // Serve the static pages
            router.route().handler(StaticHandler.create());
    
            vertx.createHttpServer().requestHandler(router::accept).listen(configuration.httpPort());
        }
    }
    

    第三步,设置静态页面
    我们使用了StaticHandler,可以查看源码,发现只需要创建webroot目录,创建index.html页面即可,

    @VertxGen
    public interface StaticHandler extends Handler<RoutingContext> {
        String DEFAULT_WEB_ROOT = "webroot";
        boolean DEFAULT_FILES_READ_ONLY = true;
        long DEFAULT_MAX_AGE_SECONDS = 86400L;
        boolean DEFAULT_CACHING_ENABLED = true;
        boolean DEFAULT_DIRECTORY_LISTING = false;
        String DEFAULT_DIRECTORY_TEMPLATE = "vertx-web-directory.html";
        boolean DEFAULT_INCLUDE_HIDDEN = true;
        long DEFAULT_CACHE_ENTRY_TIMEOUT = 30000L;
        String DEFAULT_INDEX_PAGE = "/index.html";
    

    我们在<project_path>\vertxDemo\src\main\resources\webroot下面创建index.html, 详细路径可参看这里的源代码。
    index.html

    <html>
    <head>
    </head>
    <body>
    <h1>Static web server. Click on some links below</h1>
    
    <br>
    <br>
    <a href="page1.html">Static Page 1</a>
    <a href="page2.html">Static Page 2</a>
    
    </body>
    </html>
    

    第四步 在springboot,添加postConstruct注解
    在启动类中加上,当我们启动时部署Vertx staticServer的代码。
    备注:@PostConstruct修饰的方法会在服务器加载Servle的时候运行,并且只会被服务器执行一次

    package com.yq;
    
    import com.yq.springboot.StaticServer;
    import io.vertx.core.Vertx;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    import javax.annotation.PostConstruct;
    
    
    @SpringBootApplication
    public class VertxApplication {
    
        @Autowired
        private StaticServer staticServer;
    
        public static void main(String[] args) {
            SpringApplication.run(VertxApplication.class, args);
        }
    
        @PostConstruct
        public void deployVerticle() {
            Vertx.vertx().deployVerticle(staticServer);
        }
    }
    

    启动程序后再网页打开http://127.0.0.1:8081
    效果图
    这里写图片描述

    代码放在这里,欢迎加星。

    展开全文
  • Vert.x-Web与SpringBoot整合

    万次阅读 2018-08-17 14:33:12
    本文主要介绍博主整理开发的VertxSpringBoot整合的脚手架项目。项目旨在便于现有spring项目与Vert.x整合,既能体验Vert.x的高效又兼顾spring的泛用性,降低Vert.x的学习和使用成本,可以做到spring到Vert.x...

    Vert.x的各种优点本文就不再赘述了,感兴趣的朋友可以看一下博主的另一篇博文《Spring Boot同步架构与Vert.x异步架构高并发性能对比》。本文主要介绍博主整理开发的Vertx与SpringBoot整合的脚手架项目。项目旨在便于现有spring项目与Vert.x整合,既能体验Vert.x的高效又兼顾spring的泛用性,降低Vert.x的学习和使用成本,可以做到spring到Vert.x的平滑过渡。项目web层使用了vert.x-web框架,在web层与传统spring的服务层之间加入了异步服务层,异步服务层使用Service Proxies服务代理框架实现,简化了EventBus的使用。数据连接层使用了MybatisPlus框架。

    项目结构如下图。

    其中vs-core模块为本项目核心,vs-main模块主要用于演示项目。

    vs-main中App.java为项目启动类,代码如下。

    package com.xxx;
    
    import com.xxx.handlerfactory.RouterHandlerFactory;
    import com.xxx.vertx.DeployVertxServer;
    import com.xxx.vertx.VertxUtil;
    import io.vertx.core.Vertx;
    import io.vertx.core.VertxOptions;
    import io.vertx.core.eventbus.EventBusOptions;
    import io.vertx.ext.web.Router;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.context.event.ApplicationReadyEvent;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.event.EventListener;
    
    import java.io.IOException;
    
    @SpringBootApplication
    @ComponentScan("com.xxx")
    public class App {
        /**
         * web api所在包路径
         */
        @Value("${web-api-packages}")
        private String webApiPackages;
    
        /**
         * 异步服务所在包路径
         */
        @Value("${async-service-impl-packages}")
        private String asyncServiceImplPackages;
    
        /**
         * http服务器端口号
         */
        @Value("${http-server-port}")
        private int httpServerPort;
    
        /**
         * 工作线程池大小(可根据实际情况调整)
         */
        @Value("${worker-pool-size}")
        private int workerPoolSize;
    
        /**
         * 异步服务实例数量(建议和CPU核数相同)
         */
        @Value("${async-service-instances}")
        private int asyncServiceInstances;
    
        public static void main(String[] args) {
            SpringApplication.run(App.class, args);
        }
    
        @EventListener
        public void deployVerticles(ApplicationReadyEvent event) {
            EventBusOptions eventBusOptions = new EventBusOptions();
            //便于调试 设定超时等时间较长 生产环境建议适当调整
            eventBusOptions.setConnectTimeout(1000 * 60 * 30);
            Vertx vertx = Vertx.vertx(
                    new VertxOptions().setWorkerPoolSize(workerPoolSize)
                            .setEventBusOptions(eventBusOptions)
                            .setBlockedThreadCheckInterval(999999999L)
                            .setMaxEventLoopExecuteTime(Long.MAX_VALUE)
            );
            VertxUtil.init(vertx);
            try {
                Router router = new RouterHandlerFactory(webApiPackages).createRouter();
                DeployVertxServer.startDeploy(router, asyncServiceImplPackages, httpServerPort, asyncServiceInstances);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

    该类在SpringBoot传统启动类的基础之上加入了deployVerticles方法,加上@EventListener注解表示该方法在Spring容器初始化完成后执行。该方法的主要工作是完成Vertx对象的实例化,Router构建,verticle发布等。App.java类中有几个参数需要提前在application.yml中配置,具体见代码注释。

    RestApi类类似于springMVC的Controller类,代码如下。

    package com.xxx.web;
    
    import com.xxx.anno.RouteHandler;
    import com.xxx.anno.RouteMapping;
    import com.xxx.anno.RouteMethod;
    import com.xxx.entity.User;
    import com.xxx.model.ReplyObj;
    import com.xxx.service.UserAsyncService;
    import com.xxx.service2.UserTwoAsyncService;
    import com.xxx.utils.AsyncServiceUtil;
    import com.xxx.utils.HttpUtil;
    import com.xxx.utils.ParamUtil;
    import com.xxx.vertx.VertxUtil;
    import io.vertx.core.Handler;
    import io.vertx.core.file.FileSystem;
    import io.vertx.core.json.JsonObject;
    import io.vertx.ext.web.FileUpload;
    import io.vertx.ext.web.RoutingContext;
    
    import java.util.List;
    import java.util.Set;
    
    import static java.net.HttpURLConnection.HTTP_INTERNAL_ERROR;
    import static java.net.HttpURLConnection.HTTP_OK;
    
    
    @RouteHandler("restapp")
    public class RestApi {
    
        private UserAsyncService userAsyncService = AsyncServiceUtil.getAsyncServiceInstance(UserAsyncService.class);
    
        private UserTwoAsyncService userTwoAsyncService = AsyncServiceUtil.getAsyncServiceInstance(UserTwoAsyncService.class);
    
        /**
         * 演示过滤器
         *
         * @return
         */
        @RouteMapping(value = "/*", method = RouteMethod.ROUTE, order = 2)
        public Handler<RoutingContext> appFilter() {
            return ctx -> {
                System.err.println("我是appFilter过滤器!");
                ctx.next();
            };
        }
    
        /**
         * 演示路径参数
         *
         * @return
         */
        @RouteMapping(value = "/test/:id", method = RouteMethod.GET)
        public Handler<RoutingContext> myTest() {
            return ctx -> {
                JsonObject param = ParamUtil.getRequestParams(ctx);
                HttpUtil.fireJsonResponse(ctx.response(), HTTP_OK, ReplyObj.build().setMsg("Hello,欢迎使用测试地址.....").setData(param.encode()));
            };
        }
    
        /**
         * 演示服务调用
         *
         * @return
         */
        @RouteMapping(value = "/listUsers", method = RouteMethod.GET)
        public Handler<RoutingContext> listUsers() {
            return ctx -> {
                JsonObject param = ParamUtil.getRequestParams(ctx);
                if (param.containsKey("age")) {
                    param.put("age", Integer.valueOf(param.getString("age")));
                }
                User user = new User(param);
                userAsyncService.listUsers(user, ar -> {
                    if (ar.succeeded()) {
                        List<User> userList = ar.result();
                        HttpUtil.fireJsonResponse(ctx.response(), HTTP_OK, ReplyObj.build().setData(userList));
                    } else {
                        HttpUtil.fireJsonResponse(ctx.response(), HTTP_INTERNAL_ERROR,
                                ReplyObj.build().setData(ar.cause().getMessage()).setCode(HTTP_INTERNAL_ERROR));
                    }
                });
            };
        }
    
        @RouteMapping(value = "/findUserById", method = RouteMethod.GET)
        public Handler<RoutingContext> findUserById() {
            return ctx -> {
                JsonObject param = ParamUtil.getRequestParams(ctx);
                if (!param.containsKey("id")) {
                    HttpUtil.fireJsonResponse(ctx.response(), HTTP_INTERNAL_ERROR,
                            ReplyObj.build().setMsg("缺少id参数").setCode(HTTP_INTERNAL_ERROR));
                    return;
                }
                userTwoAsyncService.findUser(Long.valueOf(param.getString("id")), ar -> {
                    if (ar.succeeded()) {
                        User user = ar.result();
                        HttpUtil.fireJsonResponse(ctx.response(), HTTP_OK, ReplyObj.build().setData(user));
                    } else {
                        HttpUtil.fireJsonResponse(ctx.response(), HTTP_INTERNAL_ERROR,
                                ReplyObj.build().setData(ar.cause().getMessage()).setCode(HTTP_INTERNAL_ERROR));
                    }
                });
            };
        }
    
        /**
         * 演示文件上传
         *
         * @return
         */
        @RouteMapping(value = "/upload", method = RouteMethod.POST)
        public Handler<RoutingContext> upload() {
            return ctx -> {
                Set<FileUpload> uploads = ctx.fileUploads();
                FileSystem fs = VertxUtil.getVertxInstance().fileSystem();
                uploads.forEach(fileUpload -> {
                    String path = "D:/vertxupload/" + fileUpload.fileName();
                    fs.copyBlocking(fileUpload.uploadedFileName(), path);
                });
                HttpUtil.fireJsonResponse(ctx.response(), HTTP_OK, ReplyObj.build().setData("OK"));
            };
        }
    
    }
    

    该类使用注解的方式定义了Router的路径,方法,并编写对应的handler处理http请求。在Vert.x-Web中,如果请求同时匹配多个路由,则会优先执行先注册的路由,如果该路由handler中执行了next()方法,则会继续执行下一个匹配的路由handler,我们可以利用此特性实现与servlet中过滤器相似的效果,例如权限控制等。请注意路由的注册顺序将影响handler的执行顺序,通过配置@RouteMapping注解中的order属性可以实现注册顺序控制,order默认为0,注册顺序为从大到小。

    为了避免event-loop被阻塞,我们使用了异步服务封装service层的同步阻塞代码,并且服务代理的handler在worker thread中执行。异步服务实际上是官方对EventBus调用的封装,简化了代码编写,因此服务代理的handler实际上就是EventBus的消费handler。要注意的是服务代理接口的参数类型与异步返回类型都有限制,具体可以参考官方文档中的Vert.x Service Proxy一节。

    服务代理接口代码如下。

    package com.xxx.service;
    
    import com.xxx.entity.User;
    import io.vertx.codegen.annotations.ProxyGen;
    import io.vertx.core.AsyncResult;
    import io.vertx.core.Handler;
    
    import java.util.List;
    
    
    @ProxyGen
    public interface UserAsyncService {
    
        void listUsers(User user, Handler<AsyncResult<List<User>>> resultHandler);
    }
    

    加上@ProxyGen可以自动生成服务代理实现类,但是并不代表我们不需要编写代码,我们仍需要自己编写服务代理接口实现类来自定义handler的逻辑。注意@ProxyGen需要配合package-info.java才能实现自动生成。

    服务代理接口实现类代码如下。

    package com.xxx.service.impl;
    
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import com.xxx.anno.AsyncServiceHandler;
    import com.xxx.entity.User;
    import com.xxx.model.BaseAsyncService;
    import com.xxx.service.UserAsyncService;
    import com.xxx.service.UserService;
    import io.vertx.core.AsyncResult;
    import io.vertx.core.Future;
    import io.vertx.core.Handler;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import java.util.List;
    
    
    @Component
    @AsyncServiceHandler
    public class UserAsyncServiceImpl implements UserAsyncService, BaseAsyncService {
    
        @Autowired
        private UserService userService;
    
        @Override
        public void listUsers(User user, Handler<AsyncResult<List<User>>> resultHandler) {
            try {
                List<User> userList = userService.list(new QueryWrapper<>(user));
                Future.succeededFuture(userList).setHandler(resultHandler);
            } catch (Exception e) {
                resultHandler.handle(Future.failedFuture(e));
            }
        }
    }
    

    注意该类需要加上@AsyncServiceHandler注解,同时还需要实现BaseAsyncService接口,这些是用于服务代理注册及实例化的,具体实现在vs-core模块中。加上@Component注解后可以注入spring服务,服务层以及数据连接层代码与传统Spring项目相同,因此本文不再赘述。

    对项目封装感兴趣的朋友可以下载源码看看。

    项目源码

    参考项目

    vertx-framework开源项目

    展开全文
  • Vert.x整合springboot

    2019-07-16 15:33:54
    1.添加maven中的依赖 <!--spring-boot依赖--> <groupId>org.spring... Vertx.vertx().deployVerticle(server); } } 注释: VertxConfiguration中的端口与application.yml中配置的端口是俩个不一样的东西

    1.添加maven中的依赖

    <!--spring-boot依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--vertx依赖-->
    <dependency>
        <groupId>io.vertx</groupId>
        <artifactId>vertx-core</artifactId>
        <version>3.7.1</version>
    </dependency>
    <dependency>
        <groupId>io.vertx</groupId>
        <artifactId>vertx-web</artifactId>
        <version>3.2.1</version>
    </dependency>

    2.编辑Vert.x配置文件

    @Configuration
    public class VertxConfiguration {
        @Autowired
        Environment environment;
    
        public int httpPort() {
            return environment.getProperty("http.port", Integer.class, 8888);
        }
    }
    

    3.编辑Vert.x启动文件

    @Component
    public class Server extends AbstractVerticle {
       @Autowired
        VertxConfiguration configuration;
    
       @Override
       public void start() throws Exception {
          vertx.createHttpServer().requestHandler(router::accept).listen(configuration.httpPort());
       }
    

    4.让springboot自动启动Vert.x

    @SpringBootApplication
    public class UStreetAppJavaApplication {
        @Autowired
        private Server server;
    
        public static void main(String[] args) {
            SpringApplication.run(UStreetAppJavaApplication.class,args);
        }
        @PostConstruct
        public void deployVerticle() {
            Vertx.vertx().deployVerticle(server);
        }
    }

    注释:VertxConfiguration中的端口与application.yml中配置的端口是俩个不一样的东西

    展开全文
  • 一、创建SpringBoot工程 二、 Vertx 实现http服务器、路由器的使用 1. 用vertx实现http服务器 添加依赖: 工程的创建可以创建两种 : 第一种:Gradle方式 第二种: Maven方式 以上两种vertx都支持: ...

    个人博客网:https://wushaopei.github.io/    (你想要这里多有)

    一、创建SpringBoot工程

    二、 Vertx 实现http服务器、路由器的使用

    1.  用vertx实现http服务器

    添加依赖:

    工程的创建可以创建两种 :

    第一种:Gradle方式

    第二种: Maven方式

    以上两种vertx都支持:

    java代码:

    
    public class Demo1 {
    
        //用vertx实现http服务器
        public static void main(String[] args){
    
            //vertx核心
            Vertx vertx = Vertx.vertx();
    
            //创建http的server
            HttpServer httpServer = vertx.createHttpServer();
            //服务器响应
            httpServer.requestHandler(request -> {
                request.response().end("Hello Itheima!");
            });
    
            httpServer.listen(8080);
        }
    }

    这里使用IDE本身自带的测试工具进行测试:

    测试结果:

    2. 自定义请求头数据

    添加响应依赖:

    java代码:

    public class Demo2 {
    
        public static void main(String [] args){
    
    
            Vertx vertx = Vertx.vertx();
    
            //web路由器
            Router router = Router.router(vertx);
    
            //接口地址为“/”
            router.route("/").handler(context -> {
                context.request();
                context.response().end("hello root!");
            });
    
            //接口地址为 “/abc”
            router.route("/abc").handler((RoutingContext context) ->{
                HttpServerRequest request = context.request();
                String name = request.getParam("name");
                String itheima = request.getHeader("itheima");
    
                context.response().end("hello abc!"+ name+ " " + itheima);
            });
    
    
            HttpServer httpServer = vertx.createHttpServer();
            //处理request(监听请求的接口地址)
            httpServer.requestHandler(router::accept);
            //监听请求的端口
            httpServer.listen(8080);
        }
    }

    httpServer 指定请求的handler,由路由器进行监听请求,在httpServer声明监听的端口号。当“/”时,路由到第一个handler请求,响应 hello root ; 当“/abc”时,路由到第二个router,响应itheima。

    测试中 指定响应头参数:

    当请求为 itheima 时,自动根据已设定好的headers的Name/value,进行value的响应。

    3. Vertx应用的 get 、post请求

    public class Demo3 {
    
        public static void main(String [] args){
    
            Vertx vertx = Vertx.vertx();
    
            //Web路由器
            Router router = Router.router(vertx);
            //get请求
            router.get("/get").handler(context -> {
               context.response().end("hello get!");
            });
            //post请求
            router.post("/post").handler(context -> {
               context.response().end("hello post!");
            });
    
            HttpServer httpServer = vertx.createHttpServer();
            //处理request
            httpServer.requestHandler(router::accept);
            httpServer.listen(8080);
        }
    }
    

    4 、 请求接口的同步、 异步处理请求

    
    public class Demo4 {
    
        public static void main(String [] args){
    
            Vertx vertx = Vertx.vertx();
    
            //Web路由器
            Router router = Router.router(vertx);
            router.get("/sync").handler(context -> {
               //同步处理请求
               context.response().end("hello get!");
                System.err.println("sync: " + Thread.currentThread());
            });
            router.get("/async").blockingHandler(context -> {
               //异步处理请求
                //执行耗时操作
                //数据库访问
                //服务访问
               context.response().end("hello *!");
                System.err.println("async: " + Thread.currentThread());
            });
    
            HttpServer httpServer = vertx.createHttpServer();
            //处理request
            httpServer.requestHandler(router::accept);
            httpServer.listen(8080);
    
        }
    
    }
    

    5.对用户的请求解析时间(测试给定的请求量时vertx处理所消耗的时间)

    
    public class Demo5 {
    
        public static void main(String[] args) {
    
            Vertx vertx = Vertx.vertx();
    
            //web路由器
            Router router = Router.router(vertx);
            router.get("/vertx").blockingHandler(context -> {
    
                long start = System.currentTimeMillis();
                Pi.computePi(20000);
                long end = System.currentTimeMillis();
    
                //同步处理请求
                context.response().end("hello" + (end - start));
    
            });
    
            HttpServer httpServer = vertx.createHttpServer();
            httpServer.requestHandler(router::accept);
            httpServer.listen(8080);
        }
    }

     

    对应的PI:

    
    public class Pi {
    
        private static final BigDecimal FOUR = BigDecimal.valueOf(4);
        private static final int roundingMode = BigDecimal.ROUND_HALF_EVEN;
    
        public static BigDecimal computePi(int digits){
            int scale = digits + 5;
            BigDecimal arctan1_5 = arctan(5,scale);
            BigDecimal arctan1_239 = arctan(239,scale);
            BigDecimal pi = arctan1_5.multiply(FOUR).subtract(arctan1_239).multiply(FOUR);
            return pi.setScale(digits,BigDecimal.ROUND_HALF_UP);
    
        }
    
        private static BigDecimal arctan(int inverseX, int scale) {
    
            BigDecimal result, numer, term;
            BigDecimal invX = BigDecimal.valueOf(inverseX);
            BigDecimal invx2 = BigDecimal.valueOf(inverseX * inverseX);
            numer = BigDecimal.ONE.divide(invX,scale,roundingMode);
            result = numer;
            int i =1;
            do{
                numer = numer.divide(invx2,scale,roundingMode);
                int denom = 2 * i + 1;
                term = numer.divide(BigDecimal.valueOf(denom),scale,roundingMode);
                if((i % 2) != 0){
                    result = result.subtract(term);
                }else {
                    result = result.add(term);
                }
                i++;
            }while (term.compareTo(BigDecimal.ZERO) != 0);
            return result;
        }
    }
    

    代码地址:

    链接:https://pan.baidu.com/s/1SWkSqCxLrg-FD4UZqlhwSg
    提取码:3vgj
     

    展开全文
  • springboot-vertx

    2021-03-09 02:44:51
    这两个密码需要设置的一致 项目介绍 springboot-vertx 是基于swak 的一个演示项目,主要演示了如下部分: 基本的启动框架 api的配置方式,例如AdminApi、AnnoApi、ParamApi、UserApi。 api权限的校验,简单的权限...
  • vertxspringboot整合案例

    千次阅读 2020-05-27 23:07:43
    <groupId>io.vertx</groupId> <artifactId>vertx-codegen</artifactId> ${vertex.version}</version> </dependency> <dependency> <groupId>io.vertx</groupId> <artifactId>vertx-web-client</artifactId> ${vertex...
  • 测试地址 待解决问题 0aef807(在 BookAsyncServiceImpl 中无法自动注入 BookService 为 null 暂时找不到原因)
  • poc-docker-springboot-helloworldip 简单的,经过码头化的spring boot服务,可打印问候世界以及主机IP地址和其他信息。 在本地运行和测试 mvn软件包&& java -jar target / poc-docker-springboot-helloworldip-...
  • springboot 集成 vertx-kafka-client

    千次阅读 2021-01-10 13:55:18
    springboot 集成 vertx-kafka-client 为什么尝试做这个集成 vertx是一套封装了netty的异步事件驱动的框架,netty采用的线程模型可以高效处理某些情况下的网络通讯,然而这套框架需要程序员使用函数编程的方式,不是...
  • 好吧,我还没有见过比较规范性的 Vert.X web 项目目录,说下我自己设计的吧 在 vertx web 中,一个 client request 过来,会由 EventLoop 捕获,解析 url 交给对应的处理器就返回了继续 EventLoop 了,处理器或者叫 ...
  • 得益于Spring Boot的...vertx-web+springboot+jpa 第三套架构过于简单就不放源码了。 想学习Vert.x的同学可以看看: Vert.x官网  官方文档中文翻译 官方示例 Vert.x-Web与SpringBoot整合  
  • Spring Cloud 是一套完整的微服务解决方案,基于 Spring Boot 框架,准确的说,它不是一个框架,而是一个大的容器,它将市面上较好的微服务框架集成进来,从而简化了开发者的代码量。 本课程由浅入深带领大家一步步...
  • 使用@WebListener注解 创建一个监听器继承ServletContextListener类 自动重写ServletContextListener中的contextInitialized(),contextDestroyed()两个方法。 contextInitialized()启动时的方法内容。...
  • vertx_example+springboot_example+maven 开发模板
  • 如果您搜索“最佳网络框架”,您可能会偶然发现Techempower基准测试,其中排名超过300个框架,在那里你可能已经注意到Vert.x是排名最高的。Vert.x是一个多语言 Web 框架,它支持Java,Kotlin,Scala,Ruby和...
  • SpringBoot 集成MQTT配置

    千次阅读 2020-12-24 04:28:50
    1. 前言公司的IOT平台主要采用MQTT(消息队列遥测传输)对...今天先整理SpringBoot集成MQTT笔记和工作中遇到的问题。2. MQTT介绍MQTT is a machine-to-machine (M2M)/"Internet of Things" connectivity protocol. It ...
  • 一. Hazelcast 1. Hazelcast简介 Hazelcast 是由Hazelcast公司开发的一款开源的分布式内存级别的缓存数据库,可以为基于JVM环境运行的各种应用提供分布式集群和分布式缓存服务。 利用Hazelcast可以满足“分布式”...

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 315
精华内容 126
关键字:

springbootvertx

spring 订阅