package samples;

/**

 * 程序猿类

 * @author louluan

 */

public class Programmer {  

    public void code()

    {

        System.out.println("I'm a Programmer,Just Coding.....");

    }

}  

package samples;

/**

 * 自定义一个类加载器，用于将字节码转换为class对象

 * @author louluan

 */

public class MyClassLoader extends ClassLoader {  

    public Class<?> defineMyClass( byte[] b, int off, int len)

    {

        return super.defineClass(b, off, len);

    }  

}  

package samples;  

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.net.URL;  

public class MyTest {  

    public static void main(String[] args) throws IOException {

        //读取本地的class文件内的字节码，转换成字节码数组

        File file = new File(".");

        InputStream  input = new FileInputStream(file.getCanonicalPath()+"\\bin\\samples\\Programmer.class");

        byte[] result = new byte[1024];  

        int count = input.read(result);

        // 使用自定义的类加载器将 byte字节码数组转换为对应的class对象

        MyClassLoader loader = new MyClassLoader();

        Class clazz = loader.defineMyClass( result, 0, count);

        //测试加载是否成功，打印class 对象的名称

        System.out.println(clazz.getCanonicalName());  

               //实例化一个Programmer对象

               Object o= clazz.newInstance();

               try {

                   //调用Programmer的code方法

                    clazz.getMethod("code", null).invoke(o, null);

                   } catch (IllegalArgumentException | InvocationTargetException

                        | NoSuchMethodException | SecurityException e) {

                     e.printStackTrace();

                  }

 }

}  

package com.samples;

import java.io.PrintStream;  

public class Programmer {  

    public void code()

    {

        System.out.println("I'm a Programmer,Just Coding.....");

    }

}  

package samples;  

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;  

import org.objectweb.asm.ClassWriter;

import org.objectweb.asm.MethodVisitor;

import org.objectweb.asm.Opcodes;

public class MyGenerator {  

    public static void main(String[] args) throws IOException {  

        System.out.println();

        ClassWriter classWriter = new ClassWriter(0);

        // 通过visit方法确定类的头部信息

        classWriter.visit(Opcodes.V1_7,// java版本

                Opcodes.ACC_PUBLIC,// 类修饰符

                "Programmer", // 类的全限定名

                null, "java/lang/Object", null);  

        //创建构造函数

        MethodVisitor mv = classWriter.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);

        mv.visitCode();

        mv.visitVarInsn(Opcodes.ALOAD, 0);

        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>","()V");

        mv.visitInsn(Opcodes.RETURN);

        mv.visitMaxs(1, 1);

        mv.visitEnd();  

        // 定义code方法

        MethodVisitor methodVisitor = classWriter.visitMethod(Opcodes.ACC_PUBLIC, "code", "()V",

                null, null);

        methodVisitor.visitCode();

        methodVisitor.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out",

                "Ljava/io/PrintStream;");

        methodVisitor.visitLdcInsn("I'm a Programmer,Just Coding.....");

        methodVisitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println",

                "(Ljava/lang/String;)V");

        methodVisitor.visitInsn(Opcodes.RETURN);

        methodVisitor.visitMaxs(2, 2);

        methodVisitor.visitEnd();

        classWriter.visitEnd();

        // 使classWriter类已经完成

        // 将classWriter转换成字节数组写到文件里面去

        byte[] data = classWriter.toByteArray();

        File file = new File("D://Programmer.class");

        FileOutputStream fout = new FileOutputStream(file);

        fout.write(data);

        fout.close();

    }

}  

import javassist.ClassPool;

import javassist.CtClass;

import javassist.CtMethod;

import javassist.CtNewMethod;  

public class MyGenerator {  

    public static void main(String[] args) throws Exception {

        ClassPool pool = ClassPool.getDefault();

        //创建Programmer类

        CtClass cc= pool.makeClass("com.samples.Programmer");

        //定义code方法

        CtMethod method = CtNewMethod.make("public void code(){}", cc);

        //插入方法代码

        method.insertBefore("System.out.println(\"I'm a Programmer,Just Coding.....\");");

        cc.addMethod(method);

        //保存生成的字节码

        cc.writeFile("d://temp");

    }

}  

