设计模式之---代理模式(AOP的原理)

代理模式主要有两种:静态代理,动态代理。

代理模式的功能主要是起到增强方法和权限拦截的作用。

 

1.静态代理:

 

其实代理模式根据这个名字就很好理解,举个简单例子:小明要去租房,但他找不到的房东,只能去找中介,中介再帮他找房东,而这个中介就起到了代理的作用。

如图所示:小明的是用户类,调用者,中介就是代理类,房东就是目标类真正需要调用的类,这时代理类就可以在中间做点手脚,起到增强方法的作用。

 

但有个问题就是如果目标类有很多方法,代理类应该也有这么多方法,这时代理类和目标应该要有一种约定,所以代理类和目标类都应该实现同一个接口。下面是代码实现:

 

 

目标类和代理类实现的同一接口,约束规定。

 

/**
 * Created by Ming on 2017/11/25.
 */
public interface LetOutService { 
    Integer letOut();
}


房东类(目标类):

/**
 * Created by Ming on 2017/11/25.
 */
public class Landlady implements LetOutService {


    @Override
    public Integer letOut() {
        System.out.println("租房方法 running...");
        return 100;
    }
}

 

 

 

中介类(代理类):

 

/**
 * Created by Ming on 2017/11/25.
 */
public class Proxy implements LetOutService {

    @Override
    public Integer letOut() {
        Landlady landlady = new Landlady();
        Integer integer = landlady.letOut();
        return integer + 100;
    }
}


用户类:

 

 

public class User {

    public static void main(String[] args) {
        Proxy proxy = new Proxy();
        Integer integer = proxy.letOut();
        System.out.println(integer);


    }
}


输出:

 

 

 

 

 

2.动态代理:

 

静态代理缺点:因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护。

解决办法动态代理:其实动态代理和静态代理的思想是不变的,动态代理和静态代理的区别就是,动态代理不用我们去手编写代理类,在运行时,动态的在内存中生产代理类。(字节码对象级别的代理对象)。

 

动态代理的API:

 在java.lang.reflect包中有一个代理类。

  • java.lang.reflect.Proxy     

 

 

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

返回指定的接口,将方法调用指定的调用处理程序的代理类的一个实例。 

返回值:Object就是代理对象

参数:

loader:代表与目标对象相同的类加载器-------目标对象.getClass().getClassLoader()

interfaces:代表与目标对象实现的所有的接口字节码对象数组----数组因为目标类可以有多个接口

h:具体的代理的操作,InvocationHandler接口

 

注意:JDK的Proxy方式实现的动态代理 目标对象必须有接口 没有接口不能实现jdk版动态代理!

 

介绍完方法,我们还是以代码为例看看怎么实现吧:

 

统一接口 :

 

/**
 * Created by Ming on 2017/11/25.
 */
public interface TargetInterface {

    void method1();
    void method2();
    int method3(Integer i);

}


目标类:

/**
 * Created by Ming on 2017/11/25.
 */
public class Target implements TargetInterface {
    @Override
    public void method1() {
        System.out.println("method1 running ...");
    }

    @Override
    public void method2() {
        System.out.println("method2 running ...");
    }

    @Override
    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

 

 

 

代理工厂类:

/**
 * Created by Ming on 2017/11/23.
 */
public class ProxyFactory {

    static <T> Object getProxy(T t){
        
        //返回一个代理对象
        Object object = Proxy.newProxyInstance(t.getClass().getClassLoader(), t.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // proxy就是目标对象,method就是调用目标对象中方法,args就是调用目标对象中方法的参数。
                //比如说:代理对象.method1(),这时proxy就是目标类,method1就是method,args就是method1方法参数。
                System.out.println("执行方法前...");
                Object invoke = method.invoke(t, args);
                System.out.println("执行方法后...");
                return invoke;
            }
        });

        return object;
    }

}

 

 

 

调用者:

 

/**
 * Created by Ming on 2017/11/25.
 */
public class User {

