【Java之设计模式】

已于 2024-03-18 13:00:47 修改
阅读量945 收藏 26
点赞数 23
分类专栏： # Java核心技术精选 文章标签： java 设计模式 开发语言
于 2024-03-18 13:00:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z140359/article/details/136805923
版权

设计模式

单例singleton

应用程序在使用过程中每一次获取的实例都是同一个，主要是解决内存空间浪费的问题。有些对象全局公用一个即可

单例的的要求

1.构造方法私有

2.提供静态方法能够获得其实例

3.提供一个自身类型的静态成员变量

单例的实现

线程安全的立即加载–>静态成员变量实例化

public class MySingleton {

    // 静态成员变量直接实例化是什么时候执行的 → 类加载的时候执行的
    // 就是在第一次返回实例之前
    private static MySingleton mySingleton = new MySingleton();

    private MySingleton() {}

    public static MySingleton getInstance() {
        //类中的静态方法里能否使用其私有的构造方法 → 可以

        // 实例化的代码只执行一次，第一次返回实例之前
        //MySingleton mySingleton = new MySingleton();
        return mySingleton;
    }
}

线程安全的立即加载–>静态代码块

public class MySingleton2 {

    // 静态成员变量直接实例化是什么时候执行的 → 类加载的时候执行的
    // 就是在第一次返回实例之前
    private static MySingleton2 mySingleton;
    // 静态代码块也是类加载的时候执行 --> 只执行一次
    static {
        mySingleton = new MySingleton2();
    }

    private MySingleton2() {
    }

    public static MySingleton2 getInstance() {
        //类中的静态方法里能否使用其私有的构造方法 → 可以

        // 实例化的代码只执行一次，第一次返回实例之前
        //MySingleton mySingleton = new MySingleton();
        return mySingleton;
    }
}

静态成员变量和静态代码块都是在类加载的时候立即加载，无论如何都只会加载一次，因此可以保证线程安全

线程安全的懒加载–>加锁

public class MySingleton4 {


    // 就是在第一次返回实例之前
    private static MySingleton4 mySingleton;


    private MySingleton4() {
    }

    public static synchronized MySingleton4 getInstance() {
        //类中的静态方法里能否使用其私有的构造方法 → 可以

        // 实例化的代码只执行一次，第一次返回实例之前
        //MySingleton mySingleton = new MySingleton();
        //我们要在第一次调用方法的时候完成实例化
        // 我们如何知道这是第一次调用这个方法 → 有什么特征
        if (mySingleton == null) { //它没有实例化 --> 第一次调用方法
            mySingleton = new MySingleton4();
        }

        return mySingleton;
    }
}

线程安全的懒加载 --> 静态内部类

解决效率问题就需要不加锁，而保证线程安全需要使用静态的成员变量，因此可以使用静态内部类来完成实例化

public class MySingleton6 {



    private MySingleton6(){}

    public static MySingleton6 getInstance() {
        // 懒加载 → 实例化的代码要在getInstance方法里面
        // 内部类提供一个方法让外部类能够获得其实例
        return Inner.getInnerInstance();
    }

    static class Inner{
        private static MySingleton6 mySingleton6 = new MySingleton6();
        /*static {
            mySingleton6 = new MySingleton6();
        }*/
        public static MySingleton6 getInnerInstance() {
            return mySingleton6;
        }

    }
}

工厂

工厂类一般类名中有Factory

工厂的作用是隐藏实现的细节，获得实例的时候不需要关心实例化的细节过程

简单工厂

  • 根据传入的参数生成不同的实例对象
public class Animal2Factory {

    public Animal2 create(String name) {
        if ("pig".equals(name)) {
            return new Pig();
        } else if ("sheep".equals(name)) {
            return new Sheep();
        } else if ("chicken".equals(name)) {
            return new Chicken();
        } //开闭原则 
        return null;
    }
}

工厂方法

将工厂定义为接口，如果需要返回新的类型的实例，去新增一个实现了工厂类接口的实体类

public interface AnimalFactory {

    //接口中提供规范，提供一个返回值为Animal的方法
    public Animal create();
}
/**
 * @author stone
 * @date 2021/12/23 11:33
 */
public class PigFactory implements AnimalFactory{
    @Override
    public Animal create() {
        return new Pig();
    }
}

工厂的分类

根据工厂中的生产方法是静态方法还非静态方法来分类

静态工厂里的生产方法是静态方法，实例工厂里的方法是非静态方法

public class MyTest {

