아.. 진작에 이렇게 할것을...ㅜㅜ

downloadmanager-context.xml

1.  
2. <?xml version="1.0" encoding="UTF-8"?>
3. <beans xmlns="http://www.springframework.org/schema/beans"
4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5.        xsi:schemaLocation="
6.                 http://www.springframework.org/schema/beans
7.                 http://www.springframework.org/schema/beans/spring-beans.xsd">
8. 
   
9.     <bean id="ftpDownloader" class="com.apress.prospring2.ch03.dm.FtpDownloader"/>
10.     <bean id="httpDownloader" class="com.apress.prospring2.ch03.dm.HttpDownloader"/>
11.     <bean id="sftpDownaloader" class="com.apress.prospring2.ch03.dm.SftpDownloader"/>
12.     <bean id="downloadManager" class="com.apress.prospring2.ch03.dm.DownloadManager">
13.         <property name="downloaders">
14.             <map>
15.                 <entry key="ftp" value-ref="ftpDownloader"/>
16.                 <entry key="http" value-ref="httpDownloader"/>
17.                 <entry key="sftp" value-ref="sftpDownaloader"/>
18.             </map>
19.         </property>
20.     </bean>
21. 
    
22. 
    
23. </beans>

Test Class : DownloadManager.java

1.  
2. package com.apress.prospring2.ch03.dm;
3. 
   
4. import org.springframework.beans.factory.xml.XmlBeanFactory;
5. import org.springframework.core.io.ClassPathResource;
6. 
   
7. import java.io.BufferedReader;
8. import java.io.IOException;
9. import java.io.InputStreamReader;
10. import java.util.Map;
11. import java.util.regex.Matcher;
12. import java.util.regex.Pattern;
13. 
    
14. /**
15.  * @author janm
16.  */
17. public class DownloadManager {
18. private static final Pattern URI_PATTERN = Pattern.compile("^([^:]*):/(.*)$");
19. private Map<String, Downloader> downloaders;
20. 
    
21. public static void main(String[] args) throws IOException {
22. XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource(
23. "/META-INF/spring/downloadmanager-context.xml"));
24. DownloadManager dm = (DownloadManager) xbf.getBean("downloadManager");
25. BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
26. while (true) {
27. String uri = reader.readLine();
28. if (uri.length() == 0)
29. break;
30. dm.download(uri);
31. }
32. }
33. 
    
34. private void download(String uri) {
35. Matcher matcher = URI_PATTERN.matcher(uri);
36. if (matcher.matches()) {
37. String scheme = matcher.group(1); //reg Exp 를 이용하여 1번그룹 추출(http, ftp, sftp)
38. System.out.println(scheme);
39. String path = matcher.group(2);
40. Downloader downloader = this.downloaders.get(scheme); // downloaderManager bean의 Map에서 스키마를 꺼낸다
41. if (downloader != null) {
42. downloader.download(path);
43. }
44. }
45. }
46. public void setDownloaders(Map<String, Downloader> downloaders) {
47. this.downloaders = downloaders;
48. }
49. }

Interface Downloader.java

1.  
2. package com.apress.prospring2.ch03.dm;
3. public interface Downloader {
       byte[] download(final String uri);
4. }

구현체 FtpDownloader.java , HttpDownloader.java , sFtpDownLoader.java

1. package com.apress.prospring2.ch03.dm;
2. import org.springframework.stereotype.Component;
3. @Component
4. public class FtpDownloader implements Downloader {
5.     public byte[] download(String uri) {
6.         System.out.println("FTP Downloading " + uri);
7.         return new byte[0];
8.     }
9. }

이 글은 스프링노트에서 작성되었습니다.

You might want to limit the size of file to be uploaded on your website as it eats up some of the bandwidth and this can cause problem to rest of the users of your site. Most of the time we do processing on files when they are uploaded on server and content validations has limitations on client side as you can not read files using javascript on client side (i.e. web browser). 

Limit on upload size makes more sense for specific purposes on your website when you know about expected size of file beforehand like image upload websites etc.

If you are using Spring framework for your project/product you can do this using latest version of commons-fileupload which lets you write your own ProgressListener using which you can limit file upload size and monitor the upload process as well. We are using Ajax in our project and for file upload we are using ajaxfileupload (see more in detail)

Following things need to be done for achieving the goal:

1. Implement the ProgressListener for your application like below by implementing org.apache.commons.fileupload.progresslistener

 
package com.listener;
 
import javax.servlet.http.HttpSession;
import net.sf.json.JSONObject;
import org.apache.commons.fileupload.ProgressListener;
 
public class AjaxProgressListener implements ProgressListener {
 
    public static final String STATUS_UPLOADING = "UPLOADING";
    public static final String STATUS_FAILED = "FAILED";
    public static final String STATUS_DONE = "DONE";
    public static final String STATUS_MAX_SIZE_EXCEEDS = "MAX_SIZE_EXCEEDS";
 
