jfinal 3.5

src/main/java/com/jfinal/aop/Aop.java

@@ -69,7 +69,9 @@ package com.jfinal.aop;
  * 
  * 4：可以在目标类中中直接配置注解 Singleton 与注解 Enhance：
  *    @Singleton(false)
- *    @Enhance(false) 
+ *    @Enhance(false)
+ *    public class MyService {...}
+ *    
  *    注意：如上在配置会覆盖掉 2、3 中 setSingleton()/setEnhance() 方法配置的默认值
  * 
  * 5：如上 2、3、4 中的配置，建议的用法是：先用 /setSingleton()/setEnhance() 配置大多数情况，然后在个别

src/main/java/com/jfinal/aop/InjectControllerFactory.java

@@ -1,80 +0,0 @@
-package com.jfinal.aop;
-
-import com.jfinal.core.Controller;
-import com.jfinal.core.ControllerFactory;
-
-/**
- * InjectControllerFactory 用于注入依赖对象并更好支持 AOP，其优点如下：
- * 1：使用 @Inject 自动化注入并 enhance 对象，免去业务层 AOP 必须手动 enhance 的步骤
- * 
- * 2：免去业务层维护单例的样板式代码，例如下面代码可以删掉了：
- *    public static final MyService me = new MyService();
- * 
- * 
- * 基本用法如下：
- * 1：配置
- *    me.setToInjectControllerFactory();
- *    
- * 2：Controller 中注入业务层，也可以注入任何其它类，不一定非得是 Service
- *    public class MyController extends Controller {
- *    
- *       @Inject
- *       MyService service;
- *       
- *       public void index() {
- *          render(service.doIt());
- *       }
- *    }
- *    
- * 3：Service 注入另一个 Service，也可以注入任何其它类，不一定非得是 Service
- *    public class MyService {
- *    
- *       @Inject
- *       OtherService other;		// OtherService 内部还可以继续接着注入
- *       
- *       public void doIt() {
- *          other.doOther();
- *       }
- *    }
- * 
- * 4：InjectControllerFactory 默认处理了从 Controller 为源头的依赖与注入链条，如果希望在拦截器
- *    使用注入功能，可以使用如下的方式：
- *    public class MyInterceptor implements Interceptor {
- *      
- *       MyService srv = Aop.get(MyService.class);
- *       
- *       public void intercept(Invocation inv) {
- *          srv.doIt();
- *       }
- *    }
- * 
- * 
- * 高级用法：
- * 1：@Inject 注解默认注入属性自身类型的对象，可以通过如下代码指定被注入的类型：
- *    @Inject(UserServiceImpl.class)			// 此处的 UserServiceImpl 为 UserService 的子类或实现类
- *    UserService userService;
- * 
- * 2：被注入对象默认会被 enhance 增强，可以通过 Aop.setEnhance(false) 配置默认不增强
- * 
- * 3：被注入对象默认是 singleton 单例，可以通过 Aop.setSingleton(false) 配置默认不为单例
- * 
- * 4：可以在 @Inject 注解中直接配置 enhance 增强与 singleton 单例：
- *    @Inject(enhance=YesOrNo.NO, singleton=YesOrNo.YES)
- *    注意：如上在 @Inject 直接配置会覆盖掉 2、3 中 setEnhance()/setSingleton() 方法配置的默认值
- * 
- * 5：如上 2、3、4 中的配置，建议的用法是：先用 setEnhance()/setSingleton() 配置大多数情况，然后在个别
- *    违反上述配置的情况下在 @Inject 中直接 enhance、singleton 来覆盖默认配置，这样可以节省大量代码
- */
-public class InjectControllerFactory extends ControllerFactory {
-	
-	@Override
-	public Controller getController(Class<? extends Controller> controllerClass) throws ReflectiveOperationException {
-		Controller c = controllerClass.newInstance();
-		// Aop.getAopFactory().inject((Class)controllerClass, c);
-		return Aop.inject(c);
-	}
-}
-
-
-
-

src/main/java/com/jfinal/aop/InterceptorManager.java

