cglib动态代理、jdk动态代理及spring动态代理使用

1.项目初始化

1.1 pom.xml

<dependencies>
        <!-- spring依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
        <!-- spring事务依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
        <!-- mybatis依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.1</version>
        </dependency>
        <!-- mybatis和spring集成依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.9</version>
        </dependency>
        <!-- 阿里的连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.12</version>
        </dependency>
        <!-- aspectj-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.5</version>
        </dependency>
         <dependency>
            <groupId>org.apache.geronimo.bundles</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8_2</version>
        </dependency>
    </dependencies>

1.2UserService对象

package com.nq.service;

import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 23:04
 */
@Component
public class UserService {

    public void test(){
        System.out.println("test方法。");
    }

    public void a(){
        System.out.println("a方法。");
    }
}

在这里插入图片描述

2.cjlib动态代理的使用

2.1所有的方法都是使用动态代理

package com.nq.service;

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

import java.lang.reflect.Method;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 23:29
 */
public class CglibTest {
    public static void main(String[] args) {
        UserService target =new UserService();

        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(UserService.class);

        enhancer.setCallbacks(new Callback[]{new MethodInterceptor() {
                    @Override
                    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                        System.out.println("before...");

                        //被代理的对象，目标方法
                        //Object result=methodProxy.invoke(target,objects);
                        //Object result=method.invoke(target,objects);
                        Object result=methodProxy.invokeSuper(o,objects);


                        System.out.println("After...");
                        return  result;
                    }
                }
        });

        UserService userService = (UserService) enhancer.create();
        userService.test();
    }
}

2.2不同的方法使用不同的代理

package com.nq.service;

import org.springframework.cglib.proxy.*;

import java.lang.reflect.Method;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 23:29
 */
public class CglibTest {
    public static void main(String[] args) {
        UserService target =new UserService();

        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(UserService.class);

        enhancer.setCallbacks(new Callback[]{new MethodInterceptor() {
                    @Override
                    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                        System.out.println("before...");

                        //被代理的对象，目标方法
                        //Object result=methodProxy.invoke(target,objects);
                        //Object result=method.invoke(target,objects);
                        Object result=methodProxy.invokeSuper(o,objects);


                        System.out.println("After...");
                        return  result;
                    }
                }
                , NoOp.INSTANCE});

        enhancer.setCallbackFilter(new CallbackFilter() {
            @Override
            public int accept(Method method) {
                if("test".equals(method.getName())){//表示test方法执行第一个代理方法，其他方法执行第二个方法
                    return 0;
                }else{
                    return 1;
                }
            }
        });
        UserService userService = (UserService) enhancer.create();
        userService.a();
    }
}

3.jdk动态代理的使用

3.1UserInterface创建接口

package com.nq.service;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 23:58
 */
public interface UserInterface {

    void test();

    void a();
}

3.2UserService实现接口

package com.nq.service;

import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 23:04
 */
@Component
public class UserService implements UserInterface{

    public void test(){
        System.out.println("test方法。");
    }

    public void a(){
        System.out.println("a方法。");
    }
}

3.3JdkTest代理的main方法

package com.nq.service;


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

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 23:56
 */
public class JdkTest {
    public static void main(String[] args) {
        UserInterface target=new UserService();
        UserInterface userInterface =(UserInterface) Proxy.newProxyInstance(JdkTest.class.getClassLoader(), new Class[]{UserInterface.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("Jdk动态代理被执行了，方法之前");
                method.invoke(target,args);
                System.out.println("Jdk动态代理被执行了，方法之后");
                return null;
            }
        });
        userInterface.test();
    }
}

在这里插入图片描述

4.spring中动态代理的使用

4.1proxyFactory 动态代理的使用方法

NickelBeforeAdvice.java方法执行之前

package com.nq.advice;

import org.springframework.aop.BeforeAdvice;
import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/30 0:59
 */
public class NickelBeforeAdvice implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("方法执行前被执行了");
    }
}

NickelAfterReturningAdvice.java方法执行之后

package com.nq.advice;

import org.aspectj.lang.annotation.AfterReturning;
import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/30 0:59
 */
public class NickelAfterReturningAdvice implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("方法returning被执行了");
    }
}

