새로운 Android Fragment 인스턴스화 모범 사례

응용 프로그램에서 새 조각을 인스턴스화하는 두 가지 일반적인 방법을 보았습니다.

Fragment newFragment = new MyFragment();

과

Fragment newFragment = MyFragment.newInstance();

두 번째 옵션은 정적 메소드를 사용 newInstance()하며 일반적으로 다음 메소드를 포함합니다.

public static Fragment newInstance() 
{
    MyFragment myFragment = new MyFragment();
    return myFragment;
}

처음에는 새로운 인스턴스 인스턴스를 만들 때 유연성을 제공하기 위해 newInstance () 메서드를 오버로드 할 수 있다는 사실이 주요 이점이라고 생각했지만 조각에 과부하 된 생성자를 만들어서이 작업을 수행 할 수도 있습니다.

내가 뭘 놓 쳤니?

한 방법이 다른 방법에 비해 어떤 이점이 있습니까? 아니면 좋은 습관입니까?

안드로이드가 나중에 프래그먼트를 다시 생성하기로 결정하면 프래그먼트의 인수가없는 생성자를 호출합니다. 따라서 생성자를 오버로드하는 것은 해결책이 아닙니다.

말했듯이 Android에서 조각을 다시 만든 후에 사용할 수 있도록 조각에 물건을 전달하는 setArguments방법 은 번들을 메서드에 전달하는 것입니다.

예를 들어, 조각에 정수를 전달하려면 다음과 같이 사용하십시오.

public static MyFragment newInstance(int someInt) {
    MyFragment myFragment = new MyFragment();

    Bundle args = new Bundle();
    args.putInt("someInt", someInt);
    myFragment.setArguments(args);

    return myFragment;
}

그리고 나중에 Fragment에서 다음 onCreate()을 사용하여 해당 정수에 액세스 할 수 있습니다.

getArguments().getInt("someInt", 0);

이 번들은 안드로이드가 조각을 재현 한 경우에도 사용할 수 있습니다.

참고 : setArguments조각이 활동에 첨부되기 전에 만 호출 할 수 있습니다.

이 접근법은 안드로이드 개발자 참조 문서에 설명되어 있습니다 : https://developer.android.com/reference/android/app/Fragment.html

newInstance()내가 보는 것을 사용하는 유일한 이점 은 다음과 같습니다.

1. 프래그먼트가 사용하는 모든 인수를 묶을 수있는 단일 장소가 있으며 프래그먼트를 인스턴스화 할 때마다 아래 코드를 작성할 필요가 없습니다.

   Bundle args = new Bundle();
   args.putInt("someInt", someInt);
   args.putString("someString", someString);
   // Put any other arguments
   myFragment.setArguments(args);

2. 다른 클래스에 충실하게 작동 할 것으로 예상 되는 인수를 알려주는 좋은 방법입니다 (단편 인스턴스에 인수가 번들로 묶여 있지 않은 경우 사례를 처리 할 수 ​​있어야 함).

따라서 정적 newInstance()을 사용하여 조각을 인스턴스화하는 것이 좋습니다.

또 다른 방법이 있습니다.

Fragment.instantiate(context, MyFragment.class.getName(), myBundle)

@yydl은 왜 newInstance메소드가 더 좋은지에 대한 설득력있는 이유를 제공합니다 .

안드로이드가 나중에 프래그먼트를 다시 생성하기로 결정하면 프래그먼트의 인수가없는 생성자를 호출합니다. 따라서 생성자를 오버로드하는 것은 해결책이 아닙니다.

여전히 constructor 을 사용하는 것이 가능합니다 . 이것이 왜 그런지 보려면 먼저 위의 대안이 Android에서 사용되는 이유를 알아야합니다.

프래그먼트를 사용하려면 인스턴스가 필요합니다. 안드로이드는 YourFragment()( 인수 생성자 없음) 호출 하여 프래그먼트의 인스턴스를 구성합니다. 안드로이드는 사용할 생성자를 알 수 없으므로 오버로드 된 생성자는 무시됩니다.

활동의 수명 동안 프래그먼트는 위와 같이 생성되고 Android에 의해 여러 번 파괴됩니다. 즉, 조각 개체 자체에 데이터를 넣으면 조각이 파괴되면 데이터가 손실됩니다.

이 문제를 해결하기 위해 android는 Bundle(calling setArguments())을 사용하여 데이터를 저장하도록 요청합니다 YourFragment. 인수 bundle는 Android에 의해 보호되므로 지속적 입니다.

이 번들을 설정하는 한 가지 방법은 정적 newInstance메소드 를 사용하는 것입니다.

public static YourFragment newInstance (int data) {
    YourFragment yf = new YourFragment()
    /* See this code gets executed immediately on your object construction */
    Bundle args = new Bundle();
    args.putInt("data", data);
    yf.setArguments(args);
    return yf;
}

