java调用go、js、python、groovy和Caffeine缓存

约定不等于承诺〃 2023-02-18 03:21 80阅读 0赞

## 一、Caffeine缓存、Caffeine基于java8的高性能,接近最优的缓存库。 ##

<dependency>
                <groupId>com.github.ben-manes.caffeine</groupId>
                <artifactId>caffeine</artifactId>
                <version>2.8.4</version>
            </dependency>
    
            <dependency>
                <groupId>com.github.ben-manes.caffeine</groupId>
                <artifactId>guava</artifactId>
                <version>2.8.4</version>
            </dependency>
    
            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>29.0-jre</version>
            </dependency>

import com.github.benmanes.caffeine.cache.*;
    import com.github.benmanes.caffeine.guava.CaffeinatedGuava;
    import com.google.common.graph.Graph;
    import lombok.NonNull;
    
    import javax.annotation.Nullable;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.TimeoutException;
    
    import static io.reactivex.internal.util.NotificationLite.getValue;
    
    public class CaffeineCache { 
    
        /** * Caffeine 缓存 */
        public static void test1(){ 
            Cache<String, String> cache = Caffeine.newBuilder()
                    // 数量上限
                    .maximumSize(1024)
                    // 过期机制
                    .expireAfterWrite(5, TimeUnit.MINUTES)
                    // 弱引用key
                    .weakKeys()
                    // 弱引用value
                    .weakValues()
                    // 剔除监听
                    .removalListener((RemovalListener<String, String>) (key, value, cause) ->
                            System.out.println("key:" + key + ", value:" + value + ", 删除原因:" + cause.toString()))
                    .build();
            // 将数据放入本地缓存中
            cache.put("username", "afei");
            cache.put("password", "123456");
            // 从本地缓存中取出数据
            System.out.println(cache.getIfPresent("username"));
            System.out.println(cache.getIfPresent("password"));
            //cache.get("blog", key -> { 
            // 本地缓存没有的话，从数据库或者Redis中获取
            //return getValue(key);
            //});
        }
    
        /** * Caffeine 异步加载缓存 * @throws ExecutionException * @throws InterruptedException * @throws TimeoutException */
        public static void test2() throws ExecutionException, InterruptedException, TimeoutException { 
            AsyncLoadingCache<String, String> cache = Caffeine.newBuilder()
                    // 数量上限
                    .maximumSize(2)
                    // 失效时间
                    .expireAfterWrite(5, TimeUnit.MINUTES)
                    .refreshAfterWrite(1, TimeUnit.MINUTES)
                    // 异步加载机制
                    .buildAsync(new CacheLoader<String, String>() { 
                        @Nullable
                        @Override
                        public String load(@NonNull String key) { 
                            return getValue(key);
                        }
                    });
            System.out.println(cache.get("username").get());
            System.out.println(cache.get("password").get(10, TimeUnit.MINUTES));
            System.out.println(cache.get("username").get(10, TimeUnit.MINUTES));
            System.out.println(cache.get("blog").get());
        }
    
        /** * Guava缓存 转换 Caffeine缓存 */
        public static void test3(){ 
            LoadingCache<String, Graph> graphs = (LoadingCache<String, Graph>) CaffeinatedGuava.build(
                    Caffeine.newBuilder().maximumSize(10_000),
                    (CacheLoader<String, Graph>) key -> createExpensiveGraph(key));
            System.out.println(graphs.asMap());
        }
    
        private static Graph createExpensiveGraph(String key) { 
            LoadingCache<String, Object> loadingCache = Caffeine.newBuilder()
                    .maximumSize(10_000)
                    .expireAfterWrite(10, TimeUnit.MINUTES)
                    .build(keys -> createExpensiveGraph(keys));
            return (Graph) loadingCache.get(key);
        }
    
    
        /** * Guava本地缓存 */
        public static void test4(){ 
            LoadingCache<String, Object> loadingCache = Caffeine.newBuilder()
                    .maximumSize(10_000)
                    .expireAfterWrite(10, TimeUnit.MINUTES)
                    .build(key -> createExpensiveGraph(key));
            String key = "name";
            // 采用同步方式去获取一个缓存和上面的手动方式是一个原理。在build Cache的时候会提供一个createExpensiveGraph函数。
            // 查询并在缺失的情况下使用同步的方式来构建一个缓存
            Object graph = loadingCache.get(key);
            // 获取组key的值返回一个Map
            List<String> keys = new ArrayList<>();
            keys.add(key);
            Map<String, Object> graphs = loadingCache.getAll(keys);
        }
    
    
        public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException { 
            test1();
            test2();
            test3();
            test4();
    
        }
    }

