设计模式--继承、装饰者、动态代理

最新推荐文章于 2024-11-06 10:15:33 发布

hello老杜

最新推荐文章于 2024-11-06 10:15:33 发布

阅读量163

点赞数

文章标签：设计模式 java

本文链接：https://blog.csdn.net/weixin_41291118/article/details/109751359

版权

Spring-静态代理、动态代理

我们先来做一个小案例：

案例结构

//建立一个Man类
public interface Man {
    public void run();
}`

//创建一个CommonMan 类实现Man接口
public class CommonMan implements Man {

    public void run() {
        System.out.println("跑步。。。");
    }
}
//测试
public class ManTest {
    public static void main(String[] args) {
        Man man = new CommonMan();
        man.run();
    }
}
//输出结果
/*跑步。。。*/

这是一个简单的通过实现类实现接口的方法，但是现在有一个问题，如果现在有人觉得这个run方法实在是太慢了想要增强这个方法怎么实现？
最简单最的方式是在写一个类继承这个CommonMan 的run方法
方案一：继承

//继承方式，增强CommonMan 的run方法
public class SuperMan extends CommonMan {
    @Override
    public void run() {
        super.run();  //原来的功能没有改变
        System.out.println("跑着跑着飞起来了。。。"); //在原有功能的基础上增强
    }
}

//测试类中需要修改--直接调用SuperMan中的方法
public class ManTest {
    public static void main(String[] args) {
  		//Man man = new CommonMan();
        //man.run();
        SuperMan man = new SuperMan();
        man.run();
    }
}

//输出结果
/*跑步。。。
飞起来。。。*/

方案二：装饰者模式：在不惊动原始设计的基础上，增强某些方法

//装饰者设计模式--增强CommonMan 的run方法
public class SuperMan2 implements Man {
	//这里直接创CommonMan 的父类对象增加复用性
    private Man cm;
    public SuperMan2(Man cm) {
        this.cm = cm;
    }
   
    @Override
    public void run() {
        cm.run();
        System.out.println("跑着跑着飞起来了。。。");
    }
}


//测试类中需要修改--直接调用SuperMan中的方法
public class ManTest {
    public static void main(String[] args) {
		Man m1 = new CommonMan();
        Man m2 = new SuperMan2(m1);
        m2.run();
    }
}

//输出结果
/*跑步。。。
飞起来。。。*/

方案三：动态代理–JDK

//动态代理--JDK
public class ManTest {
        //动态代理
        // Object 代理对象=Proxy.newProxyInstance(被代理对象的类加载器, 被代理对象的接口,实际的增强);
        //创建被代理对象（）
        Man m1 = new CommonMan();
        ClassLoader classLoader = m1.getClass().getClassLoader();
        Class[] interfaces = m1.getClass().getInterfaces();
        //创建代理对象
        Man m2 = (Man) Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("前置增强代码...");
                Object obj = method.invoke(m1, args);
                System.out.println("后置增强代码...");
                return obj;
            }
        });
        //调用代理对象的方法测试
        m2.run();
    }
}

方案四：动态代理-CGLIB

public class ManTest {
Man m1 = new CommonMan(); //创建目标对象
Enhancer enhancer = new Enhancer();   //创建增强器
enhancer.setSuperclass(m1.class); //设置父类
enhancer.setCallback(new MethodInterceptor() { //设置回调
    @Override
    public Object intercept(Object o, Method method, Object[] args, 
                            MethodProxy methodProxy) throws Throwable {
                            
        System.out.println("前置代码增强....");
        //通过调用父类方法实现对原始方法的调用
        Object obj= method.invoke(o, args);
        //后置增强内容，与JDKProxy区别：JDKProxy仅对接口方法做增强，cglib对所有方法做增强，包括Object 类中的方法
        System.out.println("后置代码增强....");
        return obj;
    }
});

//创建代理对象
Man m2= (Man) enhancer.create();
//调用方法
m2.method();
}