Android：作为字符串传输的位图导致内存不足错误答案

【问题标题】：Android : Bitmaps transmitted as String causing out of memory errorsAndroid：作为字符串传输的位图导致内存不足错误
【发布时间】：2016-05-19 14:17:29
【问题描述】：

我正在开发一个 Android 项目，在该项目中我从我们的服务器加载图像，同时加载有关餐馆的其他信息。问题是，加载需要很长时间，每当我尝试再次加载信息或将手机从横向移动到纵向或反之亦然时，我都会出现内存不足错误。

正如我在网上查到的，用户说的问题是由于位图。在服务器端，我将PNG's 转换为字符串并传输它们，然后将字符串转换为位图然后显示。为什么整个加载时间在 4-5 秒左右并崩溃。谁能帮我。

安卓代码：

餐厅列表活动：

 public class getListOfRestaurantsForUser extends AsyncTask<Double,Void,ResponseEntity<RestRestaurant[]>>{

        RestaurantList restaurantList = null;

        getListOfRestaurantsForUser(RestaurantList restaurantList){
            this.restaurantList = restaurantList;
        }


        @Override
        protected ResponseEntity<RestRestaurant[]> doInBackground(Double... doubles) {
            double longitude = doubles[0];
            double latitude = doubles[1];
            Log.d("Longitude",String.valueOf(longitude));
            final RestTemplate restTemplate = StaticRestTemplate.getRest();
            HttpHeaders requestHeaders = new HttpHeaders();
            requestHeaders.add("Cookie", "JSESSIONID=" + StaticRestTemplate.jsessionid);
            requestHeaders.setAccept(Collections.singletonList(new MediaType("application", "json")));
            HttpEntity<?> requestEntity = new HttpEntity<Object>(requestHeaders);
            restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
            return restTemplate.exchange(restaurantListURL+longitude+"/"+latitude, HttpMethod.GET, requestEntity, RestRestaurant[].class);
        }

        @Override
        protected void onPostExecute(ResponseEntity<RestRestaurant[]> responseEntity){
            RestRestaurant[] restRestaurantList = responseEntity.getBody();
            Collections.addAll(restosAsList, restRestaurantList);

            ArrayList<HashMap<String, String>> restaurantsArrayHashList = new ArrayList<>();
            for(RestRestaurant restRestaurant : restosAsList){
                HashMap<String, String> restDisplay = new HashMap<>();
                restDisplay.put(restaurantid, String.valueOf(restRestaurant.getRestaurantId()));
                restDisplay.put(restaurantName, restRestaurant.getRestaurantName());
                restDisplay.put(restaurantDistance, String.valueOf(restRestaurant.getDistanceFromUser()));
                restDisplay.put(restaurantDetails,restRestaurant.getRestaurantDetails());
                restDisplay.put(restoProfilePicture,restRestaurant.getProfilePicture());
                restaurantsArrayHashList.add(restDisplay);
            }

            listView = (ListView) findViewById(R.id.restosList);
            restaurantListAdapter = new RestaurantListAdapter(restaurantList, restaurantsArrayHashList);

            listView.setAdapter(restaurantListAdapter);

            listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
                @Override
                public void onItemClick(AdapterView<?> parent, View view,
                                        int position, long id) {

                    int restaurantId = restosAsList.get(position).getRestaurantId();
                    Intent intent = new Intent(RestaurantList.this, MenuCardList.class);
                    intent.putExtra("restaurantid", restaurantId);
                    startActivity(intent);
                    finish();
                }
            });
        }
    }

