2. 程式人生 > 實用技巧 >[MySQL] PHP IP登入限制的實現

[MySQL] PHP IP登入限制的實現

阿新 • • 發佈：2020-12-17

技術標籤：設計模式設計模式java面試

單例設計模式

餓漢式單例

餓漢式單例是在類載入的時候就立即初始化，並且建立單例物件。絕對執行緒安全，線上
程還沒出現以前就是例項化了，不可能存在訪問安全問題。

優點：沒有加任何的鎖、執行效率比較高，在使用者體驗上來說，比懶漢式更好，絕對執行緒安全，線上程還沒出現以前就是例項化了，不可能存在訪問安全問題
缺點：類載入的時候就初始化，不管用與不用都佔著空間，浪費了記憶體，有可能佔著茅
坑不拉屎。

普通餓漢式單例

public class HungrySingleton {
    private static final HungrySingleton hungrySingleton =
 
 new HungrySingleton();

    private HungrySingleton(){}

    public static HungrySingleton getInstance(){
        return  hungrySingleton;
    }
}

靜態餓漢式單例

public class HungryStaticSingleton {
    private static final HungryStaticSingleton hungrySingleton;
    static {
        hungrySingleton = new
 
 HungryStaticSingleton();
    }
    private HungryStaticSingleton(){}
    public static HungryStaticSingleton getInstance(){
        return  hungrySingleton;
    }
}

餓漢式適用於物件較少的情況。

懶漢式單例

懶漢式單例的特點是：被外部類呼叫的時候內部類才會載入

普通懶漢式

單鎖

/懶漢式單例
//在外部需要使用的時候才進行例項化
public class LazySimpleSingleton {
    private LazySimpleSingleton
 
(){}
    //靜態塊，公共記憶體區域
    private static LazySimpleSingleton lazy = null;
    public synchronized static LazySimpleSingleton getInstance(){
        if(lazy == null){
            lazy = new LazySimpleSingleton();
        }
        return lazy;
    }
}

雙重鎖

public class LazyDoubleCheckSingleton {
	private volatile static LazyDoubleCheckSingleton lazy = null;
	private LazyDoubleCheckSingleton(){}
	public static LazyDoubleCheckSingleton getInstance(){
		if(lazy == null){
			synchronized (LazyDoubleCheckSingleton.class){
				if(lazy == null){
				lazy = new LazyDoubleCheckSingleton();
                //1.分配記憶體給這個物件
                //2.初始化物件
                //3.設定 lazy 指向剛分配的記憶體地址
				}
			}
		}
		return lazy;
	}
}

雙重檢查模式，進行了兩次判斷，第一次是為了避免不要的示例，第二次是為了進行同步，避免執行緒安全問題。由於

lazy = new LazyDoubleCheckSingleton();物件的建立在jvm可能會進行排序，在多執行緒訪問下存在風險，使用volatile修飾的LazyDoubleCheckSingleton例項變數有效，解決改問題

總結

懶漢式單例存線上程安全的問題，在多執行緒情況下有一點機率建立不同的物件，

如何來使得懶漢式單例線上程環境下安全呢？

給getInstance()加上synchronized關鍵字，使這個方法變成執行緒同步方法。

但是用synchronized加鎖，線上程數量比較多情況下，如果CPU 分配壓力上升，會導致大批
量執行緒出現阻塞，從而導致程式執行效能大幅下降。

有沒有更好的解決方式？

—使用靜態內部類的方式

靜態內部類的方式建立單例

//這種形式兼顧餓漢式的記憶體浪費，也兼顧synchronized效能問題
//完美地遮蔽了這兩個缺點
public class LazyInnerClassSingleton {
    private LazyInnerClassSingleton(){}

    //static 是為了使單例的空間共享，保證這個方法不會被重寫，過載
    //jvm優先載入靜態內部類，只加載一次，利用jvm底層執行邏輯，完美的避免了執行緒安全的問題
    public static final LazyInnerClassSingleton getInstance(){
        //在返回結果以前，一定會先載入內部類
        return LazyHolder.LAZY;
    }

