Spring(四)：AOP

2024-09-05 08:48
文章标签 java spring aop

本文主要是介绍Spring(四)：AOP，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一、AOP的概念理解    

        OOP(面向对象编程)使用的是从上到下、纵向的体系结构来解决重复代码的问题，重点关注的是与实际业务联合紧密的模块。而AOP(面向切面编程)则使用的是横向的体系来解决重复代码的问题，它重点关注的是与业务无关，却为业务模块所共同调用(叫做切面Aspect)的逻辑，如执行业务模块的某一功能时，需要记录操作日志、要实现事务，保证业务操作的原子性等等。AOP将这些切面提取出来然后动态的添加到业务逻辑代码之中，即使这些Aspect的实现机制以及代码进行了修改，只需改动一处而不会影响原有业务逻辑代码，从而降低了切面与业务逻辑的耦合度 。 因此，AOP是用来在使用OOP解决问题的过程中增强解决问题的能力，是对OOP的一种补充，实现更好的模块化。

二、代理机制

        AOP采用的是代理模式实现的

(1)静态代理

Count.java 

/** * 定义一个账户接口 */  
public interface Count {  // 查看账户方法  public void queryCount();  // 修改账户方法  public void updateCount();  
}
CountImpl.java  

/** * 委托类(包含业务逻辑) */  
public class CountImpl implements Count {  @Override  public void queryCount() {  System.out.println("查看账户方法...");  }  @Override  public void updateCount() {  System.out.println("修改账户方法...");  }  
}
CountProxy.java 

