乌龟爱吃肉
乌龟爱吃肉

Dagger2 生成代码学习笔记

上一篇记录了如何使用Dagger，其中还漏了一些内容，回头再补。今天来看看Dagger在预编译时期生成的辅助代码，看看Dagger做依赖注入的实现原理是咋样的。
还是从上一篇中最简单的Sample开始。先看下代码：
MainActivity:

public class MainActivity extends AppCompatActivity {

    @Inject
    UserModel user;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        DaggerUserComponent.builder()
                .userModule(new UserModule())
                .build()
                .inject(this);

        ((TextView) findViewById(R.id.text_view)).setText("Name:" + user.getName() + "::Age:" + user.getAge());
    }
}

UserModel:

public class UserModel {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

UserModule:

@Module
public class UserModule {

    UserModule() {}

    @Provides
    UserModel provideUsers() {
        UserModel user = new UserModel();
        user.setName("lala");
        user.setAge(18);
        return user;
    }
}

UserComponent:

@Component(modules = {UserModule.class})
public interface UserComponent {
    void inject(MainActivity mainActivity);
}

运行结果如下：


Dagger2 生成代码学习笔记_第1张图片
Screenshot_2017-02-08-11-40-46.png

OK，咱们先来看看Dagger为我们上面的代码生成了哪些东东。
咱们自己的类：
1.MainActivity
2.UserComponent
3.UserModel
4.UserModule
Dagger生成的类：
1.DaggerUserComponent
2.UserModule_ProvideUsersFactory
3.MainActivity_MembersInjector
好，下面来逐个看看这几个生成类

直接从我们执行注入的代码下手:

DaggerUserComponent.builder()
                .userModule(new UserModule())
                .build()
                .inject(this);

可以看到，我们通过Builder方式，传一个UserModule的实例，build一个DaggerUserComponent的实例出来，然后调用 inject 方法执行注入操作。
下面喽一眼DaggerUserComponent的代码。
DaggerUserComponent:

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerUserComponent implements UserComponent {
  private Provider provideUsersProvider;
  private MembersInjector mainActivityMembersInjector;

  private DaggerUserComponent(Builder builder) {  
    assert builder != null;
    initialize(builder);
  }

  public static Builder builder() {  
    return new Builder();
  }

  public static UserComponent create() {  
    return builder().build();
  }

  private void initialize(final Builder builder) {  
    this.provideUsersProvider = UserModule_ProvideUsersFactory.create(builder.userModule);
    this.mainActivityMembersInjector = MainActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), provideUsersProvider);
  }

  @Override
  public void inject(MainActivity mainActivity) {  
    mainActivityMembersInjector.injectMembers(mainActivity);
  }

  public static final class Builder {
    private UserModule userModule;
  
    private Builder() {  
    }
  
    public UserComponent build() {  
      if (userModule == null) {
        this.userModule = new UserModule();
      }
      return new DaggerUserComponent(this);
    }
  
    public Builder userModule(UserModule userModule) {  
      if (userModule == null) {
        throw new NullPointerException("userModule");
      }
      this.userModule = userModule;
      return this;
    }
  }
}

这个类非常简单，它实现了咱们写的UserComponent接口，实现了inject方法。重点在初始化 (initialize) 和注入 (inject) 两个方法。

private Provider provideUsersProvider;
private MembersInjector mainActivityMembersInjector;

private void initialize(final Builder builder) {  
    this.provideUsersProvider = UserModule_ProvideUsersFactory.create(builder.userModule);
    this.mainActivityMembersInjector = MainActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), provideUsersProvider);
  }

可以看到，initialize这个方法创建了两个成员变量，provideUsersProvider 和 mainActivityMembersInjector。
创建Provider的代码引出了第二个生成类: UserModule_ProvideUserFactory

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class UserModule_ProvideUsersFactory implements Factory {
  private final UserModule module;

  public UserModule_ProvideUsersFactory(UserModule module) {  
    assert module != null;
    this.module = module;
  }

  @Override
  public UserModel get() {  
    UserModel provided = module.provideUsers();
    if (provided == null) {
      throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
    }
    return provided;
  }

  public static Factory create(UserModule module) {  
    return new UserModule_ProvideUsersFactory(module);
  }
}

顾名思义，UserModule_ProvideUsersFactory 是一个工厂类，此类用来生产我们用 @Inject 注解的UserModel实例。
上面这句是屁话，UserModel的真正的实例并不在这里生产，可以看到，这个“伪工厂”接受一个咱们写的UserModule的实例，然后在get方法中调用UserModule的provideUsers()方法（咱们自己写的），把拿到的UserModel实例返回。
咱们回到DaggerUserComponent，再瞄一眼初始化的第一句代码:
this.provideUsersProvider = UserModule_ProvideUsersFactory.create(builder.userModule);
在这里创建了一个生产UserModel实例的工厂实例。该实例的get方法返回一个UserModel的实例（从Module的provide方法中拿到的）。
OK，拿到了Provider的实例，来看看初始化的第二行代码:
this.mainActivityMembersInjector = MainActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), provideUsersProvider);
这里引出了第三个生成类，MainActivity_MembersInjector.

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class MainActivity_MembersInjector implements MembersInjector {
  private final MembersInjector supertypeInjector;
  private final Provider userProvider;

  public MainActivity_MembersInjector(MembersInjector supertypeInjector, Provider userProvider) {  
    assert supertypeInjector != null;
    this.supertypeInjector = supertypeInjector;
    assert userProvider != null;
    this.userProvider = userProvider;
  }

  @Override
  public void injectMembers(MainActivity instance) {  
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    supertypeInjector.injectMembers(instance);
    instance.user = userProvider.get();
  }

  public static MembersInjector create(MembersInjector supertypeInjector, Provider userProvider) {  
      return new MainActivity_MembersInjector(supertypeInjector, userProvider);
  }
}