package com.foo.proxy;  

/**

 * 售票服务接口实现类，车站

 * @author louluan

 */

public class Station implements TicketService {  

    @Override

    public void sellTicket() {

        System.out.println("\n\t售票.....\n");

    }  

    @Override

    public void inquire() {

        System.out.println("\n\t问询。。。。\n");

    }  

    @Override

    public void withdraw() {

        System.out.println("\n\t退票......\n");

    }  

}  

package com.foo.proxy;

/**

 * 售票服务接口

 * @author louluan

 */

public interface TicketService {  

    //售票

    public void sellTicket();  

    //问询

    public void inquire();  

    //退票

    public void withdraw();  

}  

TicketService 服务接口

package com.foo.proxy;  

/**

 * 车票代售点

 * @author louluan

 *

 */

public class StationProxy implements TicketService {  

    private Station station;  

    public StationProxy(Station station){

        this.station = station;

    }  

    @Override

    public void sellTicket() {  

        // 1.做真正业务前，提示信息

        this.showAlertInfo("××××您正在使用车票代售点进行购票，每张票将会收取5元手续费！××××");

        // 2.调用真实业务逻辑

        station.sellTicket();

        // 3.后处理

        this.takeHandlingFee();

        this.showAlertInfo("××××欢迎您的光临，再见！××××\n");  

    }  

    @Override

    public void inquire() {

        // 1做真正业务前，提示信息

        this.showAlertInfo("××××欢迎光临本代售点，问询服务不会收取任何费用，本问询信息仅供参考，具体信息以车站真实数据为准！××××");

        // 2.调用真实逻辑

        station.inquire();

        // 3。后处理

        this.showAlertInfo("××××欢迎您的光临，再见！××××\n");

    }  

    @Override

    public void withdraw() {

        // 1。真正业务前处理

        this.showAlertInfo("××××欢迎光临本代售点，退票除了扣除票额的20%外，本代理处额外加收2元手续费！××××");

        // 2.调用真正业务逻辑

        station.withdraw();

        // 3.后处理

        this.takeHandlingFee();  

    }  

    /*

     * 展示额外信息

     */

    private void showAlertInfo(String info) {

        System.out.println(info);

    }  

    /*

     * 收取手续费

     */

    private void takeHandlingFee() {

        System.out.println("收取手续费，打印发票。。。。。\n");

    }  

}  

package com.foo.proxy;  

import java.lang.reflect.Constructor;  

import javassist.*;

public class Test {  

    public static void main(String[] args) throws Exception {

       createProxy();

    }  

    /*

     * 手动创建字节码

     */

    private static void createProxy() throws Exception

