// 目标接口
interface Target {
    void request();
}

// 已有类（不兼容）
class Adaptee {
    public void specificRequest() {
        System.out.println("原始方法");
    }
}

// 适配器（用组合）
class Adapter implements Target {
    private Adaptee adaptee; //内置一个不兼容的适配者

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest(); // 翻译调用
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Target target = new Adapter(new Adaptee());
        target.request();
    }
}

// 一个维度：设备
abstract class Device {
    protected Brand brand;
}

// 另一个维度：品牌
interface Brand {
    void run();
}

class Phone extends Device {}
class Computer extends Device {}

class Apple implements Brand {}
class Xiaomi implements Brand {}

abstract class Node {
    abstract void operate();
}

class File extends Node {
    void operate() {}
}

class Folder extends Node {
    List<Node> children;

    void operate() {
        for (Node n : children) {
            n.operate();
        }
    }
}

// 抽象构件
interface Coffee {
    String getDescription();
    double cost();
}

// 具体构件（原始对象）
class SimpleCoffee implements Coffee {
    @Override
    public String getDescription() {
        return "普通咖啡";
    }

    @Override
    public double cost() {
        return 10.0;
    }
}

// 装饰器抽象类
abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;

    public CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }
}

// 具体装饰器：加糖
class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + " + 糖";
    }

    @Override
    public double cost() {
        return coffee.cost() + 2.0;
    }
}

// 具体装饰器：加牛奶
class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + " + 牛奶";
    }

    @Override
    public double cost() {
        return coffee.cost() + 3.0;
    }
}

// 测试
public class Client {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();

        coffee = new SugarDecorator(coffee); // 加糖
        coffee = new MilkDecorator(coffee);  // 再加牛奶

        System.out.println(coffee.getDescription());
        System.out.println(coffee.cost());
    }
}

public class FilterInputStream extends InputStream{ //实现
	protected InputStream in;//聚合
	protected FilterInputStream(InputStream in){
		super();
		this.in=in;
	}
		
	public int read() throws IOException{
		return in.read();
	}
	
	public int read(byte[] b) throws IOExcetion{
		return in.read(b);
	}
}

public final class RequestFacade implements HttpServletRequest{
	private Request request; //被封装的处理
	public RequestFacade(Request request){
		this.request = request
	}
	
	@Override 
	public String getParameter(String name){
		return request.getParameter(name);
	}
	
	@Override
	public String getHeader(String name){
		return request.getHeader(name);
	}
	
	@Override
	public HttpSession getSession(){
		return request.getSession();
	}
}

public final class Integer extends Number implements Comparable<Integer>{
	private static class IntegerCache{
		static final int low = -128;
		statoc final int high = 127;
		static final Integer cache[];
	}
		
	public static Integer valueOf(int i){
		if(i>=IntegerCache.low&&i<=IntegerCache.high){
			return IntegerCache.cache[ i + (-IntegerCache.low) ];
		}
		return new Integer(i);
	}
}

Proxy.newProxyInstance(
	ClassLoader  loader,
	Class<?>[]  interfaces,
	InvocationHandler  h
);

UserService proxy = (UserService) Proxy.newProxyInstance(
	UserServiceImpl.class.getClassLoader(),
	new Class[]{UserService.class},
	(p, m, a)->{
		"前置增强".sout
		Object res = m.invoke(new UserServiceImpl(), a);
		"后置增强".sout
		return res;
	}
);

/*主要流程:
	1. 用目标接口接收 proxy.newProxyInstance(...) 返回的实现类 (也是代理类)
	2. 内部: 
	   a. 生成代理类字节码 
	   -> (既继承proxy, 又实现目标接口, 并且将(...)的method重写)
		
	   b. 加载代理类 --> ( 用(...)的指定接口的类加载器加载 )
	   
	   c. 调用代理类的构造器以创建代理类对象
	   
	   $Proxy0(InvocationHandler h){
		   super(h);  //父类Proxy的构造器把h存起来
	   }
	   
	
	1. 于是这个$Proxy就有了InvocationHandler, 并且能够执行(...)的重写的invoke方法
*/

public final class $Proxy0 extends Proxy implements SellTickets{
	private static Method m3;
	
	public $Proxy0(InvocationHandler invocationHandler){
		super(invocationHandler);
	}

	static {
		m3 = Class.forName("com.itheima.pattern.proxy.jdk_proxy.SellTickets")
			    .getMethod("sell", new Class[0]);
	}

	public final void sell(){
		this.h.invoke(this, m3, null);
	}               |----------------------------                                                 
}                                                              |
							 |
                             |    
pubilc class Proxy{                                 |
	protected InvocationHandler h; ---|
}

Class MyInterceptor implements MethodInterceptor{
	@Override
	public Object intercept(Object  obj, Method  method, Object[] args, MethodProxy proxy) {//     1. 代理类实现MethodInterceptor接口, 并重写intercept方法
	"before  method".sout;
	Object  res = proxy.invokeSuper(obj, args);
	"after method".sout;
	return res;
	}
	
}

public class CglibDemo{
	public static void main(String[] args){
		Enhancer enh = new Enhancer();
		
		// 2. 将目标类设置为Enhancer的父类
		enhancer.setSuperclass(UserService.class);
		
		// 3. 设置回调函数并提供代理对象
		enhancer.setCallback(new MyInterceptor());
		
		UserService proxy = (UserService) enhancer.create();
		
		// 4. create获得proxy
		proxy.addUser();
	}

}