餐厅列表适配器：

 @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        View view = convertView;
        if (convertView == null) {
            view = inflater.inflate(R.layout.individual_restaurant_detail, null);
            TextView restaurantName = (TextView) view.findViewById(R.id.resturantName);

            TextView distanceFromUser = (TextView) view.findViewById(R.id.distanceFromUser);
            TextView restaurantDetails = (TextView) view.findViewById(R.id.restaurantDetails);
            ImageView restoImage = (ImageView) view.findViewById(R.id.resturantImage);
            HashMap<String, String> restaurantList;
            restaurantList = data.get(position);
            restaurantName.setText(restaurantList.get(RestaurantList.restaurantName));
            restaurantName.setTypeface(Typeface.DEFAULT_BOLD);
            restaurantName.setTextSize(TypedValue.COMPLEX_UNIT_SP, 15);
            double distance = Double.valueOf(restaurantList.get(RestaurantList.restaurantDistance));
            if(distance < 1000) {
                distanceFromUser.setText("Entfernung " + restaurantList.get(RestaurantList.restaurantDistance)+"m");
            }else {
                distanceFromUser.setText("Entfernung " + String.valueOf(distance/1000) +"km");
            }
            restaurantDetails.setText(restaurantList.get(RestaurantList.restaurantDetails));
            restoImage.setImageBitmap(convertByteArrayToBitmap(restaurantList.get(RestaurantList.restoProfilePicture)));

       }
        return view;
    } @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        View view = convertView;
        if (convertView == null) {
            view = inflater.inflate(R.layout.individual_restaurant_detail, null);
            TextView restaurantName = (TextView) view.findViewById(R.id.resturantName);

            TextView distanceFromUser = (TextView) view.findViewById(R.id.distanceFromUser);
            TextView restaurantDetails = (TextView) view.findViewById(R.id.restaurantDetails);
            ImageView restoImage = (ImageView) view.findViewById(R.id.resturantImage);
            HashMap<String, String> restaurantList;
            restaurantList = data.get(position);
            restaurantName.setText(restaurantList.get(RestaurantList.restaurantName));
            restaurantName.setTypeface(Typeface.DEFAULT_BOLD);
            restaurantName.setTextSize(TypedValue.COMPLEX_UNIT_SP, 15);
            double distance = Double.valueOf(restaurantList.get(RestaurantList.restaurantDistance));
            if(distance < 1000) {
                distanceFromUser.setText("Entfernung " + restaurantList.get(RestaurantList.restaurantDistance)+"m");
            }else {
                distanceFromUser.setText("Entfernung " + String.valueOf(distance/1000) +"km");
            }
            restaurantDetails.setText(restaurantList.get(RestaurantList.restaurantDetails));
            restoImage.setImageBitmap(convertByteArrayToBitmap(restaurantList.get(RestaurantList.restoProfilePicture)));

       }
        return view;
    }

  private Bitmap convertByteArrayToBitmap(String string){
        try {
            byte [] encodeByte= Base64.decode(string, Base64.DEFAULT);
            return BitmapFactory.decodeByteArray(encodeByte, 0, encodeByte.length);
        } catch (Exception ignored){}
        return null;

    }

服务器端代码：

@Override
public List<Restaurant> getNearbyRestaurants(double longitude, double latitude) {
    BASE64Encoder base64Encoder = new BASE64Encoder();
    final int R = 6371; // Radius of the earth
    List<Restaurant> restaurantList = this.listRestaurants();
    List<Restaurant> nearbyRestaurantList = new ArrayList<>();
    for(Restaurant restaurant : restaurantList){
        Double latDistance = toRad(latitude-restaurant.getLatitude());
        Double lonDistance = toRad(longitude-restaurant.getLongitude());
        Double a = Math.sin(latDistance / 2) * Math.sin(latDistance / 2) +
                Math.cos(toRad(latitude)) * Math.cos(toRad(restaurant.getLatitude())) *
                        Math.sin(lonDistance / 2) * Math.sin(lonDistance / 2);
        Double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
        Double distance = R * c;
        restaurant.setDistanceFromUser(distance);
        if(distance < 10){
            restaurant.setDistanceFromUser((restaurant.getDistanceFromUser()*1000));
            nearbyRestaurantList.add(restaurant);
        }

        String restaurantIdentifierImageString = this.restaurantImageService.getProfileIdentifierForRestaurant(restaurant.getRestaurantId());

        if(!(restaurantIdentifierImageString == null)){

           try {
               try {
                  File imagePath = new File(restaurantImagePath + restaurantIdentifierImageString +".png");
                   BufferedImage bufferedImage = ImageIO.read(imagePath);
                   ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                   ImageIO.write(bufferedImage, "png", byteArrayOutputStream);
                   restaurant.setProfilePicture( base64Encoder.encode(byteArrayOutputStream.toByteArray()));

               } catch (Exception e) {
                   File imagePath = new File(defaultProfilePath);
                   BufferedImage bufferedImage = ImageIO.read(imagePath);
                   ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                   ImageIO.write(bufferedImage, "png", byteArrayOutputStream);
                   restaurant.setProfilePicture(base64Encoder.encode(byteArrayOutputStream.toByteArray()));
               }
           }catch (Exception e){
               e.printStackTrace();
           }

        }
    }

    Collections.sort(nearbyRestaurantList, new Comparator<Restaurant>() {
        @Override
        public int compare(Restaurant o1, Restaurant o2) {
            if(o1.getDistanceFromUser() > o2.getDistanceFromUser()){
                return 1;
            }
            if(o1.getDistanceFromUser() < o2.getDistanceFromUser()){
                return -1;
            }
            return 0;
        }
    });

   return nearbyRestaurantList;
}

