java中常见的设计模式

最新推荐文章于 2024-06-15 10:13:23 发布

余笙zh

最新推荐文章于 2024-06-15 10:13:23 发布

阅读量223

点赞数

文章标签：设计模式 java

本文链接：https://blog.csdn.net/m0_73503454/article/details/134399408

版权

最早概念是在建筑领域产生的，后来被引入到软件开发领域。

模式是解决一类问题的固定写法，一个模式用来解决一种问题，经过反复优化，最终得出来的。之前的程序员们，在工作中对某一类问题解决方式进行总结归纳，一种问题对应着一个模式。设计模式就是在面向对象的基础上，更加合理的组织类与类之间的关系。

为什么学习设计模式?

学习别人的经验，拿来为我们所用，提高编程设计能力，让程序设计更加标准合理，提高开发效率。提高程序的维护性，能够看懂复杂的源码。

1、单例模式

解决的问题：在一个程序中，一个类只能创建一个对象。举例：windows任务管理器，只能打开一个。

实现：把构造方法私有化，在其他类中不能访问了，不能创建对象。可以在单例类中，向外界提供一个方法，访问到唯一的单例对象。

1.饿汉式单例(急切式)

在类加载时就创建唯一的对象，不存在线程安全问题

public class Window {
    //饿汉式单例, 静态的成员在类被加载时,就将唯一的window对象创建
    //没有任何的线程安全问题
    private static  Window  window = new Window();
    private Window(){}
	//调用getWindow，返回对象即可
    public static Window getWindow(){
        return window;
    }
}

public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(Window.getWindow());
            }).start();
        }
    }
}

Runtime类属于典型的单例设计，从源码中可以看出是饿汉式单例。利用Runtime类可以启动新的进程或进行相关运行时环境的操作。比如，取得内存空间以及释放垃圾空间。

Runtime.getRuntime();

2.懒汉式

在类加载的时候不创建对象，在使用时创建，生成对象的数量就需要我们自己来进行控制。

但是会出现线程安全问题：在多线程访问时，可能会有多个线程同时进行到if，就会创建出多个对象。

线程安全问题的解决：

1、给方法加锁，虽然可以解决，但是效率低，一次只能有一个线程进入获取。

public class Window {
    //在类加载的时候不创建改类的对象，在第一次获取单例对象时创建 
    private static  Window  window=null;
    private Window(){}

    public static  synchronized  Window getWindow(){
         if(window==null){
             window = new Window();
         }
        return window;
    }
}

public class Test {
    public static void main(String[] args) {
       for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(Window.getWindow());
            }).start();
        }
    }
}

2、给代码块加锁，双重检索+volatile

window = new Window();这一句代码可以分为3条指令执行，万一指令重排序，会导致出现一个半成品对象返回。

为什么双重检索？先确保有一个线程把对象new出来，后面的线程来了之后，只要走第一个判断就好了。一旦对象创建之后，之后效率就变高了，不用进入同步代码块里面了。

public class Window {
    //禁止整个过程中指令重排
    private static volatile  Window  window=null;
    private Window(){}
    
    public static  Window getWindow(){
        if(window==null){//如果没有的话，相当于给方法加锁
            synchronized(Window.class){
               if(window == null){//如果没有的话，相当于没有加锁
                   window = new Window();
               }//一旦对象创建之后，之后效率就变高了，不用进入同步代码块里面了
            }
        }
        return window;
    }
}

2、工厂模式

工厂--->生产对象--->spring（把创建对象的权利反转给spring框架，把创建对象和使用对象分离）

有一个工厂专门负责创建对象，使用对象时只需要找对应的工厂。根据我们产生对象的场景，需求的不同，又分为：简单工厂模式、工厂方法模式、抽象工厂模式。

1.简单工厂模式

工厂只有一个。一个工厂类负责同一类所有产品的创建；但是扩展不方便，如果增加或减少产品时，需要修改工厂类，违背了开闭原则。

该模式中包含的角色：

工厂：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类提供静态方法，可以被外界直接调用，创建所需的产品对象。

抽象产品：所有对象的父类，描述所有实例共有的接口。可以是抽象类或接口。

具体产品：是简单工厂模式的创建目标

优点：客户端不负责对象的创建，而是由专门的工厂类完成。客户端只负责对象的调用，实现了创建和调用的分离

缺点：扩展不方便，如果增加和减少子类，要修改简单工厂类，违反了开闭原则。

public interface Car {
    void run();
}

public class Aodi implements Car{
    @Override
    public void run() {
        System.out.println("奥迪汽车行驶");
    }
}

public class Bmw implements Car{
    @Override
    public void run() {
        System.out.println("宝马汽车行驶");
    }
}

public class CarFactory {
    public static Car createCar(String name){
    if(name.equals("aodi")){
        Aodi aodi = new Aodi();
        return aodi;
    }
    if(name.equals("bmw")){
        return new Bmw();
    }
    return null;
    }
}