그러나 생성자 :

public YourFragment(int data) {
    Bundle args = new Bundle();
    args.putInt("data", data);
    setArguments(args);
}

newInstance방법 과 정확히 같은 일을 할 수 있습니다 .

당연히, 이것은 실패 할 것이며 Android가 newInstance메소드 를 사용하기를 원하는 이유 중 하나입니다 .

public YourFragment(int data) {
    this.data = data; // Don't do this
}

추가 설명으로 다음은 Android의 Fragment Class입니다.

/**
 * Supply the construction arguments for this fragment.  This can only
 * be called before the fragment has been attached to its activity; that
 * is, you should call it immediately after constructing the fragment.  The
 * arguments supplied here will be retained across fragment destroy and
 * creation.
 */
public void setArguments(Bundle args) {
    if (mIndex >= 0) {
        throw new IllegalStateException("Fragment already active");
    }
    mArguments = args;
}

Android는 인수 를 구성 할 때만 설정하도록 요구하며, 인수 가 유지되도록 보장합니다.

편집 : @JHH의 의견에서 지적했듯이 일부 인수가 필요한 사용자 정의 생성자를 제공하는 경우 Java는 arg 기본 생성자 가 없는 조각을 제공하지 않습니다 . 따라서 팩토리 메소드로 피할 수있는 코드 인 인수 없음 생성자 를 정의해야합니다 newInstance.

편집 : 안드로이드는 더 이상 조각에 과부하 생성자를 사용할 수 없습니다. 이 newInstance방법을 사용해야합니다 .

나는 yydi 답변에 동의하지 않습니다 .

안드로이드가 나중에 프래그먼트를 다시 생성하기로 결정하면 프래그먼트의 인수가없는 생성자를 호출합니다. 따라서 생성자를 오버로드하는 것은 해결책이 아닙니다.

나는 그것이 해결책이고 좋은 것이라고 생각합니다. 이것이 바로 Java 핵심 언어로 개발 된 이유입니다.

안드로이드 시스템이를 파괴하고 다시 만들 수 있다는 것은 사실입니다 Fragment. 그래서 당신은 이것을 할 수 있습니다 :

public MyFragment() {
//  An empty constructor for Android System to use, otherwise exception may occur.
}

public MyFragment(int someInt) {
    Bundle args = new Bundle();
    args.putInt("someInt", someInt);
    setArguments(args);
}

그것은 당신이 당길 수 someInt에서 getArguments()이 경우에도, 후자에 Fragment시스템에 의해 재현되었다. 이것은보다 우아한 솔루션입니다static 생성자 입니다.

내 의견으로는 static생성자는 쓸모가 없으며 사용해서는 안됩니다. 또한 나중에 확장 Fragment하고 생성자에 더 많은 기능을 추가 하려는 경우 제한됩니다 . static생성자를 사용하면 이 작업을 수행 할 수 없습니다.

최신 정보:

Android는 기본이 아닌 모든 생성자에 오류를 표시하는 검사를 추가했습니다.
위에서 언급 한 이유로 비활성화하는 것이 좋습니다.

일부 코 틀린 코드 :

companion object {
    fun newInstance(first: String, second: String) : SampleFragment {
        return SampleFragment().apply {
            arguments = Bundle().apply {
                putString("firstString", first)
                putString("secondString", second)
            }
        }
    }
}

그리고 당신은 이것으로 논쟁을 얻을 수 있습니다 :

val first: String by lazy { arguments?.getString("firstString") ?: "default"}
val second: String by lazy { arguments?.getString("secondString") ?: "default"}

android에서 인수가있는 조각을 인스턴스화하는 가장 좋은 방법은 조각에 정적 팩토리 메소드를 갖는 것입니다.

public static MyFragment newInstance(String name, int age) {
    Bundle bundle = new Bundle();
    bundle.putString("name", name);
    bundle.putInt("age", age);

    MyFragment fragment = new MyFragment();
    fragment.setArguments(bundle);

    return fragment;
}

프래그먼트 인스턴스로 필드를 설정하지 않아야합니다. 안드로이드 시스템이 프래그먼트를 다시 만들 때마다 시스템에 더 많은 메모리가 필요하다고 생각되면 인수없이 생성자를 사용하여 프래그먼트를 다시 작성하는 것보다.

인수로 조각을 인스턴스화 하는 모범 사례에 대한 자세한 정보는 여기를 참조하십시오.

모범 사례에 대한 질문이 있기 때문에 일부 REST 웹 서비스로 작업 할 때 조각을 만들기 위해 하이브리드 접근법을 사용하는 것이 좋습니다.

사용자 조각을 표시하는 경우 복잡한 객체, 예를 들어 일부 사용자 모델을 전달할 수 없습니다.

