You should put `@Singleton`to `CComponent` class declaration.

    @Singleton
    @Component(modules = CCModule.class) 
    public interface CComponent {
        XXX getXXX();
    }

Explanation is in error message: `CComponent` is unscoped, `@Singleton` is a scope. Dagger 2 does not allow unscoped components to use modules with scoped bindings.&lt;br /&gt;
However, now you will get the following error:

    AComponent (unscoped) cannot depend on scoped components:
    @Component(dependencies = CComponent.class, modules = AModule.class)

Unscoped components cannot have scoped dependencies. So you need to make `AComponent` scoped. To do this create custom `AScope` annotation.

    @Scope
    @Retention(RetentionPolicy.RUNTIME)
    public @interface AScope {
    }
And annotate with it `AComponent`:

    @AScope
    @Component(dependencies = CComponent.class, modules = AModule.class)
    public interface AComponent {
    }
These are new requirements appeared in latest [snapshot release](https://github.com/google/dagger/pull/96). It was discussed in corresponding [issue](https://github.com/google/dagger/issues/107) and may still be changed.

Add

    @Singleton
    @Component(modules = {NameModule.class})
    public interface NameComponent {
    
    }

for the component because dagger2 don&#39;t allow to use unscoped components with scoped modules

Looks like a bug in the latest Dagger-2 release:
https://github.com/google/dagger/issues/107

I have a library that has a static field inside. I want to create an app and reference this library so I&#39;d have two instances of this static field. .Net runtime does not allow to reference the same library twice, but I wonder is it possible to overcome this limitation?

I&#39;m not allowed to change the library, but I can copy/rename it.

Is static context always single in C#?

Once I have got in Spark some Row class, either Dataframe or Catalyst, I want to convert it to a case class in my code. This can be done by matching

    someRow match {case Row(a:Long,b:String,c:Double) =&gt; myCaseClass(a,b,c)}
 
But it becomes ugly when the row has a huge number of columns, say a dozen of Doubles, some Booleans and even the occasional null. 

I would like just to be able to -sorry- cast Row to myCaseClass. Is it possible, or have I already got the most economical syntax?


How to convert Row of a Scala DataFrame into case class most efficiently?

I&#39;m having a problem in understanding why the following code doesn&#39;t work.

I have following project structure:

    @Component(modules = CCModule.class) 
    public interface CComponent {
        XXX getXXX();
    }

where 

    @Module
    public class CCModule {

        @Provides @Singleton
        public XXX provide XXX(){
            return new XXX();
        }
    }

and 

    @Component(dependencies = CComponent.class, modules = AAModule.class) 
    public interface AComponent {
        YYY getYYY();
    }

where

    class YYY {
       @Inject
       public YYY(XXX xxx) {
           ...
       }
    }

I initialize everything as:

    CComponent c_component = Dagger_CComponent.builder().cCModule(new CCModule()).build();

    AComponent a_component = Dagger_AComponent.builder()
            .cComponent(c_component)
            .aAModule(new AAModule())
            .build();

Once compilation takes place i get the following error:

&gt; Error:(11, 1) error:
&gt; com.test.CComponent (unscoped) may not
&gt; reference scoped bindings: @Provides @Singleton
&gt; com.test.XXX
&gt; com.test.CCModule.provideXXX()

What I&#39;m aiming for is to have one component inherit bindings from other components to have the same references to an objects (singletons).

Problems with singletons when using component dependencies

I'm having a problem in understanding why the following code doesn't work.
I have following project structure:
<pre><code class="hljs language-csharp">@Component(modules = CCModule.class) 
public interface CComponent {
 XXX getXXX();
}
</code></pre>
where
<pre><code class="hljs language-less">@Module
public class CCModule {

 @Provides @Singleton
 public XXX provide XXX(){
 return new XXX();
 }
}
</code></pre>
and
<pre><code class="hljs language-csharp">@Component(dependencies = CComponent.class, modules = AAModule.class) 
public interface AComponent {
 YYY getYYY();
}
</code></pre>
where
<pre><code class="hljs language-typescript">class YYY {
 @Inject
 public YYY(XXX xxx) {
 ...
 }
}
</code></pre>
I initialize everything as:
<pre><code class="hljs language-scss">CComponent c_component = Dagger_CComponent.builder().cCModule(new CCModule()).build();

AComponent a_component = Dagger_AComponent.builder()
 .cComponent(c_component)
 .aAModule(new AAModule())
 .build();
</code></pre>
Once compilation takes place i get the following error:
> Error:(11, 1) error:
> com.test.CComponent (unscoped) may not
> reference scoped bindings: @Provides @Singleton
> com.test.XXX
> com.test.CCModule.provideXXX()
What I'm aiming for is to have one component inherit bindings from other components to have the same references to an objects (singletons).

I am chaining async operations using RxJava, and I&#39;d like to pass some variable downstream:

    Observable
       .from(modifications)
       .flatmap( (data1) -&gt; { return op1(data1); })
       ...
       .flatmap( (data2) -&gt; { 
           // How to access data1 here ?
           return op2(data2);
       })

It seems like a common pattern but I couldn&#39;t find information about it.


In RxJava, how to pass a variable along when chaining observables?

I have a `LocalDate` variable called `date`, when I print it displays 1988-05-05 I need to convert this to be printed as 05.May 1988. How to do this?

How to format LocalDate to string?

I&#39;m trying to compile my project in IntelliJ idea. I&#39;m using a class in an external jar file and on compilation receiving the following error.

    Class file has wrong version 52.0, should be 50.0

I understand that it&#39;s saying the jar file was compiled with a newer Java version than that which IntelliJ is using. My question is how do I make them compatible? I have updated the Java on my Mac to 1.8 and when I run `java -version` or `javac -version` it confirms this.

What am I missing? (Apart from Java development experience)

Class file has wrong version 52.0, should be 50.0

I have an attribute

    private boolean include;

I would like to set its default value to true, so that in the database it must display True from default. Is this possible in JPA?

How to set default boolean value in JPA

***Solution***:
It was a mistake on my side.

The right way is **response.body().string()** other than **response.body.toString()**

Im using Jetty servlet, the URL is`http://172.16.10.126:8789/test/path/jsonpage`, every time request this URL it will return 

    {&quot;employees&quot;:[
        {&quot;firstName&quot;:&quot;John&quot;, &quot;lastName&quot;:&quot;Doe&quot;}, 
        {&quot;firstName&quot;:&quot;Anna&quot;, &quot;lastName&quot;:&quot;Smith&quot;},
        {&quot;firstName&quot;:&quot;Peter&quot;, &quot;lastName&quot;:&quot;Jones&quot;}
    ]}

It shows up when type the url into a browser, unfortunately it shows kind of memory address other than the json string when I request with `Okhttp`.

    TestActivity﹕ com.squareup.okhttp.internal.http.RealResponseBody@537a7f84




The Okhttp code Im using:

    OkHttpClient client = new OkHttpClient();
    
    String run(String url) throws IOException {
      Request request = new Request.Builder()
          .url(url)
          .build();
    
      Response response = client.newCall(request).execute();
      return response.body().string();
    }



Can anyone helpe?

How does OkHttp get Json string?

I&#39;m trying to wrap my head around scopes in Dagger 2, specifically the lifecycle of scoped graphs. How do you create a component that will be cleaned up when you leave the scope.

In the case of an Android application, using Dagger 1.x you generally have a root scope at the application level which you&#39;d extend to create a child scope at the activity level.

    public class MyActivity {

        private ObjectGraph mGraph;

        public void onCreate() {
            mGraph = ((MyApp) getApplicationContext())
                .getObjectGraph()
                .plus(new ActivityModule())
                .inject(this);
        }

        public void onDestroy() {
            mGraph = null;
        }
    }

The child scope existed as long as you kept a reference to it, which in this case was the lifecycle of your Activity. Dropping the reference in onDestroy ensured the scoped graph was free to be garbage collected.

**EDIT**

Jesse Wilson recently posted a [mea culpa](https://publicobject.com/2014/11/15/dagger-2-has-components/)

&gt; Dagger 1.0 badly screwed up its scope names ... The @Singleton annotation is used for both root graphs and custom graphs, so it&#39;s tricky to figure out what the actual scope of a thing is.

and everything else I&#39;ve read/heard points towards Dagger 2 improving the way scopes work, but I&#39;m struggling to understand the difference. According to @Kirill Boyarshinov&#39;s comment below, the lifecycle of a component or dependency is still determined, as usual, by concrete references. So is the difference between Dagger 1.x and 2.0 scopes purely a matter of semantic clarity?

## My understanding

### Dagger 1.x

Dependencies were either `@Singleton` or not. This was equally true of dependencies in the root graph and subgraphs, leading to ambiguity as to which graph the dependency was bound to (see https://stackoverflow.com/questions/25953525/in-dagger-are-singletons-within-the-sub-graph-cached-or-will-they-always-be-recr)

### Dagger 2.0

Custom scopes allow you to create semantically clear scopes, but are functionally equivalent to applying `@Singleton` in Dagger 1.x.

    // Application level
    @Singleton
    @Component( modules = MyAppModule.class )
    public interface MyAppComponent {
        void inject(Application app);
    }

    @Module
    public class MyAppModule {

        @Singleton @Named(&quot;SingletonScope&quot;) @Provides
        StringBuilder provideStringBuilderSingletonScope() {
            return new StringBuilder(&quot;App&quot;);
        }
    }

---

    // Our custom scope
    @Scope public @interface PerActivity {}

---

    // Activity level
    @PerActivty
    @Component(
        dependencies = MyAppComponent.class,
        modules = MyActivityModule.class
    )
    public interface MyActivityComponent {
        void inject(Activity activity);
    }

    @Module
    public class MyActivityModule {

        @PerActivity @Named(&quot;ActivityScope&quot;) @Provides
        StringBuilder provideStringBuilderActivityScope() {
            return new StringBuilder(&quot;Activity&quot;);
        }

        @Name(&quot;Unscoped&quot;) @Provides
        StringBuilder provideStringBuilderUnscoped() {
            return new StringBuilder(&quot;Unscoped&quot;);
        }
    }

---

    // Finally, a sample Activity which gets injected
    public class MyActivity {

        private MyActivityComponent component;

        @Inject @Named(&quot;AppScope&quot;)
        StringBuilder appScope

        @Inject @Named(&quot;ActivityScope&quot;)
        StringBuilder activityScope1

        @Inject @Named(&quot;ActivityScope&quot;)
        StringBuilder activityScope2

        @Inject @Named(&quot;Unscoped&quot;)
        StringBuilder unscoped1

        @Inject @Named(&quot;Unscoped&quot;)
        StringBuilder unscoped2

        public void onCreate() {
            component = Dagger_MyActivityComponent.builder()
                .myApplicationComponent(App.getComponent())
                .build()
                .inject(this);

            appScope.append(&quot; &gt; Activity&quot;)
            appScope.build() // output matches &quot;App (&gt; Activity)+&quot; 

            activityScope1.append(&quot;123&quot;)
            activityScope1.build() // output: &quot;Activity123&quot;

            activityScope2.append(&quot;456&quot;)
            activityScope1.build() // output: &quot;Activity123456&quot;

            unscoped1.append(&quot;123&quot;)
            unscoped1.build() // output: &quot;Unscoped123&quot;

            unscoped2.append(&quot;456&quot;)
            unscoped2.build() // output: &quot;Unscoped456&quot;

        }

        public void onDestroy() {
            component = null;
        }

    }

The takeaway being that using `@PerActivity` communicates your *intention* regarding the lifecycle of this component, but ultimately you can use the component anywhere/anytime. Dagger&#39;s only promise is that, for a given component, scope annotated methods will return a single instance. I also assume Dagger 2 uses the scope annotation on the component to verify that modules only provide dependencies that are either in the same scope or non-scoped.

### In Summary

Dependencies are still either singleton or non-singleton, but `@Singleton` is now intended for application-level singleton instances and custom scopes are the preferred method for annotating singleton dependencies with a shorter lifecycle.

The developer is responsible for managing the lifecycle of components/dependencies by dropping references that are no longer needed and responsible for ensuring that components are only created once in the scope for which they are intended, but custom scope annotations make it easier to identify that scope.

## The $64k Question*

Is my understanding of Dagger 2 scopes and lifecycles correct?

*\* Not actually a $64&#39;000 question.*

What determines the lifecycle of a component (object graph) in Dagger 2?

I&#39;m trying to add Dagger2 to my project in Android Studio but I can&#39;t find proper dependency to paste in build.gradle. Could you help and send me the proper line?

Dagger2 dependency - Gradle

I use Dagger2 for DI in my android application. I found that I have to write inject method for every class that uses @Inject field. Is there a way that I can just inject the parent class so that I don&#39;t have to call inject on every subclass?
Take Activity for example. I have a `BaseActivity` that that every Activity extends from. Is there a way that I can just create an inject method in the component for BaseActivity and just call inject in BaseActivity&#39;s onCreate, and @inject fields in sub activities get injected automatically?


Can I just inject super class when use dagger2 for dependency injection?

Dagger 1&#39;s `plus()` method is something I used quite often in previous applications, so I understand situations where you might want to have a subcomponent with full access to the parent graphs bindings.

In what situation would it be beneficial to use a *component dependency* instead of a *subcomponent dependency* and why? 

Dagger 2 subcomponents vs component dependencies

I have an Android app that uses Dagger 2 for dependency injection. I am also using the latest gradle build tools that allow a build variant for unit testing and one for instrumentation tests. I am using `java.util.Random` in my app, and I want to mock this for testing. The classes I&#39;m testing don&#39;t use any Android stuff, so they&#39;re just regular java classes.

In my main code I define a `Component` in a class that extends the `Application` class, but in the unit tests I&#39;m not using an `Application`. I tried defining a test `Module` and `Component`, but Dagger won&#39;t generate the `Component`. I have also tried using the `Component` that I defined in my application and swapping the `Module` when I build it, but the application&#39;s `Component` doesn&#39;t have `inject` methods for my test classes. How can I provide a mock implementation of `Random` for testing?

Here&#39;s some sample code:

Application:

    public class PipeGameApplication extends Application {
    
        private PipeGame pipeGame;
    
        @Singleton
        @Component(modules = PipeGameModule.class)
        public interface PipeGame {
            void inject(BoardFragment boardFragment);
            void inject(ConveyorFragment conveyorFragment);
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            pipeGame = DaggerPipeGameApplication_PipeGame.create();
        }
    
        public PipeGame component() {
            return pipeGame;
        }
    }

Module:

    @Module
    public class PipeGameModule {
    
        @Provides
        @Singleton
        Random provideRandom() {
            return new Random();
        }
    }

Base class for tests:


    public class BaseModelTest {
    
        PipeGameTest pipeGameTest;
    
        @Singleton
        @Component(modules = PipeGameTestModule.class)
        public interface PipeGameTest {
            void inject(BoardModelTest boardModelTest);
            void inject(ConveyorModelTest conveyorModelTest);
        }
    
        @Before
        public void setUp() {
            pipeGameTest = DaggerBaseModelTest_PipeGameTest.create(); // Doesn&#39;t work
        }
    
        public PipeGameTest component() {
            return pipeGameTest;
        }
    }

or:

    public class BaseModelTest {
    
        PipeGameApplication.PipeGame pipeGameTest;
    
        // This works if I make the test module extend
        // the prod module, but it can&#39;t inject my test classes
        @Before
        public void setUp() {
            pipeGameTest = DaggerPipeGameApplication_PipeGame.builder().pipeGameModule(new PipeGameModuleTest()).build();
        }
    
        public PipeGameApplication.PipeGame component() {
            return pipeGameTest;
        }
    }

Test Module:

    @Module
    public class PipeGameTestModule {
    
        @Provides
        @Singleton
        Random provideRandom() {
            return mock(Random.class);
        }
    }

Content Type	Original Author	Original Content on Stackoverflow
Question	Cativail	View Question on Stackoverflow
Solution 1 - Java	Kirill Boyarshinov	View Answer on Stackoverflow
Solution 2 - Java	sonal balekai	View Answer on Stackoverflow
Solution 3 - Java	Alexander Vasiljev	View Answer on Stackoverflow

Problems with singletons when using component dependencies

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Solution 3 - Java

How to convert Row of a Scala DataFrame into case class most efficiently?

Is static context always single in C#?

Attributions