    private HttpSession session;
 
    public void setSession(HttpSession session){
        this.session = session;
    }
 
    public void updateStatus(String status){
        session.setAttribute("progressStatus", status);
    }
 
    public void update(long bytesRead, long contentLength, int item) {
        JSONObject progressMap = new JSONObject();
        progressMap.set("bytesRead", bytesRead);
        progressMap.set("contentLength", contentLength);
        progressMap.set("item", item);
        session.setAttribute("progressMap", progressMap);
 
        if(bytesRead == contentLength) {
                session.setAttribute("progressStatus", STATUS_DONE);
        }
    }
}
 

Progress Listener will read the status of file upload using http request and will set a parameter map in session object so that it can be used for monitoring.


2. Extend the CommonsMultipartResolver provided by Spring framework and use the ProgressListener implemented to check the size of upload.

 
package com.resolver;
 
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.FileUpload;
import org.springframework.web.multipart.MaxUploadSizeExceededException;
import org.springframework.web.multipart.MultipartException;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
 
import com.listener.AjaxProgressListener;
 
 
public class AjaxMultipartResolver extends CommonsMultipartResolver {
    private AjaxProgressListener progressListener;
    private HttpServletRequest httpServletRequest;
 
    public void setProgressListener(AjaxProgressListener progressListener) {
        this.progressListener = progressListener;
    }
 
    public AjaxProgressListener getProgressListener() {
        return progressListener;
    }
 
    public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException {
        try {
            this.httpServletRequest = request;
 
            return super.resolveMultipart(request);
        } catch(MaxUploadSizeExceededException ex) {
                 this.progressListener.updateStatus(AjaxProgressListener.STATUS_MAX_SIZE_EXCEEDS);
             throw new MultipartException(ex.getMessage());
        } catch (Exception ex) {
            //exception is typically thrown when user hits stop or cancel
            //button halfway through upload
            this.progressListener.updateStatus(AjaxProgressListener.STATUS_FAILED);
            throw new MultipartException(ex.getMessage());
        }
    }
}
 
 

3. Update your application-beans.xml for your custom MultipartResolver written in step 2 and re-start the server.

 
<bean id="multipartResolver" class="com.resolver.AjaxMultipartResolver">
        <property name="maxInMemorySize">
                <!-- Max in memory 10kbytes -->
                <value>10240</value>
        </property>
        <property name="maxUploadSize">
                <!--  10 MB Max upload size -->
                <value>1024000000</value>
        </property>
        <!--
        <property name="uploadTempDir">
                <value>/tmp</value>
        </property>
        -->
        <property name="progressListener">
                <ref bean="progressListener" />
        </property>
</bean>
 
<bean id="progressListener" class="com.listener.AjaxProgressListener"/>
 

These values will be used for checking the file upload size and will automatically be set in AjaxMultipartResolver at the time of server start. Change these values according to your need. 

1. package com.mcw.sns.listener;
2. 
   
3. import javax.servlet.http.HttpSession;
4. 
   
5. import net.sf.json.JSONObject;
6. 
   
7. import org.apache.commons.fileupload.ProgressListener;
8. 
   
9. public class AjaxProgressListener implements ProgressListener {
10. 
    
11. public static final String STATUS_UPLOADING = "UPLOADING";
12. public static final String STATUS_FAILED = "FAILED";
13. public static final String STATUS_DONE = "DONE";
14. public static final String STATUS_MAX_SIZE_EXCEEDS = "MAX_SIZE_EXCEEDS";
15. 
    
16. private HttpSession session;
17. 
    
18. public void setSession(HttpSession session) {
19. this.session = session;
20. }
21. 
    
22. public void updateStatus(String status) {
23. session.setAttribute("progressStatus", status);
24. }
25. 
    
26. public void update(long bytesRead, long contentLength, int item) {
27. JSONObject progressMap = new JSONObject();
28. progressMap.put("bytesRead", bytesRead);
29. progressMap.put("contentLength", contentLength);
30. progressMap.put("item", item);
31. session.setAttribute("progressMap", progressMap);
32. 
    
33. if (bytesRead == contentLength) {
34. session.setAttribute("progressStatus", STATUS_DONE);
35. }
36. }
37. 
    
38. }

1. package com.mcw.sns.resolver;
2. 
   
3. import javax.servlet.http.HttpServletRequest;
4. 
   
5. import org.springframework.web.multipart.MaxUploadSizeExceededException;
6. import org.springframework.web.multipart.MultipartException;
7. import org.springframework.web.multipart.MultipartHttpServletRequest;
8. import org.springframework.web.multipart.commons.CommonsMultipartResolver;
9. 
   
