一切福田，不離方寸，從心而覓，感無不通。

Category Archives: Java

Spring Boot 之 使用jetty web容器

springboot 中默认的web容器是tomcat。 在maven 的pom 文件中加入如下依赖，便可使用tomcat 容器。

1
2
3
4
<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
</dependency>

  如果想使用 jetty 作为 web容器，需要2步操作： 1.排除默认的tomcat 容器

1
2
3
4
5
6
7
8
9
10
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

  2.加入 jetty 的 starter 依赖

1
2
3
4
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>

  from:https://www.cnblogs.com/appleat/p/9100822.html

龙生   23 Sep 2020
View Details

Webflux快速入门

SpringWebflux是SpringFramework5.0添加的新功能，WebFlux本身追随当下最火的Reactive Programming而诞生的框架，那么本篇就来简述一下这个框架到底是做什么的 一、关于WebFlux 我们知道传统的Web框架，比如说：struts2，springmvc等都是基于Servlet API与Servlet容器基础之上运行的，在Servlet3.1之后才有了异步非阻塞的支持。而WebFlux是一个典型非阻塞异步的框架，它的核心是基于Reactor的相关API实现的。相对于传统的web框架来说，它可以运行在诸如Netty，Undertow及支持Servlet3.1的容器上，因此它的运行环境的可选择行要比传统web框架多的多。 根据官方的说法，webflux主要在如下两方面体现出独有的优势： 1）非阻塞式 其实在servlet3.1提供了非阻塞的API，WebFlux提供了一种比其更完美的解决方案。使用非阻塞的方式可以利用较小的线程或硬件资源来处理并发进而提高其可伸缩性 2) 函数式编程端点 　　　　老生常谈的编程方式了，Spring5必须让你使用java8，那么函数式编程就是java8重要的特点之一，而WebFlux支持函数式编程来定义路由端点处理请求。   二、SpringMVC与SpringWebFlux 我们先来看官网的一张图： 它们都可以用注解式编程模型，都可以运行在tomcat，jetty，undertow等servlet容器当中。但是SpringMVC采用命令式编程方式，代码一句一句的执行，这样更有利于理解与调试，而WebFlux则是基于异步响应式编程，对于初次接触的码农们来说会不习惯。对于这两种框架官方给出的建议是： 1）如果原先使用用SpringMVC好好的话，则没必要迁移。因为命令式编程是编写、理解和调试代码的最简单方法。因为老项目的类库与代码都是基于阻塞式的。 2）如果你的团队打算使用非阻塞式web框架，WebFlux确实是一个可考虑的技术路线，而且它支持类似于SpringMvc的Annotation的方式实现编程模式，也可以在微服务架构中让WebMvc与WebFlux共用Controller，切换使用的成本相当小 3）在SpringMVC项目里如果需要调用远程服务的话，你不妨考虑一下使用WebClient，而且方法的返回值可以考虑使用Reactive Type类型的，当每个调用的延迟时间越长，或者调用之间的相互依赖程度越高，其好处就越大 我个人意见是：官网明确指出，SpringWebFlux并不是让你的程序运行的更快(相对于SpringMVC来说)，而是在有限的资源下提高系统的伸缩性，因此当你对响应式编程非常熟练的情况下并将其应用于新的系统中，还是值得考虑的，否则还是老老实实的使用WebMVC吧   三、Reactive Spring Web 在这里定义了最基本的服务端接口：HttpHandler和WebHandler 　　HttpHandler HttpHandler定义了最基本的处理Http请求行为，这个接口主要作用是处理Http请求并将结果做出响应，下面这个表格是说明了Server API的使用方式及何种方式进行响应式流支持的： Server name Server API used Reactive Streams support Netty Netty API Reactor Netty Undertow Undertow API spring-web: Undertow to Reactive Streams bridge Tomcat Servlet 3.1 non-blocking I/O; Tomcat API to read and write ByteBuffers vs byte[] spring-web: Servlet 3.1 non-blocking I/O to Reactive Streams bridge Jetty Servlet 3.1 non-blocking I/O; Jetty API to write ByteBuffers vs byte[] spring-web: Servlet 3.1 […]