NickelAroundadvice.java环绕方法

package com.nq.advice;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/30 0:59
 */
public class NickelAroundadvice implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("方法执行round之前");
        Object proceed = invocation.proceed();
        System.out.println("方法执行round之后");
        return proceed;
    }
}

NickelThrowAdvice.java抛异常方法

package com.nq.advice;

import org.springframework.aop.ThrowsAdvice;

import java.lang.reflect.Method;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/30 1:00
 */
public class NickelThrowAdvice implements ThrowsAdvice {

    public void afterThrowing(Method method, Object[] args, Object target, NullPointerException ex) {
        System.out.println("方法抛异常执行了");
    }
}

UserService.java抛异常方法

package com.nq.service;

import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 23:04
 */
@Component
public class UserService implements UserInterface{

    public void test(){
        System.out.println("test方法。");
    }

    public void a(){
        System.out.println("a方法。");
        throw  new NullPointerException();
    }
}

SpringProxtFactoryTest.java测试方法

package com.nq.service;

import com.nq.advice.NickelAfterReturningAdvice;
import com.nq.advice.NickelAroundadvice;
import com.nq.advice.NickelBeforeAdvice;
import com.nq.advice.NickelThrowAdvice;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.framework.ProxyFactory;

import java.lang.reflect.Method;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/30 0:49
 */
public class SpringProxtFactoryTest {
    public static void main(String[] args) {
        UserService target=new UserService();

        ProxyFactory proxyFactory=new ProxyFactory();
        proxyFactory.setTarget(target);
        //proxyFactory.setInterfaces(UserInterface.class);这里可以指定为接口类型
        proxyFactory.addAdvice(new NickelAroundadvice());
        proxyFactory.addAdvice(new NickelBeforeAdvice());
        UserService userService = (UserService) proxyFactory.getProxy();
        userService.test();

    }
}

在这里插入图片描述

4.2proxyFactory 对方法名字进行限制

NickelStaticMethodMatherPointcut.java方法匹配的方法

package com.nq.advice;

import org.springframework.aop.support.StaticMethodMatcherPointcut;

import java.lang.reflect.Method;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/30 1:39
 */
public class NickelStaticMethodMatherPointcut extends StaticMethodMatcherPointcut {
    @Override
    public boolean matches(Method method, Class<?> aClass) {
        return method.getName().equals("test");
    }
}

NickelPointcutAdvisor.java切面方法

package com.nq.advice;

import org.aopalliance.aop.Advice;
import org.springframework.aop.Pointcut;
import org.springframework.aop.PointcutAdvisor;
import org.springframework.aop.support.StaticMethodMatcherPointcut;

import java.lang.reflect.Method;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/30 1:34
 */
public class NickelPointcutAdvisor implements PointcutAdvisor {
    @Override
    public Pointcut getPointcut() {
        return new NickelStaticMethodMatherPointcut();
    }

    @Override
    public Advice getAdvice() {
        return new NickelBeforeAdvice();
    }

    @Override
    public boolean isPerInstance() {
        return false;
    }
}

SpringProxtFactoryTest.java测试的方法

package com.nq.service;

import com.nq.advice.*;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.framework.ProxyFactory;

import java.lang.reflect.Method;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/30 0:49
 */
public class SpringProxtFactoryTest {
    public static void main(String[] args) {
        UserService target=new UserService();

        ProxyFactory proxyFactory=new ProxyFactory();
        proxyFactory.setTarget(target);
        //proxyFactory.setInterfaces(UserInterface.class);这里可以指定为接口类型
        //proxyFactory.addAdvice(new NickelAroundadvice());
        //proxyFactory.addAdvice(new NickelBeforeAdvice());
        proxyFactory.addAdvisor(new NickelPointcutAdvisor());
        UserService userService = (UserService) proxyFactory.getProxy();
        userService.test();

    }
}

在这里插入图片描述
在这里插入图片描述
说明： proxyFactory.setOptimize(true)， proxyFactory.setProxyTargetClass(true)设置这两个值，将会使用cglib动态代理的方式，其他默认形式使用jdk动态代理的方式。proxyFactory.setExposeProxy(true)设置这个方法，查看当前代理对象是否生效。
在这里插入图片描述
在这里插入图片描述
说明：Object proxy = AopContext.currentProxy();在对应的方法书写这个方法，查看代理的方法。