10. import com.mcw.sns.listener.AjaxProgressListener;
11.  
12. public class AjaxMultipartResolver extends CommonsMultipartResolver {
13.     private AjaxProgressListener progressListener;
14.     private HttpServletRequest httpServletRequest;
15.  
16.     public void setProgressListener(AjaxProgressListener progressListener) {
17.         this.progressListener = progressListener;
18.     }
19.  
20.     public AjaxProgressListener getProgressListener() {
21.         return progressListener;
22.     }
23.  
24.     public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException {
25.         try {
26.             this.httpServletRequest = request;
27.  
28.             return super.resolveMultipart(request);
29.         } catch(MaxUploadSizeExceededException ex) {
30.          this.progressListener.updateStatus(AjaxProgressListener.STATUS_MAX_SIZE_EXCEEDS);
31.              throw new MultipartException(ex.getMessage());
32.         } catch (Exception ex) {
33.             //exception is typically thrown when user hits stop or cancel
34.             //button halfway through upload
35.             this.progressListener.updateStatus(AjaxProgressListener.STATUS_FAILED);
36.             throw new MultipartException(ex.getMessage());
37.         }
38.     }
39. }
40. 
    

1. <bean id="multipartResolver" class="com.mcw.sns.resolver.AjaxMultipartResolver">
2. <property name="maxInMemorySize">
3. <!-- Max in memory 10kbytes -->
4. <value>10240</value>
5. </property>
6. <property name="maxUploadSize">
7. <!--  10 MB Max upload size -->
8. <value>1024000000</value>
9. </property>
10.         
11.         <property name="uploadTempDir">
12. <value>D:/Temp/</value>
13. </property>
14. <property name="progressListener">
15. <ref bean="progressListener" />
16. </property>
17. </bean>
18.  
19. <bean id="progressListener" class="com.mcw.sns.listener.AjaxProgressListener"/>

이 글은 스프링노트에서 작성되었습니다.

이 글은 스프링노트에서 작성되었습니다.

Auto Wire...

스프링은 네 가지 자동 연결 모드를 제공한다. byName, byType, constructor, autodetect가 있다

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="
5.                 http://www.springframework.org/schema/beans
6.                 http://www.springframework.org/schema/beans/spring-beans.xsd">
7. 
   
8. <bean id="foo" class="com.apress.prospring2.ch03.autowiring.Foo" />
9. <bean id="bar" class="com.apress.prospring2.ch03.autowiring.Bar" />
10. 
    
11. <bean id="byName" autowire="byName"class="com.apress.prospring2.ch03.autowiring.Target" />
12. <bean id="byType" autowire="byType"class="com.apress.prospring2.ch03.autowiring.Target" />
13. <bean id="constructor" autowire="constructor"class="com.apress.prospring2.ch03.autowiring.Target" />
14. <bean id="autodetect" autowire="autodetect"class="com.apress.prospring2.ch03.autowiring.Target" />
15. 
    
16. </beans>

1) byname연결을 사용하면 스프링은 각 속성과 같은 이름을 가진 빈과 연결을 시도한다. 그러므로 만약 타겟 빈이 foo 라는 속성을 가지고 있고 foo라는 빈이 빈팩토리에 정의되어 있다면 foo 빈은 타겟의 foo 속성에 할당된다.

( 즉 위의 xml처럼 foo,bar가 있고 byName bean이 byName 연결을 사용할경우 Target에 정의된 foo,bar에 할당된다 )

2) byType자동 연결을 사용하면 스프링은 빈팩토리에 내부에 타겟 빈의 각 속성의 타입과 같은 타입의 빈으로 연결을 시도한다. 따라서 만약 String 타입 속성을 가진 타겟 빈이 있고 해당 빈팩토리에String 타입 빈이 있다면 스프링은 String 빈을 타겟 빈의 String 타입 속성에 주입할 것이다. 만약 같은 빈팩토리 내부에 같은 타입의 빈이 둘 이상이라면 즉 이 경우에 String 타입 빈이 여러 개면, 스플링은 어떤 것을 자동으로 연결할지 판단할 수 없기 때문에 예외를 발생 시킨다

3) constructor연결 모드는 byType 연결과 비슷하지만 주입을 할 때 세터가 아닌 생성자를 사용한다.스프링은 인자 수가 가장 많은 생성자에 대응을 시도한다. 따라서 만약 두 개의 생성자가 있는 데 하나는 String 타입 하나를 받고 다른 하나는 String과 Integer를 받고 빈팩토리에 String과 Integer 타입의 빈이 스프링은 두 개의 인자를 가지고 있는 생성자를 사용할 것이다.

4) autodetect는 스프링이 constructor와 byType 모드를 자동으로 선택하게 한다. 만약 빈이 (인자가 없는)기본 생성자를 가지고 있다면 스프링은 byType을 사용하고 그렇지 않으면 constructor 방식을 사용한다

이 글은 스프링노트에서 작성되었습니다.

보험합의요령(1).jpg

보험합의요령2(1).jpg

이 글은 스프링노트에서 작성되었습니다.