Spring引入静态代理解决OCP开闭原则的增强对象功能的实现-----Spring框架

最新推荐文章于 2024-09-14 18:46:05 发布

旧约Alatus

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量41

点赞数 1

分类专栏： # Spring框架 JAVA 文章标签： java 服务器开发语言后端 spring log log4j

本文链接：https://blog.csdn.net/2201_75960169/article/details/132336848

版权

JAVA 同时被 2 个专栏收录

542 篇文章 3 订阅

订阅专栏

Spring框架

131 篇文章 0 订阅

订阅专栏

文章讨论了类和类之间的泛化关系（继承）与关联关系的区别，强调了在设计中应优先选择关联关系以降低耦合度。同时，介绍了Spring中的服务接口和代理模式，以及其在OCP原则的应用和可能的缺点——类爆炸和高耦合。

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

类和类之间的关系有六种,泛化关系(继承),关联关系
泛化关系Cat is a Animal
public class Animal{} public class Cat extends Animal{}
关联关系has a
I has a pen,i has an apple
张三 has a pen
public class Person{private Apple apple} public class Apple{}在一个类的里面有另一个类
相比来说,泛化关系耦合度高于关联关系,优先选择关联关系

类和类之间的关系有六种,泛化关系(继承),关联关系
泛化关系Cat is a Animal
public class Animal{} public class Cat extends Animal{}
关联关系has a
I has a pen,i has an apple
张三 has a pen
public class Person{private Apple apple} public class Apple{}在一个类的里面有另一个类
相比来说,泛化关系耦合度高于关联关系,优先选择关联关系

package com.powernode.proxy.service;

import org.springframework.stereotype.Service;

@Service
public interface OrderService//订单业务接口,也是代理对象和目标对象的公共接口
{
    //生成订单
    void generate();
    //修改订单信息
    void Modify();
    //查看订单明细
    void detail();
}

package com.powernode.proxy.service;

import org.springframework.stereotype.Service;

@Service
public interface OrderService//订单业务接口,也是代理对象和目标对象的公共接口
{
    //生成订单
    void generate();
    //修改订单信息
    void Modify();
    //查看订单明细
    void detail();
}

package com.powernode.proxy.service.impl;

import com.powernode.proxy.service.OrderService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

//缺点一:违背了OCP开闭原则,在运行良好的代码上进行了硬编码修改
//缺点二:代码没有得到复用,相同的代码写了很多遍