龙生   22 Sep 2020
View Details

bigdecimal 保留小数位

1
2
3
4
5
6
7
8
9
10
11
12
public class test1_format {
 
    public static void main(String[] args) {
        BigDecimal decimal = new BigDecimal("1.12345");
        System.out.println(decimal);
        BigDecimal setScale = decimal.setScale(4,BigDecimal.ROUND_HALF_DOWN);
        System.out.println(setScale);
        
        BigDecimal setScale1 = decimal.setScale(4,BigDecimal.ROUND_HALF_UP);
        System.out.println(setScale1);
    }
}

  参数定义 ROUND_CEILING Rounding mode to round towards positive infinity. 向正无穷方向舍入 ROUND_DOWN Rounding mode to round towards zero. 向零方向舍入 ROUND_FLOOR Rounding mode to round towards negative infinity. 向负无穷方向舍入 ROUND_HALF_DOWN Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round down. 向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向下舍入, 例如1.55 保留一位小数结果为1.5 ROUND_HALF_EVEN Rounding mode to round towards the "nearest neighbor" unless both neighbors are equidistant, in which case, round towards the even neighbor. 向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，如果保留位数是奇数，使用ROUND_HALF_UP ，如果是偶数，使用ROUND_HALF_DOWN ROUND_HALF_UP Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in […]

龙生   03 Jul 2020
View Details

Java中四舍五入

1、Math中四舍五入的方法 Math.ceil(double a)向上舍入，将数值向上舍入为最为接近的整数，返回值是double类型 Math.floor(double a)向下舍入，将数值向下舍入为最为接近的整数，返回值是double类型 Math.round(float a)标准舍入，将数值四舍五入为最为接近的整数，返回值是int类型 Math.round(double a)标准舍入，将数值四舍五入为最为接近的整数，返回值是long类型 2、Math中random生成随机数 Math.random()生成大于等于0，小于1的随机数 3、Random类生成随机数 两种构造方式：第一种使用默认的种子（当前时间作为种子），另一个使用long型整数为种子，Random类可以生成布尔型、浮点类型、整数等类型的随机数，还可以指定生成随机数的范围 4、BigDecimal处理小数 两种构造方式：第一种直接value写数字的值，第二种用String

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import java.math.BigDecimal;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
 
public class TestNumber {
    public static void main(String[] args){
        //ceil返回大的值
        System.out.println(Math.ceil(-10.1));   //-10.0
        System.out.println(Math.ceil(10.7));    //11.0
        System.out.println(Math.ceil(-0.7));    //-0.0
        System.out.println(Math.ceil(0.0));     //0.0
        System.out.println(Math.ceil(-0.0));    //-0.0
        System.out.println(Math.ceil(-1.7));    //-1.0
 
        //floor返回小的值
        System.out.println(Math.floor(-10.1));   //-11.0
        System.out.println(Math.floor(10.7));    //10.0
        System.out.println(Math.floor(-0.7));    //-1.0
        System.out.println(Math.floor(0.0));     //0.0
        System.out.println(Math.floor(-0.0));    //-0.0
        System.out.println(Math.floor(-1.7));    //-2.0
 
        //round四舍五入，float返回int，double返回long
        System.out.println(Math.round(10.5));   //11
        System.out.println(Math.round(-10.5));  //-10
 
        //Math生成随机数
        System.out.println(Math.random());
 
        //Random类生成随机数
        Random rand=new Random();
        System.out.println(rand.nextBoolean());
        System.out.println(rand.nextDouble());
        System.out.println(rand.nextInt());
        System.out.println(rand.nextInt(10));
 
        //Random使用当前时间作为Random的种子
        Random rand2 = new Random(System.currentTimeMillis());
        System.out.println(rand2.nextBoolean());
        System.out.println(rand2.nextDouble());
        System.out.println(rand2.nextInt());
        System.out.println(rand2.nextInt(10));
        System.out.println(rand2.nextInt(5));
 
        //ThreadLocalRandom
        ThreadLocalRandom rand3 = ThreadLocalRandom.current();
        System.out.println(rand3.nextInt(5,10));
 
        //BigDecimal
        System.out.println(0.8 - 0.7);   //0.10000000000000009
        BigDecimal a1=new BigDecimal(0.1);
        BigDecimal b1=new BigDecimal(0.9);
        BigDecimal c1=a1.add(b1);
        System.out.println("a1.add(b1)="+c1);  //a1.add(b1)=1.0000000000000000277555756156289135105907917022705078125
 
        BigDecimal a2=new BigDecimal("0.1");
        BigDecimal b2=new BigDecimal("0.9");
        BigDecimal c2=a2.add(b2);
        System.out.println("a2="+a2);  //a2=0.1
        System.out.println("a2.add(b2)="+c2);  //a2.add(b2)=1.0
 
 
    }
}