MainActivity_MembersInjector的create方法接收两个参数，生成一个实例返回。这个类实现了MembersInjector接口，实现了injectMembers方法，咦？
instance.user = userProvider.get();
真相只有一个，这一句才是真正执行注入的代码。从接收到的Provider实例中通过调用get方法拿到UserModel实例，并赋给传进来的MainActivity实例的user成员变量。这也是为什么我们用 @Inject 注解的变量不可以是private的原因。
所以这么看下来，注入过程还是很简单的，像很多文章说的那样，There is no magic with Dagger.
就在飘飘然的时候，瞄见了这句代码
supertypeInjector.injectMembers(instance);
supertypeInjector？这个是初始化的时候创建塞进来的:

this.mainActivityMembersInjector = MainActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), provideUsersProvider);

注意这里有两个长得很像的类，MembersInjector 和 MembersInjectors，卧槽。
MembersInjector是一个接口，就是上面提到的那个，里面只有一个injectMembers抽象方法。那MembersInjectors是什么鬼...

public final class MembersInjectors {
  /**
   * Returns a {@link MembersInjector} implementation that injects no members
   *
   * 
Note that there is no verification that the type being injected does not have {@link Inject}
   * members, so care should be taken to ensure appropriate use.
   */
  @SuppressWarnings("unchecked")
  public static  MembersInjector noOp() {
    return (MembersInjector) NoOpMembersInjector.INSTANCE;
  }

  private static enum NoOpMembersInjector implements MembersInjector {
    INSTANCE;

    @Override public void injectMembers(Object instance) {
      if (instance == null) {
        throw new NullPointerException();
      }
    }
  }

  /**
   * Returns a {@link MembersInjector} that delegates to the {@link MembersInjector} of its
   * supertype.  This is useful for cases where a type is known not to have its own {@link Inject}
   * members, but must still inject members on its supertype(s).
   *
   * 
Note that there is no verification that the type being injected does not have {@link Inject}
   * members, so care should be taken to ensure appropriate use.
   */
  @SuppressWarnings("unchecked")
  public static  MembersInjector delegatingTo(MembersInjector delegate) {
    return (MembersInjector) delegate;
  }

  private MembersInjectors() {}
}
 
 
初始化中调用的noOp方法返回一个NoOpMembersInjector枚举类，这个类同样实现了MembersInjector接口，在injectMembers方法中check了instance是否为null。
 什么鬼，在注入前不是已经check过了么:
 
 
@Override
  public void injectMembers(MainActivity instance) {  
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    supertypeInjector.injectMembers(instance);
    instance.user = userProvider.get();
  }

 
 
这个鬼地方先按下不表，因为我也布吉岛，回头再看看回来补上，现在看不懂为什么要连着check两次。
 
 
除了上面这个问题，对于Dagger依赖注入的流程应该是比较清晰的。首先build一个DaggerUserComponent实例，把Module传进去，再调它的inject方法，DaggerUserComponent的inject方法会调到MainActivityMembersInjector的injectMembers方法，在这里执行真正的注入。
 
 
以上是依赖注入一个实例时Dagger生成的辅助代码。如果我们给两个成员注入，如下:
 
 
public class MainActivity extends AppCompatActivity {

    @Inject
    UserModel user1;

    @Inject
    UserModel user2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        DaggerUserComponent.builder()
                .userModule(new UserModule())
                .build()
                .inject(this);

        user2.setName("Arya Stark");
        user2.setAge(12);

        ((TextView) findViewById(R.id.text_view_1)).setText("Name:" + user1.getName() + "::Age:" + user1.getAge());
        ((TextView) findViewById(R.id.text_view_2)).setText("Name:" + user2.getName() + "::Age:" + user2.getAge());
    }
}

 
 
就不传图了，结果是两个不一样的TextView内容，因为这是两个不同的实例。
 那么问题来了，那单例呢？
 还是用这个Sample，我给Component类和provide方法都加上 @Singleton 注解，最后的得到的结果就是单例，怎么做到的？
 对比了代码后，我发现加Singleton注解和不加两种情况下，DaggerUserComponent的初始化代码偷偷发生了变化。
 不加 @Singleton 注解:
 
 
private void initialize(final Builder builder) {  
    this.provideUsersProvider = UserModule_ProvideUsersFactory.create(builder.userModule);
    this.mainActivityMembersInjector = MainActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), provideUsersProvider);
  }

 
 
加 @Singleton注解:
 
 
private void initialize(final Builder builder) {  
    this.provideUsersProvider = ScopedProvider.create(UserModule_ProvideUsersFactory.create(builder.userModule));
    this.mainActivityMembersInjector = MainActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), provideUsersProvider);
  }

 
 