@@ -20,6 +20,7 @@ import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.concurrent.ConcurrentHashMap;
+import com.jfinal.core.Const;
 import com.jfinal.core.Controller;
 
 /**
@@ -36,13 +37,13 @@ import com.jfinal.core.Controller;
  */
 public class InterceptorManager {
 	
-	private boolean injectDependency = true;
+	private boolean injectDependency = Const.DEFAULT_INJECT_DEPENDENCY;
 	
 	public void setInjectDependency(boolean injectDependency) {
 		this.injectDependency = injectDependency;
 	}
 	
-	public boolean getInjectDependency() {
+	public boolean isInjectDependency() {
 		return injectDependency;
 	}
 	

src/main/java/com/jfinal/config/Constants.java

@@ -18,6 +18,7 @@ package com.jfinal.config;
 
 import java.util.HashMap;
 import java.util.Map;
+import com.jfinal.aop.InterceptorManager;
 import com.jfinal.captcha.CaptchaManager;
 import com.jfinal.captcha.ICaptchaCache;
 import com.jfinal.core.ActionReporter;
@@ -54,6 +55,8 @@ final public class Constants {
 	private ControllerFactory controllerFactory = Const.DEFAULT_CONTROLLER_FACTORY;
 	private int configPluginOrder = Const.DEFAULT_CONFIG_PLUGIN_ORDER;
 	
+	private boolean injectDependency = Const.DEFAULT_INJECT_DEPENDENCY;
+	
 	private ITokenCache tokenCache = null;
 	
 	/**
@@ -156,9 +159,12 @@ final public class Constants {
 		this.controllerFactory = controllerFactory;
 	}
 	
+	public ControllerFactory getControllerFactory() {
+		return controllerFactory;
+	}
+	
 	/**
-	 * 设置为 InjectControllerFactory 用于创建 Controller 对象并针对其中使用
-	 * Inject 注解的属性进行依赖注入。
+	 * 设置对 Controller、Interceptor 进行依赖注入，默认值为 false
 	 * 
 	 * 被注入对象默认为 singleton，可以通过 Aop.setSingleton(boolean) 配置
 	 * 该默认值。
@@ -166,12 +172,13 @@ final public class Constants {
 	 * 也可通过在被注入的目标类上使用 Singleton 注解覆盖上述默认值，注解配置
 	 * 优先级高于默认配置
 	 */
-	public void setToInjectControllerFactory() {
-		this.controllerFactory = new com.jfinal.aop.InjectControllerFactory();
+	public void setInjectDependency(boolean injectDependency) {
+		this.injectDependency = injectDependency;
+		InterceptorManager.me().setInjectDependency(injectDependency);
 	}
 	
-	public ControllerFactory getControllerFactory() {
-		return controllerFactory;
+	public boolean getInjectDependency() {
+		return injectDependency;
 	}
 	
 	/**

src/main/java/com/jfinal/config/Interceptors.java

@@ -56,15 +56,5 @@ final public class Interceptors {
 		InterceptorManager.me().addGlobalServiceInterceptor(globalServiceInterceptor);
 		return this;
 	}
-	
-	/**
-	 * 配置是否对拦截器进行依赖注入，默认值为 true
-	 * 
-	 * 拦截器的依赖注入是指在拦截器中通过 @Inject 注解注入依赖对象，例如注入业务层对象
-	 */
-	public Interceptors setInjectDependency(boolean injectDependency) {
-		InterceptorManager.me().setInjectDependency(injectDependency);
-		return this;
-	}
 }
 

src/main/java/com/jfinal/config/Routes.java

@@ -77,6 +77,9 @@ public abstract class Routes {
 	 * Add inject interceptor for controller in this Routes
 	 */
 	public Routes addInterceptor(Interceptor interceptor) {
+		if (InterceptorManager.me().isInjectDependency()) {
+			com.jfinal.aop.Aop.inject(interceptor);
+		}
 		injectInters.add(interceptor);
 		return this;
 	}

src/main/java/com/jfinal/core/ActionHandler.java

@@ -32,6 +32,7 @@ import com.jfinal.render.RenderManager;
 public class ActionHandler extends Handler {
 	
 	protected boolean devMode;
+	protected boolean injectDependency;
 	protected ActionMapping actionMapping;
 	protected ControllerFactory controllerFactory;
 	protected static final RenderManager renderManager = RenderManager.me();
@@ -40,6 +41,7 @@ public class ActionHandler extends Handler {
 	protected void init(ActionMapping actionMapping, Constants constants) {
 		this.actionMapping = actionMapping;
 		this.devMode = constants.getDevMode();
+		this.injectDependency = constants.getInjectDependency();
 		this.controllerFactory = constants.getControllerFactory();
 	}
 	
@@ -71,6 +73,7 @@ public class ActionHandler extends Handler {
 		try {
 			// Controller controller = action.getControllerClass().newInstance();
 			controller = controllerFactory.getController(action.getControllerClass());
+			if (injectDependency) {com.jfinal.aop.Aop.inject(controller);}
 			controller._init_(action, request, response, urlPara[0]);
 			
 			if (devMode) {

src/main/java/com/jfinal/core/Const.java

@@ -54,5 +54,7 @@ public interface Const {
 	int DEFAULT_CONFIG_PLUGIN_ORDER = 2;
 	
 	ControllerFactory DEFAULT_CONTROLLER_FACTORY = new ControllerFactory();
+	
+	boolean DEFAULT_INJECT_DEPENDENCY = false;
 }
 

src/main/java/com/jfinal/core/ControllerFactory.java

@@ -20,7 +20,6 @@ package com.jfinal.core;
  * ControllerFactory
  */
 public class ControllerFactory {
-	
 	public Controller getController(Class<? extends Controller> controllerClass) throws ReflectiveOperationException {
 		return controllerClass.newInstance();
 	}