그러나 우리가 할 수있는 일은 onCreate그 사용자 를 체크인하는 것 입니다! = null이고 그렇지 않은 경우 데이터 레이어에서 가져 오십시오.

이런 식으로 우리는 안드로이드에 의한 프래그먼트 재생의 경우 userId에 의해 다시 생성하는 능력과 사용자 행동에 대한 snappiness뿐만 아니라 객체 자체 또는 ID 만 잡고 프래그먼트를 생성하는 기능을 모두 얻습니다.

무언가가 이것을 좋아합니다 :

public class UserFragment extends Fragment {
    public final static String USER_ID="user_id";
    private User user;
    private long userId;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        userId = getArguments().getLong(USER_ID);
        if(user==null){
            //
            // Recreating here user from user id(i.e requesting from your data model,
            // which could be services, direct request to rest, or data layer sitting
            // on application model
            //
             user = bringUser();
        }
    }

    public static UserFragment newInstance(User user, long user_id){
        UserFragment userFragment = new UserFragment();
        Bundle args = new Bundle();
        args.putLong(USER_ID,user_id);
        if(user!=null){
            userFragment.user=user;
        }
        userFragment.setArguments(args);
        return userFragment;

    }

    public static UserFragment newInstance(long user_id){
        return newInstance(null,user_id);
    }

    public static UserFragment newInstance(User user){
        return newInstance(user,user.id);
    }
}

이 코드를 100 % 사용하여 문제를 해결하십시오

firstFragment 에이 코드를 입력하십시오

public static yourNameParentFragment newInstance() {

    Bundle args = new Bundle();
    args.putBoolean("yourKey",yourValue);
    YourFragment fragment = new YourFragment();
    fragment.setArguments(args);
    return fragment;
}

이 샘플은 부울 데이터를 보냅니다.

그리고 SecendFragment에서

yourNameParentFragment name =yourNameParentFragment.newInstance();
   Bundle bundle;
   bundle=sellDiamondFragments2.getArguments();
  boolean a= bundle.getBoolean("yourKey");

첫 번째 조각의 값은 정적이어야합니다

행복한 코드

프래그먼트를 인스턴스화하는 가장 좋은 방법은 기본 Fragment.instantiate 메소드를 사용하거나 프래그먼트를 인스턴스화하는 팩토리 메소드를
작성하는 것입니다.주의 : 프래그먼트 메모리를 복원하는 동안 항상 프래그먼트에서 하나의 빈 생성자를 작성하면 런타임 예외가 발생합니다.

나는 최근에 여기 있습니다. 그러나 내가 방금 아는 어떤 것이 당신에게 약간 도움이 될 수 있습니다.

Java를 사용하는 경우 변경할 것이 없습니다. 그러나 kotlin 개발자에게는 다음과 같은 스 니펫이 있습니다.

• 부모 조각 :

inline fun <reified T : SampleFragment> newInstance(text: String): T {
    return T::class.java.newInstance().apply {
        arguments = Bundle().also { it.putString("key_text_arg", text) }
    }
}

• 정상적인 전화

val f: SampleFragment = SampleFragment.newInstance("ABC")
// or val f = SampleFragment.newInstance<SampleFragment>("ABC")

• 다음과 같은 방법으로 자식 프래그먼트 클래스에서 부모 초기화 작업을 확장 할 수 있습니다.

fun newInstance(): ChildSampleFragment {
    val child = UserProfileFragment.newInstance<ChildSampleFragment>("XYZ")
    // Do anything with the current initialized args bundle here
    // with child.arguments = ....
    return child
}

행복한 코딩.

setArguments()쓸모가 없습니다. 그것은 단지 혼란을 가져옵니다.

public class MyFragment extends Fragment {

    public String mTitle;
    public String mInitialTitle;

    public static MyFragment newInstance(String param1) {
        MyFragment f = new MyFragment();
        f.mInitialTitle = param1;
        f.mTitle = param1;
        return f;
    }

    @Override
    public void onSaveInstanceState(Bundle state) {
        state.putString("mInitialTitle", mInitialTitle);
        state.putString("mTitle", mTitle);
        super.onSaveInstanceState(state);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle state) {
        if (state != null) {
            mInitialTitle = state.getString("mInitialTitle");
            mTitle = state.getString("mTitle");
        } 
        ...
    }
}

나는 이것을 위해 많은 simpeler 솔루션을 가지고 있다고 생각합니다.

public class MyFragment extends Fragment{

   private String mTitle;
   private List<MyObject> mObjects;

   public static MyFragment newInstance(String title, List<MyObject> objects)
   MyFragment myFrag = new MyFragment();
   myFrag.mTitle = title;
   myFrag.mObjects = objects;
   return myFrag;
   }