学过struts2的人都知道,这个框架中定义了很多拦截器,主要作用是在执行某个action前先过滤某些行为,当符合条件时才执行action中的方法。当然这也涉及到了另一种编程思想(AOP面向切面编程)。本文主要讲一下这里面的大致实现方式。其实它的实现模式分两种即代理模式和反射机制。代理模式又可分为静态代理和动态代理,而动态代理又是基于反射机制的。因为我先从代理问题开始讨论,由此引出反射机制问题。
什么是代理,在我看来,其实就是某个问题某个事物不能解决,交给另一个事物来完成,从而达到相同的效果。比如你不能解决的问题,那可以交给其他人来完成。代理也就大概这个意思。在java中,通过代理可以将某些与业务逻辑无关的通用操作分离出来单独执行。下面我以“记录删除操作的日志”为例,简要阐述一下java中的代理。
首先我们先来看一下,如果将删除和记录日志写到一起,我们可以得到下面这样的代码。
package com.ev.testdelete;
import java.util.logging.Level;
import java.util.logging.Logger;
public class TestDelete {
Logger log = Logger.getLogger(this.getClass().getName());
public void delete(){
log.log(Level.INFO, "删除之前");
System.out.println("delete");
log.log(Level.INFO, "删除之后");
}
}
在主方法中我们执行这个方法可以得到下面的结果
import com.ev.testdelete.TestDelete;
public class Test {
public static void main(String[] arg){
TestDelete testDelete = new TestDelete();
testDelete.delete();
}
}
我们可以发现,这种方式是将业务逻辑(删除操作)与记录日志是合在一起的。这将导致,如果整个项目大起来的时候,维护起来是很困难的。因此就很有必要将这两个操作分开,第一个方法我们可以使用静态代理的方式。这种方式中我们要将代理类和被代理类实现同一个接口。
这个接口如下:
package com.ev.dao;
public interface DeleteDao {
public void delete();
}
下面是被代理类:
package com.ev.testdelete;
import com.ev.dao.DeleteDao;
public class TestDelete implements DeleteDao{
public void delete(){
System.out.println("delete");
}
}
然后我们再创建一个代理类如下:
package com.ev.testdelete;
import java.util.logging.Level;
import java.util.logging.Logger;
import com.ev.dao.DeleteDao;
public class DeleteProxy implements DeleteDao {
Logger log = Logger.getLogger(this.getClass().getName());
DeleteDao dao;
//将代理类与代理类绑定在一起
public DeleteProxy(DeleteDao dao){
this.dao = dao;
}
public DeleteProxy(){
}
//在这里记录日志,但业务逻辑还是由被代理类中的方法实现
@Override
public void delete() {
log.log(Level.INFO, "删除之前");
dao.delete();//执行被代理类中的业务逻辑
log.log(Level.INFO, "删除之后");
}
}
在主方法中我们可以这样调用。
package com.ev.proxyhanddle;
import java.lang.reflect.Method;
import com.ev.dao.DeleteDao;
import com.ev.person.Person;
import com.ev.testdelete.DeleteProxy;
import com.ev.testdelete.TestDelete;
public class Test {
public static void main(String[] arg){
DeleteDao dao = new DeleteProxy(new TestDelete());
dao.delete();
}
}
得到的结果与之前的一样。但是这种方式已经将日志记录与业务逻辑分开了。但是静态代理有个缺点,就是它只能代理相同类结构的对象,也就是说,这个代理类只能代理实现这个接口的类的对象,如果有一个类实现了另外一个接口,那么这个代理类就不能生效了。这就涉及到了动态代理,其实在动态代理中就用到了反射机制。它可以使用方法动态调用。
动态代理定义如下:
package com.ev.proxyhanddle;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.logging.Level;
import java.util.logging.Logger;
public class MyProxy implements InvocationHandler {
private Logger log = Logger.getLogger(this.getClass().getName());
private Object delegate;
//将代理类与代理类绑定在一起
public Object bind(Object delegate){
this.delegate = delegate;
return Proxy.newProxyInstance(delegate.getClass().getClassLoader(), delegate.getClass().getInterfaces(), this);
}
//在这里记录日志,但业务逻辑还是由被代理类中的方法实现
@Override
public Object invoke(Object arg0, Method method, Object[] arg2) throws Throwable {//这个方法会自动调用
log.log(Level.INFO, "删除之前 ");
log.log(Level.INFO, "删除之后 ");
//执行被代理类中的业务逻辑
return method.invoke(delegate, arg2);//这是返回被代理类中相关方法的返回值
}
}
这时dao接口可以定义如下:
package com.ev.dao;
public interface UserDao {
public String delete(String name);
}
它的实现类为:
package com.ev.daoimp;
import com.ev.dao.UserDao;
public class UserDaoImp implements UserDao {
@Override
public String delete(String name) {
System.out.println(name+"删除成功!");
return "success!";
}
}
主方法调用如下:
package com.ev.proxy;
import com.ev.dao.UserDao;
import com.ev.daoimp.UserDaoImp;
import com.ev.proxyhanddle.MyProxy;
public class TestProxy {
public static void main(String[] args){
UserDao user = (UserDao)new MyProxy().bind(new UserDaoImp());
String info = user.delete("YKG");
System.out.println(info);
}
}
下图是执行结果
这时不管你的类是实现哪个接口,都可以用这个代理类进行代理了。
最后我们要知道的是,这个动态代理其实就是用到了java中的反射机制。最基本的就是Class.forName()
这个函数。这个函数会返回某个类的自描述类,当然自描述类也是一种类,这个类包含了被“描述类”的相关信息,比例,这个类有哪些方法,有哪些成员变量,哪些构造方法,哪些是公有的,哪些是私有的等等。
例如,我们创建一个Person类。
package com.ev.person;
public class Person {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
这个类包含姓名和年龄。
然后我们可以通过Class cls = Class.forName("com.ev.person.Person");
获得这个类的信息。Person per = (Person)cls.newInstance();
得到这个类的实例。我们也可以获得这个类的方法然后动态调用。具体如下 :
package com.ev.proxyhanddle;
import java.lang.reflect.Method;
import com.ev.dao.DeleteDao;
import com.ev.person.Person;
import com.ev.testdelete.DeleteProxy;
import com.ev.testdelete.TestDelete;
public class Test {
public static void main(String[] arg){
try {
//得到Person类的自描述类
Class cls = Class.forName("com.ev.person.Person");
//得到Person类的实例
Person per = (Person)cls.newInstance();
//动态获得Person类的setName方法
Method setMethod = cls.getMethod("setName", String.class);
//动态调用setName方法
setMethod.invoke(per, "YKG");
//获得getName方法
Method getMethod = cls.getMethod("getName", null);
//动态调用getName方法
String name = (String)getMethod.invoke(per, null);
System.out.println(name);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
所以不管是struts2的拦截器还是动态代理,其底层还是用到了反射技术。struts2的拦截器只是通过底层的反射技术,获得某个action从而动态执行其中的方法。