【原创】分布式之缓存击穿【原创】自己动手实现静态资源服务器【原创】自己动手实现JDK动态代理...

最新推荐文章于 2022-11-09 21:25:06 发布

weixin_34167819

最新推荐文章于 2022-11-09 21:25:06 发布

阅读量92

点赞数

文章标签：数据库 java 操作系统

【原创】分布式之缓存击穿

什么是缓存击穿

在谈论缓存击穿之前，我们先来回忆下从缓存中加载数据的逻辑，如下图所示

因此，如果黑客每次故意查询一个在缓存内必然不存在的数据，导致每次请求都要去存储层去查询，这样缓存就失去了意义。如果在大流量下数据库可能挂掉。这就是缓存击穿。
场景如下图所示:

我们正常人在登录首页的时候，都是根据userID来命中数据，然而黑客的目的是破坏你的系统，黑客可以随机生成一堆userID,然后将这些请求怼到你的服务器上，这些请求在缓存中不存在，就会穿过缓存，直接怼到数据库上,从而造成数据库连接异常。

解决方案

在这里我们给出三套解决方案，大家根据项目中的实际情况，选择使用.

讲下述三种方案前，我们先回忆下redis的setnx方法

SETNX key value

将 key 的值设为 value ，当且仅当 key 不存在。

若给定的 key 已经存在，则 SETNX 不做任何动作。

SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。

可用版本：>= 1.0.0

时间复杂度： O(1)

返回值： 设置成功，返回 1。设置失败，返回 0 。

效果如下

redis> EXISTS job                # job 不存在
(integer) 0

redis> SETNX job "programmer"    # job 设置成功 (integer) 1 redis> SETNX job "code-farmer" # 尝试覆盖 job ，失败 (integer) 0 redis> GET job # 没有被覆盖 "programmer"

1、使用互斥锁

该方法是比较普遍的做法，即，在根据key获得的value值为空时，先锁上，再从数据库加载，加载完毕，释放锁。若其他线程发现获取锁失败，则睡眠50ms后重试。

至于锁的类型，单机环境用并发包的Lock类型就行，集群环境则使用分布式锁( redis的setnx)

集群环境的redis的代码如下所示:

String get(String key) {  
   String value = redis.get(key); if (value == null) { if (redis.setnx(key_mutex, "1")) { // 3 min timeout to avoid mutex holder crash redis.expire(key_mutex, 3 * 60) value = db.get(key); redis.set(key, value); redis.delete(key_mutex); } else { //其他线程休息50毫秒后重试 Thread.sleep(50); get(key); } } }

优点:

思路简单
保证一致性

缺点

代码复杂度增大
存在死锁的风险

2、异步构建缓存

在这种方案下，构建缓存采取异步策略，会从线程池中取线程来异步构建缓存，从而不会让所有的请求直接怼到数据库上。该方案redis自己维护一个timeout，当timeout小于System.currentTimeMillis()时，则进行缓存更新，否则直接返回value值。
集群环境的redis代码如下所示:

String get(final String key) {  
        V v = redis.get(key);  
        String value = v.getValue(); long timeout = v.getTimeout(); if (v.timeout <= System.currentTimeMillis()) { // 异步更新后台异常执行 threadPool.execute(new Runnable() { public void run() { String keyMutex = "mutex:" + key; if (redis.setnx(keyMutex, "1")) { // 3 min timeout to avoid mutex holder crash redis.expire(keyMutex, 3 * 60); String dbValue = db.get(key); redis.set(key, dbValue); redis.delete(keyMutex); } } }); } return value; }

优点:

性价最佳，用户无需等待

缺点

无法保证缓存一致性

3、布隆过滤器

1、原理

布隆过滤器的巨大用处就是，能够迅速判断一个元素是否在一个集合中。因此他有如下三个使用场景:

网页爬虫对URL的去重，避免爬取相同的URL地址
反垃圾邮件，从数十亿个垃圾邮件列表中判断某邮箱是否垃圾邮箱（同理，垃圾短信）
缓存击穿，将已存在的缓存放到布隆过滤器中，当黑客访问不存在的缓存时迅速返回避免缓存及DB挂掉。

OK，接下来我们来谈谈布隆过滤器的原理
其内部维护一个全为0的bit数组，需要说明的是，布隆过滤器有一个误判率的概念，误判率越低，则数组越长，所占空间越大。误判率越高则数组越小，所占的空间越小。

假设，根据误判率，我们生成一个10位的bit数组，以及2个hash函数（f1,f2

假设输入集合为(N1,N2

同理，经过计算f1(N2)

这个时候，我们有第三个数N3

若值恰巧都位于上图的红色位置中，我们则认为，N3
若值有一个不位于上图的红色位置中，我们则认为，N3

以上就是布隆过滤器的计算原理，下面我们进行性能测试，

2、性能测试

代码如下:

(1)新建一个maven工程，引入guava包

<dependencies>  
        <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>22.0</version> </dependency> </dependencies>

(2)测试一个元素是否属于一个百万元素集合所需耗时

package bloomfilter;

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import java.nio.charset.Charset;

public class Test { private static int size = 1000000; private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size); public static void main(String[] args) { for (int i = 0; i < size; i++) { bloomFilter.put(i); } long startTime = System.nanoTime(); // 获取开始时间 //判断这一百万个数中是否包含29999这个数 if (bloomFilter.mightContain(29999)) { System.out.println("命中了"); } long endTime = System.nanoTime(); // 获取结束时间 System.out.println("程序运行时间： " + (endTime - startTime) + "纳秒"); } }

输出如下所示

命中了
程序运行时间： 219386纳秒

也就是说，判断一个数是否属于一个百万级别的集合，只要0.219ms就可以完成，性能极佳。

(3)误判率的一些概念

首先，我们先不对误判率做显示的设置，进行一个测试，代码如下所示

package bloomfilter;

import java.util.ArrayList;
import java.util.List;

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels; public class Test { private static int size = 1000000; private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size); public static void main(String[] args) { for (int i = 0; i < size; i++) { bloomFilter.put(i); } List<Integer> list = new ArrayList<Integer>(1000); //故意取10000个不在过滤器里的值，看看有多少个会被认为在过滤器里 for (int i = size + 10000; i < size + 20000; i++) { if (bloomFilter.mightContain(i)) { list.add(i); } } System.out.println("误判的数量：" + list.size()); } }

输出结果如下

误判对数量：330

如果上述代码所示，我们故意取10000个不在过滤器里的值，却还有330个被认为在过滤器里，这说明了误判率为0.03.即，在不做任何设置的情况下，默认的误判率为0.03。
下面上源码来证明：

接下来我们来看一下，误判率为0.03时，底层维护的bit数组的长度如下图所示

将bloomfilter的构造方法改为

private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size,0.01);

即，此时误判率为0.01。在这种情况下，底层维护的bit数组的长度如下图所示

由此可见，误判率越低，则底层维护的数组越长，占用空间越大。因此，误判率实际取值，根据服务器所能够承受的负载来决定，不是拍脑袋瞎想的。

3、实际使用

redis伪代码如下所示

String get(String key) {  
   String value = redis.get(key); if (value == null) { if(!bloomfilter.mightContain(key)){ return null; }else{ value = db.get(key); redis.set(key, value); } } return value； }

优点:

思路简单
保证一致性
性能强

缺点

代码复杂度增大
需要另外维护一个集合来存放缓存的Key
布隆过滤器不支持删值操作

总结

在总结部分，来个漫画把。希望对大家找工作有帮助

【原创】自己动手实现静态资源服务器

引言

本文利用java自带的socket编程实现了一个简单的静态资源服务器，可以响应静态资源。本文一共有两个版本的源码。第一个版本名为Server_v1，该版本实现了一个简单的socket的服务器，帮助读者回忆socket编程。第二个版本名为Server_v2，该版本是对第一版的改良，给出了改良思路，做出了必要的封装，让其能够响应css、html、jpg等静态资源。

版本一

该版本实现一个简单的socket服务器，针对浏览器的请求，能够返回相应的页面。
其源码如下：

package mytomcat_v1;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket; import java.util.Date; /** * * @author zhengrongjun * @version v1.0 */ public class Server_V1 { public static void main(String[] args) { ServerSocket serverSocket = null; Socket client = null; try { serverSocket = new ServerSocket(9999); // 不断接收客户连接 while (true) { // 服务器阻塞等待客户端socket连接过来 client = serverSocket.accept(); // 对客户端里面端请求信息进行处理 InputStream in = client.getInputStream(); // 定义一个读取缓冲池 主要是在inputstram流中读取字节 byte[] buff = new byte[1024]; int len = in.read(buff); if (len > 0) { String msg = new String(buff, 0, len); System.out.println("===="+msg+"======"); OutputStream out = client.getOutputStream(); //构建响应信息 StringBuffer sb = new StringBuffer(); sb.append("HTTP/1.1 200 OK\n"); sb.append("Content-Type: text/html; charset=UTF-8\n"); sb.append("\n"); String html="<html><head><title>卖烧饼咯</title></head></html><body>小曲经常在" +"<font size='14' color='red'>" +new Date() +"</font>" +"<br/>卖烧饼</body></html>"; sb.append(html); out.write(sb.toString().getBytes()); out.flush(); out.close(); } } } catch (Exception e) { } } }

执行效果如下图所示，打开chrome浏览器，在导航栏输入

http://localhost:9999/docs/index.html

显示如下图所示

控制台输出如下图所示

====GET /docs/index.html HTTP/1.1
Host: localhost:9999 Connection: keep-alive Upgrade-Insecure-Requests: 1 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8 Accept-Encoding: gzip, deflate, br Accept-Language: zh-CN,zh;q=0.9 ======

版本二

该版本在版本一的基础上进行优化，使其能够有效的响应静态资源

步骤一

先看第一部分代码优化，如下图所示

红框的部分，我们可以理解为对请求信息对处理，因此我们模仿Tomcat构造一个HttpRequst来处理这一段逻辑。

另外，我们需要对静态资源进行响应，因此我们需要获取输入内容的静态资源地址，即以下部分的内容。

获取以上红框请求地址内容的代码如下

uri = msg.substring(msg.indexOf("/"),msg.indexOf("HTTP/1.1") - 1);

综上所述，我们有HttpRequest类如下所示

package mytomcat_v2;

import java.io.IOException;
import java.io.InputStream;

/**
 * 对客户端进行处理对业务类
 * 
 * @author zhengrongjun
 *
 */
public class HttpRequest {
    private String uri; public String getUri() { return uri; } public HttpRequest(InputStream in) throws IOException { // 对我们对请求字节流进行解析 resolverRequest(in); } private void resolverRequest(InputStream in) throws IOException { // TODO Auto-generated method stub byte[] buff = new byte[1024]; int len = in.read(buff); if (len > 0) { String msg = new String(buff, 0, len); System.out.println("====" + msg + "======"); // 解析出来 uri uri = msg.substring(msg.indexOf("/"), msg.indexOf("HTTP/1.1") - 1); } else { System.out.println("bad Request!"); } } }

步骤二

接下来是第二部分的代码优化，如下图所示

以上红框部分主要是对输出信息进行响应，我们模仿tomcat构造一个HttpResponse对象封装该部分逻辑。
另外，我们获取用户请求的资源文件路径，根据该路径找到相应静态文件。将该文件写入文件流，输出。
因此，我们有HttpResponse对象如下所示

package mytomcat_v2;
/**
 * 封装http响应信息
 * @author zhengrongjun
 *
 */

import java.io.FileInputStream;
import java.io.IOException; import java.io.OutputStream; public class HttpResponse { private OutputStream os = null; public HttpResponse(OutputStream os) { this.os = os; } public void writerFile(String path) throws IOException { FileInputStream fileInputStream = new FileInputStream(path); byte[] buff = new byte[1024]; int len = 0; // 构建响应信息 StringBuffer sb = new StringBuffer(); sb.append("HTTP/1.1 200 OK\n"); sb.append("Content-Type: text/html; charset=UTF-8\n"); sb.append("\n"); os.write(sb.toString().getBytes()); while ((len = fileInputStream.read(buff)) != -1) { os.write(buff, 0, len); } fileInputStream.close(); os.flush(); os.close(); } }

步骤三

接下来我们构建测试类，构建之前我们先去找一些静态资源文件。作者直接去apache的官网下把tomcat给下了下来，然后去如下目录拷贝静态资源文件

apache-tomcat-8.5.28/webapps/docs

将整个docs 文件夹拷贝至你的项目的根目录下

apache-tomcat-8.5.28/webapps/ROOT/favicon.ico

将favicon.ico图片拷贝至你的根目录下
静态资源在你的项目中的结构如下图所示

现在上我们的Server_V2的代码

package mytomcat_v2;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket; import java.util.Date; /** * * @author zhengrongjun * @version v2.0 */ public class Server_V2 { public static void main(String[] args) { ServerSocket serverSocket = null; Socket client = null; try { serverSocket = new ServerSocket(9999); // 不断接收客户连接 while (true) { // 服务器阻塞等待客户端socket连接过来 client = serverSocket.accept(); // =========请求类处理======= InputStream in = client.getInputStream(); HttpRequest request = new HttpRequest(in); String requestUri = request.getUri(); // =========响应类处理======= OutputStream os = client.getOutputStream(); HttpResponse response = new HttpResponse(os); //请求格式是/html/login.html这种，需要把开头的/删除 response.writerFile(requestUri.substring(1)); client.close(); } } catch (Exception e) { e.printStackTrace(); } } }

测试结果如下：
在浏览器输入

http://localhost:9999/docs/ssl-howto.html

效果如下

你会惊奇的发现样式并不能识别，因此我们对响应头的部分逻辑进行修改
将

sb.append("HTTP/1.1 200 OK\n");
sb.append("Content-Type: text/html; charset=UTF-8\n");
sb.append("\n");

部分修改为

if(path.endsWith("css")) {
            sb.append("HTTP/1.1 200 OK\n");
            sb.append("Content-Type: text/css; charset=UTF-8\n"); sb.append("\n"); }else { sb.append("HTTP/1.1 200 OK\n"); sb.append("Content-Type: text/html; charset=UTF-8\n"); sb.append("\n"); }

继续启动测试，效果如下

已经能够正常显示

总结

本文给出了两个版本的静态资源的服务器源码，希望读者能够有所收获。

【原创】自己动手实现JDK动态代理

项目结构如下图所示，maven项目

1、JDK动态代理

先来一段jdk动态代理的demo，
首先创建一个接口，Person

package bean;

public interface Person { public void eat(); }

然后写一个实现类PersonImpl

package bean;

public class PersonImpl implements Person{ @Override public void eat() { // TODO Auto-generated method stub System.out.println("time to eat "); } }

然后写个使用类PersonInvocationHandler

package jdk;

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class PersonInvocationHandler implements InvocationHandler { private Object obj; public PersonInvocationHandler(Object obj) { this.obj = obj; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub System.out.println("before time to eat"); method.invoke(obj, args); System.out.println("after time to eat"); return null; } }

最后再写个测试类

package jdk;

import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.lang.reflect.Proxy; import sun.misc.ProxyGenerator; import bean.Person; import bean.PersonImpl; public class jdkTest { public static void main(String[] args) throws Exception { PersonInvocationHandler personInvocationHandler = new PersonInvocationHandler( new PersonImpl()); Person personProxy = (Person) Proxy.newProxyInstance( PersonImpl.class.getClassLoader(), PersonImpl.class.getInterfaces(), personInvocationHandler); personProxy.eat(); } }

输出如下

before time to eat
time to eat 
after time to eat

接下里我们不使用JDK的API，自己实现一套代理类

2、自定义动态代理

先上测试类的代码，如下图所示，共有(1)(2)(3)处不同
image-w500

针对(1)，我们有如下代码,先抄袭JDK的InvocationHandler，改个名字成为MyInvocationHandler

package custom;

import java.lang.reflect.Method; public interface MyInvocationHandler { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable; }

编写一个JAVA类MyPersonInvocationHandler继承MyInvocationHandler，这段代码与PersonInvocationHandler的代码无异，如下所示

package custom;

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class MyPersonInvocationHandler implements MyInvocationHandler { private Object obj; public MyPersonInvocationHandler(Object obj) { this.obj = obj; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub System.out.println("before time to eat"); method.invoke(obj, args); System.out.println("after time to eat"); return null; } }

针对(2),我们实现一个自己的代理生成类MyProxy,其生成java代理类的步骤分为以下5步

生成java源碼
將源码输出到java文件中
将java文件编译成class文件
将class加载进jvm
返回代理类对象

具体代码如下

package custom;

import java.io.File; import java.io.FileWriter; import java.lang.reflect.Constructor; import java.lang.reflect.Method; import javax.tools.JavaCompiler; import javax.tools.StandardJavaFileManager; import javax.tools.ToolProvider; public class MyProxy { public static final String ln = "\r\n"; public static Object newProxyInstance(MyClassLoader myClassLoder, Class<?>[] interfaces, MyInvocationHandler h) { try{ // 1 java源碼 String src = generateSrc(interfaces); // 2 將源码输出到java文件中 String filePath = MyProxy.class.getResource("").getPath(); System.out.println(filePath); File f = new File(filePath + "$Proxy0.java"); FileWriter fw = new FileWriter(f); fw.write(src); fw.flush(); fw.close(); //3、将java文件编译成class文件 JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null); Iterable iterable = manage.getJavaFileObjects(f); JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable); task.call(); manage.close(); //4、将class加载进jvm Class proxyClass=myClassLoder.findClass("$Proxy0"); f.delete(); //5、返回代理类对象 Constructor constructor = proxyClass.getConstructor(MyInvocationHandler.class); return constructor.newInstance(h); }catch(Exception e){ e.printStackTrace(); } return null; } private static String generateSrc(Class<?>[] interfaces) { // TODO Auto-generated method stub StringBuffer sb = new StringBuffer(); sb.append("package custom;" + ln); sb.append("import java.lang.reflect.Method;" + ln); sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln); sb.append("private MyInvocationHandler h;"+ln); sb.append("public $Proxy0(MyInvocationHandler h) { " + ln); sb.append("this.h = h;"+ln); sb.append("}" + ln); for (Method m : interfaces[0].getMethods()) { sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "() {" + ln); sb.append("try{" + ln); sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod(\"" + m.getName() + "\",new Class[]{});" + ln); sb.append("this.h.invoke(this,m,null);" + ln); sb.append("}catch(Throwable e){" + ln); sb.append("e.printStackTrace();" + ln); sb.append("}"+ln); sb.append("}"+ln); } sb.append("}" + ln); return sb.toString(); } }

针对(3)，我们继承ClassLoader,实现一套自己的类加载机制MyClassLoader，如下所示,

package custom;

import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.IOException; public class MyClassLoader extends ClassLoader { private File classPathfile; public MyClassLoader() { String classpth = MyClassLoader.class.getResource("").getPath(); classPathfile = new File(classpth); } @Override public Class<?> findClass(String name) throws ClassNotFoundException { String className = MyClassLoader.class.getPackage().getName() + "." +name; if (classPathfile != null) { File file = new File(classPathfile, name + ".class"); FileInputStream fileInputStream = null; ByteArrayOutputStream outputStream = null; try{ fileInputStream = new FileInputStream(file); outputStream = new ByteArrayOutputStream(); byte[] buff = new byte[1024]; int len; while((len=fileInputStream.read(buff))!=-1){ outputStream.write(buff, 0, len); } return defineClass(className, outputStream.toByteArray(), 0, outputStream.size()); }catch(Exception e){ e.printStackTrace(); }finally{ if(null!=fileInputStream){ try { fileInputStream.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } if(null!=outputStream){ try { outputStream.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } return null; } }

最后测试类代码如下所示

package custom;

import java.lang.reflect.Proxy; import custom.MyPersonInvocationHandler; import bean.Person; import bean.PersonImpl; public class CustomTest { public static void main(String[] args) { MyPersonInvocationHandler personInvocationHandler = new MyPersonInvocationHandler( new PersonImpl()); Person personProxy = (Person) MyProxy.newProxyInstance( new MyClassLoader(), PersonImpl.class.getInterfaces(), personInvocationHandler); personProxy.eat(); } }

输出如何所示

before time to eat
time to eat 
after time to eat

至此，我们已完全实现了一套自定义的jdk动态代理类

weixin_34167819

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【原创】分布式之缓存击穿【原创】自己动手实现静态资源服务器【原创】自己动手实现JDK动态代理...

【原创】分布式之缓存击穿什么是缓存击穿在谈论缓存击穿之前，我们先来回忆下从缓存中加载数据的逻辑，如下图所示因此，如果黑客每次故意查询一个在缓存内必然不存在的数据，导致每次请求都要去存储层去查询，这样缓存就失去了意义。如果在大流量下数据库可能挂掉。这就是缓存击穿。场景如下图所示:我们正常人在登录首页的时候，都是根据userID来命中数据，然而黑客的目的是破坏你的系统，黑客可以随机生成...
复制链接

扫一扫