Java的三种代理模式 Spring代理

最新推荐文章于 2023-07-13 21:10:25 发布

PitBXu

最新推荐文章于 2023-07-13 21:10:25 发布

阅读量1.1k

点赞数 1

分类专栏：设计模式文章标签： spring 代理模式设计模式 java

本文链接：https://blog.csdn.net/PitBXu/article/details/90229512

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Java的三种代理模式

1.代理模式

代理(Proxy)是一种设计模式，提供了对目标对象另外的访问方式；即通过代理对象访问目标对象。这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。
这里使用到编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，如果需改修改，可以通过代理的方式来扩展该方法。

举个例子来说明代理的作用：假设我们想邀请一位明星，那么并不是直接连接明星，而是联系明星的经纪人，来达到同样的目的。明星就是一个目标对象，他只要负责活动中的节目，而其他琐碎的事情就交给他的代理人(经纪人)来解决。这就是代理思想在现实中的一个例子

用图表示如下:

1.1.静态代理(类似于装饰者模式)

静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类。

下面举个案例来解释：
模拟保存动作，定义一个保存动作的接口：IUserDao.java，然后目标对象实现这个接口的方法UserDao.java，此时如果使用静态代理方式，就需要在代理对象(UserDaoProxy.java)中也实现IUserDao接口。调用的时候通过调用代理对象的方法来调用目标对象。
需要注意的是，代理对象与目标对象要实现相同的接口，然后通过调用相同的方法来调用目标对象的方法。

代码示例：
接口：IUserDao.java

/**
 * 接口
 */
public interface IUserDao {

    void save();
}

目标对象：UserDao.java

/**
 * 接口实现
 * 目标对象
 */
public class UserDao implements IUserDao {
    public void save() {
        System.out.println("----UserDao 保存数据!----");
    }
}

代理对象：UserDaoProxy.java

/**
 * 代理对象,静态代理
 */
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("提交事务...");
    }
}

测试类：App.java

/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        //目标对象
        UserDao target = new UserDao();

        //代理对象,把目标对象传给代理对象,建立代理关系
        UserDaoProxy proxy = new UserDaoProxy(target);

        proxy.save();//执行的是代理的方法
    }
}

静态代理总结:

可以做到在不修改目标对象的功能前提下,对目标功能扩展.
缺点:

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

如何解决静态代理中的缺点呢?答案是可以使用动态代理方式

1.2.动态代理

首先需要记住

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

一张图说明动态代理原理

接口：

public interface TargetInterface{
    public void method1();
    public String method2();
    public int method3(int x);
}

目标对象：

public class Target implements TargetInterface{
    
    @Override
    public void method1(){
        System.out.println("method1 running ....");
    }
    
    @Override
    public void method2(){
        System.out.println("method2 running ....");
        return "method2";
    }
    
    @Override
    public void method3(int x){
        System.out.println("method3 running ....");
        return ++x;
    }
}

代理对象：