看出区别了吧？不加注解的时候拿到的Provider是UserModule_ProvideUsersFactory的实例，加了注解后拿到的是ScopedProvider的实例。
 好，来看看这个ScopedProvider.
 
 
/**
 * A {@link Provider} implementation that memoizes the result of a {@link Factory} instance.
 *
 * @author Gregory Kick
 * @since 2.0
 */
public final class ScopedProvider implements Provider {
  private static final Object UNINITIALIZED = new Object();

  private final Factory factory;
  private volatile Object instance = UNINITIALIZED;

  private ScopedProvider(Factory factory) {
    assert factory != null;
    this.factory = factory;
  }

  @SuppressWarnings("unchecked") // cast only happens when result comes from the factory
  @Override
  public T get() {
    // double-check idiom from EJ2: Item 71
    Object result = instance;
    if (result == UNINITIALIZED) {
      synchronized (this) {
        result = instance;
        if (result == UNINITIALIZED) {
          instance = result = factory.get();
        }
      }
    }
    return (T) result;
  }

  /** Returns a new scoped provider for the given factory. */
  public static  Provider create(Factory factory) {
    if (factory == null) {
      throw new NullPointerException();
    }
    return new ScopedProvider(factory);
  }
}

 
 
其实所谓的ScopedProvider就是把Factory包了一层，在里面存储了Factory的实例。当我们调用inject时，DaggerUserComponent会把调用转发给Provider，此时也就是ScopedProvider的get方法，单例的关键就在这里。
 这个类里定义了一个静态常量UNINITIALIZED,第一次进入get方法时，会把现在还是静态常量的instance赋给result局部变量。然后进入判断，拿锁，从factory实例中取出UserModel实例，赋给instance和result，然后把result返回。此时，instance变量已经变成了我们之前拿到的那个UserModel实例了。后面再进来，局部变量result(之前的UserModel实例)和静态常量不等，就再也进不去判断，直接返回instance，也就实现了单例。
 但是注意，这个单例是存在于DaggerUserComponent的实例中的，也就是说，如果DaggerUserComponent产生了新的实例，那么也会产生新的UserModel实例。不能光说不练，来做个实验。
 对MainActivity做以下更改：
 
 
public class MainActivity extends AppCompatActivity {

    @Inject
    UserModel user1;

    @Inject
    UserModel user2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        DaggerUserComponent.builder()
                .userModule(new UserModule())
                .build()
                .inject(this);

        user2.setName("Arya Stark");
        user2.setAge(12);

        ((TextView) findViewById(R.id.text_view_1)).setText("Name:" + user1.getName() + "::Age:" + user1.getAge());
        ((TextView) findViewById(R.id.text_view_2)).setText("Name:" + user2.getName() + "::Age:" + user2.getAge());

        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                DaggerUserComponent.builder()
                        .userModule(new UserModule())
                        .build()
                        .inject(MainActivity.this);
                ((TextView) findViewById(R.id.text_view_1)).setText("Name:" + user1.getName() + "::Age:" + user1.getAge());
                ((TextView) findViewById(R.id.text_view_2)).setText("Name:" + user2.getName() + "::Age:" + user2.getAge());
            }
        }, 2000);
    }
}

 
 
在第一次设置TextView的文字完了两秒后，重新进行一次注入，再更新TextView的显示。现象就是，先显示Arya Stark的信息，两秒后更新为十八岁的lala。因为第二次注入时生成了DaggerUserComponent的新实例，单例也就失效了。
 
 
自定义 @UserScope 注解
 既然前面已经把Dagger中的 @Singleton 的实现扒了个精光，那么应该很容易自定义Scope了。因为单例存在于ScopedProvider，而ScopedProvider是在Component中创建的，所以要自定义Scope，其实就是控制好Dagger给咱们生成的Component实现的生命周期。
 哦对了，先想想Scope是干啥的。我的理解是，保证某个类在一个时期中的实例的单一，也就是在定义的时期中是单例。比如我希望我们的CP项目Model在项目Activity中是单例，那么就可以定义一个ActivityScope，我希望我们的UserModel在用户登陆后直到登出前是一个单例，那么就定义一个从登陆到登出的UserScope。
 现在拓展一下我们的Sample. 在MainActivity之外，再创建SecondActivity和ThirdActivity，假设咱们的用户在SecondActivity登录，我们需要UserModel在SecondActivity到ThirdActivity之间是单例。
 OK，既然UserScope跨Activity，那只能在比Activity更大的Scope下定义了，这个Scope只能是整个App的ApplicationScope。
 好吧，咱们还是按流程来。先为整个App定义最大的Component:
 
 
@Singleton
@Component(modules = {AppModule.class})
public interface AppComponent {

    UserComponent plus(UserModule userModule);

}

 
 
注解里标识的AppModule:
 
 
@Module
public class AppModule {

    private Application application;

    public AppModule(Application application) {
        this.application = application;
    }

    @Provides
    public Application provideApplication() {
        return application;
    }

}

 
 
然后添加两个Activity，SecondActivity和ThirdActivity，并为他们分别添加Component和Module，代码就不贴了。
 这里咱们要用到一个叫做@Subcomponent的注解，它标识子Component在父Component下进行实现，后面看了源码就明白了，先记着。
 
 
