设计模式之---代理模式(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 代理的目标类可以实现接口也可以不实现，因为可以使用继承子类的方式代理。