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

Category Archives: Java

什么是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

Springboot调用soap webservice（Client）

1.使用jdk自带的webservice工具wsimport生成相关类 测试wsdl http://www.webxml.com.cn/WebServices/IpAddressSearchWebService.asmx?wsdl

1
wsimport -s d:\wsdl -p com.example.demo.request -encoding utf-8 http://www.webxml.com.cn/WebServices/IpAddressSearchWebService.asmx?wsdl

  -s 存储目录； -p 包名； -encoding 文件编码，默认会采用操作系统编码，中文为gbk，建议使用utf-8； 2.构建相关的配置类及测试方法

1
2
3
4
5
6
7
8
@Configuration
public class IpConfig {
 
    @Bean
    public IpAddressSearchWebServiceSoap webService(){
        return new IpAddressSearchWebService().getIpAddressSearchWebServiceSoap();
    }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@SpringBootApplication
@RestController
@RequestMapping("/soap")
public class DemoApplication {
 
    @Autowired
    private IpAddressSearchWebServiceSoap soap;
 
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
 
    @RequestMapping("/{ip}")
    public ArrayOfString searchIp(@PathVariable("ip") String ip) {
        ArrayOfString response = soap.getCountryCityByIp(ip);
        return response;
    }
}

    from:https://blog.csdn.net/VitaminZH/article/details/81123571

龙生   30 Mar 2020
View Details

恕我直言，我怀疑你没怎么用过枚举

我们是否一样？ 估计很多小伙伴（也包括我自己）都有这种情况，在自学Java语言看书时，关于枚举enum这一块的知识点可能都有点 “轻敌” ，觉得这块内容非常简单，一带而过，而且在实际写代码过程中也不注意运用。 是的，我也是这样！直到有一天我提的代码审核没过，被技术总监一顿批，我才重新拿起了《Java编程思想》，把枚举这块的知识点重新又审视了一遍。 为什么需要枚举 常量定义它不香吗？为啥非得用枚举？ 举个栗子，就以B站上传视频为例，视频一般有三个状态：草稿、审核和发布，我们可以将其定义为静态常量：

1
2
3
4
5
6
7
8
public class VideoStatus {
    
    public static final int Draft = 1; //草稿
    
    public static final int Review = 2; //审核
    
    public static final int Published = 3; //发布
}

  对于这种单值类型的静态常量定义，本身也没错，主要是在使用的地方没有一个明确性的约束而已，比如：

1
2
3
4
5
void judgeVideoStatus( int status ) {
    
    ...
    
}

  比如这里的 judgeVideoStatus 函数的本意是传入 VideoStatus 的三种静态常量之一，但由于没有类型上的约束，因此传入任意一个int值都是可以的，编译器也不会提出任何警告。 但是在枚举类型出现之后，上面这种情况就可以用枚举严谨地去约束，比如用枚举去定义视频状态就非常简洁了：

1
2
3
public enum VideoStatus {
    Draft, Review, Published
}

  而且主要是在用枚举的地方会有更强的类型约束：

1
2
3
4
5
6
// 入参就有明确类型约束
void judgeVideoStatus( VideoStatus status ) {
    
    ...
    
}

  这样在使用 judgeVideoStatus 函数时，入参类型就会受到明确的类型约束，一旦传入无效值，编译器就会帮我们检查，从而规避潜在问题。 除此之外，枚举在扩展性方面比普常量更方便、也更优雅。 重新系统认识一下枚举 还是拿前文《答应我，别再if/else走天下了可以吗》中的那个例子来说：比如，在后台管理系统中，肯定有用户角色一说，而且角色一般都是固定的，适合定义成一个枚举：

1
2
3
4
5
6
7
8
public enum UserRole {
 
    ROLE_ROOT_ADMIN,  // 系统管理员
 
    ROLE_ORDER_ADMIN, // 订单管理员
 
    ROLE_NORMAL       // 普通用户
}