## 二、解决 Result window is too large, from + size must be less than or equal to: \[10000\] but was \[12910\]. See the scroll api for a more efficient way to request large data sets. This limit can be set by changing the \[index.max\_result\_window\] index level setting. ##

import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.boot.context.event.ApplicationReadyEvent;
    import org.springframework.context.ApplicationListener;
    import org.springframework.core.env.Environment;
    import org.springframework.http.MediaType;
    import org.springframework.stereotype.Service;
    import java.nio.charset.StandardCharsets;
    import java.util.HashMap;
    import java.util.Map;
    
    /** * 解决Result window is too large, from + size must be less than or equal to: [10000] but was [12910]. * See the scroll api for a more efficient way to request large data sets. * This limit can be set by changing the [index.max_result_window] index level setting. */
    @Service
    @Slf4j
    public class InitElasticSearch implements ApplicationListener<ApplicationReadyEvent> { 
    
        @Override
        public void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent) { 
            //设置ES的初始化分页搜索
            Environment env = applicationReadyEvent.getApplicationContext().getEnvironment();
            String serverIp = env.getProperty("spring.data.elasticsearch.cluster-nodes");
            if (StringUtils.isNotBlank(serverIp)){ 
                String[] split = serverIp.split(":");
                String port =  env.getProperty("spring.data.elasticsearch.http-port");
                String settings = "{\"max_result_window\":\"2000000000\"}";
                String url = "http://" + split[0] + ":" + port + "/*/_settings?preserve_existing=true";
                Map<String, String> headers = new HashMap<>();
                headers.put("Content-Type", MediaType.APPLICATION_JSON_UTF8_VALUE);
                byte[] bytes = HttpUtils.sendRequest(url, headers, settings.getBytes(StandardCharsets.UTF_8), "PUT");
                String result = new String(bytes, StandardCharsets.UTF_8);
                log.info("初始化ES分页搜索：{}",result);
    
        }
    
    }

将所有的索引设置`2000000000`，因为ElasticSearch对from + size的大小进行限制，必须小于等于10000，不满足业务需求。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70]

## 三、java调用go、js、python、groovy ##

<dependency>
                <groupId>org.python</groupId>
                <artifactId>jython</artifactId>
                <version>2.7.0</version>
            </dependency>
    
            <dependency>
                <groupId>org.python</groupId>
                <artifactId>jython-standalone</artifactId>
                <version>2.7.0</version>
            </dependency>
    
            <dependency>
                  <groupId>net.java.dev.jna</groupId>
                  <artifactId>jna</artifactId>
                  <version>4.5.2</version>
            </dependency>
            
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.1.1</version>
            </dependency>

import java.util.HashMap;
    import java.util.Map;
    
    import javax.script.ScriptEngine;
    import javax.script.ScriptEngineManager;
    import javax.script.SimpleBindings;
    
    public class JsScriptEngine { 
    
        public static String runCode(String jsCode, Map<String, Object> params) { 
            try { 
                ScriptEngineManager engineManager= new ScriptEngineManager();
                ScriptEngine scriptEngine = engineManager.getEngineByName("JavaScript");
                return scriptEngine.eval(jsCode, new SimpleBindings(params)).toString();
            } catch (Exception e) { 
                throw new RuntimeException("执行js脚本出错,"+jsCode);
            }
        }
    
        public static String runCode(String jsCode) { 
            return runCode(jsCode, new HashMap<>());
        }
    
    }

