spring学习5之AOP编程代理（静态代理、动态代理、cglib代理）

AOP的概述

AOP解决OOP中遇到的一些问题.是OOP的延续和扩展.AOP可以对程序进行增强:不修改源码的情况下.
AOP可以进行权限校验,日志记录,性能监控,事务控制. 最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范.
底层实现:
代理机制:

Spring的AOP的底层用到两种代理机制：

• JDK的动态代理 :针对实现了接口的类产生代理.
• Cglib的动态代理 :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术 生成当前类的子类对象.

java的三种代理模式：静态代理、动态代理、cglib代理

代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改目标对象的前提下，提供额外的功能操作，扩展对象的功能。
简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强源对象的功能和简化访问方式。
举个例子，我们生活中去火车 站买火车票，人一多，就会非常拥挤，于是就有了代售点，我们通过代售点买火车票。这就是其中代理模式的体现，代售点代理了火车站对象，提供了购买火车票的方法。

一、静态代理

优点：可以在不修改目标对象的前提下扩展目标对象的功能。
缺点：
1.冗余。由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
2.不易维护。一旦接口增加方法，目标 对象与代理对象都要进行修改。

实例讲解：

1. 第一步：创建一个maven项目，项目名为springday3，在根目录先创建com.pp包，在改包下创建一个poxy包。然后创建一个Iuser接口

package com.pp.poxy;

public interface Iuser {
    void save();
}

2. 第二步：写一个userImpl的实现类，继承和实现 Iuser接口的方法。

package com.pp.poxy;

public class userImpl implements Iuser {
    public void save() {
        System.out.println("原有接口保存数据");
    }
}

3. 第三步：写一个代理类，首先去继承和实现Iuser接口，在改类中创建一个代理方法 userPoxy（）

package com.pp.poxy;
  /*
    * 代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，
    * 这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。
    * */
public class userPoxy implements Iuser {
    private Iuser iuser;

    public void save() {
        iuser.save();
        System.out.println("你要做的新功能");
    }
    public userPoxy(Iuser iuser){
        this.iuser=iuser;
    }

  

}

4. 第四步：编写一个测试类（这是通过代理类去加的）

package com.pp.poxy;

public class TestDemo {
    public static void main(String[] args) {
        Iuser iuser= new Iuser(){
            public void save() {
                System.out.println("我加对的第二个功能");
            }
        };

        userPoxy poxy = new userPoxy(iuser);  //创建了一个代理类，将创建的Iuser接口添加到了代理类
        poxy.save();

}

5. 第五步：测试结果

6. 总结
   以上内容是通过代理类的方式，也就是越过了实现类，自己创建了一个代理类继承我们这里的基类，然后再代理类中继承基类的方法，并且利用构造方法构造了基类。再测试类中，通过新建一个新建一个基类，我们再去初始化，再这里做我们自己的设置，最后我们将该类放入代理类中即可。通过代理类的方法，我们既可以不破坏实现类里面的代码也就是内部逻辑，还可以对原来的功能方法进行扩充。

二，动态代理

动态代理利用了JDK API，动态的再内存中构建代理对象，从而实现对目标对象的代理功能。动态代理就被城等JDK代理或接口代理。
静态代理与动态代理的主要区别：

• 静态代理再编译时已经实现，编译完成后代理类是一个实际的class文件
• 动态代理是运行时动态生成，即编译完成后没有实际的class文件，而是运行时动态生成类字节码，并加载到JVM中。
  特点：
  动态代理不需要实现接口，但要求目标对象必须实现接口，否则不能使用动态代理。

实例讲解：

1. 在 com.pp包先创建一个jdkpoxy包，创建一个UserDao类

package com.pp.jdkpoxy;

public interface UserDao {
    void save();
    void update();
}

2. 创建一个UserDaoImpl继承和实现UserDao

package com.pp.jdkpoxy;

public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("保存");
    }

    public void update() {
        System.out.println("更新");
    }
}

3. 创建一个JdkPoxyUtils代理类

package com.pp.jdkpoxy;

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

public class JdkPoxyUtils {
    /*jdk动态代理*/
    public static UserDao getPoxy(final UserDao dao){
        UserDao poxy=(UserDao)Proxy.newProxyInstance(dao.getClass().getClassLoader(),dao.getClass().getInterfaces(),new InvocationHandler(){
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if ("save".equals(method.getName())){
                    System.out.println("记录你数据库保存的日志");
                }
                return method.invoke(dao,args);
            }
        });
        return poxy;
    }
}

proxy下面的一个newProxyInstance（）方法，需要的参数有类加载器，类字节码对象，一个接口方法（需要被实例化使用）。这里if判断的内容，判断如果sava和我们拿到的代理类的方法一致就打印“记录日志”。

4. 编写测试类TestJdkPoxy

package com.pp.jdkpoxy;

import org.junit.Test;

public class TestJdkPoxy {
    @Test
    public void run(){
        UserDao poxy = JdkPoxyUtils.getPoxy(new UserDaoImpl());
        poxy.save();
    }
}

5. 效果展示

三、cglib代理

cdglib是一个第三方代码生成类库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。
cglib特点：

• JDK动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。
• 如果想代理没有实现接口的类，就可以使用CGLIB实现。
• CGLIB是一个强大的高性能的代码生成包，它可以在运行期间扩展Java类与实现Java接口。
• 它广泛的被许多AOP的框架使用，例如Spring Aop和dynaop，为它们提供方法的intercepter（拦截）
• Cglib包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新类。
• 不鼓励直接使用ASM，因为它需要你对JVM内部结构包括class文件的格式和指令集都很熟悉。
  cglib与动态代理最大的区别
• 使用动态代理的对象必须实现一个或者多个接口
• 使用cglib代理的对象无需实现接口，达到代理类无侵入。

实例演示

1. 在pom中引入cglib需要的jar包

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.5.RELEASE</version>
</dependency>

2. 在com.pp下创建CglibPoxy包，然后创建PersionDaoImpl直接写一个实现类。

package com.pp.CglibPoxy;

public class PersonDaoImpl {
    public void save() {
        System.out.println("保存");
    }

    public void update() {
        System.out.println("更新");
    }
}

3. 创建一个CglibUtils代理类

package com.pp.CglibPoxy;

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 CglibUtils {
    public static PersonDaoImpl getPoxy(){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(PersonDaoImpl.class);//要代理的类给了spring
        enhancer.setCallback(new MethodInterceptor(){

            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                if (method.getName().equals("save"))
                {
                    System.out.println("cglib动态代理的日志");
                }
                return methodProxy.invokeSuper(o,objects);
            }
        });

       PersonDaoImpl poxy= (PersonDaoImpl)enhancer.create();
       return poxy;
    }
}

这里代码创建Enhancer对象，调用setSuperclass（）方法，将要代理的类通过映射给了spring方法来管理，最后使用回调机制callback。

4. 创建测试类

package com.pp.CglibPoxy;

import org.junit.Test;

public class TestCglibdemo {
    @Test
    public void fun(){
        PersonDaoImpl poxy = CglibUtils.getPoxy();
        poxy.save();
    }
}

5. 测试结果