/** * 这是一个代理类（增强CountImpl实现类） */  
public class CountProxy implements Count {  private CountImpl countImpl;  /** * 覆盖默认构造器 *  * @param countImpl */  public CountProxy(CountImpl countImpl) {  this.countImpl = countImpl;  }  @Override  public void queryCount() {  System.out.println("事务处理之前");  // 调用委托类的方法;  countImpl.queryCount();  System.out.println("事务处理之后");  }  @Override  public void updateCount() {  System.out.println("事务处理之前");  // 调用委托类的方法;  countImpl.updateCount();  System.out.println("事务处理之后");  }  }
TestCount.java 

/** *测试Count类 */  
public class TestCount {  public static void main(String[] args) {  CountImpl countImpl = new CountImpl();

观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。 

(2)动态代理之JDK

BookFacade.java 

public interface BookFacade {  public void addBook();  
}
BookFacadeImpl.java  

public class BookFacadeImpl implements BookFacade {  @Override  public void addBook() {  System.out.println("增加图书方法。。。");  }  
}
BookFacadeProxy.java 

import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
/** * JDK动态代理代理类  */  
public class BookFacadeProxy implements InvocationHandler {  private Object target;  /** * 绑定委托对象并返回一个代理类 * @param target * @return */  public Object bind(Object target) {  this.target = target;  //取得代理对象  return Proxy.newProxyInstance(target.getClass().getClassLoader(),  target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)  }  @Override  /** * 调用目标对象的任何一个方法 都相当于调用invoke(); */  public Object invoke(Object proxy, Method method, Object[] args)  throws Throwable {  Object result=null;  System.out.println("事物开始");  //执行方法  result=method.invoke(target, args);  System.out.println("事物结束");  return result;  }  }
TestProxy.java  

import net.battier.dao.BookFacade;  
import net.battier.dao.impl.BookFacadeImpl;  
import net.battier.proxy.BookFacadeProxy;  
public class TestProxy {  public static void main(String[] args) {  BookFacadeProxy proxy = new BookFacadeProxy();  BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  bookProxy.addBook();  }  
}
JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。

(3)动态代理之CGlib

cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强。

BookCadeImpl1.java 

/** * 这个是没有实现接口的实现类 */  
public class BookFacadeImpl1 {  public void addBook() {  System.out.println("增加图书的普通方法...");  }  
}
BookFacadeProxy.java  

import java.lang.reflect.Method;  import net.sf.cglib.proxy.Enhancer;  
import net.sf.cglib.proxy.MethodInterceptor;  
import net.sf.cglib.proxy.MethodProxy;  /** * 使用cglib动态代理 */  
public class BookFacadeCglib implements MethodInterceptor {  private Object target;  /** * 创建代理对象 */  public Object getInstance(Object target) {  this.target = target;  Enhancer enhancer = new Enhancer();  enhancer.setSuperclass(this.target.getClass());  // 回调方法  enhancer.setCallback(this);  // 创建代理对象  return enhancer.create();  }  @Override  // 回调方法  public Object intercept(Object obj, Method method, Object[] args,  MethodProxy proxy) throws Throwable {  System.out.println("事物开始");  proxy.invokeSuper(obj, args);  System.out.println("事物结束");  return null;  }  
}
Testcglib.java 

import net.battier.dao.impl.BookFacadeImpl1;  
import net.battier.proxy.BookFacadeCglib;  
public class TestCglib {  public static void main(String[] args) {  BookFacadeCglib cglib=new BookFacadeCglib();  BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  bookCglib.addBook();  }  
}
Spring框架中的AOP,如果类实现了接口,就使用JDK的动态代理生成代理对象,如果这个类没有实现任何接口,使用CGLIB生成代理对象.

三、AOP概念


四、Spring中基于AspectJ的AOP

AspectJ是一个基于Java语言的AOP框架,Spring2.0以后新增了对AspectJ切点表达式支持。

AspectJ表达式:
* 语法:execution(表达式)
execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
       execution(“* cn.itcast.spring3.demo1.dao.*(..)”) ---只检索当前包
       execution(“* cn.itcast.spring3.demo1.dao..*(..)”) ---检索包及当前包的子包.
        execution(* cn.itcast.dao.GenericDAO+.*(..)) ---检索GenericDAO及子类

AspectJ增强:
     @Before 前置通知
     @AfterReturning 后置通知
     @Around 环绕通知
     @AfterThrowing抛出通知
     @After 最终final通知，不管是否异常，该通知都会执行

1、基于注解的AOP

第一步:引入相应jar包.
 spring-aspects-3.2.0.RELEASE.jar
 com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

第二步:编写被增强的类:
UserDao.java

package cn.itcast.spring3.demo1;

public class UserDao {public void add(){System.out.println("添加用户");}public int update(){System.out.println("修改用户");}public void delete(){System.out.println("删除用户");}public void find(){System.out.println("查询用户");}
}
第三步:使用AspectJ注解形式编写切面类: 

/*** 切面类:就是切点与增强结合*/
@Aspect
public class MyAspect {@Before("execution(* cn.itcast.spring3.demo1.UserDao.add(..))")public void before(){System.out.println("前置增强....");}
}
第四步:创建applicationContext.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: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/aop http://www.springframework.org/schema/aop/spring-aop.xsd"><!-- 自动生成代理--><aop:aspectj-autoproxy /><bean id="userDao" class="cn.itcast.spring3.demo1.UserDao"></bean><bean id="myAspect" class="cn.itcast.spring3.demo1.MyAspect"></bean>
</beans>
第五步：测试 

package cn.itcast.spring3.demo1;import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest1 {@Autowired@Qualifier("userDao")private UserDao userDao;@Testpublic void demo1(){userDao.add();}
}

2、基于XML的AOP

第一步:编写被增强的类:

package cn.itcast.spring3.demo2;
public class ProductDao {public int add(){System.out.println("添加商品...");int d = 10/0;return 100;}public void update(){System.out.println("修改商品...");}public void delete(){System.out.println("删除商品...");}public void find(){System.out.println("查询商品...");}
}
第二步：定义切面 

package cn.itcast.spring3.demo2;import org.aspectj.lang.ProceedingJoinPoint;/*** 切面类*/
public class MyAspectXML {	public void before(){System.out.println("前置通知...");}public void afterReturing(Object returnVal){System.out.println("后置通知...返回值:"+returnVal);}	public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{System.out.println("环绕前增强....");Object result = proceedingJoinPoint.proceed();System.out.println("环绕后增强....");return result;}	public void afterThrowing(Throwable e){System.out.println("异常通知..."+e.getMessage());}	public void after(){System.out.println("最终通知....");}
}
第三步:配置applicationContext.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: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/aop http://www.springframework.org/schema/aop/spring-aop.xsd"><!-- 定义被增强的类 --><bean id="productDao" class="cn.itcast.spring3.demo2.ProductDao"></bean><!-- 定义切面 --><bean id="myAspectXML" class="cn.itcast.spring3.demo2.MyAspectXML"></bean><!-- 定义aop配置 --><aop:config><!-- 定义切点: --><aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/><aop:aspect ref="myAspectXML"><!-- 前置通知 --><aop:before method="before" pointcut-ref="mypointcut"/> <!-- 后置通知 --><aop:after-returning method="afterReturing" pointcut-ref="mypointcut" returning="returnVal"/> <!-- 环绕通知 --><aop:around method="around" pointcut-ref="mypointcut"/> <!-- 异常通知 --><aop:after-throwing method="afterThrowing" pointcut-ref="mypointcut" throwing="e"/> <!-- 最终通知 --><aop:after method="after" pointcut-ref="mypointcut"/></aop:aspect></aop:config>
</beans>

第四步：测试类 

package cn.itcast.spring3.demo2;import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringTest2 {@Autowired@Qualifier("productDao")private ProductDao productDao;@Testpublic void demo1(){productDao.add();productDao.find();productDao.update();productDao.delete();}
}




这篇关于Spring(四)：AOP的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1138489。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...
在cscode中通过maven创建java项目

在cscode中通过maven创建java项目

在cscode中创建java项目 可以通过博客完成maven的导入 建立maven项目 使用快捷键 Ctrl + Shift + P 建立一个 Maven 项目 1 Ctrl + Shift + P 打开输入框2 输入 "> java create"3 选择 maven4 选择 No Archetype5 输入 域名6 输入项目名称7 建立一个文件目录存放项目，文件名一般为项目名8 确定
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2