4.3spring中的动态代理方式

4.3.1spring执行方法时候启动逻辑

UserService.java修改

package com.nq.service;

import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 23:04
 */
public class UserService{

    public void test(){
        System.out.println("test方法。");
    }

    public void a(){
        System.out.println("a方法。");
        //throw  new NullPointerException();
    }
}

说明：这里需要去掉Component注解

AppConfig.java配置

package com.nq.service;


import com.nq.advice.NickelAfterReturningAdvice;
import com.nq.advice.NickelBeforeAdvice;
import org.springframework.aop.framework.ProxyFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:59
 */
@ComponentScan("com.nq")
public class AppConfig {

    @Bean
    public ProxyFactoryBean userService(){
        UserService userService=new UserService();
        ProxyFactoryBean proxyFactoryBean=new ProxyFactoryBean();
        proxyFactoryBean.addAdvice(new NickelAfterReturningAdvice());
        proxyFactoryBean.setTarget(userService);
        return proxyFactoryBean;
    }

}

Test.java配置

package com.nq.service;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 23:00
 */

public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext();
        context.register(AppConfig.class);
        context.refresh();

        UserService userService = (UserService) context.getBean("userService");
        userService.test();
    }
}

启动Test.java显示结果
在这里插入图片描述

4.3.2不去掉注解，spring执行方法的时候执行对应的逻辑

修改NickelAfterReturningAdvice.Java，增加注解

package com.nq.advice;

import org.aspectj.lang.annotation.AfterReturning;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/30 0:59
 */
@Component
public class NickelAfterReturningAdvice implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("方法returning被执行了");
    }
}

修改UserService.Java，增加注解

package com.nq.service;

import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 23:04
 */
@Component
public class UserService{

    public void test(){
        System.out.println("test方法。");
    }

    public void a(){
        System.out.println("a方法。");
        //throw  new NullPointerException();
    }
}

修改AppConfig.Java配置文件

package com.nq.service;


import com.nq.advice.NickelAfterReturningAdvice;
import com.nq.advice.NickelBeforeAdvice;
import org.springframework.aop.framework.ProxyFactoryBean;
import org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:59
 */
@ComponentScan("com.nq")
public class AppConfig {

    @Bean
    public BeanNameAutoProxyCreator beanNameAutoProxyCreator(){
        BeanNameAutoProxyCreator beanNameAutoProxyCreator=new BeanNameAutoProxyCreator();
        beanNameAutoProxyCreator.setBeanNames("userSe*");
        beanNameAutoProxyCreator.setInterceptorNames("nickelAfterReturningAdvice");
        beanNameAutoProxyCreator.setProxyTargetClass(true);
        return  beanNameAutoProxyCreator;
    }

}

Test.Java配置文件

package com.nq.service;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 23:00
 */

public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext();
        context.register(AppConfig.class);
        context.refresh();

        UserService userService = (UserService) context.getBean("userService");
        userService.test();
    }
}

Test测试结果
在这里插入图片描述

4.3.3AppConfig另外实现动态代理

package com.nq.service;


import com.nq.advice.NickelAfterReturningAdvice;
import com.nq.advice.NickelBeforeAdvice;
import org.springframework.aop.framework.DefaultAdvisorChainFactory;
import org.springframework.aop.framework.ProxyFactoryBean;
import org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.NameMatchMethodPointcut;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:59
 */
@ComponentScan("com.nq")
public class AppConfig {

    @Bean
    public DefaultPointcutAdvisor defaultPointcutAdvisor(){
        NameMatchMethodPointcut pointcut=new NameMatchMethodPointcut();
        pointcut.addMethodName("test");

        DefaultPointcutAdvisor defaultPointcutAdvisor=new DefaultPointcutAdvisor();
        defaultPointcutAdvisor.setPointcut(pointcut);
        defaultPointcutAdvisor.setAdvice(new NickelAfterReturningAdvice());
        return defaultPointcutAdvisor;
    }