@Subcomponent(modules = {SecondActivityModule.class})
public interface SecondActivityComponent {
    SecondActivity inject(SecondActivity secondActivity);
}

 
 
@Subcomponent(modules = {ThirdActivityModule.class})
public interface ThirdActivityComponent {
    ThirdActivity inject(ThirdActivity thirdActivity);
}

 
 
这两个子Component的接口在inject方法中接收一个自己的Activity，然后返回去。
 之后，添加一个Application的子类:
 
 
public class DaggerDemoApplication extends Application {

    private AppComponent appComponent;
    private UserComponent userComponent;

    public static DaggerDemoApplication get(Context context) {
        return (DaggerDemoApplication) context.getApplicationContext();
    }

    @Override
    public void onCreate() {
        super.onCreate();
        initAppComponent();
    }

    private void initAppComponent() {
        appComponent = DaggerAppComponent.builder()
                .appModule(new AppModule(this))
                .build();
    }

    public UserComponent createUserComponent() {
        userComponent = appComponent.plus(new UserModule());
        return userComponent;
    }

    public void destroyUserComponent() {
        userComponent = null;
    }

    public AppComponent getAppComponent() {
        return appComponent;
    }

    public UserComponent getUserComponent() {
        return userComponent;
    }
}

 
 
注意，要在Manifest里头为Application标签加上name属性，name设为这个类名。这样，这个类就会在整个App启动的时候率先执行。
 就像前面说的，因为UserScope跨Activity，所以要把它存在AppScope里头，也就是说当UserScope开始时创建UserComponent的实现并存起来，当UserScope结束的时候，把UserComponent的实例释放。所以在这里有create和destroy两个方法，用于控制UserComponent的生命周期。
 创建UserScope注解:
 
 
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface UserScope {
}

 
 
现在更改一下Activity的内容，把MainActivity的内容更换成一个按钮，用于开启SecondActivity，在SecondActivity上添加两个TextView和一个按钮用于开启ThirdActivity，ThirdActivity只有两个TextView。
 MainActivity:
 
 
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startActivity(new Intent(MainActivity.this, SecondActivity.class));
            }
        });
    }
}

 
 
public class SecondActivity extends AppCompatActivity {

    @Inject
    UserModel user;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        DaggerDemoApplication.get(this).createUserComponent();

        DaggerDemoApplication.get(this)
                .getUserComponent()
                .plus(new SecondActivityModule())
                .inject(this);

        user.setName("Arya");
        user.setAge(12);
        ((TextView) findViewById(R.id.text_view)).setText("Name:" + user.getName() + ":::Age:" + user.getAge());

        findViewById(R.id.button_second).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startActivity(new Intent(SecondActivity.this, ThirdActivity.class));
            }
        });
    }

    @Override
    public void finish() {
        DaggerDemoApplication.get(this).destroyUserComponent();
        super.finish();
    }
}

 
 
public class ThirdActivity extends AppCompatActivity {

    @Inject
    UserModel user;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_third);

        DaggerDemoApplication.get(this)
                .getUserComponent()
                .plus(new ThirdActivityModule())
                .inject(this);

        ((TextView) findViewById(R.id.text_view)).setText("Name:" + user.getName() + ":::Age:" + user.getAge());
    }
}

 
 
运行一下。
 
 
 
 
 
  
 
   
 
    Dagger2 生成代码学习笔记_第2张图片 
   
 
  
 
  

    Screenshot_2017-02-09-09-48-06.png 
  
 
 
 
 
 
 
 
  
 
   
 
    Dagger2 生成代码学习笔记_第3张图片 
   
 
  
 
  

    Screenshot_2017-02-09-09-48-10.png 
  
 
 
 
 
 
 
 
  
 
   
 
    Dagger2 生成代码学习笔记_第4张图片 
   
 
  
 
  

    Screenshot_2017-02-09-09-48-14.png 
  
 
 
 
 
 
 
可以看到，我在SecondActivity和ThirdActivity分别进行了一次注入，只在SecondActivity更改了user的值，结果在ThirdActivity中也生效了，说明这个UserModel实例在SecondActivity和ThirdActivity之间是单例的存在。
 下面咱来看看Dagger为咱们生成的代码是怎么做到的。
 
 
