设计模式1

1、简单工程（不想说）

2、工厂模式（不想说）

3、抽象工厂模式（不想说,友情看经典产品族的那个张图，一看就会）

4、原型模式：

        1、继承cloneable方法，返回super.clone(); 浅克隆，copy的是对象的引用

        2、继承cloneable方法，通过系列化，反系列化生成新的对象;,或者通过JSON对象转化string，在string转换成对象， 深克隆，copy的是值,

          jdk下中HashMap，ArrayList，实现cloneable，使用的是深克隆,.  代码就不展示

5、建造者模式： 请参考StringBulider 一直可追加  StringBuilder sb = new StringBuilder(); sb.append("aa").append("aa");

以上都是创建型的设计模式。为了创建对象

6、代理模式，静态代理我就不讲，静态代理单一，一个代理对象只能去为一个接口服务。

    1、jdk代理，前提条件：代理对象必须是个接口，通过实现InvocationHandler, 通过反射生成一个新类,在内存中可见

         

JdkProxy jdkProxy = new JdkProxy();
IPerson person = (IPerson) jdkProxy.getInstall(new LisiPerson());

// 断点下
person.find();

// 在内存中把字节码都到class文件

byte [] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{IPerson.class});
FileOutputStream fileOutputStream = new FileOutputStream("E:\\aa.class");
fileOutputStream.write(bytes);
fileOutputStream.close();

// 在反编译下如下java文件。如下，可以清晰可见jdk是通过反射来实现的

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import jdkproxy.IPerson;

public final class  extends Proxy implements IPerson {

   private static Method m1;
   private static Method m3;
   private static Method m2;
   private static Method m0;


   public (InvocationHandler var1) throws  {
      super(var1);
   }

   public final boolean equals(Object var1) throws  {
      try {
         return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
      } catch (RuntimeException | Error var3) {
         throw var3;
      } catch (Throwable var4) {
         throw new UndeclaredThrowableException(var4);
      }
   }

   public final void find() throws  {
      try {
         super.h.invoke(this, m3, (Object[])null);
      } catch (RuntimeException | Error var2) {
         throw var2;
      } catch (Throwable var3) {
         throw new UndeclaredThrowableException(var3);
      }
   }

   public final String toString() throws  {
      try {
         return (String)super.h.invoke(this, m2, (Object[])null);
      } catch (RuntimeException | Error var2) {
         throw var2;
      } catch (Throwable var3) {
         throw new UndeclaredThrowableException(var3);
      }
   }

   public final int hashCode() throws  {
      try {
         return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
      } catch (RuntimeException | Error var2) {
         throw var2;
      } catch (Throwable var3) {
         throw new UndeclaredThrowableException(var3);
      }
   }

   static {
      try {
         m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
         m3 = Class.forName("jdkproxy.IPerson").getMethod("find", new Class[0]);
         m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
         m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      } catch (NoSuchMethodException var2) {
         throw new NoSuchMethodError(var2.getMessage());
      } catch (ClassNotFoundException var3) {
         throw new NoClassDefFoundError(var3.getMessage());
      }
   }
}

   2、cglib代理，前提条件是类，而且不能私有，实现MethodInterceptor , 它实现是通过生成字节码（Enhaner）文件生成一个派生类去重写父类的方法

      

 

        

标签：var3,Object,throw,catch,new,设计模式,Class
来源： https://blog.csdn.net/wang1989cs/article/details/116035304