工厂模式和单例模式

什么是工厂模式？

      通过一个工厂类创建类似功能的不同实现类的父类或接口，不用关注你所获取的类是怎么实现的，只要通过工厂获取到对   象即可使用

1. 工厂模式需要的三大模块：
   • 一个父类或者一个接口：定义该功能的方法、属性
   • 一个实现类或者子类：实现或者继承上面的接口或者父类
   • 工厂类：通过工厂类获取实现类的父类或者接口(多态)
2. 优点：
   • 扩展性高：当你想增加一个产品，只需要扩展工厂类，并增加一个产品即可
   • 使用简单：屏蔽了产品的具体实现，使用者只用关注产品的接口即可
   • 高度解耦

3. 缺点：

   • 每次增加一个产品的时候都需要新增一个实现类，这样下来类的数量不断增加，增加了系统 复杂度

使用：在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

 

/**
 *    接口
 */
public interface Car {

    void run();
}


/**
 *  实现类
 */
public class Bwm implements Car {
    @Override
    public void run() {
        System.out.println("宝马车在跑...");
    }
}


/**
 * 实现类
 */
public class Benz implements Car {
    @Override
    public void run() {
        System.out.println("奔驰车在跑...");
    }
}


/**
 *  工厂方法模式
 */
public interface CarFactory {
      Car createCar(String name);

}


/**
 * 奔驰汽车工厂
 */
public class BenzFactory implements CarFactory {

    @Override
    public Car createCar(String name) {
        System.out.println("奔驰汽车...");
        return new Benz();
    }
}


/**
 * 宝马汽车工厂
 */
public class BwmFactory implements CarFactory {

    @Override
    public Car createCar(String name) {

        System.out.println("宝马汽车...");
        return new Bwm();
    }
}

public class Client {
    public static void main(String[] args) {

        //工厂方法
        BwmFactory bwmFactory=new BwmFactory();
        Car car = bwmFactory.createCar("宝马");
        car.run();

        BenzFactory benzFactory=new BenziFactory();
        Car car1 = benzFactory.createCar("奔驰");
        car1.run();
    }
}

单例模式（Singleton Pattern）

     是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

//创建session单例对象
public class SessionUtil {

    static SessionFactory sessionFactory;

    static{
        Configuration configuration=new Configuration().configure("hibernate.cfg.xml");
        sessionFactory=configuration.buildSessionFactory();
    }

    /**
     * 每次调用该方法是， 都获取到一个新的Session
     * @return
     */
    public static Session openSession(){
        return sessionFactory.openSession();
    }
    //获取和当前线程绑定的session(推荐使用)
    public static Session openCurrentSession(){

        return sessionFactory.getCurrentSession();
    }
   
}

 实现方式：

   1、懒汉式， 没有加锁，线程不安全

        多线程不能正常工作。

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
    public static Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}

        加锁synchronized  线程安全

           优点：第一次调用才初始化，避免内存浪费。
           缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}

2、饿汉式

   优点：没有加锁，执行效率会提高。
   缺点：类加载时就初始化，浪费内存。

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}