  接下来我们就用这个UserRole为例来说明枚举的所有基本用法：

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
UserRole role1 = UserRole.ROLE_ROOT_ADMIN;
UserRole role2 = UserRole.ROLE_ORDER_ADMIN;
UserRole role3 = UserRole.ROLE_NORMAL;
 
// values()方法：返回所有枚举常量的数组集合
for ( UserRole role : UserRole.values() ) {
    System.out.println(role);
}
// 打印：
// ROLE_ROOT_ADMIN
// ROLE_ORDER_ADMIN
// ROLE_NORMAL
 
// ordinal()方法：返回枚举常量的序数，注意从0开始
System.out.println( role1.ordinal() ); // 打印0
System.out.println( role2.ordinal() ); // 打印1
System.out.println( role3.ordinal() ); // 打印2
 
// compareTo()方法：枚举常量间的比较
System.out.println( role1.compareTo(role2) ); //打印-1
System.out.println( role2.compareTo(role3) ); //打印-2
System.out.println( role1.compareTo(role3) ); //打印-2
 
// name()方法：获得枚举常量的名称
System.out.println( role1.name() ); // 打印ROLE_ROOT_ADMIN
System.out.println( role2.name() ); // 打印ROLE_ORDER_ADMIN
System.out.println( role3.name() ); // 打印ROLE_NORMAL
 
// valueOf()方法：返回指定名称的枚举常量
System.out.println( UserRole.valueOf( "ROLE_ROOT_ADMIN" ) );
System.out.println( UserRole.valueOf( "ROLE_ORDER_ADMIN" ) );
System.out.println( UserRole.valueOf( "ROLE_NORMAL" ) );

  除此之外，枚举还可以用于switch语句中，而且意义更加明确：

1
2
3
4
5
6
7
8
9
10
11
12
UserRole userRole = UserRole.ROLE_ORDER_ADMIN;
switch (userRole) {
    case ROLE_ROOT_ADMIN:  // 比如此处的意义就非常清晰了，比1，2，3这种数字好！
        System.out.println("这是系统管理员角色");
        break;
    case ROLE_ORDER_ADMIN:
        System.out.println("这是订单管理员角色");
        break;
    case ROLE_NORMAL:
        System.out.println("这是普通用户角色");
        break;
}

  自定义扩充枚举 上面展示的枚举例子非常简单，仅仅是单值的情形，而实际项目中用枚举往往是多值用法。 比如，我想扩充一下上面的UserRole枚举，在里面加入 角色名 — 角色编码 的对应关系，这也是实际项目中常用的用法。 这时候我们可以在枚举里自定义各种属性、构造函数、甚至各种方法：

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 enum UserRole {
 
    ROLE_ROOT_ADMIN( "系统管理员", 000000 ),
    ROLE_ORDER_ADMIN( "订单管理员", 100000 ),
    ROLE_NORMAL( "普通用户", 200000 ),
    ;
 
    // 以下为自定义属性
    
    private final String roleName;  //角色名称
 
    private final Integer roleCode; //角色编码
 
    // 以下为自定义构造函数
    
    UserRole( String roleName, Integer roleCode ) {
        this.roleName = roleName;
        this.roleCode = roleCode;
    }
 
    // 以下为自定义方法
    
    public String getRoleName() {
        return this.roleName;
    }
 
    public Integer getRoleCode() {
        return this.roleCode;
    }
 
    public static Integer getRoleCodeByRoleName( String roleName ) {
        for( UserRole enums : UserRole.values() ) {
            if( enums.getRoleName().equals( roleName ) ) {
                return enums.getRoleCode();
            }
        }
        return null;
    }
 
}

  从上述代码可知，在enum枚举类中完全可以像在普通Class里一样声明属性、构造函数以及成员方法。 枚举 + 接口 = ? 比如在我的前文《答应我，别再if/else走天下了可以吗》中讲烦人的if/else消除时，就讲过如何通过让枚举去实现接口来方便的完成。 这地方不妨再回顾一遍： 什么角色能干什么事，这很明显有一个对应关系，所以我们首先定义一个公用的接口RoleOperation，表示不同角色所能做的操作：

1
2
3
public interface RoleOperation {
    String op();  // 表示某个角色可以做哪些op操作
}

  接下来我们将不同角色的情况全部交由枚举类来做，定义一个枚举类RoleEnum，并让它去实现RoleOperation接口：

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
public enum RoleEnum implements RoleOperation {
 
    // 系统管理员(有A操作权限)
    ROLE_ROOT_ADMIN {
        @Override
        public String op() {
            return "ROLE_ROOT_ADMIN:" + " has AAA permission";
        }
    },
 
    // 订单管理员(有B操作权限)
    ROLE_ORDER_ADMIN {
        @Override
        public String op() {
            return "ROLE_ORDER_ADMIN:" + " has BBB permission";
        }
    },
 
