【Spring】Spring学习笔记---aop面向切面的编程，代理模式

一.简介

AOP 一种面向切面的编程，专注于在类和方法前插入新的执行方法
基于JDK代理模式设计的

二.案例

1.创建InvocationHandler的子实现JDKProxyProcessor类

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

//InvocationHandler的子实现
public class JDKProxyProcessor implements InvocationHandler {

    private  Object target;

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

    public JDKProxyProcessor() {
    }
	/*
    * proxy:代理对象
    * method：原始对象中的每一个方法 add方法
    * args：原始对象被调用的时候的参数 参数a,b
    * */
	//所有原始对象方法都会被invoke方法增强
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        
		//原始方法被调用 反射 相当于target.method(arg)
        Object result=method.invoke(target,args);

        System.out.println("after");

        return result;
    }
}

2.创建代理工厂JDKProxyFactory类

import java.lang.reflect.Proxy;

public class JDKProxyFactory {

    //传入target 目标对象
    //return 获得代理对象
    public static Object bind(Object target){
        //返回代理实例
        //getClassLoader类加载器，getInterfaces所有的接口,获取这两个之后创建对象
        //InvocationHandler增强原始对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),new JDKProxyProcessor(target));
    }
}

3.创建一个UserMapperInterface

public interface UserMapperInterface {
    void sayHello();
	
	int add(int a,int b);
}

3.创建一个UserMapper

public class UserMapper implements UserMapperInterface {

    @Override
    public void sayHello(){
        System.out.println("hello");
    }

	@Override
    public int add(int a, int b) {
        return a+b;
    }
}

4.创建主类ProxyMain

public class ProxyMain {
    public static void main(String[] args) {
        UserMapper userMapper=new UserMapper();
        userMapper.sayHello();
		
		//代理对象和原始对象间为兄弟关系，所以要用接口来接收
        UserMapperInterface proxyUserMapper=(UserMapperInterface) JDKProxyFactory.bind(userMapper);
        proxyUserMapper.sayHello();
		System.out.println(proxyUserMapper.add(1, 2));
    }
}

结果输出

hello
before
hello
after
before
after
3

三.延伸案例

JDKProxyProcessor类调用两次原始方法

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

//InvocationHandler的子实现
public class JDKProxyProcessor implements InvocationHandler {

    private  Object target;

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

    public JDKProxyProcessor() {
    }

    /*
    * proxy:代理对象
    * method：原始对象中的每一个方法 add方法
    * args：原始对象被调用的时候的参数 参数a,b
    * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //所有原始对象方法都会被invoke方法增强
        System.out.println("before");

        //原始方法被调用 反射 相当于target.method(arg)
        Object result=method.invoke(target,args);

        Object result1=method.invoke(target,args);

        System.out.println("after");

        return result;
    }
}

结果输出

hello
before
hello
hello
after
before
after
3

执行两次hello

四.代理方法可批量操作来记录日志

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Date;

//InvocationHandler的子实现
public class JDKProxyProcessor implements InvocationHandler {

    private  Object target;

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

    public JDKProxyProcessor() {
    }

    /*
    * proxy:代理对象
    * method：原始对象中的每一个方法 add方法
    * args：原始对象被调用的时候的参数 参数a,b
    * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      
        Object result=method.invoke(target,args);

        //记录日志信息
        System.out.println(new Date()+" use ages "+
                Arrays.toString(args)+" use "+method.getName()+
                " get " + result+" as result");

        return result;
    }
}

输出结果：

hello
hello
Sun Jan 16 11:19:48 CST 2022 use ages null use sayHello get null as result
Sun Jan 16 11:19:48 CST 2022 use ages [1, 2] use add get 3 as result
3