代理中的三种模式（静态代理、JDK动态代理、CGLIB动态代理）

第一种、静态代理

静态代理，静态代理就是一个一个的添加代理类，每一个类对应一个代理，

就好像写好了一个DAO,然后就再建一个类来重写dao，那个类跟DAO实现

是同级的，实现同一个接口，但是代理类内有个成员变量，就是要代理

的那个类的实例，然后再点出那个类的每一个方法，再插入新的东西，

这就是静态代理

代码部分

//接口
public interface MyService {

    public void add();
    public void delete();
    public void update();

}

//需要代理的类
package cn.lyj.service;

public class MyServiceImpl implements MyService{
    @Override
    public void add() {
        System.out.println("添加一个实体");
    }

    @Override
    public void delete() {
        System.out.println("删除一个实体");
    }

    @Override
    public void update() {
        System.out.println("更新一个实体信息");
    }
}

//对应的代理类
package cn.lyj.service;

public class MyServiceProxy implements MyService{

    private MyService myService;

    public MyServiceProxy(MyService myService){
        this.myService=myService;
    }

    @Override
    public void add() {
        System.out.println("事务安全开始...");  //代理类中新插入的打印
        myService.add();                      //被代理的功能
        System.out.println("事务安全结束...");
    }

    @Override
    public void delete() {
        System.out.println("事务安全开始...");
        myService.delete();
        System.out.println("事务安全结束...");
    }

    @Override
    public void update() {
        System.out.println("事务安全开始...");
        myService.update();
        System.out.println("事务安全结束...");
    }
}

//测试类
public class MyServiceTest {

    @Test                              //这里idea可以用Test直接实现main方法功能
    public void myService(){
        MyService myService1=new MyServiceImpl();               //需要代理的类
        MyService myServicepro=new MyServiceProxy(myService1);  //放到代理类中
        myServicepro.add();                                     //调用代理后的方法
    }

}

第二种、JDK动态代理

动态代理就不需要一个一个的建造代理类，直接写一个通用的类，不过

那个类是返回一个的是一个Object类，需要向下转型，需要用对应的接

口来接。

代码部分

//接口类
package cn.lyj.service;

public interface UserService2 {
    public void add();
    public void update();
    public void delete();

}

//需要代理的类
package cn.lyj.service;

public class UserServiceImpl2 implements UserService2{
    @Override
    public void add() {
        System.out.println("调用 UserDao ... add");
    }

    @Override
    public void update() {
        System.out.println("调用 UserDao ... update");
    }

    @Override
    public void delete() {
        System.out.println("调用 UserDao ... delete");
    }
}

//代理类
package cn.lyj.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//有接口，用jdk proxy 动态代理方式去替代静态代理
public class UserServiceJdkProxy implements InvocationHandler {

    private Object target; //核心业务对象

    //第一种方法

    public Object createProxy(Object targetObject){
        this.target = targetObject;
        return Proxy.newProxyInstance( //new 创建  Proxy代理 Instance实例
                targetObject.getClass().getClassLoader(),
                targetObject.getClass().getInterfaces(), this);
    }

    //方法对象.invoke(目标对象，参数)
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开启事务保护");
        System.out.println("方法名称：="+method.getName());
        Object obj=method.invoke(target,args);
        System.out.println("提交事务......");
        return obj;
    }


    //第二种方法，不用继承InvocationHandler接口

    public Object createProxy(Object targetObject){
        this.target = targetObject;
        return Proxy.newProxyInstance( //new 创建  Proxy代理 Instance实例
                targetObject.getClass().getClassLoader(),
                targetObject.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开启事务保护");
                        System.out.println("方法名称：="+method.getName());
                        Object obj=method.invoke(target,args);
                        System.out.println("提交事务......");
                        return obj;
                    }
                });
    }
}

//测试类
public class DemoUserServiceJdkProxy {

    public static void main(String[] args) {
        UserServiceJdkProxy proxy=new UserServiceJdkProxy();
        UserService2 userService=new UserServiceImpl2();
        UserService2 userService2=(UserService2) proxy.createProxy(userService);
        userService2.add();

    }

}

第三种、CGLIB代理

这个代理就是直接继承父类的东西，直接在父类的方法上，写上自己的

东西，再加上新的东西，然后通过super来调用父类的东西，插入新东西，

在调用的时候直接调那个子类。

代码部分

//需要代理的类
package cn.lyj.cglib;

public class AbcServiceImpl {

    public void add(){
        System.out.println("Abc ... 添加");
    }

    public void delete(){
        System.out.println("Abc ... 删除");
    }

}

//代理类
package cn.lyj.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class AbcCglib implements MethodInterceptor {

    //核心业务
    private Object target;

    public AbcCglib (Object target){
        this.target=target;
    }


    public Object createProxy(){
        // 使用CGLIB生成代理:
        // 1.声明增强类实例,用于生产代理类
        Enhancer enhancer = new Enhancer();
        // 2.设置被代理类字节码，CGLIB根据字节码生成被代理类的子类
        enhancer.setSuperclass(target.getClass());
        // 3.//设置回调函数，即一个方法拦截
        enhancer.setCallback(this);
        // 4.创建代理:
        return  enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("开始事务保护");
        Object ret= methodProxy.invokeSuper(o,objects);   //调用父类的实现方法

        return ret;
    }

}

//测试类
package cn.lyj.cglib;

public class Demo3 {

    public static void main(String[] args) {
        AbcServiceImpl abcService=new AbcServiceImpl();
        AbcCglib abcCglib= new AbcCglib(abcService);
        AbcServiceImpl a=(AbcServiceImpl) abcCglib.createProxy();
        a.add();
    }


}

额，由于写的太急加上这两天太困了，可能设置的类名随意了点，文字纯属个人理解，有误留言，参考请规范用类名