写 Intercept 类 继承 InvocationHandler
public class Intercept implements InvocationHandler{
/**
* 要处理的对象(也就是我们要在方法的前后加上业务逻辑的对象,如例子中的Hello)
*/
private Object target; // 被代理的目标对象
/**
* 动态生成方法被处理过后的对象 (写法固定)
* target(需要关注的类方法)
*/
public Object bind(Object target) throws InstantiationException, IllegalAccessException
{
this.target = target;
return Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result;
AOPModel model=null;
if(InterceptList.getInterceptMethod().containsKey(method.getName()))
{
model=InterceptList.getInterceptMethod().get(method.getName());
this.monitor(model.getBefore(), model.getBefore_aspectName(),this.target);
result = method.invoke(this.target, args);
this.monitor(model.getAfter(), model.getAfter_aspectName(),this.target);
}else {
result = method.invoke(this.target, args);
}
return result;
}
/**
* 依据是否注入横切关注点来决定before、after的调用
*/
private void monitor(Object clazz, String aspectName,Object target) throws Exception {
if (clazz != null) {
Method[] methods = clazz.getClass().getDeclaredMethods();
for (Method method : methods) {
if (method.getName().equals(aspectName)) {
method.invoke(clazz,target);
}
}
}
}
}
然后修改我们的IOC容器:当用户继承IOC容器后,自动查找用户配置的参数进行初始化
注意,此时使用this,new Intercept().bind()Load对象
测试类
}
/**
然后修改我们的IOC容器:当用户继承IOC容器后,自动查找用户配置的参数进行初始化
注意,此时使用this,new Intercept().bind()Load对象
public class IOC {
public IOC()
{
Init();
}
public void Init()
{
Field[] fields = getClass().getDeclaredFields();
for(Field field : fields){
Inject inject=field.getAnnotation(Inject.class);
try {
if(inject!=null)
{
field.setAccessible(true);
if(inject.Intercept())
{
field.set(this,new Intercept().bind(Class.forName(inject.ClassName().trim()).newInstance()));
}else {
field.set(this,Class.forName(inject.ClassName().trim()).newInstance());
}
}
} catch (Exception e) {
Logger.getLogger(getClass()).error("初始化容器异常:"+inject.ClassName().trim()+"初始化失败",e);
}
}
}
} 测试类
package com.metarnet.Main;
import com.metarnet.Injects.Inject;
import com.metarnet.Interfaces.BeforeAfter;
import com.metarnet.Interfaces.Interface1;
import com.metarnet.extend.AOPModel;
import com.metarnet.extend.IOC;
import com.metarnet.extend.IOCInit;
import com.metarnet.extend.InterceptList;
public class TestIOC extends IOC{
public TestIOC(){
super();
}
@Inject(ClassName = "com.metarnet.Interfaces.imps.Interface1Impl", Intercept = true)
private Interface1 interface1;
@Inject(ClassName = "com.metarnet.Interfaces.imps.Interface1Impl2", Intercept = false)
private Interface1 interface2;
@Inject(ClassName = "com.metarnet.Interfaces.imps.After", Intercept = false)
private BeforeAfter after;
@Inject(ClassName = "com.metarnet.Interfaces.imps.Before", Intercept = false)
private BeforeAfter before;
public Interface1 getInterface1() {
return interface1;
}
public void setInterface1(Interface1 interface1) {
this.interface1 = interface1;
}
/**
* 此方法可以修改为读取配置文件然后初始化
*/
public void init()
{
AOPModel model=new AOPModel();
model.setAfter(after);
model.setBefore(before);
model.setAfter_aspectName("SayAfter");
model.setBefore_aspectName("SayBefore");
InterceptList.getInterceptMethod().put("SayHello", model);
InterceptList.getInterceptList().add("interface1");
}
public static void main(String[] args) {
IOCInit.Init();
TestIOC ioc = new TestIOC();
ioc.init();
ioc.interface1.SayHello();
ioc.interface2.SayHello();
}
}
Model
/**
* 需要横切的列表
*/
public class AOPModel {
private Object before;// before 横切关注点 (之前调用)
private Object after; // after 横切关注点 (之后调用)
private String before_aspectName;//before横切调用的方法
private String after_aspectName;//after横切调用的方法
public Object getBefore() {
return before;
}
public void setBefore(Object before) {
this.before = before;
}
public Object getAfter() {
return after;
}
public void setAfter(Object after) {
this.after = after;
}
public String getBefore_aspectName() {
return before_aspectName;
}
public void setBefore_aspectName(String before_aspectName) {
this.before_aspectName = before_aspectName;
}
public String getAfter_aspectName() {
return after_aspectName;
}
public void setAfter_aspectName(String after_aspectName) {
this.after_aspectName = after_aspectName;
}
/**
* 需要监听的方法列表
*/
public final class InterceptList {
private static HashMap<String,AOPModel> map = new HashMap<String,AOPModel>();
private static ArrayList<String> list = new ArrayList<String>();
public static HashMap<String,AOPModel> getInterceptMethod() {
return map;
}
public static ArrayList<String> getInterceptList()
{
return list;
}
}