    @Bean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator=new DefaultAdvisorAutoProxyCreator();
        return defaultAdvisorAutoProxyCreator;
    }

}

测试结果
在这里插入图片描述
其中DefaultAdvisorAutoProxyCreator通过导入的方式

package com.nq.service;


import com.nq.advice.NickelAfterReturningAdvice;
import com.nq.advice.NickelBeforeAdvice;
import org.springframework.aop.framework.DefaultAdvisorChainFactory;
import org.springframework.aop.framework.ProxyFactoryBean;
import org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.NameMatchMethodPointcut;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:59
 */
@ComponentScan("com.nq")
@Import(DefaultAdvisorAutoProxyCreator.class)
public class AppConfig {

    @Bean
    public DefaultPointcutAdvisor defaultPointcutAdvisor(){
        NameMatchMethodPointcut pointcut=new NameMatchMethodPointcut();
        pointcut.addMethodName("test");

        DefaultPointcutAdvisor defaultPointcutAdvisor=new DefaultPointcutAdvisor();
        defaultPointcutAdvisor.setPointcut(pointcut);
        defaultPointcutAdvisor.setAdvice(new NickelAfterReturningAdvice());
        return defaultPointcutAdvisor;
    }
}

在这里插入图片描述

4.4spring中Aspect的使用

创建NickelAspect.java

package com.nq.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/30 2:37
 */
@Aspect
@Component
public class NickelAspect {

    @Before("execution(public void com.nq.service.UserService.test())")
    public void nickelBefore(JoinPoint joinPoint){
        System.out.println("NickelAspect执行了");
    }
}

修改AppConfig.java扫描类

package com.nq.service;


import com.nq.advice.NickelAfterReturningAdvice;
import com.nq.advice.NickelBeforeAdvice;
import org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator;
import org.springframework.aop.framework.DefaultAdvisorChainFactory;
import org.springframework.aop.framework.ProxyFactoryBean;
import org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.NameMatchMethodPointcut;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.Import;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:59
 */
@ComponentScan("com.nq")
@Import(AnnotationAwareAspectJAutoProxyCreator.class)
//@EnableAspectJAutoProxy
public class AppConfig {

}

启动测试类测试
在这里插入图片描述

5.TargetSource方法的使用

package com.nq.service;

import org.springframework.aop.TargetSource;
import org.springframework.aop.framework.ProxyFactory;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/8/1 0:58
 */
public class TargetSourceTest {
    public static void main(String[] args) {
        UserService target=new UserService();
        ProxyFactory proxyFactory=new ProxyFactory();
        proxyFactory.setTargetSource(new TargetSource() {
            @Override
            public Class<?> getTargetClass() {
                return target.getClass();
            }

            @Override
            public boolean isStatic() {
                return false;
            }

            @Override
            public Object getTarget() throws Exception {
                System.out.println("getTarget被执行了");
                return target;
            }

            @Override
            public void releaseTarget(Object o) throws Exception {

            }
        });

        UserService service = (UserService) proxyFactory.getProxy();
        service.test();
    }
}

在这里插入图片描述
说明：可以在getTarget方法里面写一定的逻辑，让getTarget对象被执行。

6.Introduction（给未实现接口的方法赋值接口）

https://www.cnblogs.com/powerwu/articles/5170861.html
AppConfig
在这里插入图片描述

package com.nq.service;


import com.nq.advice.NickelAfterReturningAdvice;
import com.nq.advice.NickelBeforeAdvice;
import org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator;
import org.springframework.aop.framework.DefaultAdvisorChainFactory;
import org.springframework.aop.framework.ProxyFactoryBean;
import org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.NameMatchMethodPointcut;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.Import;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:59
 */
@ComponentScan("com.nq")
@EnableAspectJAutoProxy
public class AppConfig {

}

OrderService.java

package com.nq.service;

import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/8/1 1:20
 */
@Component
public class OrderService {
}

OrderInterface.java

package com.nq.interfac;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/8/1 1:18
 */
public interface OrderInterface {
    void test();
}

OrderInterfaceImpl.java

package com.nq.service.impl;

import com.nq.interfac.OrderInterface;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/8/1 1:19
 */
