一、代理在使用动态代理实现拦截器之前我们先简单了解一下什么java的代理。
代理，顾名思义，就是不直接操作被代理（下面都用目标对象称呼，听起来舒服一些）对象，而是通过一个代理对象去间接的使用目标对象中的方法。代理分为两种模式，一种是静态代理，一种是动态代理。接下来先写一个静态代理的例子。
无论是静态代理还是动态代理，目标对象（target）都要实现一个接口（interface），注意，如果使用cglib提供的代理，则不必实现接口，而是通过子类去实现，暂不讨论该种方式。
（1）先定义一个接口public interface iuserdao { void save();}
（2）定义目标对象（target）public class userdaoimpl implements iuserdao { public void save() { system.out.println(--------已经保存数据---------); }}
（3）定义代理对象public class userdaoproxy implements iuserdao { private iuserdao target;//将目标对象放到代理对象中 public userdaoproxy(iuserdao target){ this.target = target; } public void save() { system.out.println(------开始事务------); target.save(); system.out.println(-------提交事务------); }}
测试一下：
public class test {public static void main(string[] args){ iuserdao userdao = new userdaoimpl(); userdaoproxy proxy = new userdaoproxy(userdao); proxy.save();//通过代理对象调用save方法 }}
输出结果为：
------开始事务------
--------已经保存数据---------
-------提交事务------
这种方式有一个问题，就是代理对象必须也要实现被代理对象所实现的同一个接口，这就出现了严重的耦合。所以，下面使用一种改进的方式，即动态代理（jdk代理）。
动态代理方式也需要目标对象（target）实现一个接口
（1）定义一个接口（iuserdao）
（2）定义一个目标对象类（userdaoimpl）
（3）创建动态代理类
public class proxyfactory { //维护一个目标对象 private object target; public proxyfactory(object target) { this.target = target; } //给目标对象生成代理对象 public object getproxyinstance() { system.out.println(----target class--- + target.getclass()); system.out.println(----target interfaces--- + target.getclass().getinterfaces()); return proxy.newproxyinstance(target.getclass().getclassloader(), target.getclass().getinterfaces(), new invocationhandler() { public object invoke(object proxy, method method, object[] args) throws throwable { system.out.println(----开始事务2-----); //执行目标对象方法 object returnvalue = method.invoke(target, args); system.out.println(----提交事务2----); return returnvalue; } }); }}
测试一下：
public class test { public static void main(string[] args) { //目标对象 iuserdao target = new userdao(); system.out.println(target.getclass()); //给目标对象创建代理对象 iuserdao proxy = (iuserdao) new proxyfactory(target).getproxyinstance(); system.out.println(----proxy----： + proxy.getclass()); proxy.save(); proxy.delete(); }}
输出结果：
class com.jd.pattern.proxy.dynamicproxy.userdao
----target class---class com.jd.pattern.proxy.dynamicproxy.userdao
----target interfaces---[ljava.lang.class;@1fb3ebeb
----proxy----：class com.sun.proxy.$proxy0
----开始事务2-----
-----保存完成------
----提交事务2----
----开始事务2-----
----删除完成----
----提交事务2----
二、使用动态代理实现一个简单的拦截器既然是采用动态代理的方式，那么肯定会有 接口、目标类、代理类，再加一个拦截器
1、定义一个接口public interface businessfacade { void dosomething();}
2、定义一个目标对象public class businessclass implements businessfacade { public void dosomething() { system.out.println(在业务组件businessclass中调用dosomething方法); }}
3、创建拦截器public class interceptorclass { public void before() { system.out.println(在interceptorclass中调用方法：before()); } public void after() { system.out.println(在interceptorclass中调用方法：after()); }}
4、创建代理public class dynamicproxyhandler { //声明被代理对象 private object target; //创建拦截器 interceptorclass interceptor = new interceptorclass(); //动态生成一个代理对象，并绑定被代理类和代理处理器 public object getproxyinstance(final object target) { this.target = target; return proxy.newproxyinstance(target.getclass().getclassloader(), target.getclass().getinterfaces(), new invocationhandler() { public object invoke(object proxy, method method, object[] args) throws throwable { interceptor.before(); object result = method.invoke(target, args); interceptor.after(); return result; } }); }}
测试一下：
public class test { public static void main(string[] args) { //创建动态代理工具 dynamicproxyhandler proxyhandler = new dynamicproxyhandler(); //创建业务组件 businessfacade target = new businessclass(); //获取代理对象 businessfacade proxy = (businessfacade) proxyhandler.getproxyinstance(target); //通过代理对象调用目标对象方法 proxy.dosomething(); }}
输出结果：
在interceptorclass中调用方法：before()
在业务组件businessclass中调用dosomething方法
在interceptorclass中调用方法：after()
以上就是java怎么通过动态代理实现一个简单的拦截器操作的详细内容。