import com.sun.jna.Structure;
    import java.util.ArrayList;
    import java.util.List;
    
    
    /** * @author nick */
    public class GoString extends Structure { 
    
        public String str;
    
    
        public GoString() { 
    
        }
    
        public GoString(String str) { 
            this.str = str;
        }
    
        @Override
        protected List<String> getFieldOrder() { 
            List<String> fields = new ArrayList<>();
            fields.add("str");
            return fields;
        }
    
        public static class byvalue extends GoString implements Structure.ByValue { 
            public byvalue(String str) { 
                super(str);
            }
        }
    
        public static class byreference extends GoString implements Structure.ByReference { 
            public byreference(String str) { 
                super(str);
            }
        }
    }

import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    
    
    public class FileUtils { 
    
        /** * 读取文件并返回utf8编码的字符流 * @param fileName * @return * @throws IOException */
        public static String readText(String fileName) throws IOException { 
            File file = new File(fileName);
            if (!file.exists()) { 
                throw new FileNotFoundException();
            }
            FileInputStream in = new FileInputStream(file);
            StringBuffer result = new StringBuffer();
            // 指定读取文件时以UTF-8的格式读取
            try(BufferedReader br = new BufferedReader(
                    new InputStreamReader(in, "UTF-8"))) { 
                String line;
                while ((line = br.readLine()) != null) { 
                    result.append(line).append("\n");
                }
            }
            return result.toString();
        }
    
        public static String readText(InputStream inputStream) throws IOException { 
            StringBuffer result = new StringBuffer();
            // 指定读取文件时以UTF-8的格式读取
            try(BufferedReader br = new BufferedReader(
                    new InputStreamReader(inputStream, "UTF-8"))) { 
                String line;
                while ((line = br.readLine()) != null) { 
                    result.append(line).append("\n");
                }
            }
            return result.toString();
        }
    
    }

import javax.management.MXBean;
    
    /** * JMX管理 * @author nick */
    @MXBean
    public interface JmxMonitorMXBean { 
    
    	/** * print server detail, * including memory, thread, buff * @return */
    	void printServer();
    
    	/** * execute JavaScript code * @param jsCode * @return */
    	void execJavaScript(String jsCode);
    
    	/** * execute groovy code * @param groovyCode * @return */
    	void execGroovyScript(String groovyCode);
    
    
    	/** * execute go code * @param goCode */
    	void execGoScript(String goCode);
    
    
    	/** * execute python code * @param pythonCode */
    	void execPythonScript(String pythonCode);
    
    }