from:https://www.cnblogs.com/testerlina/p/11349456.html

龙生   03 Jul 2020
View Details

IDEA编译通过能运行但是出现红色下划线的问题

能编译通过说明SDK导入正确，但是为啥我们点击每一个Java文件会出现好多红色的下划线 ，并提示idea cant resolve symbol 原因就是可能没有清除原来的历史缓存，导致一些错误，解决方法是 File-Invalidate Caches 然后重启IDEA，OK~困扰多年的问题解决！

龙生   03 Jul 2020
View Details

什么是RPC？

1. 基本的RPC模型 主要介绍RPC是什么，基本的RPC代码，RPC与REST的区别，gRPC的使用 1.1 基本概念 RPC（Remote Procedure Call）远程过程调用，简单的理解是一个节点请求另一个节点提供的服务 本地过程调用：如果需要将本地student对象的age+1，可以实现一个addAge()方法，将student对象传入，对年龄进行更新之后返回即可，本地方法调用的函数体通过函数指针来指定。 远程过程调用：上述操作的过程中，如果addAge()这个方法在服务端，执行函数的函数体在远程机器上，如何告诉机器需要调用这个方法呢？ 首先客户端需要告诉服务器，需要调用的函数，这里函数和进程ID存在一个映射，客户端远程调用时，需要查一下函数，找到对应的ID，然后执行函数的代码。 客户端需要把本地参数传给远程函数，本地调用的过程中，直接压栈即可，但是在远程调用过程中不再同一个内存里，无法直接传递函数的参数，因此需要客户端把参数转换成字节流，传给服务端，然后服务端将字节流转换成自身能读取的格式，是一个序列化和反序列化的过程。 3.数据准备好了之后，如何进行传输？网络传输层需要把调用的ID和序列化后的参数传给服务端，然后把计算好的结果序列化传给客户端，因此TCP层即可完成上述过程，gRPC中采用的是HTTP2协议。 总结一下上述过程：  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Client端
//    Student student = Call(ServerAddr, addAge, student)
1. 将这个调用映射为Call ID。
2. 将Call ID，student（params）序列化，以二进制形式打包
3. 把2中得到的数据包发送给ServerAddr，这需要使用网络传输层
4. 等待服务器返回结果
5. 如果服务器调用成功，那么就将结果反序列化，并赋给student，年龄更新
 
// Server端
1. 在本地维护一个Call ID到函数指针的映射call_id_map，可以用Map<String, Method> callIdMap
2. 等待服务端请求
3. 得到一个请求后，将其数据包反序列化，得到Call ID
4. 通过在callIdMap中查找，得到相应的函数指针
5. 将student（params）反序列化后，在本地调用addAge()函数，得到结果
6. 将student结果序列化后通过网络返回给Client