    //內部類預設不載入，使用到了內部類才載入
    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

這種形式兼顧餓漢式的記憶體浪費，也兼顧synchronized效能問題。內部類一定是要在方
法呼叫之前初始化，巧妙地避免了執行緒安全問題

反射破壞單例

但是，上述的構造方法只用private之外，沒有做任何處理，如果我們使用反射來呼叫其構造方法，然後，再呼叫getInstance()方法，應該就會兩個不同的例項。我們看一下測試程式碼

cpublic class LazyInnerClassSingletonTest {
    public static void main(String[] args) {
        try{
            //想搞進行破壞
            Class<?> clazz = LazyInnerClassSingleton.class;
            //通過反射拿到私有的構造方法
            Constructor c = clazz.getDeclaredConstructor(null);
            //強制訪問，跳過安全檢查，必須得從了
            c.setAccessible(true);
            //暴力初始化
            Object o1 = c.newInstance();
            //呼叫了兩次構造方法，相當於new了兩次，犯了原則性問題
            Object o2 = c.newInstance();

            System.out.println(o1 == o2);//執行結果為false
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

執行結果是false

很明顯，建立了的兩個不同的例項。現在我們在構造方法中進行一些限制，一旦重複建立，就直接丟擲異常，來看一下優化後的程式碼

public class LazyInnerClassSingleton {
    //預設使用LazyInnerClassGeneral的時候，會先初始化內部類
    //如果沒使用的話，內部類是不載入的
    private LazyInnerClassSingleton(){
        if(LazyHolder.LAZY != null){//防止反射暴力破壞單例
            throw new RuntimeException("不允許建立多個例項");
        }
    }
    //static 是為了使單例的空間共享，保證這個方法不會被重寫，過載
    //jvm優先載入靜態內部類，只加載一次，利用jvm底層執行邏輯，完美的避免了執行緒安全的問題
    public static final LazyInnerClassSingleton getInstance(){
        //在返回結果以前，一定會先載入內部類
        return LazyHolder.LAZY;
    }
    //內部類預設不載入，使用到了內部類才載入
    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

再次執行的結果：

...
Caused by: java.lang.RuntimeException: 不允許建立多個例項
	at com.gupaoedu.vip.pattern.singleton.lazy.LazyInnerClassSingleton.<init>(LazyInnerClassSingleton.java:17)
	... 5 more

至此，得到的最好用的單例建立方式！！

序列破壞單例

有時候，創建出來的單例物件需要序列化寫到磁碟中，下次使用的時候，再從磁碟讀取到物件，反序列化為實體物件，反序列化後的物件會重新分配記憶體，即重新建立，違背了單例模式的初衷，來看一段程式碼

//序列化：把記憶體中的狀態通過轉換成位元組碼的形式，通過一個IO流，寫入到其他地方
//反序列化：將已經持久化的位元組碼內容，通過IO流的讀取，進而將讀取的內容轉換為Java物件,轉換的過程中需要重新建立物件new
public class SeriableSingleton implements Serializable {    
	public  final static SeriableSingleton INSTANCE = new SeriableSingleton();
    private SeriableSingleton(){}
    
    public static SeriableSingleton getInstance(){
        return INSTANCE;
    } 
}

編寫測試程式碼：

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

        SeriableSingleton s1 = null;
        SeriableSingleton s2 = SeriableSingleton.getInstance();

        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("SeriableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (SeriableSingleton)ois.readObject();
            ois.close();

            System.out.println(s1 == s2);//執行結果是false

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

執行結果是false

可以看出，反序列化後的物件和手動建立的物件是不一致的，例項化了兩次，違背了單例的設計初衷。

我們如何保證序列化的情況下也能夠實現單例？其
實很簡單，只需要增加readResolve()方法即可。來看優化程式碼：

public class SeriableSingleton implements Serializable {


    public  final static SeriableSingleton INSTANCE = new SeriableSingleton();
    private SeriableSingleton(){}

    public static SeriableSingleton getInstance(){
        return INSTANCE;
    }

    private  Object readResolve(){
        return  INSTANCE;
    }

}

為什麼增加了readResolve()方法就能解決這個問題？

因為ObjectInputStream類的readObject()方法，呼叫了該類中的readOrdinaryObject()方法，通過反射找到一個無參的readResolve()方法，並且儲存下來，通過readResolve()方法返回例項，解決了單例被破壞的問題。但是實際上例項化了兩次，只不過新建立的物件沒有被返回而已。

註冊式單例

註冊式單例又稱為登記式單例，就是將每一個例項都登記到某一個地方，使用唯一的標識獲取例項。註冊式單例有兩種寫法：一種為容器快取，一種為列舉登記。

列舉登記

先來看列舉式單例的寫法，來看程式碼，建立EnumSingleton類：

public enum EnumSingleton {
    INSTANCE;
    private Object data;
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public static EnumSingleton getInstance(){
        return INSTANCE;
    }
}

測試：

public static void main(String[] args) {
        try {
            EnumSingleton instance1 = null;

            EnumSingleton instance2 = EnumSingleton.getInstance();
            instance2.setData(new Object());

            FileOutputStream fos = new FileOutputStream("EnumSingleton.obj");            			 ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(instance2);
            oos.flush();
            oos.close();
            
            FileInputStream fis = new FileInputStream("EnumSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            instance1 = (EnumSingleton) ois.readObject();
            ois.close();

            System.out.println(instance1.getData());
            System.out.println(instance2.getData());
            System.out.println(instance1.getData() == instance2.getData());

       }catch (Exception e){
            e.printStackTrace();
        }
    }

執行結果為true

為什麼？

反編譯EnumSingleton.java檔案得到

static 
{ 
	INSTANCE = new EnumSingleton("INSTANCE", 0); 
	$VALUES = (new EnumSingleton[] { INSTANCE }); 
}

列舉式單例在靜態程式碼塊中就給INSTANCE進行了賦值，是餓漢式單例的實現。

我們再來測試一些反射能否破壞單例

public static void main(String[] args) {
        try {
            Class clazz = EnumSingleton.class;
            Constructor c = clazz.getDeclaredConstructor(String.class,int.class);
            c.setAccessible(true);
            EnumSingleton enumSingleton = (EnumSingleton)c.newInstance("123",666);

        }catch (Exception e){
            e.printStackTrace();
        }
    }

執行報錯：

java.lang.IllegalArgumentException: Cannot reflectively create enum objects

不能用反射來建立列舉型別

來看一下jdk的Constructor 的newInstance()方法原始碼：

  @CallerSensitive
    public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

可以看到 , 在newInstance()方法中做了強制性的判斷，如果修飾符是Modifier.ENUM列舉型別，直接丟擲異常。

容器快取

public class ContainerSingleton {
    private ContainerSingleton(){}
    private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();
    public static Object getInstance(String className){
        synchronized (ioc) {
            if (!ioc.containsKey(className)) {
                Object obj = null;
                try {
                    obj = Class.forName(className).newInstance();
                    ioc.put(className, obj);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return obj;
            } else {
                return ioc.get(className);
            }
        }
    }
}

來看看Spring中的容器式單例的實現程式碼：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory { 
    /** Cache of unfinished FactoryBean instances: FactoryBean name --> BeanWrapper */ 		private final Map<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>(16);
    ...
}

容器式寫法適用於建立例項非常多的情況，便於管理。但是，是非執行緒安全的。

ThreadLocal單例

執行緒單例的實現ThreadLocal：

ThreadLocal 不能保證其建立的物件是全域性唯一，但是能保證在單個執行緒中是唯一的，天生的執行緒安全。

我們來看程式碼：

public class ThreadLocalSingleton {
    private static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance =
            new ThreadLocal<ThreadLocalSingleton>(){
                @Override
                protected ThreadLocalSingleton initialValue() {
                    return new ThreadLocalSingleton();
                }
            };

    private ThreadLocalSingleton(){}

    public static ThreadLocalSingleton getInstance(){
        return threadLocalInstance.get();
    }
}

測試程式碼：

class ExectorThread implements Runnable{
    @Override
    public void run() {
        ThreadLocalSingleton singleton = ThreadLocalSingleton.getInstance();
    }
}
public class ThreadLocalSingletonTest {
    public static void main(String[] args) {
        Thread t1 = new Thread(new ExectorThread());
        Thread t2 = new Thread(new ExectorThread());
        t1.start();
        t2.start();
        
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
    }
}

main中無論呼叫多少次，獲取到的例項都是同一個，都在兩個子執行緒中分別獲取到了不同的例項。

ThreadLocal是如果實現這樣的效果的呢？

我們知道上面的單例模式為了達到執行緒安全的目的，給方法上鎖，以時間換空間。ThreadLocal將所有的物件全部放在ThreadLocalMap中，為每個執行緒都提供一個物件，實際上是以空間換時間來實現執行緒間隔離的。

相關推薦

[MySQL] PHP IP登入限制的實現

在登入的時候 , 對安全性比較高的業務 , 需要進行限制指定IP或IP段才能登入 , 企郵企業有的就限制只能在本企業內登入

基於PHP的登入和註冊的功能的實現

1.新建三個html檔案，兩個php檔案和若干個CSS檔案和若干個JS檔案 2.登入的html頁面顯示效果圖

py mysql結合面向物件，實現類似超市導購機器的功能【2.使用者登入及註冊功能】

py mysql結合面向物件，實現類似超市導購機器的功能（自我總結） 步驟2： 編寫主類 ，將登入和註冊兩個功能分寫到兩個.py檔案中，再根據選擇型別呼叫方法：from 類 import 方法

PHP 基於 Swoole 的微信掃碼登入如何實現

隨著微信的普及，掃碼登入方式越來越被現在的應用所使用。它因為不用去記住密碼，只要有微訊號即可方便快捷登入。微信的開放平臺原生就有支援掃碼登入的功能，不過大部分人還是在用公眾平臺，所以掃碼登入只能自行實

mysql json php 直接使用_php實現簡單聊天功能

技術標籤：mysql json php 直接使用php 傳送post不等待結果php 實現留言本增刪改查功能拼團功能實現 php

SSH埠修改及限制IP登入及禁止ROOT遠端登入方法

1、修改SSH預設埠 //修改配置檔案 vi /etc/ssh/sshd_config //修改 #Port 22 為如下： Port 22

CentOS7下 MySQL定時自動備份的實現方法

生產環境遇到得最幸福得事情就是，某些場景沒辦法避免去update或者delete的時候，某個引數沒有注意。完蛋了 完蛋了，資料被我搞崩了怎麼辦，趕緊去運營找備份呀！運營說：狗屁 咱們系統從來不備份，你說：那把日誌給

MySQL通過自定義函式實現遞迴查詢父級ID或者子級ID

背 景: 在MySQL中如果是有限的層次，比如我們事先如果可以確定這個樹的最大深度,那麼所有節點為根的樹的深度均不會超過樹的最大深度，則我們可以直接通過left join來實現。

Docker部署Django+Mysql+Redis+Gunicorn+Nginx的實現

一. 前言 docker技術現在非常火熱，通過容器構建專案環境，執行效率和部署效率都很不錯。所以最近抽空看了一些教程，然後將部落格部署方式改為了docker，感覺網上沒有特別好的關於 docker 部署 django 專案的教程，特

mysql雙機熱備實現方案【可測試】

一、概念 1、熱備份和備份的區別 　　熱備份指的是：High Available（HA）即高可用，而備份指的是Backup，資料備份的一種。這是兩種不同的概念，應對的產品也是兩種功能上完全不同的產品。熱備份主要保障業務的連續性

mysql定時任務(event事件)實現詳解

1.事件簡介 事件（event）是MySQL在相應的時刻呼叫的過程式資料庫物件。一個事件可呼叫一次，也可週期性的啟動，它由一個特定的執行緒來管理的，也就是所謂的“事件排程器”。

python mysql斷開重連的實現方法

後臺服務在執行時發現一個問題，執行約15分鐘後，介面請求報錯 pymysql.err.InterfaceError: (0,\'\')

Mysql中事務ACID的實現原理詳解

引言 照例，我們先來一個場景~ 面試官:\"知道事務的四大特性麼?\" 你:\"懂，ACID嘛，原子性(Atomicity)、一致性(Consistency)、隔離性(Isolation)、永續性(Durability)！\"

MySQL資料庫定時備份的實現方法

1. 建立shell指令碼 vim backupdb.sh 建立指令碼內容如下： #!/bin/sh db_user=\"root\" db_passwd=\"123456\"

win10下MySQL 8.0登入Access denied for user‘root’@‘localhost’ (using password: YES)問題的解決方法

近些時間在開始學MySQL，安裝挺順利的，按照網上現成的教程就能安裝成功。

MySQL PHP語法淺析

我們先來看一下charAt函式的基本語法 character = str.charAt（index） charAt函式的唯一引數是字串中的index，從中提取單個字元。此索引的範圍介於0和length - 1之間，包括限制。如果未指定索引，則返回字串的第一

mysql刪除重複行的實現方法

表relation create table relation( id int primary key auto_increment,userId int not null,fanId int not null

MySql通過ip地址進行訪問的方法

1.登入mysql： mysql -u root -h 127.0.0.1 -p 2.切換資料庫 use mysql 3.授權 grant all privileges on *.* to \'root\'@\'127.0.0.1\'identified by \'密碼\';

MySQL語句加鎖的實現分析

摘要： MySQL兩條SQL語句鎖的分析 看一下下面的SQL語句加什麼鎖 SLQ1：select * from t1 where id = 10;

mysql利用引數sql_safe_updates限制update/delete範圍詳解

前言 大家應該都知道，我們在mysql運維中出現過不少因為update/delete條件錯誤導致資料被誤更新或者刪除的case，為避免類似問題的發生，可以用sql_safe_updates引數來對update/delete做限制。這個引數設定為on後，可