与之前不同，Dagger在这里并没有生成UserComponent实现的单独类，而是将它作为DaggerAppComponent的内部类。
 
 
@Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerAppComponent implements AppComponent {
  private DaggerAppComponent(Builder builder) {  
    assert builder != null;
  }

  public static Builder builder() {  
    return new Builder();
  }

  @Override
  public UserComponent plus(UserModule userModule) {  
    return new UserComponentImpl(userModule);
  }

  public static final class Builder {
    private AppModule appModule;
  
    private Builder() {  
    }
  
    public AppComponent build() {  
      if (appModule == null) {
        throw new IllegalStateException("appModule must be set");
      }
      return new DaggerAppComponent(this);
    }
  
    public Builder appModule(AppModule appModule) {  
      if (appModule == null) {
        throw new NullPointerException("appModule");
      }
      this.appModule = appModule;
      return this;
    }
  }

  private final class UserComponentImpl implements UserComponent {
    private final UserModule userModule;
    private Provider provideUsersProvider;
  
    private UserComponentImpl(UserModule userModule) {  
      if (userModule == null) {
        throw new NullPointerException();
      }
      this.userModule = userModule;
      initialize();
    }
  
    private void initialize() {  
      this.provideUsersProvider = ScopedProvider.create(UserModule_ProvideUsersFactory.create(userModule));
    }
  
    @Override
    public SecondActivityComponent plus(SecondActivityModule secondActivityModule) {  
      return new SecondActivityComponentImpl(secondActivityModule);
    }
  
    @Override
    public ThirdActivityComponent plus(ThirdActivityModule thirdActivityModule) {  
      return new ThirdActivityComponentImpl(thirdActivityModule);
    }
  
    private final class SecondActivityComponentImpl implements SecondActivityComponent {
      private final SecondActivityModule secondActivityModule;
      private MembersInjector secondActivityMembersInjector;
    
      private SecondActivityComponentImpl(SecondActivityModule secondActivityModule) {  
        if (secondActivityModule == null) {
          throw new NullPointerException();
        }
        this.secondActivityModule = secondActivityModule;
        initialize();
      }
    
      private void initialize() {  
        this.secondActivityMembersInjector = SecondActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), UserComponentImpl.this.provideUsersProvider);
      }
    
      @Override
      public SecondActivity inject(SecondActivity secondActivity) {  
        secondActivityMembersInjector.injectMembers(secondActivity);
        return secondActivity;
      }
    }
  
    private final class ThirdActivityComponentImpl implements ThirdActivityComponent {
      private final ThirdActivityModule thirdActivityModule;
      private MembersInjector thirdActivityMembersInjector;
    
      private ThirdActivityComponentImpl(ThirdActivityModule thirdActivityModule) {  
        if (thirdActivityModule == null) {
          throw new NullPointerException();
        }
        this.thirdActivityModule = thirdActivityModule;
        initialize();
      }
    
      private void initialize() {  
        this.thirdActivityMembersInjector = ThirdActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), UserComponentImpl.this.provideUsersProvider);
      }
    
      @Override
      public ThirdActivity inject(ThirdActivity thirdActivity) {  
        thirdActivityMembersInjector.injectMembers(thirdActivity);
        return thirdActivity;
      }
    }
  }
}

 
 
这个类相对比较长，但是也不难理解。可以看一眼我们是如何在DaggerDemoApplication中创建AppComponent和UserComponent的实现的。
 
 
private void initAppComponent() {
        appComponent = DaggerAppComponent.builder()
                .appModule(new AppModule(this))
                .build();
    }

    public UserComponent createUserComponent() {
        userComponent = appComponent.plus(new UserModule());
        return userComponent;
    }

 
 
父Component AppComponent实现的创建与之前无异，使用它的Builder，传一个AppModule实例再build。而作为子Component的UserComponent的创建就不同了。这里调用AppComponent的plus方法，这个方法是我们定义的接口，接收一个UserModule实例，返回UserComponent.
 在我们调用plus的时候，创建了UserComponentImpl实例并返回。在这个内部类中也有两个我们定义的接口方法，分别接收自己Activity的Module，然后返回自己Activity的Component，在这里又分别创建了SecondActivityComponentImpl和ThirdActivityComponentImpl实例。
 再进到这两个内部类中可以看到，真正的注入方法在这里。
 
 
@Override
      public SecondActivity inject(SecondActivity secondActivity) {  
        secondActivityMembersInjector.injectMembers(secondActivity);
        return secondActivity;
      }

 
 
注意，这里的secondActivityMembersInjector在SecondActivityComponentImpl的初始化方法中创建:
 
 
private void initialize() {  
        this.secondActivityMembersInjector = SecondActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), UserComponentImpl.this.provideUsersProvider);
      } 

 
 
而provider是在UserComponentImpl中的初始化方法中创建的:
 
 
private void initialize() {  
      this.provideUsersProvider = ScopedProvider.create(UserModule_ProvideUsersFactory.create(userModule));
    }

 
 
剩下的注入流程和之前的就一样了。inject方法中调用SecondActivity_MembersInjector的injectMembers方法，在这里通过调用Provider的get方法，由provider决定是否需要新建实例，需要时再调到咱们的provide方法拿到真正的实例并返回，不需要时直接返回。
 以上是对使用 @SubComponent 注解实现自定义Scope的源码解析。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Dagger2 生成代码学习笔记)

        

            

                
    
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • html 中如何使用 uniapp 的部分方法
                        某公司摸鱼前端
htmluni-app前端
                        
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验
                        我的运维人生
信息可视化数据分析数据挖掘运维开发技术共享
                        
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
    
                    
    • 
                    
  • LLM 词汇表
                        落难Coder
LLMsNLP大语言模型大模型llama人工智能
                        
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
    
                    
    • 
                    
  • 将cmd中命令输出保存为txt文本文件
                        落难Coder
Windowscmdwindow
                        
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
    
                    
    • 
                    
  • 基于社交网络算法优化的二维最大熵图像分割
                        智能算法研学社（Jack旭）
智能优化算法应用图像分割算法php开发语言
                        
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
    
                    
    • 
                    
  • 关于提高复杂业务逻辑代码可读性的思考
                        编程经验分享
