从网络获取图片,并缓存到SD卡

简介: 从网络获取图片,并缓存到SD卡

代码:

1. paths=new String[5];
2. for(int i=0;i<5;i++){
3.         //图片路径
4.         paths[i]=Environment.getExternalStorageDirectory()+"/"+i+".jpg";        
5.   }
复制代码

上面的代码要改为自己的图片路径。

主要代码:

IndexActivity


public class IndexActivity extends Activity {
        private String[] paths;
        private int j;
        private File cache;
        private String appid="";  //你的Application ID
        protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                Bmob.initialize(this, appid);
                setContentView(R.layout.activity_index);
                ///创建缓存目录
                cache=new File(Environment.getExternalStorageDirectory(),"cache");   
                if(!cache.exists()){
                        cache.mkdirs();
                }
        }
        public void skip(View v){
                Intent intent=new Intent(this,MainActivity.class);
                startActivity(intent);
        }
        public void upload(View v){
                paths=new String[5];
                for(int i=0;i<5;i++){
                        //图片路径
                        paths[i]=Environment.getExternalStorageDirectory()+"/"+i+".jpg";        
                }
                //批量上传图片
                Bmob.uploadBatch(this, paths, new UploadBatchListener() {
                        @Override
                        public void onSuccess(List<BmobFile> arg0, List<String> arg1) {
                                // TODO Auto-generated method stub
                                String strurl="";
                                for(String url:arg1){
                                        strurl=url;
                                }
                                Person p=new Person();
                                p.setIcPath(strurl);
                                p.setStr("s"+j);
                                p.save(IndexActivity.this);
                                j++;
                                toast("第"+j+"个上传成功!");
                        }
                        @Override
                        public void onProgress(int curIndex, int curPercent, int total, int totalPercent) {
                                // TODO Auto-generated method stub
                                //1、curIndex--表示当前第几个文件正在上传
                                //2、curPercent--表示当前上传文件的进度值(百分比)
                                //3、total--表示总的上传文件数
                                //4、totalPercent--表示总的上传进度(百分比)
                                MyUtil.logI(curIndex+" "+curPercent+" "+total+" "+totalPercent);
                        }
                        @Override
                        public void onError(int arg0, String arg1) {
                                // TODO Auto-generated method stub
                                toast("error "+arg1);
                                MyUtil.logI("errer "+arg1);
                        }
                });
        }
        // 清理缓存
        public void clear(View v){
                if(cache.length()!=0){
                        File[] files=cache.listFiles();
                        for(File file:files){
                                file.delete();
                        }
                        cache.delete();
                        toast("缓存清理成功");
                }else{
                        toast("暂无缓存");
                }
        }
        public void toast(String msg){
                Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
        }
}

MainActivity

public class MainActivity extends Activity {
        private ListView lv;
        private MyAdapter adapter;
        private File cache;
        private List<Person> list;
        protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);
                initView();
        }
        private void initView() {
                // TODO Auto-generated method stub
                lv=(ListView)findViewById(R.id.listView1);
                list=new ArrayList<Person>();
                cache=new File(Environment.getExternalStorageDirectory(),"cache");
                if(!cache.exists()){
                        cache.mkdirs();
                }
                getData();
        }
        private void getData() {
                // TODO Auto-generated method stub
                //查询数据
                BmobQuery<Person> bq=new BmobQuery<Person>();
                bq.setCachePolicy(CachePolicy.CACHE_ELSE_NETWORK);        //缓存查询
                bq.findObjects(this, new FindListener<Person>() {
                        @Override
                        public void onSuccess(List<Person> arg0) {
                                // TODO Auto-generated method stub
                                list=arg0;
                                adapter=new MyAdapter(MainActivity.this, list, cache);
                                lv.setAdapter(adapter);
                        }
                        @Override
                        public void onError(int arg0, String arg1) {
                                // TODO Auto-generated method stub
                                MyUtil.logI("errer "+arg1);
                        }
                });
        }

MyAdapter

