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

最新推荐文章于 2023-03-30 08:33:04 发布

weixin_奢望

最新推荐文章于 2023-03-30 08:33:04 发布

阅读量179

点赞数

分类专栏： JAVASE

本文链接：https://blog.csdn.net/weixin_44523741/article/details/89409370

版权

JAVASE 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

本文探讨了面向对象设计中的继承、装饰设计模式以及代理的概念。继承允许子类重写父类方法以实现增强功能。装饰模式则在不改变原有类的基础上，通过创建新的类来增加功能，降低了耦合度。代理模式中，静态代理通过创建代理类实现对目标对象的控制，而动态代理（JDK和Cglib）则在运行时动态生成代理对象，提供更灵活的增强方式。JDK动态代理基于接口，Cglib则是基于类的代理，适用于未实现接口的目标对象。

摘要由CSDN通过智能技术生成

1、继承
2、装饰者模式
3、静态代理
4、动态代理

1、继承、然后重写父类方法

比如有
接口 A
类A的实现类 B
类 C需要对类B进行增强、继承了类B
增强的类 C 直接重写父类方法对类B 进行了增强

使用时机:继承关系已经存在 (类C继承类B)

public interface man{
 void play();
}
public class normalman implements man{
	@Override
	public void play() {
		System.out.println("玩");
		
	}
}
public class superman extends  normalman  {
	@Override
	public void play() {
		System.out.println("超级玩");
		
	}
}

2、装饰设计模式

接口A
类A的实现类B
类C 需要增强B 同时也实现了A
需要注意的是：类C虽然增强了B,但是没有直接继承B。
类C 需要重写类A的所有方法
使用时机:(没有已知继承关系,需要自己添加继承关系的时候,建议使用包装设计模式,原理:耦合度高不利于后期维护)
缺点：一旦类A的方法过多,需要逐一实现容易造成累赘–>解决方式动态代理

public interface man{
 void play();
}
public class normalman implements man{
	@Override
	public void play() {
		System.out.println("玩");
		
	}
}
public class superman implements man  {
 public normalman  n ;

public superman (normalman   n){
  this.n=n;
}
	@Override
	public void play() {
	     n.play();
		System.out.println("超级玩");
		
	}
	@Test
	public void test(){
normalman  n = new normalman  ();
superman  sm = new superman (n);
sm.play();

}
//输出结果：  玩
            超级玩
}

3、静态代理、动态代理

代理又分为静态代理和动态代理

①静态代理

⑴特点：

用户：对功能对请求

代理：负责获取原始功能，或者增强原始功能给用户使用。

目标对象： 原始功能的提供。


代理模式对应用场景：
   1.目标对象的功能，不够用。
   2.用户拿不到目标对象。

案例：
目标对象：潘小姐。

 大朗，二郎

 用户：西门官人

 代理：大朗对门的一个开茶馆的 王婆婆。  目标和代理对象必须出于同一环境(有共同语言)

先定义一个woman接口
在这里插入图片描述
被潘小姐实现

代理人王婆也实现，然后在构造器给私有的对象赋值，在实现的方法里也添加了自己的方法。

西门官人定义了玩方法

由于潘小姐的访问权限是缺省值只能在当前包中被访问，所以西门是无法直接访问的，需要通过代理人王婆。

整体结构图
在这里插入图片描述
写一个test：

②动态代理又分为JDk动态代理和cglib动态代理

它们的区别：JDk动态代理是面向接口的、cglib动态代理是面向类的

JDk的动态代理：

一个接口A
接口A的实现类B
增强类B 的动态代理方法

直接上代码：

public interface personClass {

     void  run();

     void  play();

     String read();
}

//下面是我们要代理的类
public class personNormal implements  personClass {
    @Override
    public void run() {
        System.out.println("走了！");
    }


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

    @Override
    public String read() {
        return "can read";
    }
}



//下面是动态代理的写法，增强我们想要代理的类
// 需求: 使用动态代理的方式对普通人进行增强
public class proxyTEST {


    @Test
    public void test01(){

        final personNormal personNormal =new personNormal();
        
     
        /*参数概述: 
         *  参数1: 和被代理的对象一样的类加载器
         *  参数2: 和被代理的对象一样的接口
         *  					1 根据指定的传递接口 返回一个该接口下的实例
         *  					2 传递的接口 里面的方法就是可以被增强的所有方法
         *
         *  参数3: 所有的增强业务逻辑实现 (方法)
         * 代理对象和被代理对象实现同样的方法，所以可用父类型接口来引用。
         * */
        personClass p = (personClass)Proxy.newProxyInstance(
                personNormal.getClass().getClassLoader(),
                personNormal.getClass().getInterfaces(),
                new InvocationHandler() {

                    /*invoke方法参数概述：
                     * 参数1: 不用管 永远是固定值 指代理对象
                     * 参数2: 要被增强的方法
                     * 参数3: 要被增强的方法运行过程中需要的参数
                     * */

                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        //这里面写业务逻辑
                        System.out.println("增强了走：飞");
                        //然后还可以调用需要增强的方法 传入2个参数
                            // 让以前的方法执行
                            // 参数1:本身应该执行这个方法的对象
                            // 参数2: 执行这个方法需要的参数
                        method.invoke(personNormal,args);

                        return null;
                    }
                });
                 p.run();  //获取结果：
                            /*增强了走：飞
                              走了！
                            */

代理返回的是要增强接口的实现类，只不过用指向了接口

在这里插入图片描述



    }
    
    @Test
    public void test02(){
        final personNormal personNormal =new personNormal();

        personClass p = (personClass)Proxy.newProxyInstance(
                personNormal.getClass().getClassLoader(),
                personNormal.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        //这个返回值返回什么？
                        //返回需要增强方法的返回值,没有就返回null
                        Object invoke = method.invoke(personNormal, args);
//                        System.out.println(invoke);

                        //下面这个ruturn 又返回什么？
                         //该return 返回给增强后的方法
                        return "abcd";
                    }
                });

        String read = p.read();
        System.out.println(read); //输出结果：can read
                                           // abcd

    }

    @Test
    public void test03(){

        final personNormal personNormal =new personNormal();

        personClass p = (personClass)Proxy.newProxyInstance(
                personNormal.getClass().getClassLoader(),
                personNormal.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        // 需要增强的方法直接作为返回值呢？
                        return method.invoke(personNormal,args);
                    }
                });
        String re1ad = personNormal.read();  //输出结果 ： can read
        System.out.println(re1ad);

    }
}

cglib动态代理

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

代码实例：
目标对象类: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;
    }
}

测试类:

/**
 * 测试类
 */
public class App {

    @Test
    public void test(){
        //目标对象
        UserDao target = new UserDao();

        //代理对象
        UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();

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