Spring AOP

发布时间：2022-02-21 21:33:18
本文热度：浏览 1,545 赞 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(, 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.spring.Proxy.User.add(..))")
    public void before(){
        System.out.println("before......");
    }
    //后置通知
    @After("execution(* com.lianyou.spring.Proxy.User.add(..))")
    public void after(){
        System.out.println("after......");
    }
    //后置通知(返回通知)
    @AfterReturning("execution(* com.lianyou.spring.Proxy.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning......");
    }
    //异常通知
    @AfterThrowing("execution(* com.lianyou.spring.Proxy.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing......");
    }
    //环绕通知
    @Around("execution(* com.lianyou.spring.Proxy.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("around...前...");
        proceedingJoinPoint.proceed();
        System.out.println("around.....后.");
    }
}

（3）配置文件编写

<?xml version=".0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w.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.spring.Proxy"></context:component-scan>
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

（4）测试类的编写

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

    }

（5）相同切入点设置

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

    }

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

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

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

}

（7）完全注解开发

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

5、AspectJ XML方式

<?xml version=".0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w.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.spring.Book.Book"></bean>
        <bean id="bookProxy" class="com.lianyou.spring.Book.BookProxy"></bean>

        <aop:config>
                <!--配置切入点-->
                <aop:pointcut id="p" expression="execution(* com.lianyou.spring.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("bean.xml");     Book book = context.getBean("book", Book.class);     book.read();     System.out.println(book); }

正文到此结束

所属分类：Spring家族

本文链接： https://refblogs.com/article/119
版权声明： 本文由老牛原创发布，转载或复制请以超链接形式转载,并注明出处搬砖的码农。

Spring AOP

相关文章

热门推荐

标签云

本文目录