    // 普通用户(有C操作权限)
    ROLE_NORMAL {
        @Override
        public String op() {
            return "ROLE_NORMAL:" + " has CCC permission";
        }
    };
}

  这样，在调用处就变得异常简单了，一行代码就行了，根本不需要什么if/else：

1
2
3
4
5
6
public class JudgeRole {
    public String judge( String roleName ) {
        // 一行代码搞定！之前的if/else灰飞烟灭
        return RoleEnum.valueOf(roleName).op();
    }
}

  而且这样一来，以后假如我想扩充条件，只需要去枚举类中加代码即可，而不用改任何老代码，非常符合开闭原则！ 枚举与设计模式 什么？枚举还能实现设计模式？ 是的！不仅能而且还能实现好几种！ 1、单例模式

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
public class Singleton {
 
    // 构造函数私有化，避免外部创建实例
    private Singleton() {
 
    }
 
    //定义一个内部枚举
    public enum SingletonEnum{
 
        SEED;  // 唯一一个枚举对象，我们称它为“种子选手”！
 
        private Singleton singleton;
 
        SingletonEnum(){
            singleton = new Singleton(); //真正的对象创建隐蔽在此！
        }
 
        public Singleton getInstnce(){
            return singleton;
        }
    }
 
    // 故意外露的对象获取方法，也是外面获取实例的唯一入口
    public static Singleton getInstance(){
        return SingletonEnum.SEED.getInstnce(); // 通过枚举的种子选手来完成
    }
}

  2、策略模式 这个也比较好举例，比如用枚举就可以写出一个基于策略模式的加减乘除计算器

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
public class Test {
 
    public enum Calculator {
 
        ADDITION {
            public Double execute( Double x, Double y ) {
                return x + y; // 加法
            }
        },
 
        SUBTRACTION {
            public Double execute( Double x, Double y ) {
                return x - y; // 减法
            }
        },
 
        MULTIPLICATION {
            public Double execute( Double x, Double y ) {
                return x * y; // 乘法
            }
        },
 
 
        DIVISION {
            public Double execute( Double x, Double y ) {
                return x/y;  // 除法
            }
        };
 
        public abstract Double execute(Double x, Double y);
    }
    
    public static void main(String[] args) {
        System.out.println( Calculator.ADDITION.execute( 4.0, 2.0 ) );      
        // 打印 6.0
        System.out.println( Calculator.SUBTRACTION.execute( 4.0, 2.0 ) );    
        // 打印 2.0
        System.out.println( Calculator.MULTIPLICATION.execute( 4.0, 2.0 ) );
        // 打印 8.0
        System.out.println( Calculator.DIVISION.execute( 4.0, 2.0 ) );      
        // 打印 2.0
    }
}

  专门用于枚举的集合类 我们平常一般习惯于使用诸如：HashMap 和 HashSet等集合来盛放元素，而对于枚举，有它专门的集合类：EnumSet和EnumMap 1、EnumSet EnumSet 是专门为盛放枚举类型所设计的 Set 类型。 还是举例来说，就以文中开头定义的角色枚举为例：

1
2
3
4
5
6
7
8
public enum UserRole {
 
    ROLE_ROOT_ADMIN,  // 系统管理员
 
    ROLE_ORDER_ADMIN, // 订单管理员
 
    ROLE_NORMAL       // 普通用户
}

  比如系统里来了一批人，我们需要查看他是不是某个角色中的一个：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 定义一个管理员角色的专属集合
EnumSet<UserRole> userRolesForAdmin
    = EnumSet.of(
        UserRole.ROLE_ROOT_ADMIN,
        UserRole.ROLE_ORDER_ADMIN
    );
 
// 判断某个进来的用户是不是管理员
Boolean isAdmin( User user ) {
    
    if( userRoles.contains( user.getUserRole() ) )
        return true;
    
    return false;
}

  2、EnumMap 同样，EnumMap 则是用来专门盛放枚举类型为key的 Map 类型。 比如，系统里来了一批人，我们需要统计不同的角色到底有多少人这种的话：

1
2
3
4
5
6
7
8
9
10
Map<UserRole,Integer> userStatisticMap = new EnumMap<>(UserRole.class);
 
for ( User user : userList ) {
    Integer num = userStatisticMap.get( user.getUserRole() );
    if( null != num ) {
        userStatisticMap.put( user.getUserRole(), num+1 );
    } else {
        userStatisticMap.put( user.getUserRole(), 1 );
    }
}

