Spring AOP

  • 发布时间:2022-02-21 21:33:18
  • 本文热度:浏览 1,329 赞 0 评论 0
  • 全文共1字,阅读约需1分钟

一、AOP的概念

  1、AOP:面向切面编程,利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各个部分的耦合度降低。提高程序的可重用性,同时提高了开发效率

  2、AOP通俗描述:不通过修改源代码的方式进行功能增加。

  3、AOP的底层原理:使用JDK的动态代理和CGLIB动态代理

    (1)在有接口的情况下 使用JDK动态代理 创建接口的实现类代理对象增强类的方法

    (2)在没有接口的情况下 使用CGLIB动态代理 创建子类代理对象增强类的方法

  4、AOP术语

    (1)连接点 :类里那些方法可以被增强,这些方法被称为连接点

    (2)切入点 :类里实际被增强的方法,这些方法被称为切入点

    (3)通知(增强):实际增强的逻辑部分称为通知(增强)  

        通知分5种类型:1、前置通知:方法执行前。2、后置通知:方法执行后。3、环绕通知:方法执行前后。4、异常通知:方法执行异常时。5、最终通知:如finally

    (4)切面:把通知应用到切入点的动作

二、AOP的具体使用

  1、创建接口UserDao 

public interface UserDAO {
    public int add(int a, int b);
    public String upadate(String name);
}

 

  2、创建实现类

public class UserDaoImpl implements UserDAO {

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

    @Override
    public String upadate(String name) {
        return name;
    }
}

 

  3、创建JDKProxy

public class JDKProxy {
    public static void main(String[] args) {
        Class[] interfaces = {UserDAO.class};
        /*  可以使用匿名对象的方式 也可以使用下面新建实现类的方式
        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        });*/
        UserDaoImpl userDao = new UserDaoImpl();
        UserDAO o = (UserDAO)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int result = o.add(1, 2);
        System.out.println(result);
    }
}
class UserDaoProxy implements InvocationHandler{
    //把创建的代理对象传递过来
    private Object obj;
    public UserDaoProxy(Object obj){//使用构造器进行有参传递
        this.obj=obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方式执行前的操作
        System.out.println("方法执行之前" + method.getName() + ":传递参数:" + Arrays.toString(args));
        //被增强的方法执行
        Object invoke = method.invoke(obj,args);
        //方法执行之后的操作
        System.out.println("方法之后"+obj);
        return invoke;
    }
}

 

三、AOP操作

1、Spring框架一般都是基于AspectJ实现AOP操作

  (1)AspectJ不是Spring的组成部分 是独立的AOP框架,一般把AspectJ和Spring一起使用,进行AOP操作

2、AspectJ实现AOP操作

  (1)基于xml配置文件实现

  (2)基于注解方式实现

3、切入点表达式

(1)切入点表达式作用:知道对哪个类里面的哪个方法进行增强
(2)语法结构: execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
举例1:对com.lianyou.dao.BookDao类里面的add进行增强
execution(* com.lianyou.dao.BookDao.add(..))
举例2:对com.lianyou.dao.BookDao类里面的所有的方法进行增强
execution(* com.lianyou.dao.BookDao.* (..))

举例3:对com.atguigu.dao包里面所有类,类里面所有方法进行增强
execution(* com.atguigu.dao.*.* (..))

4、AspectJ 注解方式

(1)创建类,定义方法

@Component
public class User {
    public void add(){
        System.out.println("add......");
    }
}

 

(2)创建增强类(编写增强逻辑)

@Component
@Aspect
public class UserProxy {
    //前置通知
    @Before("execution(* com.lianyou.spring5.Proxy.User.add(..))")
    public void before(){
        System.out.println("before......");
    }
    //后置通知
    @After("execution(* com.lianyou.spring5.Proxy.User.add(..))")
    public void after(){
        System.out.println("after......");
    }
    //后置通知(返回通知)
    @AfterReturning("execution(* com.lianyou.spring5.Proxy.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning......");
    }
    //异常通知
    @AfterThrowing("execution(* com.lianyou.spring5.Proxy.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing......");
    }
    //环绕通知
    @Around("execution(* com.lianyou.spring5.Proxy.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("around...前...");
        proceedingJoinPoint.proceed();
        System.out.println("around.....后.");
    }
}

 

(3)配置文件编写

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
        <context:component-scan base-package="com.lianyou.spring5.Proxy"></context:component-scan>
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

(4)测试类的编写

 @Test
    public void testAop(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = context.getBean("user", User.class);
       user.add();
        System.out.println(user);

    }

(5)相同切入点设置

@Pointcut(value = "execution(* com.lianyou.spring5.Proxy.User.add(..))")
    public void pointCut(){

    }

    //前置通知
    @Before("pointCut()")
    public void before(){
        System.out.println("before......");
    }

(6)设置多个增强类对同一个类进行增强的优先级 使用注解@Order(1)  括号里面的值越大则优先级越小

@Component
@Aspect
@Order(1)
public class UserProxy {

}

(7)完全注解开发

@Configuration 
@ComponentScan(basePackages = {"com.lianyou"}) 
@EnableAspectJAutoProxy(proxyTargetClass = true) public class ConfigAop { }

 

5、AspectJ XML方式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
        <bean id="book" class="com.lianyou.spring5.Book.Book"></bean>
        <bean id="bookProxy" class="com.lianyou.spring5.Book.BookProxy"></bean>

        <aop:config>
                <!--配置切入点-->
                <aop:pointcut id="p" expression="execution(* com.lianyou.spring5.Book.Book.read())"/>
                <!--配置切面-->
                <aop:aspect ref="bookProxy">
                        <aop:before method="sleep" pointcut-ref="p"></aop:before>
                </aop:aspect>
        </aop:config>
</beans>
 
public class BookProxy {

    public void sleep(){
        System.out.println("sleep........");
    }
}

public class Book {
    public void read(){
        System.out.println("read。。。。。");
    }
}
public void testXML(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
Book book = context.getBean("book", Book.class);
book.read();
System.out.println(book);

}

 

 

 

 

 

 


 

                    
正文到此结束
热门推荐
相关文章
评论插件初始化中...
本文目录