后端开发日常积累

红太狼 2022-03-08 02:18 204阅读 0赞

## 1.okhttp请求https，卸载或者信任SSL证书、工具类 ##

package com.hzbank.counter.utils;
    
    import okhttp3.*;
    import org.apache.commons.lang.exception.ExceptionUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import javax.net.ssl.*;
    import java.io.IOException;
    import java.security.SecureRandom;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.concurrent.TimeUnit;
    
    
    /**
     * okhttp  请求
     *
     * @author nick
     */
    public class OkHttpUtil {
    
        private static final Logger logger = LoggerFactory.getLogger(OkHttpUtil.class);
    
        private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
    
        /**
         * get
         *
         * @param url     请求的url
         * @param queries 请求的参数，在浏览器？后面的数据，没有可以传null
         * @return
         */
        public static String get(String url, Map<String, String> queries) {
            String responseBody = "";
            StringBuffer sb = new StringBuffer(url);
            if (queries != null && queries.keySet().size() > 0) {
                boolean firstFlag = true;
                Iterator iterator = queries.entrySet().iterator();
                while (iterator.hasNext()) {
                    Map.Entry entry = (Map.Entry<String, String>) iterator.next();
                    if (firstFlag) {
                        sb.append("?" + entry.getKey() + "=" + entry.getValue());
                        firstFlag = false;
                    } else {
                        sb.append("&" + entry.getKey() + "=" + entry.getValue());
                    }
                }
            }
            Request request = new Request.Builder()
                    .url(sb.toString())
                    .build();
            Response response = null;
            try {
                OkHttpClient okHttpClient = new OkHttpClient();
                response = okHttpClient.newCall(request).execute();
                int status = response.code();
                if (response.isSuccessful()) {
                    return response.body().string();
                }
            } catch (Exception e) {
                logger.error("okhttp3 put error >> ex = {}", ExceptionUtils.getStackTrace(e));
            } finally {
                if (response != null) {
                    response.close();
                }
            }
            return responseBody;
        }
    
        /**
         * post
         *
         * @param url    请求的url
         * @param params post form 提交的参数
         * @return
         */
        public static String post(String url, Map<String, String> params) {
            String responseBody = "";
            FormBody.Builder builder = new FormBody.Builder();
            //添加参数
            if (params != null && params.keySet().size() > 0) {
                for (String key : params.keySet()) {
                    builder.add(key, params.get(key));
                }
            }
            Request request = new Request.Builder()
                    .url(url)
                    .post(builder.build())
                    .build();
            Response response = null;
            try {
                OkHttpClient okHttpClient = new OkHttpClient();
                response = okHttpClient.newCall(request).execute();
                int status = response.code();
                if (response.isSuccessful()) {
                    return response.body().string();
                }
            } catch (Exception e) {
                logger.error("okhttp3 post error >> ex = {}", ExceptionUtils.getStackTrace(e));
            } finally {
                if (response != null) {
                    response.close();
                }
            }
            return responseBody;
        }
    
        /**
         * get
         *
         * @param url     请求的url
         * @param queries 请求的参数，在浏览器？后面的数据，没有可以传null
         * @return
         */
        public static String getForHeader(String url, Map<String, String> queries) {
            String responseBody = "";
            StringBuffer sb = new StringBuffer(url);
            if (queries != null && queries.keySet().size() > 0) {
                boolean firstFlag = true;
                Iterator iterator = queries.entrySet().iterator();
                while (iterator.hasNext()) {
                    Map.Entry entry = (Map.Entry<String, String>) iterator.next();
                    if (firstFlag) {
                        sb.append("?" + entry.getKey() + "=" + entry.getValue());
                        firstFlag = false;
                    } else {
                        sb.append("&" + entry.getKey() + "=" + entry.getValue());
                    }
                }
            }
            Request request = new Request.Builder()
                    .addHeader("key", "value")
                    .url(sb.toString())
                    .build();
            Response response = null;
            try {
                OkHttpClient okHttpClient = new OkHttpClient();
                response = okHttpClient.newCall(request).execute();
                int status = response.code();
                if (response.isSuccessful()) {
                    return response.body().string();
                }
            } catch (Exception e) {
                logger.error("okhttp3 put error >> ex = {}", ExceptionUtils.getStackTrace(e));
            } finally {
                if (response != null) {
                    response.close();
                }
            }
            return responseBody;
        }
    
        /**
         * Post请求发送JSON数据....{"name":"zhangsan","pwd":"123456"}
         * 参数一：请求Url
         * 参数二：请求的JSON
         * 参数三：请求回调
         */
        public static String postJsonParams(String url, String jsonParams) {
            String responseBody = "";
            RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), jsonParams);
            Request request = new Request.Builder()
                    .url(url)
                    .post(requestBody)
                    .build();
            Response response = null;
            try {
                OkHttpClient okHttpClient = new OkHttpClient();
                response = okHttpClient.newCall(request).execute();
                int status = response.code();
                if (response.isSuccessful()) {
                    return response.body().string();
                }
            } catch (Exception e) {
                logger.error("okhttp3 post error >> ex = {}", ExceptionUtils.getStackTrace(e));
            } finally {
                if (response != null) {
                    response.close();
                }
            }
            return responseBody;
        }
    
        /**
         * Post请求发送xml数据....
         * 参数一：请求Url
         * 参数二：请求的xmlString
         * 参数三：请求回调
         */
        public static String postXmlParams(String url, String xml) {
            String responseBody = "";
            RequestBody requestBody = RequestBody.create(MediaType.parse("application/xml; charset=utf-8"), xml);
            Request request = new Request.Builder()
                    .url(url)
                    .post(requestBody)
                    .build();
            Response response = null;
            try {
                OkHttpClient okHttpClient = new OkHttpClient();
                response = okHttpClient.newCall(request).execute();
                int status = response.code();
                if (response.isSuccessful()) {
                    return response.body().string();
                }
            } catch (Exception e) {
                logger.error("okhttp3 post error >> ex = {}", ExceptionUtils.getStackTrace(e));
            } finally {
                if (response != null) {
                    response.close();
                }
            }
            return responseBody;
        }
    
    
        /**
         * 发起get请求
         *
         * @param url
         * @return
         */
        public static String httpGet(String url) {
            String result = null;
            OkHttpClient client = new OkHttpClient();
            Request request = new Request.Builder().url(url).build();
            try {
                Response response = client.newCall(request).execute();
                result = response.body().string();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /**
         * 发送httppost请求
         *
         * @param url
         * @param data 提交的参数为key=value&key1=value1的形式
         * @return
         */
        public static String httpPostParam(String url, String data) {
            String result = null;
            OkHttpClient httpClient = new OkHttpClient();
            RequestBody requestBody = RequestBody.create(MediaType.parse("text/html;charset=utf-8"), data);
            Request request = new Request.Builder().url(url).post(requestBody).build();
            try {
                Response response = httpClient.newCall(request).execute();
                result = response.body().string();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return result;
        }
    
    
        /**
         * httppsot请求不带参数
         *
         * @param url
         * @return
         */
        public static String httpPost(String url) {
            String result = null;
            OkHttpClient httpClient = new OkHttpClient();
            Request request = new Request.Builder().url(url).build();
            try {
                Response response = httpClient.newCall(request).execute();
                result = response.body().string();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return result;
        }
    
    
    
        /**
         * OkHttpClient okHttpClient = new OkHttpClient();
         * 为:
         * OkHttpClient okHttpClient = getUnsafeOkHttpClient();
         * okHttp3添加信任所有证书
         */
        public static OkHttpClient getUnsafeOkHttpClient() {
    
            try {
                final TrustManager[] trustAllCerts = new TrustManager[]{
                        new X509TrustManager() {
                            @Override
                            public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) {
                            }
    
                            @Override
                            public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) {
                            }
    
                            @Override
                            public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                                return new java.security.cert.X509Certificate[]{};
                            }
                        }
                };
    
                final SSLContext sslContext = SSLContext.getInstance("SSL");
                sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
                final javax.net.ssl.SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
                OkHttpClient.Builder builder = new OkHttpClient.Builder();
                builder.sslSocketFactory(sslSocketFactory);
    
                builder.hostnameVerifier(new HostnameVerifier() {
                    @Override
                    public boolean verify(String hostname, SSLSession session) {
                        return true;
                    }
                });
    
                return builder.build();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
    
        }
    
        /**
         * 发送http post 请求
         * https请求时判断是否需要忽略证书
         *
         * @param url
         * @param json
         * @return
         */
        public static String httpPostNoSSL(String url, String json) {
            String res = "";
            //设置忽略证书--------start-------
            X509TrustManager xtm = new X509TrustManager() {
                @Override
                public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }
    
                @Override
                public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }
    
                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    X509Certificate[] x509Certificates = new X509Certificate[0];
                    return x509Certificates;
                }
            };
    
            SSLContext sslContext = null;
            try {
                sslContext = SSLContext.getInstance("SSL");
                sslContext.init(null, new TrustManager[]{xtm}, new SecureRandom());
            } catch (Exception e) {
                e.printStackTrace();
            }
            HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            };
            //设置忽略证书--------end-------
    
            OkHttpClient okHttpClient = new OkHttpClient().newBuilder().hostnameVerifier(DO_NOT_VERIFY)
                    .sslSocketFactory(sslContext.getSocketFactory(), xtm).connectTimeout(5, TimeUnit.SECONDS).readTimeout(5, TimeUnit.SECONDS)
                    .writeTimeout(5, TimeUnit.SECONDS).build();
    
            RequestBody requestBody = RequestBody.create(JSON, json);
            //创建一个请求对象
            Request request = new Request.Builder()
                    .url(url)
                    .post(requestBody)
                    .build();
            //发送请求获取响应
            try {
                Response response = okHttpClient.newCall(request).execute();
                res = response.body().string();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return res;
        }
    }

