jenny.run

浏览: 26231 次
性别:
来自: 北京

最近访客更多访客>>

wangcaster

ssuubb2711

sblig

winting

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

设计模式之代理模式

博客分类：

设计模式

设计模式之代理模式

代理模式

代理模式是常用的java设计模式，他的特征是代理类与委托类具有相同的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类对象的相关方法，来提供特定的服务；

静态代理类实例代码：

public interface Subject {
     void operation();
}

public class RealSubject implements Subject {
    @Override
    public void operation() {
        System.out.println("real subject operate started......");
    }
}

public class Proxy implements Subject {
    //对象的组合可以在运行时动态改变行为
    private Subject subject;  

    public Proxy(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void operation() {
        System.out.println("before operate......");
        subject.operation();
        System.out.println("after operate......");
    }

}

public class Client {

    public static void main(String[] args) {
        Subject subject = new RealSubject();
        Proxy proxy = new Proxy(subject);
        proxy.operation();
    }
}

动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码，动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java反射机制可以生成任意类型的动态代理类。java.lang.reflect包中的Proxy类和InvocationHandler接口提供了生成动态代理类的能力

动态代理可以提供对另一个对象的访问，同时隐藏实际对象的具体时实，代理一般会实现它所表示的实际对象的接口，代理可以访问实际对象，但是延迟实现实际对象的部分功能，时间对象实现系统的实际功能，代理对象对客户隐藏了实际对象，客户端不知道它是与代理打交道还是与实际对象打交道

好处：可以对请求进行任何处理，在不允许直接访问某些类的情况下对访问要做做特殊处理等

1.JDK动态代理：利用java反射机制实现，必须有对应的接口

JDK动态代理中包含一个类和一个接口

1.1 InvocationHandler接口：

public interface InvocationHandler {
   // proxy:在其上调用方法的代理实例，method:要调用的方法；args:方法调用所需要的参数
public Object invoke(Object proxy, Method method, Object[] args)
                                                         throws Throwable;
}

1.2 Proxy类：

Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法

 public static Object newProxyInstance(ClassLoader loader,  Class<?>[] inter                                                 faces, InvocationHandler h)

loader：类加载器

interfaces：类全部的接口

h:得到InvocationHandler接口的子类实现

实例部分：

public interface StudentDAO {
    //保存学生
    void saveStudent(Integer i);
    //查询学生
    void query();
}

public class StudentDAOImpl implements StudentDAO {
    @Override
    public void saveStudent(Integer i) {
        System.out.println("save student material..."+i.toString());
    }

    @Override
    public void query() {
        System.out.println("query student info");
    }
}

public class StudentDAOProxy implements InvocationHandler {

    private Object orginalObject;

    public Object bind(Object obj){
        this.orginalObject = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
    }

    private void preMethod(){
        System.out.println("------------方法执行之前--------------");
    }

    private void afterMethod(){
        System.out.println("------------方法执行之后--------------");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result ;
        preMethod();
        result = method.invoke(this.orginalObject,args);
        afterMethod();
        return result;
    }
}

public class TestStudentDAOTest {

    public static void main(String[] args){
        StudentDAO dao = new StudentDAOImpl();
        StudentDAOProxy proxy = new StudentDAOProxy();
        dao = (StudentDAO)proxy.bind(dao);
        dao.saveStudent(12);
        dao.query();
    }
}

JDK的动态代理依靠接口实现，如果有些类并没有接口，则不能使用JDK代理，这就要使用Cglib动态代理了

2.Cglib动态代理：不依赖接口

CGLIB包的底层是通过使用一个小而快的字节码处理矿建ASM，来转换字节码并生成新的类，除了CGLIB包，脚本语言例如Groovy和BeanShell也是使用ASM来生成字节码，不推荐直接使用ASM，因为它要求对JVM内部结构包括class文件的格式和指令集都很熟悉；CGlib是一个强大的高性能的代码生成包，被许多AOP框架使用，如Spring AOP，为他们提供方法的interception拦截

public interface MethodInterceptor extends Callback {
    Object intercept(Object obj, Method method, Object[] args, 
                                     MethodProxy proxy) throws Throwable;
}

obj：代理对象
method：拦截方法
args：方法参数
proxy：拦截器

实例：

public abstract class AbstractStudentDAO {
    public abstract void  saveStudent();
    public abstract void queryStudent();
}

public class CglibProxy implements MethodInterceptor {

    private Object originalObj;