错误日志：

 Caused by: java.lang.OutOfMemoryError: Failed to allocate a 13176356 byte allocation with 370616 free bytes and 361KB until OOM
                                                                                    at java.lang.AbstractStringBuilder.<init>(AbstractStringBuilder.java:83)
                                                                                    at java.lang.StringBuilder.<init>(StringBuilder.java:67)
                                                                                    at com.fasterxml.jackson.core.util.TextBuffer.contentsAsString(TextBuffer.java:346)
                                                                                    at com.fasterxml.jackson.core.json.UTF8StreamJsonParser._finishAndReturnString(UTF8StreamJsonParser.java:2412)
                                                                                    at com.fasterxml.jackson.core.json.UTF8StreamJsonParser.getText(UTF8StreamJsonParser.java:285)
                                                                                    at com.fasterxml.jackson.databind.deser.std.StringDeserializer.deserialize(StringDeserializer.java:32)

如果需要更多信息，请告诉我。谢谢。

更新

Image retrieval method :

 @RequestMapping(value = "/restaurantimage/{identifier}")
    public HttpEntity<byte[]> getPhoto(@PathVariable String identifier) {
        boolean flag = false;
            try {
                byte[] image;
                try {
                    image = org.apache.commons.io.FileUtils.readFileToByteArray(new File(restaurantImagePath + identifier +".png"));
                } catch (FileNotFoundException e) {
                    flag = true;
                    image = org.apache.commons.io.FileUtils.readFileToByteArray(new File(defaultProfilePath));
                    e.printStackTrace();
                }
                HttpHeaders headers = new HttpHeaders();
                headers.setContentType(MediaType.IMAGE_PNG);
                headers.setContentLength(image.length);
                return new HttpEntity<>(image, headers);
            } catch (IOException ignored) {
            }
   return null;
}

【问题讨论】：

@fge ：因为每当我检索餐馆列表时，我都会发送该列表中的个人资料图片。我不知道如何检索httpEntity<byte[]> 并使用 Picaso 将其放入图像中而无需创建新线程。你会建议我做什么？
一种解决方案是改用 Jackson 流 API；还是不捆绑图像，而是提供一个链接，客户端可以根据需要检索该链接？
@fge ：对于另一个项目，同样的事情不会导致任何此类问题。您是否在代码中看到我可能泄漏内存或其他内容的任何内容。我有一个控制器方法可以给我图像，但是图像必须在一个新线程中检索，这将导致餐厅的细节被显示，没有图像（至少暂时）。这就是为什么正如您在服务器端代码中看到的那样，我已将图像与列表本身集成在一起。我希望现在图片更清晰。谢谢。

标签： java android memory bitmap out-of-memory

【解决方案1】：

我不知道您的服务器端有什么要求，但是对于移动应用程序，分配给应用程序的内存非常有限。您可能发送的位图必须有几千字节，当收到它时，您将其存储在字符串或字节数组中，然后将其写入字符串。这会消耗您的应用程序的大量内存，并且还会产生性能问题。

作为一种替代方法，您可以在 json 字符串中提供服务器中图像的 url，然后将该 url 传递给一些 Imagehelper/Lazyloading 库（如 Volley）的方法。

【讨论】：

图片大小超过 1mb。我仅将图像作为字符串发送。那我应该把它作为位图发送吗？我只是不知道如何在适配器中加载 Bitmap 对象。
:0 那么它肯定会消耗太多内存，请使用我建议的方法。它肯定会帮助并提高应用程序的性能，并防止这种内存不足错误。您可以使用此处给出的图像 url：gstatic.com/webp/gallery3/1.sm.png 将此 url 提供给 Picasso 的方法，它将加载图像。
我正在使用可以从 URL 给我图像的方法更新我的主要帖子。你能告诉我如何用 Picaso 调用这个方法并加载图像。现在更新帖子。

【解决方案2】：

我终于能够通过从 Picaso 加载图像并从服务器端发送图像的 URL 来解决问题。

代码：

毕加索.with(view.getContext())

Picasso.load(StaticRestTemplate.baseURL+"restaurantimage/"+restaurantList.get(RestaurantList.restoProfilePicture))
                .config(Bitmap.Config.RGB_565)
                .fit()
                .centerInside()
                .into(restoImage);

【讨论】：