设计模式

设计模式的主要作用：
重复利用
代码易于扩展
提高阅读
减少代码

设计模式23种
分为三大类
创建型：
工厂
单例
结构型：
代理，适配器
行为型：
策略模式

设计模式的六大原则：
1.开闭原则：扩展性，易于修改
2.里氏代换原则：面向对象
3.依赖倒转原则：面向接口编程
4.接口隔离原则：接口分离
5.迪米特法则：定义类尽量和其他类发生关系
6.合成复用原则：代码复用等

什么是单例设计模式：保证jvm中只能有一个实例
一种是懒汉式：
一种是饿汉式：
区别：懒汉式：线程不安全，是需要的时候才会创建
饿汉式：天生不安全的，jvm加载的时候就初始化了

简单的一个单例单例饿汉模式例子

package com.crj.designmode;

//懒汉式：当需要的时候才去创建
 class Singleton{
    private static Singleton singleton ;
    private Singleton() {}//构造方法私有
    public static Singleton getSingleton() {
        if(singleton == null) {
            synchronized (Singleton.class) {//不能用this.class,因为是静态方法,当singleton不为空的时候，才加第一层锁
                if (singleton == null) {//在判断，算是第二次加锁
                    singleton = new Singleton();
                }
            }
        }
        return singleton;//不为空，就不会发生线程安全问题，就不用加锁，这样提高程序的效率
    }
}

/**   
 * @author: crj
 * @date: 2018年12月6日 下午5:37:30 
 */
public class Lanhanshi {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getSingleton();
        Singleton s2 = Singleton.getSingleton();
        System.out.println(s1 == s2);
    }
    

}

饿汉式：

//饿汉式
 class Singleton2{
        private static Singleton2 singleton = new Singleton2();//不管需不需要，加载的时候就已经创建，static修饰不可改变，所以天生安全
        private Singleton2() {}//构造方法私有
        public static Singleton2 getSingleton() {
            return singleton;//不为空，就不会发生线程安全问题，就不用加锁，这样提高程序的效率
        }
    }

工厂模式：

package com.crj.designmode;

/** 
 * 工厂模式  
 * @author: crj
 * @date: 2018年12月6日 下午6:31:53 
 */

interface Car{
    public void run ();
}

class Aodi implements Car{
    @Override
    public void run() {
        System.out.println("我是奥迪");
        
    }
    
}

class Benchi implements Car{
    @Override
    public void run() {
        System.out.println("我是奔驰");
        
    }
    
}

class CarFactory{
    public static Car createCar(String carName) {
        Car car = null;
        switch (carName) {
        case "奥迪":
            car = new Aodi();
            break;
        case "奔驰":
            car = new Benchi();
            break;

        default:
            break;
        }
        return car;
        
    }
}

public class FactoryMode {
    public static void main(String[] args) {
        Car car = CarFactory.createCar("奔驰");
        car.run();
    }

}

代理设计模式：面向切面方程，面向AOP编程

优点：保证真实角色
远程代理RMI
延迟加载
aop，日志打印，事务，权限控制

代理分类：
静态代理：需要生成代理，
动态代理：不需要生成代理
jdk动态代理
CGLIB动态代理

静态代理和动态代理和CGLIB动态代理：

package com.crj.designmode;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**   
 * 静态代理模式：每次都要生成一个代理
 * 动态代理模式：不需要生成代理
 * 这里是一个通过中介去买房的例子说明
 * @author: crj
 * @date: 2018年12月7日 上午9:40:28 
 */

interface House{
    void buyHouse();
}

class Buyer implements House {
    @Override
    public void buyHouse() {
        System.out.println("我是买房人，我终于可以买房了");
    }
    
}
//静态代理
class Proxy implements House{
    //代理对象
    private Buyer buyer;
    Proxy(Buyer buyer){
        this.buyer = buyer;
    }
    @Override
    public void buyHouse() {
        System.out.println("我是中介，正在帮你处理买房的业务");
        buyer.buyHouse();
        System.out.println("我是中介，已经完成帮你买房的业务了");
    }
}


//动态代理
class JdkAutoProxy implements InvocationHandler{
    private Object target;
    JdkAutoProxy(Object target){
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("我是中介，正在帮你处理买房的业务");
        Object invoke = method.invoke(target, args);
        System.out.println("我是中介，已经完成帮你买房的业务了");
        return invoke;
    }
    
}

//cglib动态代理
class Cglib implements MethodInterceptor{

    @Override
    public Object intercept(Object oj, Method method, Object[] arrays, MethodProxy methodProxy) throws Throwable {
        System.out.println("我是中介，正在帮你处理买房的业务");
         Object invokeSuper = methodProxy.invokeSuper(oj, arrays);
        System.out.println("我是中介，已经完成帮你买房的业务了");
        return invokeSuper;
    }
    
}


public class StaticProxy {
    public static void main(String[] args) {
//      House house = new Proxy(new Buyer());
//      house.buyHouse();
        Buyer buyer = new Buyer();
        //动态代理
        /*JdkAutoProxy jdkAutoProxy = new JdkAutoProxy(buyer);
        House house = (House) java.lang.reflect.Proxy.newProxyInstance(buyer.getClass().getClassLoader(), buyer.getClass().getInterfaces(), jdkAutoProxy);
        house.buyHouse();*/
        //Cglib动态代理
        Cglib cglib = new Cglib();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Buyer.class);
        enhancer.setCallback(cglib);
        House house = (House) enhancer.create();
        house.buyHouse();
    }

}