三级缓存原理

//定义一个加载图片的类

public class MyFresco {
    private static MyMemocyCache myMemocyCache;
    private static MyDiskCache myDiskCache;
    private static MyFresco myFresco;
    private static Context mContext;
    public static MyFresco init(Context context){
        myMemocyCache=new MyMemocyCache();
        myDiskCache=new MyDiskCache();
        myFresco=new MyFresco();
        mContext=context;
        return myFresco;
    }
    //加载图片的方法
    public Bitmap loadPic(String url){
        //检查内存里有没有
        Bitmap picFromMemory = myMemocyCache.getPicFromMemory(url);
        if (picFromMemory==null){
            //去磁盘里获取
            Bitmap picFromDisk = myDiskCache.getPicFromDisk(url);
            if (picFromDisk==null){
            //去网络获取图片
                Bitmap picFromNet = getPicFromNet(url);
                if (picFromNet==null){
                    //网络图片没有就返回一个默认图片
                 Bitmap bitmap= BitmapFactory.decodeResource(mContext.getResources(),R.mipmap.ic_launcher);
               return bitmap;
                }else {
                    return picFromNet;
                }
            }else {
                return picFromDisk;
            }
        }else {
            return picFromMemory;
        }

    }
    //从网络中获取图片
    public Bitmap getPicFromNet(String url){
        //使用HttpUrlConnction
        URL u = null;
        try {
            u = new URL(url);
           HttpURLConnection connection = (HttpURLConnection) u.openConnection();
           connection.setConnectTimeout(5000);
           if (connection.getResponseCode()==200){
               InputStream inputStream = connection.getInputStream();//获取输入流相当于Bitmap
               Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
               return bitmap;
           }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }
}
//内存缓存类

public class MyMemocyCache {
    //内存大小的1/8
   private long size=Environment.getDataDirectory().getUsableSpace();
  private LruCache<String,Bitmap> lruCache=new LruCache<>((int) (size/8));
    //取出图片
public Bitmap getPicFromMemory(String url){
    Bitmap bitmap = lruCache.get(url);
    return bitmap;
}
    //向内存中保存图片
    public void setPicToMemocy(String url,Bitmap bitmap){
       lruCache.put(url,bitmap);
    }
}

//sdcard缓存类

public class MyDiskCache {
    private String path= Environment.getExternalStorageDirectory().getAbsolutePath();
    //保存图片
    public void setPicToDisk(String url){
        File file = new File(path, url);
        Bitmap bitmap = BitmapFactory.decodeFile(file.getAbsolutePath());
        try {
            bitmap.compress(Bitmap.CompressFormat.PNG,100,new FileOutputStream(file));//将图片压缩到sdcard
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //取出图片
    public Bitmap getPicFromDisk(String url){
        File file = new File(path, url);
        if (file.exists()){
            Bitmap bitmap = BitmapFactory.decodeFile(file.getAbsolutePath());
            return bitmap;
        }

        return null;
    }
}

//主activity调用

public class MainActivity extends AppCompatActivity {
private String pic="http://www.taopic.com/uploads/allimg/140320/235013-14032020515270.jpg";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Button start = findViewById(R.id.start);
        final ImageView image = findViewById(R.id.image);
        final MyFresco init = MyFresco.init(this);
        start.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                new Thread(){
                    @Override
                    public void run() {
                        super.run();
                        final Bitmap bitmap = init.getPicFromNet(pic);
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                image.setImageBitmap(bitmap);
                            }
                        });

                    }
                }.start();
            }
        });
    }

布局文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.example.huancun.MainActivity">

   <Button
       android:text="加载"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:id="@+id/start"/>
<ImageView
    android:layout_width="100dp"
    android:layout_height="100dp"
    android:id="@+id/image"/>
</LinearLayout>

Spring 的三级缓存机制是解决单例 Bean 循环依赖的核心设计,通过分层缓存策略提前暴露半成品 Bean 的引用,确保容器初始化顺利进行。以下是对 Bean 三级缓存原理的详细介绍: ### 三级缓存的核心组成 - **一级缓存(singletonObjects)**:也称为单例池,用于存放已经完全初始化好的单例 Bean,这些 Bean 可以直接被使用。 - **二级缓存(earlySingletonObjects)**:存放提前暴露的半成品 Bean,这些 Bean 已经实例化,但还未完成属性注入和初始化操作。 - **三级缓存(singletonFactories)**:存放的是 ObjectFactory 类型的对象,这些对象是一个工厂,用于创建 Bean 的引用。三级缓存存储的是工厂对象而不是 Bean 的实例,这样在需要时可以动态生成 Bean 的引用 [^4]。 ### 工作原理 在 Bean 的生成流程中,三级缓存的调用主要在以下三个地方: - **Bean 实例化前**:会先查询一级缓存(singletonObjects),判断 Bean 是否已经存在。如果存在,则直接返回该 Bean;如果不存在,则继续后续流程。 - **Bean 属性赋值前**:会向三级缓存(singletonFactories)中放入一个 lambda 表达式,该表达式执行则会生成一个半成品 Bean 放入二级缓存(earlySingletonObjects)。通过这种方式,提前暴露一个可以被引用的 Bean 实例,即使这个 Bean 还未完全初始化。 - **Bean 初始化完成后**:将完整的 Bean 放入一级缓存(singletonObjects),同时清空二级缓存(earlySingletonObjects)和三级缓存(singletonFactories)中的相关信息,确保 Bean 的最终状态存储在一级缓存中 [^2]。 ### 示例代码理解 以下是一个简单的示例代码,帮助理解三级缓存的工作原理: ```java import org.springframework.beans.factory.ObjectFactory; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration class AppConfig { @Bean public BeanA beanA(BeanB beanB) { return new BeanA(beanB); } @Bean public BeanB beanB(BeanA beanA) { return new BeanB(beanA); } } class BeanA { private BeanB beanB; public BeanA(BeanB beanB) { this.beanB = beanB; } } class BeanB { private BeanA beanA; public BeanB(BeanA beanA) { this.beanA = beanA; } } public class Main { public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); ConfigurableListableBeanFactory beanFactory = context.getBeanFactory(); // 模拟三级缓存的操作 // 当创建 BeanA 时,会先将 BeanA 的 ObjectFactory 放入三级缓存 ObjectFactory<?> beanAFactory = () -> context.getBean("beanA"); beanFactory.registerSingletonFactory("beanA", beanAFactory); // 当创建 BeanB 时,需要依赖 BeanA,会从三级缓存获取 BeanA 的引用 BeanB beanB = context.getBean(BeanB.class); System.out.println(beanB); } } ``` ### 应用场景和限制 从 3.6 版本开始,通过引入三级缓存,Spring 能够更全面地处理包括 AOP 在内的更复杂的循环依赖情况。但需要注意的是,三级缓存机制只能解决单例 Bean 的循环依赖问题,对于原型 Bean 和多例 Bean 的循环依赖,Spring 无法通过三级缓存来解决 [^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值