一直想通过研究别人好的代码来提高自己的水平,可是一直没有坚持下去,Hibernate看了几天实在看不明白放弃了,roller、jive也是半途而废,基本什么也没有学到,甚至可以说根本就没看明白,这次又做出学习xwork的决定,同时决定把学习的过程和学习成果写出来,也算是对自己的一个督促吧,
关于xwork我就不介绍了,网上多的是(关键是我自己的功课也没做好 ),
废话不说了!!!!把这两天看的东西写下来,先重一个例子说起,
1.随便写两个接口(我真的是随便写的,呵呵):
2.它们的实现类
3.最后一步:!!!
先来看一下在
这个对象是发生了什么
factories是一个Map类型的变量
这两行代码的目的就是把一个ContainerImpl的实现放到这个Map中(实际上并没有new一个对象,只有在用到的时候这个对象才个真正的实例化,在这里只是放入一些必要信息)。
关键来看一下factory(...)方法:
在factory(..)执行的过程中,它会执行
这段代码,它就是把一些创建对象的必要信息放到factories中,
Key也是用来保存信息的,通过Key.newInstance(type, name)来创建一个Key对象,这里的type就是上面传入的IPerson.class,在这里有一个重要的地方就是factory的创建,它是通过下面的代码完成的
这里的关键就是create(..)这个方法的实现,将来在实例化对象的时候会用到!
关于xwork我就不介绍了,网上多的是(关键是我自己的功课也没做好 ),
废话不说了!!!!把这两天看的东西写下来,先重一个例子说起,
1.随便写两个接口(我真的是随便写的,呵呵):
java 代码
- interface IPerson {
- public void say();
- }
- interface IUserPerson {
- public void say();
- }
java 代码
- public class Person implements IPerson{
- public Person(){}
- public void say(){
- System.out.println("person");
- }
- }
- /
- public class UserPerson implements IUserPerson{
- private IPerson person;
- public IPerson getPerson() {
- return person;
- }
- //这个注释就是说明需要依赖注入的
- @Inject
- public void setPerson(IPerson person) {
- this.person = person;
- }
- public void say(){
- System.out.println("userperson");
- person.say();
- }
- }
java 代码
- import com.opensymphony.xwork2.inject.Container;
- import com.opensymphony.xwork2.inject.ContainerBuilder;
- public class ContainerTest {
- private Container container;
- public static void main(String[] args) {
- ContainerTest test=new ContainerTest();
- // test.setContainer(new ContainerBuilder().factory(ActionProxyFactory.class, DefaultActionProxyFactory.class).create(true));
- test.setContainer(new ContainerBuilder().factory(IPerson.class,Person.class).factory(IUserPerson.class,UserPerson.class).create(true));
- Container container=test.getContainer();
- IUserPerson person=container.getInstance(IUserPerson.class);
- person.say();
- }
- public Container getContainer() {
- return container;
- }
- public void setContainer(Container container) {
- this.container = container;
- }
先来看一下在
java 代码
- new ContainerBuilder()
java 代码
- public ContainerBuilder() {
- // In the current container as the default Container implementation.
- factories.put(Key.newInstance(Container.class, Container.DEFAULT_NAME),
- CONTAINER_FACTORY);
- // Inject the logger for the injected member's declaring class.
- factories.put(Key.newInstance(Logger.class, Container.DEFAULT_NAME),
- LOGGER_FACTORY);
- }
这两行代码的目的就是把一个ContainerImpl的实现放到这个Map中(实际上并没有new一个对象,只有在用到的时候这个对象才个真正的实例化,在这里只是放入一些必要信息)。
关键来看一下factory(...)方法:
在factory(..)执行的过程中,它会执行
java 代码
- final InternalFactoryextends T> scopedFactory =
- scope.scopeFactory(key.getType(), key.getName(), factory);
- factories.put(key, scopedFactory);
Key也是用来保存信息的,通过Key.newInstance(type, name)来创建一个Key对象,这里的type就是上面传入的IPerson.class,在这里有一个重要的地方就是factory的创建,它是通过下面的代码完成的
java 代码
- InternalFactoryextends T> factory = new InternalFactory<t>() { </t>
- volatile ContainerImpl.ConstructorInjectorextends T> constructor;
- @SuppressWarnings("unchecked")
- //这个方法在调用ContainerImpl中的getInstance时会被调用
- public T create(InternalContext context) {
- if (constructor == null) {
- this.constructor =
- context.getContainerImpl().getConstructor(implementation);
- }
- return (T) constructor.construct(context, type);
- }
- public String toString() {
- return new LinkedHashMap
- put("type", type);
- put("name", name);
- put("implementation", implementation);
- put("scope", scope);
- }}.toString();
- }
- };