中科创达-针对接口幂等性的依赖库

ThunderSoft_repeatsubmitfilter/README.md

@@ -0,0 +1,19 @@
+# ShortUrl
+Repeatsubmitfilter是一个防止重复提交的依赖库
+
+
+## 逻辑详情
+系统加载直接自动使用
+
+## 使用步骤说明
+
+1.  应用引用依赖库
+2.  配置应用配置参数 （无需配置）
+3.  逻辑调用示例截图
+注意：需要根据自己的业务修改一下放行的白名单
+
+参考文档
+
+## 应用演示链接
+
+[使用了本依赖库的制品应用链接]

ThunderSoft_repeatsubmitfilter/pom.xml

@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>2.2.9.RELEASE</version><!--与当前制品应用默认版本统一-->
+    </parent>
+
+    <groupId>com.hq</groupId>
+    <artifactId>repeatsubmitfilter</artifactId>
+    <version>1.1.6</version>
+ <name>弱网情况下防止重复提交</name>
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <nasl.ide.version>3.3</nasl.ide.version>
+    </properties>
+    <dependencies>
+        <!--本案例是本地系统引入nasl-metadata-collector-0.7.0.jar的方式。
+        若把nasl-metadata-collector-0.7.0.jar安装到自己的maven仓库，
+        注意修改artifactId和groupId的情况下，不要使用<scope>system</scope>，会在发布时造成依赖中断。
+        不修改artifactId和groupId的情况下，nasl-metadata-maven-plugin会做特殊处理-->
+       <dependency>
+        <artifactId>nasl-metadata-collector</artifactId>
+        <groupId>com.netease.lowcode</groupId>
+        <version>0.7.0</version>
+        <optional>true</optional>
+        <scope>system</scope>
+        <systemPath>${project.basedir}/lib/nasl-metadata-collector-0.7.0.jar</systemPath>
+    </dependency>
+        <!--制品应用使用Springboot框架，父应用引用了的包，为了防止版本冲突，scope可设置为provided-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <version>3.3.0</version>
+                <configuration>
+                    <descriptorRefs>
+                        <descriptorRef>jar-with-dependencies</descriptorRef>
+                    </descriptorRefs>
+                    <appendAssemblyId>false</appendAssemblyId>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>make-assembly</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>com.netease.lowcode</groupId>
+                <artifactId>nasl-metadata-maven-plugin</artifactId>
+                <version>1.3.0</version>
+                <configuration>
+                    <jarWithDependencies>true</jarWithDependencies>
+                </configuration>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>archive</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

ThunderSoft_repeatsubmitfilter/src/main/java/com/cache/Cache.java

@@ -0,0 +1,51 @@
+package com.cache;
+
+
+public class Cache {   
+        private String key;//缓存ID   
+        private Object value;//缓存数据   
+        private long timeOut;//更新时间   
+        private boolean expired; //是否终止   
+        public Cache() {   
+                super();   
+        }   
+
+        public Cache(String key, Object value, long timeOut, boolean expired) {   
+                this.key = key;   
+                this.value = value;   
+                this.timeOut = timeOut;   
+                this.expired = expired;   
+        }   
+
+        public String getKey() {   
+                return key;   
+        }   
+
+        public long getTimeOut() {   
+                return timeOut;   
+        }   
+
+        public Object getValue() {   
+                return value;   
+        }   
+
+        public void setKey(String string) {   
+                key = string;   
+        }   
+
+        public void setTimeOut(long l) {   
+                timeOut = l;   
+        }   
+
+        public void setValue(Object object) {   
+                value = object;   
+        }   
+
+        public boolean isExpired() {   
+                return expired;   
+        }   
+
+        public void setExpired(boolean b) {   
+                expired = b;   
+        }   
+}

ThunderSoft_repeatsubmitfilter/src/main/java/com/cache/CacheManager.java