开发经验java数据库开发语言
                        
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 使用Faiss进行高效相似度搜索
                        llzwxh888
faisspython
                        
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
    
                    
    • 
                    
  • 使用LLaVa和Ollama实现多模态RAG示例
                        llzwxh888
python人工智能开发语言
                        
    本文将详细介绍如何使用LLaVa和Ollama实现多模态RAG（检索增强生成），通过提取图像中的结构化数据、生成图像字幕等功能来展示这一技术的强大之处。安装环境首先，您需要安装以下依赖包：!pipinstallllama-index-multi-modal-llms-ollama!pipinstallllama-index-readers-file!pipinstallunstructured!p
    
                    
    • 
                    
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
                        nseejrukjhad
数据库python
                        
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
    
                    
    • 
                    
  • 数组去重
                        好奇的猫猫猫

                        
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
    
                    
    • 
                    
  • GitHub上克隆项目
                        bigbig猩猩
github
                        
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • 【JS】执行时长(100分) |思路参考+代码解析（C++）
                        l939035548
JS算法数据结构c++
                        
    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
    
                    
    • 
                    
  • ARM中断处理过程
                        落汤老狗
嵌入式linux
                        
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
    
                    
    • 
                    
  • Python 实现图片裁剪（附代码） | Python工具
                        剑客阿良_ALiang

                        
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）
                        算法大师
华为od面试python算法前端
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
    
                    
    • 
                    
  • python os 环境变量
                        CV矿工
python开发语言numpy
                        
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
    
                    
    • 
                    
  • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    
                    
    • 
                    
  • 01-Git初识
                        Meereen
Gitgit
                        
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
    
                    
    • 
                    
  • 【PG】常见数据库、表属性设置
                        江无羡
数据库
                        
    PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
    
                    
    • 
                    
  • 【Git】常见命令(仅笔记)
                        好想有猫猫
GitLinux学习笔记git笔记elasticsearchlinuxc++
                        
    文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
    
                    
    • 
                    
  • 在Ubuntu中编译含有JSON的文件出现报错
                        芝麻糊76
Linuxkill_buglinuxubuntujson
                        
    在ubuntu中进行JSON相关学习的时候，我发现了一些小问题，决定与大家进行分享，减少踩坑时候出现不必要的时间耗费截取部分含有JSON部分的代码进行展示char*str="{\"title\":\"JSONExample\",\"author\":{\"name\":\"JohnDoe\",\"age\":35,\"isVerified\":true},\"tags\":[\"json\",\"
    
                    
    • 
                                
  • Java常用排序算法/程序员必须掌握的8大排序算法
                                    cugfy
java
                                    
    分类： 
 
1）插入排序（直接插入排序、希尔排序） 
2）交换排序（冒泡排序、快速排序） 
3）选择排序（直接选择排序、堆排序） 
4）归并排序 
5）分配排序（基数排序） 
 
所需辅助空间最多：归并排序 
所需辅助空间最少：堆排序 
平均速度最快：快速排序 
 
不稳定：快速排序，希尔排序，堆排序。 
 
先来看看8种排序之间的关系： 
 
  
 
 1.直接插入排序 
 
（1
    
                                
    • 
                                
  • 【Spark102】Spark存储模块BlockManager剖析
                                    bit1129
manager
                                    
    Spark围绕着BlockManager构建了存储模块，包括RDD，Shuffle，Broadcast的存储都使用了BlockManager。而BlockManager在实现上是一个针对每个应用的Master/Executor结构，即Driver上BlockManager充当了Master角色，而各个Slave上(具体到应用范围，就是Executor)的BlockManager充当了Slave角色
    
                                
    • 
                                
  • linux 查看端口被占用情况详解
                                    daizj
linux端口占用netstatlsof
                                    
    经常在启动一个程序会碰到端口被占用，这里讲一下怎么查看端口是否被占用，及哪个程序占用，怎么Kill掉已占用端口的程序 
  
1、lsof -i:port 
port为端口号 
  
[root@slave /data/spark-1.4.0-bin-cdh4]# lsof -i:8080 
COMMAND   PID USER   FD   TY
    
                                
    • 
                                
  • Hosts文件使用
                                    周凡杨
hostslocahost
                                    
         一切都要从localhost说起，经常在tomcat容器起动后，访问页面时输入http://localhost:8088/index.jsp，大家都知道localhost代表本机地址，如果本机IP是10.10.134.21，那就相当于http://10.10.134.21:8088/index.jsp，有时候也会看到http: 127.0.0.1:
    
                                
    • 
                                
  • java excel工具
                                    g21121
Java excel
                                    
    直接上代码，一看就懂，利用的是jxl： 
import java.io.File;
import java.io.IOException;
import jxl.Cell;
import jxl.Sheet;
import jxl.Workbook;
import jxl.read.biff.BiffException;
import jxl.write.Label;
import 
    
                                
    • 
                                
  • web报表工具finereport常用函数的用法总结（数组函数）
                                    老A不折腾
finereportweb报表函数总结
                                    
    ADD2ARRAY 