package Proxy;


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyTest2 {

    public static void main(String[] args) {
        
        final Target target = new Target();
        
        //动态创建代理对象
        
        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(), 
                new InvocationHandler() {
                    @Override
                    //被执行几次？------- 看代理对象调用方法几次
                    //代理对象调用接口相应方法 都是调用invoke
                    /*
                     * proxy:是代理对象
                     * method:代表的是目标方法的字节码对象
                     * args:代表是调用目标方法时参数
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //反射知识点
                        Object invoke = method.invoke(target, args);//目标对象的相应方法
                        //retrun返回的值给代理对象
                        return invoke;
                    }
                }
            );
        
        proxy.method1();//调用invoke---Method：目标对象的method1方法  args：null  返回值null
        String method2 = proxy.method2();//调用invoke---Method:目标对象的method2方法  args:null  返回值method2
        int method3 = proxy.method3(100);调用invoke-----Method:目标对象的method3方法 args:Object[]{100}  返回值100
        
        System.out.println(method2);
        System.out.println(method3);
        
    }
    
}

参数解释：

动态代理：不用手动编写一个代理对象，不需要编写与目标对象相同的方法，在运行时的内存中动态生成代理对象。------字节码对象级别的代理对象。

动态代理的 API：

代理类所在包：java.lang.reflect.Proxy

在 JDK 的 API 中存在一个 Proxy 中有生成动态代理的方法 newProxyInstance：

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

返回值：Object 代理对象

参数：loader，与目标对象相同的类加载器，target.getClass().getClassLoader()；

interfaces：目标对象实现的接口的类型,使用泛型方式确认类型。target.getClass().getInterfaces()；

h：事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入

基于动态代理的增强方法的过滤器：

package filter;


import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

import com.sun.corba.se.impl.protocol.giopmsgheaders.ReplyMessage_1_0;

public class EncodingFilter2 implements Filter{

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
    HttpServletRequest req = (HttpServletRequest) request;    
    
    HttpServletRequest enhanceRequset = (HttpServletRequest) Proxy.newProxyInstance(
            req.getClass().getClassLoader(), 
            req.getClass().getInterfaces(),
            new InvocationHandler() {
                
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                    对getParameter进行增强
                    if(method.getName().equals("getParameter")){
                        String invoke = (String) method.invoke(req, args);//乱码
                        invoke = new String(invoke.getBytes("iso8859-1"),"UTF-8");//转码
                        return invoke;
                    }
                    return method.invoke(req, args);
                }
            });
        chain.doFilter(enhanceRequset, response);//放行
    }

    @Override
    public void destroy() {
        // TODO Auto-generated method stub
        
    }

    
}

动态代理有以下特点:

代理对象不需要实现接扣口
代理对象的生成是利用 JDK 的 API 动态的在内存中构建代理对象（需要我们指定创建代理对象/目标对象实现的接口的类型）
动态代理也叫做：JDK代理，接口代理

总结:
　　代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理

1.3.Cglib代理(基于继承的方式实现)

上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候就可以使用以目标对象子类的方式类实现代理，这种方法就叫做：Cglib代理

Cglib代理，也叫作子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。

JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口，如果想代理没有实现接口的类，就可以使用Cglib实现。
Cglib 是一个强大的高性能的代码生成包，它可以在运行期扩展java类与实现java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和syn aop，为他们提供方法的interception(拦截)
Cglib 包的底层是通过使用一个小而快的字节码处理框架ASM来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对 JVM 内部结构包括 class 文件的格式和指令集都很熟悉。

Cglib子类代理实现方法:

需要引入cglib的jar文件，但是Spring的核心包中已经包括了Cglib功能，所以直接引入spring-core-3.2.5.jar即可。
引入功能包后，就可以在内存中动态构建子类。
代理的类不能为 final，否则报错。
目标对象的方法如果为 final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法。
如果方法为 static，private 则无法进行代理。

代码示例

目标对象类：UserDao.java

/**
 * 目标对象,没有实现任何接口
 */
public class UserDao {

    public void save() {
        System.out.println("----已经保存数据!----");
    }
}

Cglib代理工厂：ProxyFactory.java

/**
 * Cglib子类代理工厂
 * 对UserDao在内存中动态构建一个子类对象
 */
public class ProxyFactory implements MethodInterceptor{
    //维护目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();

    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开始事务...");

        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);

        System.out.println("提交事务...");

        return returnValue;
    }
}

PitBXu

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
Java的三种代理模式 Spring代理

Java的三种代理模式1.代理模式代理(Proxy)是一种设计模式，提供了对目标对象另外的访问方式；即通过代理对象访问目标对象。这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。这里使用到编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，如果需改修改，可以通过代理的方式来扩展该方法。举个例子来说明代理的作用：假设我们想邀请一位明星，...
复制链接

扫一扫