    {

        ClassPool pool = ClassPool.getDefault();  

        CtClass cc = pool.makeClass("com.foo.proxy.StationProxy");  

        //设置接口

        CtClass interface1 = pool.get("com.foo.proxy.TicketService");

        cc.setInterfaces(new CtClass[]{interface1});  

        //设置Field

        CtField field = CtField.make("private com.foo.proxy.Station station;", cc);  

        cc.addField(field);  

        CtClass stationClass = pool.get("com.foo.proxy.Station");

        CtClass[] arrays = new CtClass[]{stationClass};

        CtConstructor ctc = CtNewConstructor.make(arrays,null,CtNewConstructor.PASS_NONE,null,null, cc);

        //设置构造函数内部信息

        ctc.setBody("{this.station=$1;}");

        cc.addConstructor(ctc);  

        //创建收取手续 takeHandlingFee方法

        CtMethod takeHandlingFee = CtMethod.make("private void takeHandlingFee() {}", cc);

        takeHandlingFee.setBody("System.out.println(\"收取手续费，打印发票。。。。。\");");

        cc.addMethod(takeHandlingFee);  

        //创建showAlertInfo 方法

        CtMethod showInfo = CtMethod.make("private void showAlertInfo(String info) {}", cc);

        showInfo.setBody("System.out.println($1);");

        cc.addMethod(showInfo);  

        //sellTicket

        CtMethod sellTicket = CtMethod.make("public void sellTicket(){}", cc);

        sellTicket.setBody("{this.showAlertInfo(\"××××您正在使用车票代售点进行购票，每张票将会收取5元手续费！××××\");"

                + "station.sellTicket();"

                + "this.takeHandlingFee();"

                + "this.showAlertInfo(\"××××欢迎您的光临，再见！××××\");}");

        cc.addMethod(sellTicket);  

        //添加inquire方法

        CtMethod inquire = CtMethod.make("public void inquire() {}", cc);

        inquire.setBody("{this.showAlertInfo(\"××××欢迎光临本代售点，问询服务不会收取任何费用，本问询信息仅供参考，具体信息以车站真实数据为准！××××\");"

        + "station.inquire();"

        + "this.showAlertInfo(\"××××欢迎您的光临，再见！××××\");}"

        );

        cc.addMethod(inquire);  

        //添加widthraw方法

        CtMethod withdraw = CtMethod.make("public void withdraw() {}", cc);

        withdraw.setBody("{this.showAlertInfo(\"××××欢迎光临本代售点，退票除了扣除票额的20%外，本代理处额外加收2元手续费！××××\");"

                + "station.withdraw();"

                + "this.takeHandlingFee();}"

                );

        cc.addMethod(withdraw);  

        //获取动态生成的class

        Class c = cc.toClass();

        //获取构造器

        Constructor constructor= c.getConstructor(Station.class);

        //通过构造器实例化

        TicketService o = (TicketService)constructor.newInstance(new Station());

        o.inquire();  

        cc.writeFile("D://test");

    }  

}  

package com.foo.proxy;  

import java.io.FileOutputStream;

import java.io.IOException;

import java.lang.reflect.Proxy;

import sun.misc.ProxyGenerator;  

public class ProxyUtils {  

    /*

     * 将根据类信息 动态生成的二进制字节码保存到硬盘中，

     * 默认的是clazz目录下

         * params :clazz 需要生成动态代理类的类

         * proxyName : 为动态生成的代理类的名称

         */

    public static void generateClassFile(Class clazz,String proxyName)

    {

        //根据类信息和提供的代理类名称，生成字节码

                byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces());

        String paths = clazz.getResource(".").getPath();

        System.out.println(paths);

        FileOutputStream out = null;    

        try {

            //保留到硬盘中

            out = new FileOutputStream(paths+proxyName+".class");

            out.write(classFile);

            out.flush();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            try {

                out.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }  

}  

import com.foo.proxy.Rechargable;

import com.foo.proxy.Vehicle;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.lang.reflect.UndeclaredThrowableException;

/**

 生成的动态代理类的组织模式是继承Proxy类，然后实现需要实现代理的类上的所有接口，而在实现的过程中，则是通过将所有的方法都交给了InvocationHandler来处理

*/

 public final class ElectricCarProxy extends Proxy

