ORM框架涉及的设计模式

接上篇文章，解决原生JDBC访问数据库存在的问题？

①使⽤数据库连接池初始化连接资源

②将sql语句抽取到xml配置⽂件中

③使⽤反射等底层技术，⾃动将实体与表进⾏属性与字段的⾃动映射

先学习一下，ORM的所涉及的设计模式

单例模式

饿汉式

public class HungrySingleton {

    // 构造方法私有化，防止在外部类中进行初始化
    private HungrySingleton() {}

    // 将自身实例化对象设置为一个属性，并用static、final修饰，线程访问单例对象之前就已经创建好了。只能指向唯一一个对象
    private static final HungrySingleton instance = new HungrySingleton();

    // 静态方法返回该实例
    public static HungrySingleton getInstance() {
        return instance;
    }
}

懒汉式

public class LazySingleton {

    // 将自身实例化对象设置为一个属性，并用static修饰
    private static LazySingleton instance;

    // 构造方法私有化,禁止初始化/
    private LazySingleton() {}

    // 静态方法返回该实例，加synchronized关键字实现同步。在多线程的情况会考虑使用双重检验锁
    public static synchronized LazySingleton getInstance() {
        if(instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

public class test {
    public static void main(String[] args) {
        HungrySingleton instance = HungrySingleton.getInstance();
        System.out.println(instance);
        LazySingleton instances = LazySingleton.getInstance();
        System.out.println(instances);
    }
}

构建者模式

public class Computer {
    // 显示器
    private String displayer;
    // 主机
    private String mainUnit;
    // 鼠标
    private String mouse;
    // 键盘
    private String keyboard;

    @Override
    public String toString() {
        return "Computer{" +
                "displayer='" + displayer + '\'' +
                ", mainUnit='" + mainUnit + '\'' +
                ", mouse='" + mouse + '\'' +
                ", keyboard='" + keyboard + '\'' +
                '}';
    }

    public String getDisplayer() {
        return displayer;
    }

    public void setDisplayer(String displayer) {
        this.displayer = displayer;
    }

    public String getMainUnit() {
        return mainUnit;
    }

    public void setMainUnit(String mainUnit) {
        this.mainUnit = mainUnit;
    }

    public String getMouse() {
        return mouse;
    }

    public void setMouse(String mouse) {
        this.mouse = mouse;
    }

    public String getKeyboard() {
        return keyboard;
    }

    public void setKeyboard(String keyboard) {
        this.keyboard = keyboard;
    }
}

public class ComputerBuilder {

    private Computer computer = new Computer();


    public void installDisplayer(String displayer){
        computer.setDisplayer(displayer);
    }

    public void installMainUnit(String mainUnit){
        computer.setMainUnit(mainUnit);
    }

    public void installmouse(String mouse){
        computer.setMouse(mouse);
    }

    public void installkeyboard(String keyboard){
        computer.setKeyboard(keyboard);
    }

    public Computer getComputer(){
        return computer;
    }


}

public class ConsructorTest {

    public static void main(String[] args) {
        ComputerBuilder computerBuilder = new ComputerBuilder();
        computerBuilder.installDisplayer("显示器");
        computerBuilder.installMainUnit("主机");
        computerBuilder.installmouse("鼠标");
        computerBuilder.installkeyboard("键盘");

        Computer computer = computerBuilder.getComputer();
        System.out.println(computer);


    }


}

工厂模式

public abstract class Computer {

    public abstract void start();
}

public class HpComputer extends Computer {
    @Override
    public void start() {
        System.out.println("惠普电脑启动");
    }
}

public class LenovoComputer extends Computer {
    @Override
    public void start() {
        System.out.println("联想电脑启动");
    }
}

public class ComputerFactory {

    public static Computer createComputer(String type){
        Computer computer =null;
        switch (type){
            case "lenovo":
                computer = new LenovoComputer();
            case "hp":
                computer = new HpComputer();
        }

        return  computer;
    }

}

public class simpleFactoryTest {

    public static void main(String[] args) {
        Computer computer = ComputerFactory.createComputer("hp");
        computer.start();

    }
}

代理模式

静态代理

public interface IRentingHouse {
    void rentHosue();
}

public class RentingHouseImpl implements IRentingHouse {
    @Override
    public void rentHosue() {
        System.out.println("我要租用一室一厅的房子");
    }
}

public class RentingHouseProxy implements IRentingHouse {

    private IRentingHouse rentingHouse;

    public RentingHouseProxy(IRentingHouse rentingHouse) {
        this.rentingHouse = rentingHouse;
    }

    @Override
    public void rentHosue() {
        //代理前
        System.out.println("中介（代理）收取服务费3000元");
        rentingHouse.rentHosue();
        //代理后
        System.out.println("客户信息卖了3毛钱");
    }
}

public class Test {

    public static void main(String[] args) {
        IRentingHouse rentingHouse = new RentingHouseImpl();
        // 自己要租用一个一室一厅的房子
        // rentingHouse.rentHosue();

        RentingHouseProxy rentingHouseProxy = new RentingHouseProxy(rentingHouse);
        rentingHouseProxy.rentHosue();
    }
}

动态代理

静态代理问题：代理类和委托类实现了相同的接口。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。由此诞生动态代理。

动态代理是由拦截器和反射，新增一个不需要关注子类

public interface IRentingHouse {
    void rentHosue();
}

public class RentingHouseImpl implements IRentingHouse {
    @Override
    public void rentHosue() {
        System.out.println("我要租用一室一厅的房子");
    }
}

public class ProxyFactory {


    private ProxyFactory(){
    }

    private static ProxyFactory proxyFactory = new ProxyFactory();

    public static ProxyFactory getInstance() {
        return proxyFactory;
    }



    /**
     * Jdk动态代理
     * @param obj  委托对象
     * @return   代理对象
     */
    public Object getJdkProxy(Object obj) {

        // 获取代理对象
        return  Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object result = null;
                        // 写增强逻辑
                        System.out.println("中介（代理）收取服务费3000元");
                        // 调用原有业务逻辑
                        result = method.invoke(obj,args);
                        System.out.println("客户信息卖了3毛钱");
                        return result;
                    }
                });

    }


}

public class JdkProxy {

    public static void main(String[] args) {
        // 委托对象---委托方
        IRentingHouse rentingHouse = new RentingHouseImpl();

        // 从代理对象工厂获取代理对象
        IRentingHouse jdkProxy = (IRentingHouse) ProxyFactory.getInstance().getJdkProxy(rentingHouse);
        jdkProxy.rentHosue();
    }
}

下一节开始手写简单版的orm框架