public class OrderInterfaceImpl implements OrderInterface {
    @Override
    public void test() {
        System.out.println("order 里面Introduction被实现了");
    }
}

OrderAspect.java

package com.nq.aspect;

import com.nq.interfac.OrderInterface;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;
import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/8/1 1:22
 */
@Component
@Aspect
public class OrderAspect {

    @DeclareParents(value = "com.nq.service.OrderService",defaultImpl = com.nq.service.impl.OrderInterfaceImpl.class)
    public OrderInterface orderInterface;
}

IntroductionTest.java

package com.nq.service;

import com.nq.interfac.OrderInterface;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/8/1 1:26
 */
public class IntroductionTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext();
        context.register(AppConfig.class);
        context.refresh();

        OrderInterface orderService = (OrderInterface) context.getBean("orderService");
        orderService.test();
    }
}

在这里插入图片描述
说明：我们可以看到，OrderService并为实现OrderInterface接口，但是在spring容器中却可以转化为OrderInterface类型，这就是通过Aspect实现OrderService转化为OrderInterface的方式。

7.advisor方法使用

1.OrderAdvisor

OrderAdvisor.java

package com.nq.advisor;

import com.nq.advice.NickelAfterReturningAdvice;
import com.nq.service.OrderService;
import org.aopalliance.aop.Advice;
import org.springframework.aop.ClassFilter;
import org.springframework.aop.MethodMatcher;
import org.springframework.aop.Pointcut;
import org.springframework.aop.PointcutAdvisor;
import org.springframework.stereotype.Component;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/8/1 1:47
 */
@Component
public class OrderAdvisor implements PointcutAdvisor {

    ///实现切面的方法
    @Override
    public Advice getAdvice() {
        return new NickelAfterReturningAdvice();
    }

    @Override
    public Pointcut getPointcut() {
        return new Pointcut() {
            @Override
            public ClassFilter getClassFilter() {
                return new ClassFilter() {
                    @Override
                    public boolean matches(Class<?> aClass) {
                        return aClass.equals(OrderService.class);
                    }
                };
            }

            @Override
            public MethodMatcher getMethodMatcher() {
                return new MethodMatcher() {
                    @Override
                    public boolean matches(Method method, Class<?> aClass) {
                        return method.getName().equals("advisorTest");
                    }

                    @Override
                    public boolean isRuntime() {
                        return false;
                    }

                    @Override
                    public boolean matches(Method method, Class<?> aClass, Object... objects) {
                        return false;
                    }
                };
            }
        };
    }



    @Override
    public boolean isPerInstance() {
        return false;
    }
}

OrderService.java

package com.nq.service;

import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/8/1 1:20
 */
@Component
public class OrderService {

    public void advisorTest(){
        System.out.println("OrderService对象的advisorTest发现了");
    }
}

OrderTest.java

package com.nq.service;

import com.nq.advice.NickelPointcutAdvisor;
import com.nq.advisor.OrderAdvisor;
import org.springframework.aop.framework.ProxyFactory;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/8/1 2:08
 */