public class MyAdapter extends BaseAdapter {
        private Context context;
        private List<Person> list;
        private File cache;
        public MyAdapter(Context context, List<Person> list, File cache) {
                this.context = context;
                this.list = list;
                this.cache = cache;
        }
        @Override
        public int getCount() {
                // TODO Auto-generated method stub
                return list.size();
        }
        @Override
        public Object getItem(int position) {
                // TODO Auto-generated method stub
                return list.get(position);
        }
        @Override
        public long getItemId(int position) {
                // TODO Auto-generated method stub
                return position;
        }
        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
                // TODO Auto-generated method stub
                ViewHolder vh;
                if(convertView==null){
                        convertView=LayoutInflater.from(context).inflate(R.layout.item, null);
                        vh=new ViewHolder();
                        vh.tv=(TextView)convertView.findViewById(R.id.tv);
                        vh.iv=(ImageView)convertView.findViewById(R.id.iv);
                        convertView.setTag(vh);
                }else{
                        vh=(ViewHolder)convertView.getTag();
                }
                final Person p=list.get(position);
                vh.tv.setText(p.getStr());
                // 异步的加载图片
                MyUtil mu=new MyUtil();
                AsyncImageTask as=new AsyncImageTask(mu,vh.iv,cache);
                if(p.getIcPath()!=null){
                        as.execute(p.getIcPath());
                }else{
                        vh.iv.setImageResource(R.drawable.ic_launcher);
                }
                return convertView;
        }
        class ViewHolder{
                TextView tv;
                ImageView iv;
        }
}

MyUtil

public class MyUtil {
        /**
         * 从网络上获取图片,如果图片在本地存在的话就直接拿,如果不存在再去服务器上下载图片
         * */
        public Uri getImageURI(String path,File cache) throws Exception{
                String name=MD5.getMD5(path)+path.substring(path.lastIndexOf("."));
                logI("name"+name);
                File file=new File(cache, name);
                // 如果图片存在本地缓存目录,则不去服务器下载
                if(file.exists()){
                        logI("cache");
                        return Uri.fromFile(file);
                }else{
                        URL url=new URL(path);
                        HttpURLConnection conn=(HttpURLConnection)url.openConnection();
                        conn.setConnectTimeout(5000);
                        conn.setRequestMethod("GET");
                        conn.setDoInput(true);
                        if(conn.getResponseCode()==200){
                                InputStream is=conn.getInputStream();
                                FileOutputStream fos=new FileOutputStream(file);
                                byte[] b=new byte[2*1024];
                                int len=0;
                                while((len=is.read(b))!=-1){
                                        fos.write(b,0,len);
                                }
                                is.close();
                                fos.close();
                                return Uri.fromFile(file);
                        }
                }
                return null;
        }
        public static void logI(String msg){
                Log.i("-------", msg);
        }
}

AsyncImageTask

public class AsyncImageTask extends AsyncTask<String, Integer, Uri> {
        private ImageView ivIcon;
        private MyUtil mu;
        private File cache;
        public AsyncImageTask(MyUtil mu,ImageView ivIcon,File cache) {
                this.mu=mu;
                this.ivIcon = ivIcon;
                this.cache=cache;
        }
        @Override
        protected Uri doInBackground(String... arg0) {
                // TODO Auto-generated method stub
                try {
                        return mu.getImageURI(arg0[0], cache);
                } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                return null;
        }
        @Override
        protected void onPostExecute(Uri result) {
                // TODO Auto-generated method stub
                super.onPostExecute(result);
                if(ivIcon!=null && result!=null){
                        ivIcon.setImageURI(result);
                }
        }
}