在微服务的设计中，一个服务A如果访问另一个Module下的服务B，可以采用HTTP REST传输数据，并在两个服务之间进行序列化和反序列化操作，服务B把执行结果返回过来。 由于HTTP在应用层中完成，整个通信的代价较高，远程过程调用中直接基于TCP进行远程调用，数据传输在传输层TCP层完成，更适合对效率要求比较高的场景，RPC主要依赖于客户端和服务端之间建立Socket链接进行，底层实现比REST更复杂。 1.2 rpc demo   系统类图 系统调用过程   客户端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class RPCClient<T> {
    public static <T> T getRemoteProxyObj(final Class<?> serviceInterface, final InetSocketAddress addr) {
        // 1.将本地的接口调用转换成JDK的动态代理，在动态代理中实现接口的远程调用
        return (T) Proxy.newProxyInstance(serviceInterface.getClassLoader(), new Class<?>[]{serviceInterface},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Socket socket = null;
                        ObjectOutputStream output = null;
                        ObjectInputStream input = null;
                        try{
                            // 2.创建Socket客户端，根据指定地址连接远程服务提供者
                            socket = new Socket();
                            socket.connect(addr);
 
                            // 3.将远程服务调用所需的接口类、方法名、参数列表等编码后发送给服务提供者
                            output = new ObjectOutputStream(socket.getOutputStream());
                            output.writeUTF(serviceInterface.getName());
                            output.writeUTF(method.getName());
                            output.writeObject(method.getParameterTypes());
                            output.writeObject(args);
 
                            // 4.同步阻塞等待服务器返回应答，获取应答后返回
                            input = new ObjectInputStream(socket.getInputStream());
                            return input.readObject();
                        }finally {
                            if (socket != null){
                                socket.close();
                            }
                            if (output != null){
                                output.close();
                            }
                            if (input != null){
                                input.close();
                            }
                        }
                    }
                });
    }
}

  服务端：  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
public class ServiceCenter implements Server {
 
    private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
 
    private static final HashMap<String, Class> serviceRegistry = new HashMap<String, Class>();
 
    private static boolean isRunning = false;
 
    private static int port;
 
 
    public ServiceCenter(int port){
        ServiceCenter.port = port;
    }
 
 
    @Override
    public void start() throws IOException {
        ServerSocket server = new ServerSocket();
        server.bind(new InetSocketAddress(port));
        System.out.println("Server Start .....");
        try{
            while(true){
                executor.execute(new ServiceTask(server.accept()));
            }
        }finally {
            server.close();
        }
    }
 
    @Override
    public void register(Class serviceInterface, Class impl) {
        serviceRegistry.put(serviceInterface.getName(), impl);
    }
 
    @Override
    public boolean isRunning() {
        return isRunning;
    }
 
    @Override
    public int getPort() {
        return port;
    }
 
    @Override
    public void stop() {
        isRunning = false;
        executor.shutdown();
    }
   private static class ServiceTask implements Runnable {
        Socket client = null;
 
        public ServiceTask(Socket client) {
            this.client = client;
        }
 
