[REDIS] / 스프링 Java 사용 레디 스에 이미지를 저장하는 방법

/ 스프링 Java 사용 레디 스에 이미지를 저장하는 방법

내 이미지 업로드 서버 레디 스 스프링 프레임 워크를 사용하고 있습니다. 나는 레디 스에 이미지를 저장해야합니다. 나는 다음과 같은 질문을 발견하지만, 파이썬에 대한했다. 파이썬 / PIL을 사용하여 레디 스에 이미지를 저장하는 방법

나는 그것이 가장 좋은 방법은 있는지 모르겠지만 나는 (바람직하게는 스프링 프레임 워크를 사용하여) 자바에서 작업을 수행하는 방법을 알고 싶습니다. 나는 jedis을 사용하는 스프링 데이터 레디 스를 사용하고 있습니다.

나는 레디 스에서 이미지를 저장할 수있는 좋은 전략이 있는지 알고 싶습니다.

해결법

1. ==============================

   1.레디 스 바이너리 안전 때문에, Jedis의 경우에, 당신은 당신이 레디 스에 저장하는 것이 값의 다른 종류의 이진 데이터를 저장하는 BinaryJedis를 사용할 수 있습니다.

   레디 스 바이너리 안전 때문에, Jedis의 경우에, 당신은 당신이 레디 스에 저장하는 것이 값의 다른 종류의 이진 데이터를 저장하는 BinaryJedis를 사용할 수 있습니다.

   그리고 아니, 나는 레디 스에 이미지를 저장 생각하지 않는다, 따라서 메모리 내 좋은 전략이다. 즉 아주 특별한 사용 사례가 될해야합니다.

2. ==============================

   2.키 값 쌍으로 레디 스에 base64로 문자열과 저장 위치로 변환 이미지. 64 기수 문자열로 이미지를 변환하는 방법을 여기에서 찾을 수 있습니다 http://ben-bai.blogspot.in/2012/08/java-convert-image-to-base64-string-and.html

   키 값 쌍으로 레디 스에 base64로 문자열과 저장 위치로 변환 이미지. 64 기수 문자열로 이미지를 변환하는 방법을 여기에서 찾을 수 있습니다 http://ben-bai.blogspot.in/2012/08/java-convert-image-to-base64-string-and.html

