烽火台使用说明

1、烽火台开发使用说明1. IOC使用说明烽火台使用google guice 1.0作为底层的IOC框架，对guice的功能进行了简单的封装，应用程序在使用IOC功能时，应禁止使用guice提供的接口（.classpath禁止包含guice.jar），避免应用程序对guice产生依赖关系。1.1. 第一个例子1、接口Service1. public interface Service 2. void hello();3. 2、接口Service的实现类1. public class ServiceImpl implements Service2. public void hello() 3. Sy

2、stem.out.println(hello);4. 5. 3、建立依赖关系有了接口和实现类，烽火台采用Implement标记绑定ServiceImpl和Service之间的依赖关系，如下所示：1. import mon.tag.ioc.Implement;2.3. Implement(clazz=Service.class)4. public class ServiceImpl implements Service5. public void hello() 6. System.out.println(hello);7. 8. 4、依赖注入烽火台采用Inject标记创

3、建Service的实例，如下所示：1. import mon.tag.ioc.Inject;2.3. public class Main4. Inject private Service service;5. 6. public static void main(String args) 7. 8. (new Main().service.hello();9. 10. 5、Implement标签的功能是，告诉烽火台框架，ServiceImpl类是Service接口的标准实现类，任何使用Inject标签标注的Service变量（可以是static、public、prote

4、cted、private），都会被自动初始化成ServiceImpl的实例。6、烽火台也可以通过Injector类，获得Service的实例，如下所示：1. import ponent.ioc.Injector;2.3. public class Main4. public static void main(String args) 5. 6. Service service = Injector.getInstance(Service.class);7. service.hello();8. 9. 7、烽火台也可以使用ImplementBy标签，通过接口

5、绑定实现类，如下：1. import mon.tag.ioc.ImplementBy;2.3. ImplementBy(clazz=ServiceImpl.class)4. public interface Service 5. void hello();6. 7.8. public class ServiceImpl implements Service9. public void hello() 10. System.out.println(hello);11. 12. 8、说明以上演示了烽火台提供的IOC功能的主要接口Implement的功能是，绑定具体类和接口之

6、间的关系，烽火台在遇到接口时能够自动创建类，这种方式不会增加代码中依赖关系，因为实现类总是知道接口的位置；ImplementBy的功能是指定接口的实现类，功能和Implement相同，但是需要在接口类中知道有哪些实现类。这种方式可以让代码容易维护（直接打开接口文件，就能知道有哪些实现类，Implement方式需要查找接口的引用类才能知道接口有哪些实现类），但是这种方式需要在接口中依赖所有的实现类。一般不建议使用，因为它并没有松偶合接口和类之间的关系，除非接口类和实现类在同一个包路径下时，可以考虑这种方式；Inject标签的功能是告诉烽火台，在运行时，自动根据属性的类型（比如上列中service

7、的类型是Service），自动创建由Implement或ImplementBy绑定的实现类；相当于直接调用：private Service service = Injector.getInstance(Service.class)；Injector不是标签，是一个工厂类，可以通过Injector.getInstance方法，获得接口的实现类，因为局部变量不能使用Inject修饰，因此只能通过这种方式初始化接口。1.2. 依赖注入烽火台提供了两种方式支持四种注入类型，Inject标签可以支持field注入、构造函数注入、和setter注入；Injector工厂类可以支持局部变量的注入。1、fie

8、ld注入1. import mon.tag.ioc.Inject;2.3. public class Main4. Inject private Service service;5. 6. public static void main(String args) 7. 8. (new Main().service.hello();9. 10. Inject标签可以修饰static变量、private、protected、public变量；但是不能修饰final变量。Inject的实现流程是，在调用Main类的构造函数，或针对static变量在调用static函数时，自动

9、增加service = Injectot.getInstance(Service.class)。因为以上这行代码总是在您编写的所有代码前被调用，因此您在代码中尽量不要直接修改变量的值，也不要在构造函数中初始化service变量。上面的例子相当于1. import mon.tag.ioc.Inject;2.3. public class Main4. private Service service;5. 6. public void Main()7. 8. super();9. service = Injectot.getInstance(Service.class);

10、10. (构造函数的其它代码)11. 12. 13. public static void main(String args) 14. 15. service.hello();16. 17. 2、构造函数注入1. import mon.tag.ioc.Inject;2. import ponent.ioc.Injector;3.4. public class Main5. private Service service;6. 7. public Main( Inject Service service )8. 9. this.ser

11、vice = service;10. 11. 12. public static void main(String args) 13. 14. Main m = Injector.getInstance(Main.class);15. m.service.hello();16. 17. Inject标签可以修饰构造函数的输入参数，当构造函数的所有输入参数都使用Inject修饰的时候，就可以通过Injector.getInstance获得这个类的实例。上列相当于在运行时，烽火台为Main类增加了一个构造函数1. public Main()1. 2. this( Injector.getInsta

12、nce(Service.class) );3. 因此，如果您不愿意使用Injector方式获得Main的实例，上列可以修改成以下方式1. import mon.tag.ioc.Inject;2.3. public class Main4. private Service service;5. 6. / 会被替换7. public Main()8. 9. 10. 11. 12. public Main( Inject Service service )13. 14. this.service = service;15. 16. 17. public static void

13、 main(String args) 18. 19. Main m = new Main();20. m.service.hello();21. 22. 第一个构造函数会被烽火台自动生成的构造函数替换。进一步说明：并不需要修饰构造函数的所有输入参数，这样在创建类的时候可以手工传入部分参数，比如：23. public Main( int id, Inject Service service, String desc )24. 25. this.service = service;26. 这种使用方式需要工厂类的介入，在后面介绍。3、setter注入1. import mo

14、n.tag.ioc.Inject;2.3. public class Main4. private Service service;5. 6. Inject7. public void setService( Service service )8. 9. this.service = service;10. 11. 12. public static void main(String args) 13. 14. Main m = new Main();15. m.service.hello();16. 17. 这种方式和field注入方式的工作原理类似，但是setter方法在构造函数执行完以后

15、运行，因此在构造函数中不能访问service变量，烽火台修改了Main类的构造函数：1. public Main( )2. 3. 4. 5. setService( Injector.getInstance(Service.class) );6. 目前Inject标签的修饰Method的规则是：没有返回参数，只有一个输入参数，并且是对象（不能是int、long等类型）。4、Injector创建类1. import ponent.ioc.Injector;2.3. public class Main4. public static void main(Str

16、ing args) 5. 6. Service service = Injector.getInstance(Service.class);7. service.hello();8. 9. 局部变量不能用Inject修饰。1.3. 单实例对象缺省情况下，每次调用都会创建一个新的实例，烽火台支持单实例方式：1. import mon.tag.ioc.ImplementBy;2.3. public interface Service 4. void hello();5. 6.7. Implement(clazz=Service.class, scope=Implement.

17、SCOPE.SINGLETON)8. public class ServiceImpl implements Service9. public void hello() 10. System.out.println(hello);11. 12. 或者1. import mon.tag.ioc.ImplementBy;2.3. ImplementBy(clazz=ServiceImpl.class, scope=ImplementBy.SCOPE.SINGLETON)4. public interface Service 5. void hello();6. 7.8. p

18、ublic class ServiceImpl implements Service9. public void hello() 10. System.out.println(hello);11. 12. Implement和ImplementBy标签都支持scope=SCOPE.SINGLETON属性，只在第一次调用Injector.getInstance时，创建新的实例。1.4. DAO对象注入Dao对象通过InjectDAO标签注入，而不是Inject标签，（仅仅是因为，如果都使用Inject标签时，在构造类的时候，需要判断Inject的类是DAO对象，还是普通对象）。InjectDAO

19、标签支持field注入，和Method注入。1、field注入1. import mon.tag.dao.InjectDAO;2.3. public class Main4. InjectDAO private ProjMember daoProjMember;5. 6. public void txn( TxnContext context ) throws TxnException7. 8. daoProjMember.selectProj_memberList( context, inputNode, outputNode );9. 10. InjectDAO的实

20、现原理和Inject相同，都是通过修改构造函数实现。2、Mathod注入11. import mon.tag.dao.InjectDAO;12.13. public class Main14. private ProjMember daoProjMember;15. 16. InjectDAO(“daoProjMember”）17. public void txn( TxnContext context ) throws TxnException18. 19. daoProjMember.selectProj_memberList( context, inputNode

21、, outputNode );20. 21. InjectDAO还可以修饰Method，在调用方法时，自动构造DAO对象，InjectDAO编写指定需要加载的DAO对象的变量名称注入多个DAO对象1. import mon.tag.dao.InjectDAO;2.3. public class Main4. private ProjMember daoProjMember;5. private Dperson daoDperson;6. 7. InjectDAO(“daoProjMember”, “daoDperson”）8. public void txn( TxnC

22、ontext context ) throws TxnException9. 10. daoProjMember.selectProj_memberList( context, inputNode, outputNode );11. 12. 3、说明ProjMember和Dperson都是DAO对象通过这种方式生成的DAO对象，效率比TableFactory获取对象的效率要高很多，而且程序比较简洁。1.5. 一个接口多个实现类当一个接口有多个实现类时，需要用到Implement/ImplementBy的name属性1. public interface Service 2. void hell

23、o();3. 4.5. public class ServiceImplA implements Service6. public void hello() 7. System.out.println(helloA);8. 9. 10.11. public class ServiceImplB implements Service12. public void hello() 13. System.out.println(helloB);14. 15. 1、依赖绑定1. import mon.tag.ioc.Implement;2.3. public interface

24、 Service 4. void hello();5. 6.7. Implement(clazz=Service.class, name=”A”)8. public class ServiceImplA implements Service9. public void hello() 10. System.out.println(helloA);11. 12. 13.14. Implement(clazz=Service.class, name=”B”)15. public class ServiceImplB implements Service16. public void hello()

25、 17. System.out.println(helloB);18. 19. Implement的name属性，是一个区分实现类的唯一键，可以通过接口名称和name唯一确定一个实现类。2、依赖注入和一个接口一个类一样，烽火台也支持四种方式，下面是一个简洁的演示，把四种方式写在一起。1. import mon.tag.ioc.Inject;2. import ponent.ioc.Injector;3.4. public class Main5. Inject(“A”) private Service service;6. 7. p

26、ublic Main( Inject(“B”) Service service )8. 9. this.service = service;10. 11.12. Inject(“A”)13. public void setService( Service service )14. 15. this.service = service;16. 17.18. public static void main(String args) 19. 20. Service service = Injector.getInstance(Service.class, “A”);21. 22. Inject的va

27、lue属性，可以指定需要加载哪个实现类。3、通过接口绑定类ImplementBy也可以实现一个接口多个实现类的绑定1. import mon.tag.ioc.ImplementBy;2. import mon.tag.ioc.ImplementsBy;3.4. ImplementsBy(5. ImplementBy(name =A, clazz=ServiceImplA.class),6. ImplementBy(name =B, clazz=ServiceImplB.class)7. )8. public interface Service 9

28、. void hello();10. 11.12. public class ServiceImplA implements Service13. public void hello() 14. System.out.println(helloA);15. 16. 17.18. public class ServiceImplB implements Service19. public void hello() 20. System.out.println(helloB);21. 22. 可以通过ImplementsBy标签，包含一组ImplementBy标签，实现一个接口的多个实现类。1.6

29、. 一个类多个实现接口这种方式仅仅是为了满足，一个类实现了多个接口，并且同时要绑定多个接口的情形，可以通过Implements标签实现，这种情况应该比较罕见。23. import mon.tag.ioc.Implement;24. import mon.tag.ioc.Implements;25.26. public interface ServiceA 27. void helloA();28. 29.30. public interface ServiceB 31. void helloB();32. 33.34. Implements(35

30、. Implement(clazz=ServiceA.class),36. Implement(clazz=ServiceB.class)37. )38. public class ServiceImpl implements ServiceA, ServiceB39. public void helloA() 40. System.out.println(helloA);41. 42.43. public void helloB() 44. System.out.println(helloB);45. 46. 1.7. Provider烽火台提供Provider接口，允许用户在需要类的时候再

31、创建类，也可以在创建类以前做一些操作。关于使用Provider接口的方式和上面介绍的普通类完全相同。1、依赖绑定1. import mon.tag.ioc.Implement;2.3. public interface Service 4. void hello();5. 6.7. public class ServiceImpl implements Service8. public void hello() 9. System.out.println(hello);10. 11. 12.13. Implement(clazz=Service.class)14. pu

32、blic class ServiceProvider implements Provider15. public Service get()16. 17. return new ServiceImpl();18. 19. 20.21.Provider也支持单例，一个接口多个实现类等。2、直接依赖注入23. import mon.tag.ioc.Inject;24. import ponent.ioc.Injector;25.26. public class Main27. Inject private Service service

33、;28. 29. public Main( Inject Service service )30. 31. this.service = service;32. 33.34. Inject35. public void setService( Service service )36. 37. this.service = service;38. 39.40. public static void main(String args) 41. 42. Service service = Injector.getInstance(Service.class);43. 44. 虽然Service接口和

34、ServiceProvider类绑定，但是也可以象以前介绍的那样，直接注入Service对象，而不是ServiceProvider对象。3、注入Provider对象45. import mon.tag.ioc.Inject;46. import ponent.ioc.Injector;47. import ponent.ioc.Provider;48.49. public class Main50. Inject private Provider provider;51. 52. public

35、Main( Inject Provider provider )53. 54. vider = provider;55. 56.57. Inject58. public void setService(Provider provider )59. 60. vider = provider;61. 62.63. public static void main(String args) 64. 65. Provider provider = Injector.getProvider(Service.class);66. Service service = provi

36、der.get();67. service.hello();68. 69. 注入Provider接口后，可以通过Provider.get()方法获得Service对象。10. import ponent.ioc.Injector;11. import ponent.ioc.Provider;12.13. public class Main14. public static void main(String args) 15. 70. Provider provider = Injector.getProvider(Se

37、rvice.class);71. Service service = provider.get();16. service.hello();17. 18. Provider也支持单例，一个接口多个实现类等。Provider的实现原理和类的依赖绑定、依赖注入完全相同由Inject注入的类，或Injector.getProvider()得到的类，不是ServiceProvider类的实例，也不是派生类，而是一个内部类。因此不能做以下的转换ServiceProvider p = (ServiceProvider)provider;1.8. AOPGuice提供的AOP功能，只能支持由AOP加载的类，

38、烽火台暂时没有封装。1.9. 工厂接口以上介绍的依赖绑定和注入，构造函数都不能手工传入参数。1、场景以下的类，PersonImpl类的构造函数需要手工传入一个参数，这种情况，上面介绍的功能就不能满足。1. import mon.tag.ioc.Implement;2.3. public interface Person 4. void hello();5. 6.7. Implement(clazz=Person.class)8. public class PersonImpl implements Person9. private String name;10. 11.

39、 public PersonImpl( String name )12. 13. = name;14. 15. 16. public void hello() 17. System.out.println(hello: + name);18. 19. 20.2、创建工厂接口烽火台通过工厂类的方式能够允许用户传入参数。用户需要增加一个接口，如下：1. import mon.tag.ioc.InjectFactory;2.3. InjectFactory4. public interface PersonFactory5. public Person c

40、reateSomeone(String name);6. 7.接口必须由InjectFactory标签说明，对接口中的方法没有任何限制，可以包含多个方法，但是每个方法的输入参数，必须和需要创建的类的一个构造函数的参数相同。比如上列中，createSomeone返回的是一个Person对象，而Person对象已经和PersonImpl对象绑定，因此，createSomeone方法的输入参数，必须和PersonImpl类的一个构造函数的输入参数相同。3、运行原理烽火台会根据InjectFactory自动创建一个类：1. Implement(PersonFactory)2. public class

41、 AnyName implements PersonFactory3. public Person createSomeone(String name)4. 5. return new PersonImpl(name);6. 7. 8.然后把这个类和PersonFactory接口绑定。4、使用工厂类1. import mon.tag.ioc.Inject;2. import ponent.ioc.Injector;3. import ponent.ioc.Provider;4.5. public

42、 class Main6. Inject private PersonFactory factory;7. 8. public Main( Inject PersonFactory factory )9. 10. this.factory = factory;11. 12.13. Inject14. public void setService(PersonFactory factory )15. 16. this.factory = factory;17. 18.19. public static void main(String args) 20. 21. PersonFactory fa

43、ctory = Injector.getInstance(PersonFactory.class);22. Person person = factory.createSomeone(“谁呀”);23. person.hello();24. 25. PersonFactory对象，也可以通过上面介绍过的方法获得。得到Factory对象后，就可以调用工厂类通过的方法生成对象。通过工厂接口可以实现很多功能，下一节将继续讨论工厂类。1.10. 工厂接口（一个接口多个实现类）1、 接口类1. import mon.tag.ioc.Implement;2.3. public in

44、terface Person 4. void hello();5. 6.7. Implement(name=”A” clazz=Person.class)8. public class PersonImplA implements Person9. private String name;10. 11. public PersonImpl( String name )12. 13. = name;14. 15. 16. public void hello() 17. System.out.println(hello A: + name);18. 19. 20.21. Imp

45、lement(name=”B” clazz=Person.class)22. public class PersonImplB implements Person23. private String name;24. 25. public PersonImpl( String name )26. 27. = name;28. 29. 30. public void hello() 31. System.out.println(hello B: + name);32. 33. 34.2、创建工厂接口用户需要增加一个接口，如下：8. import mon

46、.tag.ioc.InjectFactory;9.10. InjectFactory11. public interface PersonFactory12. Binder(“A”) public Person createSomeoneA(String name); 13. Binder(“B”) public Person createSomeoneB(String name);14. 15.通过Binder标签，区分createSomeoneA和createSomeoneB返回不同的对象3、使用工厂类1. import mon.tag.ioc.Inject;2.3

47、. public class Main4. Inject private PersonFactory factory;5. 6. public Main( Inject PersonFactory factory )7. 8. this.factory = factory;9. 10.11. Inject12. public void setService(PersonFactory factory )13. 14. this.factory = factory;15. 16.17. public static void main(String args) 18. 19. PersonFact

48、ory factory = Injector.getInstance(PersonFactory.class);20. Person personA = factory.createSomeoneA(“谁呀”);21. personA.hello();22. Person personB = factory.createSomeoneB(“谁呀”);23. personB.hello();24.25. 26. 4、动态工厂类有时候，一个接口有很多个实现类，通过前一种方式，需要在接口中创建很多个方法，而且有可能实现类是动态的。因此烽火台通过了一个动态绑定的接口。1. import mon.tag.ioc.InjectFactory;2.3. InjectFactory4. public interface PersonFactory5. Binder public Person createSomeone(String implName, String name); 6. 7.使用Binder绑定的方法，第一个参数必须是String，用于说明当前需要返回哪种对象，后面的参数，必须和返回类的一个构造函数相同5、使用动态工厂类1. import mon