设计模式-单例模式

Sayatnoon

已于 2023-07-29 10:31:20 修改

阅读量67

点赞数

分类专栏： Java后端文章标签：设计模式单例模式

于 2023-07-19 18:16:13 首次发布

本文链接：https://blog.csdn.net/Sayatnoon/article/details/131809100

版权

Java后端专栏收录该内容

13 篇文章 0 订阅

订阅专栏

Mybatis-Plus的SqlSessionFactory单例模式实现（非Spring环境下）

单例模式（Singleton，即上图的单件）是指在程序运行期间，在内存中创建且仅创建一次对象，所有需要调用的地方共享单例对象。

六大实现方式

懒汉式-线程不安全

特征：在需要调用对象时时才进行初始化；不加锁导致线程不安全

public class UnsafeLazySingletonPattern {
    private static UnsafeLazySingletonPattern instance;

    private UnsafeLazySingletonPattern(){}

    public static UnsafeLazySingletonPattern getInstance(){
        if (instance == null){
            instance = new UnsafeLazySingletonPattern();
        }
        return instance;
    }
}

懒汉式-线程安全

特征：在需要调用对象时才初始化；加锁，线程安全

public class SafeLazySingletonPattern {
    private static SafeLazySingletonPattern instance;

    private SafeLazySingletonPattern(){}

    //synchronize加锁，线程安全
    public static synchronized SafeLazySingletonPattern getInstance(){
        if (instance == null){
            instance = new SafeLazySingletonPattern();
        }
        return instance;
    }
}

饿汉式

特征：在类加载时就初始化了对象，线程安全（因为对象早已完成初始化，对象一般不会被更新）

public class HungrySingletonPattern {

    private static HungrySingletonPattern instance = new HungrySingletonPattern();

    private HungrySingletonPattern(){}

    public static HungrySingletonPattern getInstance(){
        return instance;
    }
}

双重双检索模式

特征：需要使用时才进行初始化；两次判断有效提升线程安全；对象使用volatile关键字修饰（每次调用对象时都会更新到最新）

public class DoubleCheckSingletonPattern {

    //volatile
    private volatile static DoubleCheckSingletonPattern instance;

    private DoubleCheckSingletonPattern(){}

    public DoubleCheckSingletonPattern getInstance(){
        if (instance == null){
            synchronized (DoubleCheckSingletonPattern.class){
                //再一次判断是否为空的原因：如果两个线程都通过了第一道检验，如果第一个线程已经完成初始化，第二个线程在获取锁之后直接进行初始化，也会产生多例
                if (instance == null){
                    instance = new DoubleCheckSingletonPattern();
                }
            }
        }
        return instance;
    }
}

静态内部类模式

特点：在静态内部类中初始化对象，只有在调用相应方法，主动使用类时才会进行实例化

public class StaticInnerSingletonPattern {

    //类只有在主动使用主动加载时，才会被实例化？
    private static class InnerSingleton{
        private static final StaticInnerSingletonPattern instance = new StaticInnerSingletonPattern();
    }

    private StaticInnerSingletonPattern(){}

    public static StaticInnerSingletonPattern getInstance(){
        //主动使用，对instance实例化（延迟模式）
        return InnerSingleton.instance;
    }
}

枚举模式

最好的单例模式实现方式！

public enum EnumSingletonPattern {
    INSTANCE;

    public void doSomething(){
        System.out.println("doSomething");
    }

}

Mybatis-Plus的SqlSessionFactory单例模式实现（非Spring环境下）

配置文件（mybatis-config.xml）：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

    <!-- 配置环境 -->
    <environments default="mysql">
        <environment id="mysql">
            <!-- 事务管理可选类型：JDBC(使用JDBC的提交、回滚方式)、MANAGED(自己管理事务)-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源，可选类型：JNDI/POOLED(使用连接池)/UNPOOLED-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///myschool"/>
                <property name="username" value="root"/>
                <property name="password" value=""/>
            </dataSource>
        </environment>
    </environments>

    <!-- 管理SQL映射配置文件 -->
    <mappers>
<!--       <package name="org.example.mapper"/>-->
        <mapper class="org.example.mapper.UserMapper"/>
    </mappers>

</configuration>

以上六大方式实现SqlSessionFactory单例

懒汉不安全模式

package org.example.util;

import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;

import java.io.IOException;
import java.io.InputStream;

public class UnsafeLazySingletonSSFUtil {

    private static SqlSessionFactory sessionFactory = null;


    private SqlSessionFactory getSessionFactory() {
        try {
            InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
            sessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
            //System.out.println("不安全懒惰已连接");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return sessionFactory;
    }

    public static SqlSessionFactory getFactory(){
        //System.out.println("test");
        if (sessionFactory == null){
            sessionFactory = new UnsafeLazySingletonSSFUtil().getSessionFactory();
        }
        return sessionFactory;
    }

}

懒汉安全模式

import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;

import java.io.IOException;
import java.io.InputStream;

public class SafeLazySingletonSSFUtil {

    private static SqlSessionFactory sessionFactory;

    private static SqlSessionFactory getSessionFactory(){
        try{
            InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
            sessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
            //System.out.println("安全懒惰已连接");
        }catch (IOException e){
            e.printStackTrace();
        }
        return sessionFactory;
    }

    public static synchronized SqlSessionFactory getFactory(){
        //System.out.println("test");
        if (sessionFactory == null){
            sessionFactory = getSessionFactory();
        }
        return sessionFactory;
    }
}

饿汉模式

import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;

import java.io.IOException;
import java.io.InputStream;

public class HungrySingletonSSFUtil {

    private static SqlSessionFactory sessionFactory;

    static {
        try {
            InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
            sessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    public static SqlSessionFactory getFactory(){
        return sessionFactory;
    }
}

双重双检索模式

import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;

import java.io.IOException;
import java.io.InputStream;

public class DoubleCheckSingletonSSFUtil {

    private static volatile SqlSessionFactory sqlSessionFactory;
    private static SqlSessionFactory getSessionFactory(){
        try{
            InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
            sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
        }catch (IOException e){
            e.printStackTrace();
        }
        return sqlSessionFactory;
    }

    public static SqlSessionFactory getFactory(){
        if (sqlSessionFactory == null){
            synchronized (SqlSessionFactory.class){
                if (sqlSessionFactory == null){
                    sqlSessionFactory = getSessionFactory();
                }
            }
        }
        return sqlSessionFactory;
    }
}

静态内部类模式

import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;

import java.io.IOException;
import java.io.InputStream;


public class StaticInnerSingletonSSFUtil {

    private static class InnerSSF{
        private static SqlSessionFactory sessionFactory;
        static {
            try {
                InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
                sessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }

    public static SqlSessionFactory getFactory(){
        return InnerSSF.sessionFactory;
    }
}

枚举模式

package org.example.util;

import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;

import java.io.IOException;
import java.io.InputStream;

public enum EnumSingletonSSFUtil {
    Factory;

    private static SqlSessionFactory sessionFactory;

    static {
        try {
            InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
            sessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    public SqlSessionFactory getFactory(){
        return sessionFactory;
    }
}

使用以上工具类获得工厂类后，生产会话

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

public class SqlSessionUtil {

    static SqlSessionFactory sqlSessionFactory = SafeLazySingletonSSFUtil.getFactory();

    public static SqlSession getSession(){
        return sqlSessionFactory.openSession(true);
    }

    public static void close(SqlSession sqlSession){
        if (sqlSession != null){
            sqlSession.close();
        }
    }

}