Guice与Spring框架的区别(1)

public interface MyService ...{
void myMethod();
}
public class MyServiceImpl implements MyService ...{
public void myMethod() ...{
System.out.println("Hello，World!");
}
}

import com.google.inject.Inject;
public class Client ...{
MyService service;
@Inject //告诉容器，这里的service对象的引用，需要进行注入
void setService(MyService service) ...{ //这里的方法名字可以任意定义
this.service = service;
}
public void myMethod() ...{
service.myMethod();
}
}

import com.google.inject.Binder;
import com.google.inject.Module;
import com.google.inject.Scopes;
public class MyModule implements Module ...{
public void configure(Binder binder) ...{    
binder.bind(MyService.class).to(MyServiceImpl.class).in(Scopes.SINGLETON);
// 这句代码的意思是说：运行时动态的将MyServiceImpl对象赋给MyService定义的对象，
而且这个对象是单例的。
}
}

import com.google.inject.Guice;
import com.google.inject.Injector;
public class Test ...{
public static void main(String[] args) ...{
MyModule module = new MyModule();// 定义注射规则
Injector injector = Guice.createInjector(module);// 根据注射规则，生成注射者
Client client = new Client();
injector.injectMembers(client);// 注射者将需要注射的bean，按照规则，把client这个客户端进行注射
client.myMethod();    
}
}

import com.google.inject.ImplementedBy;
@ImplementedBy(MyServiceImpl.class)
//我总觉得这样有点背离了依赖注入的初衷了
public interface MyService ...{
void myMethod();
}

package mypackage;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.google.inject.BindingAnnotation;
@Retention(RetentionPolicy.RUNTIME)
@Target( ...{ ElementType.FIELD, ElementType.PARAMETER })
@BindingAnnotation
public @interface MyInterface ...{    
}

package mypackage;
import com.google.inject.Inject;
public class Client ...{
@Inject @MyInterface MyService service;

void setService(MyService service) ...{ // 这里的方法名字可以任意定义
this.service = service;
}
public void myMethod() ...{
service.myMethod();
}
}

binder.bind(MyService.class).annotatedWith(MyInterface.class).to(
MyServiceImpl.class).in(Scopes.SINGLETON);