    @Test
    public void mytest1() {
        // 要先创建一个工厂的实例 → 实例工厂
        Animal2Factory factory = new Animal2Factory();
        Animal2 chicken = factory.create("chicken");
        System.out.println(chicken instanceof Chicken); //true
    }

    @Test
    public void mytest2() {
        // 可以直接调用静态方法 → 静态工厂
        Animal pig = AnimalFactory.create("pig");
    }
}

建造者

建造者的侧重点在于提供方法，让你设计细节

public class MoneyBuilder {

    // 成员变量实例化，当前类执行实例化调用构造方法的时候执行
    // 当我们去new了一个moneyBuilder的时候，同时new了一个money
    Money money = new Money(); // 在set方法和build方法之前执行的

    // 如果使用的是同一个builder就意味着是对同一个money做修饰
    public void setMoneyType(String type) {
        money.setType(type);
    }

    public void setMoneyFaceValue(int value) {
        money.setFaceValue(value);
    }

    public Money build() {
        // 要在build方法之前给实例设置参数
        // 实例化过程要在build方法之前
        return money;
    }
}

@Data
public class Money {
    String type;
    int faceValue;
}

代理

匿名内部类：定义一个类，并获得这个类的实例，一般用于直接获取抽象类或者接口

new Interface/AbstractClass(){
    //实现里面的方法
}

委托方：需要执行实际方法的类

代理方：帮助委托方做本身要做的事，除此之外还进行了额外的增强

代理的主要作用就是对多个已有的功能做相同的扩展

将需要反复执行的繁琐的内容提取出来，对一个类中所有的方法进行增强

代理的分类

  • 静态代理
  • 动态代理
    • JDK动态代理
    • CGlib动态代理

静态代理：代理类需要我们自己写；

动态代理：代理类是动态生成的，不需要我们自己去写

静态代理

儿子给父亲买早餐

委托方：Father

代理方：Son

谁的方法需要被增强，谁就是委托方

代理类中需要包含委托类的成员变量，要么维护一个对象，要么通过继承

代理类中的方法与委托类中定义的方法需要相同：修饰符、返回值、方法名、参数

所以一般使用接口来制定规范

public class Father {

    public void buyBreakFast() {
        System.out.println("早餐");
    }

    public void buyLunch() {
        System.out.println("中餐");
    }

    public void buySupper() {
        System.out.println("晚餐");
    }
}

public class Son {
//通过维护一个为委托类的对象
    Father f = new Father();
    public void buyBreakFast() {
        f.buyBreakFast();
        Stronger();
    }

    public void buyLunch() {
        f.buyLunch();
        Stronger();
    }

    public void buySupper() {
        f.buySupper();
        Stronger();
    }

    public void Stronger(){
        System.out.println("加个蛋");
    }
}

动态代理

代理类的方法：

1.委托类的方法

2.增强的方法

动态代理通过InvocationHandler中的invoke方法来调用委托类中的方法，并可以在其中实现自定义的增强

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

JDK中的动态代理

获得代理对象的步骤：

1.类加载器

2.委托类所实现的接口数组–>委托类必须要实现接口–>代理类实现了和委托类相同的接口–>通过接口保证方法的规范性

3.获取InvocationHandler的实例

​ 通过实现类来获取实例

​ 匿名内部类

4.接收代理对象：使用委托类实现的接口来接收，因为代理类同样也实现了该接口

自定义的Invocation

public class CustomHandler implements InvocationHandler {
    Father f = new Father();
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        method.invoke(f,args);
        System.out.println("来三斤牛肉");
        return null;
    }
}

@Test
public void myTest1(){
    FatherInterface f = (FatherInterface) Proxy.newProxyInstance(Father.class.getClassLoader(), Father.class.getInterfaces(),
            new CustomHandler());
    f.buyBreakFast();
    f.buyLunch();
    f.buySupper();
    f.buyFood("吃鸡");
    f.buyFoods("可乐","雪碧");
}

使用代理实例化时需要3个参数：第一个是类加载器，第二个是委托类接口列表，第三个是handler

JDK中实现动态代理的过程：

package proxy.dynamic;

import java.lang.reflect.Method;