3. ==============================

   3.모든 레디 스의 첫 번째 이미지를 저장하기위한 좋은 옵션이 아닙니다. 이 같은 이미지 inmemory으로 파일을 저장할 수있는 좋은 단계하지 복용 있도록 레디 스는 inmemory입니다.

   모든 레디 스의 첫 번째 이미지를 저장하기위한 좋은 옵션이 아닙니다. 이 같은 이미지 inmemory으로 파일을 저장할 수있는 좋은 단계하지 복용 있도록 레디 스는 inmemory입니다.

   그런 다음 이미지를 입력하려면 다음과 같이 당신은 그것을 사용할 수 있습니다

   다음 단계는

   1) 다음 항아리로 받는다는의 pom.xml을

       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-core</artifactId>
           <version>${spring.version}</version>
       </dependency>
   
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-context</artifactId>
           <version>${spring.version}</version>
       </dependency>
   
       <dependency>
           <groupId>cglib</groupId>
           <artifactId>cglib</artifactId>
           <version>2.2.2</version>
       </dependency>
   
       <dependency>
              <groupId>org.springframework.data</groupId>
              <artifactId>spring-data-redis</artifactId>
              <version>1.3.0.RELEASE</version>
           </dependency>
   
               <dependency>
                  <groupId>redis.clients</groupId>
                  <artifactId>jedis</artifactId>
                  <version>2.4.1</version>
               </dependency>
   
       <dependency>
           <groupId>org.apache.commons</groupId>
           <artifactId>commons-pool2</artifactId>
           <version>2.0</version>
       </dependency>
   

   다음과 같이 2) 구성 XML을

   <beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
           xmlns:c="http://www.springframework.org/schema/c"
           xmlns:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans     
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/context 
           http://www.springframework.org/schema/context/spring-context-3.0.xsd
   
           http://www.springframework.org/schema/cache 
           http://www.springframework.org/schema/cache/spring-cache.xsd">
   
   
   
       <bean id="jeidsConnectionFactory"
         class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
         p:host-name="localhost" p:port="6379" p:password="" />
   
        <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
         p:connection-factory-ref="jeidsConnectionFactory" />
   
        <bean id="imageRepository" class="com.self.common.api.poc.ImageRepository">
         <property name="redisTemplate" ref="redisTemplate"/>
        </bean>
   
   </beans>
   

   다음과 같이 3) 클래스를 확인

   package com.self.common.api.poc;
   
   import java.awt.image.BufferedImage;
   import java.io.ByteArrayInputStream;
   import java.io.ByteArrayOutputStream;
   import java.io.File;
   import java.io.IOException;
   
   import javax.imageio.ImageIO;
   
   import org.springframework.context.ApplicationContext;
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   
   import sun.misc.BASE64Decoder;
   import sun.misc.BASE64Encoder;
   
   public class RedisMainApp {
   
    public static void main(String[] args) throws IOException {
     ApplicationContext applicationContext = new ClassPathXmlApplicationContext("mvc-dispatcher-servlet.xml");
     ImageRepository imageRepository = (ImageRepository) applicationContext.getBean("imageRepository");
   
     BufferedImage img = ImageIO.read(new File("files/img/TestImage.png"));
     BufferedImage newImg;
     String imagestr;
     imagestr = encodeToString(img, "png");
     Image image1 = new Image("1", imagestr);
   
     img = ImageIO.read(new File("files/img/TestImage2.png"));
     imagestr = encodeToString(img, "png");
     Image image2 = new Image("2", imagestr);
   
     imageRepository.put(image1);
     System.out.println(" Step 1 output : " + imageRepository.getObjects());
     imageRepository.put(image2);
     System.out.println(" Step 2 output : " + imageRepository.getObjects());
     imageRepository.delete(image1);
     System.out.println(" Step 3 output : " + imageRepository.getObjects());
   
    }
   
    /**
     * Decode string to image
     * @param imageString The string to decode
     * @return decoded image
     */
    public static BufferedImage decodeToImage(String imageString) {
   
        BufferedImage image = null;
        byte[] imageByte;
        try {
            BASE64Decoder decoder = new BASE64Decoder();
            imageByte = decoder.decodeBuffer(imageString);
            ByteArrayInputStream bis = new ByteArrayInputStream(imageByte);
            image = ImageIO.read(bis);
            bis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return image;
    }
   
    /**
     * Encode image to string
     * @param image The image to encode
     * @param type jpeg, bmp, ...
     * @return encoded string
     */
    public static String encodeToString(BufferedImage image, String type) {
        String imageString = null;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
   
        try {
            ImageIO.write(image, type, bos);
            byte[] imageBytes = bos.toByteArray();
   
            BASE64Encoder encoder = new BASE64Encoder();
            imageString = encoder.encode(imageBytes);
   
            bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return imageString;
    }
   }
   
   package com.self.common.api.poc;
   
   public class Image implements DomainObject {
   
    public static final String OBJECT_KEY = "IMAGE";
   
    public Image() {
    }
   
    public Image(String imageId, String imageAsStringBase64){
     this.imageId = imageId;
     this.imageAsStringBase64 = imageAsStringBase64;
    }
    private String imageId;
    private String imageAsStringBase64;
   
    public String getImageId() {
     return imageId;
    }
   
    public void setImageId(String imageId) {
     this.imageId = imageId;
    }
   
    public String getImageName() {
     return imageAsStringBase64;
    }
   
    public void setImageName(String imageAsStringBase64) {
     this.imageAsStringBase64 = imageAsStringBase64;
    }
   
    @Override
    public String toString() {
     return "User [id=" + imageAsStringBase64 + ", imageAsBase64String=" + imageAsStringBase64 + "]";
    }
   
    @Override
    public String getKey() {
     return getImageId();
    }
   
    @Override
    public String getObjectKey() {
     return OBJECT_KEY;
    }
   }
   
   package com.self.common.api.poc;
   
   import java.io.Serializable;
   
   public interface DomainObject extends Serializable {
   
    String getKey();
   
    String getObjectKey();
   }
   
   package com.self.common.api.poc;
   
   import java.util.List;
   
   import com.self.common.api.poc.DomainObject;
   
   public interface Repository<V extends DomainObject> {
   
    void put(V obj);
   
    V get(V key);
   
    void delete(V key);
   
    List<V> getObjects();
   }
   
   package com.self.common.api.poc;
   
   import java.util.ArrayList;
   import java.util.List;
   
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.data.redis.core.RedisTemplate;
   
   import com.self.common.api.poc.DomainObject;
   
   public class ImageRepository implements Repository<Image>{
   
    @Autowired
    private RedisTemplate<String,Image> redisTemplate;
   
    public RedisTemplate<String,Image> getRedisTemplate() {
     return redisTemplate;
    }
   
    public void setRedisTemplate(RedisTemplate<String,Image> redisTemplate) {
     this.redisTemplate = redisTemplate;
    }
   
    @Override
    public void put(Image image) {
     redisTemplate.opsForHash()
       .put(image.getObjectKey(), image.getKey(), image);
    }
   
    @Override
    public void delete(Image key) {
     redisTemplate.opsForHash().delete(key.getObjectKey(), key.getKey());
    }
   
    @Override
    public Image get(Image key) {
     return (Image) redisTemplate.opsForHash().get(key.getObjectKey(),
       key.getKey());
    }
   
    @Override
    public List<Image> getObjects() {
     List<Image> users = new ArrayList<Image>();
     for (Object user : redisTemplate.opsForHash().values(Image.OBJECT_KEY) ){
      users.add((Image) user);
     }
     return users;
    }
   
   }
   

   당신이 볼 수 sprinf jedis에 대한 자세한 참고로 http://www.javacodegeeks.com/2012/06/using-redis-with-spring.html

   샘플 코드는 http://javakart.blogspot.in/2012/12/spring-data-redis-hello-world-example.html에서 가져옵니다

4. ==============================

   4.글로벌 전사의 대답 @에서 힌트를 복용, 이것이 내가 무슨 짓을 (자바 8 필요) :

   글로벌 전사의 대답 @에서 힌트를 복용, 이것이 내가 무슨 짓을 (자바 8 필요) :

   private String getEncodedString(byte[] bytes) {
       return new String(Base64.getEncoder().encode(bytes));
   }
   
   private byte[] getDecodedByteArray(String string) {
       return Base64.getDecoder().decode(string.getBytes());
   }
   

   그리고 사용되는 스프링의 데이터 저장 및 검색하기위한 저장소 엔티티 레디 스 :

   @RedisHash("image") @Data @AllArgsConstructor
   public class RedisImageEntity {
       @Id String checksum;
       String image;
   }
   
   public interface RedisImageRepository extends CrudRepository<RedisImageEntity, String> {}
   

   마지막으로, 컨트롤러에서 :

   @RequestMapping(value = "/upload", method = RequestMethod.POST)
   ResponseEntity<ImageUploadDTO> uploadImage(MultipartFile image) {
       // ...
       redisImageRepository.save(
           new RedisImageEntity(checksum, getEncodedString(image.getBytes))
       );
       // ...
   }
   
   @RequestMapping(value = "/image", method = RequestMethod.GET)
   ResponseEntity<ImageResponseDTO> getImage(String checksum) {
       // ...
       prepareImage(getDecodedByteArray(
           redisImageRepository.findById(checksum).orElse(null)
       ));
       // ...
   }
   

from https://stackoverflow.com/questions/17916344/how-to-store-an-image-to-redis-using-java-spring by cc-by-sa and MIT license