## 2.springboot的配置文件进行加密解密 ##

<dependency>
          <groupId>com.github.ulisesbocchio</groupId>
          <artifactId>jasypt-spring-boot-starter</artifactId>
          <version>1.16</version>
      </dependency>

@Autowired
        private StringEncryptor encryptor;
    
        @Test
        public void getPassWord() {
            System.setProperty("jasypt.encryptor.password", "12345");
            StringEncryptor stringEncryptor = new DefaultLazyEncryptor(new StandardEnvironment());
            //加密方法
            System.out.println("加密方法"+stringEncryptor.encrypt("12345"));
            //解密方法
            System.out.println("解密方法"+stringEncryptor.decrypt("71cNXe4BNNRphCB45Hwq3g=="));
    
        }

## 3.一个元素在亿级数据中是否存在 ##

**典型的应用场景：**  
某些存储系统的设计中，会存在空查询缺陷：当查询一个不存在的key时，需要访问慢设备，导致效率低下。

`比如一个前端页面的缓存系统，可能这样设计`：先查询某个页面在本地是否存在，如果存在就直接返回，如果不存在，就从后端获取。但是当频繁从缓存系统查询一个页面时，缓存系统将会频繁请求后端，把压力导入后端。

这是只要增加一个`布隆算法`的服务，后端插入一个key时，在这个服务中设置一次  
需要查询后端时，先判断key在后端是否存在，这样就能避免后端的压力 同时可以避免 缓存穿透 、缓存击穿、缓存雪崩。