  用EnumMap可以说非常方便了。 总 结 小小的枚举就玩出这么多的花样，不过好在探索和总结的过程还挺有意思的，也复习了很多知识，慢慢来吧。   from:https://my.oschina.net/hansonwang99/blog/3196498

龙生   25 Mar 2020
View Details

centos7查看JAVA_HOME

windows： set java_home:查看JDK安装路径 java -version:查看JDK版本 linux： whereis java which java （java执行路径） echo $JAVA_HOME echo $PATH from:https://blog.csdn.net/Xin7Xin/article/details/86304542

龙生   27 Dec 2019
View Details

java:bytes[]转long的三种方式

bytes[] 到数字类型的转换是个经常用到的代码,解决方式也不止一种，最近需要将bytes[]转为long,有机会深入了解了一下，此文做个总结。 java代码实现 如果不想借助任何已经有的类，完全可以自己实现这段代码，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    /**
     * 将字节数组转为long<br>
     * 如果input为null,或offset指定的剩余数组长度不足8字节则抛出异常
     * @param input
     * @param offset 起始偏移量
     * @param littleEndian 输入数组是否小端模式
     * @return
     */
    public static long longFrom8Bytes(byte[] input, int offset, boolean littleEndian){
        long value=0;
        // 循环读取每个字节通过移位运算完成long的8个字节拼装
        for(int  count=0;count<8;++count){
            int shift=(littleEndian?count:(7-count))<<3;
            value |=((long)0xff<< shift) & ((long)input[offset+count] << shift);
        }
        return value;
    }

借助java.nio.ByteBuffer实现 java.nio.ByteBuffer 本身就有getLong,getInt,getFloat….方法,只要将byte[]转换为ByteBuffer就可以实现所有primitive类型的数据读取,参见javadoc。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    /**
     * 利用 {@link java.nio.ByteBuffer}实现byte[]转long
     * @param input
     * @param offset
     * @param littleEndian 输入数组是否小端模式
     * @return
     */
    public static long bytesToLong(byte[] input, int offset, boolean littleEndian) {
        // 将byte[] 封装为 ByteBuffer
        ByteBuffer buffer = ByteBuffer.wrap(input,offset,8);
        if(littleEndian){
            // ByteBuffer.order(ByteOrder) 方法指定字节序,即大小端模式(BIG_ENDIAN/LITTLE_ENDIAN)
            // ByteBuffer 默认为大端(BIG_ENDIAN)模式
            buffer.order(ByteOrder.LITTLE_ENDIAN);
        }
        return buffer.getLong();  
    }