        @Override
        public void run() {
            ObjectInputStream input = null;
            ObjectOutputStream output = null;
            try{
                input = new ObjectInputStream(client.getInputStream());
                String serviceName = input.readUTF();
                String methodName = input.readUTF();
                Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
                Object[] arguments = (Object[]) input.readObject();
                Class serviceClass = serviceRegistry.get(serviceName);
                if(serviceClass == null){
                    throw new ClassNotFoundException(serviceName + "not found!");
                }
                Method method = serviceClass.getMethod(methodName, parameterTypes);
                Object result = method.invoke(serviceClass.newInstance(), arguments);
 
                output = new ObjectOutputStream(client.getOutputStream());
                output.writeObject(result);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                if(output!=null){
                    try{
                        output.close();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }
                if (input != null) {
                    try {
                        input.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (client != null) {
                    try {
                        client.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

   

1
2
3
4
5
6
7
8
<span class="token keyword">public</span> <span class="token keyword">class</span> <span class="token class-name">ServiceProducerImpl</span> <span class="token keyword">implements</span> <span class="token class-name">ServiceProducer</span><span class="token punctuation">{</span>
    <span class="token annotation punctuation">@Override</span>
    <span class="token keyword">public</span> <span class="token class-name">String</span> <span class="token function">sendData</span><span class="token punctuation">(</span><span class="token class-name">String</span> data<span class="token punctuation">)</span> <span class="token punctuation">{</span>
        <span class="token keyword">return</span> <span class="token string">"I am service producer!!!, the data is "</span><span class="token operator">+</span> data<span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
<span class="token punctuation">}</span>
 
 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class RPCTest {
    public static void main(String[] args) throws IOException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Server serviceServer = new ServiceCenter(8088);
                    serviceServer.register(ServiceProducer.class, ServiceProducerImpl.class);
                    serviceServer.start();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        ServiceProducer service = RPCClient.getRemoteProxyObj(ServiceProducer.class, new InetSocketAddress("localhost", 8088));
        System.out.println(service.sendData("test"));
    }
}

  1.3 完整源码 RPCdemo 1.4 分析 这里客户端只需要知道Server端的接口ServiceProducer即可，服务端在执行的时候，会根据具体实例调用实际的方法ServiceProducerImpl，符合面向对象过程中父类引用指向子类对象。 2. gRPC的使用 2.1. gRPC与REST REST通常以业务为导向，将业务对象上执行的操作映射到HTTP动词，格式非常简单，可以使用浏览器进行扩展和传输，通过JSON数据完成客户端和服务端之间的消息通信，直接支持请求/响应方式的通信。不需要中间的代理，简化了系统的架构，不同系统之间只需要对JSON进行解析和序列化即可完成数据的传递。 但是REST也存在一些弊端，比如只支持请求/响应这种单一的通信方式，对象和字符串之间的序列化操作也会影响消息传递速度，客户端需要通过服务发现的方式，知道服务实例的位置，在单个请求获取多个资源时存在着挑战，而且有时候很难将所有的动作都映射到HTTP动词。 正是因为REST面临一些问题，因此可以采用gRPC作为一种替代方案，gRPC 是一种基于二进制流的消息协议，可以采用基于Protocol Buffer的IDL定义grpc API,这是Google公司用于序列化结构化数据提供的一套语言中立的序列化机制，客户端和服务端使用HTTP/2以Protocol Buffer格式交换二进制消息。 gRPC的优势是，设计复杂更新操作的API非常简单，具有高效紧凑的进程通信机制，在交换大量消息时效率高，远程过程调用和消息传递时可以采用双向的流式消息方式，同时客户端和服务端支持多种语言编写，互操作性强；不过gRPC的缺点是不方便与JavaScript集成，某些防火墙不支持该协议。 注册中心：当项目中有很多服务时，可以把所有的服务在启动的时候注册到一个注册中心里面，用于维护服务和服务器之间的列表，当注册中心接收到客户端请求时，去找到该服务是否远程可以调用，如果可以调用需要提供服务地址返回给客户端，客户端根据返回的地址和端口，去调用远程服务端的方法，执行完成之后将结果返回给客户端。这样在服务端加新功能的时候，客户端不需要直接感知服务端的方法，服务端将更新之后的结果在注册中心注册即可，而且当修改了服务端某些方法的时候，或者服务降级服务多机部署想实现负载均衡的时候，我们只需要更新注册中心的服务群即可。 RPC调用过程 2.2. gRPC与Spring Boot 这里使用SpringBoot+gRPC的形式实现RPC调用过程 项目结构分为三部分：client、grpc、server 项目结构 2.2.2 grpc   pom.xml中引入依赖：  

1
2
3
4
5
<dependency>
      <groupId>io.grpc</groupId>
      <artifactId>grpc-all</artifactId>
       <version>1.12.0</version>
</dependency>

  引入bulid  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<build>
        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.4.1.Final</version>
            </extension>
        </extensions>
        <plugins>
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.5.0</version>
                <configuration>
                    <pluginId>grpc-java</pluginId>
                    <protocArtifact>com.google.protobuf:protoc:3.0.2:exe:${os.detected.classifier}</protocArtifact>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.2.0:exe:${os.detected.classifier}</pluginArtifact>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

  创建.proto文件  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
syntax = "proto3";   // 语法版本
 
// stub选项
option java_package = "com.shgx.grpc.api";
option java_outer_classname = "RPCDateServiceApi";
option java_multiple_files = true;
 
// 定义包名
package com.shgx.grpc.api;
 
// 服务接口定义，服务端和客户端都要遵守该接口进行通信
service RPCDateService {
    rpc getDate (RPCDateRequest) returns (RPCDateResponse) {}
}
 
// 定义消息（请求）
message RPCDateRequest {
    string userName = 1;
}
 
// 定义消息（响应）
message RPCDateResponse {
    string serverDate = 1;
}

  mvn complie   生成代码： 2.2.3 client   根据gRPC中的项目配置在client和server两个Module的pom.xml添加依赖   […]

龙生   24 Jun 2020
View Details

CentOS7 SpringBoot 注册服务

1.服务配置文件

1
2
cd /etc/systemd/system
touch your_service_name.service

1
2
3
4
5
6
[Unit]
Description=zaomianbao
[Service]
ExecStart= /your_java_path/bin/java -jar /your_app_path/your_app_name.jar
[Install]
WantedBy=multi-user.target

2.启动服务

1
systemctl start your_service_name.service

  参考： https://blog.csdn.net/weixin_37490221/article/details/80758276

龙生   10 Jun 2020
View Details

linux中启动 java -jar 后台运行程序

直接用java -jar xxx.jar，当退出或关闭shell时，程序就会停止掉。以下方法可让jar运行后一直在后台运行。 方法一 java -jar xxx.jar & 说明： 在末尾加入 & 符号   方法二 （1）执行java -jar xxx.jar后 （2）ctrl+z 退出到控制台,执行 bg （3）exit 完成以上3步，退出SHELL后，jar服务一直在后台运行。   方法三 nohup java -jar xxxx.jar & 将java -jar xxxx.jar 加入  nohup   &中间，也可以实现   from:https://www.cnblogs.com/zsg88/p/9473843.html

龙生   10 Jun 2020
View Details

Dubbo

一、Dubbo是什么？ Dubbo是阿里巴巴开源的基于 Java 的高性能 RPC（一种远程调用） 分布式服务框架（SOA），致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。 二、为什么要用Dubbo？ 因为是阿里开源项目，国内很多互联网公司都在用，已经经过很多线上考验。内部使用了 Netty、Zookeeper，保证了高性能高可用性。  

1
2
3
1、使用Dubbo可以将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，可用于提高业务复用
灵活扩展，使前端应用能更快速的响应多变的市场需求。
2、分布式架构可以承受更大规模的并发流量。

  三、Dubbo 和 Spring Cloud 有什么区别？

1
2
3
4
5
1、通信方式不同：Dubbo 使用的是 RPC 通信，而Spring Cloud 使用的是HTTP RESTFul 方式。
2、组成不一样：
dubbo的服务注册中心为Zookeerper，服务监控中心为dubbo-monitor,无消息总线，服务跟踪、批量任务等组件；
spring-cloud的服务注册中心为spring-cloud netflix  enruka，服务监控中心为spring-boot admin,有消息总线，数据流、服务跟踪、批量任务等组件；
四、Dubbo需要 Web 容器吗？

  不需要，如果硬要用Web 容器，只会增加复杂性，也浪费资源。 五、Dubbo内置了哪几种服务容器？

1
2
3
4
三种服务容器：
1、Spring Container
2、Jetty Container
3、Log4j Container

  Dubbo 的服务容器只是一个简单的 Main 方法，并加载一个简单的 Spring 容器，用于暴露服务。 六、dubbo都支持什么协议，推荐用哪种？

1
2
3
4
5
1、dubbo://（推荐）
2、http://
3、rest://
4、redis://
5、memcached://

  七、Dubbo里面有哪几种节点角色？

1
2
3
4
5
1、provide：暴露服务的服务提供方
2、consumer：调用远程服务的服务消费方
3、registry:服务注册于发现的注册中心
4、monitor:统计服务调用次数和调用时间的监控中心
5、container:服务运行容器

  八、dubbo服务注册与发现的流程图 dubbo服务注册与发现的流程图 九、Dubbo默认使用什么注册中心，还有别的选择吗？ 推荐使用zookeeper作为注册中心，还有redis、multicast、simple注册中心。 十、Dubbo 核心的配置有哪些？ Dubbo 核心的配置 十一、在 Provider 上可以配置的 Consumer 端的属性有哪些？

1
2
3
4
1、timeout：方法调用超时
2、retries：失败重试次数，默认重试 2 次
3、loadbalance：负载均衡算法，默认随机
4、actives 消费者端，最大并发调用限制

  十二、Dubbo有哪几种负载均衡策略，默认是哪种？

1
2
3
4
1、random loadbalance：安权重设置随机概率（默认）；
2、roundrobin loadbalance：轮寻，按照公约后权重设置轮训比例；
3、lastactive loadbalance：最少活跃调用数，若相同则随机；
4、consistenthash loadbalance：一致性hash，相同参数的请求总是发送到同一提供者。

  十三、Dubbo启动时如果依赖的服务不可用会怎样？ Dubbo缺省会在启动时检查依赖的服务是否可用，不可用时会抛出异常，阻止 Spring 初始化完成，默认 check="true"，可以通过 check="false" 关闭检查。 十四、Dubbo推荐使用什么序列化框架，你知道的还有哪些？

1
推荐使用Hessian序列化，还有Duddo、FastJson、Java自带序列化；

  十五、Dubbo默认使用的是什么通信框架，还有别的选择吗？

1
Dubbo 默认使用 Netty 框架，也是推荐的选择，另外内容还集成有Mina、Grizzly。

  十六、Dubbo有哪几种集群容错方案，默认是哪种？ Dubbo集群容错方案 十七、服务提供者能实现失效踢出是什么原理？

1
服务失效踢出基于zookeeper的临时节点原理。

  十八、Dubbo服务之间的调用是阻塞的吗？

1
2
3
默认是同步等待结果阻塞的，支持异步调用。
Dubbo 是基于 NIO 的非阻塞实现并行调用，客户端不需要启动多线程即可完成并行调用多个远程服务，相对
多线程开销较小，异步调用会返回一个 Future 对象。

  Dubbo暂时不支持分布式事务。 十九、Dubbo的管理控制台能做什么？

1
2
管理控制台主要包含：路由规则，动态配置，服务降级，访问控制，权重调整，负载均衡，等管理功能。
注：dubbo源码中的dubbo-admin模块打成war包，发布运行即可得到dubbo控制管理界面。

  二十、Dubbo 服务暴露的过程

1
2
3
4
Dubbo 会在 Spring 实例化完 bean 之后，在刷新容器最后一步发布 ContextRefreshEvent 事件的时候，通知
实现了 ApplicationListener 的 ServiceBean 类进行回调 onApplicationEvent 事件方法，Dubbo 会在这个方法
中调用 ServiceBean 父类 ServiceConfig 的 export 方法，而该方法真正实现了服务的（异步或者非异步）发
布。

  二十一、当一个服务接口有多种实现时怎么做？ 当一个接口有多种实现时，可以用 group 属性来分组，服务提供方和消费方都指定同一个 group […]

龙生   18 May 2020
View Details

C#中TripleDES对应Java中的DESede即大家说的3DES，附C#及Java加解密结果一致的控制台程序例子

直接上代码了。 Java控制台代码： package Test; import java.security.Key; import javax.crypto.Cipher; import javax.crypto.SecretKeyFactory; import javax.crypto.spec.DESedeKeySpec; import javax.crypto.spec.IvParameterSpec; import org.apache.commons.codec.binary.Base64; public class Test { private static final String encoding = "UTF-8"; public static void main(String[] args) { try { String text = "20200121";// 明文 String key = "Tt3rLPrDIVIhXqAz";// 长度控制为16，作为3DES加密用的key String encryptStr = EncryptData(text, key);// 3DES加密结果 System.out.println("明文：" + text); System.out.println("密钥：" + key); System.out.println("密文：" + encryptStr); System.out.println("解密：" + DecryptData(encryptStr, key)); } catch (Exception e) { e.printStackTrace(); } } /** * DESede加密，key长度为16 * * @param plainText 明文 * @param key 密钥 * @return DESede加密结果 * […]

龙生   09 May 2020
View Details
1 … 40 41 42 … 64

Copyright © 2025 Longsheng All rights reserved