public class Test {
    public static void main(String[] args) {
        Car bmw  = CarFactory.createCar("bmw");
        Car aodi  = CarFactory.createCar("aodi");
        bmw.run();
        aodi.run();
    }
}

2.工厂方法模式

添加一个抽象工厂，具体工厂实现抽象工厂。一个具体工厂负责创建一个具体的产品，即使这些产品是有联系的，也必须由不同的工厂分别创建。如果产品增加或减少，只增加产品子类和工厂子类，符合开闭原则。

抽象工厂：工厂方法模式的核心，任何在模式中创建的对象的工厂类必须实现这个接口。
具体工厂：实现抽象工厂接口的具体工厂类。
抽象产品：产品对象的共同父类或接口。
具体产品：实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往——对应。

好处：符合开闭原则。若增加和减少产品子类，只增加产品子类和工厂子类，不需要修改其他产品。

缺点：需要额外的编写代码，增加了工作量。

适用场景：所有的产品子类是同一类的、比较多的。

public interface Car {
	void run();
}

public class Aodi implements Car {
    @Override
    public void run() {
        System.out.println("奥迪汽车行驶");
    }
}

public class Bmw implements Car {
    @Override
    public void run() {
        System.out.println("宝马汽车行驶");
    }
}

public interface CarFactory {
	Car createCar();
}

public class AodiFactory implements  CarFactory{
    @Override
    public Car createCar() {
        return new Aodi();
    }
}

public class BmwFactory implements  CarFactory{
    @Override
    public Car createCar() {
        return new Bmw();
    }
}

3.抽象工厂模式

一个工厂创建一个系列的产品，可以造出这个厂家所有的产品。例如华为工厂可以创建汽车产品、手机产品

抽象工厂：同一品牌中所有系列的产品
具体工厂：负责创建同一个品牌的产品。
抽象产品
具体产品

public interface AbstractFactory {
    Car getCar();
    Phone getPhone();
}

public class AodiFactory implements  AbstractFactory{
    @Override
    public Car getCar() {
        return new AodiCar();
    }

    @Override
    public Phone getPhone() {
        return new AodiPhone();
    }
}

public class BmwFactory implements AbstractFactory{
    @Override
    public Car getCar() {
        return new BmwCar();
    }

    @Override
    public Phone getPhone() {
        return new BmwPhone();
    }
}

public interface Car {
	void run();
}

public interface Phone {
	void  call();
}

public class AodiCar implements Car{
    @Override
    public void run() {
        System.out.println("奥迪汽车行驶");
    }
}

public class AodiPhone implements Phone{
    @Override
    public void call() {
        System.out.println("奥迪手机打电话");
    }
}

public class Test {
    public static void main(String[] args) {
        AbstractFactory aodiFactory = new AodiFactory();
        Car aodiCar = aodiFactory.getCar();
        Phone aodiphone = aodiFactory.getPhone();
              aodiCar.run();
              aodiphone.call();

        AbstractFactory bmwFactory = new BmwFactory();
        Car bmwCar = bmwFactory.getCar();
        Phone bmwPhone = bmwFactory.getPhone();
              bmwCar.run();
              bmwPhone.call();
    }
}

3、原型模式

spring创建bean作用域:

singleton：单例bean，一个类创建一个对象，spring启动时就创建单例对象。
prototype: 原型的（多例），每次获取时，都会创建一个新的对象。

创建一些内容相同的对象，如果每次去new就比较耗时间。可以造出来一个，然后对对象进行克隆，提高创建的效率。（注意深克隆和浅克隆）

4、代理模式

最早在spring框架中的aop提到。面向切面编程：可以对业务逻辑和非业务逻辑进行隔离，将程序中的一些非业务代码进行提取，然后让代理对象去调用公共的方法，就可以做到在不需要修改原来代码的情况下，为程序添加额外的功能。

底层实现：使用的是动态代理模式。是通过一个代理对象来实现对非业务代码进行调用的。告诉代理对象，调用哪个方法时，让代理对象去帮助我们调用哪个方法。

代理模式：分为静态代理和动态代理。

1.静态代理

目标对象（汽车厂卖汽车，最终要具体干这件事的主体）不能/不方便操作某些事情，这时可以为目标对象提供一个代理对象，代理对象代表目标对象。在调用目标对象方法时，可以为目标对象添加一些额外功能。

角色：

抽象主体(接口)
真实主体(目标对象)：实际做事情
代理对象：代表目标对象

静态代理实现：目标对象和代理对象必须实现相同的接口。如果需要代理新的目标，需要对代理对象进行修改，必须添加实现新的接口，这样违背开闭原则，扩展起来不方便。一般框架中不使用，自己在一些简单的功能中可以使用。

public class StaticProxy implements SellCar,SellPhone{}

//抽象操作定义 卖东西
public interface Sell {
     void sell();
}

//汽车厂
public class CarFactoryImpl implements Sell {
    @Override
    public void sell() {
        System.out.println("汽车厂卖汽车");
    }
}