  借助java.io.DataInputStream实现 java.io.DataInputStream 同样提供了readLong,readLong,readLong….方法,只要将byte[]转换为DataInputStream就可以实现所有primitive类型的数据读取,参见javadoc。 完整测试代码 下面的Junit 测试代码计算String 的MD5校验码(16 bytes),然后使用上述方式分别将16 bytes转换为2个long(大端模式)然后以16进制模式输出结果,以验证三种方式一致性。

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
package net.gdface.facelog;
 
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import org.junit.Test;
 
 
public class TestSerialVersionUID {
    /**
     * 生成MD5校验码
     *
     * @param source
     * @return
     */
    static public byte[] getMD5(byte[] source) {
        if (null==source)
            return null;
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            return md.digest(source);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 将16位byte[] 转换为32位的HEX格式的字符串String
     *
     * @param buffer
     * @return
     */
    static public String toHex(byte buffer[]) {
        if (null==buffer)
            return null;
        StringBuffer sb = new StringBuffer(buffer.length * 2);
        for (int i = 0; i < buffer.length; i++) {
            sb.append(Character.forDigit((buffer[i] & 240) >> 4, 16));
            sb.append(Character.forDigit(buffer[i] & 15, 16));
        }
        return sb.toString();
    }
 
    /**
     * 将字节数组转为long<br>
     * 如果input为null,或offset指定的剩余数组长度不足8字节则抛出异常
     * @param input
     * @param offset 起始偏移量
     * @param littleEndian 输入数组是否小端模式
     * @return
     */
    public static long longFrom8Bytes(byte[] input, int offset, boolean littleEndian){
        if(offset <0 || offset+8>input.length)
            throw new IllegalArgumentException(String.format("less than 8 bytes from index %d  is insufficient for long",offset));
        long value=0;
        for(int  count=0;count<8;++count){
            int shift=(littleEndian?count:(7-count))<<3;
            value |=((long)0xff<< shift) & ((long)input[offset+count] << shift);
        }
        return value;
    }
 
    /**
     * 利用 {@link java.nio.ByteBuffer}实现byte[]转long
     * @param input
     * @param offset
     * @param littleEndian 输入数组是否小端模式
     * @return
     */
    public static long bytesToLong(byte[] input, int offset, boolean littleEndian) {
        if(offset <0 || offset+8>input.length)
            throw new IllegalArgumentException(String.format("less than 8 bytes from index %d  is insufficient for long",offset));
        ByteBuffer buffer = ByteBuffer.wrap(input,offset,8);
        if(littleEndian){
            // ByteBuffer.order(ByteOrder) 方法指定字节序,即大小端模式(BIG_ENDIAN/LITTLE_ENDIAN)
            // ByteBuffer 默认为大端(BIG_ENDIAN)模式
            buffer.order(ByteOrder.LITTLE_ENDIAN);
        }
        return buffer.getLong();  
    }
    @Test
    public void test() throws IOException {
        String input="net.gdface.facelog.dborm.person.FlPersonBeanBase";
        byte[] md5 = getMD5(input.getBytes());
        System.out.printf("md5 [%s]\n",toHex(md5));
        // 三种方式运算结果对比验证
        DataInputStream dataInput = new DataInputStream(new ByteArrayInputStream(md5));
        long l1 = dataInput.readLong();
        long l2 = dataInput.readLong();
        System.out.printf("l1=0x%x l2=0x%x,DataInputStream\n", l1,l2);
 
        long ln1 = bytesToLong(md5,0, false);
        long ln2 = bytesToLong(md5,8, false);
        System.out.printf("ln1=0x%x ln2=0x%x,ByteBuffer\n", ln1,ln2);
 
        long ll1 = longFrom8Bytes(md5,0, false);
        long ll2 = longFrom8Bytes(md5,8, false);    
        System.out.printf("ll1=0x%x ll2=0x%x\n", ll1,ll2);
    }
}

输出结果 md5 [39627933ceeebf2740e1f822921f5837] l1=0x39627933ceeebf27 l2=0x40e1f822921f5837,DataInputStream ln1=0x39627933ceeebf27 ln2=0x40e1f822921f5837,,ByteBuffer ll1=0x39627933ceeebf27 ll2=0x40e1f822921f5837 参考资料 《Java 中 byte、byte 数组和 int、long 之间的转换》   from:https://blog.csdn.net/10km/article/details/77435659

龙生   23 Nov 2019
View Details

Java中四种线程安全的单例模式实现方式

第一种：饿汉模式（线程安全）

1
2
3
4
5
6
7
8
9
10
11
12
public class Single2 {
 
    private static Single2 instance = new Single2();
    
    private Single2(){
        System.out.println("Single2: " + System.nanoTime());
    }
    
    public static Single2 getInstance(){
        return instance;
    }
}

  第二种：懒汉模式 （如果方法没有synchronized，则线程不安全）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Single3 {
 
    private static Single3 instance = null;
    
    private Single3(){
        System.out.println("Single3: " + System.nanoTime());
    }
    
    public static synchronized Single3 getInstance(){
        if(instance == null){
            instance = new Single3();
        }
        return instance;
    }
}

  第三种：懒汉模式改良版（线程安全，使用了double-check，即check-加锁-check，目的是为了减少同步的开销）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Single4 {
 
    private volatile static Single4 instance = null;
    
    private Single4(){
        System.out.println("Single4: " + System.nanoTime());
    }
    
    public static Single4 getInstance(){
        if(instance == null){
            synchronized (Single4.class) {
                if(instance == null){
                    instance = new Single4();
                }
            }
        }
        return instance;
    }
}

  第四种：利用私有的内部工厂类（线程安全，内部类也可以换成内部接口，不过工厂类变量的作用域要改为public了。）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Singleton {
    
    private Singleton(){
        System.out.println("Singleton: " + System.nanoTime());
    }
    
    public static Singleton getInstance(){
        return SingletonFactory.singletonInstance;
    }
    
    private static class SingletonFactory{
        private static Singleton singletonInstance = new Singleton();
    }
}

  from:https://my.oschina.net/yangchunlian/blog/1607947

龙生   23 Nov 2019
View Details
1 … 40 41 42 … 64

Copyright © 2025 Longsheng All rights reserved