(Java)设计模式：结构型

package com.zixieqing.o1staticproxy;/** * 
@description  : 该类功能  抽象角色 * 
 * 
@package      : com.zixieqing.o1staticproxy
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public interface IHouse {    void rent();}

package com.zixieqing.o1staticproxy.impl;import com.zixieqing.o1staticproxy.IHouse;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 
@description  : 该类功能  真实角色：房东 * 
 * 
@package      : com.zixieqing.o1staticproxy.impl
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class Landlord implements IHouse {    private Logger logger = LoggerFactory.getLogger(Landlord.class);    @Override    public void rent() {        logger.info("{}有房子出售",this.getClass().getSimpleName());    }}

package com.zixieqing;import com.zixieqing.o1staticproxy.impl.Landlord;import com.zixieqing.o1staticproxy.impl.ProxyLandlord;/** * 
@description  : 该类功能  测试 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class ApiTest {    public static void main(String[] args) {        // 无代理的情况        Landlord landlord = new Landlord();        landlord.rent();    }}

package com.zixieqing.o1staticproxy;/** * 
@description  : 该类功能  抽象角色 * 
 * 
@package      : com.zixieqing.o1staticproxy
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public interface IHouse {    void rent();}

package com.zixieqing.o1staticproxy.impl;import com.zixieqing.o1staticproxy.IHouse;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 
@description  : 该类功能  真实角色：房东 * 
 * 
@package      : com.zixieqing.o1staticproxy.impl
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class Landlord implements IHouse {    private Logger logger = LoggerFactory.getLogger(Landlord.class);    @Override    public void rent() {        logger.info("{}有房子出售",this.getClass().getSimpleName());    }}

package com.zixieqing.o1staticproxy.impl;import com.zixieqing.o1staticproxy.IHouse;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 
@description  : 该类功能  代理角色： *                      代理真实角色，间接访问真实角色，从而限制、增强、修改真是角色的一些特性 * 
 * 
@package      : com.zixieqing.o1staticproxy.impl
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class ProxyLandlord implements IHouse {    private Logger logger = LoggerFactory.getLogger(ProxyLandlord.class);    /**     * 目标：真实角色     */    private IHouse target;    public ProxyLandlord(IHouse target) {        this.target = target;    }    /**     * 需求：在执行真实角色方法执行，统计耗时时长，从而提交到监控系统中让其使用     */    @Override    public void rent() {        long startTime = System.currentTimeMillis();        // 执行真实角色中的方法        target.rent();        long endTime = System.currentTimeMillis();        logger.info("耗时：{} 毫秒", (endTime - startTime));        foo();    }    // 以下即为代理角色特有的一些操作：看房子、签合同、收费、交钱给房东........    private void foo() {        logger.info("中介者还可以吃喝嫖赌............");    }}

package com.zixieqing;import com.zixieqing.o1staticproxy.impl.Landlord;import com.zixieqing.o1staticproxy.impl.ProxyLandlord;/** * 
@description  : 该类功能  测试 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class ApiTest {    public static void main(String[] args) {        // 静态代理测试        Landlord landlord = new Landlord();        ProxyLandlord proxyLandlord = new ProxyLandlord(landlord);        // 使用代理角色访问真实角色        proxyLandlord.rent();    }}

09:51:06.346 [main] INFO  c.z.o1staticproxy.impl.Landlord - Landlord有房子出售09:51:06.347 [main] INFO  c.z.o1staticproxy.impl.ProxyLandlord - 耗时：0 毫秒09:51:06.347 [main] INFO  c.z.o1staticproxy.impl.ProxyLandlord - 中介者还可以吃喝嫖赌............

/** * 为指定的接口创建代理类，返回代理类的Class对象 * @param loader代理类的类加载器 * param interfaces指定需要实现的接口列表，创建的代理默认会按顺序实现interfaces指定的接口 */public static Class getProxyClass(ClassLoader loader,Class... interfaces){}/** * 创建代理类的实例对象(先为指定的接口创建代理类，然后会生成代理类的一个实例) * @param loader代理类的类加载器 * @param interfaces指定需要实现的接口列表，创建的代理默认会按顺序实现interfaces指定的接口 * @param invocationHandler 是个接口，会返回一个代理对象 */public static Object newProxyInstance(ClassLoader loader,                                      Class[] interfaces,                                      InvocationHandler invocationHandler){}/** * InvocationHandler接口：返回一个代理对象，当调用代理对象的任何方法的时候，会就被InvocationHandler 接口的 invoke 方法处理 */public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;/** * 判断指定的类是否是一个代理类 */public static boolean isProxyClass(Class cl){}/** * 获取代理对象的InvocationHandler调用处理程序 */public static InvocationHandler getInvocationHandler(Object proxy) throws IllegalArgumentException

@Testpublic void o1jdkProxy() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {  // 1、获取接口的代理类Class对象  Class proxyClass = (Class) Proxy.getProxyClass(IHouse.class.getClassLoader(), IHouse.class);  // 2、创建代理类的处理器  InvocationHandler invocationHandler = new InvocationHandler() {            /**             * InvocationHandler接口下的invoke方法，处理代理实例上的方法调用             * @param proxy 调用该方法的代理实例             * @param method 调用代理实例上的接口方法的实例             * @param args 代理实例的参数值的对象             * @return             * @throws Throwable             */    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {      logger.info("这里是InvocationHandler，被调用的方法是：{}",method.getName());      return null;    }  };  // 3、创建代理实例  IHouse iHouse = proxyClass.getConstructor(InvocationHandler.class).newInstance(invocationHandler);  // 4、调用代理实例上的方法  iHouse.rent();}

@Testpublic void simpleWayProxy() {  // 1、使用invocationHandler接口创建代理类的处理器  InvocationHandler invocationHandler = new InvocationHandler() {    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {      logger.info("这是InvocationHandler，被调用的方法是：{}", method.getName());      return null;    }  };  // 2、直接调用Proxy的静态方法newProxyInstance()创建代理对象  IHouse ihouse = (IHouse) Proxy.newProxyInstance(IHouse.class.getClassLoader(), new Class[]{IHouse.class}, invocationHandler);  // 3、使用代理对象操作真实对象  ihouse.rent();}

import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;/** * 
@description  : 该类功能  jdk动态代理示例：接口耗时统计 * 
 * 
@package      : com.zixieqing.o1staticproxy
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */// 1、实现InvocationHandler接口   每个代理实例都有一个关联的调用处理程序对象，它实现了接口InvocationHandlerpublic class CostTimeInvocationHandler implements InvocationHandler {    private Logger logger = LoggerFactory.getLogger(CostTimeInvocationHandler.class);    /**     * 2、聚合真实对象     */    private Object target;    public CostTimeInvocationHandler(Object target) {        this.target = target;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        long startTime = System.nanoTime();        Object result = method.invoke(this.target, args);        logger.info("{} 的 {}方法 耗时 {} 纳秒", this.target.getClass(), method.getName(), (System.nanoTime() - startTime));        return result;    }    /**     * 创建代理对象     * @param target 真实角色     * @param targetInterface 这个真实角色实现的接口     * @param      * @return     */    public static  T createProxy(Object target, Class targetInterface) {        if (!targetInterface.isInterface())            throw new IllegalStateException("targetInterface必须是一个接口类型");        if (!targetInterface.isAssignableFrom(target.getClass()))            throw new IllegalStateException("target必须是targetInterface的实现类");        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),                                          target.getClass().getInterfaces(),                                          new CostTimeInvocationHandler(target));    }}

@Testpublic void jdkProxyDemo() {  // 获取代理对象  IHouse house = CostTimeInvocationHandler.createProxy(new Landlord(), IHouse.class);  // 使用代理对象调用真实对象中的方法，自然会进入InvocationHandler接口的invoke()中  house.rent();}

package com.zixieqing.o2dynamicproxy;/** * 
@description  : 该类功能  假设有一个业务，这里面有两个方法m1、m2 * 
 * 
@package      : com.zixieqing.o2dynamicproxy
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public interface IService {    void m1();    void m2();}

  package com.zixieqing.o2dynamicproxy.impl;  import com.zixieqing.o2dynamicproxy.IService;  import org.slf4j.Logger;  import org.slf4j.LoggerFactory;  /**   * 
@description  : 该类功能  业务A   * 
   * 
@package      : com.zixieqing.o2dynamicproxy.impl
   * 
@author       : ZiXieqing
   * 
@version      : V1.0.0
   */  public class ServiceA implements IService {      private Logger logger = LoggerFactory.getLogger(ServiceA.class);      @Override      public void m1() {          logger.info("这是{}类的 m1 方法",this.getClass().getSimpleName());      }      @Override      public void m2() {          logger.info("这是{}类的 m2 方法",this.getClass().getSimpleName());      }  }

  package com.zixieqing.o2dynamicproxy.impl;  import com.zixieqing.o2dynamicproxy.IService;  import org.slf4j.Logger;  import org.slf4j.LoggerFactory;  /**   * 
@description  : 该类功能  业务B   * 
   * 
@package      : com.zixieqing.o2dynamicproxy.impl
   * 
@author       : ZiXieqing
   * 
@version      : V1.0.0
   */  public class ServiceB implements IService {      private Logger logger = LoggerFactory.getLogger(ServiceB.class);      @Override      public void m1() {          logger.info("这是{}类的 m1 方法",this.getClass().getSimpleName());      }      @Override      public void m2() {          logger.info("这是{}类的 m2 方法",this.getClass().getSimpleName());      }  }

package com.zixieqing;import com.zixieqing.o2dynamicproxy.impl.ServiceA;import org.junit.Test;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.cglib.proxy.Enhancer;import org.springframework.cglib.proxy.MethodInterceptor;import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;/** * 
@description  : 该类功能  动态代理之CGLIB动态代理的MethodInterceptor拦截所有方法测试 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class CglibProxyTest {    private Logger logger = LoggerFactory.getLogger(CglibProxyTest.class);    @Test    public void methodInterceptorTest() {        // 1、创建enhancer        Enhancer enhancer = new Enhancer();        // 2、设置给谁做代理：Enhancer创建一个被代理对象的子类并且拦截所有的方法调用（非final修饰的类或方法）        enhancer.setSuperclass(ServiceA.class);        /*3、设置回调：现org.springframework.cglib.proxy.Callback接口，MethodInterceptor接口也是其子接口        当调用代理对象的任何方法的时候，都会被MethodInterceptor接口的invoke方法处理*/        enhancer.setCallback(new MethodInterceptor() {            /**             * 代理对象的方法拦截器             * @param proxy 代理对象的实例             * @param method 真实角色的方法，即：ServiceA中的方法             * @param objects 调用方法传递的参数             * @param methodProxy 方法的代理对象             * @return             * @throws Throwable             */            @Override            public Object intercept(Object proxy, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {                logger.info("这是Enhancer的方法拦截器MethodInterceptor中的invoke，即将调用；{}",method.getName());                return methodProxy.invokeSuper(proxy, objects);            }        });        // 4、创建代理对象 强转        ServiceA service = (ServiceA) enhancer.create();        // 5、通过代理对象访问真实对象        service.m1();        System.out.println("================华丽的分隔符=============");        service.m2();    }

package com.zixieqing.o2dynamicproxy.impl;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 
@description  : 该类功能  业务C * 
 * 
@package      : com.zixieqing.o2dynamicproxy.impl
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class ServiceC {    private Logger logger = LoggerFactory.getLogger(ServiceC.class);    public String m1() {        logger.info("这是普通类{}的 m1 方法",this.getClass().getSimpleName());        return "tall is cheap";    }    public String m2() {        logger.info("这是普通类{}的 m1 方法",this.getClass().getSimpleName());        return "show me the code";    }}

@Testpublic void fixedValueTest() {  // 1、创建enhancer  Enhancer enhancer = new Enhancer();  // 2、设置给谁做代理：Enhancer创建一个被代理对象的子类并且拦截所有的方法调用（非final修饰的类或方法）  enhancer.setSuperclass(ServiceC.class);  /*3、设置回调：现org.springframework.cglib.proxy.Callback接口，FixedValue接口也是其子接口        当调用代理对象的任何方法的时候，都会被FixedValue接口的loadObject方法处理*/  enhancer.setCallback(new FixedValue() {    /** * 代理对象：拦截所有方法 并 返回固定的内容 * @return 要返回的内容 * @throws Exception */    @Override    public Object loadObject() throws Exception {      logger.info("这是Enhancer的FixedValue拦截所有方法 并 返回给定内容");      return "代理对象的FixedValue已经执行完毕";    }  });  // 4、创建代理对象 强转  ServiceC service = (ServiceC) enhancer.create();  // 5、通过代理对象访问真实对象  logger.info(service.m1());  logger.info(service.m2());}

package com.zixieqing.o2dynamicproxy.impl;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 
@description  : 该类功能  业务D * 
 * 
@package      : com.zixieqing.o2dynamicproxy.impl
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class ServiceD {    private Logger logger = LoggerFactory.getLogger(ServiceD.class);    public void insertA() {        logger.info("{}的insertA方法插入了一条数据", this.getClass().getSimpleName());    }    public String getB() {        logger.info("这是{}的方法getB", this.getClass().getSimpleName());        return "紫邪情";    }}

/** * 需求： * insert开头的方法统计耗时时间 * get开头的方法直接返回固定内容 */@Testpublic void callbackFilterTest() {  Enhancer enhancer = new Enhancer();  enhancer.setSuperclass(ServiceD.class);  // 数组写法  Callback[] callbacks = {    new MethodInterceptor() {      /**       * 对象代理：insert开头的方法应该做的逻辑：统计耗时时间   * @param o 代理对象   * @param method 真实对象中的方法   * @param objects 调用方法传递的参数   * @param methodProxy 方法代理   * @return   * @throws Throwable   */      @Override      public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {        long startTime = System.nanoTime();        Object result = methodProxy.invokeSuper(o, objects);        logger.info("执行时间为：{}纳秒", (System.nanoTime()) - startTime);        return result;      }    },    new FixedValue() {      /**   * get开头的方法应该做的逻辑：返回固定字符串   * @return   * @throws Exception   */      @Override      public Object loadObject() throws Exception {        return "当前库正在进行迁移，无法访问！！";      }    }  };  // 第二个变化的地方：调用setCallbacks，将上一步的数组写法Callback[] callbacks传进去  enhancer.setCallbacks(callbacks);  // 多一步：设置过滤逻辑  enhancer.setCallbackFilter(new CallbackFilter() {    /** * 方法过滤 * @param method 真实对象中的方法 * @return 索引值     */    @Override    public int accept(Method method) {      // 如果方法是以insert开头，那就去找callbacks[0] 即：上面的MethodInterceptor，否则就是FixedValue      return method.getName().startsWith("insert") ? 0 : 1;    }  });  ServiceD serviceD = (ServiceD) enhancer.create();  // insert统计耗时  serviceD.insertA();  // get返回固定字符串  System.out.println(serviceD.getB());}

@Testpublic void callbackHelperTest() {  Enhancer enhancer = new Enhancer();  enhancer.setSuperclass(ServiceD.class);  // 方法是insert开头时要做的事情  Callback costTime = (MethodInterceptor) (Object o,                                           Method method,                                           Object[] objects,                                           MethodProxy methodProxy) -> {    long startTime = System.currentTimeMillis();    Object result = methodProxy.invokeSuper(o, objects);    System.out.println("此任务花费了：" + (System.currentTimeMillis() - startTime) + "毫秒");    return result;  };  // 以get开头的方法要做的事情  Callback returnConstStr = (FixedValue) () -> "紫邪情";  // CallbackHelper(Class superclass, Class[] interfaces)  CallbackHelper callbackHelper = new CallbackHelper(ServiceD.class, null) {    /** * 判断业务该怎么走 * @param method 方法 * @return */    @Override    protected Object getCallback(Method method) {      return method.getName().startsWith("insert") ? costTime : returnConstStr;    }  };  // 给enhancer添加Callbacks数组  enhancer.setCallbacks(callbackHelper.getCallbacks());  // 让CallbackHelper成为enhancer的过滤对象  enhancer.setCallbackFilter(callbackHelper);  /*测试*/  ServiceD serviceD = (ServiceD) enhancer.create();  serviceD.insertA();  System.out.println("================华丽的分隔符=============");  System.out.println(serviceD.getB());}

package com.zixieqing.mode;/** * 
@description  : 该类功能  实现化角色：支付模式 * 
 * 
@package      : com.zixieqing.mode
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public interface IPayMode {    boolean check(String uId);}

  package com.zixieqing.mode;  import org.slf4j.Logger;  import org.slf4j.LoggerFactory;  /**   * 
@description  : 该类功能  具体实现化角色：密码校验   * 
   * 
@package      : com.zixieqing.mode
   * 
@author       : ZiXieqing
   * 
@version      : V1.0.0
   */  public class PwdCheckImpl implements IPayMode{      private Logger logger = LoggerFactory.getLogger(PwdCheckImpl.class);      @Override      public boolean check(String uId) {          logger.info("{} 正在进行风控校验，校验用户为：{}", this.getClass().getSimpleName(), uId);          return true;      }  }

  package com.zixieqing.mode;  import org.slf4j.Logger;  import org.slf4j.LoggerFactory;  /**   * 
@description  : 该类功能  具体实现化角色：指纹校验   * 
   * 
@package      : com.zixieqing.mode
   * 
@author       : ZiXieqing
   * 
@version      : V1.0.0
   */  public class FingerprintCheckImpl implements IPayMode{      private Logger logger = LoggerFactory.getLogger(FingerprintCheckImpl.class);      @Override      public boolean check(String uId) {          logger.info("{} 正在进行风控校验，校验用户为：{}", this.getClass().getSimpleName(), uId);          return true;      }  }

package com.zixieqing.channel;import com.zixieqing.mode.IPayMode;import java.math.BigDecimal;/** * 
@description  : 该类功能  抽象化角色：聚合一个具体化对象引用 * 
 * 
@package      : com.zixieqing.channel
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public abstract class AbstractPayWay {    /**     * 聚合支付模式     */    protected IPayMode iPayMode;    protected AbstractPayWay(IPayMode iPayMode) {        this.iPayMode = iPayMode;    }    /**     * 支付方式     *      如果直接采用if-else，那实现类中这里直接if判断是支付宝还是微信，里面又继续判断是密码、人脸、指纹...，之后做逻辑即可     *      而：采用桥接模式进行桥街点拆分之后，抽象（AbstractPayWay）依赖实现（IPayMode），想要什么组合按照自己需要即可     *      这样就让抽象和实现都可以独立使用和变化     * @param uId 用户ID     * @param tradeId 交易ID     * @param amount 金额     * @return 受理情况     */    public abstract String transfer(String uId, String tradeId, BigDecimal amount);}

  package com.zixieqing.channel;  import com.zixieqing.mode.IPayMode;  import org.slf4j.Logger;  import org.slf4j.LoggerFactory;  import java.math.BigDecimal;  /**   * 
@description  : 该类功能  扩展抽象化角色   * 
   * 
@package      : com.zixieqing.channel
   * 
@author       : ZiXieqing
   * 
@version      : V1.0.0
   */  public class WeChatPay extends AbstractPayWay{      private Logger logger = LoggerFactory.getLogger(WeChatPay.class);      public WeChatPay(IPayMode iPayMode) {          super(iPayMode);      }      @Override      public String transfer(String uId, String tradeId, BigDecimal amount) {          logger.info("模拟微信渠道支付划账开始。uId：{} tradeId：{} amount：{}", uId, tradeId, amount);          boolean check = iPayMode.check(uId);          logger.info("模拟微信渠道支付风控校验。uId：{} tradeId：{} security：{}", uId, tradeId, check);          if (!check) {              logger.info("模拟微信渠道支付划账拦截。uId：{} tradeId：{} amount：{}", uId, tradeId, amount);              return "0001";          }          logger.info("模拟微信渠道支付划账成功。uId：{} tradeId：{} amount：{}", uId, tradeId, amount);          return "0000";      }  }

  package com.zixieqing.channel;  import com.zixieqing.mode.IPayMode;  import org.slf4j.Logger;  import org.slf4j.LoggerFactory;  import java.math.BigDecimal;  /**   * 
@description  : 该类功能  扩展抽象化角色   * 
   * 
@package      : com.zixieqing.channel
   * 
@author       : ZiXieqing
   * 
@version      : V1.0.0
   */  public class AliPay extends AbstractPayWay{      private Logger logger = LoggerFactory.getLogger(AliPay.class);      public AliPay(IPayMode iPayMode) {          super(iPayMode);      }      @Override      public String transfer(String uId, String tradeId, BigDecimal amount) {          logger.info("模拟支付宝渠道支付划账开始。uId：{} tradeId：{} amount：{}", uId, tradeId, amount);          boolean check = iPayMode.check(uId);          logger.info("模拟支付宝渠道支付风控校验。uId：{} tradeId：{} security：{}", uId, tradeId, check);          if (!check) {              logger.info("模拟支付宝渠道支付划账拦截。uId：{} tradeId：{} amount：{}", uId, tradeId, amount);              return "0001";          }          logger.info("模拟支付宝渠道支付划账成功。uId：{} tradeId：{} amount：{}", uId, tradeId, amount);          return "0000";      }  }

package com.zixieqing;import com.zixieqing.channel.AliPay;import com.zixieqing.channel.WeChatPay;import com.zixieqing.mode.FingerprintCheckImpl;import com.zixieqing.mode.PwdCheckImpl;import org.junit.Test;import java.math.BigDecimal;import java.util.UUID;/** * 
@description  : 该类功能  测试 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class ApiTest {    @Test    public void MyTest() {        // 1、微信+密码=支付        WeChatPay weChatPay = new WeChatPay(new PwdCheckImpl());        weChatPay.transfer("weixin-".concat(UUID.randomUUID().toString()),                    System.nanoTime() + "",                            new BigDecimal(1000));        System.out.println();        // 2、支付宝+指纹=支付        AliPay aliPay = new AliPay(new FingerprintCheckImpl());        aliPay.transfer("zfb-".concat(UUID.randomUUID().toString()),                System.nanoTime() + "",                new BigDecimal(1000));    }}

14:58:42.349 [main] INFO  com.zixieqing.channel.WeChatPay - 模拟微信渠道支付划账开始。uId：weixin-872c5f47-c529-44ca-949f-3dd772197b6e tradeId：20617275744700 amount：100014:58:42.351 [main] INFO  com.zixieqing.mode.PwdCheckImpl - PwdCheckImpl 正在进行风控校验，校验用户为：weixin-872c5f47-c529-44ca-949f-3dd772197b6e14:58:42.351 [main] INFO  com.zixieqing.channel.WeChatPay - 模拟微信渠道支付风控校验。uId：weixin-872c5f47-c529-44ca-949f-3dd772197b6e tradeId：20617275744700 security：true14:58:42.351 [main] INFO  com.zixieqing.channel.WeChatPay - 模拟微信渠道支付划账成功。uId：weixin-872c5f47-c529-44ca-949f-3dd772197b6e tradeId：20617275744700 amount：100014:58:42.351 [main] INFO  com.zixieqing.channel.AliPay - 模拟支付宝渠道支付划账开始。uId：zfb-65f4f190-6f63-4a1c-bde9-0c10a950d4d4 tradeId：20617281349700 amount：100014:58:42.352 [main] INFO  c.z.mode.FingerprintCheckImpl - FingerprintCheckImpl 正在进行风控校验，校验用户为：zfb-65f4f190-6f63-4a1c-bde9-0c10a950d4d414:58:42.352 [main] INFO  com.zixieqing.channel.AliPay - 模拟支付宝渠道支付风控校验。uId：zfb-65f4f190-6f63-4a1c-bde9-0c10a950d4d4 tradeId：20617281349700 security：true14:58:42.352 [main] INFO  com.zixieqing.channel.AliPay - 模拟支付宝渠道支付划账成功。uId：zfb-65f4f190-6f63-4a1c-bde9-0c10a950d4d4 tradeId：20617281349700 amount：1000

package com.zixieqing;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 
@description  : 该类功能  高级媒体播放器 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public interface AdvanceMediaPlayer {    Logger LOGGER = LoggerFactory.getLogger(AdvanceMediaPlayer.class);    /**     * 播放vlc格式     * @param fileName 文件名     */    void playVlc(String fileName);    /**     * 播放mp4格式     * @param fileName 文件名     */    void playMp4(String fileName);}

  package com.zixieqing.impl;  import com.zixieqing.AdvanceMediaPlayer;  /**   * 
@description  : 该类功能  播放vlc格式的播放器   * 
   * 
@package      : com.zixieqing.impl
   * 
@author       : ZiXieqing
   * 
@version      : V1.0.0
   */  public class VlcPlayer implements AdvanceMediaPlayer {      /**       * 播放vlc格式       *       * @param fileName 文件名       */      @Override      public void playVlc(String fileName) {          LOGGER.info("进行vlc播放的一些逻辑处理");      }      /**       * 播放mp4格式       *       * @param fileName 文件名       */      @Override      public void playMp4(String fileName) {          // 不做事      }  }

  package com.zixieqing.impl;  import com.zixieqing.AdvanceMediaPlayer;  /**   * 
@description  : 该类功能  mp4格式播放器   * 
   * 
@package      : com.zixieqing.impl
   * 
@author       : ZiXieqing
   * 
@version      : V1.0.0
   */  public class Mp4Player implements AdvanceMediaPlayer {      /**       * 播放vlc格式       *       * @param fileName 文件名       */      @Override      public void playVlc(String fileName) {          // 不做事      }      /**       * 播放mp4格式       *       * @param fileName 文件名       */      @Override      public void playMp4(String fileName) {          LOGGER.info("mp4格式播放器该做的逻辑处理");      }  }

package com.zixieqing;/** * 
@description  : 该类功能  媒体播放器 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public interface MediaPlayer {    /**     * 媒体播放     * @param audioType 音频类型     * @param fileName 文件名     */    void play(String audioType, String fileName);}

  package com.zixieqing.impl;  import com.zixieqing.MediaPlayer;  import com.zixieqing.MediaPlayerAdapter;  import com.zixieqing.TypeEnum;  import org.slf4j.Logger;  import org.slf4j.LoggerFactory;  /**   * 
@description  : 该类功能  音频播放器   * 
   * 
@package      : com.zixieqing.impl
   * 
@author       : ZiXieqing
   * 
@version      : V1.0.0
   */  public class AudioPlayer implements MediaPlayer {      private Logger logger = LoggerFactory.getLogger(AudioPlayer.class);      private MediaPlayerAdapter mediaPlayerAdapter;      /**       * 媒体播放       * @param audioType 音频类型       * @param fileName 文件名       */      @Override      public void play(String audioType, String fileName) {          // 支持原有的格式 mp3          if ("mp3".equalsIgnoreCase(audioType)) {              logger.info("原有格式mp3播放的一系列逻辑");          // 让其支持其他格式的音频播放          } else if (TypeEnum.VLC.toString().equalsIgnoreCase(audioType)                  || TypeEnum.MP4.toString().equalsIgnoreCase(audioType)) {              // 找适配器转              mediaPlayerAdapter = new MediaPlayerAdapter(audioType);              mediaPlayerAdapter.play(audioType, fileName);          } else {              throw new IllegalStateException("音频格式不对，请切换符合的格式");          }      }  }

package com.zixieqing;/** * 
@description  : 该类功能  音频格式类型枚举 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public enum TypeEnum {    VLC,    MP4,    MP3,}

package com.zixieqing;import com.zixieqing.impl.Mp4Player;import com.zixieqing.impl.VlcPlayer;/** * 
@description  : 该类功能  适配器： * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class MediaPlayerAdapter implements MediaPlayer{    private AdvanceMediaPlayer advanceMediaPlayer;    public MediaPlayerAdapter(String audioType) {        if (TypeEnum.VLC.toString().equalsIgnoreCase(audioType))            advanceMediaPlayer = new VlcPlayer();        if (TypeEnum.MP4.toString().equalsIgnoreCase(audioType))            advanceMediaPlayer = new Mp4Player();    }    /**     * 媒体播放     *     * @param audioType 音频类型     * @param fileName 文件名     */    @Override    public void play(String audioType, String fileName) {        if (TypeEnum.VLC.toString().equalsIgnoreCase(audioType))            advanceMediaPlayer.playVlc(fileName);        if (TypeEnum.MP4.toString().equalsIgnoreCase(audioType))            advanceMediaPlayer.playMp4(fileName);    }}

package com.zixieqing;import com.zixieqing.o1classadapter.impl.AudioPlayer;import org.junit.Test;/** * 
@description  : 该类功能  测试 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class ApiTest {    @Test    public void test() {        AudioPlayer audioPlayer = new AudioPlayer();        audioPlayer.play("mp3","大悲咒");        audioPlayer.play("mp4","画江湖");        audioPlayer.play("flac","葫芦娃");    }}

15:21:13.769 [main] INFO  c.z.o1classadapter.impl.AudioPlayer - 原有格式mp3播放的一系列逻辑15:21:13.772 [main] INFO  c.z.o.AdvanceMediaPlayer - mp4格式播放器该做的逻辑处理java.lang.IllegalStateException: 音频格式不对，请切换符合的格式at com.zixieqing.o1classadapter.impl.AudioPlayer.play(AudioPlayer.java:42)at com.zixieqing.ApiTest.test(ApiTest.java:23).....................

package com.zixieqing.o2instanceadapter.msg;import java.util.Date;/** * 
@description  : 该类功能  源角色：系统已有对象  内部订单消息体 * 
 * 
@package      : com.zixieqing.o2instanceadapter
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class InternalOrder {    /**     * 用户ID     */    private String uid;    /**     * 商品     */    private String sku;    /**     * 订单ID     */    private String orderId;    /**     * 下单时间     */    private Date createOrderTime;    public String getUid() {        return uid;    }    public void setUid(String uid) {        this.uid = uid;    }    public String getSku() {        return sku;    }    public void setSku(String sku) {        this.sku = sku;    }    public String getOrderId() {        return orderId;    }    public void setOrderId(String orderId) {        this.orderId = orderId;    }    public Date getCreateOrderTime() {        return createOrderTime;    }    public void setCreateOrderTime(Date createOrderTime) {        this.createOrderTime = createOrderTime;    }    @Override    public String toString() {        return "InternalOrder{" +                "uid='" + uid + '\'' +                ", sku='" + sku + '\'' +                ", orderId='" + orderId + '\'' +                ", createOrderTime=" + createOrderTime +                '}';    }}

package com.zixieqing.o2instanceadapter.msg;import java.math.BigDecimal;import java.util.Date;/** * 
@description  : 该类功能  源角色：系统已有对象  第三方订单消息体 * 
 * 
@package      : com.zixieqing.o2instanceadapter
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class POPOrder {    /**     * 用户ID     */    private String uId;    /**     * 订单号     */    private String orderId;    /**     * 下单时间     */    private Date orderTime;    /**     * 商品     */    private Date sku;    /**     * 商品名称     */    private Date skuName;    /**     * 金额     */    private BigDecimal decimal;    public String getuId() {        return uId;    }    public void setuId(String uId) {        this.uId = uId;    }    public String getOrderId() {        return orderId;    }    public void setOrderId(String orderId) {        this.orderId = orderId;    }    public Date getOrderTime() {        return orderTime;    }    public void setOrderTime(Date orderTime) {        this.orderTime = orderTime;    }    public Date getSku() {        return sku;    }    public void setSku(Date sku) {        this.sku = sku;    }    public Date getSkuName() {        return skuName;    }    public void setSkuName(Date skuName) {        this.skuName = skuName;    }    public BigDecimal getDecimal() {        return decimal;    }    public void setDecimal(BigDecimal decimal) {        this.decimal = decimal;    }    @Override    public String toString() {        return "POPOrder{" +                "uId='" + uId + '\'' +                ", orderId='" + orderId + '\'' +                ", orderTime=" + orderTime +                ", sku=" + sku +                ", skuName=" + skuName +                ", decimal=" + decimal +                '}';    }}

package com.zixieqing.o2instanceadapter;import java.util.Date;/** * 
@description  : 该类功能  目标角色：统一消息体 * 
 * 
@package      : com.zixieqing.o2instanceadapter
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class Message {    /**     * 用户ID     */    private String userId;    /**     * 业务ID     */    private String bizId;    /**     * 业务时间     */    private Date bizTime;    /**     * 业务描述     */    private String desc;    public String getUserId() {        return userId;    }    public void setUserId(String userId) {        this.userId = userId;    }    public String getBizId() {        return bizId;    }    public void setBizId(String bizId) {        this.bizId = bizId;    }    public Date getBizTime() {        return bizTime;    }    public void setBizTime(Date bizTime) {        this.bizTime = bizTime;    }  /**   * 注意这里做了一个小动作   */    public void setBizTime(String bizTime) {        this.bizTime = new Date(Long.parseLong(bizTime));    }    public String getDesc() {        return desc;    }    public void setDesc(String desc) {        this.desc = desc;    }}

package com.zixieqing.o2instanceadapter;import com.alibaba.fastjson.JSON;import java.lang.reflect.InvocationTargetException;import java.util.Map;/** * 
@description  : 该类功能  消息适配器 * 
 * 
@package      : com.zixieqing.o2instanceadapter
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class MessageAdapter {    /**     * 消息适配     * @param jsonStr 要适配的对象字符串 如：InternalOrder     * @param filedMap 字段映射关系   如：userId ——> uId     * @return 转换成的统一消息体     */    public static Message msgAdapter(String jsonStr, Map filedMap) throws NoSuchMethodException,            IllegalAccessException, InvocationTargetException {        Map instance = JSON.parseObject(jsonStr, Map.class);        Message message = new Message();        for (String key : filedMap.keySet()) {            Object val = instance.get(filedMap.get(key));            // 给消息通用体Message赋值            Message.class.getMethod("set" + key.substring(0, 1).toUpperCase() + key.substring(1), String.class)                    .invoke(message, val.toString());        }        return message;    }}

package com.zixieqing;import com.alibaba.fastjson.JSON;import com.zixieqing.o2instanceadapter.msg.InternalOrder;import com.zixieqing.o2instanceadapter.Message;import com.zixieqing.o2instanceadapter.MessageAdapter;import org.junit.Test;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.lang.reflect.InvocationTargetException;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;import java.util.HashMap;/** * 
@description  : 该类功能  测试 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 * 
@version      : V1.0.0
 */public class ApiTest {    private Logger logger = LoggerFactory.getLogger(ApiTest.class);    @Test    public void instanceAdapterTest() throws ParseException, NoSuchMethodException,            IllegalAccessException, InvocationTargetException {        Date data = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2022-12-13 10:39:40");        InternalOrder internalOrder = new InternalOrder();        internalOrder.setOrderId(System.nanoTime() + "");        internalOrder.setUid(System.currentTimeMillis() + "");        internalOrder.setCreateOrderTime(data);        internalOrder.setSku("10888787897898798");        HashMap filedMap = new HashMap();        filedMap.put("userId", "uid");        filedMap.put("bizId", "orderId");        filedMap.put("bizTime", "createOrderTime");        // 进行转换        Message msgAdapter = MessageAdapter.msgAdapter(JSON.toJSONString(internalOrder), filedMap);        logger.info("适配前：{}",JSON.toJSONString(internalOrder));        logger.info("适配后：{}", JSON.toJSONString(msgAdapter));    }}

package com.zixieqing;/** * 
@description  : 该类功能  抽象组件：电话 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 */public interface AbstractPhone {    /**     * 基本功能：通话     * @return 通话内容     */    String call();    /**     * 基本功能：发短信     * @return 短信内容     */    String sendMessage();}

package com.zixieqing.impl;import com.zixieqing.AbstractPhone;/** * 
@description  : 该类功能  具体组件：实现抽象组件的行为 * 
 * 
@package      : com.zixieqing.impl
 * 
@author       : ZiXieqing
 */public class PhoneImpl implements AbstractPhone {    /**     * 基本功能：通话     *     * @return 通话内容     */    @Override    public String call() {        return "电话基本功能：进行通话";    }    /**     * 基本功能：发短信     *     * @return 短信内容     */    @Override    public String sendMessage() {        return "电话基本功能：发短信";    }}

package com.zixieqing.decorator;import com.zixieqing.AbstractPhone;/** * 
@description  : 该类功能  抽象装饰器：对具体组件进行扩展 * 
 * 
@package      : com.zixieqing.decorator
 * 
@author       : ZiXieqing
 */public abstract class AbstractPhoneDecorator implements AbstractPhone{    /**     * 聚合抽象组件     *    如果这个类中只有一个方法的话，可以直接把抽象组件引用做参数传递，参考：Spring的BeanDefinitionDecorator     *    也可以根据情况选择耦合度更强一点的组合，看实际情况即可，只要这个抽象装饰器中有抽象组件的引用即可，设计模式不是一层不变的     */    protected AbstractPhone abstractPhone;    public AbstractPhoneDecorator(AbstractPhone abstractPhone) {        this.abstractPhone = abstractPhone;    }    /**     * 基本功能：通话     *     * @return 通话内容     */    @Override    public String call() {        return this.abstractPhone.call();    }    /**     * 基本功能：发短信     *     * @return 短信内容     */    @Override    public String sendMessage() {        return this.abstractPhone.sendMessage();    }    /**     * 扩展功能：看电视     */    public abstract void watchTV();}

package com.zixieqing.decorator.impl;import com.zixieqing.AbstractPhone;import com.zixieqing.decorator.AbstractPhoneDecorator;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 
@description  : 该类功能  具体装饰器：不改变原有类（具体组件）的前提下，扩展其功能 * 
 * 
@package      : com.zixieqing.decorator.impl
 * 
@author       : ZiXieqing
 */public class PhoneImplDecorator extends AbstractPhoneDecorator {    private Logger logger = LoggerFactory.getLogger(PhoneImplDecorator.class);    public PhoneImplDecorator(AbstractPhone abstractPhone) {        super(abstractPhone);    }    /**     * 扩展功能：看电视     */    @Override    public void watchTV() {        logger.info("正在观看：精钢葫芦娃");    }}

package com.zixieqing;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException;/** * 
@description  : 该类功能  充当子系统功能之一：文件加载 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 */public class FileLoad {    private Logger logger = LoggerFactory.getLogger(FileLoad.class);    /**     * 加载文件     * @param filePath 文件路径     * @return 加载出来的内容     */    public String loadFile(String filePath) {        logger.info("即将读取文件内容！");        BufferedReader br = null;        StringBuffer result = new StringBuffer();        try {            br = new BufferedReader(new FileReader(filePath));            String data = "";            while (null != (data = br.readLine())) {                result.append("\n").append(data);            }        } catch (IOException e) {            e.printStackTrace();        } finally {            if (null != br) {                try {                    br.close();                    logger.info("文件读取完毕！");                } catch (IOException e) {                    e.printStackTrace();                }            }        }        return result.toString();    }}

package com.zixieqing;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 
@description  : 该类功能  充当子系统功能之一：文件加密 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 */public class FileEncrypt {    private Logger logger = LoggerFactory.getLogger(FileEncrypt.class);    /**     * 
@description  : 该方法功能 加密文件     * 
     * 
@methodName   : encryptFile
     * 
@author: ZiXieqing
     * @param text  要加密的内容     * @return java.lang.String 加密后的内容     */    public String encryptFile(String text) {        logger.info("即将对文件内容进行加密！");        // 简单地对文本内容进行反转        String result = new StringBuffer(text).reverse().toString();        logger.info("文件内容加密成功");        return result;    }}

package com.zixieqing;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.io.FileOutputStream;import java.io.IOException;import java.nio.charset.StandardCharsets;/** * 
@description  : 该类功能  充当子系统功能之一：写文件 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 */public class FileWrite {    private Logger logger = LoggerFactory.getLogger(FileWrite.class);    /**     * 
@description  : 该方法功能 写文件     * 
     * 
@methodName   : writeFile
     * 
@author: ZiXieqing
     * @param filePath 要写入的路径     * @param text  要写入的内容     * @return boolean 是否写入成功     */    public boolean writeFile(String filePath, String text) {        FileOutputStream fos = null;        try {            logger.info("正在进行文件写入！");            fos = new FileOutputStream(filePath);            fos.write(text.getBytes(StandardCharsets.UTF_8));            logger.info("文件写入完毕！");            return true;        } catch (IOException e) {            logger.info("文件写入失败!");            e.printStackTrace();            return false;        } finally {            if (null != fos) {                try {                    fos.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }    }}

package com.zixieqing;import java.util.concurrent.atomic.AtomicReference;/** * 
@description  : 该类功能  门面角色：单例的 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 */public class FileFacade {    private static final AtomicReference INSTANCE = new AtomicReference();    /**     * 加载文件     */    private FileLoad fileLoad;    /**     * 写入文件     */    private FileWrite fileWrite;    /**     * 文件加密     */    private FileEncrypt fileEncrypt;    private FileFacade() {        fileLoad = new FileLoad();        fileWrite = new FileWrite();        fileEncrypt = new FileEncrypt();    }    /**     * 
@description  : 该方法功能 加载文件     * 
     * 
@methodName   : fileLoad
     * 
@author: ZiXieqing
     * @param filePath  文件路径     * @return java.lang.String 加载出来的文件     */    public String fileLoad(String filePath) {        return fileLoad.loadFile(filePath);    }    /**     * 
@description  : 该方法功能 加密文件     * 
     * 
@methodName   : fileEncrypt
     * 
@author: ZiXieqing
     * @param text  要加密的内容     * @return java.lang.String 加密后的内容     */    public String fileEncrypt(String text) {        return fileEncrypt.encryptFile(text);    }    /**     * 
@description  : 该方法功能 写文件     * 
     * 
@methodName   : fileWrite
     * 
@author: ZiXieqing
     * @param filePath 要写入的路径     * @param text  要写入的内容     * @return boolean 是否写入成功     */    public boolean fileWrite(String filePath, String text) {        return fileWrite.writeFile(filePath, text);    }    public static FileFacade getInstance() {        while (true) {            FileFacade FILEFACADE_INSTANCE = INSTANCE.get();            if (null != FILEFACADE_INSTANCE) return FILEFACADE_INSTANCE;            INSTANCE.compareAndSet(null, new FileFacade());            return INSTANCE.get();        }    }}

package com.zixieqing;import org.junit.Test;/** * 
@description  : 该类功能  测试 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 */public class ApiTest {    @Test    public void facadeTest() {        FileFacade fileFacade = FileFacade.getInstance();        boolean result = fileFacade.fileWrite("src/main/resources/encryptText.txt",                fileFacade.fileEncrypt(fileFacade.fileLoad("src/main/resources/originalText.txt")));        System.out.println("result = " + result);    }}

package com.zixieqing.o1transparent;/** * 
@description  : 该类功能  透明式组合模式：抽象组件 * 定义出树叶组件和数纸组件共同遵守的约定 * 
 * 
@package      : com.zixieqing.o1transparent
 * 
@author       : ZiXieqing
 */public abstract class MenuComponent {    /**     * 菜单或菜单项的名字     * @return String     */    public abstract String getName();    /**     * 添加下级子菜单     * @param menuComponent 要添加的子菜单组件     * @return boolean     */    public boolean add(MenuComponent menuComponent) {        throw new UnsupportedOperationException();    }    /**     * 删除下级子菜单项     * @param menuComponent 要删除的子菜单组件     * @return boolean     */    public boolean remove(MenuComponent menuComponent) {        throw new UnsupportedOperationException();    }    /**     * 获取子菜单项     * @param i 第i个子菜单     * @return MenuComponent     */    public MenuComponent getChild(int i) {        throw new UnsupportedOperationException();    }    /**     * 打印菜单     */    public abstract void print();}

package com.zixieqing.o1transparent.impl;import com.zixieqing.o1transparent.MenuComponent;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 
@description  : 该类功能  透明式组合模式：树叶角色 个体对象 * 一个个的个体对象 组成 组合对象 * 定义组合对象的原始对象的行为 * 此对象没有下级的子对象，因此：add、remove、getChild管理下级子对象的方法不支持 * 
 * 
@package      : com.zixieqing.o1transparent.impl
 * 
@author       : ZiXieqing
 */public class MenuItem extends MenuComponent {    private Logger logger = LoggerFactory.getLogger(MenuItem.class);    /**     * 菜单项的名字     */    private String name;    public MenuItem(String name) {        this.name = name;    }    /**     * 菜单或菜单项的名字     *     * @return String     */    @Override    public String getName() {        return this.name;    }    @Override    public void print() {        logger.info("{}",getName());    }}

package com.zixieqing.o1transparent.impl;import com.zixieqing.o1transparent.MenuComponent;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.util.ArrayList;import java.util.Iterator;import java.util.List;/** * 
@description  : 该类功能  透明式组合模式：树枝角色 * 此角色有下级的子对象，因此：有管理下级子对象的add、remove、getChild方法 * 
 * 
@package      : com.zixieqing.o1transparent.impl
 * 
@author       : ZiXieqing
 */public class Menu extends MenuComponent {    private Logger logger = LoggerFactory.getLogger(Menu.class);    private List menuComponents = new ArrayList();    /**     * 菜单的名字     */    private String name;    public Menu(String name) {        this.name = name;    }    /**     * 菜单或菜单项的名字     *     * @return String     */    @Override    public String getName() {        return this.name;    }    @Override    public boolean add(MenuComponent menuComponent) {        return this.menuComponents.add(menuComponent);    }    @Override    public boolean remove(MenuComponent menuComponent) {        return this.menuComponents.remove(menuComponent);    }    @Override    public MenuComponent getChild(int i) {        return this.menuComponents.get(i);    }    @Override    public void print() {        logger.info("{}", getName());        Iterator componentIterator = this.menuComponents.iterator();        while (componentIterator.hasNext()) {            MenuComponent menuComponent = (MenuComponent)componentIterator.next();            menuComponent.print();        }    }}

package com.zixieqing;import com.zixieqing.o1transparent.MenuComponent;import com.zixieqing.o1transparent.impl.Menu;import com.zixieqing.o1transparent.impl.MenuItem;import org.junit.Test;/** * 
@description  : 该类功能  测试 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 */public class ApiTest {    @Test    public void transparentTest() {        /*        * 构建树形结构        *            开发用户手册        *              /   \        *        管理             运维服务        *         |                 |        *      日志记录         数据同步    DB维护    资产申报    DB主机容器管理        * */        MenuComponent userManualMenu = new Menu("开发用户手册");        MenuComponent manageMenu = new Menu("管理");        MenuComponent devOpsServiceMenu = new Menu("运维服务");        userManualMenu.add(manageMenu);        userManualMenu.add(devOpsServiceMenu);        manageMenu.add(new MenuItem("日志记录"));        devOpsServiceMenu.add(new MenuItem("数据同步"));        devOpsServiceMenu.add(new MenuItem("DB维护"));        devOpsServiceMenu.add(new MenuItem("资产申报"));        devOpsServiceMenu.add(new MenuItem("DB主机容器管理"));        userManualMenu.print();    }}

package com.zixieqing.o1simple;/** * 
@description  : 该类功能  单纯亨元模式：抽象亨元角色 *                    规定出需要实现的公共接口 *                    外蕴状态以参数的形式传入 *    外蕴状态：随环境的改变而改变，由客户端保存，在亨元对象创建之后，在需要时传入到亨元对象内部 * 
 * 
@package      : com.zixieqing.o1simple
 * 
@author       : ZiXieqing
 */public abstract class AbstractFlyweight {    /**     * 业务操作方法     * @param externalState 外蕴状态     */    public abstract void operation(Character externalState);}

package com.zixieqing.o1simple.impl;import com.zixieqing.o1simple.AbstractFlyweight;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 
@description  : 该类功能  单纯亨元模式：具体亨元角色 * 
 * 
@package      : com.zixieqing.o1simple.impl
 * 
@author       : ZiXieqing
 */public class ConcreteFlyweight extends AbstractFlyweight {    private Logger logger = LoggerFactory.getLogger(ConcreteFlyweight.class);    /**     * 内蕴状态：存储在亨元对象内部，不会随着外部环境改变而改变     * 可以进行共享，由客户端调用时以参数传入     */    private Character internalState;    public ConcreteFlyweight(Character internalState) {        this.internalState = internalState;    }    /**     * 业务操作方法     *     * @param externalState 外蕴状态，不会随环境改变而改变，必须由客户端保存，客户端以参数形式传入     */    @Override    public void operation(Character externalState) {        logger.info("进入了 {} 类", this.getClass().getSimpleName());        logger.info("{} 的内蕴状态为：{}，hashcode为：{}",                this.getClass().getSimpleName(),                this.internalState,                this.internalState.hashCode());        logger.info("{} 的外蕴状态为：{}，hashcode为：{}",                this.getClass().getSimpleName(),                externalState,                externalState.hashCode());    }}

package com.zixieqing.o1simple;import com.zixieqing.o1simple.impl.ConcreteFlyweight;import java.util.HashMap;import java.util.Map;/** * 
@description  : 该类功能  单纯亨元模式：亨元工厂 负责创建和管理亨元角色 *                      客户端调用此工厂进行亨元对象的创建 *                      若是亨元对象需要外蕴状态的话，则由客户端调用此工厂时传入 *                      会检查系统中是否已经有了符合要求的亨元对象，有则返回，没有则创建 *                      此工厂在整个系统中是唯一的，因此：此工厂为单例模式 * 
 * 
@package      : com.zixieqing.o1simple
 * 
@author       : ZiXieqing
 */public class FlyweightFactory {    /**     * 聚合抽象亨元角色     */    private AbstractFlyweight flyweight;    /**     * 用来存储亨元对象，可以采用其他的存储机制     */    private Map flyweightHashMap = new HashMap();    private static volatile FlyweightFactory INSTANCE;    /**     * 创建亨元对象     * @param internalState 内蕴状态：由客户端调用时以形参传入     * @return 抽象亨元角色     */    public AbstractFlyweight factory(Character internalState) {        if (flyweightHashMap.containsKey(internalState)) return flyweightHashMap.get(internalState);        ConcreteFlyweight concreteFlyweight = new ConcreteFlyweight(internalState);        flyweightHashMap.put(internalState, concreteFlyweight);        return concreteFlyweight;    }    private FlyweightFactory() {    }    public static FlyweightFactory getInstance() {        if (null != INSTANCE) return INSTANCE;        synchronized (FlyweightFactory.class) {            if (null == INSTANCE) return new FlyweightFactory();        }        return INSTANCE;    }}

package com.zixieqing;import com.zixieqing.o1simple.AbstractFlyweight;import com.zixieqing.o1simple.FlyweightFactory;import org.junit.Test;/** * 
@description  : 该类功能  测试 * 
 * 
@package      : com.zixieqing
 * 
@author       : ZiXieqing
 */public class ApiTest {    @Test    public void simpleFlyweightTest() {        FlyweightFactory flyweightFactory = FlyweightFactory.getInstance();        AbstractFlyweight abstractFlyweight_a = flyweightFactory.factory(new Character('a'));        System.out.println(abstractFlyweight_a.hashCode());        // 由客户端以参数的形式传入外蕴状态        abstractFlyweight_a.operation('紫');        AbstractFlyweight abstractFlyweight_b = flyweightFactory.factory(new Character('b'));        System.out.println(abstractFlyweight_b.hashCode());        abstractFlyweight_b.operation('邪');        AbstractFlyweight abstractFlyweight_c = flyweightFactory.factory(new Character('a'));        System.out.println(abstractFlyweight_c.hashCode());        abstractFlyweight_c.operation('紫');    }}

192960055116:06:34.253 [main] INFO  c.z.o1simple.impl.ConcreteFlyweight - 进入了 ConcreteFlyweight 类16:06:34.255 [main] INFO  c.z.o1simple.impl.ConcreteFlyweight - ConcreteFlyweight 的内蕴状态为：a，hashcode为：9716:06:34.255 [main] INFO  c.z.o1simple.impl.ConcreteFlyweight - ConcreteFlyweight 的外蕴状态为：紫，hashcode为：32043187949218416:06:34.255 [main] INFO  c.z.o1simple.impl.ConcreteFlyweight - 进入了 ConcreteFlyweight 类16:06:34.255 [main] INFO  c.z.o1simple.impl.ConcreteFlyweight - ConcreteFlyweight 的内蕴状态为：b，hashcode为：9816:06:34.255 [main] INFO  c.z.o1simple.impl.ConcreteFlyweight - ConcreteFlyweight 的外蕴状态为：邪，hashcode为：37034192960055116:06:34.255 [main] INFO  c.z.o1simple.impl.ConcreteFlyweight - 进入了 ConcreteFlyweight 类16:06:34.255 [main] INFO  c.z.o1simple.impl.ConcreteFlyweight - ConcreteFlyweight 的内蕴状态为：a，hashcode为：9716:06:34.255 [main] INFO  c.z.o1simple.impl.ConcreteFlyweight - ConcreteFlyweight 的外蕴状态为：紫，hashcode为：32043

package com.zixieqing.o2composite;/** * 
@description  : 该类功能  复合亨元模式：抽象亨元角色 *  制定出需要实现的公共接口 *  需要外蕴状态的操作可以通过调用业务方法以参数传入 *  可以做到：并不是所有的亨元对象都是可以共享的，在具体亨元类中做处理即可 * 
 * 
@package      : com.zixieqing.o2composite
 * 
@author       : ZiXieqing
 */public abstract class Flyweight {    /**     * 业务操作方法     * @param externalState 外蕴状态     */    public abstract void operation(String externalState);}

package com.zixieqing.o2composite.impl;import com.zixieqing.o2composite.Flyweight;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 
@description  : 该类功能  复合亨元模式：具体亨元角色  又叫单纯具体亨元角色 相当于合成模式中的树叶角色 * 
 * 
@package      : com.zixieqing.o2composite.impl
 * 
@author       : ZiXieqing
 */public class FlyweightImpl extends Flyweight {    private Logger logger = LoggerFactory.getLogger(FlyweightImpl.class);    /**     * 内蕴状态     */    private String internalState;    public FlyweightImpl(String internalState) {        this.internalState = internalState;    }    /**     * 业务操作方法     *     * @param externalState 外蕴状态     */    @Override    public void operation(String externalState) {        logger.info("进入了 {} 类", this.getClass().getSimpleName());        logger.info("{} 的内蕴状态为：{}，hashcode为：{}",                this.getClass().getSimpleName(),                this.internalState,                this.internalState.hashCode());        logger.info("{} 的外蕴状态为：{}，hashcode为：{}",                this.getClass().getSimpleName(),                externalState,                externalState.hashCode());    }}

package com.zixieqing.o2composite.impl;import com.zixieqing.o2composite.Flyweight;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.util.HashMap;import java.util.Map;/** * 
@description  : 该类功能  复合亨元模式：复合亨元角色 类似组合模式中的树枝角色 *  又叫不可共享亨元对象， 此角色所代表的的对象时不可以共享的，但一个复合亨元对象可以分解为多个单纯亨元对象 *  复合亨元对象是由单纯亨元对象（FlyweightImpl）组合而来，所以复合亨元对象可以也具有add、remove方法 *  一个复合亨元对象中的所有单纯亨元对象的外蕴状态 和 复合亨元对象的外蕴状态是相等的 *  但：一个复合亨元对象中的单纯亨元对象（FlyweightImpl）彼此之间的内蕴状态不同，不然没意义了 * 
 * 
@package      : com.zixieqing.o2composite.impl
 * 
@author       : ZiXieqing
 */public class CompositeFlyweightImpl extends Flyweight {    private Logger logger = LoggerFactory.getLogger(CompositeFlyweightImpl.class);    /**     * Flyweight实例容器     */    private Map flyweightMap = new HashMap();    /**     * 添加Flyweight实例     * @param key 键     * @param value 值     */    public void addFlyweight(String key, Flyweight value) {        flyweightMap.put(key, value);    }    /**     * 业务操作方法     *     * @param externalState 外蕴状态     */    @Override    public void operation(String externalState) {        logger.info("进入了 {} ", this.getClass().getSimpleName());        Flyweight flyweightInstance;        for (Map.Entry characterFlyweightEntry : flyweightMap.entrySet()) {            flyweightInstance = characterFlyweightEntry.getValue();            flyweightInstance.operation(externalState);        }    }}

package com.zixieqing.o2composite;import com.zixieqing.o2composite.impl.CompositeFlyweightImpl;import com.zixieqing.o2composite.impl.FlyweightImpl;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.util.HashMap;import java.util.Map;/** * 
@description  : 该类功能  复合亨元模式：亨元工厂  一样还是单例 负责创建于管理亨元角色 * 此角色必须保证亨元对象可以被系统适当地共享 * 当一个客户端对象调用一个亨元对象时，亨元工厂会检查系统中是否已经有一个符合要求的亨元对象， *     若有则提供这个已有的亨元对象，若无则亨元工厂应创建一个合适的亨元对象 * 
 * 
@package      : com.zixieqing.o2composite
 * 
@author       : ZiXieqing
 */public class CompositeFlyweightFactory {    private Logger logger = LoggerFactory.getLogger(CompositeFlyweightFactory.class);    private static volatile CompositeFlyweightFactory INSTANCE;    /**     * 装单纯亨元对象 和 复合亨元对象的容器     */    private Map flyweightMap = new HashMap();    /**     * 获取单纯亨元对象     * @param externalState 外蕴状态     * @return Flyweight     */    public Flyweight simpleFlyweightFactory(String externalState) {        logger.info("进入 {} 的 compositeFlyweightFactory 方法", this.getClass().getSimpleName());        if (flyweightMap.containsKey(externalState)) return flyweightMap.get(externalState);        FlyweightImpl flyweight = new FlyweightImpl(externalState);        flyweightMap.put(externalState, flyweight);        return flyweight;    }    /**     * 获取复合亨元对象     * @param externalState 外蕴状态     * @return Flyweight     */    public Flyweight compositeFlyweightFactory(String externalState) {        logger.info("进入 {} 的 compositeFlyweightFactory 方法", this.getClass().getSimpleName());        CompositeFlyweightImpl compositeFlyweight = new CompositeFlyweightImpl();        compositeFlyweight.addFlyweight(externalState, this.simpleFlyweightFactory(externalState));        return compositeFlyweight;    }    private CompositeFlyweightFactory() {    }    /**     * 获取工厂实例     * @return CompositeFlyweightFactory     */    public static CompositeFlyweightFactory getInstance() {        if (null != INSTANCE) return INSTANCE;        synchronized (CompositeFlyweightFactory.class) {            if (null == INSTANCE) {                INSTANCE = new CompositeFlyweightFactory();            }        }        return INSTANCE;    }}