2015. 5. 19. 04:03


오늘은 코드보다는 안드로이드 스튜디오에서 사용할 수 있는 유용한 plugin을 하나 소개하려고 한다. 예전에 안드로이드 라이브러리중 ButterKnife를 소개한 적이 있다. 오늘 소개할 plugin은 ButterKnife 라이브러리 사용시 같이 사용하면 코딩을 '두배'는 더 쉽고 편하게 하도록 도와준다. plugin의 이름은 'Android ButterKnife Zelezny'이다.


우선 플러그인을 다운 받기 위해서는, File -> Setting -> plugins 를 선택해도 되고 그냥 shift키를 두번누른 후 검색어에 'plugins'를 입력하면 아랫부분에 선택할 수 있다.plugins를 선택하면 아래와 같은 화면이 나온다.



이 화면에서는 검색해도 나오지 않고 아래쪽에 보이는 버튼 중 가운데 버튼인 'Browse repositories..'를 선택해야 한다.



선택하게되면 위와같은 화면이 나오는데 이때 검색 창에 'ButterKnife'를 입력하면 제일 위에 'Android ButterKnife Zelezny'가 뜨는 것을 확인할 수 있다. 초록색 Install plugin 버튼을 누르고 안드로이드 스튜디오를 재시작 하면 설치과정은 쉽게 끝이난다. 사용법도 간편하다.



위와 같이 레이아웃을 set해줄때, 해당레이아웃에 커서를 옮긴후 generate을 실행시켜주면 된다.(윈도우에서는 alt+insert, 맥에서는 command + n) 그러면 생성할 수 있는 여러 함수들 리스트가 나오는데 그중에 'generate butterKnife injection..'을 선택하면 된다.(버터나이프 마스코트가 왼편에 있다) 



그럼 위와 같은 화면이 뜨고 확인을 누르면,



ButterKnife를 통해 내가 레이아웃에 생성해둔 뷰들이 한번에 inject되는것을 볼 수 있다.


알아둘 점은 레이아웃에 생성한 모든 뷰를 inject하는 것이 아니라 그 중 id값을 추가해 준 뷰들만 inject한다. 또한 adapter에서 레이아웃을 inflate할때, 아래쪽에 있는 'create ViewHolder' 에 체크하면 ViewHolder Pattern에 사용하는 ViewHolder도 한번에 만들어 준다. 꼭 사용해서 조금 더 편한 코딩을 하길 바란다.

Posted by 미뤽
2015. 1. 27. 01:20




[Android pattern 02] 에서의 안정성과 [Android pattern 03] 에서의 가독성을 결합한 새로운 대안이 바로 빌더 패턴이다. 필수 인자를 포함한 빌더객체를 생성하고 선택인자들을 빌더객체에 추가완료한 후에 빌더객체를 통해 원하는 생성자의 객체를 생성한다. 이렇게 하여 만든 생성자의 객체는 변경 불가능(immutable) 객체이다. 설명만 들어서는 이해하기 힘드니 코드를 살펴보자.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public class NutritionFacts {
    private final int servingSize;                    // 필수
    private final int servings;                         // 필수
    private final int calories;                          // 선택
    private final int fat;                                  // 선택
    private final int sodium;                           // 선택
    private final int carbohydrate;                 // 선택
 
    public static class Builder {
        //    필수 인자
        private final int servingSize;
        private final int servings;    
        //    선택적 인자
        private int calories = 0;                    //기본값으로 초기화
        private int fat = 0;    
        private int sodium = 0;
        private int carbohydrate = 0;
 
        public Builder ( int servingSize, int servings ) {
            this.servingSize = servingSize;
            this.servings = servings;
        }
 
        public Builder calories( int val ) { 
            calories = val;
            return this;
        }
 
        public Builder fat( int val ) { 
            fat = val;
            return this;
        }
 
        public Builder sodium( int val ) { 
            sodium = val;
            return this;
        }
 
        public Builder carbohydrate( int val ) { 
            carbohydrate = val;
            return this;
        }
 
        public NutritionFacts build() {
            return new NutritionFacts( this );
        }
    }
 
    private NutritionFacts( Builder builder ) { 
        servingSize = builder.servingSize;
        servings = builder.servings;
        calories = builder.calories;
        fat = builder.fat;
        sodium = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}
cs


NutritionFacts  의 객체는 변경불가능 하고 빌더에 정의되어 있는 setter 메소드들은 빌더 객체 자신을 반환하므로, 설정메소드를 호출하는 코드는 죽 이어서 쓸 수 있다.


1
2
3
4
5
6
7
8
 
NutritionFacts cocaCola = 
        new NutritionFacts().Builder( 2408)
                        .calories( 100 )
                        .sodium ( 35 )
                        .carbohydrate( 27 )
                        .build();
 
cs


빌더패턴은 코드의 가독성도 뛰어나고 사용하기도 쉽다.다만 코드 사용량이 점층적 생성자 패턴 등보다는 많으므로 인자가 충분히 많은 상황에서 이용해야하는게 옳다. 물론 새로운 인자가 추가될 수도 있다는 것을 고려해서 사용하는 방법도 괜찮다.


<참고서적 : Effective Java 2/E>

Posted by 미뤽
2015. 1. 26. 22:19



생성자에 전달하는 인자수가 많은 때 점층적 생성자 패턴과 함께 적용가능한 두번째 패턴은 자바빈 패턴이다.인자가 없는 생성자를 통해 객체를 만든 후, 설정 메서드들을 호출하여 필수, 선택 필드들을 채우는 방법이다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class NutritionFacts {
    private int servingSize = -1;              // 필수
    private int servings = -1;                   // 필수
    private int calories = 0;                     // 선택
    private int fat = 0;                             // 선택
    private int sodium = 0;                      // 선택
    private int carbohydrate = 0;             // 선택
 
    public NutritionFacts() { }
 
    //    setter
    public void setServingSize( int val ) { servingSize = val; }
    public void setServings( int val ) { servings = val; }
    public void setCalories( int val ) { calories = val; }
    public void setFat( int val ) { fat = val; }
    public void setSodium( int val ) { sodium = val; }
    public void setCarbohydrate( int val ) { carbohydrate = val; }
}
cs



위 코드를 통해 생성자 객체를 생성하고 인자를 넣는 방법은


1
2
3
4
5
6
NutritionFacts cocaCola = new NutritionFacts();
cocaCola.setServingSize( 240 );
cocaCola.setServings( 8 );
cocaCola.setCalories( 100 );
cocaCola.setSodium( 35 );
cocaCola.setCarbohydrate( 27 );
cs


이 패턴은 점층적 생성자 패턴과는 다르게 읽기도 쉽고 생성하기도 좋다. 하지만 이 패턴에는 두가지 심각한 단점이 있는데, 첫번째는 1회의 함수 호출로 객체 생성을 끝낼 수 없으므로, 객체 일관성(consistency)이 일시적으로 깨질 수 있다는 점이고 두번재는 자바빈 패턴으로는 변경 불가능(immutable)클래스를 만들 수 없다는 것이다.


<참고서적 : Effective Java 2/E>


Posted by 미뤽