相关文章
|
4月前
|
缓存 应用服务中间件 nginx
Web服务器的缓存机制与内容分发网络(CDN)
【8月更文第28天】随着互联网应用的发展,用户对网站响应速度的要求越来越高。为了提升用户体验,Web服务器通常会采用多种技术手段来优化页面加载速度,其中最重要的两种技术就是缓存机制和内容分发网络(CDN)。本文将深入探讨这两种技术的工作原理及其实现方法,并通过具体的代码示例加以说明。
374 1
|
25天前
|
存储 缓存 监控
网站的图片资源是否需要设置缓存?
【10月更文挑战第18天】网站的图片资源一般是需要设置缓存的,但要根据图片的具体特点和网站的需求,合理设置缓存时间和缓存策略,在提高网站性能和用户体验的同时,确保用户能够获取到准确、及时的图片信息。
|
27天前
|
存储 缓存 Dart
Flutter&鸿蒙next 封装 Dio 网络请求详解:登录身份验证与免登录缓存
本文详细介绍了如何在 Flutter 中使用 Dio 封装网络请求,实现用户登录身份验证及免登录缓存功能。首先在 `pubspec.yaml` 中添加 Dio 和 `shared_preferences` 依赖,然后创建 `NetworkService` 类封装 Dio 的功能,包括请求拦截、响应拦截、Token 存储和登录请求。最后,通过一个登录界面示例展示了如何在实际应用中使用 `NetworkService` 进行身份验证。希望本文能帮助你在 Flutter 中更好地处理网络请求和用户认证。
150 1
|
7月前
|
存储 分布式计算 监控
Hadoop【基础知识 01+02】【分布式文件系统HDFS设计原理+特点+存储原理】(部分图片来源于网络)【分布式计算框架MapReduce核心概念+编程模型+combiner&partitioner+词频统计案例解析与进阶+作业的生命周期】(图片来源于网络)
【4月更文挑战第3天】【分布式文件系统HDFS设计原理+特点+存储原理】(部分图片来源于网络)【分布式计算框架MapReduce核心概念+编程模型+combiner&partitioner+词频统计案例解析与进阶+作业的生命周期】(图片来源于网络)
313 2
|
4月前
|
存储 缓存 监控
警惕网络背后的陷阱:揭秘DNS缓存中毒如何悄然改变你的网络走向
【8月更文挑战第26天】DNS缓存中毒是一种网络攻击,通过篡改DNS服务器缓存,将用户重定向到恶意站点。攻击者利用伪造响应、事务ID猜测及中间人攻击等方式实施。这可能导致隐私泄露和恶意软件传播。防范措施包括使用DNSSEC、限制响应来源、定期清理缓存以及加强监控。了解这些有助于保护网络安全。
96 1
|
4月前
|
缓存
Flutter Image从网络加载图片刷新、强制重新渲染
Flutter Image从网络加载图片刷新、强制重新渲染
133 1
|
4月前
|
存储 Java Spring
Spring Batch:让你的数据洪流化作涓涓细流,批量处理的魔法盛宴!
【8月更文挑战第31天】在现代软件开发中,批量处理对于金融交易、数据仓库加载等数据密集型应用至关重要。Spring Batch作为Spring生态的一部分,提供了一套全面的框架,支持事务管理、错误处理、日志记录等功能,帮助开发者高效构建可靠且可扩展的批处理应用。本文将深入探讨其核心概念、关键特性和实际应用,并通过示例代码展示如何配置作业、步骤及读取器、处理器和写入器,帮助读者更好地理解和应用Spring Batch。
91 0
|
4月前
|
缓存 NoSQL Java
【Azure Redis 缓存】定位Java Spring Boot 使用 Jedis 或 Lettuce 无法连接到 Redis的网络连通性步骤
【Azure Redis 缓存】定位Java Spring Boot 使用 Jedis 或 Lettuce 无法连接到 Redis的网络连通性步骤
|
4月前
|
存储 缓存 NoSQL
【Azure Redis 缓存】Azure Cache for Redis 专用终结点, 虚拟网络, 公网访问链路
【Azure Redis 缓存】Azure Cache for Redis 专用终结点, 虚拟网络, 公网访问链路
|
4月前
|
缓存 NoSQL 网络协议
【Azure Redis 缓存 Azure Cache For Redis】在创建高级层Redis(P1)集成虚拟网络(VNET)后,如何测试VNET中资源如何成功访问及配置白名单的效果
【Azure Redis 缓存 Azure Cache For Redis】在创建高级层Redis(P1)集成虚拟网络(VNET)后,如何测试VNET中资源如何成功访问及配置白名单的效果