import com.sun.jna.Native;
    import lombok.extern.slf4j.Slf4j;
    import org.python.core.PyObject;
    import org.python.util.PythonInterpreter;
    import javax.script.ScriptEngine;
    import javax.script.ScriptEngineManager;
    import java.lang.management.*;
    import java.util.List;
    import static cn.hutool.system.SystemUtil.*;
    import static java.lang.management.ManagementFactory.getPlatformMXBeans;
    
    /** * @author nick */
    @Slf4j
    public class JmxMonitor implements JmxMonitorMXBean { 
    
    	@Override
    	public void printServer() { 
            log.info("运行环境可用cpu核心数量为:{}",Runtime.getRuntime().availableProcessors());
    		log.info("最大内存为:{}",bytes2MB(Runtime.getRuntime().maxMemory()));
    		log.info("总内存为:{}",bytes2MB(Runtime.getRuntime().totalMemory()));
    		log.info("空闲内存为:{}",bytes2MB(Runtime.getRuntime().freeMemory()));
    		MemoryMXBean memoryMXBean = getMemoryMXBean();
    		log.info("使用的堆内存:{}",bytes2MB(memoryMXBean.getHeapMemoryUsage().getUsed()));
    		List<BufferPoolMXBean> buffMXBeans = getPlatformMXBeans(BufferPoolMXBean.class);
    		buffMXBeans.stream().forEach(e-> log.info("缓冲池:{}, 缓冲池使用:{}, 缓冲池总计:{}",e.getName(), bytes2MB(e.getMemoryUsed()),bytes2MB(e.getTotalCapacity())));
    		List<GarbageCollectorMXBean> gcMXBeans = getGarbageCollectorMXBeans();
    		gcMXBeans.stream().forEach(e-> log.info(String.format("%s 发生 %s 次 gc, gc 总共消耗 %s 毫秒", e.getName(), e.getCollectionCount(), e.getCollectionTime())));
    		ThreadMXBean threadMXBean = getThreadMXBean();
    		int threadRun = 0;
    		int threadBlocked = 0;
    		int threadWaiting = 0;
    		for (long threadId : threadMXBean.getAllThreadIds()) { 
    			ThreadInfo threadInfo = threadMXBean.getThreadInfo(threadId);
    			if (threadInfo.getThreadState() == Thread.State.RUNNABLE) { 
    				threadRun++;
    			}
    			if (threadInfo.getThreadState() == Thread.State.BLOCKED) { 
    				threadBlocked++;
    			}
    			if (threadInfo.getThreadState() == Thread.State.WAITING) { 
    				threadWaiting++;
    			}
    		}
    		log.info(String.format("活跃线程数 %s, 阻塞线程数 %s, 等待线程数 %s", threadRun, threadBlocked, threadWaiting));
    	}
    
    
    	private static long bytes2MB(long bytes) { 
    		return Math.floorDiv(bytes, 1024 * 1024L);
    	}
    
    	/** * 实现JS方法 * @param jsCode */
    	@Override
    	public void execJavaScript(String jsCode){ 
    		try { 
    			String jsCodes = JsScriptEngine.runCode(jsCode);
    			log.info("js代码执行成功,{}",jsCodes);
    		} catch (Exception e) { 
    			log.error("js代码执行异常,{}",e);
    		}
    	}
    
    	/** * 实现Groovy方法 * @param groovyCode */
    	@Override
    	public void execGroovyScript(String groovyCode) { 
    		try { 
    			ScriptEngineManager engineManager= new ScriptEngineManager();
    			ScriptEngine scriptEngine = engineManager.getEngineByName("groovy");
    			Object eval = scriptEngine.eval(groovyCode);
    			log.info("groovy代码执行成功,{}",eval);
    		} catch (Exception e) { 
    			log.error("groovy代码执行异常,{}",e);
    		}
    	}
    
    	/** * 实现Go方法 * 第一种方式：当你在一个项目中需要同时使用java和go语言时，java语言对应的框架为servicecomb-java-chassis， go对应的框架为go-chassis，他们之间可以通过servicecomb-service-center进行关联。 * 第二种方式：Java调用Golang生成的动态库（dll,so） * 执行如下命令生成DLL动态链接库 ：go build -buildmode=c-shared -o lib.dll .\lib.go * 执行如下命令生成SO动态库 ：go build -buildmode=c-shared -o lib.so .\lib.go * @param goCode */
    	@Override
    	public void execGoScript(String goCode) { 
    		try { 
    			String eval = Native.loadLibrary(goCode, String.class);
    			GoString goString = new GoString(eval);
    			log.info("go代码执行成功,{}",goString);
    		} catch (Exception e){ 
    			log.error("go代码执行异常,{}",e);
    		}
    
    	}
    
    	/** * 实现Python方法 * @param pythonCode */
    	@Override
    	public void execPythonScript(String pythonCode) { 
    		try { 
    			PythonInterpreter interpreter = new PythonInterpreter();
    			PyObject eval = interpreter.eval(pythonCode);
    			log.info("python代码执行成功,{}",eval);
    		}catch (Exception e){ 
    			log.error("python代码执行异常,{}",e);
    		}
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200615211539277.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx,size_16,color_FFFFFF,t_70