`缓存穿透`：正常来说，一个合理设计的缓存命中率肯定是在50%以上，如果大量 的去避开缓存 ，就会因为 miss cache 造成对DB的负载

`缓存击穿`：某一个高流量的 热点Key，在失效的一瞬间，造成的负载

`缓存雪崩`：很多Key的失效时间相同 ，缓存同一时间大面积的失效，这个时候又来了一波请求，结果请求都怼到数据库上，从而导致数据库连接异常

// 2.Bloom Filter(布隆过滤)
        // 3.Guava 实现
    
        @Test
        public void guavaTest() {
            long star = System.currentTimeMillis();
            BloomFilter<Integer> filter = BloomFilter.create(Funnels.integerFunnel(), 10000000, 0.01);
    
            for (int i = 0; i < 10000000; i++) {
                filter.put(i);
            }
    
            Assert.assertTrue(filter.mightContain(1));
            Assert.assertTrue(filter.mightContain(2));
            Assert.assertTrue(filter.mightContain(3));
            Assert.assertFalse(filter.mightContain(10000000));
            Assert.assertFalse(filter.mightContain(1123333));
            long end = System.currentTimeMillis();
    
            System.out.println("执行时间：" + (end - star));
        }
    
        // 1.HashSet
        // 注意：HashSet 不是线程安全的，换为 ConcurrentHashMap同时把 value 写死一样可以达到 set 的效果
        @Test
        public void hashSetTest(){
            long start = System.currentTimeMillis();
            Set<Integer> hashset = new HashSet(10000000);  // e.g. int capacity=100000
            for(int i=0; i<10000000; i++){hashset.add(i);}
            Assert.assertTrue(hashset.contains(1));
            Assert.assertTrue(hashset.contains(3));
            Assert.assertFalse(hashset.contains(10000000));
            long end = System.currentTimeMillis();
            System.out.println("执行时间：" + (end - start));
        }

