spring的aop思想

1.知识点总结

springAop:
    aop: 被称为 面向 切面编程 ， 是 oop 的 延续 ，升级版;

        oop ： Oriented Object programming
        aop ： Aspect Oriented programming

    aop作用： 简化代码量 ，可以动态的 监控程序的运行 ，并添加一些功能
                获取日志 ，添加事务等....

目标类:
    public class UserServiceImpl{

        public void add(User user){ };
        public void update(User user){ };
        public void delete(int id){ };
    }

实现方式就是 继承:
    public class UserServiceImplTwo extends UserServiceImpl{

         @Override
         public void add(){
            System.out.println("事务开启");

            System.out.println("向数据库中添加数据");

            System.out.println("事务关闭");
         }
    }

spring使用 aop的思想完成了 对 不修改 源码的情况下 添加功能；
  采用的是 代理模式;
    代理模式分:
     1)jdk 代理   什么时候用， 在 目标类 是由 接口 + 实现类的情况下 使用
         这个 不需要导入 任何 jar包 ，只要有 jdk环境即可

     2)cglib 代理  什么时候用 ， 在需要生成  目标类的 子类的情况下使用
         这个 需要导入 cglib.jar ,和  asm.jar的 依赖包
      管这种方式 叫 字节码增强代理


    cglib源码：
      目标类： UserServiceImpl
      功能类： Aspect

2.案例代码
1）工程架构图：

2）代码：

1.com.oracle.cglib_proxy包：
package com.oracle.cglib_proxy;

import com.oracle.service.UserService;
import com.oracle.serviceImpl.UserServiceImpl;
import com.oracle.util.Aspect;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class Cglib_proxy {
    public static UserServiceImpl getProxy(){

        //目标类
        UserServiceImpl us = new UserServiceImpl();
        //功能类
        Aspect aspect = new Aspect();
        //辅助类
        Enhancer enhancer = new Enhancer();
        //设置一个父类
        enhancer.setSuperclass(us.getClass());
        //给目标方法 添加功能
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                aspect.before();
                Object invoke = method.invoke(us, objects);
                aspect.after();
                return invoke;
            }
        });
        //创建代理类
        UserServiceImpl userServiceImpl = (UserServiceImpl)enhancer.create();
        return  userServiceImpl;
    }
}

2.com.oracle.jdk_proxy包：
package com.oracle.jdk_proxy;

import com.oracle.service.UserService;
import com.oracle.serviceImpl.UserServiceImpl;
import com.oracle.util.Aspect;

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

public class Jdk_proxy {
    public static UserService getProxy(){

        //目标类
        UserService us = new UserServiceImpl();
        //功能类
        Aspect aspect = new Aspect();
        //jdk代理
        UserService userService = (UserService)Proxy.newProxyInstance(us.getClass().getClassLoader(),
                new Class[]{UserService.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        aspect.before();
                        Object invoke = method.invoke(us, args);
                        aspect.after();
                        return invoke;
                    }
                });
        return  userService;
    }
}

3.com.oracle.service包：
package com.oracle.service;

import com.oracle.vo.User;

public interface UserService {
    public void addUser(User user);
    public void updateUser(User user);
    public void deleteUser(int id);
}

4.com.oracle.serviceImpl包：
package com.oracle.serviceImpl;

import com.oracle.service.UserService;
import com.oracle.vo.User;

public class UserServiceImpl implements UserService {

    @Override
    public void addUser(User user) {
        System.out.println("User 添加");
    }

    @Override
    public void updateUser(User user) {
        System.out.println("User 修改");
    }

    @Override
    public void deleteUser(int id) {
        System.out.println("User 删除");
    }
}

5.com.oracle.test包：
package com.oracle.test;

import com.oracle.cglib_proxy.Cglib_proxy;
import com.oracle.jdk_proxy.Jdk_proxy;
import com.oracle.service.UserService;
import com.oracle.serviceImpl.UserServiceImpl;
import com.oracle.vo.User;
import org.junit.Test;

public class Demo {
    @Test
    public void Testjdk_proxy(){
        UserService userService = Jdk_proxy.getProxy();
        userService.addUser(new User());
        System.out.println("============");
        userService.deleteUser(1);
        System.out.println("============");
        userService.updateUser(new User());

    }
    @Test
    public void Testcglib_proxy(){
        UserService userService = Cglib_proxy.getProxy();
        userService.addUser(new User());
        System.out.println("============");
        userService.updateUser(new User());
        System.out.println("============");
        userService.deleteUser(1);
    }
}

6.com.oracle.util包：
package com.oracle.util;

/**
 * 功能类
 */
public class Aspect {
    public void before(){
        System.out.println("事务开启");
    }
    public void after(){
        System.out.println("事务结束");
    }
}

7.com.oracle.vo
package com.oracle.vo;

public class User {
    private String name;
}