0
点赞
收藏
分享

微信扫一扫

【微服务实战】01-工程结构概览

Resin_Wu 2023-08-22 阅读 32

一、Java 中有几种设计模式?

Java 中一般认为有 23 种设计模式

分为三大类:

1. 创建型模式 5 种

2. 结构型模式 7 种

3. 行为型模式 11 种

 二、什么是单例设计模式?

1. 单例模式定义

2. 单例模式的特点

3. 单例的四大原则

4.  实现单例模式的方式

(1) 饿汉式 (立即加载):
/**
 * 饿汉式(立即加载)
 */
public class Singleton1 {

    /**
     * 私有构造
     */
    private Singleton1() {
        System.out.println("构造函数Singleton1");
    }

    /**
     * 初始值为实例对象
     */
     private static Singleton1 single = new Singleton1();

     /**
      * 静态工厂方法
      * @return 单例对象
      */
     public static Singleton1 getInstance() {
        System.out.println("getInstance");
        return single;
     }

     public static void main(String[] args){
        System.out.println("初始化");
        Singleton1 instance = Singleton1.getInstance();
     }
}
(2) 懒汉式 (延迟加载):

/**
 * 懒汉式(延迟加载)
 */
public class Singleton2 {

    /**
     * 私有构造
     */
    private Singleton2() {
        System.out.println("构造函数Singleton2");
    }

    /**
     * 初始值为null
     */
    private static Singleton2 single = null;

    /**
     * 静态工厂方法
     * @return 单例对象
     */
    public static Singleton2 getInstance() {
        if(single == null){
            System.out.println("getInstance");
            single = new Singleton2();
        }
        return single;
    }

    public static void main(String[] args){
        System.out.println("初始化");
        Singleton2 instance = Singleton2.getInstance();
    }
}
(3) 同步锁 (解决线程安全问题):
/**
 *
 * 同步锁(解决线程安全问题)
 */
public class Singleton3 {

    /**
     * 私有构造
     */
    private Singleton3() {}

    /**
     * 初始值为null
     */
    private static Singleton3 single = null;
    
    public static Singleton3 getInstance() {
        // 等同于 synchronized public static Singleton3 getInstance()
        synchronized(Singleton3.class){
            // 注意:里面的判断是一定要加的,否则出现线程安全问题
            if(single == null){
                single = new Singleton3();
            }
        }
        return single;
    }
}
(4) 双重检查锁 (提高同步锁的效率):
/**
 * 双重检查锁(提高同步锁的效率)
 */
public class Singleton4 {

    /**
     * 私有构造
     */
    private Singleton4() {}

    /**
     * 初始值为null
     */
    private static Singleton4 single = null;

    /**
     * 双重检查锁
     * @return 单例对象
     */
    public static Singleton4 getInstance() {
        if (single == null) {
            synchronized (Singleton4.class) {
                if (single == null) {
                    single = new Singleton4();
                }
            }
        }
        return single;
    }
}
(5) 静态内部类:

   特点:即能延迟加载,也能保证线程安全

/**
 *
 * 静态内部类(延迟加载,线程安全)
 */
public class Singleton5 {
    /**
     * 私有构造
     */
    private Singleton5() {}

    /**
     * 静态内部类
     */
    private static class InnerObject{
        private static Singleton5 single = new Singleton5();
    }

    public static Singleton5 getInstance() {
        return InnerObject.single;
    }
}
(6) 内部枚举类实现 (防止反射攻击):
public class SingletonFactory {
    /**
     * 内部枚举类
     */
    private enum EnumSingleton{
        Singleton;
        private Singleton6 singleton;

        //枚举类的构造方法在类加载是被实例化
        private EnumSingleton(){
            singleton = new Singleton6();
        }

        public Singleton6 getInstance(){
            return singleton;
        }
    }
 
    public static Singleton6 getInstance() {
        return EnumSingleton.Singleton.getInstance();
    }
}

class Singleton6 {
    public Singleton6(){}
}

三、什么是工厂设计模式?

1. 简单工厂 (Simple Factory)

定义:

角色:

使用说明:

代码如下:

// 水果接口:
public interface Fruit {
    void whatIm();
}

// 苹果类:
public class Apple implements Fruit {
    @Override
    public void whatIm() {
        System.out.println("苹果");
    }
}

// 梨类:
public class Pear implements Fruit {
    @Override
    public void whatIm() {
        System.out.println("梨");
    }
}

//水果工厂:

public class FruitFactory {
    public Fruit createFruit(String type) {
        if (type.equals("apple")) {//生产苹果
            return new Apple();
        } else if (type.equals("pear")) {//生产梨
            return new Pear();
        }
        return null;
    }
}

// 使用工厂生产产品:
public class FruitApp {
    public static void main(String[] args) {
        FruitFactory mFactory = new FruitFactory();
        Apple apple = (Apple) mFactory.createFruit("apple");//获得苹果
        Pear pear = (Pear) mFactory.createFruit("pear");//获得梨
        apple.whatIm();
        pear.whatIm();
    }
}

2. 工厂方法 (Factory Method)

定义:

角色:

使用说明:

代码如下:

// 水果接口、苹果类和梨类:代码和上例一样

// 抽象工厂接口:
public interface FruitFactory {
    Fruit createFruit();//生产水果
}

// 苹果工厂:
public class AppleFactory implements FruitFactory {
    @Override
    public Apple createFruit() {
        return new Apple();
    }
}

// 梨工厂:
public class PearFactory implements FruitFactory {
    @Override
    public Pear createFruit() {
        return new Pear();
    }
}

// 使用工厂生产产品:
public class FruitApp {
    public static void main(String[] args){
        AppleFactory appleFactory = new AppleFactory();
        PearFactory pearFactory = new PearFactory();
        Apple apple = appleFactory.createFruit();//获得苹果
        Pear pear = pearFactory.createFruit();//获得梨
        apple.whatIm();
        pear.whatIm();
    }
}

3. 抽象工厂 (Abstract Factory)

定义:

角色:

使用说明:

用抽象工厂来实现:

// cpu接口和实现类:
public interface Cpu {
    void run();

    class Cpu650 implements Cpu {
        @Override
        public void run() {
            System.out.println("650 也厉害");
        }
    }

    class Cpu825 implements Cpu {
        @Override
        public void run() {
            System.out.println("825 更强劲");
        }
    }
}

// 屏幕接口和实现类:
public interface Screen {
    void size();
    class Screen5 implements Screen {
        @Override
        public void size() {
            System.out.println("" + "5寸");
        }
    }

    class Screen6 implements Screen {
        @Override
        public void size() {
            System.out.println("6寸");
        }
    }
}

// 抽象工厂接口:
public interface PhoneFactory {
    Cpu getCpu();//使用的cpu
    Screen getScreen();//使用的屏幕
}

// 小米手机工厂:
public class XiaoMiFactory implements PhoneFactory {
    @Override
    public Cpu.Cpu825 getCpu() {
        return new Cpu.Cpu825();//高性能处理器
    }
 
    @Override
    public Screen.Screen6 getScreen() {
        return new Screen.Screen6();//6寸大屏
    }
}

//红米手机工厂:
public class HongMiFactory implements PhoneFactory {
    @Override
    public Cpu.Cpu650 getCpu() {
        return new Cpu.Cpu650();//高效处理器
    }

    @Override
    public Screen.Screen5 getScreen() {
        return new Screen.Screen5();//小屏手机
    }
}

// 使用工厂生产产品:
public class PhoneApp {
    public static void main(String[] args){
        HongMiFactory hongMiFactory = new HongMiFactory();
        XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
        Cpu.Cpu650 cpu650 = hongMiFactory.getCpu();
        Cpu.Cpu825 cpu825 = xiaoMiFactory.getCpu();
        cpu650.run();
        cpu825.run();
        Screen.Screen5 screen5 = hongMiFactory.getScreen();
        Screen.Screen6 screen6 = xiaoMiFactory.getScreen();
        screen5.size();
        screen6.size();
    }
}

4. 三种工厂方式总结

举报

相关推荐

0 条评论