设计模式

创建型模式

单例模式

工厂模式

说明：将同一类放到一起，再将这些类型再统一

// 最大的抽象
public interface ProductFactory {
    PhoneFactory phoneFactory();
    RouterFactory routerFactory();
}

/**
 * 手机
 */
public interface PhoneFactory {
    void start();
    void stop();
    void send();
}

/**
 * 路由器
 */
public interface RouterFactory {
    void start();
    void stop();
    void setWifi();
}

// 不同工厂去创建
public class HuaweiFactory implements ProductFactory {
    @Override
    public PhoneFactory phoneFactory() {
        return new HuaweiPhone();
    }

    @Override
    public RouterFactory routerFactory() {
        return new HuaweiRouter();
    }

}

// 只是传入华为工厂，就可以清晰的构造
public class Client {
    public static void main(String[] args) {
        ProductFactory productFactory = new HuaweiFactory();
        productFactory.phoneFactory().send();
    }
}

建造者模式

好处：不需要知道类的内部构造，将产品的建造和表示分离

• 链式编程

抽象工厂模式可以看成生产汽车配件的工厂，生产一个产品族的产品，即一次产生；建造者模式则是倾向于链式编程，将汽车配件一个个组装起来

public class Worker extends Builder{
    private Product product;

    public Worker(){
        product = new Product();
    }
    @Override
    Builder builderA(String msg) {
        product.setBuildA(msg);
        return this;
    }

    @Override
    Builder builderB(String msg) {
        product.setBuildB(msg);
        return this;
    }

    @Override
    Builder builderC(String msg) {
        product.setBuildC(msg);
        return this;
    }

    @Override
    Builder builderD(String msg) {
        product.setBuildD(msg);
        return this;
    }

    @Override
    Product getProduct() {
        return product;
    }
}

原型模式

• 实现Cloneable，重写clone方法
• 对于内部类需要clone方法去操作

@Data
@AllArgsConstructor
public class Video implements Cloneable{
    private String name;

    private Date createTime;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object o = super.clone();
        Video video = (Video) o;
        // 此处对于Date类型进行了再次拷贝
        Date createTime = (Date)video.getCreateTime().clone();
        video.setCreateTime(createTime);
        return video;
    }
}

说明：内存地址、hashcode、==关系

结构型模式

适配器模式

说明：将两个不同的类通过适配器去组合，适配器当桥梁。适用于对原有代码进行维护升级

//真正的适配器，需要连接usb 连接网线
public class Adapter2 implements NetToUsb{
	// 原始的类，采用组合的方式放入
    private Adaptee adaptee;

    public Adapter2(Adaptee adaptee){
        this.adaptee = adaptee;
    }
		
    @Override
    public void handleRequest() {
    	//根据需要去转换
        adaptee.request();
    }
}

桥接模式

说明：解决多继承问题，适用于两个独立变化的维度

public class Computer {
    protected Brand brand;

    public Computer(Brand brand){
        this.brand = brand;
    }

    public void info(){
        brand.info();
    }


}

// 台式机
class Desktop extends Computer{

    public Desktop(Brand brand) {
        super(brand);
    }

    @Override
    public void info() {
        super.info();
        System.out.println("台式机");
    }
}

// 笔记本
class NoteBook extends Computer{

    public NoteBook(Brand brand) {
        super(brand);
    }

    @Override
    public void info() {
        super.info();
        System.out.println("笔记本");
    }
}

代理模式

静态代理

角色分析:

• 抽象角色：一般会使用接口和抽象类解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，
• 客户：访问对象的人

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Proxy implements Rent{
    private Host host;


    @Override
    public void rent() {
        host.rent();
    }
}

动态代理

• 角色和静态代理一致
• 代理类是动态生成
• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
  • 基于接口—JDK动态代理
  • 基于类—cglib
  • java字节码–javassist

proxy：代理，InvocationHandler：调用处理程序

@Data
public class ProxyInvocationHandler implements InvocationHandler {
   private Rent rent;

   // 得到代理类
   public Object getProxy(){
      return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(),this);
   }

   // 处理代理实例获得结果
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       Object result = method.invoke(rent, args);
       this.seeHouse();
       return null;
   }

   public void seeHouse(){
       System.out.println("看房子");
   }
}

public class Client {
   public static void main(String[] args) {
       Host host = new Host();
       ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
       proxyInvocationHandler.setRent(host);
       Rent proxy = (Rent)proxyInvocationHandler.getProxy();
       proxy.rent();
   }
}

@Data
public class ProxyInvocationHandler implements InvocationHandler {
    private Object target;

    // 得到代理类
    public Object getProxy(){
       return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
    }

    // 处理代理实例获得结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        this.log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    public void log(String t){
        System.out.println(t);
    }

}

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        proxyInvocationHandler.setTarget(userService);

        UserService proxy = (UserService) proxyInvocationHandler.getProxy();

        proxy.add();
    }
}