剑指架构师系列-Struts2构造函数的循环依赖注入

public interface IBlood {
}

public class BloodImpl implements IBlood{
	
	private IPeople people;

	
	@Inject
	public BloodImpl(@Inject IPeople people) {
		System.out.println("Blood 构造函数被调用.");
		this.people = people;
	}
}

public interface IPeople {
}

public class PeopleImpl implements IPeople{
	
	private IBlood blood;
	
	@Inject
	public PeopleImpl(@Inject IBlood blood){
		System.out.println("People 构造函数被调用 ");
		this.blood = blood;
	}
}

public interface InternalFactory<T> extends Serializable {
	T create();
}

public enum Scope {

	DEFAULT {
		@Override
		public <T> InternalFactory<? extends T> scopeFactory(String name,final InternalFactory<? extends T> factory) {
			return new InternalFactory<T>() { // 这是一个局部内部内对象
				public T create() {
					return factory.create(); //同一个方法scopeFactory中的局部变量factory
				}
			};
		}
	};

	public abstract <T> InternalFactory<? extends T> scopeFactory(String name,InternalFactory<? extends T> factory);

}

public class Manager {
	 final static Map<String, InternalFactory<?>> factories = new HashMap<String, InternalFactory<?>>();
	
	 public <T> void factory(String name,Scope scopet) {
		 
		    InternalFactory<? extends T> factory = new InternalFactory<T>() {
					public T create() {
						return (T) new PeopleImpl();
					}
		    };
		    final InternalFactory<? extends T> scopedFactory = scopet.scopeFactory(name, factory);
			factories.put(name, scopedFactory);
    } 
	 
	 
	 public static void main(String[] args) {
		 new Manager().factory("mazhi", Scope.DEFAULT);
		 InternalFactory<IPeople> x = (InternalFactory<IPeople>) factories.get("mazhi");
		 x.create();
	}
}

class ConstructionContext<T> {

	List<DelegatingInvocationHandler<T>> invocationHandlers;


	Object createProxy(Class<? super T> expectedType) {
		// if I create a proxy which implements all the interfaces of
		// the implementation type, I‘ll be able to get away with one proxy
		// instance (as opposed to one per caller ).
        // JDK只支持接口的代理，不支持类的代理
		if (!expectedType.isInterface()) {
			System.out.println("不是接口");
		}

		if (invocationHandlers == null) {
			invocationHandlers = new ArrayList<DelegatingInvocationHandler<T>>();
		}
		// Java的代理类
		DelegatingInvocationHandler<T> invocationHandler = new DelegatingInvocationHandler<T>();
		invocationHandlers.add(invocationHandler);

		return Proxy.newProxyInstance(
					expectedType.getClassLoader(),
					new Class[] { expectedType },  // 一组interfaces
					invocationHandler
				);
	}

	void setProxyDelegates(T delegate) {
		if (invocationHandlers != null) {
			for (DelegatingInvocationHandler<T> invocationHandler : invocationHandlers) {
				invocationHandler.setDelegate(delegate);
			}
		}
	}

	static class DelegatingInvocationHandler<T> implements InvocationHandler {
		T delegate;
		public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
			if (delegate == null) {
				throw new IllegalStateException(
						"Not finished constructing. Please don‘t call methods on this"
								+ " object until the caller‘s construction is complete.");
			}

			try {
				return method.invoke(delegate, args);// delegate表示希望被代理的对象
			} catch (IllegalAccessException e) {
				throw new RuntimeException(e);
			} catch (IllegalArgumentException e) {
				throw new RuntimeException(e);
			} catch (InvocationTargetException e) {
				throw e.getTargetException();
			}
		}

		void setDelegate(T delegate) {
			this.delegate = delegate;
		}
	}
}

interface A{
	public void tt();
}
class B implements A{

	public void tt() {
       System.out.println("调用了我");		
	}
}

class C {
	private A b;
	
	@Inject
	public C(A b){
		this.b = b;
	}
	
	public void print(){
		b.tt();
	}
}

@Target({ METHOD, CONSTRUCTOR, FIELD, PARAMETER })
@Retention(RUNTIME)
public @interface Inject {
	String value() default "default";
	boolean required() default true;
}

public class TestJDKProxy {

	public static void main(String[] args) throws Exception {
		new TestJDKProxy().test();
	}
	
	 public  void test() throws Exception{
		 ConstructionContext constructionContext = new ConstructionContext();
		 Object obj = constructionContext.createProxy(struts2.learn.jdk.A.class);
         Constructor cn = findConstructorIn(struts2.learn.jdk.C.class);
         Object tempC = cn.newInstance(new Object[]{obj});  // 先获取接口代理对象并注入C中
         System.out.println(cn);
         constructionContext.setProxyDelegates(new B());    // 随后还需要将真正的被代理对象设置进去
         ((C)tempC).print(); 
     }
     
	private Constructor findConstructorIn(Class implementation) {
		Constructor found = null;
		Constructor[] declaredConstructors = (Constructor[]) implementation.getDeclaredConstructors();
		for (Constructor constructor : declaredConstructors) {
			if (constructor.getAnnotation(Inject.class) != null) {
				if (found != null) {
					// 不能有多于一个构造函数上标有@Inject注解
					throw new DependencyException("More than one constructor annotated with @Inject found in "	+ implementation + ".");
				}
				found = constructor;
			}
		}
		if (found != null) {
			return found;
		}
		// If no annotated constructor is found, look for a no-arg constructor instead.
		try {
			return implementation.getDeclaredConstructor();
		} catch (NoSuchMethodException e) {
			throw new DependencyException("Could not find a suitable constructor" + " in " + implementation.getName() + ".");
		}
	}
	
}