public class OrderTest {
    public static void main(String[] args) {
        OrderService target=new OrderService();

        ProxyFactory proxyFactory=new ProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAdvisor(new OrderAdvisor());

        OrderService orderService = (OrderService) proxyFactory.getProxy();
        orderService.advisorTest();
    }
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/56651.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

20230802-下载jdk1.8、jre

20230802-下载jdk1.8、jre

搜索oracle oracle官网 https://www.oracle.com/cn/
阅读更多...
《吐血整理》进阶系列教程-拿捏Fiddler抓包教程(20)-Fiddler精选插件扩展安装让你的Fiddler开挂到你怀疑人生

《吐血整理》进阶系列教程-拿捏Fiddler抓包教程(20)-Fiddler精选插件扩展安装让你的Fiddler开挂到你怀疑人生

1.简介 Fiddler本身的功能其实也已经很强大了&#xff0c;但是Fiddler官方还有很多其他扩展插件功能&#xff0c;可以更好地辅助Fiddler去帮助用户去开发、测试和管理项目上的任务。Fiddler已有的功能已经够我们日常工作中使用了&#xff0c;为了更好的扩展Fiddler&#xff0c…
阅读更多...
MongoDB文档--架构体系

MongoDB文档--架构体系

阿丹&#xff1a; 在开始学习先了解以及目标知识的架构体系。就能事半功倍。 架构体系 MongoDB的架构体系由以下几部分组成&#xff1a; 存储结构&#xff1a;MongoDB采用文档型存储结构&#xff0c;一个数据库包含多个集合&#xff0c;一个集合包含多个文档。存储形式&#…
阅读更多...
【C++从0到王者】第十五站：list源码分析及手把手教你写一个list

【C++从0到王者】第十五站：list源码分析及手把手教你写一个list

文章目录 一、list源码分析1.分析构造函数2.分析尾插等 二、手把手教你写一个list1.结点声明2.list类的成员变量3.list类的默认构造函数4.list类的尾插5.结点的默认构造函数6.list类的迭代器7.设计const迭代器8.list的insert、erase等接口9.size10.list的clear11.list的析构函数…
阅读更多...
Java反射全面详解

Java反射全面详解

1. 什么是反射&#xff1f; 首先听这个名字就有些疑惑&#xff0c;什么是反射&#xff0c;它能用来干什么呢&#xff1f; Java官方对反射的解释是 "反射允许对封装类的字段&#xff0c;方法和构造函数进行编程式访问"。这里的字段指的就是成员变量&#xff0c;方法…
阅读更多...
STM32 串口学习（二）

STM32 串口学习（二）

要用跳线帽将PA9与RXD相连&#xff0c;PA10与TXD相连。 软件设计 void uart_init(u32 baud) {//UART 初始化设置UART1_Handler.InstanceUSART1; //USART1UART1_Handler.Init.BaudRatebound; //波特率UART1_Handler.Init.WordLengthUART_WORDLENGTH_8B; //字长为 8 位数据格式U…
阅读更多...
java+springboot+mysql疫情物资管理系统

java+springboot+mysql疫情物资管理系统

项目介绍&#xff1a; 使用javaspringbootmysql开发的疫情物资管理系统&#xff0c;系统包含超级管理员&#xff0c;系统管理员、员工角色&#xff0c;功能如下&#xff1a; 超级管理员&#xff1a;管理员管理&#xff1b;部门管理&#xff1b;职位管理&#xff1b;员工管理&…
阅读更多...
Redis哨兵模式

Redis哨兵模式

Redis哨兵模式 一、服务器准备二、安装redis1.Master服务器2.SlaveFirst服务器3.SlaveSecond服务器 三、依次开启Redis服务器四、开启哨兵1.修改Master哨兵配置文件2.修改SlaveFirst哨兵配置文件3.修改SlaveSecond哨兵配置文件4.开启哨兵5.验证是否开启成功6.主从配置如下五、挂…
阅读更多...
线程池-手写线程池Linux C简单版本（生产者-消费者模型）

线程池-手写线程池Linux C简单版本（生产者-消费者模型）

目录 简介手写线程池线程池结构体分析task_ttask_queue_tthread_pool_t 线程池函数分析thread_pool_createthread_pool_postthread_workerthread_pool_destroywait_all_donethread_pool_free 主函数调用 运行结果 简介 本线程池采用C语言实现 线程池的场景&#xff1a; 当某些…
阅读更多...
React哲学——官方示例

React哲学——官方示例

在本篇技术博客中&#xff0c;我们将介绍React官方示例&#xff1a;React哲学。我们将深入探讨这个示例中使用的组件化、状态管理和数据流等核心概念。让我们一起开始吧&#xff01; 项目概览 React是一个流行的JavaScript库&#xff0c;用于构建用户界面。React的设计理念是…
阅读更多...
组合模式(Composite)

组合模式(Composite)

组合模式是一种结构型设计模式&#xff0c;主要用来将多个对象组织成树形结构以表示“部分-整体”的层次结构&#xff0c;因此该模式也称为“部分-整体”模式。简言之&#xff0c;组合模式就是用来将一组对象组合成树状结构&#xff0c;并且能像使用独立对象一样使用它们。 Co…
阅读更多...
排序进行曲-v2.0

排序进行曲-v2.0

小程一言 这篇文章是在排序进行曲1.0之后的续讲&#xff0c; 0之后的续讲,英语在上一篇讲的排序的基本概念与分类0之后的续讲, 英语在上一篇讲的排序的基本概念与分类这片主要是对0之后的续讲,英语在上一篇讲的排序的基本概念与分类这 篇主要是对几个简单的排序进行细致的分析…
阅读更多...
HarmonyOS/OpenHarmony元服务开发-配置卡片的配置文件

HarmonyOS/OpenHarmony元服务开发-配置卡片的配置文件

卡片相关的配置文件主要包含FormExtensionAbility的配置和卡片的配置两部分&#xff1a; 1.卡片需要在module.json5配置文件中的extensionAbilities标签下&#xff0c;配置FormExtensionAbility相关信息。FormExtensionAbility需要填写metadata元信息标签&#xff0c;其中键名称…
阅读更多...
企业电子招投标采购系统java spring cloud+spring boot功能模块功能描述+数字化采购管理 采购招投标

企业电子招投标采购系统java spring cloud+spring boot功能模块功能描述+数字化采购管理 采购招投标

​功能模块&#xff1a; 待办消息&#xff0c;招标公告&#xff0c;中标公告&#xff0c;信息发布 描述&#xff1a; 全过程数字化采购管理&#xff0c;打造从供应商管理到采购招投标、采购合同、采购执行的全过程数字化管理。通供应商门户具备内外协同的能力&#xff0c;为外…
阅读更多...
Java枚举解析：掌握枚举的绝佳指南！

Java枚举解析：掌握枚举的绝佳指南！

申明&#xff1a;本人于公众号Java筑基期&#xff0c;CSDN先后发当前文章&#xff0c;标明原创&#xff0c;转载二次发文请注明转载公众号&#xff0c;另外请不要再标原创 &#xff0c;注意违规 枚举 在Java中&#xff0c;枚举&#xff08;Enumeration&#xff09;是一种特殊的…
阅读更多...
Python实现单例模式

Python实现单例模式

一、介绍 单例模式是一种常见的设计模式&#xff0c;它保证一个类只能被实例化一次&#xff0c;并提供了一个全局访问点来获取这个唯一的实例。在Python中&#xff0c;可以通过使用装饰器、元类或模块等方式实现单例模式。 二、Python实现单例模式的6种方法 1、使用模块实现…
阅读更多...
git 忽略掉不需要的文件

git 忽略掉不需要的文件

第一步&#xff1a;创建.gitignore文件 touch .gitignore 第二步&#xff1a;使用vi编辑器 输入不需要的文件&#xff0c;或用通配符*来忽视一系列文件 效果&#xff1a;
阅读更多...
什么是软件检测证明材料，如何才能获得软件检测证明材料?

什么是软件检测证明材料，如何才能获得软件检测证明材料?

一、什么是软件检测证明材料 软件检测证明材料是指在软件开发和发布过程中&#xff0c;为了证明软件的质量和合法性&#xff0c;进行的一系列检测和测试的结果的集合。它是软件开发者和用户之间信任的桥梁&#xff0c;可以帮助用户了解软件的性能和安全性&#xff0c;让用户放…
阅读更多...
开放自动化软件的硬件平台

开放自动化软件的硬件平台

自动化行业的产品主要以嵌入式系统为主&#xff0c;历来对产品硬件的可靠性和性能都提出很高的要求。最典型的产品要数PLC。PLC 要求满足体积小&#xff0c;实时性&#xff0c;可靠性&#xff0c;可扩展性强&#xff0c;环境要求高等特点。它们通常采用工业级高性能嵌入式SoC 实…
阅读更多...
LinearAlgebraMIT_6_ColumnSpaceAndNullSpace

LinearAlgebraMIT_6_ColumnSpaceAndNullSpace

这节课的两个重点是column space列空间和null space零空间。 x.1 pre-multiply/left multiply and post-multiply/right multiply 对于pre-multiply/left multiply左乘和post-multiply/right multiply右乘&#xff0c;如果用英文的pre-和post-是比较容易理解的&#xff0c; A…
阅读更多...
最新文章

Copyright @ 2022~2023