动态代理的两个使用方式(手动实现+SpringAOP实现)-Demo

亦凉 2024-03-24 18:53 33阅读 0赞

#### 一、手动实现 ####

1、具体代码

package com.xch.proxy;
    
    /**
     * 具体业务接口
     *
     * @author XuChenghe
     * @date 2023/8/18 15:09
     */
    public interface Star {
        
        /**
         * 唱歌方法
         *
         * @param name
         * @return
         */
        String sing(String name);
        
        /**
         * 跳舞方法
         */
        void dance();
        
    }

package com.xch.proxy;
    
    /**
     * 具体业务实现类
     *
     * @author XuChenghe
     * @date 2023/8/18 15:06
     */
    public class BigStar implements Star {
        private String userName;
        
        public BigStar(String userName) {
            this.userName = userName;
        }
        
        /**
         * {@inheritDoc}
         */
        public String sing(String songName) {
            System.out.println(this.userName + "正在唱：" + songName);
            return "谢谢！谢谢！";
        }
        
        /**
         * {@inheritDoc}
         */
        public void dance() {
            System.out.println(this.userName + "正在优美的跳舞~~");
        }
        
    }

package com.xch.proxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * 动态代理的工具类(产生代理的)
     * -手动实现原生动态代理
     *
     * @author XuChenghe
     * @date 2023/8/18 15:11
     */
    public class ProxyUtil {
        
        public static Star createProxy(BigStar bigStar) {
            // 参数1：ClassLoader用于指定一个类加载器
            // 参数2：指定生成的代理有哪些方法
            // 参数3：用来指定生成的代理对象要干什么事情(动态代理的核心)
            Star starProxy = (Star) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),
                    new Class[]{Star.class}, new InvocationHandler() {
                        // 回调方法
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                            // 动态代理要做的事情，会在这里写代码
                            if ("sing".equals(method.getName())) {
                                System.out.println("准备话筒，收钱20万");
                            } else if ("dance".equals(method.getName())) {
                                System.out.println("准备场地，收钱100万");
                            }
                            return method.invoke(bigStar, args);
                        }
                    }
            );
            return starProxy;
        }
        
    }

package com.xch.proxy;
    
    /**
     * 运行启动测试类
     *
     * @author XuChenghe
     * @date 2023/8/18 15:21
     */
    public class LaunchTest {
        
        public static void main(String[] args) {
            Star starProxy = ProxyUtil.createProxy(new BigStar("杨超越"));
            
            String result = starProxy.sing("好日子");
            System.out.println(result);
            
            starProxy.dance();
        }
        
    }

#### 二、SpringAOP实现 ####

1、pom文件依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
    </dependency>

2、具体代码

package com.xch.proxy_product;
    
    /**
     * 具体业务接口
     *
     * @author XuChenghe
     * @date 2023/8/18 15:09
     */
    public interface Star {
        
        /**
         * 实际生产中使用的代理调用
         *
         * @param name
         * @return
         */
        String proxySing(String name);
        
        /**
         * 实际生产中使用的代理调用
         */
        void proxyDance();
        
    }

package com.xch.proxy_product;
    
    import org.springframework.aop.framework.AopContext;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    /**
     * 具体业务实现类
     *
     * @author XuChenghe
     * @date 2023/8/18 15:06
     */
    @Service
    public class BigStar implements Star {
        
        /**
         * 唱歌方法
         *
         * @param songName
         * @return
         */
        @Transactional(rollbackFor = Exception.class)
        public String sing(String songName) {
            System.out.println("杨超越正在唱：" + songName);
            return "谢谢！谢谢！";
        }
        
        /**
         * 跳舞方法
         */
        @Transactional(rollbackFor = Exception.class)
        public void dance() {
            System.out.println("杨超越正在优美的跳舞~~");
        }
        
        /**
         * {@inheritDoc}
         */
        @Transactional(rollbackFor = Exception.class)
        public String proxySing(String songName) {
            System.out.println("准备话筒，收钱20万");
            return getCurrentProxy().sing("好日子");
        }
        
        /**
         * {@inheritDoc}
         */
        @Transactional(rollbackFor = Exception.class)
        public void proxyDance() {
            System.out.println("准备场地，收钱100万");
            getCurrentProxy().dance();
        }
        
        /**
         * 获取当前类的代理
         *
         * @return 当前类的代理
         */
        private static BigStar getCurrentProxy() {
            return (BigStar) AopContext.currentProxy();
        }
        
    }

package com.xch.proxy_product;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    /**
     * 通用业务的切面类
     *
     * @author XuChenghe
     * @date 2023/8/20 8:55
     */
    @Aspect // 声明该类的作用：切面类
    @Component // 等价于@Configuration：交由Spring的IOC容器管理
    public class BigStarAspect {
        
        /**
         * 定义公共切入点
         * -假设proxy_product是service业务层包
         * -则通过以下表达式匹配该业务包下的所有子孙类的所有public修饰的方法
         *
         * 另外，配置的切入表达式必须是符合public修饰的方法
         * 因为，Spring事务即AOP的底层通过动态代理生成代理调用该方法时，
         * 会判断方法只能是public修饰的Modifier.isPublic(method.getModifiers())
         */
        @Pointcut("execution(public * com.xch.proxy_product..*(..))")
        public void myPointcut() {
            // 公共切入点
        }
        
        /**
         * 配置切面方法(环绕通知)：方法增强
         *
         * @param pjp 连接点：当前切入方法的信息
         * @return 方法执行的返回结果
         * @throws Throwable 方法执行时抛出的异常
         */
        @Around("myPointcut()")
        public Object around(ProceedingJoinPoint pjp) throws Throwable {
            System.out.println("=====环绕通知(开始)=====");
            // 前置增强代码
            Object proceed = pjp.proceed();
            // 后置/返回增强代码
            // 最终增强代码
            // 抛出异常后增强代码
            System.out.println("=====环绕通知(结束)=====");
            return proceed;
        }
    }

package com.xch;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.EnableAspectJAutoProxy;
    
    /**
     * 启用Spring的动态代理，默认使用JDK动态代理(由proxyTargetClass控制)
     */
    @SpringBootApplication
    @EnableAspectJAutoProxy(exposeProxy = true)
    public class SubDynamicProxyApplication {
        
        public static void main(String[] args) {
            SpringApplication.run(SubDynamicProxyApplication.class, args);
        }
        
    }

package com.xch.proxy_product;
    
    import org.junit.jupiter.api.Test;
    import org.springframework.aop.support.AopUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    /**
     * 运行启动测试类
     *
     * @author XuChenghe
     * @date 2023/8/18 15:21
     */
    @SpringBootTest
    public class LaunchTest {
        
        @Autowired
        private Star star;
        
        @Test
        public void launch() {
            String result = star.proxySing("好日子");
            System.out.println(result);
        
            System.out.println();
            star.proxyDance();
        
            // 判断该注入类是否代理类
            // -Spring的IOC容器中默认都是原生对象
            // -只有配置了AOP增强的对象才是代理对象
            System.out.println(AopUtils.isAopProxy(star));
        }
        
    }