//动态代理类要和委托类实现一样的接口
//模仿jdk来实现自定义的动态代理对象
public class JdkProxy implements FatherInterface {
    Method m1;
    Method m2;
    Method m3;
    Method m4;
    Method m5;
    {
        try {
            m1 = Class.forName("proxy.dynamic.Father").getDeclaredMethod("buyBreakFast");
            m2 = Class.forName("proxy.dynamic.Father").getDeclaredMethod("buyLunch");
            m3 = Class.forName("proxy.dynamic.Father").getDeclaredMethod("buySupper");
            m4 = Class.forName("proxy.dynamic.Father").getDeclaredMethod("buyFood",String.class);
            m5 = Class.forName("proxy.dynamic.Father").getDeclaredMethod("buyFoods",String.class,String.class);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    CustomHandler handler = new CustomHandler();

    @Override
    public void buyBreakFast() {
        try {
            handler.invoke(this,m1,null);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    @Override
    public void buyLunch()   {
        try {
            handler.invoke(this,m2,null);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    @Override
    public void buySupper() {
        try {
            handler.invoke(this,m3,null);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    @Override
    public void buyFood(String food) {
        try {
            handler.invoke(this,m4,new Object[]{food});
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    @Override
    public void buyFoods(String food1, String food2) {
        try {
            handler.invoke(this,m5,new Object[]{food1,food2});
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}

在使用debug的时候要注意debug会自动调用tostring方法

CGlib动态代理

仍然是使用InvocationHandler来生成代理对象

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.12</version>
</dependency>

    @Test
    public void test1(){
        Father f = new Father();
        FatherInterface fProxy = (FatherInterface) Enhancer.create(Father.class, new InvocationHandler() {
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                method.invoke(f, objects);
                System.out.println("我是增强方法");
                return null;
            }
        });
        fProxy.buyFoods("苹果","香蕉");
    }

第一个参数仍然是委托类的.class文件，第二个是InvocationHandler，使用匿名内部类来实现

在使用CGlib的使用，接收代理对象可以使用委托类本身，也可以使用接口

一般使用接口，兼容性会更好

代理类的字节码文件

jdk
// 使用main方法，执行过程中会有一个工作路径
public static void main(String[] args) {    //通知应用程序把字节码保存起来，默认是不保存 → com.sun.proxy    // ProxyGenerator   
System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");}

生成的代理类

public final class $Proxy0 extends Proxy implements JingTianInterface {
    private static Method m6;
    static {
        try {
            m6 = Class.forName("com.cskaoyan.bean.JingTianInterface").getMethod("buyDoubleFood", Class.forName("java.lang.String"), Class.forName("java.lang.String"));
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
    public final void buyDoubleFood(String var1, String var2) throws  {
        try {
            super.h.invoke(this, m6, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }
}
cglib
public static void main(String[] args) {
    //字节码文件也是默认不保存 → value写的是路径
    // 和委托类相同的包目录
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\WorkSpace\\j36_workspace\\codes\\day03-proxy-spring\\demo4-proxy-save");
}

public class JingTian$$EnhancerByCGLIB$$75eacb68 extends JingTian implements Factory {
    private InvocationHandler CGLIB$CALLBACK_0;
    private static final Method CGLIB$buyFood$1;
    static void CGLIB$STATICHOOK1() {
        CGLIB$buyFood$1 = Class.forName("com.cskaoyan.bean.JingTian").getDeclaredMethod("buyFood", Class.forName("java.lang.String"));    
    }
	public final void buyFood(String var1) {
        try {
            InvocationHandler var10000 = this.CGLIB$CALLBACK_0;
            if (var10000 == null) {
                CGLIB$BIND_CALLBACKS(this);
                var10000 = this.CGLIB$CALLBACK_0;
            }
            var10000.invoke(this, CGLIB$buyFood$1, new Object[]{var1});
        } catch (Error | RuntimeException var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
}
Bigcoding
关注
  • 23
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java之设计模式
12-25
设计模式的学习 ******
java设计模式课程设计
10-13
使用5种设计模式完成的一个点单系统，显示不同系列下的所有商品，点击选择冰度甜度之后添加到订单中，计算总金额，下单之后发送订单到门店的后厨制作商品。使用了抽象工厂模式、装饰模式、单例模式、代理模式、原型...
Java 经典设计模式讲解以及项目实战
06-14
Java 经典设计模式讲解以及项目实战 设计模式简介：主要介绍各种设计模式的概念和运用场景等 设计模式综合运用：主要是笔者在实际工作中运用到的一些设计模式综合运用事例的提炼 Spring设计模式简介：主要是讲述...
Java扩大Java设计模式
02-16
本文工程主要计划以下几大块，希望大家也可以一起加入进来，扩大Java设计模式这块的运用场景的提炼。 1. 设计模式简介：主要介绍各种设计模式的概念和运用场景等 2. 设计模式综合运用：主要是笔者在实际工作中运用...
java环境部署
JiuMeilove的博客
06-04 434
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
java中Overload和Override的区别
codedadi的博客
06-04 634
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
JavaScript第九讲：BOM编程
星途码客的博客
06-04 1472
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
C语言数字全排列生成器
a15884871479的博客
06-05 729
这个代码的功能是生成并打印出从1到N的所有整数的全排列，并计算总共有多少种排列方式
JVM内存管理
joedan0104的专栏
06-05 226
2.JVM内存怎么分区？为什么要进行分区管理？3.分区数据怎么管理？
设计模式之装饰器模式
丿微风乍起的博客
06-05 1136
装饰器模式是一种结构型设计模式，它允许我们在不改变原有对象结构的情况下，动态地给对象增加一些职责（即增加其额外功能）。其核心在于通过组合而非继承的方式来扩展对象的功能。Component: 这是抽象组件接口，所有的具体组件和装饰器都必须实现这个接口。Concrete Component: 具体组件，这是我们要装饰的基本对象，它实现了Component接口。Decorator: 抽象装饰器，也是实现Component接口的，它包含一个对Component类型的引用，通常在构造函数中初始化。
拼图小游戏
lazy_girl_666的博客
06-03 736
把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制。
Java Map接口 - HashMap类
IT深耕十余载，大道之简
06-05 174
当哈希表中的条目数超过容量与负载因子的乘积时，哈希表会重新调整大小（rehash）。是有序的或保证顺序的稳定性）。如果在迭代期间对映射进行了修改（结构修改，如添加或删除元素），则迭代可能会抛出。如果你打算在多线程环境中使用它，你需要额外的同步措施，或者可以考虑使用。不保证映射的顺序，特别是它不保证顺序会随着时间的推移而保持不变。操作（假设哈希函数是均匀的，并且表有足够的容量）。值（value）可以是重复的，并且可以为。提供了多种方法来遍历它的键、值或键值对，如。中，键（key）必须是唯一的，并且不能为。
线程池的工作原理
qq_42301955的博客
06-05 553
线程池总结
Springboot vue3 elementplus 景点评论数据分析与可视化系统源码
scian22的博客
06-04 451
系统演示:链接：https://pan.baidu.com/s/1J056R4rYji_mc4gwteZEzg?
Javascript-对象
m0_63019813的博客
06-05 311
对象的创建
【冲刺秋招，许愿offer】第 一 天
最新发布
Panci_的博客
06-08 126
现在技术还是菜的一批，中等难度的算法题很难一次(一小时)解出来，项目稍微一深挖或者问点视频中没讲到的扩展性问题直接拉跨化身聋哑人，牛客面经越看越焦虑，里面问到的八股也不是都会，哎，感觉给我大厂面试机会也是秒挂，前面摆烂两个月了，秋招将至，再冲击一下，希望能拿到个好点的offer。逻辑过期：加一个字段来表示是否过期，业务逻辑变为，看判断是否过期，过期，获取锁，开启子线程进行缓存重建，其他线程以及主线哼返回旧数据。缓存击穿问题是由于热点Key过期了，导致大量请求到达数据库，可以用互斥锁或者逻辑过期。
Java基础 - switch case 语句
qq_46254997的博客
06-05 189
Java基础 - switch case 语句
java如何实现请求
m0_75032658的博客
06-03 158
如果你想要向数据库发送请求（如查询、更新等），你可以使用Java的JDBC（Java Database Connectivity）API。在Java中，实现请求通常指的是通过网络发送HTTP请求到服务器，或者通过其他协议（如JDBC）向数据库发送请求。注意：在使用Apache HttpClient之前，你需要将其添加到你的项目中。是Java标准库中的一个类，它允许你发送HTTP请求并接收响应。以下是一个简单的示例，展示如何使用。请注意，对于数据库连接，你需要添加相应的JDBC驱动依赖到你的项目中。
Spring运维之boot项目打包jar和插件运行并且设置启动时临时属性和自定义配置文件
多多的博客
06-04 1157
配置文件默认都是啊application开头的可以改的写一个简单的boot项目控制层用rest模式开发重命名配置文件但这样就不会提示了运行后后会存在找到其他配置文件的情况 我们要到文件资源管理器里面去查找我们可以在boot项目配置里面去手动设置指定配置文件yml不生效的大概率port:后面没有空格如果配置文件是yml修改填入的参数有所不同加入多个文件参数不同 用逗号隔开当我们配置多个配置文件的时候是后面一个配置文件里面的配置生效小结这都是boot官方文档中标注的知识。
java设计模式之外观模式
09-20
外观模式是一种结构型设计模式，它提供了一个统一的接口，用于访问子系统中的一组接口。通过外观模式，客户端可以通过简单的接口来访问复杂的子系统，而不需要了解子系统的具体实现细节。外观模式通过将客户端与子...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值