## 4.利用springboot创建线程池 ##

package com.hzbank.counter;
    
    import com.google.common.util.concurrent.ThreadFactoryBuilder;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.util.concurrent.*;
    
    @Configuration
    
    public class TreadPoolConfig {
       /**
         * 消费队列线程
         * @return
         */
        @Bean
        public ExecutorService buildConsumerQueueThreadPool(){
            ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("thread-%d").build();
            ExecutorService pool = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
            new ArrayBlockingQueue<Runnable>(5),namedThreadFactory,new ThreadPoolExecutor.AbortPolicy());
            return pool ;
        }
    }

/**
         * 利用springboot创建线程池
         */
        @Resource
        private ExecutorService executorService;
    
        public void execute() {
            //消费队列
            for (int i = 0; i < 5; i++) {
               executorService.execute(new TestRunnable());
            }
        }
    
        class TestRunnable implements Runnable {
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程被调用了。");
                while (true) {
                    try {
                        Thread.sleep(5000);
                        System.out.println(Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

## 5.责任链模式 ##

场景：  
传入了一段内容，需要对这段文本进行加工；比如过滤敏感词、错别字修改、最后署上版权等操作

package com.hzbank.counter;
    
    public interface Process {
        /**
         * 执行处理
         * @param msg
         */
        void doProcess(String msg) ;
    }

package com.hzbank.counter;
    
    public class CopyleftProcess implements Process {
        @Override
        public void doProcess(String msg) {
            System.out.println(msg + "名人处理");
        }
    }

package com.hzbank.counter;
    
    public class CopyrightProcess implements Process {
        @Override
        public void doProcess(String msg) {
            System.out.println(msg + "脏话处理");
        }
    }

package com.hzbank.counter;
    
    public class SensitiveWordProcess implements Process {
        @Override
        public void doProcess(String msg) {
            System.out.println(msg + "敏感词处理");
        }
    }

package com.hzbank.counter;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class MsgProcessChain {
    
        private List<Process> chains = new ArrayList<>() ;
    
        /**
         * 添加责任链
         * @param process
         * @return
         */
        public MsgProcessChain addChain(Process process){
            chains.add(process) ;
            return this ;
        }
    
        /**
         * 执行处理
         * @param msg
         */
        public void process(String msg){
            for (Process chain : chains) {
                chain.doProcess(msg);
            }
        }
    }

@Test
        public void processChain(){
            String msg="测试-------";
            MsgProcessChain chain = new MsgProcessChain()
                    .addChain(new SensitiveWordProcess())
                    .addChain(new CopyleftProcess())
                    .addChain(new CopyrightProcess()) ;
    
            chain.process(msg) ;
        }

参考：[https://www.jianshu.com/u/e2d07947c112][https_www.jianshu.com_u_e2d07947c112]

[https_www.jianshu.com_u_e2d07947c112]: https://www.jianshu.com/u/e2d07947c112