设计模式之 单例 代理

单例模式：懒汉、饿汉 构造私有(代码要求)

单例就是该类只能返回一个实例。

单例所具备的特点：

1. 私有化的构造函数
2. 私有的静态的全局变量
3. 公有的静态的方法
   单例分为懒汉式、饿汉式和双层锁式

    public class A{   //饿汉
        private static A instance=new A();
        private A(){}
        public static getInstance(){return instance;}
    }
                    
    public class A{   //懒汉
        private static A instance=null;
        private A(){}
        public synchronized static getInstance(){
          if(instance == null){
             instance = new A();
          }else{
             return instance;
          }
       }
    }
    public enum ClassA {//枚举方式
         classA;
    }
--------------------------------------------------------------
	饿汉式:
	public class Singleton1 {
	      private Singleton1() {};
	      private static Singleton1 single = new Singleton1();
	      public static Singleton1 getInstance() {
	          return single;
	     }
	 }
	 
	懒汉式：
	public class Singleton2 {
	      private Singleton2() {}
	      private static Singleton2 single=null;
	      public tatic Singleton2 getInstance() {
	           if (single == null) {  
	              single = new Singleton2();
	          }  
	         return single;
	     }
	 }
	线程安全：
	public class Singleton3 {
		  private Singleton3() {}
		  private static Singleton3 single ;
		  public static Singleton3 getInstance() {
			if(null == single){
				synchronized(single ){
					if(null == single){
						single = new Singleton3();
					}
				}
			}
			return single;  
		  }
	}
	

通过双重判断来保证单列设计模式在多线程中的安全性，并且它在性能方面提高了很多。
synchronized在方法上加锁 (同步锁)
synchronized在代码块内部加锁 （同步代码块）
synchronized(同步锁)

使用synchronized如何解决线程安全的问题？

1. synchronized在方法上加锁
2. synchronized在代码块内部加锁

1.懒汉 2.饿汉 3.双重判断

代理模式:(三要素：目标对象+与目标类相同的方法+增强功能代码)

• 目标对象[真正]------代理对象[额外功能]

1. 在不修改原有代码情况下,动态为之添加额外功能。
2. 将代码中通用的模块、功能、代理，抽离成独立的模块,使用动态代理，在目标对象执行时，动态加入通用的功能代码。

• 分为：静态代理 动态代理
  • 静态代理：

                  //目标类接口
                   public interface UserService{
                       public void ma();
                   }
                   //目标类
                   public class UserServiceImpl implements UserService{
                       public void ma(){

                           //.....代码实现
                       }
                   }
                   //基于接口的静态代理
                   public class ProxyUserService1 implements UserService{
                       private UserService us = new UserServiceImpl();//目标对象
                       public void ma(){//与目标类相同的方法
                           //增强功能代码1
                           us.ma()//调用目标对象的目标方法
                           //增强功能代码2
                       }
                   }

                   //基于继承的静态代理
                   public class ProxyUserService1 extends UserServiceImpl{
                       public void ma(){//与目标类相同的方法
                           //增强功能代码1
                          super.ma()//调用目标对象的目标方法
                           //增强功能代码2
                       }
                   }

• 动态代理：
  通过动态字节码技术(动态生成类对应的class字节码文件)动态生成代理类，进而反射创建代理类对象。
  实现方式:
  • a:jdk动态代理–基于接口形式实现
    Proxy.newInstance(类加载器,目标类接口,InvocationHander 额外功能)
  • b:cglib动态代理–基于继承方式实现
    Ehencer增强器
    eh.setSupperClass();