@@ -0,0 +1,198 @@
+package com.cache;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+
+
+public class CacheManager {   
+    private static HashMap cacheMap = new HashMap();   
+
+    //单实例构造方法   
+    private CacheManager() {   
+        super();   
+    }   
+    //获取布尔值的缓存   
+    public static boolean getSimpleFlag(String key){   
+        try{   
+            return (Boolean) cacheMap.get(key);   
+        }catch(NullPointerException e){   
+            return false;   
+        }   
+    }   
+    public static long getServerStartdt(String key){   
+        try {   
+            return (Long)cacheMap.get(key);   
+        } catch (Exception ex) {   
+            return 0;   
+        }   
+    }   
+    //设置布尔值的缓存   
+    public  static boolean setSimpleFlag(String key,boolean flag){
+        if (flag && getSimpleFlag(key)) {//假如为真不允许被覆盖   
+            return false;   
+        }else{   
+            cacheMap.put(key, flag);   
+            return true;   
+        }   
+    }   
+    public  static boolean setSimpleFlag(String key,long serverbegrundt){
+        if (cacheMap.get(key) == null) {   
+            cacheMap.put(key,serverbegrundt);   
+            return true;   
+        }else{   
+            return false;   
+        }   
+    }   
+
+
+    //得到缓存。同步静态方法   
+    private synchronized static Cache getCache(String key) {
+        return (Cache) cacheMap.get(key);
+    }   
+
+    //判断是否存在一个缓存   
+    private synchronized static boolean hasCache(String key) {   
+        return cacheMap.containsKey(key);   
+    }   
+
+    //清除所有缓存   
+    public synchronized static void clearAll() {   
+        cacheMap.clear();   
+    }   
+
+    //清除某一类特定缓存,通过遍历HASHMAP下的所有对象，来判断它的KEY与传入的TYPE是否匹配   
+    public synchronized static void clearAll(String type) {   
+        Iterator i = cacheMap.entrySet().iterator();   
+        String key;   
+        ArrayList<String> arr = new ArrayList<String>();   
+        try {   
+            while (i.hasNext()) {   
+                java.util.Map.Entry entry = (java.util.Map.Entry) i.next();   
+                key = (String) entry.getKey();   
+                if (key.startsWith(type)) { //如果匹配则删除掉   
+                    arr.add(key);   
+                }   
+            }   
+            for (int k = 0; k < arr.size(); k++) {   
+                clearOnly(arr.get(k));   
+            }   
+        } catch (Exception ex) {   
+            ex.printStackTrace();   
+        }   
+    }   
+
+    //清除指定的缓存   
+    public synchronized static void clearOnly(String key) {   
+        cacheMap.remove(key);   
+    }   
+
+    //载入缓存   
+    public synchronized static void putCache(String key, Cache obj) {
+        cacheMap.put(key, obj);   
+    }   
+
+    //获取缓存信息   
+    public static Cache getCacheInfo(String key) {
+
+        if (hasCache(key)) {   
+            Cache cache = getCache(key);
+            if (cacheExpired(cache)) { //调用判断是否终止方法   
+                cache.setExpired(true);   
+            }   
+            return cache;   
+        }else  
+            return null;   
+    }   
+
+    //载入缓存信息   
+    public static void putCacheInfo(String key, Cache obj, long dt, boolean expired) {
+        Cache cache = new Cache();
+        cache.setKey(key);   
+        cache.setTimeOut(dt + System.currentTimeMillis()); //设置多久后更新缓存   
+        cache.setValue(obj);   
+        cache.setExpired(expired); //缓存默认载入时，终止状态为FALSE   
+        cacheMap.put(key, cache);   
+    }   
+    //重写载入缓存信息方法   
+    public static void putCacheInfo(String key, Cache obj, long dt){
+        Cache cache = new Cache();
+        cache.setKey(key);   
+        cache.setTimeOut(dt+System.currentTimeMillis());   
+        cache.setValue(obj);   
+        cache.setExpired(false);   
+        cacheMap.put(key,cache);   
+    }   
+
+    //判断缓存是否终止   
+    public static boolean cacheExpired(Cache cache) {
+        if (null == cache) { //传入的缓存不存在   
+            return false;   
+        }   
+        long nowDt = System.currentTimeMillis(); //系统当前的毫秒数   
+        long cacheDt = cache.getTimeOut(); //缓存内的过期毫秒数   
+        if (cacheDt <= 0||cacheDt>nowDt) { //过期时间小于等于零时,或者过期时间大于当前时间时，则为FALSE   
+            return false;   
+        } else { //大于过期时间 即过期   
+            return true;   
+        }   
+    }   
+
+    //获取缓存中的大小   
+    public static int getCacheSize() {   
+        return cacheMap.size();   
+    }   
+
+    //获取指定的类型的大小   
+    public static int getCacheSize(String type) {   
+        int k = 0;   
+        Iterator i = cacheMap.entrySet().iterator();   
+        String key;   
+        try {   
+            while (i.hasNext()) {   
+                java.util.Map.Entry entry = (java.util.Map.Entry) i.next();   
+                key = (String) entry.getKey();   
+                if (key.indexOf(type) != -1) { //如果匹配则删除掉   
+                    k++;   
+                }   
+            }   
+        } catch (Exception ex) {   
+            ex.printStackTrace();   
+        }   
+
+        return k;   
+    }   
+
+    //获取缓存对象中的所有键值名称   
+    public static ArrayList<String> getCacheAllkey() {   
+        ArrayList a = new ArrayList();   
+        try {   
+            Iterator i = cacheMap.entrySet().iterator();   
+            while (i.hasNext()) {   
+                java.util.Map.Entry entry = (java.util.Map.Entry) i.next();   
+                a.add((String) entry.getKey());   
+            }   
+        } catch (Exception ex) {} finally {   
+            return a;   
+        }   
+    }   
+
+    //获取缓存对象中指定类型 的键值名称   
+    public static ArrayList<String> getCacheListkey(String type) {   
+        ArrayList a = new ArrayList();   
+        String key;   
+        try {   
+            Iterator i = cacheMap.entrySet().iterator();   
+            while (i.hasNext()) {   
+                java.util.Map.Entry entry = (java.util.Map.Entry) i.next();   
+                key = (String) entry.getKey();   
+                if (key.indexOf(type) != -1) {   
+                    a.add(key);   
+                }   
+            }   
+        } catch (Exception ex) {} finally {   
+            return a;   
+        }   
+    }   
+
+}

ThunderSoft_repeatsubmitfilter/src/main/java/com/hq/LibhqFilterEnvironmentConfiguration.java

@@ -0,0 +1,15 @@
+package com.hq;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * 加入spring环境配置（在spring.factories中指定）
+ */
+@Configuration
+@ComponentScan(basePackageClasses = LibraryAutoScan.class)
+public class LibhqFilterEnvironmentConfiguration {
+    public LibhqFilterEnvironmentConfiguration() {
+        System.out.println("LibhqFilterEnvironmentConfiguration");
+    }
+}

ThunderSoft_repeatsubmitfilter/src/main/java/com/hq/LibraryAutoScan.java

@@ -0,0 +1,8 @@
+package com.hq;
+
+/**
+ * 依赖库自动扫描类
+ * @author system
+ */
+public class LibraryAutoScan {
+}