//静态代理,实际中很少使用静态代理,因为其代理类实现的接口必须与目标类实现接口一致,扩展起来就比较麻烦
public class StaticProxy  implements Sell {
    Sell sell;
    public StaticProxy(Sell sell) {
        this.sell = sell;
    }

    //代理对象中的方法
    @Override
    public void sell() {
        System.out.println("汽车介绍");
        sell.sell();//最终执行者还是目标对象
        System.out.println("办理手续");
    }
}

public class Test {
    public static void main(String[] args) {
        Sell carFactory = new CarFactoryImpl();
        //创建汽车厂代理对象
        StaticProxy staticProxy = new StaticProxy(carFactory);
        staticProxy.sell();//看似访问的是代理类，其实是目标对象来做的
    }
}
/*
汽车介绍
汽车厂卖汽车
办理手续 
*/

2.动态代理

为目标类动态的生成代理对象，这样就可以代理任意的目标类。动态代理分为：jdk代理和cglib代理。

在spring框架中两种代理方式都支持，如果一个类实现了接口，就采用jdk代理；如果一个类没有实现接口，就采用的cglib代理。

（1）jdk代理

底层使用的反射机制，动态获取目标类对象所实现的接口，然后为目标类动态生成一个代理对象，并动态获取到要调用的方法，最终调用目标对象中的方法。

动态代理可以代理任意的目标类，但是目标类必须要实现一个接口。

动态代理器中，可以传进来任意的目标类。在getProxy方法中，获取到目标对象的接口、拿到目标对象的信息，最终为目标对象生成代理对象。代理对象实现了目标对象的接口，最后代理对象调用目标类的接口中的sell方法，其实会调用代理器类中的invoke方法。然后通过反射机制，调用目标对象中的方法。

//抽象操作定义 卖东西
public interface Sell {
     void sell();
}

//汽车厂
public class CarFactoryImpl implements Sell {
    @Override
    public void sell() {
        System.out.println("汽车厂卖汽车");
    }
}

/*
  动态代理类
  代理类不需要实现与目标类相同的接口,这样就可以代理任意的目标类
  但是是有要求的,目标类必需实现接口,此种方式是动态代理的实现方式之一: jdk代理 是一种纯反射机制实现(动态获取目标类接口方法)
 */
public class DynamicProxy implements InvocationHandler {

     Object object;//真实对象,接收任何的目标类对象

    public DynamicProxy(Object object) {
        this.object = object;
    }

    /*
       在代理类中调用目标类中的具体方法,
       动态的将代理动态对象,目标类中要调用的方法,及方法中的参数传递过来
       Method method  动态获取的真正要执行的方法
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("之前开启事务");
        method.invoke(object);//调用目标对象中的sell方法
        System.out.println("之后提交事务");
        return proxy;
    }

    //根据目标对象生成代理对象
    public Object getProxy(){
          return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
    }
}

public class Test {
    public static void main(String[] args) {
          CarFactoryImpl carFactory = new CarFactoryImpl();
          DynamicProxy dtproxy =  new DynamicProxy(carFactory);//创建动态代理器
          //这才是真正的创建动态代理对象   获取目标类所实现的接口
          Sell sell =(Sell)dtproxy.getProxy();//代理对象实现了目标对象的接口
          sell.sell();//使用代理对象调用接口中的方法,获取当前调用的方法,最终调用invoke方法
    }
}

（2）cglib代理

针对jdk代理必须要让目标类实现接口这一问题，spring后来引入chlib技术。

cglib代理：目标类不需要实现接口，在底层以生成字节码的方式，为目标类动态生成子类对象。在调用目标类方法时，对方法进行拦截，动态获取所调用的方法，最终动态调用方法。

注意：cglib代理中，目标类不能用final修饰，目标类中的方法不能用final和static修饰。

public  class CarFactoryImpl {
    public  void sell() {
        System.out.println("汽车厂卖汽车");
    }
}

//动态代理类
public class CGLibProxy implements MethodInterceptor {
    private Enhancer enhancer = new Enhancer();

    public Object getProxy(Class<?> clazz){  
        enhancer.setSuperclass(clazz);  
        enhancer.setCallback(this);  
        return enhancer.create();//为目标类生成子类对象
    }  
    /*
     * 拦截所有目标类方法的调用 
     * 参数： 
     * obj  目标实例对象 
     * method 目标方法的反射对象 
     * args 方法的参数 
     * proxy 代理类的实例 
     */
    public Object intercept(Object obj, Method method, Object[] args,  
            MethodProxy proxy) throws Throwable {
        //代理类调用父类的方法  
        System.out.println("开始事务");  
        Object obj1 = proxy.invokeSuper(obj, args);  
        System.out.println("关闭事务");  
        return obj1;  
    }
}

public class Test {
	public static void main(String[] args) {
        CGLibProxy proxy = new CGLibProxy();
        CarFactoryImpl carFactory = (CarFactoryImpl) proxy.getProxy(CarFactoryImpl.class);//为目标对象生成代理对象
        carFactory.sell();
	}
}