  implements Rechargable, Vehicle

{

  private static Method m1;

  private static Method m3;

  private static Method m4;

  private static Method m0;

  private static Method m2;  

  public ElectricCarProxy(InvocationHandler paramInvocationHandler)

    throws

  {

    super(paramInvocationHandler);

  }  

  public final boolean equals(Object paramObject)

    throws

  {

    try

    { // 方法功能实现交给InvocationHandler处理

      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();

    }

    catch (Error|RuntimeException localError)

    {

      throw localError;

    }

    catch (Throwable localThrowable)

    {

      throw new UndeclaredThrowableException(localThrowable);

    }

  }  

  public final void recharge()

    throws

  {

    try

    {  

       // 方法功能实现交给InvocationHandler处理  

      this.h.invoke(this, m3, null);

      return;

    }

    catch (Error|RuntimeException localError)

    {

      throw localError;

    }

    catch (Throwable localThrowable)

    {

      throw new UndeclaredThrowableException(localThrowable);

    }

  }  

  public final void drive()

    throws

  {

    try

    {  

       // 方法功能实现交给InvocationHandler处理  

      this.h.invoke(this, m4, null);

      return;

    }

    catch (Error|RuntimeException localError)

    {

      throw localError;

    }

    catch (Throwable localThrowable)

    {

      throw new UndeclaredThrowableException(localThrowable);

    }

  }  

  public final int hashCode()

    throws

  {

    try

    {  

       // 方法功能实现交给InvocationHandler处理  

       return ((Integer)this.h.invoke(this, m0, null)).intValue();

    }

    catch (Error|RuntimeException localError)

    {

      throw localError;

    }

    catch (Throwable localThrowable)

    {

      throw new UndeclaredThrowableException(localThrowable);

    }

  }  

  public final String toString()

    throws

  {

    try

    {  

       // 方法功能实现交给InvocationHandler处理

      return (String)this.h.invoke(this, m2, null);

    }

    catch (Error|RuntimeException localError)

    {

      throw localError;

    }

    catch (Throwable localThrowable)

    {

      throw new UndeclaredThrowableException(localThrowable);

    }

  }  

  static

  {

    try

    {  //为每一个需要方法对象，当调用相应的方法时，分别将方法对象作为参数传递给InvocationHandler处理

      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });

      m3 = Class.forName("com.foo.proxy.Rechargable").getMethod("recharge", new Class[0]);

      m4 = Class.forName("com.foo.proxy.Vehicle").getMethod("drive", new Class[0]);

      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);

      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);

      return;

    }

    catch (NoSuchMethodException localNoSuchMethodException)

    {

      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());

    }

    catch (ClassNotFoundException localClassNotFoundException)

    {

      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());

    }

  }

}  

package samples;

/**

 * 程序猿类

 * @author louluan

 */

public class Programmer {  

    public void code()

    {

        System.out.println("I'm a Programmer,Just Coding.....");

    }

}  

package samples;  

import java.lang.reflect.Method;  

import net.sf.cglib.proxy.MethodInterceptor;

import net.sf.cglib.proxy.MethodProxy;

/*

 * 实现了方法拦截器接口

 */

public class Hacker implements MethodInterceptor {

    @Override

    public Object intercept(Object obj, Method method, Object[] args,

            MethodProxy proxy) throws Throwable {

        System.out.println("**** I am a hacker,Let's see what the poor programmer is doing Now...");

        proxy.invokeSuper(obj, args);

        System.out.println("****  Oh,what a poor programmer.....");

        return null;

    }  

}  

package samples;  

import net.sf.cglib.proxy.Enhancer;  

public class Test {  

    public static void main(String[] args) {

        Programmer progammer = new Programmer();  

        Hacker hacker = new Hacker();

        //cglib 中加强器，用来创建动态代理

        Enhancer enhancer = new Enhancer();

                 //设置要创建动态代理的类

        enhancer.setSuperclass(progammer.getClass());

               // 设置回调，这里相当于是对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实行intercept()方法进行拦截

                enhancer.setCallback(hacker);

                Programmer proxy =(Programmer)enhancer.create();

                proxy.code();  

    }

}  

package samples;  

import java.lang.reflect.Method;

import net.sf.cglib.core.ReflectUtils;

import net.sf.cglib.core.Signature;

import net.sf.cglib.proxy.Callback;

import net.sf.cglib.proxy.Factory;

import net.sf.cglib.proxy.MethodInterceptor;

import net.sf.cglib.proxy.MethodProxy;  

public class Programmer

EnhancerByCGLIB

fa7aa2cd extends Programmer

  implements Factory

{

   //......省略

  private MethodInterceptor CGLIB$CALLBACK_0;  // Enchaner传入的methodInterceptor

   // ....省略

  public final void code()

  {

    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;

    if (tmp4_1 == null)

    {

      tmp4_1;

      CGLIB$BIND_CALLBACKS(this);//若callback 不为空，则调用methodInterceptor 的intercept()方法

    }

    if (this.CGLIB$CALLBACK_0 != null)

      return;

      //如果没有设置callback回调函数，则默认执行父类的方法

      super.code();

  }

   //....后续省略

}