@Service
public class OrderServiceImpl implements OrderService
{
    private static final Logger logger = LoggerFactory.getLogger(OrderServiceImpl.class);
    @Override
    public void generate()//目标方法
    {
        //模拟网络延迟,模拟生成延迟
        try {
            Thread.sleep(1234);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("订单已生成");
    }

    @Override
    public void Modify()
    {
        //模拟网络延迟,模拟生成延迟
        try {
            Thread.sleep(456);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("订单已修改");
    }

    @Override
    public void detail()
    {
        //模拟网络延迟,模拟生成延迟
        try {
            Thread.sleep(111);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("订单详情如下");
    }
}

package com.powernode.proxy.service.impl;

import com.powernode.proxy.service.OrderService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

//缺点一:违背了OCP开闭原则,在运行良好的代码上进行了硬编码修改
//缺点二:代码没有得到复用,相同的代码写了很多遍

@Service
public class OrderServiceImpl implements OrderService
{
    private static final Logger logger = LoggerFactory.getLogger(OrderServiceImpl.class);
    @Override
    public void generate()//目标方法
    {
        //模拟网络延迟,模拟生成延迟
        try {
            Thread.sleep(1234);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("订单已生成");
    }

    @Override
    public void Modify()
    {
        //模拟网络延迟,模拟生成延迟
        try {
            Thread.sleep(456);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("订单已修改");
    }

    @Override
    public void detail()
    {
        //模拟网络延迟,模拟生成延迟
        try {
            Thread.sleep(111);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("订单详情如下");
    }
}

package com.powernode.proxy.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class OrderServiceProxy implements OrderService
//代理对象和目标对象都要实现同样的接口,因为他们需要具有相同的功能
//要保障在客户端处两者没有区别,因为客户端处是面向接口编程的
{
    private static final Logger logger = LoggerFactory.getLogger(OrderServiceProxy.class);
    //将目标对象作为代理对象的一个属性,这种关系叫做关联关系,比继承关系耦合度低
    //这就是目标对象,目标对象一定是实现了OrderService接口的,这里要写一个公共接口,因为接口耦合度低
    private OrderService orderService;
    //创建代理对象的时候,传一个目标对象给代理对象
    public OrderServiceProxy(OrderService orderService)
    {
        this.orderService = orderService;
    }
    //我们还是要指向目标对象的目标方法处
    @Override
    public void generate()//代理方法
    {
        //增强功能
        long begin = System.currentTimeMillis();
        //调用目标对象的目标方法
        orderService.generate();
        long end = System.currentTimeMillis();
        long time = end - begin;
        logger.info("耗时" + time);
    }

    @Override
    public void Modify()
    {
        long begin = System.currentTimeMillis();
        //调用目标对象的目标方法
        orderService.Modify();
        long end = System.currentTimeMillis();
        long time = end - begin;
        logger.info("耗时" + time);
    }

    @Override
    public void detail()
    {
        long begin = System.currentTimeMillis();
        //调用目标对象的目标方法
        orderService.detail();
        long end = System.currentTimeMillis();
        long time = end - begin;
        logger.info("耗时" + time);
    }
}

package com.powernode.proxy.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class OrderServiceProxy implements OrderService
//代理对象和目标对象都要实现同样的接口,因为他们需要具有相同的功能
//要保障在客户端处两者没有区别,因为客户端处是面向接口编程的
{
    private static final Logger logger = LoggerFactory.getLogger(OrderServiceProxy.class);
    //将目标对象作为代理对象的一个属性,这种关系叫做关联关系,比继承关系耦合度低
    //这就是目标对象,目标对象一定是实现了OrderService接口的,这里要写一个公共接口,因为接口耦合度低
    private OrderService orderService;
    //创建代理对象的时候,传一个目标对象给代理对象
    public OrderServiceProxy(OrderService orderService)
    {
        this.orderService = orderService;
    }
    //我们还是要指向目标对象的目标方法处
    @Override
    public void generate()//代理方法
    {
        //增强功能
        long begin = System.currentTimeMillis();
        //调用目标对象的目标方法
        orderService.generate();
        long end = System.currentTimeMillis();
        long time = end - begin;
        logger.info("耗时" + time);
    }

    @Override
    public void Modify()
    {
        long begin = System.currentTimeMillis();
        //调用目标对象的目标方法
        orderService.Modify();
        long end = System.currentTimeMillis();
        long time = end - begin;
        logger.info("耗时" + time);
    }

    @Override
    public void detail()
    {
        long begin = System.currentTimeMillis();
        //调用目标对象的目标方法
        orderService.detail();
        long end = System.currentTimeMillis();
        long time = end - begin;
        logger.info("耗时" + time);
    }
}

package com.powernode.proxy.client;

import com.powernode.proxy.Spring6Config;
import com.powernode.proxy.service.OrderService;
import com.powernode.proxy.service.OrderServiceProxy;
import com.powernode.proxy.service.impl.OrderServiceImpl;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test
{
    public static void main(String[] args)
    {
//        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Spring6Config.class);
//        OrderService orderService = context.getBean("orderServiceImpl", OrderServiceImpl.class);
//        orderService.detail();
//        orderService.generate();
//        orderService.Modify();
        //缺点1:虽然解决了OCP开闭原则,但是这种方法会导致耦合程度很高,继承关系是一种耦合度非常高的关系,不建议使用
        //缺点2:代码没有得到复用
//        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Spring6Config.class);
//        OrderService orderService = context.getBean("orderServiceImplSub", OrderServiceImplSub.class);
//        orderService.detail();
//        orderService.generate();
//        orderService.Modify();
        //创建目标对象
        //代理模式的优点:解决了OCP开闭问题
        //代理模式的缺点:类爆炸,假设系统内有1000个这样的类,每个接口都要对应一个代理类,不好维护
        //怎么解决,使用动态代理(字节码生成技术)还是代理模式,添加了字节码生成技术,在内存中动态生成字节码动态代理技术
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Spring6Config.class);
        OrderService orderService = context.getBean("orderServiceImpl", OrderServiceImpl.class);
        //创建代理对象
        OrderService OS = new OrderServiceProxy(orderService);
        //调用代理对象的代理方法
        OS.generate();
        OS.Modify();
        OS.detail();
    }
}

package com.powernode.proxy.client;

import com.powernode.proxy.Spring6Config;
import com.powernode.proxy.service.OrderService;
import com.powernode.proxy.service.OrderServiceProxy;
import com.powernode.proxy.service.impl.OrderServiceImpl;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test
{
    public static void main(String[] args)
    {
//        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Spring6Config.class);
//        OrderService orderService = context.getBean("orderServiceImpl", OrderServiceImpl.class);
//        orderService.detail();
//        orderService.generate();
//        orderService.Modify();
        //缺点1:虽然解决了OCP开闭原则,但是这种方法会导致耦合程度很高,继承关系是一种耦合度非常高的关系,不建议使用
        //缺点2:代码没有得到复用
//        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Spring6Config.class);
//        OrderService orderService = context.getBean("orderServiceImplSub", OrderServiceImplSub.class);
//        orderService.detail();
//        orderService.generate();
//        orderService.Modify();
        //创建目标对象
        //代理模式的优点:解决了OCP开闭问题
        //代理模式的缺点:类爆炸,假设系统内有1000个这样的类,每个接口都要对应一个代理类,不好维护
        //怎么解决,使用动态代理(字节码生成技术)还是代理模式,添加了字节码生成技术,在内存中动态生成字节码动态代理技术
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Spring6Config.class);
        OrderService orderService = context.getBean("orderServiceImpl", OrderServiceImpl.class);
        //创建代理对象
        OrderService OS = new OrderServiceProxy(orderService);
        //调用代理对象的代理方法
        OS.generate();
        OS.Modify();
        OS.detail();
    }
}