    public Object bind(Object obj){
        this.originalObj = obj;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(obj.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    private void preMethod(){
        System.out.println("------------方法执行之前--------------");
    }

    private void afterMethod(){
        System.out.println("------------方法执行之后--------------");
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        preMethod();
        methodProxy.invokeSuper(obj,objects);
        afterMethod();
        return null;
    }
}

public class TestStudentDAOTest {

    public static void main(String[] args){
        StudentDAO dao = new StudentDAOImpl();
        StudentDAOProxy proxy = new StudentDAOProxy();
        dao = (StudentDAO)proxy.bind(dao);
        dao.saveStudent(12);
        dao.query();
    }
}

spring缺省是支持Proxy动态代理，如何强制使用CGLIB生成代理

<aop:aspectj-autoproxy proxy-target-class=“true”/>

Transaction:

<tx: annotation-driven transaction-manager=“teManager” proxy-target-class=“true” />

AOP(Aspect Oriented Programming)它是一种设计模式，用于实现一个系统中的应用

日志拦截
授权认证
事务拦截
方法缓存
数据审计

Aspect(切面)：指横切性关注点的抽象即为切面，它与类相似，只是两者的关注点不一样，类是对物体特征的抽象，而切面横切性关注点的抽象
JoinPoint（连接点）：所谓连接点是指那些被拦截到的点，在Spring中，这些点指的是方法，因为spring只是支持方法类型的连接点，实际上joinpoint还可以是field或类构造器
PointCut切入点：所谓切入点是指我们要对那些Joinpoint进行拦截的定义
Advice（通知）：所谓通知是指拦截到joinpoint之后所要做的事情就是通知，通知分为前置通知、后置通知、异常通知、最终通知、环绕通知
Target（目标对象）：代理的目标对象
Weave(织入)：指将aspects应用到target对象并导致Proxy对象创建的过程称为ahi入
Introduction（引入）：在不修改类代码的前提下，Introduction可以在运行期为类动态地添加一些方法或Field

2.1 基于代理的AOP

创建bean

<bean id=“studentDaoImpl”  class=“com.student.impl.StudentDaoImpl”/>

定义切入点

<bean id=“studentDaoPointCut” class=“org.springframework.aop.support.Jdk                                               RegexMethodPointcut”>
      <property name=“pattern” value=“.*dao”>                                //指定正则表达式，匹配以dao结尾的方法
</bean>

定义通知

<bean id=“studentDaoAdvisor”   
         class=“org.springframework.aop.support.DefaultPointcutAdvisor”>
   <property name=“advice”  ref=“studentdDaoProxy”/>
   <property name=“pointcut” ret=“studentDaoPointCut”/>
<bean>

定义代理工厂

<bean id=“studnetProxyFactory” class=“org.springframework.aop.framework.                                                  ProxyFactoryBean”>
  <property name=“interceptorNames” value=“studentDaoAdvisor”/>
  <property name=“proxyInterfaces” value=“com.student.StudentDAO”/>
<bean>

测试

ApplicationContext ctx = new ClassPathXmlApplicationContext(“application.xml");
StudentDao dao = (StudnetDao) ctx.getBean(“studentProxyFactory);
dao.saveStudent();

2.2 基于CGLIB的AOP

proxy动态代理只能对实现了接口的类生成代理，而不能针对类，CGLIB是针对类生成代理，主要是对用户类生成一个子类

基于代理的AOP实现过程比较复杂，可使用Spring提供的自动代理，让切入点和通知自动匹配

<bean id=“studentDaoAdvice” class=“org.springframework.aop.support.RegexdMet                                                      hodePointcutAdvisor”>
   <property name=“advice” ref=“studentDaoProxy”/>
   <property  name=“pattern” value=“.*student”/>
</bean>
//声明使用自动代理
<bean class=“org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator”/>

2.3基于AspectJ 的AOP

<context:annotation-config/>
<context:component-scan base-package=“com.student”/>
<aop:aspectj-autoproxy/>

@Aspect  //声明为切面
@Component  //声明为组件
public class StudentAspectJProxy{
      @Before(“execution(public void com.student.StudentDao.*student())")
      public void beforeMethod(){
           System.out.println(“方法执行之前.....");
     }
   @Before(“execution(public void com.student.StudentDao.*student())")
      public void afterMethod(){
           System.out.println(“方法执行之前.....");
     }
}

public class StudentAspectJProxy{
     @PointCut(“execution(public void com.student.StudentDao.*student())")
      public void doFilter(){ }

      @Before(“doFilter()")
      public void beforeMethod(){
           System.out.println(“方法执行之前.....");
     }

   @AfterReturning(“doFilter()")
      public void afterMethod(){
           System.out.println(“方法执行之前.....");
     }
}

查看图片附件

分享到：

模板方法模式 | Spring MVC之LocaleResolver(解析用户区 ...

2016-05-05 15:43
浏览 270
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

设计模式之代理模式

设计模式之代理模式

代理模式

1.JDK动态代理：利用java反射机制实现，必须有对应的接口

1.1 InvocationHandler接口：

1.2 Proxy类：

评论

发表评论

相关推荐

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

设计模式之代理模式

设计模式之代理模式

代理模式

1.JDK动态代理：利用java反射机制实现，必须有对应的接口

1.1 InvocationHandler接口：

1.2 Proxy类：

评论

发表评论

相关推荐

设计模式基础之类关系

设计模式之访问者模式Visitor

gof23种设计模式之总结

设计模式之备忘录模式memento

设计模式之外观模式Facade

设计模式之桥接模式bridge

设计模式之装饰者模式Decorator

观察者模式与发布/订阅模式区别

设计模式之单例模式

设计模式之创建者模式Builder

设计模式之适配器模式Adapter

设计模式之原型模式

设计模式之工厂模式

设计模式之观察者模式Observer

设计模式之责任链模式

设计模式之组合模式composite

设计模式之享元模式

设计模式之迭代器模式

设计模式之中介者模式

设计模式之中介者模式

最近访客更多访客>>