ADDARRAY(array,insertArray, start):在数组第start个位置插入insertArray中的所有元素，再返回该数组。 
示例： 
ADDARRAY([3,4, 1, 5, 7], [23, 43, 22], 3)返回[3, 4, 23, 43, 22, 1, 5, 7]. 
ADDARRAY([3,4, 1, 5, 7], "测试&q
    
                                
    • 
                                
  • 游戏服务器网络带宽负载计算
                                    墙头上一根草
服务器
                                    
    家庭所安装的4M，8M宽带。其中M是指，Mbits/S 
其中要提前说明的是： 
8bits = 1Byte 
即8位等于1字节。我们硬盘大小50G。意思是50*1024M字节，约为 50000多字节。但是网宽是以“位”为单位的，所以，8Mbits就是1M字节。是容积体积的单位。 
8Mbits/s后面的S是秒。8Mbits/s意思是 每秒8M位，即每秒1M字节。 
我是在计算我们网络流量时想到的
    
                                
    • 
                                
  • 我的spring学习笔记2-IoC（反向控制 依赖注入）
                                    aijuans
Spring 3 系列
                                    
    IoC（反向控制 依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 
IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明： 
如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
    
                                
    • 
                                
  • 高性能mysql 之 选择存储引擎(一)
                                    annan211
mysqlInnoDBMySQL引擎存储引擎
                                    
      1 没有特殊情况，应尽可能使用InnoDB存储引擎。   原因：InnoDB 和 MYIsAM 是mysql 最常用、使用最普遍的存储引擎。其中InnoDB是最重要、最广泛的存储引擎。她   被设计用来处理大量的短期事务。短期事务大部分情况下是正常提交的，很少有回滚的情况。InnoDB的性能和自动崩溃   恢复特性使得她在非事务型存储的需求中也非常流行，除非有非常
    
                                
    • 
                                
  • UDP网络编程
                                    百合不是茶
UDP编程局域网组播
                                    
      
UDP是基于无连接的,不可靠的传输   与TCP/IP相反 
  
  
  
UDP实现私聊,发送方式客户端,接受方式服务器 
package netUDP_sc;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Ine
    
                                
    • 
                                
  • JQuery对象的val()方法执行结果分析
                                    bijian1013
JavaScriptjsjquery
                                    
            JavaScript中，如果id对应的标签不存在（同理JAVA中，如果对象不存在），则调用它的方法会报错或抛异常。在实际开发中，发现JQuery在id对应的标签不存在时，调其val()方法不会报错，结果是undefined。 
        
    
                                
    • 
                                
  • http请求测试实例（采用json-lib解析）
                                    bijian1013
jsonhttp
                                    
            由于fastjson只支持JDK1.5版本，因些对于JDK1.4的项目，可以采用json-lib来解析JSON数据。如下是http请求的另外一种写法，仅供参考。 
package com;

import java.util.HashMap;
import java.util.Map;

import 
    
                                
    • 
                                
  • 【RPC框架Hessian四】Hessian与Spring集成
                                    bit1129
hessian
                                    
    在【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中介绍了基于Hessian的RPC服务的实现步骤，在那里使用Hessian提供的API完成基于Hessian的RPC服务开发和客户端调用，本文使用Spring对Hessian的集成来实现Hessian的RPC调用。 
  定义模型、接口和服务器端代码 
|---Model 
   &nb
    
                                
    • 
                                
  • 【Mahout三】基于Mahout CBayes算法的20newsgroup流程分析
                                    bit1129
Mahout
                                    
    1.Mahout环境搭建 
 1.下载Mahout 
http://mirror.bit.edu.cn/apache/mahout/0.10.0/mahout-distribution-0.10.0.tar.gz 
  
 2.解压Mahout 
 3. 配置环境变量 
vim /etc/profile

export HADOOP_HOME=/home
    
                                
    • 
                                
  • nginx负载tomcat遇非80时的转发问题
                                    ronin47

                                    
    　　nginx负载后端容器是tomcat（其它容器如WAS,JBOSS暂没发现这个问题）非８０端口，遇到跳转异常问题。解决的思路是：$host:port 
       详细如下： 
　　  
该问题是最先发现的，由于之前对nginx不是特别的熟悉所以该问题是个入门级别的：    
?       1   2   3   4   5   
    
                                
    • 
                                
  • java-17-在一个字符串中找到第一个只出现一次的字符
                                    bylijinnan
java
                                    
    

public class FirstShowOnlyOnceElement {

	/**Q17.在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b
	 * 1.int[] count:count[i]表示i对应字符出现的次数
	 * 2.将26个英文字母映射：a-z <--> 0-25
	 * 3.假设全部字母都是小写
	 */
	pu
    
                                
    • 
                                
  • mongoDB 复制集
                                    开窍的石头
mongodb
                                    
    mongo的复制集就像mysql的主从数据库，当你往其中的主复制集(primary)写数据的时候，副复制集(secondary)会自动同步主复制集(Primary)的数据,当主复制集挂掉以后其中的一个副复制集会自动成为主复制集。提供服务器的可用性。和防止当机问题 
       
 
     mo
    
                                
    • 
                                
  • [宇宙与天文]宇宙时代的经济学
                                    comsci
经济
                                    
     
    宇宙尺度的交通工具一般都体型巨大，造价高昂。。。。。 
 
     在宇宙中进行航行，近程采用反作用力类型的发动机，需要消耗少量矿石燃料，中远程航行要采用量子或者聚变反应堆发动机，进行超空间跳跃，要消耗大量高纯度水晶体能源 
 
     以目前地球上国家的经济发展水平来讲，
    
                                
    • 
                                
  • Git忽略文件
                                    Cwind
git
                                    
         有很多文件不必使用git管理。例如Eclipse或其他IDE生成的项目文件，编译生成的各种目标或临时文件等。使用git status时，会在Untracked files里面看到这些文件列表，在一次需要添加的文件比较多时（使用git add . / git add -u），会把这些所有的未跟踪文件添加进索引。  
   ==== ==== ==== 一些牢骚
    
                                
    • 
                                
  • MySQL连接数据库的必须配置
                                    dashuaifu
mysql连接数据库配置
                                    
    MySQL连接数据库的必须配置 
  
1.driverClass：com.mysql.jdbc.Driver 
  
2.jdbcUrl：jdbc:mysql://localhost:3306/dbname 
  
3.user：username 
  
4.password：password 
  
其中1是驱动名；2是url，这里的‘dbna
    
                                
    • 
                                
  • 一生要养成的60个习惯
                                    dcj3sjt126com
习惯
                                    
    一生要养成的60个习惯 
第1篇 让你更受大家欢迎的习惯 
1 守时，不准时赴约,让别人等,会失去很多机会。 
如何做到： 
①该起床时就起床， 
②养成任何事情都提前15分钟的习惯。 
③带本可以随时阅读的书，如果早了就拿出来读读。 
④有条理，生活没条理最容易耽误时间。 
⑤提前计划：将重要和不重要的事情岔开。 
⑥今天就准备好明天要穿的衣服。 
⑦按时睡觉，这会让按时起床更容易。 
2 注重
    
                                
    • 
                                
  • [介绍]Yii 是什么
                                    dcj3sjt126com
PHPyii2
                                    
    Yii 是一个高性能，基于组件的 PHP 框架，用于快速开发现代 Web 应用程序。名字 Yii （读作 易）在中文里有“极致简单与不断演变”两重含义，也可看作 Yes It Is! 的缩写。  
Yii 最适合做什么？ 
Yii 是一个通用的 Web 编程框架，即可以用于开发各种用 PHP 构建的 Web 应用。因为基于组件的框架结构和设计精巧的缓存支持，它特别适合开发大型应
    
                                
    • 
                                
  • Linux SSH常用总结
                                    eksliang
linux sshSSHD
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2186931 一、连接到远程主机 
  
格式：
ssh name@remoteserver
例如：
ssh [email protected] 
  二、连接到远程主机指定的端口 
  
格式：
ssh name@remoteserver -p 22
例如：
ssh i
    
                                
    • 
                                
  • 快速上传头像到服务端工具类FaceUtil
                                    gundumw100
android
                                    
    快速迭代用 
 
 

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOExceptio
    
                                
    • 
                                
  • jQuery入门之怎么使用
                                    ini
JavaScripthtmljqueryWebcss
                                    
    jQuery的强大我何问起（个人主页：hovertree.com）就不用多说了，那么怎么使用jQuery呢？ 
  
首先，下载jquery。下载地址：http://hovertree.com/hvtart/bjae/b8627323101a4994.htm，一个是压缩版本，一个是未压缩版本，如果在开发测试阶段，可以使用未压缩版本，实际应用一般使用压缩版本(min)。然后就在页面上引用。
    
                                
    • 
                                
  • 带filter的hbase查询优化
                                    kane_xie
查询优化hbaseRandomRowFilter
                                    
     
 问题描述 
 
hbase scan数据缓慢，server端出现LeaseException。hbase写入缓慢。     
 
 问题原因 
 
直接原因是：  hbase client端每次和regionserver交互的时候，都会在服务器端生成一个Lease,Lease的有效期由参数hbase.regionserver.lease.period确定。如果hbase scan需
    
                                
    • 
                                
  • java设计模式-单例模式
                                    men4661273
java单例枚举反射IOC
                                    
             单例模式1，饿汉模式 
//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton1 {
    //私有的默认构造函数
    private Singleton1() {}
    //已经自行实例化
    private static final Singleton1 singl
    
                                
    • 
                                
  • mongodb 查询某一天所有信息的3种方法，根据日期查询
                                    qiaolevip
每天进步一点点学习永无止境mongodb纵观千象
                                    
    // mongodb的查询真让人难以琢磨，就查询单天信息，都需要花费一番功夫才行。

// 第一种方式：
coll.aggregate([
          {$project:{sendDate: {$substr: ['$sendTime', 0, 10]}, sendTime: 1, content:1}},
          {$match:{sendDate: '2015-
    
                                
    • 
                                
  • 二维数组转换成JSON
                                    tangqi609567707
java二维数组json
                                    
    原文出处：http://blog.csdn.net/springsen/article/details/7833596 
public class Demo { 
    public static void main(String[] args) {        String[][] blogL
    
                                
    • 
                                
  • erlang supervisor
                                    wudixiaotie
erlang
                                    
    定义supervisor时，如果是监控celuesimple_one_for_one则删除children的时候就用supervisor:terminate_child (SupModuleName, ChildPid)，如果shutdown策略选择的是brutal_kill，那么supervisor会调用exit(ChildPid, kill)，这样的话如果Child的behavior是gen_
    
                                
    •