    public static void main(String[] args) {
        Target target = new Target();

        TargetInterface proxy = (TargetInterface)ProxyFactory.getProxy(target);

        proxy.method1();
        System.out.println("-------------------------");
        proxy.method2();
        System.out.println("-------------------------");
        int i = proxy.method3(100);
        System.out.println(i);

    }
}

输出:

 


 

 

 

3.Cglib代理:

 


第三方代理技术,Cglib代理。代理的原理是可以对目标对象接口实现代理,也可以进行继承代理(不能对final修饰的类进行继承代理)。

需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入spring-core包

 

代码实现:

 

目标类  (可以不用实现接口,因为生成的代理类 是目标类的子类):

 

/**
 * Created by Ming on 2017/11/25.
 */
public class Target {
    public void method1() {
        System.out.println("method1 running ...");
    }

    public void method2() {
        System.out.println("method2 running ...");
    }

    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

 

 

 

 

 

 

CglibFactory类:

 

/**
 * Created by Ming on 2017/11/25.
 */
public class CglibFactory {

    static <T> Object getProxy(T t){
        Enhancer en = new Enhancer(); //帮我们生成代理对象
        en.setSuperclass(t.getClass());//设置要代理的目标类
        en.setCallback(new MethodInterceptor() {//代理要做什么
            @Override
            public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("执行方法前。。。");
                //调用原有方法  
                Object invoke = methodProxy.invokeSuper(object, args);
//              Object invoke = method.invoke(t,args); 作用等同与上面。
                System.out.println("执行方法后。。。");
                return invoke;
            }
        });
        Object proxyObj = en.create();//生成代理对象
        return proxyObj;
    }

}


调用类:

/**
 * Created by Ming on 2017/11/25.
 */
public class User {

    public static void main(String[] args) {
        Target target = new Target();


        TargetInterface proxy = (TargetInterface) CglibFactory.getProxy(target);

        System.out.println(proxy.method3(100));

    }
}

 

 

 

输出:

 

 

 

 

 

案例:

 

使用动态代理设置全局编码:

 

 public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {

        resp.setContentType("text/html;charset=utf-8");
        HttpServletRequest request = (HttpServletRequest) req;
        //使用动态代理 设置全局编码
        HttpServletRequest proxyRequest  = (HttpServletRequest) Proxy.newProxyInstance(request.getClass().getClassLoader(),
                request.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object object, Method method, Object[] args) throws Throwable {
                        String name = method.getName();
                        if("getParameter".equals(name)){
                            String invoke = (String) method.invoke(request, args);
                            invoke = new String(invoke.getBytes("iso8859-1"),"UTF-8");
                            return invoke;
                        }
                        return method.invoke(request,args);
                    }
                }
        );
        chain.doFilter(proxyRequest,resp);
    }

 

 

 

 

重点:

Spring AOP 编程的实现原理就是动态代理。使用的是JDK代理和cglib代理,比如Spring的事务使用的是aop技术,当目标类没有实现接口时候,会使用cglib代理,实现了接口默认使用JDK代理。

Spring切面配置代理模式

想要使用CGLIB,<aop:config>下面的proxy-target-class属性为true,意思是说代理者的是类,不是接口。

<aop:config proxy-target-class="true">
        <!-- other beans defined here... -->
</aop:config>


要是使用@AspectJ注解切面的话,可以配置<aop:aspectj-autoproxy>下的proxy-target-class属性为true。

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

当然现在流行使用SpringBoot,则在SpringBoot中配置主需要在yml中添加

spring:
  aop:
    proxy-target-class: true

Spring事务配置代理模式

配置:springboot的启动类要加上@EnableTransactionManagement和@EnableAspectAutoProxy注解,且其中的proxyTargetClass属性默认的fasle,如果设置成了true就会开启cglib。

 

总结:

静态代理需要自己手动编写代理类和目标方法。

动态代理就不需要自己手动实现代理类和目标方法,但动态代理的目标类要必须实现接口!

Cglib 代理的目标类可以实现接口也可以不实现,因为可以使用继承子类的方式代理。

 

 

发布了42 篇原创文章 · 获赞 26 · 访问量 4万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 像素格子 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览